datadog 2.15.0 → 2.17.0

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

@@ -29,13 +29,13 @@ module Datadog
           class << self
             def hexdigest(type, data)
               d = case type
-                  when :sha256
-                    ::Digest::SHA256.new
-                  when :sha512
-                    ::Digest::SHA512.new
-                  else
-                    raise InvalidHashTypeError, type
-                  end
+              when :sha256
+                ::Digest::SHA256.new
+              when :sha512
+                ::Digest::SHA512.new
+              else
+                raise InvalidHashTypeError, type
+              end
 
               while (buf = data.read(DIGEST_CHUNK))
                 d.update(buf)

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

@@ -30,7 +30,7 @@ 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

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

@@ -28,7 +28,7 @@ module Datadog
 
               # Get responses from API
               yield(api, env)
-            rescue StandardError => e
+            rescue => e
               message =
                 "Internal error during #{self.class.name} request. Cause: #{e.class.name} #{e.message} " \
                   "Location: #{Array(e.backtrace).first}"

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

@@ -5,6 +5,7 @@ require 'json'
 require_relative '../config'
 require_relative 'client'
 require_relative '../../../utils/base64'
+require_relative '../../../utils/truncation'
 require_relative '../../../transport/http/response'
 require_relative '../../../transport/http/api/endpoint'
 
@@ -20,9 +21,11 @@ module Datadog
               include Datadog::Core::Transport::HTTP::Response
               include Core::Remote::Transport::Config::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
@@ -130,8 +133,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}"
 
@@ -140,7 +156,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}"
 
@@ -149,7 +165,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}"
 
@@ -215,7 +231,7 @@ module Datadog
                   env.body = env.request.parcel.data
 
                   # Query for response
-                  http_response = super(env, &block)
+                  http_response = super
 
                   response_options = {}
 

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

@@ -79,7 +79,7 @@ module Datadog
 
                 def call(env, &block)
                   # Query for response
-                  http_response = super(env, &block)
+                  http_response = super
 
                   # Process the response
                   body = JSON.parse(http_response.payload, symbolize_names: true) if http_response.ok?

data/lib/datadog/core/runtime/metrics.rb

@@ -14,7 +14,7 @@ module Datadog
     module Runtime
       # For generating runtime metrics
       class Metrics < Core::Metrics::Client
-        def initialize(**options)
+        def initialize(telemetry:, **options)
           super
 
           # Initialize service list
@@ -96,7 +96,7 @@ module Datadog
 
         def try_flush
           yield
-        rescue StandardError => e
+        rescue => e
           Datadog.logger.warn("Error while sending runtime metric. Cause: #{e.class.name} #{e.message}")
         end
 
@@ -147,7 +147,7 @@ module Datadog
           gauge(metric_name, metric_value) if metric_value
         end
 
-        # rubocop:disable Metrics/MethodLength
+        # standard:disable Metrics/MethodLength
         def flush_yjit_stats
           # Only on Ruby >= 3.2
           try_flush do
@@ -195,7 +195,7 @@ module Datadog
             end
           end
         end
-        # rubocop:enable Metrics/MethodLength
+        # standard:enable Metrics/MethodLength
       end
     end
   end

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

@@ -2,12 +2,13 @@
 
 require_relative 'emitter'
 require_relative 'event'
-require_relative 'http/transport'
 require_relative 'metrics_manager'
 require_relative 'worker'
 require_relative 'logging'
+require_relative 'transport/http'
 
 require_relative '../configuration/ext'
+require_relative '../configuration/agentless_settings_resolver'
 require_relative '../utils/forking'
 
 module Datadog
@@ -15,8 +16,10 @@ module Datadog
     module Telemetry
       # Telemetry entrypoint, coordinates sending telemetry events at various points in app lifecycle.
       # Note: Telemetry does not spawn its worker thread in fork processes, thus no telemetry is sent in forked processes.
+      #
+      # @api private
       class Component
-        attr_reader :enabled, :logger
+        attr_reader :enabled, :logger, :transport, :worker
 
         include Core::Utils::Forking
         include Telemetry::Logging
@@ -25,89 +28,100 @@ module Datadog
           enabled = settings.telemetry.enabled
           agentless_enabled = settings.telemetry.agentless_enabled
 
-          if !agentless_enabled && agent_settings.adapter != Datadog::Core::Configuration::Ext::Agent::HTTP::ADAPTER
-            enabled = false
-            logger.debug { "Telemetry disabled. Agent network adapter not supported: #{agent_settings.adapter}" }
-          end
-
           if agentless_enabled && settings.api_key.nil?
             enabled = false
-            logger.debug { 'Telemetry disabled. Agentless telemetry requires an DD_API_KEY variable to be set.' }
+            logger.debug { 'Telemetry disabled. Agentless telemetry requires a DD_API_KEY variable to be set.' }
           end
 
-          transport = if agentless_enabled
-                        Datadog::Core::Telemetry::Http::Transport.build_agentless_transport(
-                          api_key: settings.api_key,
-                          dd_site: settings.site,
-                          url_override: settings.telemetry.agentless_url_override
-                        )
-                      else
-                        Datadog::Core::Telemetry::Http::Transport.build_agent_transport(agent_settings)
-                      end
-
           Telemetry::Component.new(
-            http_transport: transport,
+            settings: settings,
+            agent_settings: agent_settings,
             enabled: enabled,
-            metrics_enabled: enabled && settings.telemetry.metrics_enabled,
-            heartbeat_interval_seconds: settings.telemetry.heartbeat_interval_seconds,
-            metrics_aggregation_interval_seconds: settings.telemetry.metrics_aggregation_interval_seconds,
-            dependency_collection: settings.telemetry.dependency_collection,
             logger: logger,
-            shutdown_timeout_seconds: settings.telemetry.shutdown_timeout_seconds,
-            log_collection_enabled: settings.telemetry.log_collection_enabled
           )
         end
 
         # @param enabled [Boolean] Determines whether telemetry events should be sent to the API
-        # @param metrics_enabled [Boolean] Determines whether telemetry metrics should be sent to the API
-        # @param heartbeat_interval_seconds [Float] How frequently heartbeats will be reported, in seconds.
-        # @param metrics_aggregation_interval_seconds [Float] How frequently metrics will be aggregated, in seconds.
-        # @param [Boolean] dependency_collection Whether to send the `app-dependencies-loaded` event
-        def initialize(
-          heartbeat_interval_seconds:,
-          metrics_aggregation_interval_seconds:,
-          dependency_collection:,
+        def initialize( # standard:disable Metrics/MethodLength
+          settings:,
+          agent_settings:,
           logger:,
-          http_transport:,
-          shutdown_timeout_seconds:,
-          enabled: true,
-          metrics_enabled: true,
-          log_collection_enabled: true
+          enabled:
         )
           @enabled = enabled
-          @log_collection_enabled = log_collection_enabled
+          @log_collection_enabled = settings.telemetry.log_collection_enabled
           @logger = logger
 
           @metrics_manager = MetricsManager.new(
-            enabled: enabled && metrics_enabled,
-            aggregation_interval: metrics_aggregation_interval_seconds
+            enabled: @enabled && settings.telemetry.metrics_enabled,
+            aggregation_interval: settings.telemetry.metrics_aggregation_interval_seconds,
           )
 
+          @stopped = false
+
+          return unless @enabled
+
+          @transport = if settings.telemetry.agentless_enabled
+            agent_settings = Core::Configuration::AgentlessSettingsResolver.call(
+              settings,
+              host_prefix: 'instrumentation-telemetry-intake',
+              url_override: settings.telemetry.agentless_url_override,
+              url_override_source: 'c.telemetry.agentless_url_override',
+              logger: logger,
+            )
+            Telemetry::Transport::HTTP.agentless_telemetry(
+              agent_settings: agent_settings,
+              logger: logger,
+              # api_key should have already validated to be
+              # not nil by +build+ method above.
+              api_key: settings.api_key,
+            )
+          else
+            Telemetry::Transport::HTTP.agent_telemetry(
+              agent_settings: agent_settings, logger: logger,
+            )
+          end
+
           @worker = Telemetry::Worker.new(
             enabled: @enabled,
-            heartbeat_interval_seconds: heartbeat_interval_seconds,
-            metrics_aggregation_interval_seconds: metrics_aggregation_interval_seconds,
-            emitter: Emitter.new(http_transport: http_transport),
+            heartbeat_interval_seconds: settings.telemetry.heartbeat_interval_seconds,
+            metrics_aggregation_interval_seconds: settings.telemetry.metrics_aggregation_interval_seconds,
+            emitter: Emitter.new(
+              @transport,
+              logger: @logger,
+              debug: settings.telemetry.debug,
+            ),
             metrics_manager: @metrics_manager,
-            dependency_collection: dependency_collection,
+            dependency_collection: settings.telemetry.dependency_collection,
             logger: logger,
-            shutdown_timeout: shutdown_timeout_seconds
+            shutdown_timeout: settings.telemetry.shutdown_timeout_seconds,
           )
-
-          @stopped = false
-
-          @worker.start
         end
 
         def disable!
           @enabled = false
-          @worker.enabled = false
+          @worker&.enabled = false
+        end
+
+        def start(initial_event_is_change = false)
+          return if !@enabled
+
+          initial_event = if initial_event_is_change
+            Event::SynthAppClientConfigurationChange.new
+          else
+            Event::AppStarted.new
+          end
+
+          @worker.start(initial_event)
         end
 
-        def stop!
+        def shutdown!
           return if @stopped
 
-          @worker.stop(true)
+          if defined?(@worker)
+            @worker&.stop(true)
+          end
+
           @stopped = true
         end
 
@@ -129,6 +143,17 @@ module Datadog
           @worker.enqueue(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 if !@enabled || forked?
+
+          @worker.flush
+        end
+
         # Report configuration changes caused by Remote Configuration.
         def client_configuration_change!(changes)
           return if !@enabled || forked?

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

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 require_relative 'request'
-require_relative 'http/transport'
+require_relative '../transport/response'
 require_relative '../utils/sequence'
 require_relative '../utils/forking'
 
@@ -10,26 +10,38 @@ module Datadog
     module Telemetry
       # Class that emits telemetry events
       class Emitter
-        attr_reader :http_transport
+        attr_reader :transport, :logger
 
         extend Core::Utils::Forking
 
-        # @param http_transport [Datadog::Core::Telemetry::Http::Transport] Transport object that can be used to send
-        #   telemetry requests via the agent
-        def initialize(http_transport:)
-          @http_transport = http_transport
+        # @param transport [Datadog::Core::Telemetry::Transport::Telemetry::Transport]
+        #   Transport object that can be used to send telemetry requests
+        def initialize(transport, logger: Datadog.logger, debug: false)
+          @transport = transport
+          @logger = logger
+          @debug = !!debug
+        end
+
+        def debug?
+          @debug
         end
 
         # Retrieves and emits a TelemetryRequest object based on the request type specified
         def request(event)
           seq_id = self.class.sequence.next
-          payload = Request.build_payload(event, seq_id)
-          res = @http_transport.request(request_type: event.type, payload: payload.to_json)
-          Datadog.logger.debug { "Telemetry sent for event `#{event.type}` (code: #{res.code.inspect})" }
+          payload = Request.build_payload(event, seq_id, debug: debug?)
+          res = @transport.send_telemetry(request_type: event.type, payload: payload)
+          logger.debug { "Telemetry sent for event `#{event.type}` (response code: #{res.code})" }
           res
         rescue => e
-          Datadog.logger.debug("Unable to send telemetry request for event `#{event.type rescue 'unknown'}`: #{e}")
-          Telemetry::Http::InternalErrorResponse.new(e)
+          logger.debug {
+            "Unable to send telemetry request for event `#{begin
+              event.type
+            rescue
+              "unknown"
+            end}`: #{e}"
+          }
+          Core::Transport::InternalErrorResponse.new(e)
         end
 
         # Initializes a Sequence object to track seq_id if not already initialized; else returns stored

data/lib/datadog/core/telemetry/event/app_client_configuration_change.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require_relative 'base'
+
+module Datadog
+  module Core
+    module Telemetry
+      module Event
+        # Telemetry class for the 'app-client-configuration-change' event
+        class AppClientConfigurationChange < Base
+          attr_reader :changes, :origin
+
+          def type
+            'app-client-configuration-change'
+          end
+
+          def initialize(changes, origin)
+            super()
+            @changes = changes
+            @origin = origin
+          end
+
+          def payload
+            {configuration: configuration}
+          end
+
+          def configuration
+            config = Datadog.configuration
+            seq_id = Event.configuration_sequence.next
+
+            res = @changes.map do |name, value|
+              {
+                name: name,
+                value: value,
+                origin: @origin,
+                seq_id: seq_id,
+              }
+            end
+
+            unless config.dig('appsec', 'sca_enabled').nil?
+              res << {
+                name: 'appsec.sca_enabled',
+                value: config.appsec.sca_enabled,
+                origin: 'code',
+                seq_id: seq_id,
+              }
+            end
+
+            res
+          end
+
+          def ==(other)
+            other.is_a?(AppClientConfigurationChange) && other.changes == @changes && other.origin == @origin
+          end
+
+          alias_method :eql?, :==
+
+          def hash
+            [self.class, @changes, @origin].hash
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/core/telemetry/event/app_closing.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require_relative 'base'
+
+module Datadog
+  module Core
+    module Telemetry
+      module Event
+        # Telemetry class for the 'app-closing' event
+        class AppClosing < Base
+          def type
+            'app-closing'
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/core/telemetry/event/app_dependencies_loaded.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require_relative 'base'
+
+module Datadog
+  module Core
+    module Telemetry
+      module Event
+        # Telemetry class for the 'app-dependencies-loaded' event
+        class AppDependenciesLoaded < Base
+          def type
+            'app-dependencies-loaded'
+          end
+
+          def payload
+            {dependencies: dependencies}
+          end
+
+          private
+
+          def dependencies
+            Gem.loaded_specs.collect do |name, gem|
+              {
+                name: name,
+                version: gem.version.to_s,
+              }
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/core/telemetry/event/app_heartbeat.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require_relative 'base'
+
+module Datadog
+  module Core
+    module Telemetry
+      module Event
+        # Telemetry class for the 'app-heartbeat' event
+        class AppHeartbeat < Base
+          def type
+            'app-heartbeat'
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/core/telemetry/event/app_integrations_change.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require_relative 'base'
+
+module Datadog
+  module Core
+    module Telemetry
+      module Event
+        # Telemetry class for the 'app-integrations-change' event
+        class AppIntegrationsChange < Base
+          def type
+            'app-integrations-change'
+          end
+
+          def payload
+            {integrations: integrations}
+          end
+
+          private
+
+          def integrations
+            instrumented_integrations = Datadog.configuration.tracing.instrumented_integrations
+            Datadog.registry.map do |integration|
+              is_instrumented = instrumented_integrations.include?(integration.name)
+
+              is_enabled = is_instrumented && integration.klass.patcher.patch_successful
+
+              version = integration.klass.class.version&.to_s
+
+              res = {
+                name: integration.name.to_s,
+                enabled: is_enabled,
+                version: version,
+                compatible: integration.klass.class.compatible?,
+                error: (patch_error(integration) if is_instrumented && !is_enabled),
+                # TODO: Track if integration is instrumented by manual configuration or by auto instrumentation
+                # auto_enabled: is_enabled && ???,
+              }
+              res.reject! { |_, v| v.nil? }
+              res
+            end
+          end
+
+          def patch_error(integration)
+            patch_error_result = integration.klass.patcher.patch_error_result
+            return patch_error_result.compact.to_s if patch_error_result
+
+            # If no error occurred during patching, but integration is still not instrumented
+            "Available?: #{integration.klass.class.available?}" \
+            ", Loaded? #{integration.klass.class.loaded?}" \
+            ", Compatible? #{integration.klass.class.compatible?}" \
+            ", Patchable? #{integration.klass.class.patchable?}"
+          end
+        end
+      end
+    end
+  end
+end