ddtrace 0.54.2 → 1.0.0.beta1

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

@@ -1,70 +0,0 @@
-# typed: true
-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).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

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

@@ -1,44 +0,0 @@
-# typed: true
-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.singleton_class.prepend(Redis::Patcher)
-        end
-      end
-    end
-  end
-end

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

@@ -1,31 +0,0 @@
-# typed: false
-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

@@ -1,28 +0,0 @@
-# typed: true
-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

@@ -1,47 +0,0 @@
-# typed: false
-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

@@ -1,76 +0,0 @@
-# typed: false
-require 'ddtrace/contrib/active_support/notifications/subscriber'
-
-module Datadog
-  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
-            DEFAULT_TRACER = -> { Datadog.tracer }
-
-            # Publicly exposes protected method `subscribe!`
-            def subscribe! # rubocop:disable Lint/UselessMethodDefinition
-              super
-            end
-
-            def subscription(span_name = nil, options = nil, tracer = nil)
-              super(
-                span_name || self.span_name,
-                options || span_options,
-                tracer || self.tracer,
-                &method(:process)
-              )
-            end
-
-            def subscribe(pattern = nil, span_name = nil, options = nil, tracer = nil)
-              if supported?
-                super(
-                  pattern || event_name,
-                  span_name || self.span_name,
-                  options || span_options,
-                  tracer || self.tracer,
-                  &method(:process)
-                )
-              end
-            end
-
-            def supported?
-              true
-            end
-
-            def span_options
-              {}
-            end
-
-            def 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
-      end
-    end
-  end
-end

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

@@ -1,68 +0,0 @@
-# typed: true
-require 'set'
-require 'ddtrace/contrib/active_support/notifications/subscription'
-
-module Datadog
-  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 = {}, tracer = -> { Datadog.tracer }, &block)
-              subscription(span_name, options, tracer, &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 = {}, tracer = -> { Datadog.tracer }, &block)
-              Subscription.new(tracer, span_name, options, &block).tap do |subscription|
-                subscriptions << subscription
-              end
-            end
-
-            private
-
-            attr_reader :subscribed, :on_subscribe_block
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,164 +0,0 @@
-# typed: false
-module Datadog
-  module Contrib
-    module ActiveSupport
-      module Notifications
-        # An ActiveSupport::Notification subscription that wraps events with tracing.
-        class Subscription
-          attr_accessor \
-            :span_name,
-            :options
-
-          def initialize(tracer, span_name, options, &block)
-            raise ArgumentError, 'Must be given a block!' unless block
-
-            @tracer = tracer
-            @span_name = span_name
-            @options = options
-            @handler = Handler.new(&block)
-            @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)
-            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
-            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)
-            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.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.message}"
-                  )
-                end
-              end
-            end
-
-            private
-
-            def blocks_for(key)
-              blocks[key] ||= []
-            end
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,24 +0,0 @@
-# typed: true
-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

@@ -1,25 +0,0 @@
-# typed: true
-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

@@ -1,48 +0,0 @@
-# typed: false
-
-module Datadog
-  module Contrib
-    # Extensions for auto instrumentation added to the base library
-    # AutoInstrumentation enables all integration
-    module AutoInstrument
-      def self.extended(base)
-        base.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
-        end
-      end
-
-      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|
-          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

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

@@ -1,31 +0,0 @@
-# typed: false
-require 'ddtrace/contrib/configuration/settings'
-require 'ddtrace/contrib/aws/ext'
-
-module Datadog
-  module Contrib
-    module Aws
-      module Configuration
-        # Custom settings for the AWS 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 :service_name, default: Ext::SERVICE_NAME
-        end
-      end
-    end
-  end
-end

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

@@ -1,24 +0,0 @@
-# typed: true
-module Datadog
-  module Contrib
-    module Aws
-      # AWS integration constants
-      module Ext
-        APP = 'aws'.freeze
-        ENV_ENABLED = 'DD_TRACE_AWS_ENABLED'.freeze
-        ENV_ANALYTICS_ENABLED = 'DD_TRACE_AWS_ANALYTICS_ENABLED'.freeze
-        ENV_ANALYTICS_ENABLED_OLD = 'DD_AWS_ANALYTICS_ENABLED'.freeze
-        ENV_ANALYTICS_SAMPLE_RATE = 'DD_TRACE_AWS_ANALYTICS_SAMPLE_RATE'.freeze
-        ENV_ANALYTICS_SAMPLE_RATE_OLD = 'DD_AWS_ANALYTICS_SAMPLE_RATE'.freeze
-        SERVICE_NAME = 'aws'.freeze
-        SPAN_COMMAND = 'aws.command'.freeze
-        TAG_AGENT = 'aws.agent'.freeze
-        TAG_DEFAULT_AGENT = 'aws-sdk-ruby'.freeze
-        TAG_HOST = 'host'.freeze
-        TAG_OPERATION = 'aws.operation'.freeze
-        TAG_PATH = 'path'.freeze
-        TAG_REGION = 'aws.region'.freeze
-      end
-    end
-  end
-end