ddtrace 1.12.1 → 1.23.2

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

@@ -1,42 +1,55 @@
 # frozen_string_literal: true
 
-require_relative '../transport/http'
+require_relative 'transport/http'
 
 module Datadog
   module Core
     module Remote
       # Endpoint negotiation
       class Negotiation
-        def initialize(_settings, agent_settings)
+        def initialize(_settings, agent_settings, suppress_logging: {})
           transport_options = {}
           transport_options[:agent_settings] = agent_settings if agent_settings
 
-          @transport_root = Datadog::Core::Transport::HTTP.root(**transport_options.dup)
+          @transport_root = Datadog::Core::Remote::Transport::HTTP.root(**transport_options.dup)
+          @logged = suppress_logging
         end
 
         def endpoint?(path)
           res = @transport_root.send_info
 
           if res.internal_error? && network_error?(res.error)
-            Datadog.logger.error { "agent unreachable: cannot negotiate #{path}" }
+            unless @logged[:agent_unreachable]
+              Datadog.logger.error { "agent unreachable: cannot negotiate #{path}" }
+              @logged[:agent_unreachable] = true
+            end
 
             return false
           end
 
           if res.not_found?
-            Datadog.logger.error { "agent reachable but has no /info endpoint: cannot negotiate #{path}" }
+            unless @logged[:no_info_endpoint]
+              Datadog.logger.error { "agent reachable but has no /info endpoint: cannot negotiate #{path}" }
+              @logged[:no_info_endpoint] = true
+            end
 
             return false
           end
 
           unless res.ok?
-            Datadog.logger.error { "agent reachable but unexpected response: cannot negotiate #{path}" }
+            unless @logged[:unexpected_response]
+              Datadog.logger.error { "agent reachable but unexpected response: cannot negotiate #{path}" }
+              @logged[:unexpected_response] = true
+            end
 
             return false
           end
 
           unless res.endpoints.include?(path)
-            Datadog.logger.error { "agent reachable but does not report #{path}" }
+            unless @logged[:no_config_endpoint]
+              Datadog.logger.error { "agent reachable but does not report #{path}" }
+              @logged[:no_config_endpoint] = true
+            end
 
             return false
           end

data/lib/datadog/core/remote/tie/tracing.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require_relative '../tie'
+
+module Datadog
+  module Core
+    module Remote
+      module Tie
+        # Extend Remote Configuration abilities with Tracing
+        module Tracing
+          # Tag per-request Remote Configuration metadata using Tracing
+          def self.tag(boot, span)
+            return if boot.nil?
+            return if span.nil?
+
+            return if Datadog::Core::Remote.active_remote.nil?
+
+            # TODO: this is not thread-consistent
+            ready = Datadog::Core::Remote.active_remote.healthy
+            status = ready ? 'ready' : 'disconnected'
+
+            span.set_tag('_dd.rc.client_id', Datadog::Core::Remote.active_remote.client.id)
+            span.set_tag('_dd.rc.status', status)
+
+            if boot.barrier != :pass
+              span.set_tag('_dd.rc.boot.time', boot.time)
+
+              if boot.barrier == :timeout
+                span.set_tag('_dd.rc.boot.timeout', true)
+              else
+                span.set_tag('_dd.rc.boot.ready', ready)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Datadog
+  module Core
+    module Remote
+      # Provide Remote Configuration extensions to other components
+      module Tie
+        Boot = Struct.new(
+          :barrier,
+          :time,
+        )
+
+        def self.boot
+          return if Datadog::Core::Remote.active_remote.nil?
+
+          barrier = nil
+
+          t = Datadog::Core::Utils::Time.measure do
+            barrier = Datadog::Core::Remote.active_remote.barrier(:once)
+          end
+
+          Boot.new(barrier, t)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require_relative '../../../core/transport/request'
+require_relative '../../../core/transport/parcel'
+
+module Datadog
+  module Core
+    module Remote
+      module Transport
+        module Config
+          # Data transfer object for encoded traces
+          class EncodedParcel
+            include Datadog::Core::Transport::Parcel
+
+            def count
+              data.length
+            end
+          end
+
+          # Config request
+          class Request < Datadog::Core::Transport::Request
+          end
+
+          # Config response
+          module Response
+            attr_reader :roots, :targets, :target_files, :client_configs
+
+            def empty?
+              @empty
+            end
+          end
+
+          # Config transport
+          class Transport
+            attr_reader :client, :apis, :default_api, :current_api_id
+
+            def initialize(apis, default_api)
+              @apis = apis
+
+              @client = HTTP::Client.new(current_api)
+            end
+
+            ##### there is only one transport! it's negotiation!
+            def send_config(payload)
+              json = JSON.dump(payload)
+              parcel = EncodedParcel.new(json)
+              request = Request.new(parcel)
+
+              @client.send_config_payload(request)
+            end
+
+            def current_api
+              @apis[HTTP::API::V7]
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Datadog
+  module Core
+    module Remote
+      module Transport
+        module HTTP
+          module API
+            # An API configured with adapter and routes
+            class Instance
+              attr_reader \
+                :adapter,
+                :headers,
+                :spec
+
+              def initialize(spec, adapter, options = {})
+                @spec = spec
+                @adapter = adapter
+                @headers = options.fetch(:headers, {})
+              end
+
+              def encoder
+                spec.encoder
+              end
+
+              def call(env)
+                # Add headers to request env, unless empty.
+                env.headers.merge!(headers) unless headers.empty?
+
+                # Send request env to the adapter.
+                adapter.call(env)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Datadog
+  module Core
+    module Remote
+      module Transport
+        module HTTP
+          module API
+            # Specification for an HTTP API
+            # Defines behaviors without specific configuration details.
+            class Spec
+              def initialize
+                yield(self) if block_given?
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require_relative '../../../encoding'
+require_relative '../../../transport/http/api/map'
+
+# TODO: Decouple standard transport/http/api/instance
+#
+# Separate classes are needed because transport/http/traces 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/spec'
+require_relative 'api/spec'
+
+# TODO: only needed for Negotiation::API::Endpoint
+require_relative 'negotiation'
+
+# TODO: only needed for Config::API::Endpoint
+require_relative 'config'
+
+module Datadog
+  module Core
+    module Remote
+      module Transport
+        module HTTP
+          # Namespace for API components
+          module API
+            # Default API versions
+            ROOT = 'root'
+            V7 = 'v0.7'
+
+            module_function
+
+            def defaults
+              Datadog::Core::Transport::HTTP::API::Map[
+                ROOT => Spec.new do |s|
+                  s.info = Negotiation::API::Endpoint.new(
+                    '/info',
+                  )
+                end,
+                V7 => Spec.new do |s|
+                  s.config = Config::API::Endpoint.new(
+                    '/v0.7/config',
+                    Core::Encoding::JSONEncoder,
+                  )
+                end,
+              ]
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,219 @@
+# frozen_string_literal: true
+
+require_relative '../../../configuration/agent_settings_resolver'
+require_relative '../../../transport/http/adapters/registry'
+require_relative '../../../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 '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 Remote
+      module Transport
+        module HTTP
+          # Builds new instances of Transport::HTTP::Client
+          class Builder
+            REGISTRY = Datadog::Core::Transport::HTTP::Adapters::Registry.new
+
+            attr_reader \
+              :apis,
+              :api_options,
+              :default_adapter,
+              :default_api,
+              :default_headers
+
+            def initialize
+              # Global settings
+              @default_adapter = nil
+              @default_headers = {}
+
+              # Client settings
+              @apis = Datadog::Core::Transport::HTTP::API::Map.new
+              @default_api = nil
+
+              # API settings
+              @api_options = {}
+
+              yield(self) if block_given?
+            end
+
+            def adapter(config, *args, **kwargs)
+              @default_adapter = case config
+                                 when Core::Configuration::AgentSettingsResolver::AgentSettings
+                                   registry_klass = REGISTRY.get(config.adapter)
+                                   raise UnknownAdapterError, config.adapter if registry_klass.nil?
+
+                                   registry_klass.build(config)
+                                 when Symbol
+                                   registry_klass = REGISTRY.get(config)
+                                   raise UnknownAdapterError, config if registry_klass.nil?
+
+                                   registry_klass.new(*args, **kwargs)
+                                 else
+                                   config
+                                 end
+            end
+
+            def headers(values = {})
+              @default_headers.merge!(values)
+            end
+
+            # Adds a new API to the client
+            # Valid options:
+            #  - :adapter
+            #  - :default
+            #  - :fallback
+            #  - :headers
+            def api(key, spec, options = {})
+              options = options.dup
+
+              # Copy spec into API map
+              @apis[key] = spec
+
+              # Apply as default API, if specified to do so.
+              @default_api = key if options.delete(:default) || @default_api.nil?
+
+              # Save all other settings for initialization
+              (@api_options[key] ||= {}).merge!(options)
+            end
+
+            def default_api=(key)
+              raise UnknownApiError, key unless @apis.key?(key)
+
+              @default_api = key
+            end
+
+            def to_transport(klass)
+              raise NoDefaultApiError if @default_api.nil?
+
+              klass.new(to_api_instances, @default_api)
+            end
+
+            def to_api_instances
+              raise NoApisError if @apis.empty?
+
+              @apis.inject(Datadog::Core::Transport::HTTP::API::Map.new) do |instances, (key, spec)|
+                instances.tap do
+                  api_options = @api_options[key].dup
+
+                  # Resolve the adapter to use for this API
+                  adapter = api_options.delete(:adapter) || @default_adapter
+                  raise NoAdapterForApiError, key if adapter.nil?
+
+                  # Resolve fallback and merge headers
+                  fallback = api_options.delete(:fallback)
+                  api_options[:headers] = @default_headers.merge((api_options[:headers] || {}))
+
+                  # Add API::Instance with all settings
+                  instances[key] = api_instance_class.new(
+                    spec,
+                    adapter,
+                    api_options
+                  )
+
+                  # Configure fallback, if provided.
+                  instances.with_fallbacks(key => fallback) unless fallback.nil?
+                end
+              end
+            end
+
+            def api_instance_class
+              API::Instance
+            end
+
+            # 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}'!"
+              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}'!"
+              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}'!"
+              end
+            end
+
+            # Raised when built without defining APIs.
+            class NoApisError < StandardError
+              def message
+                'No APIs configured for transport!'
+              end
+            end
+
+            # Raised when client built without defining a default API.
+            class NoDefaultApiError < StandardError
+              def message
+                'No default API configured for transport!'
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require_relative '../../../../core/transport/http/env'
+require_relative '../../../../core/transport/http/response'
+
+# 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.
+
+module Datadog
+  module Core
+    module Remote
+      module Transport
+        module HTTP
+          # Routes, encodes, and sends tracer data to the trace agent via HTTP.
+          class Client
+            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
+              yield(api, env)
+            rescue StandardError => e
+              message =
+                "Internal error during #{self.class.name} request. Cause: #{e.class.name} #{e.message} " \
+                  "Location: #{Array(e.backtrace).first}"
+
+              Datadog.logger.debug(message)
+
+              Datadog::Core::Transport::InternalErrorResponse.new(e)
+            end
+
+            def build_env(request)
+              Datadog::Core::Transport::HTTP::Env.new(request)
+            end
+          end
+        end
+      end
+    end
+  end
+end