feat(Instrumentation/Console): exclude commands from being traced when instrumentation type is auto

Author: gaelreyrol

src/DependencyInjection/Compiler/SetConsoleTracingExcludeCommandsPass.php

@@ -0,0 +1,24 @@
+<?php
+
+namespace FriendsOfOpenTelemetry\OpenTelemetryBundle\DependencyInjection\Compiler;
+
+use Symfony\Component\DependencyInjection\Compiler\CompilerPassInterface;
+use Symfony\Component\DependencyInjection\ContainerBuilder;
+
+class SetConsoleTracingExcludeCommandsPass implements CompilerPassInterface
+{
+    public function process(ContainerBuilder $container): void
+    {
+        if (false === $container->hasParameter('open_telemetry.instrumentation.console.tracing.exclude_commands')) {
+            return;
+        }
+
+        if (false === $container->hasDefinition('open_telemetry.instrumentation.console.trace.event_subscriber')) {
+            return;
+        }
+
+        $excludeCommands = $container->getParameter('open_telemetry.instrumentation.console.tracing.exclude_commands');
+        $container->getDefinition('open_telemetry.instrumentation.console.trace.event_subscriber')
+            ->addMethodCall('setExcludeCommands', [$excludeCommands]);
+    }
+}

src/DependencyInjection/Configuration.php

@@ -91,7 +91,11 @@ private function addInstrumentationSection(ArrayNodeDefinition $node): void
                                 ->defaultValue(InstrumentationTypeEnum::Auto->value)
                                 ->values(array_map(fn (InstrumentationTypeEnum $type) => $type->value, InstrumentationTypeEnum::cases()))
                             ->end()
-                            ->append($this->getTracingInstrumentationNode())
+                            ->append($this->getTracingInstrumentationNode(
+                                (new ArrayNodeDefinition('exclude_commands'))
+                                    ->info('Exclude commands from auto instrumentation')
+                                    ->scalarPrototype()->cannotBeEmpty()->end()
+                            ))
                             ->append($this->getMeteringInstrumentationNode())
                         ->end()
                     ->end()

src/DependencyInjection/OpenTelemetryExtension.php

@@ -24,7 +24,8 @@
  * @phpstan-type TracingInstrumentationConfig array{
  *     enabled: bool,
  *     tracer: ?string,
- *     exclude_paths?: string[]
+ *     exclude_paths?: string[],
+ *     exclude_commands?: string[]
  * }
  * @phpstan-type MeteringInstrumentationConfig array{
  *     enabled: bool,
@@ -271,6 +272,17 @@ private function setTracingInstrumentationParams(ContainerBuilder $container, st
             }
         }
 
+        if ('console' === $name) {
+            if (isset($config['tracing']['exclude_commands'])
+                && 0 < \count($config['tracing']['exclude_commands'])
+            ) {
+                $container->setParameter(
+                    sprintf('open_telemetry.instrumentation.%s.tracing.exclude_commands', $name),
+                    $config['tracing']['exclude_commands'],
+                );
+            }
+        }
+
         $container->setParameter(
             sprintf('open_telemetry.instrumentation.%s.tracing.tracer', $name),
             $config['tracing']['tracer'] ?? 'default_tracer',

src/Instrumentation/Symfony/Console/TraceableConsoleEventSubscriber.php

@@ -25,6 +25,10 @@
 final class TraceableConsoleEventSubscriber implements EventSubscriberInterface, ServiceSubscriberInterface, InstrumentationTypeInterface
 {
     private InstrumentationTypeEnum $instrumentationType = InstrumentationTypeEnum::Auto;
+    /**
+     * @var string[]
+     */
+    private array $excludeCommands = [];
 
     public function __construct(
         private readonly TracerInterface $tracer,
@@ -148,7 +152,16 @@ private function getTracer(Command $command): TracerInterface
 
     private function isAutoTraceable(Command $command): bool
     {
-        return InstrumentationTypeEnum::Auto === $this->instrumentationType;
+        if (InstrumentationTypeEnum::Auto !== $this->instrumentationType) {
+            return false;
+        }
+
+        $combinedExcludeCommands = implode('|', $this->excludeCommands);
+        if (preg_match("#{$combinedExcludeCommands}#", $command->getName())) {
+            return false;
+        }
+
+        return true;
     }
 
     private function isAttributeTraceable(Command $command): bool
@@ -168,4 +181,12 @@ public function setInstrumentationType(InstrumentationTypeEnum $type): void
     {
         $this->instrumentationType = $type;
     }
+
+    /**
+     * @param string[] $excludeCommands
+     */
+    public function setExcludeCommands(array $excludeCommands): void
+    {
+        $this->excludeCommands = $excludeCommands;
+    }
 }

src/OpenTelemetryBundle.php

@@ -5,6 +5,7 @@
 use Composer\InstalledVersions;
 use FriendsOfOpenTelemetry\OpenTelemetryBundle\DependencyInjection\Compiler\CacheInstrumentationPass;
 use FriendsOfOpenTelemetry\OpenTelemetryBundle\DependencyInjection\Compiler\HttpClientInstrumentationPass;
+use FriendsOfOpenTelemetry\OpenTelemetryBundle\DependencyInjection\Compiler\SetConsoleTracingExcludeCommandsPass;
 use FriendsOfOpenTelemetry\OpenTelemetryBundle\DependencyInjection\Compiler\SetHttpKernelTracingExcludePathsPass;
 use FriendsOfOpenTelemetry\OpenTelemetryBundle\DependencyInjection\Compiler\SetInstrumentationTypePass;
 use FriendsOfOpenTelemetry\OpenTelemetryBundle\DependencyInjection\Compiler\TracerLocatorPass;
@@ -32,6 +33,7 @@ public function build(ContainerBuilder $container): void
         $container->addCompilerPass(new CacheInstrumentationPass());
         $container->addCompilerPass(new HttpClientInstrumentationPass());
         $container->addCompilerPass(new SetHttpKernelTracingExcludePathsPass());
+        $container->addCompilerPass(new SetConsoleTracingExcludeCommandsPass());
 
         $container->addCompilerPass(new TracerLocatorPass());
     }

tests/Functional/Application/config/packages/open_telemetry.yaml

@@ -95,6 +95,12 @@ open_telemetry:
 when@auto:
   open_telemetry:
     instrumentation:
+      console:
+        type: auto
+        tracing:
+          enabled: true
+          exclude_commands:
+            - dummy
       http_kernel:
         type: auto
         tracing:

tests/Functional/Application/src/Command/AutoCommand.php

@@ -0,0 +1,17 @@
+<?php
+
+namespace App\Command;
+
+use Symfony\Component\Console\Attribute\AsCommand;
+use Symfony\Component\Console\Command\Command;
+use Symfony\Component\Console\Input\InputInterface;
+use Symfony\Component\Console\Output\OutputInterface;
+
+#[AsCommand('auto-command')]
+class AutoCommand extends Command
+{
+    protected function execute(InputInterface $input, OutputInterface $output): int
+    {
+        return Command::SUCCESS;
+    }
+}

tests/Functional/Application/src/Command/DummyCommand.php

@@ -0,0 +1,17 @@
+<?php
+
+namespace App\Command;
+
+use Symfony\Component\Console\Attribute\AsCommand;
+use Symfony\Component\Console\Command\Command;
+use Symfony\Component\Console\Input\InputInterface;
+use Symfony\Component\Console\Output\OutputInterface;
+
+#[AsCommand('dummy-command')]
+class DummyCommand extends Command
+{
+    protected function execute(InputInterface $input, OutputInterface $output): int
+    {
+        return Command::SUCCESS;
+    }
+}

…l/Instrumentation/ConsoleTracingTest.php …/Console/ConsoleAttributeTracingTest.phptests/Functional/Instrumentation/ConsoleTracingTest.php renamed to tests/Functional/Instrumentation/Console/ConsoleAttributeTracingTest.php tests/Functional/Instrumentation/ConsoleTracingTest.php renamed to tests/Functional/Instrumentation/Console/ConsoleAttributeTracingTest.php

@@ -1,6 +1,6 @@
 <?php
 
-namespace FriendsOfOpenTelemetry\OpenTelemetryBundle\Tests\Functional\Instrumentation;
+namespace FriendsOfOpenTelemetry\OpenTelemetryBundle\Tests\Functional\Instrumentation\Console;
 
 use App\Kernel;
 use FriendsOfOpenTelemetry\OpenTelemetryBundle\Tests\Functional\TracingTestCaseTrait;
@@ -13,7 +13,7 @@
 use Zalas\PHPUnit\Globals\Attribute\Env;
 
 #[Env('KERNEL_CLASS', Kernel::class)]
-class ConsoleTracingTest extends KernelTestCase
+class ConsoleAttributeTracingTest extends KernelTestCase
 {
     use TracingTestCaseTrait;
 

tests/Functional/Instrumentation/Console/ConsoleAutoTracingTest.php

@@ -0,0 +1,58 @@
+<?php
+
+namespace FriendsOfOpenTelemetry\OpenTelemetryBundle\Tests\Functional\Instrumentation\Console;
+
+use App\Kernel;
+use FriendsOfOpenTelemetry\OpenTelemetryBundle\Tests\Functional\TracingTestCaseTrait;
+use OpenTelemetry\SDK\Trace\StatusData;
+use Symfony\Bundle\FrameworkBundle\Console\Application;
+use Symfony\Bundle\FrameworkBundle\Test\KernelTestCase;
+use Symfony\Component\Console\Tester\ApplicationTester;
+use Zalas\PHPUnit\Globals\Attribute\Env;
+
+#[Env('KERNEL_CLASS', Kernel::class)]
+#[Env('APP_ENV', 'auto')]
+class ConsoleAutoTracingTest extends KernelTestCase
+{
+    use TracingTestCaseTrait;
+
+    public function testSuccess(): void
+    {
+        $kernel = self::bootKernel();
+
+        $application = new Application($kernel);
+        $application->setAutoExit(false);
+
+        $tester = new ApplicationTester($application);
+
+        $tester->run(['command' => 'auto-command']);
+        self::assertSame(0, $tester->getStatusCode());
+
+        self::assertSpansCount(1);
+
+        $mainSpan = self::getSpans()[0];
+        self::assertSpanName($mainSpan, 'auto-command');
+        self::assertSpanStatus($mainSpan, StatusData::ok());
+        self::assertSpanAttributes($mainSpan, [
+            'code.function.name' => 'execute',
+            'code.namespace' => 'App\Command\AutoCommand',
+            'symfony.console.exit_code' => 0,
+        ]);
+        self::assertSpanEventsCount($mainSpan, 0);
+    }
+
+    public function testExcluded(): void
+    {
+        $kernel = self::bootKernel();
+
+        $application = new Application($kernel);
+        $application->setAutoExit(false);
+
+        $tester = new ApplicationTester($application);
+
+        $tester->run(['command' => 'dummy-command']);
+        self::assertSame(0, $tester->getStatusCode());
+
+        self::assertSpansCount(0);
+    }
+}