This is just a test.
11 |
12 |
13 |
--------------------------------------------------------------------------------
/source/Glimpse/Store/Interface.php:
--------------------------------------------------------------------------------
1 |
6 | */
7 | interface Glimpse_Store_Interface
8 | {
9 | /**
10 | * Store data.
11 | *
12 | * @param mixed $data Data to store.
13 | */
14 | function store($data = '');
15 |
16 | /**
17 | * Fetch data.
18 | *
19 | * @return mixed Data retrieved from store.
20 | */
21 | function fetch();
22 | }
--------------------------------------------------------------------------------
/source/Glimpse/Handler/Interface.php:
--------------------------------------------------------------------------------
1 |
6 | */
7 | interface Glimpse_Handler_Interface
8 | {
9 | /**
10 | * Processes the handler pre-run.
11 | *
12 | * @param Glimpse $glimpse The current Glimpse instance.
13 | * @return string The rendered handler.
14 | */
15 | function processPreRun(Glimpse $glimpse);
16 |
17 | /**
18 | * Processes the handler post-run.
19 | *
20 | * @param Glimpse $glimpse The current Glimpse instance.
21 | * @return string The rendered handler.
22 | */
23 | function processPostRun(Glimpse $glimpse);
24 | }
--------------------------------------------------------------------------------
/source/Glimpse/Plugin/Interface.php:
--------------------------------------------------------------------------------
1 |
8 | */
9 | interface Glimpse_Plugin_Interface
10 | {
11 | /**
12 | * Gets the plugin data that should be rendered on the output protocol stream.
13 | *
14 | * @param Glimpse $glimpse The current Glimpse instance.
15 | * @return array Array conforming to the Glimpse protocol definition.
16 | */
17 | function getData(Glimpse $glimpse);
18 |
19 | /**
20 | * Get the plugin help URL.
21 | *
22 | * @return string Help URL for the plugin.
23 | */
24 | function getHelpUrl();
25 | }
--------------------------------------------------------------------------------
/source/index.php:
--------------------------------------------------------------------------------
1 | $glimpseBaseDir
11 | );
12 |
13 | // Read configuration
14 | $glimpseConfigurationFile = dirname(str_replace('phar://', '', $glimpseBaseDir) . '/glimpse') . '/glimpse.ini';
15 | if (file_exists($glimpseConfigurationFile)) {
16 | $configuration = parse_ini_file($glimpseConfigurationFile, true);
17 | $glimpseConfiguration = array_merge($glimpseConfiguration, $configuration['Glimpse']);
18 | }
19 |
20 | // Start Glimpse
21 | $glimpse = new Glimpse($glimpseConfiguration);
--------------------------------------------------------------------------------
/source/Glimpse/Plugin/Environment.php:
--------------------------------------------------------------------------------
1 |
8 | */
9 | class Glimpse_Plugin_Environment
10 | implements Glimpse_Plugin_Interface
11 | {
12 | /**
13 | * Gets the plugin data that should be rendered on the output protocol stream.
14 | *
15 | * @param Glimpse $glimpse The current Glimpse instance.
16 | * @return array Array conforming to the Glimpse protocol definition.
17 | */
18 | public function getData(Glimpse $glimpse) {
19 | $info = $glimpse->retrievePhpInfo();
20 | $data = $info["Environment"];
21 | return array(
22 | "Environment" => count($data) > 0 ? $data : null
23 | );
24 | }
25 |
26 | /**
27 | * Get the plugin help URL.
28 | *
29 | * @return string Help URL for the plugin.
30 | */
31 | public function getHelpUrl() {
32 | return "http://getGlimpse.com/Help/Plugin/Environment";
33 | }
34 | }
--------------------------------------------------------------------------------
/source/Glimpse/Plugin/Server.php:
--------------------------------------------------------------------------------
1 |
8 | */
9 | class Glimpse_Plugin_Server
10 | implements Glimpse_Plugin_Interface
11 | {
12 | /**
13 | * Gets the plugin data that should be rendered on the output protocol stream.
14 | *
15 | * @param Glimpse $glimpse The current Glimpse instance.
16 | * @return array Array conforming to the Glimpse protocol definition.
17 | */
18 | public function getData(Glimpse $glimpse) {
19 | $data = array(array('Key', 'Value'));
20 | foreach ($_SERVER as $key => $value) {
21 | $data[] = array($key, $value);
22 | }
23 |
24 | return array(
25 | "Server" => count($data) > 0 ? $data : null
26 | );
27 | }
28 |
29 | /**
30 | * Get the plugin help URL.
31 | *
32 | * @return string Help URL for the plugin.
33 | */
34 | public function getHelpUrl() {
35 | return "http://getGlimpse.com/Help/Plugin/Server";
36 | }
37 | }
--------------------------------------------------------------------------------
/source/Glimpse/Plugin/Config.php:
--------------------------------------------------------------------------------
1 |
8 | */
9 | class Glimpse_Plugin_Config
10 | implements Glimpse_Plugin_Interface
11 | {
12 | /**
13 | * Gets the plugin data that should be rendered on the output protocol stream.
14 | *
15 | * @param Glimpse $glimpse The current Glimpse instance.
16 | * @return array Array conforming to the Glimpse protocol definition.
17 | */
18 | public function getData(Glimpse $glimpse) {
19 | $info = $glimpse->retrievePhpInfo();
20 | $data = $info["PHP Configuration"];
21 | $data['Loaded extensions'] = get_loaded_extensions();
22 | $data['Loaded ZEND extensions'] = get_loaded_extensions(true);
23 |
24 | return array(
25 | "Config" => count($data) > 0 ? $data : null
26 | );
27 | }
28 |
29 | /**
30 | * Get the plugin help URL.
31 | *
32 | * @return string Help URL for the plugin.
33 | */
34 | public function getHelpUrl() {
35 | return "http://getGlimpse.com/Help/Plugin/Config";
36 | }
37 | }
--------------------------------------------------------------------------------
/source/Glimpse/Plugin/Session.php:
--------------------------------------------------------------------------------
1 |
8 | */
9 | class Glimpse_Plugin_Session
10 | implements Glimpse_Plugin_Interface
11 | {
12 | /**
13 | * Gets the plugin data that should be rendered on the output protocol stream.
14 | *
15 | * @param Glimpse $glimpse The current Glimpse instance.
16 | * @return array Array conforming to the Glimpse protocol definition.
17 | */
18 | public function getData(Glimpse $glimpse) {
19 | $data = array();
20 |
21 | if (isset($_SESSION) && count($_SESSION) > 0) {
22 | $data[] = array('Key', 'Value');
23 | foreach ($_SESSION as $key => $value) {
24 | $data = array($key, $value);
25 | }
26 | }
27 |
28 | return array(
29 | "Session" => count($data) > 0 ? $data : null
30 | );
31 | }
32 |
33 | /**
34 | * Get the plugin help URL.
35 | *
36 | * @return string Help URL for the plugin.
37 | */
38 | public function getHelpUrl() {
39 | return "http://getGlimpse.com/Help/Plugin/Session";
40 | }
41 | }
--------------------------------------------------------------------------------
/source/Glimpse/Plugin/Trace.php:
--------------------------------------------------------------------------------
1 |
8 | */
9 | class Glimpse_Plugin_Trace
10 | implements Glimpse_Plugin_Interface
11 | {
12 | /**
13 | * Gets the plugin data that should be rendered on the output protocol stream.
14 | *
15 | * @param Glimpse $glimpse The current Glimpse instance.
16 | * @return array Array conforming to the Glimpse protocol definition.
17 | */
18 | public function getData(Glimpse $glimpse) {
19 | $data = array(array('Message', 'Category', 'From First', 'From Last'));
20 | $traceData = Glimpse_Trace::retrieveMessages();
21 | foreach ($traceData as $traceEntry) {
22 | $traceEntry[] = strtolower($traceEntry[1]);
23 | $data[] = $traceEntry;
24 | }
25 |
26 | return array(
27 | "Trace" => count($data) > 0 ? $data : null
28 | );
29 | }
30 |
31 | /**
32 | * Get the plugin help URL.
33 | *
34 | * @return string Help URL for the plugin.
35 | */
36 | public function getHelpUrl() {
37 | return "http://getGlimpse.com/Help/Plugin/Trace";
38 | }
39 | }
--------------------------------------------------------------------------------
/source/Glimpse/Plugin/Plugins.php:
--------------------------------------------------------------------------------
1 |
8 | */
9 | class Glimpse_Plugin_Plugins
10 | implements Glimpse_Plugin_Interface
11 | {
12 | /**
13 | * Gets the plugin data that should be rendered on the output protocol stream.
14 | *
15 | * @param Glimpse $glimpse The current Glimpse instance.
16 | * @return array Array conforming to the Glimpse protocol definition.
17 | */
18 | public function getData(Glimpse $glimpse) {
19 | $data = array();
20 |
21 | $plugins = $glimpse->retrievePlugins();
22 | foreach ($plugins as $plugin) {
23 | $reflectedObject = new ReflectionObject($plugin);
24 | $pluginName = basename('/' . str_replace('_', '/', $reflectedObject->getName()));
25 |
26 | $data[$pluginName] = array(
27 | 'helpUrl' => !is_null($plugin->getHelpUrl()) ? $plugin->getHelpUrl() : ''
28 | );
29 | }
30 |
31 | return array(
32 | "plugins" => $data
33 | );
34 | }
35 |
36 | /**
37 | * Get the plugin help URL.
38 | *
39 | * @return string Help URL for the plugin.
40 | */
41 | public function getHelpUrl() {
42 | return null;
43 | }
44 | }
--------------------------------------------------------------------------------
/source/Glimpse/AutoLoader.php:
--------------------------------------------------------------------------------
1 |
17 | */
18 | class Glimpse_AutoLoader
19 | {
20 | /**
21 | * Registers the autoloader
22 | */
23 | public static function Register() {
24 | return spl_autoload_register(array('Glimpse_AutoLoader', 'Load'));
25 | }
26 |
27 | /**
28 | * Load a class
29 | *
30 | * @param string $className Class name to load
31 | */
32 | public static function Load($className){
33 | if ((class_exists($className)) || (strpos($className, 'Glimpse') === false)) {
34 | return false;
35 | }
36 |
37 | $classFilePath = GLIMPSE_ROOT . str_replace('_', DIRECTORY_SEPARATOR, $className) . '.php';
38 |
39 | if ((file_exists($classFilePath) === false) || (is_readable($classFilePath) === false)) {
40 | return false;
41 | }
42 |
43 | require($classFilePath);
44 | }
45 | }
--------------------------------------------------------------------------------
/source/Glimpse/Handler/Data.php:
--------------------------------------------------------------------------------
1 |
6 | */
7 | class Glimpse_Handler_Data
8 | implements Glimpse_Handler_Interface
9 | {
10 | /**
11 | * Processes the handler pre-run.
12 | *
13 | * @param Glimpse $glimpse The current Glimpse instance.
14 | * @return string The rendered handler.
15 | */
16 | public function processPreRun(Glimpse $glimpse) {
17 | }
18 |
19 |
20 | /**
21 | * Processes the handler post-run.
22 | *
23 | * @param Glimpse $glimpse The current Glimpse instance.
24 | * @return string The rendered handler.
25 | */
26 | public function processPostRun(Glimpse $glimpse) {
27 | if (!defined('GLIMPSE_RENDERED') && !isset($_REQUEST['glimpseFile'])) {
28 | define('GLIMPSE_RENDERED', true);
29 |
30 | $urlPath = $_SERVER['PHP_SELF'] . '?glimpseVersion=' . $glimpse->getVersion() . '&glimpseFile=';
31 |
32 | echo '';
36 | echo '';
37 | }
38 | }
39 | }
--------------------------------------------------------------------------------
/source/Glimpse/Store/File.php:
--------------------------------------------------------------------------------
1 |
6 | */
7 | class Glimpse_Store_File
8 | implements Glimpse_Store_Interface
9 | {
10 | protected $_fileName = '';
11 |
12 | public function __construct($fileName = null) {
13 | if (is_null($fileName)) {
14 | $tmpDir = sys_get_temp_dir();
15 | if (substr($tmpDir, -1 ) != '/' && substr($tmpDir, -1 ) != '\\') {
16 | $tmpDir .= '/';
17 | }
18 |
19 | $fileName = $tmpDir . 'glimpsestore' . md5(__FILE__);
20 | }
21 |
22 | $this->_fileName = $fileName;
23 | }
24 |
25 | /**
26 | * Store data.
27 | *
28 | * @param mixed $data Data to store.
29 | */
30 | public function store($data = '') {
31 | $fp = fopen($this->_fileName, "w");
32 |
33 | if (flock($fp, LOCK_EX)) {
34 | ftruncate($fp, 0);
35 | fwrite($fp, serialize($data));
36 | flock($fp, LOCK_UN);
37 | }
38 |
39 | fclose($fp);
40 | }
41 |
42 | /**
43 | * Fetch data.
44 | *
45 | * @return mixed Data retrieved from store.
46 | */
47 | public function fetch() {
48 | if (!file_exists($this->_fileName)) {
49 | return null;
50 | }
51 |
52 | $fileContents = '';
53 |
54 | $fp = fopen($this->_fileName, "r");
55 | if (flock($fp, LOCK_SH)) {
56 | $fileContents = fread($fp, filesize($this->_fileName));
57 | flock($fp, LOCK_UN);
58 | }
59 |
60 | fclose($fp);
61 | return unserialize($fileContents);
62 | }
63 | }
--------------------------------------------------------------------------------
/source/Glimpse/Plugin/Request.php:
--------------------------------------------------------------------------------
1 |
8 | */
9 | class Glimpse_Plugin_Request
10 | implements Glimpse_Plugin_Interface
11 | {
12 | /**
13 | * Gets the plugin data that should be rendered on the output protocol stream.
14 | *
15 | * @param Glimpse $glimpse The current Glimpse instance.
16 | * @return array Array conforming to the Glimpse protocol definition.
17 | */
18 | public function getData(Glimpse $glimpse) {
19 | $data = array();
20 |
21 | if (isset($_REQUEST) && count($_REQUEST) > 0) {
22 | $data['_REQUEST'] = array(array('Key', 'Value'));
23 | foreach ($_REQUEST as $key => $value) {
24 | $data['_REQUEST'][] = array($key, $value);
25 | }
26 | }
27 | if (isset($_GET) && count($_GET) > 0) {
28 | $data['_GET'] = array(array('Key', 'Value'));
29 | foreach ($_GET as $key => $value) {
30 | $data['_GET'][] = array($key, $value);
31 | }
32 | }
33 | if (isset($_POST) && count($_POST) > 0) {
34 | $data['_POST'] = array(array('Key', 'Value'));
35 | foreach ($_POST as $key => $value) {
36 | $data['_POST'][] = array($key, $value);
37 | }
38 | }
39 |
40 | return array(
41 | "Request" => count($data) > 0 ? $data : null
42 | );
43 | }
44 |
45 | /**
46 | * Get the plugin help URL.
47 | *
48 | * @return string Help URL for the plugin.
49 | */
50 | public function getHelpUrl() {
51 | return "http://getGlimpse.com/Help/Plugin/Request";
52 | }
53 | }
--------------------------------------------------------------------------------
/source/Glimpse/Handler/Clients.php:
--------------------------------------------------------------------------------
1 |
6 | */
7 | class Glimpse_Handler_Clients
8 | implements Glimpse_Handler_Interface
9 | {
10 | /**
11 | * Processes the handler pre-run.
12 | *
13 | * @param Glimpse $glimpse The current Glimpse instance.
14 | * @return string The rendered handler.
15 | */
16 | public function processPreRun(Glimpse $glimpse) {
17 | if (!isset($_REQUEST['glimpseFile']) || $_REQUEST['glimpseFile'] != 'Clients') {
18 | return;
19 | }
20 |
21 | // HTTP headers
22 | header('Content-Type: application/json; charset=utf-8');
23 |
24 | // Build data
25 | $requestHistory = $glimpse->getRequestHistory();
26 | if (!is_array($requestHistory) || count($requestHistory) == 0) {
27 | echo "{'Error': true, 'Message': 'No history available.'}";
28 | $glimpse->endRequest();
29 | }
30 |
31 | $data = array();
32 | foreach ($requestHistory as $request) {
33 | $data[$request->GlimpseClientName][$request->RequestId] = (object)array(
34 | 'Url' => $request->Url,
35 | 'Browser' => $request->Browser,
36 | 'RequestTime' => $request->RequestTime,
37 | 'IsAjax' => $request->IsAjax,
38 | 'Method' => $request->Method
39 | );
40 | }
41 | foreach ($data as $key => $value) {
42 | $data[$key] = (object)$value;
43 | }
44 | $data = (object)array('Data' => (object)$data);
45 |
46 | // Return a response
47 | echo json_encode($data);
48 |
49 | $glimpse->endRequest();
50 | }
51 |
52 |
53 | /**
54 | * Processes the handler post-run.
55 | *
56 | * @param Glimpse $glimpse The current Glimpse instance.
57 | * @return string The rendered handler.
58 | */
59 | public function processPostRun(Glimpse $glimpse) {
60 | }
61 | }
--------------------------------------------------------------------------------
/source/Glimpse/Handler/EmbeddedResource.php:
--------------------------------------------------------------------------------
1 |
6 | */
7 | class Glimpse_Handler_EmbeddedResource
8 | implements Glimpse_Handler_Interface
9 | {
10 | /**
11 | * The filename to serve.
12 | *
13 | * @var string
14 | */
15 | protected $_fileName = null;
16 |
17 | /**
18 | * The content type to serve.
19 | *
20 | * @var string
21 | */
22 | protected $_contentType = null;
23 |
24 | /**
25 | * Creates a new Glimpse_Handler_EmbeddedResourceHandler instance.
26 | *
27 | * @param string $fileName The filename to serve.
28 | * @param string $contentType The content type to serve.
29 | */
30 | public function __construct($fileName, $contentType) {
31 | $this->_fileName = $fileName;
32 | $this->_contentType = $contentType;
33 | }
34 |
35 | /**
36 | * Processes the handler pre-run.
37 | *
38 | * @param Glimpse $glimpse The current Glimpse instance.
39 | * @return string The rendered handler.
40 | */
41 | public function processPreRun(Glimpse $glimpse) {
42 | if (!isset($_REQUEST['glimpseFile'])) {
43 | return;
44 | }
45 |
46 | $file = $_REQUEST['glimpseFile'];
47 | $configuration = $glimpse->retrieveConfiguration();
48 | $glimpseBaseDir = $configuration['glimpsebasedir'];
49 | $fileToRender = $glimpseBaseDir . '/resources/' . $file;
50 |
51 | if (file_exists($fileToRender)) {
52 | header('Content-Type: ' . $this->_contentType);
53 | echo file_get_contents($fileToRender);
54 | $glimpse->endRequest();
55 | }
56 | }
57 |
58 |
59 | /**
60 | * Processes the handler post-run.
61 | *
62 | * @param Glimpse $glimpse The current Glimpse instance.
63 | * @param string $file The file to handle.
64 | * @return string The rendered handler.
65 | */
66 | public function processPostRun(Glimpse $glimpse) {
67 | }
68 | }
--------------------------------------------------------------------------------
/source/Glimpse/Handler/History.php:
--------------------------------------------------------------------------------
1 |
6 | */
7 | class Glimpse_Handler_History
8 | implements Glimpse_Handler_Interface
9 | {
10 | /**
11 | * Processes the handler pre-run.
12 | *
13 | * @param Glimpse $glimpse The current Glimpse instance.
14 | * @return string The rendered handler.
15 | */
16 | public function processPreRun(Glimpse $glimpse) {
17 | if (!isset($_REQUEST['glimpseFile']) || $_REQUEST['glimpseFile'] != 'History') {
18 | return;
19 | }
20 |
21 | // HTTP headers
22 | header('Content-Type: application/json; charset=utf-8');
23 |
24 | // Build data
25 | $requestHistory = $glimpse->getRequestHistory();
26 | if (!is_array($requestHistory) || count($requestHistory) == 0) {
27 | echo "{'Error': true, 'Message': 'No history available.'}";
28 | $glimpse->endRequest();
29 | }
30 |
31 | $data = array();
32 | if (isset($_REQUEST['ClientRequestId'])) {
33 | foreach ($requestHistory as $request) {
34 | if ($request->RequestId == $_REQUEST['ClientRequestId']) {
35 | $data = (object)array(
36 | 'Data' => json_encode($request->Data)
37 | );
38 | }
39 | }
40 | } else if (isset($_REQUEST['ClientName'])) {
41 | foreach ($requestHistory as $request) {
42 | if ($_REQUEST['ClientName'] == $request->GlimpseClientName) {
43 | $data[$request->GlimpseClientName][$request->RequestId] = (object)array(
44 | 'Data' => json_encode($request->Data)
45 | );
46 | }
47 | }
48 | foreach ($data as $key => $value) {
49 | $data[$key] = (object)$value;
50 | }
51 | }
52 | $data = (object)array('Data' => (object)$data);
53 |
54 | // Return a response
55 | echo json_encode($data);
56 |
57 | $glimpse->endRequest();
58 | }
59 |
60 |
61 | /**
62 | * Processes the handler post-run.
63 | *
64 | * @param Glimpse $glimpse The current Glimpse instance.
65 | * @return string The rendered handler.
66 | */
67 | public function processPostRun(Glimpse $glimpse) {
68 | }
69 | }
--------------------------------------------------------------------------------
/source/Glimpse/Trace.php:
--------------------------------------------------------------------------------
1 |
6 | */
7 | class Glimpse_Trace
8 | {
9 | /**
10 | * Trace messages
11 | *
12 | * @var array
13 | */
14 | private static $_messages = array();
15 |
16 | /**
17 | * First timing
18 | *
19 | * @var int
20 | */
21 | private static $_timingFirst = 0;
22 |
23 | /**
24 | * Last timing
25 | *
26 | * @var int
27 | */
28 | private static $_timingLast = 0;
29 |
30 | /**
31 | * Creates a new Glimpse_Trace instance.
32 | */
33 | private function __construct() {
34 | }
35 |
36 | /**
37 | * Retrieve log messages.
38 | *
39 | * @return array
40 | */
41 | public static function retrieveMessages() {
42 | return self::$_messages;
43 | }
44 |
45 | /**
46 | * Logs an Info message to the trace log.
47 | *
48 | * @param string $message Message to log.
49 | */
50 | public static function info($message = '') {
51 | self::log('Info', $message);
52 | }
53 |
54 | /**
55 | * Logs a Warn message to the trace log.
56 | *
57 | * @param string $message Message to log.
58 | */
59 | public static function warn($message = '') {
60 | self::log('Warn', $message);
61 | }
62 |
63 | /**
64 | * Logs an Error message to the trace log.
65 | *
66 | * @param string $message Message to log.
67 | */
68 | public static function error($message = '') {
69 | self::log('Error', $message);
70 | }
71 |
72 | /**
73 | * Logs a Fail message to the trace log.
74 | *
75 | * @param string $message Message to log.
76 | */
77 | public static function fail($message = '') {
78 | self::log('Fail', $message);
79 | }
80 |
81 | /**
82 | * Logs a message to the trace log.
83 | *
84 | * @param string $category Category to log (Info, Warn, Error, Fail).
85 | * @param string $message Message to log.
86 | */
87 | public static function log($category = 'Info', $message = '') {
88 | // Timing
89 | $timeFromFirst = 0;
90 | $timeFromLast = 0;
91 | if (self::$_timingFirst == 0) {
92 | self::$_timingFirst = microtime(true);
93 | self::$_timingLast = self::$_timingFirst;
94 | } else {
95 | $timeFromFirst = (microtime(true) - self::$_timingFirst) * 1000;
96 | $timeFromLast = (microtime(true) - self::$_timingLast) * 1000;
97 | }
98 |
99 | // Log
100 | self::$_messages[] = array($message, $category, number_format($timeFromFirst, 2) . ' ms', number_format($timeFromLast, 2) . ' ms');
101 |
102 | // Timing
103 | self::$_timingLast = microtime(true);
104 | }
105 | }
--------------------------------------------------------------------------------
/README.markdown:
--------------------------------------------------------------------------------
1 | A client side Glimpse into whats going on in your server
2 |
3 | Overview
4 | --------
5 | At its core Glimpse allows you to debug your PHP application right in the browser. Glimpse allows you to "Glimpse" into what's going on in your web server. In other words what Firebug is to debugging your client side code, Glimpse is to debugging your server within the client.
6 |
7 | Fundamentally Glimpse is made up of 3 different parts, all of which are extensible and customizable for any platform:
8 |
9 | * Glimpse Server Module (the one you are browsing right now)
10 | * Glimpse Client Side Viewer
11 | * Glimpse Protocol
12 |
13 |
14 | Getting started
15 | ---------------
16 | Installing Glimpse in a PHP application is very straightforward. Glimpse is supported starting with PHP 5.2 or higher.
17 |
18 | * For PHP 5.2, copy the source folder of this repository to your server and add as early as possible in your PHP script.
19 | * For PHP 5.3, copy the glimpse.phar file from the build folder of this repository to your server and add as early as possible in your PHP script.
20 |
21 | From that moment, navigate to your web application and append the ?glimpseFile=Config query string to enable/disable Glimpse. Optionally, a client name can also be specified to distinguish remote requests.
22 |
23 |
24 | How it Works
25 | ------------
26 | On the Server:
27 |
28 | 1. Server collects all server side information that will aid in debugging (i.e. PHP configuration, environment, session variables, trace data, etc)
29 | 2. It does this by running through a pipeline of server side data providers that can be dynamically controlled and added to under plugin architecture
30 | 3. Before the response is send, the server formats this data in accordance with the Glimpse Protocol and serializes it as JSON
31 | 4. Depending on whether it is a Ajax request or not, the server embeds the JSON in the HTTP Header or in the content of the page
32 |
33 | On the Client:
34 |
35 | 5. Depending on whether it is a Ajax request or not, the picks up the JSON data and to the data set by executing a pipeline of client side data providers that can be dynamically controlled and added to under plugin architecture
36 | 6. The client side module then dynamically renders a client side UI (similar to Firebug Lite) that lets you view this data
37 |
38 | Glimpse can be turned on or off by a series of different mechanistic, but at its core if the Glimpse cookie is present the server will provide the "debug" data - as a security measure, the request for debug data is "authenticated". Via the plugin model, this authentication check can have any logic that is required by the site to ensure that unauthorized users don't have access to sensitive debug data.
39 |
40 |
41 | Server Implementations
42 | ----------------------
43 | Given the scope of the project and what it can do, the concept isn't restricted to any one platform. Hence, once mature, Glimpse Server Module will be available on all major web platforms.
44 |
45 | Platforms currently supported:
46 |
47 | * ASP.Net Web Forms
48 | * ASP.Net MVC
49 | * PHP (the one you are currently browsing)
50 |
51 | Platforms soon to be supported supported:
52 |
53 | * Ruby on Rails
54 |
55 | NOTE - If you would like help develop a Glimpse Server Module for a given platform please let us know.
56 |
57 |
58 | Client Implementations
59 | ----------------------
60 | To start with the Glimpse Client Side Viewer is simply a light weight JavaScript "plugin" that understands the Glimpse Protocol and knows how to render the data. From a technology standpoint we currently use jQuery as the client side framework.
61 |
62 | Eventually, we would like to have actual browser plugins that provide richer functionality and experience, but the JavaScript version of the Glimpse Client Side Viewer is surprisingly well featured, intuitive and provides a high fidelity experience. We also hope to have a version for mobile ready soon which customizes the viewing/usage experience when using a mobile device.
63 |
64 | 
65 |
66 |
67 | Protocol
68 | --------
69 | Details on the Glimpse protocol can be found at http://getglimpse.com/Protocol.
--------------------------------------------------------------------------------
/source/Glimpse/Handler/Config.php:
--------------------------------------------------------------------------------
1 |
6 | */
7 | class Glimpse_Handler_Config
8 | implements Glimpse_Handler_Interface
9 | {
10 | /**
11 | * Processes the handler pre-run.
12 | *
13 | * @param Glimpse $glimpse The current Glimpse instance.
14 | * @return string The rendered handler.
15 | */
16 | public function processPreRun(Glimpse $glimpse) {
17 | if (!isset($_REQUEST['glimpseFile']) || $_REQUEST['glimpseFile'] != 'Config') {
18 | return;
19 | }
20 |
21 | echo "What Firebug is for the client, Glimpse does for the server... in other words, a client side Glimpse into whats going on in your server. Glimpse A client side Glimpse to your server
";
32 | echo "
";
33 | echo "
Drag the above button to your favorites bar for quick and easy access to Glimpse.
";
34 |
35 | echo "
Your Settings: This section tells you how Glimpse sees your requests.
glimpseState = " . (isset($_COOKIE['glimpseState']) && $_COOKIE['glimpseState'] != '' ? $_COOKIE['glimpseState'] : 'Off') . " ";
36 |
37 | echo "
Plugins: This is the list of Glimpse plugins for this web application. Glimpse plugins show up as individual tabs in the Glimpse client. You can stop a plugin from being loaded by setting the plugins-disabled value in glimpse.ini .
";
38 | foreach ($glimpse->retrievePlugins() as $plugin) {
39 | $pluginClass = new ReflectionObject($plugin);
40 | echo "" . $pluginClass->getName() . " ";
41 | }
42 |
43 | echo " ";
44 |
45 | echo "
More Info: ";
46 | echo "";
47 |
48 | echo "";
49 |
50 | $glimpse->endRequest();
51 | }
52 |
53 | /**
54 | * Processes the handler post-run.
55 | *
56 | * @param Glimpse $glimpse The current Glimpse instance.
57 | * @return string The rendered handler.
58 | */
59 | public function processPostRun(Glimpse $glimpse) {
60 | }
61 | }
--------------------------------------------------------------------------------
/source/Glimpse.php:
--------------------------------------------------------------------------------
1 |
6 | */
7 | class Glimpse
8 | {
9 | /**
10 | * Cache for phpinfo() results
11 | *
12 | * @var array
13 | */
14 | protected $_phpInfoResults = null;
15 |
16 | /**
17 | * Configuration
18 | *
19 | * @var array
20 | */
21 | protected $_configuration = array(
22 | 'glimpsebasedir' => '',
23 | 'plugins-disabled' => '',
24 | 'requestlimit' => 15,
25 | 'requeststore' => 'Glimpse_Store_File'
26 | );
27 |
28 | /**
29 | * Loaded handlers
30 | *
31 | * @var array
32 | */
33 | protected $_glimpseHandlers = array();
34 |
35 | /**
36 | * Loaded plugins
37 | *
38 | * @var array
39 | */
40 | protected $_glimpsePlugins = array();
41 |
42 | /**
43 | * The current request identifier.
44 | *
45 | * @var string
46 | */
47 | protected $_requestId = null;
48 |
49 | /**
50 | * The current request data.
51 | *
52 | * @var string
53 | */
54 | protected $_currentRequestData = null;
55 |
56 | /**
57 | * The request store.
58 | *
59 | * @var Glimpse_Store_File
60 | */
61 | protected $_requestStore = null;
62 |
63 | /**
64 | * Gets the Glimpse version.
65 | *
66 | * @return float
67 | */
68 | public function getVersion() {
69 | return 0.83;
70 | }
71 |
72 | /**
73 | * Get Glimpse mode.
74 | *
75 | * @return string Glimpse mode.
76 | */
77 | public function getMode() {
78 | return strtolower( isset($_COOKIE['glimpseState']) && $_COOKIE['glimpseState'] != '' ? $_COOKIE['glimpseState'] : 'off' );
79 | }
80 |
81 | /**
82 | * Gets the current request identifier.
83 | *
84 | * @return string The request identifier.
85 | */
86 | public function getRequestId() {
87 | return $this->_requestId;
88 | }
89 |
90 | /**
91 | * Gets the current request data.
92 | *
93 | * @return mixed
94 | */
95 | public function getCurrentRequestData() {
96 | return $this->_currentRequestData;
97 | }
98 |
99 | /**
100 | * Register a Glimpse handler.
101 | *
102 | * @param Glimpse_Handler_Interface $handler The handler instance to register.
103 | * @return Glimpse
104 | */
105 | public function registerHandler(Glimpse_Handler_Interface $handler) {
106 | $this->_glimpseHandlers[] = $handler;
107 | return $this;
108 | }
109 |
110 | /**
111 | * Retrieves the list of registered handlers.
112 | *
113 | * @return array Array of Glimpse_Handler_Interface
114 | */
115 | public function retrieveHandlers() {
116 | return $this->_glimpseHandlers;
117 | }
118 |
119 | /**
120 | * Register a Glimpse plugin.
121 | *
122 | * @param Glimpse_Plugin_Interface $plugin The plugin instance to register.
123 | * @return Glimpse
124 | */
125 | public function registerPlugin(Glimpse_Plugin_Interface $plugin) {
126 | $this->_glimpsePlugins[] = $plugin;
127 | return $this;
128 | }
129 |
130 | /**
131 | * Retrieves the list of registered plugins.
132 | *
133 | * @return array Array of Glimpse_Plugin_Interface
134 | */
135 | public function retrievePlugins() {
136 | return $this->_glimpsePlugins;
137 | }
138 |
139 | /**
140 | * Sets the list of registered plugins.
141 | *
142 | * @param array $plugin Array of Glimpse_Plugin_Interface
143 | * @return Glimpse
144 | */
145 | public function setPlugins($value = array()) {
146 | $this->_glimpsePlugins = $value;
147 | return $this;
148 | }
149 |
150 | /**
151 | * Configures Glimpse.
152 | *
153 | * @param array $configuration Array containg configuration values.
154 | * @return Glimpse
155 | */
156 | public function configure($configuration = array()) {
157 | foreach ($configuration as $key => $value) {
158 | $this->_configuration[$key] = $value;
159 |
160 | switch(strtolower($key)) {
161 | case 'plugins-disabled':
162 | $pluginsDisabled = explode(',', $value);
163 | foreach ($pluginsDisabled as $pluginDisable) {
164 | foreach ($this->_glimpsePlugins as $pluginKey => $pluginValue) {
165 | if (is_a($this->_glimpsePlugins[$pluginKey], $pluginDisable)) {
166 | unset($this->_glimpsePlugins[$pluginKey]);
167 | }
168 | }
169 | }
170 | break;
171 | }
172 | }
173 |
174 | return $this;
175 | }
176 |
177 | /**
178 | * Retrieves the current Glimpse configuration.
179 | *
180 | * @return array
181 | */
182 | public function retrieveConfiguration() {
183 | return $this->_configuration;
184 | }
185 |
186 | /**
187 | * Creates a Glimpse instance.
188 | *
189 | * @param array $configuration The Glimpse configuration.
190 | */
191 | public function __construct($configuration = array()) {
192 | $this->_requestId = uniqid('glimpse', true);
193 |
194 | $this->registerHandler(new Glimpse_Handler_EmbeddedResource('client.js', 'text/javascript'))
195 | ->registerHandler(new Glimpse_Handler_EmbeddedResource('logo.png', 'image/png'))
196 | ->registerHandler(new Glimpse_Handler_EmbeddedResource('sprite.png', 'image/png'))
197 | ->registerHandler(new Glimpse_Handler_Config())
198 | ->registerHandler(new Glimpse_Handler_Clients())
199 | ->registerHandler(new Glimpse_Handler_History())
200 | ->registerHandler(new Glimpse_Handler_Data());
201 |
202 | $this->registerPlugin(new Glimpse_Plugin_Server())
203 | ->registerPlugin(new Glimpse_Plugin_Session())
204 | ->registerPlugin(new Glimpse_Plugin_Request())
205 | ->registerPlugin(new Glimpse_Plugin_Config())
206 | ->registerPlugin(new Glimpse_Plugin_Trace())
207 | ->registerPlugin(new Glimpse_Plugin_Environment());
208 | //$this->registerPlugin(new Glimpse_Plugin_Plugins());
209 |
210 | $this->configure($configuration);
211 |
212 | $this->_dispatchPreRun();
213 | }
214 |
215 | /**
216 | * Destructs the Glimpse instance and renders the client-side code when Glimpse is enabled.
217 | */
218 | public function __destruct() {
219 | $this->_dispatchPostRun();
220 | }
221 |
222 | /**
223 | * Dispatches the pre-run handlers for the current request.
224 | */
225 | protected function _dispatchPreRun() {
226 | // Pre-run can run regardless of $this->getMode()
227 | $handlers = $this->retrieveHandlers();
228 | foreach ($handlers as $handler) {
229 | $handler->processPreRun($this);
230 | }
231 | }
232 |
233 | /**
234 | * Collects Glimpse data
235 | */
236 | protected function _collectData() {
237 | // Collect data for the current request
238 | $glimpseData = array();
239 | foreach ($this->retrievePlugins() as $plugin) {
240 | $data = $plugin->getData($this);
241 | if (!is_null($data) && is_array($data)) {
242 | foreach ($data as $tabName => $tabData) {
243 | $glimpseData[$tabName] = $tabData;
244 | }
245 | }
246 | }
247 | $glimpseData = (object)$glimpseData;
248 |
249 | // Glimpse client name
250 | $glimpseClientName = 'null';
251 | if (isset($_COOKIE['glimpseClientName']) && $_COOKIE['glimpseClientName'] != '') {
252 | $glimpseClientName = $_COOKIE['glimpseClientName'];
253 | }
254 |
255 | // Create request metadata
256 | $requestData = (object)array(
257 | 'GlimpseClientName' => $glimpseClientName,
258 | 'Method' => isset($_SERVER['REQUEST_METHOD']) ? $_SERVER['REQUEST_METHOD'] : 'Unknown',
259 | 'Json' => '',
260 | 'Browser' => isset($_SERVER['HTTP_USER_AGENT']) ? $_SERVER['HTTP_USER_AGENT'] : 'Unknown',
261 | 'ClientName' => $glimpseClientName,
262 | 'RequestTime' => isset($_SERVER['REQUEST_TIME']) ? date('Y-m-d H:i:s', $_SERVER['REQUEST_TIME']) : 'Unknown',
263 | 'RequestId' => $this->getRequestId(),
264 | 'IsAjax' => isset($_SERVER['HTTP_X_REQUESTED_WITH']) && $_SERVER['HTTP_USER_AGENT'] == 'XMLHttpRequest',
265 | 'Url' => isset($_SERVER['REQUEST_URI']) ? $_SERVER['REQUEST_URI'] : 'Unknown',
266 | 'Data' => $glimpseData
267 | );
268 |
269 | // Store request data
270 | $this->_currentRequestData = $requestData;
271 | $this->_appendRequestHistory($requestData);
272 | }
273 |
274 | /**
275 | * Gets the request history.
276 | *
277 | * @return array Array of requests.
278 | */
279 | public function getRequestHistory() {
280 | // Retrieve request history from store
281 | $requestStore = $this->_createRequestStore();
282 | $requestStoreData = $requestStore->fetch();
283 | if (!is_array($requestStoreData)) {
284 | $requestStoreData = array();
285 | }
286 | return $requestStoreData;
287 | }
288 |
289 | /**
290 | * Append a request history entry.
291 | *
292 | * @param mixed $requestData The request history entry to append.
293 | */
294 | protected function _appendRequestHistory($requestData) {
295 | // Retrieve request history from store
296 | $requestStore = $this->_createRequestStore();
297 | $requestStoreData = $requestStore->fetch();
298 | if (is_array($requestStoreData)) {
299 | $requestlimit = $this->_configuration['requestlimit'];
300 | while (count($requestStoreData) >= $requestlimit) {
301 | array_shift($requestStoreData);
302 | }
303 | } else {
304 | $requestStoreData = array();
305 | }
306 | $requestStoreData[] = $requestData;
307 | $requestStore->store($requestStoreData);
308 | }
309 |
310 | /**
311 | * Dispatches the post-run handlers for the current request.
312 | */
313 | protected function _dispatchPostRun() {
314 | if ($this->getMode() == 'off') {
315 | return;
316 | }
317 |
318 | // Only track non-Glimpse requests
319 | if (!isset($_REQUEST['glimpseFile'])) {
320 | $this->_collectData();
321 | }
322 |
323 | $handlers = $this->retrieveHandlers();
324 | foreach ($handlers as $handler) {
325 | $handler->processPostRun($this);
326 | }
327 | }
328 |
329 | /**
330 | * Ends the current HTTP request
331 | */
332 | public function endRequest() {
333 | die();
334 | }
335 |
336 | /**
337 | * Create a request store.
338 | *
339 | * @return Glimpse_Store_Interface
340 | */
341 | protected function _createRequestStore() {
342 | if (is_null($this->_requestStore)) {
343 | $fileStoreClass = $this->_configuration['requeststore'];
344 | $this->_requestStore = new $fileStoreClass();
345 | }
346 | return $this->_requestStore;
347 | }
348 |
349 | /**
350 | * Retrieve phpinfo() output as array.
351 | *
352 | * @return array
353 | */
354 | public function retrievePhpInfo() {
355 | if (!is_null($this->_phpInfoResults)) {
356 | return $this->_phpInfoResults;
357 | }
358 |
359 | ob_start();
360 | phpinfo(-1);
361 |
362 | $pi = preg_replace(
363 | array('#^.*(.*).*$#ms', '#
PHP License .*$#ms',
364 | '#
Configuration #', "#\r?\n#", "##", '# +<#',
365 | "#[ \t]+#", '# #', '# +#', '# class=".*?"#', '%'%',
366 | '#
(?:.*?)" src="(?:.*?)=(.*?)" alt="PHP Logo" />'
367 | .'PHP Version (.*?) (?:\n+?) #',
368 | '#
#',
369 | '#
(?:.*?)" src="(?:.*?)=(.*?)"(?:.*?)Zend Engine (.*?),(?:.*?) #',
370 | "# +#", '#
#', '# #'),
371 | array('$1', '', '', '', '' . "\n", '<', ' ', ' ', ' ', '', ' ',
372 | '
PHP Configuration '."\n".'
PHP Version $2 '.
373 | "\n".'
PHP Egg $1 ',
374 | '
PHP Credits Egg $1 ',
375 | '
Zend Engine $2 ' . "\n" .
376 | '
Zend Egg $1 ', ' ', '%S%', '%E%'),
377 | ob_get_clean());
378 |
379 | $sections = explode('
', strip_tags($pi, ''));
380 | unset($sections[0]);
381 |
382 | $pi = array();
383 | foreach($sections as $section){
384 | $n = substr($section, 0, strpos($section, ''));
385 | preg_match_all('#%S%(?: (.*?) )?(?:(.*?) )?(?:(.*?) )?%E%#', $section, $askapache, PREG_SET_ORDER);
386 | foreach($askapache as $m) {
387 | $pi[$n][$m[1]] = isset($m[2]) && (!isset($m[3]) || $m[2] == $m[3]) ? $m[2] : array_slice($m, 2);
388 | }
389 | }
390 |
391 | $this->_phpInfoResults = $pi;
392 | return $pi;
393 | }
394 | }
--------------------------------------------------------------------------------
![](\"http://getglimpse.com/content/uservoice-icon.png\")
Have a feature request? Submit the idea. ![](\"http://getglimpse.com/content/github.gif\")
Found an error? Help us improve. ![](\"http://getglimpse.com/content/twitter.png\")
Have a question? Tweet us using #glimpse.