Support tracing for Doctrine DBAL 2.10+

Author: ste93cry

composer.json

@@ -32,8 +32,9 @@
         "symfony/security-core": "^3.4.43||^4.4.11||^5.0.11"
     },
     "require-dev": {
-        "doctrine/doctrine-bundle": "^2.2",
-        "friendsofphp/php-cs-fixer": "^2.17",
+        "doctrine/dbal": "^2.10||^3.0",
+        "doctrine/doctrine-bundle": "^1.12||^2.0",
+        "friendsofphp/php-cs-fixer": "^2.18",
         "jangregor/phpstan-prophecy": "^0.8",
         "monolog/monolog": "^1.3||^2.0",
         "phpspec/prophecy": "!=1.11.0",

phpstan.neon

@@ -10,3 +10,4 @@ parameters:
         - tests/End2End/App
     dynamicConstantNames:
         - Symfony\Component\HttpKernel\Kernel::VERSION
+        - Doctrine\DBAL\Version::VERSION

psalm-baseline.xml

@@ -0,0 +1,24 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<files psalm-version="4.3.0@6f916553a8de3c5c2483162b6cc01b21b24e4d1d">
+  <file src="src/Tracing/Doctrine/DBAL/Legacy/TracingDriverConnectionForV2_11.php">
+    <MethodSignatureMismatch occurrences="3">
+      <code>$sql</code>
+      <code>$sql</code>
+      <code>TracingDriverConnectionForV2_11</code>
+    </MethodSignatureMismatch>
+    <ParamNameMismatch occurrences="1">
+      <code>$value</code>
+    </ParamNameMismatch>
+    <UnimplementedInterfaceMethod occurrences="1">
+      <code>TracingDriverConnectionForV2_11</code>
+    </UnimplementedInterfaceMethod>
+  </file>
+  <file src="src/Tracing/Doctrine/DBAL/TracingDriver.php">
+    <TooManyArguments occurrences="1">
+      <code>getSchemaManager</code>
+    </TooManyArguments>
+    <UndefinedClass occurrences="1">
+      <code>ExceptionConverter</code>
+    </UndefinedClass>
+  </file>
+</files>

psalm.xml

@@ -6,6 +6,7 @@
     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
     xmlns="https://getpsalm.org/schema/config"
     xsi:schemaLocation="https://getpsalm.org/schema/config vendor/vimeo/psalm/config.xsd"
+    errorBaseline="psalm-baseline.xml"
 >
     <projectFiles>
         <directory name="src" />

src/DependencyInjection/Compiler/DbalTracingDriverPass.php

@@ -0,0 +1,87 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Sentry\SentryBundle\DependencyInjection\Compiler;
+
+use Jean85\PrettyVersions;
+use Sentry\SentryBundle\Tracing\Doctrine\DBAL\ConnectionConfigurator;
+use Sentry\SentryBundle\Tracing\Doctrine\DBAL\TracingDriverMiddleware;
+use Symfony\Component\DependencyInjection\Compiler\CompilerPassInterface;
+use Symfony\Component\DependencyInjection\ContainerBuilder;
+use Symfony\Component\DependencyInjection\Definition;
+use Symfony\Component\DependencyInjection\Reference;
+
+final class DbalTracingPass implements CompilerPassInterface
+{
+    /**
+     * This is the format used by the DoctrineBundle bundle to register the
+     * services for each connection.
+     */
+    private const CONNECTION_SERVICE_NAME_FORMAT = 'doctrine.dbal.%s_connection';
+
+    /**
+     * This is the format used by the DoctrineBundle bundle to register the
+     * services for each connection's configuration.
+     */
+    private const CONNECTION_CONFIG_SERVICE_NAME_FORMAT = 'doctrine.dbal.%s_connection.configuration';
+
+    /**
+     * {@inheritdoc}
+     */
+    public function process(ContainerBuilder $container): void
+    {
+        if (!$container->hasParameter('doctrine.connections')) {
+            return;
+        }
+
+        /** @var string[] $connections */
+        $connections = $container->getParameter('doctrine.connections');
+
+        /** @var string[] $connectionsToTrace */
+        $connectionsToTrace = $container->getParameter('sentry.tracing.dbal.connections');
+
+        foreach ($connectionsToTrace as $connectionName) {
+            if (!\in_array(sprintf(self::CONNECTION_SERVICE_NAME_FORMAT, $connectionName), $connections, true)) {
+                continue;
+            }
+
+            if (version_compare(PrettyVersions::getVersion('doctrine/dbal')->getPrettyVersion(), '3.0.0', '>=')) {
+                $this->configureConnectionForDoctrineDBALVersion3($container, $connectionName);
+            } else {
+                $this->configureConnectionForDoctrineDBALVersion2($container, $connectionName);
+            }
+        }
+    }
+
+    private function configureConnectionForDoctrineDBALVersion3(ContainerBuilder $container, string $connectionName): void
+    {
+        $configurationDefinition = $container->getDefinition(sprintf(self::CONNECTION_CONFIG_SERVICE_NAME_FORMAT, $connectionName));
+        $setMiddlewaresMethodCallArguments = $this->getSetMiddlewaresMethodCallArguments($configurationDefinition);
+        $setMiddlewaresMethodCallArguments[0] = array_merge($setMiddlewaresMethodCallArguments[0] ?? [], [new Reference(TracingDriverMiddleware::class)]);
+
+        $configurationDefinition
+            ->removeMethodCall('setMiddlewares')
+            ->addMethodCall('setMiddlewares', $setMiddlewaresMethodCallArguments);
+    }
+
+    private function configureConnectionForDoctrineDBALVersion2(ContainerBuilder $container, string $connectionName): void
+    {
+        $connectionDefinition = $container->getDefinition(sprintf(self::CONNECTION_SERVICE_NAME_FORMAT, $connectionName));
+        $connectionDefinition->setConfigurator([new Reference(ConnectionConfigurator::class), 'configure']);
+    }
+
+    /**
+     * @return mixed[]
+     */
+    private function getSetMiddlewaresMethodCallArguments(Definition $definition): array
+    {
+        foreach ($definition->getMethodCalls() as $methodCall) {
+            if ('setMiddlewares' === $methodCall[0]) {
+                return $methodCall[1];
+            }
+        }
+
+        return [];
+    }
+}

src/DependencyInjection/Compiler/DbalTracingPass.php

@@ -154,9 +154,8 @@ private function addDistributedTracingSection(ArrayNodeDefinition $rootNode): vo
                     ->addDefaultsIfNotSet()
                     ->children()
                         ->arrayNode('dbal')
-                            ->addDefaultsIfNotSet()
-                            ->fixXmlConfig('connection')
                             ->canBeEnabled()
+                            ->fixXmlConfig('connection')
                             ->children()
                                 ->arrayNode('connections')
                                     ->defaultValue(class_exists(DoctrineBundle::class) ? ['%doctrine.default_connection%'] : [])

src/DependencyInjection/Configuration.php

@@ -67,6 +67,10 @@
             <argument type="service" id="Sentry\State\HubInterface" />
         </service>
 
+        <service id="Sentry\SentryBundle\Tracing\Doctrine\DBAL\ConnectionConfigurator" class="Sentry\SentryBundle\Tracing\Doctrine\DBAL\ConnectionConfigurator">
+            <argument type="service" id="Sentry\SentryBundle\Tracing\Doctrine\DBAL\TracingDriverMiddleware" />
+        </service>
+
         <service id="Sentry\Integration\RequestFetcherInterface" class="Sentry\SentryBundle\Integration\RequestFetcher">
             <argument type="service" id="Symfony\Component\HttpFoundation\RequestStack" />
             <argument type="service" id="Symfony\Bridge\PsrHttpMessage\HttpMessageFactoryInterface" on-invalid="null" />

src/Resources/config/services.xml

@@ -4,7 +4,7 @@
 
 namespace Sentry\SentryBundle;
 
-use Sentry\SentryBundle\DependencyInjection\Compiler\DbalTracingDriverPass;
+use Sentry\SentryBundle\DependencyInjection\Compiler\DbalTracingPass;
 use Symfony\Component\DependencyInjection\ContainerBuilder;
 use Symfony\Component\HttpKernel\Bundle\Bundle;
 
@@ -16,6 +16,6 @@ public function build(ContainerBuilder $container): void
     {
         parent::build($container);
 
-        $container->addCompilerPass(new DbalTracingDriverPass());
+        $container->addCompilerPass(new DbalTracingPass());
     }
 }

src/SentryBundle.php

@@ -0,0 +1,12 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Sentry\SentryBundle\Tracing\Doctrine\DBAL\Compatibility;
+
+/**
+ * @internal
+ */
+interface ExceptionConverterDriverInterface
+{
+}

src/Tracing/Doctrine/DBAL/Compatibility/ExceptionConverterDriverInterface.php

@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Sentry\SentryBundle\Tracing\Doctrine\DBAL\Compatibility;
+
+use Doctrine\DBAL\Driver as DriverInterface;
+
+/**
+ * @internal
+ */
+interface MiddlewareInterface
+{
+    public function wrap(DriverInterface $driver): DriverInterface;
+}

src/Tracing/Doctrine/DBAL/Compatibility/MiddlewareInterface.php

@@ -0,0 +1,46 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Sentry\SentryBundle\Tracing\Doctrine\DBAL;
+
+use Doctrine\DBAL\Connection;
+
+/**
+ * @internal
+ */
+final class ConnectionConfigurator
+{
+    /**
+     * @var TracingDriverMiddleware
+     */
+    private $tracingDriverMiddleware;
+
+    /**
+     * Constructor.
+     *
+     * @param TracingDriverMiddleware $tracingDriverMiddleware The driver middleware
+     */
+    public function __construct(TracingDriverMiddleware $tracingDriverMiddleware)
+    {
+        $this->tracingDriverMiddleware = $tracingDriverMiddleware;
+    }
+
+    /**
+     * Configures the given connecton by wrapping its driver into an instance
+     * of the {@see TracingDriver} class. This is done using the reflection,
+     * and as such should be limited only to the versions of Doctrine DBAL that
+     * are lower than 3.0. Since 3.0 onwards, the concept of driver middlewares
+     * has been introduced which allows the same thing we're doing here, but in
+     * a more appropriate and "legal" way.
+     *
+     * @param Connection $connection The connection to configure
+     */
+    public function configure(Connection $connection): void
+    {
+        $reflectionProperty = new \ReflectionProperty($connection, '_driver');
+        $reflectionProperty->setAccessible(true);
+        $reflectionProperty->setValue($connection, $this->tracingDriverMiddleware->wrap($reflectionProperty->getValue($connection)));
+        $reflectionProperty->setAccessible(false);
+    }
+}