ddtrace 0.54.2 → 1.0.0

data/lib/datadog/opentracer/rack_propagator.rb

@@ -0,0 +1,72 @@
+# typed: true
+
+require 'datadog/tracing/context'
+require 'datadog/tracing/distributed/headers/ext'
+require 'datadog/tracing/propagation/http'
+require 'datadog/tracing/trace_operation'
+require 'datadog/opentracer/propagator'
+
+module Datadog
+  module OpenTracer
+    # OpenTracing propagator for Datadog::OpenTracer::Tracer
+    module RackPropagator
+      extend Propagator
+      extend Tracing::Distributed::Headers::Ext
+      include Tracing::Distributed::Headers::Ext
+
+      BAGGAGE_PREFIX = 'ot-baggage-'.freeze
+      BAGGAGE_PREFIX_FORMATTED = 'HTTP_OT_BAGGAGE_'.freeze
+
+      class << self
+        # Inject a SpanContext into the given carrier
+        #
+        # @param span_context [SpanContext]
+        # @param carrier [Carrier] A carrier object of Rack type
+        def inject(span_context, carrier)
+          active_trace = span_context.datadog_context.active_trace
+
+          # Inject Datadog trace properties
+          Tracing::Propagation::HTTP.inject!(active_trace, carrier)
+
+          # Inject baggage
+          span_context.baggage.each do |key, value|
+            carrier[BAGGAGE_PREFIX + key] = value
+          end
+
+          nil
+        end
+
+        # Extract a SpanContext in Rack format from the given carrier.
+        #
+        # @param carrier [Carrier] A carrier object of Rack type
+        # @return [SpanContext, nil] the extracted SpanContext or nil if none could be found
+        def extract(carrier)
+          # First extract & build a Datadog context
+          datadog_trace_digest = Tracing::Propagation::HTTP.extract(carrier)
+
+          # Then extract any other baggage
+          baggage = {}
+          carrier.each do |key, value|
+            baggage[header_to_baggage(key)] = value if baggage_header?(key)
+          end
+
+          SpanContextFactory.build(
+            datadog_context: nil,
+            datadog_trace_digest: datadog_trace_digest,
+            baggage: baggage
+          )
+        end
+
+        private
+
+        def baggage_header?(header)
+          header.to_s.start_with?(BAGGAGE_PREFIX_FORMATTED)
+        end
+
+        def header_to_baggage(key)
+          key[BAGGAGE_PREFIX_FORMATTED.length, key.length].downcase
+        end
+      end
+    end
+  end
+end

data/lib/datadog/opentracer/scope.rb

@@ -0,0 +1,18 @@
+# typed: true
+
+module Datadog
+  module OpenTracer
+    # OpenTracing adapter for scope
+    # @public_api
+    class Scope < ::OpenTracing::Scope
+      attr_reader \
+        :manager,
+        :span
+
+      def initialize(manager:, span:)
+        @manager = manager
+        @span = span
+      end
+    end
+  end
+end

data/lib/datadog/opentracer/scope_manager.rb

@@ -0,0 +1,9 @@
+# typed: strict
+
+module Datadog
+  module OpenTracer
+    # @public_api
+    class ScopeManager < ::OpenTracing::ScopeManager
+    end
+  end
+end

data/lib/datadog/opentracer/span.rb

@@ -0,0 +1,101 @@
+# typed: true
+
+require 'time'
+
+require 'datadog/tracing/metadata/ext'
+
+module Datadog
+  module OpenTracer
+    # OpenTracing adapter for Datadog::Span
+    # @public_api
+    class Span < ::OpenTracing::Span
+      attr_reader \
+        :datadog_span
+
+      def initialize(datadog_span:, span_context:)
+        @datadog_span = datadog_span
+        @span_context = span_context
+      end
+
+      # Set the name of the operation
+      #
+      # @param [String] name
+      def operation_name=(name)
+        datadog_span.name = name
+      end
+
+      # Span Context
+      #
+      # @return [SpanContext]
+      def context
+        @span_context
+      end
+
+      # Set a tag value on this span
+      # @param key [String] the key of the tag
+      # @param value [String, Numeric, Boolean] the value of the tag. If it's not
+      # a String, Numeric, or Boolean it will be encoded with to_s
+      def set_tag(key, value)
+        # Special cases to convert opentracing tags to datadog tags
+        case key
+        when 'error'
+          # Opentracing supports and `error: <bool>` tag, we need to convert to span status
+          # DEV: Do not return, we want to still set the `error` tag as they requested
+          datadog_span.status = value ? Datadog::Tracing::Metadata::Ext::Errors::STATUS : 0
+        end
+
+        tap { datadog_span.set_tag(key, value) }
+      end
+
+      # Set a baggage item on the span
+      # @param key [String] the key of the baggage item
+      # @param value [String] the value of the baggage item
+      def set_baggage_item(key, value)
+        tap do
+          # SpanContext is immutable, so to make changes
+          # build a new span context.
+          @span_context = SpanContextFactory.clone(
+            span_context: context,
+            baggage: { key => value }
+          )
+        end
+      end
+
+      # Get a baggage item
+      # @param key [String] the key of the baggage item
+      # @return [String] value of the baggage item
+      def get_baggage_item(key)
+        context.baggage[key]
+      end
+
+      # @deprecated Use {#log_kv} instead.
+      # Reason: event is an optional standard log field defined in spec and not required.  Also,
+      # method name {#log_kv} is more consistent with other language implementations such as Python and Go.
+      #
+      # Add a log entry to this span
+      # @param event [String] event name for the log
+      # @param timestamp [Time] time of the log
+      # @param fields [Hash] Additional information to log
+      def log(event: nil, timestamp: Time.now, **fields)
+        super # Log deprecation warning
+
+        # If the fields specify an error
+        datadog_span.set_error(fields[:'error.object']) if fields.key?(:'error.object')
+      end
+
+      # Add a log entry to this span
+      # @param timestamp [Time] time of the log
+      # @param fields [Hash] Additional information to log
+      def log_kv(timestamp: Time.now, **fields)
+        # If the fields specify an error
+        datadog_span.set_error(fields[:'error.object']) if fields.key?(:'error.object')
+      end
+
+      # Finish the {Span}
+      # @param end_time [Time] custom end time, if not now
+      def finish(end_time: Time.now)
+        datadog_span.finish(end_time)
+      end
+    end
+  end
+end

data/lib/datadog/opentracer/span_context.rb

@@ -0,0 +1,19 @@
+# typed: true
+
+module Datadog
+  module OpenTracer
+    # OpenTracing adapter for SpanContext
+    # @public_api
+    class SpanContext < ::OpenTracing::SpanContext
+      attr_reader \
+        :datadog_context,
+        :datadog_trace_digest
+
+      def initialize(datadog_context:, datadog_trace_digest: nil, baggage: {})
+        @datadog_context = datadog_context
+        @datadog_trace_digest = datadog_trace_digest
+        @baggage = baggage.freeze
+      end
+    end
+  end
+end

data/lib/datadog/opentracer/span_context_factory.rb

@@ -0,0 +1,27 @@
+# typed: true
+
+module Datadog
+  module OpenTracer
+    # Creates new Datadog::OpenTracer::SpanContext
+    module SpanContextFactory
+      module_function
+
+      def build(datadog_context:, datadog_trace_digest: nil, baggage: {})
+        SpanContext.new(
+          datadog_context: datadog_context,
+          datadog_trace_digest: datadog_trace_digest,
+          baggage: baggage.dup
+        )
+      end
+
+      def clone(span_context:, baggage: {})
+        SpanContext.new(
+          datadog_context: span_context.datadog_context,
+          datadog_trace_digest: span_context.datadog_trace_digest,
+          # Merge baggage from previous SpanContext
+          baggage: span_context.baggage.merge(baggage)
+        )
+      end
+    end
+  end
+end

data/lib/datadog/opentracer/text_map_propagator.rb

@@ -0,0 +1,87 @@
+# typed: true
+
+require 'datadog/tracing/context'
+require 'datadog/tracing/distributed/headers/ext'
+require 'datadog/tracing/trace_operation'
+require 'datadog/opentracer/propagator'
+
+module Datadog
+  module OpenTracer
+    # OpenTracing propagator for Datadog::OpenTracer::Tracer
+    module TextMapPropagator
+      extend Propagator
+      extend Tracing::Distributed::Headers::Ext
+      include Tracing::Distributed::Headers::Ext
+
+      BAGGAGE_PREFIX = 'ot-baggage-'.freeze
+
+      class << self
+        # Inject a SpanContext into the given carrier
+        #
+        # @param span_context [SpanContext]
+        # @param carrier [Carrier] A carrier object of Rack type
+        def inject(span_context, carrier)
+          # Inject baggage
+          span_context.baggage.each do |key, value|
+            carrier[BAGGAGE_PREFIX + key] = value
+          end
+
+          # Inject Datadog trace properties
+          active_trace = span_context.datadog_context.active_trace
+          digest = active_trace.to_digest if active_trace
+          return unless digest
+
+          carrier[HTTP_HEADER_ORIGIN] = digest.trace_origin
+          carrier[HTTP_HEADER_PARENT_ID] = digest.span_id
+          carrier[HTTP_HEADER_SAMPLING_PRIORITY] = digest.trace_sampling_priority
+          carrier[HTTP_HEADER_TRACE_ID] = digest.trace_id
+
+          nil
+        end
+
+        # Extract a SpanContext in TextMap format from the given carrier.
+        #
+        # @param carrier [Carrier] A carrier object of TextMap type
+        # @return [SpanContext, nil] the extracted SpanContext or nil if none could be found
+        def extract(carrier)
+          # First extract & build a Datadog context
+          headers = DistributedHeaders.new(carrier)
+          datadog_trace_digest = headers_to_trace_digest(headers)
+
+          # Then extract any other baggage
+          baggage = {}
+          carrier.each do |key, value|
+            baggage[item_to_baggage(key)] = value if baggage_item?(key)
+          end
+
+          SpanContextFactory.build(
+            datadog_context: nil,
+            datadog_trace_digest: datadog_trace_digest,
+            baggage: baggage
+          )
+        end
+
+        private
+
+        def headers_to_trace_digest(headers)
+          return unless headers.valid?
+
+          Datadog::Tracing::TraceDigest.new(
+            span_id: headers.parent_id,
+            trace_id: headers.trace_id,
+            trace_origin: headers.origin,
+            trace_sampling_priority: headers.sampling_priority
+          )
+        end
+
+        def baggage_item?(item)
+          item.to_s.start_with?(BAGGAGE_PREFIX)
+        end
+
+        def item_to_baggage(key)
+          key[BAGGAGE_PREFIX.length, key.length]
+        end
+      end
+    end
+  end
+end

data/lib/datadog/opentracer/thread_local_scope.rb

@@ -0,0 +1,34 @@
+# typed: true
+
+module Datadog
+  module OpenTracer
+    # OpenTracing adapter for thread local scopes
+    # @public_api
+    class ThreadLocalScope < Scope
+      attr_reader \
+        :finish_on_close
+
+      def initialize(
+        manager:,
+        span:,
+        finish_on_close: true
+      )
+        super(manager: manager, span: span)
+        @finish_on_close = finish_on_close
+        @previous_scope = manager.active
+      end
+
+      # Mark the end of the active period for the current thread and Scope,
+      # updating the ScopeManager#active in the process.
+      #
+      # NOTE: Calling close more than once on a single Scope instance leads to
+      # undefined behavior.
+      def close
+        return unless equal?(manager.active)
+
+        span.finish if finish_on_close
+        manager.send(:set_scope, @previous_scope)
+      end
+    end
+  end
+end

data/lib/datadog/opentracer/thread_local_scope_manager.rb

@@ -0,0 +1,43 @@
+# typed: true
+
+module Datadog
+  module OpenTracer
+    # OpenTracing adapter for thread local scope management
+    # @public_api
+    class ThreadLocalScopeManager < ScopeManager
+      # Make a span instance active.
+      #
+      # @param span [Span] the Span that should become active
+      # @param finish_on_close [Boolean] whether the Span should automatically be
+      #   finished when Scope#close is called
+      # @return [Scope] instance to control the end of the active period for the
+      #  Span. It is a programming error to neglect to call Scope#close on the
+      #  returned instance.
+      def activate(span, finish_on_close: true)
+        ThreadLocalScope.new(
+          manager: self,
+          span: span,
+          finish_on_close: finish_on_close
+        ).tap do |scope|
+          set_scope(scope)
+        end
+      end
+
+      # @return [Scope] the currently active Scope which can be used to access the
+      # currently active Span.
+      #
+      # If there is a non-null Scope, its wrapped Span becomes an implicit parent
+      # (as Reference#CHILD_OF) of any newly-created Span at Tracer#start_active_span
+      # or Tracer#start_span time.
+      def active
+        Thread.current[object_id.to_s]
+      end
+
+      private
+
+      def set_scope(scope)
+        Thread.current[object_id.to_s] = scope
+      end
+    end
+  end
+end

data/lib/datadog/opentracer/tracer.rb

@@ -0,0 +1,214 @@
+# typed: false
+
+require 'time'
+
+require 'datadog/tracing/context'
+require 'datadog/tracing/tracer'
+
+module Datadog
+  module OpenTracer
+    # OpenTracing adapter for Datadog::Tracer
+    # @public_api
+    class Tracer < ::OpenTracing::Tracer
+      extend Forwardable
+
+      # (see Datadog::Tracer)
+      # @return [Datadog::Tracer]
+      attr_reader \
+        :datadog_tracer
+
+      # (see Datadog::Tracer#initialize)
+      def initialize(**options)
+        super()
+        @datadog_tracer = Datadog::Tracing::Tracer.new(**options)
+      end
+
+      # @return [ScopeManager] the current ScopeManager.
+      def scope_manager
+        @scope_manager ||= ThreadLocalScopeManager.new
+      end
+
+      # Returns a newly started and activated {Scope}.
+      #
+      # If `scope_manager.active` is not nil, no explicit references
+      # are provided, and `ignore_active_scope` is false, then an inferred
+      # {https://www.rubydoc.info/gems/opentracing/0.5.0/OpenTracing/Reference OpenTracing::Reference#CHILD_OF}
+      # reference is created to the `scope_manager.active`'s
+      # {SpanContext} when {#start_active_span} is invoked.
+      #
+      # @param operation_name [String] The operation name for the Span
+      # @param child_of [SpanContext, Span] SpanContext that acts as a parent to
+      #   the newly-started Span. If a Span instance is provided, its
+      #   context is automatically substituted. See [OpenTracing::Reference] for more
+      #   information.
+      #   If specified, the `references` parameter must be omitted.
+      # @param references [Array<OpenTracing::Reference>] An array of reference
+      #   objects that identify one or more parent SpanContexts.
+      # @param start_time [Time] When the Span started, if not now
+      # @param tags [Hash] Tags to assign to the Span at start time
+      # @param ignore_active_scope [Boolean] whether to create an implicit
+      #   OpenTracing::Reference#CHILD_OF reference to the ScopeManager#active.
+      # @param finish_on_close [Boolean] whether span should automatically be
+      #   finished when Scope#close is called
+      # @yield [Scope] If an optional block is passed to start_active it will
+      #   yield the newly-started Scope. If `finish_on_close` is true then the
+      #   Span will be finished automatically after the block is executed.
+      # @return [Scope] The newly-started and activated Scope
+      def start_active_span(operation_name,
+                            child_of: nil,
+                            references: nil,
+                            start_time: Time.now,
+                            tags: nil,
+                            ignore_active_scope: false,
+                            finish_on_close: true)
+
+        # When meant to automatically determine the parent,
+        # Use the active scope first, otherwise fall back to any
+        # context generated by Datadog, so as to append to it and gain
+        # the benefit of any out-of-the-box tracing from Datadog preceding
+        # the OpenTracer::Tracer.
+        #
+        # We do this here instead of in #start_span because #start_span generates
+        # spans that are not assigned to a scope, a.k.a not supposed to be used by
+        # subsequent spans implicitly. By using the existing Datadog context, the span
+        # effectively ends up "assigned to a scope", by virtue of being added to the
+        # Context. Hence, it would behave more like an active span, which is why it
+        # should only be here.
+        unless child_of || ignore_active_scope
+          child_of = if scope_manager.active
+                       scope_manager.active.span.context
+                     else
+                       SpanContextFactory.build(datadog_context: datadog_tracer.send(:call_context))
+                     end
+        end
+
+        # Create the span, and auto-add it to the Datadog context.
+        span = start_span(
+          operation_name,
+          child_of: child_of,
+          references: references,
+          start_time: start_time,
+          tags: tags,
+          ignore_active_scope: ignore_active_scope
+        )
+
+        # Overwrite the tracer context with the OpenTracing managed context.
+        # This is mostly for the benefit of any out-of-the-box tracing from Datadog,
+        # such that spans generated by that tracing will be attached to the OpenTracer
+        # parent span.
+        datadog_tracer.provider.context = span.context.datadog_context
+
+        scope_manager.activate(span, finish_on_close: finish_on_close).tap do |scope|
+          if block_given?
+            begin
+              yield(scope)
+            ensure
+              scope.close
+            end
+          end
+        end
+      end
+
+      # Like {#start_active_span}, but the returned {Span} has not been registered via the
+      # {ScopeManager}.
+      #
+      # @param operation_name [String] The operation name for the Span
+      # @param child_of [SpanContext, Span] SpanContext that acts as a parent to
+      #   the newly-started Span. If a Span instance is provided, its
+      #   context is automatically substituted. See [Reference] for more
+      #   information.
+      #   If specified, the `references` parameter must be omitted.
+      # @param references [Array<Reference>] An array of reference
+      #   objects that identify one or more parent SpanContexts.
+      # @param start_time [Time] When the Span started, if not now
+      # @param tags [Hash] Tags to assign to the Span at start time
+      # @param ignore_active_scope [Boolean] whether to create an implicit
+      #   References#CHILD_OF reference to the ScopeManager#active.
+      # @return [Span] the newly-started Span instance, which has not been
+      #   automatically registered via the ScopeManager
+      def start_span(operation_name,
+                     child_of: nil,
+                     references: nil,
+                     start_time: Time.now,
+                     tags: nil,
+                     ignore_active_scope: false)
+
+        # Derive the OpenTracer::SpanContext to inherit from.
+        parent_span_context = inherited_span_context(child_of, ignore_active_scope: ignore_active_scope)
+
+        # Retrieve Datadog::Context from parent SpanContext.
+        datadog_context = parent_span_context.nil? ? Datadog::Tracing::Context.new : parent_span_context.datadog_context
+        datadog_trace_digest = parent_span_context && parent_span_context.datadog_trace_digest
+
+        # Build the new Datadog span
+        datadog_span = datadog_tracer.trace(
+          operation_name,
+          continue_from: datadog_trace_digest,
+          _context: datadog_context,
+          start_time: start_time,
+          tags: tags || {}
+        )
+
+        # Build or extend the OpenTracer::SpanContext
+        span_context = if parent_span_context
+                         SpanContextFactory.clone(span_context: parent_span_context)
+                       else
+                         SpanContextFactory.build(datadog_context: datadog_context)
+                       end
+
+        # Wrap the Datadog span and OpenTracer::Span context in a OpenTracer::Span
+        Span.new(datadog_span: datadog_span, span_context: span_context)
+      end
+
+      # Inject a {SpanContext} into the given carrier.
+      #
+      # @param span_context [SpanContext]
+      # @param format [OpenTracing::FORMAT_TEXT_MAP, OpenTracing::FORMAT_BINARY, OpenTracing::FORMAT_RACK]
+      # @param carrier [Carrier] A carrier object of the type dictated by the specified `format`
+      def inject(span_context, format, carrier)
+        case format
+        when OpenTracing::FORMAT_TEXT_MAP
+          TextMapPropagator.inject(span_context, carrier)
+        when OpenTracing::FORMAT_BINARY
+          BinaryPropagator.inject(span_context, carrier)
+        when OpenTracing::FORMAT_RACK
+          RackPropagator.inject(span_context, carrier)
+        else
+          warn 'Unknown inject format'
+        end
+      end
+
+      # Extract a {SpanContext} in the given format from the given carrier.
+      #
+      # @param format [OpenTracing::FORMAT_TEXT_MAP, OpenTracing::FORMAT_BINARY, OpenTracing::FORMAT_RACK]
+      # @param carrier [Carrier] A carrier object of the type dictated by the specified `format`
+      # @return [SpanContext, nil] the extracted SpanContext or nil if none could be found
+      def extract(format, carrier)
+        case format
+        when OpenTracing::FORMAT_TEXT_MAP
+          TextMapPropagator.extract(carrier)
+        when OpenTracing::FORMAT_BINARY
+          BinaryPropagator.extract(carrier)
+        when OpenTracing::FORMAT_RACK
+          RackPropagator.extract(carrier)
+        else
+          warn 'Unknown extract format'
+          nil
+        end
+      end
+
+      private
+
+      def inherited_span_context(parent, ignore_active_scope: false)
+        case parent
+        when Span
+          parent.context
+        when SpanContext
+          parent
+        else
+          ignore_active_scope ? nil : scope_manager.active && scope_manager.active.span.context
+        end
+      end
+    end
+  end
+end

data/lib/datadog/opentracer.rb

@@ -0,0 +1,24 @@
+# typed: strict
+
+require 'opentracing'
+require 'opentracing/carrier'
+require 'datadog/tracing'
+
+require 'datadog/opentracer/carrier'
+require 'datadog/opentracer/tracer'
+require 'datadog/opentracer/span'
+require 'datadog/opentracer/span_context'
+require 'datadog/opentracer/span_context_factory'
+require 'datadog/opentracer/scope'
+require 'datadog/opentracer/scope_manager'
+require 'datadog/opentracer/thread_local_scope'
+require 'datadog/opentracer/thread_local_scope_manager'
+require 'datadog/opentracer/distributed_headers'
+require 'datadog/opentracer/propagator'
+require 'datadog/opentracer/text_map_propagator'
+require 'datadog/opentracer/binary_propagator'
+require 'datadog/opentracer/rack_propagator'
+require 'datadog/opentracer/global_tracer'
+
+# Modify the OpenTracing module functions
+::OpenTracing.singleton_class.prepend(Datadog::OpenTracer::GlobalTracer)

data/lib/datadog/profiling/backtrace_location.rb

@@ -0,0 +1,34 @@
+# typed: true
+
+module Datadog
+  module Profiling
+    # Entity class used to represent an entry in a stack trace.
+    # Its fields are a simplified struct version of `Thread::Backtrace::Location`.
+    class BacktraceLocation
+      attr_reader \
+        :base_label,
+        :lineno,
+        :path,
+        :hash
+
+      def initialize(
+        base_label,
+        lineno,
+        path
+      )
+        @base_label = base_label
+        @lineno = lineno
+        @path = path
+        @hash = [base_label, lineno, path].hash
+      end
+
+      def ==(other)
+        hash == other.hash
+      end
+
+      def eql?(other)
+        hash == other.hash
+      end
+    end
+  end
+end