rails-profiler 0.35.0 → 0.35.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1bdfb0831a95ebd47c1f2d396cf1180ff1d2143385082127f16c9b32e6cb0422
-  data.tar.gz: f286f70eb7ba2fcb9c69a4fc5bb54d9a90df9d957baa04e102d7bc67d0eb9476
+  metadata.gz: d04dbf2927645f4fbec0524e6171a4086a5cbc54206a3595a903229611941a5b
+  data.tar.gz: 4caba281e20e0a097204b6107e90be8ec74450f91bb96c26bbfac28737006fed
 SHA512:
-  metadata.gz: 7f59ab05dc3296b8068ce6a9c117c3ff48cf2a56ee057b01dd74404ab0de00391864eb2eedafb65efcbe4aea7b332d9c8c5edeb326a706841d36ef5f387c25ee
-  data.tar.gz: a730e9c3c3cc44835f535075f74cb7584d306009a7087b8c3d69360f4896110a494d42de787d5d8bf87893e5446308c67f16e96b601b2d0b344fa0525e5c9613
+  metadata.gz: e911c0a48a0f9e3f558e665cc1defac6c55a038f0d2f0620a6c445e41c5b3fce41bb4c8df07efa3135d382afad79d1c86d3e78b41966c800b954d67487c2cd68
+  data.tar.gz: 2962593dd780fad90a9b1ca9db957e0a8555e137acff0de9260fa3b57b9997c6b08e5e3f0a52f69cce5908c7cbd07aca3200dbcc0d8f22cf64f3405fe3547858

data/CHANGELOG.md

@@ -19,6 +19,59 @@ every commit of every tag interval is accounted for one way or the other.
 
 ## [Unreleased]
 
+## [0.35.2] - 2026-10-17
+
+<!-- stamped -->
+
+### Changed
+
+- **Performance:** The patch on `Thread#initialize` that carries the profiling context into new
+  threads is now installed by the railtie, only when the profiler is `enabled`; a disabled profiler
+  no longer touches `Thread`.
+
+### Fixed
+
+- **Cluster:** A worker forked from a process that had already started the cluster client (Puma in
+  cluster mode with `preload_app!`, a preloaded Unicorn) now gets its own heartbeat thread and
+  registers again with the master, through a `Process._fork` hook (Ruby 3.1 and later). Where the
+  hook is not available, call `Profiler::Cluster::MasterClient.restart_after_fork` from Puma's
+  `on_worker_boot`; see `docs/cluster.md`.
+- **HTTP and request bodies:** A body is now kept as base64 when its bytes are binary (a NUL byte,
+  invalid UTF-8, mostly control characters), whatever `Content-Type` it was served with, and `font/`,
+  `application/x-protobuf` and `application/gzip` are recognized as binary types. A binary string
+  is no longer turned into `?` characters. A body whose `Content-Type` declares a charset other than UTF-8 (`ISO-8859-1`...) stays text, decoded from that charset. A `Net::HTTP` response read as a stream (`read_body`
+  with a block) is recorded with no body and `response_body_not_captured`, instead of the `inspect`
+  of the stream adapter.
+- **Version:** `Profiler.version`, the version recorded in profiles and announced by the MCP server,
+  comes from `git describe` when the gem is mounted by path from a git checkout, so
+  `gem_version` is no longer always `0.0.0` there. A published gem keeps the version it was built
+  with, and `0.0.0` remains the fallback.
+- **MCP:** The `profiler-mcp` executable reads the profiles the application's file storage wrote
+  under `tmp/rails-profiler` in the current directory; it read an empty memory store of its own and
+  always answered that there were no profiles.
+- **Profile pages:** the `profiler-version` meta tag of the page layouts now reports `Profiler.version`, the same value the API returns, instead of the raw `Profiler::VERSION` constant. When the gem is mounted from a git checkout, every profile no longer shows a false "different version" warning.
+
+## [0.35.1] - 2026-10-17
+
+<!-- stamped -->
+
+### Fixed
+
+- **Release:** The version a merge publishes is now read from the subject line of each commit only,
+  never from its body, and `BREAKING-CHANGE:` (with a hyphen) publishes a major version just as
+  `BREAKING CHANGE:` already did.
+- **Canary:** A prerelease is now numbered after the version its branch is going to publish, not
+  after the last release, so RubyGems no longer sorts a recent canary as older than the release it
+  precedes.
+
+### Security
+
+- **Release:** `rake release` and its subtasks now refuse to run from a developer machine and point
+  to the `release` CI job, the only publisher. `rake build` and `rake install` keep working.
+- **CI:** The `canary` job no longer publishes a prerelease on every push to a `feature/`,
+  `bugfix/`, `hotfix/`, `fix/` or `breaking/` branch; it is now manual and publishes only when
+  someone plays it.
+
 ## [0.35.0] - 2026-10-17
 
 <!-- stamped -->
@@ -74,6 +127,7 @@ every commit of every tag interval is accounted for one way or the other.
   (`charset=utf-7`, `charset=internal`) no longer loses its profile; the body is read as UTF-8 with
   invalid bytes replaced.
 
+
 ## [0.34.4] - 2026-10-16
 
 <!-- stamped -->

data/app/views/layouts/profiler/application.html.erb

@@ -6,7 +6,7 @@
     <meta name="viewport" content="width=device-width, initial-scale=1">
     <%= csrf_meta_tags %>
     <%= csp_meta_tag %>
-    <meta name="profiler-version" content="<%= Profiler::VERSION %>">
+    <meta name="profiler-version" content="<%= Profiler.version %>">
     <meta name="profiler-name" content="<%= Profiler.configuration.resolved_name %>">
     <meta name="profiler-is-master" content="<%= Profiler.configuration.master? %>">
 

data/app/views/layouts/profiler/embedded.html.erb

@@ -6,7 +6,7 @@
   <meta name="viewport" content="width=device-width, initial-scale=1">
   <%= csrf_meta_tags %>
   <%= csp_meta_tag %>
-  <meta name="profiler-version" content="<%= Profiler::VERSION %>">
+  <meta name="profiler-version" content="<%= Profiler.version %>">
 
   <link rel="stylesheet" href="/_profiler/assets/profiler.css">
   <script src="/_profiler/assets/profiler.js" defer></script>

data/exe/profiler-mcp

@@ -4,10 +4,17 @@
 # The MCP server over stdio, without the application: its initializers do not run here, so
 # config.mcp_read_only set there has no effect. Set PROFILER_MCP_READ_ONLY=1 in the environment the
 # MCP client gives this process to leave out the write tools (Profiler::MCP::Server.read_only?).
-# `bundle exec rake profiler:mcp` boots the application and reads both.
+# `bundle exec rake profiler:mcp` boots the application and reads both. It reads the profiles of
+# the file storage under tmp/rails-profiler in the current directory: run it from the application's
+# root. An application on another storage is read through `rake profiler:mcp` or the HTTP endpoint.
 
 require "bundler/setup"
 require "profiler"
 require "profiler/mcp/server"
 
+# Without the application there is no initializer to pick a storage, and the default is :memory:
+# a store of this process alone, which never holds a profile the application wrote. Read the files
+# the application's file storage wrote under ./tmp/rails-profiler, from the application's root.
+Profiler.configure { |config| config.storage = :file }
+
 Profiler::MCP::Server.new.start(transport: :stdio)

data/lib/profiler/body_content.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module Profiler
+  # Tells a body that is text from one that is not, from the bytes themselves and not only from
+  # the Content-Type the sender declared: a binary payload served as text/plain is common, and
+  # forcing it into UTF-8 loses bytes it cannot get back.
+  module BodyContent
+    BINARY_CONTENT_TYPES = %r{
+      \A(?:image/(?!svg)|audio/|video/|font/|
+        application/(?:pdf|octet-stream|zip|gzip|x-gzip|x-protobuf|protobuf|x-msgpack|msgpack|
+                       wasm|x-font|font-|vnd\.ms-fontobject|x-tar|x-7z-compressed|x-bzip2|zstd))
+    }xi
+
+    # Enough to tell: the head of a body is where a magic number or a NUL byte shows up.
+    SAMPLE_BYTES = 8192
+    # A text holds few control characters: tab, newline, carriage return and escape set aside.
+    MAX_CONTROL_RATIO = 0.05
+
+    module_function
+
+    def binary_type?(content_type)
+      content_type.to_s.split(";").first.to_s.strip.match?(BINARY_CONTENT_TYPES)
+    end
+
+    # True for a body that cannot be kept as text: a NUL byte, bytes that are not UTF-8 (a cut
+    # in the middle of the last character excepted), or mostly control characters.
+    #
+    # A body whose Content-Type declares a charset other than UTF-8 is not judged on its UTF-8
+    # validity: its high bytes belong to that charset (ISO-8859-1, Windows-1252...) and are
+    # decoded from it afterwards. The NUL byte and control character tests still apply to it.
+    def binary_bytes?(body, content_type = nil)
+      return false if body.nil? || body.empty?
+
+      sample = body.byteslice(0, SAMPLE_BYTES).dup.force_encoding(Encoding::UTF_8)
+      return true if sample.include?("\0")
+
+      if !sample.valid_encoding? && !foreign_charset?(content_type)
+        # The sample may end inside a multi-byte character, whichever way it was cut.
+        sample = (1..3).filter_map { |n| sample.byteslice(0, sample.bytesize - n)&.force_encoding(Encoding::UTF_8) }
+                       .find(&:valid_encoding?)
+        return true if sample.nil?
+      end
+
+      sample = sample.scrub("") unless sample.valid_encoding?
+      controls = sample.count("\x01-\x08\x0B\x0C\x0E-\x1A\x1C-\x1F\x7F")
+      sample.length.positive? && controls.fdiv(sample.length) > MAX_CONTROL_RATIO
+    end
+
+    def binary?(body, content_type)
+      binary_type?(content_type) || binary_bytes?(body, content_type)
+    end
+
+    def foreign_charset?(content_type)
+      charset = content_type.to_s[/charset\s*=\s*"?([^\s";]+)/i, 1]
+      !charset.nil? && !charset.match?(/\A(?:utf-?8|us-ascii)\z/i)
+    end
+  end
+end

data/lib/profiler/cluster/master_client.rb

@@ -8,7 +8,38 @@ require_relative "security"
 module Profiler
   module Cluster
     class MasterClient
+      # Process._fork (Ruby 3.1+) runs in the parent and in the child alike. A thread does not
+      # survive a fork, so a worker forked from a process that had started the client (Puma in
+      # cluster mode with preload_app!, a preloaded Unicorn) would never heartbeat.
+      module ForkHook
+        def _fork
+          pid = super
+          MasterClient.restart_after_fork if pid.zero?
+          pid
+        end
+      end
+
+      class << self
+        # The client the railtie started in this process, for the fork hook to restart.
+        attr_accessor :current
+
+        def install_fork_hook!
+          return false if @fork_hook_installed || !Process.respond_to?(:_fork)
+
+          Process.singleton_class.prepend(ForkHook)
+          @fork_hook_installed = true
+        end
+
+        def restart_after_fork
+          current&.restart_after_fork
+        rescue => e
+          Profiler.log_warn("Cluster: could not restart the heartbeat after a fork", e)
+        end
+      end
+
       def start
+        self.class.current = self
+        self.class.install_fork_hook!
         @registered = false
         begin
           register!
@@ -16,6 +47,17 @@ module Profiler
         rescue => e
           log_warn("could not register with master at startup, will retry in the heartbeat loop", e)
         end
+        @started = true
+        start_heartbeat_thread
+      end
+
+      # In the child of a fork: the heartbeat thread of the parent is gone and the parent's
+      # registration is not the child's own, so register again from the new thread.
+      # Does nothing while a heartbeat thread is alive, nor before start.
+      def restart_after_fork
+        return if @started.nil? || @thread&.alive?
+
+        @registered = false
         start_heartbeat_thread
       end
 
@@ -61,7 +103,9 @@ module Profiler
       end
 
       def start_heartbeat_thread
-        Thread.new do
+        return if @thread&.alive?
+
+        @thread = Thread.new do
           interval = Profiler.configuration.cluster_heartbeat_interval
           loop do
             sleep interval

data/lib/profiler/console_profiler.rb

@@ -38,7 +38,7 @@ module Profiler
     def run(&block)
       profile = Models::Profile.new
       profile.profile_type = "console"
-      profile.gem_version = Profiler::VERSION
+      profile.gem_version = Profiler.version
       profile.path = Redaction.truncate(@expression, 200)
       profile.method = "CONSOLE"
 

data/lib/profiler/instrumentation/net_http_instrumentation.rb

@@ -6,6 +6,7 @@ require "zlib"
 require "stringio"
 require "securerandom"
 require_relative "../redaction"
+require_relative "../body_content"
 require_relative "../configuration"
 
 module Profiler
@@ -59,7 +60,10 @@ module Profiler
           response = super
 
           duration = ((Process.clock_gettime(Process::CLOCK_MONOTONIC) - t0) * 1000).round(2)
-          resp_body_raw = response.body.to_s
+          # read_body with a block hands each chunk to the block and keeps none: the response then
+          # holds a Net::ReadAdapter, whose to_s is an inspect and whose bytes are gone.
+          streamed = NetHttpInstrumentation.streamed_body?(response)
+          resp_body_raw = streamed ? "" : response.body.to_s
           resp_content_encoding = response["content-encoding"].to_s.strip.downcase
           resp_body = NetHttpInstrumentation.decompress_body(resp_body_raw, resp_content_encoding, limit)
           resp_truncated = limit ? resp_body.bytesize > limit : false
@@ -76,8 +80,9 @@ module Profiler
             response_headers: Redaction.filter_headers(response.to_hash.transform_values { |v| v.join(", ") }),
             response_body: processed_resp[:body],
             response_body_encoding: processed_resp[:encoding],
-            response_size: resp_body_raw.bytesize,
-            response_body_truncated: resp_truncated
+            response_size: streamed ? (declared_length(response) || 0) : resp_body_raw.bytesize,
+            response_body_truncated: resp_truncated,
+            response_body_not_captured: streamed
           )
 
           fg = Thread.current[:profiler_flamegraph_collector]
@@ -96,6 +101,11 @@ module Profiler
 
         private
 
+        def declared_length(response)
+          length = response["content-length"].to_s
+          length.match?(/\A\d+\z/) ? length.to_i : nil
+        end
+
         def build_url(host, port, path, ssl)
           scheme = ssl ? "https" : "http"
           standard_port = (ssl && port == 443) || (!ssl && port == 80)
@@ -110,7 +120,7 @@ module Profiler
       deprecate_constant :SKIP_HOSTS
 
       TEXT_CONTENT_TYPES   = /\A(text\/|application\/(json|xml|xhtml|javascript|x-www-form-urlencoded)|image\/svg)/i
-      BINARY_CONTENT_TYPES = /\A(image\/|application\/pdf|application\/octet-stream|application\/zip|audio\/|video\/)/i
+      BINARY_CONTENT_TYPES = BodyContent::BINARY_CONTENT_TYPES
 
       def self.install!
         return if @installed
@@ -255,12 +265,15 @@ module Profiler
         inflater&.close
       end
 
+      # A response read with read_body(&block) was consumed as a stream: its body is gone.
+      def self.streamed_body?(response)
+        defined?(Net::ReadAdapter) && response.body.is_a?(Net::ReadAdapter)
+      end
+
       def self.process_body(body, content_type)
         return { body: nil, encoding: "text" } if body.nil? || body.empty?
 
-        mime = content_type.split(";").first.to_s.strip
-
-        if mime.match?(BINARY_CONTENT_TYPES)
+        if BodyContent.binary?(body, content_type)
           # Masked on the raw bytes, before the encoding hides them from any later search.
           { body: Base64.strict_encode64(Redaction.hide_credentials(body.b)), encoding: "base64" }
         else

data/lib/profiler/instrumentation/thread_context_propagation.rb

@@ -37,8 +37,15 @@ module Profiler
         super(*args, &wrapper)
       end
       ruby2_keywords :initialize
+
+      # Called by the railtie once the application has decided `enabled`: the patch is on
+      # Thread#initialize for every thread of the process, so a disabled profiler leaves it out.
+      def self.install!
+        return if @installed
+
+        Thread.prepend(self)
+        @installed = true
+      end
     end
   end
 end
-
-Thread.prepend(Profiler::Instrumentation::ThreadContextPropagation)

data/lib/profiler/job_profiler.rb

@@ -55,7 +55,7 @@ module Profiler
     def run(&block)
       profile = Models::Profile.new
       profile.profile_type = "job"
-      profile.gem_version = Profiler::VERSION
+      profile.gem_version = Profiler.version
       profile.path = @job_class
       profile.method = "JOB"
       profile.parent_token = @parent_token if @parent_token

data/lib/profiler/mcp/server.rb

@@ -46,7 +46,7 @@ module Profiler
 
         @server = ::MCP::Server.new(
           name: "rails-profiler",
-          version: Profiler::VERSION,
+          version: Profiler.version,
           tools: tools,
           resources: resources
         )

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

@@ -98,8 +98,8 @@ module Profiler
           lines << "**Allocated objects:** #{profile.allocated_objects}" if profile.allocated_objects
           lines << "**Time:** #{profile.started_at}"
           if profile.gem_version
-            if profile.gem_version != Profiler::VERSION
-              lines << "**Gem Version:** #{profile.gem_version} ⚠️ (current: #{Profiler::VERSION})"
+            if profile.gem_version != Profiler.version
+              lines << "**Gem Version:** #{profile.gem_version} ⚠️ (current: #{Profiler.version})"
             else
               lines << "**Gem Version:** #{profile.gem_version}"
             end

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

@@ -91,6 +91,9 @@ module Profiler
                 lines << "- _Request body not captured: a stream that cannot be rewound is sent unread._"
               end
               lines << "- _Request body truncated: only the first bytes were kept (max_captured_body_bytes)._" if req["request_body_truncated"]
+              if req["response_body_not_captured"]
+                lines << "- _Response body not captured: it was read as a stream (read_body with a block)._"
+              end
               lines << "- _Response body truncated: only the first bytes were kept (max_captured_body_bytes)._" if req["response_body_truncated"]
               lines << "- **Error:** #{req['error']}" if req["error"]
 

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

@@ -73,7 +73,7 @@ module Profiler
               when "duration"     then profile.duration ? "#{profile.duration.round(2)}ms" : "-"
               when "gem_version"
                 v = profile.gem_version || "-"
-                v != Profiler::VERSION ? "#{v} ⚠️" : v
+                v != Profiler.version ? "#{v} ⚠️" : v
               when "token"        then profile.token.to_s
               when "parent_token" then profile.parent_token || "-"
               end

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

@@ -94,7 +94,10 @@ module Profiler
           timed_out = false
 
           loop do
-            break if Time.now > deadline && (timed_out = true)
+            if Time.now > deadline
+              timed_out = true
+              break
+            end
             run_data = proxy.get_json("/_profiler/api/test_runner/runs/#{run_id}")
             break if Profiler::TestRunner::RunStore::TERMINAL_STATUSES.include?(run_data["status"])
             sleep 2

data/lib/profiler/middleware/profiler_middleware.rb

@@ -29,7 +29,7 @@ module Profiler
         begin
           begin
             profile = Models::Profile.new(build_request(env), params: false)
-            profile.gem_version = Profiler::VERSION
+            profile.gem_version = Profiler.version
             Profiler::CurrentContext.token = profile.token
 
             # Capture request body before app processes it

data/lib/profiler/models/profile.rb

@@ -5,6 +5,7 @@ require "securerandom"
 require "json"
 require "zlib"
 require_relative "../redaction"
+require_relative "../body_content"
 require_relative "../allocation_counter"
 
 module Profiler
@@ -256,7 +257,7 @@ module Profiler
       def process_body(raw, content_type)
         return { body: nil, encoding: "text" } if raw.nil? || raw.empty?
 
-        if binary_content_type?(content_type)
+        if BodyContent.binary?(raw, content_type)
           # Masked on the raw bytes, before the encoding hides them from any later search. A
           # compressed format (zip, png, gzip...) does not hold the secret as it is.
           { body: Base64.strict_encode64(Redaction.hide_credentials(raw.b)), encoding: "base64" }
@@ -315,10 +316,6 @@ module Profiler
           text.bytesize > Profiler.configuration.compress_body_threshold
       end
 
-      def binary_content_type?(ct)
-        ct.to_s.match?(%r{image/(?!svg)|application/(?:pdf|octet-stream|zip)|audio/|video/})
-      end
-
       LEGACY_FILTERED_PARAMS = %w[password password_confirmation token secret].freeze
 
       # The key added to params cut at max_captured_body_bytes, so that the cut shows wherever

data/lib/profiler/railtie.rb

@@ -77,6 +77,13 @@ module Profiler
       app.middleware.delete Profiler::Middleware::CorsMiddleware
     end
 
+    # Thread#initialize is patched for every thread of the process: only when the profiler is on.
+    initializer "profiler.install_thread_context_propagation" do
+      next unless Profiler.configuration.enabled
+
+      Profiler::Instrumentation::ThreadContextPropagation.install!
+    end
+
     initializer "profiler.setup_test_profiler" do
       next unless Profiler.configuration.enabled && Profiler.configuration.track_tests
 

data/lib/profiler/version.rb

@@ -1,5 +1,31 @@
 # frozen_string_literal: true
 
 module Profiler
-  VERSION = "0.35.0"
+  VERSION = "0.35.2"
+
+  GEM_ROOT = File.expand_path("../..", __dir__)
+
+  # The version the gem reports (profiles, the MCP server). A published gem has it written into
+  # VERSION by the release job, and that is what this returns. VERSION stays at 0.0.0 on the
+  # default branch, so a gem mounted by path from a git checkout derives it from `git describe`
+  # instead; anything else (no git, no checkout, no tag, an installed gem) keeps VERSION.
+  def self.version
+    return @version if defined?(@version)
+
+    @version = VERSION == "0.0.0" ? (checkout_version || VERSION) : VERSION
+  end
+
+  # "0.34.2" on a tag, "0.34.2-5-g1a2b3c4" five commits after it. Nil unless the gem lives in
+  # its own git checkout: the .git next to lib/ is what tells it from a copy someone else's
+  # repository happens to contain.
+  def self.checkout_version
+    return nil unless File.exist?(File.join(GEM_ROOT, ".git")) && File.directory?(File.join(GEM_ROOT, "lib"))
+
+    described = IO.popen(["git", "-C", GEM_ROOT, "describe", "--tags", "--match", "v[0-9]*"],
+                         err: File::NULL, &:read)
+    described = described.to_s.strip.delete_prefix("v")
+    $?&.success? && described.match?(/\A\d+\.\d+\.\d+/) ? described : nil
+  rescue SystemCallError, IOError
+    nil
+  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rails-profiler
 version: !ruby/object:Gem::Version
-  version: 0.35.0
+  version: 0.35.2
 platform: ruby
 authors:
 - Sébastien Duplessy
@@ -145,6 +145,7 @@ files:
 - lib/profiler.rb
 - lib/profiler/ajax_data.rb
 - lib/profiler/allocation_counter.rb
+- lib/profiler/body_content.rb
 - lib/profiler/boot_env.rb
 - lib/profiler/cluster/master_client.rb
 - lib/profiler/cluster/security.rb