datadog 2.30.0 → 2.31.0

data/lib/datadog/core/configuration/options.rb

@@ -16,17 +16,47 @@ module Datadog
         # Class behavior for a configuration object with options
         # @public_api
         module ClassMethods
+          def settings_path
+            defined?(@settings_path) ? @settings_path : nil
+          end
+
+          # Registry of nested settings classes keyed by the option name declared
+          # via `Base.settings`. This lets us propagate a new settings path down the
+          # tree without storing parent references on the nested class or on the
+          # option definition itself.
+          def settings_children
+            @settings_children ||= if superclass <= Options
+              superclass.settings_children.dup
+            else
+              {}
+            end
+          end
+
+          def settings_path=(path)
+            @settings_path = path
+
+            # Keep nested settings paths in sync when a parent settings path is
+            # assigned later, which is how contrib integrations inject
+            # "tracing.<integration>" into their configuration classes.
+            settings_children.each do |name, settings_class|
+              nested_settings_path = path ? "#{path}.#{name}" : name.to_s
+              settings_class.settings_path = nested_settings_path
+            end
+          end
+
           def options
             # Allows for class inheritance of option definitions
-            @options ||= (superclass <= Options) ? superclass.options.dup : {}
+            @options ||= if superclass <= Options
+              superclass.options.dup
+            else
+              {}
+            end
           end
 
           protected
 
-          def option(name, meta = {}, &block)
-            settings_name = defined?(@settings_name) && @settings_name
-            option_name = settings_name ? "#{settings_name}.#{name}" : name
-            builder = OptionDefinition::Builder.new(option_name, meta, &block)
+          def option(name, attributes = {}, &block)
+            builder = OptionDefinition::Builder.new(name, attributes, &block)
             options[name] = builder.to_definition.tap do
               # Resolve and define helper functions
               helpers = default_helpers(name)
@@ -75,7 +105,11 @@ module Datadog
           end
 
           def set_option(name, value, precedence: Configuration::Option::Precedence::PROGRAMMATIC)
-            resolve_option(name).set(value, precedence: precedence)
+            option = resolve_option(name)
+            # Populate lower-precedence values so telemetry and `unset` can
+            # still observe the fallback chain after a first programmatic set.
+            option.get
+            option.set(value, precedence: precedence)
           end
 
           def unset_option(name, precedence: Configuration::Option::Precedence::PROGRAMMATIC)

data/lib/datadog/core/configuration/settings.rb

@@ -221,6 +221,8 @@ module Datadog
           #
           # @return Logger::Severity
           option :instance do |o|
+            # Telemetry for this option is manually modified and added in the AppStarted event.
+            o.skip_telemetry true
             o.after_set { |value| set_option(:level, value.level) unless value.nil? }
           end
 
@@ -912,6 +914,19 @@ module Datadog
             o.default 60.0
           end
 
+          # The interval in seconds when extended heartbeat must be sent.
+          #
+          # This method is used internally, for testing purposes only.
+          #
+          # @default `DD_TELEMETRY_EXTENDED_HEARTBEAT_INTERVAL` environment variable, otherwise `86400`.
+          # @return [Integer]
+          # @!visibility private
+          option :extended_heartbeat_interval_seconds do |o|
+            o.type :int
+            o.env Core::Telemetry::Ext::ENV_EXTENDED_HEARTBEAT_INTERVAL
+            o.default 86400
+          end
+
           # The interval in seconds when telemetry metrics are aggregated.
           # Should be a denominator of `heartbeat_interval_seconds`.
           #

data/lib/datadog/core/configuration/supported_configurations.rb

@@ -107,6 +107,7 @@ module Datadog
           "DD_TAGS",
           "DD_TELEMETRY_AGENTLESS_URL",
           "DD_TELEMETRY_DEPENDENCY_COLLECTION_ENABLED",
+          "DD_TELEMETRY_EXTENDED_HEARTBEAT_INTERVAL",
           "DD_TELEMETRY_HEARTBEAT_INTERVAL",
           "DD_TELEMETRY_LOG_COLLECTION_ENABLED",
           "DD_TELEMETRY_METRICS_AGGREGATION_INTERVAL",

data/lib/datadog/core/contrib/rails/railtie.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require_relative 'utils'
+require_relative '../../environment/process'
+require_relative '../../process_discovery'
+
+module Datadog
+  module Core
+    module Contrib
+      module Rails
+        # Railtie for core Rails setup that benefits all Datadog products.
+        class Railtie < ::Rails::Railtie
+          def self.after_initialize
+            if Datadog.configuration.experimental_propagate_process_tags_enabled
+              Datadog::Core::Environment::Process.rails_application_name =
+                Datadog::Core::Contrib::Rails::Utils.app_name
+            end
+
+            # Process Discovery should always publish after_initialize since it has access to more information
+            Datadog::Core::ProcessDiscovery.publish(Datadog.configuration)
+          end
+
+          # Registered after the method definition so the method exists if on_load fires immediately
+          # (which happens when the Railtie is loaded into an already-initialized Rails app).
+          ::ActiveSupport.on_load(:after_initialize) do
+            Datadog::Core::Contrib::Rails::Railtie.after_initialize
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/core/contrib/rails/utils.rb

@@ -7,11 +7,15 @@ module Datadog
         # common utilities for Rails
         module Utils
           def self.app_name
-            if ::Rails::VERSION::MAJOR >= 6
-              ::Rails.application.class.module_parent_name.underscore
+            application_name = if ::Rails::VERSION::MAJOR >= 6
+              ::Rails.application.class.module_parent_name
             else
-              ::Rails.application.class.parent_name.underscore
+              ::Rails.application.class.parent_name
             end
+            application_name&.underscore
+          rescue => e
+            Datadog.logger.debug("Failed to extract Rails application name: #{e.class}: #{e}")
+            nil
           end
 
           def self.railtie_supported?

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

@@ -55,7 +55,7 @@ module Datadog
             # Unhandled exception report triggering means that the application is already in a bad state
             # We don't want to swallow non-StandardError exceptions here; we would rather just let the
             # application crash
-            Datadog.logger.debug("Crashtracker failed to report unhandled exception: #{e.message}")
+            Datadog.logger.debug { "Crashtracker failed to report unhandled exception: #{e.class}: #{e}" }
           end
         end
 
@@ -130,7 +130,7 @@ module Datadog
           self.class._native_stop
           logger.debug('Crash tracking stopped successfully')
         rescue => e
-          logger.error("Failed to stop crash tracking: #{e.message}")
+          logger.error("Failed to stop crash tracking: #{e.class}: #{e}")
         end
 
         private
@@ -149,7 +149,7 @@ module Datadog
           )
           logger.debug("Crash tracking action: #{action} successful")
         rescue => e
-          logger.error("Failed to #{action} crash tracking: #{e.message}")
+          logger.error("Failed to #{action} crash tracking: #{e.class}: #{e}")
         end
       end
     end

data/lib/datadog/core/environment/container.rb

@@ -108,7 +108,7 @@ module Datadog
             end
           rescue => e
             Datadog.logger.debug(
-              "Error while checking cgroup namespace. Cause: #{e.class.name} #{e.message} Location: #{Array(e.backtrace).first}"
+              "Error while checking cgroup namespace. Cause: #{e.class}: #{e} Location: #{Array(e.backtrace).first}"
             )
             false
           end
@@ -172,7 +172,7 @@ module Datadog
           @entry = Entry.new # Empty entry if no valid cgroup entry is found
         rescue => e
           Datadog.logger.debug(
-            "Error while reading container entry. Cause: #{e.class.name} #{e.message} Location: #{Array(e.backtrace).first}"
+            "Error while reading container entry. Cause: #{e.class}: #{e} Location: #{Array(e.backtrace).first}"
           )
           @entry = Entry.new unless defined?(@entry)
           @entry

data/lib/datadog/core/environment/ext.rb

@@ -41,6 +41,7 @@ module Datadog
         TAG_ENTRYPOINT_NAME = "entrypoint.name"
         TAG_ENTRYPOINT_WORKDIR = "entrypoint.workdir"
         TAG_ENTRYPOINT_TYPE = "entrypoint.type"
+        TAG_RAILS_APPLICATION = "rails.application"
         TAG_PROCESS_TAGS = "_dd.tags.process"
         TAG_SERVICE = 'service'
         TAG_VERSION = 'version'

data/lib/datadog/core/environment/identity.rb

@@ -2,6 +2,7 @@
 
 require 'securerandom'
 
+require_relative '../configuration/config_helper'
 require_relative 'ext'
 require_relative '../utils/forking'
 
@@ -13,18 +14,39 @@ module Datadog
       module Identity
         extend Core::Utils::Forking
 
+        ENV_ROOT_SESSION_ID = '_DD_ROOT_RB_SESSION_ID'
+        ENV_PARENT_SESSION_ID = '_DD_PARENT_RB_SESSION_ID'
+
         module_function
 
-        # Retrieves number of classes from runtime
+        @root_runtime_id = DATADOG_ENV[ENV_ROOT_SESSION_ID]&.freeze
+        @parent_runtime_id = DATADOG_ENV[ENV_PARENT_SESSION_ID]&.freeze
+
         def id
           @id ||= ::SecureRandom.uuid.freeze
 
-          # Check if runtime has changed, e.g. forked.
-          after_fork! { @id = ::SecureRandom.uuid.freeze }
+          after_fork! do
+            # Order matters: capture @id before overwriting
+            @parent_runtime_id = @id
+            @root_runtime_id ||= @id
+            @id = ::SecureRandom.uuid.freeze
+          end
 
           @id
         end
 
+        def root_runtime_id
+          @root_runtime_id
+        end
+
+        def parent_runtime_id
+          @parent_runtime_id
+        end
+
+        def runtime_propagation_envs
+          {ENV_ROOT_SESSION_ID => root_runtime_id || id, ENV_PARENT_SESSION_ID => id}.freeze
+        end
+
         def pid
           ::Process.pid
         end

data/lib/datadog/core/environment/process.rb

@@ -35,6 +35,9 @@ module Datadog
 
           tags << "#{Environment::Ext::TAG_ENTRYPOINT_TYPE}:#{TagNormalizer.normalize(entrypoint_type, remove_digit_start_char: false)}"
 
+          rails_application_name = TagNormalizer.normalize_process_value(@rails_application_name.to_s)
+          tags << "#{Environment::Ext::TAG_RAILS_APPLICATION}:#{rails_application_name}" unless rails_application_name.empty?
+
           @tags = tags.freeze
         end
 
@@ -80,6 +83,15 @@ module Datadog
           File.basename(File.expand_path(File.dirname($0)))
         end
 
+        # Sets the rails application name from other places in code
+        # @param name [String] the rails application name
+        # @return [void]
+        def self.rails_application_name=(name)
+          @rails_application_name = name
+          remove_instance_variable(:@tags) if instance_variable_defined?(:@tags)
+          remove_instance_variable(:@serialized) if instance_variable_defined?(:@serialized)
+        end
+
         private_class_method :entrypoint_workdir, :entrypoint_type, :entrypoint_name, :entrypoint_basedir
       end
     end

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

@@ -101,7 +101,7 @@ module Datadog
           statsd.count(stat, value, metric_options(options))
         rescue => e
           logger.error(
-            "Failed to send count stat. Cause: #{e.class.name} #{e.message} Source: #{Array(e.backtrace).first}"
+            "Failed to send count stat. Cause: #{e.class}: #{e} Source: #{Array(e.backtrace).first}"
           )
           telemetry.report(e, description: 'Failed to send count stat')
         end
@@ -115,7 +115,7 @@ module Datadog
           statsd.distribution(stat, value, metric_options(options))
         rescue => e
           logger.error(
-            "Failed to send distribution stat. Cause: #{e.class.name} #{e.message} Source: #{Array(e.backtrace).first}"
+            "Failed to send distribution stat. Cause: #{e.class}: #{e} Source: #{Array(e.backtrace).first}"
           )
           telemetry.report(e, description: 'Failed to send distribution stat')
         end
@@ -128,7 +128,7 @@ module Datadog
           statsd.increment(stat, metric_options(options))
         rescue => e
           logger.error(
-            "Failed to send increment stat. Cause: #{e.class.name} #{e.message} Source: #{Array(e.backtrace).first}"
+            "Failed to send increment stat. Cause: #{e.class}: #{e} Source: #{Array(e.backtrace).first}"
           )
           telemetry.report(e, description: 'Failed to send increment stat')
         end
@@ -142,7 +142,7 @@ module Datadog
           statsd.gauge(stat, value, metric_options(options))
         rescue => e
           logger.error(
-            "Failed to send gauge stat. Cause: #{e.class.name} #{e.message} Source: #{Array(e.backtrace).first}"
+            "Failed to send gauge stat. Cause: #{e.class}: #{e} Source: #{Array(e.backtrace).first}"
           )
           telemetry.report(e, description: 'Failed to send gauge stat')
         end
@@ -162,7 +162,7 @@ module Datadog
           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}"
+              "Failed to send time stat. Cause: #{e.class}: #{e} Source: #{Array(e.backtrace).first}"
             )
             telemetry.report(e, description: 'Failed to send time stat')
           end

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

@@ -45,7 +45,7 @@ module Datadog
             rescue Client::SyncError => e
               # Transient errors due to network or agent. Logged the error but not via telemetry
               logger.error do
-                "remote worker client sync error: #{e.message} location: #{Array(e.backtrace).first}. skipping sync"
+                "remote worker client sync error: #{e.class}: #{e} location: #{Array(e.backtrace).first}. skipping sync"
               end
             rescue => e
               # In case of unexpected errors, reset the negotiation object
@@ -55,7 +55,7 @@ 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}. " \
+                "remote worker error: #{e.class}: #{e} location: #{Array(e.backtrace).first}. " \
                 'resetting client state'
               end
 
@@ -105,6 +105,7 @@ module Datadog
         class Barrier
           def initialize(timeout = nil)
             @once = false
+            @waited = false
             @timeout = timeout
 
             @mutex = Mutex.new
@@ -112,37 +113,53 @@ 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
+            # 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
 
-              return :pass if @once
-
-              timeout ||= @timeout
+            @mutex.synchronize do
+              return :pass if @waited
 
-              # - 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)
+              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 RUBY_VERSION >= '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
 

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

@@ -100,7 +100,7 @@ module Datadog
         def try_flush
           yield
         rescue => e
-          Datadog.logger.warn("Error while sending runtime metric. Cause: #{e.class.name} #{e.message}")
+          Datadog.logger.warn("Error while sending runtime metric. Cause: #{e.class}: #{e}")
         end
 
         def default_metric_options

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

@@ -99,6 +99,7 @@ module Datadog
           @worker = Telemetry::Worker.new(
             enabled: @enabled,
             heartbeat_interval_seconds: settings.telemetry.heartbeat_interval_seconds,
+            extended_heartbeat_interval_seconds: settings.telemetry.extended_heartbeat_interval_seconds,
             metrics_aggregation_interval_seconds: settings.telemetry.metrics_aggregation_interval_seconds,
             emitter: Emitter.new(
               @transport,
@@ -108,6 +109,8 @@ module Datadog
             metrics_manager: @metrics_manager,
             dependency_collection: settings.telemetry.dependency_collection,
             logger: logger,
+            settings: settings,
+            agent_settings: agent_settings,
             shutdown_timeout: settings.telemetry.shutdown_timeout_seconds,
           )
 

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

@@ -26,14 +26,13 @@ module Datadog
 
           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,
+                seq_id: Configuration::Option::Precedence::REMOTE_CONFIGURATION.numeric.next,
               }
             end
 
@@ -43,7 +42,7 @@ module Datadog
                 name: 'appsec.sca_enabled',
                 value: config.appsec.sca_enabled,
                 origin: 'code',
-                seq_id: seq_id,
+                seq_id: Configuration::Option::Precedence::PROGRAMMATIC.numeric.next,
               }
             end
 

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

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require_relative 'app_started'
+
+module Datadog
+  module Core
+    module Telemetry
+      module Event
+        # Telemetry class for the 'app-extended-heartbeat' event
+        class AppExtendedHeartbeat < AppStarted
+          def initialize(settings:, agent_settings:)
+            @configuration = configuration(settings, agent_settings)
+          end
+
+          def type
+            'app-extended-heartbeat'
+          end
+
+          def payload
+            {
+              configuration: @configuration,
+            }
+          end
+
+          def app_started?
+            false
+          end
+        end
+      end
+    end
+  end
+end