ddtrace 0.13.0 → 0.47.0

data/lib/ddtrace/contrib/active_support/cache/patcher.rb

@@ -0,0 +1,69 @@
+require 'ddtrace/contrib/patcher'
+require 'ddtrace/contrib/active_support/cache/instrumentation'
+
+module Datadog
+  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).send(:prepend, Cache::Instrumentation::Read)
+          end
+
+          def patch_cache_store_read_multi
+            cache_store_class(:read_multi).send(:prepend, Cache::Instrumentation::ReadMulti)
+          end
+
+          def patch_cache_store_fetch
+            cache_store_class(:fetch).send(: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.send(:prepend, Cache::Instrumentation::FetchMulti)
+          end
+
+          def patch_cache_store_write
+            cache_store_class(:write).send(: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.send(:prepend, Cache::Instrumentation::WriteMulti)
+          end
+
+          def patch_cache_store_delete
+            cache_store_class(:delete).send(:prepend, Cache::Instrumentation::Delete)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ddtrace/contrib/active_support/cache/redis.rb

@@ -0,0 +1,47 @@
+require 'ddtrace/contrib/active_support/cache/patcher'
+
+module Datadog
+  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.instance_eval do
+            class << self
+              prepend Redis::Patcher
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ddtrace/contrib/active_support/configuration/settings.rb

@@ -0,0 +1,30 @@
+require 'ddtrace/contrib/configuration/settings'
+require 'ddtrace/contrib/active_support/ext'
+
+module Datadog
+  module Contrib
+    module ActiveSupport
+      module Configuration
+        # Custom settings for the ActiveSupport integration
+        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, Ext::ENV_ANALYTICS_ENABLED_OLD], false) }
+            o.lazy
+          end
+
+          option :analytics_sample_rate do |o|
+            o.default { env_to_float([Ext::ENV_ANALYTICS_SAMPLE_RATE, Ext::ENV_ANALYTICS_SAMPLE_RATE_OLD], 1.0) }
+            o.lazy
+          end
+
+          option :cache_service, default: Ext::SERVICE_CACHE
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+module Datadog
+  module Contrib
+    module ActiveSupport
+      # ActiveSupport integration constants
+      module Ext
+        APP = 'active_support'.freeze
+        ENV_ENABLED = 'DD_TRACE_ACTIVE_SUPPORT_ENABLED'.freeze
+        ENV_ANALYTICS_ENABLED = 'DD_TRACE_ACTIVE_SUPPORT_ANALYTICS_ENABLED'.freeze
+        ENV_ANALYTICS_ENABLED_OLD = 'DD_ACTIVE_SUPPORT_ANALYTICS_ENABLED'.freeze
+        ENV_ANALYTICS_SAMPLE_RATE = 'DD_TRACE_ACTIVE_SUPPORT_ANALYTICS_SAMPLE_RATE'.freeze
+        ENV_ANALYTICS_SAMPLE_RATE_OLD = 'DD_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
+      end
+    end
+  end
+end

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

@@ -0,0 +1,46 @@
+require 'ddtrace/contrib/integration'
+require 'ddtrace/contrib/active_support/configuration/settings'
+require 'ddtrace/contrib/active_support/patcher'
+require 'ddtrace/contrib/active_support/cache/redis'
+require 'ddtrace/contrib/rails/utils'
+
+module Datadog
+  module Contrib
+    module ActiveSupport
+      # Describes the ActiveSupport integration
+      class Integration
+        include Contrib::Integration
+
+        MINIMUM_VERSION = Gem::Version.new('3.0')
+
+        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?
+          !Datadog::Contrib::Rails::Utils.railtie_supported?
+        end
+
+        def default_configuration
+          Configuration::Settings.new
+        end
+
+        def patcher
+          ActiveSupport::Patcher
+        end
+      end
+    end
+  end
+end

data/lib/ddtrace/contrib/active_support/notifications/event.rb

@@ -18,7 +18,10 @@ module Datadog
           # Redefines some class behaviors for a Subscriber to make
           # it a bit simpler for an Event.
           module ClassMethods
-            def subscribe!
+            DEFAULT_TRACER = -> { Datadog.tracer }
+
+            # Publicly exposes protected method `subscribe!`
+            def subscribe! # rubocop:disable Lint/UselessMethodDefinition
               super
             end
 
@@ -52,7 +55,17 @@ module Datadog
             end
 
             def tracer
-              Datadog.tracer
+              DEFAULT_TRACER
+            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

data/lib/ddtrace/contrib/active_support/notifications/subscriber.rb

@@ -36,12 +36,13 @@ module Datadog
             # 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 = {}, tracer = Datadog.tracer, &block)
+            def subscribe(pattern, span_name, options = {}, tracer = -> { Datadog.tracer }, &block)
               subscription(span_name, options, tracer, &block).tap do |subscription|
                 subscription.subscribe(pattern)
               end
@@ -49,7 +50,7 @@ module Datadog
 
             # Creates a subscription without activating it.
             # Subscription is added to the inheriting class' list of subscriptions.
-            def subscription(span_name, options = {}, tracer = Datadog.tracer, &block)
+            def subscription(span_name, options = {}, tracer = -> { Datadog.tracer }, &block)
               Subscription.new(tracer, span_name, options, &block).tap do |subscription|
                 subscriptions << subscription
               end

data/lib/ddtrace/contrib/active_support/notifications/subscription.rb

@@ -5,12 +5,12 @@ module Datadog
         # An ActiveSupport::Notification subscription that wraps events with tracing.
         class Subscription
           attr_accessor \
-            :tracer,
             :span_name,
             :options
 
           def initialize(tracer, span_name, options, &block)
-            raise ArgumentError, 'Must be given a block!' unless block_given?
+            raise ArgumentError, 'Must be given a block!' unless block
+
             @tracer = tracer
             @span_name = span_name
             @options = options
@@ -18,6 +18,10 @@ module Datadog
             @callbacks = Callbacks.new
           end
 
+          def tracer
+            @tracer.is_a?(Proc) ? @tracer.call : @tracer
+          end
+
           # ActiveSupport 3.x calls this
           def call(name, start, finish, id, payload)
             start_span(name, id, payload, start)
@@ -35,21 +39,23 @@ module Datadog
           end
 
           def before_trace(&block)
-            callbacks.add(:before_trace, &block) if block_given?
+            callbacks.add(:before_trace, &block) if block
           end
 
           def after_trace(&block)
-            callbacks.add(:after_trace, &block) if block_given?
+            callbacks.add(:after_trace, &block) if block
           end
 
           def subscribe(pattern)
             return false if subscribers.key?(pattern)
+
             subscribers[pattern] = ::ActiveSupport::Notifications.subscribe(pattern, self)
             true
           end
 
           def unsubscribe(pattern)
             return false unless subscribers.key?(pattern)
+
             ::ActiveSupport::Notifications.unsubscribe(subscribers[pattern])
             subscribers.delete(pattern)
             true
@@ -57,7 +63,8 @@ module Datadog
 
           def unsubscribe_all
             return false if subscribers.empty?
-            subscribers.keys.each { |pattern| unsubscribe(pattern) }
+
+            subscribers.each_key { |pattern| unsubscribe(pattern) }
             true
           end
 
@@ -72,14 +79,15 @@ module Datadog
             callbacks.run(name, :before_trace, id, payload, start)
 
             # Start a trace
-            tracer.trace(@span_name, @options).tap do |span|
-              # Assign start time if provided
-              span.start_time = start unless start.nil?
+            tracer.trace(@span_name, @options.dup).tap do |span|
+              # Start span if time is provided
+              span.start(start) unless start.nil?
+              payload[:datadog_span] = span
             end
           end
 
           def finish_span(name, id, payload, finish = nil)
-            tracer.active_span.tap do |span|
+            payload[:datadog_span].tap do |span|
               # If no active span, return.
               return nil if span.nil?
 
@@ -110,7 +118,7 @@ module Datadog
             def run(span, name, id, payload)
               run!(span, name, id, payload)
             rescue StandardError => e
-              Datadog::Tracer.log.debug("ActiveSupport::Notifications handler for '#{name}' failed: #{e.message}")
+              Datadog.logger.debug("ActiveSupport::Notifications handler for '#{name}' failed: #{e.message}")
             end
 
             def run!(*args)
@@ -127,7 +135,7 @@ module Datadog
             end
 
             def add(key, &block)
-              blocks_for(key) << block if block_given?
+              blocks_for(key) << block if block
             end
 
             def run(event, key, *args)
@@ -135,7 +143,7 @@ module Datadog
                 begin
                   callback.call(event, key, *args)
                 rescue StandardError => e
-                  Datadog::Tracer.log.debug(
+                  Datadog.logger.debug(
                     "ActiveSupport::Notifications '#{key}' callback for '#{event}' failed: #{e.message}"
                   )
                 end

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

@@ -0,0 +1,23 @@
+require 'ddtrace/contrib/patcher'
+require 'ddtrace/contrib/active_support/cache/patcher'
+
+module Datadog
+  module Contrib
+    module ActiveSupport
+      # Patcher enables patching of 'active_support' module.
+      module Patcher
+        include Contrib::Patcher
+
+        module_function
+
+        def target_version
+          Integration.version
+        end
+
+        def patch
+          Cache::Patcher.patch
+        end
+      end
+    end
+  end
+end

data/lib/ddtrace/contrib/analytics.rb

@@ -0,0 +1,24 @@
+require 'ddtrace/analytics'
+
+module Datadog
+  module Contrib
+    # Defines analytics behavior for integrations
+    module Analytics
+      module_function
+
+      # Checks whether analytics should be enabled.
+      # `flag` is a truthy/falsey value that represents a setting on the integration.
+      def enabled?(flag = nil)
+        (Datadog.configuration.analytics.enabled && flag != false) || flag == true
+      end
+
+      def set_sample_rate(span, sample_rate)
+        Datadog::Analytics.set_sample_rate(span, sample_rate)
+      end
+
+      def set_measured(span, value = true)
+        Datadog::Analytics.set_measured(span, value)
+      end
+    end
+  end
+end

data/lib/ddtrace/contrib/auto_instrument.rb

@@ -0,0 +1,49 @@
+require 'ddtrace'
+
+module Datadog
+  module Contrib
+    # Extensions for auto instrumentation added to the base library
+    # AutoInstrumentation enables all integration
+    module AutoInstrument
+      def self.extended(base)
+        base.send(:extend, Patch)
+      end
+
+      # Patch adds method for invoking auto_instrumentation
+      module Patch
+        def add_auto_instrument
+          super
+
+          if Datadog::Contrib::Rails::Utils.railtie_supported?
+            require 'ddtrace/contrib/rails/auto_instrument_railtie'
+          else
+            AutoInstrument.patch_all
+          end
+          AutoInstrument.patch_all
+        end
+      end
+
+      def self.patch_all
+        integrations = []
+
+        Datadog.registry.each do |integration|
+          # some instrumentations are automatically enabled when the `rails` instrumentation is enabled,
+          # patching them on their own automatically outside of the rails integration context would
+          # cause undesirable service naming, so we exclude them based their auto_instrument? setting.
+          # we also don't want to mix rspec/cucumber integration in as rspec is env we run tests in.
+          next unless integration.klass.auto_instrument?
+
+          integrations << integration.name
+        end
+
+        Datadog.configure do |c|
+          c.reduce_log_verbosity
+          # This will activate auto-instrumentation for Rails
+          integrations.each do |integration_name|
+            c.use integration_name
+          end
+        end
+      end
+    end
+  end
+end