PhpTek\Sentry\Log\SentryLogger

Complexity

Total Complexity

37

Size/Duplication

Total Lines	307
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	6

Importance

Changes

0

14 Methods

Rating	Name	Duplication	Size	Complexity
A	defaultEnv()	0	4	1
A	defaultTags()	0	9	1
A	defaultExtra()	0	6	1
A	getPackageInfo()	0	18	5
A	getRequestType()	0	7	3
A	getPeakMemory()	0	6	1
A	getUserAgent()	0	10	2
A	getReqMethod()	0	10	2
A	getSAPI()	0	4	1
A	getAdaptor()	0	4	1
A	factory()	0	26	3
A	backtrace()	0	35	3
B	get_ip()	0	35	8
A	user_data()	0	12	5

<?php

/**
 * Class: SentryLogger.
 *
 * @author  Russell Michell 2017-2019 <russ@theruss.com>
 * @package phptek/sentry
 */

namespace PhpTek\Sentry\Log;

use SilverStripe\Control\Director;
use SilverStripe\Control\Middleware\TrustedProxyMiddleware;
use SilverStripe\Core\Injector\Injector;
use SilverStripe\Dev\Backtrace;
use SilverStripe\Security\Member;
use SilverStripe\Security\Security;
use SilverStripe\Core\Config\Configurable;
use PhpTek\Sentry\Adaptor\SentryAdaptor;

/**
 * The SentryLogWriter class is a bridge between {@link SentryAdaptor} and
 * SilverStripe's use of Monolog.
 */
class SentryLogger
{
    use Configurable;

    /**
     * @var SentryAdaptor
     */
    public $adaptor = null;

    /**
     * Stipulates what gets shown in the Sentry UI, should some metric not be
     * available for any reason.
     *
     * @const string
     */
    const SLW_NOOP = 'Unavailable';

    /**
     * A static constructor as per {@link Zend_Log_FactoryInterface}.
     *
     * @param  array $config    An array of optional additional configuration for
     *                          passing custom information to Sentry. See the README
     *                          for more detail.
     * @return SentryLogger
     */
    public static function factory(array $config = []) : SentryLogger
    {
        $env = $config['env'] ?? [];
        $user = $config['user'] ?? [];
        $tags = $config['tags'] ?? [];
        $extra = $config['extra'] ?? [];
        $level = $config['level'] ?? [];
        $logger = Injector::inst()->create(static::class);

        // Set default environment
        $env = $env ?: $logger->defaultEnv();
        // Set any available user data
        $user = $user ?: [];
        // Set any available tags available in SS config
        $tags = array_merge($logger->defaultTags(), $tags);
        // Set any available additional (extra) data
        $extra = array_merge($logger->defaultExtra(), $extra);

        $logger->adaptor->setContext('env', $env);
        $logger->adaptor->setContext('tags', $tags);
        $logger->adaptor->setContext('extra', $extra);
        $logger->adaptor->setContext('user', $user);
        $logger->adaptor->setContext('level', $level);

        return $logger;
    }

    /**
     * @return SentryAdaptor
     */
    public function getAdaptor() : SentryAdaptor
    {
        return $this->adaptor;
    }

    /**
     * Returns a default environment when one isn't passed to the factory()
     * method.
     *
     * @return string
     */
    public function defaultEnv() : string
    {
        return Director::get_environment_type();
    }

    /**
     * Returns a default set of additional "tags" we wish to send to Sentry.
     * By default, Sentry reports on several mertrics, and we're already sending
     * {@link Member} data. But there are additional data that would be useful
     * for debugging via the Sentry UI.
     *
     * These data can augment that which is sent to Sentry at setup
     * time in _config.php. See the README for more detail.
     *
     * N.b. Tags can be used to group messages within the Sentry UI itself, so there
     * should only be "static" data being sent, not something that can drastically
     * or minutely change, such as memory usage for example.
     *
     * @return array
     */
    public function defaultTags() : array
    {
        return [
            'Request-Method'=> $this->getReqMethod(),
            'Request-Type'  => $this->getRequestType(),
            'SAPI'          => $this->getSAPI(),
            'SS-Version'    => $this->getPackageInfo('silverstripe/framework')
        ];
    }

    /**
     * Returns a default set of extra data to show upon selecting a message for
     * analysis in the Sentry UI. This can augment the data sent to Sentry at setup
     * time in _config.php as well as at runtime when calling SS_Log itself.
     * See the README for more detail.
     *
     * @return array
     */
    public function defaultExtra() : array
    {
        return [
            'Peak-Memory'   => $this->getPeakMemory()
        ];
    }

    /**
     * Return the version of $pkg taken from composer.lock.
     *
     * @param  string $pkg e.g. "silverstripe/framework"
     * @return string
     */
    public function getPackageInfo(string $pkg) : string
    {
        $lockFileJSON = BASE_PATH . '/composer.lock';

        if (!file_exists($lockFileJSON) || !is_readable($lockFileJSON)) {
            return self::SLW_NOOP;
        }

        $lockFileData = json_decode(file_get_contents($lockFileJSON), true);

        foreach ($lockFileData['packages'] as $package) {
            if ($package['name'] === $pkg) {
                return $package['version'];
            }
        }

        return self::SLW_NOOP;
    }

    /**
     * What sort of request is this? (A harder question to answer than you might
     * think: http://stackoverflow.com/questions/6275363/what-is-the-correct-terminology-for-a-non-ajax-request)
     *
     * @return string
     */
    public function getRequestType() : string
    {
        $isCLI = $this->getSAPI() !== 'cli';
        $isAjax = Director::is_ajax();

        return $isCLI && $isAjax ? 'AJAX' : 'Non-Ajax';
    }

    /**
     * Return peak memory usage.
     *
     * @return string
     */
    public function getPeakMemory() : string
    {
        $peak = memory_get_peak_usage(true) / 1024 / 1024;

        return (string) round($peak, 2) . 'Mb';
    }

    /**
     * Basic User-Agent check and return.
     *
     * @return string
     */
    public function getUserAgent() : string
    {
        $ua = @$_SERVER['HTTP_USER_AGENT'];

        if (!empty($ua)) {
            return $ua;
        }

        return self::SLW_NOOP;
    }

    /**
     * Basic request method check and return.
     *
     * @return string
     */
    public function getReqMethod() : string
    {
        $method = @$_SERVER['REQUEST_METHOD'];

        if (!empty($method)) {
            return $method;
        }

        return self::SLW_NOOP;
    }

    /**
     * @return string
     */
    public function getSAPI() : string
    {
        return php_sapi_name();
    }

    /**
     * Returns the client IP address which originated this request.
     * Lifted and modified from SilverStripe 3's SS_HTTPRequest.
     *
     * @return string
     */
    public static function get_ip() : string
    {
        $headerOverrideIP = null;

        if (defined('TRUSTED_PROXY')) {
            $headers = (defined('SS_TRUSTED_PROXY_IP_HEADER')) ?
                [SS_TRUSTED_PROXY_IP_HEADER] :
                null;

            if (!$headers) {
                // Backwards compatible defaults
                $headers = ['HTTP_CLIENT_IP', 'HTTP_X_FORWARDED_FOR'];
            }

            foreach ($headers as $header) {
                if (!empty($_SERVER[$header])) {
                    $headerOverrideIP = $_SERVER[$header];

                    break;
                }
            }
        }

        $proxy = Injector::inst()->create(TrustedProxyMiddleware::class);

        if ($headerOverrideIP) {
            return $proxy->getIPFromHeaderValue($headerOverrideIP);
        }

        if (isset($_SERVER['REMOTE_ADDR'])) {
            return $_SERVER['REMOTE_ADDR'];
        }

        return '';
    }

    /**
     * Returns a default set of additional data specific to the user's part in
     * the request.
     *
     * @param  mixed Member|null $member
     * @return array
     */
    public static function user_data(Member $member = null) : array
    {
        if (!$member) {
            $member = Security::getCurrentUser();
        }

        return [
            'IPAddress' => self::get_ip() ?: self::SLW_NOOP,
            'ID'       => $member ? $member->getField('ID') : self::SLW_NOOP,
            'Email'    => $member ? $member->getField('Email') : self::SLW_NOOP,
        ];
    }

    /**
     * Manually extract or generate a suitable backtrace. This is especially useful
     * in non-exception reports such as those that use Sentry\Client::captureMessage().
     *
     * @param  array $record
     * @return array
     */
    public static function backtrace(array $record) : array
    {
        if (!empty($record['context']['trace'])) {
            // Provided trace
            $bt = $record['context']['trace'];
        } elseif (isset($record['context']['exception'])) {
            // Generate trace from exception
            $bt = $record['context']['exception']->getTrace();
        } else {
            // Failover: build custom trace
            $bt = debug_backtrace();

            // Push current line into context
            array_unshift($bt, [
                'file'     => $bt['file'] ?? 'N/A',
                'line'     => $bt['line'] ?? 'N/A',
                'function' => '',
                'class'    => '',
                'type'     => '',
                'args'     => [],
            ]);
        }

        // Regardless of where it came from, filter the exception
        return Backtrace::filter_backtrace($bt, [
            '',
            'Monolog\\Handler\\AbstractProcessingHandler->handle',
            'Monolog\\Logger->addRecord',
            'Monolog\\Logger->error',
            'Monolog\\Logger->log',
            'Monolog\\Logger->warn',
            'PhpTek\\Sentry\\Handler\\SentryHandler->write',
            'PhpTek\\Sentry\\Handler\\SentryHandler->backtrace',
        ]);
    }
}