datadog 2.12.1 → 2.19.0

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

@@ -20,7 +20,7 @@ module Datadog
           end
 
           def id
-            @id ||= "#{type}::#{name}::#{tags.join(',')}"
+            @id ||= "#{type}::#{name}::#{tags.join(",")}"
           end
 
           def track(value)
@@ -47,7 +47,7 @@ module Datadog
               values == other.values && tags == other.tags && common == other.common && type == other.type
           end
 
-          alias eql? ==
+          alias_method :eql?, :==
 
           def hash
             [self.class, name, values, tags, common, type].hash
@@ -88,7 +88,7 @@ module Datadog
             super && interval == other.interval
           end
 
-          alias eql? ==
+          alias_method :eql?, :==
 
           def hash
             [super, interval].hash
@@ -108,9 +108,9 @@ module Datadog
             value = value.to_i
 
             if values.empty?
-              values << [Time.now.to_i, value]
+              values << [Core::Utils::Time.now.to_i, value]
             else
-              values[0][0] = Time.now.to_i
+              values[0][0] = Core::Utils::Time.now.to_i
               values[0][1] += value
             end
             nil
@@ -129,9 +129,9 @@ module Datadog
 
           def track(value)
             if values.empty?
-              values << [Time.now.to_i, value]
+              values << [Core::Utils::Time.now.to_i, value]
             else
-              values[0][0] = Time.now.to_i
+              values[0][0] = Core::Utils::Time.now.to_i
               values[0][1] = value
             end
             nil
@@ -155,7 +155,7 @@ module Datadog
 
           def track(value = 1.0)
             @value += value
-            @values = [[Time.now.to_i, @value / interval]]
+            @values = [[Core::Utils::Time.now.to_i, @value / interval]]
             nil
           end
         end

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

@@ -11,17 +11,17 @@ module Datadog
         class << self
           using Core::Utils::Hash::Refinement
 
-          def build_payload(event, seq_id)
+          def build_payload(event, seq_id, api_version: 'v2', debug: false)
             hash = {
-              api_version: Http::Ext::API_VERSION,
+              api_version: api_version,
               application: application,
-              debug: false,
+              debug: debug,
               host: host,
               payload: event.payload,
               request_type: event.type,
               runtime_id: Core::Environment::Identity.id,
               seq_id: seq_id,
-              tracer_time: Time.now.to_i,
+              tracer_time: Core::Utils::Time.now.to_i,
             }
             hash.compact!
             hash

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

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require_relative '../../../encoding'
+require_relative '../../../transport/http/api/map'
+require_relative '../../../transport/http/api/instance'
+require_relative '../../../transport/http/api/spec'
+require_relative 'telemetry'
+
+module Datadog
+  module Core
+    module Telemetry
+      module Transport
+        module HTTP
+          # Namespace for API components
+          module API
+            # Default API versions
+            AGENT_TELEMETRY = 'agent_telemetry'
+            AGENTLESS_TELEMETRY = 'agentless_telemetry'
+
+            module_function
+
+            def defaults
+              Datadog::Core::Transport::HTTP::API::Map[
+                AGENT_TELEMETRY => Telemetry::API::Spec.new do |s|
+                  s.telemetry = Telemetry::API::Endpoint.new(
+                    '/telemetry/proxy/api/v2/apmtelemetry',
+                    Core::Encoding::JSONEncoder,
+                  )
+                end,
+                AGENTLESS_TELEMETRY => Telemetry::API::Spec.new do |s|
+                  s.telemetry = Telemetry::API::Endpoint.new(
+                    '/api/v2/apmtelemetry',
+                    Core::Encoding::JSONEncoder,
+                  )
+                end,
+              ]
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require_relative '../../../transport/http/env'
+require_relative '../../../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 Telemetry
+      module Transport
+        module HTTP
+          # Routes, encodes, and sends DI data to the trace agent via HTTP.
+          class Client
+            attr_reader :api, :logger
+
+            def initialize(api, logger:)
+              @api = api
+              @logger = logger
+            end
+
+            def send_request(request, &block)
+              # Build request into env
+              env = build_env(request)
+
+              # Get responses from API
+              yield(api, env)
+            rescue => e
+              message =
+                "Internal error during #{self.class.name} request. Cause: #{e.class.name} #{e.message} " \
+                  "Location: #{Array(e.backtrace).first}"
+
+              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

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

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+require_relative '../../../transport/http/api/endpoint'
+require_relative '../../../transport/http/api/instance'
+require_relative '../../../transport/http/api/spec'
+require_relative '../../../transport/request'
+require_relative 'client'
+
+module Datadog
+  module Core
+    module Telemetry
+      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'
+
+                attr_reader \
+                  :encoder
+
+                def initialize(path, encoder)
+                  super(:post, path)
+                  @encoder = encoder
+                end
+
+                def call(env, &block)
+                  # Encode body & type
+                  env.headers[HEADER_CONTENT_TYPE] = encoder.content_type
+                  env.headers.update(headers(
+                    request_type: env.request.request_type,
+                    api_key: env.request.api_key,
+                  ))
+                  env.body = env.request.parcel.data
+
+                  super
+                end
+
+                def headers(request_type:, api_key:, api_version: 'v2')
+                  {
+                    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-Request-Type' => request_type,
+                    'DD-Client-Library-Language' => Core::Environment::Ext::LANG,
+                    'DD-Client-Library-Version' => Core::Environment::Identity.gem_datadog_version_semver2,
+
+                    # Enable debug mode for telemetry
+                    # 'DD-Telemetry-Debug-Enabled' => 'true',
+                  }.tap do |result|
+                    result['DD-API-KEY'] = api_key unless api_key.nil?
+                  end
+                end
+              end
+            end
+          end
+
+          HTTP::Client.include(Telemetry::Client)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require_relative 'telemetry'
+require_relative 'http/api'
+require_relative '../../transport/http'
+
+module Datadog
+  module Core
+    module Telemetry
+      module Transport
+        # Namespace for HTTP transport components
+        module HTTP
+          module_function
+
+          # Builds a new Transport::HTTP::Client with default settings
+          # Pass a block to override any settings.
+          def agentless_telemetry(
+            agent_settings:,
+            logger:,
+            api_key: nil,
+            api_version: nil,
+            headers: nil
+          )
+            Core::Transport::HTTP.build(api_instance_class: Telemetry::API::Instance,
+              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]
+
+              # Call block to apply any customization, if provided
+              yield(transport) if block_given?
+            end.to_transport(Core::Telemetry::Transport::Telemetry::Transport).tap do |transport|
+              transport.api_key = api_key
+            end
+          end
+
+          # Builds a new Transport::HTTP::Client with default settings
+          # Pass a block to override any settings.
+          def agent_telemetry(
+            agent_settings:,
+            logger:,
+            api_version: nil,
+            headers: nil
+          )
+            Core::Transport::HTTP.build(api_instance_class: Telemetry::API::Instance,
+              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]
+
+              # Call block to apply any customization, if provided
+              yield(transport) if block_given?
+            end.to_transport(Core::Telemetry::Transport::Telemetry::Transport)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require_relative '../../transport/parcel'
+require_relative 'http/client'
+require_relative 'http/telemetry'
+
+module Datadog
+  module Core
+    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
+
+            def initialize(request_type, parcel, api_key)
+              @request_type = request_type
+              super(parcel)
+              @api_key = api_key
+            end
+          end
+
+          class Transport
+            attr_reader :client, :apis, :default_api, :current_api_id, :logger
+            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)
+              request = Request.new(request_type, parcel, api_key)
+
+              @client.send_telemetry_payload(request)
+              # Perform no error checking here
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -17,8 +17,6 @@ module Datadog
         DEFAULT_BUFFER_MAX_SIZE = 1000
         APP_STARTED_EVENT_RETRIES = 10
 
-        TELEMETRY_STARTED_ONCE = Utils::OnlyOnceSuccessful.new(APP_STARTED_EVENT_RETRIES)
-
         def initialize(
           heartbeat_interval_seconds:,
           metrics_aggregation_interval_seconds:,
@@ -48,14 +46,25 @@ module Datadog
           @buffer_size = buffer_size
 
           self.buffer = buffer_klass.new(@buffer_size)
+
+          @initial_event_once = Utils::OnlyOnceSuccessful.new(APP_STARTED_EVENT_RETRIES)
         end
 
         attr_reader :logger
+        attr_reader :initial_event_once
+        attr_reader :initial_event
 
-        def start
+        # 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?
 
+          @initial_event = initial_event
+
           # starts async worker
+          # perform should return true if thread was actually started,
+          # false otherwise
           perform
         end
 
@@ -65,18 +74,60 @@ module Datadog
           super
         end
 
+        # Returns true if event was enqueued, nil if not.
+        # While returning false may seem more reasonable, the only reason
+        # 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?
 
           buffer.push(event)
+          true
+        end
+
+        def sent_initial_event?
+          initial_event_once.success?
         end
 
-        def sent_started_event?
-          TELEMETRY_STARTED_ONCE.success?
+        def failed_initial_event?
+          initial_event_once.failed?
         end
 
-        def failed_to_start?
-          TELEMETRY_STARTED_ONCE.failed?
+        def need_initial_event?
+          !sent_initial_event? && !failed_initial_event?
+        end
+
+        # Wait for the worker to send out all events that have already
+        # been queued, up to 15 seconds. Returns whether all events have
+        # 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
         end
 
         private
@@ -84,11 +135,26 @@ module Datadog
         def perform(*events)
           return if !enabled? || forked?
 
-          started! unless sent_started_event?
+          if need_initial_event?
+            started!
+            unless sent_initial_event?
+              # We still haven't succeeded in sending the started event,
+              # which will make flush_events do nothing - but the events
+              # given to us as the parameter have already been removed
+              # from the queue.
+              # Put the events back to the front of the queue to not
+              # lose them.
+              buffer.unshift(*events)
+              return
+            end
+          end
 
           metric_events = @metrics_manager.flush!
           events = [] if events.nil?
-          flush_events(events + metric_events)
+          events += metric_events
+          if events.any?
+            flush_events(events)
+          end
 
           @current_ticks += 1
           return if @current_ticks < @ticks_per_heartbeat
@@ -98,9 +164,6 @@ module Datadog
         end
 
         def flush_events(events)
-          return if events.empty?
-          return if !enabled? || !sent_started_event?
-
           events = deduplicate_logs(events)
 
           logger.debug { "Sending #{events&.count} telemetry events" }
@@ -108,7 +171,7 @@ module Datadog
         end
 
         def heartbeat!
-          return if !enabled? || !sent_started_event?
+          return if !enabled? || !sent_initial_event?
 
           send_event(Event::AppHeartbeat.new)
         end
@@ -116,26 +179,29 @@ module Datadog
         def started!
           return unless enabled?
 
-          if failed_to_start?
-            logger.debug('Telemetry app-started event exhausted retries, disabling telemetry worker')
-            disable!
-            return
-          end
-
-          TELEMETRY_STARTED_ONCE.run do
-            res = send_event(Event::AppStarted.new)
+          initial_event_once.run do
+            res = send_event(initial_event)
 
             if res.ok?
-              logger.debug('Telemetry app-started event is successfully sent')
+              logger.debug { "Telemetry initial event (#{initial_event.type}) is successfully sent" }
 
-              send_event(Event::AppDependenciesLoaded.new) if @dependency_collection
+              # TODO Dependencies loaded event should probably check for new
+              # 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:
 
               true
             else
-              logger.debug('Error sending telemetry app-started event, retry after heartbeat interval...')
+              logger.debug("Error sending telemetry initial event (#{initial_event.type}), retry after heartbeat interval...")
               false
             end
           end
+
+          if failed_initial_event?
+            logger.debug { "Telemetry initial event (#{initial_event.type}) exhausted retries, disabling telemetry worker" }
+            disable!
+          end
         end
 
         def send_event(event)

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/adapters/test.rb

@@ -38,7 +38,8 @@ module Datadog
               @status = status
             end
 
-            def url; end
+            def url
+            end
 
             # Response for test adapter
             class Response

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

@@ -7,6 +7,23 @@ 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,

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

@@ -8,6 +8,23 @@ module Datadog
           # Specification for an HTTP API
           # Defines behaviors without specific configuration details.
           class Spec
+            # Raised when an endpoint is invoked on an API that did not
+            # define that endpoint.
+            class EndpointNotDefinedError < StandardError
+              attr_reader :spec, :endpoint_name
+
+              def initialize(endpoint_name, spec)
+                @spec = spec
+                @endpoint_name = endpoint_name
+
+                super(message)
+              end
+
+              def message
+                "No #{endpoint_name} endpoint is defined for API specification!"
+              end
+            end
+
             def initialize
               yield(self) if block_given?
             end