datadog 2.1.0 → 2.3.0

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

@@ -0,0 +1,410 @@
+# frozen_string_literal: true
+
+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
+      # https://github.com/DataDog/dd-trace-rb/issues/3450 .
+      # See also https://bugs.ruby-lang.org/issues/20586 for more details.
+      #
+      # 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.
+      #
+      # A lot of these APIs do very similar things -- they're provided by Ruby as helpers so users don't need to keep
+      # reimplementing them but share the same underlying buggy code. And so our monkey patches are a bit repetitive
+      # as well.
+      # We don't DRY out this file to have minimal overhead.
+      #
+      # These monkey patches are applied by the profiler when the "dir_interruption_workaround_enabled" setting is
+      # enabled. See the profiling settings for more detail.
+      module DirMonkeyPatches
+        def self.apply!
+          ::Dir.singleton_class.prepend(Datadog::Profiling::Ext::DirClassMonkeyPatches)
+          ::Dir.prepend(Datadog::Profiling::Ext::DirInstanceMonkeyPatches)
+
+          true
+        end
+      end
+
+      if RUBY_VERSION.start_with?("2.")
+        # Monkey patches for Dir.singleton_class (Ruby 2 version). See DirMonkeyPatches above for more details.
+        module DirClassMonkeyPatches
+          def [](*args, &block)
+            Datadog::Profiling::Collectors::CpuAndWallTimeWorker._native_hold_signals
+            super
+          ensure
+            Datadog::Profiling::Collectors::CpuAndWallTimeWorker._native_resume_signals
+          end
+
+          def children(*args, &block)
+            Datadog::Profiling::Collectors::CpuAndWallTimeWorker._native_hold_signals
+            super
+          ensure
+            Datadog::Profiling::Collectors::CpuAndWallTimeWorker._native_resume_signals
+          end
+
+          # NOTE: When wrapping methods that yield, it's OK if the `yield` raises an exception while signals are
+          # enabled. This is because:
+          # * We can call `_native_resume_signals` many times in a row, both because it's idempotent, as well as it's
+          #   very low overhead (see benchmarks/profiler_hold_resume_interruptions.rb)
+          # * When an exception is being raised, the iteration will stop anyway, so there's no longer a concern of a
+          #   signal causing Ruby to return an incorrect value
+          def each_child(*args, &block)
+            if block
+              begin
+                # <-- Begin critical region
+                Datadog::Profiling::Collectors::CpuAndWallTimeWorker._native_hold_signals
+                super do |entry_name|
+                  Datadog::Profiling::Collectors::CpuAndWallTimeWorker._native_resume_signals
+                  # <-- We're safe now while running customer code
+                  yield entry_name
+                  # <-- We'll go back to the Dir internals, critical region again
+                  Datadog::Profiling::Collectors::CpuAndWallTimeWorker._native_hold_signals
+                end
+              ensure
+                # <-- End critical region
+                Datadog::Profiling::Collectors::CpuAndWallTimeWorker._native_resume_signals
+              end
+            else
+              # This returns an enumerator. We don't want/need to intercede here, the enumerator will eventually call the
+              # other branch once it gets going.
+              super
+            end
+          end
+
+          def empty?(*args, &block)
+            Datadog::Profiling::Collectors::CpuAndWallTimeWorker._native_hold_signals
+            super
+          ensure
+            Datadog::Profiling::Collectors::CpuAndWallTimeWorker._native_resume_signals
+          end
+
+          def entries(*args, &block)
+            Datadog::Profiling::Collectors::CpuAndWallTimeWorker._native_hold_signals
+            super
+          ensure
+            Datadog::Profiling::Collectors::CpuAndWallTimeWorker._native_resume_signals
+          end
+
+          # See note on methods that yield above.
+          def foreach(*args, &block)
+            if block
+              begin
+                # <-- Begin critical region
+                Datadog::Profiling::Collectors::CpuAndWallTimeWorker._native_hold_signals
+                super do |entry_name|
+                  Datadog::Profiling::Collectors::CpuAndWallTimeWorker._native_resume_signals
+                  # <-- We're safe now while running customer code
+                  yield entry_name
+                  # <-- We'll go back to the Dir internals, critical region again
+                  Datadog::Profiling::Collectors::CpuAndWallTimeWorker._native_hold_signals
+                end
+              ensure
+                # <-- End critical region
+                Datadog::Profiling::Collectors::CpuAndWallTimeWorker._native_resume_signals
+              end
+            else
+              # This returns an enumerator. We don't want/need to intercede here, the enumerator will eventually call the
+              # other branch once it gets going.
+              super
+            end
+          end
+
+          # See note on methods that yield above.
+          def glob(*args, &block)
+            if block
+              begin
+                # <-- Begin critical region
+                Datadog::Profiling::Collectors::CpuAndWallTimeWorker._native_hold_signals
+                super do |entry_name|
+                  Datadog::Profiling::Collectors::CpuAndWallTimeWorker._native_resume_signals
+                  # <-- We're safe now while running customer code
+                  yield entry_name
+                  # <-- We'll go back to the Dir internals, critical region again
+                  Datadog::Profiling::Collectors::CpuAndWallTimeWorker._native_hold_signals
+                end
+              ensure
+                # <-- End critical region
+                Datadog::Profiling::Collectors::CpuAndWallTimeWorker._native_resume_signals
+              end
+            else
+              begin
+                Datadog::Profiling::Collectors::CpuAndWallTimeWorker._native_hold_signals
+                super
+              ensure
+                Datadog::Profiling::Collectors::CpuAndWallTimeWorker._native_resume_signals
+              end
+            end
+          end
+
+          def home(*args, &block)
+            Datadog::Profiling::Collectors::CpuAndWallTimeWorker._native_hold_signals
+            super
+          ensure
+            Datadog::Profiling::Collectors::CpuAndWallTimeWorker._native_resume_signals
+          end
+        end
+      else
+        # Monkey patches for Dir.singleton_class (Ruby 3 version). See DirMonkeyPatches above for more details.
+        module DirClassMonkeyPatches
+          def [](*args, **kwargs, &block)
+            Datadog::Profiling::Collectors::CpuAndWallTimeWorker._native_hold_signals
+            super
+          ensure
+            Datadog::Profiling::Collectors::CpuAndWallTimeWorker._native_resume_signals
+          end
+
+          def children(*args, **kwargs, &block)
+            Datadog::Profiling::Collectors::CpuAndWallTimeWorker._native_hold_signals
+            super
+          ensure
+            Datadog::Profiling::Collectors::CpuAndWallTimeWorker._native_resume_signals
+          end
+
+          # See note on methods that yield above.
+          def each_child(*args, **kwargs, &block)
+            if block
+              begin
+                # <-- Begin critical region
+                Datadog::Profiling::Collectors::CpuAndWallTimeWorker._native_hold_signals
+                super do |entry_name|
+                  Datadog::Profiling::Collectors::CpuAndWallTimeWorker._native_resume_signals
+                  # <-- We're safe now while running customer code
+                  yield entry_name
+                  # <-- We'll go back to the Dir internals, critical region again
+                  Datadog::Profiling::Collectors::CpuAndWallTimeWorker._native_hold_signals
+                end
+              ensure
+                # <-- End critical region
+                Datadog::Profiling::Collectors::CpuAndWallTimeWorker._native_resume_signals
+              end
+            else
+              # This returns an enumerator. We don't want/need to intercede here, the enumerator will eventually call the
+              # other branch once it gets going.
+              super
+            end
+          end
+
+          def empty?(*args, **kwargs, &block)
+            Datadog::Profiling::Collectors::CpuAndWallTimeWorker._native_hold_signals
+            super
+          ensure
+            Datadog::Profiling::Collectors::CpuAndWallTimeWorker._native_resume_signals
+          end
+
+          def entries(*args, **kwargs, &block)
+            Datadog::Profiling::Collectors::CpuAndWallTimeWorker._native_hold_signals
+            super
+          ensure
+            Datadog::Profiling::Collectors::CpuAndWallTimeWorker._native_resume_signals
+          end
+
+          # See note on methods that yield above.
+          def foreach(*args, **kwargs, &block)
+            if block
+              begin
+                # <-- Begin critical region
+                Datadog::Profiling::Collectors::CpuAndWallTimeWorker._native_hold_signals
+                super do |entry_name|
+                  Datadog::Profiling::Collectors::CpuAndWallTimeWorker._native_resume_signals
+                  # <-- We're safe now while running customer code
+                  yield entry_name
+                  # <-- We'll go back to the Dir internals, critical region again
+                  Datadog::Profiling::Collectors::CpuAndWallTimeWorker._native_hold_signals
+                end
+              ensure
+                # <-- End critical region
+                Datadog::Profiling::Collectors::CpuAndWallTimeWorker._native_resume_signals
+              end
+            else
+              # This returns an enumerator. We don't want/need to intercede here, the enumerator will eventually call the
+              # other branch once it gets going.
+              super
+            end
+          end
+
+          # See note on methods that yield above.
+          def glob(*args, **kwargs, &block)
+            if block
+              begin
+                # <-- Begin critical region
+                Datadog::Profiling::Collectors::CpuAndWallTimeWorker._native_hold_signals
+                super do |entry_name|
+                  Datadog::Profiling::Collectors::CpuAndWallTimeWorker._native_resume_signals
+                  # <-- We're safe now while running customer code
+                  yield entry_name
+                  # <-- We'll go back to the Dir internals, critical region again
+                  Datadog::Profiling::Collectors::CpuAndWallTimeWorker._native_hold_signals
+                end
+              ensure
+                # <-- End critical region
+                Datadog::Profiling::Collectors::CpuAndWallTimeWorker._native_resume_signals
+              end
+            else
+              begin
+                Datadog::Profiling::Collectors::CpuAndWallTimeWorker._native_hold_signals
+                super
+              ensure
+                Datadog::Profiling::Collectors::CpuAndWallTimeWorker._native_resume_signals
+              end
+            end
+          end
+
+          def home(*args, **kwargs, &block)
+            Datadog::Profiling::Collectors::CpuAndWallTimeWorker._native_hold_signals
+            super
+          ensure
+            Datadog::Profiling::Collectors::CpuAndWallTimeWorker._native_resume_signals
+          end
+        end
+      end
+
+      if RUBY_VERSION.start_with?("2.")
+        # Monkey patches for Dir (Ruby 2 version). See DirMonkeyPatches above for more details.
+        module DirInstanceMonkeyPatches
+          # See note on methods that yield above.
+          def each(*args, &block)
+            if block
+              begin
+                # <-- Begin critical region
+                Datadog::Profiling::Collectors::CpuAndWallTimeWorker._native_hold_signals
+                super do |entry_name|
+                  Datadog::Profiling::Collectors::CpuAndWallTimeWorker._native_resume_signals
+                  # <-- We're safe now while running customer code
+                  yield entry_name
+                  # <-- We'll go back to the Dir internals, critical region again
+                  Datadog::Profiling::Collectors::CpuAndWallTimeWorker._native_hold_signals
+                end
+              ensure
+                Datadog::Profiling::Collectors::CpuAndWallTimeWorker._native_resume_signals # <-- End critical region
+              end
+            else
+              # This returns an enumerator. We don't want/need to intercede here, the enumerator will eventually call the
+              # other branch once it gets going.
+              super
+            end
+          end
+
+          unless RUBY_VERSION.start_with?("2.5.") # This is Ruby 2.6+
+            # See note on methods that yield above.
+            def each_child(*args, &block)
+              if block
+                begin
+                  # <-- Begin critical region
+                  Datadog::Profiling::Collectors::CpuAndWallTimeWorker._native_hold_signals
+                  super do |entry_name|
+                    Datadog::Profiling::Collectors::CpuAndWallTimeWorker._native_resume_signals
+                    # <-- We're safe now while running customer code
+                    yield entry_name
+                    # <-- We'll go back to the Dir internals, critical region again
+                    Datadog::Profiling::Collectors::CpuAndWallTimeWorker._native_hold_signals
+                  end
+                ensure
+                  # <-- End critical region
+                  Datadog::Profiling::Collectors::CpuAndWallTimeWorker._native_resume_signals
+                end
+              else
+                # This returns an enumerator. We don't want/need to intercede here, the enumerator will eventually call the
+                # other branch once it gets going.
+                super
+              end
+            end
+
+            def children(*args, &block)
+              Datadog::Profiling::Collectors::CpuAndWallTimeWorker._native_hold_signals
+              super
+            ensure
+              Datadog::Profiling::Collectors::CpuAndWallTimeWorker._native_resume_signals
+            end
+          end
+
+          def tell(*args, &block)
+            Datadog::Profiling::Collectors::CpuAndWallTimeWorker._native_hold_signals
+            super
+          ensure
+            Datadog::Profiling::Collectors::CpuAndWallTimeWorker._native_resume_signals
+          end
+
+          def pos(*args, &block)
+            Datadog::Profiling::Collectors::CpuAndWallTimeWorker._native_hold_signals
+            super
+          ensure
+            Datadog::Profiling::Collectors::CpuAndWallTimeWorker._native_resume_signals
+          end
+        end
+      else
+        # Monkey patches for Dir (Ruby 3 version). See DirMonkeyPatches above for more details.
+        module DirInstanceMonkeyPatches
+          # See note on methods that yield above.
+          def each(*args, **kwargs, &block)
+            if block
+              begin
+                # <-- Begin critical region
+                Datadog::Profiling::Collectors::CpuAndWallTimeWorker._native_hold_signals
+                super do |entry_name|
+                  Datadog::Profiling::Collectors::CpuAndWallTimeWorker._native_resume_signals
+                  # <-- We're safe now while running customer code
+                  yield entry_name
+                  # <-- We'll go back to the Dir internals, critical region again
+                  Datadog::Profiling::Collectors::CpuAndWallTimeWorker._native_hold_signals
+                end
+              ensure
+                Datadog::Profiling::Collectors::CpuAndWallTimeWorker._native_resume_signals # <-- End critical region
+              end
+            else
+              # This returns an enumerator. We don't want/need to intercede here, the enumerator will eventually call the
+              # other branch once it gets going.
+              super
+            end
+          end
+
+          # See note on methods that yield above.
+          def each_child(*args, **kwargs, &block)
+            if block
+              begin
+                # <-- Begin critical region
+                Datadog::Profiling::Collectors::CpuAndWallTimeWorker._native_hold_signals
+                super do |entry_name|
+                  Datadog::Profiling::Collectors::CpuAndWallTimeWorker._native_resume_signals
+                  # <-- We're safe now while running customer code
+                  yield entry_name
+                  # <-- We'll go back to the Dir internals, critical region again
+                  Datadog::Profiling::Collectors::CpuAndWallTimeWorker._native_hold_signals
+                end
+              ensure
+                # <-- End critical region
+                Datadog::Profiling::Collectors::CpuAndWallTimeWorker._native_resume_signals
+              end
+            else
+              # This returns an enumerator. We don't want/need to intercede here, the enumerator will eventually call the
+              # other branch once it gets going.
+              super
+            end
+          end
+
+          def children(*args, **kwargs, &block)
+            Datadog::Profiling::Collectors::CpuAndWallTimeWorker._native_hold_signals
+            super
+          ensure
+            Datadog::Profiling::Collectors::CpuAndWallTimeWorker._native_resume_signals
+          end
+
+          def tell(*args, **kwargs, &block)
+            Datadog::Profiling::Collectors::CpuAndWallTimeWorker._native_hold_signals
+            super
+          ensure
+            Datadog::Profiling::Collectors::CpuAndWallTimeWorker._native_resume_signals
+          end
+
+          def pos(*args, **kwargs, &block)
+            Datadog::Profiling::Collectors::CpuAndWallTimeWorker._native_hold_signals
+            super
+          ensure
+            Datadog::Profiling::Collectors::CpuAndWallTimeWorker._native_resume_signals
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/profiling/ext.rb

@@ -3,31 +3,31 @@
 module Datadog
   module Profiling
     module Ext
-      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'
+      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"
 
       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'
+          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'
+          PPROF_DEFAULT_FILENAME = "rubyprofile.pprof"
+          CODE_PROVENANCE_FILENAME = "code-provenance.json"
         end
       end
     end

data/lib/datadog/profiling/flush.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'json'
+require "json"
 
 module Datadog
   module Profiling

data/lib/datadog/profiling/http_transport.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require_relative '../core/transport/ext'
+require_relative "../core/transport/ext"
 
 module Datadog
   module Profiling
@@ -53,7 +53,7 @@ module Datadog
 
         if status == :ok
           if (200..299).cover?(result)
-            Datadog.logger.debug('Successfully reported profiling data')
+            Datadog.logger.debug("Successfully reported profiling data")
             true
           else
             Datadog.logger.error(
@@ -73,7 +73,7 @@ module Datadog
       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}/"
+          "#{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
@@ -82,12 +82,14 @@ module Datadog
       end
 
       def validate_agent_settings(agent_settings)
-        supported_adapters = [Datadog::Core::Configuration::Ext::Agent::UnixSocket::ADAPTER,
-                              Datadog::Core::Configuration::Ext::Agent::HTTP::ADAPTER]
+        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'
+                        " is not supported"
         end
       end
 

data/lib/datadog/profiling/load_native_extension.rb

@@ -15,26 +15,26 @@ begin
   require "datadog_profiling_loader.#{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 ' \
+    "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']}"
+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
+  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 # rubocop:disable Style/EmptyElse
+  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
 end
 
-init_function_name = "Init_#{extension_name.split('.').first}"
+init_function_name = "Init_#{extension_name.split(".").first}"
 
 status, result = Datadog::Profiling::Loader._native_load(full_file_path, init_function_name)
 

data/lib/datadog/profiling/preload.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
-require_relative '../../datadog'
+require_relative "../../datadog"
 
 Datadog::Profiling.start_if_enabled

data/lib/datadog/profiling/profiler.rb

@@ -8,34 +8,30 @@ module Datadog
 
       private
 
-      attr_reader :worker, :scheduler, :optional_crashtracker
+      attr_reader :worker, :scheduler
 
       public
 
-      def initialize(worker:, scheduler:, optional_crashtracker:)
+      def initialize(worker:, scheduler:)
         @worker = worker
         @scheduler = scheduler
-        @optional_crashtracker = optional_crashtracker
       end
 
       def start
         after_fork! do
-          optional_crashtracker.reset_after_fork if optional_crashtracker
           worker.reset_after_fork
           scheduler.reset_after_fork
         end
 
-        optional_crashtracker.start if optional_crashtracker
         worker.start(on_failure_proc: proc { component_failed(:worker) })
         scheduler.start(on_failure_proc: proc { component_failed(:scheduler) })
       end
 
       def shutdown!
-        Datadog.logger.debug('Shutting down profiler')
+        Datadog.logger.debug("Shutting down profiler")
 
         stop_worker
         stop_scheduler
-        optional_crashtracker.stop if optional_crashtracker
       end
 
       private
@@ -52,13 +48,14 @@ module Datadog
       def component_failed(failed_component)
         Datadog.logger.warn(
           "Detected issue with profiler (#{failed_component} component), stopping profiling. " \
-          'See previous log messages for details.'
+          "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.
 
         if failed_component == :worker
+          scheduler.mark_profiler_failed
           stop_scheduler
         elsif failed_component == :scheduler
           stop_worker