ls-trace 0.1.1

data/lib/ddtrace/context.rb

@@ -0,0 +1,284 @@
+require 'thread'
+
+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
+          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
+          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?
+        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?
+          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 check_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, nil 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.
+    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()
+
+        reset
+        [trace, sampled]
+      end
+    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
+    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 check_finished_spans
+      @finished_spans > 0 && @trace.length == @finished_spans
+    end
+
+    def attach_sampling_priority
+      @current_root_span.set_metric(
+        Ext::DistributedTracing::SAMPLING_PRIORITY_KEY,
+        @sampling_priority
+      )
+    end
+
+    def attach_origin
+      @current_root_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
+
+    # 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

@@ -0,0 +1,132 @@
+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 = []
+    end
+
+    def add_children(m, spans, ids, leaf)
+      spans << leaf
+      ids.add(leaf.span_id)
+
+      if m[leaf.span_id]
+        m[leaf.span_id].each do |sub|
+          add_children(m, spans, ids, sub)
+        end
+      end
+    end
+
+    def partial_traces(context)
+      # 1st step, taint all parents of an unfinished span as unflushable
+      unflushable_ids = Set.new
+
+      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
+
+      # 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
+      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
+
+      return [nil, nil] if partial_traces.empty?
+      [partial_traces, all_ids]
+    end
+
+    def partial_flush(context)
+      traces, flushed_ids = partial_traces(context)
+      return nil unless traces && flushed_ids
+
+      # 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
+
+    # 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
+      end
+    end
+
+    private :add_children
+    private :partial_traces
+    private :partial_flush
+  end
+end

data/lib/ddtrace/contrib/action_pack/action_controller/instrumentation.rb

@@ -0,0 +1,144 @@
+require 'ddtrace/ext/http'
+
+require 'ddtrace/contrib/action_pack/ext'
+require 'ddtrace/contrib/action_pack/utils'
+require 'ddtrace/contrib/rack/middlewares'
+
+module Datadog
+  module Contrib
+    module ActionPack
+      module ActionController
+        # Instrumentation for ActionController components
+        module Instrumentation
+          module_function
+
+          def start_processing(payload)
+            # trace the execution
+            tracer = Datadog.configuration[:action_pack][:tracer]
+            service = Datadog.configuration[:action_pack][:controller_service]
+            type = Datadog::Ext::HTTP::TYPE_INBOUND
+            span = tracer.trace(Ext::SPAN_ACTION_CONTROLLER, service: service, span_type: type)
+
+            # attach the current span to the tracing context
+            tracing_context = payload.fetch(:tracing_context)
+            tracing_context[:dd_request_span] = span
+          rescue StandardError => e
+            Datadog::Tracer.log.error(e.message)
+          end
+
+          def finish_processing(payload)
+            # retrieve the tracing context and the latest active span
+            tracing_context = payload.fetch(:tracing_context)
+            env = payload.fetch(:env)
+            span = tracing_context[:dd_request_span]
+            return unless span && !span.finished?
+
+            begin
+              # Set the resource name, if it's still the default name
+              if span.resource == span.name
+                span.resource = "#{payload.fetch(:controller)}##{payload.fetch(:action)}"
+              end
+
+              # Set the resource name of the Rack request span unless this is an exception controller.
+              unless exception_controller?(payload)
+                rack_request_span = env[Datadog::Contrib::Rack::TraceMiddleware::RACK_REQUEST_SPAN]
+                rack_request_span.resource = span.resource if rack_request_span
+              end
+
+              # Set analytics sample rate
+              Utils.set_analytics_sample_rate(span)
+
+              # Associate with runtime metrics
+              Datadog.runtime_metrics.associate_with_span(span)
+
+              span.set_tag(Ext::TAG_ROUTE_ACTION, payload.fetch(:action))
+              span.set_tag(Ext::TAG_ROUTE_CONTROLLER, payload.fetch(:controller))
+
+              exception = payload[:exception_object]
+              if exception.nil?
+                # [christian] in some cases :status is not defined,
+                # rather than firing an error, simply acknowledge we don't know it.
+                status = payload.fetch(:status, '?').to_s
+                span.status = 1 if status.starts_with?('5')
+              elsif Utils.exception_is_error?(exception)
+                span.set_error(exception)
+              end
+            ensure
+              span.finish
+            end
+          rescue StandardError => e
+            Datadog::Tracer.log.error(e.message)
+          end
+
+          def exception_controller?(payload)
+            exception_controller_class = Datadog.configuration[:action_pack][:exception_controller]
+            controller = payload.fetch(:controller)
+            headers = payload.fetch(:headers)
+
+            # If no exception controller class has been set,
+            # guess whether this is an exception controller from the headers.
+            if exception_controller_class.nil?
+              !headers[:request_exception].nil?
+            # If an exception controller class has been specified,
+            # check if the controller is a kind of the exception controller class.
+            elsif exception_controller_class.is_a?(Class) || exception_controller_class.is_a?(Module)
+              controller <= exception_controller_class
+            # Otherwise if the exception controller class is some other value (like false)
+            # assume that this controller doesn't handle exceptions.
+            else
+              false
+            end
+          end
+
+          # Instrumentation for ActionController::Metal
+          module Metal
+            def process_action(*args)
+              # mutable payload with a tracing context that is used in two different
+              # signals; it propagates the request span so that it can be finished
+              # no matter what
+              payload = {
+                controller: self.class,
+                action: action_name,
+                env: request.env,
+                headers: {
+                  # The exception this controller was given in the request,
+                  # which is typical if the controller is configured to handle exceptions.
+                  request_exception: request.headers['action_dispatch.exception']
+                },
+                tracing_context: {}
+              }
+
+              begin
+                # process and catch request exceptions
+                Instrumentation.start_processing(payload)
+                result = super(*args)
+                status = datadog_response_status
+                payload[:status] = status unless status.nil?
+                result
+              # rubocop:disable Lint/RescueException
+              rescue Exception => e
+                payload[:exception] = [e.class.name, e.message]
+                payload[:exception_object] = e
+                raise e
+              end
+            # rubocop:enable Lint/RescueException
+            ensure
+              Instrumentation.finish_processing(payload)
+            end
+
+            def datadog_response_status
+              case response
+              when ::ActionDispatch::Response
+                response.status
+              when Array
+                # Likely a Rack response array: first element is the status.
+                status = response.first
+                status.class <= Integer ? status : nil
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end