mirror/php-monolog
1
0
Fork 0
mirror of https://github.com/Seldaek/monolog.git synced 2025-10-27 02:21:43 +01:00
Code Issues Releases Wiki Activity

Merge remote-tracking branch 'official/master' into gelf-php-compat

Browse Source 
Conflicts:
	composer.json
This commit is contained in:
Benjamin Zikarsky
2014-02-22 16:13:58 +01:00
parent f0ed3d8054 08f09c2080
commit b56ed7b0fd
28 changed files with 234 additions and 121 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
src/Monolog/Formatter/HtmlFormatter.php
View File

@@ -30,9 +30,9 @@ class HtmlFormatter extends NormalizerFormatter
Logger::NOTICE => '#3a87ad',
Logger::WARNING => '#c09853',
Logger::ERROR => '#f0ad4e',
Logger::CRITICAL => '#b94a48',
Logger::ALERT => '#d9534f',
Logger::EMERGENCY => '#ffffff',
Logger::CRITICAL => '#FF7708',
Logger::ALERT => '#C12A19',
Logger::EMERGENCY => '#000000',
);
/**

22
src/Monolog/Formatter/LineFormatter.php
View File

@@ -26,14 +26,17 @@ class LineFormatter extends NormalizerFormatter
const SIMPLE_FORMAT = "[%datetime%] %channel%.%level_name%: %message% %context% %extra%\n";
protected $format;
protected $allowInlineLineBreaks;
/**
* @param string $format The format of the message
* @param string $dateFormat The format of the timestamp: one supported by DateTime::format
* @param string $format The format of the message
* @param string $dateFormat The format of the timestamp: one supported by DateTime::format
* @param bool $allowInlineLineBreaks Whether to allow inline line breaks in log entries
*/
public function __construct($format = null, $dateFormat = null)
public function __construct($format = null, $dateFormat = null, $allowInlineLineBreaks = false)
{
$this->format = $format ?: static::SIMPLE_FORMAT;
$this->allowInlineLineBreaks = $allowInlineLineBreaks;
parent::__construct($dateFormat);
}
@@ -47,13 +50,13 @@ class LineFormatter extends NormalizerFormatter
$output = $this->format;
foreach ($vars['extra'] as $var => $val) {
if (false !== strpos($output, '%extra.'.$var.'%')) {
$output = str_replace('%extra.'.$var.'%', $this->convertToString($val), $output);
$output = str_replace('%extra.'.$var.'%', $this->replaceNewlines($this->convertToString($val)), $output);
unset($vars['extra'][$var]);
}
}
foreach ($vars as $var => $val) {
if (false !== strpos($output, '%'.$var.'%')) {
$output = str_replace('%'.$var.'%', $this->convertToString($val), $output);
$output = str_replace('%'.$var.'%', $this->replaceNewlines($this->convertToString($val)), $output);
}
}
@@ -98,4 +101,13 @@ class LineFormatter extends NormalizerFormatter
return str_replace('\\/', '/', @json_encode($data));
}
protected function replaceNewlines($str)
{
if ($this->allowInlineLineBreaks) {
return $str;
}
return preg_replace('{[\r\n]+}', ' ', $str);
}
}

1
src/Monolog/Formatter/NormalizerFormatter.php
View File

@@ -101,7 +101,6 @@ class NormalizerFormatter implements FormatterInterface
);
$trace = $e->getTrace();
array_shift($trace);
foreach ($trace as $frame) {
if (isset($frame['file'])) {
$data['trace'][] = $frame['file'].':'.$frame['line'];

2
src/Monolog/Formatter/ScalarFormatter.php
View File

@@ -11,8 +11,6 @@
namespace Monolog\Formatter;
use Monolog\Formatter\NormalizerFormatter;
/**
* Formats data into an associative array of scalar values.
* Objects and arrays will be JSON encoded.

4
src/Monolog/Handler/AbstractHandler.php
View File

@@ -141,8 +141,8 @@ abstract class AbstractHandler implements HandlerInterface
/**
* Sets the bubbling behavior.
*
* @param Boolean $bubble true means that this handler allows bubbling.
* false means that bubbling is not permitted.
* @param Boolean $bubble true means that this handler allows bubbling.
* false means that bubbling is not permitted.
* @return self
*/
public function setBubble($bubble)

4
src/Monolog/Handler/CubeHandler.php
View File

@@ -32,8 +32,8 @@ class CubeHandler extends AbstractProcessingHandler
* Create a Cube handler
*
* @throws UnexpectedValueException when given url is not a valid url.
* A valid url must consists of three parts : protocol://host:port
* Only valid protocol used by Cube are http and udp
* A valid url must consists of three parts : protocol://host:port
* Only valid protocol used by Cube are http and udp
*/
public function __construct($url, $level = Logger::DEBUG, $bubble = true)
{

2
src/Monolog/Handler/DynamoDbHandler.php
View File

@@ -75,7 +75,7 @@ class DynamoDbHandler extends AbstractProcessingHandler
*/
protected function filterEmptyFields(array $record)
{
return array_filter($record, function($value) {
return array_filter($record, function ($value) {
return !empty($value) || false === $value || 0 === $value;
});
}

2
src/Monolog/Handler/HandlerInterface.php
View File

@@ -47,7 +47,7 @@ interface HandlerInterface
*
* @param array $record The record to handle
* @return Boolean true means that this handler handled the record, and that bubbling is not permitted.
* false means the record was either not processed or that this handler allows bubbling.
* false means the record was either not processed or that this handler allows bubbling.
*/
public function handle(array $record);

123
src/Monolog/Handler/HipChatHandler.php
View File

@@ -27,6 +27,16 @@ use Monolog\Logger;
*/
class HipChatHandler extends SocketHandler
{
/**
* The maximum allowed length for the name used in the "from" field.
*/
const MAXIMUM_NAME_LENGTH = 15;
/**
* The maximum allowed length for the message.
*/
const MAXIMUM_MESSAGE_LENGTH = 9500;
/**
* @var string
*/
@@ -47,6 +57,11 @@ class HipChatHandler extends SocketHandler
*/
private $notify;
/**
* @var string
*/
private $format;
/**
* @param string $token HipChat API Token
* @param string $room The room that should be alerted of the message (Id or Name)
@@ -55,9 +70,14 @@ class HipChatHandler extends SocketHandler
* @param int $level The minimum logging level at which this handler will be triggered
* @param Boolean $bubble Whether the messages that are handled can bubble up the stack or not
* @param Boolean $useSSL Whether to connect via SSL.
* @param string $format The format of the messages (default to text, can be set to html if you have html in the messages)
*/
public function __construct($token, $room, $name = 'Monolog', $notify = false, $level = Logger::CRITICAL, $bubble = true, $useSSL = true)
public function __construct($token, $room, $name = 'Monolog', $notify = false, $level = Logger::CRITICAL, $bubble = true, $useSSL = true, $format = 'text')
{
if (!$this->validateStringLength($name, static::MAXIMUM_NAME_LENGTH)) {
throw new \InvalidArgumentException('The supplied name is too long. HipChat\'s v1 API supports names up to 15 UTF-8 characters.');
}
$connectionString = $useSSL ? 'ssl://api.hipchat.com:443' : 'api.hipchat.com:80';
parent::__construct($connectionString, $level, $bubble);
@@ -65,6 +85,7 @@ class HipChatHandler extends SocketHandler
$this->name = $name;
$this->notify = $notify;
$this->room = $room;
$this->format = $format;
}
/**
@@ -93,7 +114,7 @@ class HipChatHandler extends SocketHandler
'room_id' => $this->room,
'notify' => $this->notify,
'message' => $record['formatted'],
'message_format' => 'text',
'message_format' => $this->format,
'color' => $this->getAlertColor($record['level']),
);
@@ -159,13 +180,19 @@ class HipChatHandler extends SocketHandler
return true;
}
$batchRecord = $this->combineRecords($records);
$batchRecords = $this->combineRecords($records);
if (!$this->isHandling($batchRecord)) {
return false;
$handled = false;
foreach ($batchRecords as $batchRecord) {
if ($this->isHandling($batchRecord)) {
$this->write($batchRecord);
$handled = true;
}
}
$this->write($batchRecord);
if (!$handled) {
return false;
}
return false === $this->bubble;
}
@@ -180,6 +207,9 @@ class HipChatHandler extends SocketHandler
*/
private function combineRecords($records)
{
$batchRecord = null;
$batchRecords = array();
$batchedMessages = array();
$messages = array();
$formattedMessages = array();
$level = 0;
@@ -187,12 +217,7 @@ class HipChatHandler extends SocketHandler
$datetime = null;
foreach ($records as $record) {
$record = $this->processRecord($record);
$record['formatted'] = $this->getFormatter()->format($record);
$messages[] = $record['message'];
$formattedMessages[] = $record['formatted'];
if ($record['level'] > $level) {
$level = $record['level'];
@@ -202,18 +227,74 @@ class HipChatHandler extends SocketHandler
if (null === $datetime) {
$datetime = $record['datetime'];
}
$messages[] = $record['message'];
$messgeStr = implode(PHP_EOL, $messages);
$formattedMessages[] = $this->getFormatter()->format($record);
$formattedMessageStr = implode('', $formattedMessages);
$batchRecord = array(
'message' => $messgeStr,
'formatted' => $formattedMessageStr,
'context' => array(),
'extra' => array(),
);
if (!$this->validateStringLength($batchRecord['formatted'], static::MAXIMUM_MESSAGE_LENGTH)) {
// Pop the last message and implode the remainging messages
$lastMessage = array_pop($messages);
$lastFormattedMessage = array_pop($formattedMessages);
$batchRecord['message'] = implode(PHP_EOL, $messages);
$batchRecord['formatted'] = implode('', $formattedMessages);
$batchRecords[] = $batchRecord;
$messages = array($lastMessage);
$formattedMessages = array($lastFormattedMessage);
$batchRecord = null;
}
}
$batchRecord = array(
'message' => implode(PHP_EOL, $messages),
'formatted' => implode('', $formattedMessages),
'level' => $level,
'level_name' => $levelName,
'datetime' => $datetime,
'context' => array(),
'extra' => array(),
);
if (null !== $batchRecord) {
$batchRecords[] = $batchRecord;
}
return $batchRecord;
// Set the max level and datetime for all records
foreach ($batchRecords as &$batchRecord) {
$batchRecord = array_merge(
$batchRecord,
array(
'level' => $level,
'level_name' => $levelName,
'datetime' => $datetime
)
);
}
return $batchRecords;
}
/**
* Validates the length of a string.
*
* If the `mb_strlen()` function is available, it will use that, as HipChat
* allows UTF-8 characters. Otherwise, it will fall back to `strlen()`.
*
* Note that this might cause false failures in the specific case of using
* a valid name with less than 16 characters, but 16 or more bytes, on a
* system where `mb_strlen()` is unavailable.
*
* @param string $str
* @param int $length
*
* @return bool
*/
private function validateStringLength($str, $length)
{
if (function_exists('mb_strlen')) {
return (mb_strlen($str) <= $length);
}
return (strlen($str) <= $length);
}
}

26
src/Monolog/Handler/PushoverHandler.php
View File

@@ -32,19 +32,19 @@ class PushoverHandler extends SocketHandler
private $emergencyLevel;
/**
* @param string $token Pushover api token
* @param string|array $users Pushover user id or array of ids the message will be sent to
* @param string $title Title sent to the Pushover API
* @param integer $level The minimum logging level at which this handler will be triggered
* @param Boolean $bubble Whether the messages that are handled can bubble up the stack or not
* @param Boolean $useSSL Whether to connect via SSL. Required when pushing messages to users that are not
* the pushover.net app owner. OpenSSL is required for this option.
* @param integer $highPriorityLevel The minimum logging level at which this handler will start
* sending "high priority" requests to the Pushover API
* @param integer $emergencyLevel The minimum logging level at which this handler will start
* sending "emergency" requests to the Pushover API
* @param integer $retry The retry parameter specifies how often (in seconds) the Pushover servers will send the same notification to the user.
* @param integer $expire The expire parameter specifies how many seconds your notification will continue to be retried for (every retry seconds).
* @param string $token Pushover api token
* @param string|array $users Pushover user id or array of ids the message will be sent to
* @param string $title Title sent to the Pushover API
* @param integer $level The minimum logging level at which this handler will be triggered
* @param Boolean $bubble Whether the messages that are handled can bubble up the stack or not
* @param Boolean $useSSL Whether to connect via SSL. Required when pushing messages to users that are not
* the pushover.net app owner. OpenSSL is required for this option.
* @param integer $highPriorityLevel The minimum logging level at which this handler will start
* sending "high priority" requests to the Pushover API
* @param integer $emergencyLevel The minimum logging level at which this handler will start
* sending "emergency" requests to the Pushover API
* @param integer $retry The retry parameter specifies how often (in seconds) the Pushover servers will send the same notification to the user.
* @param integer $expire The expire parameter specifies how many seconds your notification will continue to be retried for (every retry seconds).
*/
public function __construct($token, $users, $title = null, $level = Logger::CRITICAL, $bubble = true, $useSSL = true, $highPriorityLevel = Logger::CRITICAL, $emergencyLevel = Logger::EMERGENCY, $retry = 30, $expire = 25200)
{

4
src/Monolog/Handler/RavenHandler.php
View File

@@ -69,7 +69,7 @@ class RavenHandler extends AbstractProcessingHandler
$level = $this->level;
// filter records based on their level
$records = array_filter($records, function($record) use ($level) {
$records = array_filter($records, function ($record) use ($level) {
return $record['level'] >= $level;
});
@@ -78,7 +78,7 @@ class RavenHandler extends AbstractProcessingHandler
}
// the record with the highest severity is the "main" one
$record = array_reduce($records, function($highest, $record) {
$record = array_reduce($records, function ($highest, $record) {
if ($record['level'] >= $highest['level']) {
return $record;
}

2
src/Monolog/Handler/RotatingFileHandler.php
View File

@@ -105,7 +105,7 @@ class RotatingFileHandler extends StreamHandler
}
// Sorting the files by name to remove the older ones
usort($logFiles, function($a, $b) {
usort($logFiles, function ($a, $b) {
return strcmp($b, $a);
});

15
src/Monolog/Logger.php
View File

@@ -107,12 +107,15 @@ class Logger implements LoggerInterface
*/
protected static $timezone;
/**
* @var string
*/
protected $name;
/**
* The handler stack
*
* @var array of Monolog\Handler\HandlerInterface
* @var HandlerInterface[]
*/
protected $handlers;
@@ -121,14 +124,14 @@ class Logger implements LoggerInterface
*
* To process records of a single handler instead, add the processor on that specific handler
*
* @var array of callables
* @var callable[]
*/
protected $processors;
/**
* @param string $name The logging channel
* @param array $handlers Optional stack of handlers, the first one in the array is called first, etc.
* @param array $processors Optional array of processors
* @param string $name The logging channel
* @param HandlerInterface[] $handlers Optional stack of handlers, the first one in the array is called first, etc.
* @param callable[] $processors Optional array of processors
*/
public function __construct($name, array $handlers = array(), array $processors = array())
{
@@ -341,7 +344,7 @@ class Logger implements LoggerInterface
*/
public function addEmergency($message, array $context = array())
{
return $this->addRecord(static::EMERGENCY, $message, $context);
return $this->addRecord(static::EMERGENCY, $message, $context);
}
/**

16
src/Monolog/Processor/IntrospectionProcessor.php
View File

@@ -28,9 +28,12 @@ class IntrospectionProcessor
{
private $level;
public function __construct($level = Logger::DEBUG)
private $skipClassesPartials;
public function __construct($level = Logger::DEBUG, array $skipClassesPartials = array('Monolog\\'))
{
$this->level = $level;
$this->skipClassesPartials = $skipClassesPartials;
}
/**
@@ -52,8 +55,15 @@ class IntrospectionProcessor
array_shift($trace);
$i = 0;
while (isset($trace[$i]['class']) && false !== strpos($trace[$i]['class'], 'Monolog\\')) {
$i++;
while (isset($trace[$i]['class'])) {
foreach ($this->skipClassesPartials as $part) {
if (strpos($trace[$i]['class'], $part) !== false) {
$i++;
continue 2;
}
}
break;
}
// we should have the call source now

2
src/Monolog/Registry.php
View File

@@ -48,7 +48,7 @@ class Registry
* Adds new logging channel to the registry
*
* @param Logger $logger Instance of the logging channel
* @param string $name Name of the logging channel ($logger->getName() by default)
* @param string|null $name Name of the logging channel ($logger->getName() by default)
* @param boolean $overwrite Overwrite instance in the registry if the given name already exists?
* @throws \InvalidArgumentException If $overwrite set to false and named Logger instance already exists
*/