ddtrace 0.13.0 → 0.47.0

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

@@ -17,7 +17,7 @@ module Datadog
           end
 
           def tracer
-            configuration[:tracer]
+            -> { configuration[:tracer] }
           end
 
           def configuration

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

@@ -1,3 +1,5 @@
+require 'ddtrace/contrib/analytics'
+require 'ddtrace/contrib/active_record/ext'
 require 'ddtrace/contrib/active_record/event'
 
 module Datadog
@@ -9,8 +11,6 @@ module Datadog
           include ActiveRecord::Event
 
           EVENT_NAME = 'instantiation.active_record'.freeze
-          SPAN_NAME = 'active_record.instantiation'.freeze
-          DEFAULT_SERVICE_NAME = 'active_record'.freeze
 
           module_function
 
@@ -24,7 +24,7 @@ module Datadog
           end
 
           def span_name
-            self::SPAN_NAME
+            Ext::SPAN_INSTANTIATION
           end
 
           def process(span, event, _id, payload)
@@ -34,15 +34,24 @@ module Datadog
                            elsif span.parent
                              span.parent.service
                            else
-                             self::DEFAULT_SERVICE_NAME
+                             Ext::SERVICE_NAME
                            end
 
             span.resource = payload.fetch(:class_name)
-            span.span_type = 'custom'
-            span.set_tag('active_record.instantiation.class_name', payload.fetch(:class_name))
-            span.set_tag('active_record.instantiation.record_count', payload.fetch(:record_count))
+            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::Tracer.log.debug(e.message)
+            Datadog.logger.debug(e.message)
           end
         end
       end

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

@@ -1,3 +1,7 @@
+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
@@ -9,7 +13,7 @@ module Datadog
           include ActiveRecord::Event
 
           EVENT_NAME = 'sql.active_record'.freeze
-          SPAN_NAME = 'active_record.sql'.freeze
+          PAYLOAD_CACHE = 'CACHE'.freeze
 
           module_function
 
@@ -18,28 +22,44 @@ module Datadog
           end
 
           def span_name
-            self::SPAN_NAME
+            Ext::SPAN_SQL
           end
 
           def process(span, event, _id, payload)
-            connection_config = Utils.connection_config(payload[:connection_id])
-            span.name = "#{connection_config[:adapter_name]}.query"
-            span.service = configuration[:service_name]
+            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] == 'CACHE')
+            cached = payload[:cached] || (payload[:name] == PAYLOAD_CACHE)
 
-            span.set_tag('active_record.db.vendor', connection_config[:adapter_name])
-            span.set_tag('active_record.db.name', connection_config[:database_name])
-            span.set_tag('active_record.db.cached', cached) if cached
-            span.set_tag('out.host', connection_config[:adapter_host])
-            span.set_tag('out.port', connection_config[:adapter_port])
+            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::Tracer.log.debug(e.message)
+            Datadog.logger.debug(e.message)
           end
         end
       end

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

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

@@ -0,0 +1,53 @@
+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,6 +1,4 @@
-require 'ddtrace/ext/sql'
-require 'ddtrace/ext/app_types'
-require 'ddtrace/contrib/active_record/utils'
+require 'ddtrace/contrib/patcher'
 require 'ddtrace/contrib/active_record/events'
 
 module Datadog
@@ -8,44 +6,16 @@ module Datadog
     module ActiveRecord
       # Patcher enables patching of 'active_record' module.
       module Patcher
-        include Base
-
-        register_as :active_record, auto_patch: false
-        option :service_name, depends_on: [:tracer] do |value|
-          (value || Utils.adapter_name).tap do |v|
-            get_option(:tracer).set_service_info(v, 'active_record', Ext::AppTypes::DB)
-          end
-        end
-        option :orm_service_name
-        option :tracer, default: Datadog.tracer do |value|
-          (value || Datadog.tracer).tap do |v|
-            # Make sure to update tracers of all subscriptions
-            Events.subscriptions.each do |subscription|
-              subscription.tracer = v
-            end
-          end
-        end
-
-        @patched = false
+        include Contrib::Patcher
 
         module_function
 
-        # patched? tells whether patch has been successfully applied
-        def patched?
-          @patched
+        def target_version
+          Integration.version
         end
 
         def patch
-          if !@patched && defined?(::ActiveRecord)
-            begin
-              Events.subscribe!
-              @patched = true
-            rescue StandardError => e
-              Datadog::Tracer.log.error("Unable to apply Active Record integration: #{e}")
-            end
-          end
-
-          @patched
+          Events.subscribe!
         end
       end
     end

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

@@ -1,57 +1,102 @@
+require 'ddtrace/ext/runtime'
+
 module Datadog
   module Contrib
     module ActiveRecord
       # Common utilities for Rails
       module Utils
+        EMPTY_CONFIG = {}.freeze
+
         def self.adapter_name
-          connection_config[:adapter_name]
+          Datadog::Utils::Database.normalize_vendor(connection_config[:adapter])
         end
 
         def self.database_name
-          connection_config[:database_name]
+          connection_config[:database]
         end
 
         def self.adapter_host
-          connection_config[:adapter_host]
+          connection_config[:host]
         end
 
         def self.adapter_port
-          connection_config[:adapter_port]
-        end
-
-        def self.connection_config(object_id = nil)
-          config = object_id.nil? ? default_connection_config : connection_config_by_id(object_id)
-          {
-            adapter_name: Datadog::Utils::Database.normalize_vendor(config[:adapter]),
-            adapter_host: config[:host],
-            adapter_port: config[:port],
-            database_name: config[:database]
-          }
+          connection_config[:port]
         end
 
-        # Attempt to retrieve the connection from an object ID.
-        def self.connection_by_id(object_id)
-          return nil if object_id.nil?
-          ObjectSpace._id2ref(object_id)
-        rescue StandardError
-          nil
-        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?
 
-        # Attempt to retrieve the connection config from an object ID.
-        # Typical of ActiveSupport::Notifications `sql.active_record`
-        def self.connection_config_by_id(object_id)
-          connection = connection_by_id(object_id)
-          return {} if connection.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 connection.instance_variable_defined?(:@config)
-            connection.instance_variable_get(:@config)
+          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::Ext::Runtime::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: #{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
@@ -59,9 +104,18 @@ module Datadog
                                     end
 
           connection_pool = ::ActiveRecord::Base.connection_handler.retrieve_connection_pool(current_connection_name)
-          connection_pool.nil? ? {} : (@default_connection_config = connection_pool.spec.config)
+          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

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

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