ddtrace 0.49.0 → 1.12.1

data/lib/ddtrace/contrib/concurrent_ruby/context_composite_executor_service.rb

@@ -1,41 +0,0 @@
-require 'concurrent/executor/executor_service'
-
-module Datadog
-  module Contrib
-    module ConcurrentRuby
-      # wraps existing executor to carry over trace context
-      class ContextCompositeExecutorService
-        extend Forwardable
-        include Concurrent::ExecutorService
-
-        attr_accessor :composited_executor
-
-        def initialize(composited_executor)
-          @composited_executor = composited_executor
-        end
-
-        # post method runs the task within composited executor - in a different thread
-        def post(*args, &task)
-          parent_context = datadog_configuration.tracer.provider.context
-
-          @composited_executor.post(*args) do
-            begin
-              original_context = datadog_configuration.tracer.provider.context
-              datadog_configuration.tracer.provider.context = parent_context
-              yield
-            ensure
-              # Restore context in case the current thread gets reused
-              datadog_configuration.tracer.provider.context = original_context
-            end
-          end
-        end
-
-        def datadog_configuration
-          Datadog.configuration[:concurrent_ruby]
-        end
-
-        delegate [:can_overflow?, :serialized?] => :composited_executor
-      end
-    end
-  end
-end

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

@@ -1,12 +0,0 @@
-module Datadog
-  module Contrib
-    module ConcurrentRuby
-      # ConcurrentRuby integration constants
-      module Ext
-        APP = 'concurrent-ruby'.freeze
-        SERVICE_NAME = 'concurrent-ruby'.freeze
-        ENV_ENABLED = 'DD_TRACE_CONCURRENT_RUBY_ENABLED'.freeze
-      end
-    end
-  end
-end

data/lib/ddtrace/contrib/concurrent_ruby/future_patch.rb

@@ -1,23 +0,0 @@
-require 'ddtrace/contrib/concurrent_ruby/context_composite_executor_service'
-
-module Datadog
-  module Contrib
-    module ConcurrentRuby
-      # This patches the Future - to wrap executor service using ContextCompositeExecutorService
-      module FuturePatch
-        def self.included(base)
-          base.class_eval do
-            alias_method :ns_initialize_without_datadog, :ns_initialize
-            remove_method(:ns_initialize)
-
-            def ns_initialize(value, opts)
-              ns_initialize_without_datadog(value, opts)
-
-              @executor = ContextCompositeExecutorService.new(@executor)
-            end
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,38 +0,0 @@
-require 'ddtrace/contrib/integration'
-require 'ddtrace/contrib/concurrent_ruby/patcher'
-require 'ddtrace/contrib/concurrent_ruby/configuration/settings'
-
-module Datadog
-  module Contrib
-    module ConcurrentRuby
-      # Describes the ConcurrentRuby integration
-      class Integration
-        include Contrib::Integration
-
-        MINIMUM_VERSION = Gem::Version.new('0.9')
-
-        register_as :concurrent_ruby
-
-        def self.version
-          Gem.loaded_specs['concurrent-ruby'] && Gem.loaded_specs['concurrent-ruby'].version
-        end
-
-        def self.loaded?
-          !defined?(::Concurrent::Future).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/concurrent_ruby/patcher.rb

@@ -1,28 +0,0 @@
-require 'ddtrace/contrib/patcher'
-
-module Datadog
-  module Contrib
-    module ConcurrentRuby
-      # Patcher enables patching of 'Future' class.
-      module Patcher
-        include Contrib::Patcher
-
-        module_function
-
-        def target_version
-          Integration.version
-        end
-
-        def patch
-          require 'ddtrace/contrib/concurrent_ruby/future_patch'
-          patch_future
-        end
-
-        # Propagate tracing context in Concurrent::Future
-        def patch_future
-          ::Concurrent::Future.send(:include, FuturePatch)
-        end
-      end
-    end
-  end
-end

data/lib/ddtrace/contrib/configurable.rb

@@ -1,102 +0,0 @@
-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

@@ -1,81 +0,0 @@
-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

@@ -1,39 +0,0 @@
-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

@@ -1,55 +0,0 @@
-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

@@ -1,28 +0,0 @@
-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

@@ -1,17 +0,0 @@
-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

@@ -1,98 +0,0 @@
-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

@@ -1,24 +0,0 @@
-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

@@ -1,45 +0,0 @@
-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

@@ -1,23 +0,0 @@
-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