ddtrace 0.13.0 → 0.47.0

data/lib/ddtrace/contrib/configurable.rb

@@ -0,0 +1,102 @@
+require 'ddtrace/contrib/configuration/resolver'
+require 'ddtrace/contrib/configuration/settings'
+
+module Datadog
+  module Contrib
+    # Defines configurable behavior for integrations.
+    #
+    # This module is responsible for coordination between
+    # the configuration resolver and default configuration
+    # fallback.
+    module Configurable
+      def self.included(base)
+        base.send(:include, InstanceMethods)
+      end
+
+      # Configurable instance behavior for integrations
+      module InstanceMethods
+        # Provides a new configuration instance for this integration.
+        #
+        # This method normally needs to be overridden for each integration
+        # as their settings, defaults and environment variables are
+        # specific for each integration.
+        #
+        # DEV(1.0): Rename to `new_configuration`, make it protected.
+        # DEV(1.0):
+        # DEV(1.0): This method always provides a new instance of the configuration object for
+        # DEV(1.0): the current integration, not the currently effective default configuration.
+        # DEV(1.0): This is a misnomer of its function.
+        # DEV(1.0):
+        # DEV(1.0): Unfortunately, change this would be a breaking change for all custom integrations,
+        # DEV(1.0): thus we have to be very intentional with the right time to make this change.
+        # DEV(1.0): Currently marking this for a 1.0 milestone.
+        def default_configuration
+          Configuration::Settings.new
+        end
+
+        # Get matching configuration by matcher.
+        # If no match, returns the default configuration instance.
+        def configuration(matcher = :default)
+          return default_configuration_instance if matcher == :default
+
+          resolver.get(matcher) || default_configuration_instance
+        end
+
+        # Resolves the matching configuration for integration-specific value.
+        # If no match, returns the default configuration instance.
+        def resolve(value)
+          return default_configuration_instance if value == :default
+
+          resolver.resolve(value) || default_configuration_instance
+        end
+
+        # Returns all registered matchers and their respective configurations.
+        def configurations
+          resolver.configurations.merge(default: default_configuration_instance)
+        end
+
+        # Create or update configuration associated with `matcher` with
+        # the provided `options` and `&block`.
+        def configure(matcher = :default, options = {}, &block)
+          config = if matcher == :default
+                     default_configuration_instance
+                   else
+                     # Get or add the configuration
+                     resolver.get(matcher) || resolver.add(matcher, default_configuration)
+                   end
+
+          # Apply the settings
+          config.configure(options, &block)
+          config
+        end
+
+        # Resets all configuration options
+        def reset_configuration!
+          @resolver = nil
+          @default_configuration = nil
+        end
+
+        protected
+
+        # DEV(1.0): Rename to `default_configuration`, make it public.
+        # DEV(1.0): See comment on `default_configuration` for more information.
+        def default_configuration_instance
+          @default_configuration ||= default_configuration # rubocop:disable Naming/MemoizedInstanceVariableName
+        end
+
+        # Overridable configuration resolver.
+        #
+        # This resolver is responsible for performing the matching
+        # of `#configure(matcher)` `matcher`s with `value`s provided
+        # in subsequent calls to `#resolve(value)`.
+        #
+        # By default, the `value` in `#resolve(value)` must be equal
+        # to the `matcher` object provided in `#configure(matcher)`
+        # to retrieve the associated configuration.
+        def resolver
+          @resolver ||= Configuration::Resolver.new
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,81 @@
+module Datadog
+  module Contrib
+    module Configuration
+      # Resolves an integration-specific matcher to an associated
+      # object.
+      #
+      # Integrations that perform any configuration matching
+      # based on patterns might want to override this class
+      # to provide richer matching. For example, match configuration
+      # based on: HTTP request parameters, request headers,
+      # async queue name.
+      #
+      # When overriding this class, for simple use cases, only
+      # overriding `#parse_matcher` might suffice. See
+      # `#parse_matcher`'s documentation for more information.
+      class Resolver
+        attr_reader :configurations
+
+        def initialize
+          @configurations = {}
+        end
+
+        # Adds a new `matcher`, associating with it a `value`.
+        #
+        # This `value` is returned when `#resolve` is called
+        # with a matching value for this matcher. When multiple
+        # matchers would match, `#resolve` returns the latest
+        # added one.
+        #
+        # The `matcher` can be transformed internally by the
+        # `#parse_matcher` method before being stored.
+        #
+        # The `value` can also be retrieved by calling `#get`
+        # with the same `matcher` added by this method.
+        #
+        # @param [Object] matcher integration-specific matcher
+        # @param [Object] value arbitrary value to be associated with `matcher`
+        def add(matcher, value)
+          @configurations[parse_matcher(matcher)] = value
+        end
+
+        # Retrieves the stored value for a `matcher`
+        # previously stored by `#add`.
+        #
+        # @param [Object] matcher integration-specific matcher
+        # @return [Object] previously stored `value` from `#add`, or `nil` if not found
+        def get(matcher)
+          @configurations[parse_matcher(matcher)]
+        end
+
+        # Matches an arbitrary value against the configured
+        # matchers previously set with `#add`.
+        #
+        # If multiple matchers would match, returns the latest one.
+        #
+        # @param [Object] value integration-specific value
+        # @return [Object] matching `value` configured at `#add`, or `nil` if none match
+        def resolve(value)
+          @configurations[value]
+        end
+
+        protected
+
+        # Converts `matcher` into an appropriate key
+        # for the internal Hash storage.
+        #
+        # It's recommended to override this method,
+        # instead of the public methods, if the
+        # integration can simply convert both
+        # `matcher` (provided to `#add`) and `value`
+        # (provided to `#resolve`) to the same value.
+        #
+        # @param [Object] matcher integration-specific matcher
+        # @return [Object] processed matcher
+        def parse_matcher(matcher)
+          matcher
+        end
+      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 and Regexps against `object.to_s` objects
+        # and Procs against plain objects.
+        class PatternResolver < Contrib::Configuration::Resolver
+          def resolve(value)
+            return if configurations.empty?
+
+            # Try to find a matching pattern
+            _, config = configurations.reverse_each.find do |matcher, _|
+              matcher === if matcher.is_a?(Proc)
+                            value
+                          else
+                            value.to_s
+                          end
+            end
+
+            config
+          end
+
+          protected
+
+          def parse_matcher(matcher)
+            if matcher.is_a?(Regexp) || matcher.is_a?(Proc)
+              matcher
+            else
+              matcher.to_s
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,55 @@
+require 'ddtrace/configuration/base'
+require 'ddtrace/utils/only_once'
+
+module Datadog
+  module Contrib
+    module Configuration
+      # Common settings for all integrations
+      class Settings
+        include Datadog::Configuration::Base
+
+        DEPRECATION_WARN_ONLY_ONCE = Datadog::Utils::OnlyOnce.new
+
+        option :analytics_enabled, default: false
+        option :analytics_sample_rate, default: 1.0
+        option :enabled, default: true
+        option :service_name
+        option :tracer do |o|
+          o.delegate_to { Datadog.tracer }
+          o.on_set do |_value|
+            log_deprecation_warning
+          end
+        end
+
+        def configure(options = {})
+          self.class.options.dependency_order.each do |name|
+            self[name] = options[name] if options.key?(name)
+          end
+
+          yield(self) if block_given?
+        end
+
+        def [](name)
+          respond_to?(name) ? send(name) : get_option(name)
+        end
+
+        def []=(name, value)
+          respond_to?("#{name}=") ? send("#{name}=", value) : set_option(name, value)
+        end
+
+        DEPRECATION_WARNING = %(
+          Explicitly providing a tracer instance is DEPRECATED.
+          It's recommended to not provide an explicit tracer instance
+          and let Datadog::Contrib::Configuration::Settings resolve
+          the correct tracer internally.
+          ).freeze
+
+        def log_deprecation_warning
+          DEPRECATION_WARN_ONLY_ONCE.run do
+            Datadog.logger.warn("tracer:#{DEPRECATION_WARNING}:#{caller.join("\n")}")
+          end
+        end
+      end
+    end
+  end
+end

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