ddtrace 0.42.0 → 0.47.0

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

@@ -5,6 +5,7 @@ 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
@@ -29,6 +30,12 @@ module Datadog
           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

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

@@ -1,3 +1,5 @@
+require 'ddtrace/ext/runtime'
+
 module Datadog
   module Contrib
     module ActiveRecord
@@ -21,44 +23,80 @@ module Datadog
           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`.
+        # Returns the connection configuration hash from the
+        # current connection
         #
-        # See this PR for more details: https://github.com/rails/rails/pull/34602
+        # 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
-                 # 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 }
+                   # 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.instance_variable_defined?(:@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
@@ -66,10 +104,19 @@ module Datadog
                                     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)
+          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

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

@@ -18,9 +18,13 @@ module Datadog
             # 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
+            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)
 
@@ -59,6 +63,32 @@ module Datadog
             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)
@@ -82,6 +112,29 @@ module Datadog
             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)
@@ -105,6 +158,31 @@ module Datadog
             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)
@@ -128,6 +206,29 @@ module Datadog
             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)

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

@@ -17,8 +17,11 @@ module Datadog
 
           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
 
@@ -30,14 +33,32 @@ module Datadog
             cache_store_class(:read).send(:prepend, Cache::Instrumentation::Read)
           end
 
+          def patch_cache_store_read_multi
+            cache_store_class(:read_multi).send(:prepend, Cache::Instrumentation::ReadMulti)
+          end
+
           def patch_cache_store_fetch
             cache_store_class(:fetch).send(: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.send(:prepend, Cache::Instrumentation::FetchMulti)
+          end
+
           def patch_cache_store_write
             cache_store_class(:write).send(: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.send(:prepend, Cache::Instrumentation::WriteMulti)
+          end
+
           def patch_cache_store_delete
             cache_store_class(:delete).send(:prepend, Cache::Instrumentation::Delete)
           end

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

@@ -12,12 +12,15 @@ module Datadog
         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

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

@@ -1,8 +1,8 @@
 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
@@ -27,6 +27,12 @@ module Datadog
           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

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

@@ -20,7 +20,8 @@ module Datadog
           module ClassMethods
             DEFAULT_TRACER = -> { Datadog.tracer }
 
-            def subscribe!
+            # Publicly exposes protected method `subscribe!`
+            def subscribe! # rubocop:disable Lint/UselessMethodDefinition
               super
             end
 
@@ -56,6 +57,16 @@ module Datadog
             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

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

@@ -36,6 +36,7 @@ module Datadog
             # Should be triggered by the inheriting class.
             def subscribe!
               return subscribed? if subscribed? || on_subscribe_block.nil?
+
               on_subscribe_block.call
               @subscribed = true
             end

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

@@ -9,7 +9,8 @@ module Datadog
             :options
 
           def initialize(tracer, span_name, options, &block)
-            raise ArgumentError, 'Must be given a block!' unless block_given?
+            raise ArgumentError, 'Must be given a block!' unless block
+
             @tracer = tracer
             @span_name = span_name
             @options = options
@@ -38,21 +39,23 @@ module Datadog
           end
 
           def before_trace(&block)
-            callbacks.add(:before_trace, &block) if block_given?
+            callbacks.add(:before_trace, &block) if block
           end
 
           def after_trace(&block)
-            callbacks.add(:after_trace, &block) if block_given?
+            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
@@ -60,7 +63,8 @@ module Datadog
 
           def unsubscribe_all
             return false if subscribers.empty?
-            subscribers.keys.each { |pattern| unsubscribe(pattern) }
+
+            subscribers.each_key { |pattern| unsubscribe(pattern) }
             true
           end
 
@@ -131,7 +135,7 @@ module Datadog
             end
 
             def add(key, &block)
-              blocks_for(key) << block if block_given?
+              blocks_for(key) << block if block
             end
 
             def run(event, key, *args)