rails-profiler 0.34.4 → 0.34.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d4912dd474a748e657c35111e3224d83500e75960ef2592e5cd652155dc62617
-  data.tar.gz: d0d4cb0f34f25d98f5be08875bdc59ec4cc84894f7cbe0b512fd1ecd153dda4b
+  metadata.gz: 0637e842e7e8cce996b450d94201b5a117bc6797fe095a488ea9f0b9b54c504f
+  data.tar.gz: 5949fcd0e376266ebfff2cc698b4964c4af39f85ae83832e905c0909354844dc
 SHA512:
-  metadata.gz: 3ca18ad3dd582e68c2bb935a5ace8628dc466a4999fa655e54117879548d543c5a291ec98765eb25456b0ff8fa774ee0f98f939544a346aa9b3368d37c421f72
-  data.tar.gz: e144011d2fd93d37aa3166748bf2d3671d8d246325a475cf13d756b188dd99999ef6f95b232fd36eca444c91e24e2715c1902695697ea1930407bc932b2e952d
+  metadata.gz: a5834f8092fa5c9346fb578444a32e43ffb1ebe669ece132b8214d1400257a6dabcea588b3a81125924c40f64fd98aa410e92523500c829b7af06f128be42997
+  data.tar.gz: 4728ac7e13f397cf2439a079f63430d74056a9bf126c7cfb29001fcde35003b076b76426b600465a246c2a177f660600f9ae4e2deef445273cfb43464d09b398

data/CHANGELOG.md

@@ -19,6 +19,53 @@ every commit of every tag interval is accounted for one way or the other.
 
 ## [Unreleased]
 
+## [0.34.6] - 2026-10-16
+
+<!-- stamped -->
+
+### Added
+
+- **Test runner:** `config.test_runner_kill_grace_seconds` (5 by default),
+  `config.test_runner_max_output_bytes` (5 MB by default) and `config.test_runner_max_active_runs`
+  (2 by default), described under the fixes below. `nil` lifts either limit.
+
+### Fixed
+
+- **Test runner:** A test process ended by a signal (killed for lack of memory, crashed, stopped by
+  another program) is no longer reported `passed` with exit code 0. The run ends `signaled`, with no
+  exit code, the name of the signal in a new `signal` field of the API, a `Signal` line in the MCP
+  tool `run_tests`, a `[Profiler]` line at the end of its output, and "Ended by a signal" in the page.
+- **Test runner:** **Stop** now stops the whole test run. The test process runs in a process group
+  of its own: `TERM` goes to the whole group, the processes rspec or rails started included, and
+  `KILL` follows after `config.test_runner_kill_grace_seconds` for whatever ignored it. A stopped
+  run used to leave those processes, and a process ignoring `TERM`, running.
+- **Test runner:** The output a run keeps is limited to `config.test_runner_max_output_bytes`: its
+  beginning, a `[Profiler] Output truncated` line, and its last quarter once the run ends, with the
+  number of bytes left out. It used to be kept whole, however large. At most 20 finished runs are
+  kept, on top of the one hour they were already kept.
+- **Test runner:** Starting a run while `config.test_runner_max_active_runs` runs still have their
+  test process is refused, with a `429` from the API, the reason in the page, and a tool error from
+  `run_tests`. Any number of runs could be started at once.
+- **Test runner:** A run is only known to the server process that started it. With Puma in cluster
+  mode, a request reaching another worker gets a `404` that now gives this reason; the
+  [test runner documentation](docs/testing.md#several-server-processes) describes the limit.
+
+## [0.34.5] - 2026-10-16
+
+<!-- stamped -->
+
+### Fixed
+
+- **Request capture:** the parameters of a request are now read once the application has returned, so
+  route parameters are present and `param_encoding` is applied, and they are converted to UTF-8. They
+  used to be read in the outermost middleware, before the router ran.
+- **Request capture:** a text body keeps its accents. It is now read in the `charset` of its
+  `Content-Type`, UTF-8 when it declares none, and invalid bytes are replaced, instead of every
+  accent being turned into a replacement character.
+- **Request capture:** a request whose `Content-Type` declares a charset Ruby cannot convert from
+  (`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/assets/builds/profiler.js

@@ -5311,7 +5311,7 @@
     if (status === "passed") return "var(--profiler-success, #10b981)";
     if (status === "failed") return "var(--profiler-error, #ef4444)";
     if (status === "running") return "var(--profiler-accent, #06b6d4)";
-    if (status === "killed" || status === "error") return "var(--profiler-warning, #f59e0b)";
+    if (status === "killed" || status === "signaled" || status === "error") return "var(--profiler-warning, #f59e0b)";
     return "var(--profiler-text-muted, #888)";
   }
   function statusLabel(status) {
@@ -5321,6 +5321,7 @@
       passed: "\u2713 Passed",
       failed: "\u2717 Failed",
       killed: "\u25A0 Killed",
+      signaled: "\u26A1 Ended by a signal",
       error: "\u26A0 Error"
     };
     return map[status] || status;
@@ -5430,7 +5431,7 @@
     }, [refetchFiles]);
     y2(() => {
       if (!currentRun || !isRunning) return;
-      if (["passed", "failed", "killed", "error"].includes(currentRun.status)) {
+      if (["passed", "failed", "killed", "signaled", "error"].includes(currentRun.status)) {
         setIsRunning(false);
         return;
       }
@@ -5495,8 +5496,8 @@
         const data = await startTestRun({ data: { files: Array.from(selected), framework } });
         setCurrentRun(data);
         setIsRunning(true);
-      } catch {
-        setError("Failed to start test run");
+      } catch (e3) {
+        setError(e3 instanceof Error && e3.message ? e3.message : "Failed to start test run");
       }
     };
     const stopRun = async () => {

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

@@ -10,6 +10,10 @@ module Profiler
       # How long the page waits before asking for the output that came since.
       STREAM_RETRY_MS = 1000
 
+      # Runs live in the memory of the server process that started them.
+      RUN_NOT_FOUND = "Run not found. Runs are kept by the server process that started them: " \
+                      "with several processes (Puma in cluster mode), follow a run from that process."
+
       def files
         framework = params[:framework]
         tree = Profiler::TestRunner::Discovery.files(framework: framework)
@@ -34,11 +38,13 @@ module Profiler
         render json: run.to_h, status: :created
       rescue Profiler::TestRunner::InvalidFileError => e
         render json: { error: e.message }, status: :unprocessable_entity
+      rescue Profiler::TestRunner::TooManyRunsError => e
+        render json: { error: e.message }, status: :too_many_requests
       end
 
       def show
         run = Profiler::TestRunner.run_store.find(params[:id])
-        return render json: { error: "Run not found" }, status: :not_found unless run
+        return render json: { error: RUN_NOT_FOUND }, status: :not_found unless run
 
         render json: run.to_h
       end
@@ -51,7 +57,7 @@ module Profiler
         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
+          render json: { error: RUN_NOT_FOUND }, status: :not_found
           return
         end
 
@@ -75,7 +81,8 @@ module Profiler
         if killed
           head :no_content
         else
-          render json: { error: "Run not found or not running" }, status: :not_found
+          known = Profiler::TestRunner.run_store.find(params[:id])
+          render json: { error: known ? "Run not running" : RUN_NOT_FOUND }, status: :not_found
         end
       end
 

data/lib/profiler/configuration.rb

@@ -49,6 +49,8 @@ module Profiler
                   :track_console,
                   :apply_env_overrides_when_disabled, :restrict_storage_permissions,
                   :test_runner_allow_undiscovered_files, :allow_explain_outside_development,
+                  :test_runner_kill_grace_seconds,
+                  :test_runner_max_output_bytes, :test_runner_max_active_runs,
                   :track_mailers, :capture_mail_body, :sanitize_mailer_recipients, :mailer_skip_actions,
                   :compress_bodies, :compress_body_threshold, :max_captured_body_bytes, :max_captured_log_bytes,
                   :redact_sensitive_data, :filter_parameters, :env_allowlist,
@@ -113,6 +115,14 @@ module Profiler
       # only runs in the development and test environments, even with enabled = true elsewhere:
       # PostgreSQL's EXPLAIN ANALYZE runs the query. true allows it in every environment.
       @allow_explain_outside_development = false
+      # Stopping a run sends TERM to its whole process group, then KILL after this many seconds
+      # if any process of the group is still there.
+      @test_runner_kill_grace_seconds = 5
+      # What a run keeps of its output, in bytes: the beginning, then the last quarter of this
+      # once it is exceeded, with a marker in between. nil keeps everything.
+      @test_runner_max_output_bytes = 5 * 1024 * 1024
+      # Runs whose test process has not ended yet; another one is refused. nil for no limit.
+      @test_runner_max_active_runs = 2
       @track_mailers = true
       @capture_mail_body = false
       @sanitize_mailer_recipients = false

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

@@ -45,7 +45,7 @@ module Profiler
           run_started_at = Time.now
           begin
             run = Profiler::TestRunner::Runner.start(files: files, framework: framework)
-          rescue Profiler::TestRunner::InvalidFileError => e
+          rescue Profiler::TestRunner::InvalidFileError, Profiler::TestRunner::TooManyRunsError => e
             return ::MCP::Tool::Response.new([{ type: "text", text: e.message }], error: true)
           end
 
@@ -108,7 +108,9 @@ module Profiler
           text += "| Field | Value |\n|-------|-------|\n"
           text += "| Run ID | `#{run_id}` |\n"
           text += "| Status | **#{run_data["status"]}** |\n"
-          text += "| Exit code | #{run_data["exit_code"].inspect} |\n\n"
+          text += "| Exit code | #{run_data["exit_code"].inspect} |\n"
+          text += "| Signal | #{run_data["signal"]} |\n" if run_data["signal"]
+          text += "\n"
           text += "## Output\n```\n#{output.strip}\n```"
           [{ type: "text", text: text }]
         end
@@ -136,6 +138,7 @@ module Profiler
           lines << "| Files | #{files.size} |"
           lines << "| Status | **#{run.status}** |"
           lines << "| Exit code | #{run.exit_code.inspect} |"
+          lines << "| Signal | #{run.signal} |" if run.signal
           lines << "| Duration | #{run.to_h[:duration]&.round(0)}ms |"
 
           if timed_out

data/lib/profiler/middleware/profiler_middleware.rb

@@ -28,7 +28,7 @@ module Profiler
         kept = nil
         begin
           begin
-            profile = Models::Profile.new(build_request(env))
+            profile = Models::Profile.new(build_request(env), params: false)
             profile.gem_version = Profiler::VERSION
             Profiler::CurrentContext.token = profile.token
 
@@ -57,10 +57,12 @@ module Profiler
           begin
             response = @app.call(env)
           rescue Exception => e # rubocop:disable Lint/RescueException
+            capture_params(env, profile) if failed_request?(e)
             record_failed_request(env, profile, collectors, request_body, allocations_before, e) if failed_request?(e)
             raise
           end
 
+          capture_params(env, profile)
           response, kept = complete_profile(env, profile, collectors, request_body, allocations_before, response)
           response
         ensure
@@ -74,6 +76,14 @@ module Profiler
 
       private
 
+      # Read after the application has run, so after the routing: the route parameters are there,
+      # and the params carry the encoding the route declared, as the controller saw them.
+      def capture_params(env, profile)
+        profile.capture_params(build_request(env))
+      rescue => e
+        Profiler.log_error("ProfilerMiddleware: could not read the request params", e)
+      end
+
       def complete_profile(env, profile, collectors, request_body, allocations_before, response)
         status, headers, body = response
 

data/lib/profiler/models/profile.rb

@@ -22,7 +22,9 @@ module Profiler
                     :collectors_released_after_seconds, :params_truncated,
                     :gem_version
 
-      def initialize(request = nil)
+      # +params+: false leaves the params to capture_params, for a caller that builds the profile
+      # before the router has run.
+      def initialize(request = nil, params: true)
         @token = SecureRandom.hex(16)
         @started_at = Time.now
         @collectors_data = {}
@@ -34,12 +36,19 @@ module Profiler
         if request
           @path = request.path
           @method = request.request_method
-          @params, @params_truncated = cap_params(sanitize_params(request.params),
-                                                  Profiler.configuration.max_captured_body_bytes)
+          capture_params(request) if params
           @headers = extract_headers(request.env)
         end
       end
 
+      # The request's params as the controller sees them. Read once the router has run: Rails
+      # adds the route parameters (:id...) and applies the routes' param_encoding only then, so
+      # a read before it keeps neither.
+      def capture_params(request)
+        @params, @params_truncated = cap_params(sanitize_params(utf8_params(request.params)),
+                                                Profiler.configuration.max_captured_body_bytes)
+      end
+
       # The sizes are those of the whole bodies, when a body was cut at max_captured_body_bytes;
       # *_size_is_minimum when the whole size is not known (no Content-Length, a stream that
       # stopped), only that it is at least that.
@@ -252,7 +261,7 @@ module Profiler
           # compressed format (zip, png, gzip...) does not hold the secret as it is.
           { body: Base64.strict_encode64(Redaction.hide_credentials(raw.b)), encoding: "base64" }
         else
-          text = Redaction.filter_body(raw, content_type).encode("UTF-8", invalid: :replace, undef: :replace)
+          text = utf8_text(Redaction.filter_body(raw, content_type), content_type)
           if compress_body?(text)
             # The fastest level: paid on the request, a quarter larger than the default level.
             { body: Base64.strict_encode64(Zlib::Deflate.deflate(text, Zlib::BEST_SPEED)), encoding: "gzip+base64" }
@@ -262,6 +271,39 @@ module Profiler
         end
       end
 
+      # The text as UTF-8: a body read from the wire is binary, and is taken for the charset its
+      # Content-Type declares (UTF-8 when it declares none, or one Ruby does not know). Bytes
+      # that do not belong to it are replaced, never raised on.
+      def utf8_text(text, content_type)
+        return text.encode("UTF-8", invalid: :replace, undef: :replace) unless text.encoding == Encoding::BINARY
+
+        charset = content_type.to_s[/charset\s*=\s*"?([^\s";]+)/i, 1]
+        source = begin
+          charset ? Encoding.find(charset) : Encoding::UTF_8
+        rescue ArgumentError
+          Encoding::UTF_8
+        end
+        # "internal" is a name Ruby knows but resolves to nil, "utf-7" is a dummy encoding with no converter.
+        source ||= Encoding::UTF_8
+        begin
+          text.dup.force_encoding(source).encode("UTF-8", invalid: :replace, undef: :replace)
+        rescue EncodingError
+          text.dup.force_encoding(Encoding::UTF_8).encode("UTF-8", invalid: :replace, undef: :replace)
+        end
+      end
+
+      # The params with their strings in UTF-8: a route's param_encoding gives some another
+      # encoding, which the profile must not carry into its JSON.
+      def utf8_params(value)
+        case value
+        when Hash then value.to_h { |k, v| [utf8_params(k), utf8_params(v)] }
+        when Array then value.map { |v| utf8_params(v) }
+        when String
+          value.encoding == Encoding::UTF_8 ? value : value.encode("UTF-8", invalid: :replace, undef: :replace)
+        else value
+        end
+      end
+
       def body_size(captured, total)
         captured_size = captured.to_s.bytesize
         total ||= captured_size

data/lib/profiler/test_runner/run_store.rb

@@ -6,10 +6,18 @@ require_relative "../redaction"
 
 module Profiler
   module TestRunner
+    # Raised by RunStore#create when as many runs as allowed still have their test process.
+    class TooManyRunsError < StandardError; end
+
+    # The runs live in the memory of the process that started them: under a server running
+    # several processes (Puma in cluster mode), a run is only known to the worker that started it.
     class RunStore
       TTL = 3600 # 1 hour
+      # Finished runs kept at most, the oldest dropped first, on top of the TTL.
+      MAX_FINISHED_RUNS = 20
 
-      Run = Struct.new(:id, :status, :pid, :started_at, :finished_at, :output_lines, :exit_code, :files, :framework, keyword_init: true) do
+      # signal: the name of the signal that ended the process ("SIGKILL"), nil when it exited.
+      Run = Struct.new(:id, :status, :pid, :started_at, :finished_at, :output_lines, :exit_code, :signal, :files, :framework, keyword_init: true) do
         def to_h
           super.merge(
             started_at: started_at&.iso8601,
@@ -20,7 +28,9 @@ module Profiler
         end
       end
 
-      TERMINAL_STATUSES = %w[passed failed killed error].freeze
+      # signaled: the process was ended by a signal that did not come from the profiler (out of
+      # memory, a crash, another program), so the tests neither passed nor failed.
+      TERMINAL_STATUSES = %w[passed failed killed signaled error].freeze
       NOT_FOUND = { chunks: [].freeze, status: "not_found", position: 0, finished: true }.freeze
 
       def initialize
@@ -29,25 +39,51 @@ module Profiler
         @held  = Concurrent::Hash.new
         @output_finished = Concurrent::Hash.new
         @held_lock = Mutex.new
+        @output_limits = Concurrent::Hash.new
+        @active = Concurrent::Hash.new
+        @create_lock = Mutex.new
       end
 
-      def create(files:, framework:)
-        id  = SecureRandom.hex(8)
-        run = Run.new(
-          id: id,
-          status: "pending",
-          pid: nil,
-          started_at: Time.now,
-          finished_at: nil,
-          output_lines: Concurrent::Array.new,
-          exit_code: nil,
-          files: files,
-          framework: framework.to_s
-        )
-        @runs[id]  = run
-        @locks[id] = { mutex: Mutex.new, cond: ConditionVariable.new }
-        cleanup_old_runs
-        run
+      # max_active: the run is refused when that many runs still have their test process; a run
+      # counts from here until #release. max_output_bytes: what the run keeps of its output (see
+      # #keep_output). nil for no limit.
+      def create(files:, framework:, max_active: nil, max_output_bytes: nil)
+        @create_lock.synchronize do
+          if max_active && @active.size >= max_active
+            raise TooManyRunsError,
+                  "#{@active.size} test runs are already running, the limit is #{max_active} " \
+                  "(config.test_runner_max_active_runs). Wait for one to end, or stop it."
+          end
+
+          id  = SecureRandom.hex(8)
+          run = Run.new(
+            id: id,
+            status: "pending",
+            pid: nil,
+            started_at: Time.now,
+            finished_at: nil,
+            output_lines: Concurrent::Array.new,
+            exit_code: nil,
+            signal: nil,
+            files: files,
+            framework: framework.to_s
+          )
+          cleanup_old_runs
+          @runs[id]  = run
+          @locks[id] = { mutex: Mutex.new, cond: ConditionVariable.new }
+          @active[id] = true
+          if max_output_bytes
+            tail = max_output_bytes / 4
+            @output_limits[id] = { head: max_output_bytes - tail, tail: tail, kept: 0, after_head: 0, end: nil, end_bytes: 0 }
+          end
+          run
+        end
+      end
+
+      # The test process of the run ended: it no longer counts against max_active.
+      def release(id)
+        @active.delete(id)
+        nil
       end
 
       def find(id)
@@ -88,7 +124,7 @@ module Profiler
           cut = text.bytesize - holdback
           @held[id] = text.byteslice(cut, text.bytesize - cut)
           shown = as_text(text.byteslice(0, cut))
-          run.output_lines.push(shown) unless shown.empty?
+          keep_output(id, run, shown) unless shown.empty?
         end
         signal(id)
       end
@@ -102,7 +138,8 @@ module Profiler
         @held_lock.synchronize do
           @output_finished[id] = true
           rest = @held.delete(id)
-          run.output_lines.push(as_text(rest)) if rest && !rest.empty?
+          keep_output(id, run, as_text(rest)) if rest && !rest.empty?
+          release_tail(id, run)
         end
         signal(id)
       end
@@ -171,10 +208,64 @@ module Profiler
         bytes.dup.force_encoding(Encoding::UTF_8).scrub
       end
 
-      def forget_output(id)
+      # Under a limit, the output is kept as it comes up to the head (the limit less a quarter),
+      # then a marker line is shown at once and only the last quarter is kept, in a buffer
+      # shown by #release_tail once the process printed everything: the summary of a test run is
+      # at its end. Lines only ever get added, so the positions the pages hold stay right.
+      # Called under @held_lock.
+      def keep_output(id, run, text)
+        limit = @output_limits[id]
+        return run.output_lines.push(text) unless limit
+
+        unless limit[:end]
+          room = limit[:head] - limit[:kept]
+          if text.bytesize <= room
+            limit[:kept] += text.bytesize
+            return run.output_lines.push(text)
+          end
+
+          # What fits, without the first bytes of a character the limit cuts in two.
+          head = text.byteslice(0, room).scrub("")
+          run.output_lines.push(head) unless head.empty?
+          run.output_lines.push("\n[Profiler] Output truncated: the run printed more than " \
+                                "#{limit[:head]} bytes. The rest is not kept; its last " \
+                                "#{limit[:tail]} bytes are shown once the run ends.\n")
+          limit[:kept] += head.bytesize
+          limit[:end] = []
+          text = text.byteslice(head.bytesize, text.bytesize - head.bytesize)
+        end
+
+        # The pieces of the end, the oldest dropped while the others hold enough without it.
+        limit[:after_head] += text.bytesize
+        limit[:end] << text
+        limit[:end_bytes] += text.bytesize
+        while limit[:end_bytes] - limit[:end].first.bytesize >= limit[:tail]
+          limit[:end_bytes] -= limit[:end].shift.bytesize
+        end
+      end
+
+      # Shows the end kept past the limit, and lets anything appended later (the profiler's own
+      # lines about the end of the process) through.
+      def release_tail(id, run)
+        limit = @output_limits.delete(id)
+        return unless limit && limit[:end]
+
+        tail = limit[:end].join
+        tail = tail.byteslice(tail.bytesize - limit[:tail], limit[:tail]) if tail.bytesize > limit[:tail]
+        # Dropping from the front can leave the last bytes of a character first.
+        tail = tail.byteslice(1, tail.bytesize - 1) while !tail.empty? && (tail.getbyte(0) & 0xC0) == 0x80
+        left_out = limit[:after_head] - tail.bytesize
+        run.output_lines.push("[Profiler] #{left_out} bytes left out. The last #{tail.bytesize} bytes " \
+                              "of the output:\n")
+        run.output_lines.push(tail.scrub) unless tail.empty?
+      end
+
+      def forget(id)
+        @runs.delete(id)
+        @locks.delete(id)
         @held.delete(id)
         @output_finished.delete(id)
-        true
+        @output_limits.delete(id)
       end
 
       def snapshot(run, position)
@@ -187,9 +278,13 @@ module Profiler
         }
       end
 
+      # Finished runs older than the TTL, and the oldest past MAX_FINISHED_RUNS, are dropped; a
+      # run whose process is still there (killed, still printing) is kept whatever its age.
       def cleanup_old_runs
         cutoff = Time.now - TTL
-        @runs.delete_if { |id, r| r.finished_at && r.finished_at < cutoff && @locks.delete(id) && forget_output(id) }
+        finished = @runs.values.select { |r| r.finished_at && !@active.key?(r.id) }.sort_by(&:finished_at)
+        expired, recent = finished.partition { |r| r.finished_at < cutoff }
+        (expired + recent.first([recent.size - MAX_FINISHED_RUNS, 0].max)).each { |r| forget(r.id) }
       end
     end
 

data/lib/profiler/test_runner/runner.rb

@@ -21,24 +21,49 @@ module Profiler
 
       # Every caller (the HTTP controller, the MCP run_tests tool) goes through here, so the
       # selection is checked once, before any run is recorded or any process is started.
+      # Raises TooManyRunsError when config.test_runner_max_active_runs runs still have their
+      # test process.
       def self.start(files:, framework:)
         validate_files!(files, framework)
-        run = Profiler::TestRunner.run_store.create(files: files, framework: framework)
+        config = Profiler.configuration
+        run = Profiler::TestRunner.run_store.create(
+          files: files, framework: framework,
+          max_active: config.test_runner_max_active_runs,
+          max_output_bytes: config.test_runner_max_output_bytes
+        )
         spawn_async(run)
         run
       end
 
+      # The test process leads its own process group (see run_process): TERM goes to the whole
+      # group, the processes rspec or rails started included, and KILL follows after
+      # config.test_runner_kill_grace_seconds for whatever is still there.
       def self.kill(run_id)
         run = Profiler::TestRunner.run_store.find(run_id)
         return false unless run && run.pid && run.status == "running"
 
         begin
-          Process.kill("TERM", run.pid)
-          Profiler::TestRunner.run_store.update(run_id, status: "killed", finished_at: Time.now)
-          true
+          Process.kill("TERM", -run.pid)
         rescue Errno::ESRCH
           # Process already exited
-          false
+          return false
+        end
+        Profiler::TestRunner.run_store.update(run_id, status: "killed", finished_at: Time.now)
+        kill_group_later(run.pid)
+        true
+      end
+
+      # The group exists as long as one of its processes does. Its id is the pid of the test
+      # process, which the system can give to a new process once the whole group is gone; that
+      # takes the pids to wrap around within the delay, and the new process would have to lead a
+      # group of its own.
+      def self.kill_group_later(pgid)
+        delay = Profiler.configuration.test_runner_kill_grace_seconds.to_f
+        Thread.new do
+          sleep delay
+          Process.kill("KILL", -pgid)
+        rescue Errno::ESRCH, Errno::EPERM
+          nil # the group ended on TERM
         end
       end
 
@@ -123,6 +148,8 @@ module Profiler
             status: "error",
             finished_at: Time.now
           )
+        ensure
+          Profiler::TestRunner.run_store.release(run.id)
         end
       end
 
@@ -132,8 +159,9 @@ module Profiler
 
         Profiler::TestRunner.run_store.update(run.id, status: "running", started_at: Time.now)
 
-        # unsetenv_others: the child gets exactly env, not the ENV of this process
-        IO.popen([env, *cmd, unsetenv_others: true, err: [:child, :out]], "r") do |io|
+        # unsetenv_others: the child gets exactly env, not the ENV of this process. pgroup: the
+        # child leads a process group of its own, which kill stops as a whole.
+        IO.popen([env, *cmd, unsetenv_others: true, pgroup: true, err: [:child, :out]], "r") do |io|
           Profiler::TestRunner.run_store.update(run.id, pid: io.pid)
 
           begin
@@ -148,21 +176,38 @@ module Profiler
           end
         end
 
-        exit_code = $?.exitstatus || 0
+        process_status = $?
+        exit_code = process_status.exitstatus # nil when a signal ended the process
+        signal = signal_name(process_status.termsig) if process_status.signaled?
         # A run killed from the profiler stays killed, whatever the process answered to TERM.
         status = if run.status == "killed" then "killed"
+                 elsif signal then "signaled"
                  elsif exit_code == 0 then "passed"
                  else "failed"
                  end
 
+        if status == "signaled"
+          # Before the status: a page following the run stops at its terminal status.
+          Profiler::TestRunner.run_store.append_output(
+            run.id, "\n[Profiler] The test process was ended by #{signal} before it finished: " \
+                    "the result of the tests is unknown.\n"
+          )
+        end
+
         Profiler::TestRunner.run_store.update(
           run.id,
           status: status,
           finished_at: Time.now,
-          exit_code: exit_code
+          exit_code: exit_code,
+          signal: signal
         )
       end
 
+      def self.signal_name(number)
+        name = Signal.signame(number)
+        name ? "SIG#{name}" : "signal #{number}"
+      end
+
       def self.build_command(files, framework)
         root = project_root
         absolute_files = files.map { |f| File.join(root, f) }

data/lib/profiler/version.rb

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

metadata

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