From cd4e6b3b2697d09f210e9f003fce2da0c9b1b6e5 Mon Sep 17 00:00:00 2001 From: Justin Hileman Date: Thu, 27 Sep 2012 17:59:32 -0700 Subject: [PATCH 1/7] Initial logging proposal. C.f. #112 Add logging to the Mustache Engine. * Add a Logger interface. * If a Logger instance is passed to the Engine constructor (or added later via setLogger) template compiling, caching, errors and missing partials will be logged. * Add a Stream Logger and Monolog Logger implementation. You should use the Monolog Logger. --- src/Mustache/Engine.php | 96 ++++++++++++++++++++++++- src/Mustache/Logger.php | 75 ++++++++++++++++++++ src/Mustache/Logger/AbstractLogger.php | 98 ++++++++++++++++++++++++++ src/Mustache/Logger/MonologLogger.php | 59 ++++++++++++++++ src/Mustache/Logger/StreamLogger.php | 63 +++++++++++++++++ 5 files changed, 388 insertions(+), 3 deletions(-) create mode 100644 src/Mustache/Logger.php create mode 100644 src/Mustache/Logger/AbstractLogger.php create mode 100644 src/Mustache/Logger/MonologLogger.php create mode 100644 src/Mustache/Logger/StreamLogger.php diff --git a/src/Mustache/Engine.php b/src/Mustache/Engine.php index 34d3ce2..b5b7b22 100644 --- a/src/Mustache/Engine.php +++ b/src/Mustache/Engine.php @@ -34,12 +34,13 @@ class Mustache_Engine // Environment private $templateClassPrefix = '__Mustache_'; private $cache = null; + private $cacheFileMode = null; private $loader; private $partialsLoader; private $helpers; private $escape; private $charset = 'UTF-8'; - private $cacheFileMode = null; + private $logger; /** * Mustache class constructor. @@ -81,6 +82,9 @@ class Mustache_Engine * * // Character set for `htmlspecialchars`. Defaults to 'UTF-8'. Use 'UTF-8'. * 'charset' => 'ISO-8859-1', + * + * // A Mustache Logger instance. No logging will occur unless this is set. + * 'logger' => new Mustache_StreamLogger('php://stderr'), * ); * * @param array $options (default: array()) @@ -126,6 +130,10 @@ class Mustache_Engine if (isset($options['charset'])) { $this->charset = $options['charset']; } + + if (isset($options['logger'])) { + $this->setLogger($options['logger']); + } } /** @@ -330,6 +338,26 @@ class Mustache_Engine $this->getHelpers()->remove($name); } + /** + * Set the Mustache Logger instance. + * + * @param Mustache_Logger $logger + */ + public function setLogger(Mustache_Logger $logger) + { + $this->logger = $logger; + } + + /** + * Get the current Mustache Logger instance. + * + * @return Mustache_Logger + */ + public function getLogger() + { + return $this->logger; + } + /** * Set the Mustache Tokenizer instance. * @@ -453,7 +481,12 @@ class Mustache_Engine try { return $this->loadSource($this->getPartialsLoader()->load($name)); } catch (InvalidArgumentException $e) { - // If the named partial cannot be found, return null. + // If the named partial cannot be found, log then return null. + $this->log( + Mustache_Logger::WARNING, + sprintf('Partial not found: "%s"', $name), + array('name' => $name) + ); } } @@ -496,15 +529,33 @@ class Mustache_Engine if (!class_exists($className, false)) { if ($fileName = $this->getCacheFilename($source)) { if (!is_file($fileName)) { + $this->log( + Mustache_Logger::DEBUG, + sprintf('Writing "%s" class to template cache: "%s"', $className, $fileName), + array('className' => $className, 'fileName' => $fileName) + ); + $this->writeCacheFile($fileName, $this->compile($source)); } require_once $fileName; } else { + $this->log( + Mustache_Logger::WARNING, + sprintf('Template cache disabled, evaluating "%s" class at runtime', $className), + array('className' => $className) + ); + eval('?>'.$this->compile($source)); } } + $this->log( + Mustache_Logger::DEBUG, + sprintf('Instantiating template: "%s"', $className), + array('className' => $className) + ); + $this->templates[$className] = new $className($this); } @@ -553,6 +604,12 @@ class Mustache_Engine $tree = $this->parse($source); $name = $this->getTemplateClassName($source); + $this->log( + Mustache_Logger::INFO, + sprintf('Compiling template to "%s" class', $name), + array('name' => $name) + ); + return $this->getCompiler()->compile($source, $tree, $name, isset($this->escape), $this->charset); } @@ -573,7 +630,7 @@ class Mustache_Engine /** * Helper method to dump a generated Mustache Template subclass to the file cache. * - * @throws RuntimeException if unable to create the cache directory or write $fileName + * @throws RuntimeException if unable to create the cache directory or write to $fileName. * * @param string $fileName * @param string $source @@ -584,12 +641,25 @@ class Mustache_Engine { $dirName = dirname($fileName); if (!is_dir($dirName)) { + $this->log( + Mustache_Logger::INFO, + sprintf('Creating Mustache template cache directory: "%s"', $dirName), + array('dirName' => $dirName) + ); + @mkdir($dirName, 0777, true); if (!is_dir($dirName)) { throw new RuntimeException(sprintf('Failed to create cache directory "%s".', $dirName)); } + } + $this->log( + Mustache_Logger::DEBUG, + sprintf('Caching compiled template to "%s"', dirname($fileName)), + array('filename' => $fileName) + ); + $tempFile = tempnam($dirName, basename($fileName)); if (false !== @file_put_contents($tempFile, $source)) { if (@rename($tempFile, $fileName)) { @@ -598,8 +668,28 @@ class Mustache_Engine return; } + + $this->log( + Mustache_Logger::ERROR, + sprintf('Unable to rename Mustache temp cache file: "%s" -> "%s"', $tempFile, $fileName), + array('tempFile' => $tempFile, 'fileName' => $fileName) + ); } throw new RuntimeException(sprintf('Failed to write cache file "%s".', $fileName)); } + + /** + * Add a log record if logging is enabled. + * + * @param integer $level The logging level + * @param string $message The log message + * @param array $context The log context + */ + private function log($level, $message, array $context = array()) + { + if (isset($this->logger)) { + $this->logger->log($level, $message, $context); + } + } } diff --git a/src/Mustache/Logger.php b/src/Mustache/Logger.php new file mode 100644 index 0000000..0200970 --- /dev/null +++ b/src/Mustache/Logger.php @@ -0,0 +1,75 @@ + 'DEBUG', + 200 => 'INFO', + 250 => 'NOTICE', + 300 => 'WARNING', + 400 => 'ERROR', + 500 => 'CRITICAL', + 550 => 'ALERT', + 600 => 'EMERGENCY', + ); + + /** + * Abstract Logger constructor. + * + * @throws InvalidArgumentException if the logging level is unknown. + * + * @param integer $level The minimum logging level which will be written + */ + public function __construct($level = self::ERROR) + { + if (!array_key_exists($level, self::$levels)) { + throw new InvalidArgumentException('Unexpected logging level: ' . $level); + } + + $this->level = $level; + } + + /** + * Adds a log record. + * + * @see Mustache_Logger_AbstractLogger::write + * + * @param integer $level The logging level + * @param string $message The log message + * @param array $context The log context + */ + public function log($level, $message, array $context = array()) + { + if ($level >= $this->level) { + $this->writeLog($level, $message, $context); + } + } + + /** + * Gets the name of the logging level. + * + * @throws InvalidArgumentException if the logging level is unknown. + * + * @param integer $level + * + * @return string + */ + public static function getLevelName($level) + { + if (!array_key_exists($level, self::$levels)) { + throw new InvalidArgumentException('Unexpected logging level: ' . $level); + } + + return self::$levels[$level]; + } + + /** + * Format a log line for output. + * + * @param integer $level The logging level + * @param string $message The log message + * @param array $context The log context + */ + public static function formatLine($level, $message, array $context = array()) + { + return sprintf('%s: %s %s', self::getLevelName($level), (string) $message, json_encode($context)); + } + + /** + * Write a record to the log. Implemented by subclasses. + * + * @param integer $level The logging level + * @param string $message The log message + * @param array $context The log context + */ + abstract protected function write($level, $message, array $context = array()); +} diff --git a/src/Mustache/Logger/MonologLogger.php b/src/Mustache/Logger/MonologLogger.php new file mode 100644 index 0000000..2123343 --- /dev/null +++ b/src/Mustache/Logger/MonologLogger.php @@ -0,0 +1,59 @@ +logger = $logger; + } + + /** + * Adds a log record. + * + * Overload the AbstractLogger::log method, because all log messages should + * be passed through to Monolog regardless of the log level. Monolog will + * handle ignoring the messages it doesn't care about. + * + * @param integer $level The logging level + * @param string $message The log message + * @param array $context The log context + */ + public function log($level, $message, array $context = array()) + { + $this->write($level, $message, $context); + } + + /** + * Write a record to the log. + * + * @param integer $level The logging level + * @param string $message The log message + * @param array $context The log context + */ + protected function write($level, $message, array $context = array()) + { + $this->logger->addRecord($level, $message, $context); + } +} diff --git a/src/Mustache/Logger/StreamLogger.php b/src/Mustache/Logger/StreamLogger.php new file mode 100644 index 0000000..05939bf --- /dev/null +++ b/src/Mustache/Logger/StreamLogger.php @@ -0,0 +1,63 @@ +stream = $stream; + } else { + $this->url = $stream; + } + } + + /** + * Write a record to the log. + * + * @param integer $level The logging level + * @param string $message The log message + * @param array $context The log context + */ + protected function write($level, $message, array $context = array()) + { + if ($this->stream === null) { + if (!isset($this->url)) { + throw new LogicException('Missing stream url, the stream can not be opened. This may be caused by a premature call to close().'); + } + + $this->stream = fopen($this->url, 'a'); + if (!is_resource($this->stream)) { + throw new UnexpectedValueException(sprintf('The stream or file "%s" could not be opened.', $this->url)); + } + } + + fwrite($this->stream, self::formatLine($level, $message, $context)); + } +} From 782017e4619f12516bf230a45b6f54686ea285ea Mon Sep 17 00:00:00 2001 From: Justin Hileman Date: Fri, 28 Sep 2012 11:03:52 -0400 Subject: [PATCH 2/7] Add get/setLevel to AbstractLogger. --- src/Mustache/Logger/AbstractLogger.php | 22 ++++++++++++++++++++++ 1 file changed, 22 insertions(+) diff --git a/src/Mustache/Logger/AbstractLogger.php b/src/Mustache/Logger/AbstractLogger.php index d22f166..498cdce 100644 --- a/src/Mustache/Logger/AbstractLogger.php +++ b/src/Mustache/Logger/AbstractLogger.php @@ -33,6 +33,18 @@ abstract class Mustache_Logger_AbstractLogger implements Mustache_Logger * @param integer $level The minimum logging level which will be written */ public function __construct($level = self::ERROR) + { + $this->setLevel($level); + } + + /** + * Set the minimum logging level. + * + * @throws InvalidArgumentException if the logging level is unknown. + * + * @param integer $level The minimum logging level which will be written + */ + public function setLevel($level) { if (!array_key_exists($level, self::$levels)) { throw new InvalidArgumentException('Unexpected logging level: ' . $level); @@ -41,6 +53,16 @@ abstract class Mustache_Logger_AbstractLogger implements Mustache_Logger $this->level = $level; } + /** + * Get the current minimum logging level. + * + * @return integer + */ + public function getLevel() + { + return $this->level; + } + /** * Adds a log record. * From 8c059f566b3fad10a98767821df5d97ea71eef64 Mon Sep 17 00:00:00 2001 From: Justin Hileman Date: Fri, 28 Sep 2012 11:04:12 -0400 Subject: [PATCH 3/7] MonologLogger should not extend AbstractLogger. --- src/Mustache/Logger/MonologLogger.php | 14 +------------- 1 file changed, 1 insertion(+), 13 deletions(-) diff --git a/src/Mustache/Logger/MonologLogger.php b/src/Mustache/Logger/MonologLogger.php index 2123343..a6a9ea0 100644 --- a/src/Mustache/Logger/MonologLogger.php +++ b/src/Mustache/Logger/MonologLogger.php @@ -12,7 +12,7 @@ /** * A Mustache Monolog Logger adapter. */ -class MonologLogger extends Mustache_Logger_AbstractLogger +class MonologLogger implements Mustache_Logger { protected $logger; @@ -41,18 +41,6 @@ class MonologLogger extends Mustache_Logger_AbstractLogger * @param array $context The log context */ public function log($level, $message, array $context = array()) - { - $this->write($level, $message, $context); - } - - /** - * Write a record to the log. - * - * @param integer $level The logging level - * @param string $message The log message - * @param array $context The log context - */ - protected function write($level, $message, array $context = array()) { $this->logger->addRecord($level, $message, $context); } From d1fb1d86c546a83f02ae3b6023d28512b14a7832 Mon Sep 17 00:00:00 2001 From: Justin Hileman Date: Fri, 28 Sep 2012 11:04:29 -0400 Subject: [PATCH 4/7] Handle prematurely closed streams in StreamLogger. --- src/Mustache/Logger/StreamLogger.php | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/Mustache/Logger/StreamLogger.php b/src/Mustache/Logger/StreamLogger.php index 05939bf..727a626 100644 --- a/src/Mustache/Logger/StreamLogger.php +++ b/src/Mustache/Logger/StreamLogger.php @@ -47,7 +47,7 @@ class StreamLogger extends Mustache_Logger_AbstractLogger */ protected function write($level, $message, array $context = array()) { - if ($this->stream === null) { + if (!is_resource($this->stream)) { if (!isset($this->url)) { throw new LogicException('Missing stream url, the stream can not be opened. This may be caused by a premature call to close().'); } From 7522e2206dc3593f3314d6c132c4c8a8cb9a164b Mon Sep 17 00:00:00 2001 From: Justin Hileman Date: Fri, 30 Nov 2012 19:01:47 -0800 Subject: [PATCH 5/7] Update loging to match (proposed) logging PSR. --- src/Mustache/Engine.php | 10 +- src/Mustache/Logger.php | 138 ++++++++++++----- src/Mustache/Logger/AbstractLogger.php | 120 --------------- src/Mustache/Logger/MonologLogger.php | 47 ------ src/Mustache/Logger/StreamLogger.php | 204 ++++++++++++++++++++++++- 5 files changed, 307 insertions(+), 212 deletions(-) delete mode 100644 src/Mustache/Logger/AbstractLogger.php delete mode 100644 src/Mustache/Logger/MonologLogger.php diff --git a/src/Mustache/Engine.php b/src/Mustache/Engine.php index b5b7b22..43ac4f6 100644 --- a/src/Mustache/Engine.php +++ b/src/Mustache/Engine.php @@ -341,17 +341,21 @@ class Mustache_Engine /** * Set the Mustache Logger instance. * - * @param Mustache_Logger $logger + * @param Mustache_Logger|Psr\Log\LoggerInterface $logger */ - public function setLogger(Mustache_Logger $logger) + public function setLogger($logger = null) { + if ($logger !== null && !($logger instanceof Mustache_Logger || is_a($logger, 'Psr\\Log\\LoggerInterface'))) { + throw new InvalidArgumentException('Expected an instance of Mustache_Logger or Psr\\Log\\LoggerInterface.'); + } + $this->logger = $logger; } /** * Get the current Mustache Logger instance. * - * @return Mustache_Logger + * @return Mustache_Logger|Psr\Log\LoggerInterface */ public function getLogger() { diff --git a/src/Mustache/Logger.php b/src/Mustache/Logger.php index 0200970..0a6b027 100644 --- a/src/Mustache/Logger.php +++ b/src/Mustache/Logger.php @@ -10,66 +10,126 @@ */ /** - * The Mustache Logger interface. + * Describes a Mustache logger instance + * + * This is identical to the Psr\Log\LoggerInterface. + * + * The message MUST be a string or object implementing __toString(). + * + * The message MAY contain placeholders in the form: %foo% where foo + * will be replaced by the context data in key "foo". + * + * The context array can contain arbitrary data, the only assumption that + * can be made by implementors is that if an Exception instance is given + * to produce a stack trace, it MUST be in a key named "exception". + * + * See https://github.com/php-fig/fig-standards/blob/master/accepted/PSR-3-logger-interface.md + * for the full interface specification. */ interface Mustache_Logger { /** - * Detailed debug information + * Psr\Log compatible log levels */ - const DEBUG = 100; + const EMERGENCY = 'emergency'; + const ALERT = 'alert'; + const CRITICAL = 'critical'; + const ERROR = 'error'; + const WARNING = 'warning'; + const NOTICE = 'notice'; + const INFO = 'info'; + const DEBUG = 'debug'; /** - * Interesting events + * System is unusable. * - * Examples: User logs in, SQL logs. + * @param string $message + * @param array $context + * @return null */ - const INFO = 200; + public function emergency($message, array $context = array()); /** - * Uncommon events - */ - const NOTICE = 250; - - /** - * Exceptional occurrences that are not errors + * Action must be taken immediately. * - * Examples: Use of deprecated APIs, poor use of an API, - * undesirable things that are not necessarily wrong. + * Example: Entire website down, database unavailable, etc. This should + * trigger the SMS alerts and wake you up. + * + * @param string $message + * @param array $context + * @return null */ - const WARNING = 300; + public function alert($message, array $context = array()); /** - * Runtime errors - */ - const ERROR = 400; - - /** - * Critical conditions + * Critical conditions. * * Example: Application component unavailable, unexpected exception. - */ - const CRITICAL = 500; - - /** - * Action must be taken immediately * - * Example: Entire website down, database unavailable, etc. - * This should trigger the SMS alerts and wake you up. + * @param string $message + * @param array $context + * @return null */ - const ALERT = 550; + public function critical($message, array $context = array()); /** - * Urgent alert. - */ - const EMERGENCY = 600; - - /** - * Adds a log record. + * Runtime errors that do not require immediate action but should typically + * be logged and monitored. * - * @param integer $level The logging level - * @param string $message The log message - * @param array $context The log context + * @param string $message + * @param array $context + * @return null + */ + public function error($message, array $context = array()); + + /** + * Exceptional occurrences that are not errors. + * + * Example: Use of deprecated APIs, poor use of an API, undesirable things + * that are not necessarily wrong. + * + * @param string $message + * @param array $context + * @return null + */ + public function warning($message, array $context = array()); + + /** + * Normal but significant events. + * + * @param string $message + * @param array $context + * @return null + */ + public function notice($message, array $context = array()); + + /** + * Interesting events. + * + * Example: User logs in, SQL logs. + * + * @param string $message + * @param array $context + * @return null + */ + public function info($message, array $context = array()); + + /** + * Detailed debug information. + * + * @param string $message + * @param array $context + * @return null + */ + public function debug($message, array $context = array()); + + /** + * Logs with an arbitrary level. + * + * @param mixed $level + * @param string $message + * @param array $context + * @return null */ public function log($level, $message, array $context = array()); -} +} \ No newline at end of file diff --git a/src/Mustache/Logger/AbstractLogger.php b/src/Mustache/Logger/AbstractLogger.php deleted file mode 100644 index 498cdce..0000000 --- a/src/Mustache/Logger/AbstractLogger.php +++ /dev/null @@ -1,120 +0,0 @@ - 'DEBUG', - 200 => 'INFO', - 250 => 'NOTICE', - 300 => 'WARNING', - 400 => 'ERROR', - 500 => 'CRITICAL', - 550 => 'ALERT', - 600 => 'EMERGENCY', - ); - - /** - * Abstract Logger constructor. - * - * @throws InvalidArgumentException if the logging level is unknown. - * - * @param integer $level The minimum logging level which will be written - */ - public function __construct($level = self::ERROR) - { - $this->setLevel($level); - } - - /** - * Set the minimum logging level. - * - * @throws InvalidArgumentException if the logging level is unknown. - * - * @param integer $level The minimum logging level which will be written - */ - public function setLevel($level) - { - if (!array_key_exists($level, self::$levels)) { - throw new InvalidArgumentException('Unexpected logging level: ' . $level); - } - - $this->level = $level; - } - - /** - * Get the current minimum logging level. - * - * @return integer - */ - public function getLevel() - { - return $this->level; - } - - /** - * Adds a log record. - * - * @see Mustache_Logger_AbstractLogger::write - * - * @param integer $level The logging level - * @param string $message The log message - * @param array $context The log context - */ - public function log($level, $message, array $context = array()) - { - if ($level >= $this->level) { - $this->writeLog($level, $message, $context); - } - } - - /** - * Gets the name of the logging level. - * - * @throws InvalidArgumentException if the logging level is unknown. - * - * @param integer $level - * - * @return string - */ - public static function getLevelName($level) - { - if (!array_key_exists($level, self::$levels)) { - throw new InvalidArgumentException('Unexpected logging level: ' . $level); - } - - return self::$levels[$level]; - } - - /** - * Format a log line for output. - * - * @param integer $level The logging level - * @param string $message The log message - * @param array $context The log context - */ - public static function formatLine($level, $message, array $context = array()) - { - return sprintf('%s: %s %s', self::getLevelName($level), (string) $message, json_encode($context)); - } - - /** - * Write a record to the log. Implemented by subclasses. - * - * @param integer $level The logging level - * @param string $message The log message - * @param array $context The log context - */ - abstract protected function write($level, $message, array $context = array()); -} diff --git a/src/Mustache/Logger/MonologLogger.php b/src/Mustache/Logger/MonologLogger.php deleted file mode 100644 index a6a9ea0..0000000 --- a/src/Mustache/Logger/MonologLogger.php +++ /dev/null @@ -1,47 +0,0 @@ -logger = $logger; - } - - /** - * Adds a log record. - * - * Overload the AbstractLogger::log method, because all log messages should - * be passed through to Monolog regardless of the log level. Monolog will - * handle ignoring the messages it doesn't care about. - * - * @param integer $level The logging level - * @param string $message The log message - * @param array $context The log context - */ - public function log($level, $message, array $context = array()) - { - $this->logger->addRecord($level, $message, $context); - } -} diff --git a/src/Mustache/Logger/StreamLogger.php b/src/Mustache/Logger/StreamLogger.php index 727a626..57e90f3 100644 --- a/src/Mustache/Logger/StreamLogger.php +++ b/src/Mustache/Logger/StreamLogger.php @@ -18,8 +18,19 @@ * * Hint: Try `php://stderr` for your stream URL. */ -class StreamLogger extends Mustache_Logger_AbstractLogger +class StreamLogger implements Mustache_Logger { + protected static $levels = array( + self::DEBUG => 100, + self::INFO => 200, + self::NOTICE => 250, + self::WARNING => 300, + self::ERROR => 400, + self::CRITICAL => 500, + self::ALERT => 550, + self::EMERGENCY => 600, + ); + protected $stream = null; protected $url = null; @@ -29,7 +40,7 @@ class StreamLogger extends Mustache_Logger_AbstractLogger */ public function __construct($stream, $level = Mustache_Logger::ERROR) { - parent::__construct($level); + $this->setLevel($level); if (is_resource($stream)) { $this->stream = $stream; @@ -38,6 +49,158 @@ class StreamLogger extends Mustache_Logger_AbstractLogger } } + /** + * Set the minimum logging level. + * + * @throws InvalidArgumentException if the logging level is unknown. + * + * @param integer $level The minimum logging level which will be written + */ + public function setLevel($level) + { + if (!array_key_exists($level, self::$levels)) { + throw new InvalidArgumentException('Unexpected logging level: ' . $level); + } + + $this->level = $level; + } + + /** + * Get the current minimum logging level. + * + * @return integer + */ + public function getLevel() + { + return $this->level; + } + + /** + * System is unusable. + * + * @param string $message + * @param array $context + * @return null + */ + public function emergency($message, array $context = array()) + { + $this->log(self::EMERGENCY, $message, $context); + } + + /** + * Action must be taken immediately. + * + * Example: Entire website down, database unavailable, etc. This should + * trigger the SMS alerts and wake you up. + * + * @param string $message + * @param array $context + * @return null + */ + public function alert($message, array $context = array()) + { + $this->log(self::ALERT, $message, $context); + } + + /** + * Critical conditions. + * + * Example: Application component unavailable, unexpected exception. + * + * @param string $message + * @param array $context + * @return null + */ + public function critical($message, array $context = array()) + { + $this->log(self::CRITICAL, $message, $context); + } + + /** + * Runtime errors that do not require immediate action but should typically + * be logged and monitored. + * + * @param string $message + * @param array $context + * @return null + */ + public function error($message, array $context = array()) + { + $this->log(self::ERROR, $message, $context); + } + + /** + * Exceptional occurrences that are not errors. + * + * Example: Use of deprecated APIs, poor use of an API, undesirable things + * that are not necessarily wrong. + * + * @param string $message + * @param array $context + * @return null + */ + public function warning($message, array $context = array()) + { + $this->log(self::WARNING, $message, $context); + } + + /** + * Normal but significant events. + * + * @param string $message + * @param array $context + * @return null + */ + public function notice($message, array $context = array()) + { + $this->log(self::NOTICE, $message, $context); + } + + /** + * Interesting events. + * + * Example: User logs in, SQL logs. + * + * @param string $message + * @param array $context + * @return null + */ + public function info($message, array $context = array()) + { + $this->log(self::INFO, $message, $context); + } + + /** + * Detailed debug information. + * + * @param string $message + * @param array $context + * @return null + */ + public function debug($message, array $context = array()) + { + $this->log(self::DEBUG, $message, $context); + } + + /** + * Logs with an arbitrary level. + * + * @param mixed $level + * @param string $message + * @param array $context + * @return null + */ + public function log($level, $message, array $context = array()) + { + if (!array_key_exists($level, self::$levels)) { + throw new InvalidArgumentException('Unexpected logging level: ' . $level); + } + + if (self::$levels[$level] >= $this->level) { + $this->writeLog($level, $message, $context); + } + } + /** * Write a record to the log. * @@ -45,7 +208,7 @@ class StreamLogger extends Mustache_Logger_AbstractLogger * @param string $message The log message * @param array $context The log context */ - protected function write($level, $message, array $context = array()) + protected function writeLog($level, $message, array $context = array()) { if (!is_resource($this->stream)) { if (!isset($this->url)) { @@ -60,4 +223,39 @@ class StreamLogger extends Mustache_Logger_AbstractLogger fwrite($this->stream, self::formatLine($level, $message, $context)); } + + /** + * Gets the name of the logging level. + * + * @throws InvalidArgumentException if the logging level is unknown. + * + * @param integer $level + * + * @return string + */ + protected static function getLevelName($level) + { + if (!array_key_exists($level, self::$levels)) { + throw new InvalidArgumentException('Unexpected logging level: ' . $level); + } + + return strtoupper($level); + } + + /** + * Format a log line for output. + * + * @param integer $level The logging level + * @param string $message The log message + * @param array $context The log context + */ + protected static function formatLine($level, $message, array $context = array()) + { + $message = (string) $message; + foreach ($context as $key => $val) { + $message = str_replace('%'.$key.'%', $val, $message); + } + + return sprintf('%s: %s %s', self::getLevelName($level), (string) $message, json_encode($context)); + } } From 1515f5126b35436228f40ee3338c8ede5398d7fb Mon Sep 17 00:00:00 2001 From: Justin Hileman Date: Fri, 11 Jan 2013 22:41:28 -0800 Subject: [PATCH 6/7] Update logger to implement accepted PSR log spec Add tests! --- src/Mustache/Engine.php | 22 +- src/Mustache/Logger.php | 4 +- src/Mustache/Logger/AbstractLogger.php | 121 ++++++++++ src/Mustache/Logger/StreamLogger.php | 159 ++++---------- test/Mustache/Test/EngineTest.php | 79 ++++++- .../Test/Logger/AbstractLoggerTest.php | 60 +++++ .../Mustache/Test/Logger/StreamLoggerTest.php | 206 ++++++++++++++++++ 7 files changed, 521 insertions(+), 130 deletions(-) create mode 100644 src/Mustache/Logger/AbstractLogger.php create mode 100644 test/Mustache/Test/Logger/AbstractLoggerTest.php create mode 100644 test/Mustache/Test/Logger/StreamLoggerTest.php diff --git a/src/Mustache/Engine.php b/src/Mustache/Engine.php index 43ac4f6..16e2e86 100644 --- a/src/Mustache/Engine.php +++ b/src/Mustache/Engine.php @@ -488,7 +488,7 @@ class Mustache_Engine // If the named partial cannot be found, log then return null. $this->log( Mustache_Logger::WARNING, - sprintf('Partial not found: "%s"', $name), + 'Partial not found: "{name}"', array('name' => $name) ); } @@ -535,7 +535,7 @@ class Mustache_Engine if (!is_file($fileName)) { $this->log( Mustache_Logger::DEBUG, - sprintf('Writing "%s" class to template cache: "%s"', $className, $fileName), + 'Writing "{className}" class to template cache: "{fileName}"', array('className' => $className, 'fileName' => $fileName) ); @@ -546,7 +546,7 @@ class Mustache_Engine } else { $this->log( Mustache_Logger::WARNING, - sprintf('Template cache disabled, evaluating "%s" class at runtime', $className), + 'Template cache disabled, evaluating "{className}" class at runtime', array('className' => $className) ); @@ -556,7 +556,7 @@ class Mustache_Engine $this->log( Mustache_Logger::DEBUG, - sprintf('Instantiating template: "%s"', $className), + 'Instantiating template: "{className}"', array('className' => $className) ); @@ -610,8 +610,8 @@ class Mustache_Engine $this->log( Mustache_Logger::INFO, - sprintf('Compiling template to "%s" class', $name), - array('name' => $name) + 'Compiling template to "{className}" class', + array('className' => $name) ); return $this->getCompiler()->compile($source, $tree, $name, isset($this->escape), $this->charset); @@ -647,7 +647,7 @@ class Mustache_Engine if (!is_dir($dirName)) { $this->log( Mustache_Logger::INFO, - sprintf('Creating Mustache template cache directory: "%s"', $dirName), + 'Creating Mustache template cache directory: "{dirName}"', array('dirName' => $dirName) ); @@ -660,8 +660,8 @@ class Mustache_Engine $this->log( Mustache_Logger::DEBUG, - sprintf('Caching compiled template to "%s"', dirname($fileName)), - array('filename' => $fileName) + 'Caching compiled template to "{fileName}"', + array('fileName' => $fileName) ); $tempFile = tempnam($dirName, basename($fileName)); @@ -675,8 +675,8 @@ class Mustache_Engine $this->log( Mustache_Logger::ERROR, - sprintf('Unable to rename Mustache temp cache file: "%s" -> "%s"', $tempFile, $fileName), - array('tempFile' => $tempFile, 'fileName' => $fileName) + 'Unable to rename Mustache temp cache file: "{tempName}" -> "{fileName}"', + array('tempName' => $tempFile, 'fileName' => $fileName) ); } diff --git a/src/Mustache/Logger.php b/src/Mustache/Logger.php index 0a6b027..e08359a 100644 --- a/src/Mustache/Logger.php +++ b/src/Mustache/Logger.php @@ -16,7 +16,7 @@ * * The message MUST be a string or object implementing __toString(). * - * The message MAY contain placeholders in the form: %foo% where foo + * The message MAY contain placeholders in the form: {foo} where foo * will be replaced by the context data in key "foo". * * The context array can contain arbitrary data, the only assumption that @@ -132,4 +132,4 @@ interface Mustache_Logger * @return null */ public function log($level, $message, array $context = array()); -} \ No newline at end of file +} diff --git a/src/Mustache/Logger/AbstractLogger.php b/src/Mustache/Logger/AbstractLogger.php new file mode 100644 index 0000000..bb057d6 --- /dev/null +++ b/src/Mustache/Logger/AbstractLogger.php @@ -0,0 +1,121 @@ +log(Mustache_Logger::EMERGENCY, $message, $context); + } + + /** + * Action must be taken immediately. + * + * Example: Entire website down, database unavailable, etc. This should + * trigger the SMS alerts and wake you up. + * + * @param string $message + * @param array $context + */ + public function alert($message, array $context = array()) + { + $this->log(Mustache_Logger::ALERT, $message, $context); + } + + /** + * Critical conditions. + * + * Example: Application component unavailable, unexpected exception. + * + * @param string $message + * @param array $context + */ + public function critical($message, array $context = array()) + { + $this->log(Mustache_Logger::CRITICAL, $message, $context); + } + + /** + * Runtime errors that do not require immediate action but should typically + * be logged and monitored. + * + * @param string $message + * @param array $context + */ + public function error($message, array $context = array()) + { + $this->log(Mustache_Logger::ERROR, $message, $context); + } + + /** + * Exceptional occurrences that are not errors. + * + * Example: Use of deprecated APIs, poor use of an API, undesirable things + * that are not necessarily wrong. + * + * @param string $message + * @param array $context + */ + public function warning($message, array $context = array()) + { + $this->log(Mustache_Logger::WARNING, $message, $context); + } + + /** + * Normal but significant events. + * + * @param string $message + * @param array $context + */ + public function notice($message, array $context = array()) + { + $this->log(Mustache_Logger::NOTICE, $message, $context); + } + + /** + * Interesting events. + * + * Example: User logs in, SQL logs. + * + * @param string $message + * @param array $context + */ + public function info($message, array $context = array()) + { + $this->log(Mustache_Logger::INFO, $message, $context); + } + + /** + * Detailed debug information. + * + * @param string $message + * @param array $context + */ + public function debug($message, array $context = array()) + { + $this->log(Mustache_Logger::DEBUG, $message, $context); + } +} diff --git a/src/Mustache/Logger/StreamLogger.php b/src/Mustache/Logger/StreamLogger.php index 57e90f3..7f3fd50 100644 --- a/src/Mustache/Logger/StreamLogger.php +++ b/src/Mustache/Logger/StreamLogger.php @@ -18,7 +18,7 @@ * * Hint: Try `php://stderr` for your stream URL. */ -class StreamLogger implements Mustache_Logger +class Mustache_Logger_StreamLogger extends Mustache_Logger_AbstractLogger { protected static $levels = array( self::DEBUG => 100, @@ -35,6 +35,8 @@ class StreamLogger implements Mustache_Logger protected $url = null; /** + * @throws InvalidArgumentException if the logging level is unknown. + * * @param string $stream Resource instance or URL * @param integer $level The minimum logging level at which this handler will be triggered */ @@ -49,6 +51,16 @@ class StreamLogger implements Mustache_Logger } } + /** + * Close stream resources. + */ + public function __destruct() + { + if (is_resource($this->stream)) { + fclose($this->stream); + } + } + /** * Set the minimum logging level. * @@ -75,120 +87,14 @@ class StreamLogger implements Mustache_Logger return $this->level; } - /** - * System is unusable. - * - * @param string $message - * @param array $context - * @return null - */ - public function emergency($message, array $context = array()) - { - $this->log(self::EMERGENCY, $message, $context); - } - - /** - * Action must be taken immediately. - * - * Example: Entire website down, database unavailable, etc. This should - * trigger the SMS alerts and wake you up. - * - * @param string $message - * @param array $context - * @return null - */ - public function alert($message, array $context = array()) - { - $this->log(self::ALERT, $message, $context); - } - - /** - * Critical conditions. - * - * Example: Application component unavailable, unexpected exception. - * - * @param string $message - * @param array $context - * @return null - */ - public function critical($message, array $context = array()) - { - $this->log(self::CRITICAL, $message, $context); - } - - /** - * Runtime errors that do not require immediate action but should typically - * be logged and monitored. - * - * @param string $message - * @param array $context - * @return null - */ - public function error($message, array $context = array()) - { - $this->log(self::ERROR, $message, $context); - } - - /** - * Exceptional occurrences that are not errors. - * - * Example: Use of deprecated APIs, poor use of an API, undesirable things - * that are not necessarily wrong. - * - * @param string $message - * @param array $context - * @return null - */ - public function warning($message, array $context = array()) - { - $this->log(self::WARNING, $message, $context); - } - - /** - * Normal but significant events. - * - * @param string $message - * @param array $context - * @return null - */ - public function notice($message, array $context = array()) - { - $this->log(self::NOTICE, $message, $context); - } - - /** - * Interesting events. - * - * Example: User logs in, SQL logs. - * - * @param string $message - * @param array $context - * @return null - */ - public function info($message, array $context = array()) - { - $this->log(self::INFO, $message, $context); - } - - /** - * Detailed debug information. - * - * @param string $message - * @param array $context - * @return null - */ - public function debug($message, array $context = array()) - { - $this->log(self::DEBUG, $message, $context); - } - /** * Logs with an arbitrary level. * + * @throws InvalidArgumentException if the logging level is unknown. + * * @param mixed $level * @param string $message * @param array $context - * @return null */ public function log($level, $message, array $context = array()) { @@ -196,7 +102,7 @@ class StreamLogger implements Mustache_Logger throw new InvalidArgumentException('Unexpected logging level: ' . $level); } - if (self::$levels[$level] >= $this->level) { + if (self::$levels[$level] >= self::$levels[$this->level]) { $this->writeLog($level, $message, $context); } } @@ -217,7 +123,9 @@ class StreamLogger implements Mustache_Logger $this->stream = fopen($this->url, 'a'); if (!is_resource($this->stream)) { + // @codeCoverageIgnoreStart throw new UnexpectedValueException(sprintf('The stream or file "%s" could not be opened.', $this->url)); + // @codeCoverageIgnoreEnd } } @@ -235,10 +143,6 @@ class StreamLogger implements Mustache_Logger */ protected static function getLevelName($level) { - if (!array_key_exists($level, self::$levels)) { - throw new InvalidArgumentException('Unexpected logging level: ' . $level); - } - return strtoupper($level); } @@ -248,14 +152,37 @@ class StreamLogger implements Mustache_Logger * @param integer $level The logging level * @param string $message The log message * @param array $context The log context + * + * @return string */ protected static function formatLine($level, $message, array $context = array()) + { + return sprintf( + "%s: %s\n", + self::getLevelName($level), + self::interpolateMessage($message, $context) + ); + } + + /** + * Interpolate context values into the message placeholders. + * + * @param string $message + * @param array $context + * + * @return string + */ + protected static function interpolateMessage($message, array $context = array()) { $message = (string) $message; + + // build a replacement array with braces around the context keys + $replace = array(); foreach ($context as $key => $val) { - $message = str_replace('%'.$key.'%', $val, $message); + $replace['{' . $key . '}'] = $val; } - return sprintf('%s: %s %s', self::getLevelName($level), (string) $message, json_encode($context)); + // interpolate replacement values into the the message and return + return strtr($message, $replace); } } diff --git a/test/Mustache/Test/EngineTest.php b/test/Mustache/Test/EngineTest.php index 7178786..bf59d18 100644 --- a/test/Mustache/Test/EngineTest.php +++ b/test/Mustache/Test/EngineTest.php @@ -27,11 +27,14 @@ class Mustache_Test_EngineTest extends PHPUnit_Framework_TestCase public function testConstructor() { + $logger = new Mustache_Logger_StreamLogger(tmpfile()); $loader = new Mustache_Loader_StringLoader; $partialsLoader = new Mustache_Loader_ArrayLoader; $mustache = new Mustache_Engine(array( 'template_class_prefix' => '__whot__', - 'cache' => self::$tempDir, + 'cache' => self::$tempDir, + 'cache_file_mode' => 777, + 'logger' => $logger, 'loader' => $loader, 'partials_loader' => $partialsLoader, 'partials' => array( @@ -45,6 +48,7 @@ class Mustache_Test_EngineTest extends PHPUnit_Framework_TestCase 'charset' => 'ISO-8859-1', )); + $this->assertSame($logger, $mustache->getLogger()); $this->assertSame($loader, $mustache->getLoader()); $this->assertSame($partialsLoader, $mustache->getPartialsLoader()); $this->assertEquals('{{ foo }}', $partialsLoader->load('foo')); @@ -85,12 +89,17 @@ class Mustache_Test_EngineTest extends PHPUnit_Framework_TestCase public function testSettingServices() { + $logger = new Mustache_Logger_StreamLogger(tmpfile()); $loader = new Mustache_Loader_StringLoader; $tokenizer = new Mustache_Tokenizer; $parser = new Mustache_Parser; $compiler = new Mustache_Compiler; $mustache = new Mustache_Engine; + $this->assertNotSame($logger, $mustache->getLogger()); + $mustache->setLogger($logger); + $this->assertSame($logger, $mustache->getLogger()); + $this->assertNotSame($loader, $mustache->getLoader()); $mustache->setLoader($loader); $this->assertSame($loader, $mustache->getLoader()); @@ -222,6 +231,74 @@ class Mustache_Test_EngineTest extends PHPUnit_Framework_TestCase $mustache->setHelpers('monkeymonkeymonkey'); } + /** + * @expectedException InvalidArgumentException + */ + public function testSetLoggerThrowsExceptions() + { + $mustache = new Mustache_Engine; + $mustache->setLogger(new StdClass); + } + + public function testPartialLoadFailLogging() + { + $name = tempnam(sys_get_temp_dir(), 'mustache-test'); + $mustache = new Mustache_Engine(array( + 'logger' => new Mustache_Logger_StreamLogger($name, Mustache_Logger::WARNING), + 'partials' => array( + 'foo' => 'FOO', + 'bar' => 'BAR', + ), + )); + + $result = $mustache->render('{{> foo }}{{> bar }}{{> baz }}', array()); + $this->assertEquals('FOOBAR', $result); + + $this->assertContains('WARNING: Partial not found: "baz"', file_get_contents($name)); + } + + public function testCacheWarningLogging() + { + $name = tempnam(sys_get_temp_dir(), 'mustache-test'); + $mustache = new Mustache_Engine(array( + 'logger' => new Mustache_Logger_StreamLogger($name, Mustache_Logger::WARNING) + )); + + $result = $mustache->render('{{ foo }}', array('foo' => 'FOO')); + $this->assertEquals('FOO', $result); + + $this->assertContains('WARNING: Template cache disabled, evaluating', file_get_contents($name)); + } + + public function testLoggingIsNotTooAnnoying() + { + $name = tempnam(sys_get_temp_dir(), 'mustache-test'); + $mustache = new Mustache_Engine(array( + 'logger' => new Mustache_Logger_StreamLogger($name) + )); + + $result = $mustache->render('{{ foo }}{{> bar }}', array('foo' => 'FOO')); + $this->assertEquals('FOO', $result); + + $this->assertEmpty(file_get_contents($name)); + } + + public function testVerboseLoggingIsVerbose() + { + $name = tempnam(sys_get_temp_dir(), 'mustache-test'); + $mustache = new Mustache_Engine(array( + 'logger' => new Mustache_Logger_StreamLogger($name, Mustache_Logger::DEBUG) + )); + + $result = $mustache->render('{{ foo }}{{> bar }}', array('foo' => 'FOO')); + $this->assertEquals('FOO', $result); + + $log = file_get_contents($name); + + $this->assertContains("DEBUG: Instantiating template: ", $log); + $this->assertContains("WARNING: Partial not found: \"bar\"", $log); + } + private static function rmdir($path) { $path = rtrim($path, '/').'/'; diff --git a/test/Mustache/Test/Logger/AbstractLoggerTest.php b/test/Mustache/Test/Logger/AbstractLoggerTest.php new file mode 100644 index 0000000..733b2eb --- /dev/null +++ b/test/Mustache/Test/Logger/AbstractLoggerTest.php @@ -0,0 +1,60 @@ +emergency('emergency message'); + $logger->alert('alert message'); + $logger->critical('critical message'); + $logger->error('error message'); + $logger->warning('warning message'); + $logger->notice('notice message'); + $logger->info('info message'); + $logger->debug('debug message'); + + $expected = array( + array(Mustache_Logger::EMERGENCY, 'emergency message', array()), + array(Mustache_Logger::ALERT, 'alert message', array()), + array(Mustache_Logger::CRITICAL, 'critical message', array()), + array(Mustache_Logger::ERROR, 'error message', array()), + array(Mustache_Logger::WARNING, 'warning message', array()), + array(Mustache_Logger::NOTICE, 'notice message', array()), + array(Mustache_Logger::INFO, 'info message', array()), + array(Mustache_Logger::DEBUG, 'debug message', array()), + ); + + $this->assertEquals($expected, $logger->log); + } +} + +class Mustache_Test_Logger_TestLogger extends Mustache_Logger_AbstractLogger +{ + public $log = array(); + + /** + * Logs with an arbitrary level. + * + * @param mixed $level + * @param string $message + * @param array $context + */ + public function log($level, $message, array $context = array()) + { + $this->log[] = array($level, $message, $context); + } +} diff --git a/test/Mustache/Test/Logger/StreamLoggerTest.php b/test/Mustache/Test/Logger/StreamLoggerTest.php new file mode 100644 index 0000000..9dfd4c2 --- /dev/null +++ b/test/Mustache/Test/Logger/StreamLoggerTest.php @@ -0,0 +1,206 @@ +log(Mustache_Logger::CRITICAL, 'message'); + + $this->assertEquals("CRITICAL: message\n", file_get_contents($name)); + } + + public function testAcceptsResource() + { + $name = tempnam(sys_get_temp_dir(), 'mustache-test'); + $file = fopen($name, 'a'); + $logger = new Mustache_Logger_StreamLogger($file); + $logger->log(Mustache_Logger::CRITICAL, 'message'); + + $this->assertEquals("CRITICAL: message\n", file_get_contents($name)); + } + + /** + * @expectedException LogicException + */ + public function testPrematurelyClosedStreamThrowsException() + { + $stream = tmpfile(); + $logger = new Mustache_Logger_StreamLogger($stream); + fclose($stream); + + $logger->log(Mustache_Logger::CRITICAL, 'message'); + } + + /** + * @dataProvider getLevels + */ + public function testLoggingThresholds($logLevel, $level, $shouldLog) + { + $stream = tmpfile(); + $logger = new Mustache_Logger_StreamLogger($stream, $logLevel); + $logger->log($level, "logged"); + + rewind($stream); + $result = fread($stream, 1024); + + if ($shouldLog) { + $this->assertContains("logged", $result); + } else { + $this->assertEmpty($result); + } + } + + public function getLevels() + { + // $logLevel, $level, $shouldLog + return array( + // identities + array(Mustache_Logger::EMERGENCY, Mustache_Logger::EMERGENCY, true), + array(Mustache_Logger::ALERT, Mustache_Logger::ALERT, true), + array(Mustache_Logger::CRITICAL, Mustache_Logger::CRITICAL, true), + array(Mustache_Logger::ERROR, Mustache_Logger::ERROR, true), + array(Mustache_Logger::WARNING, Mustache_Logger::WARNING, true), + array(Mustache_Logger::NOTICE, Mustache_Logger::NOTICE, true), + array(Mustache_Logger::INFO, Mustache_Logger::INFO, true), + array(Mustache_Logger::DEBUG, Mustache_Logger::DEBUG, true), + + // one above + array(Mustache_Logger::ALERT, Mustache_Logger::EMERGENCY, true), + array(Mustache_Logger::CRITICAL, Mustache_Logger::ALERT, true), + array(Mustache_Logger::ERROR, Mustache_Logger::CRITICAL, true), + array(Mustache_Logger::WARNING, Mustache_Logger::ERROR, true), + array(Mustache_Logger::NOTICE, Mustache_Logger::WARNING, true), + array(Mustache_Logger::INFO, Mustache_Logger::NOTICE, true), + array(Mustache_Logger::DEBUG, Mustache_Logger::INFO, true), + + // one below + array(Mustache_Logger::EMERGENCY, Mustache_Logger::ALERT, false), + array(Mustache_Logger::ALERT, Mustache_Logger::CRITICAL, false), + array(Mustache_Logger::CRITICAL, Mustache_Logger::ERROR, false), + array(Mustache_Logger::ERROR, Mustache_Logger::WARNING, false), + array(Mustache_Logger::WARNING, Mustache_Logger::NOTICE, false), + array(Mustache_Logger::NOTICE, Mustache_Logger::INFO, false), + array(Mustache_Logger::INFO, Mustache_Logger::DEBUG, false), + ); + } + + /** + * @dataProvider getLogMessages + */ + public function testLogging($level, $message, $context, $expected) + { + $stream = tmpfile(); + $logger = new Mustache_Logger_StreamLogger($stream, Mustache_Logger::DEBUG); + $logger->log($level, $message, $context); + + rewind($stream); + $result = fread($stream, 1024); + + $this->assertEquals($expected, $result); + } + + public function getLogMessages() + { + // $level, $message, $context, $expected + return array( + array(Mustache_Logger::DEBUG, 'debug message', array(), "DEBUG: debug message\n"), + array(Mustache_Logger::INFO, 'info message', array(), "INFO: info message\n"), + array(Mustache_Logger::NOTICE, 'notice message', array(), "NOTICE: notice message\n"), + array(Mustache_Logger::WARNING, 'warning message', array(), "WARNING: warning message\n"), + array(Mustache_Logger::ERROR, 'error message', array(), "ERROR: error message\n"), + array(Mustache_Logger::CRITICAL, 'critical message', array(), "CRITICAL: critical message\n"), + array(Mustache_Logger::ALERT, 'alert message', array(), "ALERT: alert message\n"), + array(Mustache_Logger::EMERGENCY, 'emergency message', array(), "EMERGENCY: emergency message\n"), + + // with context + array( + Mustache_Logger::ERROR, + 'error message', + array('name' => 'foo', 'number' => 42), + "ERROR: error message\n" + ), + + // with interpolation + array( + Mustache_Logger::ERROR, + 'error {name}-{number}', + array('name' => 'foo', 'number' => 42), + "ERROR: error foo-42\n" + ), + + // with iterpolation false positive + array( + Mustache_Logger::ERROR, + 'error {nothing}', + array('name' => 'foo', 'number' => 42), + "ERROR: error {nothing}\n" + ), + + // with interpolation injection + array( + Mustache_Logger::ERROR, + '{foo}', + array('foo' => '{bar}', 'bar' => 'FAIL'), + "ERROR: {bar}\n" + ), + ); + } + + public function testChangeLoggingLevels() + { + $stream = tmpfile(); + $logger = new Mustache_Logger_StreamLogger($stream); + + $logger->setLevel(Mustache_Logger::ERROR); + $this->assertEquals(Mustache_Logger::ERROR, $logger->getLevel()); + + $logger->log(Mustache_Logger::WARNING, 'ignore this'); + + $logger->setLevel(Mustache_Logger::INFO); + $this->assertEquals(Mustache_Logger::INFO, $logger->getLevel()); + + $logger->log(Mustache_Logger::WARNING, 'log this'); + + $logger->setLevel(Mustache_Logger::CRITICAL); + $this->assertEquals(Mustache_Logger::CRITICAL, $logger->getLevel()); + + $logger->log(Mustache_Logger::ERROR, 'ignore this'); + + rewind($stream); + $result = fread($stream, 1024); + + $this->assertEquals("WARNING: log this\n", $result); + } + + /** + * @expectedException InvalidArgumentException + */ + public function testThrowsInvalidArgumentExceptionWhenSettingUnknownLevels() + { + $logger = new Mustache_Logger_StreamLogger(tmpfile()); + $logger->setLevel('bacon'); + } + + /** + * @expectedException InvalidArgumentException + */ + public function testThrowsInvalidArgumentExceptionWhenLoggingUnknownLevels() + { + $logger = new Mustache_Logger_StreamLogger(tmpfile()); + $logger->log('bacon', 'CODE BACON ERROR!'); + } +} From d252fddf4ab731ade8aca80214dd5c27407b4ac3 Mon Sep 17 00:00:00 2001 From: Justin Hileman Date: Fri, 11 Jan 2013 22:53:27 -0800 Subject: [PATCH 7/7] Add plug for PSR-3 --- src/Mustache/Engine.php | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/src/Mustache/Engine.php b/src/Mustache/Engine.php index 16e2e86..5eafe81 100644 --- a/src/Mustache/Engine.php +++ b/src/Mustache/Engine.php @@ -83,7 +83,9 @@ class Mustache_Engine * // Character set for `htmlspecialchars`. Defaults to 'UTF-8'. Use 'UTF-8'. * 'charset' => 'ISO-8859-1', * - * // A Mustache Logger instance. No logging will occur unless this is set. + * // A Mustache Logger instance. No logging will occur unless this is set. Using a PSR-3 compatible + * // logging library -- such as Monolog -- is highly recommended. A simple stream logger implementation is + * // available as well: * 'logger' => new Mustache_StreamLogger('php://stderr'), * ); *