Facile\SentryModule\Log\Writer\Sentry

Complexity

Total Complexity

33

Size/Duplication

Total Lines	211
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	4

Test Coverage

Coverage

88.17%

Importance

Changes

0

7 Methods

Rating	Name	Duplication	Size	Complexity
B	__construct()	0	24	6
C	doWrite()	0	47	9
C	cleanBacktrace()	0	30	7
A	sanitizeContextData()	0	6	1
B	sanitizeContextItem()	0	16	6
A	objectIsThrowable()	0	4	2
A	contextContainsException()	0	8	2

<?php

namespace Facile\SentryModule\Log\Writer;

use Facile\SentryModule\Service\Client;
use Traversable;
use Zend\Log\Writer\AbstractWriter;
use Zend\Log\Logger;
use Raven_Client;

/**
 * Class Sentry.
 */
class Sentry extends AbstractWriter
{
    /**
     * @var Client
     */
    protected $client;

    /**
     * @var array
     */
    protected $priorityMap = [
        Logger::EMERG => Raven_Client::FATAL,
        Logger::ALERT => Raven_Client::ERROR,
        Logger::CRIT => Raven_Client::ERROR,
        Logger::ERR => Raven_Client::ERROR,
        Logger::WARN => Raven_Client::WARNING,
        Logger::NOTICE => Raven_Client::INFO,
        Logger::INFO => Raven_Client::INFO,
        Logger::DEBUG => Raven_Client::DEBUG,
    ];

    /**
     * @var array
     */
    protected $excludedBacktraceNamespaces = [
        'Facile\\SentryModule\\Log\\',
        'Psr\\Log\\',
        'Zend\\Log\\',
        'Monolog\\',
    ];

    /**
     * Sentry constructor.
     *
     * @param array $options
     *
     * @throws \RuntimeException
     * @throws \Zend\Log\Exception\InvalidArgumentException
     */
    public function __construct(array $options = null)
    {
        parent::__construct($options);

        if ($options instanceof Traversable) {
            $options = iterator_to_array($options);
        }

        if (!is_array($options) || !array_key_exists('client', $options)) {
            throw new \RuntimeException('No client specified in options');
        }

        if (
            array_key_exists('excluded_backtrace_namespaces', $options) &&
            is_array($options['excluded_backtrace_namespaces'])
        ) {
            $this->excludedBacktraceNamespaces = array_merge(
                $this->excludedBacktraceNamespaces,
                $options['excluded_backtrace_namespaces']
            );
        }

        $this->client = $options['client'];
    }

    /**
     * Write a message to the log.
     *
     * @param array $event log data event
     */
    protected function doWrite(array $event)
    {
        $priority = $this->priorityMap[$event['priority']];

        $extra = $event['extra'];
        if ($extra instanceof Traversable) {
            $extra = iterator_to_array($extra);
        } elseif (!is_array($extra)) {
            $extra = [];
        }

        if ($this->contextContainsException($extra)) {
            /** @var \Throwable $exception */
            $exception = $extra['exception'];
            unset($extra['exception']);

            if ($event['message'] !== $exception->getMessage()) {
                $exception = new ContextException($event['message'], $exception->getCode(), $exception);
            }

            $this->client->getRaven()->captureException(
                $exception,
                [
                    'extra' => $this->sanitizeContextData($extra),
                    'level' => $priority,
                ]
            );

            return;
        }

        $stack = isset($extra['stack']) && is_array($extra['stack']) ? $extra['stack'] : null;

        if (!$stack) {
            $stack = $this->cleanBacktrace(debug_backtrace());
            if (!count($stack)) {
                $stack = false;
            }
        }

        $this->client->getRaven()->captureMessage(
            $event['message'],
            $this->sanitizeContextData($extra),
            $priority,
            $stack

It seems like $stack can also be of type array; however, Raven_Client::captureMessage() does only seem to accept boolean, maybe add an additional type check?

        );
    }

    /**
     * Remove first backtrace items until it founds something different from loggers.
     *
     * @param array $backtrace
     *
     * @return array
     */
    protected function cleanBacktrace(array $backtrace)
    {
        $excludeNamespaces = $this->excludedBacktraceNamespaces;

        $lastItem = null;
        while (count($backtrace)) {
            $item = $backtrace[0];
            if (!array_key_exists('class', $item)) {
                break;
            }
            $exclude = false;
            foreach ($excludeNamespaces as $namespace) {
                if (0 === strpos($item['class'], $namespace)) {
                    $exclude = true;
                    break;
                }
            }
            if (!$exclude) {
                break;
            }

            $lastItem = array_shift($backtrace);
        }

        if ($lastItem) {
            array_unshift($backtrace, $lastItem);
        }

        return $backtrace;
    }

    /**
     * @param array $context
     *
     * @return array
     */
    protected function sanitizeContextData(array $context)
    {
        array_walk_recursive($context, [$this, 'sanitizeContextItem']);

        return $context;
    }

    /**
     * @param mixed $value
     */
    protected function sanitizeContextItem(&$value)
    {
        if ($value instanceof Traversable) {
            $value = iterator_to_array($value);
        }

        if (is_array($value)) {
            $value = $this->sanitizeContextData($value);
        }

        if (is_object($value)) {
            $value = method_exists($value, '__toString') ? (string) $value : get_class($value);
        } elseif (is_resource($value)) {
            $value = get_resource_type($value);
        }
    }

    /**
     * @param mixed $object
     *
     * @return bool
     */
    protected function objectIsThrowable($object)
    {
        return $object instanceof \Throwable || $object instanceof \Exception;
    }

    /**
     * @param array $context
     *
     * @return bool
     */
    protected function contextContainsException(array $context)
    {
        if (!array_key_exists('exception', $context)) {
            return false;
        }

        return $this->objectIsThrowable($context['exception']);
    }
}