ddtrace 1.12.1 → 1.23.2

data/lib/datadog/tracing/transport/http/api.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require_relative '../../../core/encoding'
+
+require_relative '../../../core/transport/http/api/map'
+require_relative 'api/spec'
+
+require_relative 'traces'
+
+module Datadog
+  module Tracing
+    module Transport
+      module HTTP
+        # Namespace for API components
+        module API
+          # Default API versions
+          V4 = 'v0.4'
+          V3 = 'v0.3'
+
+          module_function
+
+          def defaults
+            Datadog::Core::Transport::HTTP::API::Map[
+              V4 => Spec.new do |s|
+                s.traces = Traces::API::Endpoint.new(
+                  '/v0.4/traces',
+                  Core::Encoding::MsgpackEncoder,
+                  service_rates: true
+                )
+              end,
+              V3 => Spec.new do |s|
+                s.traces = Traces::API::Endpoint.new(
+                  '/v0.3/traces',
+                  Core::Encoding::MsgpackEncoder
+                )
+              end,
+            ].with_fallbacks(V4 => V3)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/{core → tracing}/transport/http/builder.rb

@@ -1,50 +1,18 @@
 # frozen_string_literal: true
 
-require_relative '../../configuration/agent_settings_resolver'
-require_relative '../../../../ddtrace/transport/http/adapters/registry'
-require_relative '../../../../ddtrace/transport/http/api/map'
-
-# TODO: Decouple standard transport/http/api/instance
-#
-# Separate classes are needed because transport/http/trace includes
-# Trace::API::Instance which closes over and uses a single spec, which is
-# negotiated as either /v3 or /v4 for the whole API at the spec level, but we
-# need an independent toplevel path at the endpoint level.
-#
-# Separate classes are needed because of `include Trace::API::Instance`.
-#
-# Below should be:
-# require_relative '../../../../ddtrace/transport/http/api/instance'
+require_relative '../../../core/configuration/agent_settings_resolver'
+require_relative '../../../core/transport/http/adapters/registry'
+require_relative '../../../core/transport/http/api/map'
 require_relative 'api/instance'
-
-# TODO: Decouple transport/http/client
-#
-# The standard one does `include Transport::HTTP::Statistics` and performs
-# stats updates, which may or may not be desirable in general.
-#
-# Below should be:
-# require_relative '../../../../ddtrace/transport/http/client'
 require_relative 'client'
 
-# TODO: Decouple transport/http/builder
-#
-# This class is duplicated even though it is tantalisingly close to the
-# one in ddtrace/transport mostly because it refers to a different
-# `API::Instance` in `#api_instance_class` but also because it operates on a
-# different `HTTP::Client`, as well as de-hardcoding the transport class
-# `Transport::Traces::Transport` in `#to_transport`
-#
-# Additionally, its design makes it so there can be only one (API, Client,
-# Transport) triplet, requiring a new transport instance for any varying
-# element of the triplet.
-
 module Datadog
-  module Core
+  module Tracing
     module Transport
       module HTTP
         # Builds new instances of Transport::HTTP::Client
         class Builder
-          REGISTRY = Datadog::Transport::HTTP::Adapters::Registry.new
+          REGISTRY = Datadog::Core::Transport::HTTP::Adapters::Registry.new
 
           attr_reader \
             :apis,
@@ -59,7 +27,7 @@ module Datadog
             @default_headers = {}
 
             # Client settings
-            @apis = Datadog::Transport::HTTP::API::Map.new
+            @apis = Datadog::Core::Transport::HTTP::API::Map.new
             @default_api = nil
 
             # API settings
@@ -114,16 +82,17 @@ module Datadog
             @default_api = key
           end
 
-          def to_transport(klass)
+          def to_transport
             raise NoDefaultApiError if @default_api.nil?
 
-            klass.new(to_api_instances, @default_api)
+            # DEV: Should not be specific to traces
+            Transport::Traces::Transport.new(to_api_instances, @default_api)
           end
 
           def to_api_instances
             raise NoApisError if @apis.empty?
 
-            @apis.inject(Datadog::Transport::HTTP::API::Map.new) do |instances, (key, spec)|
+            @apis.inject(Datadog::Core::Transport::HTTP::API::Map.new) do |instances, (key, spec)|
               instances.tap do
                 api_options = @api_options[key].dup
 
@@ -154,46 +123,22 @@ module Datadog
 
           # Raised when the API key does not match known APIs.
           class UnknownApiError < StandardError
-            attr_reader :key
-
             def initialize(key)
-              super()
-
-              @key = key
-            end
-
-            def message
-              "Unknown transport API '#{key}'!"
+              super("Unknown transport API '#{key}'!")
             end
           end
 
           # Raised when the identifier cannot be matched to an adapter.
           class UnknownAdapterError < StandardError
-            attr_reader :type
-
             def initialize(type)
-              super()
-
-              @type = type
-            end
-
-            def message
-              "Unknown transport adapter '#{type}'!"
+              super("Unknown transport adapter '#{type}'!")
             end
           end
 
           # Raised when an adapter cannot be resolved for an API instance.
           class NoAdapterForApiError < StandardError
-            attr_reader :key
-
             def initialize(key)
-              super()
-
-              @key = key
-            end
-
-            def message
-              "No adapter resolved for transport API '#{key}'!"
+              super("No adapter resolved for transport API '#{key}'!")
             end
           end
 

data/lib/datadog/tracing/transport/http/client.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require_relative 'statistics'
+require_relative '../../../core/transport/http/env'
+require_relative '../../../core/transport/http/response'
+
+module Datadog
+  module Tracing
+    module Transport
+      module HTTP
+        # Routes, encodes, and sends tracer data to the trace agent via HTTP.
+        class Client
+          include Datadog::Tracing::Transport::HTTP::Statistics
+
+          attr_reader :api
+
+          def initialize(api)
+            @api = api
+          end
+
+          def send_request(request, &block)
+            # Build request into env
+            env = build_env(request)
+
+            # Get responses from API
+            response = yield(api, env)
+
+            # Update statistics
+            update_stats_from_response!(response)
+
+            response
+          rescue StandardError => e
+            message =
+              "Internal error during #{self.class.name} request. Cause: #{e.class.name} #{e.message} " \
+                "Location: #{Array(e.backtrace).first}"
+
+            # Log error
+            if stats.consecutive_errors > 0
+              Datadog.logger.debug(message)
+            else
+              Datadog.logger.error(message)
+            end
+
+            # Update statistics
+            update_stats_from_exception!(e)
+
+            Datadog::Core::Transport::InternalErrorResponse.new(e)
+          end
+
+          def build_env(request)
+            Datadog::Core::Transport::HTTP::Env.new(request)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/tracing/transport/http/statistics.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require_relative '../statistics'
+
+module Datadog
+  module Tracing
+    module Transport
+      module HTTP
+        # Tracks statistics for HTTP transports
+        module Statistics
+          def self.included(base)
+            base.include(Datadog::Tracing::Transport::Statistics)
+            base.include(InstanceMethods)
+          end
+
+          # Instance methods for HTTP statistics
+          module InstanceMethods
+            # Decorate metrics for HTTP responses
+            def metrics_for_response(response)
+              super.tap do |metrics|
+                # Add status code tag to api.responses metric
+                if metrics.key?(:api_responses)
+                  (metrics[:api_responses].options[:tags] ||= []).tap do |tags|
+                    tags << metrics_tag_value(response.code)
+                  end
+                end
+              end
+            end
+
+            private
+
+            # The most common status code on a healthy tracer
+            STATUS_CODE_200 = 'status_code:200'
+
+            def metrics_tag_value(status_code)
+              if status_code == 200
+                STATUS_CODE_200 # DEV Saves string concatenation/creation for common case
+              else
+                "status_code:#{status_code}"
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/tracing/transport/http/traces.rb

@@ -0,0 +1,152 @@
+# frozen_string_literal: true
+
+require 'json'
+
+require_relative '../traces'
+require_relative 'client'
+require_relative '../../../core/transport/http/response'
+require_relative '../../../core/transport/http/api/endpoint'
+require_relative 'api/instance'
+
+module Datadog
+  module Tracing
+    module Transport
+      module HTTP
+        # HTTP transport behavior for traces
+        module Traces
+          # Response from HTTP transport for traces
+          class Response
+            include Datadog::Core::Transport::HTTP::Response
+            include Datadog::Tracing::Transport::Traces::Response
+
+            def initialize(http_response, options = {})
+              super(http_response)
+              @service_rates = options.fetch(:service_rates, nil)
+              @trace_count = options.fetch(:trace_count, 0)
+            end
+          end
+
+          # Extensions for HTTP client
+          module Client
+            def send_traces_payload(request)
+              send_request(request) do |api, env|
+                api.send_traces(env)
+              end
+            end
+          end
+
+          module API
+            # Extensions for HTTP API Spec
+            module Spec
+              attr_reader :traces
+
+              def traces=(endpoint)
+                @traces = endpoint
+              end
+
+              def send_traces(env, &block)
+                raise NoTraceEndpointDefinedError, self if traces.nil?
+
+                traces.call(env, &block)
+              end
+
+              def encoder
+                traces.encoder
+              end
+
+              # Raised when traces sent but no traces endpoint is defined
+              class NoTraceEndpointDefinedError < StandardError
+                attr_reader :spec
+
+                def initialize(spec)
+                  super
+
+                  @spec = spec
+                end
+
+                def message
+                  'No trace endpoint is defined for API specification!'
+                end
+              end
+            end
+
+            # Extensions for HTTP API Instance
+            module Instance
+              def send_traces(env)
+                raise TracesNotSupportedError, spec unless spec.is_a?(Traces::API::Spec)
+
+                spec.send_traces(env) do |request_env|
+                  call(request_env)
+                end
+              end
+
+              # Raised when traces sent to API that does not support traces
+              class TracesNotSupportedError < StandardError
+                attr_reader :spec
+
+                def initialize(spec)
+                  super
+
+                  @spec = spec
+                end
+
+                def message
+                  'Traces not supported for this API!'
+                end
+              end
+            end
+
+            # Endpoint for submitting trace data
+            class Endpoint < Datadog::Core::Transport::HTTP::API::Endpoint
+              HEADER_CONTENT_TYPE = 'Content-Type'
+              HEADER_TRACE_COUNT = 'X-Datadog-Trace-Count'
+              SERVICE_RATE_KEY = 'rate_by_service'
+
+              attr_reader \
+                :encoder
+
+              def initialize(path, encoder, options = {})
+                super(:post, path)
+                @encoder = encoder
+                @service_rates = options.fetch(:service_rates, false)
+              end
+
+              def service_rates?
+                @service_rates == true
+              end
+
+              def call(env, &block)
+                # Add trace count header
+                env.headers[HEADER_TRACE_COUNT] = env.request.parcel.trace_count.to_s
+
+                # Encode body & type
+                env.headers[HEADER_CONTENT_TYPE] = encoder.content_type
+                env.body = env.request.parcel.data
+
+                # Query for response
+                http_response = super(env, &block)
+
+                # Process the response
+                response_options = { trace_count: env.request.parcel.trace_count }.tap do |options|
+                  # Parse service rates, if configured to do so.
+                  if service_rates? && !http_response.payload.to_s.empty?
+                    body = JSON.parse(http_response.payload)
+                    options[:service_rates] = body[SERVICE_RATE_KEY] if body.is_a?(Hash) && body.key?(SERVICE_RATE_KEY)
+                  end
+                end
+
+                # Build and return a trace response
+                Traces::Response.new(http_response, response_options)
+              end
+            end
+          end
+
+          # Add traces behavior to transport components
+          HTTP::Client.include(Traces::Client)
+          HTTP::API::Spec.include(Traces::API::Spec)
+          HTTP::API::Instance.include(Traces::API::Instance)
+        end
+      end
+    end
+  end
+end

data/lib/datadog/tracing/transport/http.rb

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+require 'uri'
+
+require_relative '../../core/environment/container'
+require_relative '../../core/environment/ext'
+require_relative '../../core/transport/ext'
+require_relative '../../core/transport/http/adapters/net'
+require_relative '../../core/transport/http/adapters/test'
+require_relative '../../core/transport/http/adapters/unix_socket'
+require_relative 'http/api'
+require_relative 'http/builder'
+require_relative '../../../ddtrace/version'
+
+module Datadog
+  module Tracing
+    module Transport
+      # Namespace for HTTP transport components
+      module HTTP
+        # NOTE: Due to... legacy reasons... This class likes having a default `AgentSettings` instance to fall back to.
+        # Because we generate this instance with an empty instance of `Settings`, the resulting `AgentSettings` below
+        # represents only settings specified via environment variables + the usual defaults.
+        #
+        # DO NOT USE THIS IN NEW CODE, as it ignores any settings specified by users via `Datadog.configure`.
+        DO_NOT_USE_ENVIRONMENT_AGENT_SETTINGS = Datadog::Core::Configuration::AgentSettingsResolver.call(
+          Datadog::Core::Configuration::Settings.new,
+          logger: nil,
+        )
+
+        module_function
+
+        # Builds a new Transport::HTTP::Client
+        def new(&block)
+          Builder.new(&block).to_transport
+        end
+
+        # Builds a new Transport::HTTP::Client with default settings
+        # Pass a block to override any settings.
+        def default(
+          agent_settings: DO_NOT_USE_ENVIRONMENT_AGENT_SETTINGS,
+          **options
+        )
+          new do |transport|
+            transport.adapter(agent_settings)
+            transport.headers default_headers
+
+            apis = API.defaults
+
+            transport.api API::V4, apis[API::V4], fallback: API::V3, default: true
+            transport.api API::V3, apis[API::V3]
+
+            # Apply any settings given by options
+            unless options.empty?
+              transport.default_api = options[:api_version] if options.key?(:api_version)
+              transport.headers options[:headers] if options.key?(:headers)
+            end
+
+            if agent_settings.deprecated_for_removal_transport_configuration_proc
+              agent_settings.deprecated_for_removal_transport_configuration_proc.call(transport)
+            end
+
+            # Call block to apply any customization, if provided
+            yield(transport) if block_given?
+          end
+        end
+
+        def default_headers
+          {
+            Datadog::Core::Transport::Ext::HTTP::HEADER_CLIENT_COMPUTED_TOP_LEVEL => '1',
+            Datadog::Core::Transport::Ext::HTTP::HEADER_META_LANG => Datadog::Core::Environment::Ext::LANG,
+            Datadog::Core::Transport::Ext::HTTP::HEADER_META_LANG_VERSION => Datadog::Core::Environment::Ext::LANG_VERSION,
+            Datadog::Core::Transport::Ext::HTTP::HEADER_META_LANG_INTERPRETER =>
+              Datadog::Core::Environment::Ext::LANG_INTERPRETER,
+            Datadog::Core::Transport::Ext::HTTP::HEADER_META_LANG_INTERPRETER_VENDOR => Core::Environment::Ext::LANG_ENGINE,
+            Datadog::Core::Transport::Ext::HTTP::HEADER_META_TRACER_VERSION =>
+              Datadog::Core::Environment::Ext::TRACER_VERSION
+          }.tap do |headers|
+            # Add container ID, if present.
+            container_id = Datadog::Core::Environment::Container.container_id
+            headers[Datadog::Core::Transport::Ext::HTTP::HEADER_CONTAINER_ID] = container_id unless container_id.nil?
+          end
+        end
+
+        def default_adapter
+          Datadog::Core::Transport::Ext::HTTP::ADAPTER
+        end
+
+        def default_hostname(logger: Datadog.logger)
+          logger.warn(
+            'Deprecated for removal: Using #default_hostname for configuration is deprecated and will ' \
+              'be removed on a future ddtrace release.'
+          )
+
+          DO_NOT_USE_ENVIRONMENT_AGENT_SETTINGS.hostname
+        end
+
+        def default_port(logger: Datadog.logger)
+          logger.warn(
+            'Deprecated for removal: Using #default_hostname for configuration is deprecated and will ' \
+              'be removed on a future ddtrace release.'
+          )
+
+          DO_NOT_USE_ENVIRONMENT_AGENT_SETTINGS.port
+        end
+
+        def default_url(logger: Datadog.logger)
+          logger.warn(
+            'Deprecated for removal: Using #default_url for configuration is deprecated and will ' \
+              'be removed on a future ddtrace release.'
+          )
+
+          nil
+        end
+
+        # Add adapters to registry
+        Builder::REGISTRY.set(Datadog::Core::Transport::HTTP::Adapters::Net, Datadog::Core::Transport::Ext::HTTP::ADAPTER)
+        Builder::REGISTRY.set(Datadog::Core::Transport::HTTP::Adapters::Test, Datadog::Core::Transport::Ext::Test::ADAPTER)
+        Builder::REGISTRY.set(
+          Datadog::Core::Transport::HTTP::Adapters::UnixSocket,
+          Datadog::Core::Transport::Ext::UnixSocket::ADAPTER
+        )
+      end
+    end
+  end
+end

data/lib/datadog/tracing/transport/io/client.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+require_relative '../statistics'
+require_relative 'response'
+
+module Datadog
+  module Tracing
+    module Transport
+      module IO
+        # Encodes and writes tracer data to IO
+        class Client
+          include Transport::Statistics
+
+          attr_reader \
+            :encoder,
+            :out
+
+          def initialize(out, encoder, options = {})
+            @out = out
+            @encoder = encoder
+
+            @request_block = options.fetch(:request, method(:send_default_request))
+            @encode_block = options.fetch(:encode, method(:encode_data))
+            @write_block = options.fetch(:write, method(:write_data))
+            @response_block = options.fetch(:response, method(:build_response))
+          end
+
+          def send_request(request)
+            # Write data to IO
+            # If block is given, allow it to handle writing
+            # Otherwise do a standard encode/write/response.
+            response = if block_given?
+                         yield(out, request)
+                       else
+                         @request_block.call(out, request)
+                       end
+
+            # Update statistics
+            update_stats_from_response!(response)
+
+            # Return response
+            response
+          rescue StandardError => e
+            message =
+              "Internal error during IO transport request. Cause: #{e.class.name} #{e.message} " \
+                "Location: #{Array(e.backtrace).first}"
+
+            # Log error
+            if stats.consecutive_errors > 0
+              Datadog.logger.debug(message)
+            else
+              Datadog.logger.error(message)
+            end
+
+            # Update statistics
+            update_stats_from_exception!(e)
+
+            InternalErrorResponse.new(e)
+          end
+
+          def encode_data(encoder, request)
+            request.parcel.encode_with(encoder)
+          end
+
+          def write_data(out, data)
+            out.puts(data)
+          end
+
+          def build_response(_request, _data, result)
+            IO::Response.new(result)
+          end
+
+          private
+
+          def send_default_request(out, request)
+            # Encode data
+            data = @encode_block.call(encoder, request)
+
+            # Write to IO
+            result = @write_block.call(out, data)
+
+            # Generate a response
+            @response_block.call(request, data, result)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/tracing/transport/io/response.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require_relative '../../../core/transport/response'
+
+module Datadog
+  module Tracing
+    module Transport
+      module IO
+        # Response from HTTP transport for traces
+        class Response
+          include Datadog::Core::Transport::Response
+
+          attr_reader \
+            :result
+
+          def initialize(result)
+            @result = result
+          end
+
+          def ok?
+            true
+          end
+        end
+      end
+    end
+  end
+end