Add a DBAL driver that supports distributed tracing

Author: ste93cry

composer.json

@@ -32,7 +32,6 @@
         "symfony/security-core": "^3.4.43||^4.4.11||^5.0.11"
     },
     "require-dev": {
-        "doctrine/dbal": "^2.10||^3.0",
         "doctrine/doctrine-bundle": "^2.2",
         "friendsofphp/php-cs-fixer": "^2.17",
         "jangregor/phpstan-prophecy": "^0.8",

src/DependencyInjection/Compiler/DbalSqlTracingLoggerPass.php

@@ -0,0 +1,58 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Sentry\SentryBundle\DependencyInjection\Compiler;
+
+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 DbalTracingDriverPass implements CompilerPassInterface
+{
+    /**
+     * {@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('doctrine.dbal.%s_connection', $connectionName), $connections, true)) {
+                continue;
+            }
+
+            $configurationDefinition = $container->getDefinition(sprintf('doctrine.dbal.%s_connection.configuration', $connectionName));
+            $setMiddlewaresMethodCallArguments = $this->getSetMiddlewaresMethodCallArguments($configurationDefinition);
+            $setMiddlewaresMethodCallArguments[0] = array_merge($setMiddlewaresMethodCallArguments[0] ?? [], [new Reference(TracingDriverMiddleware::class)]);
+
+            $configurationDefinition
+                ->removeMethodCall('setMiddlewares')
+                ->addMethodCall('setMiddlewares', $setMiddlewaresMethodCallArguments);
+        }
+    }
+
+    /**
+     * @return mixed[]
+     */
+    private function getSetMiddlewaresMethodCallArguments(Definition $definition): array
+    {
+        foreach ($definition->getMethodCalls() as $methodCall) {
+            if ('setMiddlewares' === $methodCall[0]) {
+                return $methodCall[1];
+            }
+        }
+
+        return [];
+    }
+}

src/DependencyInjection/Compiler/DbalTracingDriverPass.php

@@ -5,7 +5,6 @@
 namespace Sentry\SentryBundle\DependencyInjection;
 
 use Doctrine\Bundle\DoctrineBundle\DoctrineBundle;
-use InvalidArgumentException;
 use Jean85\PrettyVersions;
 use LogicException;
 use Sentry\Client;
@@ -18,7 +17,7 @@
 use Sentry\SentryBundle\EventListener\ErrorListener;
 use Sentry\SentryBundle\EventListener\MessengerListener;
 use Sentry\SentryBundle\SentryBundle;
-use Sentry\SentryBundle\Tracing\DbalSqlTracingLogger;
+use Sentry\SentryBundle\Tracing\Doctrine\DBAL\TracingDriverMiddleware;
 use Sentry\Serializer\RepresentationSerializer;
 use Sentry\Serializer\Serializer;
 use Sentry\Transport\TransportFactoryInterface;
@@ -145,7 +144,7 @@ private function registerErrorListenerConfiguration(ContainerBuilder $container,
      */
     private function registerMessengerListenerConfiguration(ContainerBuilder $container, array $config): void
     {
-        if (!$config['enabled']) {
+        if (!$this->isConfigEnabled($container, $config)) {
             $container->removeDefinition(MessengerListener::class);
 
             return;
@@ -159,14 +158,16 @@ private function registerMessengerListenerConfiguration(ContainerBuilder $contai
      */
     private function registerTracingConfiguration(ContainerBuilder $container, array $config): void
     {
-        if ($this->isConfigEnabled($container, $config['dbal']) && !class_exists(DoctrineBundle::class)) {
-            throw new LogicException('DBAL tracing support cannot be enabled as the DoctrineBundle bundle is not installed. Try running "composer require doctrine/doctrine-bundle".');
+        $isConfigEnabled = $this->isConfigEnabled($container, $config['dbal']);
+
+        if ($isConfigEnabled && !class_exists(DoctrineBundle::class)) {
+            throw new LogicException('DBAL tracing support cannot be enabled as the DoctrineBundle bundle is not installed.');
         }
 
-        $container->setParameter('sentry.tracing.dbal.connections', $config['dbal']['enabled'] ? $config['dbal']['connections'] : []);
+        $container->setParameter('sentry.tracing.dbal.connections', $isConfigEnabled ? $config['dbal']['connections'] : []);
 
-        if (!$config['dbal']['enabled']) {
-            $container->removeDefinition(DbalSqlTracingLogger::class);
+        if (!$isConfigEnabled) {
+            $container->removeDefinition(TracingDriverMiddleware::class);
         }
     }
 
@@ -237,16 +238,4 @@ private function isIntegrationEnabled(string $integrationClass, array $integrati
 
         return false;
     }
-
-    /**
-     * @param array<string, mixed> $config
-     */
-    protected function isConfigEnabled(ContainerBuilder $container, array $config): bool
-    {
-        if (!isset($config['enabled'])) {
-            throw new InvalidArgumentException('The $config argument has no key named "enabled".');
-        }
-
-        return (bool) $container->getParameterBag()->resolveValue($config['enabled']);
-    }
 }

src/DependencyInjection/SentryExtension.php

@@ -63,7 +63,7 @@
             <tag name="console.command" />
         </service>
 
-        <service id="Sentry\SentryBundle\Tracing\DbalSqlTracingLogger" class="Sentry\SentryBundle\Tracing\DbalSqlTracingLogger">
+        <service id="Sentry\SentryBundle\Tracing\Doctrine\DBAL\TracingDriverMiddleware" class="Sentry\SentryBundle\Tracing\Doctrine\DBAL\TracingDriverMiddleware">
             <argument type="service" id="Sentry\State\HubInterface" />
         </service>
 

src/Resources/config/services.xml

@@ -4,7 +4,7 @@
 
 namespace Sentry\SentryBundle;
 
-use Sentry\SentryBundle\DependencyInjection\Compiler\DbalSqlTracingLoggerPass;
+use Sentry\SentryBundle\DependencyInjection\Compiler\DbalTracingDriverPass;
 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 DbalSqlTracingLoggerPass());
+        $container->addCompilerPass(new DbalTracingDriverPass());
     }
 }

src/SentryBundle.php

@@ -0,0 +1,77 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Sentry\SentryBundle\Tracing\Doctrine\DBAL;
+
+use Doctrine\DBAL\Connection;
+use Doctrine\DBAL\Driver\API\ExceptionConverter;
+use Doctrine\DBAL\Driver as DriverInterface;
+use Doctrine\DBAL\Platforms\AbstractPlatform;
+use Sentry\State\HubInterface;
+
+/**
+ * This is a simple implementation of the {@see DriverInterface} interface that
+ * decorates an existing driver to support distributed tracing capabilities.
+ */
+final class TracingDriver implements DriverInterface
+{
+    /**
+     * @var HubInterface The current hub
+     */
+    private $hub;
+
+    /**
+     * @var DriverInterface The instance of the decorated driver
+     */
+    private $decoratedDriver;
+
+    /**
+     * Constructor.
+     *
+     * @param HubInterface    $hub             The current hub
+     * @param DriverInterface $decoratedDriver The instance of the driver to decorate
+     */
+    public function __construct(HubInterface $hub, DriverInterface $decoratedDriver)
+    {
+        $this->hub = $hub;
+        $this->decoratedDriver = $decoratedDriver;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function connect(array $params)
+    {
+        return new TracingDriverConnection(
+            $this->hub,
+            $this->decoratedDriver->connect($params),
+            $this->decoratedDriver->getDatabasePlatform()->getName(),
+            $params
+        );
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function getDatabasePlatform()
+    {
+        return $this->decoratedDriver->getDatabasePlatform();
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function getSchemaManager(Connection $conn, AbstractPlatform $platform)
+    {
+        return $this->decoratedDriver->getSchemaManager($conn, $platform);
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function getExceptionConverter(): ExceptionConverter
+    {
+        return $this->decoratedDriver->getExceptionConverter();
+    }
+}