datadog 2.0.0 → 2.2.0

data/lib/datadog/tracing/contrib/action_mailer/event.rb

@@ -27,9 +27,11 @@ module Datadog
               Datadog.configuration.tracing[:action_mailer]
             end
 
-            def process(span, event, _id, payload)
+            def on_start(span, event, _id, payload)
+              super
+
+              span.type = span_type
               span.service = configuration[:service_name] if configuration[:service_name]
-              span.resource = payload[:mailer]
               span.set_tag(Tracing::Metadata::Ext::TAG_COMPONENT, Ext::TAG_COMPONENT)
 
               # Set analytics sample rate
@@ -39,10 +41,6 @@ module Datadog
 
               # Measure service stats
               Contrib::Analytics.set_measured(span)
-
-              report_if_exception(span, payload)
-            rescue StandardError => e
-              Datadog.logger.debug(e.message)
             end
           end
         end

data/lib/datadog/tracing/contrib/action_mailer/events/deliver.rb

@@ -30,15 +30,20 @@ module Datadog
               Tracing::Metadata::Ext::AppTypes::TYPE_WORKER
             end
 
-            def process(span, event, _id, payload)
+            def on_start(span, event, _id, payload)
               super
 
-              span.type = span_type
+              span.set_tag(Tracing::Metadata::Ext::TAG_OPERATION, Ext::TAG_OPERATION_DELIVER)
+            end
+
+            def on_finish(span, event, _id, payload)
+              super
+
+              span.resource = payload[:mailer] # Mailer is not available at `on_start`
+
               span.set_tag(Ext::TAG_MAILER, payload[:mailer])
               span.set_tag(Ext::TAG_MSG_ID, payload[:message_id])
 
-              span.set_tag(Tracing::Metadata::Ext::TAG_OPERATION, Ext::TAG_OPERATION_DELIVER)
-
               # Since email data can contain PII we disable by default
               # Some of these fields can be either strings or arrays, so we try to normalize
               # https://github.com/rails/rails/blob/18707ab17fa492eb25ad2e8f9818a320dc20b823/actionmailer/lib/action_mailer/base.rb#L742-L754

data/lib/datadog/tracing/contrib/action_mailer/events/process.rb

@@ -30,10 +30,11 @@ module Datadog
               Tracing::Metadata::Ext::HTTP::TYPE_TEMPLATE
             end
 
-            def process(span, event, _id, payload)
+            def on_start(span, event, _id, payload)
               super
 
-              span.type = span_type
+              span.resource = payload[:mailer] # Mailer is not available at `on_start`
+
               span.set_tag(Ext::TAG_ACTION, payload[:action])
               span.set_tag(Ext::TAG_MAILER, payload[:mailer])
 

data/lib/datadog/tracing/contrib/action_view/events/render_partial.rb

@@ -27,7 +27,7 @@ module Datadog
               Ext::SPAN_RENDER_PARTIAL
             end
 
-            def process(span, _event, _id, payload)
+            def on_start(span, _event, _id, payload)
               span.service = configuration[:service_name] if configuration[:service_name]
               span.type = Tracing::Metadata::Ext::HTTP::TYPE_TEMPLATE
 
@@ -41,10 +41,6 @@ module Datadog
 
               # Measure service stats
               Contrib::Analytics.set_measured(span)
-
-              record_exception(span, payload)
-            rescue StandardError => e
-              Datadog.logger.debug(e.message)
             end
           end
         end

data/lib/datadog/tracing/contrib/action_view/events/render_template.rb

@@ -27,7 +27,7 @@ module Datadog
               Ext::SPAN_RENDER_TEMPLATE
             end
 
-            def process(span, _event, _id, payload)
+            def on_start(span, _event, _id, payload)
               span.service = configuration[:service_name] if configuration[:service_name]
               span.type = Tracing::Metadata::Ext::HTTP::TYPE_TEMPLATE
 

data/lib/datadog/tracing/contrib/active_job/events/discard.rb

@@ -26,7 +26,7 @@ module Datadog
               Ext::SPAN_DISCARD
             end
 
-            def process(span, event, _id, payload)
+            def on_start(span, event, _id, payload)
               span.name = span_name
               span.service = configuration[:service_name] if configuration[:service_name]
               span.resource = payload[:job].class.name

data/lib/datadog/tracing/contrib/active_job/events/enqueue.rb

@@ -26,7 +26,7 @@ module Datadog
               Ext::SPAN_ENQUEUE
             end
 
-            def process(span, event, _id, payload)
+            def on_start(span, event, _id, payload)
               span.name = span_name
               span.service = configuration[:service_name] if configuration[:service_name]
               span.resource = payload[:job].class.name

data/lib/datadog/tracing/contrib/active_job/events/enqueue_at.rb

@@ -26,7 +26,7 @@ module Datadog
               Ext::SPAN_ENQUEUE
             end
 
-            def process(span, event, _id, payload)
+            def on_start(span, event, _id, payload)
               span.name = span_name
               span.service = configuration[:service_name] if configuration[:service_name]
               span.resource = payload[:job].class.name

data/lib/datadog/tracing/contrib/active_job/events/enqueue_retry.rb

@@ -26,7 +26,7 @@ module Datadog
               Ext::SPAN_ENQUEUE_RETRY
             end
 
-            def process(span, event, _id, payload)
+            def on_start(span, event, _id, payload)
               span.name = span_name
               span.service = configuration[:service_name] if configuration[:service_name]
               span.resource = payload[:job].class.name

data/lib/datadog/tracing/contrib/active_job/events/perform.rb

@@ -26,7 +26,7 @@ module Datadog
               Ext::SPAN_PERFORM
             end
 
-            def process(span, event, _id, payload)
+            def on_start(span, event, _id, payload)
               span.name = span_name
               span.service = configuration[:service_name] if configuration[:service_name]
               span.resource = payload[:job].class.name

data/lib/datadog/tracing/contrib/active_job/events/retry_stopped.rb

@@ -26,7 +26,7 @@ module Datadog
               Ext::SPAN_RETRY_STOPPED
             end
 
-            def process(span, event, _id, payload)
+            def on_start(span, event, _id, payload)
               span.name = span_name
               span.service = configuration[:service_name] if configuration[:service_name]
               span.resource = payload[:job].class.name

data/lib/datadog/tracing/contrib/active_model_serializers/events/render.rb

@@ -30,7 +30,7 @@ module Datadog
               Ext::SPAN_RENDER
             end
 
-            def process(span, _event, _id, payload)
+            def on_start(span, _event, _id, payload)
               span.set_tag(Tracing::Metadata::Ext::TAG_OPERATION, Ext::TAG_OPERATION_RENDER)
 
               set_common_tags(span, payload)

data/lib/datadog/tracing/contrib/active_model_serializers/events/serialize.rb

@@ -32,7 +32,7 @@ module Datadog
               Ext::SPAN_SERIALIZE
             end
 
-            def process(span, _event, _id, payload)
+            def on_start(span, _event, _id, payload)
               span.set_tag(Tracing::Metadata::Ext::TAG_OPERATION, Ext::TAG_OPERATION_SERIALIZE)
 
               set_common_tags(span, payload)

data/lib/datadog/tracing/contrib/active_record/events/instantiation.rb

@@ -31,7 +31,7 @@ module Datadog
               Ext::SPAN_INSTANTIATION
             end
 
-            def process(span, event, _id, payload)
+            def on_start(span, event, _id, payload)
               span.resource = payload.fetch(:class_name)
               span.type = Ext::SPAN_TYPE_INSTANTIATION
               span.set_tag(Tracing::Metadata::Ext::TAG_COMPONENT, Ext::TAG_COMPONENT)

data/lib/datadog/tracing/contrib/active_record/events/sql.rb

@@ -29,7 +29,7 @@ module Datadog
               Ext::SPAN_SQL
             end
 
-            def process(span, event, _id, payload)
+            def on_start(span, event, _id, payload)
               config = Utils.connection_config(payload[:connection], payload[:connection_id])
               settings = Datadog.configuration.tracing[:active_record, config]
               adapter_name = Contrib::Utils::Database.normalize_vendor(config[:adapter])

data/lib/datadog/tracing/contrib/active_support/cache/event.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require_relative '../notifications/event'
+
+module Datadog
+  module Tracing
+    module Contrib
+      module ActiveSupport
+        module Cache
+          # Defines basic behaviors for an ActiveSupport event.
+          module Event
+            def self.included(base)
+              base.include(ActiveSupport::Notifications::Event)
+              base.extend(ClassMethods)
+            end
+
+            # Class methods for ActiveRecord events.
+            module ClassMethods
+              def span_options
+                {}
+              end
+
+              def configuration
+                Datadog.configuration.tracing[:active_support]
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/tracing/contrib/active_support/cache/events/cache.rb

@@ -0,0 +1,156 @@
+# frozen_string_literal: true
+
+require_relative '../../ext'
+require_relative '../event'
+
+module Datadog
+  module Tracing
+    module Contrib
+      module ActiveSupport
+        module Cache
+          module Events
+            # Defines instrumentation for instantiation.active_record event
+            module Cache
+              include ActiveSupport::Cache::Event
+
+              module_function
+
+              # Acts as this module's initializer.
+              def subscribe!
+                @cache_backend = {}
+                super
+              end
+
+              def event_name
+                /\Acache_(?:delete|read|read_multi|write|write_multi)\.active_support\z/
+              end
+
+              def span_name
+                Ext::SPAN_CACHE
+              end
+
+              def span_options
+                {
+                  type: Ext::SPAN_TYPE_CACHE
+                }
+              end
+
+              # DEV: Look for other uses of `ActiveSupport::Cache::Store#instrument`, to find other useful event keys.
+              MAPPING = {
+                'cache_delete.active_support' => { resource: Ext::RESOURCE_CACHE_DELETE },
+                'cache_read.active_support' => { resource: Ext::RESOURCE_CACHE_GET },
+                'cache_read_multi.active_support' => { resource: Ext::RESOURCE_CACHE_MGET, multi_key: true },
+                'cache_write.active_support' => { resource: Ext::RESOURCE_CACHE_SET },
+                'cache_write_multi.active_support' => { resource: Ext::RESOURCE_CACHE_MSET, multi_key: true }
+              }.freeze
+
+              def trace?(event, _payload)
+                return false if !Tracing.enabled? || !configuration.enabled
+
+                # DEV-3.0: Backwards compatibility code for the 2.x gem series.
+                # DEV-3.0: See documentation at {Datadog::Tracing::Contrib::ActiveSupport::Cache::Instrumentation}
+                # DEV-3.0: for the complete information about this backwards compatibility code.
+                case event
+                when 'cache_read.active_support'
+                  !ActiveSupport::Cache::Instrumentation.nested_read?
+                when 'cache_read_multi.active_support'
+                  !ActiveSupport::Cache::Instrumentation.nested_multiread?
+                else
+                  true
+                end
+              end
+
+              def on_start(span, event, _id, payload)
+                key = payload[:key]
+                store = payload[:store]
+
+                mapping = MAPPING[event]
+
+                span.service = configuration[:cache_service]
+                span.resource = mapping[:resource]
+
+                span.set_tag(Tracing::Metadata::Ext::TAG_COMPONENT, Ext::TAG_COMPONENT)
+                span.set_tag(Tracing::Metadata::Ext::TAG_OPERATION, Ext::TAG_OPERATION_CACHE)
+
+                if span.service != Datadog.configuration.service
+                  span.set_tag(Tracing::Contrib::Ext::Metadata::TAG_BASE_SERVICE, Datadog.configuration.service)
+                end
+
+                span.set_tag(Ext::TAG_CACHE_BACKEND, cache_backend(store))
+
+                span.set_tag('EVENT', event)
+
+                set_cache_key(span, key, mapping[:multi_key])
+              end
+
+              def set_cache_key(span, key, multi_key)
+                if multi_key
+                  keys = key.is_a?(Hash) ? key.keys : key # `write`s use Hashes, while `read`s use Arrays
+                  resolved_key = keys.map { |k| ::ActiveSupport::Cache.expand_cache_key(k) }
+                  cache_key = Core::Utils.truncate(resolved_key, Ext::QUANTIZE_CACHE_MAX_KEY_SIZE)
+                  span.set_tag(Ext::TAG_CACHE_KEY_MULTI, cache_key)
+                else
+                  resolved_key = ::ActiveSupport::Cache.expand_cache_key(key)
+                  cache_key = Core::Utils.truncate(resolved_key, Ext::QUANTIZE_CACHE_MAX_KEY_SIZE)
+                  span.set_tag(Ext::TAG_CACHE_KEY, cache_key)
+                end
+              end
+
+              # The name of the `store` is never saved by Rails.
+              # ActiveSupport looks up stores by converting a symbol into a 'require' path,
+              # then "camelizing" it for a `const_get` call:
+              # ```
+              # require "active_support/cache/#{store}"
+              # ActiveSupport::Cache.const_get(store.to_s.camelize)
+              # ```
+              # @see https://github.com/rails/rails/blob/261975dbef77731d2c76f907f1076c5132ebc0e4/activesupport/lib/active_support/cache.rb#L139-L149
+              #
+              # We can reverse engineer
+              # the original symbol by converting the class name to snake case:
+              # e.g. ActiveSupport::Cache::RedisStore -> active_support/cache/redis_store
+              # In this case, `redis_store` is the store name.
+              #
+              # Because there's no API retrieve only the class name
+              # (only `RedisStore`, and not `ActiveSupport::Cache::RedisStore`)
+              # the easiest way to retrieve the store symbol is to convert the fully qualified
+              # name using the Rails-provided method `#underscore`, which is the reverse of `#camelize`,
+              # then extracting the last part of it.
+              #
+              # Also, this method caches the store name, given this value will be retrieve
+              # multiple times and involves string manipulation.
+              def cache_backend(store)
+                # Cache the backend name to avoid the expensive string manipulation required to calculate it.
+                # DEV: We can't store it directly in the `store` object because it is a frozen String.
+                if (name = @cache_backend[store])
+                  return name
+                end
+
+                # DEV: #underscore is available through ActiveSupport, and is
+                # DEV: the exact reverse operation to `#camelize`.
+                # DEV: #demodulize is available through ActiveSupport, and is
+                # DEV: used to remove the module ('*::') part of a constant name.
+                name = ::ActiveSupport::Inflector.demodulize(store)
+                name = ::ActiveSupport::Inflector.underscore(name)
+
+                # Despite a given application only ever having 1-3 store types,
+                # we limit the size of the `@cache_backend` just in case, because
+                # the user can create custom Cache store classes themselves.
+                @cache_backend[store] = name if @cache_backend.size < 50
+
+                name
+              end
+
+              # DEV: There are two possibly interesting fields in the `on_finish` payload:
+              # | `:hit`             | If this read is a hit   |
+              # | `:super_operation` | `:fetch` if a read is done with [`fetch`][ActiveSupport::Cache::Store#fetch] |
+              # @see https://github.com/rails/rails/blob/b9d6759401c3d50a51e0a7650cb2331f4218d11f/guides/source/active_support_instrumentation.md?plain=1#L528-L529
+              # def on_finish(span, event, id, payload)
+              #   super
+              # end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/tracing/contrib/active_support/cache/events.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require_relative 'events/cache'
+
+module Datadog
+  module Tracing
+    module Contrib
+      module ActiveSupport
+        module Cache
+          # Defines collection of instrumented ActiveSupport events
+          module Events
+            ALL = [
+              Events::Cache,
+            ].freeze
+
+            module_function
+
+            def all
+              self::ALL
+            end
+
+            def subscriptions
+              all.collect(&:subscriptions).collect(&:to_a).flatten
+            end
+
+            def subscribe!
+              all.each(&:subscribe!)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/tracing/contrib/active_support/cache/instrumentation.rb

@@ -9,7 +9,31 @@ module Datadog
     module Contrib
       module ActiveSupport
         module Cache
-          # Defines instrumentation for ActiveSupport caching
+          # DEV-3.0: Backwards compatibility code for the 2.x gem series.
+          # DEV-3.0:
+          # DEV-3.0: `ActiveSupport::Cache` is now instrumented by subscribing to ActiveSupport::Notifications events.
+          # DEV-3.0: The implementation is located at {Datadog::Tracing::Contrib::ActiveSupport::Cache::Events::Cache}.
+          # DEV-3.0: The events emitted provide richer introspection points (e.g. events for cache misses on `#fetch`) while
+          # DEV-3.0: also ensuring we are using Rails' public API for improved compatibility.
+          # DEV-3.0:
+          # DEV-3.0: But a few operations holds us back:
+          # DEV-3.0: 1. `ActiveSupport::Cache::Store#fetch`:
+          # DEV-3.0:   This method does not have an event that can produce an equivalent span to today's 2.x implementation.
+          # DEV-3.0:   In 2.x, `#fetch` produces two separate, *nested* spans: one for the `#read` operation and
+          # DEV-3.0:   another for the `#write` operation that is called internally by `#fetch` when the cache key needs
+          # DEV-3.0:   to be populated on a cache miss.
+          # DEV-3.0:   But the ActiveSupport events emitted by `#fetch` provide two *sibling* events for the`#read` and
+          # DEV-3.0:   `#write` operations.
+          # DEV-3.0:   Moving from nested spans to sibling spans would be a breaking change. One notable difference is
+          # DEV-3.0:   that if the nested `#write` operation fails 2.x, the `#read` span is marked as an error. This would
+          # DEV-3.0:   not be the case with sibling spans, and would be a very visible change.
+          # DEV-3.0: 2. `ActiveSupport::Cache::Store#read_multi` & `ActiveSupport::Cache::Store#fetch_multi`:
+          # DEV-3.0:   ActiveSupport events were introduced in ActiveSupport 5.2.0 for these methods.
+          # DEV-3.0:
+          # DEV-3.0: At the end of the day, moving to ActiveSupport events is the better approach, but we have to retain
+          # DEV-3.0: this last few monkey patches (and all the supporting code) to avoid a breaking change for now.
+          #
+          # Defines the deprecate  monkey-patch instrumentation for `ActiveSupport::Cache::Store#fetch`
           module Instrumentation
             module_function
 
@@ -43,6 +67,10 @@ module Datadog
             # In most of the cases, `#fetch()` and `#read()` calls are nested.
             # Instrument both does not add any value.
             # This method checks if these two operations are nested.
+            #
+            # DEV-3.0: We should not have these checks in the 3.x series because ActiveSupport events provide more
+            # DEV-3.0: legible nested spans. While using ActiveSupport events, the nested spans actually provide meaningful
+            # DEV-3.0: information.
             def nested_read?
               current_span = Tracing.active_span
               current_span && current_span.name == Ext::SPAN_CACHE && current_span.resource == Ext::RESOURCE_CACHE_GET
@@ -107,29 +135,20 @@ module Datadog
               end
             end
 
-            # Defines instrumentation for ActiveSupport cache reading
-            module Read
-              include InstanceMethods
-
-              def read(*args, &block)
-                return super if Instrumentation.nested_read?
-
-                Instrumentation.trace(Ext::RESOURCE_CACHE_GET, dd_store_name, key: args[0]) { super }
-              end
-            end
-
-            # Defines instrumentation for ActiveSupport cache reading of multiple keys
+            # Defines the the legacy monkey-patching instrumentation for ActiveSupport cache read_multi
+            # DEV-3.0: ActiveSupport::Notifications events were introduced in ActiveSupport 5.2.0 for this method.
+            # DEV-3.0: As long as we support ActiveSupport < 5.2.0, we have to keep this method.
             module ReadMulti
               include InstanceMethods
 
-              def read_multi(*keys, &block)
+              def read_multi(*keys, **options, &block)
                 return super if Instrumentation.nested_multiread?
 
                 Instrumentation.trace(Ext::RESOURCE_CACHE_MGET, dd_store_name, multi_key: keys) { super }
               end
             end
 
-            # Defines instrumentation for ActiveSupport cache fetching
+            # Defines the the legacy monkey-patching instrumentation for ActiveSupport cache fetch
             module Fetch
               include InstanceMethods
 
@@ -140,11 +159,13 @@ module Datadog
               end
             end
 
-            # Defines instrumentation for ActiveSupport cache fetching of multiple keys
+            # Defines the the legacy monkey-patching instrumentation for ActiveSupport cache fetch_multi
+            # DEV-3.0: ActiveSupport::Notifications events were introduced in ActiveSupport 5.2.0 for this method.
+            # DEV-3.0: As long as we support ActiveSupport < 5.2.0, we have to keep this method.
             module FetchMulti
               include InstanceMethods
 
-              def fetch_multi(*args, &block)
+              def fetch_multi(*args, **options, &block)
                 return super if Instrumentation.nested_multiread?
 
                 keys = args[-1].instance_of?(Hash) ? args[0..-2] : args
@@ -152,30 +173,13 @@ module Datadog
               end
             end
 
-            # Defines instrumentation for ActiveSupport cache writing
-            module Write
-              include InstanceMethods
-
-              def write(*args, &block)
-                Instrumentation.trace(Ext::RESOURCE_CACHE_SET, dd_store_name, key: args[0]) { super }
-              end
-            end
-
-            # Defines instrumentation for ActiveSupport cache writing of multiple keys
-            module WriteMulti
-              include InstanceMethods
-
-              def write_multi(hash, options = nil)
-                Instrumentation.trace(Ext::RESOURCE_CACHE_MSET, dd_store_name, multi_key: hash.keys) { super }
-              end
-            end
-
-            # Defines instrumentation for ActiveSupport cache deleting
-            module Delete
-              include InstanceMethods
-
-              def delete(*args, &block)
-                Instrumentation.trace(Ext::RESOURCE_CACHE_DELETE, dd_store_name, key: args[0]) { super }
+            # Backports the payload[:store] key present since Rails 6.1:
+            # https://github.com/rails/rails/commit/6fa747f2946ee244b2aab0cd8c3c064f05d950a5
+            module Store
+              def instrument(operation, key, options = nil)
+                polyfill_options = options&.dup || {}
+                polyfill_options[:store] = self.class.name
+                super(operation, key, polyfill_options)
               end
             end
           end

data/lib/datadog/tracing/contrib/active_support/cache/patcher.rb

@@ -2,6 +2,7 @@
 
 require_relative '../../patcher'
 require_relative 'instrumentation'
+require_relative 'events'
 
 module Datadog
   module Tracing
@@ -19,54 +20,30 @@ module Datadog
             end
 
             def patch
-              patch_cache_store_read
-              patch_cache_store_read_multi
-              patch_cache_store_fetch
-              patch_cache_store_fetch_multi
-              patch_cache_store_write
-              patch_cache_store_write_multi
-              patch_cache_store_delete
+              Events.subscribe!
+
+              # Backfill the `:store` key in the ActiveSupport event payload for older Rails.
+              if Integration.version < Gem::Version.new('6.1.0')
+                ::ActiveSupport::Cache::Store.prepend(Cache::Instrumentation::Store)
+              end
+
+              # DEV-3.0: Backwards compatibility code for the 2.x gem series.
+              # DEV-3.0: See documentation at {Datadog::Tracing::Contrib::ActiveSupport::Cache::Instrumentation}
+              # DEV-3.0: for the complete information about this backwards compatibility code.
+              patch_legacy_cache_store
             end
 
             # This method is overwritten by
             # `datadog/tracing/contrib/active_support/cache/redis.rb`
             # with more complex behavior.
             def cache_store_class(meth)
-              ::ActiveSupport::Cache::Store
-            end
-
-            def patch_cache_store_read
-              cache_store_class(:read).prepend(Cache::Instrumentation::Read)
-            end
-
-            def patch_cache_store_read_multi
-              cache_store_class(:read_multi).prepend(Cache::Instrumentation::ReadMulti)
-            end
-
-            def patch_cache_store_fetch
-              cache_store_class(:fetch).prepend(Cache::Instrumentation::Fetch)
-            end
-
-            def patch_cache_store_fetch_multi
-              klass = cache_store_class(:fetch_multi)
-              return unless klass.public_method_defined?(:fetch_multi)
-
-              klass.prepend(Cache::Instrumentation::FetchMulti)
-            end
-
-            def patch_cache_store_write
-              cache_store_class(:write).prepend(Cache::Instrumentation::Write)
-            end
-
-            def patch_cache_store_write_multi
-              klass = cache_store_class(:write_multi)
-              return unless klass.public_method_defined?(:write_multi)
-
-              klass.prepend(Cache::Instrumentation::WriteMulti)
+              [::ActiveSupport::Cache::Store]
             end
 
-            def patch_cache_store_delete
-              cache_store_class(:delete).prepend(Cache::Instrumentation::Delete)
+            def patch_legacy_cache_store
+              cache_store_class(:read_multi).each { |clazz| clazz.prepend(Cache::Instrumentation::ReadMulti) }
+              cache_store_class(:fetch).each { |clazz| clazz.prepend(Cache::Instrumentation::Fetch) }
+              cache_store_class(:fetch_multi).each { |clazz| clazz.prepend(Cache::Instrumentation::FetchMulti) }
             end
           end
         end

data/lib/datadog/tracing/contrib/active_support/cache/redis.rb

@@ -30,7 +30,10 @@ module Datadog
 
               def cache_store_class(meth)
                 if patch_redis?(meth)
-                  ::ActiveSupport::Cache::RedisStore
+                  [::ActiveSupport::Cache::RedisStore, ::ActiveSupport::Cache::Store]
+                elsif Gem.loaded_specs['redis'] && defined?(::ActiveSupport::Cache::RedisCacheStore) \
+                    && ::ActiveSupport::Cache::RedisCacheStore.instance_methods(false).include?(meth)
+                  [::ActiveSupport::Cache::RedisCacheStore, ::ActiveSupport::Cache::Store]
                 else
                   super
                 end