├── .gitignore
├── tests
    ├── PHPUnit_Framework_TestCase.php
    ├── bootstrap.php
    ├── PsrLogCompatTest.php
    └── AnalogTest.php
├── examples
    ├── ignore.php
    ├── stderr.php
    ├── syslog.php
    ├── default.php
    ├── slackbot.php
    ├── variable.php
    ├── mail.php
    ├── post.php
    ├── file.php
    ├── server.php
    ├── amon.php
    ├── psr-0.php
    ├── buffer.php
    ├── gelf.php
    ├── firephp.php
    ├── chromelogger.php
    ├── mongo.php
    ├── threshold.php
    ├── levelbuffer.php
    ├── multi.php
    └── SplClassLoader.php
├── .travis.yml
├── lib
    ├── Analog
    │   ├── Handler
    │   │   ├── Buffer
    │   │   │   └── Destructor.php
    │   │   ├── Ignore.php
    │   │   ├── Null.php
    │   │   ├── Stderr.php
    │   │   ├── Variable.php
    │   │   ├── Mail.php
    │   │   ├── File.php
    │   │   ├── Amon.php
    │   │   ├── Threshold.php
    │   │   ├── ChromeLogger.php
    │   │   ├── Slackbot.php
    │   │   ├── LevelName.php
    │   │   ├── Post.php
    │   │   ├── WPMail.php
    │   │   ├── GELF.php
    │   │   ├── Multi.php
    │   │   ├── Buffer.php
    │   │   ├── Mongo.php
    │   │   ├── LevelBuffer.php
    │   │   ├── Syslog.php
    │   │   └── FirePHP.php
    │   ├── Logger.php
    │   └── Analog.php
    ├── Analog.php
    └── ChromePhp.php
├── phpunit.xml.dist
├── composer.json
├── LICENSE
└── README.md


/.gitignore:
--------------------------------------------------------------------------------
1 | vendor/*
2 | /composer.lock
3 | 


--------------------------------------------------------------------------------
/tests/PHPUnit_Framework_TestCase.php:
--------------------------------------------------------------------------------
1 | <?php
2 | 
3 | use PHPUnit\Framework\TestCase;
4 | 
5 | class PHPUnit_Framework_TestCase extends TestCase {}
6 | 


--------------------------------------------------------------------------------
/examples/ignore.php:
--------------------------------------------------------------------------------
1 | <?php
2 | 
3 | require '../lib/Analog.php';
4 | 
5 | Analog::handler (Analog\Handler\Ignore::init ());
6 | 
7 | Analog::log ('Hellooooooo');
8 | 
9 | ?>


--------------------------------------------------------------------------------
/examples/stderr.php:
--------------------------------------------------------------------------------
1 | <?php
2 | 
3 | require '../lib/Analog.php';
4 | 
5 | Analog::handler (Analog\Handler\Stderr::init ());
6 | 
7 | Analog::log ('Output to php://stderr');
8 | 
9 | ?>


--------------------------------------------------------------------------------
/examples/syslog.php:
--------------------------------------------------------------------------------
1 | <?php
2 | 
3 | require '../lib/Analog.php';
4 | 
5 | Analog::handler (Analog\Handler\Syslog::init ('analog', 'user'));
6 | 
7 | Analog::log ('Error message', Analog::WARNING);
8 | 
9 | ?>


--------------------------------------------------------------------------------
/examples/default.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | require '../lib/Analog.php';
 4 | 
 5 | Analog::log ('foo');
 6 | Analog::log ('bar');
 7 | 
 8 | echo file_get_contents (Analog::handler ());
 9 | unlink (Analog::handler ());
10 | 
11 | ?>


--------------------------------------------------------------------------------
/examples/slackbot.php:
--------------------------------------------------------------------------------
1 | <?php
2 | 
3 | require '../lib/Analog.php';
4 | 
5 | Analog::handler (Analog\Handler\Slackbot::init ('teamname', 'token', 'channel'));
6 | 
7 | Analog::log ('Error message', Analog::WARNING);
8 | 
9 | ?>


--------------------------------------------------------------------------------
/.travis.yml:
--------------------------------------------------------------------------------
 1 | language: php
 2 | php:
 3 |   - 5.4
 4 |   - 5.5
 5 |   - 5.6
 6 |   - 7.0
 7 |   - hhvm
 8 | 
 9 | before_script: composer install --no-interaction --prefer-source
10 | script:
11 |   - vendor/bin/phpunit --coverage-text --verbose
12 | 


--------------------------------------------------------------------------------
/examples/variable.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | require '../lib/Analog.php';
 4 | 
 5 | $log = '';
 6 | 
 7 | Analog::handler (Analog\Handler\Variable::init ($log));
 8 | 
 9 | Analog::log ('foo');
10 | Analog::log ('bar');
11 | 
12 | echo $log;
13 | 
14 | ?>


--------------------------------------------------------------------------------
/examples/mail.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | require '../lib/Analog.php';
 4 | 
 5 | Analog::handler (Analog\Handler\Mail::init (
 6 | 	'you@example.com',
 7 | 	'Log message',
 8 | 	'noreply@example.com'
 9 | ));
10 | 
11 | Analog::log ('Error message');
12 | 
13 | ?>


--------------------------------------------------------------------------------
/examples/post.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | require '../lib/Analog.php';
 4 | 
 5 | $log = '';
 6 | 
 7 | Analog::handler (Analog\Handler\Post::init ('http://localhost:8080/'));
 8 | 
 9 | Analog::log ('foo');
10 | Analog::log ('bar');
11 | 
12 | echo $log;
13 | 
14 | ?>


--------------------------------------------------------------------------------
/tests/bootstrap.php:
--------------------------------------------------------------------------------
1 | <?php
2 | 
3 | $filename = __DIR__ .'/../vendor/autoload.php';
4 | if (!file_exists($filename)) {
5 |     throw new Exception("You need to execute `composer install` before running the tests. (vendors are required for test execution)");
6 | }
7 | 
8 | require_once $filename;
9 | 


--------------------------------------------------------------------------------
/examples/file.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | require '../lib/Analog.php';
 4 | 
 5 | $log_file = 'log.txt';
 6 | 
 7 | Analog::handler (Analog\Handler\File::init ($log_file));
 8 | 
 9 | Analog::log ('foo');
10 | Analog::log ('bar');
11 | 
12 | echo file_get_contents ($log_file);
13 | unlink ($log_file);
14 | 
15 | ?>


--------------------------------------------------------------------------------
/lib/Analog/Handler/Buffer/Destructor.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Analog\Handler\Buffer;
 4 | 
 5 | /**
 6 |  * A destructor object to call close() for us at the end of the request.
 7 |  */
 8 | class Destructor {
 9 | 	public function __destruct () {
10 | 		\Analog\Handler\Buffer::close ();
11 | 	}
12 | }


--------------------------------------------------------------------------------
/examples/server.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /**
 4 |  * This works with test_post.php to verify sent data.
 5 |  * Run me via:
 6 |  *
 7 |  *     php -S localhost:8080 server.php
 8 |  *
 9 |  * Note: Requires PHP 5.4+
10 |  */
11 | file_put_contents ('php://stdout', 'Logged: ' . join (' - ', $_POST) . "\n");
12 | 
13 | ?>


--------------------------------------------------------------------------------
/examples/amon.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | // 1. Install the Amon PHP lib from http://amon.cx/guide/clients/php/
 4 | require 'amon.php';
 5 | 
 6 | require '../lib/Analog.php';
 7 | 
 8 | Analog::handler (Analog\Handler\Amon::init (
 9 | 	'http://127.0.0.1',
10 | 	2464
11 | ));
12 | 
13 | Analog::log ('Error message');
14 | Analog::log ('Debug info', Analog::DEBUG);
15 | 
16 | ?>


--------------------------------------------------------------------------------
/examples/psr-0.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | require 'SplClassLoader.php';
 4 | 
 5 | $loader = new SplClassLoader ('Analog', '../lib');
 6 | $loader->register ();
 7 | 
 8 | use \Analog\Analog;
 9 | 
10 | $log = '';
11 | 
12 | Analog::handler (\Analog\Handler\Variable::init ($log));
13 | 
14 | Analog::log ('Test one');
15 | Analog::log ('Test two');
16 | 
17 | echo $log;
18 | 
19 | ?>


--------------------------------------------------------------------------------
/examples/buffer.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | require '../lib/Analog.php';
 4 | 
 5 | Analog::handler (Analog\Handler\Buffer::init (
 6 | 	Analog\Handler\Mail::init (
 7 | 		'you@example.com',
 8 | 		'Log messages',
 9 | 		'noreply@example.com'
10 | 	)
11 | ));
12 | 
13 | // will all be sent as one email instead of three
14 | Analog::log ('Message one');
15 | Analog::log ('Message two');
16 | Analog::log ('Message three');
17 | 
18 | ?>


--------------------------------------------------------------------------------
/examples/gelf.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | // 1. Install the GELF classes from https://github.com/Graylog2/gelf-php
 4 | require 'GELFMessage.php';
 5 | require 'GELFMessagePublisher.php';
 6 | 
 7 | require '../lib/Analog.php';
 8 | 
 9 | Analog::handler (Analog\Handler\GELF::init (
10 | 	'localhost'
11 | ));
12 | 
13 | Analog::log ('Error message');
14 | Analog::log (array ('Debug info', __FILE__, __LINE__), Analog::DEBUG);
15 | 
16 | ?>


--------------------------------------------------------------------------------
/lib/Analog/Handler/Ignore.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Analog\Handler;
 4 | 
 5 | /**
 6 |  * Ignores anything sent to it so you can disable logging.
 7 |  *
 8 |  * Usage:
 9 |  *
10 |  *     Analog::handler (Analog\Handler\Ignore::init ());
11 |  *     
12 |  *     Analog::log ('Log me');
13 |  */
14 | class Ignore {
15 | 	public static function init () {
16 | 		return function ($info) {
17 | 			// do nothing
18 | 		};
19 | 	}
20 | }


--------------------------------------------------------------------------------
/examples/firephp.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | require '../lib/Analog.php';
 4 | 
 5 | Analog::handler (Analog\Handler\FirePHP::init ());
 6 | 
 7 | // debug-level message
 8 | Analog::log (array ('A debug message', __FILE__, __LINE__), Analog::DEBUG);
 9 | 
10 | // an info message
11 | Analog::log (array ('An error message', __FILE__, __LINE__), Analog::INFO);
12 | 
13 | // an error with no file/line #'s
14 | Analog::log ('Another error message');
15 | 
16 | ?>


--------------------------------------------------------------------------------
/examples/chromelogger.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | require '../lib/Analog.php';
 4 | 
 5 | Analog::handler (Analog\Handler\ChromeLogger::init ());
 6 | 
 7 | // debug-level message
 8 | Analog::debug ($_SERVER);
 9 | 
10 | // an info message
11 | Analog::info ('An error message');
12 | 
13 | // a warning message
14 | Analog::warning ('Turn back before it\'s too late');
15 | 
16 | // an error with no file/line #'s
17 | Analog::log ('Another error message');
18 | 
19 | ?>


--------------------------------------------------------------------------------
/examples/mongo.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | require '../lib/Analog.php';
 4 | 
 5 | Analog::handler (Analog\Handler\Mongo::init (
 6 | 	'localhost:27017',
 7 | 	'testing',
 8 | 	'log'
 9 | ));
10 | 
11 | Analog::log ('Error message');
12 | Analog::log ('Debug info', Analog::DEBUG);
13 | 
14 | $m = new MongoClient ('mongodb://localhost:27017');
15 | $cur = $m->testing->log->find ();
16 | foreach ($cur as $doc) {
17 | 	print_r ($doc);
18 | }
19 | $m->testing->log->remove ();
20 | 
21 | ?>
22 | 


--------------------------------------------------------------------------------
/lib/Analog/Handler/Null.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Analog\Handler;
 4 | 
 5 | /**
 6 |  * Note: Deprecated because Null is a reserved word in PHP7.
 7 |  * Please use Analog\Handler\Ignore instead.
 8 |  *
 9 |  * Ignores anything sent to it so you can disable logging.
10 |  *
11 |  * Usage:
12 |  *
13 |  *     Analog::handler (Analog\Handler\Null::init ());
14 |  *     
15 |  *     Analog::log ('Log me');
16 |  */
17 | class Null {
18 | 	public static function init () {
19 | 		return function ($info) {
20 | 			// do nothing
21 | 		};
22 | 	}
23 | }


--------------------------------------------------------------------------------
/lib/Analog/Handler/Stderr.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Analog\Handler;
 4 | 
 5 | /**
 6 |  * Send the output to STDERR.
 7 |  *
 8 |  * Usage:
 9 |  *
10 |  *     Analog::handler (Analog\Handler\Stderr::init ());
11 |  *     
12 |  *     Analog::log ('Log me');
13 |  *
14 |  * Note: Uses Analog::$format for the appending format.
15 |  */
16 | class Stderr {
17 | 	public static function init () {
18 | 		return function ($info, $buffered = false) {
19 | 			file_put_contents ('php://stderr', ($buffered)
20 | 				? $info
21 | 				: vsprintf (\Analog\Analog::$format, $info));
22 | 		};
23 | 	}
24 | }


--------------------------------------------------------------------------------
/examples/threshold.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | require '../lib/Analog.php';
 4 | 
 5 | $log = '';
 6 | 
 7 | Analog::handler (Analog\Handler\Threshold::init (
 8 | 	Analog\Handler\Variable::init ($log),
 9 | 	Analog::ERROR
10 | ));
11 | 
12 | // these will be ignored
13 | Analog::log ('Debugging...', Analog::DEBUG);
14 | Analog::log ('Minor warning...', Analog::WARNING);
15 | 
16 | echo "Log is still empty:\n" . $log . "\n";
17 | 
18 | // but these will be logged
19 | Analog::log ('An error...', Analog::ERROR);
20 | Analog::log ('Oh noes!', Analog::URGENT);
21 | 
22 | echo "Log now has everything:\n" . $log;
23 | 
24 | ?>


--------------------------------------------------------------------------------
/examples/levelbuffer.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | require '../lib/Analog.php';
 4 | 
 5 | $log = '';
 6 | 
 7 | Analog::handler (Analog\Handler\LevelBuffer::init (
 8 | 	Analog\Handler\Variable::init ($log),
 9 | 	Analog::CRITICAL
10 | ));
11 | 
12 | // none of these will trigger sending the log
13 | Analog::log ('Debugging...', Analog::DEBUG);
14 | Analog::log ('Minor warning...', Analog::WARNING);
15 | Analog::log ('An error...', Analog::ERROR);
16 | 
17 | echo "Log is still empty:\n" . $log . "\n";
18 | 
19 | // but this will, and will include all the others in the log
20 | Analog::log ('Oh noes!', Analog::URGENT);
21 | 
22 | echo "Log now has everything:\n" . $log;
23 | 
24 | ?>


--------------------------------------------------------------------------------
/lib/Analog/Handler/Variable.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Analog\Handler;
 4 | 
 5 | /**
 6 |  * Append the log info to a variable passed in as a reference.
 7 |  *
 8 |  * Usage:
 9 |  *
10 |  *     $my_log = '';
11 |  *     Analog::handler (Analog\Handler\Variable::init ($my_log));
12 |  *     
13 |  *     Analog::log ('Log me');
14 |  *     echo $my_log;
15 |  *
16 |  * Note: Uses Analog::$format for the appending format.
17 |  */
18 | class Variable {
19 | 	public static function init (&$log) {
20 | 		return function ($info, $buffered = false) use (&$log) {
21 | 			$log .= ($buffered)
22 | 				? $info
23 | 				: vsprintf (\Analog\Analog::$format, $info);
24 | 		};
25 | 	}
26 | }


--------------------------------------------------------------------------------
/phpunit.xml.dist:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="UTF-8"?>
 2 | 
 3 | <phpunit backupGlobals="false"
 4 |          backupStaticAttributes="false"
 5 |          bootstrap="./tests/bootstrap.php"
 6 |          colors="true"
 7 |          convertErrorsToExceptions="true"
 8 |          convertNoticesToExceptions="true"
 9 |          convertWarningsToExceptions="true"
10 |          processIsolation="false"
11 |          stopOnFailure="false"
12 |          syntaxCheck="false"
13 | >
14 |     <testsuites>
15 |         <testsuite name="Analog Test Suite">
16 |             <directory suffix="Test.php" phpVersion="5.3.2" phpVersionOperator=">=">./tests</directory>
17 |         </testsuite>
18 |     </testsuites>
19 | </phpunit>
20 | 


--------------------------------------------------------------------------------
/lib/Analog.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /**
 4 |  * Register a very simple autoloader for the pre-built handlers
 5 |  * based on the current working directory.
 6 |  */
 7 | spl_autoload_register (function ($class) {
 8 | 	$file = str_replace ('\\', DIRECTORY_SEPARATOR, ltrim ($class, '\\')) . '.php';
 9 | 	if (file_exists (__DIR__ . DIRECTORY_SEPARATOR . $file)) {
10 | 		require_once $file;
11 | 		return true;
12 | 	}
13 | 	return false;
14 | });
15 | 
16 | /**
17 |  * We simply alias extend the main class so that Analog is
18 |  * available as a global class. This saves us adding
19 |  * `use \Analog\Analog` at the top of every file,
20 |  * or worse, typeing `\Analog\Analog::log()` everywhere.
21 |  */
22 | class_alias ('\Analog\Analog', 'Analog');


--------------------------------------------------------------------------------
/examples/multi.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | require '../lib/Analog.php';
 4 | 
 5 | $errors = "Errors:\n";
 6 | $warnings = "Warnings:\n";
 7 | $debug = "Debug:\n";
 8 | 
 9 | Analog::handler (Analog\Handler\Multi::init (array (
10 | 	Analog::ERROR   => Analog\Handler\Variable::init ($errors),
11 | 	Analog::WARNING => Analog\Handler\Variable::init ($warnings),
12 | 	Analog::DEBUG   => Analog\Handler\Variable::init ($debug)
13 | )));
14 | 
15 | Analog::log ('First error');
16 | Analog::log ('Emergency!', Analog::URGENT);
17 | Analog::log ('A warning...', Analog::WARNING);
18 | Analog::log ('Some info', Analog::INFO);
19 | Analog::log ('Debugging output', Analog::DEBUG);
20 | 
21 | echo $errors;
22 | echo "-----\n";
23 | echo $warnings;
24 | echo "-----\n";
25 | echo $debug;
26 | 
27 | ?>


--------------------------------------------------------------------------------
/composer.json:
--------------------------------------------------------------------------------
 1 | {
 2 | 	"name": "analog/analog",
 3 | 	"type": "library",
 4 | 	"description": "PHP logging class that can be extended via closures. Includes several pre-built handlers including file, mail, syslog, HTTP post, and MongoDB.",
 5 | 	"keywords": ["log", "logging", "logger", "syslog", "error", "debug", "debugging", "alerts"],
 6 | 	"homepage": "https://github.com/jbroadway/analog",
 7 | 	"license": "MIT",
 8 | 	"authors": [
 9 | 		{
10 | 			"name": "Johnny Broadway",
11 | 			"email": "johnny@johnnybroadway.com",
12 | 			"homepage": "http://www.johnnybroadway.com/"
13 | 		}
14 | 	],
15 | 	"require": {
16 | 		"psr/log": "1.*",
17 | 		"php": ">=5.3.2"
18 | 	},
19 | 	"require-dev": {
20 | 		"phpunit/phpunit": "^4.8.36 || ^5.7 || ^6.5"
21 | 	},
22 | 	"autoload": {
23 | 		"psr-0": {
24 | 			"Analog": "lib/"
25 | 		}
26 | 	}
27 | }
28 | 


--------------------------------------------------------------------------------
/lib/Analog/Handler/Mail.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Analog\Handler;
 4 | 
 5 | /**
 6 |  * Send the log message to the specified email address.
 7 |  *
 8 |  * Usage:
 9 |  *
10 |  *     Analog::handler (Analog\Handler\Mail::init (
11 |  *         'you@example.com',     // to
12 |  *         'Subject line',        // subject
13 |  *         'no-reply@example.com' // from
14 |  *     ));
15 |  */
16 | class Mail {
17 | 	public static function init ($to, $subject, $from) {
18 | 		return function ($info, $buffered = false) use ($to, $subject, $from) {
19 | 			if($info=="") return; // do not send empty mail.
20 | 			$headers = sprintf ("From: %s\r\nContent-type: text/plain; charset=utf-8\r\n", $from);
21 | 			$body = ($buffered)
22 | 				? "Logged:\n" . $info
23 | 				: vsprintf ("Machine: %s\nDate: %s\nLevel: %d\nMessage: %s", $info);
24 | 
25 | 			mail ($to, $subject, wordwrap ($body, 70), $headers);
26 | 		};
27 | 	}
28 | }
29 | 


--------------------------------------------------------------------------------
/lib/Analog/Handler/File.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Analog\Handler;
 4 | 
 5 | /**
 6 |  * Append to the specified log file. Does the same thing as the default
 7 |  * handling.
 8 |  *
 9 |  * Usage:
10 |  *
11 |  *     $log_file = 'log.txt';
12 |  *     Analog::handler (Analog\Handler\File::init ($log_file));
13 |  *     
14 |  *     Analog::log ('Log me');
15 |  *
16 |  * Note: Uses Analog::$format for the appending format.
17 |  */
18 | class File {
19 | 	public static function init ($file) {
20 | 		return function ($info, $buffered = false) use ($file) {
21 | 			$f = fopen ($file, 'a+');
22 | 			if (! $f) {
23 | 				throw new \LogicException ('Could not open file for writing');
24 | 			}
25 | 	
26 | 			if (! flock ($f, LOCK_EX)) {
27 | 				throw new \RuntimeException ('Could not lock file');
28 | 			}
29 | 	
30 | 			fwrite ($f, ($buffered)
31 | 				? $info
32 | 				: vsprintf (\Analog\Analog::$format, $info));
33 | 			flock ($f, LOCK_UN);
34 | 			fclose ($f);
35 | 		};
36 | 	}
37 | }
38 | 


--------------------------------------------------------------------------------
/tests/PsrLogCompatTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | date_default_timezone_set ('GMT');
 4 | 
 5 | require_once ('lib/Analog.php');
 6 | 
 7 | use Analog\Logger;
 8 | use Analog\Handler\Variable;
 9 | use Psr\Log\Test\LoggerInterfaceTest;
10 | 
11 | if (! class_exists ('PHPUnit_Framework_TestCase')) {
12 | 	require_once ('tests/PHPUnit_Framework_TestCase.php');
13 | }
14 | 
15 | class PsrLogCompatTest extends LoggerInterfaceTest {
16 | 	private $log = '';
17 | 
18 | 	public function getLogger () {
19 | 		$logger = new Logger ();
20 | 		$logger->handler (Variable::init ($this->log));
21 | 		$logger->format ("%3\$d %4\$s\n");
22 | 		return $logger;
23 | 	}
24 | 
25 | 	public function getLogs () {
26 | 		$logger = $this->getLogger ();
27 | 
28 | 		$logs = explode ("\n", trim ($this->log));
29 | 
30 | 		foreach ($logs as $key => $line) {
31 | 			list ($level, $msg) = explode (' ', $line, 2);
32 | 			$logs[$key] = $logger->convert_log_level ((int) $level, true) . ' ' . $msg;
33 | 		}
34 | 
35 | 		return $logs;
36 | 	}
37 | }


--------------------------------------------------------------------------------
/lib/Analog/Handler/Amon.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Analog\Handler;
 4 | 
 5 | /**
 6 |  * Send the log message to an Amon monitoring server (http://amon.cx/).
 7 |  *
 8 |  * Usage:
 9 |  *
10 |  *     // First include the Amon classes
11 |  *     require 'amon.php';
12 |  *     
13 |  *     // Initialize the Analog Amon handler
14 |  *     Analog::handler (Analog\Handler\Amon::init (
15 |  *         'http://127.0.0.1', // server address
16 |  *         2464,               // port number
17 |  *         'abc123def456'      // application key
18 |  *     ));
19 |  */
20 | class Amon {
21 | 	public static function init ($host = 'http://127.0.0.1', $port = 2464, $key = false) {
22 | 		\Amon::config (array (
23 | 			'host' => $host,
24 | 			'port' => $port,
25 | 			'application_key' => $key
26 | 		));
27 | 
28 | 		$tags = array (
29 | 			0 => 'urgent',
30 | 			1 => 'alert',
31 | 			2 => 'critical',
32 | 			3 => 'error',
33 | 			4 => 'warning',
34 | 			5 => 'notice',
35 | 			6 => 'info',
36 | 			7 => 'debug'
37 | 		);
38 | 
39 | 		return function ($info) use ($tags) {
40 | 			\Amon::log ($info, array ($tags[$info['level']]));
41 | 		};
42 | 	}
43 | }


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | The MIT License
 2 | 
 3 | Copyright (c) 2012 Johnny Broadway
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in
13 | all copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
21 | THE SOFTWARE.
22 | 


--------------------------------------------------------------------------------
/lib/Analog/Handler/Threshold.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Analog\Handler;
 4 | 
 5 | /**
 6 |  * Only writes log messages above a certain threshold
 7 |  *
 8 |  *
 9 |  * Usage:
10 |  *
11 |  *     Analog::handler (Analog\Handler\Threshold::init (
12 |  *         Analog\Handler\File::init ($file),
13 |  *         Analog::ERROR
14 |  *     ));
15 |  *     
16 |  *     // Only message three will be logged
17 |  *     Analog::log ('Message one', Analog::DEBUG);
18 |  *     Analog::log ('Message two', Analog::WARNING);
19 |  *     Analog::log ('Message three', Analog::URGENT);
20 |  *
21 |  * Note: Uses Analog::$format to format the messages as they're appended
22 |  * to the buffer.
23 |  */
24 | class Threshold {
25 | 	/**
26 | 	 * This contains the handler to send to on close.
27 | 	 */
28 | 	public static $handler;
29 | 
30 | 	/**
31 | 	 * Accepts another handler function to be used on close().
32 | 	 * $until_level defaults to ERROR.
33 | 	 */
34 | 	public static function init ($handler, $until_level = 3) {
35 | 		self::$handler = $handler;
36 | 
37 | 		return function ($info) use ($until_level) {
38 | 			if ($info['level'] <= $until_level) {
39 | 				$handler = Threshold::$handler;
40 | 				$handler ($info);
41 | 			}
42 | 		};
43 | 	}
44 | 
45 | }


--------------------------------------------------------------------------------
/lib/Analog/Handler/ChromeLogger.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Analog\Handler;
 4 | 
 5 | require_once __DIR__ . '/../../ChromePhp.php';
 6 | 
 7 | /**
 8 |  * Log to the [Chrome Logger](http://craig.is/writing/chrome-logger).
 9 |  * Based on the [ChromePhp library](https://github.com/ccampbell/chromephp).
10 |  *
11 |  * Usage:
12 |  *
13 |  *     Analog::handler (Analog\Handler\ChromeLogger::init ());
14 |  *     
15 |  *     // send a debug message
16 |  *     Analog::debug ($an_object);
17 |  *
18 |  *     // send an ordinary message
19 |  *     Analog::info ('An error message');
20 |  */
21 | class ChromeLogger {
22 | 	public static function init () {
23 | 		return function ($info) {
24 | 			switch ($info['level']) {
25 | 				case \Analog\Analog::DEBUG:
26 | 					\ChromePhp::log ($info['message']);
27 | 					break;
28 | 				case \Analog\Analog::INFO:
29 | 				case \Analog\Analog::NOTICE:
30 | 					\ChromePhp::info ($info['message']);
31 | 					break;
32 | 				case \Analog\Analog::WARNING:
33 | 					\ChromePhp::warn ($info['message']);
34 | 					break;
35 | 				case \Analog\Analog::ERROR:
36 | 				case \Analog\Analog::CRITICAL:
37 | 				case \Analog\Analog::ALERT:
38 | 				case \Analog\Analog::URGENT:
39 | 					\ChromePhp::error ($info['message']);
40 | 					break;
41 | 			}
42 | 		};
43 | 	}
44 | }


--------------------------------------------------------------------------------
/lib/Analog/Handler/Slackbot.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Analog\Handler;
 4 | 
 5 | /**
 6 |  * Post the log info to the specified Slack channel through Slack's Slackbot.
 7 |  *
 8 |  * Usage:
 9 |  *
10 |  *     $team = 'team-subdomain';
11 |  *     $token = 'slackbot token';
12 |  *     $channel = 'slack-channel';
13 |  *     Analog::handler (Analog\Handler\Slackbot::init ($team, $token, $channel));
14 |  *
15 |  * Note: Requires cURL.
16 |  */
17 | class Slackbot {
18 | 	public static function init ($team, $token, $channel) {
19 | 		return function ($info) use ($team, $token, $channel) {
20 | 			if (! extension_loaded ('curl')) {
21 | 				throw new \LogicException ('CURL extension not loaded.');
22 | 			}
23 | 			
24 | 			$url = sprintf (
25 | 				'https://%s.slack.com/services/hooks/slackbot?token=%s&channel=%s',
26 | 				$team,
27 | 				$token,
28 | 				$channel
29 | 			);
30 | 			
31 | 			$msg = sprintf (
32 | 				'%s (%d): %s',
33 | 				$info['machine'],
34 | 				$info['level'],
35 | 				$info['message']
36 | 			);
37 | 
38 | 			$ch = curl_init ();
39 | 			curl_setopt ($ch, CURLOPT_URL, $url);
40 | 			curl_setopt ($ch, CURLOPT_POST, 1);
41 | 			curl_setopt ($ch, CURLOPT_RETURNTRANSFER, 1);
42 | 			curl_setopt ($ch, CURLOPT_POSTFIELDS, $msg);
43 | 			curl_exec ($ch);
44 | 			curl_close ($ch);
45 | 		};
46 | 	}
47 | }


--------------------------------------------------------------------------------
/lib/Analog/Handler/LevelName.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Analog\Handler;
 4 | 
 5 | /**
 6 |  * Translates log level codes to their names
 7 |  *
 8 |  *
 9 |  * Usage:
10 |  *
11 |  *     // The log level (3rd value) must be formatted as a string
12 |  *     Analog::$format = "%s - %s - %s - %s\n";
13 |  * 
14 |  *     Analog::handler (Analog\Handler\LevelName::init (
15 |  *         Analog\Handler\File::init ($file)
16 |  *     ));
17 |  */
18 | class LevelName {
19 | 	/**
20 | 	 * Translation list for log levels.
21 | 	 */
22 | 	private static $log_levels = array (
23 | 		\Analog\Analog::DEBUG    => 'DEBUG',
24 | 		\Analog\Analog::INFO     => 'INFO',
25 | 		\Analog\Analog::NOTICE   => 'NOTICE',
26 | 		\Analog\Analog::WARNING  => 'WARNING',
27 | 		\Analog\Analog::ERROR    => 'ERROR',
28 | 		\Analog\Analog::CRITICAL => 'CRITICAL',
29 | 		\Analog\Analog::ALERT    => 'ALERT',
30 | 		\Analog\Analog::URGENT   => 'URGENT'
31 | 	);
32 | 
33 | 	/**
34 | 	 * This contains the handler to send to
35 | 	 */
36 | 	public static $handler;
37 | 
38 | 	public static function init ($handler) {
39 | 		self::$handler = $handler;
40 | 
41 | 		return function ($info) {
42 | 			if (isset(self::$log_levels[$info['level']])) {
43 | 				$info['level'] = self::$log_levels[$info['level']];
44 | 			}
45 | 			$handler = LevelName::$handler;
46 | 			$handler ($info);
47 | 		};
48 | 	}
49 | 
50 | }


--------------------------------------------------------------------------------
/lib/Analog/Handler/Post.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Analog\Handler;
 4 | 
 5 | /**
 6 |  * Post the log info to the specified address.
 7 |  *
 8 |  * Usage:
 9 |  *
10 |  *     $address = 'http://my-log-server/log-me';
11 |  *     Analog::handler (Analog\Handler\Post::init ($address));
12 |  *
13 |  * The server will receive an HTTP POST request with four
14 |  * parameters:
15 |  *
16 |  * - machine
17 |  * - date
18 |  * - level
19 |  * - message
20 |  *
21 |  * Note: Requires cURL.
22 |  */
23 | class Post {
24 | 	public static function init ($address) {
25 | 		return function ($info) use ($address) {
26 | 			if (! extension_loaded ('curl')) {
27 | 				throw new \LogicException ('CURL extension not loaded.');
28 | 			}
29 | 
30 | 			$ch = curl_init ();
31 | 			curl_setopt ($ch, CURLOPT_URL, $address);
32 | 			curl_setopt ($ch, CURLOPT_MAXREDIRS, 3);
33 | 			curl_setopt ($ch, CURLOPT_FOLLOWLOCATION, 0);
34 | 			curl_setopt ($ch, CURLOPT_RETURNTRANSFER, 1);
35 | 			curl_setopt ($ch, CURLOPT_VERBOSE, 0);
36 | 			curl_setopt ($ch, CURLOPT_HEADER, 0);
37 | 			curl_setopt ($ch, CURLOPT_CONNECTTIMEOUT, 10);
38 | 			curl_setopt ($ch, CURLOPT_SSL_VERIFYPEER, 0);
39 | 			curl_setopt ($ch, CURLOPT_SSL_VERIFYHOST, 0);
40 | 			curl_setopt ($ch, CURLOPT_POST, 1);
41 | 			curl_setopt ($ch, CURLOPT_POSTFIELDS, $info);
42 | 			curl_exec ($ch);
43 | 			curl_close ($ch);
44 | 		};
45 | 	}
46 | }


--------------------------------------------------------------------------------
/lib/Analog/Handler/WPMail.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Analog\Handler;
 4 | 
 5 | /**
 6 |  * Send the log message to the specified email address using WordPress wp_mail.
 7 |  *
 8 |  * You can also specify a template in your theme to style how the email looks like.
 9 |  *
10 |  * Usage:
11 |  *
12 |  *     Analog::handler (Analog\Handler\WPMail::init (
13 |  *         'you@example.com',       // to
14 |  *         'Subject line',          // subject
15 |  *         'no-reply@example.com',  // from
16 |  *         'log-email-template.php' // email template in theme
17 |  *     ));
18 |  */
19 | class WPMail {
20 | 	public static function init ($to, $subject, $from, $template='') {
21 | 		return function ($info, $buffered = false) use ($to, $subject, $from, $template) {
22 | 			$body = ($buffered)
23 | 				? "Logged:\n" . $info
24 | 				: vsprintf ("Machine: %s\nDate: %s\nLevel: %d\nMessage: %s", $info);
25 | 
26 | 
27 | 			$log_template = locate_template( $template );
28 | 
29 | 			if ( ! empty( $log_template ) ) {
30 | 				ob_start();
31 | 				include_once $log_template;
32 | 				$body = ob_get_clean();
33 | 			} else {
34 | 				$body = wordwrap( $body, 70 );
35 | 			}
36 | 
37 | 			add_filter( 'wp_mail_content_type', array( __CLASS__, 'set_email_content_type' ) );
38 | 
39 | 			wp_mail( $to, $subject, $body );
40 | 
41 | 			remove_filter( 'wp_mail_content_type', array( __CLASS__, 'set_email_content_type' ) );
42 | 
43 | 		};
44 | 	}
45 | 
46 | 	public static function set_email_content_type() {
47 | 		return 'text/html';
48 | 	}
49 | }


--------------------------------------------------------------------------------
/lib/Analog/Handler/GELF.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Analog\Handler;
 4 | 
 5 | /**
 6 |  * Send the log message to a Graylog2 server (http://graylog2.org/).
 7 |  *
 8 |  * Usage:
 9 |  *
10 |  *     // First include the GELF classes from
11 |  *     // https://github.com/Graylog2/gelf-php
12 |  *     require 'GELFMessage.php';
13 |  *     require 'GELFMessagePublisher.php';
14 |  *     
15 |  *     // Initialize the Analog GELF handler
16 |  *     Analog::handler (Analog\Handler\GELF::init (
17 |  *         '172.16.22.30'
18 |  *     ));
19 |  *     
20 |  *     // Send a message with file and line number
21 |  *     Analog::log (array ('Log me', __FILE__, __LINE__), Analog::DEBUG);
22 |  *     
23 |  *     // Send an ordinary message
24 |  *     Analog::log ('An error message');
25 |  */
26 | class GELF {
27 | 	public static function init ($host = '127.0.0.1', $port = \GELFMessagePublisher::GRAYLOG2_DEFAULT_PORT) {
28 | 		$publisher = new \GELFMessagePublisher ($host, $port);
29 | 
30 | 		return function ($info) use ($publisher) {
31 | 			$message = new \GELFMessage ();
32 | 			$message->setHost ($info['machine']);
33 | 			$message->setLevel ($info['level']);
34 | 
35 | 			if (is_array ($info['message'])) {
36 | 				$message->setShortMessage ($info['message'][0]);
37 | 				$message->setFullMessage ($info['message'][0]);
38 | 				$message->setFile ($info['message'][1]);
39 | 				$message->setLine ($info['message'][2]);
40 | 			} else {
41 | 				$message->setShortMessage ($info['message']);
42 | 				$message->setFullMessage ($info['message']);
43 | 			}
44 | 
45 | 			$publisher->publish ($message);
46 | 		};
47 | 	}
48 | }


--------------------------------------------------------------------------------
/lib/Analog/Handler/Multi.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Analog\Handler;
 4 | 
 5 | /**
 6 |  * Sends messages to one or more of the other handlers based on its
 7 |  * log level.
 8 |  *
 9 |  * Usage:
10 |  *
11 |  *		Analog::handler( Analog\Handler\Multi::init( array(
12 |  *			// anything error or worse goes to this
13 |  *			Analog::ERROR => array(
14 |  *				Analog\Handler\Mail::init( $to, $subject, $from ),
15 |  *				Analog\Handler\Stderr::init()
16 |  *			),
17 |  *
18 |  *			// Warnings are sent here
19 |  *			Analog::WARNING => Analog\Handler\File::init( 'logs/warnings.log' ),
20 |  *
21 |  *			// Debug and info messages sent here
22 |  *			Analog::DEBUG   => Analog\Handler\Ignore::init() // do nothing
23 |  *		) ) );
24 |  *     
25 |  *     // will be ignored
26 |  *     Analog::log ('Ignore me', Analog::DEBUG);
27 |  *
28 |  *     // will be written to logs/warnings.log
29 |  *     Analog::log ('Log me', Analog::WARNING);
30 |  *
31 |  *     // will trigger an email notice
32 |  *     Analog::log ('Uh oh...', Analog::ERROR);
33 |  */
34 | class Multi {
35 | 	public static function init ($handlers) {
36 | 		return function ($info) use ($handlers) {
37 | 			$level = is_numeric ($info['level']) ? $info['level'] : 3;
38 | 			while ($level <= 7) {
39 | 				if ( isset ( $handlers[ $level ] ) ) {
40 | 
41 | 					if ( ! is_array( $handlers[ $level ] ) ) {
42 | 						$handlers[ $level ] = array( $handlers[ $level ] );
43 | 					}
44 | 
45 | 					foreach ( $handlers[ $level ] as $handler ) {
46 | 						$handler( $info );
47 | 					}
48 | 
49 | 					return;
50 | 				}
51 | 				$level++;
52 | 			}
53 | 		};
54 | 	}
55 | }


--------------------------------------------------------------------------------
/lib/Analog/Handler/Buffer.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Analog\Handler;
 4 | 
 5 | /**
 6 |  * Buffers messages to be sent as a batch to another handler at the end
 7 |  * of the request. Currently only works with the Mail handler.
 8 |  *
 9 |  * Usage:
10 |  *
11 |  *     Analog::handler (Analog\Handler\Buffer::init (
12 |  *         Analog\Handler\Mail::init ($to, $subject, $from)
13 |  *     ));
14 |  *     
15 |  *     // will all be buffered into one email
16 |  *     Analog::log ('Message one', Analog::DEBUG);
17 |  *     Analog::log ('Message two', Analog::WARNING);
18 |  *     Analog::log ('Message three', Analog::ERROR);
19 |  *
20 |  * Note: Uses Analog::$format to format the messages as they're appended
21 |  * to the buffer.
22 |  */
23 | class Buffer {
24 | 	/**
25 | 	 * This builds a log string of all messages logged.
26 | 	 */
27 | 	public static $buffer = '';
28 | 
29 | 	/**
30 | 	 * This contains the handler to send to on close.
31 | 	 */
32 | 	private static $handler;
33 | 
34 | 	/**
35 | 	 * A copy of our destructor object that will call close() on our behalf,
36 | 	 * since static classes can't have their own __destruct() methods.
37 | 	 */
38 | 	private static $destructor;
39 | 
40 | 	/**
41 | 	 * Accepts another handler function to be used on close().
42 | 	 */
43 | 	public static function init ($handler) {
44 | 		self::$handler = $handler;
45 | 		self::$destructor = new \Analog\Handler\Buffer\Destructor ();
46 | 
47 | 		return function ($info) {
48 | 			Buffer::$buffer .= vsprintf (\Analog\Analog::$format, $info);
49 | 		};
50 | 	}
51 | 
52 | 	/**
53 | 	 * Passes the buffered log to the final $handler.
54 | 	 */
55 | 	public static function close () {
56 | 		$handler = self::$handler;
57 | 		return $handler (self::$buffer, true);
58 | 	}
59 | }
60 | 


--------------------------------------------------------------------------------
/lib/Analog/Handler/Mongo.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Analog\Handler;
 4 | 
 5 | /**
 6 |  * Send the log message to the specified collection in a
 7 |  * MongoDB database.
 8 |  *
 9 |  * Usage:
10 |  *
11 |  *     Analog::handler (Analog\Handler\Mongo::init (
12 |  *         'localhost:27017', // connection string
13 |  *         'mydb',            // database name
14 |  *         'log'              // collection name
15 |  *     ));
16 |  *
17 |  * Alternately, if you have an existing Mongo connection,
18 |  * you can simply initialize it with that:
19 |  *
20 |  *     $conn = new MongoClient ('localhost:27017');           // mongo driver
21 |  *     $conn = new MongoDB\Driver\Manager('localhost:27017'); // mongodb driver
22 |  *     Analog::handler (Analog\Handler\Mongo::init (
23 |  *         $conn,  // Mongo object
24 |  *         'mydb', // database name
25 |  *         'log'   // collection name
26 |  *     ));
27 |  */
28 | class Mongo {
29 | 	public static function init ($server, $database, $collection) {
30 | 		if ($server instanceof \MongoDB\Driver\Manager) {
31 | 			$driver = 'mongodb';
32 | 			$manager = $server;
33 | 		} elseif ($server instanceof \MongoClient) {
34 | 			$db = $server->{$database};
35 | 		} else {
36 | 			if (class_exists('\MongoDB\Driver\Manager')) {
37 | 				$driver = 'mongodb';
38 | 				$manager = new \MongoDB\Driver\Manager("mongodb://$server");
39 | 			} else {
40 | 				$conn = new \MongoClient ("mongodb://$server");
41 | 				$db = $conn->{$database};
42 | 			}
43 | 		}
44 | 		if ($driver == 'mongodb') {
45 | 			return function ($info) use ($manager, $database, $collection) {
46 | 				$bulk = new \MongoDB\Driver\BulkWrite;
47 | 				$bulk->insert($info);
48 | 				$dbAndColl = $database.'.'.$collection;
49 | 				$manager->executeBulkWrite($dbAndColl, $bulk);
50 | 			};
51 | 		} else {
52 | 			return function ($info) use ($db, $collection) {
53 | 				$db->{$collection}->insert ($info);
54 | 			};
55 | 		}
56 | 	}
57 | }
58 | 


--------------------------------------------------------------------------------
/lib/Analog/Handler/LevelBuffer.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Analog\Handler;
 4 | 
 5 | /**
 6 |  * Buffers messages to be sent as a batch to another handler only when a
 7 |  * message of a certain level threshold has been received. This means for
 8 |  * example that you can trigger a handler only if an error has occurred.
 9 |  * Currently only works with the Mail handler.
10 |  *
11 |  * Inspired by the Monolog FingersCrossedHandler.
12 |  *
13 |  * Usage:
14 |  *
15 |  *     Analog::handler (Analog\Handler\LevelBuffer::init (
16 |  *         Analog\Handler\Mail::init ($to, $subject, $from),
17 |  *         Analog::ERROR
18 |  *     ));
19 |  *     
20 |  *     // will all be buffered until something ERROR or above is logged
21 |  *     Analog::log ('Message one', Analog::DEBUG);
22 |  *     Analog::log ('Message two', Analog::WARNING);
23 |  *     Analog::log ('Message three', Analog::URGENT);
24 |  *
25 |  * Note: Uses Analog::$format to format the messages as they're appended
26 |  * to the buffer.
27 |  */
28 | class LevelBuffer {
29 | 	/**
30 | 	 * This builds a log string of all messages logged.
31 | 	 */
32 | 	public static $buffer = '';
33 | 
34 | 	/**
35 | 	 * This contains the handler to send to on close.
36 | 	 */
37 | 	private static $handler;
38 | 
39 | 	/**
40 | 	 * Accepts another handler function to be used on close().
41 | 	 * $until_level defaults to CRITICAL.
42 | 	 */
43 | 	public static function init ($handler, $until_level = 2) {
44 | 		self::$handler = $handler;
45 | 
46 | 		return function ($info) use ($until_level) {
47 | 			LevelBuffer::$buffer .= vsprintf (\Analog\Analog::$format, $info);
48 | 			if ($info['level'] <= $until_level) {
49 | 				// flush and reset the buffer
50 | 				LevelBuffer::flush ();
51 | 				LevelBuffer::$buffer = '';
52 | 			}
53 | 		};
54 | 	}
55 | 
56 | 	/**
57 | 	 * Passes the buffered log to the final $handler.
58 | 	 */
59 | 	public static function flush () {
60 | 		$handler = self::$handler;
61 | 		return $handler (self::$buffer, true);
62 | 	}
63 | }


--------------------------------------------------------------------------------
/lib/Analog/Handler/Syslog.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Analog\Handler;
 4 | 
 5 | /**
 6 |  * Send the log message to the syslog service. This was borrowed largely
 7 |  * from the Monolog syslog handler.
 8 |  *
 9 |  * Usage:
10 |  *
11 |  *     Analog::handler (Analog\Handler\Syslog::init ('ident', 'facility'));
12 |  */
13 | class Syslog {
14 | 	public static $levels = array (
15 | 		\Analog\Analog::DEBUG    => LOG_DEBUG,
16 | 		\Analog\Analog::INFO     => LOG_INFO,
17 | 		\Analog\Analog::NOTICE   => LOG_NOTICE,
18 | 		\Analog\Analog::WARNING  => LOG_WARNING,
19 | 		\Analog\Analog::ERROR    => LOG_ERR,
20 | 		\Analog\Analog::CRITICAL => LOG_CRIT,
21 | 		\Analog\Analog::ALERT    => LOG_ALERT,
22 | 		\Analog\Analog::URGENT   => LOG_EMERG
23 | 	);
24 | 
25 | 	public static $facilities = array (
26 | 		'auth'     => LOG_AUTH,
27 | 		'authpriv' => LOG_AUTHPRIV,
28 | 		'cron'     => LOG_CRON,
29 | 		'daemon'   => LOG_DAEMON,
30 | 		'kern'     => LOG_KERN,
31 | 		'lpr'      => LOG_LPR,
32 | 		'mail'     => LOG_MAIL,
33 | 		'news'     => LOG_NEWS,
34 | 		'syslog'   => LOG_SYSLOG,
35 | 		'user'     => LOG_USER,
36 | 		'uucp'     => LOG_UUCP
37 | 	);
38 | 
39 | 	public static function init ($ident, $facility) {
40 | 		if (! defined ('PHP_WINDOWS_VERSION_BUILD')) {
41 | 			self::$facilities['local0'] = LOG_LOCAL0;
42 | 			self::$facilities['local1'] = LOG_LOCAL1;
43 | 			self::$facilities['local2'] = LOG_LOCAL2;
44 | 			self::$facilities['local3'] = LOG_LOCAL3;
45 | 			self::$facilities['local4'] = LOG_LOCAL4;
46 | 			self::$facilities['local5'] = LOG_LOCAL5;
47 | 			self::$facilities['local6'] = LOG_LOCAL6;
48 | 			self::$facilities['local7'] = LOG_LOCAL7;
49 | 		}
50 | 
51 | 		if (array_key_exists (strtolower ($facility), self::$facilities)) {
52 | 			$facility = self::$facilities[strtolower ($facility)];
53 | 		} elseif (! in_array ($facility, array_values (self::$facilities), true)) {
54 | 			throw new \UnexpectedValueException ('Unknown facility value "' . $facility . '"');
55 | 		}
56 | 
57 | 		return function ($info) use ($ident, $facility) {
58 | 			if (! openlog ($ident, LOG_PID, $facility)) {
59 | 				throw new \LogicException ('Can\'t open syslog for ident "' . $ident . '" and facility "' . $facility . '"');
60 | 			}
61 | 
62 | 			syslog (Syslog::$levels[$info['level']], vsprintf ('%1$s: %4$s', $info));
63 | 
64 | 			closelog ();
65 | 		};
66 | 	}
67 | }
68 | 


--------------------------------------------------------------------------------
/lib/Analog/Handler/FirePHP.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Analog\Handler;
 4 | 
 5 | /**
 6 |  * Log via FirePHP using the Wildfire protocol (http://www.firephp.org/).
 7 |  * Based loosely on the Monolog FirePHP handler.
 8 |  *
 9 |  * Usage:
10 |  *
11 |  *     Analog::handler (Analog\Handler\FirePHP::init ());
12 |  *     
13 |  *     // send a debug message with file and line number
14 |  *     Analog::log (array ('Log me', __FILE__, __LINE__), Analog::DEBUG);
15 |  *
16 |  *     // send an ordinary message
17 |  *     Analog::log ('An error message');
18 |  */
19 | class FirePHP {
20 | 	/**
21 | 	 * Translation list for log levels.
22 | 	 */
23 | 	private static $log_levels = array (
24 | 		\Analog\Analog::DEBUG    => 'LOG',
25 | 		\Analog\Analog::INFO     => 'INFO',
26 | 		\Analog\Analog::NOTICE   => 'INFO',
27 | 		\Analog\Analog::WARNING  => 'WARN',
28 | 		\Analog\Analog::ERROR    => 'ERROR',
29 | 		\Analog\Analog::CRITICAL => 'ERROR',
30 | 		\Analog\Analog::ALERT    => 'ERROR',
31 | 		\Analog\Analog::URGENT   => 'ERROR'
32 | 	);
33 | 
34 | 	/**
35 | 	 * Message index increases by 1 each time a message is sent.
36 | 	 */
37 | 	private static $message_index = 1;
38 | 
39 | 	/**
40 | 	 * Formats a log header to be sent.
41 | 	 */
42 | 	public static function format_header ($info) {
43 | 		if (is_array ($info['message'])) {
44 | 			$extra = array (
45 | 				'Type' => self::$log_levels[$info['level']],
46 | 				'File' => $info['message'][1],
47 | 				'Line' => $info['message'][2]
48 | 			);
49 | 			$info['message'] = $info['message'][0];
50 | 		} else {
51 | 			$extra = array ('Type' => self::$log_levels[$info['level']]);
52 | 		}
53 | 
54 | 		$json = json_encode (array ($extra, $info['message']));
55 | 
56 | 		return sprintf ('X-Wf-1-1-1-%d: %s|%s|', self::$message_index++, strlen ($json), $json);
57 | 	}
58 | 
59 | 	/**
60 | 	 * Sends the initial headers if FirePHP is available then returns a
61 | 	 * closure that handles sending log messages.
62 | 	 */
63 | 	public static function init () {
64 | 		if (! isset ($_SERVER['HTTP_USER_AGENT']) 
65 | 			|| preg_match ('{\bFirePHP/\d+\.\d+\b}', $_SERVER['HTTP_USER_AGENT'])
66 | 			|| isset ($_SERVER['HTTP_X_FIREPHP_VERSION'])) {
67 | 
68 | 			header ('X-Wf-Protocol-1: http://meta.wildfirehq.org/Protocol/JsonStream/0.2');
69 | 			header ('X-Wf-1-Plugin-1: http://meta.firephp.org/Wildfire/Plugin/FirePHP/Library-FirePHPCore/0.3');
70 | 			header ('X-Wf-1-Structure-1: http://meta.firephp.org/Wildfire/Structure/FirePHP/FirebugConsole/0.1');
71 | 		}
72 | 
73 | 		return function ($info) {
74 | 			header (FirePHP::format_header ($info));
75 | 		};
76 | 	}
77 | }


--------------------------------------------------------------------------------
/tests/AnalogTest.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | require_once ('lib/Analog.php');
  4 | 
  5 | use PHPUnit\Framework\TestCase;
  6 | 
  7 | class AnalogTest extends TestCase {
  8 | 	public static $log = '';
  9 | 
 10 | 	/**
 11 | 	 * @covers Analog::handler
 12 | 	 * @covers Analog::log
 13 | 	 * @covers Analog\Handler\File::init
 14 | 	 */
 15 | 	function test_default () {
 16 | 		@unlink (Analog::handler ());
 17 | 
 18 | 		// Check it wrote correctly to temp file
 19 | 		Analog::log ('Foo');
 20 | 		$this->assertStringMatchesFormat (
 21 | 			"localhost - %d-%d-%d %d:%d:%d - 3 - Foo\n",
 22 | 			file_get_contents (Analog::handler ())
 23 | 		);
 24 | 		unlink (Analog::handler ());
 25 | 	}
 26 | 
 27 | 	/**
 28 | 	 * @depends test_default
 29 | 	 */
 30 | 	function test_format () {
 31 | 		// Test changing the format string and write again
 32 | 		Analog::$format = "%s, %s, %d, %s\n";
 33 | 		Analog::log ('Foo');
 34 | 		$this->assertStringMatchesFormat (
 35 | 			"localhost, %d-%d-%d %d:%d:%d, 3, Foo\n",
 36 | 			file_get_contents (Analog::handler ())
 37 | 		);
 38 | 		unlink (Analog::handler ());
 39 | 	}
 40 | 	
 41 | 	/**
 42 | 	 * @depends test_format
 43 | 	 */
 44 | 	function test_tz_and_dates () {
 45 | 		// Test changing the date_format
 46 | 		Analog::$date_format = 'r'; // RFC2822 format
 47 | 		Analog::log ('Foo');
 48 | 		$this->assertStringMatchesFormat (
 49 | 			"localhost, %s, %d %s %d %d:%d:%d +0000, 3, Foo\n",
 50 | 			file_get_contents (Analog::handler ())
 51 | 		);
 52 | 		unlink (Analog::handler ());
 53 | 
 54 | 		// Test changing the timezone
 55 | 		Analog::$timezone = 'CST';
 56 | 		Analog::log ('Foo');
 57 | 
 58 | 		$dt = new \DateTime ('now', new \DateTimeZone (Analog::$timezone));
 59 | 		$zone_offset = $dt->format ('O');
 60 | 
 61 | 		$this->assertStringMatchesFormat (
 62 | 			"localhost, %s, %d %s %d %d:%d:%d $zone_offset, 3, Foo\n",
 63 | 			file_get_contents (Analog::handler ())
 64 | 		);
 65 | 		unlink (Analog::handler ());
 66 | 		
 67 | 		Analog::$date_format = 'Y-m-d H:i:s';
 68 | 		Analog::$timezone = 'GMT';
 69 | 	}
 70 | 
 71 | 	/**
 72 | 	 * @depends test_tz_and_dates
 73 | 	 */
 74 | 	function test_handler () {
 75 | 		// Test logging using a closure
 76 | 		Analog::handler (function ($msg) {
 77 | 			AnalogTest::$log .= vsprintf (Analog::$format, $msg);
 78 | 		});
 79 | 
 80 | 		Analog::log ('Testing');
 81 | 		$this->assertStringMatchesFormat (
 82 | 			"localhost, %d-%d-%d %d:%d:%d, 3, Testing\n",
 83 | 			self::$log
 84 | 		);
 85 | 
 86 | 		self::$log = '';
 87 | 	}
 88 | 	
 89 | 	/**
 90 | 	 * @depends test_handler
 91 | 	 */
 92 | 	function test_level () {
 93 | 		// Test default_level change
 94 | 		Analog::$default_level = 1;
 95 | 		Analog::log ('Testing');
 96 | 		$this->assertStringMatchesFormat (
 97 | 			"localhost, %d-%d-%d %d:%d:%d, 1, Testing\n",
 98 | 			self::$log
 99 | 		);
100 | 		
101 | 		Analog::$default_level = 3;
102 | 	}
103 | 	
104 | 	/*
105 | 	 * @depends test_level
106 | 	 * @covers Analog::urgent
107 | 	 * @covers Analog::alert
108 | 	 * @covers Analog::critical
109 | 	 * @covers Analog::error
110 | 	 * @covers Analog::warning
111 | 	 * @covers Analog::notice
112 | 	 * @covers Analog::info
113 | 	 * @covers Analog::debug
114 | 	 */
115 | 	function test_aliases () {
116 | 		self::$log = '';
117 | 
118 | 		Analog::urgent ('Testing');
119 | 		$this->assertStringMatchesFormat (
120 | 			"localhost, %d-%d-%d %d:%d:%d, 0, Testing\n",
121 | 			self::$log
122 | 		);
123 | 
124 | 		self::$log = '';
125 | 
126 | 		Analog::alert ('Testing');
127 | 		$this->assertStringMatchesFormat (
128 | 			"localhost, %d-%d-%d %d:%d:%d, 1, Testing\n",
129 | 			self::$log
130 | 		);
131 | 
132 | 		self::$log = '';
133 | 
134 | 		Analog::error ('Testing');
135 | 		$this->assertStringMatchesFormat (
136 | 			"localhost, %d-%d-%d %d:%d:%d, 3, Testing\n",
137 | 			self::$log
138 | 		);
139 | 
140 | 		self::$log = '';
141 | 
142 | 		Analog::warning ('Testing');
143 | 		$this->assertStringMatchesFormat (
144 | 			"localhost, %d-%d-%d %d:%d:%d, 4, Testing\n",
145 | 			self::$log
146 | 		);
147 | 
148 | 		self::$log = '';
149 | 
150 | 		Analog::notice ('Testing');
151 | 		$this->assertStringMatchesFormat (
152 | 			"localhost, %d-%d-%d %d:%d:%d, 5, Testing\n",
153 | 			self::$log
154 | 		);
155 | 
156 | 		self::$log = '';
157 | 
158 | 		Analog::info ('Testing');
159 | 		$this->assertStringMatchesFormat (
160 | 			"localhost, %d-%d-%d %d:%d:%d, 6, Testing\n",
161 | 			self::$log
162 | 		);
163 | 
164 | 		self::$log = '';
165 | 
166 | 		Analog::debug ('Testing');
167 | 		$this->assertStringMatchesFormat (
168 | 			"localhost, %d-%d-%d %d:%d:%d, 7, Testing\n",
169 | 			self::$log
170 | 		);
171 | 
172 | 		self::$log = '';
173 | 	}
174 | }
175 | 
176 | ?>
177 | 


--------------------------------------------------------------------------------
/examples/SplClassLoader.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | /*
  4 |  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  5 |  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  6 |  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  7 |  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  8 |  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  9 |  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 10 |  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 11 |  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 12 |  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 13 |  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 14 |  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 15 |  *
 16 |  * This software consists of voluntary contributions made by many individuals
 17 |  * and is licensed under the MIT license. For more information, see
 18 |  * <http://www.doctrine-project.org>.
 19 |  */
 20 |  
 21 | /**
 22 |  * SplClassLoader implementation that implements the technical interoperability
 23 |  * standards for PHP 5.3 namespaces and class names.
 24 |  *
 25 |  * http://groups.google.com/group/php-standards/web/psr-0-final-proposal?pli=1
 26 |  *
 27 |  *     // Example which loads classes for the Doctrine Common package in the
 28 |  *     // Doctrine\Common namespace.
 29 |  *     $classLoader = new SplClassLoader('Doctrine\Common', '/path/to/doctrine');
 30 |  *     $classLoader->register();
 31 |  *
 32 |  * @license http://www.opensource.org/licenses/mit-license.html  MIT License
 33 |  * @author Jonathan H. Wage <jonwage@gmail.com>
 34 |  * @author Roman S. Borschel <roman@code-factory.org>
 35 |  * @author Matthew Weier O'Phinney <matthew@zend.com>
 36 |  * @author Kris Wallsmith <kris.wallsmith@gmail.com>
 37 |  * @author Fabien Potencier <fabien.potencier@symfony-project.org>
 38 |  */
 39 | class SplClassLoader
 40 | {
 41 |     private $_fileExtension = '.php';
 42 |     private $_namespace;
 43 |     private $_includePath;
 44 |     private $_namespaceSeparator = '\\';
 45 | 
 46 |     /**
 47 |      * Creates a new <tt>SplClassLoader</tt> that loads classes of the
 48 |      * specified namespace.
 49 |      * 
 50 |      * @param string $ns The namespace to use.
 51 |      */
 52 |     public function __construct($ns = null, $includePath = null)
 53 |     {
 54 |         $this->_namespace = $ns;
 55 |         $this->_includePath = $includePath;
 56 |     }
 57 | 
 58 |     /**
 59 |      * Sets the namespace separator used by classes in the namespace of this class loader.
 60 |      * 
 61 |      * @param string $sep The separator to use.
 62 |      */
 63 |     public function setNamespaceSeparator($sep)
 64 |     {
 65 |         $this->_namespaceSeparator = $sep;
 66 |     }
 67 | 
 68 |     /**
 69 |      * Gets the namespace seperator used by classes in the namespace of this class loader.
 70 |      *
 71 |      * @return void
 72 |      */
 73 |     public function getNamespaceSeparator()
 74 |     {
 75 |         return $this->_namespaceSeparator;
 76 |     }
 77 | 
 78 |     /**
 79 |      * Sets the base include path for all class files in the namespace of this class loader.
 80 |      * 
 81 |      * @param string $includePath
 82 |      */
 83 |     public function setIncludePath($includePath)
 84 |     {
 85 |         $this->_includePath = $includePath;
 86 |     }
 87 | 
 88 |     /**
 89 |      * Gets the base include path for all class files in the namespace of this class loader.
 90 |      *
 91 |      * @return string $includePath
 92 |      */
 93 |     public function getIncludePath()
 94 |     {
 95 |         return $this->_includePath;
 96 |     }
 97 | 
 98 |     /**
 99 |      * Sets the file extension of class files in the namespace of this class loader.
100 |      * 
101 |      * @param string $fileExtension
102 |      */
103 |     public function setFileExtension($fileExtension)
104 |     {
105 |         $this->_fileExtension = $fileExtension;
106 |     }
107 | 
108 |     /**
109 |      * Gets the file extension of class files in the namespace of this class loader.
110 |      *
111 |      * @return string $fileExtension
112 |      */
113 |     public function getFileExtension()
114 |     {
115 |         return $this->_fileExtension;
116 |     }
117 | 
118 |     /**
119 |      * Installs this class loader on the SPL autoload stack.
120 |      */
121 |     public function register()
122 |     {
123 |         spl_autoload_register(array($this, 'loadClass'));
124 |     }
125 | 
126 |     /**
127 |      * Uninstalls this class loader from the SPL autoloader stack.
128 |      */
129 |     public function unregister()
130 |     {
131 |         spl_autoload_unregister(array($this, 'loadClass'));
132 |     }
133 | 
134 |     /**
135 |      * Loads the given class or interface.
136 |      *
137 |      * @param string $className The name of the class to load.
138 |      * @return void
139 |      */
140 |     public function loadClass($className)
141 |     {
142 |         if (null === $this->_namespace || $this->_namespace.$this->_namespaceSeparator === substr($className, 0, strlen($this->_namespace.$this->_namespaceSeparator))) {
143 |             $fileName = '';
144 |             $namespace = '';
145 |             if (false !== ($lastNsPos = strripos($className, $this->_namespaceSeparator))) {
146 |                 $namespace = substr($className, 0, $lastNsPos);
147 |                 $className = substr($className, $lastNsPos + 1);
148 |                 $fileName = str_replace($this->_namespaceSeparator, DIRECTORY_SEPARATOR, $namespace) . DIRECTORY_SEPARATOR;
149 |             }
150 |             $fileName .= str_replace('_', DIRECTORY_SEPARATOR, $className) . $this->_fileExtension;
151 | 
152 |             require ($this->_includePath !== null ? $this->_includePath . DIRECTORY_SEPARATOR : '') . $fileName;
153 |         }
154 |     }
155 | }
156 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | ## Analog - PHP micro logging package <!-- [![Build Status](https://travis-ci.org/jbroadway/analog.png)](https://travis-ci.org/jbroadway/analog) -->
  2 | 
  3 | * Copyright: (c) 2012-Present Johnny Broadway
  4 | * License: http://www.opensource.org/licenses/mit-license.php
  5 | 
  6 | <a href='http://www.pledgie.com/campaigns/16595'><img alt='Click here to lend your support to: Analog and make a donation at www.pledgie.com !' src='http://www.pledgie.com/campaigns/16595.png?skin_name=chrome' border='0' /></a>
  7 | 
  8 | A PHP logging package based on the idea of using closures
  9 | for configurability and extensibility. It functions as a static class, but you can
 10 | completely control the writing of log messages through a closure function
 11 | (aka [anonymous functions](http://ca3.php.net/manual/en/functions.anonymous.php)),
 12 | or use the `Analog\Logger` wrapper that implements the
 13 | [PSR-3 specification](https://github.com/php-fig/fig-standards/blob/master/accepted/PSR-3-logger-interface.md).
 14 | 
 15 | By default, this class will write to a file named `sys_get_temp_dir() . '/analog.txt'`
 16 | using the format `"machine - date - level - message\n"`, making it usable with no
 17 | customization necessary.
 18 | 
 19 | Analog also comes with over a dozen pre-written handlers in the Analog/Handlers folder,
 20 | with examples for each in the examples folder. These include:
 21 | 
 22 | * Amon - Send logs to the [Amon](http://amon.cx/) server monitoring tool
 23 | * Buffer - Buffer messages to send all at once (works with File, Mail, Stderr, and Variable handlers)
 24 | * ChromeLogger - Sends messages to [Chrome Logger](http://craig.is/writing/chrome-logger) browser plugin
 25 | * File - Append messages to a file
 26 | * FirePHP - Send messages to [FirePHP](http://www.firephp.org/) browser plugin
 27 | * GELF - Send message to the [Graylog2](http://www.graylog2.org/) log management server
 28 | * Ignore - Do nothing
 29 | * LevelBuffer - Buffer messages and send only if sufficient error level reached
 30 | * LevelName - Convert log level numbers to names in log output
 31 | * Mail - Send email notices
 32 | * Mongo - Save to MongoDB collection
 33 | * Multi - Send different log levels to different handlers
 34 | * Post - Send messages over HTTP POST to another machine
 35 | * Slackbot - Post messages to Slack via Slackbot
 36 | * Stderr - Send messages to STDERR
 37 | * Syslog - Send messages to syslog
 38 | * Threshold - Only writes log messages above a certain threshold
 39 | * Variable - Buffer messages to a variable reference.
 40 | 
 41 | So while it's a micro class, it's highly extensible and very capable out of the box too.
 42 | 
 43 | ### Rationale
 44 | 
 45 | I wrote this because I wanted something very small and simple like
 46 | [KLogger](https://github.com/katzgrau/KLogger), and preferably not torn out
 47 | of a wider framework if possible. After searching, I wasn't happy with the
 48 | single-purpose libraries I found. With KLogger for example, I didn't want an
 49 | object instance but rather a static class, and I wanted more flexibility in
 50 | the back-end.
 51 | 
 52 | I also found some that had the flexibility also had more complexity, for example
 53 | [Monolog](https://github.com/Seldaek/monolog) is dozens of source files (not incl. tests).
 54 | With closures, this seemed to be a good balance of small without sacrificing
 55 | flexibility.
 56 | 
 57 | > What about Analog, the logfile analyzer? Well, since it hasn't been updated
 58 | > since 2004, I think it's safe to call a single-file PHP logging class the
 59 | > same thing without it being considered stepping on toes :)
 60 | 
 61 | ### Usage
 62 | 
 63 | Basic usage, with a custom handler function:
 64 | 
 65 | ```php
 66 | <?php
 67 | 
 68 | require_once 'Analog.php';
 69 | 
 70 | // Default logging to /tmp/analog.txt
 71 | Analog::log ('Log this error');
 72 | 
 73 | // Log to a MongoDB log collection
 74 | Analog::handler (function ($info) {
 75 | 	static $conn = null;
 76 | 	if (! $conn) {
 77 | 		$conn = new Mongo ('localhost:27017');
 78 | 	}
 79 | 	$conn->mydb->log->insert ($info);
 80 | });
 81 | 
 82 | // Log an alert
 83 | Analog::log ('The sky is falling!', Analog::ALERT);
 84 | 
 85 | // Log some debug info
 86 | Analog::log ('Debugging info', Analog::DEBUG);
 87 | 
 88 | ?>
 89 | ```
 90 | 
 91 | Usage with [PSR-0](https://github.com/php-fig/fig-standards/blob/master/accepted/PSR-0.md),
 92 | [Composer](http://getcomposer.org/), and the FirePHP handler:
 93 | 
 94 | 1\. Create a `composer.json` file in the root of your project with the following contents.
 95 | 
 96 | ```json
 97 | {
 98 | 	"require": {
 99 | 		"analog/analog": "dev-master"
100 | 	}
101 | }
102 | ```
103 | 
104 | 2\. Run `php composer.phar install` from the terminal in the root of your project.
105 | 
106 | 3\. Include Composer's autoloader and use the `Analog\Analog` class.
107 | 
108 | ```php
109 | <?php
110 | 
111 | require_once 'vendor/autoload.php';
112 | 
113 | use Analog\Analog;
114 | 
115 | Analog::log ('Log this error');
116 | 
117 | Analog::handler (\Analog\Handler\FirePHP::init ());
118 | 
119 | Analog::log ('Take me to your browser');
120 | 
121 | ?>
122 | ```
123 | 
124 | Usage with [PSR-3](https://github.com/php-fig/fig-standards/blob/master/accepted/PSR-3-logger-interface.md),
125 | [Composer](http://getcomposer.org/), and the Variable handler:
126 | 
127 | 1\. Create a `composer.json` file in the root of your project with the following contents.
128 | 
129 | ```json
130 | {
131 | 	"require": {
132 | 		"analog/analog": "dev-master"
133 | 	}
134 | }
135 | ```
136 | 
137 | 2\. Run `php composer.phar install` from the terminal in the root of your project.
138 | 
139 | 3\. Include Composer's autoloader and use the `Analog\Logger` class.
140 | 
141 | ```php
142 | <?php
143 | 
144 | require_once 'vendor/autoload.php';
145 | 
146 | $logger = new Analog\Logger;
147 | 
148 | $log = '';
149 | 
150 | $logger->handler (Analog\Handler\Variable::init ($log));
151 | 
152 | $logger->alert ('Things are really happening right now!');
153 | 
154 | var_dump ($log);
155 | 
156 | ?>
157 | ```
158 | 
159 | For more examples, see the [examples](https://github.com/jbroadway/analog/tree/master/examples) folder.
160 | 


--------------------------------------------------------------------------------
/lib/Analog/Logger.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace Analog;
  4 | 
  5 | use Psr\Log\LoggerInterface;
  6 | use Psr\Log\LogLevel;
  7 | use Psr\Log\InvalidArgumentException;
  8 | 
  9 | /**
 10 |  * Analog - PHP 5.3+ logging class
 11 |  *
 12 |  * Copyright (c) 2012 Johnny Broadway
 13 |  *
 14 |  * Permission is hereby granted, free of charge, to any person obtaining a copy
 15 |  * of this software and associated documentation files (the "Software"), to deal
 16 |  * in the Software without restriction, including without limitation the rights
 17 |  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 18 |  * copies of the Software, and to permit persons to whom the Software is furnished
 19 |  * to do so, subject to the following conditions:
 20 |  *
 21 |  * The above copyright notice and this permission notice shall be included in all
 22 |  * copies or substantial portions of the Software.
 23 |  *
 24 |  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 25 |  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 26 |  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 27 |  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 28 |  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 29 |  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 30 |  * THE SOFTWARE.
 31 |  */
 32 | 
 33 | /**
 34 |  * Implements the PSR-3 standard as a wrapper to Analog. For more information,
 35 |  * see:
 36 |  *
 37 |  * https://github.com/php-fig/fig-standards/blob/master/accepted/PSR-3-logger-interface.md
 38 |  *
 39 |  * Usage:
 40 |  *
 41 |  *     <?php
 42 |  *     
 43 |  *     require_once ('vendor/autoload.php');
 44 |  *
 45 |  *     $log = new Analog\Logger ();
 46 |  *     
 47 |  *     $log->notice ('Things are really happening right now.');
 48 |  *     
 49 |  *     ?>
 50 |  *
 51 |  * @package Analog
 52 |  * @author Johnny Broadway
 53 |  */
 54 | class Logger implements LoggerInterface {
 55 | 	/**
 56 | 	 * Converts from PSR-3 log levels to Analog log levels.
 57 | 	 */
 58 | 	public function convert_log_level ($level, $reverse = false) {
 59 | 		if ($reverse) {
 60 | 			switch ($level) {
 61 | 				case Analog::URGENT:
 62 | 					return LogLevel::EMERGENCY;
 63 | 				case Analog::ALERT:
 64 | 					return LogLevel::ALERT;
 65 | 				case Analog::CRITICAL:
 66 | 					return LogLevel::CRITICAL;
 67 | 				case Analog::ERROR:
 68 | 					return LogLevel::ERROR;
 69 | 				case Analog::WARNING:
 70 | 					return LogLevel::WARNING;
 71 | 				case Analog::NOTICE:
 72 | 					return LogLevel::NOTICE;
 73 | 				case Analog::INFO:
 74 | 					return LogLevel::INFO;
 75 | 				case Analog::DEBUG:
 76 | 					return LogLevel::DEBUG;
 77 | 			}
 78 | 			throw new InvalidArgumentException ('Level "' . $level . '" is not defined.');
 79 | 		} else {
 80 | 			switch ($level) {
 81 | 				case LogLevel::EMERGENCY:
 82 | 					return Analog::URGENT;
 83 | 				case LogLevel::ALERT:
 84 | 					return Analog::ALERT;
 85 | 				case LogLevel::CRITICAL:
 86 | 					return Analog::CRITICAL;
 87 | 				case LogLevel::ERROR:
 88 | 					return Analog::ERROR;
 89 | 				case LogLevel::WARNING:
 90 | 					return Analog::WARNING;
 91 | 				case LogLevel::NOTICE:
 92 | 					return Analog::NOTICE;
 93 | 				case LogLevel::INFO:
 94 | 					return Analog::INFO;
 95 | 				case LogLevel::DEBUG:
 96 | 					return Analog::DEBUG;
 97 | 			}
 98 | 			throw new InvalidArgumentException ('Level "' . $level . '" is not defined.');
 99 | 		}
100 | 	}
101 | 
102 | 	/**
103 | 	 * Interpolates context values into the message placeholders.
104 | 	 */
105 | 	private function interpolate ($message, array $context = array ()) {
106 | 		if (is_array ($message)) {
107 | 			return $message;
108 | 		}
109 | 
110 | 		// build a replacement array with braces around the context keys
111 | 		$replace = array ();
112 | 		foreach ($context as $key => $val) {
113 | 			if (is_object ($val) && get_class ($val) === 'DateTime') {
114 | 				$val = $val->format ('Y-m-d H:i:s');
115 | 			} elseif (is_object ($val)) {
116 | 				$val = json_encode ($val);
117 | 			} elseif (is_array ($val)) {
118 | 				$val = json_encode ($val);
119 | 			} elseif (is_resource ($val)) {
120 | 				$val = (string) $val;
121 | 			}
122 | 			$replace['{' . $key . '}'] = $val;
123 | 		}
124 | 		
125 | 		// interpolate replacement values into the the message and return
126 | 		return strtr ($message, $replace);
127 | 	}
128 | 
129 | 	/**
130 | 	 * Sets the Analog log handler.
131 | 	 */
132 | 	public function handler ($handler) {
133 | 		Analog::handler ($handler);
134 | 	}
135 | 
136 | 	/**
137 | 	 * Sets the log message format.
138 | 	 */
139 | 	public function format ($format) {
140 | 		Analog::$format = $format;
141 | 	}
142 | 
143 | 	/**
144 | 	 * System is unusable.
145 | 	 */
146 | 	public function emergency ($message, array $context = array ()) {
147 | 		$this->_log (Analog::URGENT, $message, $context);
148 | 	}
149 | 
150 | 	/**
151 | 	 * Action must be taken immediately.
152 | 	 */
153 | 	public function alert ($message, array $context = array ()) {
154 | 		$this->_log (Analog::ALERT, $message, $context);
155 | 	}
156 | 
157 | 	/**
158 | 	 * Critical conditions.
159 | 	 */
160 | 	public function critical ($message, array $context = array ()) {
161 | 		$this->_log (Analog::CRITICAL, $message, $context);
162 | 	}
163 | 
164 | 	/**
165 | 	 * Runtime errors that do not require immediate action but should typically
166 | 	 * be logged and monitored.
167 | 	 */
168 | 	public function error ($message, array $context = array ()) {
169 | 		$this->_log (Analog::ERROR, $message, $context);
170 | 	}
171 | 
172 | 	/**
173 | 	 * Exceptional occurrences that are not errors.
174 | 	 */
175 | 	public function warning ($message, array $context = array ()) {
176 | 		$this->_log (Analog::WARNING, $message, $context);
177 | 	}
178 | 
179 | 	/**
180 | 	 * Normal but significant events.
181 | 	 */
182 | 	public function notice ($message, array $context = array ()) {
183 | 		$this->_log (Analog::NOTICE, $message, $context);
184 | 	}
185 | 
186 | 	/**
187 | 	 * Interesting events.
188 | 	 */
189 | 	public function info ($message, array $context = array ()) {
190 | 		$this->_log (Analog::INFO, $message, $context);
191 | 	}
192 | 
193 | 	/**
194 | 	 * Detailed debug information.
195 | 	 */
196 | 	public function debug ($message, array $context = array ()) {
197 | 		$this->_log (Analog::DEBUG, $message, $context);
198 | 	}
199 | 
200 | 	/**
201 | 	 * Logs with an arbitrary level.
202 | 	 */
203 | 	public function log ($level, $message, array $context = array ()) {
204 | 		$this->_log (
205 | 			$this->convert_log_level ($level),
206 | 			$message,
207 | 			$context
208 | 		);
209 | 	}
210 | 
211 | 	/**
212 | 	 * Perform the logging to Analog after the log level has been converted.
213 | 	 */
214 | 	private function _log ($level, $message, $context) {
215 | 		Analog::log (
216 | 			$this->interpolate ($message, $context),
217 | 			$level
218 | 		);
219 | 	}
220 | }


--------------------------------------------------------------------------------
/lib/Analog/Analog.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace Analog;
  4 | 
  5 | /**
  6 |  * Analog - PHP 5.3+ logging class
  7 |  *
  8 |  * Copyright (c) 2012 Johnny Broadway
  9 |  *
 10 |  * Permission is hereby granted, free of charge, to any person obtaining a copy
 11 |  * of this software and associated documentation files (the "Software"), to deal
 12 |  * in the Software without restriction, including without limitation the rights
 13 |  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 14 |  * copies of the Software, and to permit persons to whom the Software is furnished
 15 |  * to do so, subject to the following conditions:
 16 |  *
 17 |  * The above copyright notice and this permission notice shall be included in all
 18 |  * copies or substantial portions of the Software.
 19 |  *
 20 |  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 21 |  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 22 |  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 23 |  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 24 |  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 25 |  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 26 |  * THE SOFTWARE.
 27 |  */
 28 | 
 29 | /**
 30 |  * A short and simple logging class for based on the idea of using closures for
 31 |  * configurability and extensibility. Functions as a static class, but you can
 32 |  * completely control the formatting and writing of log messages through closures.
 33 |  *
 34 |  * By default, this class will write to a file named /tmp/log.txt using a format
 35 |  * "machine - date - level - message\n".
 36 |  *
 37 |  * I wrote this because I wanted something simple and small like KLogger, and
 38 |  * preferably not torn out of a wider framework if possible. After searching,
 39 |  * I wasn't happy with the single-purpose libraries I found. With KLogger for
 40 |  * example, I didn't want an object instance but rather a static class, and I
 41 |  * wanted more flexibility in the back-end.
 42 |  *
 43 |  * I also found that the ones that had really flexible back-ends supported a lot
 44 |  * that I could never personally foresee needing, and could be easier to extend
 45 |  * with new back-ends that may be needed over time. Closures seem a natural fit for
 46 |  * this kind of thing.
 47 |  *
 48 |  * What about Analog, the logfile analyzer? Well, since it hasn't been updated
 49 |  * since 2004, I think it's safe to call a single-file PHP logging class the
 50 |  * same thing without it being considered stepping on toes :)
 51 |  *
 52 |  * Usage:
 53 |  *
 54 |  *     <?php
 55 |  *     
 56 |  *     require_once ('Analog.php');
 57 |  *     
 58 |  *     // Default logging to /tmp/analog.txt
 59 |  *     Analog::log ('Log this error');
 60 |  *     
 61 |  *     // Log to a MongoDB log collection
 62 |  *     Analog::handler (function ($info) {
 63 |  *         static $conn = null;
 64 |  *         if (! $conn) {
 65 |  *             $conn = new Mongo ('localhost:27017');
 66 |  *         }
 67 |  *         $conn->mydb->log->insert ($info);
 68 |  *     });
 69 |  *     
 70 |  *     // Log an alert
 71 |  *     Analog::log ('The sky is falling!', Analog::ALERT);
 72 |  *     
 73 |  *     // Log some debug info
 74 |  *     Analog::log ('Debugging info', Analog::DEBUG);
 75 |  *     
 76 |  *     ?>
 77 |  *
 78 |  * @package Analog
 79 |  * @author Johnny Broadway
 80 |  */
 81 | class Analog {
 82 | 	/**
 83 | 	 * List of severity levels.
 84 | 	 */
 85 | 	const URGENT   = 0; // It's an emergency
 86 | 	const ALERT    = 1; // Immediate action required
 87 | 	const CRITICAL = 2; // Critical conditions
 88 | 	const ERROR    = 3; // An error occurred
 89 | 	const WARNING  = 4; // Something unexpected happening
 90 | 	const NOTICE   = 5; // Something worth noting
 91 | 	const INFO     = 6; // Information, not an error
 92 | 	const DEBUG    = 7; // Debugging messages
 93 | 
 94 | 	/**
 95 | 	 * The default format for log messages (machine, date, level, message)
 96 | 	 * written to a file. To change the order of items in the string,
 97 | 	 * use `%1$s` references.
 98 | 	 */
 99 | 	public static $format = "%s - %s - %d - %s\n";
100 | 
101 | 	/**
102 | 	 * The default date/time format for log messages written to a file.
103 | 	 * Feeds into the `$format` property.
104 | 	 */
105 | 	public static $date_format = 'Y-m-d H:i:s';
106 | 	
107 | 	/**
108 | 	 * Timezone for date/time values.
109 | 	 */
110 | 	public static $timezone = 'GMT';
111 | 	
112 | 	/**
113 | 	 * Default log level.
114 | 	 */
115 | 	public static $default_level = 3;
116 | 
117 | 	/**
118 | 	 * The method of saving the log output. See Analog::handler()
119 | 	 * for details on setting this.
120 | 	 */
121 | 	private static $handler = null;
122 | 
123 | 	/**
124 | 	 * The name of the current machine, defaults to $_SERVER['SERVER_ADDR']
125 | 	 * on first call to format_message(), or 'localhost' if $_SERVER['SERVER_ADDR']
126 | 	 * is not set (e.g., during CLI use).
127 | 	 */
128 | 	public static $machine = null;
129 | 
130 | 	/**
131 | 	 * Handler getter/setter. If no handler is provided, it will set it to
132 | 	 * sys_get_temp_dir() . '/analog.txt' as a default. Usage:
133 | 	 *
134 | 	 *    Analog::handler ('my_log.txt');
135 | 	 *
136 | 	 * Using a closure:
137 | 	 *
138 | 	 *     Analog::handler (function ($msg) {
139 | 	 *         return error_log ($msg);
140 | 	 *     });
141 |  	 */
142 | 	public static function handler ($handler = false) {
143 | 		if ($handler) {
144 | 			self::$handler = $handler;
145 | 		} elseif (! self::$handler) {
146 | 			self::$handler = realpath (sys_get_temp_dir ()) . DIRECTORY_SEPARATOR . 'analog.txt';
147 | 		}
148 | 		return self::$handler;
149 | 	}
150 | 
151 | 	/**
152 | 	 * Get the log info as an associative array.
153 | 	 */
154 | 	private static function get_struct ($message, $level) {
155 | 		if (self::$machine === null) {
156 | 			self::$machine = (isset ($_SERVER['SERVER_ADDR'])) ? $_SERVER['SERVER_ADDR'] : 'localhost';
157 | 		}
158 | 
159 | 		$dt = new \DateTime ('now', new \DateTimeZone (self::$timezone));
160 | 
161 | 		return array (
162 | 			'machine' => self::$machine,
163 | 			'date' => $dt->format (self::$date_format),
164 | 			'level' => $level,
165 | 			'message' => $message
166 | 		);
167 | 	}
168 | 
169 | 	/**
170 | 	 * Write a raw message to the log using a function or the default
171 | 	 * file logging.
172 | 	 */
173 | 	private static function write ($struct) {
174 | 		$handler = self::handler ();
175 | 
176 | 		if (! $handler instanceof \Closure) {
177 | 			$handler = \Analog\Handler\File::init ($handler);
178 | 		}
179 | 		return $handler ($struct);
180 | 	}
181 | 
182 | 	/**
183 | 	 * This is the main function you will call to log messages.
184 | 	 * Defaults to severity level Analog::ERROR, which can be
185 | 	 * changed via the `$default_level` property.
186 | 	 * Usage:
187 | 	 *
188 | 	 *     Analog::log ('Debug info', Analog::DEBUG);
189 | 	 */
190 | 	public static function log ($message, $level = null) {
191 | 		$level = ($level !== null) ? $level : self::$default_level;
192 | 		return self::write (self::get_struct ($message, $level));
193 | 	}
194 | 	
195 | 	/**
196 | 	 * Shortcut method for Analog::log($info, Analog::URGENT)
197 | 	 * Usage:
198 | 	 *
199 | 	 *     Analog::urgent ('Debug info');
200 | 	 */
201 | 	public static function urgent ($message) {
202 | 		return self::write (self::get_struct ($message, self::URGENT));
203 | 	}
204 | 	
205 | 	/**
206 | 	 * Shortcut method for Analog::log($info, Analog::ALERT)
207 | 	 * Usage:
208 | 	 *
209 | 	 *     Analog::alert ('Debug info');
210 | 	 */
211 | 	public static function alert ($message) {
212 | 		return self::write (self::get_struct ($message, self::ALERT));
213 | 	}
214 | 	
215 | 	/**
216 | 	 * Shortcut method for Analog::log($info, Analog::ERROR)
217 | 	 * Usage:
218 | 	 *
219 | 	 *     Analog::error ('Debug info');
220 | 	 */
221 | 	public static function error ($message) {
222 | 		return self::write (self::get_struct ($message, self::ERROR));
223 | 	}
224 | 	
225 | 	/**
226 | 	 * Shortcut method for Analog::log($info, Analog::WARNING)
227 | 	 * Usage:
228 | 	 *
229 | 	 *     Analog::warning ('Debug info');
230 | 	 */
231 | 	public static function warning ($message) {
232 | 		return self::write (self::get_struct ($message, self::WARNING));
233 | 	}
234 | 	
235 | 	/**
236 | 	 * Shortcut method for Analog::log($info, Analog::NOTICE)
237 | 	 * Usage:
238 | 	 *
239 | 	 *     Analog::notice ('Debug info');
240 | 	 */
241 | 	public static function notice ($message) {
242 | 		return self::write (self::get_struct ($message, self::NOTICE));
243 | 	}
244 | 	
245 | 	/**
246 | 	 * Shortcut method for Analog::log($info, Analog::INFO)
247 | 	 * Usage:
248 | 	 *
249 | 	 *     Analog::info ('Debug info');
250 | 	 */
251 | 	public static function info ($message) {
252 | 		return self::write (self::get_struct ($message, self::INFO));
253 | 	}
254 | 	
255 | 	/**
256 | 	 * Shortcut method for Analog::log($info, Analog::DEBUG)
257 | 	 * Usage:
258 | 	 *
259 | 	 *     Analog::debug ('Debug info');
260 | 	 */
261 | 	public static function debug ($message) {
262 | 		return self::write (self::get_struct ($message, self::DEBUG));
263 | 	}
264 | 	
265 | }


--------------------------------------------------------------------------------
/lib/ChromePhp.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | /**
  3 |  * Copyright 2010-2013 Craig Campbell
  4 |  *
  5 |  * Licensed under the Apache License, Version 2.0 (the "License");
  6 |  * you may not use this file except in compliance with the License.
  7 |  * You may obtain a copy of the License at
  8 |  *
  9 |  * http://www.apache.org/licenses/LICENSE-2.0
 10 |  *
 11 |  * Unless required by applicable law or agreed to in writing, software
 12 |  * distributed under the License is distributed on an "AS IS" BASIS,
 13 |  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 14 |  * See the License for the specific language governing permissions and
 15 |  * limitations under the License.
 16 |  */
 17 | 
 18 | /**
 19 |  * Server Side Chrome PHP debugger class
 20 |  *
 21 |  * @package ChromePhp
 22 |  * @author Craig Campbell <iamcraigcampbell@gmail.com>
 23 |  */
 24 | class ChromePhp
 25 | {
 26 |     /**
 27 |      * @var string
 28 |      */
 29 |     const VERSION = '4.0.0';
 30 | 
 31 |     /**
 32 |      * @var string
 33 |      */
 34 |     const HEADER_NAME = 'X-ChromeLogger-Data';
 35 | 
 36 |     /**
 37 |      * @var string
 38 |      */
 39 |     const BACKTRACE_LEVEL = 'backtrace_level';
 40 | 
 41 |     /**
 42 |      * @var string
 43 |      */
 44 |     const LOG = 'log';
 45 | 
 46 |     /**
 47 |      * @var string
 48 |      */
 49 |     const WARN = 'warn';
 50 | 
 51 |     /**
 52 |      * @var string
 53 |      */
 54 |     const ERROR = 'error';
 55 | 
 56 |     /**
 57 |      * @var string
 58 |      */
 59 |     const GROUP = 'group';
 60 | 
 61 |     /**
 62 |      * @var string
 63 |      */
 64 |     const INFO = 'info';
 65 | 
 66 |     /**
 67 |      * @var string
 68 |      */
 69 |     const GROUP_END = 'groupEnd';
 70 | 
 71 |     /**
 72 |      * @var string
 73 |      */
 74 |     const GROUP_COLLAPSED = 'groupCollapsed';
 75 | 
 76 |     /**
 77 |      * @var string
 78 |      */
 79 |     protected $_php_version;
 80 | 
 81 |     /**
 82 |      * @var int
 83 |      */
 84 |     protected $_timestamp;
 85 | 
 86 |     /**
 87 |      * @var array
 88 |      */
 89 |     protected $_json = array(
 90 |         'version' => self::VERSION,
 91 |         'columns' => array('log', 'backtrace', 'type'),
 92 |         'rows' => array()
 93 |     );
 94 | 
 95 |     /**
 96 |      * @var array
 97 |      */
 98 |     protected $_backtraces = array();
 99 | 
100 |     /**
101 |      * @var bool
102 |      */
103 |     protected $_error_triggered = false;
104 | 
105 |     /**
106 |      * @var array
107 |      */
108 |     protected $_settings = array(
109 |         self::BACKTRACE_LEVEL => 1
110 |     );
111 | 
112 |     /**
113 |      * @var ChromePhp
114 |      */
115 |     protected static $_instance;
116 | 
117 |     /**
118 |      * Prevent recursion when working with objects referring to each other
119 |      *
120 |      * @var array
121 |      */
122 |     protected $_processed = array();
123 | 
124 |     /**
125 |      * constructor
126 |      */
127 |     private function __construct()
128 |     {
129 |         $this->_php_version = phpversion();
130 |         $this->_timestamp = $this->_php_version >= 5.1 ? $_SERVER['REQUEST_TIME'] : time();
131 |         $this->_json['request_uri'] = $_SERVER['REQUEST_URI'];
132 |     }
133 | 
134 |     /**
135 |      * gets instance of this class
136 |      *
137 |      * @return ChromePhp
138 |      */
139 |     public static function getInstance()
140 |     {
141 |         if (self::$_instance === null) {
142 |             self::$_instance = new self();
143 |         }
144 |         return self::$_instance;
145 |     }
146 | 
147 |     /**
148 |      * logs a variable to the console
149 |      *
150 |      * @param mixed $data,... unlimited OPTIONAL number of additional logs [...]
151 |      * @return void
152 |      */
153 |     public static function log()
154 |     {
155 |         return self::_log('', func_get_args());
156 |     }
157 | 
158 |     /**
159 |      * logs a warning to the console
160 |      *
161 |      * @param mixed $data,... unlimited OPTIONAL number of additional logs [...]
162 |      * @return void
163 |      */
164 |     public static function warn()
165 |     {
166 |         return self::_log(self::WARN, func_get_args());
167 |     }
168 | 
169 |     /**
170 |      * logs an error to the console
171 |      *
172 |      * @param mixed $data,... unlimited OPTIONAL number of additional logs [...]
173 |      * @return void
174 |      */
175 |     public static function error()
176 |     {
177 |         return self::_log(self::ERROR, func_get_args());
178 |     }
179 | 
180 |     /**
181 |      * sends a group log
182 |      *
183 |      * @param string value
184 |      */
185 |     public static function group()
186 |     {
187 |         return self::_log(self::GROUP, func_get_args());
188 |     }
189 | 
190 |     /**
191 |      * sends an info log
192 |      *
193 |      * @param mixed $data,... unlimited OPTIONAL number of additional logs [...]
194 |      * @return void
195 |      */
196 |     public static function info()
197 |     {
198 |         return self::_log(self::INFO, func_get_args());
199 |     }
200 | 
201 |     /**
202 |      * sends a collapsed group log
203 |      *
204 |      * @param string value
205 |      */
206 |     public static function groupCollapsed()
207 |     {
208 |         return self::_log(self::GROUP_COLLAPSED, func_get_args());
209 |     }
210 | 
211 |     /**
212 |      * ends a group log
213 |      *
214 |      * @param string value
215 |      */
216 |     public static function groupEnd()
217 |     {
218 |         return self::_log(self::GROUP_END, func_get_args());
219 |     }
220 | 
221 |     /**
222 |      * internal logging call
223 |      *
224 |      * @param string $type
225 |      * @return void
226 |      */
227 |     protected static function _log($type, array $args)
228 |     {
229 |         // nothing passed in, don't do anything
230 |         if (count($args) == 0 && $type != self::GROUP_END) {
231 |             return;
232 |         }
233 | 
234 |         $logger = self::getInstance();
235 | 
236 |         $logger->_processed = array();
237 | 
238 |         $logs = array();
239 |         foreach ($args as $arg) {
240 |             $logs[] = $logger->_convert($arg);
241 |         }
242 | 
243 |         $backtrace = debug_backtrace(false);
244 |         $level = $logger->getSetting(self::BACKTRACE_LEVEL);
245 | 
246 |         $backtrace_message = 'unknown';
247 |         if (isset($backtrace[$level]['file']) && isset($backtrace[$level]['line'])) {
248 |             $backtrace_message = $backtrace[$level]['file'] . ' : ' . $backtrace[$level]['line'];
249 |         }
250 | 
251 |         $logger->_addRow($logs, $backtrace_message, $type);
252 |     }
253 | 
254 |     /**
255 |      * converts an object to a better format for logging
256 |      *
257 |      * @param Object
258 |      * @return array
259 |      */
260 |     protected function _convert($object)
261 |     {
262 |         // if this isn't an object then just return it
263 |         if (!is_object($object)) {
264 |             return $object;
265 |         }
266 | 
267 |         //Mark this object as processed so we don't convert it twice and it
268 |         //Also avoid recursion when objects refer to each other
269 |         $this->_processed[] = $object;
270 | 
271 |         $object_as_array = array();
272 | 
273 |         // first add the class name
274 |         $object_as_array['___class_name'] = get_class($object);
275 | 
276 |         // loop through object vars
277 |         $object_vars = get_object_vars($object);
278 |         foreach ($object_vars as $key => $value) {
279 | 
280 |             // same instance as parent object
281 |             if ($value === $object || in_array($value, $this->_processed, true)) {
282 |                 $value = 'recursion - parent object [' . get_class($value) . ']';
283 |             }
284 |             $object_as_array[$key] = $this->_convert($value);
285 |         }
286 | 
287 |         $reflection = new ReflectionClass($object);
288 | 
289 |         // loop through the properties and add those
290 |         foreach ($reflection->getProperties() as $property) {
291 | 
292 |             // if one of these properties was already added above then ignore it
293 |             if (array_key_exists($property->getName(), $object_vars)) {
294 |                 continue;
295 |             }
296 |             $type = $this->_getPropertyKey($property);
297 | 
298 |             if ($this->_php_version >= 5.3) {
299 |                 $property->setAccessible(true);
300 |             }
301 | 
302 |             try {
303 |                 $value = $property->getValue($object);
304 |             } catch (ReflectionException $e) {
305 |                 $value = 'only PHP 5.3 can access private/protected properties';
306 |             }
307 | 
308 |             // same instance as parent object
309 |             if ($value === $object || in_array($value, $this->_processed, true)) {
310 |                 $value = 'recursion - parent object [' . get_class($value) . ']';
311 |             }
312 | 
313 |             $object_as_array[$type] = $this->_convert($value);
314 |         }
315 |         return $object_as_array;
316 |     }
317 | 
318 |     /**
319 |      * takes a reflection property and returns a nicely formatted key of the property name
320 |      *
321 |      * @param ReflectionProperty
322 |      * @return string
323 |      */
324 |     protected function _getPropertyKey(ReflectionProperty $property)
325 |     {
326 |         $static = $property->isStatic() ? ' static' : '';
327 |         if ($property->isPublic()) {
328 |             return 'public' . $static . ' ' . $property->getName();
329 |         }
330 | 
331 |         if ($property->isProtected()) {
332 |             return 'protected' . $static . ' ' . $property->getName();
333 |         }
334 | 
335 |         if ($property->isPrivate()) {
336 |             return 'private' . $static . ' ' . $property->getName();
337 |         }
338 |     }
339 | 
340 |     /**
341 |      * adds a value to the data array
342 |      *
343 |      * @var mixed
344 |      * @return void
345 |      */
346 |     protected function _addRow(array $logs, $backtrace, $type)
347 |     {
348 |         // if this is logged on the same line for example in a loop, set it to null to save space
349 |         if (in_array($backtrace, $this->_backtraces)) {
350 |             $backtrace = null;
351 |         }
352 | 
353 |         // for group, groupEnd, and groupCollapsed
354 |         // take out the backtrace since it is not useful
355 |         if ($type == self::GROUP || $type == self::GROUP_END || $type == self::GROUP_COLLAPSED) {
356 |             $backtrace = null;
357 |         }
358 | 
359 |         if ($backtrace !== null) {
360 |             $this->_backtraces[] = $backtrace;
361 |         }
362 | 
363 |         $row = array($logs, $backtrace, $type);
364 | 
365 |         $this->_json['rows'][] = $row;
366 |         $this->_writeHeader($this->_json);
367 |     }
368 | 
369 |     protected function _writeHeader($data)
370 |     {
371 |         header(self::HEADER_NAME . ': ' . $this->_encode($data));
372 |     }
373 | 
374 |     /**
375 |      * encodes the data to be sent along with the request
376 |      *
377 |      * @param array $data
378 |      * @return string
379 |      */
380 |     protected function _encode($data)
381 |     {
382 |         return base64_encode(utf8_encode(json_encode($data)));
383 |     }
384 | 
385 |     /**
386 |      * adds a setting
387 |      *
388 |      * @param string key
389 |      * @param mixed value
390 |      * @return void
391 |      */
392 |     public function addSetting($key, $value)
393 |     {
394 |         $this->_settings[$key] = $value;
395 |     }
396 | 
397 |     /**
398 |      * add ability to set multiple settings in one call
399 |      *
400 |      * @param array $settings
401 |      * @return void
402 |      */
403 |     public function addSettings(array $settings)
404 |     {
405 |         foreach ($settings as $key => $value) {
406 |             $this->addSetting($key, $value);
407 |         }
408 |     }
409 | 
410 |     /**
411 |      * gets a setting
412 |      *
413 |      * @param string key
414 |      * @return mixed
415 |      */
416 |     public function getSetting($key)
417 |     {
418 |         if (!isset($this->_settings[$key])) {
419 |             return null;
420 |         }
421 |         return $this->_settings[$key];
422 |     }
423 | }


--------------------------------------------------------------------------------