ddtrace 0.38.0

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,112 @@
+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
+          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)
+          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

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

data/lib/ddtrace/configuration/settings.rb

@@ -0,0 +1,273 @@
+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, 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
+
+          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_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
+      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|
+        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
+          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.lazy
+      end
+
+      settings :tracer do
+        option :enabled, default: true
+        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

data/lib/ddtrace/context.rb

@@ -0,0 +1,305 @@
+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.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
+            Datadog.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.configuration.diagnostics.debug
+            opened_spans = @trace.length - @finished_spans
+            Datadog.logger.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.debug("unfinished span: #{unfinished_spans.first}") if Datadog.configuration.diagnostics.debug
+            Datadog.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