ddtrace 0.53.0 → 1.9.0

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

@@ -1,31 +0,0 @@
-# typed: true
-require 'ddtrace/contrib/active_support/notifications/event'
-
-module Datadog
-  module Contrib
-    module ActiveRecord
-      # Defines basic behaviors for an ActiveRecord event.
-      module Event
-        def self.included(base)
-          base.include(ActiveSupport::Notifications::Event)
-          base.extend(ClassMethods)
-        end
-
-        # Class methods for ActiveRecord events.
-        module ClassMethods
-          def span_options
-            { service: configuration[:service_name] }
-          end
-
-          def tracer
-            -> { configuration[:tracer] }
-          end
-
-          def configuration
-            Datadog.configuration[:active_record]
-          end
-        end
-      end
-    end
-  end
-end

data/lib/ddtrace/contrib/active_record/events/instantiation.rb

@@ -1,61 +0,0 @@
-# typed: false
-require 'ddtrace/contrib/analytics'
-require 'ddtrace/contrib/active_record/ext'
-require 'ddtrace/contrib/active_record/event'
-
-module Datadog
-  module Contrib
-    module ActiveRecord
-      module Events
-        # Defines instrumentation for instantiation.active_record event
-        module Instantiation
-          include ActiveRecord::Event
-
-          EVENT_NAME = 'instantiation.active_record'.freeze
-
-          module_function
-
-          def supported?
-            Gem.loaded_specs['activerecord'] \
-              && Gem.loaded_specs['activerecord'].version >= Gem::Version.new('4.2')
-          end
-
-          def event_name
-            self::EVENT_NAME
-          end
-
-          def span_name
-            Ext::SPAN_INSTANTIATION
-          end
-
-          def process(span, event, _id, payload)
-            # Inherit service name from parent, if available.
-            span.service = if configuration[:orm_service_name]
-                             configuration[:orm_service_name]
-                           elsif span.parent
-                             span.parent.service
-                           else
-                             Ext::SERVICE_NAME
-                           end
-
-            span.resource = payload.fetch(:class_name)
-            span.span_type = Ext::SPAN_TYPE_INSTANTIATION
-
-            # Set analytics sample rate
-            if Contrib::Analytics.enabled?(configuration[:analytics_enabled])
-              Contrib::Analytics.set_sample_rate(span, configuration[:analytics_sample_rate])
-            end
-
-            # Measure service stats
-            Contrib::Analytics.set_measured(span)
-
-            span.set_tag(Ext::TAG_INSTANTIATION_CLASS_NAME, payload.fetch(:class_name))
-            span.set_tag(Ext::TAG_INSTANTIATION_RECORD_COUNT, payload.fetch(:record_count))
-          rescue StandardError => e
-            Datadog.logger.debug(e.message)
-          end
-        end
-      end
-    end
-  end
-end

data/lib/ddtrace/contrib/active_record/events/sql.rb

@@ -1,69 +0,0 @@
-# typed: false
-require 'ddtrace/ext/integration'
-require 'ddtrace/ext/net'
-require 'ddtrace/contrib/analytics'
-require 'ddtrace/contrib/active_record/ext'
-require 'ddtrace/contrib/active_record/event'
-
-module Datadog
-  module Contrib
-    module ActiveRecord
-      module Events
-        # Defines instrumentation for sql.active_record event
-        module SQL
-          include ActiveRecord::Event
-
-          EVENT_NAME = 'sql.active_record'.freeze
-          PAYLOAD_CACHE = 'CACHE'.freeze
-
-          module_function
-
-          def event_name
-            self::EVENT_NAME
-          end
-
-          def span_name
-            Ext::SPAN_SQL
-          end
-
-          def process(span, event, _id, payload)
-            config = Utils.connection_config(payload[:connection], payload[:connection_id])
-            settings = Datadog.configuration[:active_record, config]
-            adapter_name = Datadog::Utils::Database.normalize_vendor(config[:adapter])
-            service_name = if settings.service_name != Datadog::Utils::Database::VENDOR_DEFAULT
-                             settings.service_name
-                           else
-                             adapter_name
-                           end
-
-            span.name = "#{adapter_name}.query"
-            span.service = service_name
-            span.resource = payload.fetch(:sql)
-            span.span_type = Datadog::Ext::SQL::TYPE
-
-            # Tag as an external peer service
-            span.set_tag(Datadog::Ext::Integration::TAG_PEER_SERVICE, span.service)
-
-            # Set analytics sample rate
-            if Contrib::Analytics.enabled?(configuration[:analytics_enabled])
-              Contrib::Analytics.set_sample_rate(span, configuration[:analytics_sample_rate])
-            end
-
-            # Find out if the SQL query has been cached in this request. This meta is really
-            # helpful to users because some spans may have 0ns of duration because the query
-            # is simply cached from memory, so the notification is fired with start == finish.
-            cached = payload[:cached] || (payload[:name] == PAYLOAD_CACHE)
-
-            span.set_tag(Ext::TAG_DB_VENDOR, adapter_name)
-            span.set_tag(Ext::TAG_DB_NAME, config[:database])
-            span.set_tag(Ext::TAG_DB_CACHED, cached) if cached
-            span.set_tag(Datadog::Ext::NET::TARGET_HOST, config[:host]) if config[:host]
-            span.set_tag(Datadog::Ext::NET::TARGET_PORT, config[:port]) if config[:port]
-          rescue StandardError => e
-            Datadog.logger.debug(e.message)
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,31 +0,0 @@
-# typed: false
-require 'ddtrace/contrib/active_record/events/instantiation'
-require 'ddtrace/contrib/active_record/events/sql'
-
-module Datadog
-  module Contrib
-    module ActiveRecord
-      # Defines collection of instrumented ActiveRecord events
-      module Events
-        ALL = [
-          Events::Instantiation,
-          Events::SQL
-        ].freeze
-
-        module_function
-
-        def all
-          self::ALL
-        end
-
-        def subscriptions
-          all.collect(&:subscriptions).collect(&:to_a).flatten
-        end
-
-        def subscribe!
-          all.each(&:subscribe!)
-        end
-      end
-    end
-  end
-end

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

@@ -1,25 +0,0 @@
-# typed: true
-module Datadog
-  module Contrib
-    module ActiveRecord
-      # ActiveRecord integration constants
-      module Ext
-        APP = 'active_record'.freeze
-        ENV_ENABLED = 'DD_TRACE_ACTIVE_RECORD_ENABLED'.freeze
-        ENV_ANALYTICS_ENABLED = 'DD_TRACE_ACTIVE_RECORD_ANALYTICS_ENABLED'.freeze
-        ENV_ANALYTICS_ENABLED_OLD = 'DD_ACTIVE_RECORD_ANALYTICS_ENABLED'.freeze
-        ENV_ANALYTICS_SAMPLE_RATE = 'DD_TRACE_ACTIVE_RECORD_ANALYTICS_SAMPLE_RATE'.freeze
-        ENV_ANALYTICS_SAMPLE_RATE_OLD = 'DD_ACTIVE_RECORD_ANALYTICS_SAMPLE_RATE'.freeze
-        SERVICE_NAME = 'active_record'.freeze
-        SPAN_INSTANTIATION = 'active_record.instantiation'.freeze
-        SPAN_SQL = 'active_record.sql'.freeze
-        SPAN_TYPE_INSTANTIATION = 'custom'.freeze
-        TAG_DB_CACHED = 'active_record.db.cached'.freeze
-        TAG_DB_NAME = 'active_record.db.name'.freeze
-        TAG_DB_VENDOR = 'active_record.db.vendor'.freeze
-        TAG_INSTANTIATION_CLASS_NAME = 'active_record.instantiation.class_name'.freeze
-        TAG_INSTANTIATION_RECORD_COUNT = 'active_record.instantiation.record_count'.freeze
-      end
-    end
-  end
-end

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

@@ -1,54 +0,0 @@
-# typed: false
-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'
-require 'ddtrace/contrib/rails/utils'
-
-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
-
-        # 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
-          ActiveRecord::Patcher
-        end
-
-        def resolver
-          @resolver ||= Configuration::Resolver.new
-        end
-      end
-    end
-  end
-end

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

@@ -1,24 +0,0 @@
-# typed: true
-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,124 +0,0 @@
-# typed: false
-require 'datadog/core/environment/ext'
-
-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
-
-        # Returns the connection configuration hash from the
-        # current connection
-        #
-        # Since Rails 6.0, we have direct access to the object,
-        # while older versions of Rails only provide us the
-        # connection id.
-        #
-        # @see 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?
-                   # Since Rails 6.0, the connection object
-                   # is directly available.
-                   connection
-                 else
-                   # For Rails < 6.0, only the `connection_id`
-                   # is available. We have to find the connection
-                   # object from it.
-                   connection_from_id(connection_id)
-                 end
-
-          if conn && conn.instance_variable_defined?(:@config)
-            conn.instance_variable_get(:@config)
-          else
-            EMPTY_CONFIG
-          end
-        end
-
-        # DEV: JRuby responds to {ObjectSpace._id2ref}, despite raising an error
-        # DEV: when invoked. Thus, we have to explicitly check for Ruby runtime.
-        if Datadog::Core::Environment::Ext::RUBY_ENGINE != 'jruby'
-          # CRuby has access to {ObjectSpace._id2ref}, which allows for
-          # direct look up of the connection object.
-          def self.connection_from_id(connection_id)
-            # `connection_id` is the `#object_id` of the
-            # connection. We can perform an ObjectSpace
-            # lookup to find it.
-            #
-            # This works not only for ActiveRecord, but for
-            # extensions that might have their own connection
-            # pool (e.g. https://rubygems.org/gems/makara).
-            ObjectSpace._id2ref(connection_id)
-          rescue => e
-            # Because `connection_id` references a live connection
-            # present in the current stack, it is very unlikely that
-            # `_id2ref` will fail, but we add this safeguard just
-            # in case.
-            Datadog.logger.debug(
-              "connection_id #{connection_id} does not represent a valid object. " \
-                      "Cause: #{e.message} Source: #{Array(e.backtrace).first}"
-            )
-          end
-        else
-          # JRuby does not enable {ObjectSpace._id2ref} by default,
-          # as it has large performance impact:
-          # https://github.com/jruby/jruby/wiki/PerformanceTuning/cf155dd9#dont-enable-objectspace
-          #
-          # This fallback code does not support the makara gem,
-          # as its connections don't live in the ActiveRecord
-          # connection pool.
-          def self.connection_from_id(connection_id)
-            ::ActiveRecord::Base
-              .connection_handler
-              .connection_pool_list
-              .flat_map(&:connections)
-              .find { |c| c.object_id == connection_id }
-          end
-        end
-
-        # @return [Hash]
-        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 = db_config(connection_pool))
-        rescue StandardError
-          EMPTY_CONFIG
-        end
-
-        # @return [Hash]
-        def self.db_config(connection_pool)
-          if ::Rails::VERSION::MAJOR >= 6 && ::Rails::VERSION::MINOR >= 1
-            connection_pool.db_config.configuration_hash
-          else
-            connection_pool.spec.config
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,259 +0,0 @@
-# typed: false
-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 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 = 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.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.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 = Datadog::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
-      end
-    end
-  end
-end