ddtrace 0.35.2 → 1.1.0

data/lib/ddtrace/buffer.rb

@@ -1,119 +0,0 @@
-require 'thread'
-require 'ddtrace/diagnostics/health'
-require 'ddtrace/runtime/object_space'
-
-module Datadog
-  # Trace buffer that stores application traces. The buffer has a maximum size and when
-  # the buffer is full, a random trace is discarded. This class is thread-safe and is used
-  # automatically by the ``Tracer`` instance when a ``Span`` is finished.
-  class TraceBuffer
-    def initialize(max_size)
-      @max_size = max_size
-
-      @mutex = Mutex.new()
-      @traces = []
-      @closed = false
-
-      # Initialize metric values
-      @buffer_accepted = 0
-      @buffer_accepted_lengths = 0
-      @buffer_dropped = 0
-      @buffer_spans = 0
-    end
-
-    # Add a new ``trace`` in the local queue. This method doesn't block the execution
-    # even if the buffer is full. In that case, a random trace is discarded.
-    def push(trace)
-      @mutex.synchronize do
-        return if @closed
-        len = @traces.length
-        if len < @max_size || @max_size <= 0
-          @traces << trace
-        else
-          # we should replace a random trace with the new one
-          replace_index = rand(len)
-          replaced_trace = @traces[replace_index]
-          @traces[replace_index] = trace
-          measure_drop(replaced_trace)
-        end
-
-        measure_accept(trace)
-      end
-    end
-
-    # Return the current number of stored traces.
-    def length
-      @mutex.synchronize do
-        return @traces.length
-      end
-    end
-
-    # Return if the buffer is empty.
-    def empty?
-      @mutex.synchronize do
-        return @traces.empty?
-      end
-    end
-
-    # Stored traces are returned and the local buffer is reset.
-    def pop
-      @mutex.synchronize do
-        traces = @traces
-        @traces = []
-
-        measure_pop(traces)
-
-        return traces
-      end
-    end
-
-    def close
-      @mutex.synchronize do
-        @closed = true
-      end
-    end
-
-    # Aggregate metrics:
-    # They reflect buffer activity since last #pop.
-    # These may not be as accurate or as granular, but they
-    # don't use as much network traffic as live stats.
-
-    def measure_accept(trace)
-      @buffer_spans += trace.length
-      @buffer_accepted += 1
-      @buffer_accepted_lengths += trace.length
-    rescue StandardError => e
-      Datadog.logger.debug("Failed to measure queue accept. Cause: #{e.message} Source: #{e.backtrace.first}")
-    end
-
-    def measure_drop(trace)
-      @buffer_dropped += 1
-      @buffer_spans -= trace.length
-      @buffer_accepted_lengths -= trace.length
-    rescue StandardError => e
-      Datadog.logger.debug("Failed to measure queue drop. Cause: #{e.message} Source: #{e.backtrace.first}")
-    end
-
-    def measure_pop(traces)
-      # Accepted
-      Datadog.health_metrics.queue_accepted(@buffer_accepted)
-      Datadog.health_metrics.queue_accepted_lengths(@buffer_accepted_lengths)
-
-      # Dropped
-      Datadog.health_metrics.queue_dropped(@buffer_dropped)
-
-      # Queue gauges
-      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
-      @buffer_accepted_lengths = 0
-      @buffer_dropped = 0
-      @buffer_spans = 0
-    rescue StandardError => e
-      Datadog.logger.debug("Failed to measure queue. Cause: #{e.message} Source: #{e.backtrace.first}")
-    end
-  end
-end

data/lib/ddtrace/chunker.rb

@@ -1,34 +0,0 @@
-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/base.rb

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

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

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

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

@@ -1,123 +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_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

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