ddtrace 0.11.2 → 0.11.3

data/lib/ddtrace/contrib/rack/middlewares.rb

@@ -37,6 +37,10 @@ module Datadog
           request_span = tracer.trace('rack.request', trace_options)
           env[:datadog_rack_request_span] = request_span
 
+          # Copy the original env, before the rest of the stack executes.
+          # Values may change; we want values before that happens.
+          original_env = env.dup
+
           # call the rest of the stack
           status, headers, response = @app.call(env)
           [status, headers, response]
@@ -60,7 +64,7 @@ module Datadog
           # the result for this request; `resource` and `tags` are expected to
           # be set in another level but if they're missing, reasonable defaults
           # are used.
-          set_request_tags!(request_span, env, status, headers, response)
+          set_request_tags!(request_span, env, status, headers, response, original_env)
 
           # ensure the request_span is finished and the context reset;
           # this assumes that the Rack middleware creates a root span
@@ -80,13 +84,20 @@ module Datadog
           end
         end
 
-        def set_request_tags!(request_span, env, status, headers, response)
-          # the source of truth in Rack is the PATH_INFO key that holds the
-          # URL for the current request; some framework may override that
-          # value, especially during exception handling and because of that
-          # we prefer using the `REQUEST_URI` if this is available.
-          # NOTE: `REQUEST_URI` is Rails specific and may not apply for other frameworks
-          url = env['REQUEST_URI'] || env['PATH_INFO']
+        def set_request_tags!(request_span, env, status, headers, response, original_env)
+          # http://www.rubydoc.info/github/rack/rack/file/SPEC
+          # The source of truth in Rack is the PATH_INFO key that holds the
+          # URL for the current request; but some frameworks may override that
+          # value, especially during exception handling.
+          #
+          # Because of this, we prefer to use REQUEST_URI, if available, which is the
+          # relative path + query string, and doesn't mutate.
+          #
+          # REQUEST_URI is only available depending on what web server is running though.
+          # So when its not available, we want the original, unmutated PATH_INFO, which
+          # is just the relative path without query strings.
+          url = env['REQUEST_URI'] || original_env['PATH_INFO']
+          request_id = get_request_id(headers, env)
 
           request_span.resource ||= resource_name_for(env, status)
           if request_span.get_tag(Datadog::Ext::HTTP::METHOD).nil?
@@ -110,6 +121,9 @@ module Datadog
           if request_span.get_tag(Datadog::Ext::HTTP::STATUS_CODE).nil? && status
             request_span.set_tag(Datadog::Ext::HTTP::STATUS_CODE, status)
           end
+          if request_span.get_tag(Datadog::Ext::HTTP::REQUEST_ID).nil? && request_id
+            request_span.set_tag(Datadog::Ext::HTTP::REQUEST_ID, request_id)
+          end
 
           # detect if the status code is a 5xx and flag the request span as an error
           # unless it has been already set by the underlying framework
@@ -117,6 +131,14 @@ module Datadog
             request_span.status = 1
           end
         end
+
+        # If Rails is present, it will sanitize & use the Request ID header,
+        # or generate a UUID if no request ID header is present, then set that as headers['X-Request-Id'].
+        # Othewise use whatever Rack variables are present (they should all be the same.)
+        def get_request_id(headers, env)
+          headers ||= {}
+          headers['X-Request-Id'] || headers['X-Request-ID'] || env['HTTP_X_REQUEST_ID']
+        end
       end
     end
   end

data/lib/ddtrace/contrib/rails/action_controller.rb

@@ -6,9 +6,13 @@ module Datadog
     module Rails
       # Code used to create and handle 'rails.action_controller' spans.
       module ActionController
+        include Datadog::Patcher
+
         def self.instrument
           # patch Rails core components
-          Datadog::RailsActionPatcher.patch_action_controller
+          do_once(:instrument) do
+            Datadog::RailsActionPatcher.patch_action_controller
+          end
         end
 
         def self.start_processing(payload)
@@ -46,20 +50,14 @@ module Datadog
             span.set_tag('rails.route.action', payload.fetch(:action))
             span.set_tag('rails.route.controller', payload.fetch(:controller))
 
-            if payload[:exception].nil?
+            exception = payload[:exception_object]
+            if exception.nil?
               # [christian] in some cases :status is not defined,
               # rather than firing an error, simply acknowledge we don't know it.
               status = payload.fetch(:status, '?').to_s
               span.status = 1 if status.starts_with?('5')
-            else
-              error = payload[:exception]
-              if defined?(::ActionDispatch::ExceptionWrapper)
-                status = ::ActionDispatch::ExceptionWrapper.status_code_for_exception(error[0])
-                status = status ? status.to_s : '?'
-              else
-                status = '500'
-              end
-              span.set_error(error) if status.starts_with?('5')
+            elsif Utils.exception_is_error?(exception)
+              span.set_error(exception)
             end
           ensure
             span.finish()

data/lib/ddtrace/contrib/rails/action_view.rb

@@ -5,9 +5,13 @@ module Datadog
     module Rails
       # Code used to create and handle 'rails.render_template' and 'rails.render_partial' spans.
       module ActionView
+        include Datadog::Patcher
+
         def self.instrument
           # patch Rails core components
-          Datadog::RailsRendererPatcher.patch_renderer
+          do_once(:instrument) do
+            Datadog::RailsRendererPatcher.patch_renderer
+          end
         end
 
         def self.start_render_template(payload)

data/lib/ddtrace/contrib/rails/active_record.rb

@@ -7,13 +7,17 @@ module Datadog
     module Rails
       # Code used to create and handle 'mysql.query', 'postgres.query', ... spans.
       module ActiveRecord
+        include Datadog::Patcher
+
         def self.instrument
           # ActiveRecord is instrumented only if it's available
           return unless defined?(::ActiveRecord)
 
-          # subscribe when the active record query has been processed
-          ::ActiveSupport::Notifications.subscribe('sql.active_record') do |*args|
-            sql(*args)
+          do_once(:instrument) do
+            # subscribe when the active record query has been processed
+            ::ActiveSupport::Notifications.subscribe('sql.active_record') do |*args|
+              sql(*args)
+            end
           end
         end
 

data/lib/ddtrace/contrib/rails/active_support.rb

@@ -6,9 +6,13 @@ module Datadog
     module Rails
       # Code used to create and handle 'rails.cache' spans.
       module ActiveSupport
+        include Datadog::Patcher
+
         def self.instrument
-          # patch Rails core components
-          Datadog::RailsCachePatcher.patch_cache_store
+          do_once(:instrument) do
+            # patch Rails core components
+            Datadog::RailsCachePatcher.patch_cache_store
+          end
         end
 
         def self.start_trace_cache(payload)

data/lib/ddtrace/contrib/rails/core_extensions.rb

@@ -4,193 +4,211 @@ module Datadog
   # rubocop:disable Metrics/MethodLength
   # rubocop:disable Metrics/ModuleLength
   module RailsRendererPatcher
+    include Datadog::Patcher
+
     module_function
 
     def patch_renderer
-      if defined?(::ActionView::TemplateRenderer) && defined?(::ActionView::PartialRenderer)
-        patch_template_renderer(::ActionView::TemplateRenderer)
-        patch_partial_renderer(::ActionView::PartialRenderer)
-      elsif defined?(::ActionView::Rendering) && defined?(::ActionView::Partials::PartialRenderer)
-        # NOTE: Rails < 3.1 compatibility: different classes are used
-        patch_template_renderer(::ActionView::Rendering)
-        patch_partial_renderer(::ActionView::Partials::PartialRenderer)
-      else
-        Datadog::Tracer.log.debug('Expected Template/Partial classes not found; template rendering disabled')
+      do_once(:patch_renderer) do
+        if defined?(::ActionView::TemplateRenderer) && defined?(::ActionView::PartialRenderer)
+          patch_template_renderer(::ActionView::TemplateRenderer)
+          patch_partial_renderer(::ActionView::PartialRenderer)
+        elsif defined?(::ActionView::Rendering) && defined?(::ActionView::Partials::PartialRenderer)
+          # NOTE: Rails < 3.1 compatibility: different classes are used
+          patch_template_renderer(::ActionView::Rendering)
+          patch_partial_renderer(::ActionView::Partials::PartialRenderer)
+        else
+          Datadog::Tracer.log.debug('Expected Template/Partial classes not found; template rendering disabled')
+        end
       end
     end
 
     def patch_template_renderer(klass)
-      klass.class_eval do
-        def render_with_datadog(*args, &block)
-          # create a tracing context and start the rendering span
-          # NOTE: Rails < 3.1 compatibility: preserve the tracing
-          # context when a partial is rendered
-          @tracing_context ||= {}
-          if @tracing_context.empty?
-            Datadog::Contrib::Rails::ActionView.start_render_template(tracing_context: @tracing_context)
+      do_once(:patch_template_renderer) do
+        klass.class_eval do
+          def render_with_datadog(*args, &block)
+            # create a tracing context and start the rendering span
+            # NOTE: Rails < 3.1 compatibility: preserve the tracing
+            # context when a partial is rendered
+            @tracing_context ||= {}
+            if @tracing_context.empty?
+              Datadog::Contrib::Rails::ActionView.start_render_template(tracing_context: @tracing_context)
+            end
+
+            render_without_datadog(*args, &block)
+          rescue Exception => e
+            # attach the exception to the tracing context if any
+            @tracing_context[:exception] = e
+            raise e
+          ensure
+            # ensure that the template `Span` is finished even during exceptions
+            Datadog::Contrib::Rails::ActionView.finish_render_template(tracing_context: @tracing_context)
           end
 
-          render_without_datadog(*args)
-        rescue Exception => e
-          # attach the exception to the tracing context if any
-          @tracing_context[:exception] = e
-          raise e
-        ensure
-          # ensure that the template `Span` is finished even during exceptions
-          Datadog::Contrib::Rails::ActionView.finish_render_template(tracing_context: @tracing_context)
-        end
-
-        def render_template_with_datadog(*args)
-          begin
-            # arguments based on render_template signature (stable since Rails 3.2)
-            template = args[0]
-            layout_name = args[1]
-
-            # update the tracing context with computed values before the rendering
-            template_name = template.try('identifier')
-            template_name = Datadog::Contrib::Rails::Utils.normalize_template_name(template_name)
-            layout = if layout_name.is_a?(String)
-                       # NOTE: Rails < 3.1 compatibility: the second argument is the layout name
-                       layout_name
-                     else
-                       layout_name.try(:[], 'virtual_path')
-                     end
-            @tracing_context[:template_name] = template_name
-            @tracing_context[:layout] = layout
-          rescue StandardError => e
-            Datadog::Tracer.log.debug(e.message)
+          def render_template_with_datadog(*args)
+            begin
+              # arguments based on render_template signature (stable since Rails 3.2)
+              template = args[0]
+              layout_name = args[1]
+
+              # update the tracing context with computed values before the rendering
+              template_name = template.try('identifier')
+              template_name = Datadog::Contrib::Rails::Utils.normalize_template_name(template_name)
+              layout = if layout_name.is_a?(String)
+                         # NOTE: Rails < 3.1 compatibility: the second argument is the layout name
+                         layout_name
+                       else
+                         layout_name.try(:[], 'virtual_path')
+                       end
+              @tracing_context[:template_name] = template_name
+              @tracing_context[:layout] = layout
+            rescue StandardError => e
+              Datadog::Tracer.log.debug(e.message)
+            end
+
+            # execute the original function anyway
+            render_template_without_datadog(*args)
           end
 
-          # execute the original function anyway
-          render_template_without_datadog(*args)
-        end
+          # method aliasing to patch the class
+          alias_method :render_without_datadog, :render
+          alias_method :render, :render_with_datadog
 
-        # method aliasing to patch the class
-        alias_method :render_without_datadog, :render
-        alias_method :render, :render_with_datadog
-
-        if klass.private_method_defined?(:render_template) || klass.method_defined?(:render_template)
-          alias_method :render_template_without_datadog, :render_template
-          alias_method :render_template, :render_template_with_datadog
-        else
-          # NOTE: Rails < 3.1 compatibility: the method name is different
-          alias_method :render_template_without_datadog, :_render_template
-          alias_method :_render_template, :render_template_with_datadog
+          if klass.private_method_defined?(:render_template) || klass.method_defined?(:render_template)
+            alias_method :render_template_without_datadog, :render_template
+            alias_method :render_template, :render_template_with_datadog
+          else
+            # NOTE: Rails < 3.1 compatibility: the method name is different
+            alias_method :render_template_without_datadog, :_render_template
+            alias_method :_render_template, :render_template_with_datadog
+          end
         end
       end
     end
 
     def patch_partial_renderer(klass)
-      klass.class_eval do
-        def render_with_datadog(*args, &block)
-          # Create a tracing context and start the rendering span
-          tracing_context = {}
-          Datadog::Contrib::Rails::ActionView.start_render_partial(tracing_context: tracing_context)
-          tracing_contexts[current_span_id] = tracing_context
-
-          render_without_datadog(*args)
-        rescue Exception => e
-          # attach the exception to the tracing context if any
-          tracing_contexts[current_span_id][:exception] = e
-          raise e
-        ensure
-          # Ensure that the template `Span` is finished even during exceptions
-          # Remove the existing tracing context (to avoid leaks)
-          tracing_contexts.delete(current_span_id)
-
-          # Then finish the span associated with the context
-          Datadog::Contrib::Rails::ActionView.finish_render_partial(tracing_context: tracing_context)
-        end
+      do_once(:patch_partial_renderer) do
+        klass.class_eval do
+          def render_with_datadog(*args, &block)
+            # Create a tracing context and start the rendering span
+            tracing_context = {}
+            Datadog::Contrib::Rails::ActionView.start_render_partial(tracing_context: tracing_context)
+            tracing_contexts[current_span_id] = tracing_context
+
+            render_without_datadog(*args)
+          rescue Exception => e
+            # attach the exception to the tracing context if any
+            tracing_contexts[current_span_id][:exception] = e
+            raise e
+          ensure
+            # Ensure that the template `Span` is finished even during exceptions
+            # Remove the existing tracing context (to avoid leaks)
+            tracing_contexts.delete(current_span_id)
 
-        def render_partial_with_datadog(*args)
-          begin
-            # update the tracing context with computed values before the rendering
-            template_name = Datadog::Contrib::Rails::Utils.normalize_template_name(@template.try('identifier'))
-            tracing_contexts[current_span_id][:template_name] = template_name
-          rescue StandardError => e
-            Datadog::Tracer.log.debug(e.message)
+            # Then finish the span associated with the context
+            Datadog::Contrib::Rails::ActionView.finish_render_partial(tracing_context: tracing_context)
           end
 
-          # execute the original function anyway
-          render_partial_without_datadog(*args)
-        end
+          def render_partial_with_datadog(*args)
+            begin
+              # update the tracing context with computed values before the rendering
+              template_name = Datadog::Contrib::Rails::Utils.normalize_template_name(@template.try('identifier'))
+              tracing_contexts[current_span_id][:template_name] = template_name
+            rescue StandardError => e
+              Datadog::Tracer.log.debug(e.message)
+            end
+
+            # execute the original function anyway
+            render_partial_without_datadog(*args)
+          end
 
-        # Table of tracing contexts, one per partial/span, keyed by span_id
-        # because there will be multiple concurrent contexts, depending on how
-        # many partials are nested within one another.
-        def tracing_contexts
-          @tracing_contexts ||= {}
-        end
+          # Table of tracing contexts, one per partial/span, keyed by span_id
+          # because there will be multiple concurrent contexts, depending on how
+          # many partials are nested within one another.
+          def tracing_contexts
+            @tracing_contexts ||= {}
+          end
 
-        def current_span_id
-          Datadog.configuration[:rails][:tracer].call_context.current_span.span_id
-        end
+          def current_span_id
+            Datadog.configuration[:rails][:tracer].call_context.current_span.span_id
+          end
 
-        # method aliasing to patch the class
-        alias_method :render_without_datadog, :render
-        alias_method :render, :render_with_datadog
-        alias_method :render_partial_without_datadog, :render_partial
-        alias_method :render_partial, :render_partial_with_datadog
+          # method aliasing to patch the class
+          alias_method :render_without_datadog, :render
+          alias_method :render, :render_with_datadog
+          alias_method :render_partial_without_datadog, :render_partial
+          alias_method :render_partial, :render_partial_with_datadog
+        end
       end
     end
   end
 
   # RailsActionPatcher contains functions to patch Rails action controller instrumentation
   module RailsActionPatcher
+    include Datadog::Patcher
+
     module_function
 
     def patch_action_controller
-      patch_process_action
+      do_once(:patch_action_controller) do
+        patch_process_action
+      end
     end
 
     def patch_process_action
-      ::ActionController::Instrumentation.class_eval do
-        def process_action_with_datadog(*args)
-          # mutable payload with a tracing context that is used in two different
-          # signals; it propagates the request span so that it can be finished
-          # no matter what
-          payload = {
-            controller: self.class,
-            action: action_name,
-            headers: {
-              # The exception this controller was given in the request,
-              # which is typical if the controller is configured to handle exceptions.
-              request_exception: request.headers['action_dispatch.exception']
-            },
-            tracing_context: {}
-          }
-
-          begin
-            # process and catch request exceptions
-            Datadog::Contrib::Rails::ActionController.start_processing(payload)
-            result = process_action_without_datadog(*args)
-            payload[:status] = response.status
-            result
-          rescue Exception => e
-            payload[:exception] = [e.class.name, e.message]
-            payload[:exception_object] = e
-            raise e
+      do_once(:patch_process_action) do
+        ::ActionController::Instrumentation.class_eval do
+          def process_action_with_datadog(*args)
+            # mutable payload with a tracing context that is used in two different
+            # signals; it propagates the request span so that it can be finished
+            # no matter what
+            payload = {
+              controller: self.class,
+              action: action_name,
+              headers: {
+                # The exception this controller was given in the request,
+                # which is typical if the controller is configured to handle exceptions.
+                request_exception: request.headers['action_dispatch.exception']
+              },
+              tracing_context: {}
+            }
+
+            begin
+              # process and catch request exceptions
+              Datadog::Contrib::Rails::ActionController.start_processing(payload)
+              result = process_action_without_datadog(*args)
+              payload[:status] = response.status
+              result
+            rescue Exception => e
+              payload[:exception] = [e.class.name, e.message]
+              payload[:exception_object] = e
+              raise e
+            end
+          ensure
+            Datadog::Contrib::Rails::ActionController.finish_processing(payload)
           end
-        ensure
-          Datadog::Contrib::Rails::ActionController.finish_processing(payload)
-        end
 
-        alias_method :process_action_without_datadog, :process_action
-        alias_method :process_action, :process_action_with_datadog
+          alias_method :process_action_without_datadog, :process_action
+          alias_method :process_action, :process_action_with_datadog
+        end
       end
     end
   end
 
   # RailsCachePatcher contains function to patch Rails caching libraries.
   module RailsCachePatcher
+    include Datadog::Patcher
+
     module_function
 
     def patch_cache_store
-      patch_cache_store_read
-      patch_cache_store_fetch
-      patch_cache_store_write
-      patch_cache_store_delete
-      reload_cache_store
+      do_once(:patch_cache_store) do
+        patch_cache_store_read
+        patch_cache_store_fetch
+        patch_cache_store_write
+        patch_cache_store_delete
+        reload_cache_store
+      end
     end
 
     def cache_store_class(k)
@@ -210,107 +228,116 @@ module Datadog
     end
 
     def patch_cache_store_read
-      cache_store_class(:read).class_eval do
-        alias_method :read_without_datadog, :read
-        def read(*args, &block)
-          payload = {
-            action: 'GET',
-            key: args[0],
-            tracing_context: {}
-          }
-
-          begin
-            # process and catch cache exceptions
-            Datadog::Contrib::Rails::ActiveSupport.start_trace_cache(payload)
-            read_without_datadog(*args, &block)
-          rescue Exception => e
-            payload[:exception] = [e.class.name, e.message]
-            payload[:exception_object] = e
-            raise e
+      do_once(:patch_cache_store_read) do
+        cache_store_class(:read).class_eval do
+          alias_method :read_without_datadog, :read
+          def read(*args, &block)
+            payload = {
+              action: 'GET',
+              key: args[0],
+              tracing_context: {}
+            }
+
+            begin
+              # process and catch cache exceptions
+              Datadog::Contrib::Rails::ActiveSupport.start_trace_cache(payload)
+              read_without_datadog(*args, &block)
+            rescue Exception => e
+              payload[:exception] = [e.class.name, e.message]
+              payload[:exception_object] = e
+              raise e
+            end
+          ensure
+            Datadog::Contrib::Rails::ActiveSupport.finish_trace_cache(payload)
           end
-        ensure
-          Datadog::Contrib::Rails::ActiveSupport.finish_trace_cache(payload)
         end
       end
     end
 
     def patch_cache_store_fetch
-      cache_store_class(:fetch).class_eval do
-        alias_method :fetch_without_datadog, :fetch
-        def fetch(*args, &block)
-          payload = {
-            action: 'GET',
-            key: args[0],
-            tracing_context: {}
-          }
-
-          begin
-            # process and catch cache exceptions
-            Datadog::Contrib::Rails::ActiveSupport.start_trace_cache(payload)
-            fetch_without_datadog(*args, &block)
-          rescue Exception => e
-            payload[:exception] = [e.class.name, e.message]
-            payload[:exception_object] = e
-            raise e
+      do_once(:patch_cache_store_fetch) do
+        cache_store_class(:fetch).class_eval do
+          alias_method :fetch_without_datadog, :fetch
+          def fetch(*args, &block)
+            payload = {
+              action: 'GET',
+              key: args[0],
+              tracing_context: {}
+            }
+
+            begin
+              # process and catch cache exceptions
+              Datadog::Contrib::Rails::ActiveSupport.start_trace_cache(payload)
+              fetch_without_datadog(*args, &block)
+            rescue Exception => e
+              payload[:exception] = [e.class.name, e.message]
+              payload[:exception_object] = e
+              raise e
+            end
+          ensure
+            Datadog::Contrib::Rails::ActiveSupport.finish_trace_cache(payload)
           end
-        ensure
-          Datadog::Contrib::Rails::ActiveSupport.finish_trace_cache(payload)
         end
       end
     end
 
     def patch_cache_store_write
-      cache_store_class(:write).class_eval do
-        alias_method :write_without_datadog, :write
-        def write(*args, &block)
-          payload = {
-            action: 'SET',
-            key: args[0],
-            tracing_context: {}
-          }
-
-          begin
-            # process and catch cache exceptions
-            Datadog::Contrib::Rails::ActiveSupport.start_trace_cache(payload)
-            write_without_datadog(*args, &block)
-          rescue Exception => e
-            payload[:exception] = [e.class.name, e.message]
-            payload[:exception_object] = e
-            raise e
+      do_once(:patch_cache_store_write) do
+        cache_store_class(:write).class_eval do
+          alias_method :write_without_datadog, :write
+          def write(*args, &block)
+            payload = {
+              action: 'SET',
+              key: args[0],
+              tracing_context: {}
+            }
+
+            begin
+              # process and catch cache exceptions
+              Datadog::Contrib::Rails::ActiveSupport.start_trace_cache(payload)
+              write_without_datadog(*args, &block)
+            rescue Exception => e
+              payload[:exception] = [e.class.name, e.message]
+              payload[:exception_object] = e
+              raise e
+            end
+          ensure
+            Datadog::Contrib::Rails::ActiveSupport.finish_trace_cache(payload)
           end
-        ensure
-          Datadog::Contrib::Rails::ActiveSupport.finish_trace_cache(payload)
         end
       end
     end
 
     def patch_cache_store_delete
-      cache_store_class(:delete).class_eval do
-        alias_method :delete_without_datadog, :delete
-        def delete(*args, &block)
-          payload = {
-            action: 'DELETE',
-            key: args[0],
-            tracing_context: {}
-          }
-
-          begin
-            # process and catch cache exceptions
-            Datadog::Contrib::Rails::ActiveSupport.start_trace_cache(payload)
-            delete_without_datadog(*args, &block)
-          rescue Exception => e
-            payload[:exception] = [e.class.name, e.message]
-            payload[:exception_object] = e
-            raise e
+      do_once(:patch_cache_store_delete) do
+        cache_store_class(:delete).class_eval do
+          alias_method :delete_without_datadog, :delete
+          def delete(*args, &block)
+            payload = {
+              action: 'DELETE',
+              key: args[0],
+              tracing_context: {}
+            }
+
+            begin
+              # process and catch cache exceptions
+              Datadog::Contrib::Rails::ActiveSupport.start_trace_cache(payload)
+              delete_without_datadog(*args, &block)
+            rescue Exception => e
+              payload[:exception] = [e.class.name, e.message]
+              payload[:exception_object] = e
+              raise e
+            end
+          ensure
+            Datadog::Contrib::Rails::ActiveSupport.finish_trace_cache(payload)
           end
-        ensure
-          Datadog::Contrib::Rails::ActiveSupport.finish_trace_cache(payload)
         end
       end
     end
 
     def self.reload_cache_store
-      return unless Datadog.registry[:redis].patched?
+      redis = Datadog.registry[:redis]
+      return unless redis && redis.patched?
 
       return unless defined?(::ActiveSupport::Cache::RedisStore) &&
                     defined?(::Rails.cache) &&