datadog 2.4.0 → 2.44.0

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

@@ -1,9 +1,9 @@
 # frozen_string_literal: true
 
-require 'securerandom'
+require "securerandom"
 
-require_relative 'configuration'
-require_relative 'dispatcher'
+require_relative "configuration"
+require_relative "dispatcher"
 
 module Datadog
   module Core
@@ -11,12 +11,15 @@ module Datadog
       # Client communicates with the agent and sync remote configuration
       class Client
         class TransportError < StandardError; end
+
         class SyncError < StandardError; end
 
-        attr_reader :transport, :repository, :id, :dispatcher
+        attr_reader :transport, :repository, :id, :dispatcher, :settings, :logger
 
-        def initialize(transport, capabilities, repository: Configuration::Repository.new)
+        def initialize(transport, capabilities, settings:, logger:, repository: Configuration::Repository.new)
           @transport = transport
+          @settings = settings
+          @logger = logger
 
           @repository = repository
           @id = SecureRandom.uuid
@@ -24,95 +27,103 @@ module Datadog
           @dispatcher = Dispatcher.new(@capabilities.receivers)
         end
 
-        # rubocop:disable Metrics/AbcSize,Metrics/PerceivedComplexity,Metrics/MethodLength,Metrics/CyclomaticComplexity
         def sync
           # TODO: Skip sync if no capabilities are registered
           response = transport.send_config(payload)
 
           if response.ok?
-            # when response is completely empty, do nothing as in: leave as is
-            if response.empty?
-              Datadog.logger.debug { 'remote: empty response => NOOP' }
+            process_response(response)
+          elsif response.internal_error?
+            raise TransportError, response.to_s
+          end
+        end
 
-              return
-            end
+        private
 
-            begin
-              paths = response.client_configs.map do |path|
-                Configuration::Path.parse(path)
-              end
+        def process_response(response)
+          # when response is completely empty, do nothing as in: leave as is
+          if response.empty?
+            logger.debug { "remote: empty response => NOOP" }
 
-              targets = Configuration::TargetMap.parse(response.targets)
+            return
+          end
 
-              contents = Configuration::ContentList.parse(response.target_files)
-            rescue Remote::Configuration::Path::ParseError => e
-              raise SyncError, e.message
+          begin
+            paths = response.client_configs.map do |path|
+              Configuration::Path.parse(path)
             end
 
-            # To make sure steep does not complain
-            return unless paths && targets && contents
+            targets = Configuration::TargetMap.parse(response.targets)
 
-            # TODO: sometimes it can strangely be so that paths.empty?
-            # TODO: sometimes it can strangely be so that targets.empty?
+            contents = Configuration::ContentList.parse(response.target_files)
+          rescue Remote::Configuration::Path::ParseError => e
+            raise SyncError, "#{e.class}: #{e.message}"
+          end
 
-            changes = repository.transaction do |current, transaction|
-              # paths to be removed: previously applied paths minus ingress paths
-              (current.paths - paths).each { |p| transaction.delete(p) }
+          # To make sure steep does not complain
+          return unless paths && targets && contents
 
-              # go through each ingress path
-              paths.each do |path|
-                # match target with path
-                target = targets[path]
+          # TODO: sometimes it can strangely be so that paths.empty?
+          # TODO: sometimes it can strangely be so that targets.empty?
 
-                # abort entirely if matching target not found
-                raise SyncError, "no target for path '#{path}'" if target.nil?
+          apply_config(paths, targets, contents)
+        end
 
-                # new paths are not in previously applied paths
-                new = !current.paths.include?(path)
+        def apply_config(paths, targets, contents)
+          changes = repository.transaction do |current, transaction|
+            # paths to be removed: previously applied paths minus ingress paths
+            (current.paths - paths).each { |p| transaction.delete(p) }
 
-                # updated paths are in previously applied paths
-                # but the content hash changed
-                changed = current.paths.include?(path) && !current.contents.find_content(path, target)
+            # go through each ingress path
+            paths.each do |path|
+              # match target with path
+              target = targets[path]
 
-                # skip if unchanged
-                same = !new && !changed
+              # abort entirely if matching target not found
+              raise SyncError, "no target for path '#{path}'" if target.nil?
 
-                next if same
+              # new paths are not in previously applied paths
+              new = !current.paths.include?(path)
 
-                # match content with path and target
-                content = contents.find_content(path, target)
+              # updated paths are in previously applied paths
+              # but the content hash changed
+              changed = current.paths.include?(path) && !current.contents.find_content(path, target)
 
-                # abort entirely if matching content not found
-                raise SyncError, "no valid content for target at path '#{path}'" if content.nil?
+              # skip if unchanged
+              same = !new && !changed
 
-                # to be added or updated << config
-                # TODO: metadata (hash, version, etc...)
-                transaction.insert(path, target, content) if new
-                transaction.update(path, target, content) if changed
-              end
+              next if same
 
-              # save backend opaque backend state
-              transaction.set(opaque_backend_state: targets.opaque_backend_state)
-              transaction.set(targets_version: targets.version)
+              # match content with path and target
+              content = contents.find_content(path, target)
 
-              # upon transaction end, new list of applied config + metadata (add, change, remove) will be saved
-              # TODO: also remove stale config (matching removed) from cache (client configs is exhaustive list of paths)
-            end
+              # abort entirely if matching content not found
+              if content.nil?
+                raise SyncError, "no valid content for target at path '#{path}'"
+              end
 
-            if changes.empty?
-              Datadog.logger.debug { 'remote: no changes' }
-            else
-              dispatcher.dispatch(changes, repository)
+              # to be added or updated << config
+              # TODO: metadata (hash, version, etc...)
+              transaction.insert(path, target, content) if new
+              transaction.update(path, target, content) if changed
             end
-          elsif response.internal_error?
-            raise TransportError, response.to_s
+
+            # save backend opaque backend state
+            transaction.set(opaque_backend_state: targets.opaque_backend_state)
+            transaction.set(targets_version: targets.version)
+
+            # upon transaction end, new list of applied config + metadata (add, change, remove) will be saved
+            # TODO: also remove stale config (matching removed) from cache (client configs is exhaustive list of paths)
           end
-        end
-        # rubocop:enable Metrics/AbcSize,Metrics/PerceivedComplexity,Metrics/MethodLength,Metrics/CyclomaticComplexity
 
-        private
+          if changes.empty?
+            logger.debug { "remote: no changes" }
+          else
+            dispatcher.dispatch(changes, repository)
+          end
+        end
 
-        def payload # rubocop:disable Metrics/MethodLength
+        def payload # standard:disable Metrics/MethodLength
           state = repository.state
 
           client_tracer_tags = [
@@ -127,25 +138,37 @@ module Datadog
             "ruby.runtime.engine.name:#{RUBY_ENGINE}",
             "ruby.runtime.engine.version:#{ruby_engine_version}",
             "ruby.rubygems.platform.local:#{Gem::Platform.local}",
-            "ruby.gem.libddwaf.version:#{gem_spec('libddwaf').version}",
-            "ruby.gem.libddwaf.platform:#{gem_spec('libddwaf').platform}",
-            "ruby.gem.libdatadog.version:#{gem_spec('libdatadog').version}",
-            "ruby.gem.libdatadog.platform:#{gem_spec('libdatadog').platform}",
+            "ruby.gem.libddwaf.version:#{gem_spec("libddwaf").version}",
+            "ruby.gem.libddwaf.platform:#{gem_spec("libddwaf").platform}",
+            "ruby.gem.libdatadog.version:#{gem_spec("libdatadog").version}",
+            "ruby.gem.libdatadog.platform:#{gem_spec("libdatadog").platform}",
           ]
 
+          if (git_repository_url = Core::Environment::Git.git_repository_url)
+            client_tracer_tags << "git.repository_url:#{git_repository_url}"
+          end
+          if (git_commit_sha = Core::Environment::Git.git_commit_sha)
+            client_tracer_tags << "git.commit.sha:#{git_commit_sha}"
+          end
+
           client_tracer = {
             runtime_id: Core::Environment::Identity.id,
             language: Core::Environment::Identity.lang,
             tracer_version: tracer_version,
             service: service_name,
-            env: Datadog.configuration.env,
+            env: settings.env,
             tags: client_tracer_tags,
           }
 
-          app_version = Datadog.configuration.version
+          app_version = settings.version
 
           client_tracer[:app_version] = app_version if app_version
 
+          if settings.experimental_propagate_process_tags_enabled
+            process_tags = Core::Environment::Process.tags
+            client_tracer[:process_tags] = process_tags if process_tags.any?
+          end
+
           {
             client: {
               state: {
@@ -162,14 +185,14 @@ module Datadog
               is_agent: false,
               client_tracer: client_tracer,
               # base64 is needed otherwise the Go agent fails with an unmarshal error
-              capabilities: @capabilities.base64_capabilities
+              capabilities: @capabilities.base64_capabilities,
             },
             cached_target_files: state.cached_target_files,
           }
         end
 
         def service_name
-          Datadog.configuration.remote.service || Datadog.configuration.service
+          settings.remote.service || settings.service
         end
 
         def tracer_version
@@ -187,40 +210,40 @@ module Datadog
         def native_platform
           return @native_platform unless @native_platform.nil?
 
-          os = if RUBY_ENGINE == 'jruby'
-                 os_name = java.lang.System.get_property('os.name')
-
-                 case os_name
-                 when /linux/i then 'linux'
-                 when /mac/i   then 'darwin'
-                 else os_name
-                 end
-               else
-                 Gem::Platform.local.os
-               end
-
-          version = if os != 'linux'
-                      nil
-                    elsif RUBY_PLATFORM =~ /linux-(.+)$/
-                      # Old rubygems don't handle non-gnu linux correctly
-                      Regexp.last_match(1)
-                    else
-                      'gnu'
-                    end
-
-          cpu = if RUBY_ENGINE == 'jruby'
-                  os_arch = java.lang.System.get_property('os.arch')
-
-                  case os_arch
-                  when 'amd64' then 'x86_64'
-                  when 'aarch64' then os == 'darwin' ? 'arm64' : 'aarch64'
-                  else os_arch
-                  end
-                else
-                  Gem::Platform.local.cpu
-                end
-
-          @native_platform = [cpu, os, version].compact.join('-')
+          os = if RUBY_ENGINE == "jruby"
+            os_name = java.lang.System.get_property("os.name")
+
+            case os_name
+            when /linux/i then "linux"
+            when /mac/i then "darwin"
+            else os_name
+            end
+          else
+            Gem::Platform.local.os
+          end
+
+          version = if os != "linux"
+            nil
+          elsif RUBY_PLATFORM =~ /linux-(.+)$/
+            # Old rubygems don't handle non-gnu linux correctly
+            Regexp.last_match(1)
+          else
+            "gnu"
+          end
+
+          cpu = if RUBY_ENGINE == "jruby"
+            os_arch = java.lang.System.get_property("os.arch")
+
+            case os_arch
+            when "amd64" then "x86_64"
+            when "aarch64" then (os == "darwin") ? "arm64" : "aarch64"
+            else os_arch
+            end
+          else
+            Gem::Platform.local.cpu
+          end
+
+          @native_platform = [cpu, os, version].compact.join("-")
         end
 
         GemSpecificationFallback = _ = Struct.new(:version, :platform) # rubocop:disable Naming/ConstantName

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

@@ -1,35 +1,39 @@
 # frozen_string_literal: true
 
-require_relative 'worker'
-require_relative 'client/capabilities'
-require_relative 'client'
-require_relative 'transport/http'
-require_relative '../remote'
-require_relative 'negotiation'
+require_relative "worker"
+require_relative "client/capabilities"
+require_relative "client"
+require_relative "transport/http"
+require_relative "../remote"
+require_relative "negotiation"
 
 module Datadog
   module Core
     module Remote
       # Configures the HTTP transport to communicate with the agent
-      # to fetch and sync the remote configuration
+      # to fetch and sync the remote configuration.
+      #
+      # @api private
       class Component
-        attr_reader :client, :healthy
+        attr_reader :logger, :client, :healthy, :worker
 
-        def initialize(settings, capabilities, agent_settings)
-          transport_options = {}
-          transport_options[:agent_settings] = agent_settings if agent_settings
+        def initialize(settings, capabilities, agent_settings, logger:)
+          @logger = logger
+          @settings = settings
+          @capabilities = capabilities
+          @agent_settings = agent_settings
 
-          negotiation = Negotiation.new(settings, agent_settings)
-          transport_v7 = Datadog::Core::Remote::Transport::HTTP.v7(**transport_options.dup)
+          negotiation = Negotiation.new(settings, agent_settings, logger: logger)
+          @transport = Datadog::Core::Remote::Transport::HTTP.v7(agent_settings: agent_settings, logger: logger)
 
           @barrier = Barrier.new(settings.remote.boot_timeout_seconds)
 
-          @client = Client.new(transport_v7, capabilities)
+          @client = Client.new(@transport, @capabilities, settings: settings, logger: logger)
           @healthy = false
-          Datadog.logger.debug { "new remote configuration client: #{@client.id}" }
+          logger.debug { "new remote configuration client: #{@client.id} products: #{@capabilities.products.sort.join(", ")}" }
 
-          @worker = Worker.new(interval: settings.remote.poll_interval_seconds) do
-            unless @healthy || negotiation.endpoint?('/v0.7/config')
+          @worker = Worker.new(interval: settings.remote.poll_interval_seconds, logger: logger) do
+            unless @healthy || negotiation.endpoint?("/v0.7/config")
               @barrier.lift
 
               next
@@ -40,25 +44,25 @@ module Datadog
               @healthy ||= true
             rescue Client::SyncError => e
               # Transient errors due to network or agent. Logged the error but not via telemetry
-              Datadog.logger.error do
-                "remote worker client sync error: #{e.message} location: #{Array(e.backtrace).first}. skipping sync"
+              logger.error do
+                "remote worker client sync error: #{e.class}: #{e.message} location: #{Array(e.backtrace).first}. skipping sync"
               end
-            rescue StandardError => e
+            rescue => e
               # In case of unexpected errors, reset the negotiation object
               # given external conditions have changed and the negotiation
               # negotiation object stores error logging state that should be reset.
-              negotiation = Negotiation.new(settings, agent_settings)
+              negotiation = Negotiation.new(settings, agent_settings, logger: logger)
 
               # Transient errors due to network or agent. Logged the error but not via telemetry
-              Datadog.logger.error do
-                "remote worker error: #{e.class.name} #{e.message} location: #{Array(e.backtrace).first}. "\
-                'reseting client state'
+              logger.error do
+                "remote worker error: #{e.class}: #{e.message} location: #{Array(e.backtrace).first}. " \
+                "resetting client state"
               end
 
               # client state is unknown, state might be corrupted
-              @client = Client.new(transport_v7, capabilities)
+              @client = Client.new(@transport, @capabilities, settings: settings, logger: logger)
               @healthy = false
-              Datadog.logger.debug { "new remote configuration client: #{@client.id}" }
+              logger.debug { "new remote configuration client: #{@client.id} products: #{@capabilities.products.sort.join(", ")}" }
 
               # TODO: bail out if too many errors?
             end
@@ -89,10 +93,29 @@ module Datadog
           @worker.stop
         end
 
+        # Recreates the remote configuration client after a fork.
+        # This ensures each forked process has a unique client ID and fresh state.
+        def after_fork
+          @worker.after_fork
+          @barrier = Barrier.new(@settings.remote.boot_timeout_seconds)
+          @client = Client.new(@transport, @capabilities, settings: @settings, logger: @logger)
+          @healthy = false
+          logger.debug { "remote configuration client recreated after fork: #{@client.id} products: #{@capabilities.products.sort.join(", ")}" }
+        end
+
+        def add_products(*products)
+          @capabilities.add_products(*products)
+        end
+
+        def remove_products(*products)
+          @capabilities.remove_products(*products)
+        end
+
         # Barrier provides a mechanism to fence execution until a condition happens
         class Barrier
           def initialize(timeout = nil)
             @once = false
+            @waited = false
             @timeout = timeout
 
             @mutex = Mutex.new
@@ -100,49 +123,63 @@ module Datadog
           end
 
           # Wait for first lift to happen, otherwise don't wait
+          #
+          # Returns:
+          # - :lift if the barrier was lifted (worker completed a cycle)
+          # - :timeout if the wait timed out before the barrier was lifted
+          # - :pass if wait_once was already called previously
+          #
+          # Uses a separate @waited flag to distinguish "already waited" (:pass)
+          # from "worker lifted before we could wait" (:lift). Without this,
+          # a race between Worker#start and wait_once can cause the first call
+          # to return :pass if the worker completes before wait_once runs.
           def wait_once(timeout = nil)
-            # TTAS (Test and Test-And-Set) optimisation
-            # Since @once only ever goes from false to true, this is semantically valid
-            return :pass if @once
-
-            begin
-              @mutex.lock
-
-              return :pass if @once
-
-              timeout ||= @timeout
-
-              # - starting with Ruby 3.2, ConditionVariable#wait returns nil on
-              #   timeout and an integer otherwise
-              # - before Ruby 3.2, ConditionVariable returns itself
-              # so we have to rely on @once having been set
-              if RUBY_VERSION >= '3.2'
-                lifted = @condition.wait(@mutex, timeout)
+            # TTAS (Test and Test-And-Set) optimisation for subsequent calls.
+            # @waited is only set inside the mutex and only transitions false -> true,
+            # so an unsynchronized read is safe: a stale `false` just falls through
+            # to the synchronized path which re-checks.
+            return :pass if @waited
+
+            @mutex.synchronize do
+              return :pass if @waited
+
+              if @once
+                # Worker lifted the barrier before we could wait.
+                # This is still the first call, so return :lift not :pass.
+                lifted = true
               else
-                @condition.wait(@mutex, timeout)
-                lifted = @once
+                timeout ||= @timeout
+
+                # - starting with Ruby 3.2, ConditionVariable#wait returns nil on
+                #   timeout and an integer otherwise
+                # - before Ruby 3.2, ConditionVariable returns itself
+                # so we have to rely on @once having been set
+                if RubyVersion.is?(">= 3.2")
+                  lifted = @condition.wait(@mutex, timeout)
+                else
+                  @condition.wait(@mutex, timeout)
+                  lifted = @once
+                end
               end
 
+              @waited = true
+
               if lifted
                 :lift
               else
                 @once = true
                 :timeout
               end
-            ensure
-              @mutex.unlock
             end
           end
 
           # Release all current waiters
           def lift
-            @mutex.lock
+            @mutex.synchronize do
+              @once ||= true
 
-            @once ||= true
-
-            @condition.broadcast
-          ensure
-            @mutex.unlock
+              @condition.broadcast
+            end
           end
         end
 
@@ -152,10 +189,15 @@ module Datadog
           #
           # Those checks are instead performed inside the worker loop.
           # This allows users to upgrade their agent while keeping their application running.
-          def build(settings, agent_settings, telemetry:)
+          def build(settings, agent_settings, logger:, telemetry:, open_feature_component_provider: nil)
             return unless settings.remote.enabled
 
-            new(settings, Client::Capabilities.new(settings, telemetry), agent_settings)
+            capabilities = Client::Capabilities.new(
+              settings,
+              telemetry,
+              open_feature_component_provider: open_feature_component_provider,
+            )
+            new(settings, capabilities, agent_settings, logger: logger)
           end
         end
       end

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

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-require_relative 'path'
-require_relative 'digest'
+require_relative "path"
+require_relative "digest"
 
 module Datadog
   module Core
@@ -22,6 +22,18 @@ module Datadog
           attr_accessor :version
 
           def initialize(path:, data:)
+            if data.nil?
+              # +data+ is passed to Digest calculation and also is
+              # unconditionally taken length of by +length+ method.
+              # As such, the class is not written to expect +data+ to be nil.
+              # Detect bad incoming values here to provide earlier diagnostics
+              # when developing tests, for example.
+              raise ArgumentError, "data must not be nil"
+            end
+            unless String === data
+              raise ArgumentError, "Invalid type for data: #{data.class}: expected String"
+            end
+
             @path = path
             @data = data
             @apply_state = ApplyState::UNACKNOWLEDGED
@@ -72,8 +84,9 @@ module Datadog
           private_class_method :new
         end
 
-        # ContentList stores a list of Conetnt instances
-        # It provides convinient methods for finding content base on Configuration::Path and Configuration::Target
+        # ContentList stores a list of Content instances.
+        # It provides convenient methods for finding content based on
+        # Configuration::Path and Configuration::Target.
         class ContentList < Array
           class << self
             def parse(array)

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

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'digest'
+require "digest"
 
 module Datadog
   module Core
@@ -24,26 +24,33 @@ module Datadog
           class InvalidHashTypeError < StandardError; end
           attr_reader :type, :hexdigest
 
-          DIGEST_CHUNK = 1024
-
           class << self
             def hexdigest(type, data)
+              unless String === data
+                # This class (Digest) passes +data+ to the Ruby standard
+                # library Digest routines without validating its type.
+                # The stdlib Digest requires a String, and the previous
+                # implementation of this class that used StringIO
+                # unconditionally read from +data+ without validating the
+                # type. Meaning, passing +nil+ as +data+ has never worked.
+                # It still doesn't work in the present implementation.
+                # Flag the nil data now to get earlier diagnostics when
+                # developing tests for example.
+                raise ArgumentError, "Invalid type for data: #{data.class}: expected String"
+              end
+
               d = case type
-                  when :sha256
-                    ::Digest::SHA256.new
-                  when :sha512
-                    ::Digest::SHA512.new
-                  else
-                    raise InvalidHashTypeError, type
-                  end
-
-              while (buf = data.read(DIGEST_CHUNK))
-                d.update(buf)
+              when :sha256
+                ::Digest::SHA256.new
+              when :sha512
+                ::Digest::SHA512.new
+              else
+                raise InvalidHashTypeError, type
               end
 
+              d.update(data)
+
               d.hexdigest
-            ensure
-              data.rewind
             end
           end