EasyTaxi\NewRelic\Transaction

Complexity

Total Complexity

18

Size/Duplication

Total Lines	87
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	5

Test Coverage

Coverage

89.13%

Importance

Changes

0

8 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	14	3
A	setFormatter()	0	4	1
A	transactionStart()	0	12	2
A	shouldBeMonitored()	0	4	2
A	transactionEnd()	0	8	2
A	transactionFail()	0	8	2
A	__call()	0	13	2
A	addNewRelicParameter()	0	10	4

<?php

namespace EasyTaxi\NewRelic;

use EasyTaxi\NewRelic\Config\TransactionConfig;
use EasyTaxi\NewRelic\Exception\InvalidCallerInstanceException;
use EasyTaxi\NewRelic\Exception\NotLoadedNewRelicExtensionException;
use EasyTaxi\NewRelic\Formatter\ArgumentsFormatter;
use EasyTaxi\NewRelic\Formatter\FormatterInterface;

class Transaction
{
    private $instance;
    private $config;
    private $formatter;

    public function __construct($instance, TransactionConfig $config)
    {
        if (!is_object($instance)) {
            throw new InvalidCallerInstanceException();
        }

        $this->instance = $instance;
        $this->config = $config;
        $this->formatter = new ArgumentsFormatter();

        if (!extension_loaded('newrelic')) {
            throw new NotLoadedNewRelicExtensionException();
        }
    }

    public function setFormatter(FormatterInterface $formatter)
    {
        $this->formatter = $formatter;
    }

    public function __call($name, $arguments)
    {
        $this->transactionStart($name, $arguments);

        try {
            return call_user_func_array([$this->instance, $name], $arguments);
        } catch (\Exception $genericException) {
            $this->transactionFail($name, $genericException);
            throw $genericException;
        } finally {
            $this->transactionEnd($name);
        }
    }

    private function addNewRelicParameter($customParameters)
    {
        foreach ($customParameters as $key => $value) {
            if (null === $value || is_scalar($value)) {
                newrelic_add_custom_parameter($key, $value);
            } else {
                newrelic_add_custom_parameter($key, @json_encode($value));
            }
        }
    }

    private function transactionStart($name, $arguments)
    {
        if (!$this->shouldBeMonitored($name)) {
            return;
        }

        newrelic_set_appname($this->config->applicationName);
        newrelic_start_transaction($this->config->applicationName);
        newrelic_name_transaction($this->config->transactionName);
        $customParameters = $this->formatter->format($arguments);
        $this->addNewRelicParameter($customParameters);
    }

    private function shouldBeMonitored($name)
    {
        return !$this->config->monitoredMethodName || $name == $this->config->monitoredMethodName;
    }

    private function transactionEnd($name)
    {
        if (!$this->shouldBeMonitored($name)) {
            return;
        }

        newrelic_end_transaction();
    }

    private function transactionFail($name, \Exception $genericException)
    {
        if (!$this->shouldBeMonitored($name)) {
            return;
        }

        newrelic_notice_error($genericException->getMessage(), $genericException);
    }
}