ls-trace 0.1.2 → 0.2.0

data/lib/ddtrace/configuration/options.rb

@@ -70,12 +70,17 @@ module Datadog
           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|
+          self.class.options.merge(options).each_with_object({}) do |(key, _), hash|
             hash[key] = get_option(key)
           end
         end

data/lib/ddtrace/configuration/pin_setup.rb

@@ -13,7 +13,7 @@ module Datadog
 
         ATTRS.each { |key| pin.public_send("#{key}=", opts[key]) if opts[key] }
 
-        pin.config = opts.reject { |key, _| ATTRS.include?(key) }
+        pin.config = opts.reject { |key, _| ATTRS.include?(key) || DEPRECATED_ATTRS.include?(key) }
 
         true
       end
@@ -22,7 +22,8 @@ module Datadog
 
       attr_reader :pin, :opts
 
-      ATTRS = [:app, :tags, :app_type, :name, :tracer, :service_name].freeze
+      ATTRS = [:app, :tags, :app_type, :name, :service_name].freeze
+      DEPRECATED_ATTRS = [:tracer].freeze
 
       private_constant :ATTRS
     end

data/lib/ddtrace/configuration/settings.rb

@@ -1,35 +1,63 @@
+require 'logger'
 require 'ddtrace/configuration/base'
 
 require 'ddtrace/ext/analytics'
 require 'ddtrace/ext/distributed'
 require 'ddtrace/ext/runtime'
-
-require 'ddtrace/tracer'
-require 'ddtrace/metrics'
-require 'ddtrace/diagnostics/health'
+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.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
 
-      option :report_hostname do |o|
-        o.default { env_to_bool(Ext::NET::ENV_REPORT_HOSTNAME, false) }
+      option :api_key do |o|
+        o.default { ENV.fetch(Ext::Environment::ENV_API_KEY, nil) }
         o.lazy
       end
 
-      option :runtime_metrics_enabled do |o|
-        o.default { env_to_bool(Ext::Runtime::Metrics::ENV_ENABLED, false) }
-        o.lazy
+      settings :diagnostics do
+        option :debug do |o|
+          o.default { env_to_bool(Datadog::Ext::Diagnostics::DD_TRACE_DEBUG, false) }
+          o.lazy
+        end
+
+        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
@@ -56,49 +84,195 @@ module Datadog
         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)
-            )
-          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::INFO
+      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 :tracer do |o|
-        o.default Tracer.new
+      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?
 
-        # On reset, shut down the old tracer,
-        # then instantiate a new one.
-        o.resetter do |tracer|
-          tracer.shutdown!
-          Tracer.new
+          tags
         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)
+        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
 
-          tracer.tap do |t|
-            unless options.nil?
-              t.configure(options)
-              t.class.log = options[:log] if options[:log]
-              t.set_tags(options[:tags]) if options[:tags]
-              t.set_tags(env: options[:env]) if options[:env]
-              t.class.debug_logging = options.fetch(:debug, false)
-            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
 
-      def runtime_metrics(options = nil)
-        runtime_metrics = get_option(:tracer).writer.runtime_metrics
-        return runtime_metrics if options.nil?
+      settings :tracer do
+        option :enabled do |o|
+          o.default { env_to_bool(Datadog::Ext::Diagnostics::DD_TRACE_ENABLED, true) }
+          o.lazy
+        end
+        option :hostname # TODO: Deprecate
+        option :instance
 
-        runtime_metrics.configure(options)
+        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

data/lib/ddtrace/context.rb

@@ -1,4 +1,8 @@
 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
@@ -89,9 +93,17 @@ module Datadog
         # 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
-          Datadog::Tracer.log.debug("context full, ignoring span #{span.name}")
           # 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)
@@ -111,12 +123,18 @@ module Datadog
         # on per-instrumentation code to retrieve handle parent/child relations.
         set_current_span(span.parent)
         return if span.tracer.nil?
-        return unless Datadog::Tracer.debug_logging
-        if span.parent.nil? && !check_finished_spans
-          opened_spans = @trace.length - @finished_spans
-          Datadog::Tracer.log.debug("root span #{span.name} closed but has #{opened_spans} unfinished spans:")
-          @trace.each do |s|
-            Datadog::Tracer.log.debug("unfinished span: #{s}") unless s.finished?
+        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
@@ -126,7 +144,14 @@ module Datadog
     # is considered finished if all spans in this context are finished.
     def finished?
       @mutex.synchronize do
-        return check_finished_spans
+        return all_spans_finished?
+      end
+    end
+
+    # @@return [Numeric] numbers of finished spans
+    def finished_span_count
+      @mutex.synchronize do
+        @finished_spans
       end
     end
 
@@ -139,27 +164,66 @@ module Datadog
     end
 
     # Returns both the trace list generated in the current context and
-    # if the context is sampled or not. It returns nil, nil if the ``Context`` is
-    # not finished. If a trace is returned, the \Context will be reset so that it
+    # 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
 
-        attach_sampling_priority if sampled && @sampling_priority
-        attach_origin if @origin
-
         # still return sampled attribute, even if context is not finished
-        return nil, sampled unless check_finished_spans()
+        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
@@ -180,6 +244,7 @@ module Datadog
       @finished_spans = 0
       @current_span = nil
       @current_root_span = nil
+      @overflow = false
     end
 
     def set_current_span(span)
@@ -195,19 +260,19 @@ module Datadog
 
     # Returns if the trace for the current Context is finished or not.
     # Low-level internal function, not thread-safe.
-    def check_finished_spans
+    def all_spans_finished?
       @finished_spans > 0 && @trace.length == @finished_spans
     end
 
-    def attach_sampling_priority
-      @current_root_span.set_metric(
+    def attach_sampling_priority(span)
+      span.set_metric(
         Ext::DistributedTracing::SAMPLING_PRIORITY_KEY,
         @sampling_priority
       )
     end
 
-    def attach_origin
-      @current_root_span.set_tag(
+    def attach_origin(span)
+      span.set_tag(
         Ext::DistributedTracing::ORIGIN_KEY,
         @origin
       )
@@ -236,49 +301,5 @@ module Datadog
         end
       end
     end
-
-    # Delete any span matching the condition. This is thread safe.
-    def delete_span_if
-      @mutex.synchronize do
-        @trace.delete_if do |span|
-          finished = span.finished?
-          delete_span = yield span
-          if delete_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
-          end
-          delete_span
-        end
-      end
-    end
-  end
-
-  # ThreadLocalContext can be used as a tracer global reference to create
-  # a different \Context for each thread. In synchronous tracer, this
-  # is required to prevent multiple threads sharing the same \Context
-  # in different executions.
-  class ThreadLocalContext
-    # ThreadLocalContext can be used as a tracer global reference to create
-    # a different \Context for each thread. In synchronous tracer, this
-    # is required to prevent multiple threads sharing the same \Context
-    # in different executions.
-    def initialize
-      self.local = Datadog::Context.new
-    end
-
-    # Override the thread-local context with a new context.
-    def local=(ctx)
-      Thread.current[:datadog_context] = ctx
-    end
-
-    # Return the thread-local context.
-    def local
-      Thread.current[:datadog_context] ||= Datadog::Context.new
-    end
   end
 end