ddtrace 0.13.0 → 0.47.0

data/lib/ddtrace/opentelemetry/extensions.rb

@@ -0,0 +1,13 @@
+require 'ddtrace/span'
+require 'ddtrace/opentelemetry/span'
+
+module Datadog
+  module OpenTelemetry
+    # Defines extensions to ddtrace for OpenTelemetry support
+    module Extensions
+      def self.extended(base)
+        Datadog::Span.send(:prepend, OpenTelemetry::Span)
+      end
+    end
+  end
+end

data/lib/ddtrace/opentelemetry/span.rb

@@ -0,0 +1,33 @@
+require 'ddtrace/ext/environment'
+
+module Datadog
+  module OpenTelemetry
+    # Extensions for Datadog::Span
+    module Span
+      TAG_SERVICE_NAME = 'service.name'.freeze
+      TAG_SERVICE_VERSION = 'service.version'.freeze
+
+      def set_tag(key, value)
+        # Configure sampling priority if they give us a forced tracing tag
+        # DEV: Do not set if the value they give us is explicitly "false"
+        case key
+        when TAG_SERVICE_NAME
+          if defined?(super)
+            # Set original tag and Datadog version tag
+            self.service = value
+            super
+          end
+        when TAG_SERVICE_VERSION
+          if defined?(super)
+            # Set original tag and Datadog version tag
+            super
+            super(Datadog::Ext::Environment::TAG_VERSION, value)
+          end
+        else
+          # Otherwise, set the tag normally.
+          super if defined?(super)
+        end
+      end
+    end
+  end
+end

data/lib/ddtrace/opentracer.rb

@@ -0,0 +1,40 @@
+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

data/lib/ddtrace/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/ddtrace/opentracer/carrier.rb

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

data/lib/ddtrace/opentracer/distributed_headers.rb

@@ -0,0 +1,55 @@
+require 'ddtrace/span'
+require 'ddtrace/ext/distributed'
+
+module Datadog
+  module OpenTracer
+    # DistributedHeaders provides easy access and validation to headers
+    class DistributedHeaders
+      include Datadog::Ext::DistributedTracing
+
+      def initialize(carrier)
+        @carrier = carrier
+      end
+
+      def valid?
+        # Sampling priority is optional.
+        !trace_id.nil? && !parent_id.nil?
+      end
+
+      def trace_id
+        id HTTP_HEADER_TRACE_ID
+      end
+
+      def parent_id
+        id HTTP_HEADER_PARENT_ID
+      end
+
+      def sampling_priority
+        hdr = @carrier[HTTP_HEADER_SAMPLING_PRIORITY]
+        # 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[HTTP_HEADER_ORIGIN]
+        # 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::Span::EXTERNAL_MAX_ID
+
+        value < 0 ? value + 0x1_0000_0000_0000_0000 : value
+      end
+    end
+  end
+end

data/lib/ddtrace/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.tracer = tracer.datadog_tracer }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ddtrace/opentracer/propagator.rb

@@ -0,0 +1,22 @@
+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

@@ -0,0 +1,60 @@
+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

@@ -0,0 +1,15 @@
+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

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

data/lib/ddtrace/opentracer/span.rb

@@ -0,0 +1,94 @@
+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

@@ -0,0 +1,14 @@
+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

@@ -0,0 +1,23 @@
+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

@@ -0,0 +1,75 @@
+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