ddtrace 0.34.1 → 1.23.1

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

@@ -1,46 +0,0 @@
-require 'ddtrace/ext/sql'
-require 'ddtrace/ext/app_types'
-require 'ddtrace/contrib/integration'
-require 'ddtrace/contrib/active_record/events'
-require 'ddtrace/contrib/active_record/configuration/resolver'
-require 'ddtrace/contrib/active_record/configuration/settings'
-require 'ddtrace/contrib/active_record/patcher'
-
-module Datadog
-  module Contrib
-    module ActiveRecord
-      # Describes the ActiveRecord integration
-      class Integration
-        include Contrib::Integration
-
-        MINIMUM_VERSION = Gem::Version.new('3.0')
-
-        register_as :active_record, auto_patch: false
-
-        def self.version
-          Gem.loaded_specs['activerecord'] && Gem.loaded_specs['activerecord'].version
-        end
-
-        def self.loaded?
-          !defined?(::ActiveRecord).nil?
-        end
-
-        def self.compatible?
-          super && version >= MINIMUM_VERSION
-        end
-
-        def default_configuration
-          Configuration::Settings.new
-        end
-
-        def patcher
-          ActiveRecord::Patcher
-        end
-
-        def resolver
-          @resolver ||= Configuration::Resolver.new
-        end
-      end
-    end
-  end
-end

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

@@ -1,23 +0,0 @@
-require 'ddtrace/contrib/patcher'
-require 'ddtrace/contrib/active_record/events'
-
-module Datadog
-  module Contrib
-    module ActiveRecord
-      # Patcher enables patching of 'active_record' module.
-      module Patcher
-        include Contrib::Patcher
-
-        module_function
-
-        def target_version
-          Integration.version
-        end
-
-        def patch
-          Events.subscribe!
-        end
-      end
-    end
-  end
-end

data/lib/ddtrace/contrib/active_record/utils.rb

@@ -1,76 +0,0 @@
-module Datadog
-  module Contrib
-    module ActiveRecord
-      # Common utilities for Rails
-      module Utils
-        EMPTY_CONFIG = {}.freeze
-
-        def self.adapter_name
-          Datadog::Utils::Database.normalize_vendor(connection_config[:adapter])
-        end
-
-        def self.database_name
-          connection_config[:database]
-        end
-
-        def self.adapter_host
-          connection_config[:host]
-        end
-
-        def self.adapter_port
-          connection_config[:port]
-        end
-
-        # In newer Rails versions, the `payload` contains both the `connection` and its `object_id` named `connection_id`.
-        #
-        # So, if rails is recent we'll have a direct access to the connection.
-        # Else, we'll find it thanks to the passed `connection_id`.
-        #
-        # See this PR for more details: https://github.com/rails/rails/pull/34602
-        #
-        def self.connection_config(connection = nil, connection_id = nil)
-          return default_connection_config if connection.nil? && connection_id.nil?
-
-          conn = if !connection.nil?
-                   connection
-                 # Rails 3.0 - 3.2
-                 elsif Gem.loaded_specs['activerecord'].version < Gem::Version.new('4.0')
-                   ::ActiveRecord::Base
-                     .connection_handler
-                     .connection_pools
-                     .values
-                     .flat_map(&:connections)
-                     .find { |c| c.object_id == connection_id }
-                 # Rails 4.2+
-                 else
-                   ::ActiveRecord::Base
-                     .connection_handler
-                     .connection_pool_list
-                     .flat_map(&:connections)
-                     .find { |c| c.object_id == connection_id }
-                 end
-
-          if conn.instance_variable_defined?(:@config)
-            conn.instance_variable_get(:@config)
-          else
-            EMPTY_CONFIG
-          end
-        end
-
-        def self.default_connection_config
-          return @default_connection_config if instance_variable_defined?(:@default_connection_config)
-          current_connection_name = if ::ActiveRecord::Base.respond_to?(:connection_specification_name)
-                                      ::ActiveRecord::Base.connection_specification_name
-                                    else
-                                      ::ActiveRecord::Base
-                                    end
-
-          connection_pool = ::ActiveRecord::Base.connection_handler.retrieve_connection_pool(current_connection_name)
-          connection_pool.nil? ? EMPTY_CONFIG : (@default_connection_config = connection_pool.spec.config)
-        rescue StandardError
-          EMPTY_CONFIG
-        end
-      end
-    end
-  end
-end

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

@@ -1,157 +0,0 @@
-require 'ddtrace/contrib/active_support/ext'
-
-module Datadog
-  module Contrib
-    module ActiveSupport
-      module Cache
-        # Defines instrumentation for ActiveSupport caching
-        # rubocop:disable Lint/RescueException
-        module Instrumentation
-          module_function
-
-          def start_trace_cache(payload)
-            tracer = Datadog.configuration[:active_support][:tracer]
-
-            # 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 = tracer.active_span
-            return if payload[:action] == Ext::RESOURCE_CACHE_GET &&
-                      current_span.try(:name) == Ext::SPAN_CACHE &&
-                      current_span.try(:resource) == Ext::RESOURCE_CACHE_GET
-
-            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 = tracer.trace(Ext::SPAN_CACHE, service: service, span_type: type)
-            span.resource = payload.fetch(:action)
-            tracing_context[:dd_cache_span] = span
-          rescue StandardError => e
-            Datadog::Logger.log.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 = Datadog::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.log.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 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 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 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
-      end
-    end
-  end
-end

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

@@ -1,48 +0,0 @@
-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_fetch
-            patch_cache_store_write
-            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_fetch
-            cache_store_class(:fetch).send(:prepend, Cache::Instrumentation::Fetch)
-          end
-
-          def patch_cache_store_write
-            cache_store_class(:write).send(:prepend, Cache::Instrumentation::Write)
-          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

@@ -1,47 +0,0 @@
-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/master/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

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

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

@@ -1,21 +0,0 @@
-module Datadog
-  module Contrib
-    module ActiveSupport
-      # ActiveSupport integration constants
-      module Ext
-        APP = 'active_support'.freeze
-        ENV_ANALYTICS_ENABLED = 'DD_ACTIVE_SUPPORT_ANALYTICS_ENABLED'.freeze
-        ENV_ANALYTICS_SAMPLE_RATE = '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_SET = 'SET'.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
-      end
-    end
-  end
-end

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

@@ -1,40 +0,0 @@
-require 'ddtrace/contrib/integration'
-require 'ddtrace/contrib/active_support/configuration/settings'
-require 'ddtrace/contrib/active_support/patcher'
-
-require 'ddtrace/contrib/active_support/cache/redis'
-
-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
-
-        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,62 +0,0 @@
-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.send(:include, Subscriber)
-            base.send(: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
-            def subscribe!
-              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
-              Datadog.tracer
-            end
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,66 +0,0 @@
-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.send(: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