ddtrace 0.49.0 → 1.12.1

data/lib/ddtrace/opentracer/propagator.rb

@@ -1,22 +0,0 @@
-module Datadog
-  module OpenTracer
-    # OpenTracing propagator for Datadog::OpenTracer::Tracer
-    module Propagator
-      # Inject a SpanContext into the given carrier
-      #
-      # @param span_context [SpanContext]
-      # @param carrier [Carrier] A carrier object of the type dictated by the specified `format`
-      def inject(span_context, carrier)
-        raise NotImplementedError
-      end
-
-      # Extract a SpanContext in the given format from the given carrier.
-      #
-      # @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(carrier)
-        raise NotImplementedError
-      end
-    end
-  end
-end

data/lib/ddtrace/opentracer/rack_propagator.rb

@@ -1,60 +0,0 @@
-require 'ddtrace/propagation/http_propagator'
-
-module Datadog
-  module OpenTracer
-    # OpenTracing propagator for Datadog::OpenTracer::Tracer
-    module RackPropagator
-      extend Propagator
-      extend Datadog::Ext::DistributedTracing
-      include Datadog::Ext::DistributedTracing
-
-      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)
-          # Inject Datadog trace properties
-          Datadog::HTTPPropagator.inject!(span_context.datadog_context, 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_context = Datadog::HTTPPropagator.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: datadog_context, 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/ddtrace/opentracer/scope.rb

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

data/lib/ddtrace/opentracer/scope_manager.rb

@@ -1,6 +0,0 @@
-module Datadog
-  module OpenTracer
-    class ScopeManager < ::OpenTracing::ScopeManager
-    end
-  end
-end

data/lib/ddtrace/opentracer/span.rb

@@ -1,94 +0,0 @@
-module Datadog
-  module OpenTracer
-    # OpenTracing adapter for Datadog::Span
-    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::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/ddtrace/opentracer/span_context.rb

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

data/lib/ddtrace/opentracer/span_context_factory.rb

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

data/lib/ddtrace/opentracer/text_map_propagator.rb

@@ -1,75 +0,0 @@
-require 'ddtrace/ext/distributed'
-
-module Datadog
-  module OpenTracer
-    # OpenTracing propagator for Datadog::OpenTracer::Tracer
-    module TextMapPropagator
-      extend Propagator
-      extend Datadog::Ext::DistributedTracing
-      include Datadog::Ext::DistributedTracing
-
-      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 Datadog trace properties
-          span_context.datadog_context.tap do |datadog_context|
-            carrier[HTTP_HEADER_TRACE_ID] = datadog_context.trace_id
-            carrier[HTTP_HEADER_PARENT_ID] = datadog_context.span_id
-            carrier[HTTP_HEADER_SAMPLING_PRIORITY] = datadog_context.sampling_priority
-            carrier[HTTP_HEADER_ORIGIN] = datadog_context.origin
-          end
-
-          # Inject baggage
-          span_context.baggage.each do |key, value|
-            carrier[BAGGAGE_PREFIX + key] = value
-          end
-
-          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_context = if headers.valid?
-                              Datadog::Context.new(
-                                trace_id: headers.trace_id,
-                                span_id: headers.parent_id,
-                                sampling_priority: headers.sampling_priority,
-                                origin: headers.origin
-                              )
-                            else
-                              Datadog::Context.new
-                            end
-
-          # 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: datadog_context, baggage: baggage)
-        end
-
-        private
-
-        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/ddtrace/opentracer/thread_local_scope.rb

@@ -1,31 +0,0 @@
-module Datadog
-  module OpenTracer
-    # OpenTracing adapter for thread local scopes
-    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/ddtrace/opentracer/thread_local_scope_manager.rb

@@ -1,40 +0,0 @@
-module Datadog
-  module OpenTracer
-    # OpenTracing adapter for thread local scope management
-    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/ddtrace/opentracer/tracer.rb

@@ -1,208 +0,0 @@
-require 'ddtrace/tracer'
-
-module Datadog
-  module OpenTracer
-    # OpenTracing adapter for Datadog::Tracer
-    class Tracer < ::OpenTracing::Tracer
-      extend Forwardable
-
-      attr_reader \
-        :datadog_tracer
-
-      def_delegators \
-        :datadog_tracer,
-        :configure
-
-      def initialize(options = {})
-        super()
-        @datadog_tracer = Datadog::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 the Tracer's ScopeManager#active is not nil, no explicit references
-      # are provided, and `ignore_active_scope` is false, then an inferred
-      # References#CHILD_OF reference is created to the ScopeManager#active's
-      # SpanContext when start_active 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 [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.
-      # @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.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.datadog_span.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? ? nil : parent_span_context.datadog_context
-
-        # Build the new Datadog span
-        datadog_span = datadog_tracer.start_span(
-          operation_name,
-          child_of: 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_span.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/ddtrace/opentracer.rb

@@ -1,40 +0,0 @@
-module Datadog
-  # Namespace for ddtrace OpenTracing implementation
-  module OpenTracer
-    module_function
-
-    def supported?
-      Gem::Version.new(RUBY_VERSION) >= Gem::Version.new('2.1')
-    end
-
-    def load_opentracer
-      require 'opentracing'
-      require 'opentracing/carrier'
-      require 'ddtrace'
-      require 'ddtrace/opentracer/carrier'
-      require 'ddtrace/opentracer/tracer'
-      require 'ddtrace/opentracer/span'
-      require 'ddtrace/opentracer/span_context'
-      require 'ddtrace/opentracer/span_context_factory'
-      require 'ddtrace/opentracer/scope'
-      require 'ddtrace/opentracer/scope_manager'
-      require 'ddtrace/opentracer/thread_local_scope'
-      require 'ddtrace/opentracer/thread_local_scope_manager'
-      require 'ddtrace/opentracer/distributed_headers'
-      require 'ddtrace/opentracer/propagator'
-      require 'ddtrace/opentracer/text_map_propagator'
-      require 'ddtrace/opentracer/binary_propagator'
-      require 'ddtrace/opentracer/rack_propagator'
-      require 'ddtrace/opentracer/global_tracer'
-
-      # Modify the OpenTracing module functions
-      OpenTracing.module_eval do
-        class << self
-          prepend Datadog::OpenTracer::GlobalTracer
-        end
-      end
-    end
-
-    load_opentracer if supported?
-  end
-end