ddtrace 1.14.0 → 1.15.0

data/lib/datadog/core/transport/http/adapters/test.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+require_relative '../../../../core/transport/response'
+
+module Datadog
+  module Core
+    module Transport
+      module HTTP
+        module Adapters
+          # Adapter for testing
+          class Test
+            attr_reader \
+              :buffer,
+              :status
+
+            # @param buffer [Array] an optional array that will capture all spans sent to this adapter, defaults to +nil+
+            # @deprecated Positional parameters are deprecated. Use named parameters instead.
+            def initialize(buffer = nil, **options)
+              @buffer = buffer || options[:buffer]
+              @mutex = Mutex.new
+              @status = 200
+            end
+
+            def call(env)
+              add_request(env)
+              Response.new(status)
+            end
+
+            def buffer?
+              !@buffer.nil?
+            end
+
+            def add_request(env)
+              @mutex.synchronize { buffer << env } if buffer?
+            end
+
+            def set_status!(status)
+              @status = status
+            end
+
+            def url; end
+
+            # Response for test adapter
+            class Response
+              include Datadog::Core::Transport::Response
+
+              attr_reader \
+                :body,
+                :code
+
+              def initialize(code, body = nil)
+                @code = code
+                @body = body
+              end
+
+              def payload
+                @body
+              end
+
+              def ok?
+                code.between?(200, 299)
+              end
+
+              def unsupported?
+                code == 415
+              end
+
+              def not_found?
+                code == 404
+              end
+
+              def client_error?
+                code.between?(400, 499)
+              end
+
+              def server_error?
+                code.between?(500, 599)
+              end
+
+              def inspect
+                "#{super}, code:#{code}"
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/core/transport/http/adapters/unix_socket.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+require 'net/http'
+require_relative '../../../transport/ext'
+require_relative 'net'
+
+module Datadog
+  module Core
+    module Transport
+      module HTTP
+        module Adapters
+          # Adapter for Unix sockets
+          class UnixSocket < Adapters::Net
+            attr_reader \
+              :filepath, # DEV(1.0): Rename to `uds_path`
+              :timeout
+
+            alias_method :uds_path, :filepath
+
+            # @deprecated Positional parameters are deprecated. Use named parameters instead.
+            # rubocop:disable Lint/MissingSuper
+            def initialize(uds_path = nil, **options)
+              @filepath = uds_path || options.fetch(:uds_path)
+              @timeout = options[:timeout] || Datadog::Core::Transport::Ext::UnixSocket::DEFAULT_TIMEOUT_SECONDS
+            end
+            # rubocop:enable Lint/MissingSuper
+
+            def self.build(agent_settings)
+              new(
+                uds_path: agent_settings.uds_path,
+                timeout: agent_settings.timeout_seconds,
+              )
+            end
+
+            def open(&block)
+              # Open connection
+              connection = HTTP.new(
+                uds_path,
+                read_timeout: timeout,
+                continue_timeout: timeout
+              )
+
+              connection.start(&block)
+            end
+
+            def url
+              "http+unix://#{uds_path}?timeout=#{timeout}"
+            end
+
+            # Re-implements Net:HTTP with underlying Unix socket
+            class HTTP < ::Net::HTTP
+              DEFAULT_TIMEOUT = 1
+
+              attr_reader \
+                :filepath, # DEV(1.0): Rename to `uds_path`
+                :unix_socket
+
+              alias_method :uds_path, :filepath
+
+              def initialize(uds_path, options = {})
+                super('localhost', 80)
+                @filepath = uds_path
+                @read_timeout = options.fetch(:read_timeout, DEFAULT_TIMEOUT)
+                @continue_timeout = options.fetch(:continue_timeout, DEFAULT_TIMEOUT)
+                @debug_output = options[:debug_output] if options.key?(:debug_output)
+              end
+
+              def connect
+                @unix_socket = UNIXSocket.open(uds_path)
+                @socket = ::Net::BufferedIO.new(@unix_socket).tap do |socket|
+                  socket.read_timeout = @read_timeout
+                  socket.continue_timeout = @continue_timeout
+                  socket.debug_output = @debug_output
+                end
+                on_connect
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/core/transport/http/api/endpoint.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module Datadog
+  module Core
+    module Transport
+      module HTTP
+        module API
+          # Endpoint
+          class Endpoint
+            attr_reader \
+              :verb,
+              :path
+
+            def initialize(verb, path)
+              @verb = verb
+              @path = path
+            end
+
+            def call(env)
+              env.verb = verb
+              env.path = path
+              yield(env)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/core/transport/http/api/fallbacks.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Datadog
+  module Core
+    module Transport
+      module HTTP
+        module API
+          # Extension for Map with adds fallback versions.
+          module Fallbacks
+            def fallbacks
+              @fallbacks ||= {}
+            end
+
+            def with_fallbacks(fallbacks)
+              tap { add_fallbacks!(fallbacks) }
+            end
+
+            def add_fallbacks!(fallbacks)
+              self.fallbacks.merge!(fallbacks)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/core/transport/http/api/map.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require_relative 'fallbacks'
+
+module Datadog
+  module Core
+    module Transport
+      module HTTP
+        module API
+          # A mapping of API version => API Routes/Instance
+          class Map < Hash
+            include Fallbacks
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/core/transport/http/env.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module Datadog
+  module Core
+    module Transport
+      module HTTP
+        # Data structure for an HTTP request
+        class Env < Hash
+          attr_reader \
+            :request
+
+          # rubocop:disable Lint/MissingSuper
+          def initialize(request, options = nil)
+            @request = request
+            merge!(options) unless options.nil?
+          end
+          # rubocop:enable Lint/MissingSuper
+
+          def verb
+            self[:verb]
+          end
+
+          def verb=(value)
+            self[:verb] = value
+          end
+
+          def path
+            self[:path]
+          end
+
+          def path=(value)
+            self[:path] = value
+          end
+
+          def body
+            self[:body]
+          end
+
+          def body=(value)
+            self[:body] = value
+          end
+
+          def headers
+            self[:headers] ||= {}
+          end
+
+          def headers=(value)
+            self[:headers] = value
+          end
+
+          def form
+            self[:form] ||= {}
+          end
+
+          def form=(value)
+            self[:form] = value
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/core/transport/http/response.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require_relative '../../../core/transport/response'
+
+module Datadog
+  module Core
+    module Transport
+      module HTTP
+        # Wraps an HTTP response from an adapter.
+        #
+        # Used by endpoints to wrap responses from adapters with
+        # fields or behavior that's specific to that endpoint.
+        module Response
+          def initialize(http_response)
+            @http_response = http_response
+          end
+
+          # (see Datadog::Core::Transport::Response#payload)
+          def payload
+            @http_response.payload
+          end
+
+          # (see Datadog::Core::Transport::Response#internal_error?)
+          def internal_error?
+            @http_response.internal_error?
+          end
+
+          # (see Datadog::Core::Transport::Response#unsupported?)
+          def unsupported?
+            @http_response.unsupported?
+          end
+
+          # (see Datadog::Core::Transport::Response#ok?)
+          def ok?
+            @http_response.ok?
+          end
+
+          # (see Datadog::Core::Transport::Response#not_found?)
+          def not_found?
+            @http_response.not_found?
+          end
+
+          # (see Datadog::Core::Transport::Response#client_error?)
+          def client_error?
+            @http_response.client_error?
+          end
+
+          # (see Datadog::Core::Transport::Response#server_error?)
+          def server_error?
+            @http_response.server_error?
+          end
+
+          def code
+            @http_response.respond_to?(:code) ? @http_response.code : nil
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/core/transport/parcel.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Datadog
+  module Core
+    module Transport
+      # Data transfer object for generic data
+      # @abstract
+      module Parcel
+        attr_reader \
+          :data
+
+        def initialize(data)
+          @data = data
+        end
+
+        def encode_with(encoder)
+          raise NotImplementedError
+        end
+      end
+    end
+  end
+end

data/lib/datadog/core/transport/request.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Datadog
+  module Core
+    module Transport
+      # Defines request for transport operations
+      class Request
+        attr_reader \
+          :parcel
+
+        def initialize(parcel = nil)
+          @parcel = parcel
+        end
+      end
+    end
+  end
+end

data/lib/datadog/core/transport/response.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module Datadog
+  module Core
+    module Transport
+      # Defines abstract response for transport operations
+      module Response
+        def payload
+          nil
+        end
+
+        def ok?
+          nil
+        end
+
+        def unsupported?
+          nil
+        end
+
+        def not_found?
+          nil
+        end
+
+        def client_error?
+          nil
+        end
+
+        def server_error?
+          nil
+        end
+
+        def internal_error?
+          nil
+        end
+
+        def inspect
+          "#{self.class} ok?:#{ok?} unsupported?:#{unsupported?}, " \
+            "not_found?:#{not_found?}, client_error?:#{client_error?}, " \
+            "server_error?:#{server_error?}, internal_error?:#{internal_error?}, " \
+            "payload:#{payload}"
+        end
+      end
+
+      # A generic error response for internal errors
+      class InternalErrorResponse
+        include Response
+
+        attr_reader :error
+
+        def initialize(error)
+          @error = error
+        end
+
+        def internal_error?
+          true
+        end
+
+        def inspect
+          "#{super}, error_type:#{error.class} error:#{error}"
+        end
+      end
+    end
+  end
+end

data/lib/datadog/core/workers/polling.rb

@@ -6,7 +6,7 @@ module Datadog
     module Workers
       # Adds polling (async looping) behavior to workers
       module Polling
-        SHUTDOWN_TIMEOUT = 1
+        DEFAULT_SHUTDOWN_TIMEOUT = 1
 
         def self.included(base)
           base.include(Workers::IntervalLoop)
@@ -21,7 +21,7 @@ module Datadog
           end
         end
 
-        def stop(force_stop = false, timeout = SHUTDOWN_TIMEOUT)
+        def stop(force_stop = false, timeout = DEFAULT_SHUTDOWN_TIMEOUT)
           if running?
             # Attempt graceful stop and wait
             stop_loop

data/lib/datadog/opentelemetry/api/context.rb

@@ -2,6 +2,7 @@
 
 require_relative 'trace/span'
 require_relative '../../tracing/trace_operation'
+require_relative '../trace'
 
 module Datadog
   module OpenTelemetry
@@ -66,9 +67,15 @@ module Datadog
         # @param [Object] value Object to be stored under key
         # @return [Context]
         def set_values(values)
-          trace = nil
-          if (current_span = values[CURRENT_SPAN_KEY])
-            trace = current_span.datadog_trace
+          if (current_span = values[CURRENT_SPAN_KEY]) && current_span.datadog_trace
+            # Because `#set_value` returns new context, we have to create
+            # a new copy of the active trace to ensure there's no conflict with
+            # other users of the active trace.
+            # It effectively becomes an internal trace propagation.
+            trace = Datadog::OpenTelemetry::Trace.start_trace_copy(
+              current_span.datadog_trace,
+              parent_span: current_span.datadog_span
+            )
           end
 
           existing_values = @trace && @trace.otel_values || {}

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

@@ -81,8 +81,9 @@ module Datadog
         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('S')
+          Array(dd_id).pack('Q')
         end
       end
     end

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

@@ -27,7 +27,7 @@ module Datadog
         #
         # @param [Span] span the {Span} that just ended.
         def on_finish(span)
-          span.datadog_span.finish
+          span.datadog_span.finish(ns_to_time(span.end_timestamp))
         end
 
         # Export all ended spans to the configured `Exporter` that have not yet
@@ -81,10 +81,22 @@ module Datadog
           kind = span.kind || 'internal'
           tags[Tracing::Metadata::Ext::TAG_KIND] = kind
 
-          datadog_span = Tracing.trace(span.name, tags: tags)
+          datadog_span = Tracing.trace(
+            span.name,
+            tags: tags,
+            start_time: ns_to_time(span.start_timestamp)
+          )
+
           datadog_span.set_error([nil, span.status.description]) unless span.status.ok?
+          datadog_span.set_tags(span.attributes)
+
           datadog_span
         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

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

@@ -0,0 +1,68 @@
+# 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
+
+        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)
+            value = @attributes[key]
+            span.set_tag(key, value)
+
+            span.service = value if key == 'service.name'
+          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
+
+        ::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