datadog 2.16.0 → 2.17.0

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

@@ -75,10 +75,10 @@ module Datadog
           #
           # Versions < 5.0 are always single-threaded, but do not have the kwarg option.
           options = if dogstatsd_version >= Gem::Version.new('5.2')
-                      { single_thread: true }
-                    else
-                      {}
-                    end
+            {single_thread: true}
+          else
+            {}
+          end
 
           Datadog::Statsd.new(default_hostname, default_port, **options)
         end
@@ -99,7 +99,7 @@ module Datadog
           raise ArgumentError if value.nil?
 
           statsd.count(stat, value, metric_options(options))
-        rescue StandardError => e
+        rescue => e
           logger.error(
             "Failed to send count stat. Cause: #{e.class.name} #{e.message} Source: #{Array(e.backtrace).first}"
           )
@@ -113,7 +113,7 @@ module Datadog
           raise ArgumentError if value.nil?
 
           statsd.distribution(stat, value, metric_options(options))
-        rescue StandardError => e
+        rescue => e
           logger.error(
             "Failed to send distribution stat. Cause: #{e.class.name} #{e.message} Source: #{Array(e.backtrace).first}"
           )
@@ -126,7 +126,7 @@ module Datadog
           options = yield if block_given?
 
           statsd.increment(stat, metric_options(options))
-        rescue StandardError => e
+        rescue => e
           logger.error(
             "Failed to send increment stat. Cause: #{e.class.name} #{e.message} Source: #{Array(e.backtrace).first}"
           )
@@ -140,7 +140,7 @@ module Datadog
           raise ArgumentError if value.nil?
 
           statsd.gauge(stat, value, metric_options(options))
-        rescue StandardError => e
+        rescue => e
           logger.error(
             "Failed to send gauge stat. Cause: #{e.class.name} #{e.message} Source: #{Array(e.backtrace).first}"
           )
@@ -159,7 +159,7 @@ module Datadog
               finished = Utils::Time.get_time
               distribution(stat, ((finished - start) * 1000), options)
             end
-          rescue StandardError => e
+          rescue => e
             # TODO: Likely to be redundant, since `distribution` handles its own errors.
             logger.error(
               "Failed to send time stat. Cause: #{e.class.name} #{e.message} Source: #{Array(e.backtrace).first}"
@@ -173,7 +173,7 @@ module Datadog
         end
 
         def close
-          @statsd.close if @statsd && @statsd.respond_to?(:close)
+          @statsd.close if @statsd&.respond_to?(:close)
         end
 
         private
@@ -185,10 +185,8 @@ module Datadog
             defined?(Datadog::Statsd::VERSION) &&
               Datadog::Statsd::VERSION &&
               Gem::Version.new(Datadog::Statsd::VERSION)
-          ) || (
-            Gem.loaded_specs['dogstatsd-ruby'] &&
-              Gem.loaded_specs['dogstatsd-ruby'].version
-          )
+          ) ||
+            Gem.loaded_specs['dogstatsd-ruby']&.version
         end
 
         IGNORED_STATSD_ONLY_ONCE = Utils::OnlyOnce.new

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

@@ -17,25 +17,25 @@ module Datadog
               l.progname = nil
               l.formatter = proc do |_severity, datetime, _progname, msg|
                 stat = JSON.parse(msg[3..-1]) # Trim off leading progname...
-                "#{JSON.dump(timestamp: datetime.to_i, message: 'Metric sent.', metric: stat)}\n"
+                "#{JSON.dump(timestamp: datetime.to_i, message: "Metric sent.", metric: stat)}\n"
               end
             end
           end
 
           def count(stat, value, options = nil)
-            logger.info({ stat: stat, type: :count, value: value, options: options }.to_json)
+            logger.info({stat: stat, type: :count, value: value, options: options}.to_json)
           end
 
           def distribution(stat, value, options = nil)
-            logger.info({ stat: stat, type: :distribution, value: value, options: options }.to_json)
+            logger.info({stat: stat, type: :distribution, value: value, options: options}.to_json)
           end
 
           def increment(stat, options = nil)
-            logger.info({ stat: stat, type: :increment, options: options }.to_json)
+            logger.info({stat: stat, type: :increment, options: options}.to_json)
           end
 
           def gauge(stat, value, options = nil)
-            logger.info({ stat: stat, type: :gauge, value: value, options: options }.to_json)
+            logger.info({stat: stat, type: :gauge, value: value, options: options}.to_json)
           end
         end
       end

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.rb

@@ -11,6 +11,7 @@ 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, :logger
@@ -119,7 +120,7 @@ module Datadog
           end
         end
 
-        def payload # rubocop:disable Metrics/MethodLength
+        def payload # standard:disable Metrics/MethodLength
           state = repository.state
 
           client_tracer_tags = [
@@ -134,10 +135,10 @@ 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)
@@ -202,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

@@ -42,7 +42,7 @@ module Datadog
               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.
@@ -50,8 +50,8 @@ module Datadog
 
               # Transient errors due to network or agent. Logged the error but not via telemetry
               logger.error do
-                "remote worker error: #{e.class.name} #{e.message} location: #{Array(e.backtrace).first}. "\
-                'reseting client state'
+                "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

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

@@ -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

@@ -16,6 +16,8 @@ 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, :transport, :worker
 
@@ -40,7 +42,7 @@ module Datadog
         end
 
         # @param enabled [Boolean] Determines whether telemetry events should be sent to the API
-        def initialize( # rubocop: disable Metrics/MethodLength
+        def initialize( # standard:disable Metrics/MethodLength
           settings:,
           agent_settings:,
           logger:,
@@ -60,25 +62,25 @@ module Datadog
           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
+            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,
@@ -94,8 +96,6 @@ module Datadog
             logger: logger,
             shutdown_timeout: settings.telemetry.shutdown_timeout_seconds,
           )
-
-          @worker.start
         end
 
         def disable!
@@ -103,10 +103,25 @@ module Datadog
           @worker&.enabled = false
         end
 
-        def stop!
+        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 shutdown!
           return if @stopped
 
-          @worker&.stop(true)
+          if defined?(@worker)
+            @worker&.stop(true)
+          end
+
           @stopped = true
         end
 

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

@@ -34,7 +34,13 @@ module Datadog
           logger.debug { "Telemetry sent for event `#{event.type}` (response code: #{res.code})" }
           res
         rescue => e
-          logger.debug { "Unable to send telemetry request for event `#{event.type rescue 'unknown'}`: #{e}" }
+          logger.debug {
+            "Unable to send telemetry request for event `#{begin
+              event.type
+            rescue
+              "unknown"
+            end}`: #{e}"
+          }
           Core::Transport::InternalErrorResponse.new(e)
         end
 

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