ddtrace 0.39.0 → 0.44.0

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

@@ -76,8 +76,8 @@ module Datadog
 
             # Start a trace
             tracer.trace(@span_name, @options.dup).tap do |span|
-              # Assign start time if provided
-              span.start_time = start unless start.nil?
+              # Start span if time is provided
+              span.start(start) unless start.nil?
               payload[:datadog_span] = span
             end
           end

data/lib/ddtrace/contrib/aws/instrumentation.rb

@@ -1,5 +1,7 @@
 require 'ddtrace/contrib/analytics'
 require 'ddtrace/contrib/aws/ext'
+require 'ddtrace/ext/http'
+require 'ddtrace/ext/integration'
 
 module Datadog
   module Contrib
@@ -25,10 +27,13 @@ module Datadog
 
         def annotate!(span, context)
           span.service = configuration[:service_name]
-          span.span_type = Datadog::Ext::AppTypes::WEB
+          span.span_type = Datadog::Ext::HTTP::TYPE_OUTBOUND
           span.name = Ext::SPAN_COMMAND
           span.resource = context.safely(:resource)
 
+          # 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])

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

@@ -1,5 +1,4 @@
 require 'ddtrace/contrib/patcher'
-require 'ddtrace/ext/app_types'
 require 'ddtrace/contrib/aws/ext'
 
 module Datadog

data/lib/ddtrace/contrib/aws/services.rb

@@ -104,6 +104,7 @@ module Datadog
         States
         StorageGateway
         Support
+        Textract
         WAF
         WAFRegional
         WorkDocs

data/lib/ddtrace/contrib/configurable.rb

@@ -28,6 +28,8 @@ module Datadog
 
         # If the key has matching configuration explicitly defined for it,
         # then return true. Otherwise return false.
+        # Note: a resolver's resolve method should not return a fallback value
+        # See: https://github.com/DataDog/dd-trace-rb/issues/1204
         def configuration_for?(key)
           key = resolver.resolve(key) unless key == :default
           configurations.key?(key)

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

@@ -8,19 +8,20 @@ module Datadog
         # Matches strings against Regexps.
         class PatternResolver < Datadog::Contrib::Configuration::Resolver
           def resolve(name)
+            return if patterns.empty?
+
             # 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
+                (pattern === name)
               else
-                pattern === name.to_s # Co-erce to string
+                (pattern === name.to_s) ||
+                  (pattern == name) # Only required during configuration time.
               end
             end
 
             # Return match or default
-            matching_pattern || :default
+            matching_pattern
           end
 
           def add(pattern)

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

@@ -0,0 +1,38 @@
+require 'ddtrace/contrib/configuration/settings'
+require 'ddtrace/contrib/cucumber/ext'
+
+module Datadog
+  module Contrib
+    module Cucumber
+      module Configuration
+        # Custom settings for the Cucumber integration
+        class Settings < Contrib::Configuration::Settings
+          option :enabled do |o|
+            o.default { env_to_bool(Ext::ENV_ENABLED, true) }
+            o.lazy
+          end
+
+          option :analytics_enabled do |o|
+            o.default { env_to_bool(Ext::ENV_ANALYTICS_ENABLED, true) }
+            o.lazy
+          end
+
+          option :analytics_sample_rate do |o|
+            o.default { env_to_float(Ext::ENV_ANALYTICS_SAMPLE_RATE, 1.0) }
+            o.lazy
+          end
+
+          option :service_name do |o|
+            o.default { Datadog.configuration.service || Ext::SERVICE_NAME }
+            o.lazy
+          end
+
+          option :operation_name do |o|
+            o.default { ENV.key?(Ext::ENV_OPERATION_NAME) ? ENV[Ext::ENV_OPERATION_NAME] : Ext::OPERATION_NAME }
+            o.lazy
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+module Datadog
+  module Contrib
+    module Cucumber
+      # Cucumber integration constants
+      module Ext
+        APP = 'cucumber'.freeze
+        ENV_ANALYTICS_ENABLED = 'DD_TRACE_CUCUMBER_ANALYTICS_ENABLED'.freeze
+        ENV_ANALYTICS_SAMPLE_RATE = 'DD_TRACE_CUCUMBER_ANALYTICS_SAMPLE_RATE'.freeze
+        ENV_ENABLED = 'DD_TRACE_CUCUMBER_ENABLED'.freeze
+        ENV_OPERATION_NAME = 'DD_TRACE_CUCUMBER_OPERATION_NAME'.freeze
+        FRAMEWORK = 'cucumber'.freeze
+        OPERATION_NAME = 'cucumber.test'.freeze
+        SERVICE_NAME = 'cucumber'.freeze
+        STEP_SPAN_TYPE = 'step'.freeze
+        TEST_TYPE = 'test'.freeze
+      end
+    end
+  end
+end

data/lib/ddtrace/contrib/cucumber/formatter.rb

@@ -0,0 +1,104 @@
+require 'ddtrace/ext/app_types'
+require 'ddtrace/ext/ci'
+require 'ddtrace/ext/test'
+require 'ddtrace/contrib/analytics'
+require 'ddtrace/contrib/cucumber/ext'
+
+module Datadog
+  module Contrib
+    module Cucumber
+      # Defines collection of instrumented Cucumber events
+      class Formatter
+        attr_reader :config
+        private :config
+
+        attr_reader :current_feature_span, :current_step_span
+        private :current_feature_span, :current_step_span
+
+        def initialize(config)
+          @config = config
+
+          bind_events(config)
+        end
+
+        def bind_events(config)
+          config.on_event :test_case_started, &method(:on_test_case_started)
+          config.on_event :test_case_finished, &method(:on_test_case_finished)
+          config.on_event :test_step_started, &method(:on_test_step_started)
+          config.on_event :test_step_finished, &method(:on_test_step_finished)
+        end
+
+        def on_test_case_started(event)
+          trace_options = {
+            app: Ext::APP,
+            resource: event.test_case.name,
+            service: configuration[:service_name],
+            span_type: Datadog::Ext::AppTypes::TEST,
+            tags: tags.merge(Datadog.configuration.tags)
+          }
+          @current_feature_span = tracer.trace(configuration[:operation_name], trace_options)
+          @current_feature_span.set_tag(Datadog::Ext::Test::TAG_FRAMEWORK, Ext::FRAMEWORK)
+          @current_feature_span.set_tag(Datadog::Ext::Test::TAG_NAME, event.test_case.name)
+          @current_feature_span.set_tag(Datadog::Ext::Test::TAG_SUITE, event.test_case.location.file)
+          @current_feature_span.set_tag(Datadog::Ext::Test::TAG_TYPE, Ext::TEST_TYPE)
+          @current_feature_span.set_tag(Datadog::Ext::Test::TAG_SPAN_KIND, Datadog::Ext::AppTypes::TEST)
+
+          # Set analytics sample rate
+          if Datadog::Contrib::Analytics.enabled?(configuration[:analytics_enabled])
+            Datadog::Contrib::Analytics.set_sample_rate(@current_feature_span, configuration[:analytics_sample_rate])
+          end
+
+          # Measure service stats
+          Contrib::Analytics.set_measured(@current_feature_span)
+        end
+
+        def on_test_case_finished(event)
+          return if @current_feature_span.nil?
+          @current_feature_span.status = 1 if event.result.failed?
+          @current_feature_span.set_tag(Datadog::Ext::Test::TAG_STATUS, status_from_result(event.result))
+          @current_feature_span.finish
+        end
+
+        def on_test_step_started(event)
+          trace_options = {
+            resource: event.test_step.to_s,
+            span_type: Ext::STEP_SPAN_TYPE
+          }
+          @current_step_span = tracer.trace(Ext::STEP_SPAN_TYPE, trace_options)
+        end
+
+        def on_test_step_finished(event)
+          return if @current_step_span.nil?
+          unless event.result.passed?
+            @current_step_span.set_error event.result.exception
+          end
+          @current_step_span.set_tag(Datadog::Ext::Test::TAG_STATUS, status_from_result(event.result))
+          @current_step_span.finish
+        end
+
+        private
+
+        def status_from_result(result)
+          if result.skipped?
+            return Datadog::Ext::Test::Status::SKIP
+          elsif result.ok?
+            return Datadog::Ext::Test::Status::PASS
+          end
+          Datadog::Ext::Test::Status::FAIL
+        end
+
+        def configuration
+          Datadog.configuration[:cucumber]
+        end
+
+        def tracer
+          configuration[:tracer]
+        end
+
+        def tags
+          @tags ||= Datadog::Ext::CI.tags(ENV)
+        end
+      end
+    end
+  end
+end

data/lib/ddtrace/contrib/cucumber/instrumentation.rb

@@ -0,0 +1,24 @@
+require 'ddtrace/contrib/cucumber/formatter'
+
+module Datadog
+  module Contrib
+    module Cucumber
+      # Instrumentation for Cucumber
+      module Instrumentation
+        def self.included(base)
+          base.send(:prepend, InstanceMethods)
+        end
+
+        # Instance methods for configuration
+        module InstanceMethods
+          attr_reader :datadog_formatter
+
+          def formatters
+            @datadog_formatter ||= Datadog::Contrib::Cucumber::Formatter.new(@configuration)
+            [@datadog_formatter] + super
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,40 @@
+require 'ddtrace/contrib/integration'
+require 'ddtrace/contrib/cucumber/configuration/settings'
+require 'ddtrace/contrib/cucumber/patcher'
+require 'ddtrace/contrib/integration'
+
+module Datadog
+  module Contrib
+    module Cucumber
+      # Description of Cucumber integration
+      class Integration
+        include Contrib::Integration
+
+        MINIMUM_VERSION = Gem::Version.new('3.0.0')
+
+        register_as :cucumber, auto_patch: true
+
+        def self.version
+          Gem.loaded_specs['cucumber'] \
+            && Gem.loaded_specs['cucumber'].version
+        end
+
+        def self.loaded?
+          !defined?(::Cucumber).nil? && !defined?(::Cucumber::Runtime).nil?
+        end
+
+        def self.compatible?
+          super && version >= MINIMUM_VERSION
+        end
+
+        def default_configuration
+          Configuration::Settings.new
+        end
+
+        def patcher
+          Patcher
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+require 'ddtrace/contrib/patcher'
+require 'ddtrace/contrib/cucumber/instrumentation'
+
+module Datadog
+  module Contrib
+    module Cucumber
+      # Patcher enables patching of 'cucumber' module.
+      module Patcher
+        include Contrib::Patcher
+
+        module_function
+
+        def target_version
+          Integration.version
+        end
+
+        def patch
+          ::Cucumber::Runtime.send(:include, Instrumentation)
+        end
+      end
+    end
+  end
+end

data/lib/ddtrace/contrib/dalli/instrumentation.rb

@@ -1,3 +1,4 @@
+require 'ddtrace/ext/integration'
 require 'ddtrace/ext/net'
 require 'ddtrace/contrib/analytics'
 require 'ddtrace/contrib/dalli/ext'
@@ -20,6 +21,9 @@ module Datadog
               span.service = datadog_configuration[:service_name]
               span.span_type = Datadog::Contrib::Dalli::Ext::SPAN_TYPE_COMMAND
 
+              # 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?(datadog_configuration[:analytics_enabled])
                 Contrib::Analytics.set_sample_rate(span, datadog_configuration[:analytics_sample_rate])

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

@@ -23,6 +23,8 @@ module Datadog
           end
 
           option :service_name, default: Ext::SERVICE_NAME
+          option :client_service_name, default: Ext::CLIENT_SERVICE_NAME
+          option :error_handler, default: Datadog::Tracer::DEFAULT_ON_ERROR
         end
       end
     end

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

@@ -10,7 +10,9 @@ module Datadog
         ENV_ANALYTICS_SAMPLE_RATE = 'DD_TRACE_DELAYED_JOB_ANALYTICS_SAMPLE_RATE'.freeze
         ENV_ANALYTICS_SAMPLE_RATE_OLD = 'DD_DELAYED_JOB_ANALYTICS_SAMPLE_RATE'.freeze
         SERVICE_NAME = 'delayed_job'.freeze
+        CLIENT_SERVICE_NAME = 'delayed_job-client'.freeze
         SPAN_JOB = 'delayed_job'.freeze
+        SPAN_ENQUEUE = 'delayed_job.enqueue'.freeze
         TAG_ATTEMPTS = 'delayed_job.attempts'.freeze
         TAG_ID = 'delayed_job.id'.freeze
         TAG_PRIORITY = 'delayed_job.priority'.freeze

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

@@ -7,22 +7,13 @@ module Datadog
     module DelayedJob
       # DelayedJob plugin that instruments invoke_job hook
       class Plugin < Delayed::Plugin
-        def self.instrument(job, &block)
+        def self.instrument_invoke(job, &block)
           return block.call(job) unless tracer && tracer.enabled
 
-          # When DelayedJob is used through ActiveJob, we need to parse the payload differentely
-          # to get the actual job name
-          job_name = if job.payload_object.respond_to?(:job_data)
-                       job.payload_object.job_data['job_class']
-                     else
-                       job.name
-                     end
-
-          tracer.trace(Ext::SPAN_JOB, service: configuration[:service_name], resource: job_name) do |span|
-            # Set analytics sample rate
-            if Contrib::Analytics.enabled?(configuration[:analytics_enabled])
-              Contrib::Analytics.set_sample_rate(span, configuration[:analytics_sample_rate])
-            end
+          tracer.trace(Ext::SPAN_JOB, service: configuration[:service_name], resource: job_name(job),
+                                      on_error: configuration[:error_handler]) do |span|
+
+            set_sample_rate(span)
 
             # Measure service stats
             Contrib::Analytics.set_measured(span)
@@ -37,6 +28,23 @@ module Datadog
           end
         end
 
+        def self.instrument_enqueue(job, &block)
+          return block.call(job) unless tracer && tracer.enabled
+
+          tracer.trace(Ext::SPAN_ENQUEUE, service: configuration[:client_service_name], resource: job_name(job)) do |span|
+            set_sample_rate(span)
+
+            # Measure service stats
+            Contrib::Analytics.set_measured(span)
+
+            span.set_tag(Ext::TAG_QUEUE, job.queue) if job.queue
+            span.set_tag(Ext::TAG_PRIORITY, job.priority)
+            span.span_type = Datadog::Ext::AppTypes::WORKER
+
+            yield job
+          end
+        end
+
         def self.flush(worker, &block)
           yield worker
 
@@ -51,8 +59,24 @@ module Datadog
           configuration[:tracer]
         end
 
+        def self.job_name(job)
+          # When DelayedJob is used through ActiveJob, we need to parse the payload differentely
+          # to get the actual job name
+          return job.payload_object.job_data['job_class'] if job.payload_object.respond_to?(:job_data)
+
+          job.name
+        end
+
+        def self.set_sample_rate(span)
+          # Set analytics sample rate
+          if Contrib::Analytics.enabled?(configuration[:analytics_enabled])
+            Contrib::Analytics.set_sample_rate(span, configuration[:analytics_sample_rate])
+          end
+        end
+
         callbacks do |lifecycle|
-          lifecycle.around(:invoke_job, &method(:instrument))
+          lifecycle.around(:invoke_job, &method(:instrument_invoke))
+          lifecycle.around(:enqueue, &method(:instrument_enqueue))
           lifecycle.around(:execute, &method(:flush))
         end
       end