ls-trace 0.1.2 → 0.2.0

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.logger.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

data/lib/ddtrace/context_provider.rb

@@ -0,0 +1,50 @@
+module Datadog
+  # DefaultContextProvider is a default context provider that retrieves
+  # all contexts from the current thread-local storage. It is suitable for
+  # synchronous programming.
+  class DefaultContextProvider
+    # Initializes the default context provider with a thread-bound context.
+    def initialize
+      @context = ThreadLocalContext.new
+    end
+
+    # Sets the current context.
+    def context=(ctx)
+      @context.local = ctx
+    end
+
+    # Return the current context.
+    def context
+      @context.local
+    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.
+    #
+    # To support multiple tracers simultaneously, each \ThreadLocalContext
+    # instance has its own thread-local variable.
+    def initialize
+      @key = "datadog_context_#{object_id}".to_sym
+
+      self.local = Datadog::Context.new
+    end
+
+    # Override the thread-local context with a new context.
+    def local=(ctx)
+      Thread.current[@key] = ctx
+    end
+
+    # Return the thread-local context.
+    def local
+      Thread.current[@key] ||= Datadog::Context.new
+    end
+  end
+end

data/lib/ddtrace/contrib/action_cable/configuration/settings.rb

@@ -0,0 +1,30 @@
+require 'ddtrace/contrib/configuration/settings'
+require 'ddtrace/contrib/action_cable/ext'
+
+module Datadog
+  module Contrib
+    module ActionCable
+      module Configuration
+        # Custom settings for the ActionCable integration
+        class Settings < Contrib::Configuration::Settings
+          option :enabled do |o|
+            o.default { env_to_bool(Ext::ENV_ENABLED, true) }
+            o.lazy
+          end
+
+          option :analytics_enabled do |o|
+            o.default { env_to_bool([Ext::ENV_ANALYTICS_ENABLED, Ext::ENV_ANALYTICS_ENABLED_OLD], false) }
+            o.lazy
+          end
+
+          option :analytics_sample_rate do |o|
+            o.default { env_to_float([Ext::ENV_ANALYTICS_SAMPLE_RATE, Ext::ENV_ANALYTICS_SAMPLE_RATE_OLD], 1.0) }
+            o.lazy
+          end
+
+          option :service_name, default: Ext::SERVICE_NAME
+        end
+      end
+    end
+  end
+end

data/lib/ddtrace/contrib/action_cable/event.rb

@@ -0,0 +1,65 @@
+require 'ddtrace/contrib/analytics'
+require 'ddtrace/contrib/active_support/notifications/event'
+require 'ddtrace/contrib/action_cable/ext'
+
+module Datadog
+  module Contrib
+    module ActionCable
+      # Defines basic behaviors for an event.
+      module Event
+        def self.included(base)
+          base.send(:include, ActiveSupport::Notifications::Event)
+          base.send(:extend, ClassMethods)
+        end
+
+        # Class methods for events.
+        module ClassMethods
+          def span_options
+            { service: configuration[:service_name] }
+          end
+
+          def tracer
+            -> { configuration[:tracer] }
+          end
+
+          def configuration
+            Datadog.configuration[:action_cable]
+          end
+        end
+      end
+
+      # Defines behavior for the first event of a thread execution.
+      #
+      # This event is not expected to be nested with other event,
+      # but to start a fresh tracing context.
+      module RootContextEvent
+        def self.included(base)
+          base.send(:include, ActiveSupport::Notifications::Event)
+          base.send(:extend, ClassMethods)
+        end
+
+        # Class methods for events.
+        module ClassMethods
+          include Contrib::ActionCable::Event::ClassMethods
+
+          def subscription(*args)
+            super.tap do |subscription|
+              subscription.before_trace { ensure_clean_context! }
+            end
+          end
+
+          private
+
+          # Context objects are thread-bound.
+          # If an integration re-uses threads, context from a previous trace
+          # could leak into the new trace. This "cleans" current context,
+          # preventing such a leak.
+          def ensure_clean_context!
+            return unless configuration[:tracer].call_context.current_span
+            configuration[:tracer].provider.context = Context.new
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ddtrace/contrib/action_cable/events.rb

@@ -0,0 +1,33 @@
+require 'ddtrace/contrib/action_cable/event'
+require 'ddtrace/contrib/action_cable/events/broadcast'
+require 'ddtrace/contrib/action_cable/events/perform_action'
+require 'ddtrace/contrib/action_cable/events/transmit'
+
+module Datadog
+  module Contrib
+    module ActionCable
+      # Defines collection of instrumented ActionCable events
+      module Events
+        ALL = [
+          Events::Broadcast,
+          Events::PerformAction,
+          Events::Transmit
+        ].freeze
+
+        module_function
+
+        def all
+          self::ALL
+        end
+
+        def subscriptions
+          all.collect(&:subscriptions).collect(&:to_a).flatten
+        end
+
+        def subscribe!
+          all.each(&:subscribe!)
+        end
+      end
+    end
+  end
+end

data/lib/ddtrace/contrib/action_cable/events/broadcast.rb

@@ -0,0 +1,49 @@
+require 'ddtrace/contrib/analytics'
+require 'ddtrace/contrib/action_cable/event'
+
+module Datadog
+  module Contrib
+    module ActionCable
+      module Events
+        # Defines instrumentation for 'broadcast.action_cable' event.
+        #
+        # A single 'broadcast' event will trigger as many 'transmit' events
+        # as there are clients subscribed to a channel.
+        module Broadcast
+          include ActionCable::Event
+
+          EVENT_NAME = 'broadcast.action_cable'.freeze
+
+          module_function
+
+          def event_name
+            self::EVENT_NAME
+          end
+
+          def span_name
+            Ext::SPAN_BROADCAST
+          end
+
+          def span_type
+            # Starts a broadcast of messages over WebSockets
+            Datadog::Ext::AppTypes::WEB
+          end
+
+          def process(span, _event, _id, payload)
+            channel = payload[:broadcasting] # Channel has high cardinality
+            span.service = configuration[:service_name]
+            span.span_type = span_type
+
+            # Set analytics sample rate
+            if Contrib::Analytics.enabled?(configuration[:analytics_enabled])
+              Contrib::Analytics.set_sample_rate(span, configuration[:analytics_sample_rate])
+            end
+
+            span.set_tag(Ext::TAG_CHANNEL, channel)
+            span.set_tag(Ext::TAG_BROADCAST_CODER, payload[:coder])
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ddtrace/contrib/action_cable/events/perform_action.rb

@@ -0,0 +1,55 @@
+require 'ddtrace/contrib/analytics'
+require 'ddtrace/contrib/action_cable/event'
+
+module Datadog
+  module Contrib
+    module ActionCable
+      module Events
+        # Defines instrumentation for 'perform_action.action_cable' event.
+        #
+        # An action, triggered by a WebSockets client, invokes a method
+        # in the server's channel instance.
+        module PerformAction
+          include ActionCable::RootContextEvent
+
+          EVENT_NAME = 'perform_action.action_cable'.freeze
+
+          module_function
+
+          def event_name
+            self::EVENT_NAME
+          end
+
+          def span_name
+            Ext::SPAN_ACTION
+          end
+
+          def span_type
+            # A request to perform_action comes from a WebSocket connection
+            Datadog::Ext::AppTypes::WEB
+          end
+
+          def process(span, _event, _id, payload)
+            channel_class = payload[:channel_class]
+            action = payload[:action]
+
+            span.service = configuration[:service_name]
+            span.resource = "#{channel_class}##{action}"
+            span.span_type = span_type
+
+            # Set analytics sample rate
+            if Contrib::Analytics.enabled?(configuration[:analytics_enabled])
+              Contrib::Analytics.set_sample_rate(span, configuration[:analytics_sample_rate])
+            end
+
+            # Measure service stats
+            Contrib::Analytics.set_measured(span)
+
+            span.set_tag(Ext::TAG_CHANNEL_CLASS, channel_class)
+            span.set_tag(Ext::TAG_ACTION, action)
+          end
+        end
+      end
+    end
+  end
+end