ddtrace 1.14.0 → 1.16.2

data/lib/datadog/core/remote/transport/http/negotiation.rb

@@ -0,0 +1,146 @@
+# frozen_string_literal: true
+
+require 'json'
+
+require_relative '../negotiation'
+require_relative 'client'
+require_relative '../../../transport/http/response'
+require_relative '../../../transport/http/api/endpoint'
+
+# 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 'api/instance'
+# Below should be:
+# require_relative '../../../../ddtrace/transport/http/api/spec'
+require_relative 'api/spec'
+
+module Datadog
+  module Core
+    module Remote
+      module Transport
+        module HTTP
+          # HTTP transport behavior for agent feature negotiation
+          module Negotiation
+            # Response from HTTP transport for agent feature negotiation
+            class Response
+              include Datadog::Core::Transport::HTTP::Response
+              include Core::Remote::Transport::Negotiation::Response
+
+              def initialize(http_response, options = {})
+                super(http_response)
+
+                # TODO: transform endpoint hash in a better object for negotiation
+                # TODO: transform config in a better object, notably config has max_request_bytes
+                @version = options[:version]
+                @endpoints = options[:endpoints]
+                @config = options[:config]
+              end
+            end
+
+            # Extensions for HTTP client
+            module Client
+              def send_info_payload(request)
+                send_request(request) do |api, env|
+                  api.send_info(env)
+                end
+              end
+            end
+
+            module API
+              # Extensions for HTTP API Spec
+              module Spec
+                attr_reader :info
+
+                def info=(endpoint)
+                  @info = endpoint
+                end
+
+                def send_info(env, &block)
+                  raise NoNegotiationEndpointDefinedError, self if info.nil?
+
+                  info.call(env, &block)
+                end
+
+                # Raised when traces sent but no traces endpoint is defined
+                class NoNegotiationEndpointDefinedError < StandardError
+                  attr_reader :spec
+
+                  def initialize(spec)
+                    super()
+
+                    @spec = spec
+                  end
+
+                  def message
+                    'No info endpoint is defined for API specification!'
+                  end
+                end
+              end
+
+              # Extensions for HTTP API Instance
+              module Instance
+                def send_info(env)
+                  raise NegotiationNotSupportedError, spec unless spec.is_a?(Negotiation::API::Spec)
+
+                  spec.send_info(env) do |request_env|
+                    call(request_env)
+                  end
+                end
+
+                # Raised when traces sent to API that does not support traces
+                class NegotiationNotSupportedError < StandardError
+                  attr_reader :spec
+
+                  def initialize(spec)
+                    super()
+
+                    @spec = spec
+                  end
+
+                  def message
+                    'Info not supported for this API!'
+                  end
+                end
+              end
+
+              # Endpoint for negotiation
+              class Endpoint < Datadog::Core::Transport::HTTP::API::Endpoint
+                def initialize(path)
+                  super(:get, path)
+                end
+
+                def call(env, &block)
+                  # Query for response
+                  http_response = super(env, &block)
+
+                  # Process the response
+                  body = JSON.parse(http_response.payload, symbolize_names: true) if http_response.ok?
+
+                  # TODO: there should be more processing here to ensure a proper response_options
+                  response_options = body.is_a?(Hash) ? body : {}
+
+                  # Build and return a trace response
+                  Negotiation::Response.new(http_response, response_options)
+                end
+              end
+            end
+
+            # Add negotiation behavior to transport components
+            HTTP::Client.include(Negotiation::Client)
+            HTTP::API::Spec.include(Negotiation::API::Spec)
+            HTTP::API::Instance.include(Negotiation::API::Instance)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,179 @@
+# frozen_string_literal: true
+
+require 'uri'
+
+require_relative '../../environment/container'
+require_relative '../../environment/ext'
+require_relative '../../transport/ext'
+require_relative '../../transport/http/adapters/net'
+require_relative '../../transport/http/adapters/unix_socket'
+require_relative '../../transport/http/adapters/test'
+
+# TODO: Improve negotiation to allow per endpoint selection
+#
+# Since endpoint negotiation happens at the `API::Spec` level there can not be
+# a mix of endpoints at various versions or versionless without describing all
+# the possible combinations as specs. See http/api.
+#
+# Below should be:
+# require_relative '../../transport/http/api'
+require_relative 'http/api'
+
+# TODO: Decouple transport/http/builder
+#
+# See http/builder
+#
+# Below should be:
+# require_relative '../../transport/http/builder'
+require_relative 'http/builder'
+
+# TODO: Decouple transport/http
+#
+# Because a new transport is required for every (API, Client, Transport)
+# triplet and endpoints cannot be negotiated independently, there can not be a
+# single `default` transport, but only endpoint-specific ones.
+
+module Datadog
+  module Core
+    module Remote
+      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(klass, &block)
+            Builder.new(&block).to_transport(klass)
+          end
+
+          # Builds a new Transport::HTTP::Client with default settings
+          # Pass a block to override any settings.
+          def root(
+            agent_settings: DO_NOT_USE_ENVIRONMENT_AGENT_SETTINGS,
+            **options
+          )
+            new(Core::Remote::Transport::Negotiation::Transport) do |transport|
+              transport.adapter(agent_settings)
+              transport.headers(default_headers)
+
+              apis = API.defaults
+
+              transport.api API::ROOT, apis[API::ROOT]
+
+              # 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
+
+          # Builds a new Transport::HTTP::Client with default settings
+          # Pass a block to override any settings.
+          def v7(
+            agent_settings: DO_NOT_USE_ENVIRONMENT_AGENT_SETTINGS,
+            **options
+          )
+            new(Core::Remote::Transport::Config::Transport) do |transport|
+              transport.adapter(agent_settings)
+              transport.headers default_headers
+
+              apis = API.defaults
+
+              transport.api API::V7, apis[API::V7]
+
+              # 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_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
+end

data/lib/datadog/core/{transport → remote/transport}/negotiation.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require_relative '../../../ddtrace/transport/request'
+require_relative '../../../core/transport/request'
 
 # TODO: Resolve conceptual conundrum
 #
@@ -23,35 +23,37 @@ require_relative '../../../ddtrace/transport/request'
 
 module Datadog
   module Core
-    module Transport
-      module Negotiation
-        # Negotiation request
-        class Request < Datadog::Transport::Request
-        end
+    module Remote
+      module Transport
+        module Negotiation
+          # Negotiation request
+          class Request < Datadog::Core::Transport::Request
+          end
 
-        # Negotiation response
-        module Response
-          attr_reader :version, :endpoints, :config
-        end
+          # Negotiation response
+          module Response
+            attr_reader :version, :endpoints, :config
+          end
 
-        # Negotiation transport
-        class Transport
-          attr_reader :client, :apis, :default_api, :current_api_id
+          # Negotiation transport
+          class Transport
+            attr_reader :client, :apis, :default_api, :current_api_id
 
-          def initialize(apis, default_api)
-            @apis = apis
+            def initialize(apis, default_api)
+              @apis = apis
 
-            @client = HTTP::Client.new(current_api)
-          end
+              @client = HTTP::Client.new(current_api)
+            end
 
-          def send_info
-            request = Request.new
+            def send_info
+              request = Request.new
 
-            @client.send_info_payload(request)
-          end
+              @client.send_info_payload(request)
+            end
 
-          def current_api
-            @apis[HTTP::API::ROOT]
+            def current_api
+              @apis[HTTP::API::ROOT]
+            end
           end
         end
       end

data/lib/datadog/core/remote/worker.rb

@@ -28,7 +28,9 @@ module Datadog
 
           @starting = true
 
-          @thr = Thread.new { poll(@interval) }
+          thread = Thread.new { poll(@interval) }
+          thread.name = self.class.name unless Gem::Version.new(RUBY_VERSION) < Gem::Version.new('2.3')
+          @thr = thread
 
           @started = true
           @starting = false

data/lib/datadog/core/telemetry/collector.rb

@@ -11,7 +11,7 @@ require_relative 'v1/dependency'
 require_relative 'v1/host'
 require_relative 'v1/integration'
 require_relative 'v1/product'
-require_relative '../../../ddtrace/transport/ext'
+require_relative '../transport/ext'
 
 module Datadog
   module Core
@@ -146,6 +146,7 @@ module Datadog
           options['logger.instance'] = configuration.logger.instance.class.to_s
           options['appsec.enabled'] = configuration.dig('appsec', 'enabled') if configuration.respond_to?('appsec')
           options['tracing.opentelemetry.enabled'] = !defined?(Datadog::OpenTelemetry::LOADED).nil?
+          options['tracing.opentracing.enabled'] = !defined?(Datadog::OpenTracer::LOADED).nil?
           options.compact!
           options
         end
@@ -190,7 +191,7 @@ module Datadog
 
         def agent_transport
           adapter = Core::Configuration::AgentSettingsResolver.call(Datadog.configuration).adapter
-          if adapter == Datadog::Transport::Ext::UnixSocket::ADAPTER
+          if adapter == Datadog::Core::Transport::Ext::UnixSocket::ADAPTER
             'UDS'
           else
             'TCP'

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

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative '../../configuration/settings'
+require_relative '../../transport/ext'
 require_relative 'env'
 require_relative 'ext'
 require_relative 'adapters/net'
@@ -38,7 +39,7 @@ module Datadog
 
           def headers(request_type:, api_version: Http::Ext::API_VERSION)
             {
-              Datadog::Transport::Ext::HTTP::HEADER_DD_INTERNAL_UNTRACED_REQUEST => '1',
+              Datadog::Core::Transport::Ext::HTTP::HEADER_DD_INTERNAL_UNTRACED_REQUEST => '1',
               Http::Ext::HEADER_CONTENT_TYPE => Http::Ext::CONTENT_TYPE_APPLICATION_JSON,
               Http::Ext::HEADER_DD_TELEMETRY_API_VERSION => api_version,
               Http::Ext::HEADER_DD_TELEMETRY_REQUEST_TYPE => request_type,

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

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require_relative '../configuration/ext'
+# DEV(2.0): This file should replace /ddtrace/transport/ext.rb
+# WARN: This file is used in /dd trace/transport/ext.rb which is a public API. Any changes here
+# should be treated as changes to a public API.
+module Datadog
+  module Core
+    module Transport
+      module Ext
+        module HTTP
+          ADAPTER = Datadog::Core::Configuration::Ext::Agent::HTTP::ADAPTER
+          DEFAULT_HOST = Datadog::Core::Configuration::Ext::Agent::HTTP::DEFAULT_HOST
+          DEFAULT_PORT = Datadog::Core::Configuration::Ext::Agent::HTTP::DEFAULT_PORT
+
+          HEADER_CONTAINER_ID = 'Datadog-Container-ID'
+          HEADER_DD_API_KEY = 'DD-API-KEY'
+          # Tells agent that `_dd.top_level` metrics have been set by the tracer.
+          # The agent will not calculate top-level spans but instead trust the tracer tagging.
+          #
+          # This prevents partially flushed traces being mistakenly marked as top-level.
+          #
+          # Setting this header to any non-empty value enables this feature.
+          HEADER_CLIENT_COMPUTED_TOP_LEVEL = 'Datadog-Client-Computed-Top-Level'
+          HEADER_META_LANG = 'Datadog-Meta-Lang'
+          HEADER_META_LANG_VERSION = 'Datadog-Meta-Lang-Version'
+          HEADER_META_LANG_INTERPRETER = 'Datadog-Meta-Lang-Interpreter'
+          HEADER_META_TRACER_VERSION = 'Datadog-Meta-Tracer-Version'
+
+          # Header that prevents the Net::HTTP integration from tracing internal trace requests.
+          # Set it to any value to skip tracing.
+          HEADER_DD_INTERNAL_UNTRACED_REQUEST = 'DD-Internal-Untraced-Request'
+        end
+
+        module Test
+          ADAPTER = :test
+        end
+
+        module UnixSocket
+          ADAPTER = Datadog::Core::Configuration::Ext::Agent::UnixSocket::ADAPTER
+          DEFAULT_PATH = Datadog::Core::Configuration::Ext::Agent::UnixSocket::DEFAULT_PATH
+          DEFAULT_TIMEOUT_SECONDS = Datadog::Core::Configuration::Ext::Agent::UnixSocket::DEFAULT_TIMEOUT_SECONDS
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,168 @@
+# frozen_string_literal: true
+
+require_relative '../../../../core/transport/response'
+require_relative '../../../../core/vendor/multipart-post/net/http/post/multipart'
+
+module Datadog
+  module Core
+    module Transport
+      module HTTP
+        module Adapters
+          # Adapter for Net::HTTP
+          class Net
+            attr_reader \
+              :hostname,
+              :port,
+              :timeout,
+              :ssl
+
+            # in seconds
+            DEFAULT_TIMEOUT = 30
+
+            # @deprecated Positional parameters are deprecated. Use named parameters instead.
+            def initialize(hostname = nil, port = nil, **options)
+              @hostname = hostname || options.fetch(:hostname)
+              @port = port || options.fetch(:port)
+              @timeout = options[:timeout] || DEFAULT_TIMEOUT
+              @ssl = options.key?(:ssl) ? options[:ssl] == true : false
+            end
+
+            def self.build(agent_settings)
+              new(
+                hostname: agent_settings.hostname,
+                port: agent_settings.port,
+                timeout: agent_settings.timeout_seconds,
+                ssl: agent_settings.ssl
+              )
+            end
+
+            def open(&block)
+              # DEV Initializing +Net::HTTP+ directly help us avoid expensive
+              # options processing done in +Net::HTTP.start+:
+              # https://github.com/ruby/ruby/blob/b2d96abb42abbe2e01f010ffc9ac51f0f9a50002/lib/net/http.rb#L614-L618
+              req = ::Net::HTTP.new(hostname, port, nil)
+
+              req.use_ssl = ssl
+              req.open_timeout = req.read_timeout = timeout
+
+              req.start(&block)
+            end
+
+            def call(env)
+              if respond_to?(env.verb)
+                send(env.verb, env)
+              else
+                raise UnknownHTTPMethod, env
+              end
+            end
+
+            def get(env)
+              get = ::Net::HTTP::Get.new(env.path, env.headers)
+
+              # Connect and send the request
+              http_response = open do |http|
+                http.request(get)
+              end
+
+              # Build and return response
+              Response.new(http_response)
+            end
+
+            def post(env)
+              post = nil
+
+              if env.form.nil? || env.form.empty?
+                post = ::Net::HTTP::Post.new(env.path, env.headers)
+                post.body = env.body
+              else
+                post = ::Datadog::Core::Vendor::Net::HTTP::Post::Multipart.new(
+                  env.path,
+                  env.form,
+                  env.headers
+                )
+              end
+
+              # Connect and send the request
+              http_response = open do |http|
+                http.request(post)
+              end
+
+              # Build and return response
+              Response.new(http_response)
+            end
+
+            def url
+              "http://#{hostname}:#{port}?timeout=#{timeout}"
+            end
+
+            # Raised when called with an unknown HTTP method
+            class UnknownHTTPMethod < StandardError
+              attr_reader :verb
+
+              def initialize(verb)
+                super("No matching Net::HTTP function for '#{verb}'!")
+              end
+            end
+
+            # A wrapped Net::HTTP response that implements the Transport::Response interface
+            class Response
+              include Datadog::Core::Transport::Response
+
+              attr_reader :http_response
+
+              def initialize(http_response)
+                @http_response = http_response
+              end
+
+              def payload
+                return super if http_response.nil?
+
+                http_response.body
+              end
+
+              def code
+                return super if http_response.nil?
+
+                http_response.code.to_i
+              end
+
+              def ok?
+                return super if http_response.nil?
+
+                code.between?(200, 299)
+              end
+
+              def unsupported?
+                return super if http_response.nil?
+
+                code == 415
+              end
+
+              def not_found?
+                return super if http_response.nil?
+
+                code == 404
+              end
+
+              def client_error?
+                return super if http_response.nil?
+
+                code.between?(400, 499)
+              end
+
+              def server_error?
+                return super if http_response.nil?
+
+                code.between?(500, 599)
+              end
+
+              def inspect
+                "#{super}, http_response:#{http_response}"
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Datadog
+  module Core
+    module Transport
+      module HTTP
+        module Adapters
+          # List of available adapters
+          class Registry
+            def initialize
+              @adapters = {}
+            end
+
+            def get(name)
+              @adapters[name]
+            end
+
+            def set(klass, name = nil)
+              name ||= klass.to_s
+              return if name.nil?
+
+              @adapters[name] = klass
+            end
+          end
+        end
+      end
+    end
+  end
+end