ddtrace 0.12.0.beta2 → 0.12.0.rc1

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

@@ -13,6 +13,8 @@ module Datadog
       # application. If request tags are not set by the app, they will be set using
       # information available at the Rack level.
       class TraceMiddleware
+        RACK_REQUEST_SPAN = 'datadog.rack_request_span'.freeze
+
         def initialize(app)
           @app = app
         end
@@ -35,7 +37,17 @@ module Datadog
           # start a new request span and attach it to the current Rack environment;
           # we must ensure that the span `resource` is set later
           request_span = tracer.trace('rack.request', trace_options)
-          env[:datadog_rack_request_span] = request_span
+          env[RACK_REQUEST_SPAN] = request_span
+
+          # TODO: For backwards compatibility; this attribute is deprecated.
+          env[:datadog_rack_request_span] = env[RACK_REQUEST_SPAN]
+
+          # Add deprecation warnings
+          add_deprecation_warnings(env)
+
+          # 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)
@@ -60,7 +72,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
@@ -73,20 +85,26 @@ module Datadog
         end
 
         def resource_name_for(env, status)
-          if Datadog.configuration[:rack][:middleware_names]
+          if Datadog.configuration[:rack][:middleware_names] && env['RESPONSE_MIDDLEWARE']
             "#{env['RESPONSE_MIDDLEWARE']}##{env['REQUEST_METHOD']}"
           else
             "#{env['REQUEST_METHOD']} #{status}".strip
           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)
@@ -94,7 +112,8 @@ module Datadog
             request_span.set_tag(Datadog::Ext::HTTP::METHOD, env['REQUEST_METHOD'])
           end
           if request_span.get_tag(Datadog::Ext::HTTP::URL).nil?
-            request_span.set_tag(Datadog::Ext::HTTP::URL, url)
+            options = Datadog.configuration[:rack][:quantize]
+            request_span.set_tag(Datadog::Ext::HTTP::URL, Datadog::Quantization::HTTP.url(url, options))
           end
           if request_span.get_tag(Datadog::Ext::HTTP::BASE_URL).nil?
             request_obj = ::Rack::Request.new(env)
@@ -129,6 +148,34 @@ module Datadog
           headers ||= {}
           headers['X-Request-Id'] || headers['X-Request-ID'] || env['HTTP_X_REQUEST_ID']
         end
+
+        private
+
+        REQUEST_SPAN_DEPRECATION_WARNING = %(
+          :datadog_rack_request_span is considered an internal symbol in the Rack env,
+          and has been been DEPRECATED. Public support for its usage is discontinued.
+          If you need the Rack request span, try using `Datadog.tracer.active_span`.
+          This key will be removed in version 0.14.0).freeze
+
+        def add_deprecation_warnings(env)
+          env.instance_eval do
+            def [](key)
+              if key == :datadog_rack_request_span && !@request_span_warning_issued
+                Datadog::Tracer.log.warn(REQUEST_SPAN_DEPRECATION_WARNING)
+                @request_span_warning_issued = true
+              end
+              super
+            end
+
+            def []=(key, value)
+              if key == :datadog_rack_request_span && !@request_span_warning_issued
+                Datadog::Tracer.log.warn(REQUEST_SPAN_DEPRECATION_WARNING)
+                @request_span_warning_issued = true
+              end
+              super
+            end
+          end
+        end
       end
     end
   end

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

@@ -8,6 +8,7 @@ module Datadog
         option :tracer, default: Datadog.tracer
         option :distributed_tracing, default: false
         option :middleware_names, default: false
+        option :quantize, default: {}
         option :application
         option :service_name, default: 'rack', depends_on: [:tracer] do |value|
           get_option(:tracer).set_service_info(value, 'rack', Ext::AppTypes::WEB)
@@ -17,12 +18,24 @@ module Datadog
         module_function
 
         def patch
-          return true if patched?
+          unless patched?
+            require_relative 'middlewares'
+            @patched = true
+          end
 
-          require_relative 'middlewares'
-          @patched = true
+          if !@middleware_patched && get_option(:middleware_names)
+            if get_option(:application)
+              enable_middleware_names
+              @middleware_patched = true
+            else
+              Datadog::Tracer.log.warn(%(
+              Rack :middleware_names requires you to also pass :application.
+              Middleware names have NOT been patched; please provide :application.
+              e.g. use: :rack, middleware_names: true, application: my_rack_app).freeze)
+            end
+          end
 
-          enable_middleware_names if get_option(:middleware_names)
+          @patched || @middleware_patched
         end
 
         def patched?
@@ -30,8 +43,7 @@ module Datadog
         end
 
         def enable_middleware_names
-          root = get_option(:application) || rails_app
-          retain_middleware_name(root)
+          retain_middleware_name(get_option(:application))
         rescue => e
           # We can safely ignore these exceptions since they happen only in the
           # context of middleware patching outside a Rails server process (eg. a
@@ -40,11 +52,6 @@ module Datadog
           Tracer.log.debug("Error patching middleware stack: #{e}")
         end
 
-        def rails_app
-          return unless Datadog.registry[:rails].compatible?
-          ::Rails.application.app
-        end
-
         def retain_middleware_name(middleware)
           return unless middleware && middleware.respond_to?(:call)
 

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_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,250 @@ 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)
+      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
+            # 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)
+          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
 
-          # 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
+          # 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
-
-        # 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
-      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
+        if Gem::Version.new(RUBY_VERSION) >= Gem::Version.new('2.0.0')
+          # Patch Rails controller base class
+          ::ActionController::Metal.send(:prepend, ActionControllerPatch)
+        else
+          # Rewrite module that gets composed into the Rails controller base class
+          ::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
+
+            alias_method :process_action_without_datadog, :process_action
+            alias_method :process_action, :process_action_with_datadog
           end
-        ensure
-          Datadog::Contrib::Rails::ActionController.finish_processing(payload)
         end
+      end
+    end
 
-        alias_method :process_action_without_datadog, :process_action
-        alias_method :process_action, :process_action_with_datadog
+    # ActionController patch for Ruby 2.0+
+    module ActionControllerPatch
+      def process_action(*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 = super(*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
     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,101 +267,109 @@ 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