ddtrace 1.4.2 → 1.19.0

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

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require_relative 'span_processor'
+require_relative 'id_generator'
+require_relative 'propagator'
+
+module Datadog
+  module OpenTelemetry
+    module SDK
+      # The Configurator is responsible for setting wiring up
+      # different OpenTelemetry requirements together.
+      # Some of the requirements will be changed to Datadog versions.
+      module Configurator
+        def initialize
+          super
+          @id_generator = IdGenerator
+        end
+
+        # Ensure Datadog-configure propagation styles have are applied when configured.
+        #
+        # DEV: Support configuring propagation through the environment variable
+        # DEV: `OTEL_PROPAGATORS`, similar to `DD_TRACE_PROPAGATION*`?
+        def configure_propagation
+          @propagators = [Propagator.new(Tracing::Contrib::HTTP::Distributed::Propagation.new)]
+          super
+        end
+
+        # Ensure Datadog-configure trace writer is configured.
+        def wrapped_exporters_from_env
+          [SpanProcessor.new]
+        end
+
+        ::OpenTelemetry::SDK::Configurator.prepend(self)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Datadog
+  module OpenTelemetry
+    module SDK
+      # Generates Datadog-compatible IDs for OpenTelemetry traces.
+      # OpenTelemetry traces already produce Datadog-compatible IDs.
+      class IdGenerator
+        class << self
+          include ::OpenTelemetry::Trace
+
+          # Generates a valid trace identifier, a 16-byte string with at least one
+          # non-zero byte.
+          #
+          # @return [String] a valid trace ID.
+          def generate_trace_id
+            loop do
+              id = Random.bytes(8) # DEV: Change to 16 (16*8-byte) when 128-bit trace_id is supported.
+              return id unless id == ::OpenTelemetry::Trace::INVALID_SPAN_ID
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+module Datadog
+  module OpenTelemetry
+    module SDK
+      # Compatibility wrapper to allow Datadog propagators to fulfill the
+      # OpenTelemetry propagator API.
+      class Propagator
+        def initialize(datadog_propagator)
+          @datadog_propagator = datadog_propagator
+        end
+
+        def inject(
+          carrier, context: ::OpenTelemetry::Context.current,
+          setter: ::OpenTelemetry::Context::Propagation.text_map_setter
+        )
+          unless setter == ::OpenTelemetry::Context::Propagation.text_map_setter
+            Datadog.logger.error(
+              'Custom setter is not supported. Please inform the `ddtrace` team at ' \
+            ' https://github.com/DataDog/dd-trace-rb of your use case so we can best support you. Using the default ' \
+            'OpenTelemetry::Context::Propagation.text_map_setter as a fallback setter.'
+            )
+          end
+
+          @datadog_propagator.inject!(context.trace.to_digest, carrier)
+        end
+
+        def extract(
+          carrier, context: ::OpenTelemetry::Context.current,
+          getter: ::OpenTelemetry::Context::Propagation.text_map_getter
+        )
+          unless getter == ::OpenTelemetry::Context::Propagation.text_map_getter
+            Datadog.logger.error(
+              'Custom getter is not supported. Please inform the `ddtrace` team at ' \
+            ' https://github.com/DataDog/dd-trace-rb of your use case so we can best support you. Using the default ' \
+            'OpenTelemetry::Context::Propagation.text_map_getter as a fallback getter.'
+            )
+          end
+
+          digest = @datadog_propagator.extract(carrier)
+          return context unless digest
+
+          trace_id = to_otel_id(digest.trace_id)
+          span_id = to_otel_id(digest.span_id)
+
+          if digest.trace_state || digest.trace_flags
+            trace_flags = ::OpenTelemetry::Trace::TraceFlags.from_byte(digest.trace_flags)
+            tracestate = Tracing::Distributed::TraceContext.new(fetcher: nil).send(:build_tracestate, digest)
+          else
+            trace_flags = if Tracing::Sampling::PrioritySampler.sampled?(digest.trace_sampling_priority)
+                            ::OpenTelemetry::Trace::TraceFlags::SAMPLED
+                          else
+                            ::OpenTelemetry::Trace::TraceFlags::DEFAULT
+                          end
+            tracestate = ::OpenTelemetry::Trace::Tracestate::DEFAULT
+          end
+
+          span_context = ::OpenTelemetry::Trace::SpanContext.new(
+            trace_id: trace_id,
+            span_id: span_id,
+            trace_flags: trace_flags,
+            tracestate: tracestate,
+            remote: true
+          )
+
+          span = ::OpenTelemetry::Trace.non_recording_span(span_context)
+
+          trace = Tracing.continue_trace!(digest)
+
+          span.datadog_trace = trace
+
+          ::OpenTelemetry::Trace.context_with_span(span, parent_context: context)
+        end
+
+        # Returns fields set by this propagator.
+        # DEV: Doesn't seem like it's used in production Otel code paths.
+        def fields
+          []
+        end
+
+        private
+
+        # Converts the {Numeric} Datadog id object to OpenTelemetry's byte array format.
+        # This method currently converts an unsigned 64-bit Integer to a binary String.
+        def to_otel_id(dd_id)
+          Array(dd_id).pack('Q')
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,134 @@
+# frozen_string_literal: true
+
+require_relative 'trace/span'
+
+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(ns_to_time(span.end_timestamp))
+        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)
+          attributes = span.attributes.dup # Dup to allow modification of frozen Hash
+
+          name, kwargs = span_arguments(span, attributes)
+
+          datadog_span = Tracing.trace(name, **kwargs)
+
+          datadog_span.set_error([nil, span.status.description]) unless span.status.ok?
+          datadog_span.set_tags(span.attributes)
+
+          datadog_span
+        end
+
+        # Some special attributes can override Datadog Span fields
+        def span_arguments(span, attributes)
+          if attributes.key?('analytics.event') && (analytics_event = attributes['analytics.event']).respond_to?(:casecmp)
+            attributes[Tracing::Metadata::Ext::Analytics::TAG_SAMPLE_RATE] = analytics_event.casecmp('true') == 0 ? 1 : 0
+          end
+          attributes[Tracing::Metadata::Ext::TAG_KIND] = span.kind || 'internal'
+
+          kwargs = { start_time: ns_to_time(span.start_timestamp) }
+
+          name = if attributes.key?('operation.name')
+                   attributes['operation.name']
+                 elsif (rich_name = Datadog::OpenTelemetry::Trace::Span.enrich_name(span.kind, attributes))
+                   rich_name.downcase
+                 else
+                   span.kind
+                 end
+
+          kwargs[:resource] = attributes.key?('resource.name') ? attributes['resource.name'] : span.name
+          kwargs[:service] = attributes['service.name'] if attributes.key?('service.name')
+          kwargs[:type] = attributes['span.type'] if attributes.key?('span.type')
+
+          attributes.reject! { |key, _| OpenTelemetry::Trace::Span::DATADOG_SPAN_ATTRIBUTE_OVERRIDES.include?(key) }
+
+          # DEV: There's no `flat_map!`; we have to split it into two operations
+          attributes = attributes.map do |key, value|
+            Datadog::OpenTelemetry::Trace::Span.serialize_attribute(key, value)
+          end
+          attributes.flatten!(1)
+
+          kwargs[:tags] = attributes
+
+          [name, kwargs]
+        end
+
+        # From nanoseconds, used by OpenTelemetry, to a {Time} object, used by the Datadog Tracer.
+        def ns_to_time(timestamp_ns)
+          Time.at(timestamp_ns / 1000000000.0)
+        end
+      end
+    end
+  end
+end

data/lib/datadog/opentelemetry/sdk/trace/span.rb

@@ -0,0 +1,167 @@
+# frozen_string_literal: true
+
+module Datadog
+  module OpenTelemetry
+    module Trace
+      # Stores associated Datadog entities to the OpenTelemetry Span.
+      module Span
+        # Attributes are equivalent to span tags and metrics.
+        def set_attribute(key, value)
+          res = super
+          # Attributes can get dropped or their values truncated by `super`
+          datadog_set_attribute(key)
+          res
+        end
+
+        # `alias` performed to match {OpenTelemetry::SDK::Trace::Span} aliasing upstream
+        alias []= set_attribute
+
+        # Attributes are equivalent to span tags and metrics.
+        def add_attributes(attributes)
+          res = super
+          # Attributes can get dropped or their values truncated by `super`
+          attributes.each { |key, _| datadog_set_attribute(key) }
+          res
+        end
+
+        # Captures changes to span error state.
+        def status=(s)
+          super
+
+          return unless status # Return if status are currently disabled by OpenTelemetry.
+          return unless (span = datadog_span)
+
+          # Status code can only change into an error state.
+          # Other change operations should be ignored.
+          span.set_error(status.description) if status && status.code == ::OpenTelemetry::Trace::Status::ERROR
+        end
+
+        # Serialize values into Datadog span tags and metrics.
+        # Notably, arrays are exploded into many keys, each with
+        # a numeric suffix representing the array index, for example:
+        # `'foo' => ['a','b']` becomes `'foo.0' => 'a', 'foo.1' => 'b'`
+        def self.serialize_attribute(key, value)
+          if value.is_a?(Array)
+            value.flat_map.with_index do |v, idx|
+              serialize_attribute("#{key}.#{idx}", v)
+            end
+          elsif value.is_a?(TrueClass) || value.is_a?(FalseClass)
+            [[key, value.to_s]]
+          else
+            [[key, value]]
+          end
+        end
+
+        # Create a meaningful Datadog operation name from the OpenTelemetry
+        # semantic convention for span kind and span attributes.
+        # @see https://opentelemetry.io/docs/specs/semconv/general/trace/
+
+        # rubocop:disable Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity
+        def self.enrich_name(kind, attrs)
+          if attrs.key?('http.request.method')
+            return 'http.server.request' if kind == :server
+            return 'http.client.request' if kind == :client
+          end
+
+          return "#{attrs['db.system']}.query" if attrs.key?('db.system') && kind == :client
+
+          if (attrs.key?('messaging.system') || attrs.key?('messaging.operation')) &&
+              [:consumer, :producer, :server, :client].include?(kind)
+
+            return "#{attrs['messaging.system']}.#{attrs['messaging.operation']}"
+          end
+
+          if attrs.key?('rpc.system')
+            if attrs['rpc.system'] == 'aws-api' && kind == :client
+              service = attrs['rpc.service']
+              return "aws.#{service || 'client'}.request"
+            end
+
+            if kind == :client
+              return "#{attrs['rpc.system']}.client.request"
+            elsif kind == :server
+              return "#{attrs['rpc.system']}.server.request"
+            end
+          end
+
+          if attrs.key?('faas.invoked_provider') && attrs.key?('faas.invoked_name') && kind == :client
+            provider = attrs['faas.invoked_provider']
+            name = attrs['faas.invoked_name']
+            return "#{provider}.#{name}.invoke"
+          end
+
+          return "#{attrs['faas.trigger']}.invoke" if attrs.key?('faas.trigger') && kind == :server
+
+          return 'graphql.server.request' if attrs.key?('graphql.operation.type')
+
+          if kind == :server
+            protocol = attrs['network.protocol.name']
+            return protocol ? "#{protocol}.server.request" : 'server.request'
+          end
+
+          if kind == :client
+            protocol = attrs['network.protocol.name']
+            return protocol ? "#{protocol}.client.request" : 'client.request'
+          end
+
+          kind.to_s
+        end
+        # rubocop:enable Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity
+
+        private
+
+        def datadog_set_attribute(key)
+          # Return if attributes are currently disabled by OpenTelemetry.
+          return unless defined?(@attributes) && @attributes
+          return unless (span = datadog_span)
+
+          # DEV: Accesses `@attributes` directly, since using `#attributes`
+          # DEV: clones the hash, causing unnecessary overhead.
+          if @attributes.key?(key)
+            # Try to find a richer operation name, unless an explicit override was provided.
+            if !@attributes.key?('operation.name') && (rich_name = Span.enrich_name(kind, @attributes))
+              span.name = rich_name.downcase
+            end
+
+            Span.serialize_attribute(key, @attributes[key]).each do |new_key, value|
+              override_datadog_values(span, new_key, value)
+
+              # When an attribute is used to override a Datadog Span property,
+              # it should NOT be set as a Datadog Span tag.
+              span.set_tag(new_key, value) unless DATADOG_SPAN_ATTRIBUTE_OVERRIDES.include?(new_key)
+            end
+          else
+            span.clear_tag(key)
+
+            if key == 'service.name'
+              # By removing the service name, we set it to the fallback default,
+              # effectively removing the `service` attribute from OpenTelemetry's perspective.
+              span.service = Datadog.send(:components).tracer.default_service
+            end
+          end
+        end
+
+        # Some special attributes can override Datadog Span fields beyond tags and metrics.
+        # @return [Boolean] true if the key is a Datadog Span override attribute, false otherwise
+        def override_datadog_values(span, key, value)
+          span.name = value if key == 'operation.name'
+          span.resource = value if key == 'resource.name'
+          span.service = value if key == 'service.name'
+          span.type = value if key == 'span.type'
+
+          if key == 'analytics.event' && value.respond_to?(:casecmp)
+            Datadog::Tracing::Analytics.set_sample_rate(
+              span,
+              value.casecmp('true') == 0 ? 1 : 0
+            )
+          end
+        end
+
+        DATADOG_SPAN_ATTRIBUTE_OVERRIDES = ['analytics.event', 'operation.name', 'resource.name', 'service.name',
+                                            'span.type'].freeze
+
+        ::OpenTelemetry::SDK::Trace::Span.prepend(self)
+      end
+    end
+  end
+end

data/lib/datadog/opentelemetry/trace.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require_relative '../tracing/trace_digest'
+
+module Datadog
+  module OpenTelemetry
+    # OpenTelemetry utilities related to the respective Datadog trace.
+    module Trace
+      class << self
+        # Creates a new TraceOperation object that can be attached to a new
+        # OpenTelemetry span.
+        # If `parent_span` is provided, then that span is set as the currently
+        # active parent span.
+        #
+        # @return [TraceOperation]
+        def start_trace_copy(trace, parent_span: nil)
+          digest = if parent_span
+                     digest_with_parent_span(trace, parent_span)
+                   else
+                     trace.to_digest
+                   end
+
+          # Create a new TraceOperation, attached to the current Datadog Tracer.
+          Datadog::Tracing.continue_trace!(digest)
+        end
+
+        private
+
+        # Creates a TraceDigest with the active span modified.
+        # This supports the implementation of `OpenTelemetry::Trace.context_with_span`,
+        # which allows you to specific any span as the arbitrary parent of a new span.
+        def digest_with_parent_span(trace, parent_span)
+          digest = trace.to_digest
+
+          Tracing::TraceDigest.new(
+            span_id: parent_span.id,
+            span_name: parent_span.name,
+            span_resource: parent_span.resource,
+            span_service: parent_span.service,
+            span_type: parent_span.type,
+            trace_distributed_tags: digest.trace_distributed_tags,
+            trace_hostname: digest.trace_hostname,
+            trace_id: digest.trace_id,
+            trace_name: digest.trace_name,
+            trace_origin: digest.trace_origin,
+            trace_process_id: digest.trace_process_id,
+            trace_resource: digest.trace_resource,
+            trace_runtime_id: digest.trace_runtime_id,
+            trace_sampling_priority: digest.trace_sampling_priority,
+            trace_service: digest.trace_service,
+            trace_state: digest.trace_state,
+            trace_state_unknown_fields: digest.trace_state_unknown_fields,
+          ).freeze
+        end
+      end
+    end
+  end
+end

data/lib/datadog/opentelemetry.rb

@@ -0,0 +1,48 @@
+# 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)
+require_relative 'opentelemetry/sdk/trace/span' 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

@@ -1,4 +1,4 @@
-# typed: true
+# frozen_string_literal: true
 
 module Datadog
   module OpenTracer

data/lib/datadog/opentracer/carrier.rb

@@ -1,4 +1,4 @@
-# typed: strict
+# frozen_string_literal: true
 
 module Datadog
   module OpenTracer

data/lib/datadog/opentracer/distributed_headers.rb

@@ -1,15 +1,11 @@
-# typed: true
-
-require_relative '../tracing/span'
-require_relative '../tracing/distributed/headers/ext'
+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
-      include Tracing::Distributed::Headers::Ext
-
       def initialize(carrier)
         @carrier = carrier
       end
@@ -20,15 +16,15 @@ module Datadog
       end
 
       def trace_id
-        id HTTP_HEADER_TRACE_ID
+        id Tracing::Distributed::Datadog::TRACE_ID_KEY
       end
 
       def parent_id
-        id HTTP_HEADER_PARENT_ID
+        id Tracing::Distributed::Datadog::PARENT_ID_KEY
       end
 
       def sampling_priority
-        hdr = @carrier[HTTP_HEADER_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
@@ -40,7 +36,7 @@ module Datadog
       end
 
       def origin
-        hdr = @carrier[HTTP_HEADER_ORIGIN]
+        hdr = @carrier[Tracing::Distributed::Datadog::ORIGIN_KEY]
         # Only return the value if it is not an empty string
         hdr if hdr != ''
       end
@@ -49,7 +45,7 @@ module Datadog
 
       def id(header)
         value = @carrier[header].to_i
-        return if value.zero? || value >= Datadog::Tracing::Span::EXTERNAL_MAX_ID
+        return if value.zero? || value >= Datadog::Tracing::Utils::EXTERNAL_MAX_ID
 
         value < 0 ? value + 0x1_0000_0000_0000_0000 : value
       end

data/lib/datadog/opentracer/global_tracer.rb

@@ -1,4 +1,4 @@
-# typed: true
+# frozen_string_literal: true
 
 module Datadog
   module OpenTracer

data/lib/datadog/opentracer/propagator.rb

@@ -1,4 +1,4 @@
-# typed: false
+# frozen_string_literal: true
 
 module Datadog
   module OpenTracer

data/lib/datadog/opentracer/rack_propagator.rb

@@ -1,7 +1,4 @@
-# typed: true
-
 require_relative '../tracing/context'
-require_relative '../tracing/distributed/headers/ext'
 require_relative '../tracing/propagation/http'
 require_relative '../tracing/trace_operation'
 require_relative 'propagator'
@@ -11,8 +8,6 @@ module Datadog
     # 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

data/lib/datadog/opentracer/scope.rb

@@ -1,4 +1,4 @@
-# typed: true
+# frozen_string_literal: true
 
 module Datadog
   module OpenTracer

data/lib/datadog/opentracer/scope_manager.rb

@@ -1,4 +1,4 @@
-# typed: strict
+# frozen_string_literal: true
 
 module Datadog
   module OpenTracer