ddtrace 0.46.0 → 0.51.0

data/lib/ddtrace/context.rb

@@ -189,6 +189,9 @@ module Datadog
         # Root span is finished at this point, we can configure it
         annotate_for_flush!(@current_root_span)
 
+        # Allow caller to modify trace before context is reset
+        yield(trace) if block_given?
+
         reset
         [trace, sampled]
       end
@@ -227,6 +230,20 @@ module Datadog
       attach_origin(span) if @origin
     end
 
+    def attach_sampling_priority(span)
+      span.set_metric(
+        Ext::DistributedTracing::SAMPLING_PRIORITY_KEY,
+        @sampling_priority
+      )
+    end
+
+    def attach_origin(span)
+      span.set_tag(
+        Ext::DistributedTracing::ORIGIN_KEY,
+        @origin
+      )
+    end
+
     # Return a string representation of the context.
     def to_s
       @mutex.synchronize do
@@ -282,20 +299,6 @@ module Datadog
       @finished_spans > 0 && @trace.length == @finished_spans
     end
 
-    def attach_sampling_priority(span)
-      span.set_metric(
-        Ext::DistributedTracing::SAMPLING_PRIORITY_KEY,
-        @sampling_priority
-      )
-    end
-
-    def attach_origin(span)
-      span.set_tag(
-        Ext::DistributedTracing::ORIGIN_KEY,
-        @origin
-      )
-    end
-
     # Return the start time of the root span, or nil if there are no spans or this is undefined.
     def start_time
       @mutex.synchronize do

data/lib/ddtrace/context_flush.rb

@@ -9,9 +9,15 @@ module Datadog
       #
       # @return [Array<Span>] trace to be flushed, or +nil+ if the trace is not finished
       def consume!(context)
-        trace, sampled = context.get
+        trace, sampled = get_trace(context)
         trace if sampled
       end
+
+      protected
+
+      def get_trace(context)
+        context.get
+      end
     end
 
     # Performs partial trace flushing to avoid large traces residing in memory for too long
@@ -34,7 +40,7 @@ module Datadog
       #
       # @return [Array<Span>] partial or complete trace to be flushed, or +nil+ if no spans are finished
       def consume!(context)
-        trace, sampled = context.get
+        trace, sampled = get_trace(context)
 
         return nil unless sampled
         return trace if trace && !trace.empty?
@@ -42,6 +48,12 @@ module Datadog
         partial_trace(context)
       end
 
+      protected
+
+      def get_trace(context)
+        context.get
+      end
+
       private
 
       def partial_trace(context)

data/lib/ddtrace/context_provider.rb

@@ -55,8 +55,6 @@ module Datadog
 
     # Return the thread-local context.
     def local(thread = Thread.current)
-      raise ArgumentError, '\'thread\' must be a Thread.' unless thread.is_a?(Thread)
-
       thread[@key] ||= Datadog::Context.new
     end
   end

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

@@ -8,8 +8,8 @@ module Datadog
       # Defines basic behaviors for an event.
       module Event
         def self.included(base)
-          base.send(:include, ActiveSupport::Notifications::Event)
-          base.send(:extend, ClassMethods)
+          base.include(ActiveSupport::Notifications::Event)
+          base.extend(ClassMethods)
         end
 
         # Class methods for events.
@@ -34,8 +34,8 @@ module Datadog
       # but to start a fresh tracing context.
       module RootContextEvent
         def self.included(base)
-          base.send(:include, ActiveSupport::Notifications::Event)
-          base.send(:extend, ClassMethods)
+          base.include(ActiveSupport::Notifications::Event)
+          base.extend(ClassMethods)
         end
 
         # Class methods for events.

data/lib/ddtrace/contrib/action_pack/action_controller/instrumentation.rb

@@ -61,7 +61,7 @@ module Datadog
                 # [christian] in some cases :status is not defined,
                 # rather than firing an error, simply acknowledge we don't know it.
                 status = payload.fetch(:status, '?').to_s
-                span.status = 1 if status.starts_with?('5')
+                span.status = 1 if status.start_with?('5')
               elsif Utils.exception_is_error?(exception)
                 span.set_error(exception)
               end

data/lib/ddtrace/contrib/action_pack/action_controller/patcher.rb

@@ -16,7 +16,7 @@ module Datadog
           end
 
           def patch
-            ::ActionController::Metal.send(:prepend, ActionController::Instrumentation::Metal)
+            ::ActionController::Metal.prepend(ActionController::Instrumentation::Metal)
           end
         end
       end

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

@@ -11,7 +11,7 @@ module Datadog
             # You can add custom errors via `config.action_dispatch.rescue_responses`
             status = ::ActionDispatch::ExceptionWrapper.status_code_for_exception(exception.class.name)
             # Only 5XX exceptions are actually errors (e.g. don't flag 404s)
-            status.to_s.starts_with?('5')
+            status.to_s.start_with?('5')
           else
             true
           end

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

@@ -6,8 +6,8 @@ module Datadog
       # Defines basic behavior for an ActionView event.
       module Event
         def self.included(base)
-          base.send(:include, ActiveSupport::Notifications::Event)
-          base.send(:extend, ClassMethods)
+          base.include(ActiveSupport::Notifications::Event)
+          base.extend(ClassMethods)
         end
 
         # Class methods for ActionView events.

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

@@ -31,12 +31,12 @@ module Datadog
             #  Rendering events are not nested in this version, creating
             #  render_partial spans outside of the parent render_template span.
             #  We fall back to manual patching instead.
-            ::ActionView::TemplateRenderer.send(:prepend, Instrumentation::TemplateRenderer::RailsLessThan4)
-            ::ActionView::PartialRenderer.send(:prepend, Instrumentation::PartialRenderer::RailsLessThan4)
+            ::ActionView::TemplateRenderer.prepend(Instrumentation::TemplateRenderer::RailsLessThan4)
+            ::ActionView::PartialRenderer.prepend(Instrumentation::PartialRenderer::RailsLessThan4)
           elsif defined?(::ActionView::Rendering) && defined?(::ActionView::Partials::PartialRenderer)
             # NOTE: Rails < 3.1 compatibility: different classes are used
-            ::ActionView::Rendering.send(:prepend, Instrumentation::TemplateRenderer::Rails30)
-            ::ActionView::Partials::PartialRenderer.send(:prepend, Instrumentation::PartialRenderer::RailsLessThan4)
+            ::ActionView::Rendering.prepend(Instrumentation::TemplateRenderer::Rails30)
+            ::ActionView::Partials::PartialRenderer.prepend(Instrumentation::PartialRenderer::RailsLessThan4)
           else
             Datadog.logger.debug('Expected Template/Partial classes not found; template rendering disabled')
           end

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

@@ -9,8 +9,8 @@ module Datadog
       # Defines basic behaviors for an ActiveModelSerializers event.
       module Event
         def self.included(base)
-          base.send(:include, ActiveSupport::Notifications::Event)
-          base.send(:extend, ClassMethods)
+          base.include(ActiveSupport::Notifications::Event)
+          base.extend(ClassMethods)
         end
 
         # Class methods for ActiveModelSerializers events.

data/lib/ddtrace/contrib/active_record/configuration/makara_resolver.rb

@@ -0,0 +1,30 @@
+module Datadog
+  module Contrib
+    module ActiveRecord
+      module Configuration
+        # The `makara` gem has the concept of **role**, which can be
+        # inferred from the configuration `name`, in the form of:
+        # `master/0`, `replica/0`, `replica/1`, etc.
+        # The first part of this string is the database role.
+        #
+        # This allows the matching of a connection based on its role,
+        # instead of connection-specific information.
+        module MakaraResolver
+          def normalize_for_config(active_record_config)
+            hash = super
+            hash[:makara_role] = active_record_config[:makara_role]
+            hash
+          end
+
+          def normalize_for_resolve(active_record_config)
+            hash = super
+
+            hash[:makara_role] = active_record_config[:name].split('/')[0].to_s if active_record_config[:name].is_a?(String)
+
+            hash
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ddtrace/contrib/active_record/configuration/resolver.rb

@@ -1,55 +1,132 @@
 require 'ddtrace/contrib/configuration/resolver'
 require 'ddtrace/vendor/active_record/connection_specification'
+require_relative 'makara_resolver'
 
 module Datadog
   module Contrib
     module ActiveRecord
       module Configuration
         # Converts Symbols, Strings, and Hashes to a normalized connection settings Hash.
+        #
+        # When matching using a Hash, these are the valid fields:
+        # ```
+        # {
+        #   adapter: ...,
+        #   host: ...,
+        #   port: ...,
+        #   database: ...,
+        #   username: ...,
+        #   role: ...,
+        # }
+        # ```
+        #
+        # Partial matching is supported: not including certain fields or setting them to `nil`
+        # will cause them to matching all values for that field. For example: `database: nil`
+        # will match any database, given the remaining fields match.
+        #
+        # Any fields not listed above are discarded.
+        #
+        # When more than one configuration could be matched, the last one to match is selected,
+        # based on addition order (`#add`).
         class Resolver < Contrib::Configuration::Resolver
-          def initialize(configurations = nil)
-            @configurations = configurations
+          prepend MakaraResolver
+
+          def initialize(active_record_configuration = nil)
+            super()
+
+            @active_record_configuration = active_record_configuration
           end
 
-          def resolve(key)
-            normalize(resolve_connection_key(key).symbolize_keys)
+          def active_record_configuration
+            @active_record_configuration || ::ActiveRecord::Base.configurations
           end
 
-          def resolve_connection_key(key)
-            result = connection_resolver.resolve(key)
+          def add(matcher, value)
+            parsed = parse_matcher(matcher)
 
-            if result.respond_to?(:configuration_hash) # Rails >= 6.1
-              result.configuration_hash
-            else # Rails < 6.1
-              result
+            # In case of error parsing, don't store `nil` key
+            # as it wouldn't be useful for matching configuration
+            # hashes in `#resolve`.
+            super(parsed, value) if parsed
+          end
+
+          def resolve(db_config)
+            active_record_config = resolve_connection_key(db_config).symbolize_keys
+
+            hash = normalize_for_resolve(active_record_config)
+
+            # Hashes in Ruby maintain insertion order
+            _, config = @configurations.reverse_each.find do |matcher, _|
+              matcher.none? do |key, value|
+                value != hash[key]
+              end
             end
+
+            config
+          rescue => e
+            Datadog.logger.error(
+              "Failed to resolve ActiveRecord configuration key #{db_config.inspect}. " \
+              "Cause: #{e.message} Source: #{e.backtrace.first}"
+            )
+
+            nil
           end
 
-          def configurations
-            @configurations || ::ActiveRecord::Base.configurations
+          protected
+
+          def parse_matcher(matcher)
+            resolved_pattern = resolve_connection_key(matcher).symbolize_keys
+            normalized = normalize_for_config(resolved_pattern)
+
+            # Remove empty fields to allow for partial matching
+            normalized.reject! { |_, v| v.nil? }
+
+            normalized
+          rescue => e
+            Datadog.logger.error(
+              "Failed to resolve ActiveRecord configuration key #{matcher.inspect}. " \
+              "Cause: #{e.message} Source: #{e.backtrace.first}"
+            )
           end
 
           def connection_resolver
-            @resolver ||= begin
-              if defined?(::ActiveRecord::Base.configurations.resolve)
-                ::ActiveRecord::DatabaseConfigurations.new(configurations)
-              elsif defined?(::ActiveRecord::ConnectionAdapters::ConnectionSpecification::Resolver)
-                ::ActiveRecord::ConnectionAdapters::ConnectionSpecification::Resolver.new(configurations)
-              else
-                ::Datadog::Vendor::ActiveRecord::ConnectionAdapters::ConnectionSpecification::Resolver.new(configurations)
-              end
+            @resolver ||= if defined?(::ActiveRecord::Base.configurations.resolve)
+                            ::ActiveRecord::DatabaseConfigurations.new(active_record_configuration)
+                          elsif defined?(::ActiveRecord::ConnectionAdapters::ConnectionSpecification::Resolver)
+                            ::ActiveRecord::ConnectionAdapters::ConnectionSpecification::Resolver.new(
+                              active_record_configuration
+                            )
+                          else
+                            ::Datadog::Vendor::ActiveRecord::ConnectionAdapters::ConnectionSpecification::Resolver.new(
+                              active_record_configuration
+                            )
+                          end
+          end
+
+          def resolve_connection_key(key)
+            result = connection_resolver.resolve(key)
+
+            if result.respond_to?(:configuration_hash) # Rails >= 6.1
+              result.configuration_hash
+            else # Rails < 6.1
+              result
             end
           end
 
-          def normalize(hash)
+          # Extract only fields we'd like to match
+          # from the ActiveRecord configuration.
+          def normalize_for_config(active_record_config)
             {
-              adapter: hash[:adapter],
-              host: hash[:host],
-              port: hash[:port],
-              database: hash[:database],
-              username: hash[:username]
+              adapter: active_record_config[:adapter],
+              host: active_record_config[:host],
+              port: active_record_config[:port],
+              database: active_record_config[:database],
+              username: active_record_config[:username]
             }
           end
+
+          # Both resolvers perform the same operations for this implementation, but can be specialized
+          alias_method :normalize_for_resolve, :normalize_for_config
         end
       end
     end

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

@@ -6,8 +6,8 @@ module Datadog
       # Defines basic behaviors for an ActiveRecord event.
       module Event
         def self.included(base)
-          base.send(:include, ActiveSupport::Notifications::Event)
-          base.send(:extend, ClassMethods)
+          base.include(ActiveSupport::Notifications::Event)
+          base.extend(ClassMethods)
         end
 
         # Class methods for ActiveRecord events.

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

@@ -1,4 +1,4 @@
-require 'ddtrace/ext/runtime'
+require 'datadog/core/environment/ext'
 
 module Datadog
   module Contrib
@@ -54,7 +54,7 @@ module Datadog
 
         # 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'
+        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)

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

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