ddtrace 0.38.0

data/lib/ddtrace/configuration.rb

@@ -0,0 +1,53 @@
+require 'forwardable'
+
+require 'ddtrace/configuration/pin_setup'
+require 'ddtrace/configuration/settings'
+require 'ddtrace/configuration/components'
+
+module Datadog
+  # Configuration provides a unique access point for configurations
+  module Configuration
+    extend Forwardable
+
+    attr_writer :configuration
+
+    def configuration
+      @configuration ||= Settings.new
+    end
+
+    def configure(target = configuration, opts = {})
+      if target.is_a?(Settings)
+        yield(target) if block_given?
+
+        # Build immutable components from settings
+        @components ||= nil
+        @components = if @components
+                        Components.replace!(@components, target)
+                      else
+                        Components.new(target)
+                      end
+
+        target
+      else
+        PinSetup.new(target, opts).call
+      end
+    end
+
+    def_delegators \
+      :components,
+      :health_metrics,
+      :logger,
+      :runtime_metrics,
+      :tracer
+
+    def shutdown!
+      components.teardown! if @components
+    end
+
+    protected
+
+    def components
+      @components ||= Components.new(configuration)
+    end
+  end
+end

data/lib/ddtrace/configuration/base.rb

@@ -0,0 +1,84 @@
+require 'ddtrace/environment'
+require 'ddtrace/configuration/options'
+
+module Datadog
+  module Configuration
+    # Basic configuration behavior
+    module Base
+      def self.included(base)
+        base.send(:extend, Datadog::Environment::Helpers)
+        base.send(:include, Datadog::Environment::Helpers)
+        base.send(:include, Options)
+
+        base.send(:extend, ClassMethods)
+        base.send(:include, InstanceMethods)
+      end
+
+      # Class methods for configuration
+      module ClassMethods
+        protected
+
+        # Allows subgroupings of settings to be defined.
+        # e.g. `settings :foo { option :bar }` --> `config.foo.bar`
+        def settings(name, &block)
+          settings_class = new_settings_class(&block)
+
+          option(name) do |o|
+            o.default { settings_class.new }
+            o.lazy
+            o.resetter do |value|
+              value.reset! if value.respond_to?(:reset!)
+              value
+            end
+          end
+        end
+
+        private
+
+        def new_settings_class(&block)
+          Class.new { include Datadog::Configuration::Base }.tap do |klass|
+            klass.instance_eval(&block) if block_given?
+          end
+        end
+      end
+
+      # Instance methods for configuration
+      module InstanceMethods
+        def initialize(options = {})
+          configure(options) unless options.empty?
+        end
+
+        def configure(opts = {})
+          # Sort the options in preference of dependency order first
+          ordering = self.class.options.dependency_order
+          sorted_opts = opts.sort_by do |name, _value|
+            ordering.index(name) || (ordering.length + 1)
+          end
+
+          # Ruby 2.0 doesn't support Array#to_h
+          sorted_opts = Hash[*sorted_opts.flatten]
+
+          # Apply options in sort order
+          sorted_opts.each do |name, value|
+            if respond_to?("#{name}=")
+              send("#{name}=", value)
+            elsif option_defined?(name)
+              set_option(name, value)
+            end
+          end
+
+          # Apply any additional settings from block
+          yield(self) if block_given?
+        end
+
+        def to_h
+          options_hash
+        end
+
+        def reset!
+          reset_options!
+        end
+      end
+    end
+  end
+end

data/lib/ddtrace/configuration/components.rb

@@ -0,0 +1,154 @@
+require 'ddtrace/diagnostics/health'
+require 'ddtrace/logger'
+require 'ddtrace/runtime/metrics'
+require 'ddtrace/tracer'
+require 'ddtrace/workers/runtime_metrics'
+
+module Datadog
+  module Configuration
+    # Global components for the trace library.
+    # rubocop:disable Metrics/LineLength
+    class Components
+      class << self
+        def replace!(old, settings)
+          replacement = new(settings)
+          old.teardown!(replacement)
+          replacement
+        end
+
+        def build_health_metrics(settings)
+          settings = settings.diagnostics.health_metrics
+          options = { enabled: settings.enabled }
+          options[:statsd] = settings.statsd unless settings.statsd.nil?
+
+          Datadog::Diagnostics::Health::Metrics.new(options)
+        end
+
+        def build_logger(settings)
+          logger = settings.logger.instance || Datadog::Logger.new(STDOUT)
+          logger.level = settings.diagnostics.debug ? ::Logger::DEBUG : settings.logger.level
+
+          logger
+        end
+
+        def build_runtime_metrics(settings)
+          options = { enabled: settings.runtime_metrics.enabled }
+          options[:statsd] = settings.runtime_metrics.statsd unless settings.runtime_metrics.statsd.nil?
+          options[:services] = [settings.service] unless settings.service.nil?
+
+          Datadog::Runtime::Metrics.new(options)
+        end
+
+        def build_runtime_metrics_worker(settings)
+          # NOTE: Should we just ignore building the worker if its not enabled?
+          options = settings.runtime_metrics.opts.merge(
+            enabled: settings.runtime_metrics.enabled,
+            metrics: build_runtime_metrics(settings)
+          )
+
+          Datadog::Workers::RuntimeMetrics.new(options)
+        end
+
+        def build_tracer(settings)
+          # If a custom tracer has been provided, use it instead.
+          # Ignore all other options (they should already be configured.)
+          tracer = settings.tracer.instance
+          return tracer unless tracer.nil?
+
+          tracer = Tracer.new(
+            default_service: settings.service,
+            enabled: settings.tracer.enabled,
+            partial_flush: settings.tracer.partial_flush.enabled,
+            tags: build_tracer_tags(settings)
+          )
+
+          # TODO: We reconfigure the tracer here because it has way too many
+          #       options it allows to mutate, and it's overwhelming to rewrite
+          #       tracer initialization for now. Just reconfigure using the
+          #       existing mutable #configure function. Remove when these components
+          #       are extracted.
+          tracer.configure(build_tracer_options(settings))
+
+          tracer
+        end
+
+        private
+
+        def build_tracer_tags(settings)
+          settings.tags.dup.tap do |tags|
+            tags['env'] = settings.env unless settings.env.nil?
+            tags['version'] = settings.version unless settings.version.nil?
+          end
+        end
+
+        def build_tracer_options(settings)
+          settings = settings.tracer
+
+          {}.tap do |opts|
+            opts[:hostname] = settings.hostname unless settings.hostname.nil?
+            opts[:min_spans_before_partial_flush] = settings.partial_flush.min_spans_threshold unless settings.partial_flush.min_spans_threshold.nil?
+            opts[:partial_flush] = settings.partial_flush.enabled unless settings.partial_flush.enabled.nil?
+            opts[:port] = settings.port unless settings.port.nil?
+            opts[:priority_sampling] = settings.priority_sampling unless settings.priority_sampling.nil?
+            opts[:sampler] = settings.sampler unless settings.sampler.nil?
+            opts[:transport_options] = settings.transport_options
+            opts[:writer] = settings.writer unless settings.writer.nil?
+            opts[:writer_options] = settings.writer_options if settings.writer.nil?
+          end
+        end
+      end
+
+      attr_reader \
+        :health_metrics,
+        :logger,
+        :runtime_metrics,
+        :tracer
+
+      def initialize(settings)
+        # Logger
+        @logger = self.class.build_logger(settings)
+
+        # Tracer
+        @tracer = self.class.build_tracer(settings)
+
+        # Runtime metrics
+        @runtime_metrics = self.class.build_runtime_metrics_worker(settings)
+
+        # Health metrics
+        @health_metrics = self.class.build_health_metrics(settings)
+      end
+
+      # Shuts down all the components in use.
+      # If it has another instance to compare to, it will compare
+      # and avoid tearing down parts still in use.
+      def teardown!(replacement = nil)
+        # Shutdown the old tracer, unless it's still being used.
+        # (e.g. a custom tracer instance passed in.)
+        tracer.shutdown! unless replacement && tracer == replacement.tracer
+
+        # Shutdown workers
+        runtime_metrics.enabled = false
+        runtime_metrics.stop(true)
+
+        # Shutdown the old metrics, unless they are still being used.
+        # (e.g. custom Statsd instances.)
+        old_statsd = [
+          runtime_metrics.metrics.statsd,
+          health_metrics.statsd
+        ].compact.uniq
+
+        new_statsd =  if replacement
+                        [
+                          replacement.runtime_metrics.metrics.statsd,
+                          replacement.health_metrics.statsd
+                        ].compact.uniq
+                      else
+                        []
+                      end
+
+        unused_statsd = (old_statsd - (old_statsd & new_statsd))
+        unused_statsd.each(&:close)
+      end
+    end
+  end
+end

data/lib/ddtrace/configuration/dependency_resolver.rb

@@ -0,0 +1,24 @@
+require 'tsort'
+
+module Datadog
+  module Configuration
+    # Resolver performs a topological sort over the dependency graph
+    class DependencyResolver
+      include TSort
+
+      def initialize(dependency_graph = {})
+        @dependency_graph = dependency_graph
+      end
+
+      def tsort_each_node(&blk)
+        @dependency_graph.each_key(&blk)
+      end
+
+      def tsort_each_child(node, &blk)
+        @dependency_graph.fetch(node).each(&blk)
+      end
+
+      alias call tsort
+    end
+  end
+end

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,123 @@
+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_given? ? block : value
+        end
+
+        def delegate_to(&block)
+          @delegate_to = block
+        end
+
+        def helper(name, *_args, &block)
+          @helpers[name] = block
+        end
+
+        # rubocop:disable Style/TrivialAccessors
+        # (Rubocop erroneously thinks #lazy == #lazy= )
+        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