refactor(DependencyInjection): move configurate in compiler passes

phpunit.xml.dist

@@ -1,6 +1,6 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <phpunit xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-    xsi:noNamespaceSchemaLocation="https://schema.phpunit.de/10.5/phpunit.xsd"
+    xsi:noNamespaceSchemaLocation="https://schema.phpunit.de/11.5/phpunit.xsd"
     bootstrap="vendor/autoload.php"
     executionOrder="depends,defects"
     beStrictAboutOutputDuringTests="true"

src/DependencyInjection/Compiler/CacheInstrumentationPass.php

@@ -0,0 +1,78 @@
+<?php
+
+namespace FriendsOfOpenTelemetry\OpenTelemetryBundle\DependencyInjection\Compiler;
+
+use Symfony\Component\Cache\CacheItem;
+use Symfony\Component\DependencyInjection\ChildDefinition;
+use Symfony\Component\DependencyInjection\Compiler\CompilerPassInterface;
+use Symfony\Component\DependencyInjection\ContainerBuilder;
+use Symfony\Component\DependencyInjection\Definition;
+use Symfony\Component\DependencyInjection\Reference;
+
+class CacheInstrumentationPass implements CompilerPassInterface
+{
+    public function process(ContainerBuilder $container): void
+    {
+        if (false === $container->hasParameter('open_telemetry.instrumentation.cache.tracing.enabled')
+            || false === $container->getParameter('open_telemetry.instrumentation.cache.tracing.enabled')) {
+            $container->removeDefinition('open_telemetry.instrumentation.cache.trace.tag_aware_adapter');
+            $container->removeDefinition('open_telemetry.instrumentation.cache.trace.adapter');
+
+            return;
+        }
+
+        if (!class_exists(CacheItem::class)) {
+            throw new \LogicException('Cache instrumentation cannot be enabled because the symfony/cache package is not installed.');
+        }
+
+        foreach ($container->findTaggedServiceIds('cache.pool') as $serviceId => $tags) {
+            $cachePoolDefinition = $container->getDefinition($serviceId);
+            if ($cachePoolDefinition->isAbstract()) {
+                continue;
+            }
+
+            $definitionClass = $this->resolveDefinitionClass($container, $cachePoolDefinition);
+            if (null === $definitionClass) {
+                continue;
+            }
+
+            $traceableCachePoolDefinition = new ChildDefinition('open_telemetry.instrumentation.cache.trace.adapter');
+            $traceableCachePoolDefinition
+                ->setDecoratedService($serviceId)
+                ->setArgument('$adapter', new Reference('.inner'));
+
+            $container->setDefinition($serviceId.'.tracer', $traceableCachePoolDefinition);
+        }
+
+        foreach ($container->findTaggedServiceIds('cache.taggable') as $serviceId => $tags) {
+            $cachePoolDefinition = $container->getDefinition($serviceId);
+            if ($cachePoolDefinition->isAbstract()) {
+                continue;
+            }
+
+            $definitionClass = $this->resolveDefinitionClass($container, $cachePoolDefinition);
+            if (null === $definitionClass) {
+                continue;
+            }
+
+            $traceableCachePoolDefinition = new ChildDefinition('open_telemetry.instrumentation.cache.trace.tag_aware_adapter');
+            $traceableCachePoolDefinition
+                ->setDecoratedService($serviceId)
+                ->setArgument('$adapter', new Reference('.inner'));
+
+            $container->setDefinition($serviceId.'.tracer', $traceableCachePoolDefinition);
+        }
+    }
+
+    private function resolveDefinitionClass(ContainerBuilder $container, Definition $definition): ?string
+    {
+        $class = $definition->getClass();
+
+        while (null === $class && $definition instanceof ChildDefinition) {
+            $definition = $container->findDefinition($definition->getParent());
+            $class = $definition->getClass();
+        }
+
+        return $class;
+    }
+}

src/DependencyInjection/Compiler/ConsoleInstrumentationPass.php

@@ -0,0 +1,19 @@
+<?php
+
+namespace FriendsOfOpenTelemetry\OpenTelemetryBundle\DependencyInjection\Compiler;
+
+use Symfony\Component\DependencyInjection\Compiler\CompilerPassInterface;
+use Symfony\Component\DependencyInjection\ContainerBuilder;
+
+class ConsoleInstrumentationPass implements CompilerPassInterface
+{
+    public function process(ContainerBuilder $container): void
+    {
+        if (true === $container->hasParameter('open_telemetry.instrumentation.console.tracing.enabled')
+            && true === $container->getParameter('open_telemetry.instrumentation.console.tracing.enabled')) {
+            return;
+        }
+
+        $container->removeDefinition('open_telemetry.instrumentation.console.trace.event_subscriber');
+    }
+}

src/DependencyInjection/Compiler/RemoveDoctrineInstrumentationPass.php → src/DependencyInjection/Compiler/DoctrineInstrumentationPass.php

@@ -2,20 +2,24 @@
 
 namespace FriendsOfOpenTelemetry\OpenTelemetryBundle\DependencyInjection\Compiler;
 
+use Doctrine\Bundle\DoctrineBundle\DoctrineBundle;
 use Symfony\Component\DependencyInjection\Compiler\CompilerPassInterface;
 use Symfony\Component\DependencyInjection\ContainerBuilder;
 
-class RemoveDoctrineInstrumentationPass implements CompilerPassInterface
+class DoctrineInstrumentationPass implements CompilerPassInterface
 {
     public function process(ContainerBuilder $container): void
     {
         if (false === $container->hasParameter('open_telemetry.instrumentation.doctrine.tracing.enabled')
             || false === $container->getParameter('open_telemetry.instrumentation.doctrine.tracing.enabled')) {
-            $container->removeDefinition('open_telemetry.instrumentation.doctrine.trace.middleware');
+            return;
         }
 
-        if (false === $container->hasParameter('open_telemetry.instrumentation.doctrine.metering.enabled')
-            || false === $container->getParameter('open_telemetry.instrumentation.doctrine.metering.enabled')) {
+        if (!class_exists(DoctrineBundle::class)) {
+            throw new \LogicException('Doctrine instrumentation cannot be enabled because the doctrine/doctrine-bundle package is not installed.');
         }
+
+        $container->getDefinition('open_telemetry.instrumentation.doctrine.trace.middleware')
+            ->addTag('doctrine.middleware');
     }
 }

src/DependencyInjection/Compiler/HttpClientTracingPass.php → src/DependencyInjection/Compiler/HttpClientInstrumentationPass.php

@@ -5,30 +5,33 @@
 use Symfony\Component\DependencyInjection\Compiler\CompilerPassInterface;
 use Symfony\Component\DependencyInjection\ContainerBuilder;
 use Symfony\Component\DependencyInjection\Reference;
+use Symfony\Component\HttpClient\HttpClient;
 
-class HttpClientTracingPass implements CompilerPassInterface
+class HttpClientInstrumentationPass implements CompilerPassInterface
 {
     public function process(ContainerBuilder $container): void
     {
-        $decoratedService = $this->getDecoratedService($container);
-        if (null === $decoratedService) {
+        if (false === $container->hasParameter('open_telemetry.instrumentation.http_client.tracing.enabled')
+            || false === $container->getParameter('open_telemetry.instrumentation.http_client.tracing.enabled')) {
             $container->removeDefinition('open_telemetry.instrumentation.http_client.trace.client');
 
             return;
         }
 
-        if (true === $container->hasParameter('open_telemetry.instrumentation.http_client.tracing.enabled')
-            && true === $container->getParameter('open_telemetry.instrumentation.http_client.tracing.enabled')) {
-            $container->getDefinition('open_telemetry.instrumentation.http_client.trace.client')
-                ->setArgument('$client', new Reference('.inner'))
-                ->setDecoratedService($decoratedService[0], null, $decoratedService[1]);
-        } else {
-            $container->removeDefinition('open_telemetry.instrumentation.http_client.trace.client');
+        if (!class_exists(HttpClient::class)) {
+            throw new \LogicException('Http client instrumentation cannot be enabled because the symfony/http-client package is not installed.');
         }
 
-        if (true === $container->hasParameter('open_telemetry.instrumentation.http_client.metering.enabled')
-            && true === $container->getParameter('open_telemetry.instrumentation.http_client.metering.enabled')) {
+        $decoratedService = $this->getDecoratedService($container);
+        if (null === $decoratedService) {
+            $container->removeDefinition('open_telemetry.instrumentation.http_client.trace.client');
+
+            return;
         }
+
+        $container->getDefinition('open_telemetry.instrumentation.http_client.trace.client')
+            ->setArgument('$client', new Reference('.inner'))
+            ->setDecoratedService($decoratedService[0], null, $decoratedService[1]);
     }
 
     /**

src/DependencyInjection/Compiler/HttpKernelInstrumentationPass.php

@@ -0,0 +1,20 @@
+<?php
+
+namespace FriendsOfOpenTelemetry\OpenTelemetryBundle\DependencyInjection\Compiler;
+
+use Symfony\Component\DependencyInjection\Compiler\CompilerPassInterface;
+use Symfony\Component\DependencyInjection\ContainerBuilder;
+
+class HttpKernelInstrumentationPass implements CompilerPassInterface
+{
+    public function process(ContainerBuilder $container): void
+    {
+        if (true === $container->hasParameter('open_telemetry.instrumentation.http_kernel.tracing.enabled')
+            && true === $container->getParameter('open_telemetry.instrumentation.http_kernel.tracing.enabled')) {
+            return;
+        }
+
+        $container->removeDefinition('open_telemetry.instrumentation.http_kernel.trace.event_subscriber');
+        $container->removeDefinition('open_telemetry.instrumentation.http_kernel.trace.route_loader');
+    }
+}

src/DependencyInjection/Compiler/MailerInstrumentationPass.php

@@ -0,0 +1,27 @@
+<?php
+
+namespace FriendsOfOpenTelemetry\OpenTelemetryBundle\DependencyInjection\Compiler;
+
+use Symfony\Component\DependencyInjection\Compiler\CompilerPassInterface;
+use Symfony\Component\DependencyInjection\ContainerBuilder;
+use Symfony\Component\Mailer\MailerInterface;
+use Symfony\Component\Mailer\Transport\TransportFactoryInterface;
+
+class MailerInstrumentationPass implements CompilerPassInterface
+{
+    public function process(ContainerBuilder $container): void
+    {
+        if (true === $container->hasParameter('open_telemetry.instrumentation.mailer.tracing.enabled')
+            && true === $container->getParameter('open_telemetry.instrumentation.mailer.tracing.enabled')) {
+            return;
+        }
+
+        if (!interface_exists(MailerInterface::class) || !interface_exists(TransportFactoryInterface::class)) {
+            throw new \LogicException('Mailer instrumentation cannot be enabled because the symfony/mailer package is not installed.');
+        }
+
+        $container->removeDefinition('open_telemetry.instrumentation.mailer.trace.transports');
+        $container->removeDefinition('open_telemetry.instrumentation.mailer.trace.default_transport');
+        $container->removeDefinition('open_telemetry.instrumentation.mailer.trace.mailer');
+    }
+}

src/DependencyInjection/Compiler/MessengerInstrumentationPass.php

@@ -0,0 +1,34 @@
+<?php
+
+namespace FriendsOfOpenTelemetry\OpenTelemetryBundle\DependencyInjection\Compiler;
+
+use Symfony\Component\DependencyInjection\Compiler\CompilerPassInterface;
+use Symfony\Component\DependencyInjection\ContainerBuilder;
+use Symfony\Component\Messenger\Middleware\MiddlewareInterface;
+use Symfony\Component\Messenger\Transport\TransportFactoryInterface;
+
+class MessengerInstrumentationPass implements CompilerPassInterface
+{
+    public function process(ContainerBuilder $container): void
+    {
+        if (false === $container->hasParameter('open_telemetry.instrumentation.messenger.tracing.enabled')
+            || false === $container->getParameter('open_telemetry.instrumentation.messenger.tracing.enabled')) {
+            return;
+        }
+
+        if (!interface_exists(MiddlewareInterface::class) || !interface_exists(TransportFactoryInterface::class)) {
+            throw new \LogicException('Messenger instrumentation cannot be enabled because the symfony/messenger package is not installed.');
+        }
+
+        $container
+            ->setAlias('messenger.transport.open_telemetry_tracer.factory', 'open_telemetry.instrumentation.messenger.trace.transport_factory');
+        $container
+            ->setAlias('messenger.middleware.open_telemetry_tracer', 'open_telemetry.instrumentation.messenger.trace.middleware');
+
+        $container->getDefinition('open_telemetry.instrumentation.messenger.trace.transport_factory')
+            ->addTag('messenger.transport_factory')
+            ->addTag('kernel.reset', ['method' => 'reset']);
+        $container->getDefinition('open_telemetry.instrumentation.messenger.trace.middleware')
+            ->addTag('messenger.middleware');
+    }
+}