rails-profiler 0.32.3 → 0.33.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 97fa343641a35a6bb20283e405ed8955b7039d4da924a7ce4195feeaeffacec6
-  data.tar.gz: d7f9d92015e47e0f20c2b344e2d297b169fcf5d9b184aad17f8d3c68f109f5f2
+  metadata.gz: d632e07d28796ba7902cd20f9466b4c529c77ab76b5627c2b946e6b059b23c1f
+  data.tar.gz: 7c91607d3ae24180f6708938a8dfa118ad297b11a6b9749cf155adeef5b81336
 SHA512:
-  metadata.gz: cd484fea1576a382bc4a6ecef0a39bad2d25b0197d672c62b41e83fed0ef39dfbaf96e8d6100d9d34ed8fca48d765dacbf97099b8963f505503cfc56058be646
-  data.tar.gz: de36e884fb0fd828d6d498c93858c73998762ec5823c7be1806897bd66ab36a97e61c2a1aa9d5a854694a6d184495855c812afcc0b6646cfe5318aac0f0dd037
+  metadata.gz: a7781894a3b105e730d47d63c0e7a2a15b28a58a51a38fc4662fb193c0665c1cdb8fd7072cadc7926f38a96e6a68a350ae19f16ef2560a119c89355fdbe3f4a6
+  data.tar.gz: e626c7d2d344ad58473fdecbbbaf3bfae340faf17eb1dd25ca7f88325ffe87c9a9837fefcdc9b1dea3cdc3541ce46a4156d1d4b17acd3f4b049defd2c08fcd03

data/CHANGELOG.md

@@ -19,6 +19,55 @@ every commit of every tag interval is accounted for one way or the other.
 
 ## [Unreleased]
 
+## [0.33.1] - 2026-10-14
+
+<!-- stamped -->
+
+### Fixed
+
+- **Packaging:** The published gem now contains `app/assets/javascript/profiler-ajax-interceptor.js`,
+  the script the toolbar injects to link the `fetch`, `XMLHttpRequest` and Turbo requests of a page
+  to that page. It was missing from every published version: with the gem installed from a
+  registry, those requests were never linked to their page, and the only trace was the log line
+  `ToolbarInjector: could not load the AJAX interceptor script`. A gem used from a git checkout or
+  a local path was not affected.
+- **Release:** A version is now published only once both test suites (Ruby 3.3 and 3.4) have
+  passed, as written in the `needs` of the `release` and `canary` jobs, and once the built gem
+  has been installed and found to carry every file it reads at run time. The suites already held
+  publication back before, but only through the order of the pipeline stages.
+
+## [0.33.0] - 2026-10-14
+
+<!-- stamped -->
+
+### Added
+
+- **AJAX:** Requests made by Turbo (Hotwire) for a `<turbo-frame>`, and requests answered with
+  Turbo Stream actions, carry a `FRAME` or `STREAM` badge in the AJAX panel of the toolbar and in
+  the AJAX tab of the dashboard. The AJAX data of a page in the API gives each request a `turbo`
+  field: `frame`, `stream` or `null`. The MCP tool `get_profile_ajax` gives the same kind on a
+  `Turbo` line of each Turbo request, and none for a plain fetch. The Request tab of a frame
+  request shows its `Turbo-Frame` header.
+
+### Fixed
+
+- **AJAX:** A Turbo Drive visit is no longer listed as an AJAX request of the page it leaves,
+  and neither is a link Turbo prefetches on hover: they are the next page, with their own
+  profile. The requests a page reached by a Drive visit makes are linked to that page instead of
+  to the first page of the session.
+- **Toolbar:** After a Turbo Drive visit, the toolbar of the previous page is taken down: it no
+  longer keeps checking for updates of the previous profile, and `Alt+P` toggles the toolbar
+  once instead of once per page visited.
+
+### Limitations
+
+- **Toolbar:** A Turbo 8 page refresh with morphing (`turbo_refreshes_with method: :morph`, or
+  a `broadcasts_refreshes` model) is not handled: it empties the toolbar, which keeps checking
+  for updates of the profile of the page as first loaded, and the requests made after it stay
+  linked to that profile. This predates this release and is left for a later one.
+- **Toolbar:** After going back in the browser history, two toolbar containers are left in the
+  page, only one of them visible. This predates this release too.
+
 ## [0.32.3] - 2026-10-14
 
 <!-- stamped -->

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

@@ -3356,6 +3356,10 @@
     };
     return map[method] || "";
   }
+  var TURBO_TITLES = {
+    frame: "Turbo Frame request",
+    stream: "Turbo Stream response"
+  };
   function AjaxPanel({ ajaxData }) {
     return /* @__PURE__ */ u3(k, { children: [
       /* @__PURE__ */ u3("div", { class: "profiler-toolbar-panel-header", children: [
@@ -3373,6 +3377,7 @@
           return /* @__PURE__ */ u3("div", { class: `profiler-ajax-card ${statusCls}`, children: /* @__PURE__ */ u3("div", { class: "profiler-ajax-card__row", children: [
             /* @__PURE__ */ u3("div", { class: "profiler-flex profiler-flex--gap-2", children: [
               /* @__PURE__ */ u3("span", { class: `badge ${methodBadgeClass(req.method)}`, children: req.method }),
+              req.turbo && /* @__PURE__ */ u3("span", { class: "badge badge-default", title: TURBO_TITLES[req.turbo], children: req.turbo.toUpperCase() }),
               /* @__PURE__ */ u3("span", { class: "profiler-text--xs profiler-text--truncate", children: req.path })
             ] }),
             /* @__PURE__ */ u3("div", { class: "profiler-flex profiler-flex--gap-2", children: [
@@ -4367,14 +4372,26 @@
     if (!el || !toggleEl) return;
     const token = el.dataset.token;
     if (!token) return;
+    window.__PROFILER_TOOLBAR_TEARDOWN__?.();
+    const listeners = new AbortController();
+    const { signal } = listeners;
+    const teardown = () => {
+      listeners.abort();
+      J(null, el);
+      if (window.__PROFILER_TOOLBAR_TEARDOWN__ === teardown) delete window.__PROFILER_TOOLBAR_TEARDOWN__;
+    };
+    window.__PROFILER_TOOLBAR_TEARDOWN__ = teardown;
+    document.addEventListener("turbo:load", () => {
+      if (!el.isConnected) teardown();
+    }, { signal });
     const themeEls = [el, toggleEl];
     applyTheme(themeEls);
     window.addEventListener("storage", (e3) => {
       if (e3.key === "profiler-theme") applyTheme(themeEls);
-    });
+    }, { signal });
     window.addEventListener("profiler:theme-change", ((e3) => {
       if (e3.detail?.theme) themeEls.forEach((elem) => elem.setAttribute("data-theme", e3.detail.theme));
-    }));
+    }), { signal });
     let isCollapsed = localStorage.getItem("profiler-toolbar-collapsed") === "true";
     toggleEl.dataset.collapsed = String(isCollapsed);
     if (isCollapsed && !el.style.transform) {
@@ -4406,13 +4423,13 @@
         }, ANIM_MS + 50);
       }
     }
-    toggleEl.addEventListener("click", toggleCollapse);
+    toggleEl.addEventListener("click", toggleCollapse, { signal });
     document.addEventListener("keydown", (e3) => {
       if (e3.altKey && e3.key === "p") {
         e3.preventDefault();
         toggleCollapse();
       }
-    });
+    }, { signal });
     J(
       /* @__PURE__ */ u3(QueryClientProvider, { client: toolbarQueryClient, children: /* @__PURE__ */ u3(ToolbarMount, { token }) }),
       el

data/app/assets/builds/profiler.js

@@ -8173,6 +8173,10 @@
   }
 
   // app/assets/typescript/profiler/components/dashboard/tabs/AjaxTab.tsx
+  var TURBO_TITLES = {
+    frame: "Turbo Frame request",
+    stream: "Turbo Stream response"
+  };
   function AjaxTab({ ajaxData }) {
     if (!ajaxData?.requests?.length) {
       return /* @__PURE__ */ u3("div", { class: "profiler-empty", children: [
@@ -8225,6 +8229,7 @@
         /* @__PURE__ */ u3("div", { class: "profiler-ajax-card__row", children: [
           /* @__PURE__ */ u3("div", { class: "profiler-flex profiler-flex--gap-3", children: [
             /* @__PURE__ */ u3("span", { class: `profiler-ajax-card__method badge-${methodBadge(req.method)}`, children: req.method }),
+            req.turbo && /* @__PURE__ */ u3("span", { class: "badge-default", title: TURBO_TITLES[req.turbo], children: req.turbo.toUpperCase() }),
             /* @__PURE__ */ u3("strong", { class: "profiler-ajax-card__path", children: req.path })
           ] }),
           /* @__PURE__ */ u3("div", { class: "profiler-flex profiler-flex--gap-2", children: [

data/app/assets/javascript/profiler-ajax-interceptor.js

@@ -0,0 +1,193 @@
+// Profiler AJAX Request Interceptor
+// This script intercepts fetch() and XMLHttpRequest calls to link AJAX requests to their parent page
+
+(function() {
+  'use strict';
+
+  // Get parent token from window variable set by the profiler
+  if (!window.__PROFILER_PARENT_TOKEN__) {
+    console.warn('[Profiler] Parent token not found, AJAX tracking disabled');
+    return;
+  }
+
+  // Check if already intercepted (by Chrome extension or another script)
+  if (window.__PROFILER_INTERCEPTOR_ACTIVE__) {
+    console.debug('[Profiler] Interceptor already active, skipping');
+    return;
+  }
+  window.__PROFILER_INTERCEPTOR_ACTIVE__ = true;
+
+  // Save references to originals (they might already be wrapped by extension)
+  const originalFetch = window.fetch;
+  const originalXHROpen = XMLHttpRequest.prototype.open;
+  const originalXHRSend = XMLHttpRequest.prototype.send;
+  const pendingXHRRequests = new WeakMap();
+  // The fetches Turbo makes, by the AbortSignal it hands to fetch(): { frame: true } when the
+  // request loads a <turbo-frame>.
+  const turboRequests = new WeakMap();
+  const TURBO_STREAM_MIME = 'text/vnd.turbo-stream.html';
+
+  // The page the sub-requests belong to. Read at each link, not once: a Turbo Drive visit
+  // renders a new page, whose inline script sets the token again, without reloading this one.
+  function currentParentToken() {
+    return window.__PROFILER_PARENT_TOKEN__;
+  }
+
+  function isRequest(input) {
+    return typeof Request !== 'undefined' && input instanceof Request;
+  }
+
+  function hasHeader(headers, name) {
+    if (!headers) return false;
+    if (typeof headers.has === 'function') return headers.has(name);
+    const wanted = name.toLowerCase();
+    return Object.keys(headers).some(key => key.toLowerCase() === wanted && headers[key] != null && headers[key] !== '');
+  }
+
+  // Turbo (7 and 8) announces each of its requests before calling fetch(), with the options it
+  // will pass to it, signal included.
+  document.addEventListener('turbo:before-fetch-request', function(event) {
+    const options = event.detail && event.detail.fetchOptions;
+    if (!options || !options.signal) return;
+    turboRequests.set(options.signal, { frame: hasHeader(options.headers, 'Turbo-Frame') });
+  });
+
+  // A Turbo Drive visit, a prefetch on hover, or a form submission answered with a page is the
+  // next page, which carries its own toolbar: not a sub-request of this one. A <turbo-frame>
+  // load, and any request answered with Turbo Stream actions, update this page: they are.
+  function isNavigation(args, response) {
+    const init = args[1];
+    const signal = (init && init.signal) || (isRequest(args[0]) ? args[0].signal : null);
+    const turbo = signal && turboRequests.get(signal);
+    if (!turbo || turbo.frame) return false;
+
+    const contentType = response.headers.get('Content-Type') || '';
+    return !contentType.startsWith(TURBO_STREAM_MIME);
+  }
+
+  // Helper function to check if path should be skipped
+  function shouldSkipPath(url) {
+    try {
+      const urlObj = new URL(url, window.location.origin);
+      const path = urlObj.pathname;
+
+      // Skip profiler's own requests
+      if (path.startsWith('/_profiler')) {
+        return true;
+      }
+
+      return false;
+    } catch (e) {
+      return false;
+    }
+  }
+
+  // Helper function to link child profile to parent
+  function linkChildProfile(childToken) {
+    const parentToken = currentParentToken();
+    if (!childToken || !parentToken) return;
+
+    console.debug('[Profiler] Linking AJAX request:', { parent: parentToken, child: childToken });
+
+    // Post to the link API endpoint
+    const linkUrl = '/_profiler/api/ajax/link';
+    const body = JSON.stringify({
+      parent_token: parentToken,
+      child_token: childToken
+    });
+
+    // Use original fetch to avoid infinite loop
+    originalFetch.call(window, linkUrl, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'Accept': 'application/json',
+        'X-Profiler-Request': '1'
+      },
+      body: body
+    }).then(response => {
+      if (response.ok) {
+        // Refresh toolbar after successful link (with small delay to let backend process)
+        setTimeout(() => {
+          if (typeof window.__PROFILER_REFRESH_TOOLBAR__ === 'function') {
+            window.__PROFILER_REFRESH_TOOLBAR__();
+          }
+        }, 100);
+      }
+    }).catch(err => {
+      // Fail silently - don't break the page if profiler API fails
+      console.debug('[Profiler] Failed to link AJAX request:', err);
+    });
+  }
+
+  // Listen for events from Chrome extension (if installed)
+  window.addEventListener('__profilerRequest', function(event) {
+    const { token } = event.detail;
+    if (token) {
+      console.debug('[Profiler] Received profiler event from extension:', token);
+      linkChildProfile(token);
+    }
+  });
+
+  // Override fetch()
+  window.fetch = async function(...args) {
+    const url = isRequest(args[0]) ? args[0].url : String(args[0]);
+
+    // Skip profiler paths
+    if (shouldSkipPath(url)) {
+      return originalFetch.apply(this, args);
+    }
+
+    try {
+      const response = await originalFetch.apply(this, args);
+
+      // Extract profiler token from response headers
+      const profilerToken = response.headers.get('X-Profiler-Token');
+
+      if (profilerToken && !isNavigation(args, response)) {
+        linkChildProfile(profilerToken);
+      }
+
+      return response;
+    } catch (error) {
+      throw error;
+    }
+  };
+
+  // Override XMLHttpRequest.open()
+  XMLHttpRequest.prototype.open = function(method, url, ...args) {
+    const urlString = typeof url === 'string' ? url : url.toString();
+
+    // Store request metadata
+    pendingXHRRequests.set(this, {
+      url: urlString,
+      method: method,
+      timestamp: Date.now()
+    });
+
+    return originalXHROpen.apply(this, [method, url, ...args]);
+  };
+
+  // Override XMLHttpRequest.send()
+  XMLHttpRequest.prototype.send = function(...args) {
+    const requestData = pendingXHRRequests.get(this);
+
+    // Skip profiler paths
+    if (requestData && shouldSkipPath(requestData.url)) {
+      return originalXHRSend.apply(this, args);
+    }
+
+    // Add load event listener to capture response
+    this.addEventListener('load', function() {
+      const profilerToken = this.getResponseHeader('X-Profiler-Token');
+
+      if (profilerToken && requestData) {
+        linkChildProfile(profilerToken);
+      }
+    });
+
+    return originalXHRSend.apply(this, args);
+  };
+
+  console.debug('[Profiler] AJAX interceptor initialized with parent token:', currentParentToken());
+})();

data/lib/profiler/collectors/ajax_collector.rb

@@ -105,9 +105,30 @@ module Profiler
           "method" => profile.method,
           "status" => profile.status,
           "duration" => profile.duration,
-          "started_at" => profile.started_at&.iso8601
+          "started_at" => profile.started_at&.iso8601,
+          "turbo" => turbo_kind(profile)
         }
       end
+
+      TURBO_STREAM_MIME = "text/vnd.turbo-stream.html"
+
+      # "frame" for a request a <turbo-frame> made (Turbo sends its id in Turbo-Frame), "stream"
+      # for one answered with Turbo Stream actions, nil for any other fetch or XHR.
+      def turbo_kind(profile)
+        return "frame" if header_value(profile.headers, "Turbo-Frame").to_s != ""
+        return "stream" if header_value(profile.response_headers, "Content-Type").to_s.start_with?(TURBO_STREAM_MIME)
+
+        nil
+      end
+
+      # Header names keep the case they were saved with: Content-Type from Rack 2, content-type
+      # from Rack 3.
+      def header_value(headers, name)
+        return nil unless headers.respond_to?(:each)
+
+        headers.each { |key, value| return value if key.to_s.casecmp?(name) }
+        nil
+      end
     end
   end
 end

data/lib/profiler/mcp/tools/get_profile_ajax.rb

@@ -61,6 +61,7 @@ module Profiler
               lines << "- **Path:** #{req['path']}"
               lines << "- **Status:** #{req['status']}"
               lines << "- **Duration:** #{req['duration'].round(2)} ms"
+              lines << "- **Turbo:** #{req['turbo']}" if req['turbo']
               lines << "- **Token:** #{req['token']}" if req['token']
               lines << "- **Started At:** #{req['started_at']}" if req['started_at']
             end

data/lib/profiler/models/profile.rb

@@ -346,7 +346,7 @@ module Profiler
         Accept Accept-Charset Accept-Encoding Accept-Language
         Authorization Cache-Control Connection Content-Length Content-Type
         Cookie Host If-Modified-Since If-None-Match Origin
-        Referer User-Agent
+        Referer User-Agent Turbo-Frame
       ].freeze
 
       def extract_headers(env)

data/lib/profiler/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Profiler
-  VERSION = "0.32.3"
+  VERSION = "0.33.1"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rails-profiler
 version: !ruby/object:Gem::Version
-  version: 0.32.3
+  version: 0.33.1
 platform: ruby
 authors:
 - Sébastien Duplessy
@@ -109,6 +109,7 @@ files:
 - app/assets/builds/profiler-toolbar.js
 - app/assets/builds/profiler.css
 - app/assets/builds/profiler.js
+- app/assets/javascript/profiler-ajax-interceptor.js
 - app/controllers/profiler/api/ajax_controller.rb
 - app/controllers/profiler/api/cluster_controller.rb
 - app/controllers/profiler/api/console_controller.rb