rails-profiler 0.33.0 → 0.33.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4dc81c1f51aaa36f9a01703962763e6526c95ea44a86aec0f6580a46c6239bfe
-  data.tar.gz: 1555289065c0d81d6267b21ddb9d3ae2c2c0716e1290f33e30df30590ff4b8c9
+  metadata.gz: d632e07d28796ba7902cd20f9466b4c529c77ab76b5627c2b946e6b059b23c1f
+  data.tar.gz: 7c91607d3ae24180f6708938a8dfa118ad297b11a6b9749cf155adeef5b81336
 SHA512:
-  metadata.gz: 967050b5160cb75653481fd86444696cb81fa84c46aa7faa34064a3c281c0acaa5ec08d4029a8b1aca2525da8ffb5d0033b934025d885a8b53e969faca151293
-  data.tar.gz: e63d49ccaf002fb7b4911920fc3e279597451fa276d669f557fde971e13e2855cbc347cc16bf254ff2d995b14ba0c18454e929910326a41d0104ee83db49c327
+  metadata.gz: a7781894a3b105e730d47d63c0e7a2a15b28a58a51a38fc4662fb193c0665c1cdb8fd7072cadc7926f38a96e6a68a350ae19f16ef2560a119c89355fdbe3f4a6
+  data.tar.gz: e626c7d2d344ad58473fdecbbbaf3bfae340faf17eb1dd25ca7f88325ffe87c9a9837fefcdc9b1dea3cdc3541ce46a4156d1d4b17acd3f4b049defd2c08fcd03

data/CHANGELOG.md

@@ -19,6 +19,23 @@ 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 -->

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

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rails-profiler
 version: !ruby/object:Gem::Version
-  version: 0.33.0
+  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