datadog 2.8.0 → 2.39.0

data/lib/datadog/profiling/ext/dir_monkey_patches.rb

@@ -4,9 +4,10 @@ module Datadog
   module Profiling
     # Monkey patches needed for profiler features and compatibility
     module Ext
-      # All Ruby versions as of this writing have bugs in the dir class implementation, causing issues such as
+      # Ruby versions before 3.4 have bugs in the `Dir` class implementation, causing issues such as
       # https://github.com/DataDog/dd-trace-rb/issues/3450 .
-      # See also https://bugs.ruby-lang.org/issues/20586 for more details.
+      # This was fixed upstream in https://bugs.ruby-lang.org/issues/20586 but we use this monkey patch to work around
+      # the issue on legacy versions (it gets applied by `Datadog::Profiling::Component`).
       #
       # This monkey patch for the Ruby `Dir` class works around these bugs for affected Ruby versions by temporarily
       # blocking the profiler from interrupting system calls.
@@ -27,9 +28,13 @@ module Datadog
         end
       end
 
-      if RUBY_VERSION.start_with?("2.")
+      if RubyVersion.is?("< 3")
         # Monkey patches for Dir.singleton_class (Ruby 2 version). See DirMonkeyPatches above for more details.
         module DirClassMonkeyPatches
+          # Steep: Workaround that defines args and block only for Ruby 2.x.
+          # @type var args: ::Array[any]
+          # @type var block: ^(?) -> any | nil
+
           def [](*args, &block)
             Datadog::Profiling::Collectors::CpuAndWallTimeWorker._native_hold_signals
             super
@@ -148,6 +153,11 @@ module Datadog
       else
         # Monkey patches for Dir.singleton_class (Ruby 3 version). See DirMonkeyPatches above for more details.
         module DirClassMonkeyPatches
+          # Steep: Workaround that defines args, kwargs and block only for Ruby 3.x.
+          # @type var args: ::Array[any]
+          # @type var kwargs: ::Hash[::Symbol, any]
+          # @type var block: ^(?) -> any | nil
+
           def [](*args, **kwargs, &block)
             Datadog::Profiling::Collectors::CpuAndWallTimeWorker._native_hold_signals
             super
@@ -260,9 +270,13 @@ module Datadog
         end
       end
 
-      if RUBY_VERSION.start_with?("2.")
+      if RubyVersion.is?("< 3")
         # Monkey patches for Dir (Ruby 2 version). See DirMonkeyPatches above for more details.
         module DirInstanceMonkeyPatches
+          # Steep: Workaround that defines args and block only for Ruby 2.x.
+          # @type var args: ::Array[any]
+          # @type var block: ^(?) -> any | nil
+
           # See note on methods that yield above.
           def each(*args, &block)
             if block
@@ -286,7 +300,7 @@ module Datadog
             end
           end
 
-          unless RUBY_VERSION.start_with?("2.5.") # This is Ruby 2.6+
+          if RubyVersion.is?(">= 2.6.0") # This method is Ruby 2.6+
             # See note on methods that yield above.
             def each_child(*args, &block)
               if block
@@ -336,6 +350,11 @@ module Datadog
       else
         # Monkey patches for Dir (Ruby 3 version). See DirMonkeyPatches above for more details.
         module DirInstanceMonkeyPatches
+          # Steep: Workaround that defines args, kwargs and block only for Ruby 3.x.
+          # @type var args: ::Array[any]
+          # @type var kwargs: ::Hash[::Symbol, any]
+          # @type var block: ^(?) -> any | nil
+
           # See note on methods that yield above.
           def each(*args, **kwargs, &block)
             if block

data/lib/datadog/profiling/ext/exec_monkey_patch.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Datadog
+  module Profiling
+    module Ext
+      # The profiler gathers data by sending `SIGPROF` unix signals to Ruby application threads.
+      #
+      # When using `Kernel#exec` on Linux, it can happen that a signal sent before calling `exec` arrives after
+      # the new process is running, causing it to fail with the `Profiling timer expired` error message.
+      # To avoid this, the profiler installs a monkey patch on `Kernel#exec` to stop profiling before actually
+      # calling `exec`.
+      # This monkey patch is available for Ruby 2.7+; let us know if you need it on earlier Rubies.
+      # For more details see https://github.com/DataDog/dd-trace-rb/issues/5101 .
+      module ExecMonkeyPatch
+        def self.apply!
+          ::Object.prepend(ObjectMonkeyPatch)
+
+          true
+        end
+
+        module ObjectMonkeyPatch
+          private
+
+          def exec(...)
+            Datadog.send(:components, allow_initialization: false)&.profiler&.shutdown!(report_last_profile: false)
+            super
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/profiling/ext.rb

@@ -6,28 +6,13 @@ module Datadog
       ENV_ENABLED = "DD_PROFILING_ENABLED"
       ENV_UPLOAD_TIMEOUT = "DD_PROFILING_UPLOAD_TIMEOUT"
       ENV_MAX_FRAMES = "DD_PROFILING_MAX_FRAMES"
-      ENV_AGENTLESS = "DD_PROFILING_AGENTLESS"
       ENV_ENDPOINT_COLLECTION_ENABLED = "DD_PROFILING_ENDPOINT_COLLECTION_ENABLED"
 
+      # WARNING: This should not be used, only for internal testing
+      ENV_AGENTLESS = "DD_PROFILING_AGENTLESS" # rubocop:disable CustomCops/EnvStringValidationCop
       module Transport
         module HTTP
-          FORM_FIELD_TAG_ENV = "env"
-          FORM_FIELD_TAG_HOST = "host"
-          FORM_FIELD_TAG_LANGUAGE = "language"
-          FORM_FIELD_TAG_PID = "process_id"
           FORM_FIELD_TAG_PROFILER_VERSION = "profiler_version"
-          FORM_FIELD_TAG_RUNTIME = "runtime"
-          FORM_FIELD_TAG_RUNTIME_ENGINE = "runtime_engine"
-          FORM_FIELD_TAG_RUNTIME_ID = "runtime-id"
-          FORM_FIELD_TAG_RUNTIME_PLATFORM = "runtime_platform"
-          FORM_FIELD_TAG_RUNTIME_VERSION = "runtime_version"
-          FORM_FIELD_TAG_SERVICE = "service"
-          FORM_FIELD_TAG_VERSION = "version"
-          TAG_GIT_REPOSITORY_URL = "git.repository_url"
-          TAG_GIT_COMMIT_SHA = "git.commit.sha"
-
-          PPROF_DEFAULT_FILENAME = "rubyprofile.pprof"
-          CODE_PROVENANCE_FILENAME = "code-provenance.json"
         end
       end
     end

data/lib/datadog/profiling/flush.rb

@@ -6,36 +6,45 @@ module Datadog
   module Profiling
     # Entity class used to represent metadata for a given profile
     class Flush
-      attr_reader \
-        :start,
-        :finish,
-        :pprof_file_name,
-        :pprof_data, # gzipped pprof bytes
-        :code_provenance_file_name,
-        :code_provenance_data, # gzipped json bytes
-        :tags_as_array,
-        :internal_metadata_json,
-        :info_json
+      attr_reader :start #: ::Time
+      attr_reader :finish #: ::Time
+      attr_reader :encoded_profile #: Datadog::Profiling::EncodedProfile
+      attr_reader :code_provenance_data #: ::String?
+      attr_reader :metrics #: ::String
+      attr_reader :tags_as_array #: Array[[::String, ::String]]
+      attr_reader :process_tags #: ::String
+      attr_reader :internal_metadata_json #: ::String
+      attr_reader :info_json #: ::String
 
+      # @rbs start: ::Time
+      # @rbs finish: ::Time
+      # @rbs encoded_profile: Datadog::Profiling::EncodedProfile
+      # @rbs code_provenance_data: ::String?
+      # @rbs metrics: Array[[::String, ::Numeric]]
+      # @rbs tags_as_array: Array[[::String, ::String]]
+      # @rbs process_tags: ::String
+      # @rbs internal_metadata: ::Hash[::Symbol, ::String | bool | ::Numeric]
+      # @rbs info_json: ::String
+      # @rbs return: void
       def initialize(
         start:,
         finish:,
-        pprof_file_name:,
-        pprof_data:,
-        code_provenance_file_name:,
+        encoded_profile:,
         code_provenance_data:,
+        metrics:,
         tags_as_array:,
+        process_tags:,
         internal_metadata:,
         info_json:
       )
         @start = start
         @finish = finish
-        @pprof_file_name = pprof_file_name
-        @pprof_data = pprof_data
-        @code_provenance_file_name = code_provenance_file_name
+        @encoded_profile = encoded_profile
         @code_provenance_data = code_provenance_data
+        @metrics = JSON.generate(metrics)
         @tags_as_array = tags_as_array
-        @internal_metadata_json = JSON.fast_generate(internal_metadata)
+        @process_tags = process_tags
+        @internal_metadata_json = JSON.generate(internal_metadata)
         @info_json = info_json
       end
     end

data/lib/datadog/profiling/http_transport.rb

@@ -8,48 +8,39 @@ module Datadog
     # Used to report profiling data to Datadog.
     # Methods prefixed with _native_ are implemented in `http_transport.c`
     class HttpTransport
-      attr_reader :exporter_configuration
-
-      def initialize(agent_settings:, site:, api_key:, upload_timeout_seconds:)
-        @upload_timeout_milliseconds = (upload_timeout_seconds * 1_000).to_i
-
-        validate_agent_settings(agent_settings)
-
-        @exporter_configuration =
+      # @rbs @exporter_configuration: exporter_configuration_array
+
+      attr_reader :exporter_configuration #: exporter_configuration_array
+
+      # @rbs agent_settings: Datadog::Core::Configuration::AgentSettings
+      # @rbs site: ::String?
+      # @rbs api_key: ::String?
+      # @rbs upload_timeout_seconds: ::Integer
+      # @rbs use_system_dns: bool
+      # @rbs return: void
+      def initialize(agent_settings:, site:, api_key:, upload_timeout_seconds:, use_system_dns:)
+        timeout_milliseconds = (upload_timeout_seconds * 1_000).to_i
+
+        # Steep: multiple issues here
+        # first https://github.com/soutaro/steep/issues/363
+        # then https://github.com/soutaro/steep/issues/1603 (remove the .freeze to see it)
+        @exporter_configuration = # steep:ignore IncompatibleAssignment
           if agentless?(site, api_key)
-            [:agentless, site, api_key].freeze
+            [:agentless, timeout_milliseconds, use_system_dns, site, api_key].freeze
           else
-            [:agent, base_url_from(agent_settings)].freeze
+            [:agent, timeout_milliseconds, use_system_dns, agent_settings.url].freeze
           end
 
-        status, result = validate_exporter(exporter_configuration)
+        status, result = self.class._native_validate_exporter(exporter_configuration)
 
         raise(ArgumentError, "Failed to initialize transport: #{result}") if status == :error
       end
 
+      #: (Datadog::Profiling::Flush) -> bool
       def export(flush)
-        status, result = do_export(
-          exporter_configuration: exporter_configuration,
-          upload_timeout_milliseconds: @upload_timeout_milliseconds,
-
-          # why "timespec"?
-          # libdatadog represents time using POSIX's struct timespec, see
-          # https://www.gnu.org/software/libc/manual/html_node/Time-Types.html
-          # aka it represents the seconds part separate from the nanoseconds part
-          start_timespec_seconds: flush.start.tv_sec,
-          start_timespec_nanoseconds: flush.start.tv_nsec,
-          finish_timespec_seconds: flush.finish.tv_sec,
-          finish_timespec_nanoseconds: flush.finish.tv_nsec,
-
-          pprof_file_name: flush.pprof_file_name,
-          pprof_data: flush.pprof_data,
-          code_provenance_file_name: flush.code_provenance_file_name,
-          code_provenance_data: flush.code_provenance_data,
-
-          tags_as_array: flush.tags_as_array,
-          internal_metadata_json: flush.internal_metadata_json,
-
-          info_json: flush.info_json
+        status, result = self.class._native_do_export(
+          exporter_configuration,
+          flush
         )
 
         if status == :ok
@@ -57,7 +48,7 @@ module Datadog
             Datadog.logger.debug("Successfully reported profiling data")
             true
           else
-            Datadog.logger.error(
+            Datadog.logger.warn(
               "Failed to report profiling data (#{config_without_api_key}): " \
               "server returned unexpected HTTP #{result} status code"
             )
@@ -67,7 +58,7 @@ module Datadog
             false
           end
         else
-          Datadog.logger.error("Failed to report profiling data (#{config_without_api_key}): #{result}")
+          Datadog.logger.warn("Failed to report profiling data (#{config_without_api_key}): #{result}")
           Datadog::Core::Telemetry::Logger.error("Failed to report profiling data")
           false
         end
@@ -75,71 +66,14 @@ module Datadog
 
       private
 
-      def base_url_from(agent_settings)
-        case agent_settings.adapter
-        when Datadog::Core::Configuration::Ext::Agent::HTTP::ADAPTER
-          "#{agent_settings.ssl ? "https" : "http"}://#{agent_settings.hostname}:#{agent_settings.port}/"
-        when Datadog::Core::Configuration::Ext::Agent::UnixSocket::ADAPTER
-          "unix://#{agent_settings.uds_path}"
-        else
-          raise ArgumentError, "Unexpected adapter: #{agent_settings.adapter}"
-        end
-      end
-
-      def validate_agent_settings(agent_settings)
-        supported_adapters = [
-          Datadog::Core::Configuration::Ext::Agent::UnixSocket::ADAPTER,
-          Datadog::Core::Configuration::Ext::Agent::HTTP::ADAPTER
-        ]
-        unless supported_adapters.include?(agent_settings.adapter)
-          raise ArgumentError,
-            "Unsupported transport configuration for profiling: Adapter #{agent_settings.adapter} " \
-                        " is not supported"
-        end
-      end
-
+      #: (::String?, ::String?) -> bool?
       def agentless?(site, api_key)
-        site && api_key && Core::Environment::VariableHelpers.env_to_bool(Profiling::Ext::ENV_AGENTLESS, false)
-      end
-
-      def validate_exporter(exporter_configuration)
-        self.class._native_validate_exporter(exporter_configuration)
-      end
-
-      def do_export(
-        exporter_configuration:,
-        upload_timeout_milliseconds:,
-        start_timespec_seconds:,
-        start_timespec_nanoseconds:,
-        finish_timespec_seconds:,
-        finish_timespec_nanoseconds:,
-        pprof_file_name:,
-        pprof_data:,
-        code_provenance_file_name:,
-        code_provenance_data:,
-        tags_as_array:,
-        internal_metadata_json:,
-        info_json:
-      )
-        self.class._native_do_export(
-          exporter_configuration,
-          upload_timeout_milliseconds,
-          start_timespec_seconds,
-          start_timespec_nanoseconds,
-          finish_timespec_seconds,
-          finish_timespec_nanoseconds,
-          pprof_file_name,
-          pprof_data,
-          code_provenance_file_name,
-          code_provenance_data,
-          tags_as_array,
-          internal_metadata_json,
-          info_json,
-        )
+        site && api_key && %w[1 true].include?(ENV[Profiling::Ext::ENV_AGENTLESS] || "") # rubocop:disable CustomCops/EnvUsageCop
       end
 
+      #: () -> ::String
       def config_without_api_key
-        "#{exporter_configuration[0]}: #{exporter_configuration[1]}"
+        "#{exporter_configuration[0]}: #{exporter_configuration[3]}"
       end
     end
   end

data/lib/datadog/profiling/load_native_extension.rb

@@ -1,41 +1,9 @@
 # frozen_string_literal: true
 
-# This file is used to load the profiling native extension. It works in two steps:
-#
-# 1. Load the datadog_profiling_loader extension. This extension will be used to load the actual extension, but in
-#    a special way that avoids exposing native-level code symbols. See `datadog_profiling_loader.c` for more details.
-#
-# 2. Use the Datadog::Profiling::Loader exposed by the datadog_profiling_loader extension to load the actual
-#    profiling native extension.
-#
-# All code on this file is on-purpose at the top-level; this makes it so this file is executed only once,
-# the first time it gets required, to avoid any issues with the native extension being initialized more than once.
-
 begin
-  require "datadog_profiling_loader.#{RUBY_VERSION}_#{RUBY_PLATFORM}"
+  require "datadog_profiling_native_extension.#{RUBY_VERSION}_#{RUBY_PLATFORM}"
 rescue LoadError => e
   raise LoadError,
-    "Failed to load the profiling loader extension. To fix this, please remove and then reinstall datadog " \
-    "(Details: #{e.message})"
-end
-
-extension_name = "datadog_profiling_native_extension.#{RUBY_VERSION}_#{RUBY_PLATFORM}"
-file_name = "#{extension_name}.#{RbConfig::CONFIG["DLEXT"]}"
-full_file_path = "#{__dir__}/../../#{file_name}"
-
-unless File.exist?(full_file_path)
-  extension_dir = Gem.loaded_specs["datadog"].extension_dir
-  candidate_path = "#{extension_dir}/#{file_name}"
-  if File.exist?(candidate_path)
-    full_file_path = candidate_path
-  else
-    # We found none of the files. This is unexpected. Let's go ahead anyway, the error is going to be reported further
-    # down anyway.
-  end
+    "Failed to load the profiling native extension. To fix this, please remove and then reinstall datadog " \
+    "(Details: #{e.class}: #{e.message})"
 end
-
-init_function_name = "Init_#{extension_name.split(".").first}"
-
-status, result = Datadog::Profiling::Loader._native_load(full_file_path, init_function_name)
-
-raise "Failure to load #{extension_name} due to #{result}" if status == :error

data/lib/datadog/profiling/profiler.rb

@@ -8,54 +8,73 @@ module Datadog
 
       private
 
-      attr_reader :worker, :scheduler
+      attr_reader :worker #: Datadog::Profiling::Collectors::CpuAndWallTimeWorker
+      attr_reader :scheduler #: Datadog::Profiling::Scheduler
 
       public
 
+      # @rbs worker: Datadog::Profiling::Collectors::CpuAndWallTimeWorker
+      # @rbs scheduler: Datadog::Profiling::Scheduler
+      # @rbs return: void
       def initialize(worker:, scheduler:)
         @worker = worker
         @scheduler = scheduler
       end
 
+      #: () -> void
       def start
         after_fork! do
           worker.reset_after_fork
           scheduler.reset_after_fork
         end
 
-        worker.start(on_failure_proc: proc { component_failed(:worker) })
+        worker.start(
+          on_failure_proc: ->(log_failure: true) do
+            # @type var log_failure: bool
+            component_failed(:worker, log_failure: log_failure)
+          end
+        )
         scheduler.start(on_failure_proc: proc { component_failed(:scheduler) })
       end
 
-      def shutdown!
+      # @rbs report_last_profile: bool
+      # @rbs return: void
+      def shutdown!(report_last_profile: true)
         Datadog.logger.debug("Shutting down profiler")
 
         stop_worker
+        scheduler.disable_reporting unless report_last_profile
         stop_scheduler
       end
 
       private
 
+      #: () -> void
       def stop_worker
         worker.stop
       end
 
+      #: () -> void
       def stop_scheduler
         scheduler.enabled = false
         scheduler.stop(true)
       end
 
-      def component_failed(failed_component)
-        Datadog.logger.warn(
-          "Detected issue with profiler (#{failed_component} component), stopping profiling. " \
-          "See previous log messages for details."
-        )
-
-        # We explicitly not stop the crash tracker in this situation, under the assumption that, if a component failed,
-        # we're operating in a degraded state and crash tracking may still be helpful.
+      # @rbs failed_component: :worker | :scheduler | ::Symbol
+      # @rbs log_failure: bool
+      # @rbs return: void
+      def component_failed(failed_component, log_failure: true)
+        if log_failure
+          Datadog.logger.warn(
+            "Detected issue with profiler (#{failed_component} component), stopping profiling. " \
+            "See previous log messages for details."
+          )
+          Datadog::Core::Telemetry::Logger
+            .error("Detected issue with profiler (#{failed_component} component), stopping profiling")
+        end
 
         if failed_component == :worker
-          scheduler.mark_profiler_failed
+          scheduler.disable_reporting
           stop_scheduler
         elsif failed_component == :scheduler
           stop_worker

data/lib/datadog/profiling/scheduler.rb

@@ -24,7 +24,7 @@ module Datadog
       attr_reader \
         :exporter,
         :transport,
-        :profiler_failed
+        :reporting_disabled
 
       public
 
@@ -36,7 +36,8 @@ module Datadog
       )
         @exporter = exporter
         @transport = transport
-        @profiler_failed = false
+        @reporting_disabled = false
+        @stop_requested = false
 
         # Workers::Async::Thread settings
         self.fork_policy = fork_policy
@@ -64,9 +65,10 @@ module Datadog
       rescue Exception => e # rubocop:disable Lint/RescueException
         Datadog.logger.warn(
           "Profiling::Scheduler thread error. " \
-          "Cause: #{e.class.name} #{e.message} Location: #{Array(e.backtrace).first}"
+          "Cause: #{e.class}: #{e.message} Location: #{Array(e.backtrace).first}"
         )
         on_failure_proc&.call
+        Datadog::Core::Telemetry::Logger.report(e, description: "Profiling::Scheduler thread error")
         raise
       ensure
         Datadog.logger.debug("#flush was interrupted or failed before it could complete") if interrupted
@@ -81,14 +83,15 @@ module Datadog
         true
       end
 
-      # This is called by the Profiler class whenever an issue happened in the profiler. This makes sure that even
-      # if there is data to be flushed, we don't try to flush it.
-      def mark_profiler_failed
-        @profiler_failed = true
+      # Called by the Profiler when it wants to prevent any further reporting,
+      # even if there is data to be flushed.
+      # Used when the profiler failed or we're otherwise in a hurry to shut down.
+      def disable_reporting
+        @reporting_disabled = true
       end
 
       def work_pending?
-        !profiler_failed && exporter.can_flush?
+        !reporting_disabled && exporter.can_flush? && (run_loop? || !stop_requested?)
       end
 
       def reset_after_fork
@@ -132,14 +135,20 @@ module Datadog
         begin
           transport.export(flush)
         rescue => e
-          Datadog.logger.error(
-            "Unable to report profile. Cause: #{e.class.name} #{e.message} Location: #{Array(e.backtrace).first}"
+          Datadog.logger.warn(
+            "Unable to report profile. Cause: #{e.class}: #{e.message} Location: #{Array(e.backtrace).first}"
           )
           Datadog::Core::Telemetry::Logger.report(e, description: "Unable to report profile")
         end
 
+        @stop_requested = !run_loop?
+
         true
       end
+
+      def stop_requested?
+        @stop_requested
+      end
     end
   end
 end

data/lib/datadog/profiling/sequence_tracker.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require_relative "../core/utils/forking"
+
+module Datadog
+  module Profiling
+    # Used to generate the `profile_seq` tag, which effectively counts how many profiles we've attempted to report
+    # from a given runtime-id.
+    #
+    # Note that the above implies a few things:
+    # 1. The sequence number only gets incremented when we decide to report a profile and create a `Flush` for it
+    # 2. The `SequenceTracker` must live across profiler reconfigurations and resets, since no matter how many
+    #    profiler instances get created due to reconfiguration, the runtime-id is still the same, so the sequence number
+    #    should be kept and not restarted from 0
+    # 3. The `SequenceTracker` must be reset after a fork, since the runtime-id will change, and we want to start
+    #    counting from 0 again
+    #
+    # This is why this module is implemented as a singleton that we reuse, not as an instance that we recreate.
+    #
+    # Note that this module is not thread-safe, so it's up to the callers to make sure
+    # it's only used by a single thread at a time (which is what the `Profiling::Exporter`)
+    # is doing.
+    module SequenceTracker
+      class << self
+        include Core::Utils::Forking
+
+        def get_next
+          reset! unless defined?(@sequence_number)
+          after_fork! { reset! }
+
+          next_seq = @sequence_number
+          @sequence_number += 1
+          next_seq
+        end
+
+        private
+
+        def reset!
+          @sequence_number = 0
+        end
+      end
+    end
+  end
+end