datadog 2.4.0 → 2.44.0

data/lib/datadog/core/remote/configuration/path.rb

@@ -30,21 +30,21 @@ module Datadog
 
               raise ParseError, "could not parse: #{path.inspect}" if m.nil?
 
-              org_id = m['org_id'] ? m['org_id'].to_i : nil
+              org_id = m["org_id"]&.to_i
 
-              source = m['source']
-              raise ParseError, 'missing source value' unless source
+              source = m["source"]
+              raise ParseError, "missing source value" unless source
 
               source = source.delete("/#{org_id}") if org_id
 
-              product = m['product']
-              raise ParseError, 'missing product value' unless product
+              product = m["product"]
+              raise ParseError, "missing product value" unless product
 
-              config_id = m['config_id']
-              raise ParseError, 'missing config_id value' unless config_id
+              config_id = m["config_id"]
+              raise ParseError, "missing config_id value" unless config_id
 
-              name = m['name']
-              raise ParseError, 'missing name value' unless name
+              name = m["name"]
+              raise ParseError, "missing name value" unless name
 
               new(source: source, org_id: org_id, product: product, config_id: config_id, name: name)
             end

data/lib/datadog/core/remote/configuration/repository.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require_relative 'content'
+require_relative "content"
 
 module Datadog
   module Core
@@ -80,7 +80,7 @@ module Datadog
               @targets_version = repository.targets_version
               @config_states = contents_to_config_states(repository.contents)
               @has_error = false
-              @error = ''
+              @error = ""
               @opaque_backend_state = repository.opaque_backend_state
               @cached_target_files = contents_to_cached_target_files(repository.contents)
             end
@@ -111,9 +111,9 @@ module Datadog
                   hashes: content.hashes.map do |algorithm, hexdigest|
                     {
                       algorithm: algorithm,
-                      hash: hexdigest
+                      hash: hexdigest,
                     }
-                  end
+                  end,
                 }
               end
             end
@@ -185,7 +185,7 @@ module Datadog
               end
             end
 
-            # Update existimng repository's contents
+            # Update existing repository's contents
             class Update
               attr_reader :path, :target, :content
 
@@ -237,6 +237,10 @@ module Datadog
                 @path = path
                 @previous = previous
               end
+
+              def type
+                :delete
+              end
             end
 
             # Insert change
@@ -247,6 +251,10 @@ module Datadog
                 @path = path
                 @content = content
               end
+
+              def type
+                :insert
+              end
             end
 
             # Update change
@@ -258,6 +266,10 @@ module Datadog
                 @content = content
                 @previous = previous
               end
+
+              def type
+                :update
+              end
             end
           end
 
@@ -272,7 +284,8 @@ module Datadog
 
               return deleted(path, previous) if previous && content.nil?
               return inserted(path, content) if content && previous.nil?
-              return updated(path, content, previous) if content && previous
+
+              updated(path, content, previous) if content && previous
             end
 
             def deleted(path, previous)

data/lib/datadog/core/remote/configuration/target.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-require_relative 'path'
-require_relative 'digest'
+require_relative "path"
+require_relative "digest"
 
 module Datadog
   module Core
@@ -11,8 +11,15 @@ module Datadog
         class TargetMap < Hash
           class << self
             def parse(hash)
-              opaque_backend_state = hash['signed']['custom']['opaque_backend_state']
-              version = hash['signed']['version']
+              signed = hash.fetch("signed")
+              # Note that the +dig+ call permits +hash['signed']+ to be
+              # missing the +custom+ subtree entirely.
+              # Previously the subtree was required but +opaque_backend_state+
+              # could still be missing (and obtained here as nil).
+              opaque_backend_state = signed.dig("custom", "opaque_backend_state")
+              # The version appears to be optional to the rest of this class,
+              # and we have tests that do not provide it.
+              version = signed["version"]
 
               map = new
 
@@ -21,7 +28,7 @@ module Datadog
                 @version = version
               end
 
-              hash['signed']['targets'].each_with_object(map) do |(p, t), m|
+              signed.fetch("targets").each_with_object(map) do |(p, t), m|
                 path = Configuration::Path.parse(p)
                 target = Configuration::Target.parse(t)
 
@@ -46,9 +53,9 @@ module Datadog
         class Target
           class << self
             def parse(hash)
-              length = Integer(hash['length'])
-              digests = Configuration::DigestList.parse(hash['hashes'])
-              version = Integer(hash['custom']['v'])
+              length = Integer(hash.fetch("length"))
+              digests = Configuration::DigestList.parse(hash.fetch("hashes"))
+              version = Integer(hash.dig("custom", "v"))
 
               new(digests: digests, length: length, version: version)
             end

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

@@ -1,9 +1,9 @@
 # frozen_string_literal: true
 
-require_relative 'configuration/path'
-require_relative 'configuration/content'
-require_relative 'configuration/target'
-require_relative 'configuration/repository'
+require_relative "configuration/path"
+require_relative "configuration/content"
+require_relative "configuration/target"
+require_relative "configuration/repository"
 
 module Datadog
   module Core

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

@@ -4,9 +4,9 @@ module Datadog
   module Core
     module Remote
       module Ext
-        ENV_ENABLED = 'DD_REMOTE_CONFIGURATION_ENABLED'
-        ENV_POLL_INTERVAL_SECONDS = 'DD_REMOTE_CONFIG_POLL_INTERVAL_SECONDS'
-        ENV_BOOT_TIMEOUT_SECONDS = 'DD_REMOTE_CONFIG_BOOT_TIMEOUT_SECONDS'
+        ENV_ENABLED = "DD_REMOTE_CONFIGURATION_ENABLED"
+        ENV_POLL_INTERVAL_SECONDS = "DD_REMOTE_CONFIG_POLL_INTERVAL_SECONDS"
+        ENV_BOOT_TIMEOUT_SECONDS = "DD_REMOTE_CONFIG_BOOT_TIMEOUT_SECONDS"
       end
     end
   end

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

@@ -1,17 +1,17 @@
 # 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, suppress_logging: {})
-          transport_options = {}
-          transport_options[:agent_settings] = agent_settings if agent_settings
+        attr_reader :logger
 
-          @transport_root = Datadog::Core::Remote::Transport::HTTP.root(**transport_options.dup)
+        def initialize(_settings, agent_settings, logger: Datadog.logger, suppress_logging: {})
+          @logger = logger
+          @transport_root = Datadog::Core::Remote::Transport::HTTP.root(agent_settings: agent_settings, logger: logger)
           @logged = suppress_logging
         end
 
@@ -20,7 +20,7 @@ module Datadog
 
           if res.internal_error? && network_error?(res.error)
             unless @logged[:agent_unreachable]
-              Datadog.logger.warn { "agent unreachable: cannot negotiate #{path}" }
+              logger.warn { "agent unreachable: cannot negotiate #{path}" }
               @logged[:agent_unreachable] = true
             end
 
@@ -29,7 +29,7 @@ module Datadog
 
           if res.not_found?
             unless @logged[:no_info_endpoint]
-              Datadog.logger.warn { "agent reachable but has no /info endpoint: cannot negotiate #{path}" }
+              logger.warn { "agent reachable but has no /info endpoint: cannot negotiate #{path}" }
               @logged[:no_info_endpoint] = true
             end
 
@@ -38,7 +38,7 @@ module Datadog
 
           unless res.ok?
             unless @logged[:unexpected_response]
-              Datadog.logger.warn { "agent reachable but unexpected response: cannot negotiate #{path}" }
+              logger.warn { "agent reachable but unexpected response: cannot negotiate #{path}" }
               @logged[:unexpected_response] = true
             end
 
@@ -47,14 +47,14 @@ module Datadog
 
           unless res.endpoints.include?(path)
             unless @logged[:no_config_endpoint]
-              Datadog.logger.warn { "agent reachable but does not report #{path}" }
+              logger.warn { "agent reachable but does not report #{path}" }
               @logged[:no_config_endpoint] = true
             end
 
             return false
           end
 
-          Datadog.logger.debug { "agent reachable and reports #{path}" }
+          logger.debug { "agent reachable and reports #{path}" }
 
           true
         end

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

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require_relative '../tie'
+require_relative "../tie"
 
 module Datadog
   module Core
@@ -17,18 +17,18 @@ module Datadog
 
             # TODO: this is not thread-consistent
             ready = Datadog::Core::Remote.active_remote.healthy
-            status = ready ? 'ready' : 'disconnected'
+            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)
+            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)
+              span.set_tag("_dd.rc.boot.time", boot.time)
 
               if boot.barrier == :timeout
-                span.set_tag('_dd.rc.boot.timeout', true)
+                span.set_tag("_dd.rc.boot.timeout", true)
               else
-                span.set_tag('_dd.rc.boot.ready', ready)
+                span.set_tag("_dd.rc.boot.ready", ready)
               end
             end
           end

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

@@ -1,56 +1,30 @@
 # frozen_string_literal: true
 
-require_relative '../../../core/transport/request'
-require_relative '../../../core/transport/parcel'
+require_relative "../../../core/transport/request"
+require_relative "../../../core/transport/parcel"
+require_relative "../../../core/transport/transport"
+require_relative "http/config"
 
 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!
+          class Transport < Core::Transport::Transport
             def send_config(payload)
-              json = JSON.dump(payload)
-              parcel = EncodedParcel.new(json)
+              encoder = Core::Encoding::JSONEncoder
+              parcel = Core::Transport::Parcel.new(
+                encoder.encode(payload),
+                content_type: encoder.content_type,
+              )
               request = Request.new(parcel)
 
-              @client.send_config_payload(request)
-            end
-
-            def current_api
-              @apis[HTTP::API::V7]
+              @client.send_request(:config, request)
             end
           end
         end

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

@@ -1,28 +1,11 @@
 # frozen_string_literal: true
 
-require 'json'
-
-require_relative '../config'
-require_relative 'client'
-require_relative '../../../utils/base64'
-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 '../../../core/transport/http/api/instance'
-require_relative 'api/instance'
-# Below should be:
-# require_relative '../../../core/transport/http/api/spec'
-require_relative 'api/spec'
+require "json"
+
+require_relative "../../../transport/http/api/endpoint"
+require_relative "../../../transport/http/response"
+require_relative "../../../utils/base64_codec"
+require_relative "../../../utils/truncation"
 
 module Datadog
   module Core
@@ -33,12 +16,13 @@ module Datadog
           module Config
             # Response from HTTP transport for remote configuration
             class Response
-              include Datadog::Core::Transport::HTTP::Response
-              include Core::Remote::Transport::Config::Response
+              include Core::Transport::HTTP::Response
 
-              def initialize(http_response, options = {}) # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/MethodLength,Metrics/PerceivedComplexity
+              def initialize(http_response, options = {}) # standard:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/MethodLength,Metrics/PerceivedComplexity
                 super(http_response)
 
+                raise AgentErrorResponse.new(http_response.code, http_response.payload) if http_response.code != 200
+
                 begin
                   payload = JSON.parse(http_response.payload, symbolize_names: true)
                 rescue JSON::ParserError => e
@@ -51,7 +35,7 @@ module Datadog
 
                 # TODO: these fallbacks should be improved
                 roots = payload[:roots] || []
-                targets = payload[:targets] || Datadog::Core::Utils::Base64.strict_encode64('{}')
+                targets = payload[:targets] || Datadog::Core::Utils::Base64Codec.strict_encode64("{}")
                 target_files = payload[:target_files] || []
                 client_configs = payload[:client_configs] || []
 
@@ -61,7 +45,7 @@ module Datadog
                   raise TypeError.new(String, root) unless root.is_a?(String)
 
                   decoded = begin
-                    Datadog::Core::Utils::Base64.strict_decode64(root) # TODO: unprocessed, don't symbolize_names
+                    Datadog::Core::Utils::Base64Codec.strict_decode64(root) # TODO: unprocessed, don't symbolize_names
                   rescue ArgumentError
                     raise DecodeError.new(:roots, root)
                   end
@@ -81,7 +65,7 @@ module Datadog
 
                 @targets = begin
                   decoded = begin
-                    Datadog::Core::Utils::Base64.strict_decode64(targets)
+                    Datadog::Core::Utils::Base64Codec.strict_decode64(targets)
                   rescue ArgumentError
                     raise DecodeError.new(:targets, targets)
                   end
@@ -109,14 +93,14 @@ module Datadog
                   raise TypeError.new(String, raw) unless raw.is_a?(String)
 
                   content = begin
-                    Datadog::Core::Utils::Base64.strict_decode64(raw)
+                    Datadog::Core::Utils::Base64Codec.strict_decode64(raw)
                   rescue ArgumentError
                     raise DecodeError.new(:target_files, raw)
                   end
 
                   {
                     path: h[:path].freeze,
-                    content: StringIO.new(content.freeze),
+                    content: content.freeze,
                   }
                 end.freeze
 
@@ -127,6 +111,12 @@ module Datadog
                 end.freeze
               end
 
+              attr_reader :roots, :targets, :target_files, :client_configs
+
+              def empty?
+                @empty
+              end
+
               def inspect
                 "#{super}, #{
                   {
@@ -146,8 +136,21 @@ module Datadog
                 end
               end
 
+              # Base class for Remote Configuration Config errors
+              class ConfigError < StandardError
+              end
+
+              # When the agent returned an error response to our request
+              class AgentErrorResponse < ConfigError
+                def initialize(code, body)
+                  truncated_body = Core::Utils::Truncation.truncate_in_middle(body, 700, 300)
+                  message = "Agent returned an error response: #{code}: #{truncated_body}"
+                  super(message)
+                end
+              end
+
               # When an expected value type is incorrect
-              class TypeError < StandardError
+              class TypeError < ConfigError
                 def initialize(type, value)
                   message = "not a #{type}: #{value.inspect}"
 
@@ -156,7 +159,7 @@ module Datadog
               end
 
               # When value decoding fails
-              class DecodeError < StandardError
+              class DecodeError < ConfigError
                 def initialize(key, value)
                   message = "could not decode key #{key.inspect}: #{value.inspect}"
 
@@ -165,7 +168,7 @@ module Datadog
               end
 
               # When value parsing fails
-              class ParseError < StandardError
+              class ParseError < ConfigError
                 def initialize(key, value)
                   message = "could not parse key #{key.inspect}: #{value.inspect}"
 
@@ -174,75 +177,10 @@ module Datadog
               end
             end
 
-            # Extensions for HTTP client
-            module Client
-              def send_config_payload(request)
-                send_request(request) do |api, env|
-                  api.send_config(env)
-                end
-              end
-            end
-
             module API
-              # Extensions for HTTP API Spec
-              module Spec
-                attr_reader :config
-
-                def config=(endpoint)
-                  @config = endpoint
-                end
-
-                def send_config(env, &block)
-                  raise NoConfigEndpointDefinedError, self if config.nil?
-
-                  config.call(env, &block)
-                end
-
-                # Raised when traces sent but no traces endpoint is defined
-                class NoConfigEndpointDefinedError < StandardError
-                  attr_reader :spec
-
-                  def initialize(spec)
-                    super()
-
-                    @spec = spec
-                  end
-
-                  def message
-                    'No config endpoint is defined for API specification!'
-                  end
-                end
-              end
-
-              # Extensions for HTTP API Instance
-              module Instance
-                def send_config(env)
-                  raise ConfigNotSupportedError, spec unless spec.is_a?(Config::API::Spec)
-
-                  spec.send_config(env) do |request_env|
-                    call(request_env)
-                  end
-                end
-
-                # Raised when traces sent to API that does not support traces
-                class ConfigNotSupportedError < StandardError
-                  attr_reader :spec
-
-                  def initialize(spec)
-                    super()
-
-                    @spec = spec
-                  end
-
-                  def message
-                    'Config not supported for this API!'
-                  end
-                end
-              end
-
               # Endpoint for remote configuration
               class Endpoint < Datadog::Core::Transport::HTTP::API::Endpoint
-                HEADER_CONTENT_TYPE = 'Content-Type'
+                HEADER_CONTENT_TYPE = "Content-Type"
 
                 attr_reader :encoder
 
@@ -257,7 +195,7 @@ module Datadog
                   env.body = env.request.parcel.data
 
                   # Query for response
-                  http_response = super(env, &block)
+                  http_response = super
 
                   response_options = {}
 
@@ -266,12 +204,6 @@ module Datadog
                 end
               end
             end
-
-            # Add remote configuration behavior to transport components
-            ###### overrides send_payload! which calls send_<endpoint>! kills any other possible endpoint!
-            HTTP::Client.include(Config::Client)
-            HTTP::API::Spec.include(Config::API::Spec)
-            HTTP::API::Instance.include(Config::API::Instance)
           end
         end
       end