rails-profiler 0.33.0 → 0.33.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4dc81c1f51aaa36f9a01703962763e6526c95ea44a86aec0f6580a46c6239bfe
-  data.tar.gz: 1555289065c0d81d6267b21ddb9d3ae2c2c0716e1290f33e30df30590ff4b8c9
+  metadata.gz: 8e1caccb1662a8f09108682f5933e943d41a0b36ed7d60930c60eb8c385b5159
+  data.tar.gz: c10d767853cc07caa36484f9693a4c4adeef415e0874d29ca817d8d7d1b17730
 SHA512:
-  metadata.gz: 967050b5160cb75653481fd86444696cb81fa84c46aa7faa34064a3c281c0acaa5ec08d4029a8b1aca2525da8ffb5d0033b934025d885a8b53e969faca151293
-  data.tar.gz: e63d49ccaf002fb7b4911920fc3e279597451fa276d669f557fde971e13e2855cbc347cc16bf254ff2d995b14ba0c18454e929910326a41d0104ee83db49c327
+  metadata.gz: 8aacfc0469f52d9f6a11a58356eebb853ff716f2729ca47833b9b0ca99197f767a0dad5904f8c9e7d8a8501869dd712a0c5e6e246fa8ea0e55976b546589d1ac
+  data.tar.gz: 3ce33e8db95c0ae4028a68e11d941bb72072b5a6edcf539cfc0fb918c2248d675c4df92e28788da0d59d942546458384b22ec5ac974bb58404be1d0049130627

data/CHANGELOG.md

@@ -19,6 +19,64 @@ every commit of every tag interval is accounted for one way or the other.
 
 ## [Unreleased]
 
+## [0.33.2] - 2026-10-14
+
+<!-- stamped -->
+
+### Changed
+
+- **Configuration:** A String in `config.http_skip_hosts` is now a host name, compared whole and
+  ignoring case, instead of a pattern: `"example.com"` no longer leaves out `notexample.com`,
+  `exampleXcom` or `example.com.attacker.net`. A String that starts with a dot is a domain whose
+  subdomains are left out (`".internal"` leaves out `api.internal`). A Regexp is matched as
+  before. An entry that is not a host name, a wildcard String (`"*.internal"`), an empty one, or
+  anything that is neither a String nor a Regexp (`nil`), is left out when the list is set, with
+  a warning in the log that says what to write, and the other entries are kept. It does not
+  raise: the gem is loaded in production too, where a mistake in this list must not stop the
+  application from booting, even with the profiler disabled.
+- **Dumps:** A dump is stored as its formatted text only: the raw `value` field, which no tab
+  read and the API did not document, is no longer part of the dump data.
+
+### Fixed
+
+- **Configuration:** A String in `config.skip_paths` no longer fails every request with a
+  `TypeError`: it skips the path equal to it, and a Regexp is matched as before. A single
+  pattern, a String or a Regexp, set without a list is read as a list of one.
+- **Outbound HTTP:** A String in `config.http_skip_hosts` that is not a valid Regexp, such as
+  `"*.internal"` added with `<<`, no longer fails every `Net::HTTP` call of a profiled request
+  with a `RegexpError`.
+- **Database:** A query that binds bytes, a `blob` or `bytea` column such as an image, no longer
+  loses the profile of its request when it is saved: the bind shows as text when its bytes are
+  valid UTF-8, and as `[binary data, N bytes]` otherwise.
+- **Logs:** A line logged with bytes that are not valid UTF-8 no longer raises an
+  `Encoding::CompatibilityError` in the application's own logger call (Rails 7.1 and later), and
+  a binary line no longer loses the profile when it is saved: the line is kept as UTF-8, what
+  cannot be read replaced with U+FFFD, and a line in another encoding is converted.
+- **Dumps:** `Profiler.dump` of an object that refers to itself, directly or through an instance
+  variable, no longer fails the request with a `SystemStackError` (a 500 with the file store), and
+  an Array or a Hash holding itself no longer loses the profile. An object whose own `inspect`
+  recurses without end shows `[Error formatting value: stack level too deep]`.
+- **Middleware:** A page whose body is made of fragments of different encodings, a binary one
+  among UTF-8 ones, no longer fails with an `Encoding::CompatibilityError` once profiled: its
+  bytes are joined as the application gave them, and it gets its toolbar.
+
+## [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/collectors/database_collector.rb

@@ -9,6 +9,8 @@ module Profiler
       BACKTRACE_DEPTH = 10
       MAX_SCANNED_FRAMES = 100
       FRAMES_PAST_APPLICATION = 15
+      # What a bind holding bytes that are not text shows instead (see #displayable_bind).
+      BINARY_BIND = "[binary data, %d bytes]"
 
 
       # Frames between the application's code and the subscriber: the profiler itself, the
@@ -122,9 +124,9 @@ module Profiler
         binds.map do |bind|
           if bind.respond_to?(:value)
             name = bind.name if bind.respond_to?(:name)
-            Profiler::Redaction.filter_named(name, bind.value)
+            displayable_bind(Profiler::Redaction.filter_named(name, bind.value))
           else
-            bind
+            displayable_bind(bind)
           end
         end
       rescue StandardError
@@ -132,6 +134,18 @@ module Profiler
         binds.map { Profiler::Redaction::MASK }
       end
 
+      # A blob or bytea value is bytes, not text: kept as it is, it fails the JSON of the whole
+      # profile when it is saved. Bytes that are valid UTF-8 are shown as text, others as their
+      # size. Text in another encoding stays as it is: JSON converts it.
+      def displayable_bind(value)
+        value = value.to_s if defined?(ActiveModel::Type::Binary::Data) && value.is_a?(ActiveModel::Type::Binary::Data)
+        return value unless value.is_a?(String)
+        return value if value.valid_encoding? && value.encoding != Encoding::BINARY
+
+        utf8 = value.dup.force_encoding(Encoding::UTF_8)
+        utf8.valid_encoding? ? utf8 : format(BINARY_BIND, value.bytesize)
+      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.

data/lib/profiler/collectors/dump_collector.rb

@@ -33,9 +33,10 @@ module Profiler
         dumps = @dumps || Thread.current[:profiler_dumps] || []
         unsubscribe
 
+        # Only the formatted text is kept: the object itself can refer to itself, or hold what
+        # JSON cannot write, and would make the profile fail when it is saved.
         formatted_dumps = dumps.map do |dump|
           {
-            value: dump[:value],
             formatted: format_value(dump[:value]),
             file: dump[:file],
             line: dump[:line],
@@ -97,7 +98,8 @@ module Profiler
           formatted += ">"
           formatted
         end
-      rescue => e
+      # An inspect of the application's that recurses without end is said, like any other error.
+      rescue StandardError, SystemStackError => e
         "[Error formatting value: #{e.message}]"
       end
     end

data/lib/profiler/collectors/log_collector.rb

@@ -68,7 +68,7 @@ module Profiler
 
           entry = {
             level: SEVERITY_LABELS[severity] || "UNKNOWN",
-            message: msg.to_s.strip,
+            message: self.class.readable(msg.to_s).strip,
             timestamp: Time.now.iso8601(3)
           }
           logs.respond_to?(:record) ? logs.record(entry) : logs << entry
@@ -78,6 +78,20 @@ module Profiler
         def <<(msg)
           add(0, msg.to_s)
         end
+
+        # The line as valid UTF-8, a copy when it has to change: bytes that are not text in its
+        # encoding would raise in strip, inside the application's own logger call, or fail the
+        # JSON of the profile when it is saved. Binary bytes are read as UTF-8; a line in another
+        # encoding is converted. What cannot be read becomes U+FFFD.
+        def self.readable(text)
+          return text if text.encoding == Encoding::UTF_8 && text.valid_encoding?
+
+          if [Encoding::UTF_8, Encoding::BINARY, Encoding::US_ASCII].include?(text.encoding)
+            text.dup.force_encoding(Encoding::UTF_8).scrub
+          else
+            text.encode(Encoding::UTF_8, invalid: :replace, undef: :replace)
+          end
+        end
       end
 
       def icon

data/lib/profiler/configuration.rb

@@ -38,13 +38,13 @@ module Profiler
     LOCAL_HTTP_HOSTS = [/\A127\.0\.0\.1\z/, /\Alocalhost\z/i, /\A::1\z/].freeze
 
     attr_accessor :storage_options, :collectors,
-                  :skip_paths, :slow_query_threshold, :max_queries_warning, :sql_backtrace,
+                  :slow_query_threshold, :max_queries_warning, :sql_backtrace,
                   :track_memory, :allocated_objects_warning_threshold,
                   :mcp_enabled, :mcp_transport, :mcp_port,
                   :authorization_mode, :extension_cors_enabled,
                   :cors_allowed_origins, :api_forgery_protection, :frame_ancestors,
                   :track_ajax, :ajax_skip_paths,
-                  :track_http, :slow_http_threshold, :http_skip_hosts, :http_backtrace_depth,
+                  :track_http, :slow_http_threshold, :http_backtrace_depth,
                   :track_jobs,
                   :track_console,
                   :apply_env_overrides_when_disabled, :restrict_storage_permissions,
@@ -148,7 +148,23 @@ module Profiler
       @tmp_path = value.nil? ? nil : Pathname.new(value)
     end
 
-    attr_reader :cluster_allowed_slave_urls, :mcp_allowed_hosts
+    attr_reader :cluster_allowed_slave_urls, :mcp_allowed_hosts, :skip_paths, :http_skip_hosts
+
+    # Paths that are not profiled: a Regexp matched against the path, or a String equal to it.
+    # A single pattern is a list of one.
+    def skip_paths=(value)
+      @skip_paths = Array(value)
+    end
+
+    # Hosts whose outbound calls are left out: a String is a host name, matched whole and
+    # case-insensitively, or, when it starts with a dot (".internal"), a domain whose subdomains
+    # are left out; a Regexp is matched against the host name. Any other entry (a wildcard
+    # "*.internal", an empty String, nil) is left out with a warning in the log, the others kept:
+    # the gem is loaded in production too, where a mistake here must not stop the application
+    # from booting.
+    def http_skip_hosts=(value)
+      @http_skip_hosts = Array(value).select { |entry| valid_http_skip_host?(entry) }
+    end
 
     # Host names the MCP HTTP endpoint accepts beyond the loopback ones and config.hosts: a String
     # (a host name, any port, or a host:port) or a Regexp anchored with \A and \z, matched
@@ -323,6 +339,22 @@ module Profiler
       end
     end
 
+    def valid_http_skip_host?(entry)
+      problem =
+        case entry
+        when Regexp then nil
+        when String
+          if entry.strip.empty? || entry.match?(/[*\s]/)
+            "is not a host name; list each host, a domain as \".internal\" for its subdomains, or use a Regexp"
+          end
+        else "must be a String or a Regexp"
+        end
+      return true unless problem
+
+      Profiler.log_warn("config.http_skip_hosts: #{entry.inspect} #{problem}; ignored")
+      false
+    end
+
     def validate_mcp_allowed_host_pattern(pattern)
       unless Profiler::Cluster::Security.anchored_pattern?(pattern)
         raise ArgumentError, "config.mcp_allowed_hosts: #{pattern.inspect} must start with \\A and end with \\z, " \

data/lib/profiler/instrumentation/net_http_instrumentation.rb

@@ -122,12 +122,29 @@ module Profiler
       # it are the profiler's, whichever code makes them.
       def self.skip_host?(host, port = nil)
         config = Profiler.configuration
-        return true if config.http_skip_hosts.any? { |pattern| host.match?(pattern) }
+        return true if config.http_skip_hosts.any? { |pattern| skip_host_pattern?(pattern, host) }
 
         master = master_address(config.master_url)
         !master.nil? && master[0].casecmp?(host) && (port.nil? || master[1] == port)
       end
 
+      # A String is never read as a Regexp: "example.com" would match notexample.com, and
+      # "*.internal" would raise on every call. It is the host name, or, starting with a dot, a
+      # domain whose subdomains match. A list changed in place (<<) is not validated: anything
+      # else matches nothing.
+      def self.skip_host_pattern?(pattern, host)
+        case pattern
+        when Regexp then pattern.match?(host)
+        when String
+          if pattern.start_with?(".")
+            host.length > pattern.length && host.downcase.end_with?(pattern.downcase)
+          else
+            pattern.casecmp?(host)
+          end
+        else false
+        end
+      end
+
       def self.master_address(url)
         return nil if url.nil? || url.to_s.empty?
 

data/lib/profiler/middleware/profiler_middleware.rb

@@ -278,7 +278,8 @@ module Profiler
 
         # Skip profiler's own paths and static assets
         path = env["PATH_INFO"]
-        Profiler.configuration.skip_paths.none? { |pattern| path =~ pattern }
+        # === matches a Regexp against the path and compares a String with it.
+        Profiler.configuration.skip_paths.none? { |pattern| pattern === path }
       end
 
       def build_request(env)
@@ -371,13 +372,7 @@ module Profiler
       def read_buffered_body(body)
         content =
           begin
-            if body.respond_to?(:to_ary)
-              body.to_ary.join
-            else
-              parts = +""
-              body.each { |part| parts << part }
-              parts
-            end
+            join_parts(body.respond_to?(:to_ary) ? body.to_ary : body)
           rescue Exception # rubocop:disable Lint/RescueException
             begin
               close_body(body)
@@ -390,6 +385,20 @@ module Profiler
         content
       end
 
+      # The fragments' bytes, joined as they are: fragments of different encodings (a binary one
+      # among UTF-8 ones) cannot be joined as text, and converting them would change the page.
+      # The result takes the encoding of the first fragment, as CapturingBody does.
+      def join_parts(parts)
+        content = String.new(encoding: Encoding::BINARY)
+        encoding = nil
+        parts.each do |part|
+          part = part.to_s
+          encoding ||= part.encoding
+          content << part.b
+        end
+        content.force_encoding(encoding || Encoding::UTF_8)
+      end
+
       def close_body(body)
         body.close if body.respond_to?(:close) && !(body.respond_to?(:closed?) && body.closed?)
       end

data/lib/profiler/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Profiler
-  VERSION = "0.33.0"
+  VERSION = "0.33.2"
 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.2
 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