class LoggerDataCollector in Zircon Profile 8

LogDataCollector.

@author Fabien Potencier <[e-mail]>

Hierarchy

• class \Symfony\Component\HttpKernel\DataCollector\DataCollector implements \Symfony\Component\HttpKernel\DataCollector\Serializable, DataCollectorInterface
  • class \Symfony\Component\HttpKernel\DataCollector\LoggerDataCollector implements LateDataCollectorInterface

1 file declares its use of LoggerDataCollector

LoggerDataCollectorTest.php in vendor/symfony/http-kernel/Tests/DataCollector/LoggerDataCollectorTest.php

File

vendor/symfony/http-kernel/DataCollector/LoggerDataCollector.php, line 23

Namespace

Symfony\Component\HttpKernel\DataCollector

class LoggerDataCollector extends DataCollector implements LateDataCollectorInterface {
  private $logger;
  public function __construct($logger = null) {
    if (null !== $logger && $logger instanceof DebugLoggerInterface) {
      $this->logger = $logger;
    }
  }

  /**
   * {@inheritdoc}
   */
  public function collect(Request $request, Response $response, \Exception $exception = null) {

    // everything is done as late as possible
  }

  /**
   * {@inheritdoc}
   */
  public function lateCollect() {
    if (null !== $this->logger) {
      $this->data = $this
        ->computeErrorsCount();
      $this->data['logs'] = $this
        ->sanitizeLogs($this->logger
        ->getLogs());
    }
  }

  /**
   * Gets the called events.
   *
   * @return array An array of called events
   *
   * @see TraceableEventDispatcherInterface
   */
  public function countErrors() {
    return isset($this->data['error_count']) ? $this->data['error_count'] : 0;
  }

  /**
   * Gets the logs.
   *
   * @return array An array of logs
   */
  public function getLogs() {
    return isset($this->data['logs']) ? $this->data['logs'] : array();
  }
  public function getPriorities() {
    return isset($this->data['priorities']) ? $this->data['priorities'] : array();
  }
  public function countDeprecations() {
    return isset($this->data['deprecation_count']) ? $this->data['deprecation_count'] : 0;
  }
  public function countScreams() {
    return isset($this->data['scream_count']) ? $this->data['scream_count'] : 0;
  }

  /**
   * {@inheritdoc}
   */
  public function getName() {
    return 'logger';
  }
  private function sanitizeLogs($logs) {
    $errorContextById = array();
    $sanitizedLogs = array();
    foreach ($logs as $log) {
      $context = $this
        ->sanitizeContext($log['context']);
      if (isset($context['type'], $context['file'], $context['line'], $context['level'])) {
        $errorId = md5("{$context['type']}/{$context['line']}/{$context['file']}\0{$log['message']}", true);
        $silenced = !($context['type'] & $context['level']);
        if (isset($errorContextById[$errorId])) {
          if (isset($errorContextById[$errorId]['errorCount'])) {
            ++$errorContextById[$errorId]['errorCount'];
          }
          else {
            $errorContextById[$errorId]['errorCount'] = 2;
          }
          if (!$silenced && isset($errorContextById[$errorId]['scream'])) {
            unset($errorContextById[$errorId]['scream']);
            $errorContextById[$errorId]['level'] = $context['level'];
          }
          continue;
        }
        $errorContextById[$errorId] =& $context;
        if ($silenced) {
          $context['scream'] = true;
        }
        $log['context'] =& $context;
        unset($context);
      }
      else {
        $log['context'] = $context;
      }
      $sanitizedLogs[] = $log;
    }
    return $sanitizedLogs;
  }
  private function sanitizeContext($context) {
    if (is_array($context)) {
      foreach ($context as $key => $value) {
        $context[$key] = $this
          ->sanitizeContext($value);
      }
      return $context;
    }
    if (is_resource($context)) {
      return sprintf('Resource(%s)', get_resource_type($context));
    }
    if (is_object($context)) {
      return sprintf('Object(%s)', get_class($context));
    }
    return $context;
  }
  private function computeErrorsCount() {
    $count = array(
      'error_count' => $this->logger
        ->countErrors(),
      'deprecation_count' => 0,
      'scream_count' => 0,
      'priorities' => array(),
    );
    foreach ($this->logger
      ->getLogs() as $log) {
      if (isset($count['priorities'][$log['priority']])) {
        ++$count['priorities'][$log['priority']]['count'];
      }
      else {
        $count['priorities'][$log['priority']] = array(
          'count' => 1,
          'name' => $log['priorityName'],
        );
      }
      if (isset($log['context']['type'], $log['context']['level'])) {
        if (E_DEPRECATED === $log['context']['type'] || E_USER_DEPRECATED === $log['context']['type']) {
          ++$count['deprecation_count'];
        }
        elseif (!($log['context']['type'] & $log['context']['level'])) {
          ++$count['scream_count'];
        }
      }
    }
    ksort($count['priorities']);
    return $count;
  }

}

Members

Name	Modifiers	Type	Description	Overrides
DataCollector::$data	protected	property
DataCollector::$valueExporter	private	property
DataCollector::serialize	public	function		1
DataCollector::unserialize	public	function		1
DataCollector::varToString	protected	function	Converts a PHP variable to a string.
LoggerDataCollector::$logger	private	property
LoggerDataCollector::collect	public	function	Collects data for the given Request and Response. Overrides DataCollectorInterface::collect
LoggerDataCollector::computeErrorsCount	private	function
LoggerDataCollector::countDeprecations	public	function
LoggerDataCollector::countErrors	public	function	Gets the called events.
LoggerDataCollector::countScreams	public	function
LoggerDataCollector::getLogs	public	function	Gets the logs.
LoggerDataCollector::getName	public	function	Returns the name of the collector. Overrides DataCollectorInterface::getName
LoggerDataCollector::getPriorities	public	function
LoggerDataCollector::lateCollect	public	function	Collects data as late as possible. Overrides LateDataCollectorInterface::lateCollect
LoggerDataCollector::sanitizeContext	private	function
LoggerDataCollector::sanitizeLogs	private	function
LoggerDataCollector::__construct	public	function