rails-profiler 0.31.2 → 0.31.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e53e69cbdde6c7e775444a738e0069cef86994f505f77d86673a15e25adc768d
-  data.tar.gz: c134819ed6bff52aa1d5ad7309b752e1ed6c6a6e1803510d4387462f1607b73a
+  metadata.gz: 3ca8756c9efed6c4619db0cbc1226f104deb5f7287f972b137f9a8bf291a40c4
+  data.tar.gz: dcb61c33b3262c081493beb1ee783923b3c7b3ac8d4cd26ef9195ea4e3ff182d
 SHA512:
-  metadata.gz: 1a277a3d46f4967dc8d875957e95b4d2df118c5a7a96dfcdac83e4a932c4aa4fbd73e1498ef5250bf714e96b5842d99814b617e7f530befcef2eac07984e571c
-  data.tar.gz: 978b1b85623419ca8fd8afe3c9550f24be03dbd5e1a8ef02f8ded99270cff218f2e2d68622b66b9edc7def30a46cb574c8b06bdb7b3cdb6f3502b91a919d7941
+  metadata.gz: 2576d031d1b4d3e6e462392ed5ca00bc83c12eaed23b9ec07ea842bd3365e373d7eff1b4c53ae73e779366fc947ad70f01f15e8b1108c8fb36e85409986ebd22
+  data.tar.gz: 4b4d5914c82c06e58fd1d8e14157a28b2d0a9bbc00d15f574a5a5bdb0e782c0e9957042f25c38ba2d6cbc93c159b0b4d2f921667d552e397f37fed896bcc2245

data/CHANGELOG.md

@@ -19,6 +19,125 @@ every commit of every tag interval is accounted for one way or the other.
 
 ## [Unreleased]
 
+## [0.31.4] - 2026-10-05
+
+<!-- stamped -->
+
+### Fixed
+
+- **Storage:** A save into the file store costs the same whatever the number of profiles on disk:
+  it listed the directory and read the size of every file on each save, about 5 ms with 500
+  profiles and 100 ms with 10,000, now under 1 ms. The store keeps an index next to the profiles
+  (`.profiles-index.jsonl`, with its lock `.profiles-index.lock`), which the processes writing to
+  the directory share; a missing or damaged one is rebuilt from the profile files, so the profiles
+  already saved are found without any migration. Temporary files left by a killed process are now
+  removed. The index relies on `flock`: a file store shared between hosts over NFS is not
+  supported, use Redis there.
+- **Storage:** `config.max_profiles` (100) is honoured by every backend, the first saved profiles
+  evicted first (a job saved when it ends counts as new, whenever it started): only the memory
+  store applied it, so the file store grew to `max_size` (100 MB,
+  tens of thousands of profiles), SQLite without limit and Redis up to its TTL. In the test
+  environment, where every example saves a profile, there is no cap on the count unless the
+  application sets one.
+- **Storage:** Finding the children of a page (its AJAX sub-requests and its jobs) reads only
+  them, through an index of their parent, instead of reading and parsing every stored profile
+  (about 260 ms with 1,500 profiles of 17 KB in the file store, now under 1 ms). Every profile page
+  and toolbar paid it, once for the child jobs and once more for the AJAX tab; they now read the
+  children once.
+- **Dashboard:** The HTTP, job, console and test lists are filtered and paged by the storage, and
+  list summaries of the profiles (without the bodies, params, headers and nested collector data):
+  they loaded the 1,000 newest profiles in full on every page (about 200 ms with 1,500 profiles of
+  17 KB, now under 10 ms), showed nothing past the thousandth, said there was no next page there,
+  and missed the profiles of one type behind 1,000 newer ones of another. The MCP tools and
+  resources that list one type of profile (jobs, console, tests) and the test report ask the
+  storage for that type too, and found nothing behind 500 newer profiles of another type.
+- **AJAX:** The AJAX tab shows the sub-requests of a page whatever `config.collectors` holds: it
+  only appeared with `AjaxCollector` in the list, which the default list does not have. The jobs a
+  page enqueued are no longer counted as AJAX requests: they stay under its child jobs. The MCP
+  tool `get_profile_ajax` finds the sub-requests too: it read the AJAX data saved with the page,
+  before any sub-request.
+- **Storage:** The storage is created once, under a lock: the first requests of a threaded server
+  could each create their own store (16 for 16 threads in the spec), and with the memory store the
+  profiles saved in all but one were lost. Several file, SQLite or Redis stores share their data
+  and lost nothing.
+- **Storage:** A store that cannot be created (its index or lock replaced by a symbolic link, say)
+  is reported once per process instead of with a backtrace on every request: the profiles are not
+  saved and no toolbar is added, the dashboard and its API answer `503` with the cause in one line
+  (no path) instead of a `500`, the MCP tools an error with it, and the store is created again
+  once the cause is gone.
+- **Upgrading:** the file, SQLite and Redis stores now keep 100 profiles outside the test
+  environment, and **the first save after the upgrade removes the profiles past the cap**, the
+  first saved first: of 3,000 profiles written by 0.31.1 in the file store, about 80 remain, and
+  that first save takes about a second, during which the other processes writing to the store
+  wait. To keep them, set `config.max_profiles` (or `storage_options[:max_profiles]`) **before**
+  upgrading: to a higher number, or to `nil` for the earlier behaviour, no cap on the count (the
+  file store then keeps up to `max_size`, Redis up to its TTL). The memory store keeps 100 with
+  `nil`, as before. A Redis store written by an earlier version is indexed once, by one process,
+  on first use, which also removes the profiles past the cap then (about 0.4 s for 20,000).
+
+## [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/console_controller.rb

@@ -4,17 +4,7 @@ module Profiler
   module Api
     class ConsoleController < ApplicationController
       def index
-        limit  = (params[:limit]  || 50).to_i
-        offset = (params[:offset] || 0).to_i
-        all    = Profiler.storage.list(limit: 1000, offset: 0)
-        console = all.select { |p| p.profile_type == "console" }
-        page   = console.drop(offset).first(limit + 1)
-        render json: {
-          profiles: page.first(limit).map(&:to_h),
-          limit:    limit,
-          offset:   offset,
-          has_more: page.size > limit
-        }
+        render_profile_page(type: "console")
       end
 
       def show

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

@@ -4,17 +4,7 @@ module Profiler
   module Api
     class JobsController < ApplicationController
       def index
-        limit  = (params[:limit]  || 50).to_i
-        offset = (params[:offset] || 0).to_i
-        all    = Profiler.storage.list(limit: 1000, offset: 0)
-        jobs   = all.select { |p| p.profile_type == "job" }
-        page   = jobs.drop(offset).first(limit + 1)
-        render json: {
-          profiles: page.first(limit).map(&:to_h),
-          limit:    limit,
-          offset:   offset,
-          has_more: page.size > limit
-        }
+        render_profile_page(type: "job")
       end
 
       def show

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

@@ -4,20 +4,16 @@ module Profiler
   module Api
     class ProfilesController < ApplicationController
       def index
-        limit  = (params[:limit]  || 50).to_i
-        offset = (params[:offset] || 0).to_i
-        all    = Profiler.storage.list(limit: 1000, offset: 0)
         # all_types is an opt-in used by the cluster proxy so it can mirror the full
-        # storage.list contract; the dashboard relies on the default http-only filter.
-        scope  = all_types? ? all : all.select { |p| p.profile_type == "http" }
-        scope  = scope.select { |p| p.parent_token == params[:parent_token] } if params[:parent_token].present?
-        page   = scope.drop(offset).first(limit + 1)
-        render json: {
-          profiles: page.first(limit).map(&:to_h),
-          limit:    limit,
-          offset:   offset,
-          has_more: page.size > limit
-        }
+        # storage.list contract (every type, or the one given as type, full profiles); the
+        # dashboard relies on the default: http profiles, as summaries.
+        if params[:parent_token].present?
+          render_children_page
+        elsif all_types?
+          render_profile_page(type: profile_type_param, summary: false)
+        else
+          render_profile_page(type: "http")
+        end
       end
 
       def show
@@ -29,6 +25,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),
@@ -55,22 +53,16 @@ module Profiler
         %w[1 true].include?(params[:all_types].to_s)
       end
 
-      def recalculate_ajax_data(profile)
-        # Find AJAX collector in the configured collectors
-        ajax_collector_class = Profiler::Collectors::AjaxCollector
-
-        if Profiler.configuration.collectors.include?(ajax_collector_class)
-          collector = ajax_collector_class.new(profile)
-          collector.collect
+      def profile_type_param
+        params[:type].to_s.match?(/\A[a-z_]{1,32}\z/) ? params[:type].to_s : nil
+      end
 
-          # Update tab metadata to reflect has_data status
-          if profile.instance_variable_get(:@collectors_metadata)
-            ajax_tab = profile.instance_variable_get(:@collectors_metadata).find { |tab| tab[:key] == 'ajax' }
-            if ajax_tab
-              ajax_tab[:has_data] = collector.has_data?
-            end
-          end
-        end
+      # The children of a page, oldest last, read through the store's parent index.
+      def render_children_page
+        limit, offset = page_params
+        children = Profiler.storage.find_by_parent(params[:parent_token].to_s).reverse
+        children = children.select { |p| p.profile_type == "http" } unless all_types?
+        render_page(children.drop(offset).first(limit + 1), limit, offset)
       end
     end
   end

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

@@ -4,17 +4,7 @@ module Profiler
   module Api
     class TestsController < ApplicationController
       def index
-        limit  = (params[:limit]  || 50).to_i
-        offset = (params[:offset] || 0).to_i
-        all    = Profiler.storage.list(limit: 1000, offset: 0)
-        tests  = all.select { |p| p.profile_type == "test" }
-        page   = tests.drop(offset).first(limit + 1)
-        render json: {
-          profiles: page.first(limit).map(&:to_h),
-          limit:    limit,
-          offset:   offset,
-          has_more: page.size > limit
-        }
+        render_profile_page(type: "test")
       end
 
       def show

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

@@ -16,32 +16,14 @@ 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)),
           events_cursor: events_cursor
         }
       end
-
-      private
-
-      def recalculate_ajax_data(profile)
-        # Find AJAX collector in the configured collectors
-        ajax_collector_class = Profiler::Collectors::AjaxCollector
-
-        if Profiler.configuration.collectors.include?(ajax_collector_class)
-          collector = ajax_collector_class.new(profile)
-          collector.collect
-
-          # Update tab metadata to reflect has_data status
-          if profile.instance_variable_get(:@collectors_metadata)
-            ajax_tab = profile.instance_variable_get(:@collectors_metadata).find { |tab| tab[:key] == 'ajax' }
-            if ajax_tab
-              ajax_tab[:has_data] = collector.has_data?
-            end
-          end
-        end
-      end
     end
   end
 end

data/app/controllers/profiler/application_controller.rb

@@ -6,6 +6,9 @@ module Profiler
   class ApplicationController < ActionController::Base
     layout "profiler/application"
 
+    # A store that cannot be created: the cause in one line, as a 503, for every page and API.
+    rescue_from Profiler::Storage::Unavailable::Error, with: :storage_unavailable
+
     before_action :check_authorization
     before_action :authorize_request
     # Declared after the access checks, so that an unauthorized request gets its 403 first.
@@ -48,6 +51,14 @@ module Profiler
       deny("Missing #{Profiler::FORGERY_PROTECTION_HEADER} header or CSRF token")
     end
 
+    def storage_unavailable(error)
+      if controller_path.start_with?("profiler/api/")
+        render json: { error: error.message }, status: :service_unavailable
+      else
+        render plain: error.message, status: :service_unavailable
+      end
+    end
+
     def deny(message)
       if controller_path.start_with?("profiler/api/")
         render json: { error: message }, status: :forbidden
@@ -56,22 +67,51 @@ module Profiler
       end
     end
 
+    # A page of one type of profile, filtered, ordered and paged by the store: one profile more
+    # than the limit tells whether there is a next page, at any offset.
+    def render_profile_page(type:, summary: true)
+      limit, offset = page_params
+      render_page(Profiler.storage.list(limit: limit + 1, offset: offset, type: type, summary: summary), limit, offset)
+    end
+
+    def render_page(profiles, limit, offset)
+      render json: {
+        profiles: profiles.first(limit).map(&:to_h),
+        limit:    limit,
+        offset:   offset,
+        has_more: profiles.size > limit
+      }
+    end
+
+    def page_params
+      [[(params[:limit] || 50).to_i, 0].max, [(params[:offset] || 0).to_i, 0].max]
+    end
+
+    # The children of a page, read once per request: the child jobs and the AJAX tab share them.
+    def child_profiles(profile)
+      @child_profiles ||= {}
+      @child_profiles[profile.token] ||= (@resolved_storage || Profiler.storage).find_by_parent(profile.token)
+    end
+
+    # The AJAX sub-requests are saved after the page: their tab is computed here, whatever the
+    # configured collector list (Profiler::AjaxData).
+    def recalculate_ajax_data(profile)
+      Profiler::AjaxData.attach(profile, child_profiles(profile))
+    end
+
     def build_child_jobs(profile)
-      storage = @resolved_storage || Profiler.storage
-      storage.find_by_parent(profile.token)
-             .select { |p| p.profile_type == "job" }
-             .map do |j|
-               job_data = j.collector_data("job") || {}
-               {
-                 token: j.token,
-                 job_class: j.path,
-                 job_id: job_data["job_id"],
-                 queue: job_data["queue"],
-                 status: job_data["status"],
-                 duration: j.duration,
-                 started_at: j.started_at&.iso8601
-               }
-             end
+      child_profiles(profile).select { |p| p.profile_type == "job" }.map do |j|
+        job_data = j.collector_data("job") || {}
+        {
+          token: j.token,
+          job_class: j.path,
+          job_id: job_data["job_id"],
+          queue: job_data["queue"],
+          status: job_data["status"],
+          duration: j.duration,
+          started_at: j.started_at&.iso8601
+        }
+      end
     end
 
     def build_parent_summary(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),
@@ -142,22 +144,6 @@ module Profiler
       end
     end
 
-    def recalculate_ajax_data(profile)
-      ajax_collector_class = Profiler::Collectors::AjaxCollector
-
-      if Profiler.configuration.collectors.include?(ajax_collector_class)
-        collector = ajax_collector_class.new(profile, storage: @resolved_storage || Profiler.storage)
-        collector.collect
-
-        if profile.instance_variable_get(:@collectors_metadata)
-          ajax_tab = profile.instance_variable_get(:@collectors_metadata).find { |tab| tab[:key] == 'ajax' }
-          if ajax_tab
-            ajax_tab[:has_data] = collector.has_data?
-          end
-        end
-      end
-    end
-
     def filter_profiles(profiles)
       filtered = profiles
 

data/lib/profiler/ajax_data.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require_relative "collectors/ajax_collector"
+
+module Profiler
+  # The AJAX tab of a page: its sub-requests are saved after the page itself, so the tab is
+  # computed when the page is shown, from its children, whatever the configured collector list.
+  # The children are the ones the caller already read (the same find_by_parent gives the child
+  # jobs): only the http ones are sub-requests, the jobs stay in child_jobs.
+  module AjaxData
+    # Hands the children already read to the AjaxCollector in place of the storage.
+    Children = Struct.new(:profiles) do
+      def find_by_parent(_parent_token)
+        profiles
+      end
+    end
+
+    module_function
+
+    # Adds the ajax collector data to profile, and its tab when it has none: a page without
+    # sub-requests and without the tab is left as it is.
+    def attach(profile, children)
+      requests = children.select { |child| child.profile_type == "http" }
+      # A copy: the memory store hands out the very tabs it keeps.
+      tabs = profile.collectors_metadata = (profile.collectors_metadata || []).map(&:dup)
+      tab = tabs.find { |entry| (entry[:key] || entry["key"]).to_s == "ajax" }
+      return if requests.empty? && tab.nil?
+
+      collector = Collectors::AjaxCollector.new(profile, storage: Children.new(requests))
+      collector.collect
+      if tab.nil?
+        profile.add_collector_metadata(collector)
+      elsif tab.key?("key")
+        tab["has_data"] = collector.has_data?
+      else
+        tab[:has_data] = collector.has_data?
+      end
+    end
+  end
+end

data/lib/profiler/cluster/slave_proxy.rb

@@ -33,11 +33,13 @@ module Profiler
 
       # Storage-compatible interface for MCP query tools
 
-      def list(limit: 50, offset: 0, **)
-        # all_types mirrors Profiler.storage.list, which returns every profile type;
-        # without it the proxy would only ever see http profiles (see ProfilesController#index).
-        data = get_json("/_profiler/api/profiles", limit: limit, offset: offset, all_types: true)
-        Array(data["profiles"]).map { |h| profile_from_api(h) }
+      def list(limit: 50, offset: 0, type: nil, **)
+        # all_types mirrors Profiler.storage.list, which returns every profile type, or the one
+        # given as type; without it the proxy would only ever see http profiles (see
+        # ProfilesController#index). A slave of an earlier version ignores type: filtered here too.
+        data = get_json("/_profiler/api/profiles", limit: limit, offset: offset, all_types: true, type: type)
+        profiles = Array(data["profiles"]).map { |h| profile_from_api(h) }
+        type ? profiles.select { |p| p.profile_type == type.to_s } : profiles
       end
 
       # A token that is not one the gem issues is not found, without asking the slave.

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],