EightPointsGuzzleExtension::defineTwigDebugExtension() - Code Metrics - Inspection of "[Profiler] Add request profiling to performance me..." - 8p/EightPointsGuzzleBundle - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Pull Request — master (#216)

unknown

created 2018-10-04 20:02 UTC

defineTwigDebugExtension() A

↳ Parent: EightPointsGuzzleExtension

Complexity

Conditions	1
Paths	1

Size

Total Lines	6
Code Lines	4

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	1
eloc	4
nc	1
nop	1
dl	0
loc	6
rs	10
c	0
b	0
f	0

<?php

namespace EightPoints\Bundle\GuzzleBundle\DependencyInjection;

use EightPoints\Bundle\GuzzleBundle\Twig\Extension\DebugExtension;
use RuntimeException;
use Symfony\Component\DependencyInjection\ContainerBuilder;
use Symfony\Component\DependencyInjection\Loader\XmlFileLoader;
use Symfony\Component\DependencyInjection\Reference;
use Symfony\Component\DependencyInjection\Definition;
use Symfony\Component\Config\FileLocator;
use Symfony\Component\HttpKernel\DependencyInjection\Extension;
use Symfony\Component\ExpressionLanguage\Expression;
use GuzzleHttp\HandlerStack;

class EightPointsGuzzleExtension extends Extension
{
    /** @var \EightPoints\Bundle\GuzzleBundle\EightPointsGuzzleBundlePlugin[] */
    protected $plugins;

    /**
     * @param \EightPoints\Bundle\GuzzleBundle\EightPointsGuzzleBundlePlugin[] $plugins
     */
    public function __construct(array $plugins = [])
    {
        $this->plugins = $plugins;
    }

    /**
     * {@inheritdoc}
     */
    public function getConfiguration(array $config, ContainerBuilder $container) : Configuration
    {
        return new Configuration($this->getAlias(), $container->getParameter('kernel.debug'), $this->plugins);
    }

    /**
     * Loads the Guzzle configuration.
     *
     * @param array $configs an array of configuration settings
     * @param \Symfony\Component\DependencyInjection\ContainerBuilder $container a ContainerBuilder instance
     *
     * @throws \InvalidArgumentException
     * @throws \Symfony\Component\DependencyInjection\Exception\BadMethodCallException
     * @throws \Symfony\Component\DependencyInjection\Exception\InvalidArgumentException
     * @throws \Exception
     *
     * @return void
     */
    public function load(array $configs, ContainerBuilder $container)
    {
        $configPath = implode(DIRECTORY_SEPARATOR, [__DIR__, '..', 'Resources', 'config']);
        $loader     = new XmlFileLoader($container, new FileLocator($configPath));

        $loader->load('services.xml');

        $configuration = new Configuration($this->getAlias(), $container->getParameter('kernel.debug'), $this->plugins);
        $config        = $this->processConfiguration($configuration, $configs);
        $logging       = $config['logging'] === true;
        $profiling     = $config['profiling'] === true;

        foreach ($this->plugins as $plugin) {
            $container->addObjectResource(new \ReflectionClass(get_class($plugin)));
            $plugin->load($config, $container);
        }

        if ($logging) {
            $this->defineTwigDebugExtension($container);
            $this->defineLogger($container);
            $this->defineDataCollector($container);
            $this->defineFormatter($container);
            $this->defineSymfonyLogFormatter($container);
            $this->defineSymfonyLogMiddleware($container);
        }

        foreach ($config['clients'] as $name => $options) {
            $argument = [
                'base_uri' => $options['base_url'],
                'handler'  => $this->createHandler($container, $name, $options, $logging, $profiling)
            ];

            // if present, add default options to the constructor argument for the Guzzle client
            if (isset($options['options']) && is_array($options['options'])) {
                foreach ($options['options'] as $key => $value) {
                    if ($value === null || (is_array($value) && count($value) === 0)) {
                        continue;
                    }

                    $argument[$key] = $value;
                }
            }

            $client = new Definition($options['class']);
            $client->addArgument($argument);
            $client->setPublic(true);
            $client->setLazy($options['lazy']);

            // set service name based on client name
            $serviceName = sprintf('%s.client.%s', $this->getAlias(), $name);
            $container->setDefinition($serviceName, $client);
        }
    }

    /**
     * @param \Symfony\Component\DependencyInjection\ContainerBuilder $container
     * @param string $clientName
     * @param array $options
     * @param bool $logging
     *
     * @throws \Symfony\Component\DependencyInjection\Exception\BadMethodCallException
     * @throws \Symfony\Component\DependencyInjection\Exception\InvalidArgumentException
     *
     * @return \Symfony\Component\DependencyInjection\Definition
     */
    protected function createHandler(ContainerBuilder $container, string $clientName, array $options, bool $logging, bool $profiling) : Definition
    {
        // Event Dispatching service
        $eventServiceName = sprintf('eight_points_guzzle.middleware.event_dispatch.%s', $clientName);
        $eventService = $this->createEventMiddleware($clientName);
        $container->setDefinition($eventServiceName, $eventService);

        // Create the event Dispatch Middleware
        $eventExpression  = new Expression(sprintf("service('%s').dispatchEvent()", $eventServiceName));

        $handler = new Definition(HandlerStack::class);
        $handler->setFactory([HandlerStack::class, 'create']);
        $handler->setPublic(true);
        $handler->setLazy($options['lazy']);

        if ($logging) {
            $this->defineLogMiddleware($container, $handler, $clientName);
            $this->defineRequestTimeMiddleware($container, $handler, $clientName);
            $this->attachSymfonyLogMiddlewareToHandler($handler);
        }

        if ($profiling) {
            $this->defineProfileMiddleware($container, $handler, $clientName);
        }

        foreach ($this->plugins as $plugin) {
            $plugin->loadForClient($options['plugin'][$plugin->getPluginName()], $container, $clientName, $handler);
        }

        // goes on the end of the stack.
        $handler->addMethodCall('unshift', [$eventExpression, 'events']);

        return $handler;
    }

    /**
     * @param ContainerBuilder $container
     *
     * @return void
     */
    protected function defineTwigDebugExtension(ContainerBuilder $container)
    {
        $twigDebugExtensionDefinition = new Definition(DebugExtension::class);
        $twigDebugExtensionDefinition->addTag('twig.extension');
        $twigDebugExtensionDefinition->setPublic(false);
        $container->setDefinition('eight_points_guzzle.twig_extension.debug', $twigDebugExtensionDefinition);
    }

    /**
     * Define Logger
     *
     * @param \Symfony\Component\DependencyInjection\ContainerBuilder $container
     *
     * @throws \Symfony\Component\DependencyInjection\Exception\BadMethodCallException
     *
     * @return void
     */
    protected function defineLogger(ContainerBuilder $container)
    {
        $loggerDefinition = new Definition('%eight_points_guzzle.logger.class%');
        $loggerDefinition->setPublic(true);
        $container->setDefinition('eight_points_guzzle.logger', $loggerDefinition);
    }

    /**
     * Define Data Collector
     *
     * @param \Symfony\Component\DependencyInjection\ContainerBuilder $container
     *
     * @throws \Symfony\Component\DependencyInjection\Exception\BadMethodCallException
     *
     * @return void
     */
    protected function defineDataCollector(ContainerBuilder $container)
    {
        $dataCollectorDefinition = new Definition('%eight_points_guzzle.data_collector.class%');
        $dataCollectorDefinition->addArgument(new Reference('eight_points_guzzle.logger'));
        $dataCollectorDefinition->setPublic(false);
        $dataCollectorDefinition->addTag('data_collector', [
            'id' => 'eight_points_guzzle',
            'template' => '@EightPointsGuzzle/debug.html.twig',
        ]);
        $container->setDefinition('eight_points_guzzle.data_collector', $dataCollectorDefinition);
    }

    /**
     * Define Formatter
     *
     * @param \Symfony\Component\DependencyInjection\ContainerBuilder $container
     *
     * @throws \Symfony\Component\DependencyInjection\Exception\BadMethodCallException
     *
     * @return void
     */
    protected function defineFormatter(ContainerBuilder $container)
    {
        $formatterDefinition = new Definition('%eight_points_guzzle.formatter.class%');
        $formatterDefinition->setPublic(true);
        $container->setDefinition('eight_points_guzzle.formatter', $formatterDefinition);
    }

    /**
     * Define Request Time Middleware
     *
     * @param \Symfony\Component\DependencyInjection\ContainerBuilder $container
     * @param \Symfony\Component\DependencyInjection\Definition $handler
     * @param string $clientName
     *
     * @return void
     */
    protected function defineRequestTimeMiddleware(ContainerBuilder $container, Definition $handler, string $clientName)
    {
        $requestTimeMiddlewareDefinitionName = sprintf('eight_points_guzzle.middleware.request_time.%s', $clientName);
        $requestTimeMiddlewareDefinition = new Definition('%eight_points_guzzle.middleware.request_time.class%');
        $requestTimeMiddlewareDefinition->addArgument(new Reference('eight_points_guzzle.logger'));
        $requestTimeMiddlewareDefinition->addArgument(new Reference('eight_points_guzzle.data_collector'));
        $requestTimeMiddlewareDefinition->setPublic(true);
        $container->setDefinition($requestTimeMiddlewareDefinitionName, $requestTimeMiddlewareDefinition);

        $requestTimeExpression = new Expression(sprintf("service('%s')", $requestTimeMiddlewareDefinitionName));
        $handler->addMethodCall('after', ['log', $requestTimeExpression, 'request_time']);
    }

    /**
     * Define Log Middleware for client
     *
     * @param \Symfony\Component\DependencyInjection\ContainerBuilder $container
     * @param \Symfony\Component\DependencyInjection\Definition $handler
     * @param string $clientName
     *
     * @return void
     */
    protected function defineLogMiddleware(ContainerBuilder $container, Definition $handler, string $clientName)
    {
        $logMiddlewareDefinitionName = sprintf('eight_points_guzzle.middleware.log.%s', $clientName);
        $logMiddlewareDefinition = new Definition('%eight_points_guzzle.middleware.log.class%');
        $logMiddlewareDefinition->addArgument(new Reference('eight_points_guzzle.logger'));
        $logMiddlewareDefinition->addArgument(new Reference('eight_points_guzzle.formatter'));
        $logMiddlewareDefinition->setPublic(true);
        $container->setDefinition($logMiddlewareDefinitionName, $logMiddlewareDefinition);

        $logExpression = new Expression(sprintf("service('%s').log()", $logMiddlewareDefinitionName));
        $handler->addMethodCall('push', [$logExpression, 'log']);
    }

    /**
     * Define Profile Middleware for client
     *
     * @param \Symfony\Component\DependencyInjection\ContainerBuilder $container
     * @param \Symfony\Component\DependencyInjection\Definition $handler
     * @param string $clientName
     *
     * @return void
     */
    protected function defineProfileMiddleware(ContainerBuilder $container, Definition $handler, string $clientName)
    {
        if (!class_exists('Symfony\Component\Stopwatch\Stopwatch')) {
            throw new RuntimeException('Eightpoint GuzzleBundle profiling requires "symfony/stopwatch" package');
        }

        $logMiddlewareDefinitionName = sprintf('eight_points_guzzle.middleware.profile.%s', $clientName);
        $logMiddlewareDefinition = new Definition('%eight_points_guzzle.middleware.profile.class%');
        $logMiddlewareDefinition->addArgument(new Reference('debug.stopwatch'));
        $logMiddlewareDefinition->setPublic(false);
        $container->setDefinition($logMiddlewareDefinitionName, $logMiddlewareDefinition);

        $logExpression = new Expression(sprintf("service('%s').profile()", $logMiddlewareDefinitionName));
        $handler->addMethodCall('push', [$logExpression, 'profile']);
    }

    /**
     * @param \Symfony\Component\DependencyInjection\Definition $handler
     *
     * @return void
     */
    protected function attachSymfonyLogMiddlewareToHandler(Definition $handler)
    {
        $logExpression = new Expression(sprintf("service('%s')", 'eight_points_guzzle.middleware.symfony_log'));
        $handler->addMethodCall('push', [$logExpression, 'symfony_log']);
    }

    /**
     * Create Middleware For dispatching events
     *
     * @param string $name
     *
     * @return \Symfony\Component\DependencyInjection\Definition
     */
    protected function createEventMiddleware(string $name) : Definition
    {
        $eventMiddleWare = new Definition('%eight_points_guzzle.middleware.event_dispatcher.class%');
        $eventMiddleWare->addArgument(new Reference('event_dispatcher'));
        $eventMiddleWare->addArgument($name);
        $eventMiddleWare->setPublic(true);

        return $eventMiddleWare;
    }

    /**
     * @param \Symfony\Component\DependencyInjection\ContainerBuilder $container
     *
     * @return void
     */
    protected function defineSymfonyLogFormatter(ContainerBuilder $container)
    {
        $formatterDefinition = new Definition('%eight_points_guzzle.symfony_log_formatter.class%');
        $formatterDefinition->setArguments(['%eight_points_guzzle.symfony_log_formatter.pattern%']);
        $formatterDefinition->setPublic(true);
        $container->setDefinition('eight_points_guzzle.symfony_log_formatter', $formatterDefinition);
    }

    /**
     * @param \Symfony\Component\DependencyInjection\ContainerBuilder $container
     *
     * @return void
     */
    protected function defineSymfonyLogMiddleware(ContainerBuilder $container)
    {
        $logMiddlewareDefinition = new Definition('%eight_points_guzzle.middleware.symfony_log.class%');
        $logMiddlewareDefinition->addArgument(new Reference('logger'));
        $logMiddlewareDefinition->addArgument(new Reference('eight_points_guzzle.symfony_log_formatter'));
        $logMiddlewareDefinition->setPublic(true);
        $logMiddlewareDefinition->addTag('monolog.logger', ['channel' => 'eight_points_guzzle']);
        $container->setDefinition('eight_points_guzzle.middleware.symfony_log', $logMiddlewareDefinition);
    }

    /**
     * Returns alias of extension
     *
     * @return string
     */
    public function getAlias() : string
    {
        return 'eight_points_guzzle';
    }
}


1			<?php
2
3			namespace EightPoints\Bundle\GuzzleBundle\DependencyInjection;
4
5			use EightPoints\Bundle\GuzzleBundle\Twig\Extension\DebugExtension;
6			use RuntimeException;
7			use Symfony\Component\DependencyInjection\ContainerBuilder;
8			use Symfony\Component\DependencyInjection\Loader\XmlFileLoader;
9			use Symfony\Component\DependencyInjection\Reference;
10			use Symfony\Component\DependencyInjection\Definition;
11			use Symfony\Component\Config\FileLocator;
12			use Symfony\Component\HttpKernel\DependencyInjection\Extension;
13			use Symfony\Component\ExpressionLanguage\Expression;
14			use GuzzleHttp\HandlerStack;
15
16			class EightPointsGuzzleExtension extends Extension
17			{
18			/** @var \EightPoints\Bundle\GuzzleBundle\EightPointsGuzzleBundlePlugin[] */
19			protected $plugins;
20
21			/**
22			* @param \EightPoints\Bundle\GuzzleBundle\EightPointsGuzzleBundlePlugin[] $plugins
23			*/
24			public function __construct(array $plugins = [])
25			{
26			$this->plugins = $plugins;
27			}
28
29			/**
30			* {@inheritdoc}
31			*/
32			public function getConfiguration(array $config, ContainerBuilder $container) : Configuration
33			{
34			return new Configuration($this->getAlias(), $container->getParameter('kernel.debug'), $this->plugins);
35			}
36
37			/**
38			* Loads the Guzzle configuration.
39			*
40			* @param array $configs an array of configuration settings
41			* @param \Symfony\Component\DependencyInjection\ContainerBuilder $container a ContainerBuilder instance
42			*
43			* @throws \InvalidArgumentException
44			* @throws \Symfony\Component\DependencyInjection\Exception\BadMethodCallException
45			* @throws \Symfony\Component\DependencyInjection\Exception\InvalidArgumentException
46			* @throws \Exception
47			*
48			* @return void
49			*/
50			public function load(array $configs, ContainerBuilder $container)
51			{
52			$configPath = implode(DIRECTORY_SEPARATOR, [__DIR__, '..', 'Resources', 'config']);
53			$loader = new XmlFileLoader($container, new FileLocator($configPath));
54
55			$loader->load('services.xml');
56
57			$configuration = new Configuration($this->getAlias(), $container->getParameter('kernel.debug'), $this->plugins);
58			$config = $this->processConfiguration($configuration, $configs);
59			$logging = $config['logging'] === true;
60			$profiling = $config['profiling'] === true;
61
62			foreach ($this->plugins as $plugin) {
63			$container->addObjectResource(new \ReflectionClass(get_class($plugin)));
64			$plugin->load($config, $container);
65			}
66
67			if ($logging) {
68			$this->defineTwigDebugExtension($container);
69			$this->defineLogger($container);
70			$this->defineDataCollector($container);
71			$this->defineFormatter($container);
72			$this->defineSymfonyLogFormatter($container);
73			$this->defineSymfonyLogMiddleware($container);
74			}
75
76			foreach ($config['clients'] as $name => $options) {
77			$argument = [
78			'base_uri' => $options['base_url'],
79			'handler' => $this->createHandler($container, $name, $options, $logging, $profiling)
80			];
81
82			// if present, add default options to the constructor argument for the Guzzle client
83			if (isset($options['options']) && is_array($options['options'])) {
84			foreach ($options['options'] as $key => $value) {
85			if ($value === null \|\| (is_array($value) && count($value) === 0)) {
86			continue;
87			}
88
89			$argument[$key] = $value;
90			}
91			}
92
93			$client = new Definition($options['class']);
94			$client->addArgument($argument);
95			$client->setPublic(true);
96			$client->setLazy($options['lazy']);
97
98			// set service name based on client name
99			$serviceName = sprintf('%s.client.%s', $this->getAlias(), $name);
100			$container->setDefinition($serviceName, $client);
101			}
102			}
103
104			/**
105			* @param \Symfony\Component\DependencyInjection\ContainerBuilder $container
106			* @param string $clientName
107			* @param array $options
108			* @param bool $logging
109			*
110			* @throws \Symfony\Component\DependencyInjection\Exception\BadMethodCallException
111			* @throws \Symfony\Component\DependencyInjection\Exception\InvalidArgumentException
112			*
113			* @return \Symfony\Component\DependencyInjection\Definition
114			*/
115			protected function createHandler(ContainerBuilder $container, string $clientName, array $options, bool $logging, bool $profiling) : Definition
116			{
117			// Event Dispatching service
118			$eventServiceName = sprintf('eight_points_guzzle.middleware.event_dispatch.%s', $clientName);
119			$eventService = $this->createEventMiddleware($clientName);
120			$container->setDefinition($eventServiceName, $eventService);
121
122			// Create the event Dispatch Middleware
123			$eventExpression = new Expression(sprintf("service('%s').dispatchEvent()", $eventServiceName));
124
125			$handler = new Definition(HandlerStack::class);
126			$handler->setFactory([HandlerStack::class, 'create']);
127			$handler->setPublic(true);
128			$handler->setLazy($options['lazy']);
129
130			if ($logging) {
131			$this->defineLogMiddleware($container, $handler, $clientName);
132			$this->defineRequestTimeMiddleware($container, $handler, $clientName);
133			$this->attachSymfonyLogMiddlewareToHandler($handler);
134			}
135
136			if ($profiling) {
137			$this->defineProfileMiddleware($container, $handler, $clientName);
138			}
139
140			foreach ($this->plugins as $plugin) {
141			$plugin->loadForClient($options['plugin'][$plugin->getPluginName()], $container, $clientName, $handler);
142			}
143
144			// goes on the end of the stack.
145			$handler->addMethodCall('unshift', [$eventExpression, 'events']);
146
147			return $handler;
148			}
149
150			/**
151			* @param ContainerBuilder $container
152			*
153			* @return void
154			*/
155			protected function defineTwigDebugExtension(ContainerBuilder $container)
156			{
157			$twigDebugExtensionDefinition = new Definition(DebugExtension::class);
158			$twigDebugExtensionDefinition->addTag('twig.extension');
159			$twigDebugExtensionDefinition->setPublic(false);
160			$container->setDefinition('eight_points_guzzle.twig_extension.debug', $twigDebugExtensionDefinition);
161			}
162
163			/**
164			* Define Logger
165			*
166			* @param \Symfony\Component\DependencyInjection\ContainerBuilder $container
167			*
168			* @throws \Symfony\Component\DependencyInjection\Exception\BadMethodCallException
169			*
170			* @return void
171			*/
172			protected function defineLogger(ContainerBuilder $container)
173			{
174			$loggerDefinition = new Definition('%eight_points_guzzle.logger.class%');
175			$loggerDefinition->setPublic(true);
176			$container->setDefinition('eight_points_guzzle.logger', $loggerDefinition);
177			}
178
179			/**
180			* Define Data Collector
181			*
182			* @param \Symfony\Component\DependencyInjection\ContainerBuilder $container
183			*
184			* @throws \Symfony\Component\DependencyInjection\Exception\BadMethodCallException
185			*
186			* @return void
187			*/
188			protected function defineDataCollector(ContainerBuilder $container)
189			{
190			$dataCollectorDefinition = new Definition('%eight_points_guzzle.data_collector.class%');
191			$dataCollectorDefinition->addArgument(new Reference('eight_points_guzzle.logger'));
192			$dataCollectorDefinition->setPublic(false);
193			$dataCollectorDefinition->addTag('data_collector', [
194			'id' => 'eight_points_guzzle',
195			'template' => '@EightPointsGuzzle/debug.html.twig',
196			]);
197			$container->setDefinition('eight_points_guzzle.data_collector', $dataCollectorDefinition);
198			}
199
200			/**
201			* Define Formatter
202			*
203			* @param \Symfony\Component\DependencyInjection\ContainerBuilder $container
204			*
205			* @throws \Symfony\Component\DependencyInjection\Exception\BadMethodCallException
206			*
207			* @return void
208			*/
209			protected function defineFormatter(ContainerBuilder $container)
210			{
211			$formatterDefinition = new Definition('%eight_points_guzzle.formatter.class%');
212			$formatterDefinition->setPublic(true);
213			$container->setDefinition('eight_points_guzzle.formatter', $formatterDefinition);
214			}
215
216			/**
217			* Define Request Time Middleware
218			*
219			* @param \Symfony\Component\DependencyInjection\ContainerBuilder $container
220			* @param \Symfony\Component\DependencyInjection\Definition $handler
221			* @param string $clientName
222			*
223			* @return void
224			*/
225			protected function defineRequestTimeMiddleware(ContainerBuilder $container, Definition $handler, string $clientName)
226			{
227			$requestTimeMiddlewareDefinitionName = sprintf('eight_points_guzzle.middleware.request_time.%s', $clientName);
228			$requestTimeMiddlewareDefinition = new Definition('%eight_points_guzzle.middleware.request_time.class%');
229			$requestTimeMiddlewareDefinition->addArgument(new Reference('eight_points_guzzle.logger'));
230			$requestTimeMiddlewareDefinition->addArgument(new Reference('eight_points_guzzle.data_collector'));
231			$requestTimeMiddlewareDefinition->setPublic(true);
232			$container->setDefinition($requestTimeMiddlewareDefinitionName, $requestTimeMiddlewareDefinition);
233
234			$requestTimeExpression = new Expression(sprintf("service('%s')", $requestTimeMiddlewareDefinitionName));
235			$handler->addMethodCall('after', ['log', $requestTimeExpression, 'request_time']);
236			}
237
238			/**
239			* Define Log Middleware for client
240			*
241			* @param \Symfony\Component\DependencyInjection\ContainerBuilder $container
242			* @param \Symfony\Component\DependencyInjection\Definition $handler
243			* @param string $clientName
244			*
245			* @return void
246			*/
247			protected function defineLogMiddleware(ContainerBuilder $container, Definition $handler, string $clientName)
248			{
249			$logMiddlewareDefinitionName = sprintf('eight_points_guzzle.middleware.log.%s', $clientName);
250			$logMiddlewareDefinition = new Definition('%eight_points_guzzle.middleware.log.class%');
251			$logMiddlewareDefinition->addArgument(new Reference('eight_points_guzzle.logger'));
252			$logMiddlewareDefinition->addArgument(new Reference('eight_points_guzzle.formatter'));
253			$logMiddlewareDefinition->setPublic(true);
254			$container->setDefinition($logMiddlewareDefinitionName, $logMiddlewareDefinition);
255
256			$logExpression = new Expression(sprintf("service('%s').log()", $logMiddlewareDefinitionName));
257			$handler->addMethodCall('push', [$logExpression, 'log']);
258			}
259
260			/**
261			* Define Profile Middleware for client
262			*
263			* @param \Symfony\Component\DependencyInjection\ContainerBuilder $container
264			* @param \Symfony\Component\DependencyInjection\Definition $handler
265			* @param string $clientName
266			*
267			* @return void
268			*/
269			protected function defineProfileMiddleware(ContainerBuilder $container, Definition $handler, string $clientName)
270			{
271			if (!class_exists('Symfony\Component\Stopwatch\Stopwatch')) {
272			throw new RuntimeException('Eightpoint GuzzleBundle profiling requires "symfony/stopwatch" package');
273			}
274
275			$logMiddlewareDefinitionName = sprintf('eight_points_guzzle.middleware.profile.%s', $clientName);
276			$logMiddlewareDefinition = new Definition('%eight_points_guzzle.middleware.profile.class%');
277			$logMiddlewareDefinition->addArgument(new Reference('debug.stopwatch'));
278			$logMiddlewareDefinition->setPublic(false);
279			$container->setDefinition($logMiddlewareDefinitionName, $logMiddlewareDefinition);
280
281			$logExpression = new Expression(sprintf("service('%s').profile()", $logMiddlewareDefinitionName));
282			$handler->addMethodCall('push', [$logExpression, 'profile']);
283			}
284
285			/**
286			* @param \Symfony\Component\DependencyInjection\Definition $handler
287			*
288			* @return void
289			*/
290			protected function attachSymfonyLogMiddlewareToHandler(Definition $handler)
291			{
292			$logExpression = new Expression(sprintf("service('%s')", 'eight_points_guzzle.middleware.symfony_log'));
293			$handler->addMethodCall('push', [$logExpression, 'symfony_log']);
294			}
295
296			/**
297			* Create Middleware For dispatching events
298			*
299			* @param string $name
300			*
301			* @return \Symfony\Component\DependencyInjection\Definition
302			*/
303			protected function createEventMiddleware(string $name) : Definition
304			{
305			$eventMiddleWare = new Definition('%eight_points_guzzle.middleware.event_dispatcher.class%');
306			$eventMiddleWare->addArgument(new Reference('event_dispatcher'));
307			$eventMiddleWare->addArgument($name);
308			$eventMiddleWare->setPublic(true);
309
310			return $eventMiddleWare;
311			}
312
313			/**
314			* @param \Symfony\Component\DependencyInjection\ContainerBuilder $container
315			*
316			* @return void
317			*/
318			protected function defineSymfonyLogFormatter(ContainerBuilder $container)
319			{
320			$formatterDefinition = new Definition('%eight_points_guzzle.symfony_log_formatter.class%');
321			$formatterDefinition->setArguments(['%eight_points_guzzle.symfony_log_formatter.pattern%']);
322			$formatterDefinition->setPublic(true);
323			$container->setDefinition('eight_points_guzzle.symfony_log_formatter', $formatterDefinition);
324			}
325
326			/**
327			* @param \Symfony\Component\DependencyInjection\ContainerBuilder $container
328			*
329			* @return void
330			*/
331			protected function defineSymfonyLogMiddleware(ContainerBuilder $container)
332			{
333			$logMiddlewareDefinition = new Definition('%eight_points_guzzle.middleware.symfony_log.class%');
334			$logMiddlewareDefinition->addArgument(new Reference('logger'));
335			$logMiddlewareDefinition->addArgument(new Reference('eight_points_guzzle.symfony_log_formatter'));
336			$logMiddlewareDefinition->setPublic(true);
337			$logMiddlewareDefinition->addTag('monolog.logger', ['channel' => 'eight_points_guzzle']);
338			$container->setDefinition('eight_points_guzzle.middleware.symfony_log', $logMiddlewareDefinition);
339			}
340
341			/**
342			* Returns alias of extension
343			*
344			* @return string
345			*/
346			public function getAlias() : string
347			{
348			return 'eight_points_guzzle';
349			}
350			}
351

8p / EightPointsGuzzleBundle

GitHub Access Token became invalid

Pull Request — master (#216)

defineTwigDebugExtension() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like