ddtrace 0.34.2 → 0.35.0

data/lib/ddtrace.rb

@@ -34,7 +34,7 @@ module Datadog
   # Add shutdown hook:
   # Ensures the tracer has an opportunity to flush traces
   # and cleanup before terminating the process.
-  at_exit { Datadog.tracer.shutdown! }
+  at_exit { Datadog.shutdown! }
 end
 
 require 'ddtrace/contrib/action_cable/integration'

data/lib/ddtrace/buffer.rb

@@ -83,7 +83,7 @@ module Datadog
       @buffer_accepted += 1
       @buffer_accepted_lengths += trace.length
     rescue StandardError => e
-      Datadog::Logger.log.debug("Failed to measure queue accept. Cause: #{e.message} Source: #{e.backtrace.first}")
+      Datadog.logger.debug("Failed to measure queue accept. Cause: #{e.message} Source: #{e.backtrace.first}")
     end
 
     def measure_drop(trace)
@@ -91,21 +91,21 @@ module Datadog
       @buffer_spans -= trace.length
       @buffer_accepted_lengths -= trace.length
     rescue StandardError => e
-      Datadog::Logger.log.debug("Failed to measure queue drop. Cause: #{e.message} Source: #{e.backtrace.first}")
+      Datadog.logger.debug("Failed to measure queue drop. Cause: #{e.message} Source: #{e.backtrace.first}")
     end
 
     def measure_pop(traces)
       # Accepted
-      Diagnostics::Health.metrics.queue_accepted(@buffer_accepted)
-      Diagnostics::Health.metrics.queue_accepted_lengths(@buffer_accepted_lengths)
+      Datadog.health_metrics.queue_accepted(@buffer_accepted)
+      Datadog.health_metrics.queue_accepted_lengths(@buffer_accepted_lengths)
 
       # Dropped
-      Diagnostics::Health.metrics.queue_dropped(@buffer_dropped)
+      Datadog.health_metrics.queue_dropped(@buffer_dropped)
 
       # Queue gauges
-      Diagnostics::Health.metrics.queue_max_length(@max_size)
-      Diagnostics::Health.metrics.queue_spans(@buffer_spans)
-      Diagnostics::Health.metrics.queue_length(traces.length)
+      Datadog.health_metrics.queue_max_length(@max_size)
+      Datadog.health_metrics.queue_spans(@buffer_spans)
+      Datadog.health_metrics.queue_length(traces.length)
 
       # Reset aggregated metrics
       @buffer_accepted = 0
@@ -113,7 +113,7 @@ module Datadog
       @buffer_dropped = 0
       @buffer_spans = 0
     rescue StandardError => e
-      Datadog::Logger.log.debug("Failed to measure queue. Cause: #{e.message} Source: #{e.backtrace.first}")
+      Datadog.logger.debug("Failed to measure queue. Cause: #{e.message} Source: #{e.backtrace.first}")
     end
   end
 end

data/lib/ddtrace/chunker.rb

@@ -0,0 +1,34 @@
+require 'json'
+require 'msgpack'
+
+module Datadog
+  # Chunks list of elements into batches
+  module Chunker
+    module_function
+
+    # Chunks a list into batches of at most +max_chunk_size+ elements each.
+    #
+    # An exception can occur if a single element is too large. That single
+    # element will be returned in its own chunk. You have to verify by yourself
+    # when such elements are returned.
+    #
+    # @param list [Enumerable] list of elements
+    # @param max_chunk_size [Numeric] maximum acceptable chunk size
+    # @return [Enumerable] lazy list of chunks
+    def chunk_by_size(list, max_chunk_size)
+      chunk_agg = 0
+      list.slice_before do |elem|
+        size = elem.size
+        chunk_agg += size
+        if chunk_agg > max_chunk_size
+          # Can't fit element in current chunk, start a new one.
+          chunk_agg = size
+          true
+        else
+          # Add to current chunk
+          false
+        end
+      end
+    end
+  end
+end

data/lib/ddtrace/configuration.rb

@@ -1,9 +1,14 @@
+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
@@ -13,18 +18,36 @@ module Datadog
     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
 
-    # Helper methods
-    def tracer
-      configuration.tracer
+    def_delegators \
+      :components,
+      :health_metrics,
+      :logger,
+      :runtime_metrics,
+      :tracer
+
+    def shutdown!
+      components.teardown! if @components
     end
 
-    def runtime_metrics
-      tracer.writer.runtime_metrics
+    protected
+
+    def components
+      @components ||= Components.new(configuration)
     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
+        ].uniq
+
+        new_statsd =  if replacement
+                        [
+                          replacement.runtime_metrics.metrics.statsd,
+                          replacement.health_metrics.statsd
+                        ].uniq
+                      else
+                        []
+                      end
+
+        unused_statsd = (old_statsd - (old_statsd & new_statsd))
+        unused_statsd.each(&:close)
+      end
+    end
+  end
+end

data/lib/ddtrace/configuration/settings.rb

@@ -1,3 +1,4 @@
+require 'logger'
 require 'ddtrace/configuration/base'
 
 require 'ddtrace/ext/analytics'
@@ -5,34 +6,41 @@ require 'ddtrace/ext/distributed'
 require 'ddtrace/ext/runtime'
 require 'ddtrace/ext/sampling'
 
-require 'ddtrace/tracer'
-require 'ddtrace/metrics'
-require 'ddtrace/diagnostics/health'
-
 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|
-        # TODO: Raise deprecation warning
-        o.default { env_to_bool(Ext::Analytics::ENV_TRACE_ANALYTICS_ENABLED, nil) }
-        o.lazy
+        o.delegate_to { get_option(:analytics).enabled }
+        o.on_set do |value|
+          # TODO: Raise deprecation warning
+          get_option(:analytics).enabled = value
+        end
       end
 
       settings :diagnostics do
-        option :health_metrics do |o|
-          o.default do
-            Datadog::Diagnostics::Health::Metrics.new(
-              enabled: env_to_bool(Datadog::Ext::Diagnostics::Health::Metrics::ENV_ENABLED, false)
-            )
+        option :debug, default: false
+
+        settings :health_metrics do
+          option :enabled do |o|
+            o.default { env_to_bool(Datadog::Ext::Diagnostics::Health::Metrics::ENV_ENABLED, false) }
+            o.lazy
           end
 
-          o.lazy
+          option :statsd
         end
       end
 
@@ -63,7 +71,19 @@ module Datadog
       option :env do |o|
         o.default { ENV.fetch(Ext::Environment::ENV_ENVIRONMENT, nil) }
         o.lazy
-        o.on_set { |value| get_option(:tracer).set_tags('env' => value) }
+      end
+
+      settings :logger do
+        option :instance do |o|
+          o.setter { |value, old_value| value.is_a?(::Logger) ? value : old_value }
+          o.on_set { |value| set_option(:level, value.level) unless value.nil? }
+        end
+
+        option :level, default: ::Logger::WARN
+      end
+
+      def logger=(logger)
+        get_option(:logger).instance = logger
       end
 
       option :report_hostname do |o|
@@ -71,19 +91,34 @@ module Datadog
         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)
-        runtime_metrics = get_option(:tracer).writer.runtime_metrics
-        return runtime_metrics if 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
-        runtime_metrics.configure(options)
+        settings.enabled = options[:enabled] if options.key?(:enabled)
+        settings.statsd = options[:statsd] if options.key?(:statsd)
+        settings
       end
 
       option :runtime_metrics_enabled do |o|
-        # TODO: Raise deprecation warning
-        o.default { env_to_bool(Ext::Runtime::Metrics::ENV_ENABLED, false) }
-        o.lazy
+        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
@@ -101,7 +136,6 @@ module Datadog
       option :service do |o|
         o.default { ENV.fetch(Ext::Environment::ENV_SERVICE, nil) }
         o.lazy
-        o.on_set { |value| get_option(:tracer).default_service = value }
       end
 
       option :tags do |o|
@@ -125,62 +159,96 @@ module Datadog
           # Coerce keys to strings
           string_tags = Hash[new_value.collect { |k, v| [k.to_s, v] }]
 
+          # Cross-populate tag values with other settings
+          if env.nil? && string_tags.key?(Ext::Environment::TAG_ENV)
+            self.env = string_tags[Ext::Environment::TAG_ENV]
+          end
+
+          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.on_set { |value| get_option(:tracer).set_tags(value) }
-
         o.lazy
       end
 
-      option :tracer do |o|
-        o.default { Tracer.new }
-        o.lazy
+      settings :tracer do
+        option :enabled, default: true
+        option :hostname # TODO: Deprecate
+        option :instance
 
-        # On reset, shut down the old tracer,
-        # then instantiate a new one.
-        o.resetter do |tracer|
-          tracer.shutdown!
-          Tracer.new
-        end
-
-        # Backwards compatibility for configuring tracer e.g. `c.tracer debug: true`
-        o.helper :tracer do |options = nil|
-          tracer = options && options.key?(:instance) ? set_option(:tracer, options[:instance]) : get_option(:tracer)
-
-          tracer.tap do |t|
-            unless options.nil?
-              t.configure(options)
-
-              if options[:log]
-                # TODO: Raise deprecation warning
-                Datadog::Logger.log = options[:log]
-              end
-
-              if options[:tags]
-                # TODO: Raise deprecation warning
-                t.set_tags(options[:tags])
-              end
-
-              if options[:env]
-                # TODO: Raise deprecation warning
-                t.set_tags(env: options[:env])
-              end
-
-              if options.key?(:debug)
-                # TODO: Raise deprecation warning
-                Datadog::Logger.debug_logging = options[:debug]
-              end
-            end
-          end
+        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
-        o.on_set { |value| get_option(:tracer).set_tags('version' => value) }
       end
     end
   end