ddtrace 0.54.2 → 1.10.1

data/lib/datadog/opentelemetry/sdk/span_processor.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+module Datadog
+  module OpenTelemetry
+    module SDK
+      # Keeps OpenTelemetry spans in sync with the Datadog execution context.
+      # Also responsible for flushing spans when their are finished.
+      class SpanProcessor
+        # Called when a {Span} is started, if the {Span#recording?}
+        # returns true.
+        #
+        # This method is called synchronously on the execution thread, should
+        # not throw or block the execution thread.
+        #
+        # @param [Span] span the {Span} that just started.
+        # @param [Context] parent_context the parent {Context} of the newly
+        #  started span.
+        def on_start(span, parent_context)
+          create_matching_datadog_span(span, parent_context)
+        end
+
+        # Called when a {Span} is ended, if the {Span#recording?}
+        # returns true.
+        #
+        # This method is called synchronously on the execution thread, should
+        # not throw or block the execution thread.
+        #
+        # @param [Span] span the {Span} that just ended.
+        def on_finish(span)
+          span.datadog_span.finish
+        end
+
+        # Export all ended spans to the configured `Exporter` that have not yet
+        # been exported.
+        #
+        # This method should only be called in cases where it is absolutely
+        # necessary, such as when using some FaaS providers that may suspend
+        # the process after an invocation, but before the `Processor` exports
+        # the completed spans.
+        #
+        # @param [optional Numeric] timeout An optional timeout in seconds.
+        # @return [Integer] Export::SUCCESS if no error occurred, Export::FAILURE if
+        #   a non-specific failure occurred, Export::TIMEOUT if a timeout occurred.
+        def force_flush(timeout: nil)
+          writer.force_flush(timeout: timeout) if writer.respond_to? :force_flush
+          Export::SUCCESS
+        end
+
+        # Called when {TracerProvider#shutdown} is called.
+        #
+        # @param [optional Numeric] timeout An optional timeout in seconds.
+        # @return [Integer] Export::SUCCESS if no error occurred, Export::FAILURE if
+        #   a non-specific failure occurred, Export::TIMEOUT if a timeout occurred.
+        def shutdown(timeout: nil)
+          writer.stop
+          Export::SUCCESS
+        end
+
+        private
+
+        def writer
+          Datadog.configuration.tracing.writer
+        end
+
+        def create_matching_datadog_span(span, parent_context)
+          if parent_context.trace
+            Tracing.send(:tracer).send(:call_context).activate!(parent_context.ensure_trace)
+          else
+            Tracing.continue_trace!(nil)
+          end
+
+          datadog_span = start_datadog_span(span)
+
+          span.datadog_span = datadog_span
+          span.datadog_trace = Tracing.active_trace
+        end
+
+        def start_datadog_span(span)
+          tags = span.resource.attribute_enumerator.to_h
+
+          kind = span.kind || 'internal'
+          tags[Tracing::Metadata::Ext::TAG_KIND] = kind
+
+          datadog_span = Tracing.trace(span.name, tags: tags)
+          datadog_span.set_error([nil, span.status.description]) unless span.status.ok?
+          datadog_span
+        end
+      end
+    end
+  end
+end

data/lib/datadog/opentelemetry.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+# Entrypoint file for OpenTelemetry integration.
+#
+# This file's path is part of the @public_api.
+#
+# OpenTelemetry includes metrics, tracing, logs, and profiling.
+# This file activates the integrations of all OpenTelemetry
+# components supported by Datadog.
+
+require_relative 'tracing'
+require_relative 'opentelemetry/api/context'
+
+# DEV: Should this be a Contrib integration, that depends on the `opentelemetry-sdk`
+# DEV: and checks for compatibility?
+# DEV: This is different from our existing OpenTracer API, but there are many safety
+# DEV: features built into Contrib instrumentation today.
+require_relative 'opentelemetry/sdk/configurator' if defined?(OpenTelemetry::SDK)
+
+module Datadog
+  # Datadog OpenTelemetry integration.
+  module OpenTelemetry
+    # Used by Telemetry to decide if OpenTelemetry instrumentation is enabled
+    LOADED = true
+
+    # Use `Datadog.logger` as the default logger
+    def logger
+      @logger ||= ::Datadog.logger
+    end
+
+    ::OpenTelemetry.singleton_class.prepend(self)
+  end
+end
+
+# OpenTelemetry does not wait until the "root" span is finished to flush:
+# the "root" span does not have special influence on flushing order.
+#
+# The "root" OpenTelemetry span might be a span that is never finished, but
+# instead a placeholder for distributed tracing information, and ultimately gets discarded.
+# Consumers of the OpenTelemetry SpanProcessor pipeline are free to flush spans whenever
+# an individual span is finished.
+# Currently, this closely translates to Datadog's partial flushing.
+#
+# @see OpenTelemetry::SDK::Trace::SpanProcessor#on_finish
+Datadog.configure do |c|
+  c.tracing.partial_flush.enabled = true
+end

data/lib/datadog/opentracer/binary_propagator.rb

@@ -0,0 +1,24 @@
+module Datadog
+  module OpenTracer
+    # OpenTracing propagator for Datadog::OpenTracer::Tracer
+    module BinaryPropagator
+      extend Propagator
+
+      # Inject a SpanContext into the given carrier
+      #
+      # @param span_context [SpanContext]
+      # @param carrier [Carrier] A carrier object of Binary type
+      def self.inject(span_context, carrier)
+        nil
+      end
+
+      # Extract a SpanContext in Binary format from the given carrier.
+      #
+      # @param carrier [Carrier] A carrier object of Binary type
+      # @return [SpanContext, nil] the extracted SpanContext or nil if none could be found
+      def self.extract(carrier)
+        SpanContext::NOOP_INSTANCE
+      end
+    end
+  end
+end

data/lib/datadog/opentracer/carrier.rb

@@ -0,0 +1,7 @@
+module Datadog
+  module OpenTracer
+    # @public_api
+    class Carrier < ::OpenTracing::Carrier
+    end
+  end
+end

data/lib/datadog/opentracer/distributed_headers.rb

@@ -0,0 +1,54 @@
+require_relative '../tracing/distributed/datadog'
+require_relative '../tracing/utils'
+
+module Datadog
+  module OpenTracer
+    # DistributedHeaders provides easy access and validation to headers
+    # @public_api
+    class DistributedHeaders
+      def initialize(carrier)
+        @carrier = carrier
+      end
+
+      def valid?
+        # Sampling priority is optional.
+        !trace_id.nil? && !parent_id.nil?
+      end
+
+      def trace_id
+        id Tracing::Distributed::Datadog::TRACE_ID_KEY
+      end
+
+      def parent_id
+        id Tracing::Distributed::Datadog::PARENT_ID_KEY
+      end
+
+      def sampling_priority
+        hdr = @carrier[Tracing::Distributed::Datadog::SAMPLING_PRIORITY_KEY]
+        # It's important to make a difference between no header,
+        # and a header defined to zero.
+        return unless hdr
+
+        value = hdr.to_i
+        return if value < 0
+
+        value
+      end
+
+      def origin
+        hdr = @carrier[Tracing::Distributed::Datadog::ORIGIN_KEY]
+        # Only return the value if it is not an empty string
+        hdr if hdr != ''
+      end
+
+      private
+
+      def id(header)
+        value = @carrier[header].to_i
+        return if value.zero? || value >= Datadog::Tracing::Utils::EXTERNAL_MAX_ID
+
+        value < 0 ? value + 0x1_0000_0000_0000_0000 : value
+      end
+    end
+  end
+end

data/lib/datadog/opentracer/global_tracer.rb

@@ -0,0 +1,15 @@
+module Datadog
+  module OpenTracer
+    # Patch for OpenTracing module
+    module GlobalTracer
+      def global_tracer=(tracer)
+        super.tap do
+          if tracer.class <= Datadog::OpenTracer::Tracer
+            # Update the Datadog global tracer, too.
+            Datadog.configure { |c| c.tracing.instance = tracer.datadog_tracer }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/opentracer/propagator.rb

@@ -0,0 +1,24 @@
+module Datadog
+  module OpenTracer
+    # OpenTracing propagator for Datadog::OpenTracer::Tracer
+    # @abstract
+    # @public_api
+    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/datadog/opentracer/rack_propagator.rb

@@ -0,0 +1,71 @@
+require_relative '../tracing/context'
+require_relative '../tracing/propagation/http'
+require_relative '../tracing/trace_operation'
+require_relative 'propagator'
+
+module Datadog
+  module OpenTracer
+    # OpenTracing propagator for Datadog::OpenTracer::Tracer
+    module RackPropagator
+      extend Propagator
+
+      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)
+          digest = if span_context.datadog_context && span_context.datadog_context.active_trace
+                     span_context.datadog_context.active_trace.to_digest
+                   else
+                     span_context.datadog_trace_digest
+                   end
+
+          # Inject Datadog trace properties
+          Tracing::Propagation::HTTP.inject!(digest, 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,16 @@
+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,7 @@
+module Datadog
+  module OpenTracer
+    # @public_api
+    class ScopeManager < ::OpenTracing::ScopeManager
+    end
+  end
+end

data/lib/datadog/opentracer/span.rb

@@ -0,0 +1,99 @@
+require 'time'
+
+require_relative '../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,17 @@
+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,25 @@
+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,86 @@
+require_relative '../tracing/context'
+require_relative '../tracing/distributed/datadog'
+require_relative '../tracing/trace_operation'
+require_relative 'propagator'
+
+module Datadog
+  module OpenTracer
+    # OpenTracing propagator for Datadog::OpenTracer::Tracer
+    module TextMapPropagator
+      extend Propagator
+
+      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
+          digest = if span_context.datadog_context && span_context.datadog_context.active_trace
+                     span_context.datadog_context.active_trace.to_digest
+                   else
+                     span_context.datadog_trace_digest
+                   end
+          return unless digest
+
+          carrier[Tracing::Distributed::Datadog::ORIGIN_KEY] = digest.trace_origin
+          carrier[Tracing::Distributed::Datadog::PARENT_ID_KEY] = digest.span_id
+          carrier[Tracing::Distributed::Datadog::SAMPLING_PRIORITY_KEY] = digest.trace_sampling_priority
+          carrier[Tracing::Distributed::Datadog::TRACE_ID_KEY] = 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,32 @@
+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,64 @@
+require_relative '../core/utils/sequence'
+
+module Datadog
+  module OpenTracer
+    # OpenTracing adapter for thread local scope management
+    # @public_api
+    class ThreadLocalScopeManager < ScopeManager
+      def initialize(*args, &block)
+        super(*args, &block)
+        @thread_key = "dd_opentracer_context_#{ThreadLocalScopeManager.next_instance_id}".to_sym
+      end
+
+      ruby2_keywords :initialize if respond_to?(:ruby2_keywords, true)
+
+      # 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[@thread_key]
+      end
+
+      # Ensure two instances of {FiberLocalContext} do not conflict.
+      # We previously used {FiberLocalContext#object_id} to ensure uniqueness
+      # but the VM is allowed to reuse `object_id`, allow for the possibility that
+      # a new FiberLocalContext would be able to read an old FiberLocalContext's
+      # value.
+      UNIQUE_INSTANCE_MUTEX = Mutex.new
+      UNIQUE_INSTANCE_GENERATOR = Datadog::Core::Utils::Sequence.new
+
+      private_constant :UNIQUE_INSTANCE_MUTEX, :UNIQUE_INSTANCE_GENERATOR
+
+      def self.next_instance_id
+        UNIQUE_INSTANCE_MUTEX.synchronize { UNIQUE_INSTANCE_GENERATOR.next }
+      end
+
+      private
+
+      def set_scope(scope)
+        Thread.current[@thread_key] = scope
+      end
+    end
+  end
+end