datadog 2.21.0 → 2.38.0

data/lib/datadog/core/configuration.rb

@@ -238,7 +238,7 @@ module Datadog
           yield write_components
         rescue ThreadError => e
           logger_without_components.error(
-            'Detected deadlock during datadog initialization. ' \
+            "Detected deadlock during datadog initialization: #{e.class}: #{e.message}. " \
             'Please report this at https://github.com/datadog/dd-trace-rb/blob/master/CONTRIBUTING.md#found-a-bug' \
             "\n\tSource:\n\t#{Array(e.backtrace).join("\n\t")}"
           )
@@ -284,7 +284,7 @@ module Datadog
         # This enables logging during initialization, otherwise we'd run into deadlocks.
 
         @temp_logger ||= begin
-          logger = configuration.logger.instance || Core::Logger.new($stdout)
+          logger = configuration.logger.instance || Core::Logger.new($stderr)
           logger.level = configuration.diagnostics.debug ? ::Logger::DEBUG : configuration.logger.level
           logger
         end
@@ -298,7 +298,7 @@ module Datadog
           debug_env_value = DATADOG_ENV[Ext::Diagnostics::ENV_DEBUG_ENABLED]&.strip&.downcase
           debug_value = debug_env_value == 'true' || debug_env_value == '1'
 
-          logger = Core::Logger.new($stdout)
+          logger = Core::Logger.new($stderr)
           # We cannot access config and the default level is INFO, so we need to set the level manually
           logger.level = debug_value ? ::Logger::DEBUG : ::Logger::INFO
           logger

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.message}")
+            nil
           end
 
           def self.railtie_supported?

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

@@ -3,8 +3,6 @@
 require 'libdatadog'
 
 require_relative 'tag_builder'
-require_relative '../utils/only_once'
-require_relative '../utils/at_fork_monkey_patch'
 
 module Datadog
   module Core
@@ -18,10 +16,8 @@ module Datadog
       #
       # Methods prefixed with _native_ are implemented in `crashtracker.c`
       class Component
-        ONLY_ONCE = Core::Utils::OnlyOnce.new
-
         def self.build(settings, agent_settings, logger:)
-          tags = TagBuilder.call(settings)
+          tags = latest_tags(settings)
           agent_base_url = agent_settings.url
 
           ld_library_path = ::Libdatadog.ld_library_path
@@ -45,6 +41,32 @@ module Datadog
           ).tap(&:start)
         end
 
+        # Reports unhandled exceptions to the crash tracker if available and appropriate.
+        # This is called from the at_exit hook to report unhandled exceptions.
+        def self.report_unhandled_exception(exception)
+          return unless exception && !exception.is_a?(SystemExit) && !exception.is_a?(NoMemoryError)
+
+          begin
+            crashtracker = Datadog.send(:components, allow_initialization: false)&.crashtracker
+            return unless crashtracker
+
+            crashtracker.report_unhandled_exception(exception)
+          rescue => e
+            # 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.class}: #{e.message}" }
+          end
+        end
+
+        # Gets the latest tags from the current configuration.
+        #
+        # We always fetch fresh tags because:
+        # After forking, we need the latest tags, not the parent's tags, such as the pid or runtime-id
+        def self.latest_tags(settings)
+          TagBuilder.call(settings)
+        end
+
         def initialize(tags:, agent_base_url:, ld_library_path:, path_to_crashtracking_receiver_binary:, logger:)
           @tags = tags
           @agent_base_url = agent_base_url
@@ -54,31 +76,61 @@ module Datadog
         end
 
         def start
-          Utils::AtForkMonkeyPatch.apply!
-
           start_or_update_on_fork(action: :start, tags: tags)
-
-          ONLY_ONCE.run do
-            Utils::AtForkMonkeyPatch.at_fork(:child) do
-              # Must NOT reference `self` here, as only the first instance will
-              # be captured by the ONLY_ONCE and we want to pick the latest active one
-              # (which may have different tags or agent config)
-              Datadog.send(:components, allow_initialization: false)&.crashtracker&.update_on_fork
-            end
-          end
         end
 
         def update_on_fork(settings: Datadog.configuration)
-          # Here we pick up the latest settings, so that we pick up any tags that change after forking
-          # such as the pid or runtime-id
-          start_or_update_on_fork(action: :update_on_fork, tags: TagBuilder.call(settings))
+          start_or_update_on_fork(action: :update_on_fork, tags: self.class.latest_tags(settings))
+        end
+
+        def report_unhandled_exception(exception)
+          # Maximum number of stack frames to include in exception crash reports
+          # This is the same number used for signal-based crashtracking's runtime stack
+          max_exception_stack_frames = 512
+
+          # extract all frame data upfront; c expects exactly 3 elements, proper types, no nils
+          # limit to max_exception_stack_frames frames
+          all_backtrace_locations = exception.backtrace_locations || []
+          was_truncated = all_backtrace_locations.length > max_exception_stack_frames
+
+          backtrace_slice = all_backtrace_locations[0...max_exception_stack_frames] || []
+          # @type var frames_data: Array[[String, String, Integer]]
+          frames_data = backtrace_slice.map do |loc|
+            file = loc.path
+            file = '<unknown>' if file.nil? || file.empty? || !file.is_a?(String)
+
+            function = loc.label
+            function = '<unknown>' if function.nil? || function.empty? || !function.is_a?(String)
+
+            line = loc.lineno
+            line = 0 if line.nil? || line < 0 || !line.is_a?(Integer)
+
+            [file, function, line]
+          end
+
+          # Add truncation indicator frame if we had to cut off frames
+          if was_truncated
+            truncated_count = all_backtrace_locations.length - max_exception_stack_frames
+            frames_data << ['<truncated>', "<truncated #{truncated_count} more frames>", 0]
+          end
+
+          exception_message = exception.message
+          exception_type = exception.class.to_s
+
+          success = self.class._native_report_ruby_exception(
+            exception_type,
+            exception_message,
+            frames_data,
+          )
+
+          logger.debug('Crashtracker failed to report unhandled exception to crash tracker') unless success
         end
 
         def stop
           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.message}")
         end
 
         private
@@ -97,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.message}")
         end
       end
     end

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

@@ -2,6 +2,7 @@
 
 require_relative '../tag_builder'
 require_relative '../utils'
+require_relative '../environment/process'
 
 module Datadog
   module Core
@@ -13,6 +14,11 @@ module Datadog
             'is_crash' => 'true',
           )
 
+          if settings.experimental_propagate_process_tags_enabled
+            process_tags = Environment::Process.serialized
+            hash['process_tags'] = process_tags unless process_tags.empty?
+          end
+
           Utils.encode_tags(hash)
         end
       end

data/lib/datadog/core/ddsketch.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Datadog
+  module Core
+    # Used to access ddsketch APIs.
+    # APIs in this class are implemented as native code.
+    class DDSketch
+      def self.supported?
+        Datadog::Core::LIBDATADOG_API_FAILURE.nil?
+      end
+
+      def initialize
+        unless self.class.supported?
+          raise(ArgumentError, "DDSketch is not supported: #{Datadog::Core::LIBDATADOG_API_FAILURE}")
+        end
+      end
+    end
+  end
+end

data/lib/datadog/core/diagnostics/environment_logger.rb

@@ -52,7 +52,9 @@ module Datadog
             log_configuration!('CORE', data.to_json)
           end
         rescue => e
-          logger.warn("Failed to collect core environment information: #{e} Location: #{Array(e.backtrace).first}")
+          logger.warn(
+            "Failed to collect core environment information: #{e.class}: #{e.message} Location: #{Array(e.backtrace).first}"
+          )
         end
       end
 

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

@@ -1,5 +1,8 @@
 # frozen_string_literal: true
 
+require_relative '../utils/fnv'
+require_relative 'process'
+
 module Datadog
   module Core
     module Environment
@@ -59,19 +62,80 @@ module Datadog
           @client = Remote::Transport::HTTP.root(agent_settings: agent_settings, logger: logger)
         end
 
-        # Fetches the information from the agent.
+        # Fetches the information from the Trace Agent.
         # @return [Datadog::Core::Remote::Transport::HTTP::Negotiation::Response] the response from the agent
         # @return [nil] if an error occurred while fetching the information
         def fetch
           res = @client.send_info
           return unless res.ok?
 
+          update_propagation_checksum(res)
+
           res
         end
 
         def ==(other)
           other.is_a?(self.class) && other.agent_settings == agent_settings
         end
+
+        # Returns the propagation checksum, comprising of process tags and optionally container tags (from the Trace Agent)
+        # Currently called/used by the DBM code to inject the propagation checksum into the SQL comment.
+        #
+        # This checksum is used for correlation across signals (traces, DBM, data streams, etc.) in environments
+        #
+        # The checksum is populated by the trace transport's periodic fetch calls.
+        # @return [Integer, nil] the FNV hash based on the container and process tags or nil
+        attr_reader :propagation_checksum
+
+        private
+
+        # Trace Agent 7.69.0+ provides a SHA256 checksum in the response header DATADOG-CONTAINER-TAGS-HASH based on the container id computed in Datadog::Core::Environment::Container
+        # This is a short checksum that uniquely identifies this process, its container environment, and
+        # the Datadog agent it connects to.
+        #
+        # This checksum only has to be internally consistent: the same value must be used by every signal
+        # emitted by this process+container+agent combinations). It is not required that this checksum is
+        # consistent with other SDKs.
+        # During calls to the Trace Agent, this checksum is cached but invalidated if a new value is returned
+        # The resulting propagation_checksum uses the container_tags_checksum
+        # https://github.com/DataDog/datadog-agent/pull/38515
+        attr_reader :container_tags_checksum
+
+        # Setting DD_EXPERIMENTAL_PROPAGATE_PROCESS_TAGS_ENABLED to true enables the following behavior:
+        #  - Computes a propagation checksum from process tags and optionally container tags when tags change
+        #  - This is needed in traces (dsm and dbm related spans), DBM, and DSM.
+        #
+        # Container tags extraction:
+        # Datadog::Core::Environment::Container extracts the container id from the cgroup folder if possible
+        # (note: not currently available in cgroupv2) and sends it to the Trace Agent via the header Datadog-Container-ID.
+        # The Trace Agent takes the container id and looks for matching container tags to compute a SHA256 checksum via the response header DATADOG-CONTAINER-TAGS-HASH
+        # https://github.com/DataDog/datadog-agent/blob/c923da011c8e51c35c0d05b6b10d016521915e7d/pkg/trace/api/info.go#L203-L227
+        #
+        # When deciding whether the propagation checksum should be updated, we need to be aware of some concerns:
+        #     - The tracer fails to send the container id in the first place
+        #     - It is possible that older Trace Agents may not have this specific header
+        #     - It is possible that we don't have access to the value if the Trace Agent is temporarily down. In these cases, we need to check for the value again on the next call to the info endpoint
+        #     - If we have access to the value, we need to check if it changed from the previous value.
+        #     - The Trace Agent runs into a permissions/setup issue.
+        def update_propagation_checksum(res)
+          return unless Datadog.configuration.experimental_propagate_process_tags_enabled
+
+          header_value = res.headers[Core::Transport::Ext::HTTP::HEADER_CONTAINER_TAGS_HASH]
+          new_container_tags_checksum = header_value if header_value && !header_value.empty?
+
+          # if the Trace Agent returns a new value for the checksum, calculate and cache the propagation checksum
+          # If there was no previous propagation_checksum, then we should calculate the checksum by checking the agent and getting process info
+          if @propagation_checksum.nil? || (new_container_tags_checksum && new_container_tags_checksum != @container_tags_checksum)
+            @container_tags_checksum = new_container_tags_checksum
+
+            checksum_input = Process.serialized
+            # Use local variable for Steep type narrowing (helps Steep with type narrowing)
+            container_checksum = @container_tags_checksum
+            checksum_input += container_checksum if container_checksum
+
+            @propagation_checksum = Core::Utils::FNV.fnv1_64(checksum_input)
+          end
+        end
       end
     end
   end

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

@@ -10,40 +10,67 @@ module Datadog
       # about the current Linux container identity.
       # @see https://man7.org/linux/man-pages/man7/cgroups.7.html
       module Cgroup
-        LINE_REGEX = /^(\d+):([^:]*):(.+)$/.freeze
-
-        Descriptor = Struct.new(
-          :id,
-          :groups,
+        # A parsed cgroup entry from /proc/<pid>/cgroup
+        Entry = Struct.new(
+          :hierarchy,
+          :controllers,
           :path,
-          :controllers
+          :inode
         )
 
         module_function
 
-        def descriptors(process = 'self')
-          [].tap do |descriptors|
-            filepath = "/proc/#{process}/cgroup"
-
-            if File.exist?(filepath)
-              File.foreach("/proc/#{process}/cgroup") do |line|
-                line = line.strip
-                descriptors << parse(line) unless line.empty?
-              end
-            end
-          rescue => e
-            Datadog.logger.error(
-              "Error while parsing cgroup. Cause: #{e.class.name} #{e.message} Location: #{Array(e.backtrace).first}"
-            )
+        # Parses the /proc/self/cgroup file,
+        # @return [Array<Entry>] one entry for each valid cgroup line
+        def entries
+          filepath = '/proc/self/cgroup'
+          return [] unless File.exist?(filepath)
+
+          ret = []
+          File.foreach(filepath) do |entry_line|
+            ret << parse(entry_line) unless entry_line.empty?
           end
+          ret
         end
 
-        def parse(line)
-          id, groups, path = line.scan(LINE_REGEX).first
+        # Parses a single cgroup entry from /proc/<pid>/cgroup.
+        #
+        # Files can have cgroup v1 and v2 entries mixed. Their format is the same.
+        #
+        # Each entry has 3 colon-separated fields:
+        #   hierarchy-ID:controllers:path
+        # Examples:
+        #   10:memory:/docker/1234567890abcdef (cgroup v1)
+        #   0::/docker/1234567890abcdef (cgroup v2)
+        #
+        # @see https://man7.org/linux/man-pages/man7/cgroups.7.html#:~:text=%2Fproc%2Fpid%2Fcgroup
+        # @return [Entry]
+        def parse(entry_line)
+          hierarchy, controllers, path = entry_line.split(':', 3)
 
-          Descriptor.new(id, groups, path).tap do |descriptor|
-            descriptor.controllers = groups.split(',') unless groups.nil?
-          end
+          Entry.new(
+            hierarchy,
+            controllers,
+            path,
+            inode_for(controllers, path)
+          )
+        end
+
+        # We can find the container inode by running a file stat on the cgroup filesystem path.
+        # Example:
+        #   For the entry `0:cpu:/docker/abc123`,
+        #   we read `stat -c '%i' /sys/fs/cgroup/cpu/docker/abc123`
+        def inode_for(controllers, path)
+          return if controllers.nil? || path.nil?
+
+          # In cgroup v1, when multiple controllers are co-mounted, the controllers
+          # becomes part of the directory name (with commas preserved).
+          # Example entry:
+          #   For the line "10:cpu,cpuacct:/docker/abc123", the path is
+          #   "/sys/fs/cgroup/cpu,cpuacct/docker/abc123"
+          inode_path = File.join('/sys/fs/cgroup', controllers, path)
+
+          File.stat(inode_path).ino if File.exist?(inode_path)
         end
       end
     end