Add sql.origin to SQL query spans (#398)

Author: stayallive

config/sentry.php

@@ -37,6 +37,9 @@
         // Capture SQL queries as spans
         'sql_queries' => true,
 
+        // Try to find out where the SQL query originated from and add it to the query spans
+        'sql_origin' => true,
+
         // Capture views as spans
         'views' => true,
     ],

src/Sentry/Laravel/Tracing/BacktraceHelper.php

@@ -0,0 +1,110 @@
+<?php
+
+namespace Sentry\Laravel\Tracing;
+
+use Sentry\Frame;
+use Sentry\Options;
+use Sentry\FrameBuilder;
+use Illuminate\Support\Str;
+use Sentry\Serializer\RepresentationSerializerInterface;
+
+class BacktraceHelper
+{
+    /**
+     * @var Options The SDK client options
+     */
+    private $options;
+
+    /**
+     * @var FrameBuilder An instance of the builder of {@see Frame} objects
+     */
+    private $frameBuilder;
+
+    /**
+     * Constructor.
+     *
+     * @param Options                           $options                  The SDK client options
+     * @param RepresentationSerializerInterface $representationSerializer The representation serializer
+     */
+    public function __construct(Options $options, RepresentationSerializerInterface $representationSerializer)
+    {
+        $this->options = $options;
+        $this->frameBuilder = new FrameBuilder($options, $representationSerializer);
+    }
+
+    /**
+     * Find the first in app frame for a given backtrace.
+     *
+     * @param array<int, array<string, mixed>> $backtrace The backtrace
+     *
+     * @phpstan-param list<array{
+     *     line?: integer,
+     *     file?: string,
+     * }> $backtrace
+     */
+    public function findFirstInAppFrameForBacktrace(array $backtrace): ?Frame
+    {
+        $file = Frame::INTERNAL_FRAME_FILENAME;
+        $line = 0;
+
+        foreach ($backtrace as $backtraceFrame) {
+            $frame = $this->frameBuilder->buildFromBacktraceFrame($file, $line, $backtraceFrame);
+
+            if ($frame->isInApp()) {
+                return $frame;
+            }
+
+            $file = $backtraceFrame['file'] ?? Frame::INTERNAL_FRAME_FILENAME;
+            $line = $backtraceFrame['line'] ?? 0;
+        }
+
+        return null;
+    }
+
+    /**
+     * Takes a frame and if it's a compiled view path returns the original view path.
+     *
+     * @param \Sentry\Frame $frame
+     *
+     * @return string|null
+     */
+    public function getOriginalViewPathForFrameOfCompiledViewPath(Frame $frame): ?string
+    {
+        // Check if we are dealing with a frame for a cached view path
+        if (!Str::startsWith($frame->getFile(), '/storage/framework/views/')) {
+            return null;
+        }
+
+        // If for some reason the file does not exists, skip resolving
+        if (!file_exists($frame->getAbsoluteFilePath())) {
+            return null;
+        }
+
+        $viewFileContents = file_get_contents($frame->getAbsoluteFilePath());
+
+        preg_match('/PATH (?<originalPath>.*?) ENDPATH/', $viewFileContents, $matches);
+
+        // No path comment found in the file, must be a very old Laravel version
+        if (empty($matches['originalPath'])) {
+            return null;
+        }
+
+        return $this->stripPrefixFromFilePath($matches['originalPath']);
+    }
+
+    /**
+     * Removes from the given file path the specified prefixes.
+     *
+     * @param string $filePath The path to the file
+     */
+    private function stripPrefixFromFilePath(string $filePath): string
+    {
+        foreach ($this->options->getPrefixes() as $prefix) {
+            if (Str::startsWith($filePath, $prefix)) {
+                return mb_substr($filePath, mb_strlen($prefix));
+            }
+        }
+
+        return $filePath;
+    }
+}

src/Sentry/Laravel/Tracing/EventHandler.php

@@ -53,6 +53,13 @@ class EventHandler
      */
     private $traceSqlQueries;
 
+    /**
+     * Indicates if we should we add SQL query origin data to query spans.
+     *
+     * @var bool
+     */
+    private $traceSqlQueryOrigins;
+
     /**
      * Indicates if we should trace queue job spans.
      *
@@ -81,17 +88,28 @@ class EventHandler
      */
     private $currentQueueJobSpan;
 
+    /**
+     * The backtrace helper.
+     *
+     * @var \Sentry\Laravel\Tracing\BacktraceHelper
+     */
+    private $backtraceHelper;
+
     /**
      * EventHandler constructor.
      *
      * @param \Illuminate\Contracts\Container\Container $container
+     * @param \Sentry\Laravel\Tracing\BacktraceHelper   $backtraceHelper
      * @param array                                     $config
      */
-    public function __construct(Container $container, array $config)
+    public function __construct(Container $container, BacktraceHelper $backtraceHelper, array $config)
     {
         $this->container = $container;
+        $this->backtraceHelper = $backtraceHelper;
 
         $this->traceSqlQueries = ($config['sql_queries'] ?? true) === true;
+        $this->traceSqlQueryOrigins = ($config['sql_origin'] ?? true) === true;
+
         $this->traceQueueJobs = ($config['queue_jobs'] ?? false) === true;
         $this->traceQueueJobsAsTransactions = ($config['queue_job_transactions'] ?? false) === true;
     }
@@ -210,10 +228,36 @@ private function recordQuerySpan($query, $time): void
         $context->setStartTimestamp(microtime(true) - $time / 1000);
         $context->setEndTimestamp($context->getStartTimestamp() + $time / 1000);
 
+        if ($this->traceSqlQueryOrigins) {
+            $queryOrigin = $this->resolveQueryOriginFromBacktrace($context);
+
+            if ($queryOrigin !== null) {
+                $context->setData(['sql.origin' => $queryOrigin]);
+            }
+        }
+
         $parentSpan->startChild($context);
     }
 
     /**
+     * Try to find the origin of the SQL query that was just executed.
+     *
+     * @return string|null
+     */
+    private function resolveQueryOriginFromBacktrace(): ?string
+    {
+        $firstAppFrame = $this->backtraceHelper->findFirstInAppFrameForBacktrace(debug_backtrace(DEBUG_BACKTRACE_IGNORE_ARGS));
+
+        if ($firstAppFrame === null) {
+            return null;
+        }
+
+        $filePath = $this->backtraceHelper->getOriginalViewPathForFrameOfCompiledViewPath($firstAppFrame) ?? $firstAppFrame->getFile();
+
+        return "{$filePath}:{$firstAppFrame->getLine()}";
+    }
+
+    /*
      * Since Laravel 5.2
      *
      * @param \Illuminate\Queue\Events\JobProcessing $event

src/Sentry/Laravel/Tracing/ServiceProvider.php

@@ -8,8 +8,10 @@
 use Illuminate\Foundation\Http\Kernel as HttpKernel;
 use Illuminate\View\Engines\EngineResolver;
 use Illuminate\View\Factory as ViewFactory;
+use InvalidArgumentException;
 use Laravel\Lumen\Application as Lumen;
 use Sentry\Laravel\BaseServiceProvider;
+use Sentry\Serializer\RepresentationSerializer;
 
 class ServiceProvider extends BaseServiceProvider
 {
@@ -39,6 +41,15 @@ public function register(): void
     {
         $this->app->singleton(Middleware::class);
 
+        $this->app->singleton(BacktraceHelper::class, function () {
+            /** @var \Sentry\State\Hub $sentry */
+            $sentry = $this->app->make(self::$abstract);
+
+            $options = $sentry->getClient()->getOptions();
+
+            return new BacktraceHelper($options, new RepresentationSerializer($options));
+        });
+
         if (!$this->app instanceof Lumen) {
             $this->app->booted(function () {
                 $this->app->make(Middleware::class)->setBootedTimestamp();
@@ -48,7 +59,11 @@ public function register(): void
 
     private function bindEvents(array $tracingConfig): void
     {
-        $handler = new EventHandler($this->app, $tracingConfig);
+        $handler = new EventHandler(
+            $this->app,
+            $this->app->make(BacktraceHelper::class),
+            $tracingConfig
+        );
 
         $handler->subscribe();
 

test/Sentry/SentryLaravelTestCase.php

@@ -6,6 +6,7 @@
 use Sentry\Breadcrumb;
 use Sentry\State\Scope;
 use ReflectionProperty;
+use Sentry\Laravel\Tracing;
 use Sentry\State\HubInterface;
 use Sentry\Laravel\ServiceProvider;
 use Orchestra\Testbench\TestCase as LaravelTestCase;
@@ -30,6 +31,7 @@ protected function getPackageProviders($app)
     {
         return [
             ServiceProvider::class,
+            Tracing\ServiceProvider::class,
         ];
     }
 

test/Sentry/Tracing/EventHandlerTest.php

@@ -3,20 +3,21 @@
 namespace Sentry\Laravel\Tests\Tracing;
 
 use ReflectionClass;
-use Orchestra\Testbench\TestCase;
+use Sentry\Laravel\Tests\SentryLaravelTestCase;
+use Sentry\Laravel\Tracing\BacktraceHelper;
 use RuntimeException;
 use Sentry\Laravel\Tests\ExpectsException;
 use Sentry\Laravel\Tracing\EventHandler;
 
-class EventHandlerTest extends TestCase
+class EventHandlerTest extends SentryLaravelTestCase
 {
     use ExpectsException;
 
     public function test_missing_event_handler_throws_exception()
     {
         $this->safeExpectException(RuntimeException::class);
 
-        $handler = new EventHandler($this->app, []);
+        $handler = new EventHandler($this->app, $this->app->make(BacktraceHelper::class), []);
 
         $handler->thisIsNotAHandlerAndShouldThrowAnException();
     }
@@ -30,7 +31,7 @@ public function test_all_mapped_event_handlers_exist()
 
     private function tryAllEventHandlerMethods(array $methods): void
     {
-        $handler = new EventHandler($this->app, []);
+        $handler = new EventHandler($this->app, $this->app->make(BacktraceHelper::class), []);
 
         $methods = array_map(static function ($method) {
             return "{$method}Handler";