asminog\yii2sentry\SentryTarget

Complexity

Total Complexity

32

Size/Duplication

Total Lines	238
Duplicated Lines	0 %

Importance

Changes	5
Bugs	3	Features	0

12 Methods

Rating	Name	Duplication	Size	Complexity
A	convertLevel()	0	3	2
A	setScopeExtras()	0	4	1
B	setScopeUser()	0	12	7
A	clearScope()	0	4	1
A	export()	0	20	3
A	setExtraContext()	0	8	2
A	setScopeTags()	0	4	1
A	runExtraCallback()	0	11	4
A	setScopeLevel()	0	6	1
A	getRelease()	0	3	1
B	convertMessage()	0	23	7
A	init()	0	15	2

<?php

namespace asminog\yii2sentry;

use Exception;
use Sentry\Severity;
use Sentry\State\Scope;
use Throwable;
use Yii;
use yii\base\InvalidConfigException;
use yii\helpers\ArrayHelper;
use yii\helpers\VarDumper;
use yii\log\Logger;
use yii\log\Target;
use function Sentry\captureException;
use function Sentry\captureMessage;
use function Sentry\configureScope;
use function Sentry\init;

/**
 * SentryTarget send logs to Sentry.
 *
 * @see https://sentry.io
 *
 * @property array $scopeExtras
 * @property int $scopeLevel
 * @property array $scopeTags
 * @property string $contextMessage
 */
class SentryTarget extends Target
{
    /**
     * @var string DNS for sentry.
     */
    public string $dsn;

    /**
     * @var string Release for sentry.
     */
    public string $release = 'auto';

    /**
     * @var array Options for sentry.
     */
    public array $options = [];

    /**
     * @var array UserIdentity attributes for user context.
     */
    public array $collectUserAttributes = ['id', 'username', 'email'];

    /**
     * @var array Allow to collect context automatically.
     */
    public array $collectContext = ['_SESSION', 'argv'];

    /**
     * @var callable Callback function that can modify extra's array
     */
    public $extraCallback;

    const SENTRY_LEVELS = [
        Logger::LEVEL_ERROR => Severity::ERROR,
        Logger::LEVEL_WARNING => Severity::WARNING,
        Logger::LEVEL_INFO => Severity::INFO,
        Logger::LEVEL_TRACE => Severity::DEBUG,
        Logger::LEVEL_PROFILE_BEGIN => Severity::DEBUG,
        Logger::LEVEL_PROFILE_END => Severity::DEBUG,
        Logger::LEVEL_PROFILE => Severity::DEBUG,
    ];


    /**
     * @inheritdoc
     */
    public function init()
    {
        $this->logVars = [];

        init(
            array_merge(
                $this->options,
                [
                    'dsn' => $this->dsn,
                    'release' => ($this->release == 'auto' ? $this->getRelease() : $this->release)
                ]
            )
        );

        parent::init();
    }

    /**
     * Get release based on git information
     * @return string
     */
    private function getRelease(): string
    {
        return trim(exec('test git --version 2>&1 >/dev/null && git log --pretty="%H" -n1 HEAD || echo "trunk"'));
    }

    /**
     * @inheritdoc
     * @throws InvalidConfigException
     */
    public function export()
    {
        foreach ($this->messages as $message) {
            [$message, $level, $category] = $message;

            $this->clearScope();
            $this->setScopeUser();
            $this->setExtraContext();
            $this->setScopeLevel($level);
            $this->setScopeTags(['category' => $category]);

            if ($message instanceof Throwable) {
                $this->setScopeExtras($this->runExtraCallback($message));
                captureException($message);
                continue;
            }

            $message = $this->convertMessage($message);

            captureMessage($message);
        }
    }

    /**
     * Set sentry level scope based on yii2 level message
     *
     * @param int $level
     */
    private function setScopeLevel(int $level)
    {
        $level = $this->convertLevel($level);

        configureScope(function (Scope $scope) use ($level) : void {
            $scope->setLevel($level);
        });
    }

    /**
     * Convert Logger level to Sentry level
     * @param int $level
     * @return Severity
     */
    private function convertLevel(int $level): Severity
    {
        return isset(self::SENTRY_LEVELS[$level]) ? new Severity(self::SENTRY_LEVELS[$level]) : Severity::fatal();
    }

    /**
     * Set sentry user scope based on yii2 Yii::$app->user
     * @throws InvalidConfigException
     * @throws Exception
     */
    private function setScopeUser()
    {
        if (session_status() === PHP_SESSION_ACTIVE and Yii::$app->get('user', false) !== null and Yii::$app->user->getId() and !empty($this->collectUserAttributes)) {

The method getId() does not exist on null.

            $attributes = ['id' => Yii::$app->user->getId()];
            if (($user = Yii::$app->user->identity) !== null) {
                foreach ($this->collectUserAttributes as $collectUserAttribute) {
                    $attributes[$collectUserAttribute] = ArrayHelper::getValue($user, $collectUserAttribute);
                }
            }

            configureScope(function (Scope $scope) use ($attributes): void {
                $scope->setUser($attributes);
            });
        }
    }

    /**
     * Set sentry scope tags
     *
     * @param array $tags
     */
    private function setScopeTags(array $tags)
    {
        configureScope(function (Scope $scope) use ($tags): void {
            $scope->setTags($tags);
        });
    }

    /**
     * Add extra context if needed
     */
    private function setExtraContext()
    {
        if (!empty($this->collectContext)) {
            $this->logVars = $this->collectContext;
            $extraContext = $this->getContextMessage();

            $this->setScopeExtras(['CONTEXT' => $extraContext]);
            $this->logVars = [];
        }
    }

    /**
     * Set sentry scope extras
     * @param array $extras
     */
    private function setScopeExtras(array $extras)
    {
        configureScope(function (Scope $scope) use ($extras): void {
            $scope->setExtras($extras);
        });
    }

    /**
     * Calls the extra user callback if it exists
     *
     * @param mixed $message log message from Logger::messages
     * @param array $extra
     * @return array
     */
    protected function runExtraCallback($message, array $extra = []): array
    {
        if ($this->extraCallback and is_callable($this->extraCallback)) {
            $extra = call_user_func($this->extraCallback, $message, $extra);
        }

        if (!is_array($extra)) {
            $extra = ['extra' => VarDumper::dumpAsString($extra)];
        }

        return $extra;
    }

    /**
     * Clear sentry scope for new message
     */
    private function clearScope()
    {
        configureScope(function (Scope $scope): void {
            $scope->clear();
        });
    }

    /**
     * @param $message
     * @return string
     */
    private function convertMessage($message): string
    {
        if (is_array($message)) {
            if (isset($message['tags'])) {
                $this->setScopeTags($message['tags']);
                unset($message['tags']);
            }

            if (isset($message['extra'])) {
                $this->setScopeExtras($this->runExtraCallback($message, $message['extra']));
                unset($message['extra']);
            }

            if (count($message) == 1 and isset($message['msg'])) {
                $message = $message['msg'];
            }
        }

        if (!is_string($message)) {
            $message = VarDumper::dumpAsString($message);
        }

        return $message;
    }
}