datadog 2.0.0.beta1

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

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+require_relative '../../patcher'
+require_relative '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
+
+            # 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)
+            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,47 @@
+# frozen_string_literal: true
+
+require_relative '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,47 @@
+# frozen_string_literal: true
+
+require_relative '../../configuration/settings'
+require_relative '../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.type :bool
+              o.env Ext::ENV_ENABLED
+              o.default true
+            end
+
+            # @!visibility private
+            option :analytics_enabled do |o|
+              o.type :bool
+              o.env Ext::ENV_ANALYTICS_ENABLED
+              o.default false
+            end
+
+            option :analytics_sample_rate do |o|
+              o.type :float
+              o.env Ext::ENV_ANALYTICS_SAMPLE_RATE
+              o.default 1.0
+            end
+
+            option :cache_service do |o|
+              o.type :string, nilable: true
+              o.default do
+                Contrib::SpanAttributeSchema.fetch_service_name(
+                  '',
+                  Ext::SERVICE_CACHE
+                )
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+# frozen_string_literal: 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'
+          # @!visibility private
+          ENV_ANALYTICS_ENABLED = 'DD_TRACE_ACTIVE_SUPPORT_ANALYTICS_ENABLED'
+          ENV_ANALYTICS_SAMPLE_RATE = 'DD_TRACE_ACTIVE_SUPPORT_ANALYTICS_SAMPLE_RATE'
+          QUANTIZE_CACHE_MAX_KEY_SIZE = 300
+          RESOURCE_CACHE_DELETE = 'DELETE'
+          RESOURCE_CACHE_GET = 'GET'
+          RESOURCE_CACHE_MGET = 'MGET'
+          RESOURCE_CACHE_SET = 'SET'
+          RESOURCE_CACHE_MSET = 'MSET'
+          SERVICE_CACHE = 'active_support-cache'
+          SPAN_CACHE = 'rails.cache'
+          SPAN_TYPE_CACHE = 'cache'
+          TAG_CACHE_BACKEND = 'rails.cache.backend'
+          TAG_CACHE_KEY = 'rails.cache.key'
+          TAG_CACHE_KEY_MULTI = 'rails.cache.keys'
+          TAG_COMPONENT = 'active_support'
+          TAG_OPERATION_CACHE = 'cache'
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require_relative '../integration'
+require_relative 'configuration/settings'
+require_relative 'patcher'
+require_relative 'cache/redis'
+require_relative '../rails/integration'
+require_relative '../rails/utils'
+
+module Datadog
+  module Tracing
+    module Contrib
+      module ActiveSupport
+        # Describes the ActiveSupport integration
+        class Integration
+          include Contrib::Integration
+
+          MINIMUM_VERSION = Contrib::Rails::Ext::MINIMUM_VERSION
+
+          # @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,71 @@
+# frozen_string_literal: true
+
+require_relative '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,71 @@
+# frozen_string_literal: true
+
+require 'set'
+require_relative '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

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

@@ -0,0 +1,164 @@
+# frozen_string_literal: true
+
+module Datadog
+  module Tracing
+    module Contrib
+      module ActiveSupport
+        module Notifications
+          # An ActiveSupport::Notification subscription that wraps events with tracing.
+          class Subscription
+            attr_accessor \
+              :span_name,
+              :options
+
+            def initialize(span_name, options, &block)
+              raise ArgumentError, 'Must be given a block!' unless block
+
+              @span_name = span_name
+              @options = options
+              @handler = Handler.new(&block)
+              @callbacks = Callbacks.new
+            end
+
+            # ActiveSupport 3.x calls this
+            def call(name, start, finish, id, payload)
+              start_span(name, id, payload, start)
+              finish_span(name, id, payload, finish)
+            end
+
+            # ActiveSupport 4+ calls this on start
+            def start(name, id, payload)
+              start_span(name, id, payload)
+            end
+
+            # ActiveSupport 4+ calls this on finish
+            def finish(name, id, payload)
+              finish_span(name, id, payload)
+            end
+
+            def before_trace(&block)
+              callbacks.add(:before_trace, &block) if block
+            end
+
+            def after_trace(&block)
+              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
+            end
+
+            def unsubscribe_all
+              return false if subscribers.empty?
+
+              subscribers.each_key { |pattern| unsubscribe(pattern) }
+              true
+            end
+
+            protected
+
+            attr_reader \
+              :handler,
+              :callbacks
+
+            def start_span(name, id, payload, start = nil)
+              # Run callbacks
+              callbacks.run(name, :before_trace, id, payload, start)
+
+              # Start a trace
+              Tracing.trace(@span_name, **@options).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)
+              payload[:datadog_span].tap do |span|
+                # If no active span, return.
+                return nil if span.nil?
+
+                # Run handler for event
+                handler.run(span, name, id, payload)
+
+                # Finish the span
+                span.finish(finish)
+
+                # Run callbacks
+                callbacks.run(name, :after_trace, span, id, payload, finish)
+              end
+            end
+
+            # Pattern => ActiveSupport:Notifications::Subscribers
+            def subscribers
+              @subscribers ||= {}
+            end
+
+            # Wrapper for subscription handler
+            class Handler
+              attr_reader :block
+
+              def initialize(&block)
+                @block = block
+              end
+
+              def run(span, name, id, payload)
+                run!(span, name, id, payload)
+              rescue StandardError => e
+                Datadog.logger.debug(
+                  "ActiveSupport::Notifications handler for '#{name}' failed: #{e.class.name} #{e.message}"
+                )
+              end
+
+              def run!(*args)
+                @block.call(*args)
+              end
+            end
+
+            # Wrapper for subscription callbacks
+            class Callbacks
+              attr_reader :blocks
+
+              def initialize
+                @blocks = {}
+              end
+
+              def add(key, &block)
+                blocks_for(key) << block if block
+              end
+
+              def run(event, key, *args)
+                blocks_for(key).each do |callback|
+                  begin
+                    callback.call(event, key, *args)
+                  rescue StandardError => e
+                    Datadog.logger.debug(
+                      "ActiveSupport::Notifications '#{key}' callback for '#{event}' failed: #{e.class.name} #{e.message}"
+                    )
+                  end
+                end
+              end
+
+              private
+
+              def blocks_for(key)
+                blocks[key] ||= []
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require_relative '../patcher'
+require_relative 'cache/patcher'
+
+module Datadog
+  module Tracing
+    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
+end

data/lib/datadog/tracing/contrib/analytics.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require_relative '../analytics'
+
+module Datadog
+  module Tracing
+    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.tracing.analytics.enabled && flag != false) || flag == true
+        end
+
+        def set_sample_rate(span, sample_rate)
+          Tracing::Analytics.set_sample_rate(span, sample_rate)
+        end
+
+        def set_measured(span, value = true)
+          Tracing::Analytics.set_measured(span, value)
+        end
+      end
+    end
+  end
+end

data/lib/datadog/tracing/contrib/auto_instrument.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require_relative '../contrib'
+require_relative 'extensions'
+
+module Datadog
+  module Tracing
+    # Out-of-the-box instrumentation for tracing
+    module Contrib
+      # Auto-activate instrumentation
+      def self.auto_instrument!
+        require_relative 'rails/utils'
+
+        # Defer to Rails if this is a Rails application
+        if Datadog::Tracing::Contrib::Rails::Utils.railtie_supported?
+          require_relative 'rails/auto_instrument_railtie'
+        else
+          AutoInstrument.patch_all!
+        end
+      end
+
+      # Extensions for auto instrumentation added to the base library
+      # AutoInstrumentation enables all integration
+      module AutoInstrument
+        def self.patch_all!
+          integrations = []
+
+          Contrib::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|
+            # Ignore any instrumentation load errors (otherwise it might spam logs)
+            c.tracing.ignore_integration_load_errors = true
+
+            # Activate instrumentation for each integration
+            integrations.each do |integration_name|
+              c.tracing.instrument integration_name
+            end
+          end
+        end
+      end
+    end
+  end
+end
+
+Datadog::Tracing::Contrib.auto_instrument!