datadog 2.23.0 → 2.24.0

data/lib/datadog/di/probe_notification_builder.rb

@@ -46,7 +46,7 @@ module Datadog
         build_snapshot(context)
       end
 
-      NANOSECONDS = 10**9
+      NANOSECONDS = 1_000_000_000
       MILLISECONDS = 1000
 
       def build_snapshot(context)
@@ -134,7 +134,7 @@ module Datadog
           format_caller_locations(caller_locations)
         end
 
-        {
+        payload = {
           service: settings.service,
           debugger: {
             type: 'snapshot',
@@ -189,6 +189,10 @@ module Datadog
           message: message,
           timestamp: timestamp,
         }
+
+        tag_process_tags!(payload, settings)
+
+        payload
       end
 
       def build_status(probe, message:, status:)
@@ -236,6 +240,15 @@ module Datadog
         [message, evaluation_errors]
       end
 
+      def tag_process_tags!(payload, settings)
+        return unless settings.experimental_propagate_process_tags_enabled
+
+        process_tags = Core::Environment::Process.serialized
+        return if process_tags.empty?
+
+        payload[:process_tags] = process_tags
+      end
+
       def timestamp_now
         (Core::Utils::Time.now.to_f * MILLISECONDS).to_i
       end

data/lib/datadog/di/remote.rb

@@ -12,8 +12,6 @@ module Datadog
     #
     # @api private
     module Remote
-      class ReadError < StandardError; end
-
       class << self
         PRODUCT = 'LIVE_DEBUGGING'
 
@@ -28,7 +26,7 @@ module Datadog
         end
 
         def receivers(telemetry)
-          receiver do |repository, _changes|
+          receiver do |repository, changes|
             # DEV: Filter our by product. Given it will be very common
             # DEV: we can filter this out before we receive the data in this method.
             # DEV: Apply this refactor to AppSec as well if implemented.
@@ -41,84 +39,23 @@ module Datadog
             # If the component is nil for some reason, we also don't have a
             # logger instance to report the issue.
             if component
-
-              probe_manager = component.probe_manager
-              probe_notification_builder = component.probe_notification_builder
-              probe_notifier_worker = component.probe_notifier_worker
-
-              current_probe_ids = {}
-              repository.contents.each do |content|
-                case content.path.product
-                when PRODUCT
-                  begin
-                    probe_spec = parse_content(content)
-                    probe = component.parse_probe_spec_and_notify(probe_spec)
-                    component.logger.debug { "di: received #{probe.type} probe at #{probe.location} (#{probe.id}) via RC" }
-
-                    begin
-                      # TODO test exception capture
-                      probe_manager.add_probe(probe)
-                      content.applied
-                    rescue DI::Error::DITargetNotInRegistry => exc
-                      component.telemetry&.report(exc, description: "Line probe is targeting a loaded file that is not in code tracker")
-
-                      payload = probe_notification_builder.build_errored(probe, exc)
-                      probe_notifier_worker.add_status(payload)
-
-                      # If a probe fails to install, we will mark the content
-                      # as errored. On subsequent remote configuration application
-                      # attemps, probe manager will raise the "previously errored"
-                      # exception and we'll rescue it here, again marking the
-                      # content as errored but with a somewhat different exception
-                      # message.
-                      # TODO assert content state (errored for this example)
-                      content.errored("Error applying dynamic instrumentation configuration: #{exc.class.name} #{exc.message}")
-                    rescue => exc
-                      raise if component.settings.dynamic_instrumentation.internal.propagate_all_exceptions
-
-                      component.logger.debug { "di: unhandled exception adding #{probe.type} probe at #{probe.location} (#{probe.id}) in DI remote receiver: #{exc.class}: #{exc}" }
-                      component.telemetry&.report(exc, description: "Unhandled exception adding probe in DI remote receiver")
-
-                      # TODO test this path
-                      payload = probe_notification_builder.build_errored(probe, exc)
-                      probe_notifier_worker.add_status(payload)
-
-                      # If a probe fails to install, we will mark the content
-                      # as errored. On subsequent remote configuration application
-                      # attemps, probe manager will raise the "previously errored"
-                      # exception and we'll rescue it here, again marking the
-                      # content as errored but with a somewhat different exception
-                      # message.
-                      # TODO assert content state (errored for this example)
-                      content.errored("Error applying dynamic instrumentation configuration: #{exc.class.name} #{exc.message}")
-                    end
-
-                    # Important: even if processing fails for this probe config,
-                    # we need to note it as being current so that we do not
-                    # try to remove instrumentation that is still supposed to be
-                    # active.
-                    current_probe_ids[probe_spec.fetch('id')] = true
-                  rescue => exc
-                    raise if component.settings.dynamic_instrumentation.internal.propagate_all_exceptions
-
-                    component.logger.debug { "di: unhandled exception handling a probe in DI remote receiver: #{exc.class}: #{exc}" }
-                    component.telemetry&.report(exc, description: "Unhandled exception handling probe in DI remote receiver")
-
-                    # TODO assert content state (errored for this example)
-                    content.errored("Error applying dynamic instrumentation configuration: #{exc.class.name} #{exc.message}")
-                  end
+              changes.each do |change|
+                case change.type
+                when :insert
+                  add_probe(change.content, component)
+                when :update
+                  # We do not implement updates at the moment, remove the
+                  # probe and reinstall.
+                  remove_probe(change.content, component)
+                  add_probe(change.content, component)
+                when :delete
+                  remove_probe(change.previous, component)
+                else
+                  # This really should never happen since we generate the
+                  # change types in the library.
+                  component.logger.debug { "di: unrecognized change type: #{change.type}" }
                 end
               end
-
-              begin
-                # TODO test exception capture
-                probe_manager.remove_other_probes(current_probe_ids.keys)
-              rescue => exc
-                raise if component.settings.dynamic_instrumentation.internal.propagate_all_exceptions
-
-                component.logger.debug { "di: unhandled exception removing probes in DI remote receiver: #{exc.class}: #{exc}" }
-                component.telemetry&.report(exc, description: "Unhandled exception removing probes in DI remote receiver")
-              end
             end
           end
         end
@@ -130,14 +67,82 @@ module Datadog
 
         private
 
-        def parse_content(content)
-          data = content.data.read
+        def add_probe(content, component)
+          probe_spec = parse_content(content)
+          probe = component.parse_probe_spec_and_notify(probe_spec)
+          component.logger.debug { "di: received #{probe.type} probe at #{probe.location} (#{probe.id}) via RC" }
+
+          begin
+            # TODO test exception capture
+            component.probe_manager.add_probe(probe)
+            content.applied
+          rescue DI::Error::DITargetNotInRegistry => exc
+            component.telemetry&.report(exc, description: "Line probe is targeting a loaded file that is not in code tracker")
+
+            payload = component.probe_notification_builder.build_errored(probe, exc)
+            component.probe_notifier_worker.add_status(payload)
+
+            # If a probe fails to install, we will mark the content
+            # as errored. On subsequent remote configuration application
+            # attemps, probe manager will raise the "previously errored"
+            # exception and we'll rescue it here, again marking the
+            # content as errored but with a somewhat different exception
+            # message.
+            # TODO assert content state (errored for this example)
+            content.errored("Error applying dynamic instrumentation configuration: #{exc.class.name} #{exc.message}")
+          rescue => exc
+            raise if component.settings.dynamic_instrumentation.internal.propagate_all_exceptions
+
+            component.logger.debug { "di: unhandled exception adding #{probe.type} probe at #{probe.location} (#{probe.id}) in DI remote receiver: #{exc.class}: #{exc}" }
+            component.telemetry&.report(exc, description: "Unhandled exception adding probe in DI remote receiver")
+
+            # TODO test this path
+            payload = component.probe_notification_builder.build_errored(probe, exc)
+            component.probe_notifier_worker.add_status(payload)
+
+            # If a probe fails to install, we will mark the content
+            # as errored. On subsequent remote configuration application
+            # attemps, probe manager will raise the "previously errored"
+            # exception and we'll rescue it here, again marking the
+            # content as errored but with a somewhat different exception
+            # message.
+            # TODO assert content state (errored for this example)
+            content.errored("Error applying dynamic instrumentation configuration: #{exc.class.name} #{exc.message}")
+          end
+
+          # Important: even if processing fails for this probe config,
+          # we need to note it as being current so that we do not
+          # try to remove instrumentation that is still supposed to be
+          # active.
+          #current_probe_ids[probe_spec.fetch('id')] = true
+        rescue => exc
+          raise if component.settings.dynamic_instrumentation.internal.propagate_all_exceptions
+
+          component.logger.debug { "di: unhandled exception handling a probe in DI remote receiver: #{exc.class}: #{exc}" }
+          component.telemetry&.report(exc, description: "Unhandled exception handling probe in DI remote receiver")
 
-          content.data.rewind
+          # TODO assert content state (errored for this example)
+          content.errored("Error applying dynamic instrumentation configuration: #{exc.class.name} #{exc.message}")
+        end
 
-          raise ReadError, 'EOF reached' if data.nil?
+        # This method does not mark +previous_content+ as succeeded or errored,
+        # because that content is from a previous RC response and has already
+        # been marked. Removal of probes happens when an RC entry disappears,
+        # as such there is nothing to mark.
+        def remove_probe(previous_content, component)
+          # TODO test exception capture
+          probe_spec = parse_content(previous_content)
+          probe_id = probe_spec.fetch('id')
+          component.probe_manager.remove_probe(probe_id)
+        rescue => exc
+          raise if component.settings.dynamic_instrumentation.internal.propagate_all_exceptions
+
+          component.logger.debug { "di: unhandled exception removing probes in DI remote receiver: #{exc.class}: #{exc}" }
+          component.telemetry&.report(exc, description: "Unhandled exception removing probes in DI remote receiver")
+        end
 
-          JSON.parse(data)
+        def parse_content(content)
+          JSON.parse(content.data)
         end
       end
     end

data/lib/datadog/di/transport/diagnostics.rb

@@ -1,6 +1,10 @@
 # frozen_string_literal: true
 
+require 'json'
+
 require_relative '../../core/transport/parcel'
+require_relative '../../core/transport/request'
+require_relative '../../core/transport/transport'
 require_relative 'http/diagnostics'
 
 module Datadog
@@ -14,46 +18,14 @@ module Datadog
         class Request < Datadog::Core::Transport::Request
         end
 
-        class Transport
-          attr_reader :client, :apis, :default_api, :current_api_id, :logger
-
-          def initialize(apis, default_api, logger:)
-            @apis = apis
-            @logger = logger
-
-            @client = DI::Transport::HTTP::Diagnostics::Client.new(current_api, logger: logger)
-          end
-
-          def current_api
-            @apis[HTTP::API::DIAGNOSTICS]
-          end
-
+        class Transport < Core::Transport::Transport
           def send_diagnostics(payload)
+            # TODO use transport encoder functionality?
             json = JSON.dump(payload)
             parcel = EncodedParcel.new(json)
             request = Request.new(parcel)
 
-            response = @client.send_diagnostics_payload(request)
-            unless response.ok?
-              # TODO Datadog::Core::Transport::InternalErrorResponse
-              # does not have +code+ method, what is the actual API of
-              # these response objects?
-              raise Error::AgentCommunicationError, "send_diagnostics failed: #{begin
-                response.code
-              rescue
-                "???"
-              end}: #{response.payload}"
-            end
-          rescue Error::AgentCommunicationError
-            raise
-          # Datadog::Core::Transport does not perform any exception mapping,
-          # therefore we could have any exception here from failure to parse
-          # agent URI for example.
-          # If we ever implement retries for network errors, we should distinguish
-          # actual network errors from non-network errors that are raised by
-          # transport code.
-          rescue => exc
-            raise Error::AgentCommunicationError, "send_diagnostics failed: #{exc.class}: #{exc}"
+            client.send_request(:diagnostics, request)
           end
         end
       end

data/lib/datadog/di/transport/http/diagnostics.rb

@@ -1,43 +1,13 @@
 # frozen_string_literal: true
 
-require_relative '../../../core/transport/http/api/instance'
-require_relative '../../../core/transport/http/api/spec'
-require_relative '../../../core/transport/http/client'
+require_relative '../../../core/transport/http/api/endpoint'
 
 module Datadog
   module DI
     module Transport
       module HTTP
         module Diagnostics
-          class Client < Core::Transport::HTTP::Client
-            def send_diagnostics_payload(request)
-              send_request(request) do |api, env|
-                api.send_diagnostics(env)
-              end
-            end
-          end
-
           module API
-            class Instance < Core::Transport::HTTP::API::Instance
-              def send_diagnostics(env)
-                raise Core::Transport::HTTP::API::Instance::EndpointNotSupportedError.new('diagnostics', self) unless spec.is_a?(Diagnostics::API::Spec)
-
-                spec.send_diagnostics(env) do |request_env|
-                  call(request_env)
-                end
-              end
-            end
-
-            class Spec < Core::Transport::HTTP::API::Spec
-              attr_accessor :diagnostics
-
-              def send_diagnostics(env, &block)
-                raise Core::Transport::HTTP::API::Spec::EndpointNotDefinedError.new('diagnostics', self) if diagnostics.nil?
-
-                diagnostics.call(env, &block)
-              end
-            end
-
             class Endpoint < Datadog::Core::Transport::HTTP::API::Endpoint
               attr_reader :encoder
 

data/lib/datadog/di/transport/http/input.rb

@@ -1,43 +1,13 @@
 # frozen_string_literal: true
 
-require_relative '../../../core/transport/http/api/instance'
-require_relative '../../../core/transport/http/api/spec'
-require_relative '../../../core/transport/http/client'
+require_relative '../../../core/transport/http/api/endpoint'
 
 module Datadog
   module DI
     module Transport
       module HTTP
         module Input
-          class Client < Core::Transport::HTTP::Client
-            def send_input_payload(request)
-              send_request(request) do |api, env|
-                api.send_input(env)
-              end
-            end
-          end
-
           module API
-            class Instance < Core::Transport::HTTP::API::Instance
-              def send_input(env)
-                raise Core::Transport::HTTP::API::Instance::EndpointNotSupportedError.new('input', self) unless spec.is_a?(Input::API::Spec)
-
-                spec.send_input(env) do |request_env|
-                  call(request_env)
-                end
-              end
-            end
-
-            class Spec < Core::Transport::HTTP::API::Spec
-              attr_accessor :input
-
-              def send_input(env, &block)
-                raise Core::Transport::HTTP::API::Spec::EndpointNotDefinedError.new('input', self) if input.nil?
-
-                input.call(env, &block)
-              end
-            end
-
             class Endpoint < Datadog::Core::Transport::HTTP::API::Endpoint
               HEADER_CONTENT_TYPE = 'Content-Type'
 

data/lib/datadog/di/transport/http.rb

@@ -1,31 +1,46 @@
 # frozen_string_literal: true
 
+require_relative '../../core/encoding'
+require_relative '../../core/transport/http'
 require_relative 'diagnostics'
 require_relative 'input'
-require_relative 'http/api'
-require_relative '../../core/transport/http'
 
 module Datadog
   module DI
     module Transport
       # Namespace for HTTP transport components
       module HTTP
-        module_function
+        DIAGNOSTICS = Diagnostics::API::Endpoint.new(
+          '/debugger/v1/diagnostics',
+          Core::Encoding::JSONEncoder,
+        )
+
+        INPUT = Input::API::Endpoint.new(
+          '/debugger/v2/input',
+          Core::Encoding::JSONEncoder,
+        )
+
+        LEGACY_INPUT = Input::API::Endpoint.new(
+          # We used to use /debugger/v1/input, but now input
+          # payloads should be going to the diagnostics endpoint
+          # which I gather performs data redaction.
+          '/debugger/v1/diagnostics',
+          Core::Encoding::JSONEncoder,
+        )
 
         # Builds a new Transport::HTTP::Client with default settings
         # Pass a block to override any settings.
-        def diagnostics(
+        def self.diagnostics(
           agent_settings:,
           logger:,
-          api_version: nil,
           headers: nil
         )
-          Core::Transport::HTTP.build(api_instance_class: Diagnostics::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::DIAGNOSTICS, apis[API::DIAGNOSTICS]
+            agent_settings: agent_settings,
+            headers: headers,
+          ) do |transport|
+            transport.api 'diagnostics', DIAGNOSTICS
 
             # Call block to apply any customization, if provided
             yield(transport) if block_given?
@@ -34,22 +49,18 @@ module Datadog
 
         # Builds a new Transport::HTTP::Client with default settings
         # Pass a block to override any settings.
-        def input(
+        def self.input(
           agent_settings:,
           logger:,
-          api_version: nil,
           headers: nil
         )
           Core::Transport::HTTP.build(
-            api_instance_class: Input::API::Instance,
             logger: logger,
             agent_settings: agent_settings,
-            api_version: api_version,
             headers: headers,
           ) do |transport|
-            apis = API.defaults
-
-            transport.api API::INPUT, apis[API::INPUT]
+            transport.api 'input', INPUT, fallback: 'legacy_input', default: true
+            transport.api 'legacy_input', LEGACY_INPUT
 
             # Call block to apply any customization, if provided
             yield(transport) if block_given?

data/lib/datadog/di/transport/input.rb

@@ -5,6 +5,7 @@ require_relative '../../core/encoding'
 require_relative '../../core/tag_builder'
 require_relative '../../core/transport/parcel'
 require_relative '../../core/transport/request'
+require_relative '../../core/transport/transport'
 require_relative '../error'
 require_relative 'http/input'
 
@@ -26,9 +27,7 @@ module Datadog
           end
         end
 
-        class Transport
-          attr_reader :client, :apis, :default_api, :current_api_id, :logger
-
+        class Transport < Core::Transport::Transport
           # The limit on an individual snapshot payload, aka "log line",
           # is 1 MB.
           #
@@ -48,17 +47,6 @@ module Datadog
           # max chunk size, it will still get sent out.
           DEFAULT_CHUNK_SIZE = 2 * 1024 * 1024
 
-          def initialize(apis, default_api, logger:)
-            @apis = apis
-            @logger = logger
-
-            @client = DI::Transport::HTTP::Input::Client.new(current_api, logger: logger)
-          end
-
-          def current_api
-            @apis[HTTP::API::INPUT]
-          end
-
           def send_input(payload, tags)
             # Tags are the same for all chunks, serialize them one time.
             serialized_tags = Core::TagBuilder.serialize_tags(tags)
@@ -101,27 +89,12 @@ module Datadog
             parcel = EncodedParcel.new(chunked_payload)
             request = Request.new(parcel, serialized_tags)
 
-            response = @client.send_input_payload(request)
-            unless response.ok?
-              # TODO Datadog::Core::Transport::InternalErrorResponse
-              # does not have +code+ method, what is the actual API of
-              # these response objects?
-              raise Error::AgentCommunicationError, "send_input failed: #{begin
-                response.code
-              rescue
-                "???"
-              end}: #{response.payload}"
+            client.send_request(:input, request).tap do |response|
+              if downgrade?(response)
+                downgrade!
+                return send_input_chunk(chunked_payload, serialized_tags)
+              end
             end
-          rescue Error::AgentCommunicationError
-            raise
-          # Datadog::Core::Transport does not perform any exception mapping,
-          # therefore we could have any exception here from failure to parse
-          # agent URI for example.
-          # If we ever implement retries for network errors, we should distinguish
-          # actual network errors from non-network errors that are raised by
-          # transport code.
-          rescue => exc
-            raise Error::AgentCommunicationError, "send_input failed: #{exc.class}: #{exc}"
           end
         end
       end

data/lib/datadog/di.rb

@@ -9,16 +9,13 @@ module Datadog
   #
   # @api private
   module DI
+    INSTRUMENTED_COUNTERS_LOCK = Mutex.new
+
     class << self
       def enabled?
         Datadog.configuration.dynamic_instrumentation.enabled
       end
-    end
-
-    # Expose DI to global shared objects
-    Extensions.activate!
 
-    class << self
       # This method is called from DI Remote handler to issue DI operations
       # to the probe manager (add or remove probes).
       #
@@ -31,6 +28,65 @@ module Datadog
       def component
         Datadog.send(:components).dynamic_instrumentation
       end
+
+      # Track how many outstanding instrumentations are in DI.
+      #
+      # It is hard to find the actual instrumentations - there is no
+      # method provided by Ruby to list all trace points, and we would
+      # need to manually track our instrumentation modules for method probes.
+      # Plus, tracking the modules could create active references to
+      # instrumentation, which is not desired.
+      #
+      # A simpler solution is to maintain a counter which is increased
+      # whenever a probe is installed and decreased when a probe is removed.
+      #
+      # This counter does not include pending probes - being not installed,
+      # those pose no concerns to customer applications.
+      def instrumented_count(kind = nil)
+        INSTRUMENTED_COUNTERS_LOCK.synchronize do
+          if defined?(@instrumented_count)
+            if kind
+              validate_kind!(kind)
+              @instrumented_count[kind] || 0
+            else
+              @instrumented_count.inject(0) do |sum, (_kind, count)|
+                sum + count
+              end
+            end
+          else
+            0
+          end
+        end
+      end
+
+      def instrumented_count_inc(kind)
+        validate_kind!(kind)
+        INSTRUMENTED_COUNTERS_LOCK.synchronize do
+          @instrumented_count = Hash.new(0) unless defined?(@instrumented_count)
+          @instrumented_count[kind] += 1
+        end
+      end
+
+      def instrumented_count_dec(kind)
+        validate_kind!(kind)
+        INSTRUMENTED_COUNTERS_LOCK.synchronize do
+          @instrumented_count = Hash.new(0) unless defined?(@instrumented_count)
+          if @instrumented_count[kind] <= 0
+            Datadog.logger.debug { "di: attempting to decrease instrumented count below zero for #{kind}" }
+            return
+          end
+          @instrumented_count[kind] -= 1
+        end
+      end
+
+      private def validate_kind!(kind)
+        unless %i[line method].include?(kind)
+          raise ArgumentError, "Invalid kind: #{kind}"
+        end
+      end
     end
+
+    # Expose DI to global shared objects
+    Extensions.activate!
   end
 end

data/lib/datadog/open_feature/evaluation_engine.rb

@@ -9,7 +9,8 @@ module Datadog
   module OpenFeature
     # This class performs the evaluation of the feature flag
     class EvaluationEngine
-      ReconfigurationError = Class.new(StandardError)
+      # Steep: https://github.com/soutaro/steep/issues/1880
+      ReconfigurationError = Class.new(StandardError) # steep:ignore IncompatibleAssignment
 
       ALLOWED_TYPES = %i[boolean string number float integer object].freeze