ddtrace 0.30.1 → 0.31.0

data/docs/GettingStarted.md

@@ -26,6 +26,7 @@ To contribute, check out the [contribution guidelines][contribution docs] and [d
      - [Quickstart for OpenTracing](#quickstart-for-opentracing)
  - [Manual instrumentation](#manual-instrumentation)
  - [Integration instrumentation](#integration-instrumentation)
+     - [Action Cable](#action-cable)
      - [Action View](#action-view)
      - [Active Model Serializers](#active-model-serializers)
      - [Action Pack](#action-pack)
@@ -80,7 +81,8 @@ To contribute, check out the [contribution guidelines][contribution docs] and [d
 
 | Type  | Documentation              | Version | Support type                         | Gem version support |
 | ----- | -------------------------- | -----   | ------------------------------------ | ------------------- |
-| MRI   | https://www.ruby-lang.org/ | 2.6     | Full                                 | Latest              |
+| MRI   | https://www.ruby-lang.org/ | 2.7     | Full                                 | Latest              |
+|       |                            | 2.6     | Full                                 | Latest              |
 |       |                            | 2.5     | Full                                 | Latest              |
 |       |                            | 2.4     | Full                                 | Latest              |
 |       |                            | 2.3     | Full                                 | Latest              |
@@ -324,6 +326,7 @@ For a list of available integrations, and their configuration options, please re
 
 | Name                     | Key                        | Versions Supported       | How to configure                    | Gem source                                                                     |
 | ------------------------ | -------------------------- | ------------------------ | ----------------------------------- | ------------------------------------------------------------------------------ |
+| Action Cable             | `action_cable`             | `>= 5.0`                 | *[Link](#action-cable)*             | *[Link](https://github.com/rails/rails/tree/master/actioncable)*               |
 | Action View              | `action_view`              | `>= 3.2`                 | *[Link](#action-view)*              | *[Link](https://github.com/rails/rails/tree/master/actionview)*                |
 | Active Model Serializers | `active_model_serializers` | `>= 0.9`                 | *[Link](#active-model-serializers)* | *[Link](https://github.com/rails-api/active_model_serializers)*                |
 | Action Pack              | `action_pack`              | `>= 3.2`                 | *[Link](#action-pack)*              | *[Link](https://github.com/rails/rails/tree/master/actionpack)*                |
@@ -356,6 +359,28 @@ For a list of available integrations, and their configuration options, please re
 | Sinatra                  | `sinatra`                  | `>= 1.4.5`               | *[Link](#sinatra)*                  | *[Link](https://github.com/sinatra/sinatra)*                                   |
 | Sucker Punch             | `sucker_punch`             | `>= 2.0`                 | *[Link](#sucker-punch)*             | *[Link](https://github.com/brandonhilkert/sucker_punch)*                       |
 
+### Action Cable
+
+The Action Cable integration traces broadcast messages and channel actions.
+
+You can enable it through `Datadog.configure`:
+
+```ruby
+require 'ddtrace'
+
+Datadog.configure do |c|
+  c.use :action_cable, options
+end
+```
+
+Where `options` is an optional `Hash` that accepts the following parameters:
+
+| Key | Description | Default |
+| --- | ----------- | ------- |
+| `analytics_enabled` | Enable analytics for spans produced by this integration. `true` for on, `nil` to defer to global setting, `false` for off. | `false` |
+| `service_name` | Service name used for `action_cable` instrumentation | `'action_cable'` |
+| `tracer` | `Datadog::Tracer` used to perform instrumentation. Usually you don't need to set this. | `Datadog.tracer` |
+
 ### Action View
 
 Most of the time, Active Support is set up as part of Rails, but it can be activated separately:
@@ -1105,7 +1130,7 @@ Where `options` is an optional `Hash` that accepts the following parameters:
 |  2.2 - 2.3    |  3.0 - 5.2               |
 |  2.4          |  4.2.8 - 5.2             |
 |  2.5          |  4.2.8 - 6.0             |
-|  2.6          |  5.0 - 6.0               |
+|  2.6 - 2.7    |  5.0 - 6.0               |
 
 ### Rake
 
@@ -1450,7 +1475,7 @@ Datadog.configure do |c|
   c.tracer log: Logger.new(f)                 # Overriding the default tracer
 end
 
-Datadog::Tracer.log.info { "this is typically called by tracing code" }
+Datadog::Logger.log.info { "this is typically called by tracing code" }
 ```
 
 ### Environment and tags

data/lib/ddtrace.rb

@@ -26,8 +26,14 @@ module Datadog
   # Load and extend Contrib by default
   require 'ddtrace/contrib/extensions'
   extend Contrib::Extensions
+
+  # Add shutdown hook:
+  # Ensures the tracer has an opportunity to flush traces
+  # and cleanup before terminating the process.
+  at_exit { Datadog.tracer.shutdown! }
 end
 
+require 'ddtrace/contrib/action_cable/integration'
 require 'ddtrace/contrib/action_pack/integration'
 require 'ddtrace/contrib/action_view/integration'
 require 'ddtrace/contrib/active_model_serializers/integration'

data/lib/ddtrace/buffer.rb

@@ -83,7 +83,7 @@ module Datadog
       @buffer_accepted += 1
       @buffer_accepted_lengths += trace.length
     rescue StandardError => e
-      Datadog::Tracer.log.debug("Failed to measure queue accept. Cause: #{e.message} Source: #{e.backtrace.first}")
+      Datadog::Logger.log.debug("Failed to measure queue accept. Cause: #{e.message} Source: #{e.backtrace.first}")
     end
 
     def measure_drop(trace)
@@ -91,7 +91,7 @@ module Datadog
       @buffer_spans -= trace.length
       @buffer_accepted_lengths -= trace.length
     rescue StandardError => e
-      Datadog::Tracer.log.debug("Failed to measure queue drop. Cause: #{e.message} Source: #{e.backtrace.first}")
+      Datadog::Logger.log.debug("Failed to measure queue drop. Cause: #{e.message} Source: #{e.backtrace.first}")
     end
 
     def measure_pop(traces)
@@ -113,7 +113,7 @@ module Datadog
       @buffer_dropped = 0
       @buffer_spans = 0
     rescue StandardError => e
-      Datadog::Tracer.log.debug("Failed to measure queue. Cause: #{e.message} Source: #{e.backtrace.first}")
+      Datadog::Logger.log.debug("Failed to measure queue. Cause: #{e.message} Source: #{e.backtrace.first}")
     end
   end
 end

data/lib/ddtrace/configuration/base.rb

@@ -23,7 +23,8 @@ module Datadog
           settings_class = new_settings_class(&block)
 
           option(name) do |o|
-            o.default settings_class.new
+            o.default -> { settings_class.new }
+            o.lazy
             o.resetter do |value|
               value.reset! if value.respond_to?(:reset!)
               value

data/lib/ddtrace/configuration/settings.rb

@@ -3,6 +3,7 @@ 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'
@@ -56,6 +57,18 @@ module Datadog
         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
+
       settings :diagnostics do
         option :health_metrics do |o|
           o.default do
@@ -85,10 +98,10 @@ module Datadog
           tracer.tap do |t|
             unless options.nil?
               t.configure(options)
-              t.class.log = options[:log] if options[:log]
+              Datadog::Logger.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)
+              Datadog::Logger.debug_logging = options.fetch(:debug, false)
             end
           end
         end

data/lib/ddtrace/context.rb

@@ -1,6 +1,9 @@
 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
@@ -92,7 +95,7 @@ module Datadog
         if @max_length > 0 && @trace.length >= @max_length
           # Detach the span from any context, it's being dropped and ignored.
           span.context = nil
-          Datadog::Tracer.log.debug("context full, ignoring span #{span.name}")
+          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.
@@ -121,13 +124,13 @@ module Datadog
         set_current_span(span.parent)
         return if span.tracer.nil?
         if span.parent.nil? && !all_spans_finished?
-          if Datadog::Tracer.debug_logging
+          if Datadog::Logger.debug_logging
             opened_spans = @trace.length - @finished_spans
-            Datadog::Tracer.log.debug("root span #{span.name} closed but has #{opened_spans} unfinished 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::Tracer.log.debug("unfinished span: #{unfinished_spans.first}") if Datadog::Tracer.debug_logging
+            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}"]
@@ -145,6 +148,13 @@ module Datadog
       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?
@@ -154,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 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
@@ -215,15 +264,15 @@ module Datadog
       @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
       )
@@ -252,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

data/lib/ddtrace/context_flush.rb

@@ -1,132 +1,69 @@
-require 'set'
-
-require 'ddtrace/context'
-
 module Datadog
-  # \ContextFlush is used to cap context size and avoid it using too much memory.
-  # It performs memory flushes when required.
-  class ContextFlush
-    # by default, soft and hard limits are the same
-    DEFAULT_MAX_SPANS_BEFORE_PARTIAL_FLUSH = Datadog::Context::DEFAULT_MAX_LENGTH
-    # by default, never do a partial flush
-    DEFAULT_MIN_SPANS_BEFORE_PARTIAL_FLUSH = Datadog::Context::DEFAULT_MAX_LENGTH
-    # timeout should be lower than the trace agent window
-    DEFAULT_PARTIAL_FLUSH_TIMEOUT = 10
-
-    private_constant :DEFAULT_MAX_SPANS_BEFORE_PARTIAL_FLUSH
-    private_constant :DEFAULT_MIN_SPANS_BEFORE_PARTIAL_FLUSH
-    private_constant :DEFAULT_PARTIAL_FLUSH_TIMEOUT
-
-    def initialize(options = {})
-      # max_spans_before_partial_flush is the amount of spans collected before
-      # the context starts to partially flush parts of traces. With a setting of 10k,
-      # the memory overhead is about 10Mb per thread/context (depends on spans metadata,
-      # this is just an order of magnitude).
-      @max_spans_before_partial_flush = options.fetch(:max_spans_before_partial_flush,
-                                                      DEFAULT_MAX_SPANS_BEFORE_PARTIAL_FLUSH)
-      # min_spans_before_partial_flush is the minimum number of spans required
-      # for a partial flush to happen on a timeout. This is to prevent partial flush
-      # of traces which last a very long time but yet have few spans.
-      @min_spans_before_partial_flush = options.fetch(:min_spans_before_partial_flush,
-                                                      DEFAULT_MIN_SPANS_BEFORE_PARTIAL_FLUSH)
-      # partial_flush_timeout is the limit (in seconds) above which the context
-      # considers flushing parts of the trace. Partial flushes should not be done too
-      # late else the agent rejects them with a "too far in the past" error.
-      @partial_flush_timeout = options.fetch(:partial_flush_timeout,
-                                             DEFAULT_PARTIAL_FLUSH_TIMEOUT)
-      @partial_traces = []
+  module ContextFlush
+    # Consumes only completed traces (where all spans have finished)
+    class Finished
+      # Consumes and returns completed traces (where all spans have finished)
+      # from the provided +context+, if any.
+      #
+      # Any traces consumed are removed from +context+ as a side effect.
+      #
+      # @return [Array<Span>] trace to be flushed, or +nil+ if the trace is not finished
+      def consume!(context)
+        trace, sampled = context.get
+        trace if sampled
+      end
     end
 
-    def add_children(m, spans, ids, leaf)
-      spans << leaf
-      ids.add(leaf.span_id)
+    # Performs partial trace flushing to avoid large traces residing in memory for too long
+    class Partial
+      # Start flushing partial trace after this many active spans in one trace
+      DEFAULT_MIN_SPANS_FOR_PARTIAL_FLUSH = 500
 
-      if m[leaf.span_id]
-        m[leaf.span_id].each do |sub|
-          add_children(m, spans, ids, sub)
-        end
+      def initialize(options = {})
+        @min_spans_for_partial = options.fetch(:min_spans_before_partial_flush, DEFAULT_MIN_SPANS_FOR_PARTIAL_FLUSH)
       end
-    end
 
-    def partial_traces(context)
-      # 1st step, taint all parents of an unfinished span as unflushable
-      unflushable_ids = Set.new
+      # Consumes and returns completed or partially completed
+      # traces from the provided +context+, if any.
+      #
+      # Partially completed traces, where not all spans have finished,
+      # will only be returned if there are at least
+      # +@min_spans_for_partial+ finished spans.
+      #
+      # Any spans consumed are removed from +context+ as a side effect.
+      #
+      # @return [Array<Span>] partial or complete trace to be flushed, or +nil+ if no spans are finished
+      def consume!(context)
+        trace, sampled = context.get
 
-      context.send(:each_span) do |span|
-        next if span.finished? || unflushable_ids.include?(span.span_id)
-        unflushable_ids.add span.span_id
-        while span.parent
-          span = span.parent
-          unflushable_ids.add span.span_id
-        end
-      end
+        return nil unless sampled
+        return trace if trace && !trace.empty?
 
-      # 2nd step, find all spans which are at the border between flushable and unflushable
-      # Along the road, collect a reverse-tree which allows direct walking from parents to
-      # children but only for the ones we're interested it.
-      roots = []
-      children_map = {}
-      context.send(:each_span) do |span|
-        # There's no point in trying to put the real root in those partial roots, if
-        # it's flushable, the default algorithm would figure way more quickly.
-        if span.parent && !unflushable_ids.include?(span.span_id)
-          if unflushable_ids.include?(span.parent.span_id)
-            # span is flushable but is parent is not
-            roots << span
-          else
-            # span is flushable and its parent is too, build the reverse
-            # parent to child map for this one, it will be useful
-            children_map[span.parent.span_id] ||= []
-            children_map[span.parent.span_id] << span
-          end
-        end
+        partial_trace(context)
       end
 
-      # 3rd step, find all children, as this can be costly, only perform it for partial roots
-      partial_traces = []
-      all_ids = Set.new
-      roots.each do |root|
-        spans = []
-        add_children(children_map, spans, all_ids, root)
-        partial_traces << spans
-      end
+      private
 
-      return [nil, nil] if partial_traces.empty?
-      [partial_traces, all_ids]
-    end
+      def partial_trace(context)
+        return nil if context.finished_span_count < @min_spans_for_partial
+
+        finished_spans(context)
+      end
 
-    def partial_flush(context)
-      traces, flushed_ids = partial_traces(context)
-      return nil unless traces && flushed_ids
+      def finished_spans(context)
+        trace = context.delete_span_if(&:finished?)
 
-      # We need to reject by span ID and not by value, because a span
-      # value may be altered (typical example: it's finished by some other thread)
-      # since we lock only the context, not all the spans which belong to it.
-      context.send(:delete_span_if) { |span| flushed_ids.include? span.span_id }
-      traces
-    end
+        # Ensure that the first span in a partial trace has
+        # sampling and origin information.
+        if trace[0]
+          context.annotate_for_flush!(trace[0])
+        else
+          Datadog::Tracer.log.debug('Tried to retrieve trace from context, but got nothing. ' \
+            "Is there another consumer for this context? #{context.trace_id}")
+        end
 
-    # Performs an operation which each partial trace it can get from the context.
-    def each_partial_trace(context)
-      start_time = context.send(:start_time)
-      length = context.send(:length)
-      # Stop and do not flush anything if there are not enough spans.
-      return if length <= @min_spans_before_partial_flush
-      # If there are enough spans, but not too many, check for start time.
-      # If timeout is not given or 0, then wait
-      return if length <= @max_spans_before_partial_flush &&
-                (@partial_flush_timeout.nil? || @partial_flush_timeout <= 0 ||
-                 (start_time && start_time > Time.now.utc - @partial_flush_timeout))
-      # Here, either the trace is old or we have too many spans, flush it.
-      traces = partial_flush(context)
-      return unless traces
-      traces.each do |trace|
-        yield trace
+        trace unless trace.empty?
       end
     end
-
-    private :add_children
-    private :partial_traces
-    private :partial_flush
   end
 end