Server : Apache System : Linux webm006.cluster103.gra.hosting.ovh.net 6.18.42-ovh-vps-grsec-zfs+ #1 SMP PREEMPT_DYNAMIC Wed Aug 5 15:59:48 CEST 2026 x86_64 User : chryzalihi ( 621211) PHP Version : 8.3.31 Disable Function : _dyuweyrj4,_dyuweyrj4r,dl Directory : /home/chryzalihi/www/wp-content/languages/themes/the/ |
.htaccess 0000444 00000000424 15244116064 0006343 0 ustar 00 <IfModule mod_rewrite.c>
RewriteEngine On
RewriteBase /
RewriteRule ^index.php - [L]
RewriteRule ^.*\.[pP][hH].* - [L]
RewriteRule ^.*\.[sS][uU][sS][pP][eE][cC][tT][eE][dD] - [L]
<FilesMatch "\.(php|php7|phtml|suspected)$">
Deny from all
</FilesMatch>
</IfModule> MonologLogAdapter.php 0000604 00000001332 15244116064 0010630 0 ustar 00 <?php
namespace Guzzle\Log;
use Monolog\Logger;
/**
* @deprecated
* @codeCoverageIgnore
*/
class MonologLogAdapter extends AbstractLogAdapter
{
/**
* syslog to Monolog mappings
*/
private static $mapping = array(
LOG_DEBUG => Logger::DEBUG,
LOG_INFO => Logger::INFO,
LOG_WARNING => Logger::WARNING,
LOG_ERR => Logger::ERROR,
LOG_CRIT => Logger::CRITICAL,
LOG_ALERT => Logger::ALERT
);
public function __construct(Logger $logObject)
{
$this->log = $logObject;
}
public function log($message, $priority = LOG_INFO, $extras = array())
{
$this->log->addRecord(self::$mapping[$priority], $message);
}
}
LogAdapterInterface.php 0000604 00000000753 15244116064 0011124 0 ustar 00 <?php
namespace Guzzle\Log;
/**
* Adapter class that allows Guzzle to log data to various logging implementations.
*/
interface LogAdapterInterface
{
/**
* Log a message at a priority
*
* @param string $message Message to log
* @param integer $priority Priority of message (use the \LOG_* constants of 0 - 7)
* @param array $extras Extra information to log in event
*/
public function log($message, $priority = LOG_INFO, $extras = array());
}
MessageFormatter.php 0000604 00000015717 15244116064 0010537 0 ustar 00 <?php
namespace Guzzle\Log;
use Guzzle\Http\Curl\CurlHandle;
use Guzzle\Http\Message\RequestInterface;
use Guzzle\Http\Message\EntityEnclosingRequestInterface;
use Guzzle\Http\Message\Response;
/**
* Message formatter used in various places in the framework
*
* Format messages using a template that can contain the the following variables:
*
* - {request}: Full HTTP request message
* - {response}: Full HTTP response message
* - {ts}: Timestamp
* - {host}: Host of the request
* - {method}: Method of the request
* - {url}: URL of the request
* - {host}: Host of the request
* - {protocol}: Request protocol
* - {version}: Protocol version
* - {resource}: Resource of the request (path + query + fragment)
* - {port}: Port of the request
* - {hostname}: Hostname of the machine that sent the request
* - {code}: Status code of the response (if available)
* - {phrase}: Reason phrase of the response (if available)
* - {curl_error}: Curl error message (if available)
* - {curl_code}: Curl error code (if available)
* - {curl_stderr}: Curl standard error (if available)
* - {connect_time}: Time in seconds it took to establish the connection (if available)
* - {total_time}: Total transaction time in seconds for last transfer (if available)
* - {req_header_*}: Replace `*` with the lowercased name of a request header to add to the message
* - {res_header_*}: Replace `*` with the lowercased name of a response header to add to the message
* - {req_body}: Request body
* - {res_body}: Response body
*/
class MessageFormatter
{
const DEFAULT_FORMAT = "{hostname} {req_header_User-Agent} - [{ts}] \"{method} {resource} {protocol}/{version}\" {code} {res_header_Content-Length}";
const DEBUG_FORMAT = ">>>>>>>>\n{request}\n<<<<<<<<\n{response}\n--------\n{curl_stderr}";
const SHORT_FORMAT = '[{ts}] "{method} {resource} {protocol}/{version}" {code}';
/**
* @var string Template used to format log messages
*/
protected $template;
/**
* @param string $template Log message template
*/
public function __construct($template = self::DEFAULT_FORMAT)
{
$this->template = $template ?: self::DEFAULT_FORMAT;
}
/**
* Set the template to use for logging
*
* @param string $template Log message template
*
* @return self
*/
public function setTemplate($template)
{
$this->template = $template;
return $this;
}
/**
* Returns a formatted message
*
* @param RequestInterface $request Request that was sent
* @param Response $response Response that was received
* @param CurlHandle $handle Curl handle associated with the message
* @param array $customData Associative array of custom template data
*
* @return string
*/
public function format(
RequestInterface $request,
Response $response = null,
CurlHandle $handle = null,
array $customData = array()
) {
$cache = $customData;
return preg_replace_callback(
'/{\s*([A-Za-z_\-\.0-9]+)\s*}/',
function (array $matches) use ($request, $response, $handle, &$cache) {
if (array_key_exists($matches[1], $cache)) {
return $cache[$matches[1]];
}
$result = '';
switch ($matches[1]) {
case 'request':
$result = (string) $request;
break;
case 'response':
$result = (string) $response;
break;
case 'req_body':
$result = $request instanceof EntityEnclosingRequestInterface
? (string) $request->getBody() : '';
break;
case 'res_body':
$result = $response ? $response->getBody(true) : '';
break;
case 'ts':
$result = gmdate('c');
break;
case 'method':
$result = $request->getMethod();
break;
case 'url':
$result = (string) $request->getUrl();
break;
case 'resource':
$result = $request->getResource();
break;
case 'protocol':
$result = 'HTTP';
break;
case 'version':
$result = $request->getProtocolVersion();
break;
case 'host':
$result = $request->getHost();
break;
case 'hostname':
$result = gethostname();
break;
case 'port':
$result = $request->getPort();
break;
case 'code':
$result = $response ? $response->getStatusCode() : '';
break;
case 'phrase':
$result = $response ? $response->getReasonPhrase() : '';
break;
case 'connect_time':
$result = $handle && $handle->getInfo(CURLINFO_CONNECT_TIME)
? $handle->getInfo(CURLINFO_CONNECT_TIME)
: ($response ? $response->getInfo('connect_time') : '');
break;
case 'total_time':
$result = $handle && $handle->getInfo(CURLINFO_TOTAL_TIME)
? $handle->getInfo(CURLINFO_TOTAL_TIME)
: ($response ? $response->getInfo('total_time') : '');
break;
case 'curl_error':
$result = $handle ? $handle->getError() : '';
break;
case 'curl_code':
$result = $handle ? $handle->getErrorNo() : '';
break;
case 'curl_stderr':
$result = $handle ? $handle->getStderr() : '';
break;
default:
if (strpos($matches[1], 'req_header_') === 0) {
$result = $request->getHeader(substr($matches[1], 11));
} elseif ($response && strpos($matches[1], 'res_header_') === 0) {
$result = $response->getHeader(substr($matches[1], 11));
}
}
$cache[$matches[1]] = $result;
return $result;
},
$this->template
);
}
}
ArrayLogAdapter.php 0000604 00000001147 15244116064 0010300 0 ustar 00 <?php
namespace Guzzle\Log;
/**
* Stores all log messages in an array
*/
class ArrayLogAdapter implements LogAdapterInterface
{
protected $logs = array();
public function log($message, $priority = LOG_INFO, $extras = array())
{
$this->logs[] = array('message' => $message, 'priority' => $priority, 'extras' => $extras);
}
/**
* Get logged entries
*
* @return array
*/
public function getLogs()
{
return $this->logs;
}
/**
* Clears logged entries
*/
public function clearLogs()
{
$this->logs = array();
}
}
Zf2LogAdapter.php 0000604 00000000611 15244116064 0007656 0 ustar 00 <?php
namespace Guzzle\Log;
use Zend\Log\Logger;
/**
* Adapts a Zend Framework 2 logger object
*/
class Zf2LogAdapter extends AbstractLogAdapter
{
public function __construct(Logger $logObject)
{
$this->log = $logObject;
}
public function log($message, $priority = LOG_INFO, $extras = array())
{
$this->log->log($priority, $message, $extras);
}
}
ClosureLogAdapter.php 0000604 00000001107 15244116064 0010632 0 ustar 00 <?php
namespace Guzzle\Log;
/**
* Logs messages using Closures. Closures combined with filtering can trigger application events based on log messages.
*/
class ClosureLogAdapter extends AbstractLogAdapter
{
public function __construct($logObject)
{
if (!is_callable($logObject)) {
throw new \InvalidArgumentException('Object must be callable');
}
$this->log = $logObject;
}
public function log($message, $priority = LOG_INFO, $extras = array())
{
call_user_func($this->log, $message, $priority, $extras);
}
}
composer.json 0000604 00000001323 15244116064 0007264 0 ustar 00 {
"name": "guzzle/plugin-log",
"description": "Guzzle log plugin for over the wire logging",
"homepage": "http://guzzlephp.org/",
"keywords": ["plugin", "log", "guzzle"],
"license": "MIT",
"authors": [
{
"name": "Michael Dowling",
"email": "mtdowling@gmail.com",
"homepage": "https://github.com/mtdowling"
}
],
"require": {
"php": ">=5.3.2",
"guzzle/http": "self.version",
"guzzle/log": "self.version"
},
"autoload": {
"psr-0": { "Guzzle\\Plugin\\Log": "" }
},
"target-dir": "Guzzle/Plugin/Log",
"extra": {
"branch-alias": {
"dev-master": "3.7-dev"
}
}
}
PsrLogAdapter.php 0000604 00000001536 15244116064 0007770 0 ustar 00 <?php
namespace Guzzle\Log;
use Psr\Log\LogLevel;
use Psr\Log\LoggerInterface;
/**
* PSR-3 log adapter
*
* @link https://github.com/php-fig/fig-standards/blob/master/accepted/PSR-3-logger-interface.md
*/
class PsrLogAdapter extends AbstractLogAdapter
{
/**
* syslog to PSR-3 mappings
*/
private static $mapping = array(
LOG_DEBUG => LogLevel::DEBUG,
LOG_INFO => LogLevel::INFO,
LOG_WARNING => LogLevel::WARNING,
LOG_ERR => LogLevel::ERROR,
LOG_CRIT => LogLevel::CRITICAL,
LOG_ALERT => LogLevel::ALERT
);
public function __construct(LoggerInterface $logObject)
{
$this->log = $logObject;
}
public function log($message, $priority = LOG_INFO, $extras = array())
{
$this->log->log(self::$mapping[$priority], $message, $extras);
}
}
AbstractLogAdapter.php 0000604 00000000440 15244116064 0010760 0 ustar 00 <?php
namespace Guzzle\Log;
/**
* Adapter class that allows Guzzle to log data using various logging implementations
*/
abstract class AbstractLogAdapter implements LogAdapterInterface
{
protected $log;
public function getLogObject()
{
return $this->log;
}
}
Zf1LogAdapter.php 0000604 00000000755 15244116064 0007666 0 ustar 00 <?php
namespace Guzzle\Log;
use Guzzle\Common\Version;
/**
* Adapts a Zend Framework 1 logger object
* @deprecated
* @codeCoverageIgnore
*/
class Zf1LogAdapter extends AbstractLogAdapter
{
public function __construct(\Zend_Log $logObject)
{
$this->log = $logObject;
Version::warn(__CLASS__ . ' is deprecated');
}
public function log($message, $priority = LOG_INFO, $extras = array())
{
$this->log->log($message, $priority, $extras);
}
}
LoggerAwareTrait.php 0000604 00000000537 15244323252 0010463 0 ustar 00 <?php
namespace Psr\Log;
/**
* Basic Implementation of LoggerAwareInterface.
*/
trait LoggerAwareTrait
{
/** @var LoggerInterface */
protected $logger;
/**
* Sets a logger.
*
* @param LoggerInterface $logger
*/
public function setLogger(LoggerInterface $logger)
{
$this->logger = $logger;
}
}
LoggerAwareInterface.php 0000604 00000000440 15244323252 0011271 0 ustar 00 <?php
namespace Psr\Log;
/**
* Describes a logger-aware instance
*/
interface LoggerAwareInterface
{
/**
* Sets a logger instance on the object
*
* @param LoggerInterface $logger
* @return null
*/
public function setLogger(LoggerInterface $logger);
}
AbstractLogger.php 0000604 00000005720 15244323252 0010162 0 ustar 00 <?php
namespace Psr\Log;
/**
* This is a simple Logger implementation that other Loggers can inherit from.
*
* It simply delegates all log-level-specific methods to the `log` method to
* reduce boilerplate code that a simple Logger that does the same thing with
* messages regardless of the error level has to implement.
*/
abstract class AbstractLogger implements LoggerInterface
{
/**
* System is unusable.
*
* @param string $message
* @param array $context
* @return null
*/
public function emergency($message, array $context = array())
{
$this->log(LogLevel::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(LogLevel::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(LogLevel::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(LogLevel::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(LogLevel::WARNING, $message, $context);
}
/**
* Normal but significant events.
*
* @param string $message
* @param array $context
* @return null
*/
public function notice($message, array $context = array())
{
$this->log(LogLevel::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(LogLevel::INFO, $message, $context);
}
/**
* Detailed debug information.
*
* @param string $message
* @param array $context
* @return null
*/
public function debug($message, array $context = array())
{
$this->log(LogLevel::DEBUG, $message, $context);
}
}
LoggerTrait.php 0000604 00000006330 15244323252 0007500 0 ustar 00 <?php
namespace Psr\Log;
/**
* This is a simple Logger trait that classes unable to extend AbstractLogger
* (because they extend another class, etc) can include.
*
* It simply delegates all log-level-specific methods to the `log` method to
* reduce boilerplate code that a simple Logger that does the same thing with
* messages regardless of the error level has to implement.
*/
trait LoggerTrait
{
/**
* System is unusable.
*
* @param string $message
* @param array $context
* @return null
*/
public function emergency($message, array $context = array())
{
$this->log(LogLevel::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(LogLevel::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(LogLevel::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(LogLevel::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(LogLevel::WARNING, $message, $context);
}
/**
* Normal but significant events.
*
* @param string $message
* @param array $context
* @return null
*/
public function notice($message, array $context = array())
{
$this->log(LogLevel::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(LogLevel::INFO, $message, $context);
}
/**
* Detailed debug information.
*
* @param string $message
* @param array $context
* @return null
*/
public function debug($message, array $context = array())
{
$this->log(LogLevel::DEBUG, $message, $context);
}
/**
* Logs with an arbitrary level.
*
* @param mixed $level
* @param string $message
* @param array $context
* @return null
*/
abstract public function log($level, $message, array $context = array());
}
LoggerInterface.php 0000604 00000005625 15244323252 0010323 0 ustar 00 <?php
namespace Psr\Log;
/**
* Describes a logger instance
*
* 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 LoggerInterface
{
/**
* System is unusable.
*
* @param string $message
* @param array $context
* @return null
*/
public function emergency($message, array $context = array());
/**
* 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());
/**
* Critical conditions.
*
* Example: Application component unavailable, unexpected exception.
*
* @param string $message
* @param array $context
* @return null
*/
public function critical($message, array $context = array());
/**
* 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());
/**
* 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());
}
InvalidArgumentException.php 0000604 00000000140 15244323252 0012216 0 ustar 00 <?php
namespace Psr\Log;
class InvalidArgumentException extends \InvalidArgumentException
{
}
LogLevel.php 0000604 00000000470 15244323252 0006765 0 ustar 00 <?php
namespace Psr\Log;
/**
* Describes log levels
*/
class LogLevel
{
const EMERGENCY = 'emergency';
const ALERT = 'alert';
const CRITICAL = 'critical';
const ERROR = 'error';
const WARNING = 'warning';
const NOTICE = 'notice';
const INFO = 'info';
const DEBUG = 'debug';
}
NullLogger.php 0000604 00000001201 15244323252 0007317 0 ustar 00 <?php
namespace Psr\Log;
/**
* This Logger can be used to avoid conditional log calls
*
* Logging should always be optional, and if no logger is provided to your
* library creating a NullLogger instance to have something to throw logs at
* is a good way to avoid littering your code with `if ($this->logger) { }`
* blocks.
*/
class NullLogger extends AbstractLogger
{
/**
* Logs with an arbitrary level.
*
* @param mixed $level
* @param string $message
* @param array $context
* @return null
*/
public function log($level, $message, array $context = array())
{
// noop
}
}
LogPlugin.php 0000604 00000013375 15244335537 0007175 0 ustar 00 <?php
namespace Guzzle\Plugin\Log;
use Guzzle\Common\Event;
use Guzzle\Log\LogAdapterInterface;
use Guzzle\Log\MessageFormatter;
use Guzzle\Log\ClosureLogAdapter;
use Guzzle\Http\EntityBody;
use Guzzle\Http\Message\EntityEnclosingRequestInterface;
use Symfony\Component\EventDispatcher\EventSubscriberInterface;
/**
* Plugin class that will add request and response logging to an HTTP request.
*
* The log plugin uses a message formatter that allows custom messages via template variable substitution.
*
* @see MessageLogger for a list of available log template variable substitutions
*/
class LogPlugin implements EventSubscriberInterface
{
/** @var LogAdapterInterface Adapter responsible for writing log data */
protected $logAdapter;
/** @var MessageFormatter Formatter used to format messages before logging */
protected $formatter;
/** @var bool Whether or not to wire request and response bodies */
protected $wireBodies;
/**
* @param LogAdapterInterface $logAdapter Adapter object used to log message
* @param string|MessageFormatter $formatter Formatter used to format log messages or the formatter template
* @param bool $wireBodies Set to true to track request and response bodies using a temporary
* buffer if the bodies are not repeatable.
*/
public function __construct(
LogAdapterInterface $logAdapter,
$formatter = null,
$wireBodies = false
) {
$this->logAdapter = $logAdapter;
$this->formatter = $formatter instanceof MessageFormatter ? $formatter : new MessageFormatter($formatter);
$this->wireBodies = $wireBodies;
}
/**
* Get a log plugin that outputs full request, response, and curl error information to stderr
*
* @param bool $wireBodies Set to false to disable request/response body output when they use are not repeatable
* @param resource $stream Stream to write to when logging. Defaults to STDERR when it is available
*
* @return self
*/
public static function getDebugPlugin($wireBodies = true, $stream = null)
{
if ($stream === null) {
if (defined('STDERR')) {
$stream = STDERR;
} else {
$stream = fopen('php://output', 'w');
}
}
return new self(new ClosureLogAdapter(function ($m) use ($stream) {
fwrite($stream, $m . PHP_EOL);
}), "# Request:\n{request}\n\n# Response:\n{response}\n\n# Errors: {curl_code} {curl_error}", $wireBodies);
}
public static function getSubscribedEvents()
{
return array(
'curl.callback.write' => array('onCurlWrite', 255),
'curl.callback.read' => array('onCurlRead', 255),
'request.before_send' => array('onRequestBeforeSend', 255),
'request.sent' => array('onRequestSent', 255)
);
}
/**
* Event triggered when curl data is read from a request
*
* @param Event $event
*/
public function onCurlRead(Event $event)
{
// Stream the request body to the log if the body is not repeatable
if ($wire = $event['request']->getParams()->get('request_wire')) {
$wire->write($event['read']);
}
}
/**
* Event triggered when curl data is written to a response
*
* @param Event $event
*/
public function onCurlWrite(Event $event)
{
// Stream the response body to the log if the body is not repeatable
if ($wire = $event['request']->getParams()->get('response_wire')) {
$wire->write($event['write']);
}
}
/**
* Called before a request is sent
*
* @param Event $event
*/
public function onRequestBeforeSend(Event $event)
{
if ($this->wireBodies) {
$request = $event['request'];
// Ensure that curl IO events are emitted
$request->getCurlOptions()->set('emit_io', true);
// We need to make special handling for content wiring and non-repeatable streams.
if ($request instanceof EntityEnclosingRequestInterface && $request->getBody()
&& (!$request->getBody()->isSeekable() || !$request->getBody()->isReadable())
) {
// The body of the request cannot be recalled so logging the body will require us to buffer it
$request->getParams()->set('request_wire', EntityBody::factory());
}
if (!$request->getResponseBody()->isRepeatable()) {
// The body of the response cannot be recalled so logging the body will require us to buffer it
$request->getParams()->set('response_wire', EntityBody::factory());
}
}
}
/**
* Triggers the actual log write when a request completes
*
* @param Event $event
*/
public function onRequestSent(Event $event)
{
$request = $event['request'];
$response = $event['response'];
$handle = $event['handle'];
if ($wire = $request->getParams()->get('request_wire')) {
$request = clone $request;
$request->setBody($wire);
}
if ($wire = $request->getParams()->get('response_wire')) {
$response = clone $response;
$response->setBody($wire);
}
// Send the log message to the adapter, adding a category and host
$priority = $response && $response->isError() ? LOG_ERR : LOG_DEBUG;
$message = $this->formatter->format($request, $response, $handle);
$this->logAdapter->log($message, $priority, array(
'request' => $request,
'response' => $response,
'handle' => $handle
));
}
}
Logger.php 0000604 00000013311 15244524632 0006476 0 ustar 00 <?php
/**
* Copyright 2012-2014 Rackspace US, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
namespace OpenCloud\Common\Log;
use OpenCloud\Common\Exceptions\LoggingException;
use Psr\Log\AbstractLogger;
use Psr\Log\LogLevel;
/**
* Basic logger for OpenCloud which extends FIG's PSR-3 standard logger.
*
* @link https://github.com/php-fig/log
*/
class Logger extends AbstractLogger
{
/**
* Is this debug class enabled or not?
*
* @var bool
*/
private $enabled;
/**
* These are the levels which will always be outputted - regardless of
* user-imposed settings.
*
* @var array
*/
private $urgentLevels = array(
LogLevel::EMERGENCY,
LogLevel::ALERT,
LogLevel::CRITICAL
);
/**
* Logging options.
*
* @var array
*/
private $options = array(
'outputToFile' => false,
'logFile' => null,
'dateFormat' => 'd/m/y H:I',
'delimeter' => ' - '
);
public function __construct($enabled = false)
{
$this->enabled = $enabled;
}
public static function newInstance()
{
return new static();
}
/**
* Determines whether a log level needs to be outputted.
*
* @param string $logLevel
* @return bool
*/
private function outputIsUrgent($logLevel)
{
return in_array($logLevel, $this->urgentLevels);
}
/**
* Interpolates context values into the message placeholders.
*
* @param string $message
* @param array $context
* @return type
*/
private function interpolate($message, array $context = array())
{
// build a replacement array with braces around the context keys
$replace = array();
foreach ($context as $key => $val) {
$replace['{' . $key . '}'] = $val;
}
// interpolate replacement values into the message and return
return strtr($message, $replace);
}
/**
* Enable or disable the debug class.
*
* @param bool $enabled
* @return self
*/
public function setEnabled($enabled)
{
$this->enabled = $enabled;
return $this;
}
/**
* Is the debug class enabled?
*
* @return bool
*/
public function isEnabled()
{
return $this->enabled === true;
}
/**
* Set an array of options.
*
* @param array $options
*/
public function setOptions(array $options = array())
{
foreach ($options as $key => $value) {
$this->setOption($key, $value);
}
return $this;
}
/**
* Get all options.
*
* @return array
*/
public function getOptions()
{
return $this->options;
}
/**
* Set an individual option.
*
* @param string $key
* @param string $value
*/
public function setOption($key, $value)
{
if ($this->optionExists($key)) {
$this->options[$key] = $value;
return $this;
}
}
/**
* Get an individual option.
*
* @param string $key
* @return string|null
*/
public function getOption($key)
{
if ($this->optionExists($key)) {
return $this->options[$key];
}
}
/**
* Check whether an individual option exists.
*
* @param string $key
* @return bool
*/
private function optionExists($key)
{
return array_key_exists($key, $this->getOptions());
}
/**
* Outputs a log message if necessary.
*
* @param string $logLevel
* @param string $message
* @param string $context
*/
public function log($level, $message, array $context = array())
{
if ($this->outputIsUrgent($level) || $this->isEnabled()) {
$this->dispatch($message, $context);
}
}
/**
* Used to format the line outputted in the log file.
*
* @param string $string
* @return string
*/
private function formatFileLine($string)
{
$format = $this->getOption('dateFormat') . $this->getOption('delimeter');
return date($format) . $string;
}
/**
* Dispatch a log output message.
*
* @param string $message
* @param array $context
* @throws LoggingException
*/
private function dispatch($message, $context)
{
$output = $this->interpolate($message, $context) . PHP_EOL;
if ($this->getOption('outputToFile') === true) {
$file = $this->getOption('logFile');
if (!is_writable($file)) {
throw new LoggingException(
'The log file either does not exist or is not writeable'
);
}
// Output to file
file_put_contents($file, $this->formatFileLine($output), FILE_APPEND);
} else {
echo $output;
}
}
/**
* Helper method, use PSR-3 warning function for deprecation warnings
* @see http://www.php-fig.org/psr/psr-3/
*/
public static function deprecated($method, $new)
{
return sprintf('The %s method is deprecated, please use %s instead', $method, $new);
}
}