Add spans for Redis commands

Author: stayallive

config/sentry.php

@@ -47,6 +47,12 @@
         // Capture views as spans
         'views' => true,
 
+        // Capture Redis operations as spans (this enables Redis events in Laravel)
+        'redis_commands' => env('SENTRY_TRACE_REDIS_COMMANDS', false),
+
+        // Try to find out where the Redis command originated from and add it to the command spans
+        'redis_origin' => true,
+
         // Capture HTTP client requests as spans
         'http_client_requests' => true,
 

src/Sentry/Laravel/Tracing/EventHandler.php

@@ -9,6 +9,7 @@
 use Illuminate\Queue\Events as QueueEvents;
 use Illuminate\Queue\Queue;
 use Illuminate\Queue\QueueManager;
+use Illuminate\Redis\Events as RedisEvents;
 use Illuminate\Routing\Events as RoutingEvents;
 use RuntimeException;
 use Sentry\Laravel\Integration;
@@ -31,6 +32,7 @@ class EventHandler
      */
     protected static $eventHandlerMap = [
         RoutingEvents\RouteMatched::class => 'routeMatched',
+        RedisEvents\CommandExecuted::class => 'redisCommandExecuted',
         DatabaseEvents\QueryExecuted::class => 'queryExecuted',
         HttpClientEvents\RequestSending::class => 'httpClientRequestSending',
         HttpClientEvents\ResponseReceived::class => 'httpClientResponseReceived',
@@ -59,12 +61,26 @@ class EventHandler
     private $traceSqlQueries;
 
     /**
-     * Indicates if we should we add SQL query origin data to query spans.
+     * Indicates if we should we add SQL query origin data to the query spans.
      *
      * @var bool
      */
     private $traceSqlQueryOrigins;
 
+    /**
+     * Indicates if we should we add Redis commands as spans.
+     *
+     * @var bool
+     */
+    private $traceRedisCommands;
+
+    /**
+     * Indicates if we should we add Redis command origin data to the command spans.
+     *
+     * @var bool
+     */
+    private $traceRedisCommandOrigins;
+
     /**
      * Indicates if we should trace queue job spans.
      *
@@ -115,6 +131,9 @@ public function __construct(array $config, BacktraceHelper $backtraceHelper)
         $this->traceSqlQueries = ($config['sql_queries'] ?? true) === true;
         $this->traceSqlQueryOrigins = ($config['sql_origin'] ?? true) === true;
 
+        $this->traceRedisCommands = ($config['redis_commands'] ?? false) === true;
+        $this->traceRedisCommandOrigins = ($config['redis_origin'] ?? true) === true;
+
         $this->traceHttpClientRequests = ($config['http_client_requests'] ?? true) === true;
 
         $this->traceQueueJobs = ($config['queue_jobs'] ?? false) === true;
@@ -128,6 +147,7 @@ public function __construct(array $config, BacktraceHelper $backtraceHelper)
      *
      * @uses self::routeMatchedHandler()
      * @uses self::queryExecutedHandler()
+     * @uses self::redisCommandExecutedHandler()
      * @uses self::transactionBeginningHandler()
      * @uses self::transactionCommittedHandler()
      * @uses self::transactionRolledBackHandler()
@@ -176,7 +196,7 @@ public function subscribeQueueEvents(Dispatcher $dispatcher, QueueManager $queue
      * Pass through the event and capture any errors.
      *
      * @param string $method
-     * @param array  $arguments
+     * @param array $arguments
      */
     public function __call(string $method, array $arguments)
     {
@@ -227,7 +247,7 @@ protected function queryExecutedHandler(DatabaseEvents\QueryExecuted $query): vo
         $context->setEndTimestamp($context->getStartTimestamp() + $query->time / 1000);
 
         if ($this->traceSqlQueryOrigins) {
-            $queryOrigin = $this->resolveQueryOriginFromBacktrace();
+            $queryOrigin = $this->resolveEventOriginFromBacktrace();
 
             if ($queryOrigin !== null) {
                 $context->setData(['sql.origin' => $queryOrigin]);
@@ -238,11 +258,11 @@ protected function queryExecutedHandler(DatabaseEvents\QueryExecuted $query): vo
     }
 
     /**
-     * Try to find the origin of the SQL query that was just executed.
+     * Try to find the origin of the event we are currently recording.
      *
      * @return string|null
      */
-    private function resolveQueryOriginFromBacktrace(): ?string
+    private function resolveEventOriginFromBacktrace(): ?string
     {
         $firstAppFrame = $this->backtraceHelper->findFirstInAppFrameForBacktrace(debug_backtrace(DEBUG_BACKTRACE_IGNORE_ARGS));
 
@@ -255,6 +275,45 @@ private function resolveQueryOriginFromBacktrace(): ?string
         return "{$filePath}:{$firstAppFrame->getLine()}";
     }
 
+    protected function redisCommandExecutedHandler(RedisEvents\CommandExecuted $event): void
+    {
+        if (!$this->traceRedisCommands) {
+            return;
+        }
+
+        $parentSpan = SentrySdk::getCurrentHub()->getSpan();
+
+        // If there is no tracing span active there is no need to handle the event
+        if ($parentSpan === null) {
+            return;
+        }
+
+        // @TODO: Do we need/want to prefix all data with `db.redis`? It's already in the `db.redis` op so maybe it's not needed?
+        $data = [
+            'db.redis.connection' => $event->connectionName,
+            // @TODO: Sending all the parameters should possibly be locked behind `send_default_pii`? It does contain sensitive data but also Redis integration is opt-in so maybe it's fine?
+            'db.redis.parameters' => $event->parameters,
+        ];
+
+        $context = new SpanContext();
+        $context->setOp('db.redis');
+        $context->setDescription(strtoupper($event->command) . ' ' . ($event->parameters[0] ?? null));
+        $context->setStartTimestamp(microtime(true) - $event->time / 1000);
+        $context->setEndTimestamp($context->getStartTimestamp() + $event->time / 1000);
+
+        if ($this->traceRedisCommandOrigins) {
+            $commandOrigin = $this->resolveEventOriginFromBacktrace();
+
+            if ($commandOrigin !== null) {
+                $data['db.redis.origin'] = $commandOrigin;
+            }
+        }
+
+        $context->setData($data);
+
+        $parentSpan->startChild($context);
+    }
+
     protected function transactionBeginningHandler(DatabaseEvents\TransactionBeginning $event): void
     {
         $parentSpan = SentrySdk::getCurrentHub()->getSpan();
@@ -316,7 +375,7 @@ protected function httpClientResponseReceivedHandler(HttpClientEvents\ResponseRe
         if (!$this->traceHttpClientRequests) {
             return;
         }
-    
+
         $span = $this->popSpan();
 
         if ($span !== null) {

src/Sentry/Laravel/Tracing/ServiceProvider.php

@@ -8,6 +8,7 @@
 use Illuminate\Contracts\View\Engine;
 use Illuminate\Contracts\View\View;
 use Illuminate\Foundation\Http\Kernel as HttpKernel;
+use Illuminate\Redis\RedisManager;
 use Illuminate\Routing\Contracts\CallableDispatcher;
 use Illuminate\Routing\Contracts\ControllerDispatcher;
 use Illuminate\View\Engines\EngineResolver;
@@ -86,6 +87,13 @@ private function bindEvents(array $tracingConfig): void
         } catch (BindingResolutionException $e) {
             // If we cannot resolve the event dispatcher we also cannot listen to events
         }
+
+        // Enable Redis events in the framework if the user has enabled it
+        if (($tracingConfig['redis_commands'] ?? false) === true) {
+            $this->app->afterResolving(RedisManager::class, static function (RedisManager $redis): void {
+                $redis->enableEvents();
+            });
+        }
     }
 
     private function bindViewEngine($tracingConfig): void