ddtrace 0.50.0 → 1.0.0

data/lib/ddtrace/configuration/option_definition.rb

@@ -1,121 +0,0 @@
-require 'ddtrace/configuration/option'
-
-module Datadog
-  module Configuration
-    # Represents a definition for an integration configuration option
-    class OptionDefinition
-      IDENTITY = ->(new_value, _old_value) { new_value }
-
-      attr_reader \
-        :default,
-        :delegate_to,
-        :depends_on,
-        :lazy,
-        :name,
-        :on_set,
-        :resetter,
-        :setter
-
-      def initialize(name, meta = {}, &block)
-        @default = meta[:default]
-        @delegate_to = meta[:delegate_to]
-        @depends_on = meta[:depends_on] || []
-        @lazy = meta[:lazy] || false
-        @name = name.to_sym
-        @on_set = meta[:on_set]
-        @resetter = meta[:resetter]
-        @setter = meta[:setter] || block || IDENTITY
-      end
-
-      # Creates a new Option, bound to the context provided.
-      def build(context)
-        Option.new(self, context)
-      end
-
-      # Acts as DSL for building OptionDefinitions
-      class Builder
-        attr_reader \
-          :helpers
-
-        def initialize(name, options = {})
-          @default = nil
-          @delegate_to = nil
-          @depends_on = []
-          @helpers = {}
-          @lazy = false
-          @name = name.to_sym
-          @on_set = nil
-          @resetter = nil
-          @setter = OptionDefinition::IDENTITY
-
-          # If options were supplied, apply them.
-          apply_options!(options)
-
-          # Apply block if given.
-          yield(self) if block_given?
-        end
-
-        def depends_on(*values)
-          @depends_on = values.flatten
-        end
-
-        def default(value = nil, &block)
-          @default = block || value
-        end
-
-        def delegate_to(&block)
-          @delegate_to = block
-        end
-
-        def helper(name, *_args, &block)
-          @helpers[name] = block
-        end
-
-        def lazy(value = true)
-          @lazy = value
-        end
-
-        def on_set(&block)
-          @on_set = block
-        end
-
-        def resetter(&block)
-          @resetter = block
-        end
-
-        def setter(&block)
-          @setter = block
-        end
-
-        # For applying options for OptionDefinition
-        def apply_options!(options = {})
-          return if options.nil? || options.empty?
-
-          default(options[:default]) if options.key?(:default)
-          delegate_to(&options[:delegate_to]) if options.key?(:delegate_to)
-          depends_on(*options[:depends_on]) if options.key?(:depends_on)
-          lazy(options[:lazy]) if options.key?(:lazy)
-          on_set(&options[:on_set]) if options.key?(:on_set)
-          resetter(&options[:resetter]) if options.key?(:resetter)
-          setter(&options[:setter]) if options.key?(:setter)
-        end
-
-        def to_definition
-          OptionDefinition.new(@name, meta)
-        end
-
-        def meta
-          {
-            default: @default,
-            delegate_to: @delegate_to,
-            depends_on: @depends_on,
-            lazy: @lazy,
-            on_set: @on_set,
-            resetter: @resetter,
-            setter: @setter
-          }
-        end
-      end
-    end
-  end
-end

data/lib/ddtrace/configuration/option_definition_set.rb

@@ -1,18 +0,0 @@
-require 'ddtrace/configuration/dependency_resolver'
-
-module Datadog
-  module Configuration
-    # Represents a set of configuration option definitions for an integration
-    class OptionDefinitionSet < Hash
-      def dependency_order
-        DependencyResolver.new(dependency_graph).call
-      end
-
-      def dependency_graph
-        each_with_object({}) do |(name, option), graph|
-          graph[name] = option.depends_on
-        end
-      end
-    end
-  end
-end

data/lib/ddtrace/configuration/option_set.rb

@@ -1,6 +0,0 @@
-module Datadog
-  module Configuration
-    class OptionSet < Hash
-    end
-  end
-end

data/lib/ddtrace/configuration/options.rb

@@ -1,111 +0,0 @@
-require 'ddtrace/configuration/option_set'
-require 'ddtrace/configuration/option_definition'
-require 'ddtrace/configuration/option_definition_set'
-
-module Datadog
-  module Configuration
-    # Behavior for a configuration object that has options
-    module Options
-      def self.included(base)
-        base.extend(ClassMethods)
-        base.include(InstanceMethods)
-      end
-
-      # Class behavior for a configuration object with options
-      module ClassMethods
-        def options
-          # Allows for class inheritance of option definitions
-          @options ||= superclass <= Options ? superclass.options.dup : OptionDefinitionSet.new
-        end
-
-        protected
-
-        def option(name, meta = {}, &block)
-          builder = OptionDefinition::Builder.new(name, meta, &block)
-          options[name] = builder.to_definition.tap do
-            # Resolve and define helper functions
-            helpers = default_helpers(name)
-            # Prevent unnecessary creation of an identical copy of helpers if there's nothing to merge
-            helpers = helpers.merge(builder.helpers) unless builder.helpers.empty?
-            define_helpers(helpers)
-          end
-        end
-
-        private
-
-        def default_helpers(name)
-          option_name = name.to_sym
-
-          {
-            option_name.to_sym => proc do
-              get_option(option_name)
-            end,
-            "#{option_name}=".to_sym => proc do |value|
-              set_option(option_name, value)
-            end
-          }
-        end
-
-        def define_helpers(helpers)
-          helpers.each do |name, block|
-            next unless block.is_a?(Proc)
-
-            define_method(name, &block)
-          end
-        end
-      end
-
-      # Instance behavior for a configuration object with options
-      module InstanceMethods
-        def options
-          @options ||= OptionSet.new
-        end
-
-        def set_option(name, value)
-          add_option(name) unless options.key?(name)
-          options[name].set(value)
-        end
-
-        def get_option(name)
-          add_option(name) unless options.key?(name)
-          options[name].get
-        end
-
-        def reset_option(name)
-          assert_valid_option!(name)
-          options[name].reset if options.key?(name)
-        end
-
-        def option_defined?(name)
-          self.class.options.key?(name)
-        end
-
-        def options_hash
-          self.class.options.merge(options).each_with_object({}) do |(key, _), hash|
-            hash[key] = get_option(key)
-          end
-        end
-
-        def reset_options!
-          options.values.each(&:reset)
-        end
-
-        private
-
-        def add_option(name)
-          assert_valid_option!(name)
-          definition = self.class.options[name]
-          definition.build(self).tap do |option|
-            options[name] = option
-          end
-        end
-
-        def assert_valid_option!(name)
-          raise(InvalidOptionError, "#{self.class.name} doesn't define the option: #{name}") unless option_defined?(name)
-        end
-      end
-
-      InvalidOptionError = Class.new(StandardError)
-    end
-  end
-end

data/lib/ddtrace/configuration/pin_setup.rb

@@ -1,31 +0,0 @@
-module Datadog
-  module Configuration
-    # PinSetup translates a flat hash into a Pin configuration
-    # This class should be removed if we ever remove/refactor the Pin class
-    class PinSetup
-      def initialize(target, opts = {})
-        @pin = Pin.get_from(target)
-        @opts = opts
-      end
-
-      def call
-        return unless pin
-
-        ATTRS.each { |key| pin.public_send("#{key}=", opts[key]) if opts[key] }
-
-        pin.config = opts.reject { |key, _| ATTRS.include?(key) || DEPRECATED_ATTRS.include?(key) }
-
-        true
-      end
-
-      private
-
-      attr_reader :pin, :opts
-
-      ATTRS = [:app, :tags, :app_type, :name, :service_name].freeze
-      DEPRECATED_ATTRS = [:tracer].freeze
-
-      private_constant :ATTRS
-    end
-  end
-end

data/lib/ddtrace/configuration/settings.rb

@@ -1,388 +0,0 @@
-require 'logger'
-require 'ddtrace/configuration/base'
-
-require 'ddtrace/ext/analytics'
-require 'ddtrace/ext/distributed'
-require 'ddtrace/ext/profiling'
-require 'ddtrace/ext/runtime'
-require 'ddtrace/ext/sampling'
-require 'ddtrace/ext/test'
-
-module Datadog
-  module Configuration
-    # Global configuration settings for the trace library.
-    # rubocop:disable Metrics/ClassLength
-    class Settings
-      include Base
-
-      def initialize(*_)
-        super
-
-        # WORKAROUND: The values for services, version, and env can get set either directly OR as a side effect of
-        # accessing tags (reading or writing). This is of course really confusing and error-prone, e.g. in an app
-        # WITHOUT this workaround where you define `DD_TAGS=env:envenvtag,service:envservicetag,version:envversiontag`
-        # and do:
-        #
-        # puts Datadog.configuration.instance_exec { "#{service} #{env} #{version}" }
-        # Datadog.configuration.tags
-        # puts Datadog.configuration.instance_exec { "#{service} #{env} #{version}" }
-        #
-        # the output will be:
-        #
-        # [empty]
-        # envservicetag envenvtag envversiontag
-        #
-        # That is -- the proper values for service/env/version are only set AFTER something accidentally or not triggers
-        # the resolution of the tags.
-        # This is really confusing, error prone, etc, so calling tags here is a really hacky but effective way to
-        # avoid this. I could not think of a better way of fixing this issue without massive refactoring of tags parsing
-        # (so that the individual service/env/version get correctly set even from their tags values, not as a side
-        # effect). Sorry :(
-        tags
-      end
-
-      settings :analytics do
-        option :enabled do |o|
-          o.default { env_to_bool(Ext::Analytics::ENV_TRACE_ANALYTICS_ENABLED, nil) }
-          o.lazy
-        end
-      end
-
-      option :analytics_enabled do |o|
-        o.delegate_to { get_option(:analytics).enabled }
-        o.on_set do |value|
-          # TODO: Raise deprecation warning
-          get_option(:analytics).enabled = value
-        end
-      end
-
-      option :api_key do |o|
-        o.default { ENV.fetch(Ext::Environment::ENV_API_KEY, nil) }
-        o.lazy
-      end
-
-      settings :diagnostics do
-        option :debug do |o|
-          o.default { env_to_bool(Datadog::Ext::Diagnostics::DD_TRACE_DEBUG, false) }
-          o.lazy
-          o.on_set do |enabled|
-            # Enable rich debug print statements.
-            # We do not need to unnecessarily load 'pp' unless in debugging mode.
-            require 'pp' if enabled
-          end
-        end
-
-        settings :health_metrics do
-          option :enabled do |o|
-            o.default { env_to_bool(Datadog::Ext::Diagnostics::Health::Metrics::ENV_ENABLED, false) }
-            o.lazy
-          end
-
-          option :statsd
-        end
-
-        settings :startup_logs do
-          option :enabled do |o|
-            # Defaults to nil as we want to know when the default value is being used
-            o.default { env_to_bool(Datadog::Ext::Diagnostics::DD_TRACE_STARTUP_LOGS, nil) }
-            o.lazy
-          end
-        end
-      end
-
-      settings :distributed_tracing do
-        option :propagation_extract_style do |o|
-          o.default do
-            # Look for all headers by default
-            env_to_list([Ext::DistributedTracing::PROPAGATION_STYLE_EXTRACT_ENV,
-                         Ext::DistributedTracing::PROPAGATION_EXTRACT_STYLE_ENV_OLD],
-                        [Ext::DistributedTracing::PROPAGATION_STYLE_DATADOG,
-                         Ext::DistributedTracing::PROPAGATION_STYLE_B3,
-                         Ext::DistributedTracing::PROPAGATION_STYLE_B3_SINGLE_HEADER])
-          end
-
-          o.lazy
-        end
-
-        option :propagation_inject_style do |o|
-          o.default do
-            # Only inject Datadog headers by default
-            env_to_list([Ext::DistributedTracing::PROPAGATION_STYLE_INJECT_ENV,
-                         Ext::DistributedTracing::PROPAGATION_INJECT_STYLE_ENV_OLD],
-                        [Ext::DistributedTracing::PROPAGATION_STYLE_DATADOG])
-          end
-
-          o.lazy
-        end
-      end
-
-      option :env do |o|
-        # NOTE: env also gets set as a side effect of tags. See the WORKAROUND note in #initialize for details.
-        o.default { ENV.fetch(Ext::Environment::ENV_ENVIRONMENT, nil) }
-        o.lazy
-      end
-
-      settings :logger do
-        option :instance do |o|
-          o.on_set { |value| set_option(:level, value.level) unless value.nil? }
-        end
-
-        option :level, default: ::Logger::INFO
-      end
-
-      def logger=(logger)
-        get_option(:logger).instance = logger
-      end
-
-      settings :profiling do
-        option :enabled do |o|
-          o.default { env_to_bool(Ext::Profiling::ENV_ENABLED, false) }
-          o.lazy
-        end
-
-        settings :exporter do
-          option :transport
-          option :transport_options do |o|
-            o.setter do
-              # NOTE: As of April 2021 there may be a few profiler private beta customers with this setting, but since I'm
-              # marking this as deprecated before public beta, we can remove this for 1.0 without concern.
-              Datadog.logger.warn(
-                'Configuring the profiler c.profiling.exporter.transport_options is no longer needed, as the profiler ' \
-                'will reuse your existing global or tracer configuration. ' \
-                'This setting is deprecated for removal in a future ddtrace version ' \
-                '(1.0 or profiling GA, whichever comes first).'
-              )
-              nil
-            end
-            o.default { nil }
-            o.lazy
-          end
-        end
-
-        option :max_events, default: 32768
-
-        # Controls the maximum number of frames for each thread sampled. Can be tuned to avoid omitted frames in the
-        # produced profiles. Increasing this may increase the overhead of profiling.
-        option :max_frames do |o|
-          o.default { env_to_int(Ext::Profiling::ENV_MAX_FRAMES, 400) }
-          o.lazy
-        end
-
-        settings :upload do
-          option :timeout_seconds do |o|
-            o.setter { |value| value.nil? ? 30.0 : value.to_f }
-            o.default { env_to_float(Ext::Profiling::ENV_UPLOAD_TIMEOUT, 30.0) }
-            o.lazy
-          end
-        end
-      end
-
-      option :report_hostname do |o|
-        o.default { env_to_bool(Ext::NET::ENV_REPORT_HOSTNAME, false) }
-        o.lazy
-      end
-
-      settings :runtime_metrics do
-        option :enabled do |o|
-          o.default { env_to_bool(Ext::Runtime::Metrics::ENV_ENABLED, false) }
-          o.lazy
-        end
-
-        option :opts, default: ->(_i) { {} }, lazy: true
-        option :statsd
-      end
-
-      # Backwards compatibility for configuring runtime metrics e.g. `c.runtime_metrics enabled: true`
-      def runtime_metrics(options = nil)
-        settings = get_option(:runtime_metrics)
-        return settings if options.nil?
-
-        # If options were provided (old style) then raise warnings and apply them:
-        # TODO: Raise deprecation warning
-        settings.enabled = options[:enabled] if options.key?(:enabled)
-        settings.statsd = options[:statsd] if options.key?(:statsd)
-        settings
-      end
-
-      option :runtime_metrics_enabled do |o|
-        o.delegate_to { get_option(:runtime_metrics).enabled }
-        o.on_set do |value|
-          # TODO: Raise deprecation warning
-          get_option(:runtime_metrics).enabled = value
-        end
-      end
-
-      settings :sampling do
-        option :default_rate do |o|
-          o.default { env_to_float(Ext::Sampling::ENV_SAMPLE_RATE, nil) }
-          o.lazy
-        end
-
-        option :rate_limit do |o|
-          o.default { env_to_float(Ext::Sampling::ENV_RATE_LIMIT, 100) }
-          o.lazy
-        end
-      end
-
-      option :service do |o|
-        # NOTE: service also gets set as a side effect of tags. See the WORKAROUND note in #initialize for details.
-        o.default { ENV.fetch(Ext::Environment::ENV_SERVICE, nil) }
-        o.lazy
-      end
-
-      option :site do |o|
-        o.default { ENV.fetch(Ext::Environment::ENV_SITE, nil) }
-        o.lazy
-      end
-
-      option :tags do |o|
-        o.default do
-          tags = {}
-
-          # Parse tags from environment
-          env_to_list(Ext::Environment::ENV_TAGS).each do |tag|
-            pair = tag.split(':')
-            tags[pair.first] = pair.last if pair.length == 2
-          end
-
-          # Override tags if defined
-          tags[Ext::Environment::TAG_ENV] = env unless env.nil?
-          tags[Ext::Environment::TAG_VERSION] = version unless version.nil?
-
-          tags
-        end
-
-        o.setter do |new_value, old_value|
-          # Coerce keys to strings
-          string_tags = new_value.collect { |k, v| [k.to_s, v] }.to_h
-
-          # Cross-populate tag values with other settings
-
-          self.env = string_tags[Ext::Environment::TAG_ENV] if env.nil? && string_tags.key?(Ext::Environment::TAG_ENV)
-
-          if version.nil? && string_tags.key?(Ext::Environment::TAG_VERSION)
-            self.version = string_tags[Ext::Environment::TAG_VERSION]
-          end
-
-          if service.nil? && string_tags.key?(Ext::Environment::TAG_SERVICE)
-            self.service = string_tags[Ext::Environment::TAG_SERVICE]
-          end
-
-          # Merge with previous tags
-          (old_value || {}).merge(string_tags)
-        end
-
-        o.lazy
-      end
-
-      settings :test_mode do
-        option :enabled do |o|
-          o.default { env_to_bool(Ext::Test::ENV_MODE_ENABLED, false) }
-          o.lazy
-        end
-
-        option :context_flush do |o|
-          o.default { nil }
-          o.lazy
-        end
-
-        option :writer_options do |o|
-          o.default { {} }
-          o.lazy
-        end
-      end
-
-      option :time_now_provider do |o|
-        o.default { ::Time.now }
-
-        o.on_set do |time_provider|
-          Utils::Time.now_provider = time_provider
-        end
-
-        o.resetter do |_value|
-          # TODO: Resetter needs access to the default value
-          # TODO: to help reduce duplication.
-          -> { ::Time.now }.tap do |default|
-            Utils::Time.now_provider = default
-          end
-        end
-      end
-
-      settings :tracer do
-        option :enabled do |o|
-          o.default { env_to_bool(Datadog::Ext::Diagnostics::DD_TRACE_ENABLED, true) }
-          o.lazy
-        end
-        option :hostname # TODO: Deprecate
-        option :instance
-
-        settings :partial_flush do
-          option :enabled, default: false
-          option :min_spans_threshold
-        end
-
-        option :port # TODO: Deprecate
-        option :priority_sampling # TODO: Deprecate
-        option :sampler
-        option :transport_options, default: ->(_i) { {} }, lazy: true # TODO: Deprecate
-        option :writer # TODO: Deprecate
-        option :writer_options, default: ->(_i) { {} }, lazy: true # TODO: Deprecate
-      end
-
-      # Backwards compatibility for configuring tracer e.g. `c.tracer debug: true`
-      def tracer(options = nil)
-        settings = get_option(:tracer)
-        return settings if options.nil?
-
-        # If options were provided (old style) then raise warnings and apply them:
-        options = options.dup
-
-        if options.key?(:log)
-          # TODO: Raise deprecation warning
-          get_option(:logger).instance = options.delete(:log)
-        end
-
-        if options.key?(:tags)
-          # TODO: Raise deprecation warning
-          set_option(:tags, options.delete(:tags))
-        end
-
-        if options.key?(:env)
-          # TODO: Raise deprecation warning
-          set_option(:env, options.delete(:env))
-        end
-
-        if options.key?(:debug)
-          # TODO: Raise deprecation warning
-          get_option(:diagnostics).debug = options.delete(:debug)
-        end
-
-        if options.key?(:partial_flush)
-          # TODO: Raise deprecation warning
-          settings.partial_flush.enabled = options.delete(:partial_flush)
-        end
-
-        if options.key?(:min_spans_before_partial_flush)
-          # TODO: Raise deprecation warning
-          settings.partial_flush.min_spans_threshold = options.delete(:min_spans_before_partial_flush)
-        end
-
-        # Forward remaining options to settings
-        options.each do |key, value|
-          setter = :"#{key}="
-          settings.send(setter, value) if settings.respond_to?(setter)
-        end
-      end
-
-      def tracer=(tracer)
-        get_option(:tracer).instance = tracer
-      end
-
-      option :version do |o|
-        # NOTE: version also gets set as a side effect of tags. See the WORKAROUND note in #initialize for details.
-        o.default { ENV.fetch(Ext::Environment::ENV_VERSION, nil) }
-        o.lazy
-      end
-    end
-  end
-end