ddtrace 0.41.0 → 0.46.0

data/lib/ddtrace/contrib/auto_instrument.rb

@@ -0,0 +1,49 @@
+require 'ddtrace'
+
+module Datadog
+  module Contrib
+    # Extensions for auto instrumentation added to the base library
+    # AutoInstrumentation enables all integration
+    module AutoInstrument
+      def self.extended(base)
+        base.send(:extend, Patch)
+      end
+
+      # Patch adds method for invoking auto_instrumentation
+      module Patch
+        def add_auto_instrument
+          super
+
+          if Datadog::Contrib::Rails::Utils.railtie_supported?
+            require 'ddtrace/contrib/rails/auto_instrument_railtie'
+          else
+            AutoInstrument.patch_all
+          end
+          AutoInstrument.patch_all
+        end
+      end
+
+      def self.patch_all
+        integrations = []
+
+        Datadog.registry.each do |integration|
+          # some instrumentations are automatically enabled when the `rails` instrumentation is enabled,
+          # patching them on their own automatically outside of the rails integration context would
+          # cause undesirable service naming, so we exclude them based their auto_instrument? setting.
+          # we also don't want to mix rspec/cucumber integration in as rspec is env we run tests in.
+          next unless integration.klass.auto_instrument?
+
+          integrations << integration.name
+        end
+
+        Datadog.configure do |c|
+          c.reduce_log_verbosity
+          # This will activate auto-instrumentation for Rails
+          integrations.each do |integration_name|
+            c.use integration_name
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -1,5 +1,6 @@
 require 'ddtrace/contrib/analytics'
 require 'ddtrace/contrib/aws/ext'
+require 'ddtrace/ext/http'
 require 'ddtrace/ext/integration'
 
 module Datadog
@@ -26,7 +27,7 @@ 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)
 

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
@@ -36,6 +35,7 @@ module Datadog
 
           available_services.each_with_object([]) do |service, constants|
             next if ::Aws.autoload?(service)
+
             constants << ::Aws.const_get(service, false).const_get(:Client, false) rescue next
           end
         end

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

@@ -52,6 +52,7 @@ module Datadog
         ElasticLoadBalancingV2
         ElasticTranscoder
         ElasticsearchService
+        EventBridge
         Firehose
         GameLift
         Glacier
@@ -104,6 +105,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,17 @@ 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
+            patterns.find do |pattern|
               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
           end
 
           def add(pattern)

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

@@ -0,0 +1,28 @@
+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 :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,17 @@
+module Datadog
+  module Contrib
+    module Cucumber
+      # Cucumber integration constants
+      module Ext
+        APP = 'cucumber'.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,98 @@
+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, :current_feature_span, :current_step_span
+        private :config
+        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)
+
+          # 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?
+
+          @current_step_span.set_error event.result.exception unless event.result.passed?
+          @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,45 @@
+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
+
+        # test environments should not auto instrument test libraries
+        def auto_instrument?
+          false
+        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/patcher.rb

@@ -17,46 +17,8 @@ module Datadog
         end
 
         def patch
-          add_pin!
           ::Dalli::Server.send(:include, Instrumentation)
         end
-
-        # DEPRECATED: Only kept for users still using `Dalli.datadog_pin` to configure.
-        #             Replaced by configuration API, i.e. `c.use :dalli`.
-        def add_pin!
-          DeprecatedPin
-            .new(
-              get_option(:service_name),
-              app: Ext::APP,
-              app_type: Datadog::Ext::AppTypes::CACHE,
-              tracer: -> { get_option(:tracer) }
-            ).onto(::Dalli)
-        end
-
-        def get_option(option)
-          Datadog.configuration[:dalli].get_option(option)
-        end
-
-        # Implementation of deprecated Pin, which raises warnings when accessed.
-        # To be removed when support for Datadog::Pin with Dalli is removed.
-        class DeprecatedPin < Datadog::Pin
-          include Datadog::DeprecatedPin
-
-          DEPRECATION_WARNING = %(
-            Use of Datadog::Pin with Dalli is DEPRECATED.
-            Upgrade to the configuration API using the migration guide here:
-            https://github.com/DataDog/dd-trace-rb/releases/tag/v0.11.0).freeze
-
-          def service_name=(service_name)
-            Datadog.configuration[:dalli][:service_name] = service_name
-          end
-
-          def log_deprecation_warning(method_name)
-            do_once(method_name) do
-              Datadog.logger.warn("#{method_name}:#{DEPRECATION_WARNING}")
-            end
-          end
-        end
       end
     end
   end

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