ddtrace 0.53.0 → 1.0.0.beta1

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

@@ -0,0 +1,269 @@
+# typed: false
+require 'datadog/core/utils'
+require 'datadog/tracing/metadata/ext'
+require 'datadog/tracing/contrib/active_support/ext'
+
+module Datadog
+  module Tracing
+    module Contrib
+      module ActiveSupport
+        module Cache
+          # Defines instrumentation for ActiveSupport caching
+          # rubocop:disable Lint/RescueException
+          module Instrumentation
+            module_function
+
+            def start_trace_cache(payload)
+              # In most of the cases Rails ``fetch()`` and ``read()`` calls are nested.
+              # This check ensures that two reads are not nested since they don't provide
+              # interesting details.
+              # NOTE: the ``finish_trace_cache()`` is fired but it already has a safe-guard
+              # to avoid any kind of issue.
+              current_span = Tracing.active_span
+              return if current_span.try(:name) == Ext::SPAN_CACHE &&
+                        (
+                          payload[:action] == Ext::RESOURCE_CACHE_GET &&
+                          current_span.try(:resource) == Ext::RESOURCE_CACHE_GET ||
+                          payload[:action] == Ext::RESOURCE_CACHE_MGET &&
+                          current_span.try(:resource) == Ext::RESOURCE_CACHE_MGET
+                        )
+
+              tracing_context = payload.fetch(:tracing_context)
+
+              # create a new ``Span`` and add it to the tracing context
+              service = Datadog.configuration[:active_support][:cache_service]
+              type = Ext::SPAN_TYPE_CACHE
+              span = Tracing.trace(Ext::SPAN_CACHE, service: service, span_type: type)
+              span.resource = payload.fetch(:action)
+
+              span.set_tag(Tracing::Metadata::Ext::TAG_COMPONENT, Ext::TAG_COMPONENT)
+              span.set_tag(Tracing::Metadata::Ext::TAG_OPERATION, Ext::TAG_OPERATION_CACHE)
+
+              # Tag as an external peer service
+              span.set_tag(Tracing::Metadata::Ext::TAG_PEER_SERVICE, service)
+
+              tracing_context[:dd_cache_span] = span
+            rescue StandardError => e
+              Datadog.logger.debug(e.message)
+            end
+
+            def finish_trace_cache(payload)
+              # retrieve the tracing context and continue the trace
+              tracing_context = payload.fetch(:tracing_context)
+              span = tracing_context[:dd_cache_span]
+              return unless span && !span.finished?
+
+              begin
+                # discard parameters from the cache_store configuration
+                if defined?(::Rails)
+                  store, = *Array.wrap(::Rails.configuration.cache_store).flatten
+                  span.set_tag(Ext::TAG_CACHE_BACKEND, store)
+                end
+
+                normalized_key = ::ActiveSupport::Cache.expand_cache_key(payload.fetch(:key))
+                cache_key = Core::Utils.truncate(normalized_key, Ext::QUANTIZE_CACHE_MAX_KEY_SIZE)
+                span.set_tag(Ext::TAG_CACHE_KEY, cache_key)
+
+                span.set_error(payload[:exception]) if payload[:exception]
+              ensure
+                span.finish
+              end
+            rescue StandardError => e
+              Datadog.logger.debug(e.message)
+            end
+
+            def finish_trace_cache_multi(payload)
+              # retrieve the tracing context and continue the trace
+              tracing_context = payload.fetch(:tracing_context)
+              span = tracing_context[:dd_cache_span]
+              return unless span && !span.finished?
+
+              begin
+                # discard parameters from the cache_store configuration
+                if defined?(::Rails)
+                  store, = *Array.wrap(::Rails.configuration.cache_store).flatten
+                  span.set_tag(Ext::TAG_CACHE_BACKEND, store)
+                end
+                normalized_keys = payload.fetch(:keys, []).map do |key|
+                  ::ActiveSupport::Cache.expand_cache_key(key)
+                end
+                cache_keys = Core::Utils.truncate(normalized_keys, Ext::QUANTIZE_CACHE_MAX_KEY_SIZE)
+                span.set_tag(Ext::TAG_CACHE_KEY_MULTI, cache_keys)
+
+                span.set_error(payload[:exception]) if payload[:exception]
+              ensure
+                span.finish
+              end
+            rescue StandardError => e
+              Datadog.logger.debug(e.message)
+            end
+
+            # Defines instrumentation for ActiveSupport cache reading
+            module Read
+              def read(*args, &block)
+                payload = {
+                  action: Ext::RESOURCE_CACHE_GET,
+                  key: args[0],
+                  tracing_context: {}
+                }
+
+                begin
+                  # process and catch cache exceptions
+                  Instrumentation.start_trace_cache(payload)
+                  super
+                rescue Exception => e
+                  payload[:exception] = [e.class.name, e.message]
+                  payload[:exception_object] = e
+                  raise e
+                end
+              ensure
+                Instrumentation.finish_trace_cache(payload)
+              end
+            end
+
+            # Defines instrumentation for ActiveSupport cache reading of multiple keys
+            module ReadMulti
+              def read_multi(*keys, &block)
+                payload = {
+                  action: Ext::RESOURCE_CACHE_MGET,
+                  keys: keys,
+                  tracing_context: {}
+                }
+
+                begin
+                  # process and catch cache exceptions
+                  Instrumentation.start_trace_cache(payload)
+                  super
+                rescue Exception => e
+                  payload[:exception] = [e.class.name, e.message]
+                  payload[:exception_object] = e
+                  raise e
+                end
+              ensure
+                Instrumentation.finish_trace_cache_multi(payload)
+              end
+            end
+
+            # Defines instrumentation for ActiveSupport cache fetching
+            module Fetch
+              def fetch(*args, &block)
+                payload = {
+                  action: Ext::RESOURCE_CACHE_GET,
+                  key: args[0],
+                  tracing_context: {}
+                }
+
+                begin
+                  # process and catch cache exceptions
+                  Instrumentation.start_trace_cache(payload)
+                  super
+                rescue Exception => e
+                  payload[:exception] = [e.class.name, e.message]
+                  payload[:exception_object] = e
+                  raise e
+                end
+              ensure
+                Instrumentation.finish_trace_cache(payload)
+              end
+            end
+
+            # Defines instrumentation for ActiveSupport cache fetching of multiple keys
+            module FetchMulti
+              def fetch_multi(*args, &block)
+                # extract options hash
+                keys = args[-1].instance_of?(Hash) ? args[0..-2] : args
+                payload = {
+                  action: Ext::RESOURCE_CACHE_MGET,
+                  keys: keys,
+                  tracing_context: {}
+                }
+
+                begin
+                  # process and catch cache exceptions
+                  Instrumentation.start_trace_cache(payload)
+                  super
+                rescue Exception => e
+                  payload[:exception] = [e.class.name, e.message]
+                  payload[:exception_object] = e
+                  raise e
+                end
+              ensure
+                Instrumentation.finish_trace_cache_multi(payload)
+              end
+            end
+
+            # Defines instrumentation for ActiveSupport cache writing
+            module Write
+              def write(*args, &block)
+                payload = {
+                  action: Ext::RESOURCE_CACHE_SET,
+                  key: args[0],
+                  tracing_context: {}
+                }
+
+                begin
+                  # process and catch cache exceptions
+                  Instrumentation.start_trace_cache(payload)
+                  super
+                rescue Exception => e
+                  payload[:exception] = [e.class.name, e.message]
+                  payload[:exception_object] = e
+                  raise e
+                end
+              ensure
+                Instrumentation.finish_trace_cache(payload)
+              end
+            end
+
+            # Defines instrumentation for ActiveSupport cache writing of multiple keys
+            module WriteMulti
+              def write_multi(hash, options = nil)
+                payload = {
+                  action: Ext::RESOURCE_CACHE_MSET,
+                  keys: hash.keys,
+                  tracing_context: {}
+                }
+
+                begin
+                  # process and catch cache exceptions
+                  Instrumentation.start_trace_cache(payload)
+                  super
+                rescue Exception => e
+                  payload[:exception] = [e.class.name, e.message]
+                  payload[:exception_object] = e
+                  raise e
+                end
+              ensure
+                Instrumentation.finish_trace_cache_multi(payload)
+              end
+            end
+
+            # Defines instrumentation for ActiveSupport cache deleting
+            module Delete
+              def delete(*args, &block)
+                payload = {
+                  action: Ext::RESOURCE_CACHE_DELETE,
+                  key: args[0],
+                  tracing_context: {}
+                }
+
+                begin
+                  # process and catch cache exceptions
+                  Instrumentation.start_trace_cache(payload)
+                  super
+                rescue Exception => e
+                  payload[:exception] = [e.class.name, e.message]
+                  payload[:exception_object] = e
+                  raise e
+                end
+              ensure
+                Instrumentation.finish_trace_cache(payload)
+              end
+            end
+          end
+          # rubocop:enable Lint/RescueException
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,72 @@
+# typed: true
+require 'datadog/tracing/contrib/patcher'
+require 'datadog/tracing/contrib/active_support/cache/instrumentation'
+
+module Datadog
+  module Tracing
+    module Contrib
+      module ActiveSupport
+        module Cache
+          # Patcher enables patching of 'active_support' module.
+          module Patcher
+            include Contrib::Patcher
+
+            module_function
+
+            def target_version
+              Integration.version
+            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
+            end
+
+            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)
+            end
+
+            def patch_cache_store_delete
+              cache_store_class(:delete).prepend(Cache::Instrumentation::Delete)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,46 @@
+# typed: true
+require 'datadog/tracing/contrib/active_support/cache/patcher'
+
+module Datadog
+  module Tracing
+    module Contrib
+      module ActiveSupport
+        module Cache
+          # Support for Redis with ActiveSupport
+          module Redis
+            # Patching behavior for Redis with ActiveSupport
+            module Patcher
+              # For Rails < 5.2 w/ redis-activesupport...
+              # When Redis is used, we can't only patch Cache::Store as it is
+              # Cache::RedisStore, a sub-class of it that is used, in practice.
+              # We need to do a per-method monkey patching as some of them might
+              # be redefined, and some of them not. The latest version of redis-activesupport
+              # redefines write but leaves untouched read and delete:
+              # https://github.com/redis-store/redis-activesupport/blob/v4.1.5/lib/active_support/cache/redis_store.rb
+              #
+              # For Rails >= 5.2 w/o redis-activesupport...
+              # ActiveSupport includes a Redis cache store internally, and does not require these overrides.
+              # https://github.com/rails/rails/blob/master/activesupport/lib/active_support/cache/redis_cache_store.rb
+              def patch_redis?(meth)
+                !Gem.loaded_specs['redis-activesupport'].nil? \
+                  && defined?(::ActiveSupport::Cache::RedisStore) \
+                  && ::ActiveSupport::Cache::RedisStore.instance_methods(false).include?(meth)
+              end
+
+              def cache_store_class(meth)
+                if patch_redis?(meth)
+                  ::ActiveSupport::Cache::RedisStore
+                else
+                  super
+                end
+              end
+            end
+
+            # Decorate Cache patcher with Redis support
+            Cache::Patcher.singleton_class.prepend(Redis::Patcher)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/tracing/contrib/active_support/configuration/settings.rb

@@ -0,0 +1,34 @@
+# typed: false
+require 'datadog/tracing/contrib/configuration/settings'
+require 'datadog/tracing/contrib/active_support/ext'
+
+module Datadog
+  module Tracing
+    module Contrib
+      module ActiveSupport
+        module Configuration
+          # Custom settings for the ActiveSupport integration
+          # @public_api
+          class Settings < Contrib::Configuration::Settings
+            option :enabled do |o|
+              o.default { env_to_bool(Ext::ENV_ENABLED, true) }
+              o.lazy
+            end
+
+            option :analytics_enabled do |o|
+              o.default { env_to_bool(Ext::ENV_ANALYTICS_ENABLED, false) }
+              o.lazy
+            end
+
+            option :analytics_sample_rate do |o|
+              o.default { env_to_float(Ext::ENV_ANALYTICS_SAMPLE_RATE, 1.0) }
+              o.lazy
+            end
+
+            option :cache_service, default: Ext::SERVICE_CACHE
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/tracing/contrib/active_support/ext.rb

@@ -0,0 +1,30 @@
+# typed: true
+module Datadog
+  module Tracing
+    module Contrib
+      module ActiveSupport
+        # ActiveSupport integration constants
+        # @public_api Changing resource names, tag names, or environment variables creates breaking changes.
+        module Ext
+          ENV_ENABLED = 'DD_TRACE_ACTIVE_SUPPORT_ENABLED'.freeze
+          ENV_ANALYTICS_ENABLED = 'DD_TRACE_ACTIVE_SUPPORT_ANALYTICS_ENABLED'.freeze
+          ENV_ANALYTICS_SAMPLE_RATE = 'DD_TRACE_ACTIVE_SUPPORT_ANALYTICS_SAMPLE_RATE'.freeze
+          QUANTIZE_CACHE_MAX_KEY_SIZE = 300
+          RESOURCE_CACHE_DELETE = 'DELETE'.freeze
+          RESOURCE_CACHE_GET = 'GET'.freeze
+          RESOURCE_CACHE_MGET = 'MGET'.freeze
+          RESOURCE_CACHE_SET = 'SET'.freeze
+          RESOURCE_CACHE_MSET = 'MSET'.freeze
+          SERVICE_CACHE = 'active_support-cache'.freeze
+          SPAN_CACHE = 'rails.cache'.freeze
+          SPAN_TYPE_CACHE = 'cache'.freeze
+          TAG_CACHE_BACKEND = 'rails.cache.backend'.freeze
+          TAG_CACHE_KEY = 'rails.cache.key'.freeze
+          TAG_CACHE_KEY_MULTI = 'rails.cache.keys'.freeze
+          TAG_COMPONENT = 'active_support'.freeze
+          TAG_OPERATION_CACHE = 'cache'.freeze
+        end
+      end
+    end
+  end
+end

data/lib/datadog/tracing/contrib/active_support/integration.rb

@@ -0,0 +1,50 @@
+# typed: false
+require 'datadog/tracing/contrib/integration'
+require 'datadog/tracing/contrib/active_support/configuration/settings'
+require 'datadog/tracing/contrib/active_support/patcher'
+require 'datadog/tracing/contrib/active_support/cache/redis'
+require 'datadog/tracing/contrib/rails/utils'
+
+module Datadog
+  module Tracing
+    module Contrib
+      module ActiveSupport
+        # Describes the ActiveSupport integration
+        class Integration
+          include Contrib::Integration
+
+          MINIMUM_VERSION = Gem::Version.new('3.2')
+
+          # @public_api Changing the integration name or integration options can cause breaking changes
+          register_as :active_support, auto_patch: false
+
+          def self.version
+            Gem.loaded_specs['activesupport'] && Gem.loaded_specs['activesupport'].version
+          end
+
+          def self.loaded?
+            !defined?(::ActiveSupport).nil?
+          end
+
+          def self.compatible?
+            super && version >= MINIMUM_VERSION
+          end
+
+          # enabled by rails integration so should only auto instrument
+          # if detected that it is being used without rails
+          def auto_instrument?
+            !Contrib::Rails::Utils.railtie_supported?
+          end
+
+          def new_configuration
+            Configuration::Settings.new
+          end
+
+          def patcher
+            ActiveSupport::Patcher
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,70 @@
+# typed: false
+require 'datadog/tracing/contrib/active_support/notifications/subscriber'
+
+module Datadog
+  module Tracing
+    module Contrib
+      module ActiveSupport
+        module Notifications
+          # Defines behaviors for an ActiveSupport::Notifications event.
+          # Compose this into a module or class, then define
+          # #event_name, #span_name, and #process. You can then
+          # invoke Event.subscribe! to more easily subscribe to an event.
+          module Event
+            def self.included(base)
+              base.include(Subscriber)
+              base.extend(ClassMethods)
+              base.send(:on_subscribe) { base.subscribe }
+            end
+
+            # Redefines some class behaviors for a Subscriber to make
+            # it a bit simpler for an Event.
+            module ClassMethods
+              # Publicly exposes protected method `subscribe!`
+              def subscribe! # rubocop:disable Lint/UselessMethodDefinition
+                super
+              end
+
+              def subscription(span_name = nil, options = nil)
+                super(
+                  span_name || self.span_name,
+                  options || span_options,
+                  &method(:process)
+                )
+              end
+
+              def subscribe(pattern = nil, span_name = nil, options = nil)
+                if supported?
+                  super(
+                    pattern || event_name,
+                    span_name || self.span_name,
+                    options || span_options,
+                    &method(:process)
+                  )
+                end
+              end
+
+              def supported?
+                true
+              end
+
+              def span_options
+                {}
+              end
+
+              def report_if_exception(span, payload)
+                exception = payload_exception(payload)
+                span.set_error(payload[:exception]) if exception
+              end
+
+              def payload_exception(payload)
+                payload[:exception_object] ||
+                  payload[:exception] # Fallback for ActiveSupport < 5.0
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/tracing/contrib/active_support/notifications/subscriber.rb

@@ -0,0 +1,70 @@
+# typed: true
+require 'set'
+require 'datadog/tracing/contrib/active_support/notifications/subscription'
+
+module Datadog
+  module Tracing
+    module Contrib
+      module ActiveSupport
+        module Notifications
+          # For classes that listen to ActiveSupport::Notification events.
+          # Creates subscriptions that are wrapped with tracing.
+          module Subscriber
+            def self.included(base)
+              base.extend(ClassMethods)
+            end
+
+            # Class methods that are implemented in the inheriting class.
+            module ClassMethods
+              # Returns a list of subscriptions created for this class.
+              def subscriptions
+                @subscriptions ||= Set.new
+              end
+
+              # Returns whether subscriptions have been activated, via #subscribe!
+              def subscribed?
+                subscribed == true
+              end
+
+              protected
+
+              # Defines a callback for when subscribe! is called.
+              # Should contain subscription setup, defined by the inheriting class.
+              def on_subscribe(&block)
+                @on_subscribe_block = block
+              end
+
+              # Runs the on_subscribe callback once, to activate subscriptions.
+              # Should be triggered by the inheriting class.
+              def subscribe!
+                return subscribed? if subscribed? || on_subscribe_block.nil?
+
+                on_subscribe_block.call
+                @subscribed = true
+              end
+
+              # Creates a subscription and immediately activates it.
+              def subscribe(pattern, span_name, options = {}, &block)
+                subscription(span_name, options, &block).tap do |subscription|
+                  subscription.subscribe(pattern)
+                end
+              end
+
+              # Creates a subscription without activating it.
+              # Subscription is added to the inheriting class' list of subscriptions.
+              def subscription(span_name, options = {}, &block)
+                Subscription.new(span_name, options, &block).tap do |subscription|
+                  subscriptions << subscription
+                end
+              end
+
+              private
+
+              attr_reader :subscribed, :on_subscribe_block
+            end
+          end
+        end
+      end
+    end
+  end
+end