rails-profiler 0.30.14 → 0.31.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e09eb31d9bcb170273cd7c9df1f6e149d772d38cd52fd0f6d2930644054ccc8d
-  data.tar.gz: 5b8996d059b59b4a69e702ff238060dd83e08614fa416ae09ed8ed077d0d550f
+  metadata.gz: 1c74753b10258047c15aafb6de0c2b5900bc16f01f4b499405b5b72d0d6d3b9e
+  data.tar.gz: 55ad17c8d51cf4eb8e2ed9ec3fd7158a15e23becba666b204b11d7b7c81f0e47
 SHA512:
-  metadata.gz: 5042a2f2c93acb5fd91e27907880d01b51aecaa7316a34886b827ec73584d9e3dcf356d07079f368066511fe447b06ecbeba1520e5a245befd82eb10f45b2d46
-  data.tar.gz: 8ca5df627c525ad56bddfcfa01771f0e8d23f2c3b6ade75d71dde0ea9db85a2d06ca2b2807f834f6195aba3423197d674986033427edae7d612ada1b7398b028
+  metadata.gz: f1984f7c3ef795d9f318ddc33b64e964a8ed0171878fd913a927ad7c7d4479ba4523159598e75ddd3f52a8985bdaca9cb24bd49a8e0a0f6e1fbc025b904254ba
+  data.tar.gz: 855f08439f3cd174f3686150eed1f813b349e7591dd731b554941be172b9557ff835229268a3dce9605825e161b353a4456e444f1680ed239f40ebf1a6c37abc

data/CHANGELOG.md

@@ -19,6 +19,64 @@ every commit of every tag interval is accounted for one way or the other.
 
 ## [Unreleased]
 
+## [0.31.0] - 2026-10-05
+
+<!-- stamped -->
+
+### Added
+
+- **Cluster:** `config.cluster_allowed_slave_urls` accepts `Regexp` entries next to URLs, for
+  slaves whose names are not known in advance, such as one container per git worktree:
+  `[%r{\Ahttp://travel-api-[a-z0-9-]+:3000\z}]`. Until now such a setup had to fall back to
+  `:any`, which reopens the server-side request forgery closed in 0.30.11. A pattern must start
+  with `\A` and end with `\z`, and compile once wrapped to match the whole URL; any other `Regexp`
+  raises an `ArgumentError` when assigned. It is matched as a whole against the URL as the master
+  keeps it (lower-case scheme and host, no default port, no trailing slash), after the existing
+  checks, which it cannot lift: user info, a query, a fragment or a `.` or `..` segment are still
+  refused, and plain HTTP to a host that is not a loopback address still needs
+  `cluster_allow_insecure_http`. A `String` entry is always a URL, never a pattern. The default,
+  `[]`, still refuses every URL. A slave URL whose path segment decodes to a `\` is now refused
+  like one that decodes to a `/`.
+
+## [0.30.15] - 2026-10-05
+
+<!-- stamped -->
+
+### Fixed
+
+- **Toolbar:** Stop the toolbar from holding a server thread for as long as its page stays open.
+  Every page kept a server-sent events stream open on `/_profiler/api/events/:token`, and the
+  server waited on it in one of its threads, 30 seconds at a time; a closed page was only noticed
+  at the next 30-second heartbeat. With as many open (or recently closed) pages as the server has
+  threads (3 in the Puma configuration Rails generates), the application stopped answering. The toolbar now asks whether
+  its profile was saved again with short requests the server answers at once: after 1 s, then
+  less and less often (10 in the first minute, 2 a minute after that), none while the tab is
+  hidden, and none after 10 minutes without a save. `GET /_profiler/api/events/:token` now
+  answers JSON (`cursor`, `updated`) for a `since` version, and the toolbar data carries the
+  version it reflects as `events_cursor`. With Redis storage, saves are counted in Redis: the
+  bus no longer keeps a listening thread and a dedicated Redis connection in each process, and a
+  failing Redis no longer leaves every toolbar without updates until the next page.
+- **Test runner:** Follow the output of a run live again on `/_profiler/test_runner`. The output
+  stream answered `500` on every request since server-sent events were added for the toolbar
+  (its controller picked up the wrong `SSE` class), so the page showed the output as it was when
+  it started following and then stopped. The stream now answers at once with the output there
+  is and the browser asks again every second, with the position it reached, while the run is in
+  progress: following a run holds no server thread either.
+- **Test runner:** Show the output of a run as UTF-8 text. The process is read 256 bytes at a
+  time, so a character could be cut between two pieces: the output stream then failed on every
+  request, the run's JSON (`GET /_profiler/api/test_runner/runs/:id`, which `run_tests` reads on a
+  slave) warned or failed, and non-ASCII output was labelled binary. The first bytes of a cut
+  character now wait for the next piece, and bytes that are not UTF-8 show as `U+FFFD`.
+- **Test runner:** Keep a killed run `killed`, and send its end to the page only with its last
+  output. The status of a killed run became `passed` or `failed` once the process exited, and the
+  page following a killed run, or a run whose test command failed to start, could stop before
+  the summary or the `[Profiler] Error:` line.
+- **MCP:** `run_tests` with a `slave` (FAB-20) returns as soon as the run on the slave is over, with
+  its output. It waited for statuses the test runner never gives (`completed`, `cancelled`), so a
+  run that passed was reported as timed out after `timeout_seconds` (120 by default), holding a
+  server thread of the master all that time, and it read the output from a field the slave does
+  not send, so the output was always empty.
+
 ## [0.30.14] - 2026-10-05
 
 <!-- stamped -->

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

@@ -4210,43 +4210,108 @@
     return query;
   }
 
+  // app/assets/typescript/profiler/hooks/profileUpdatePoller.ts
+  var POLL_DELAYS_MS = [1e3, 1e3, 2e3, 2e3, 4e3, 4e3, 8e3, 8e3, 15e3, 15e3];
+  var STEADY_DELAY_MS = 3e4;
+  var GIVE_UP_AFTER_MS = 10 * 6e4;
+  function isValidAnswer(answer) {
+    return typeof answer === "object" && answer !== null && Number.isFinite(answer.cursor);
+  }
+  function startProfileUpdatePoller(options) {
+    const now = options.now ?? (() => Date.now());
+    const setTimer = options.setTimer ?? ((fn, ms) => setTimeout(fn, ms));
+    const clearTimer = options.clearTimer ?? ((timer2) => clearTimeout(timer2));
+    let cursor = options.cursor;
+    let step = 0;
+    let lastSaveAt = now();
+    let timer = null;
+    let paused = false;
+    let stopped = false;
+    let inFlight = false;
+    const cancelTimer = () => {
+      if (timer !== null) {
+        clearTimer(timer);
+        timer = null;
+      }
+    };
+    const scheduleNext = () => {
+      cancelTimer();
+      if (stopped || paused) return;
+      if (now() - lastSaveAt >= GIVE_UP_AFTER_MS) return;
+      const delay = step < POLL_DELAYS_MS.length ? POLL_DELAYS_MS[step] : STEADY_DELAY_MS;
+      step += 1;
+      timer = setTimer(() => {
+        timer = null;
+        void checkNow();
+      }, delay);
+    };
+    const checkNow = async () => {
+      if (stopped || inFlight) return;
+      inFlight = true;
+      try {
+        const answer = await options.check(cursor);
+        if (stopped) return;
+        if (isValidAnswer(answer)) {
+          cursor = Math.max(cursor, answer.cursor);
+          if (answer.updated === true) {
+            step = 0;
+            lastSaveAt = now();
+            options.onUpdate();
+          }
+        }
+      } catch {
+      } finally {
+        inFlight = false;
+      }
+      scheduleNext();
+    };
+    scheduleNext();
+    return {
+      pause() {
+        paused = true;
+        cancelTimer();
+      },
+      resume() {
+        if (stopped) return;
+        paused = false;
+        cancelTimer();
+        void checkNow();
+      },
+      stop() {
+        stopped = true;
+        cancelTimer();
+      }
+    };
+  }
+
   // app/assets/typescript/profiler/hooks/useProfileEvents.ts
   var BASE = "/_profiler";
-  function useProfileEvents(token, collectors, onUpdate) {
-    const [connected, setConnected] = d2(false);
-    const fallbackRef = A2(null);
+  function useProfileEvents(token, cursor, onUpdate) {
+    const onUpdateRef = A2(onUpdate);
+    onUpdateRef.current = onUpdate;
+    const ready = cursor !== void 0;
     y2(() => {
-      if (!token) return;
-      const clearFallback = () => {
-        if (fallbackRef.current !== null) {
-          clearInterval(fallbackRef.current);
-          fallbackRef.current = null;
-        }
-      };
-      const params = new URLSearchParams();
-      collectors.forEach((c3) => params.append("collectors[]", c3));
-      const url = `${BASE}/api/events/${token}?${params.toString()}`;
-      const es = new EventSource(url);
-      es.addEventListener("profile_update", () => {
-        onUpdate();
+      if (!token || cursor === void 0) return;
+      const poller = startProfileUpdatePoller({
+        cursor,
+        check: (since) => apiFetch({
+          url: `${BASE}/api/events/${encodeURIComponent(token)}`,
+          method: "GET",
+          params: { since }
+        }),
+        onUpdate: () => onUpdateRef.current()
       });
-      es.onopen = () => {
-        setConnected(true);
-        clearFallback();
-      };
-      es.onerror = () => {
-        es.close();
-        setConnected(false);
-        if (fallbackRef.current === null) {
-          fallbackRef.current = setInterval(() => onUpdate(), 1e4);
-        }
+      const onVisibilityChange = () => {
+        if (document.hidden) poller.pause();
+        else poller.resume();
       };
+      document.addEventListener("visibilitychange", onVisibilityChange);
+      if (document.hidden) poller.pause();
       return () => {
-        es.close();
-        clearFallback();
+        document.removeEventListener("visibilitychange", onVisibilityChange);
+        poller.stop();
       };
-    }, [token]);
-    return { connected };
+    }, [token, ready]);
   }
 
   // app/assets/typescript/profiler/toolbar-bundle.tsx
@@ -4266,7 +4331,7 @@
         refetch();
       };
     }, [refetch]);
-    useProfileEvents(token, [], () => {
+    useProfileEvents(token, data?.events_cursor, () => {
       refetch();
     });
     const profile = data?.profile ?? null;

data/app/assets/builds/profiler.js

@@ -5418,7 +5418,7 @@
         es.close();
       });
       es.onerror = () => {
-        es.close();
+        if (es.readyState !== EventSource.CLOSED) return;
         fetch(`${BASE}/api/test_runner/runs/${currentRun.id}`).then((r3) => r3.json()).then((data) => {
           setCurrentRun(data);
           setIsRunning(false);

data/app/controllers/profiler/api/events_controller.rb

@@ -2,32 +2,21 @@
 
 module Profiler
   module Api
+    # Tells the toolbar whether its profile was saved again since the version it holds. Answered
+    # at once: the toolbar asks again later, so no server thread waits for a save that may never
+    # come, however many pages are open.
     class EventsController < Profiler::ApplicationController
-      include ActionController::Live
+      VERSION_FORMAT = /\A\d+\z/
 
-      def subscribe
-        response.headers["Content-Type"]      = "text/event-stream"
-        response.headers["Cache-Control"]     = "no-cache"
-        response.headers["X-Accel-Buffering"] = "no"
+      def show
+        cursor = Profiler::SSE.current.version(params[:token])
+        since = params[:since].to_s
+        # Without a version (none sent, NaN, anything but digits) the caller holds none: it gets
+        # the current one and no update, rather than an update on every check.
+        return render json: { cursor: cursor, updated: false } unless VERSION_FORMAT.match?(since)
 
-        sse = ActionController::Live::SSE.new(response.stream, retry: 3000, event: "profile_update")
-        id  = Profiler::SSE.current.subscribe(params[:token], Array(params[:collectors]))
-
-        begin
-          loop do
-            event = Profiler::SSE.current.wait_for_event(id, timeout: 30)
-            if event
-              sse.write(event)
-            else
-              sse.write({}, event: "heartbeat")
-            end
-          end
-        rescue ActionController::Live::ClientDisconnected, IOError
-          # Client disconnected — normal exit
-        ensure
-          Profiler::SSE.current.unsubscribe(id)
-          sse.close
-        end
+        since = since.to_i
+        render json: { cursor: [cursor, since].max, updated: cursor > since }
       end
     end
   end

data/app/controllers/profiler/api/test_runner_controller.rb

@@ -1,12 +1,14 @@
 # frozen_string_literal: true
 
+require "stringio"
 require "profiler/test_runner/discovery"
 require "profiler/test_runner/runner"
 
 module Profiler
   module Api
     class TestRunnerController < ApplicationController
-      include ActionController::Live
+      # How long the page waits before asking for the output that came since.
+      STREAM_RETRY_MS = 1000
 
       def files
         framework = params[:framework]
@@ -41,47 +43,31 @@ module Profiler
         render json: run.to_h
       end
 
-      # SSE endpoint — streams output chunks as server-sent events.
-      # Replaces polling for live test output in the frontend.
+      # Server-sent events with the output of a run from the position the page holds: what is
+      # there now, then the response ends. The page's EventSource comes back after `retry`, with
+      # the position reached in Last-Event-ID, so no server thread waits on a run that prints
+      # nothing, however many pages follow it.
       def stream
-        run = Profiler::TestRunner.run_store.find(params[:id])
-        unless run
+        position = [(request.headers["Last-Event-ID"].presence || params[:position]).to_i, 0].max
+        result = Profiler::TestRunner.run_store.read_output(params[:id], position: position)
+        if result[:status] == "not_found"
           render json: { error: "Run not found" }, status: :not_found
           return
         end
 
-        response.headers["Content-Type"]  = "text/event-stream"
-        response.headers["Cache-Control"] = "no-cache"
-        response.headers["X-Accel-Buffering"] = "no"
-
-        sse = SSE.new(response.stream, retry: 1000, event: "output")
-        position = 0
-
-        begin
-          loop do
-            result = Profiler::TestRunner.run_store.wait_for_output(
-              params[:id], position: position, timeout: 15
-            )
-
-            result[:chunks].each do |chunk|
-              sse.write({ chunk: chunk })
-            end
-            position = result[:position]
-
-            if result[:finished]
-              current_run = Profiler::TestRunner.run_store.find(params[:id])
-              sse.write(
-                { status: result[:status], exit_code: current_run&.exit_code },
-                event: "done"
-              )
-              break
-            end
-          end
-        rescue ActionController::Live::ClientDisconnected, IOError
-          # Client navigated away — normal exit
-        ensure
-          sse.close
+        body = StringIO.new
+        body.write("retry: #{STREAM_RETRY_MS}\n\n")
+        sse = ActionController::Live::SSE.new(body, event: "output")
+        result[:chunks].each.with_index(position + 1) do |chunk, id|
+          sse.write({ chunk: chunk }, id: id)
+        end
+        if result[:finished]
+          run = Profiler::TestRunner.run_store.find(params[:id])
+          sse.write({ status: result[:status], exit_code: run&.exit_code }, event: "done")
         end
+
+        response.headers["Cache-Control"] = "no-cache"
+        render plain: body.string, content_type: "text/event-stream"
       end
 
       def destroy

data/app/controllers/profiler/api/toolbar_controller.rb

@@ -4,6 +4,9 @@ module Profiler
   module Api
     class ToolbarController < Profiler::ApplicationController
       def show
+        # Read before the profile: a save landing in between makes the toolbar fetch it again
+        # rather than miss it.
+        events_cursor = Profiler::SSE.current.version(params[:token])
         profile = Profiler.storage.load(params[:token])
 
         unless profile
@@ -14,7 +17,10 @@ module Profiler
         # Recalculate AJAX collector data (since AJAX requests happen after page load)
         recalculate_ajax_data(profile)
 
-        render json: { profile: profile.to_h.merge(child_jobs: build_child_jobs(profile)) }
+        render json: {
+          profile: profile.to_h.merge(child_jobs: build_child_jobs(profile)),
+          events_cursor: events_cursor
+        }
       end
 
       private

data/config/routes.rb

@@ -55,7 +55,7 @@ Profiler::Engine.routes.draw do
     get    "test_runner/runs/:id",        to: "test_runner#show",   as: :test_runner_run
     get    "test_runner/runs/:id/stream", to: "test_runner#stream", as: :test_runner_run_stream
     delete "test_runner/runs/:id",        to: "test_runner#destroy"
-    get    "events/:token",               to: "events#subscribe",  as: :profile_events
+    get    "events/:token",               to: "events#show",       as: :profile_events
 
     # Cluster endpoints (master-side), routed only on a node with cluster_master set
     constraints(->(_request) { Profiler.configuration.cluster_master? }) do

data/lib/profiler/cluster/security.rb

@@ -82,11 +82,27 @@ module Profiler
 
           allowed = config.cluster_allowed_slave_urls
           return nil if allowed == :any
-          return nil if Array(allowed).any? { |entry| covers?(normalize(entry), target) }
+
+          registered = normalized_url(url)
+          return nil if Array(allowed).any? { |entry| entry_allows?(entry, target, registered) }
 
           "#{url} is not allowed by config.cluster_allowed_slave_urls"
         end
 
+        # Whether a Regexp entry of cluster_allowed_slave_urls is anchored at both ends: its source
+        # starts with \A and ends with an unescaped \z. \Z, ^ and $ do not count, since they let a
+        # trailing newline or another line through. A check of the written form, so that a pattern
+        # reads as what it does; the match itself is made whole by whole_url_pattern.
+        def anchored_pattern?(pattern)
+          return false unless pattern.is_a?(Regexp)
+
+          source = pattern.source
+          return false unless source.start_with?("\\A")
+
+          ending = source.match(/(\\+)z\z/)
+          !ending.nil? && ending[1].length.odd? && source.length > 4
+        end
+
         # Same transport rule for the master URL a slave sends its secret to.
         def master_url_denial(url)
           target = normalize(url)
@@ -139,6 +155,32 @@ module Profiler
           "#{path.inspect} is not a valid path"
         end
 
+        # One entry of cluster_allowed_slave_urls against a URL already through normalize and the
+        # transport rule. A Regexp is matched, as a whole, against the URL as the registry keeps it
+        # (normalized_url), and only when anchored; anything else is an URL compared by covers?,
+        # so a String is never read as a pattern.
+        def entry_allows?(entry, target, registered)
+          if entry.is_a?(Regexp)
+            return false unless registered && anchored_pattern?(entry)
+
+            whole_url_pattern(entry).match?(registered)
+          else
+            covers?(normalize(entry), target)
+          end
+        rescue RegexpError
+          false
+        end
+
+        # The pattern wrapped again in \A(?:...)\z, so that a top-level alternation (\Aa|b\z)
+        # cannot leave one branch anchored at a single end: this wrapping, not anchored_pattern?,
+        # is what makes the match cover the whole URL. Compiled once per pattern. Raises
+        # RegexpError when the wrapping does not compile, for instance when an x-mode comment
+        # swallows the closing \z.
+        def whole_url_pattern(pattern)
+          @whole_url_patterns ||= {}
+          @whole_url_patterns[pattern] ||= Regexp.new("\\A(?:#{pattern.source})\\z", pattern.options)
+        end
+
         # Scheme, host and port compared after normalization (case, default port, IPv6 brackets),
         # and a path prefix compared segment by segment.
         def covers?(entry, target)
@@ -149,8 +191,8 @@ module Profiler
         end
 
         # Returns { scheme:, host:, port:, segments: }, or nil for anything that is not a plain
-        # http(s) URL: user info, a query, a fragment, or a "." or ".." path segment are refused
-        # rather than interpreted.
+        # http(s) URL: user info, a query, a fragment, or a "." or ".." path segment, or one that
+        # decodes to a "/" or a "\\", are refused rather than interpreted.
         def normalize(url)
           uri = URI.parse(url.to_s.strip)
           return nil unless uri.is_a?(URI::HTTP) && uri.host && !uri.host.empty?
@@ -158,7 +200,7 @@ module Profiler
 
           segments = uri.path.to_s.split("/").reject(&:empty?)
           decoded = segments.map { |segment| URI.decode_www_form_component(segment) }
-          return nil if decoded.any? { |segment| segment == "." || segment == ".." || segment.include?("/") }
+          return nil if decoded.any? { |segment| segment == "." || segment == ".." || segment.match?(%r{[/\\]}) }
 
           { scheme: uri.scheme.downcase, host: uri.hostname.downcase, port: uri.port, segments: decoded }
         rescue URI::Error, ArgumentError

data/lib/profiler/configuration.rb

@@ -47,7 +47,7 @@ module Profiler
                   :name, :master_url, :self_url,
                   :cluster_heartbeat_interval, :cluster_offline_threshold,
                   :cluster_master, :cluster_secret, :cluster_require_secret,
-                  :cluster_allowed_slave_urls, :cluster_allow_insecure_http
+                  :cluster_allow_insecure_http
 
     attr_writer :tmp_path
 
@@ -117,6 +117,30 @@ module Profiler
       @tmp_path || default_tmp_path
     end
 
+    attr_reader :cluster_allowed_slave_urls
+
+    # :any, or a list of slave URLs and anchored Regexp patterns (see Profiler::Cluster::Security).
+    # A Regexp that is not anchored with \A and \z is refused here, at boot, rather than ignored.
+    def cluster_allowed_slave_urls=(value)
+      unless value == :any
+        require_relative "cluster/security"
+        Array(value).grep(Regexp).each do |pattern|
+          unless Profiler::Cluster::Security.anchored_pattern?(pattern)
+            raise ArgumentError, "config.cluster_allowed_slave_urls: #{pattern.inspect} must start with \\A and " \
+                                 "end with \\z, so that it matches the whole slave URL"
+          end
+
+          begin
+            Profiler::Cluster::Security.whole_url_pattern(pattern)
+          rescue RegexpError => e
+            raise ArgumentError, "config.cluster_allowed_slave_urls: #{pattern.inspect} cannot be matched against " \
+                                 "the whole slave URL (#{e.message}); an x-mode comment must not hide the \\z"
+          end
+        end
+      end
+      @cluster_allowed_slave_urls = value
+    end
+
     def enabled=(value)
       @assigned |= [:enabled]
       @enabled = value

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

@@ -96,11 +96,12 @@ module Profiler
           loop do
             break if Time.now > deadline && (timed_out = true)
             run_data = proxy.get_json("/_profiler/api/test_runner/runs/#{run_id}")
-            break if %w[completed failed cancelled].include?(run_data["status"])
+            break if Profiler::TestRunner::RunStore::TERMINAL_STATUSES.include?(run_data["status"])
             sleep 2
           end
 
-          output = run_data["output_lines"]&.join.to_s
+          # The slave answers with RunStore::Run#to_h, which carries the whole output as "output".
+          output = run_data["output"].to_s
           output = "…(truncated)\n" + output[-(max_output)..] if output.length > max_output
 
           text = "# Test Run on slave '#{params["slave"]}' #{timed_out ? "(timed out)" : ""}\n\n"

data/lib/profiler/sse/event_bus.rb

@@ -1,46 +1,47 @@
 # frozen_string_literal: true
 
 require "singleton"
-require "securerandom"
-require "timeout"
-require "set"
-require "concurrent"
 
 module Profiler
   module SSE
+    # Remembers, per profile token, the version of its last save, so that a page showing the
+    # profile can ask whether it changed since the version it holds. Nothing here waits: a
+    # request asking for the version is answered at once, and the toolbar comes back later (see
+    # Api::EventsController).
+    #
+    # A version is the time of the save in microseconds, so that versions from the worker
+    # processes of one machine compare with each other: without Redis, each worker only knows
+    # the saves it made, and a page sees a save when one of its questions reaches that worker.
     class EventBus
       include Singleton
 
-      def initialize
-        @subscriptions = Concurrent::Hash.new
-      end
+      # The tokens remembered; the oldest saved is forgotten first. A forgotten token reads as
+      # version 0, which is never newer than what a page holds, and its next save is seen again.
+      MAX_TOKENS = 1000
 
-      def subscribe(token, collectors)
-        id = SecureRandom.uuid
-        @subscriptions[id] = { token: token, collectors: Set.new(collectors.map(&:to_s)), queue: Queue.new }
-        id
+      def initialize
+        @versions = {}
+        @mutex = Mutex.new
       end
 
-      def unsubscribe(id)
-        @subscriptions.delete(id)
+      def broadcast(token)
+        now = Process.clock_gettime(Process::CLOCK_REALTIME, :microsecond)
+        @mutex.synchronize do
+          # Strictly increasing within the process, even for two saves in one microsecond.
+          version = [now, @versions.delete(token).to_i + 1].max
+          @versions[token] = version
+          @versions.shift while @versions.size > MAX_TOKENS
+          version
+        end
       end
 
-      def broadcast(token, collectors)
-        changed = Set.new(collectors.map(&:to_s))
-        @subscriptions.each_value do |sub|
-          next unless sub[:token] == token
-          # Empty collector set means "match all"; non-empty set filters by intersection.
-          next if sub[:collectors].any? && (sub[:collectors] & changed).empty?
-          sub[:queue] << { token: token, collectors: changed.to_a, timestamp: Time.now.to_f }
-        end
+      # The version of the last save of +token+ seen by this process, 0 when none was.
+      def version(token)
+        @mutex.synchronize { @versions.fetch(token, 0) }
       end
 
-      def wait_for_event(id, timeout: 30)
-        sub = @subscriptions[id]
-        return nil unless sub
-        Timeout.timeout(timeout) { sub[:queue].pop }
-      rescue Timeout::Error
-        nil
+      def reset!
+        @mutex.synchronize { @versions.clear }
       end
     end
   end

data/lib/profiler/sse/redis_event_bus.rb

@@ -1,78 +1,46 @@
 # frozen_string_literal: true
 
 require "singleton"
-require "securerandom"
-require "timeout"
-require "set"
-require "json"
-require "concurrent"
 
 module Profiler
   module SSE
+    # The version of each profile's last save, kept in Redis next to the profiles so that every
+    # process and every machine sharing them counts the same saves (see EventBus). A version is
+    # a counter Redis increments, so versions only compare with versions of the same Redis.
+    #
+    # Nothing waits on Redis beyond its client's own timeouts: there is no subscription and no
+    # listening thread, and a failing Redis reads as no newer save.
     class RedisEventBus
       include Singleton
 
-      CHANNEL_PREFIX = "profiler:events"
+      KEY_PREFIX = "profiler:events"
+      # As long as RedisStore keeps a profile by default: past that, nobody looks at its page.
+      TTL = 24 * 60 * 60
 
-      def initialize
-        @subscriptions = Concurrent::Hash.new
-        @listener_thread = nil
-        @listener_mutex = Mutex.new
-      end
-
-      def subscribe(token, collectors)
-        id = SecureRandom.uuid
-        @subscriptions[id] = { token: token, collectors: Set.new(collectors.map(&:to_s)), queue: Queue.new }
-        ensure_listener_running
-        id
-      end
-
-      def unsubscribe(id)
-        @subscriptions.delete(id)
-      end
-
-      def broadcast(token, collectors)
-        payload = { token: token, collectors: collectors.map(&:to_s), timestamp: Time.now.to_f }.to_json
-        publish_redis_client.publish("#{CHANNEL_PREFIX}:#{token}", payload)
+      def broadcast(token)
+        key = key(token)
+        version, _expire = redis.multi do |transaction|
+          transaction.incr(key)
+          transaction.expire(key, TTL)
+        end
+        version
       end
 
-      def wait_for_event(id, timeout: 30)
-        sub = @subscriptions[id]
-        return nil unless sub
-        Timeout.timeout(timeout) { sub[:queue].pop }
-      rescue Timeout::Error
-        nil
+      # The version of the last save of +token+, 0 when none is known or Redis cannot be read.
+      def version(token)
+        redis.get(key(token)).to_i
+      rescue StandardError
+        0
       end
 
       private
 
-      def publish_redis_client
-        Profiler.storage.redis
+      def key(token)
+        "#{KEY_PREFIX}:#{token}"
       end
 
-      def ensure_listener_running
-        @listener_mutex.synchronize do
-          return if @listener_thread&.alive?
-
-          @listener_thread = Thread.new do
-            # Use a dedicated connection for blocking psubscribe
-            Profiler.storage.redis.dup.psubscribe("#{CHANNEL_PREFIX}:*") do |on|
-              on.pmessage do |_pattern, _channel, message|
-                payload = JSON.parse(message, symbolize_names: true)
-                token = payload[:token]
-                changed = Set.new(payload[:collectors].map(&:to_s))
-
-                @subscriptions.each_value do |sub|
-                  next unless sub[:token] == token
-                  next if sub[:collectors].any? && (sub[:collectors] & changed).empty?
-                  sub[:queue] << { token: token, collectors: changed.to_a, timestamp: payload[:timestamp] }
-                end
-              end
-            end
-          rescue StandardError
-            # Thread restarts on the next subscribe call
-          end
-        end
+      def redis
+        Profiler.storage.redis
       end
     end
   end

data/lib/profiler/storage/base_store.rb

@@ -3,11 +3,12 @@
 module Profiler
   module Storage
     class BaseStore
-      # Public interface: persists the profile then fires an SSE broadcast.
+      # Public interface: persists the profile then records the save, for the pages showing it
+      # to see it changed (Profiler::SSE).
       # Subclasses implement #do_save, not #save.
       def save(token, profile)
         result = do_save(token, profile)
-        broadcast_event(token, profile)
+        broadcast_event(token)
         result
       end
 
@@ -47,9 +48,8 @@ module Profiler
 
       private
 
-      def broadcast_event(token, profile)
-        collectors = profile.collectors_data.keys
-        Profiler::SSE.current.broadcast(token, collectors)
+      def broadcast_event(token)
+        Profiler::SSE.current.broadcast(token)
       rescue StandardError
         # Never let a broadcast failure prevent profile persistence
       end

data/lib/profiler/test_runner/run_store.rb

@@ -21,6 +21,7 @@ module Profiler
       end
 
       TERMINAL_STATUSES = %w[passed failed killed error].freeze
+      NOT_FOUND = { chunks: [].freeze, status: "not_found", position: 0, finished: true }.freeze
 
       def initialize
         @runs  = Concurrent::Hash.new
@@ -68,16 +69,25 @@ module Profiler
       # last bytes that could start a credential wait for the next piece, so that none is ever
       # shown cut in two. What is held back is released by finish_output, once the process has
       # nothing more to print: a killed run still prints its summary after its status changed.
+      #
+      # The process is read in binary pieces of a fixed size, so a character can be cut in two
+      # as well: its first bytes wait for the next piece the same way. What is shown is UTF-8,
+      # with any byte that is not replaced by U+FFFD, so that every reader (JSON of the run, the
+      # stream, run_tests) gets text it can encode.
       def append_output(id, chunk)
         run = @runs[id]
         return unless run
 
         @held_lock.synchronize do
-          text = Profiler::Redaction.hide_credentials(@held.fetch(id, "".b) + chunk.to_s.b)
-          holdback = @output_finished[id] ? 0 : Profiler::Redaction.held_back_bytes(text)
+          text = Profiler::Redaction.hide_credentials(@held.fetch(id, "".b) + chunk.to_s.b).b
+          holdback = if @output_finished[id]
+                       0
+                     else
+                       [Profiler::Redaction.held_back_bytes(text), incomplete_character_bytes(text)].max
+                     end
           cut = text.bytesize - holdback
           @held[id] = text.byteslice(cut, text.bytesize - cut)
-          shown = text.byteslice(0, cut).force_encoding(chunk.to_s.encoding)
+          shown = as_text(text.byteslice(0, cut))
           run.output_lines.push(shown) unless shown.empty?
         end
         signal(id)
@@ -92,16 +102,29 @@ module Profiler
         @held_lock.synchronize do
           @output_finished[id] = true
           rest = @held.delete(id)
-          run.output_lines.push(rest) if rest && !rest.empty?
+          run.output_lines.push(as_text(rest)) if rest && !rest.empty?
         end
         signal(id)
       end
 
+      # The output from +position+ on, as it is now, without waiting for more.
+      # Returns { chunks: [...], status: "...", position: N, finished: bool }, finished once the
+      # status is terminal and the reader of the process has read everything: a killed run gets
+      # its status at once, and prints its summary after.
+      def read_output(id, position:)
+        run = @runs[id]
+        return NOT_FOUND unless run
+
+        result = snapshot(run, position)
+        result[:finished] &&= @output_finished.fetch(id, false)
+        result
+      end
+
       # Block until new output is available at +position+ or the run terminates.
-      # Returns { chunks: [...], status: "...", position: N, finished: bool }.
+      # Returns the same as read_output.
       def wait_for_output(id, position:, timeout: 10)
         run = @runs[id]
-        return { chunks: [], status: "not_found", position: 0, finished: true } unless run
+        return NOT_FOUND unless run
 
         lock = @locks[id]
         return snapshot(run, position) unless lock
@@ -128,6 +151,26 @@ module Profiler
         lock[:mutex].synchronize { lock[:cond].broadcast }
       end
 
+      # How many bytes at the end of +bytes+ start a UTF-8 character that the next piece ends.
+      def incomplete_character_bytes(bytes)
+        [3, bytes.bytesize].min.times do |back|
+          byte = bytes.getbyte(bytes.bytesize - 1 - back)
+          next if byte & 0xC0 == 0x80 # a continuation byte: the start is further back
+
+          length = if byte >= 0xF0 then 4
+                   elsif byte >= 0xE0 then 3
+                   elsif byte >= 0xC0 then 2
+                   else 1
+                   end
+          return length > back + 1 ? back + 1 : 0
+        end
+        0
+      end
+
+      def as_text(bytes)
+        bytes.dup.force_encoding(Encoding::UTF_8).scrub
+      end
+
       def forget_output(id)
         @held.delete(id)
         @output_finished.delete(id)

data/lib/profiler/test_runner/runner.rb

@@ -118,13 +118,14 @@ module Profiler
         Thread.new do
           run_process(run)
         rescue => e
+          # The output first: a page following the run stops at its terminal status.
+          Profiler::TestRunner.run_store.append_output(run.id, "\n[Profiler] Error: #{e.message}\n")
+          Profiler::TestRunner.run_store.finish_output(run.id)
           Profiler::TestRunner.run_store.update(
             run.id,
             status: "error",
             finished_at: Time.now
           )
-          Profiler::TestRunner.run_store.append_output(run.id, "\n[Profiler] Error: #{e.message}\n")
-          Profiler::TestRunner.run_store.finish_output(run.id)
         end
       end
 
@@ -151,7 +152,11 @@ module Profiler
         end
 
         exit_code = $?.exitstatus || 0
-        status = exit_code == 0 ? "passed" : "failed"
+        # A run killed from the profiler stays killed, whatever the process answered to TERM.
+        status = if run.status == "killed" then "killed"
+                 elsif exit_code == 0 then "passed"
+                 else "failed"
+                 end
 
         Profiler::TestRunner.run_store.update(
           run.id,

data/lib/profiler/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rails-profiler
 version: !ruby/object:Gem::Version
-  version: 0.30.14
+  version: 0.31.0
 platform: ruby
 authors:
 - Sébastien Duplessy