ddtrace 0.34.1 → 1.23.1

data/lib/ddtrace/configuration/options.rb

@@ -1,112 +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.send(:extend, ClassMethods)
-        base.send(:include, InstanceMethods)
-      end
-
-      # Class behavior for a configuration object with options
-      module ClassMethods
-        def options
-          @options ||= begin
-            # Allows for class inheritance of option definitions
-            superclass <= Options ? superclass.options.dup : OptionDefinitionSet.new
-          end
-        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).merge(builder.helpers)
-            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
-          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)
-          unless option_defined?(name)
-            raise(InvalidOptionError, "#{self.class.name} doesn't define the option: #{name}")
-          end
-        end
-      end
-
-      InvalidOptionError = Class.new(StandardError)
-    end
-  end
-end

data/lib/ddtrace/configuration/pin_setup.rb

@@ -1,30 +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) }
-
-        true
-      end
-
-      private
-
-      attr_reader :pin, :opts
-
-      ATTRS = [:app, :tags, :app_type, :name, :tracer, :service_name].freeze
-
-      private_constant :ATTRS
-    end
-  end
-end

data/lib/ddtrace/configuration/settings.rb

@@ -1,187 +0,0 @@
-require 'ddtrace/configuration/base'
-
-require 'ddtrace/ext/analytics'
-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.
-    class Settings
-      include Base
-
-      #
-      # Configuration options
-      #
-      option :analytics_enabled do |o|
-        # TODO: Raise deprecation warning
-        o.default { env_to_bool(Ext::Analytics::ENV_TRACE_ANALYTICS_ENABLED, nil) }
-        o.lazy
-      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)
-            )
-          end
-
-          o.lazy
-        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_EXTRACT_STYLE_ENV,
-                        [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_INJECT_STYLE_ENV,
-                        [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
-        o.on_set { |value| get_option(:tracer).set_tags('env' => value) }
-      end
-
-      option :report_hostname do |o|
-        o.default { env_to_bool(Ext::NET::ENV_REPORT_HOSTNAME, false) }
-        o.lazy
-      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?
-
-        # TODO: Raise deprecation warning
-        runtime_metrics.configure(options)
-      end
-
-      option :runtime_metrics_enabled do |o|
-        # TODO: Raise deprecation warning
-        o.default { env_to_bool(Ext::Runtime::Metrics::ENV_ENABLED, false) }
-        o.lazy
-      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
-        o.on_set { |value| get_option(:tracer).default_service = value }
-      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] }]
-
-          # 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
-
-        # 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
-        end
-      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
-end

data/lib/ddtrace/configuration.rb

@@ -1,30 +0,0 @@
-require 'ddtrace/configuration/pin_setup'
-require 'ddtrace/configuration/settings'
-
-module Datadog
-  # Configuration provides a unique access point for configurations
-  module Configuration
-    attr_writer :configuration
-
-    def configuration
-      @configuration ||= Settings.new
-    end
-
-    def configure(target = configuration, opts = {})
-      if target.is_a?(Settings)
-        yield(target) if block_given?
-      else
-        PinSetup.new(target, opts).call
-      end
-    end
-
-    # Helper methods
-    def tracer
-      configuration.tracer
-    end
-
-    def runtime_metrics
-      tracer.writer.runtime_metrics
-    end
-  end
-end

data/lib/ddtrace/context.rb

@@ -1,305 +0,0 @@
-require 'thread'
-require 'ddtrace/diagnostics/health'
-
-require 'ddtrace/context_flush'
-require 'ddtrace/context_provider'
-
-module Datadog
-  # \Context is used to keep track of a hierarchy of spans for the current
-  # execution flow. During each logical execution, the same \Context is
-  # used to represent a single logical trace, even if the trace is built
-  # asynchronously.
-  #
-  # A single code execution may use multiple \Context if part of the execution
-  # must not be related to the current tracing. As example, a delayed job may
-  # compose a standalone trace instead of being related to the same trace that
-  # generates the job itself. On the other hand, if it's part of the same
-  # \Context, it will be related to the original trace.
-  #
-  # This data structure is thread-safe.
-  # rubocop:disable Metrics/ClassLength
-  class Context
-    # 100k spans is about a 100Mb footprint
-    DEFAULT_MAX_LENGTH = 100_000
-
-    attr_reader :max_length
-
-    # Initialize a new thread-safe \Context.
-    def initialize(options = {})
-      @mutex = Mutex.new
-      # max_length is the amount of spans above which, for a given trace,
-      # the context will simply drop and ignore spans, avoiding high memory usage.
-      @max_length = options.fetch(:max_length, DEFAULT_MAX_LENGTH)
-      reset(options)
-    end
-
-    def trace_id
-      @mutex.synchronize do
-        @parent_trace_id
-      end
-    end
-
-    def span_id
-      @mutex.synchronize do
-        @parent_span_id
-      end
-    end
-
-    def sampling_priority
-      @mutex.synchronize do
-        @sampling_priority
-      end
-    end
-
-    def sampling_priority=(priority)
-      @mutex.synchronize do
-        @sampling_priority = priority
-      end
-    end
-
-    def origin
-      @mutex.synchronize do
-        @origin
-      end
-    end
-
-    def origin=(origin)
-      @mutex.synchronize do
-        @origin = origin
-      end
-    end
-
-    # Return the last active span that corresponds to the last inserted
-    # item in the trace list. This cannot be considered as the current active
-    # span in asynchronous environments, because some spans can be closed
-    # earlier while child spans still need to finish their traced execution.
-    def current_span
-      @mutex.synchronize do
-        return @current_span
-      end
-    end
-
-    def current_root_span
-      @mutex.synchronize do
-        return @current_root_span
-      end
-    end
-
-    # Add a span to the context trace list, keeping it as the last active span.
-    def add_span(span)
-      @mutex.synchronize do
-        # If hitting the hard limit, just drop spans. This is really a rare case
-        # as it means despite the soft limit, the hard limit is reached, so the trace
-        # by default has 10000 spans, all of which belong to unfinished parts of a
-        # larger trace. This is a catch-all to reduce global memory usage.
-        if @max_length > 0 && @trace.length >= @max_length
-          # Detach the span from any context, it's being dropped and ignored.
-          span.context = nil
-          Datadog::Logger.log.debug("context full, ignoring span #{span.name}")
-
-          # If overflow has already occurred, don't send this metric.
-          # Prevents metrics spam if buffer repeatedly overflows for the same trace.
-          unless @overflow
-            Diagnostics::Health.metrics.error_context_overflow(1, tags: ["max_length:#{@max_length}"])
-            @overflow = true
-          end
-
-          return
-        end
-        set_current_span(span)
-        @current_root_span = span if @trace.empty?
-        @trace << span
-        span.context = self
-      end
-    end
-
-    # Mark a span as a finished, increasing the internal counter to prevent
-    # cycles inside _trace list.
-    def close_span(span)
-      @mutex.synchronize do
-        @finished_spans += 1
-        # Current span is only meaningful for linear tree-like traces,
-        # in other cases, this is just broken and one should rely
-        # on per-instrumentation code to retrieve handle parent/child relations.
-        set_current_span(span.parent)
-        return if span.tracer.nil?
-        if span.parent.nil? && !all_spans_finished?
-          if Datadog::Logger.debug_logging
-            opened_spans = @trace.length - @finished_spans
-            Datadog::Logger.log.debug("root span #{span.name} closed but has #{opened_spans} unfinished spans:")
-          end
-
-          @trace.reject(&:finished?).group_by(&:name).each do |unfinished_span_name, unfinished_spans|
-            Datadog::Logger.log.debug("unfinished span: #{unfinished_spans.first}") if Datadog::Logger.debug_logging
-            Diagnostics::Health.metrics.error_unfinished_spans(
-              unfinished_spans.length,
-              tags: ["name:#{unfinished_span_name}"]
-            )
-          end
-        end
-      end
-    end
-
-    # Returns if the trace for the current Context is finished or not. A \Context
-    # is considered finished if all spans in this context are finished.
-    def finished?
-      @mutex.synchronize do
-        return all_spans_finished?
-      end
-    end
-
-    # @@return [Numeric] numbers of finished spans
-    def finished_span_count
-      @mutex.synchronize do
-        @finished_spans
-      end
-    end
-
-    # Returns true if the context is sampled, that is, if it should be kept
-    # and sent to the trace agent.
-    def sampled?
-      @mutex.synchronize do
-        return @sampled
-      end
-    end
-
-    # Returns both the trace list generated in the current context and
-    # if the context is sampled or not.
-    #
-    # It returns +[nil,@sampled]+ if the \Context is
-    # not finished.
-    #
-    # If a trace is returned, the \Context will be reset so that it
-    # can be re-used immediately.
-    #
-    # This operation is thread-safe.
-    #
-    # @return [Array<Array<Span>, Boolean>] finished trace and sampled flag
-    def get
-      @mutex.synchronize do
-        trace = @trace
-        sampled = @sampled
-
-        # still return sampled attribute, even if context is not finished
-        return nil, sampled unless all_spans_finished?
-
-        # Root span is finished at this point, we can configure it
-        annotate_for_flush!(@current_root_span)
-
-        reset
-        [trace, sampled]
-      end
-    end
-
-    # Delete any span matching the condition. This is thread safe.
-    #
-    # @return [Array<Span>] deleted spans
-    def delete_span_if
-      @mutex.synchronize do
-        [].tap do |deleted_spans|
-          @trace.delete_if do |span|
-            finished = span.finished?
-
-            next unless yield span
-
-            deleted_spans << span
-
-            # We need to detach the span from the context, else, some code
-            # finishing it afterwards would mess up with the number of
-            # finished_spans and possibly cause other side effects.
-            span.context = nil
-            # Acknowledge there's one span less to finish, if needed.
-            # It's very important to keep this balanced.
-            @finished_spans -= 1 if finished
-
-            true
-          end
-        end
-      end
-    end
-
-    # Set tags to root span required for flush
-    def annotate_for_flush!(span)
-      attach_sampling_priority(span) if @sampled && @sampling_priority
-      attach_origin(span) if @origin
-    end
-
-    # Return a string representation of the context.
-    def to_s
-      @mutex.synchronize do
-        # rubocop:disable Metrics/LineLength
-        "Context(trace.length:#{@trace.length},sampled:#{@sampled},finished_spans:#{@finished_spans},current_span:#{@current_span})"
-      end
-    end
-
-    private
-
-    def reset(options = {})
-      @trace = []
-      @parent_trace_id = options.fetch(:trace_id, nil)
-      @parent_span_id = options.fetch(:span_id, nil)
-      @sampled = options.fetch(:sampled, false)
-      @sampling_priority = options.fetch(:sampling_priority, nil)
-      @origin = options.fetch(:origin, nil)
-      @finished_spans = 0
-      @current_span = nil
-      @current_root_span = nil
-      @overflow = false
-    end
-
-    def set_current_span(span)
-      @current_span = span
-      if span
-        @parent_trace_id = span.trace_id
-        @parent_span_id = span.span_id
-        @sampled = span.sampled
-      else
-        @parent_span_id = nil
-      end
-    end
-
-    # Returns if the trace for the current Context is finished or not.
-    # Low-level internal function, not thread-safe.
-    def all_spans_finished?
-      @finished_spans > 0 && @trace.length == @finished_spans
-    end
-
-    def attach_sampling_priority(span)
-      span.set_metric(
-        Ext::DistributedTracing::SAMPLING_PRIORITY_KEY,
-        @sampling_priority
-      )
-    end
-
-    def attach_origin(span)
-      span.set_tag(
-        Ext::DistributedTracing::ORIGIN_KEY,
-        @origin
-      )
-    end
-
-    # Return the start time of the root span, or nil if there are no spans or this is undefined.
-    def start_time
-      @mutex.synchronize do
-        return nil if @trace.empty?
-        @trace[0].start_time
-      end
-    end
-
-    # Return the length of the current trace held by this context.
-    def length
-      @mutex.synchronize do
-        @trace.length
-      end
-    end
-
-    # Iterate on each span within the trace. This is thread safe.
-    def each_span
-      @mutex.synchronize do
-        @trace.each do |span|
-          yield span
-        end
-      end
-    end
-  end
-end