ddtrace 0.42.0 → 0.47.0

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

@@ -24,6 +24,7 @@ module Datadog
 
           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/plugin.rb

@@ -10,7 +10,8 @@ module Datadog
         def self.instrument_invoke(job, &block)
           return block.call(job) unless tracer && tracer.enabled
 
-          tracer.trace(Ext::SPAN_JOB, service: configuration[:service_name], resource: job_name(job)) do |span|
+          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

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

@@ -1,3 +1,4 @@
+require 'ddtrace/patcher'
 require 'ddtrace/contrib/patcher'
 require 'ddtrace/ext/app_types'
 require 'ddtrace/ext/integration'

data/lib/ddtrace/contrib/elasticsearch/quantize.rb

@@ -17,7 +17,7 @@ module Datadog
 
         def format_url(url)
           sanitize_fragment_with_id(url)
-            .gsub(/(?:[\d]+)/, PLACEHOLDER)
+            .gsub(/(?:\d+)/, PLACEHOLDER)
         end
 
         def format_body(body, options = {})
@@ -60,6 +60,7 @@ module Datadog
         # If JSON parsing fails, it prints fail_value.
         def reserialize_json(string, fail_value = PLACEHOLDER)
           return string unless block_given?
+
           begin
             JSON.dump(yield(JSON.parse(string)))
           rescue JSON::ParserError
@@ -72,7 +73,7 @@ module Datadog
         # This is meant as simple heuristic that attempts to detect if particular fragment
         # represents document Id. This is meant to reduce the cardinality in most frequent cases.
         def sanitize_fragment_with_id(url)
-          url.gsub(%r{^(/?[^/]*/[^/]*/)(?:[^\?/\d]*[\d]+[^\?/]*)}, ID_PLACEHOLDER)
+          url.gsub(%r{^(/?[^/]*/[^/]*/)(?:[^?/\d]*\d+[^?/]*)}, ID_PLACEHOLDER)
         end
       end
     end

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

@@ -13,8 +13,8 @@ module Datadog
         def self.included(base)
           base.send(:prepend, InstanceMethods)
         end
+
         # InstanceMethods - implementing instrumentation
-        # rubocop:disable Metrics/ModuleLength
         module InstanceMethods
           include Datadog::Contrib::HttpAnnotationHelper
 
@@ -36,12 +36,14 @@ module Datadog
           def perform
             load_datadog_configuration_for(url)
             return super unless tracer_enabled?
+
             datadog_before_request
             super
           end
 
           def complete
             return super unless tracer_enabled?
+
             begin
               response_options = mirror.options
               response_code = (response_options[:response_code] || response_options[:code]).to_i
@@ -99,21 +101,21 @@ module Datadog
 
           def datadog_tag_request
             span = @datadog_span
-            method = 'N/A'
-            if instance_variable_defined?(:@datadog_method) && !@datadog_method.nil?
-              method = @datadog_method.to_s
-            end
+            method = Ext::NOT_APPLICABLE_METHOD
+            method = @datadog_method.to_s if instance_variable_defined?(:@datadog_method) && !@datadog_method.nil?
             span.resource = method
             # Tag as an external peer service
             span.set_tag(Datadog::Ext::Integration::TAG_PEER_SERVICE, span.service)
             # 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)
+            this_uri = uri
+            return unless this_uri
+
+            span.set_tag(Datadog::Ext::HTTP::URL, this_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)
+            span.set_tag(Datadog::Ext::NET::TARGET_HOST, this_uri.host)
+            span.set_tag(Datadog::Ext::NET::TARGET_PORT, this_uri.port)
           end
 
           def set_span_error_message(message)
@@ -124,7 +126,6 @@ module Datadog
 
           def uri
             URI.parse(url)
-          # rubocop:disable Lint/HandleExceptions
           rescue URI::InvalidURIError
           end
 

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

@@ -12,6 +12,7 @@ module Datadog
         SERVICE_NAME = 'ethon'.freeze
         SPAN_REQUEST = 'ethon.request'.freeze
         SPAN_MULTI_REQUEST = 'ethon.multi.request'.freeze
+        NOT_APPLICABLE_METHOD = 'N/A'.freeze
       end
     end
   end

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

@@ -63,6 +63,12 @@ module Datadog
               @options
             end
 
+            # default_options in this case contains our specific middleware options
+            # so we want it to take precedence in build_request_options
+            def build_request_options!(datum)
+              datadog_configuration(datum[:host]).options_hash.merge(@default_options)
+            end
+
             def initialize(stack)
               super(stack, self.class.options)
             end
@@ -113,9 +119,7 @@ module Datadog
           span.set_tag(Datadog::Ext::Integration::TAG_PEER_SERVICE, span.service)
 
           # Set analytics sample rate
-          if analytics_enabled?
-            Contrib::Analytics.set_sample_rate(span, analytics_sample_rate)
-          end
+          Contrib::Analytics.set_sample_rate(span, analytics_sample_rate) if analytics_enabled?
 
           span.set_tag(Datadog::Ext::HTTP::URL, datum[:path])
           span.set_tag(Datadog::Ext::HTTP::METHOD, datum[:method].to_s.upcase)
@@ -130,9 +134,7 @@ module Datadog
 
               if datum.key?(:response)
                 response = datum[:response]
-                if error_handler.call(response)
-                  span.set_error(["Error #{response[:status]}", response[:body]])
-                end
+                span.set_error(["Error #{response[:status]}", response[:body]]) if error_handler.call(response)
                 span.set_tag(Datadog::Ext::HTTP::STATUS_CODE, response[:status])
               end
               span.set_error(datum[:error]) if datum.key?(:error)
@@ -149,7 +151,7 @@ module Datadog
         end
 
         def build_request_options!(datum)
-          datadog_configuration(datum[:host]).options_hash.merge(@default_options)
+          @default_options.merge(datadog_configuration(datum[:host]).options_hash)
         end
 
         def datadog_configuration(host = :default)

data/lib/ddtrace/contrib/extensions.rb

@@ -27,8 +27,27 @@ module Datadog
 
           # Activate integrations
           if target.respond_to?(:integrations_pending_activation)
+            reduce_verbosity = target.respond_to?(:reduce_verbosity?) ? target.reduce_verbosity? : false
             target.integrations_pending_activation.each do |integration|
-              integration.patch if integration.respond_to?(:patch)
+              next unless integration.respond_to?(:patch)
+
+              # integration.patch returns either true or a hash of details on why patching failed
+              patch_results = integration.patch
+
+              next if patch_results == true
+
+              # if patching failed, only log output if verbosity is unset
+              # or if patching failure is due to compatibility or integration specific reasons
+              next unless !reduce_verbosity ||
+                          ((patch_results[:available] && patch_results[:loaded]) &&
+                           (!patch_results[:compatible] || !patch_results[:patchable]))
+
+              desc = "Available?: #{patch_results[:available]}"
+              desc += ", Loaded? #{patch_results[:loaded]}"
+              desc += ", Compatible? #{patch_results[:compatible]}"
+              desc += ", Patchable? #{patch_results[:patchable]}"
+
+              Datadog.logger.warn("Unable to patch #{patch_results[:name]} (#{desc})")
             end
 
             target.integrations_pending_activation.clear
@@ -48,9 +67,32 @@ module Datadog
             end
           end
 
-          def [](integration_name, configuration_name = :default)
+          # For the provided `integration_name`, resolves a matching configuration
+          # for the provided integration from an integration-specific `key`.
+          #
+          # How the matching is performed is integration-specific.
+          #
+          # @param [Symbol] integration_name the integration name
+          # @param [Object] key the integration-specific lookup key
+          # @return [Datadog::Contrib::Configuration::Settings]
+          def [](integration_name, key = :default)
+            integration = fetch_integration(integration_name)
+            integration.resolve(key) unless integration.nil?
+          end
+
+          # For the provided `integration_name`, retrieves a configuration previously
+          # stored by `#instrument`. Specifically, `describes` should be
+          # the same value provided in the `describes:` option for `#instrument`.
+          #
+          # If no `describes` value is provided, the default configuration is returned.
+          #
+          # @param [Symbol] integration_name the integration name
+          # @param [Object] describes the previously configured `describes:` object. If `nil`,
+          #   fetches the default configuration
+          # @return [Datadog::Contrib::Configuration::Settings]
+          def configuration(integration_name, describes = nil)
             integration = fetch_integration(integration_name)
-            integration.configuration(configuration_name) unless integration.nil?
+            integration.configuration(describes) unless integration.nil?
           end
 
           def instrument(integration_name, options = {}, &block)
@@ -86,6 +128,14 @@ module Datadog
             registry[name] ||
               raise(InvalidIntegrationError, "'#{name}' is not a valid integration.")
           end
+
+          def reduce_verbosity?
+            defined?(@reduce_verbosity) ? @reduce_verbosity : false
+          end
+
+          def reduce_log_verbosity
+            @reduce_verbosity ||= true
+          end
         end
       end
     end