rails-profiler 0.30.14 → 0.30.15

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e09eb31d9bcb170273cd7c9df1f6e149d772d38cd52fd0f6d2930644054ccc8d
-  data.tar.gz: 5b8996d059b59b4a69e702ff238060dd83e08614fa416ae09ed8ed077d0d550f
+  metadata.gz: 2acc29c9f259551473810464771039fd61748d4387892bb42eda70cbe78648de
+  data.tar.gz: d47575f34e2dd8ad24e6290c2633a2a5d57e6591439eb954ce3d74f60ea17749
 SHA512:
-  metadata.gz: 5042a2f2c93acb5fd91e27907880d01b51aecaa7316a34886b827ec73584d9e3dcf356d07079f368066511fe447b06ecbeba1520e5a245befd82eb10f45b2d46
-  data.tar.gz: 8ca5df627c525ad56bddfcfa01771f0e8d23f2c3b6ade75d71dde0ea9db85a2d06ca2b2807f834f6195aba3423197d674986033427edae7d612ada1b7398b028
+  metadata.gz: 784d7a77e084ffc3ffb1c4664f3e6519323146a1a40a1cd783b2144950ede1129702b1e32e4b5583449bc8786d438fcdf2b943730aecdc2d5c95bbc4944309f2
+  data.tar.gz: 0d9d5aa7631bfc6459a5f66a7f9f181093a4365c4459ac27423d378532fad2b6858586a3b565bf985719f60aedb3a75aab5a47b86bd28ff3bbf36ce5c1280366

data/CHANGELOG.md

@@ -19,6 +19,45 @@ every commit of every tag interval is accounted for one way or the other.
 
 ## [Unreleased]
 
+## [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/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.30.15"
 end

metadata

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