EkinoNewRelicExtension::load() - Code Metrics - Inspection of "Fix memory leak (#191)" - ekino/EkinoNewRelicBundle - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( bf6a9d...dfd885 )

by Tobias

created 2018-06-24 16:44 UTC

EkinoNewRelicExtension::load() F

↳ Parent: EkinoNewRelicExtension

Complexity

Conditions	12
Paths	384

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	12
nc	384
nop	2
dl	0
loc	96
rs	3.1539
c	0
b	0
f	0

How to fix Long Method Complexity

<?php

declare(strict_types=1);

/*
 * This file is part of Ekino New Relic bundle.
 *
 * (c) Ekino - Thomas Rabaix <[email protected]>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace  Ekino\NewRelicBundle\DependencyInjection;

use Ekino\NewRelicBundle\Listener\CommandListener;
use Ekino\NewRelicBundle\Listener\RequestListener;
use Ekino\NewRelicBundle\Listener\ResponseListener;
use Ekino\NewRelicBundle\NewRelic\AdaptiveInteractor;
use Ekino\NewRelicBundle\NewRelic\BlackholeInteractor;
use Ekino\NewRelicBundle\NewRelic\Config;
use Ekino\NewRelicBundle\NewRelic\LoggingInteractorDecorator;
use Ekino\NewRelicBundle\NewRelic\NewRelicInteractor;
use Ekino\NewRelicBundle\NewRelic\NewRelicInteractorInterface;
use Ekino\NewRelicBundle\TransactionNamingStrategy\ControllerNamingStrategy;
use Ekino\NewRelicBundle\TransactionNamingStrategy\RouteNamingStrategy;
use Ekino\NewRelicBundle\TransactionNamingStrategy\TransactionNamingStrategyInterface;
use Symfony\Component\Config\FileLocator;
use Symfony\Component\DependencyInjection\ContainerBuilder;
use Symfony\Component\DependencyInjection\ContainerInterface;
use Symfony\Component\DependencyInjection\Loader;
use Symfony\Component\DependencyInjection\Reference;
use Symfony\Component\HttpKernel\DependencyInjection\Extension;

/**
 * This is the class that loads and manages your bundle configuration.
 *
 * To learn more see {@link http://symfony.com/doc/current/cookbook/bundles/extension.html}
 */
class EkinoNewRelicExtension extends Extension
{
    public function load(array $configs, ContainerBuilder $container): void
    {
        $configuration = new Configuration();
        $config = $this->processConfiguration($configuration, $configs);

        $loader = new Loader\XmlFileLoader($container, new FileLocator(__DIR__.'/../Resources/config'));
        $loader->load('services.xml');

        $container->setAlias(NewRelicInteractorInterface::class, $this->getInteractorServiceId($config))->setPublic(false);
        $container->setAlias(TransactionNamingStrategyInterface::class, $this->getTransactionNamingServiceId($config))->setPublic(false);

        if ($config['logging']) {
            $container->register(LoggingInteractorDecorator::class)
                ->setDecoratedService(NewRelicInteractorInterface::class)
                ->setArguments(
                    [
                        '$interactor' => new Reference(LoggingInteractorDecorator::class.'.inner'),
                        '$logger' => new Reference('logger', ContainerInterface::NULL_ON_INVALID_REFERENCE),
                    ]
                )
                ->setPublic(false)
            ;
        }

        if (empty($config['deployment_names'])) {
            $config['deployment_names'] = \array_values(\array_filter(\explode(';', $config['application_name'] ?? '')));
        }

        $container->getDefinition(Config::class)
            ->setArguments(
                [
                    '$name' => $config['application_name'],
                    '$apiKey' => $config['api_key'],
                    '$licenseKey' => $config['license_key'],
                    '$xmit' => $config['xmit'],
                    '$deploymentNames' => $config['deployment_names'],
                ]
            );

        if ($config['http']['enabled']) {
            $loader->load('http_listener.xml');
            $container->getDefinition(RequestListener::class)
                ->setArguments(
                    [
                        '$ignoreRoutes' => $config['http']['ignored_routes'],
                        '$ignoredPaths' => $config['http']['ignored_paths'],
                        '$symfonyCache' => $config['http']['using_symfony_cache'],
                    ]
                );

            $container->getDefinition(ResponseListener::class)
                ->setArguments(
                    [
                        '$instrument' => $config['instrument'],
                        '$symfonyCache' => $config['http']['using_symfony_cache'],
                    ]
                );
        }

        if ($config['commands']['enabled']) {
            $loader->load('command_listener.xml');
            $container->getDefinition(CommandListener::class)
                ->setArguments(
                    [
                        '$ignoredCommands' => $config['commands']['ignored_commands'],
                    ]
                );
        }

        if ($config['exceptions']['enabled']) {
            $loader->load('exception_listener.xml');
        }

        if ($config['deprecations']['enabled']) {
            $loader->load('deprecation_listener.xml');
        }

        if ($config['twig']) {
            $loader->load('twig.xml');
        }

        if ($config['enabled'] && $config['monolog']['enabled']) {
            if (!\class_exists(\Monolog\Handler\NewRelicHandler::class)) {
                throw new \LogicException('The "symfony/monolog-bundle" package must be installed in order to use "monolog" option.');
            }
            $loader->load('monolog.xml');
            $container->setParameter('ekino.new_relic.monolog.channels', $config['monolog']['channels'] ?? null);
            $container->setAlias('ekino.new_relic.logs_handler', $config['monolog']['service'])->setPublic(false);

            $level = $config['monolog']['level'];
            // This service is used by MonologHandlerPass to inject into Monolog Service
            $container->findDefinition('ekino.new_relic.logs_handler')
                ->setArguments(
                    [
                        '$level' => \is_int($level) ? $level : \constant('Monolog\Logger::'.\strtoupper($level)),
                        '$appName' => $config['application_name'],
                    ]
                );
        }
    }

    private function getInteractorServiceId(array $config): string
    {
        if (!$config['enabled']) {
            return BlackholeInteractor::class;
        }

        if (!isset($config['interactor'])) {
            // Fallback on AdaptiveInteractor.
            return AdaptiveInteractor::class;
        }

        if ('auto' === $config['interactor']) {
            // Check if the extension is loaded or not
            return \extension_loaded('newrelic') ? NewRelicInteractor::class : BlackholeInteractor::class;
        }

        return $config['interactor'];
    }

    private function getTransactionNamingServiceId(array $config): string
    {
        switch ($config['http']['transaction_naming']) {
            case 'controller':
                return ControllerNamingStrategy::class;
            case 'route':
                return RouteNamingStrategy::class;
            case 'service':
                if (!isset($config['http']['transaction_naming_service'])) {
                    throw new \LogicException(
                        'When using the "service", transaction naming scheme, the "transaction_naming_service" config parameter must be set.'
                    );
                }

                return $config['http']['transaction_naming_service'];
            default:
                throw new \InvalidArgumentException(
                    \sprintf(
                        'Invalid transaction naming scheme "%s", must be "route", "controller" or "service".',
                        $config['http']['transaction_naming']
                    )
                );
        }
    }
}


1			<?php
2
3			declare(strict_types=1);
4
5			/*
6			* This file is part of Ekino New Relic bundle.
7			*
8			* (c) Ekino - Thomas Rabaix <[email protected]>
9			*
10			* For the full copyright and license information, please view the LICENSE
11			* file that was distributed with this source code.
12			*/
13
14			namespace Ekino\NewRelicBundle\DependencyInjection;
15
16			use Ekino\NewRelicBundle\Listener\CommandListener;
17			use Ekino\NewRelicBundle\Listener\RequestListener;
18			use Ekino\NewRelicBundle\Listener\ResponseListener;
19			use Ekino\NewRelicBundle\NewRelic\AdaptiveInteractor;
20			use Ekino\NewRelicBundle\NewRelic\BlackholeInteractor;
21			use Ekino\NewRelicBundle\NewRelic\Config;
22			use Ekino\NewRelicBundle\NewRelic\LoggingInteractorDecorator;
23			use Ekino\NewRelicBundle\NewRelic\NewRelicInteractor;
24			use Ekino\NewRelicBundle\NewRelic\NewRelicInteractorInterface;
25			use Ekino\NewRelicBundle\TransactionNamingStrategy\ControllerNamingStrategy;
26			use Ekino\NewRelicBundle\TransactionNamingStrategy\RouteNamingStrategy;
27			use Ekino\NewRelicBundle\TransactionNamingStrategy\TransactionNamingStrategyInterface;
28			use Symfony\Component\Config\FileLocator;
29			use Symfony\Component\DependencyInjection\ContainerBuilder;
30			use Symfony\Component\DependencyInjection\ContainerInterface;
31			use Symfony\Component\DependencyInjection\Loader;
32			use Symfony\Component\DependencyInjection\Reference;
33			use Symfony\Component\HttpKernel\DependencyInjection\Extension;
34
35			/**
36			* This is the class that loads and manages your bundle configuration.
37			*
38			* To learn more see {@link http://symfony.com/doc/current/cookbook/bundles/extension.html}
39			*/
40			class EkinoNewRelicExtension extends Extension
41			{
42			public function load(array $configs, ContainerBuilder $container): void
43			{
44			$configuration = new Configuration();
45			$config = $this->processConfiguration($configuration, $configs);
46
47			$loader = new Loader\XmlFileLoader($container, new FileLocator(__DIR__.'/../Resources/config'));
48			$loader->load('services.xml');
49
50			$container->setAlias(NewRelicInteractorInterface::class, $this->getInteractorServiceId($config))->setPublic(false);
51			$container->setAlias(TransactionNamingStrategyInterface::class, $this->getTransactionNamingServiceId($config))->setPublic(false);
52
53			if ($config['logging']) {
54			$container->register(LoggingInteractorDecorator::class)
55			->setDecoratedService(NewRelicInteractorInterface::class)
56			->setArguments(
57			[
58			'$interactor' => new Reference(LoggingInteractorDecorator::class.'.inner'),
59			'$logger' => new Reference('logger', ContainerInterface::NULL_ON_INVALID_REFERENCE),
60			]
61			)
62			->setPublic(false)
63			;
64			}
65
66			if (empty($config['deployment_names'])) {
67			$config['deployment_names'] = \array_values(\array_filter(\explode(';', $config['application_name'] ?? '')));
68			}
69
70			$container->getDefinition(Config::class)
71			->setArguments(
72			[
73			'$name' => $config['application_name'],
74			'$apiKey' => $config['api_key'],
75			'$licenseKey' => $config['license_key'],
76			'$xmit' => $config['xmit'],
77			'$deploymentNames' => $config['deployment_names'],
78			]
79			);
80
81			if ($config['http']['enabled']) {
82			$loader->load('http_listener.xml');
83			$container->getDefinition(RequestListener::class)
84			->setArguments(
85			[
86			'$ignoreRoutes' => $config['http']['ignored_routes'],
87			'$ignoredPaths' => $config['http']['ignored_paths'],
88			'$symfonyCache' => $config['http']['using_symfony_cache'],
89			]
90			);
91
92			$container->getDefinition(ResponseListener::class)
93			->setArguments(
94			[
95			'$instrument' => $config['instrument'],
96			'$symfonyCache' => $config['http']['using_symfony_cache'],
97			]
98			);
99			}
100
101			if ($config['commands']['enabled']) {
102			$loader->load('command_listener.xml');
103			$container->getDefinition(CommandListener::class)
104			->setArguments(
105			[
106			'$ignoredCommands' => $config['commands']['ignored_commands'],
107			]
108			);
109			}
110
111			if ($config['exceptions']['enabled']) {
112			$loader->load('exception_listener.xml');
113			}
114
115			if ($config['deprecations']['enabled']) {
116			$loader->load('deprecation_listener.xml');
117			}
118
119			if ($config['twig']) {
120			$loader->load('twig.xml');
121			}
122
123			if ($config['enabled'] && $config['monolog']['enabled']) {
124			if (!\class_exists(\Monolog\Handler\NewRelicHandler::class)) {
125			throw new \LogicException('The "symfony/monolog-bundle" package must be installed in order to use "monolog" option.');
126			}
127			$loader->load('monolog.xml');
128			$container->setParameter('ekino.new_relic.monolog.channels', $config['monolog']['channels'] ?? null);
129			$container->setAlias('ekino.new_relic.logs_handler', $config['monolog']['service'])->setPublic(false);
130
131			$level = $config['monolog']['level'];
132			// This service is used by MonologHandlerPass to inject into Monolog Service
133			$container->findDefinition('ekino.new_relic.logs_handler')
134			->setArguments(
135			[
136			'$level' => \is_int($level) ? $level : \constant('Monolog\Logger::'.\strtoupper($level)),
137			'$appName' => $config['application_name'],
138			]
139			);
140			}
141			}
142
143			private function getInteractorServiceId(array $config): string
144			{
145			if (!$config['enabled']) {
146			return BlackholeInteractor::class;
147			}
148
149			if (!isset($config['interactor'])) {
150			// Fallback on AdaptiveInteractor.
151			return AdaptiveInteractor::class;
152			}
153
154			if ('auto' === $config['interactor']) {
155			// Check if the extension is loaded or not
156			return \extension_loaded('newrelic') ? NewRelicInteractor::class : BlackholeInteractor::class;
157			}
158
159			return $config['interactor'];
160			}
161
162			private function getTransactionNamingServiceId(array $config): string
163			{
164			switch ($config['http']['transaction_naming']) {
165			case 'controller':
166			return ControllerNamingStrategy::class;
167			case 'route':
168			return RouteNamingStrategy::class;
169			case 'service':
170			if (!isset($config['http']['transaction_naming_service'])) {
171			throw new \LogicException(
172			'When using the "service", transaction naming scheme, the "transaction_naming_service" config parameter must be set.'
173			);
174			}
175
176			return $config['http']['transaction_naming_service'];
177			default:
178			throw new \InvalidArgumentException(
179			\sprintf(
180			'Invalid transaction naming scheme "%s", must be "route", "controller" or "service".',
181			$config['http']['transaction_naming']
182			)
183			);
184			}
185			}
186			}
187

ekino / EkinoNewRelicBundle

Push — master ( bf6a9d...dfd885 )

EkinoNewRelicExtension::load() F

Complexity

Size

Duplication

Importance

How to fix Long Method Complexity

Long Method

Duplication Side-by-Side

Filter issues like