ddtrace 0.11.4 → 0.12.0.beta1

data/lib/ddtrace/contrib/graphql/patcher.rb

@@ -0,0 +1,57 @@
+require 'ddtrace/ext/app_types'
+require 'ddtrace/ext/http'
+
+module Datadog
+  module Contrib
+    module GraphQL
+      # Provides instrumentation for `graphql` through the GraphQL tracing framework
+      module Patcher
+        include Base
+        register_as :graphql
+
+        option :tracer, default: Datadog.tracer
+        option :service_name, default: 'ruby-graphql', depends_on: [:tracer] do |value|
+          get_option(:tracer).set_service_info(value, 'ruby-graphql', Ext::AppTypes::WEB)
+          value
+        end
+        option :schemas
+
+        class << self
+          def patch
+            return patched? if patched? || !compatible? || get_option(:schemas).nil?
+
+            get_option(:schemas).each { |s| patch_schema!(s) }
+
+            @patched = true
+          end
+
+          def patch_schema!(schema)
+            tracer = get_option(:tracer)
+            service_name = get_option(:service_name)
+
+            schema.define do
+              use(
+                ::GraphQL::Tracing::DataDogTracing,
+                tracer: tracer,
+                service: service_name
+              )
+            end
+          end
+
+          def patched?
+            return @patched if defined?(@patched)
+            @patched = false
+          end
+
+          private
+
+          def compatible?
+            defined?(::GraphQL) \
+              && defined?(::GraphQL::Tracing::DataDogTracing) \
+              && Gem.loaded_specs['graphql'].version >= Gem::Version.new('1.7.9')
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -37,10 +37,6 @@ 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]
@@ -64,7 +60,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, original_env)
+          set_request_tags!(request_span, env, status, headers, response)
 
           # ensure the request_span is finished and the context reset;
           # this assumes that the Rack middleware creates a root span
@@ -84,19 +80,13 @@ module Datadog
           end
         end
 
-        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']
+        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']
           request_id = get_request_id(headers, env)
 
           request_span.resource ||= resource_name_for(env, status)

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

@@ -6,13 +6,9 @@ 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
-          do_once(:instrument) do
-            Datadog::RailsActionPatcher.patch_action_controller
-          end
+          Datadog::RailsActionPatcher.patch_action_controller
         end
 
         def self.start_processing(payload)
@@ -50,14 +46,20 @@ module Datadog
             span.set_tag('rails.route.action', payload.fetch(:action))
             span.set_tag('rails.route.controller', payload.fetch(:controller))
 
-            exception = payload[:exception_object]
-            if exception.nil?
+            if payload[: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')
-            elsif Utils.exception_is_error?(exception)
-              span.set_error(exception)
+            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')
             end
           ensure
             span.finish()

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

@@ -5,13 +5,9 @@ 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
-          do_once(:instrument) do
-            Datadog::RailsRendererPatcher.patch_renderer
-          end
+          Datadog::RailsRendererPatcher.patch_renderer
         end
 
         def self.start_render_template(payload)

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

@@ -1,5 +1,4 @@
 require 'ddtrace/ext/sql'
-
 require 'ddtrace/contrib/rails/utils'
 
 module Datadog
@@ -7,16 +6,19 @@ 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)
 
-          do_once(:instrument) do
-            # subscribe when the active record query has been processed
-            ::ActiveSupport::Notifications.subscribe('sql.active_record') do |*args|
-              sql(*args)
+          # subscribe when the active record query has been processed
+          ::ActiveSupport::Notifications.subscribe('sql.active_record') do |*args|
+            sql(*args)
+          end
+
+          if Datadog::Contrib::Rails::Patcher.active_record_instantiation_tracing_supported?
+            # subscribe when the active record instantiates objects
+            ::ActiveSupport::Notifications.subscribe('instantiation.active_record') do |*args|
+              instantiation(*args)
             end
           end
         end
@@ -24,14 +26,16 @@ module Datadog
         def self.sql(_name, start, finish, _id, payload)
           tracer = Datadog.configuration[:rails][:tracer]
           database_service = Datadog.configuration[:rails][:database_service]
-          connection_config = Datadog::Contrib::Rails::Utils.connection_config(payload[:connection_id])
-          span_type = Datadog::Ext::SQL::TYPE
+          adapter_name = Datadog::Contrib::Rails::Utils.adapter_name
+          database_name = Datadog::Contrib::Rails::Utils.database_name
+          adapter_host = Datadog::Contrib::Rails::Utils.adapter_host
+          adapter_port = Datadog::Contrib::Rails::Utils.adapter_port
 
           span = tracer.trace(
-            "#{connection_config[:adapter_name]}.query",
+            "#{adapter_name}.query",
             resource: payload.fetch(:sql),
             service: database_service,
-            span_type: span_type
+            span_type: Datadog::Ext::SQL::TYPE
           )
 
           # Find out if the SQL query has been cached in this request. This meta is really
@@ -42,16 +46,33 @@ module Datadog
           # the span should have the query ONLY in the Resource attribute,
           # so that the ``sql.query`` tag will be set in the agent with an
           # obfuscated version
-          span.span_type = Datadog::Ext::SQL::TYPE
-          span.set_tag('rails.db.vendor', connection_config[:adapter_name])
-          span.set_tag('rails.db.name', connection_config[:database_name])
+          span.set_tag('rails.db.vendor', adapter_name)
+          span.set_tag('rails.db.name', database_name)
           span.set_tag('rails.db.cached', cached) if cached
-          span.set_tag('out.host', connection_config[:adapter_host])
-          span.set_tag('out.port', connection_config[:adapter_port])
+          span.set_tag('out.host', adapter_host)
+          span.set_tag('out.port', adapter_port)
+          span.start_time = start
+          span.finish(finish)
+        rescue StandardError => e
+          Datadog::Tracer.log.debug(e.message)
+        end
+
+        def self.instantiation(_name, start, finish, _id, payload)
+          tracer = Datadog.configuration[:rails][:tracer]
+
+          span = tracer.trace(
+            'active_record.instantiation',
+            resource: payload.fetch(:class_name),
+            span_type: 'custom'
+          )
+
+          span.service = span.parent ? span.parent.service : Datadog.configuration[:rails][:service_name]
+          span.set_tag('active_record.instantiation.class_name', payload.fetch(:class_name))
+          span.set_tag('active_record.instantiation.record_count', payload.fetch(:record_count))
           span.start_time = start
           span.finish(finish)
         rescue StandardError => e
-          Datadog::Tracer.log.error(e.message)
+          Datadog::Tracer.log.debug(e.message)
         end
       end
     end

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

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

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

@@ -4,211 +4,193 @@ module Datadog
   # rubocop:disable Metrics/MethodLength
   # rubocop:disable Metrics/ModuleLength
   module RailsRendererPatcher
-    include Datadog::Patcher
-
     module_function
 
     def patch_renderer
-      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
+      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
 
     def patch_template_renderer(klass)
-      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)
+      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
 
-          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)
+          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)
           end
 
-          # method aliasing to patch the class
-          alias_method :render_without_datadog, :render
-          alias_method :render, :render_with_datadog
+          # execute the original function anyway
+          render_template_without_datadog(*args)
+        end
 
-          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
+        # 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
         end
       end
     end
 
     def patch_partial_renderer(klass)
-      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)
-
-            # Then finish the span associated with the context
-            Datadog::Contrib::Rails::ActionView.finish_render_partial(tracing_context: tracing_context)
-          end
+      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
 
-          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)
+        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
 
-          # 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
+          # execute the original function anyway
+          render_partial_without_datadog(*args)
+        end
 
-          def current_span_id
-            Datadog.configuration[:rails][:tracer].call_context.current_span.span_id
-          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
 
-          # 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
+        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
       end
     end
   end
 
   # RailsActionPatcher contains functions to patch Rails action controller instrumentation
   module RailsActionPatcher
-    include Datadog::Patcher
-
     module_function
 
     def patch_action_controller
-      do_once(:patch_action_controller) do
-        patch_process_action
-      end
+      patch_process_action
     end
 
     def patch_process_action
-      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)
+      ::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
-
-          alias_method :process_action_without_datadog, :process_action
-          alias_method :process_action, :process_action_with_datadog
+        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
       end
     end
   end
 
   # RailsCachePatcher contains function to patch Rails caching libraries.
   module RailsCachePatcher
-    include Datadog::Patcher
-
     module_function
 
     def patch_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
+      patch_cache_store_read
+      patch_cache_store_fetch
+      patch_cache_store_write
+      patch_cache_store_delete
+      reload_cache_store
     end
 
     def cache_store_class(k)
@@ -228,116 +210,107 @@ module Datadog
     end
 
     def patch_cache_store_read
-      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)
+      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
       end
     end
 
     def patch_cache_store_fetch
-      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)
+      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
       end
     end
 
     def patch_cache_store_write
-      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)
+      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
       end
     end
 
     def patch_cache_store_delete
-      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)
+      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
       end
     end
 
     def self.reload_cache_store
-      redis = Datadog.registry[:redis]
-      return unless redis && redis.patched?
+      return unless Datadog.registry[:redis].patched?
 
       return unless defined?(::ActiveSupport::Cache::RedisStore) &&
                     defined?(::Rails.cache) &&