Diagnostics\Debug.php

  1: <?php
  2: 
  3: /**
  4:  * This file is part of the Nette Framework (http://nette.org)
  5:  *
  6:  * Copyright (c) 2004, 2011 David Grudl (http://davidgrudl.com)
  7:  *
  8:  * For the full copyright and license information, please view
  9:  * the file license.txt that was distributed with this source code.
 10:  */
 11: 
 12: namespace Nette;
 13: 
 14: use Nette,
 15:     Nette\Environment;
 16: 
 17: 
 18: 
 19: /**
 20:  * Debugger: displays and logs errors.
 21:  *
 22:  * Behavior is determined by two factors: mode & output
 23:  * - modes: production / development
 24:  * - output: HTML / AJAX / CLI / other (e.g. XML)
 25:  *
 26:  * @author     David Grudl
 27:  */
 28: final class Debug
 29: {
 30:     /** @var bool in production mode is suppressed any debugging output */
 31:     public static $productionMode;
 32: 
 33:     /** @var bool in console mode is omitted HTML output */
 34:     public static $consoleMode;
 35: 
 36:     /** @var int timestamp with microseconds of the start of the request */
 37:     public static $time;
 38: 
 39:     /** @var bool is Firebug & FireLogger detected? */
 40:     private static $firebugDetected;
 41: 
 42:     /** @var bool is AJAX request detected? */
 43:     private static $ajaxDetected;
 44: 
 45:     /** @var string  requested URI or command line */
 46:     public static $source;
 47: 
 48:     /********************* Debug::dump() ****************d*g**/
 49: 
 50:     /** @var int  how many nested levels of array/object properties display {@link Debug::dump()} */
 51:     public static $maxDepth = 3;
 52: 
 53:     /** @var int  how long strings display {@link Debug::dump()} */
 54:     public static $maxLen = 150;
 55: 
 56:     /** @var int  display location? {@link Debug::dump()} */
 57:     public static $showLocation = FALSE;
 58: 
 59:     /********************* errors and exceptions reporing ****************d*g**/
 60: 
 61:     /** server modes {@link Debug::enable()} */
 62:     const DEVELOPMENT = FALSE,
 63:         PRODUCTION = TRUE,
 64:         DETECT = NULL;
 65: 
 66:     /** @var bool determines whether any error will cause immediate death */
 67:     public static $strictMode = FALSE; // $immediateDeath
 68: 
 69:     /** @var bool disables the @ (shut-up) operator so that notices and warnings are no longer hidden */
 70:     public static $scream = FALSE;
 71: 
 72:     /** @var array of callbacks specifies the functions that are automatically called after fatal error */
 73:     public static $onFatalError = array();
 74: 
 75:     /** @var string name of the directory where errors should be logged; FALSE means that logging is disabled */
 76:     public static $logDirectory;
 77: 
 78:     /** @var string email to sent error notifications */
 79:     public static $email;
 80: 
 81:     /** @var callback handler for sending emails */
 82:     public static $mailer = array(__CLASS__, 'defaultMailer');
 83: 
 84:     /** @var int interval for sending email is 2 days */
 85:     public static $emailSnooze = 172800;
 86: 
 87:     /** @var string URL pattern mask to open editor */
 88:     public static $editor = 'editor://open/?file=%file&line=%line';
 89: 
 90:     /** @var bool {@link Debug::enable()} */
 91:     private static $enabled = FALSE;
 92: 
 93:     /** @var mixed {@link Debug::tryError()} FALSE means catching is disabled */
 94:     private static $lastError = FALSE;
 95: 
 96:     /********************* debug bar ****************d*g**/
 97: 
 98:     /** @var bool determines whether show Debug Bar */
 99:     public static $showBar = TRUE;
100: 
101:     /** @var array */
102:     private static $panels = array();
103: 
104:     /** @var array payload filled by {@link Debug::_errorHandler()} */
105:     private static $errors;
106: 
107:     /********************* Firebug extension ****************d*g**/
108: 
109:     /** {@link Debug::log()} and {@link Debug::fireLog()} */
110:     const DEBUG = 'debug',
111:         INFO = 'info',
112:         WARNING = 'warning',
113:         ERROR = 'error',
114:         CRITICAL = 'critical';
115: 
116: 
117: 
118:     /**
119:      * Static class - cannot be instantiated.
120:      */
121:     final public function __construct()
122:     {
123:         throw new \LogicException("Cannot instantiate static class " . get_class($this));
124:     }
125: 
126: 
127: 
128:     /**
129:      * Static class constructor.
130:      * @internal
131:      */
132:     public static function _init()
133:     {
134:         self::$time = microtime(TRUE);
135:         self::$consoleMode = PHP_SAPI === 'cli';
136:         self::$productionMode = self::DETECT;
137:         if (self::$consoleMode) {
138:             self::$source = empty($_SERVER['argv']) ? 'cli' : 'cli: ' . implode(' ', $_SERVER['argv']);
139:         } else {
140:             self::$firebugDetected = isset($_SERVER['HTTP_X_FIRELOGGER']);
141:             self::$ajaxDetected = isset($_SERVER['HTTP_X_REQUESTED_WITH']) && $_SERVER['HTTP_X_REQUESTED_WITH'] === 'XMLHttpRequest';
142:             if (isset($_SERVER['REQUEST_URI'])) {
143:                 self::$source = (isset($_SERVER['HTTPS']) && strcasecmp($_SERVER['HTTPS'], 'off') ? 'https://' : 'http://')
144:                     . (isset($_SERVER['HTTP_HOST']) ? $_SERVER['HTTP_HOST'] : (isset($_SERVER['SERVER_NAME']) ? $_SERVER['SERVER_NAME'] : ''))
145:                     . $_SERVER['REQUEST_URI'];
146:             }
147:         }
148: 
149:         $tab = array('Nette\DebugHelpers', 'renderTab'); $panel = array('Nette\DebugHelpers', 'renderPanel');
150:         self::addPanel(new DebugPanel('time', $tab, $panel));
151:         self::addPanel(new DebugPanel('memory', $tab, $panel));
152:         self::addPanel($tmp = new DebugPanel('errors', $tab, $panel)); $tmp->data = & self::$errors;
153:         self::addPanel(new DebugPanel('dumps', $tab, $panel));
154:     }
155: 
156: 
157: 
158:     /********************* errors and exceptions reporing ****************d*g**/
159: 
160: 
161: 
162:     /**
163:      * Enables displaying or logging errors and exceptions.
164:      * @param  mixed         production, development mode, autodetection or IP address(es) whitelist.
165:      * @param  string        error log directory; enables logging in production mode, FALSE means that logging is disabled
166:      * @param  string        administrator email; enables email sending in production mode
167:      * @return void
168:      */
169:     public static function enable($mode = NULL, $logDirectory = NULL, $email = NULL)
170:     {
171:         error_reporting(E_ALL | E_STRICT);
172: 
173:         // production/development mode detection
174:         if (is_bool($mode)) {
175:             self::$productionMode = $mode;
176: 
177:         } elseif (is_string($mode)) { // IP addresses
178:             $mode = preg_split('#[,\s]+#', "$mode 127.0.0.1 ::1");
179:         }
180: 
181:         if (is_array($mode)) { // IP addresses whitelist detection
182:             self::$productionMode = !isset($_SERVER['REMOTE_ADDR']) || !in_array($_SERVER['REMOTE_ADDR'], $mode, TRUE);
183:         }
184: 
185:         if (self::$productionMode === self::DETECT) {
186:             if (class_exists('Nette\Environment')) {
187:                 self::$productionMode = Environment::isProduction();
188: 
189:             } elseif (isset($_SERVER['SERVER_ADDR']) || isset($_SERVER['LOCAL_ADDR'])) { // IP address based detection
190:                 $addrs = array();
191:                 if (isset($_SERVER['HTTP_X_FORWARDED_FOR'])) { // proxy server detected
192:                     $addrs = preg_split('#,\s*#', $_SERVER['HTTP_X_FORWARDED_FOR']);
193:                 }
194:                 if (isset($_SERVER['REMOTE_ADDR'])) {
195:                     $addrs[] = $_SERVER['REMOTE_ADDR'];
196:                 }
197:                 $addrs[] = isset($_SERVER['SERVER_ADDR']) ? $_SERVER['SERVER_ADDR'] : $_SERVER['LOCAL_ADDR'];
198:                 self::$productionMode = FALSE;
199:                 foreach ($addrs as $addr) {
200:                     $oct = explode('.', $addr);
201:                     if ($addr !== '::1' && (count($oct) !== 4 || ($oct[0] !== '10' && $oct[0] !== '127' && ($oct[0] !== '172' || $oct[1] < 16 || $oct[1] > 31)
202:                         && ($oct[0] !== '169' || $oct[1] !== '254') && ($oct[0] !== '192' || $oct[1] !== '168')))
203:                     ) {
204:                         self::$productionMode = TRUE;
205:                         break;
206:                     }
207:                 }
208: 
209:             } else {
210:                 self::$productionMode = !self::$consoleMode;
211:             }
212:         }
213: 
214:         // logging configuration
215:         if (is_string($logDirectory)) {
216:             self::$logDirectory = realpath($logDirectory);
217:             if (self::$logDirectory === FALSE) {
218:                 throw new \DirectoryNotFoundException("Directory '$logDirectory' is not found.");
219:             }
220:         } elseif ($logDirectory === FALSE) {
221:             self::$logDirectory = FALSE;
222: 
223:         } else {
224:             self::$logDirectory = defined('APP_DIR') ? APP_DIR . '/../log' : getcwd() . '/log';
225:         }
226:         if (self::$logDirectory) {
227:             ini_set('error_log', self::$logDirectory . '/php_error.log');
228:         }
229: 
230:         // php configuration
231:         if (function_exists('ini_set')) {
232:             ini_set('display_errors', !self::$productionMode); // or 'stderr'
233:             ini_set('html_errors', FALSE);
234:             ini_set('log_errors', FALSE);
235: 
236:         } elseif (ini_get('display_errors') != !self::$productionMode && ini_get('display_errors') !== (self::$productionMode ? 'stderr' : 'stdout')) { // intentionally ==
237:             throw new \NotSupportedException('Function ini_set() must be enabled.');
238:         }
239: 
240:         if ($email) {
241:             if (!is_string($email)) {
242:                 throw new \InvalidArgumentException('Email address must be a string.');
243:             }
244:             self::$email = $email;
245:         }
246: 
247:         if (!defined('E_DEPRECATED')) {
248:             define('E_DEPRECATED', 8192);
249:         }
250: 
251:         if (!defined('E_USER_DEPRECATED')) {
252:             define('E_USER_DEPRECATED', 16384);
253:         }
254: 
255:         if (!self::$enabled) {
256:             register_shutdown_function(array(__CLASS__, '_shutdownHandler'));
257:             set_exception_handler(array(__CLASS__, '_exceptionHandler'));
258:             set_error_handler(array(__CLASS__, '_errorHandler'));
259:             self::$enabled = TRUE;
260:         }
261:     }
262: 
263: 
264: 
265:     /**
266:      * Is Debug enabled?
267:      * @return bool
268:      */
269:     public static function isEnabled()
270:     {
271:         return self::$enabled;
272:     }
273: 
274: 
275: 
276:     /**
277:      * Logs message or exception to file (if not disabled) and sends email notification (if enabled).
278:      * @param  string|Exception
279:      * @param  int  one of constant Debug::INFO, WARNING, ERROR (sends email), CRITICAL (sends email)
280:      * @return void
281:      */
282:     public static function log($message, $priority = self::INFO)
283:     {
284:         if (self::$logDirectory === FALSE) {
285:             return;
286: 
287:         } elseif (!self::$logDirectory) {
288:             throw new \InvalidStateException('Logging directory is not specified in Nette\Debug::$logDirectory.');
289: 
290:         } elseif (!is_dir(self::$logDirectory)) {
291:             throw new \DirectoryNotFoundException("Directory '" . self::$logDirectory . "' is not found or is not directory.");
292:         }
293: 
294:         if ($message instanceof \Exception) {
295:             $exception = $message;
296:             $message = "PHP Fatal error: "
297:                 . ($message instanceof \FatalErrorException ? $exception->getMessage() : "Uncaught exception " . get_class($exception) . " with message '" . $exception->getMessage() . "'")
298:                 . " in " . $exception->getFile() . ":" . $exception->getLine();
299: 
300:             $hash = md5($exception );
301:             $exceptionFilename = "exception " . @date('Y-m-d H-i-s') . " $hash.html";
302:             foreach (new \DirectoryIterator(self::$logDirectory) as $entry) {
303:                 if (strpos($entry, $hash)) {
304:                     $exceptionFilename = NULL; break;
305:                 }
306:             }
307:         }
308: 
309:         error_log(
310:             @date('[Y-m-d H-i-s] ') . trim($message) .
311:                 (self::$source ? '  @  ' . self::$source : '') .
312:                 (!empty($exceptionFilename) ? '  @@  ' . $exceptionFilename : '') . PHP_EOL,
313:             3, self::$logDirectory . '/' . strtolower($priority) . '.log'
314:         );
315: 
316:         if (($priority === self::ERROR || $priority === self::CRITICAL) && self::$email
317:             && @filemtime(self::$logDirectory . '/email-sent') + self::$emailSnooze < time() // @ - file may not exist
318:             && @file_put_contents(self::$logDirectory . '/email-sent', 'sent')) { // @ - file may not be writable
319:             call_user_func(self::$mailer, $message);
320:         }
321: 
322:         if (!empty($exceptionFilename) && $logHandle = @fopen(self::$logDirectory . '/'. $exceptionFilename, 'w')) {
323:             ob_start(); // double buffer prevents sending HTTP headers in some PHP
324:             ob_start(function($buffer) use ($logHandle) { fwrite($logHandle, $buffer); }, 1);
325:             DebugHelpers::renderBlueScreen($exception);
326:             ob_end_flush();
327:             ob_end_clean();
328:             fclose($logHandle);
329:         }
330:     }
331: 
332: 
333: 
334:     /**
335:      * Shutdown handler to catch fatal errors and execute of the planned activities.
336:      * @return void
337:      * @internal
338:      */
339:     public static function _shutdownHandler()
340:     {
341:         // 1) fatal error handler
342:         static $types = array(
343:             E_ERROR => 1,
344:             E_CORE_ERROR => 1,
345:             E_COMPILE_ERROR => 1,
346:             E_PARSE => 1,
347:         );
348:         $error = error_get_last();
349:         if (isset($types[$error['type']])) {
350:             self::_exceptionHandler(new \FatalErrorException($error['message'], 0, $error['type'], $error['file'], $error['line'], NULL));
351:             return;
352:         }
353: 
354:         // 2) debug bar (require HTML & development mode)
355:         if (self::$showBar && !self::$productionMode && !self::$ajaxDetected && !self::$consoleMode
356:             && (!preg_match('#^Content-Type: (?!text/html)#im', implode("\n", headers_list())))) {
357:             DebugHelpers::renderDebugBar(self::$panels);
358:         }
359:     }
360: 
361: 
362: 
363:     /**
364:      * Handler to catch uncaught exception.
365:      * @param  \Exception
366:      * @return void
367:      * @internal
368:      */
369:     public static function _exceptionHandler(\Exception $exception)
370:     {
371:         if (!headers_sent()) { // for PHP < 5.2.4
372:             header('HTTP/1.1 500 Internal Server Error');
373:         }
374: 
375:         $htmlMode = !self::$ajaxDetected && !preg_match('#^Content-Type: (?!text/html)#im', implode("\n", headers_list()));
376: 
377:         try {
378:             if (self::$productionMode) {
379:                 self::log($exception, self::ERROR);
380: 
381:                 if (self::$consoleMode) {
382:                     echo "ERROR: the server encountered an internal error and was unable to complete your request.\n";
383: 
384:                 } elseif ($htmlMode) {
385:                     echo "<!DOCTYPE html><meta http-equiv='Content-Type' content='text/html; charset=utf-8'><meta name=robots content=noindex><meta name=generator content='Nette Framework'>\n\n";
386:                     echo "<style>body{color:#333;background:white;width:500px;margin:100px auto}h1{font:bold 47px/1.5 sans-serif;margin:.6em 0}p{font:21px/1.5 Georgia,serif;margin:1.5em 0}small{font-size:70%;color:gray}</style>\n\n";
387:                     echo "<title>Server Error</title>\n\n<h1>Server Error</h1>\n\n<p>We're sorry! The server encountered an internal error and was unable to complete your request. Please try again later.</p>\n\n<p><small>error 500</small></p>";
388:                 }
389: 
390:             } else {
391:                 if (self::$consoleMode) { // dump to console
392:                     echo "$exception\n";
393: 
394:                 } elseif ($htmlMode) { // dump to browser
395:                     DebugHelpers::renderBlueScreen($exception);
396: 
397:                 } elseif (!self::fireLog($exception, self::ERROR)) { // AJAX or non-HTML mode
398:                     self::log($exception);
399:                 }
400:             }
401: 
402:             foreach (self::$onFatalError as $handler) {
403:                 call_user_func($handler, $exception);
404:             }
405:         } catch (\Exception $e) {
406:             echo "\nNette\\Debug FATAL ERROR: thrown ", get_class($e), ': ', $e->getMessage(), "\nwhile processing ", get_class($exception), ': ', $exception->getMessage(), "\n";
407:             exit;
408:         }
409:     }
410: 
411: 
412: 
413:     /**
414:      * Handler to catch warnings and notices.
415:      * @param  int    level of the error raised
416:      * @param  string error message
417:      * @param  string file that the error was raised in
418:      * @param  int    line number the error was raised at
419:      * @param  array  an array of variables that existed in the scope the error was triggered in
420:      * @return bool   FALSE to call normal error handler, NULL otherwise
421:      * @throws \FatalErrorException
422:      * @internal
423:      */
424:     public static function _errorHandler($severity, $message, $file, $line, $context)
425:     {
426:         if (self::$scream) {
427:             error_reporting(E_ALL | E_STRICT);
428:         }
429: 
430:         if (self::$lastError !== FALSE && ($severity & error_reporting()) === $severity) { // tryError mode
431:             self::$lastError = new \ErrorException($message, 0, $severity, $file, $line);
432:             return NULL;
433:         }
434: 
435:         if ($severity === E_RECOVERABLE_ERROR || $severity === E_USER_ERROR) {
436:             throw new \FatalErrorException($message, 0, $severity, $file, $line, $context);
437: 
438:         } elseif (($severity & error_reporting()) !== $severity) {
439:             return FALSE; // calls normal error handler to fill-in error_get_last()
440: 
441:         } elseif (self::$strictMode && !self::$productionMode) {
442:             self::_exceptionHandler(new \FatalErrorException($message, 0, $severity, $file, $line, $context));
443:             exit;
444:         }
445: 
446:         static $types = array(
447:             E_WARNING => 'Warning',
448:             E_COMPILE_WARNING => 'Warning', // currently unable to handle
449:             E_USER_WARNING => 'Warning',
450:             E_NOTICE => 'Notice',
451:             E_USER_NOTICE => 'Notice',
452:             E_STRICT => 'Strict standards',
453:             E_DEPRECATED => 'Deprecated',
454:             E_USER_DEPRECATED => 'Deprecated',
455:         );
456: 
457:         $message = 'PHP ' . (isset($types[$severity]) ? $types[$severity] : 'Unknown error') . ": $message";
458:         $count = & self::$errors["$message|$file|$line"];
459: 
460:         if ($count++) { // repeated error
461:             return NULL;
462: 
463:         } elseif (self::$productionMode) {
464:             self::log("$message in $file:$line", self::ERROR);
465:             return NULL;
466: 
467:         } else {
468:             $ok = self::fireLog(new \ErrorException($message, 0, $severity, $file, $line), self::WARNING);
469:             return self::$consoleMode || (!self::$showBar && !$ok) ? FALSE : NULL;
470:         }
471: 
472:         return FALSE; // call normal error handler
473:     }
474: 
475: 
476: 
477:     /** @deprecated */
478:     public static function processException(\Exception $exception)
479:     {
480:         trigger_error(__METHOD__ . '() is deprecated; use ' . __CLASS__ . '::log($exception, Debug::ERROR) instead.', E_USER_WARNING);
481:         self::log($exception, self::ERROR);
482:     }
483: 
484: 
485: 
486:     /**
487:      * Handles exception throwed in __toString().
488:      * @param  \Exception
489:      * @return void
490:      */
491:     public static function toStringException(\Exception $exception)
492:     {
493:         if (self::$enabled) {
494:             self::_exceptionHandler($exception);
495:         } else {
496:             trigger_error($exception->getMessage(), E_USER_ERROR);
497:         }
498:         exit;
499:     }
500: 
501: 
502: 
503:     /**
504:      * Starts catching potential errors/warnings.
505:      * @return void
506:      */
507:     public static function tryError()
508:     {
509:         if (!self::$enabled && self::$lastError === FALSE) {
510:             set_error_handler(array(__CLASS__, '_errorHandler'));
511:         }
512:         self::$lastError = NULL;
513:     }
514: 
515: 
516: 
517:     /**
518:      * Returns catched error/warning message.
519:      * @param  \ErrorException  catched error
520:      * @return bool
521:      */
522:     public static function catchError(& $error)
523:     {
524:         if (!self::$enabled && self::$lastError !== FALSE) {
525:             restore_error_handler();
526:         }
527:         $error = self::$lastError;
528:         self::$lastError = FALSE;
529:         return (bool) $error;
530:     }
531: 
532: 
533: 
534:     /**
535:      * Default mailer.
536:      * @param  string
537:      * @return void
538:      */
539:     private static function defaultMailer($message)
540:     {
541:         $host = isset($_SERVER['HTTP_HOST']) ? $_SERVER['HTTP_HOST'] :
542:                 (isset($_SERVER['SERVER_NAME']) ? $_SERVER['SERVER_NAME'] : '');
543: 
544:         $parts = str_replace(
545:             array("\r\n", "\n"),
546:             array("\n", PHP_EOL),
547:             array(
548:                 'headers' => "From: noreply@$host\nX-Mailer: Nette Framework\n",
549:                 'subject' => "PHP: An error occurred on the server $host",
550:                 'body' => "[" . @date('Y-m-d H:i:s') . "] $message", // @ - timezone may not be set
551:             )
552:         );
553: 
554:         mail(self::$email, $parts['subject'], $parts['body'], $parts['headers']);
555:     }
556: 
557: 
558: 
559:     /********************* useful tools ****************d*g**/
560: 
561: 
562: 
563:     /**
564:      * Dumps information about a variable in readable format.
565:      * @param  mixed  variable to dump
566:      * @param  bool   return output instead of printing it? (bypasses $productionMode)
567:      * @return mixed  variable itself or dump
568:      */
569:     public static function dump($var, $return = FALSE)
570:     {
571:         if (!$return && self::$productionMode) {
572:             return $var;
573:         }
574: 
575:         $output = "<pre class=\"nette-dump\">" . DebugHelpers::htmlDump($var) . "</pre>\n";
576: 
577:         if (!$return && self::$showLocation) {
578:             $trace = debug_backtrace();
579:             $i = isset($trace[1]['class']) && $trace[1]['class'] === __CLASS__ ? 1 : 0;
580:             if (isset($trace[$i]['file'], $trace[$i]['line'])) {
581:                 $output = substr_replace($output, ' <small>' . htmlspecialchars("in file {$trace[$i]['file']} on line {$trace[$i]['line']}", ENT_NOQUOTES) . '</small>', -8, 0);
582:             }
583:         }
584: 
585:         if (self::$consoleMode) {
586:             $output = htmlspecialchars_decode(strip_tags($output), ENT_NOQUOTES);
587:         }
588: 
589:         if ($return) {
590:             return $output;
591: 
592:         } else {
593:             echo $output;
594:             return $var;
595:         }
596:     }
597: 
598: 
599: 
600:     /**
601:      * Starts/stops stopwatch.
602:      * @param  string  name
603:      * @return float   elapsed seconds
604:      */
605:     public static function timer($name = NULL)
606:     {
607:         static $time = array();
608:         $now = microtime(TRUE);
609:         $delta = isset($time[$name]) ? $now - $time[$name] : 0;
610:         $time[$name] = $now;
611:         return $delta;
612:     }
613: 
614: 
615: 
616:     /********************* debug bar ****************d*g**/
617: 
618: 
619: 
620:     /**
621:      * Add custom panel.
622:      * @param  IDebugPanel
623:      * @return void
624:      */
625:     public static function addPanel(IDebugPanel $panel)
626:     {
627:         self::$panels[] = $panel;
628:     }
629: 
630: 
631: 
632:     /**
633:      * Dumps information about a variable in Nette Debug Bar.
634:      * @param  mixed  variable to dump
635:      * @param  string optional title
636:      * @return mixed  variable itself
637:      */
638:     public static function barDump($var, $title = NULL)
639:     {
640:         if (!self::$productionMode) {
641:             $dump = array();
642:             foreach ((is_array($var) ? $var : array('' => $var)) as $key => $val) {
643:                 $dump[$key] = DebugHelpers::clickableDump($val);
644:             }
645:             self::$panels[3]->data[] = array('title' => $title, 'dump' => $dump);
646:         }
647:         return $var;
648:     }
649: 
650: 
651: 
652:     /********************* Firebug extension ****************d*g**/
653: 
654: 
655: 
656:     /**
657:      * Sends message to FireLogger console.
658:      * @see http://firelogger.binaryage.com
659:      * @param  mixed   message to log
660:      * @return bool    was successful?
661:      */
662:     public static function fireLog($message)
663:     {
664:         if (self::$productionMode) {
665:             return;
666: 
667:         } elseif (!self::$firebugDetected || headers_sent()) {
668:             return FALSE;
669:         }
670: 
671:         static $payload = array('logs' => array());
672: 
673:         $item = array(
674:             'name' => 'PHP',
675:             'level' => 'debug',
676:             'order' => count($payload['logs']),
677:             'time' => str_pad(number_format((microtime(TRUE) - self::$time) * 1000, 1, '.', ' '), 8, '0', STR_PAD_LEFT) . ' ms',
678:             'template' => '',
679:             'message' => '',
680:             'style' => 'background:#767ab6',
681:         );
682: 
683:         $args = func_get_args();
684:         if (isset($args[0]) && is_string($args[0])) {
685:             $item['template'] = array_shift($args);
686:         }
687: 
688:         if (isset($args[0]) && $args[0] instanceof \Exception) {
689:             $e = array_shift($args);
690:             $trace = $e->getTrace();
691:             if (isset($trace[0]['class']) && $trace[0]['class'] === __CLASS__ && ($trace[0]['function'] === '_shutdownHandler' || $trace[0]['function'] === '_errorHandler')) {
692:                 unset($trace[0]);
693:             }
694: 
695:             $item['exc_info'] = array(
696:                 $e->getMessage(),
697:                 $e->getFile(),
698:                 array(),
699:             );
700:             $item['exc_frames'] = array();
701: 
702:             foreach ($trace as $frame) {
703:                 $frame += array('file' => NULL, 'line' => NULL, 'class' => NULL, 'type' => NULL, 'function' => NULL, 'object' => NULL, 'args' => NULL);
704:                 $item['exc_info'][2][] = array($frame['file'], $frame['line'], "$frame[class]$frame[type]$frame[function]", $frame['object']);
705:                 $item['exc_frames'][] = $frame['args'];
706:             }
707: 
708:             $file = str_replace(dirname(dirname(dirname($e->getFile()))), "\xE2\x80\xA6", $e->getFile());
709:             $item['template'] = ($e instanceof \ErrorException ? '' : get_class($e) . ': ') . $e->getMessage() . ($e->getCode() ? ' #' . $e->getCode() : '') . ' in ' . $file . ':' . $e->getLine();
710:             array_unshift($trace, array('file' => $e->getFile(), 'line' => $e->getLine()));
711: 
712:         } else {
713:             $trace = debug_backtrace();
714:             if (isset($trace[0]['class']) && $trace[0]['class'] === __CLASS__ && ($trace[0]['function'] === '_shutdownHandler' || $trace[0]['function'] === '_errorHandler')) {
715:                 unset($trace[0]);
716:             }
717:         }
718: 
719:         if (isset($args[0]) && in_array($args[0], array(self::DEBUG, self::INFO, self::WARNING, self::ERROR, self::CRITICAL), TRUE)) {
720:             $item['level'] = array_shift($args);
721:         }
722: 
723:         $item['args'] = $args;
724: 
725:         foreach ($trace as $frame) {
726:             if (isset($frame['file']) && is_file($frame['file'])) {
727:                 $item['pathname'] = $frame['file'];
728:                 $item['lineno'] = $frame['line'];
729:                 break;
730:             }
731:         }
732: 
733:         $payload['logs'][] = DebugHelpers::jsonDump($item, -1);
734:         foreach (str_split(base64_encode(@json_encode($payload)), 4990) as $k => $v) {
735:             header("FireLogger-de11e-$k:$v");
736:         }
737:         return TRUE;
738:     }
739: 
740: }
741: 
742: 
743: 
744: Debug::_init();
745:
Namespaces

Classes

Interfaces
