rails-profiler 0.31.1 → 0.31.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f57ca8fcbd7fef2ddd81f41ab6c1b7b254e814ec986692ed906533f0c9042d4b
-  data.tar.gz: 66e0072789af17ddb711b3911c60d5ebaa683d040117ee44f2dba7b30e126ce7
+  metadata.gz: '09422d8df091081147998c5e266018f8156874c3f2590b4269dfc1bab5b2efcf'
+  data.tar.gz: 3f0ac06620cf6d1f0297528cdce39e80962b736e835d127538968a2aff8b748f
 SHA512:
-  metadata.gz: 9378049525fb7fa8127ddcbe51be0f02a2fe27915cae7aad5cdbce22ce80ba6a5c2ee69b67980366f51f32cb29306c6d14d41878b3773aadaff4a7c5df0fe661
-  data.tar.gz: 1b881dbe5033362810063c9d86946978c94e7dcb95cad19130a729e80f1e6bdbfff20e754feb6f8c9f37dcb3d7bc3dd2571e282463824cd918fa0ea201f1087e
+  metadata.gz: 7d74679898828ec69cea3718945c08e8c8ce4aec93d1ccb8942de28617a888ff2dfc2fbde4e4c01892f9a05a8723f713907a87b378b3be5dd11d5cb7cec7500b
+  data.tar.gz: 918333cbc7efbb6c61217adb4c52ced40be60a62b621fb828e942878598defd92d69bd36672bf515bcd5b6f9e4ed82869268fe704f64b674c309e2f61846fe6a

data/CHANGELOG.md

@@ -19,6 +19,128 @@ 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 -->
+
+### Fixed
+
+- **Middleware:** Stream responses through instead of buffering them. The profiler read every
+  response body to the end before handing it to the server, so an `ActionController::Live`,
+  `response.stream` or enumerator response, or a server-sent events stream, left only once it was
+  over (a stream of 5 chunks 200 ms apart sent its first chunk after 1 s instead of 0.2 s, and an
+  endless event stream never answered), and a file sent with `send_file` lost `to_path`, so the
+  server could no longer send it by its path. A body that does not answer `to_ary`, a
+  `text/event-stream` or a body sent by its path now goes to the server chunk by chunk, keeps
+  `to_path` and `close`, and its profile is saved when the server closes it, also when the client
+  went away, with the body seen so far and the full duration. The collectors that only gather
+  what notifications and the logger hand them (SQL, views, cache, exceptions, timeline, logs,
+  outbound HTTP) stay subscribed until then, so the queries and views of a `render stream: true`
+  page or of an enumerator are still recorded; dumps, mailers, I18n and function profiling are
+  read when the application returns. While the server iterates the body, the log lines, outbound
+  HTTP calls and `Profiler.measure` blocks it runs are recorded as well. Until it is saved, a
+  streamed profile is not listed and its token answers 404: an endless event stream is never
+  listed. A body the server never closes is finished when the fiber that started it starts its
+  next profiled request, never cutting a stream that a fiber-based server such as Falcon runs
+  alongside, and its subscriptions are dropped after 5 minutes at the latest, which the profile
+  and the Request tab then say; the server still closes the application's body. Rails 7.0 pages, whose body has no `to_ary`, and pages a `Live`
+  controller renders whole still get the toolbar. The toolbar is only injected in pages returned
+  whole, so a `render stream: true` page has none.
+- **Middleware:** Stop turning an error raised while a response body is iterated (a stream that
+  fails part way, a file sent with `send_file` that disappeared) into an empty `200`. The error now
+  reaches the server, as it does without the profiler, and the profile keeps it.
+- **Middleware:** Keep the request and response bodies of a profile to the first
+  `config.max_captured_body_bytes` (256 KB by default) instead of copying them whole: a 2 MB upload
+  took 2.8 MB in its profile, plus transient copies. `rack.input` is read only up to that size, then
+  rewound for the application, and an input that cannot be rewound is no longer read at all. The
+  Request tab and the MCP profile detail say when a body was cut, with its whole size, or "at
+  least" that size when it is not known; the profile carries `request_body_truncated`,
+  `request_body_size`, `response_body_truncated`, `response_body_size` and their
+  `*_size_is_minimum`. Only the raw bodies are capped: the parsed `params` and the
+  `Parameters:` log line keep their full size, so a 5 MB JSON request still takes about 15 MB in
+  its profile. To keep whole bodies, as before, set `config.max_captured_body_bytes = nil`.
+- **Profiles:** Report the number of objects allocated (`allocated_objects`) instead of a figure
+  shown as memory. `GC.stat` has no `:total_allocated_size` on the supported Rubies, so `memory`
+  was always that number times 40, never a measured byte count. The toolbar, the dashboards, the
+  profile list and the MCP tools show "Allocations". The counter belongs to the process: on a
+  multi-threaded server it includes what other threads allocated meanwhile. Nothing to change on
+  upgrade: the API and the stored profiles still carry `memory` (deprecated, the count times 40),
+  and profiles saved by earlier versions are read back with their count. The option
+  `memory_warning_threshold`, which nothing ever compared with, is deprecated for
+  `allocated_objects_warning_threshold`, a number of objects, still without effect; setting the
+  old one warns and converts it.
+- **Toolbar:** Leave a response already framed with `Transfer-Encoding` untouched. Under Rails
+  7.0, a `render stream: true` page arrives chunked, and the toolbar was put among the chunks,
+  which broke the framing: the browser got an empty or cut page.
+- **Toolbar:** Correct the `Content-Length` of a page the toolbar is injected into. It kept the
+  length of the page without the toolbar, so a server that honours it cut the page short.
+- **Toolbar:** Inject the toolbar into a page whose headers are a plain `Hash` with a lower-case
+  `content-type`, the form Rack 3 requires; only `Content-Type` was looked up. Every response
+  header the profiler reads or writes now ignores the case.
+
 ## [0.31.1] - 2026-10-05
 
 <!-- stamped -->

data/app/assets/builds/profiler-toolbar.js

@@ -3831,6 +3831,16 @@
     ] });
   }
 
+  // app/assets/typescript/profiler/dashboard/utils.ts
+  function allocatedObjects(profile) {
+    if (profile.allocated_objects != null) return profile.allocated_objects;
+    return profile.memory != null ? Math.round(profile.memory / 40) : null;
+  }
+  function formatAllocations(count) {
+    return count == null ? "-" : `${count.toLocaleString("en")} objects`;
+  }
+  var ALLOCATIONS_HINT = "Objects allocated by the whole process while this ran: on a multi-threaded server, it includes what other threads allocated meanwhile.";
+
   // app/assets/typescript/profiler/components/toolbar/ToolbarApp.tsx
   function statusClass2(status) {
     if (status >= 200 && status < 300) return "profiler-text--success";
@@ -3903,12 +3913,9 @@
                     " ms"
                   ] })
                 ] }),
-                profile.memory && /* @__PURE__ */ u3("div", { class: "profiler-toolbar-panel-row", children: [
-                  /* @__PURE__ */ u3("span", { children: "Memory" }),
-                  /* @__PURE__ */ u3("strong", { children: [
-                    (profile.memory / 1024 / 1024).toFixed(2),
-                    " MB"
-                  ] })
+                allocatedObjects(profile) != null && /* @__PURE__ */ u3("div", { class: "profiler-toolbar-panel-row", title: ALLOCATIONS_HINT, children: [
+                  /* @__PURE__ */ u3("span", { children: "Allocations" }),
+                  /* @__PURE__ */ u3("strong", { children: formatAllocations(allocatedObjects(profile)) })
                 ] }),
                 /* @__PURE__ */ u3("div", { class: "profiler-toolbar-panel-row", children: [
                   /* @__PURE__ */ u3("span", { children: "Started" }),

data/app/assets/builds/profiler.js

@@ -3994,6 +3994,14 @@
   function getGemVersion() {
     return document.querySelector('meta[name="profiler-version"]')?.content ?? "";
   }
+  function allocatedObjects(profile) {
+    if (profile.allocated_objects != null) return profile.allocated_objects;
+    return profile.memory != null ? Math.round(profile.memory / 40) : null;
+  }
+  function formatAllocations(count) {
+    return count == null ? "-" : `${count.toLocaleString("en")} objects`;
+  }
+  var ALLOCATIONS_HINT = "Objects allocated by the whole process while this ran: on a multi-threaded server, it includes what other threads allocated meanwhile.";
 
   // app/assets/typescript/profiler/components/dashboard/tabs/shared/utils.ts
   function methodBadge(method) {
@@ -5556,10 +5564,6 @@
   function formatTime(iso) {
     return new Date(iso).toLocaleTimeString("en", { hour12: false });
   }
-  function formatMemory(bytes) {
-    if (!bytes) return "-";
-    return (bytes / 1024 / 1024).toFixed(2) + " MB";
-  }
   var PRESETS = [
     { key: "slow", label: "Slow" },
     { key: "many_queries", label: "Many queries" },
@@ -5797,8 +5801,8 @@
           bv = b.duration;
           break;
         case "memory":
-          av = a3.memory ?? 0;
-          bv = b.memory ?? 0;
+          av = allocatedObjects(a3) ?? 0;
+          bv = allocatedObjects(b) ?? 0;
           break;
         case "status":
           av = a3.status;
@@ -6043,8 +6047,8 @@
                   "Queries ",
                   sortIcon(httpSort.col, httpSort.dir, "queries")
                 ] }),
-                /* @__PURE__ */ u3("th", { class: `sortable${httpSort.col === "memory" ? " sortable--active" : ""}`, onClick: () => toggleHttpSort("memory"), children: [
-                  "Memory ",
+                /* @__PURE__ */ u3("th", { class: `sortable${httpSort.col === "memory" ? " sortable--active" : ""}`, onClick: () => toggleHttpSort("memory"), title: ALLOCATIONS_HINT, children: [
+                  "Allocations ",
                   sortIcon(httpSort.col, httpSort.dir, "memory")
                 ] }),
                 /* @__PURE__ */ u3("th", { class: `sortable${httpSort.col === "status" ? " sortable--active" : ""}`, onClick: () => toggleHttpSort("status"), children: [
@@ -6066,7 +6070,7 @@
                   " ms"
                 ] }) }),
                 /* @__PURE__ */ u3("td", { children: p3.collectors_data?.database?.total_queries ?? "\u2014" }),
-                /* @__PURE__ */ u3("td", { children: formatMemory(p3.memory ?? void 0) }),
+                /* @__PURE__ */ u3("td", { children: formatAllocations(allocatedObjects(p3)) }),
                 /* @__PURE__ */ u3("td", { children: /* @__PURE__ */ u3("span", { class: statusClass(p3.status), children: p3.status }) }),
                 /* @__PURE__ */ u3("td", { class: "profiler-text--xs profiler-text--mono profiler-text--muted", children: /* @__PURE__ */ u3("button", { class: "token-copy", onClick: () => copyToken(p3.token), title: "Copy full token", children: copiedToken === p3.token ? "\u2713" : p3.token.substring(0, 8) + "\u2026" }) }),
                 /* @__PURE__ */ u3("td", { children: /* @__PURE__ */ u3("button", { class: "btn-row-delete", onClick: () => deleteProfile2(p3.token), title: "Delete", children: "\xD7" }) })
@@ -6458,9 +6462,36 @@
     parts.push(`  '${url}'`);
     return parts.join(" \\\n");
   }
+  function truncationNotes(profile, routeData) {
+    const notes = [];
+    const describe = (what, truncated, size, minimum) => {
+      if (truncated) {
+        const total = size != null ? `${minimum ? "at least " : ""}${size.toLocaleString("en")} bytes, ` : "";
+        notes.push(`${what} body truncated: ${total}only the beginning was kept (max_captured_body_bytes).`);
+      }
+    };
+    describe(
+      "Request",
+      profile.request_body_truncated ?? routeData.request_body_truncated,
+      profile.request_body_size ?? routeData.request_body_size,
+      profile.request_body_size_is_minimum ?? routeData.request_body_size_is_minimum
+    );
+    describe(
+      "Response",
+      profile.response_body_truncated ?? routeData.response_body_truncated,
+      profile.response_body_size ?? routeData.response_body_size,
+      profile.response_body_size_is_minimum ?? routeData.response_body_size_is_minimum
+    );
+    const releasedAfter = profile.collectors_released_after_seconds ?? routeData.collectors_released_after_seconds;
+    if (releasedAfter != null) {
+      notes.push(`Incomplete profile: the collectors of this stream were released after ${releasedAfter} s, before the server closed it; what it did later is missing.`);
+    }
+    return notes;
+  }
   function RequestTab({ profile }) {
     const routeData = profile.collectors_data?.request ?? {};
     const hasParams = profile.params && Object.keys(profile.params).length > 0;
+    const notes = truncationNotes(profile, routeData);
     return /* @__PURE__ */ u3("div", { class: "profiler-ajax-card profiler-ajax-card--success", style: "margin-bottom:8px;background:var(--profiler-bg-elevated);transform:translateX(3px);box-shadow:var(--profiler-shadow-sm);transition:none", children: [
       /* @__PURE__ */ u3(
         HttpCardHeader,
@@ -6480,6 +6511,7 @@
           routeData.route_pattern
         ] })
       ] }),
+      notes.map((note) => /* @__PURE__ */ u3("div", { class: "profiler-ajax-card__row profiler-text--xs profiler-text--warning", children: note }, note)),
       /* @__PURE__ */ u3(
         HttpReqRespDetail,
         {
@@ -7381,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");
@@ -7690,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";
@@ -7782,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)"
             }
           )
         ] })
@@ -7791,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 (",
@@ -8878,12 +8926,9 @@
             "Status: ",
             /* @__PURE__ */ u3("strong", { children: profile.status })
           ] }),
-          profile.memory && /* @__PURE__ */ u3("span", { children: [
-            "Memory: ",
-            /* @__PURE__ */ u3("strong", { children: [
-              (profile.memory / 1024 / 1024).toFixed(2),
-              " MB"
-            ] })
+          allocatedObjects(profile) != null && /* @__PURE__ */ u3("span", { title: ALLOCATIONS_HINT, children: [
+            "Allocations: ",
+            /* @__PURE__ */ u3("strong", { children: formatAllocations(allocatedObjects(profile)) })
           ] }),
           /* @__PURE__ */ u3("span", { style: "color:var(--profiler-text-muted)", children: new Date(profile.started_at).toLocaleString("en", { hour12: false, month: "short", day: "numeric", hour: "2-digit", minute: "2-digit", second: "2-digit" }) }),
           profile.gem_version && /* @__PURE__ */ u3("span", { class: "profiler-version-badge", children: [
@@ -9038,12 +9083,9 @@
             "Status: ",
             /* @__PURE__ */ u3("strong", { children: /* @__PURE__ */ u3("span", { class: `badge-${isFailed ? "error" : "success"}`, children: isFailed ? "Failed" : "Completed" }) })
           ] }),
-          profile.memory != null && /* @__PURE__ */ u3("span", { children: [
-            "Memory: ",
-            /* @__PURE__ */ u3("strong", { children: [
-              (profile.memory / 1024 / 1024).toFixed(2),
-              " MB"
-            ] })
+          allocatedObjects(profile) != null && /* @__PURE__ */ u3("span", { title: ALLOCATIONS_HINT, children: [
+            "Allocations: ",
+            /* @__PURE__ */ u3("strong", { children: formatAllocations(allocatedObjects(profile)) })
           ] }),
           profile.gem_version && /* @__PURE__ */ u3("span", { class: "profiler-version-badge", children: [
             "v",
@@ -9170,12 +9212,9 @@
             "Status: ",
             /* @__PURE__ */ u3("strong", { children: /* @__PURE__ */ u3("span", { class: `badge-${isFailed ? "error" : "success"}`, children: isFailed ? "Error" : "OK" }) })
           ] }),
-          profile.memory != null && /* @__PURE__ */ u3("span", { children: [
-            "Memory: ",
-            /* @__PURE__ */ u3("strong", { children: [
-              (profile.memory / 1024 / 1024).toFixed(2),
-              " MB"
-            ] })
+          allocatedObjects(profile) != null && /* @__PURE__ */ u3("span", { title: ALLOCATIONS_HINT, children: [
+            "Allocations: ",
+            /* @__PURE__ */ u3("strong", { children: formatAllocations(allocatedObjects(profile)) })
           ] }),
           profile.gem_version && /* @__PURE__ */ u3("span", { class: "profiler-version-badge", children: [
             "v",
@@ -9300,12 +9339,9 @@
             "Status: ",
             /* @__PURE__ */ u3("strong", { children: /* @__PURE__ */ u3("span", { class: `badge-${isFailed ? "error" : testStatus === "pending" ? "warning" : "success"}`, children: testStatus === "failed" ? "\u2717 Failed" : testStatus === "pending" ? "\u23F8 Pending" : "\u2713 Passed" }) })
           ] }),
-          profile.memory != null && /* @__PURE__ */ u3("span", { children: [
-            "Memory: ",
-            /* @__PURE__ */ u3("strong", { children: [
-              (profile.memory / 1024 / 1024).toFixed(2),
-              " MB"
-            ] })
+          allocatedObjects(profile) != null && /* @__PURE__ */ u3("span", { title: ALLOCATIONS_HINT, children: [
+            "Allocations: ",
+            /* @__PURE__ */ u3("strong", { children: formatAllocations(allocatedObjects(profile)) })
           ] })
         ] }),
         testData?.test_file && /* @__PURE__ */ u3("div", { class: "profiler-text--xs profiler-text--muted profiler-mt-2", children: [

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/allocation_counter.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Profiler
+  # What every profile reports as allocated_objects: the number of objects Ruby allocated
+  # between two readings. GC.stat has no byte count of allocations (no :total_allocated_size on
+  # the supported Rubies), so none is reported.
+  #
+  # The counter belongs to the process, not to the thread: on a multi-threaded server, or with
+  # jobs running alongside, the figure includes what the other threads allocated meanwhile.
+  module AllocationCounter
+    # The bytes per object that profiles saved by earlier versions multiplied the count by, as
+    # `memory`: kept to read them back, and to keep writing that field for older readers.
+    LEGACY_BYTES_PER_OBJECT = 40
+
+    module_function
+
+    def current
+      GC.stat(:total_allocated_objects)
+    end
+  end
+end

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
@@ -71,6 +72,36 @@ module Profiler
         # Override in subclasses to collect data
       end
 
+      # Whether collect reads nothing from the request's thread (thread-local slots, the
+      # locale): only then can a streamed response keep the collector subscribed until the
+      # server closes its body, and collect it from whichever thread closes it. The default
+      # is the safe answer: collected on the request's thread when the application returns.
+      def collect_from_any_thread?
+        false
+      end
+
+      # Gives back the thread-local slots subscribe took over, and nothing else: a streamed
+      # response does this on the request's thread when the application returns, and keeps the
+      # notification subscriptions until its body is closed. Idempotent, like unsubscribe.
+      def release_thread_slots
+        restore_thread_slots
+      end
+
+      # Puts the slots subscribe claimed back, for a while, on the thread (or fiber) that
+      # iterates a streamed body: the logs, outbound HTTP calls and measures it makes belong to
+      # this profile. Returns what the slots held there, for return_thread_slots.
+      def lend_thread_slots
+        (@thread_slot_values || {}).to_h do |key, value|
+          previous = Thread.current[key]
+          Thread.current[key] = value
+          [key, previous]
+        end
+      end
+
+      def return_thread_slots(previous)
+        previous&.each { |key, value| Thread.current[key] = value }
+      end
+
       def toolbar_summary
         # Override in subclasses to provide summary for toolbar
         ""
@@ -104,6 +135,7 @@ module Profiler
       def claim_thread_slot(key, value)
         @claimed_thread_slots ||= {}
         @claimed_thread_slots[key] = Thread.current[key] unless @claimed_thread_slots.key?(key)
+        (@thread_slot_values ||= {})[key] = value
         Thread.current[key] = value
       end
 
@@ -112,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],
@@ -82,6 +82,11 @@ module Profiler
         store_data(data)
       end
 
+      # Collect reads only what the collector gathered itself.
+      def collect_from_any_thread?
+        true
+      end
+
       def unsubscribe
         unsubscribe_notifications(@subscriptions)
       end