datadog 2.17.0 → 2.37.0

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

@@ -2,9 +2,8 @@
 
 require_relative '../../../transport/http/api/endpoint'
 require_relative '../../../transport/http/api/instance'
-require_relative '../../../transport/http/api/spec'
+require_relative '../../../transport/http/client'
 require_relative '../../../transport/request'
-require_relative 'client'
 
 module Datadog
   module Core
@@ -12,35 +11,7 @@ module Datadog
       module Transport
         module HTTP
           module Telemetry
-            module Client
-              def send_telemetry_payload(request)
-                send_request(request) do |api, env| # steep:ignore
-                  api.send_telemetry(env)
-                end
-              end
-            end
-
             module API
-              class Instance < Core::Transport::HTTP::API::Instance
-                def send_telemetry(env)
-                  raise Core::Transport::HTTP::API::Instance::EndpointNotSupportedError.new('telemetry', self) unless spec.is_a?(Telemetry::API::Spec)
-
-                  spec.send_telemetry(env) do |request_env|
-                    call(request_env)
-                  end
-                end
-              end
-
-              class Spec < Core::Transport::HTTP::API::Spec
-                attr_accessor :telemetry
-
-                def send_telemetry(env, &block)
-                  raise Core::Transport::HTTP::API::Spec::EndpointNotDefinedError.new('telemetry', self) if telemetry.nil?
-
-                  telemetry.call(env, &block)
-                end
-              end
-
               class Endpoint < Datadog::Core::Transport::HTTP::API::Endpoint
                 HEADER_CONTENT_TYPE = 'Content-Type'
 
@@ -64,27 +35,30 @@ module Datadog
                   super
                 end
 
-                def headers(request_type:, api_key:, api_version: 'v2')
+                def headers(request_type:, api_key:)
                   {
                     Core::Transport::Ext::HTTP::HEADER_DD_INTERNAL_UNTRACED_REQUEST => '1',
                     # Provided by encoder
                     # 'Content-Type' => 'application/json',
-                    'DD-Telemetry-API-Version' => api_version,
+                    'DD-Telemetry-API-Version' => 'v2',
                     'DD-Telemetry-Request-Type' => request_type,
                     'DD-Client-Library-Language' => Core::Environment::Ext::LANG,
                     'DD-Client-Library-Version' => Core::Environment::Identity.gem_datadog_version_semver2,
+                    'DD-Session-ID' => Core::Environment::Identity.id,
 
                     # Enable debug mode for telemetry
                     # 'DD-Telemetry-Debug-Enabled' => 'true',
                   }.tap do |result|
                     result['DD-API-KEY'] = api_key unless api_key.nil?
+                    root = Core::Environment::Identity.root_runtime_id
+                    result['DD-Root-Session-ID'] = root if root
+                    parent = Core::Environment::Identity.parent_runtime_id
+                    result['DD-Parent-Session-ID'] = parent if parent
                   end
                 end
               end
             end
           end
-
-          HTTP::Client.include(Telemetry::Client)
         end
       end
     end

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

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
-require_relative 'telemetry'
-require_relative 'http/api'
+require_relative '../../encoding'
 require_relative '../../transport/http'
+require_relative 'telemetry'
 
 module Datadog
   module Core
@@ -10,6 +10,16 @@ module Datadog
       module Transport
         # Namespace for HTTP transport components
         module HTTP
+          AGENT_TELEMETRY = Telemetry::API::Endpoint.new(
+            '/telemetry/proxy/api/v2/apmtelemetry',
+            Core::Encoding::JSONEncoder,
+          )
+
+          AGENTLESS_TELEMETRY = Telemetry::API::Endpoint.new(
+            '/api/v2/apmtelemetry',
+            Core::Encoding::JSONEncoder,
+          )
+
           module_function
 
           # Builds a new Transport::HTTP::Client with default settings
@@ -18,18 +28,14 @@ module Datadog
             agent_settings:,
             logger:,
             api_key: nil,
-            api_version: nil,
             headers: nil
           )
-            Core::Transport::HTTP.build(api_instance_class: Telemetry::API::Instance,
+            Core::Transport::HTTP.build(
               logger: logger,
               agent_settings: agent_settings,
-              api_version: api_version,
-              headers: headers) do |transport|
-              apis = API.defaults
-
-              transport.api API::AGENTLESS_TELEMETRY, apis[API::AGENTLESS_TELEMETRY]
-
+              headers: headers
+            ) do |transport|
+              transport.api 'agentless_telemetry', AGENTLESS_TELEMETRY
               # Call block to apply any customization, if provided
               yield(transport) if block_given?
             end.to_transport(Core::Telemetry::Transport::Telemetry::Transport).tap do |transport|
@@ -42,15 +48,14 @@ module Datadog
           def agent_telemetry(
             agent_settings:,
             logger:,
-            api_version: nil,
             headers: nil
           )
-            Core::Transport::HTTP.build(api_instance_class: Telemetry::API::Instance,
+            Core::Transport::HTTP.build(
               logger: logger,
-              agent_settings: agent_settings, api_version: api_version, headers: headers) do |transport|
-              apis = API.defaults
-
-              transport.api API::AGENT_TELEMETRY, apis[API::AGENT_TELEMETRY]
+              agent_settings: agent_settings,
+              headers: headers
+            ) do |transport|
+              transport.api 'agent_telemetry', AGENT_TELEMETRY
 
               # Call block to apply any customization, if provided
               yield(transport) if block_given?

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

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 require_relative '../../transport/parcel'
-require_relative 'http/client'
+require_relative '../../transport/transport'
 require_relative 'http/telemetry'
 
 module Datadog
@@ -9,10 +9,6 @@ module Datadog
     module Telemetry
       module Transport
         module Telemetry
-          class EncodedParcel
-            include Datadog::Core::Transport::Parcel
-          end
-
           class Request < Datadog::Core::Transport::Request
             attr_reader :request_type
             attr_reader :api_key
@@ -24,23 +20,18 @@ module Datadog
             end
           end
 
-          class Transport
-            attr_reader :client, :apis, :default_api, :current_api_id, :logger
+          class Transport < Core::Transport::Transport
             attr_accessor :api_key
 
-            def initialize(apis, default_api, logger:)
-              @apis = apis
-              @logger = logger
-
-              @client = HTTP::Client.new(@apis[default_api], logger: logger)
-            end
-
             def send_telemetry(request_type:, 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(request_type, parcel, api_key)
 
-              @client.send_telemetry_payload(request)
+              @client.send_request(:telemetry, request)
               # Perform no error checking here
             end
           end

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

@@ -9,7 +9,10 @@ require_relative '../workers/queue'
 module Datadog
   module Core
     module Telemetry
-      # Accumulates events and sends them to the API at a regular interval, including heartbeat event.
+      # Accumulates events and sends them to the API at a regular interval,
+      # including heartbeat event.
+      #
+      # @api private
       class Worker
         include Core::Workers::Queue
         include Core::Workers::Polling
@@ -24,6 +27,9 @@ module Datadog
           metrics_manager:,
           dependency_collection:,
           logger:,
+          settings:,
+          agent_settings:,
+          extended_heartbeat_interval_seconds:,
           enabled: true,
           shutdown_timeout: Workers::Polling::DEFAULT_SHUTDOWN_TIMEOUT,
           buffer_size: DEFAULT_BUFFER_MAX_SIZE
@@ -32,33 +38,50 @@ module Datadog
           @metrics_manager = metrics_manager
           @dependency_collection = dependency_collection
           @logger = logger
+          @settings = settings
+          @agent_settings = agent_settings
 
           @ticks_per_heartbeat = (heartbeat_interval_seconds / metrics_aggregation_interval_seconds).to_i
+          @ticks_per_extended_heartbeat = (extended_heartbeat_interval_seconds / metrics_aggregation_interval_seconds).to_i
           @current_ticks = 0
 
           # Workers::Polling settings
           self.enabled = enabled
           # Workers::IntervalLoop settings
           self.loop_base_interval = metrics_aggregation_interval_seconds
-          self.fork_policy = Core::Workers::Async::Thread::FORK_POLICY_STOP
+          # We actually restart the worker after fork, but this is done
+          # via the AtForkMonkeyPatch rather than the worker fork policy
+          # because we also need to reset state outside of the worker
+          # (e.g. the metrics).
+          self.fork_policy = Core::Workers::Async::Thread::FORK_POLICY_RESTART
 
           @shutdown_timeout = shutdown_timeout
           @buffer_size = buffer_size
 
+          initialize_state
+        end
+
+        # To make the method calls clear, the initialization code is in this
+        # method called +initialize_state+ which is called from +after_fork+.
+        # This way users of this class (e.g. telemetry Component) do not
+        # need to invoke +initialize_state+ directly, which can be confusing.
+        private def initialize_state
           self.buffer = buffer_klass.new(@buffer_size)
 
           @initial_event_once = Utils::OnlyOnceSuccessful.new(APP_STARTED_EVENT_RETRIES)
+          @extended_heartbeat_ticks = 0
         end
 
         attr_reader :logger
         attr_reader :initial_event_once
         attr_reader :initial_event
+        attr_reader :emitter
 
         # Returns true if worker thread is successfully started,
         # false if worker thread was not started but telemetry is enabled,
         # nil if telemetry is disabled.
         def start(initial_event)
-          return if !enabled? || forked?
+          return unless enabled?
 
           @initial_event = initial_event
 
@@ -79,7 +102,7 @@ module Datadog
         # for not enqueueing event (presently) is that telemetry is disabled
         # altogether, and in this case other methods return nil.
         def enqueue(event)
-          return if !enabled? || forked?
+          return unless enabled?
 
           buffer.push(event)
           true
@@ -102,38 +125,16 @@ module Datadog
         # been flushed.
         #
         # @api private
-        def flush
-          return true unless enabled? || !run_loop?
-
-          started = Utils::Time.get_time
-          loop do
-            # The AppStarted event is triggered by the worker itself,
-            # from the worker thread. As such the main thread has no way
-            # to delay itself until that event is queued and we need some
-            # way to wait until that event is sent out to assert on it in
-            # the test suite. Check the run once flag which *should*
-            # indicate the event has been queued (at which point our queue
-            # depth check should waint until it's sent).
-            # This is still a hack because the flag can be overridden
-            # either way with or without the event being sent out.
-            # Note that if the AppStarted sending fails, this check
-            # will return false and flushing will be blocked until the
-            # 15 second timeout.
-            # Note that the first wait interval between telemetry event
-            # sending is 10 seconds, the timeout needs to be strictly
-            # greater than that.
-            return true if buffer.empty? && !in_iteration? && sent_initial_event?
-
-            sleep 0.5
-
-            return false if Utils::Time.get_time - started > 15
-          end
+        def flush(timeout: nil)
+          # Increase default timeout to 15 seconds - see the comment in
+          # +idle?+ for more details.
+          super(timeout: timeout || 15)
         end
 
         private
 
         def perform(*events)
-          return if !enabled? || forked?
+          return unless enabled?
 
           if need_initial_event?
             started!
@@ -157,6 +158,13 @@ module Datadog
           end
 
           @current_ticks += 1
+          @extended_heartbeat_ticks += 1
+
+          if @extended_heartbeat_ticks >= @ticks_per_extended_heartbeat
+            @extended_heartbeat_ticks = 0
+            extended_heartbeat!
+          end
+
           return if @current_ticks < @ticks_per_heartbeat
 
           @current_ticks = 0
@@ -176,6 +184,12 @@ module Datadog
           send_event(Event::AppHeartbeat.new)
         end
 
+        def extended_heartbeat!
+          return if !enabled? || !sent_initial_event?
+
+          send_event(Event::AppExtendedHeartbeat.new(settings: @settings, agent_settings: @agent_settings))
+        end
+
         def started!
           return unless enabled?
 
@@ -189,7 +203,9 @@ module Datadog
               # dependencies and send the new ones.
               # System tests demand only one instance of this event per
               # dependency.
-              send_event(Event::AppDependenciesLoaded.new) if @dependency_collection && initial_event.class.eql?(Telemetry::Event::AppStarted) # standard:disable Style/ClassEqualityComparison:
+              if @dependency_collection && initial_event.app_started?
+                send_event(Event::AppDependenciesLoaded.new)
+              end
 
               true
             else
@@ -212,6 +228,8 @@ module Datadog
           res
         end
 
+        # This method overrides Queue's dequeue method and does LIFO instead
+        # of FIFO that Queue implements. Why?
         def dequeue
           buffer.pop
         end
@@ -240,6 +258,45 @@ module Datadog
           disable!
         end
 
+        # Call this method in a forked child to reset the state of this worker.
+        #
+        # Discard any accumulated events since they will be sent by
+        # the parent.
+        # Discard any accumulated metrics.
+        # Restart the worker thread, if it was running in the parent process.
+        #
+        # This method cannot be called +after_fork+ because workers define
+        # and call +after_fork+ which is supposed to do different things.
+        def after_fork_monkey_patched
+          # If telemetry is disabled, we still reset the state to avoid
+          # having wrong state. It is possible that in the future telemetry
+          # will be re-enabled after errors.
+          initialize_state
+          # In the child process, we get a new runtime_id.
+          # As such we need to send AppStarted event.
+          # In the parent process, the event may have been the
+          # SynthAppClientConfigurationChange instead of AppStarted,
+          # and in that case we need to convert it to the "regular"
+          # AppStarted event.
+          if defined?(@initial_event) && @initial_event.is_a?(Event::SynthAppClientConfigurationChange)
+            # It would be great to just replace the initial event in
+            # +initialize_state+ method. Unfortunately this event requires
+            # the entire component tree to build its payload, which we
+            # 1) don't currently have in telemetry and
+            # 2) don't want to keep a permanent reference to in any case.
+            # Therefore we have this +reset!+ method that changes the
+            # event type while keeping the payload.
+            @initial_event.reset! # steep:ignore NoMethod
+          end
+
+          if enabled? && !worker.nil?
+            # Start the background thread if it was started in the parent
+            # process (which requires telemetry to be enabled).
+            # This should be done after all of the state resets.
+            perform
+          end
+        end
+
         # Deduplicate logs by counting the number of repeated occurrences of the same log
         # entry and replacing them with a single entry with the calculated `count` value.
         # Non-log events are unchanged.
@@ -270,6 +327,25 @@ module Datadog
 
           other_events + uniq_logs
         end
+
+        def idle?
+          # The AppStarted event is triggered by the worker itself,
+          # from the worker thread. As such the main thread has no way
+          # to delay itself until that event is queued and we need some
+          # way to wait until that event is sent out to assert on it in
+          # the test suite. Check the run once flag which *should*
+          # indicate the event has been queued (at which point our queue
+          # depth check should wait until it's sent).
+          # This is still a hack because the flag can be overridden
+          # either way with or without the event being sent out.
+          # Note that if the AppStarted sending fails, this check
+          # will return false and flushing will be blocked until the
+          # 15 second timeout.
+          # Note that the first wait interval between telemetry event
+          # sending is 10 seconds, the timeout needs to be strictly
+          # greater than that.
+          super && sent_initial_event?
+        end
       end
     end
   end

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

@@ -8,6 +8,9 @@ module Datadog
       module Ext
         module HTTP
           HEADER_CONTAINER_ID = 'Datadog-Container-ID'
+          HEADER_CONTAINER_TAGS_HASH = 'Datadog-Container-Tags-Hash'
+          HEADER_ENTITY_ID = 'Datadog-Entity-ID'
+          HEADER_EXTERNAL_ENV = 'Datadog-External-Env'
           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.

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

@@ -48,7 +48,7 @@ module Datadog
             end
 
             def get(env)
-              get = ::Net::HTTP::Get.new(env.path, env.headers)
+              get = ::Net::HTTP::Get.new(net_http_path_from_env(env), env.headers)
 
               # Connect and send the request
               http_response = open do |http|
@@ -63,7 +63,7 @@ module Datadog
               post = nil
 
               if env.form.nil? || env.form.empty?
-                post = ::Net::HTTP::Post.new(env.path, env.headers)
+                post = ::Net::HTTP::Post.new(net_http_path_from_env(env), env.headers)
                 post.body = env.body
               else
                 post = ::Datadog::Core::Vendor::Net::HTTP::Post::Multipart.new(
@@ -86,6 +86,21 @@ module Datadog
               "http://#{hostname}:#{port}?timeout=#{timeout}"
             end
 
+            def net_http_path_from_env(env)
+              path = env.path
+              case query = env.query
+              when Hash
+                path = path + '?' + URI.encode_www_form(query)
+              when String
+                path = path + '?' + query
+              when nil
+                # Nothing
+              else
+                raise ArgumentError, "Invalid type for query: #{query}"
+              end
+              path
+            end
+
             # Raised when called with an unknown HTTP method
             class UnknownHTTPMethod < StandardError
               attr_reader :verb

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

@@ -9,13 +9,18 @@ module Datadog
         module API
           # Endpoint
           class Endpoint
-            attr_reader \
-              :verb,
-              :path
+            attr_reader :verb
+            attr_reader :path
 
-            def initialize(verb, path)
+            # TODO Currently only Traces transport specifies an encoder.
+            # Other transports perform encoding "inline" / ad-hoc.
+            # They should probably use this encoder field instead.
+            attr_reader :encoder
+
+            def initialize(verb, path, encoder: nil)
               @verb = verb
               @path = path
+              @encoder = encoder
             end
 
             def call(env)

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

@@ -7,36 +7,19 @@ module Datadog
         module API
           # An API configured with adapter and routes
           class Instance
-            # Raised when an endpoint is invoked on an API that is not the
-            # of expected API class for that endpoint.
-            class EndpointNotSupportedError < StandardError
-              attr_reader :spec, :endpoint_name
-
-              def initialize(endpoint_name, spec)
-                @spec = spec
-                @endpoint_name = endpoint_name
-
-                super(message)
-              end
-
-              def message
-                "#{endpoint_name} not supported for this API!"
-              end
-            end
-
             attr_reader \
               :adapter,
               :headers,
-              :spec
+              :endpoint
 
-            def initialize(spec, adapter, options = {})
-              @spec = spec
+            def initialize(endpoint, adapter, options = {})
+              @endpoint = endpoint
               @adapter = adapter
               @headers = options.fetch(:headers, {})
             end
 
             def encoder
-              spec.encoder
+              endpoint.encoder
             end
 
             def call(env)

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

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require_relative '../../configuration/agent_settings_resolver'
+require_relative '../../configuration/agent_settings'
 require_relative 'adapters/registry'
 require_relative 'api/map'
 
@@ -13,7 +13,6 @@ module Datadog
           REGISTRY = Datadog::Core::Transport::HTTP::Adapters::Registry.new
 
           attr_reader \
-            :api_instance_class,
             :apis,
             :api_options,
             :default_adapter,
@@ -21,7 +20,7 @@ module Datadog
             :default_headers,
             :logger
 
-          def initialize(api_instance_class:, logger: Datadog.logger)
+          def initialize(logger: Datadog.logger)
             # Global settings
             @default_adapter = nil
             @default_headers = {}
@@ -33,7 +32,6 @@ module Datadog
             # API settings
             @api_options = {}
 
-            @api_instance_class = api_instance_class
             @logger = logger
 
             yield(self) if block_given?
@@ -41,7 +39,7 @@ module Datadog
 
           def adapter(config, *args, **kwargs)
             @default_adapter = case config
-            when Core::Configuration::AgentSettingsResolver::AgentSettings
+            when Core::Configuration::AgentSettings
               registry_klass = REGISTRY.get(config.adapter)
               raise UnknownAdapterError, config.adapter if registry_klass.nil?
 
@@ -73,6 +71,12 @@ module Datadog
             @apis[key] = spec
 
             # Apply as default API, if specified to do so.
+            #
+            # This code also sets the first defined API to be the default API.
+            # In APIs without fallbacks (currently, everything other than
+            # tracing's Traces, though DI Input will also have fallbacks soon)
+            # there is only one declaration of `transport.api`, and that
+            # API is set as the default API in the transport by this line.
             @default_api = key if options.delete(:default) || @default_api.nil?
 
             # Save all other settings for initialization
@@ -94,7 +98,7 @@ module Datadog
           def to_api_instances
             raise NoApisError if @apis.empty?
 
-            @apis.inject(Datadog::Core::Transport::HTTP::API::Map.new) do |instances, (key, spec)|
+            @apis.inject(API::Map.new) do |instances, (key, spec)|
               instances.tap do
                 api_options = @api_options[key].dup
 
@@ -107,7 +111,7 @@ module Datadog
                 api_options[:headers] = @default_headers.merge((api_options[:headers] || {}))
 
                 # Add API::Instance with all settings
-                instances[key] = api_instance_class.new(
+                instances[key] = API::Instance.new(
                   spec,
                   adapter,
                   api_options