ddtrace 0.13.0 → 0.47.0

data/lib/ddtrace/configuration/{resolver.rb → dependency_resolver.rb}

@@ -1,9 +1,9 @@
 require 'tsort'
 
 module Datadog
-  class Configuration
+  module Configuration
     # Resolver performs a topological sort over the dependency graph
-    class Resolver
+    class DependencyResolver
       include TSort
 
       def initialize(dependency_graph = {})

data/lib/ddtrace/configuration/option.rb

@@ -0,0 +1,64 @@
+module Datadog
+  module Configuration
+    # Represents an instance of an integration configuration option
+    class Option
+      attr_reader \
+        :definition
+
+      def initialize(definition, context)
+        @definition = definition
+        @context = context
+        @value = nil
+        @is_set = false
+      end
+
+      def set(value)
+        old_value = @value
+        (@value = context_exec(value, old_value, &definition.setter)).tap do |v|
+          @is_set = true
+          context_exec(v, old_value, &definition.on_set) if definition.on_set
+        end
+      end
+
+      def get
+        if @is_set
+          @value
+        elsif definition.delegate_to
+          context_eval(&definition.delegate_to)
+        else
+          set(default_value)
+        end
+      end
+
+      def reset
+        @value = if definition.resetter
+                   # Don't change @is_set to false; custom resetters are
+                   # responsible for changing @value back to a good state.
+                   # Setting @is_set = false would cause a default to be applied.
+                   context_exec(@value, &definition.resetter)
+                 else
+                   @is_set = false
+                   nil
+                 end
+      end
+
+      def default_value
+        if definition.lazy
+          context_eval(&definition.default)
+        else
+          definition.default
+        end
+      end
+
+      private
+
+      def context_exec(*args, &block)
+        @context.instance_exec(*args, &block)
+      end
+
+      def context_eval(&block)
+        @context.instance_eval(&block)
+      end
+    end
+  end
+end

data/lib/ddtrace/configuration/option_definition.rb

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

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

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

data/lib/ddtrace/configuration/options.rb

@@ -0,0 +1,111 @@
+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.send(:extend, ClassMethods)
+        base.send(: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,5 +1,5 @@
 module Datadog
-  class Configuration
+  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
@@ -13,7 +13,7 @@ module Datadog
 
         ATTRS.each { |key| pin.public_send("#{key}=", opts[key]) if opts[key] }
 
-        pin.config = opts.reject { |key, _| ATTRS.include?(key) }
+        pin.config = opts.reject { |key, _| ATTRS.include?(key) || DEPRECATED_ATTRS.include?(key) }
 
         true
       end
@@ -22,7 +22,8 @@ module Datadog
 
       attr_reader :pin, :opts
 
-      ATTRS = [:app, :tags, :app_type, :name, :tracer, :service_name].freeze
+      ATTRS = [:app, :tags, :app_type, :name, :service_name].freeze
+      DEPRECATED_ATTRS = [:tracer].freeze
 
       private_constant :ATTRS
     end

data/lib/ddtrace/configuration/settings.rb

@@ -0,0 +1,299 @@
+require 'logger'
+require 'ddtrace/configuration/base'
+
+require 'ddtrace/ext/analytics'
+require 'ddtrace/ext/distributed'
+require 'ddtrace/ext/runtime'
+require 'ddtrace/ext/sampling'
+
+module Datadog
+  module Configuration
+    # Global configuration settings for the trace library.
+    # rubocop:disable Metrics/ClassLength
+    class Settings
+      include Base
+
+      #
+      # Configuration options
+      #
+      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|
+        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
+
+      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|
+        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 = Hash[new_value.collect { |k, v| [k.to_s, v] }]
+
+          # 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
+
+      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|
+        o.default { ENV.fetch(Ext::Environment::ENV_VERSION, nil) }
+        o.lazy
+      end
+    end
+  end
+end