ddtrace 0.52.0 → 1.8.0

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

@@ -1,57 +0,0 @@
-# typed: true
-module Datadog
-  module Contrib
-    module Aws
-      # A wrapper around Seahorse::Client::RequestContext
-      class ParsedContext
-        def initialize(context)
-          @context = context
-        end
-
-        def safely(attr, fallback = nil)
-          public_send(attr) rescue fallback
-        end
-
-        def resource
-          "#{service}.#{operation}"
-        end
-
-        def operation
-          context.operation_name
-        end
-
-        def status_code
-          context.http_response.status_code
-        end
-
-        def http_method
-          context.http_request.http_method
-        end
-
-        def region
-          context.client.config.region
-        end
-
-        def retry_attempts
-          context.retries
-        end
-
-        def path
-          context.http_request.endpoint.path
-        end
-
-        def host
-          context.http_request.endpoint.host
-        end
-
-        private
-
-        attr_reader :context
-
-        def service
-          context.client.class.to_s.split('::')[1].downcase
-        end
-      end
-    end
-  end
-end

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

@@ -1,54 +0,0 @@
-# typed: false
-require 'ddtrace/contrib/patcher'
-require 'ddtrace/contrib/aws/ext'
-
-module Datadog
-  module Contrib
-    module Aws
-      # Patcher enables patching of 'aws' module.
-      module Patcher
-        include Contrib::Patcher
-
-        module_function
-
-        def target_version
-          Integration.version
-        end
-
-        def patch
-          require 'ddtrace/contrib/aws/parsed_context'
-          require 'ddtrace/contrib/aws/instrumentation'
-          require 'ddtrace/contrib/aws/services'
-
-          add_plugin(Seahorse::Client::Base, *loaded_constants)
-
-          # Special handling for S3 URL Presigning.
-          # @see {Datadog::Contrib::Aws::S3Presigner}
-          ::Aws::S3::Presigner.prepend(S3Presigner) if defined?(::Aws::S3::Presigner)
-        end
-
-        def add_plugin(*targets)
-          targets.each { |klass| klass.add_plugin(Instrumentation) }
-        end
-
-        def loaded_constants
-          # Cross-check services against loaded AWS constants
-          # Module#const_get can return a constant from ancestors when there's a miss.
-          # If this conincidentally matches another constant, it will attempt to patch
-          # the wrong constant, resulting in patch failure.
-          available_services = ::Aws.constants & SERVICES.map(&:to_sym)
-
-          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
-
-        def get_option(option)
-          Datadog.configuration[:aws].get_option(option)
-        end
-      end
-    end
-  end
-end

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

@@ -1,119 +0,0 @@
-# typed: true
-module Datadog
-  module Contrib
-    # rubocop:disable Metrics/ModuleLength:
-    module Aws
-      SERVICES = %w[
-        ACM
-        APIGateway
-        AppStream
-        ApplicationAutoScaling
-        ApplicationDiscoveryService
-        Athena
-        AutoScaling
-        Batch
-        Budgets
-        CloudDirectory
-        CloudFormation
-        CloudFront
-        CloudHSM
-        CloudHSMV2
-        CloudSearch
-        CloudSearchDomain
-        CloudTrail
-        CloudWatch
-        CloudWatchEvents
-        CloudWatchLogs
-        CodeBuild
-        CodeCommit
-        CodeDeploy
-        CodePipeline
-        CodeStar
-        CognitoIdentity
-        CognitoIdentityProvider
-        CognitoSync
-        ConfigService
-        CostandUsageReportService
-        DAX
-        DataPipeline
-        DatabaseMigrationService
-        DeviceFarm
-        DirectConnect
-        DirectoryService
-        DynamoDB
-        DynamoDBStreams
-        EC2
-        ECR
-        ECS
-        EFS
-        EMR
-        ElastiCache
-        ElasticBeanstalk
-        ElasticLoadBalancing
-        ElasticLoadBalancingV2
-        ElasticTranscoder
-        ElasticsearchService
-        EventBridge
-        Firehose
-        GameLift
-        Glacier
-        Glue
-        Greengrass
-        Health
-        IAM
-        ImportExport
-        Inspector
-        IoT
-        IoTDataPlane
-        KMS
-        Kinesis
-        KinesisAnalytics
-        Lambda
-        LambdaPreview
-        Lex
-        LexModelBuildingService
-        Lightsail
-        MTurk
-        MachineLearning
-        MarketplaceCommerceAnalytics
-        MarketplaceEntitlementService
-        MarketplaceMetering
-        MigrationHub
-        Mobile
-        OpsWorks
-        OpsWorksCM
-        Organizations
-        Pinpoint
-        Polly
-        RDS
-        Redshift
-        Rekognition
-        ResourceGroupsTaggingAPI
-        Route53
-        Route53Domains
-        S3
-        SES
-        SMS
-        SNS
-        SQS
-        SSM
-        STS
-        SWF
-        ServiceCatalog
-        Schemas
-        Shield
-        SimpleDB
-        Snowball
-        States
-        StorageGateway
-        Support
-        Textract
-        WAF
-        WAFRegional
-        WorkDocs
-        WorkSpaces
-        XRay
-      ].freeze
-    end
-  end
-end

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

@@ -1,21 +0,0 @@
-# typed: false
-require 'ddtrace/contrib/configuration/settings'
-require 'ddtrace/contrib/concurrent_ruby/ext'
-
-module Datadog
-  module Contrib
-    module ConcurrentRuby
-      module Configuration
-        # Custom settings for the ConcurrentRuby 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, default: Ext::SERVICE_NAME
-        end
-      end
-    end
-  end
-end

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

@@ -1,42 +0,0 @@
-# typed: true
-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,13 +0,0 @@
-# typed: true
-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,24 +0,0 @@
-# typed: false
-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,39 +0,0 @@
-# typed: false
-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,30 +0,0 @@
-# typed: true
-require 'ddtrace/contrib/patcher'
-
-module Datadog
-  module Contrib
-    module ConcurrentRuby
-      # Patcher enables patching of 'Future' class.
-      module Patcher
-        include Kernel # Ensure that kernel methods are always available (https://sorbet.org/docs/error-reference#7003)
-        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.include(FuturePatch)
-        end
-      end
-    end
-  end
-end

data/lib/ddtrace/contrib/configurable.rb

@@ -1,103 +0,0 @@
-# typed: true
-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.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,82 +0,0 @@
-# typed: true
-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,40 +0,0 @@
-# typed: true
-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,56 +0,0 @@
-# typed: false
-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