datadog 2.7.1 → 2.17.0

data/lib/datadog/core/rate_limiter.rb

@@ -13,13 +13,15 @@ module Datadog
       # to be side-effect free.
       #
       # @return [Boolean] whether a resource conforms with the current limit
-      def allow?(size = 1); end
+      def allow?(size = 1)
+      end
 
       # The effective rate limiting ratio based on
       # recent calls to `allow?`.
       #
       # @return [Float] recent allowance ratio
-      def effective_rate; end
+      def effective_rate
+      end
     end
 
     # Implementation of the Token Bucket metering algorithm

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

@@ -32,6 +32,12 @@ module Datadog
               register_receivers(Datadog::AppSec::Remote.receivers(@telemetry))
             end
 
+            if settings.respond_to?(:dynamic_instrumentation) && settings.dynamic_instrumentation.enabled
+              register_capabilities(Datadog::DI::Remote.capabilities)
+              register_products(Datadog::DI::Remote.products)
+              register_receivers(Datadog::DI::Remote.receivers(@telemetry))
+            end
+
             register_capabilities(Datadog::Tracing::Remote.capabilities)
             register_products(Datadog::Tracing::Remote.products)
             register_receivers(Datadog::Tracing::Remote.receivers(@telemetry))

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

@@ -11,12 +11,14 @@ 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, :logger
 
-        def initialize(transport, capabilities, repository: Configuration::Repository.new)
+        def initialize(transport, capabilities, logger: Datadog.logger, repository: Configuration::Repository.new)
           @transport = transport
+          @logger = logger
 
           @repository = repository
           @id = SecureRandom.uuid
@@ -24,95 +26,101 @@ 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.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
+              raise SyncError, "no valid content for target at path '#{path}'" if content.nil?
 
-            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,12 +135,19 @@ 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,
@@ -188,37 +203,37 @@ module Datadog
           return @native_platform unless @native_platform.nil?
 
           os = if RUBY_ENGINE == 'jruby'
-                 os_name = java.lang.System.get_property('os.name')
+            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
+            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
+            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
+            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

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

@@ -13,22 +13,21 @@ module Datadog
       # Configures the HTTP transport to communicate with the agent
       # to fetch and sync the remote configuration
       class Component
-        attr_reader :client, :healthy
+        attr_reader :logger, :client, :healthy
 
-        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
 
-          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_v7 = 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_v7, capabilities, logger: logger)
           @healthy = false
-          Datadog.logger.debug { "new remote configuration client: #{@client.id}" }
+          logger.debug { "new remote configuration client: #{@client.id}" }
 
-          @worker = Worker.new(interval: settings.remote.poll_interval_seconds) do
+          @worker = Worker.new(interval: settings.remote.poll_interval_seconds, logger: logger) do
             unless @healthy || negotiation.endpoint?('/v0.7/config')
               @barrier.lift
 
@@ -40,25 +39,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
+              logger.error do
                 "remote worker client sync error: #{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.name} #{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_v7, capabilities, logger: logger)
               @healthy = false
-              Datadog.logger.debug { "new remote configuration client: #{@client.id}" }
+              logger.debug { "new remote configuration client: #{@client.id}" }
 
               # TODO: bail out if too many errors?
             end
@@ -152,10 +151,10 @@ 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:)
             return unless settings.remote.enabled
 
-            new(settings, Client::Capabilities.new(settings, telemetry), agent_settings)
+            new(settings, Client::Capabilities.new(settings, telemetry), agent_settings, logger: logger)
           end
         end
       end

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/configuration/repository.rb

@@ -272,7 +272,8 @@ module Datadog
 
               return deleted(path, previous) if previous && content.nil?
               return inserted(path, content) if content && previous.nil?
-              return updated(path, content, previous) if content && previous
+
+              updated(path, content, previous) if content && previous
             end
 
             def deleted(path, previous)

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

@@ -7,11 +7,11 @@ module Datadog
     module Remote
       # Endpoint negotiation
       class Negotiation
-        def initialize(_settings, agent_settings, suppress_logging: {})
-          transport_options = {}
-          transport_options[:agent_settings] = agent_settings if agent_settings
+        attr_reader :logger
 
-          @transport_root = Datadog::Core::Remote::Transport::HTTP.root(**transport_options.dup)
+        def initialize(_settings, agent_settings, logger: Datadog.logger, suppress_logging: {})
+          @logger = logger
+          @transport_root = Datadog::Core::Remote::Transport::HTTP.root(agent_settings: agent_settings, logger: logger)
           @logged = suppress_logging
         end
 
@@ -20,7 +20,7 @@ module Datadog
 
           if res.internal_error? && network_error?(res.error)
             unless @logged[:agent_unreachable]
-              Datadog.logger.warn { "agent unreachable: cannot negotiate #{path}" }
+              logger.warn { "agent unreachable: cannot negotiate #{path}" }
               @logged[:agent_unreachable] = true
             end
 
@@ -29,7 +29,7 @@ module Datadog
 
           if res.not_found?
             unless @logged[:no_info_endpoint]
-              Datadog.logger.warn { "agent reachable but has no /info endpoint: cannot negotiate #{path}" }
+              logger.warn { "agent reachable but has no /info endpoint: cannot negotiate #{path}" }
               @logged[:no_info_endpoint] = true
             end
 
@@ -38,7 +38,7 @@ module Datadog
 
           unless res.ok?
             unless @logged[:unexpected_response]
-              Datadog.logger.warn { "agent reachable but unexpected response: cannot negotiate #{path}" }
+              logger.warn { "agent reachable but unexpected response: cannot negotiate #{path}" }
               @logged[:unexpected_response] = true
             end
 
@@ -47,14 +47,14 @@ module Datadog
 
           unless res.endpoints.include?(path)
             unless @logged[:no_config_endpoint]
-              Datadog.logger.warn { "agent reachable but does not report #{path}" }
+              logger.warn { "agent reachable but does not report #{path}" }
               @logged[:no_config_endpoint] = true
             end
 
             return false
           end
 
-          Datadog.logger.debug { "agent reachable and reports #{path}" }
+          logger.debug { "agent reachable and reports #{path}" }
 
           true
         end

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

@@ -32,12 +32,13 @@ module Datadog
 
           # Config transport
           class Transport
-            attr_reader :client, :apis, :default_api, :current_api_id
+            attr_reader :client, :apis, :default_api, :current_api_id, :logger
 
-            def initialize(apis, default_api)
+            def initialize(apis, default_api, logger: Datadog.logger)
               @apis = apis
+              @logger = logger
 
-              @client = HTTP::Client.new(current_api)
+              @client = HTTP::Client.new(current_api, logger: logger)
             end
 
             ##### there is only one transport! it's negotiation!

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

@@ -2,24 +2,9 @@
 
 require_relative '../../../encoding'
 require_relative '../../../transport/http/api/map'
-
-# TODO: Decouple standard transport/http/api/instance
-#
-# Separate classes are needed because transport/http/traces includes
-# Trace::API::Instance which closes over and uses a single spec, which is
-# negotiated as either /v3 or /v4 for the whole API at the spec level, but we
-# need an independent toplevel path at the endpoint level.
-#
-# Separate classes are needed because of `include Trace::API::Instance`.
-#
-# Below should be:
-# require_relative '../../../../datadog/core/transport/http/api/spec'
-require_relative 'api/spec'
-
-# TODO: only needed for Negotiation::API::Endpoint
+require_relative '../../../transport/http/api/instance'
+require_relative '../../../transport/http/api/spec'
 require_relative 'negotiation'
-
-# TODO: only needed for Config::API::Endpoint
 require_relative 'config'
 
 module Datadog
@@ -36,7 +21,7 @@ module Datadog
             module_function
 
             def defaults
-              Datadog::Core::Transport::HTTP::API::Map[
+              Core::Transport::HTTP::API::Map[
                 ROOT => Spec.new do |s|
                   s.info = Negotiation::API::Endpoint.new(
                     '/info',
@@ -50,6 +35,16 @@ module Datadog
                 end,
               ]
             end
+
+            class Instance < Core::Transport::HTTP::API::Instance
+              include Config::API::Instance
+              include Negotiation::API::Instance
+            end
+
+            class Spec < Core::Transport::HTTP::API::Spec
+              include Config::API::Spec
+              include Negotiation::API::Spec
+            end
           end
         end
       end

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

@@ -15,10 +15,11 @@ module Datadog
         module HTTP
           # Routes, encodes, and sends tracer data to the trace agent via HTTP.
           class Client
-            attr_reader :api
+            attr_reader :api, :logger
 
-            def initialize(api)
+            def initialize(api, logger: Datadog.logger)
               @api = api
+              @logger = logger
             end
 
             def send_request(request, &block)
@@ -27,12 +28,12 @@ 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}"
 
-              Datadog.logger.debug(message)
+              logger.debug(message)
 
               Datadog::Core::Transport::InternalErrorResponse.new(e)
             end