ddtrace 0.33.1 → 0.34.0

data/lib/ddtrace/contrib/action_cable/events/perform_action.rb

@@ -42,6 +42,9 @@ module Datadog
               Contrib::Analytics.set_sample_rate(span, configuration[:analytics_sample_rate])
             end
 
+            # Measure service stats
+            Contrib::Analytics.set_measured(span)
+
             span.set_tag(Ext::TAG_CHANNEL_CLASS, channel_class)
             span.set_tag(Ext::TAG_ACTION, action)
           end

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

@@ -3,6 +3,7 @@ require 'ddtrace/ext/http'
 require 'ddtrace/contrib/action_pack/ext'
 require 'ddtrace/contrib/action_pack/utils'
 require 'ddtrace/contrib/rack/middlewares'
+require 'ddtrace/contrib/analytics'
 
 module Datadog
   module Contrib
@@ -48,6 +49,9 @@ module Datadog
               # Set analytics sample rate
               Utils.set_analytics_sample_rate(span)
 
+              # Measure service stats
+              Contrib::Analytics.set_measured(span)
+
               # Associate with runtime metrics
               Datadog.runtime_metrics.associate_with_span(span)
 

data/lib/ddtrace/contrib/action_view/events/render_partial.rb

@@ -31,6 +31,9 @@ module Datadog
               span.set_tag(Ext::TAG_TEMPLATE_NAME, template_name)
             end
 
+            # Measure service stats
+            Contrib::Analytics.set_measured(span)
+
             record_exception(span, payload)
           rescue StandardError => e
             Datadog::Logger.log.debug(e.message)

data/lib/ddtrace/contrib/action_view/events/render_template.rb

@@ -34,6 +34,9 @@ module Datadog
             layout = payload[:layout]
             span.set_tag(Ext::TAG_LAYOUT, layout) if layout
 
+            # Measure service stats
+            Contrib::Analytics.set_measured(span)
+
             record_exception(span, payload)
           rescue StandardError => e
             Datadog::Logger.log.debug(e.message)

data/lib/ddtrace/contrib/action_view/instrumentation/partial_renderer.rb

@@ -37,6 +37,9 @@ module Datadog
                 Ext::TAG_TEMPLATE_NAME,
                 template_name
               )
+
+              # Measure service stats
+              Contrib::Analytics.set_measured(active_datadog_span)
             end
           end
 

data/lib/ddtrace/contrib/action_view/instrumentation/template_renderer.rb

@@ -50,6 +50,9 @@ module Datadog
                         layout_name
                       )
                     end
+
+                    # Measure service stats
+                    Contrib::Analytics.set_measured(active_datadog_span)
                   rescue StandardError => e
                     Datadog::Logger.log.debug(e.message)
                   end
@@ -127,6 +130,9 @@ module Datadog
                   layout
                 )
               end
+
+              # Measure service stats
+              Contrib::Analytics.set_measured(active_datadog_span)
             end
 
             private

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

@@ -36,6 +36,9 @@ module Datadog
               Contrib::Analytics.set_sample_rate(span, configuration[:analytics_sample_rate])
             end
 
+            # Measure service stats
+            Contrib::Analytics.set_measured(span)
+
             # Set the resource name and serializer name
             res = resource(payload[:serializer])
             span.resource = res

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

@@ -45,6 +45,9 @@ module Datadog
               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

data/lib/ddtrace/contrib/analytics.rb

@@ -15,6 +15,10 @@ module Datadog
       def set_sample_rate(span, sample_rate)
         Datadog::Analytics.set_sample_rate(span, sample_rate)
       end
+
+      def set_measured(span, value = true)
+        Datadog::Analytics.set_measured(span, value)
+      end
     end
   end
 end

data/lib/ddtrace/contrib/configuration/resolvers/pattern_resolver.rb

@@ -0,0 +1,39 @@
+require 'ddtrace/contrib/configuration/resolver'
+
+module Datadog
+  module Contrib
+    module Configuration
+      # Resolves a value to a configuration key
+      module Resolvers
+        # Matches strings against Regexps.
+        class PatternResolver < Datadog::Contrib::Configuration::Resolver
+          def resolve(name)
+            # Try to find a matching pattern
+            matching_pattern = patterns.find do |pattern|
+              # Rubocop incorrectly thinks assignment is done here...
+              # rubocop:disable Style/ConditionalAssignment
+              if pattern.is_a?(Proc)
+                pattern === name
+              else
+                pattern === name.to_s # Co-erce to string
+              end
+            end
+
+            # Return match or default
+            matching_pattern || :default
+          end
+
+          def add(pattern)
+            patterns << (pattern.is_a?(Regexp) || pattern.is_a?(Proc) ? pattern : pattern.to_s)
+          end
+
+          private
+
+          def patterns
+            @patterns ||= Set.new
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ddtrace/contrib/delayed_job/plugin.rb

@@ -23,6 +23,10 @@ module Datadog
             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_ID, job.id)
             span.set_tag(Ext::TAG_QUEUE, job.queue) if job.queue
             span.set_tag(Ext::TAG_PRIORITY, job.priority)

data/lib/ddtrace/contrib/ethon/configuration/settings.rb

@@ -19,6 +19,7 @@ module Datadog
 
           option :distributed_tracing, default: true
           option :service_name, default: Ext::SERVICE_NAME
+          option :split_by_domain, default: false
         end
       end
     end

data/lib/ddtrace/contrib/ethon/easy_patch.rb

@@ -2,6 +2,7 @@ require 'ddtrace/ext/net'
 require 'ddtrace/ext/distributed'
 require 'ddtrace/propagation/http_propagator'
 require 'ddtrace/contrib/ethon/ext'
+require 'ddtrace/contrib/http_annotation_helper'
 
 module Datadog
   module Contrib
@@ -14,7 +15,10 @@ module Datadog
 
         # InstanceMethods - implementing instrumentation
         module InstanceMethods
+          include Datadog::Contrib::HttpAnnotationHelper
+
           def http_request(url, action_name, options = {})
+            load_datadog_configuration_for(url)
             return super unless tracer_enabled?
 
             # It's tricky to get HTTP method from libcurl
@@ -23,14 +27,13 @@ module Datadog
           end
 
           def headers=(headers)
-            return super unless tracer_enabled?
-
             # Store headers to call this method again when span is ready
             @datadog_original_headers = headers
             super
           end
 
           def perform
+            load_datadog_configuration_for(url)
             return super unless tracer_enabled?
             datadog_before_request
             super
@@ -61,17 +64,17 @@ module Datadog
           def reset
             super
           ensure
-            if tracer_enabled?
-              @datadog_span = nil
-              @datadog_method = nil
-              @datadog_original_headers = nil
-            end
+            @datadog_span = nil
+            @datadog_method = nil
+            @datadog_original_headers = nil
+            @datadog_configuration = nil
           end
 
           def datadog_before_request(parent_span: nil)
+            load_datadog_configuration_for(url)
             @datadog_span = datadog_configuration[:tracer].trace(
               Ext::SPAN_REQUEST,
-              service: datadog_configuration[:service_name],
+              service: uri ? service_name(uri.host, datadog_configuration) : datadog_configuration[:service_name],
               span_type: Datadog::Ext::HTTP::TYPE_OUTBOUND
             )
             @datadog_span.parent = parent_span unless parent_span.nil?
@@ -91,9 +94,10 @@ module Datadog
 
           private
 
+          attr_reader :datadog_configuration
+
           def datadog_tag_request
             span = @datadog_span
-            uri = URI.parse(url)
             method = 'N/A'
             if instance_variable_defined?(:@datadog_method) && !@datadog_method.nil?
               method = @datadog_method.to_s
@@ -103,12 +107,11 @@ module Datadog
             # Set analytics sample rate
             Contrib::Analytics.set_sample_rate(span, analytics_sample_rate) if analytics_enabled?
 
+            return unless uri
             span.set_tag(Datadog::Ext::HTTP::URL, uri.path)
             span.set_tag(Datadog::Ext::HTTP::METHOD, method)
             span.set_tag(Datadog::Ext::NET::TARGET_HOST, uri.host)
             span.set_tag(Datadog::Ext::NET::TARGET_PORT, uri.port)
-          rescue URI::InvalidURIError
-            return
           end
 
           def set_span_error_message(message)
@@ -117,8 +120,14 @@ module Datadog
             @datadog_span.set_tag(Datadog::Ext::Errors::MSG, message)
           end
 
-          def datadog_configuration
-            Datadog.configuration[:ethon]
+          def uri
+            URI.parse(url)
+          # rubocop:disable Lint/HandleExceptions
+          rescue URI::InvalidURIError
+          end
+
+          def load_datadog_configuration_for(host = :default)
+            @datadog_configuration = Datadog.configuration[:ethon, host]
           end
 
           def tracer_enabled?

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

@@ -1,5 +1,6 @@
 require 'ddtrace/contrib/integration'
 require 'ddtrace/contrib/ethon/configuration/settings'
+require 'ddtrace/contrib/configuration/resolvers/pattern_resolver'
 require 'ddtrace/contrib/ethon/patcher'
 
 module Datadog
@@ -32,6 +33,10 @@ module Datadog
         def patcher
           Patcher
         end
+
+        def resolver
+          @resolver ||= Contrib::Configuration::Resolvers::PatternResolver.new
+        end
       end
     end
   end

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

@@ -1,5 +1,6 @@
 require 'ddtrace/contrib/integration'
 require 'ddtrace/contrib/excon/configuration/settings'
+require 'ddtrace/contrib/configuration/resolvers/pattern_resolver'
 require 'ddtrace/contrib/excon/patcher'
 
 module Datadog
@@ -32,6 +33,10 @@ module Datadog
         def patcher
           Patcher
         end
+
+        def resolver
+          @resolver ||= Contrib::Configuration::Resolvers::PatternResolver.new
+        end
       end
     end
   end

data/lib/ddtrace/contrib/excon/middleware.rb

@@ -5,24 +5,28 @@ require 'ddtrace/ext/distributed'
 require 'ddtrace/propagation/http_propagator'
 require 'ddtrace/contrib/analytics'
 require 'ddtrace/contrib/excon/ext'
+require 'ddtrace/contrib/http_annotation_helper'
 
 module Datadog
   module Contrib
     module Excon
       # Middleware implements an excon-middleware for ddtrace instrumentation
       class Middleware < ::Excon::Middleware::Base
+        include Datadog::Contrib::HttpAnnotationHelper
+
         DEFAULT_ERROR_HANDLER = lambda do |response|
           Datadog::Ext::HTTP::ERROR_RANGE.cover?(response[:status])
         end
 
         def initialize(stack, options = {})
           super(stack)
-          @options = Datadog.configuration[:excon].options_hash.merge(options)
+          @default_options = datadog_configuration.options_hash.merge(options)
         end
 
         def request_call(datum)
           begin
             unless datum.key?(:datadog_span)
+              @options = build_request_options!(datum)
               tracer.trace(Ext::SPAN_REQUEST).tap do |span|
                 datum[:datadog_span] = span
                 annotate!(span, datum)
@@ -99,13 +103,9 @@ module Datadog
           @options[:error_handler] || DEFAULT_ERROR_HANDLER
         end
 
-        def split_by_domain?
-          @options[:split_by_domain] == true
-        end
-
         def annotate!(span, datum)
           span.resource = datum[:method].to_s.upcase
-          span.service = service_name(datum)
+          span.service = service_name(datum[:host], @options)
           span.span_type = Datadog::Ext::HTTP::TYPE_OUTBOUND
 
           # Set analytics sample rate
@@ -144,9 +144,12 @@ module Datadog
           Datadog::HTTPPropagator.inject!(span.context, datum[:headers])
         end
 
-        def service_name(datum)
-          # TODO: Change this to implement more sensible multiplexing
-          split_by_domain? ? datum[:host] : @options[:service_name]
+        def build_request_options!(datum)
+          datadog_configuration(datum[:host]).options_hash.merge(@default_options)
+        end
+
+        def datadog_configuration(host = :default)
+          Datadog.configuration[:excon, host]
         end
       end
     end

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

@@ -1,4 +1,5 @@
 require 'ddtrace/contrib/integration'
+require 'ddtrace/contrib/configuration/resolvers/pattern_resolver'
 require 'ddtrace/contrib/faraday/configuration/settings'
 require 'ddtrace/contrib/faraday/patcher'
 
@@ -32,6 +33,10 @@ module Datadog
         def patcher
           Patcher
         end
+
+        def resolver
+          @resolver ||= Contrib::Configuration::Resolvers::PatternResolver.new
+        end
       end
     end
   end

data/lib/ddtrace/contrib/faraday/middleware.rb

@@ -4,6 +4,7 @@ require 'ddtrace/ext/net'
 require 'ddtrace/propagation/http_propagator'
 require 'ddtrace/contrib/analytics'
 require 'ddtrace/contrib/faraday/ext'
+require 'ddtrace/contrib/http_annotation_helper'
 
 module Datadog
   module Contrib
@@ -11,18 +12,22 @@ module Datadog
       # Middleware implements a faraday-middleware for ddtrace instrumentation
       class Middleware < ::Faraday::Middleware
         include Datadog::Ext::DistributedTracing
+        include Datadog::Contrib::HttpAnnotationHelper
 
         def initialize(app, options = {})
           super(app)
           @options = datadog_configuration.options_hash.merge(options)
-          setup_service!
         end
 
         def call(env)
-          tracer.trace(Ext::SPAN_REQUEST) do |span|
-            annotate!(span, env)
-            propagate!(span, env) if options[:distributed_tracing] && tracer.enabled
-            app.call(env).on_complete { |resp| handle_response(span, resp) }
+          # Resolve configuration settings to use for this request.
+          # Do this once to reduce expensive regex calls.
+          request_options = build_request_options!(env)
+
+          request_options[:tracer].trace(Ext::SPAN_REQUEST) do |span|
+            annotate!(span, env, request_options)
+            propagate!(span, env) if request_options[:distributed_tracing] && request_options[:tracer].enabled
+            app.call(env).on_complete { |resp| handle_response(span, resp, request_options) }
           end
         end
 
@@ -30,14 +35,15 @@ module Datadog
 
         attr_reader :app, :options
 
-        def annotate!(span, env)
+        def annotate!(span, env, options)
           span.resource = resource_name(env)
-          span.service = service_name(env)
+          service_name(env[:url].host, options)
+          span.service = options[:split_by_domain] ? env[:url].host : options[:service_name]
           span.span_type = Datadog::Ext::HTTP::TYPE_OUTBOUND
 
           # Set analytics sample rate
-          if analytics_enabled?
-            Contrib::Analytics.set_sample_rate(span, analytics_sample_rate)
+          if Contrib::Analytics.enabled?(options[:analytics_enabled])
+            Contrib::Analytics.set_sample_rate(span, options[:analytics_sample_rate])
           end
 
           span.set_tag(Datadog::Ext::HTTP::URL, env[:url].path)
@@ -46,7 +52,7 @@ module Datadog
           span.set_tag(Datadog::Ext::NET::TARGET_PORT, env[:url].port)
         end
 
-        def handle_response(span, env)
+        def handle_response(span, env, options)
           if options.fetch(:error_handler).call(env)
             span.set_error(["Error #{env[:status]}", env[:body]])
           end
@@ -58,34 +64,16 @@ module Datadog
           Datadog::HTTPPropagator.inject!(span.context, env[:request_headers])
         end
 
-        def datadog_configuration
-          Datadog.configuration[:faraday]
-        end
-
-        def tracer
-          options[:tracer]
-        end
-
-        def service_name(env)
-          return env[:url].host if options[:split_by_domain]
-
-          options[:service_name]
-        end
-
         def resource_name(env)
           env[:method].to_s.upcase
         end
 
-        def analytics_enabled?
-          Contrib::Analytics.enabled?(options[:analytics_enabled])
-        end
-
-        def analytics_sample_rate
-          options[:analytics_sample_rate]
+        def build_request_options!(env)
+          datadog_configuration(env[:url].host).options_hash.merge(options)
         end
 
-        def setup_service!
-          return if options[:service_name] == datadog_configuration[:service_name]
+        def datadog_configuration(host = :default)
+          Datadog.configuration[:faraday, host]
         end
       end
     end