rails-profiler 0.31.2 → 0.31.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e53e69cbdde6c7e775444a738e0069cef86994f505f77d86673a15e25adc768d
-  data.tar.gz: c134819ed6bff52aa1d5ad7309b752e1ed6c6a6e1803510d4387462f1607b73a
+  metadata.gz: '09422d8df091081147998c5e266018f8156874c3f2590b4269dfc1bab5b2efcf'
+  data.tar.gz: 3f0ac06620cf6d1f0297528cdce39e80962b736e835d127538968a2aff8b748f
 SHA512:
-  metadata.gz: 1a277a3d46f4967dc8d875957e95b4d2df118c5a7a96dfcdac83e4a932c4aa4fbd73e1498ef5250bf714e96b5842d99814b617e7f530befcef2eac07984e571c
-  data.tar.gz: 978b1b85623419ca8fd8afe3c9550f24be03dbd5e1a8ef02f8ded99270cff218f2e2d68622b66b9edc7def30a46cb574c8b06bdb7b3cdb6f3502b91a919d7941
+  metadata.gz: 7d74679898828ec69cea3718945c08e8c8ce4aec93d1ccb8942de28617a888ff2dfc2fbde4e4c01892f9a05a8723f713907a87b378b3be5dd11d5cb7cec7500b
+  data.tar.gz: 918333cbc7efbb6c61217adb4c52ced40be60a62b621fb828e942878598defd92d69bd36672bf515bcd5b6f9e4ed82869268fe704f64b674c309e2f61846fe6a

data/CHANGELOG.md

@@ -19,6 +19,69 @@ every commit of every tag interval is accounted for one way or the other.
 
 ## [Unreleased]
 
+## [0.31.3] - 2026-10-05
+
+<!-- stamped -->
+
+### Fixed
+
+- **Collectors:** a profile no longer records the SQL queries, views, cache operations, timeline
+  events, exceptions and mails of other requests. The collectors subscribed to the process-wide
+  `ActiveSupport::Notifications` bus without looking at the thread, so on a multi-threaded server
+  (Puma, Sidekiq) a profile could show the queries of a concurrent request, another user's
+  included. Each collector now records the events of its own request: its thread, the threads it
+  starts with `Thread.new`, the thread `ActionController::Live` runs the action in, the fibers
+  it creates (Ruby 3.2+, the layout of `render stream: true` under Falcon), the server thread
+  iterating a streamed body, and the queries of `load_async`, which Rails reports on the
+  request's thread. The process holds one subscriber per event instead of one per profiled request,
+  so an SQL event costs the same however many requests are profiled at once (6 us with 8 requests
+  profiled, 260 us before, measured). A job performed inline still shows in both profiles; one
+  performed by ActiveJob's `:async` adapter is profiled apart from the request that enqueued it,
+  even while that request still runs. A test profile no longer shows the queries the application
+  server runs for a system test in its own thread: they are in the profile of that HTTP request.
+- **Instrumentation:** a thread created by a pool while a request ran (a concurrent-ruby worker
+  behind `Concurrent::Promises`, ActiveJob's `:async` adapter or `ActionController::Live`, or the
+  thread Puma starts for a request marked as IO bound) no longer keeps that request's HTTP and
+  timeline collectors for good, which put the outgoing HTTP calls of other requests' tasks in its
+  profile. A task posted to a concurrent-ruby executor now runs in the context of the request that
+  posted it, and a pool thread inherits nothing. On Puma with 8 threads, 40 concurrent requests
+  each running a query and an HTTP call in a `Concurrent::Promises.future`: 0 queries and 0 HTTP
+  calls of another request in a profile, none lost, against 560 foreign queries, 35 misattributed
+  and 36 lost HTTP calls before (measured, `script/bench/puma_attribution.rb`).
+- **Function profiler:** without the `stackprof` gem, which the gem does not depend on, the
+  function profiler stays off instead of falling back to a `TracePoint` enabled on every thread of
+  the process, which called `GC.stat` four times per method and tripled the cost of a request, for
+  a tab that is not shown. To trace again, set `Profiler.function_profiling_tracepoint_fallback =
+  true`; the `TracePoint`, like the one of the `full` mode chosen from the dashboard, is now
+  enabled on the request's thread only. The Timeline tab now says that stackprof is missing and
+  how to add it, instead of a button to enable function profiling that changed nothing, and no
+  longer says that sampling is on by default whatever the Gemfile.
+- **Database:** the caller of a query is captured the first time a statement runs in the request
+  (values left out, as the N+1 detection groups them) and for every slow query, instead of for
+  every query, at about 0.1 ms each. The N+1 groups of the Database tab and of the MCP
+  `n1-patterns` resource keep their location. The backtrace now starts at the application's code
+  that ran the query, cleaned by `Rails.backtrace_cleaner` as in the Exception tab, or without
+  Rails, past the frames of gems and of Ruby; it often started inside Active Support, with the
+  application's first frame too far down for the three frames `n1-patterns` shows.
+  `config.sql_backtrace = :all` captures every query again, `:none` none.
+- **Routes and Env tabs:** a profile no longer stores the whole route table and `ENV`, rebuilt and
+  sorted on every request (the route table alone cost 7.7 ms per request with 210 routes, and 29 KB
+  per profile, measured). It keeps the route its request matched, the one of the request's verb
+  (a `PUT` showed the `PATCH` route of the same action). The Routes tab, the toolbar and the MCP
+  `get_profile` tool list the route table of the process that serves them, rebuilt when the
+  routes are reloaded in development; the Env tab of an HTTP profile shows the current `ENV` of that
+  process, not the `ENV` as it was during the request, masked as before. The profiles of jobs,
+  console expressions and tests, which run in another process, keep that process's `ENV`, masked,
+  as before. Profiles saved by an earlier version keep
+  showing their own table and variables. With both changes, the profiler adds about 10 to 13 ms to
+  the reference page of `script/bench/request_overhead.rb` instead of 21 to 22 ms with stackprof
+  and 26 ms without it in 0.31.2 (Ruby 3.3, measured); the README gives this measured cost instead
+  of "< 5ms per request".
+- **Upgrading:** to get the previous behaviours back, set `config.sql_backtrace = :all` and
+  `Profiler.function_profiling_tracepoint_fallback = true` in `config/initializers/profiler.rb`.
+  The Routes and Env tabs cannot show the table and the variables of the request's time any more:
+  they show the process's current ones.
+
 ## [0.31.2] - 2026-10-05
 
 <!-- stamped -->

data/app/assets/builds/profiler.js

@@ -7413,7 +7413,9 @@
     const [totalCount, setTotalCount] = d2(0);
     const [fnSortKey, setFnSortKey] = d2("total_duration");
     const [fnSortDir, setFnSortDir] = d2("desc");
-    const [fnEnabled, setFnEnabled] = d2(functionProfileData?.enabled ?? false);
+    const [fnEnabled, setFnEnabled] = d2(
+      functionProfileData?.reason === "stackprof_missing" ? true : functionProfileData?.enabled ?? false
+    );
     const [fnMaxFrames, setFnMaxFrames] = d2(functionProfileData?.max_frames ?? 2e3);
     const [fnMode, setFnMode] = d2(functionProfileData?.mode === "lite" ? "lite" : "full");
     const [fnClock, setFnClock] = d2(functionProfileData?.clock ?? "wall");
@@ -7722,6 +7724,7 @@
     const [hoveredFnName, setHoveredFnName] = d2(null);
     const fnRendererRef = A2(null);
     const hasData = enabled && data?.enabled && (data.functions?.length ?? 0) > 0;
+    const stackprofMissing = data?.reason === "stackprof_missing" && mode === "lite";
     const dataMode = data?.mode ?? "full";
     const dataClock = data?.clock ?? "wall";
     const isSampling = dataMode === "lite";
@@ -7814,7 +7817,7 @@
               class: `profiler-fn-profiling__toggle${enabled ? " profiler-fn-profiling__toggle--active" : ""}`,
               onClick: onToggle,
               disabled: toggling,
-              children: toggling ? "\u2026" : enabled ? "Enabled \u2014 click to disable" : "Disabled \u2014 click to enable"
+              children: toggling ? "\u2026" : enabled ? "Enabled (click to disable)" : "Disabled (click to enable)"
             }
           )
         ] })
@@ -7823,12 +7826,25 @@
         "Enable function profiling to see where your app spends time.",
         " ",
         /* @__PURE__ */ u3("strong", { children: "Lite" }),
-        ": statistical sampling via stackprof \u2014 very low overhead (<1%), enabled by default.",
+        ": statistical sampling with the stackprof gem, to add to the application's Gemfile; very low overhead (<1%), on by default once stackprof is installed.",
         " ",
         /* @__PURE__ */ u3("strong", { children: "Full" }),
         ": exhaustive TracePoint tracing with memory bytes \u2014 significant overhead."
       ] }),
-      enabled && !hasData && /* @__PURE__ */ u3("p", { class: "profiler-fn-profiling__hint", children: "Function profiling is active. Data will appear on the next request." }),
+      enabled && stackprofMissing && /* @__PURE__ */ u3("p", { class: "profiler-fn-profiling__hint", children: [
+        "No data: sampling needs the ",
+        /* @__PURE__ */ u3("code", { children: "stackprof" }),
+        " gem, which is not installed. Add",
+        " ",
+        /* @__PURE__ */ u3("code", { children: 'gem "stackprof"' }),
+        " to the application's Gemfile. To trace every method call instead, at a much higher cost, choose ",
+        /* @__PURE__ */ u3("strong", { children: "Full" }),
+        ", or set",
+        " ",
+        /* @__PURE__ */ u3("code", { children: "Profiler.function_profiling_tracepoint_fallback = true" }),
+        " in an initializer."
+      ] }),
+      enabled && !hasData && !stackprofMissing && /* @__PURE__ */ u3("p", { class: "profiler-fn-profiling__hint", children: "Function profiling is active. Data will appear on the next request." }),
       hasData && /* @__PURE__ */ u3(k, { children: [
         data.frame_cap_reached && /* @__PURE__ */ u3("div", { class: "profiler-fn-profiling__cap-warning", children: [
           "\u26A0 Frame cap reached (",

data/app/controllers/profiler/api/profiles_controller.rb

@@ -29,6 +29,8 @@ module Profiler
 
         # Recalculate AJAX collector data (since AJAX requests happen after page load)
         recalculate_ajax_data(profile)
+        # The route table and ENV are the process's, not stored in the profile
+        Profiler::ProcessSnapshot.hydrate(profile)
 
         render json: profile.to_h.merge(
           child_jobs: build_child_jobs(profile),

data/app/controllers/profiler/api/toolbar_controller.rb

@@ -16,6 +16,8 @@ module Profiler
 
         # Recalculate AJAX collector data (since AJAX requests happen after page load)
         recalculate_ajax_data(profile)
+        # The route table and ENV are the process's, not stored in the profile
+        Profiler::ProcessSnapshot.hydrate(profile)
 
         render json: {
           profile: profile.to_h.merge(child_jobs: build_child_jobs(profile)),

data/app/controllers/profiler/profiles_controller.rb

@@ -22,6 +22,8 @@ module Profiler
 
       # Recalculate AJAX collector data (since AJAX requests happen after page load)
       recalculate_ajax_data(@profile)
+      # The route table and ENV are the process's, not stored in the profile
+      Profiler::ProcessSnapshot.hydrate(@profile)
 
       @profile_data = @profile.to_h.merge(
         child_jobs: build_child_jobs(@profile),

data/lib/profiler/collectors/base_collector.rb

@@ -2,6 +2,7 @@
 
 require_relative "../redaction"
 require_relative "lifecycle"
+require_relative "scoped_notifications"
 
 module Profiler
   module Collectors
@@ -143,10 +144,14 @@ module Profiler
         @claimed_thread_slots = nil
       end
 
-      def unsubscribe_notifications(subscriptions)
-        return unless defined?(ActiveSupport::Notifications)
+      # Subscribes to +event+ for the request being profiled only: the block never sees what
+      # another request's thread emits (see ScopedNotifications). Returns the handle to release.
+      def subscribe_notification(event, &block)
+        ScopedNotifications.subscribe(event, &block)
+      end
 
-        subscriptions.each { |sub| ActiveSupport::Notifications.unsubscribe(sub) }
+      def unsubscribe_notifications(subscriptions)
+        subscriptions.each { |handle| ScopedNotifications.unsubscribe(handle) }
         subscriptions.clear
       end
     end

data/lib/profiler/collectors/cache_collector.rb

@@ -35,7 +35,7 @@ module Profiler
       def subscribe
         return unless defined?(ActiveSupport::Notifications)
 
-        @subscriptions << ActiveSupport::Notifications.monotonic_subscribe("cache_read.active_support") do |name, started, finished, unique_id, payload|
+        @subscriptions << subscribe_notification("cache_read.active_support") do |name, started, finished, unique_id, payload|
           duration = ((finished - started) * 1000).round(2)
           @cache_reads << {
             key: payload[:key],
@@ -44,7 +44,7 @@ module Profiler
           }
         end
 
-        @subscriptions << ActiveSupport::Notifications.monotonic_subscribe("cache_write.active_support") do |name, started, finished, unique_id, payload|
+        @subscriptions << subscribe_notification("cache_write.active_support") do |name, started, finished, unique_id, payload|
           duration = ((finished - started) * 1000).round(2)
           @cache_writes << {
             key: payload[:key],
@@ -52,7 +52,7 @@ module Profiler
           }
         end
 
-        @subscriptions << ActiveSupport::Notifications.monotonic_subscribe("cache_delete.active_support") do |name, started, finished, unique_id, payload|
+        @subscriptions << subscribe_notification("cache_delete.active_support") do |name, started, finished, unique_id, payload|
           duration = ((finished - started) * 1000).round(2)
           @cache_deletes << {
             key: payload[:key],

data/lib/profiler/collectors/database_collector.rb

@@ -6,10 +6,24 @@ require_relative "../models/sql_query"
 module Profiler
   module Collectors
     class DatabaseCollector < BaseCollector
+      BACKTRACE_DEPTH = 10
+      MAX_SCANNED_FRAMES = 100
+      FRAMES_PAST_APPLICATION = 15
+
+
+      # Frames between the application's code and the subscriber: the profiler itself, the
+      # notifications bus and Active Record.
+      INTERNAL_FRAMES = [
+        File.expand_path("..", __dir__) + "/",
+        "/active_support/notifications",
+        "/active_record/"
+      ].freeze
+
       def initialize(profile)
         super
         @queries = []
-        @subscription = nil
+        @subscriptions = []
+        @seen_statements = {}
       end
 
       def icon
@@ -34,7 +48,10 @@ module Profiler
       def subscribe
         return unless defined?(ActiveSupport::Notifications)
 
-        @subscription = ActiveSupport::Notifications.monotonic_subscribe("sql.active_record") do |name, started, finished, unique_id, payload|
+        @backtrace_mode = Profiler.configuration.sql_backtrace&.to_sym
+        @slow_query_threshold = Profiler.configuration.slow_query_threshold
+
+        @subscriptions << subscribe_notification("sql.active_record") do |name, started, finished, unique_id, payload|
           duration = ((finished - started) * 1000).round(2) # milliseconds
 
           # Skip schema queries and internal Rails queries
@@ -47,7 +64,7 @@ module Profiler
             binds: extract_binds(payload[:binds]),
             name: payload[:name],
             connection: payload[:connection],
-            backtrace: extract_backtrace
+            backtrace: backtrace?(payload[:sql], duration) ? extract_backtrace : []
           )
 
           @queries << query
@@ -74,10 +91,7 @@ module Profiler
       end
 
       def unsubscribe
-        return unless @subscription
-
-        ActiveSupport::Notifications.unsubscribe(@subscription)
-        @subscription = nil
+        unsubscribe_notifications(@subscriptions)
       end
 
       def toolbar_summary
@@ -118,10 +132,114 @@ module Profiler
         binds.map { Profiler::Redaction::MASK }
       end
 
+      # Capturing the caller costs tens of microseconds. The first run of a statement locates
+      # it, an N+1 loop included (its repeats are the same statement with other values); a slow
+      # query is always located.
+      def backtrace?(sql, duration)
+        case @backtrace_mode
+        when :all then true
+        when :none then false
+        else
+          key = statement_key(sql)
+          first = !@seen_statements.key?(key)
+          @seen_statements[key] = true if first
+          first || duration > @slow_query_threshold
+        end
+      end
+
+      # The statement with its values left out, exactly as the N+1 detection of the Database tab
+      # (DatabaseTab.tsx) and of the MCP (Resources::N1Patterns) groups queries: the first query
+      # of each group is then always one whose caller was captured, values inlined in the SQL
+      # (MySQL) included.
+      def statement_key(sql)
+        sql.to_s
+           .gsub(/\$\d+/, "?")
+           .gsub(/\b\d+\b/, "?")
+           .gsub(/'[^']*'/, "?")
+           .gsub(/"[^"]*"/, "?")
+           .strip
+      end
+
+      # The code that ran the query: the frames Rails.backtrace_cleaner keeps, as the exception
+      # tab shows them, or without Rails, the frames outside gems and Ruby itself. Whatever stands
+      # in between (the profiler, Active Support, Active Record, the driver, other gems) is left
+      # out, so that the first frames are the application's.
       def extract_backtrace
-        caller_locations(5, 10)
-          .reject { |loc| loc.path.include?("active_record") }
-          .map { |loc| "#{loc.path}:#{loc.lineno}:in `#{loc.label}`" }
+        cleaner = rails_backtrace_cleaner
+        cleaned = []
+        plain = []
+        scanned = 0
+        last_kept = nil
+        while scanned < MAX_SCANNED_FRAMES && cleaned.size < BACKTRACE_DEPTH
+          chunk = caller_locations(1 + scanned, 25)
+          break if chunk.nil? || chunk.empty?
+
+          chunk.each do |loc|
+            scanned += 1
+            path = loc.path.to_s
+            next if INTERNAL_FRAMES.any? { |internal| path.include?(internal) }
+            # Gems and Ruby are never the application's code, and Rails' cleaner silences them
+            # too: a string test spares it most frames.
+            next if library_frame?(path)
+
+            line = "#{path}:#{loc.lineno}:in `#{loc.label}`"
+            if cleaner && (kept = clean_frame(cleaner, line))
+              cleaned << kept
+              last_kept = scanned
+            end
+            plain << line if plain.size < BACKTRACE_DEPTH
+            break if cleaned.size == BACKTRACE_DEPTH
+          end
+          # Without Rails, the first frames outside gems are enough; with it, the application's
+          # frames come together: a few frames past the last one kept, the rest is the framework.
+          break if cleaner.nil? && plain.size >= BACKTRACE_DEPTH
+          break if last_kept && scanned - last_kept > FRAMES_PAST_APPLICATION
+        end
+
+        frames = cleaned.empty? ? plain : cleaned
+        frames.empty? ? fallback_backtrace : frames
+      end
+
+      def rails_backtrace_cleaner
+        Rails.backtrace_cleaner if defined?(Rails) && Rails.respond_to?(:backtrace_cleaner)
+      rescue StandardError
+        nil
+      end
+
+      # The frame as the cleaner shows it, or nil when it silences it.
+      def clean_frame(cleaner, line)
+        cleaner.respond_to?(:clean_frame) ? cleaner.clean_frame(line) : cleaner.clean([line]).first
+      rescue StandardError
+        nil
+      end
+
+      def fallback_backtrace
+        (caller_locations(1, BACKTRACE_DEPTH + 20) || []).filter_map do |loc|
+          path = loc.path.to_s
+          "#{path}:#{loc.lineno}:in `#{loc.label}`" unless INTERNAL_FRAMES.any? { |internal| path.include?(internal) }
+        end.first(BACKTRACE_DEPTH)
+      end
+
+      # Ruby itself and the directories gems are installed in; an application that lives under a
+      # directory called gems is not one.
+      def library_frame?(path)
+        path.start_with?("<internal:") || library_prefixes.any? { |dir| path.start_with?(dir) }
+      end
+
+      def library_prefixes
+        @library_prefixes ||= begin
+          dirs = [RbConfig::CONFIG["rubylibdir"], RbConfig::CONFIG["rubyarchdir"], RbConfig::CONFIG["bindir"]]
+          dirs.concat(Gem.path) if defined?(Gem)
+          dirs << bundle_path
+          dirs.compact.reject(&:empty?).map { |dir| File.join(File.expand_path(dir), "") }.uniq.freeze
+        end
+      end
+
+      # Bundler raises without a Gemfile.
+      def bundle_path
+        Bundler.bundle_path.to_s if defined?(Bundler) && Bundler.respond_to?(:bundle_path)
+      rescue StandardError
+        nil
       end
     end
   end

data/lib/profiler/collectors/env_collector.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative "base_collector"
+require_relative "../process_snapshot"
 
 module Profiler
   module Collectors
@@ -24,14 +25,21 @@ module Profiler
         }
       end
 
+      # ENV is the process's, not the request's: an HTTP profile keeps none of it, and the Env tab
+      # shows the variables of the process that displays the profile, which is the one that served
+      # the request (ProcessSnapshot). A job, a console expression or a test runs in another
+      # process (Sidekiq, the console, rspec): its profile keeps that process's ENV, masked.
       def collect
-        variables = Profiler::Redaction.env_snapshot
-        store_data({ variables: variables, total: variables.size })
+        if @profile.profile_type.to_s == "http"
+          store_data({ scope: "process" })
+        else
+          variables = Profiler::Redaction.env_snapshot
+          store_data({ variables: variables, total: variables.size })
+        end
       end
 
       def toolbar_summary
-        data = panel_content
-        { text: "#{data[:total] || 0} vars", color: "gray" }
+        { text: "#{ENV.size} vars", color: "gray" }
       end
     end
   end

data/lib/profiler/collectors/exception_collector.rb

@@ -31,11 +31,12 @@ module Profiler
       def subscribe
         @exception_data = nil
 
-        @subscriber = ActiveSupport::Notifications.subscribe("process_action.action_controller") do |*args|
-          event = ActiveSupport::Notifications::Event.new(*args)
-          ex = event.payload[:exception_object]
-          capture_exception(ex) if ex && @exception_data.nil?
-        end
+        @subscriptions = [
+          subscribe_notification("process_action.action_controller") do |_name, _started, _finished, _id, payload|
+            ex = payload[:exception_object]
+            capture_exception(ex) if ex && @exception_data.nil?
+          end
+        ]
       end
 
       def capture(ex)
@@ -54,10 +55,7 @@ module Profiler
       end
 
       def unsubscribe
-        return unless @subscriber
-
-        ActiveSupport::Notifications.unsubscribe(@subscriber)
-        @subscriber = nil
+        unsubscribe_notifications(@subscriptions) if @subscriptions
       end
 
       def has_data?

data/lib/profiler/collectors/flamegraph_collector.rb

@@ -38,7 +38,7 @@ module Profiler
         claim_thread_slot(:profiler_flamegraph_collector, self)
 
         # Controller action
-        @subscriptions << ActiveSupport::Notifications.monotonic_subscribe("process_action.action_controller") do |_name, started, finished, _unique_id, payload|
+        @subscriptions << subscribe_notification("process_action.action_controller") do |_name, started, finished, _unique_id, payload|
           add_event Models::TimelineEvent.new(
             name: "#{payload[:controller]}##{payload[:action]}",
             started_at: started,
@@ -56,7 +56,7 @@ module Profiler
         end
 
         # Template rendering
-        @subscriptions << ActiveSupport::Notifications.monotonic_subscribe("render_template.action_view") do |_name, started, finished, _unique_id, payload|
+        @subscriptions << subscribe_notification("render_template.action_view") do |_name, started, finished, _unique_id, payload|
           identifier = short_identifier(payload[:identifier])
           add_event Models::TimelineEvent.new(
             name: "Render: #{identifier}",
@@ -68,7 +68,7 @@ module Profiler
         end
 
         # Partial rendering
-        @subscriptions << ActiveSupport::Notifications.monotonic_subscribe("render_partial.action_view") do |_name, started, finished, _unique_id, payload|
+        @subscriptions << subscribe_notification("render_partial.action_view") do |_name, started, finished, _unique_id, payload|
           identifier = short_identifier(payload[:identifier])
           add_event Models::TimelineEvent.new(
             name: "Partial: #{identifier}",
@@ -80,7 +80,7 @@ module Profiler
         end
 
         # SQL queries
-        @subscriptions << ActiveSupport::Notifications.monotonic_subscribe("sql.active_record") do |_name, started, finished, _unique_id, payload|
+        @subscriptions << subscribe_notification("sql.active_record") do |_name, started, finished, _unique_id, payload|
           next if payload[:name] == "SCHEMA"
           next if payload[:sql] =~ /^(BEGIN|COMMIT|ROLLBACK|SAVEPOINT)/i
 
@@ -96,7 +96,7 @@ module Profiler
 
         # Cache operations
         %w[cache_read.active_support cache_write.active_support cache_delete.active_support].each do |event_name|
-          @subscriptions << ActiveSupport::Notifications.monotonic_subscribe(event_name) do |name, started, finished, _unique_id, payload|
+          @subscriptions << subscribe_notification(event_name) do |name, started, finished, _unique_id, payload|
             op = name.split(".").first.sub("cache_", "")
             key = payload[:key].to_s
             add_event Models::TimelineEvent.new(

data/lib/profiler/collectors/function_profiler_collector.rb

@@ -5,7 +5,7 @@ require_relative "base_collector"
 begin
   require "stackprof"
 rescue LoadError
-  # stackprof not available — lite mode will fall back to TracePoint without memory tracking
+  # stackprof not available: lite mode stays off, unless Profiler.function_profiling_tracepoint_fallback
 end
 
 module Profiler
@@ -55,6 +55,20 @@ module Profiler
 
         mode  = Profiler.function_profiling_mode
         clock = Profiler.function_profiling_clock
+
+        # Sampling needs stackprof, which the gem does not depend on. Tracing every method call
+        # instead costs several times the rest of the profiler: only when asked for.
+        if stackprof_missing?(mode)
+          store_data({
+            enabled:    false,
+            reason:     "stackprof_missing",
+            max_frames: Profiler.function_profiling_max_frames,
+            mode:       mode,
+            clock:      clock
+          })
+          return
+        end
+
         @subscribed = true
         claim_thread_slot(:fn_profiler_mode, mode)
         claim_thread_slot(:fn_profiler_clock, clock)
@@ -119,6 +133,7 @@ module Profiler
 
       def toolbar_summary
         return { text: "off", color: "gray" } unless Profiler.function_profiling_enabled
+        return { text: "off", color: "gray" } if stackprof_missing?(Profiler.function_profiling_mode)
         case Profiler.function_profiling_mode
         when "lite" then { text: "sampling on", color: "blue" }
         else             { text: "fn profiling on", color: "purple" }
@@ -127,6 +142,10 @@ module Profiler
 
       private
 
+      def stackprof_missing?(mode)
+        mode == "lite" && !defined?(StackProf) && !Profiler.function_profiling_tracepoint_fallback
+      end
+
       # ── StackProf (lite mode) ──────────────────────────────────────────────────
 
       def store_sampler_busy(mode, clock)
@@ -297,10 +316,9 @@ module Profiler
         claim_thread_slot(:fn_profiler_depth, Hash.new(0))
 
         @trace = TracePoint.new(:call, :return) do |tp|
-          next unless tp.path&.start_with?(app_root)
-
           stack = Thread.current[:fn_profiler_stack]
           next unless stack
+          next unless tp.path&.start_with?(app_root)
 
           case tp.event
           when :call
@@ -339,7 +357,13 @@ module Profiler
           end
         end
 
-        @trace.enable
+        # On the request's thread only: a TracePoint enabled for the whole process slows down
+        # every other thread, other requests included.
+        begin
+          @trace.enable(target_thread: Thread.current)
+        rescue ArgumentError
+          @trace.enable # a Ruby without target_thread: the hook returns at once on other threads
+        end
       end
 
       def collect_tracepoint(mode)

data/lib/profiler/collectors/mailer_collector.rb

@@ -40,15 +40,10 @@ module Profiler
         return unless defined?(ActiveSupport::Notifications)
         return unless Profiler.configuration.track_mailers
 
-        # Capture the subscriber thread so notifications from other threads (e.g. async
-        # job threads delivering mail enqueued via deliver_later) are ignored by this collector.
-        @subscriber_thread = Thread.current
-
         # Use a stack so multiple deliver_later calls in the same request are all tracked.
         claim_thread_slot(:profiler_pending_processes, [])
 
-        @subscriptions << ActiveSupport::Notifications.monotonic_subscribe("process.action_mailer") do |_name, started, finished, _id, payload|
-          next unless Thread.current.equal?(@subscriber_thread)
+        @subscriptions << subscribe_notification("process.action_mailer") do |_name, started, finished, _id, payload|
           next if rails_preview_request?
 
           mailer_class = payload[:mailer].to_s
@@ -64,8 +59,7 @@ module Profiler
           }
         end
 
-        @subscriptions << ActiveSupport::Notifications.monotonic_subscribe("deliver.action_mailer") do |_name, started, finished, _id, payload|
-          next unless Thread.current.equal?(@subscriber_thread)
+        @subscriptions << subscribe_notification("deliver.action_mailer") do |_name, started, finished, _id, payload|
           next unless payload[:perform_deliveries]
           next if rails_preview_request?