specwrk 0.20.1 → 0.21.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f54d9828f2a51417c4956185d141b8a3a74876a1379df8701182885ad932c515
-  data.tar.gz: a48f11d3a7977d02a5967e2d674ee68cf54a874a598e48db5b58ca3049ad80ac
+  metadata.gz: ec2663b93b4ed3469ecfaebea825d97a2bd2b6764ccae67bc316efd6de2f53a6
+  data.tar.gz: 23e5e30cb0e6d9644085b0597e36f3c7380baea67ee01aaad70af9341b347fd8
 SHA512:
-  metadata.gz: d013fd261c119d58e7b607c4c9aaddd02c020d45e2ae56776ea111ea3217c248808d1fab8e93b4e440322b1ef9096efdad19de22e79683fa9e5116275ed91ce3
-  data.tar.gz: 2905267a34c6daab6e7f771b61d1bd0c4ffcef368646391ede9e9065e69452c047b4bd88695b930df953a3cbc0beab404cd73185d0f020556c1b09f6c14c5a25
+  metadata.gz: 99066768c088081d7c3c69a52ce51898a4ea7cd533581fc70829f70edc25b423b583d9883dda079070a17c5ef5f135ca330afeb62a6027897650cfc1f2b82318
+  data.tar.gz: c3a606f594a5dc018556149b79846ec3ccee01b89ef016396c327e250aeba6d84cfcb7c1bdfd7b7a9c121f835f5c7818356be5c5cdbef826cc794506dd4bc55b

data/CHANGELOG.md

@@ -1,7 +1,17 @@
 # Changelog
 
-## Unreleased  
-[Compare](https://github.com/danielwestendorf/specwrk/compare/v0.20.1...main)  
+## Unreleased
+[Compare](https://github.com/danielwestendorf/specwrk/compare/v0.21.0...main)
+
+## v0.21.0 — 2026-09-13
+[Compare](https://github.com/danielwestendorf/specwrk/compare/v0.20.2...v0.21.0)
+- Add configurable lifecycle hooks — [#193](https://github.com/danielwestendorf/specwrk/pull/193) by [@danielwestendorf](https://github.com/danielwestendorf)
+- Add opt-in gzip request compression and negotiated gzip responses — [#195](https://github.com/danielwestendorf/specwrk/pull/195) by [@danielwestendorf](https://github.com/danielwestendorf)
+
+## v0.20.2 — 2026-08-27  
+[Compare](https://github.com/danielwestendorf/specwrk/compare/v0.20.1...v0.20.2)  
+- Add a seed option for configuring the target bucket timing duration — [#191](https://github.com/danielwestendorf/specwrk/pull/191) by [@danielwestendorf](https://github.com/danielwestendorf)  
+- Print an indicator while workers wait for outstanding examples to finish — [#192](https://github.com/danielwestendorf/specwrk/pull/192) by [@danielwestendorf](https://github.com/danielwestendorf)  
 
 ## v0.20.1 — 2026-08-23  
 [Compare](https://github.com/danielwestendorf/specwrk/compare/v0.20.0...v0.20.1)  

data/README.md

@@ -53,6 +53,7 @@ Options:
   --run=VALUE, -r VALUE             # The run identifier for this job execution. Overrides SPECWRK_RUN, default: "main"
   --timeout=VALUE, -t VALUE         # The amount of time to wait for the server to respond. Overrides SPECWRK_TIMEOUT, default: "5"
   --network-retries=VALUE           # The number of times to retry in the event of a network failure. Overrides SPECWRK_NETWORK_RETRIES, default: "1"
+  --[no-]http-compression           # Compress large JSON request bodies sent to the server. Overrides SPECWRK_HTTP_COMPRESSION, default: false
   --id=VALUE                        # The identifier for this worker. Overrides SPECWRK_ID. If none provided one in the format of specwrk-worker-8_RAND_CHARS-COUNT_INDEX will be used
   --count=VALUE, -c VALUE           # The number of worker processes you want to start, default: 1
   --output=VALUE, -o VALUE          # Directory where worker output is stored. Overrides SPECWRK_OUT, default: ".specwrk/"
@@ -115,7 +116,9 @@ Options:
   --run=VALUE, -r VALUE             # The run identifier for this job execution. Overrides SPECWRK_RUN, default: "main"
   --timeout=VALUE, -t VALUE         # The amount of time to wait for the server to respond. Overrides SPECWRK_TIMEOUT, default: "5"
   --network-retries=VALUE           # The number of times to retry in the event of a network failure. Overrides SPECWRK_NETWORK_RETRIES, default: "1"
+  --[no-]http-compression           # Compress large JSON request bodies sent to the server. Overrides SPECWRK_HTTP_COMPRESSION, default: false
   --max-retries=VALUE               # Number of times an example will be re-run should it fail, default: 0
+  --target-bucket-timing-duration=VALUE  # Target runtime duration per bucket in seconds, overriding the average timings calculation. Overrides SPECWRK_TARGET_BUCKET_TIMING_DURATION, default: "0"
   --help, -h                        # Print this help
 ```
 
@@ -143,6 +146,7 @@ Options:
   --run=VALUE, -r VALUE             # The run identifier for this job execution. Overrides SPECWRK_RUN, default: "main"
   --timeout=VALUE, -t VALUE         # The amount of time to wait for the server to respond. Overrides SPECWRK_TIMEOUT, default: "5"
   --network-retries=VALUE           # The number of times to retry in the event of a network failure. Overrides SPECWRK_NETWORK_RETRIES, default: "1"
+  --[no-]http-compression           # Compress large JSON request bodies sent to the server. Overrides SPECWRK_HTTP_COMPRESSION, default: false
   --help, -h                        # Print this help
 ```
 
@@ -163,15 +167,40 @@ Description:
 Options:
   --watchfile=VALUE                 # Path to watchfile configuration, default: "Specwrk.watchfile.rb"
   --count=VALUE, -c VALUE           # The number of worker processes you want to start, default: 1
+  --[no-]http-compression           # Compress large JSON request bodies sent to the server. Overrides SPECWRK_HTTP_COMPRESSION, default: false
   --help, -h                        # Print this help
 ```
 
+## Lifecycle hooks
+
+Lifecycle hooks run synchronously in the process performing the corresponding work. Add hook registrations to `Specwrk.hooks.rb` in the directory where you run `specwrk`; the file is loaded automatically by the `seed`, `work`, `serve`, `start`, and `watch` commands. Use `--hooks=path/to/hooks.rb` to load a different file.
+
+The hooks file is ordinary Ruby and is loaded into the parent, server, seed, and worker processes as applicable. Hooks remain process-local and are not serialized between processes.
+
+| Hook Method | Description | Arguments |
+| --- | --- | --- |
+| `Specwrk.before_seed(&blk)` | Runs before seeding examples to the server | none |
+| `Specwrk.after_seed(&blk)` | Runs after seeding examples to the server | `examples` RSpec examples |
+| `Specwrk.before_server_seed(&blk)` | Runs in the server before seeding examples | none |
+| `Specwrk.after_server_seed(&blk)` | Runs in the server after seeding examples | `examples` RSpec examples |
+| `Specwrk.before_worker_fork(&blk)` | Runs in the parent process before spawning each worker | none |
+| `Specwrk.after_worker_fork(&blk)` | Runs in each worker process immediately after it is spawned | none |
+| `Specwrk.before_worker_examples_execute(&blk)` | Runs in a worker before an examples group is passed to the RSpec runner | `examples` RSpec examples in the group |
+| `Specwrk.after_worker_examples_execute(&blk)` | Runs in a worker after an examples group is executed by the RSpec runner | `examples` RSpec examples in the group |
+| `Specwrk.before_worker_exit(&blk)` | Runs in each worker after work completes and before the process exits | `status` Worker exit status |
+| `Specwrk.after_all_workers_exit(&blk)` | Runs in the parent process after all workers exit | `status` Overall worker exit status |
+
+Response compression is negotiated automatically by HTTP clients and the queue server. Request compression is disabled by default; enable it with `--http-compression` or `SPECWRK_HTTP_COMPRESSION=1` on client commands to gzip seed data and worker results that are at least 1 KiB. Set `SPECWRK_HTTP_COMPRESSION_MINIMUM_SIZE` to change this byte threshold. Upgrade the queue server before enabling request compression because it does not fall back when a server cannot decode gzip.
+
 ## Configuring your test environment
 If your test suite tracks state, starts servers, etc. and you plan on running many processes on the same node, you'll need to make
 adjustments to avoid conflicting port usage or database/state mutations.
 
 `specwrk` workers will have `TEST_ENV_NUMBER={i}` set to help you configure approriately.
 
+Workers print `W` without a newline while waiting for outstanding examples to finish. Set
+`SPECWRK_WAITING_OUTPUT=0` to disable this output.
+
 ### Rails
 Rails has had easy multi-process test setup for a while now by creating unique test databases per process. For my rails v7.2 app which uses PostgreSQL and Capybara, I made these changes to my `spec/rails_helper.rb`:
 

data/Specwrk.hooks.rb

@@ -0,0 +1,68 @@
+# specwrk_hook_log = lambda do |event, **details|
+#   specwrk_env = ENV.each_with_object({}) do |(name, value), values|
+#     next unless name.start_with?("SPECWRK_")
+#
+#     values[name] = if name.match?(/KEY|TOKEN|SECRET|PASSWORD/)
+#       "[REDACTED]"
+#     else
+#       value
+#     end
+#   end.sort.to_h
+#
+#   context = {
+#     event: event,
+#     pid: Process.pid,
+#     ppid: Process.ppid,
+#     specwrk_env: specwrk_env
+#   }.merge(details)
+#
+#   puts context.map { |name, value| "#{name}=#{value.inspect}" }.join(" ")
+# end
+#
+# Specwrk.before_seed do
+#   specwrk_hook_log.call("before_seed")
+# end
+#
+# Specwrk.after_seed do |examples|
+#   specwrk_hook_log.call("after_seed", example_count: examples.length)
+# end
+#
+# Specwrk.before_server_seed do
+#   specwrk_hook_log.call("before_server_seed")
+# end
+#
+# Specwrk.after_server_seed do |examples|
+#   specwrk_hook_log.call("after_server_seed", example_count: examples.length)
+# end
+#
+# Specwrk.before_worker_fork do
+#   specwrk_hook_log.call("before_worker_fork")
+# end
+#
+# Specwrk.after_worker_fork do
+#   specwrk_hook_log.call("after_worker_fork")
+# end
+#
+# Specwrk.before_worker_examples_execute do |examples|
+#   specwrk_hook_log.call(
+#     "before_worker_examples_execute",
+#     example_count: examples.length,
+#     example_ids: examples.map { |example| example[:id] }
+#   )
+# end
+#
+# Specwrk.after_worker_examples_execute do |examples|
+#   specwrk_hook_log.call(
+#     "after_worker_examples_execute",
+#     example_count: examples.length,
+#     example_ids: examples.map { |example| example[:id] }
+#   )
+# end
+#
+# Specwrk.before_worker_exit do |status|
+#   specwrk_hook_log.call("before_worker_exit", status: status)
+# end
+#
+# Specwrk.after_all_workers_exit do |status|
+#   specwrk_hook_log.call("after_all_workers_exit", status: status)
+# end

data/lib/specwrk/cli.rb

@@ -14,8 +14,26 @@ module Specwrk
   module CLI
     extend Dry::CLI::Registry
 
+    module HooksConfigurable
+      extend Hookable
+
+      on_included do |base|
+        base.unique_option :hooks, type: :string, default: "Specwrk.hooks.rb", desc: "Path to lifecycle hooks configuration"
+      end
+
+      on_setup do |hooks: "Specwrk.hooks.rb", **|
+        hooks_file = Pathname.new(hooks).expand_path(Dir.pwd).to_s
+        ENV["SPECWRK_HOOKS_FILE"] = hooks_file
+        Hooks.load_file(hooks_file)
+      end
+    end
+
     module WorkerProcesses
       WORKER_INIT_SCRIPT = <<~RUBY
+        require "specwrk"
+        Specwrk::Hooks.load_file(ENV["SPECWRK_HOOKS_FILE"])
+        Specwrk::Hooks.run(:after_worker_fork)
+
         writer = IO.for_fd(Integer(ENV.fetch("SPECWRK_FINAL_FD")))
         $final_output = writer # standard:disable Style/GlobalVars
         $final_output.sync = true # standard:disable Style/GlobalVars
@@ -31,6 +49,7 @@ module Specwrk
         end
 
         status = Specwrk::Worker.run!
+        Specwrk::Hooks.run(:before_worker_exit, status)
         $final_output.close # standard:disable Style/GlobalVars
         exit(status)
       RUBY
@@ -45,6 +64,7 @@ module Specwrk
             "SPECWRK_FINAL_FD" => writer.fileno.to_s
           )
 
+          Hooks.run(:before_worker_fork)
           Process.spawn(
             env, RbConfig.ruby, "-e", WORKER_INIT_SCRIPT,
             writer.fileno => writer,
@@ -95,14 +115,16 @@ module Specwrk
         base.unique_option :run, type: :string, default: ENV.fetch("SPECWRK_RUN", "main"), aliases: ["-r"], desc: "The run identifier for this job execution. Overrides SPECWRK_RUN"
         base.unique_option :timeout, type: :integer, default: ENV.fetch("SPECWRK_TIMEOUT", "5"), aliases: ["-t"], desc: "The amount of time to wait for the server to respond. Overrides SPECWRK_TIMEOUT"
         base.unique_option :network_retries, type: :integer, default: ENV.fetch("SPECWRK_NETWORK_RETRIES", "1"), desc: "The number of times to retry in the event of a network failure. Overrides SPECWRK_NETWORK_RETRIES"
+        base.unique_option :http_compression, type: :boolean, default: ENV.fetch("SPECWRK_HTTP_COMPRESSION", "0") == "1", desc: "Compress large JSON request bodies sent to the server. Overrides SPECWRK_HTTP_COMPRESSION"
       end
 
-      on_setup do |uri:, key:, run:, timeout:, network_retries:, **|
+      on_setup do |uri:, key:, run:, timeout:, network_retries:, http_compression: false, **|
         ENV["SPECWRK_SRV_URI"] = uri
         ENV["SPECWRK_SRV_KEY"] = key
         ENV["SPECWRK_RUN"] = run
         ENV["SPECWRK_TIMEOUT"] = timeout
         ENV["SPECWRK_NETWORK_RETRIES"] = network_retries
+        ENV["SPECWRK_HTTP_COMPRESSION"] = http_compression ? "1" : "0"
       end
     end
 
@@ -164,12 +186,14 @@ module Specwrk
 
     class Seed < Dry::CLI::Command
       include Clientable
+      include HooksConfigurable
 
       desc "Seed the server with a list of specs for the run"
       option :max_retries, default: 0, desc: "Number of times an example will be re-run should it fail"
+      option :target_bucket_timing_duration, default: ENV.fetch("SPECWRK_TARGET_BUCKET_TIMING_DURATION", "0"), desc: "Target runtime duration per bucket in seconds, overriding the average timings calculation. Overrides SPECWRK_TARGET_BUCKET_TIMING_DURATION"
       argument :dir, type: :array, required: false, desc: "Relative spec directory to run against, default: spec/"
 
-      def call(max_retries:, dir:, **args)
+      def call(max_retries:, dir:, target_bucket_timing_duration:, **args)
         dir = ["spec"] if dir.length.zero?
 
         self.class.setup(**args)
@@ -178,10 +202,12 @@ module Specwrk
         require "specwrk/client"
 
         ENV["SPECWRK_SEED"] = "1"
+        target_bucket_timing_duration = Float(target_bucket_timing_duration)
+        ENV["SPECWRK_TARGET_BUCKET_TIMING_DURATION"] = target_bucket_timing_duration.to_s
         examples = ListExamples.new(dir).examples
 
         Client.wait_for_server!
-        Client.new.seed(examples, max_retries)
+        Client.new.seed(examples, max_retries, target_bucket_timing_duration: target_bucket_timing_duration)
         file_count = examples.group_by { |e| e[:file_path] }.keys.size
         puts "🌱 Seeded #{examples.size} examples across #{file_count} files"
       rescue Errno::ECONNREFUSED
@@ -196,6 +222,7 @@ module Specwrk
     class Work < Dry::CLI::Command
       include Workable
       include Clientable
+      include HooksConfigurable
 
       desc "Start one or more worker processes"
 
@@ -213,7 +240,10 @@ module Specwrk
       end
 
       def wait_for_workers_exit
-        @exited_pids = Specwrk.wait_for_pids_exit(@worker_pids)
+        Specwrk.wait_for_pids_exit(@worker_pids).tap do |exited_pids|
+          @exited_pids = exited_pids
+          Hooks.run(:after_all_workers_exit, status)
+        end
       end
 
       def status
@@ -223,6 +253,7 @@ module Specwrk
 
     class Serve < Dry::CLI::Command
       include Servable
+      include HooksConfigurable
 
       desc "Start a queue server"
       option :single_run, type: :boolean, default: false, desc: "Act on shutdown requests from clients"
@@ -243,9 +274,12 @@ module Specwrk
       include Clientable
       include Workable
       include Servable
+      include HooksConfigurable
 
       SEED_INIT_SCRIPT = <<~'RUBY'
         require "json"
+        require "specwrk"
+        Specwrk::Hooks.load_file(ENV["SPECWRK_HOOKS_FILE"])
         require "specwrk/list_examples"
         require "specwrk/client"
 
@@ -344,8 +378,11 @@ module Specwrk
     class Watch < Dry::CLI::Command
       include WorkerProcesses
       include PortDiscoverable
+      include HooksConfigurable
 
       SEED_LOOP_INIT_SCRIPT = <<~RUBY
+        require "specwrk"
+        Specwrk::Hooks.load_file(ENV["SPECWRK_HOOKS_FILE"])
         require "specwrk/ipc"
         require "specwrk/seed_loop"
 
@@ -359,8 +396,9 @@ module Specwrk
       desc "Start a server and workers, watch for file changes in the current directory, and execute specs"
       option :watchfile, type: :string, default: "Specwrk.watchfile.rb", desc: "Path to watchfile configuration"
       option :count, type: :integer, default: 1, aliases: ["-c"], desc: "The number of worker processes you want to start"
+      option :http_compression, type: :boolean, default: ENV.fetch("SPECWRK_HTTP_COMPRESSION", "0") == "1", desc: "Compress large JSON request bodies sent to the server. Overrides SPECWRK_HTTP_COMPRESSION"
 
-      def call(count:, watchfile:, **args)
+      def call(count:, watchfile:, http_compression: false, **args)
         $stdout.sync = true
 
         # nil this env var if it exists to prevent never-ending workers
@@ -374,6 +412,9 @@ module Specwrk
         ENV["SPECWRK_MAX_BUCKET_SIZE"] = "1"
         ENV["SPECWRK_COUNT"] = count.to_s
         ENV["SPECWRK_RUN"] = "watch"
+        ENV["SPECWRK_HTTP_COMPRESSION"] = http_compression ? "1" : "0"
+
+        self.class.setup(**args)
 
         web_pid
 

data/lib/specwrk/client.rb

@@ -3,6 +3,7 @@
 require "uri"
 require "net/http"
 require "json"
+require "zlib"
 
 require "specwrk"
 
@@ -13,6 +14,7 @@ Specwrk.net_http = Net::HTTP
 module Specwrk
   class Client
     LockedResponseError = Class.new(StandardError)
+    HTTP_COMPRESSION_MINIMUM_SIZE = 1024
 
     def self.connect?
       http = build_http
@@ -119,8 +121,12 @@ module Specwrk
       end
     end
 
-    def seed(examples, max_retries)
-      response = post "/seed", body: {max_retries: max_retries, examples: examples}.to_json
+    def seed(examples, max_retries, target_bucket_timing_duration: 0)
+      response = post "/seed", body: {
+        max_retries: max_retries,
+        examples: examples,
+        target_bucket_timing_duration: target_bucket_timing_duration
+      }.to_json
 
       (response.code == "200") ? true : raise(UnhandledResponseError.new("#{response.code}: #{response.body}"))
     end
@@ -128,56 +134,64 @@ module Specwrk
     private
 
     def get(path, headers: default_headers, body: nil)
-      request = Specwrk.net_http::Get.new(path, headers)
-      request.body = body if body
-
-      make_request(request)
+      make_request Specwrk.net_http::Get, path, headers: headers, body: body
     end
 
     def post(path, headers: default_headers, body: nil)
-      request = Specwrk.net_http::Post.new(path, headers)
-      request.body = body if body
-
-      make_request(request)
+      make_request Specwrk.net_http::Post, path, headers: headers, body: body
     end
 
     def put(path, headers: default_headers, body: nil)
-      request = Specwrk.net_http::Put.new(path, headers)
-      request.body = body if body
-
-      make_request(request)
+      make_request Specwrk.net_http::Put, path, headers: headers, body: body
     end
 
     def delete(path, headers: default_headers, body: nil)
-      request = Specwrk.net_http::Delete.new(path, headers)
-      request.body = body if body
-
-      make_request(request)
+      make_request Specwrk.net_http::Delete, path, headers: headers, body: body
     end
 
-    def make_request(request)
-      @mutex.synchronize do
-        @last_request_at = Time.now
-        @http.request(request).tap do |response|
-          @retry_count = 0
-          raise LockedResponseError if response.code == "423"
+    def make_request(request_class, path, headers:, body:)
+      headers = headers.dup
 
-          @worker_status = response["x-specwrk-status"].to_i if response["x-specwrk-status"]
-        end
+      if http_compression? && headers["Content-Type"] == "application/json" && body&.bytesize.to_i >= http_compression_minimum_size
+        body = Zlib.gzip(body)
+        headers["Content-Encoding"] = "gzip"
       end
-    rescue LockedResponseError
-      sleep rand
-      retry
-    rescue Net::ReadTimeout, Net::WriteTimeout => e
-      @retry_count ||= 0
 
-      raise e if @retry_count == ENV["SPECWRK_NETWORK_RETRIES"].to_i
-      @retry_count += 1
+      request = request_class.new(path, headers)
+      request.body = body if body
 
-      warn e
-      sleep @retry_count
+      begin
+        @mutex.synchronize do
+          @last_request_at = Time.now
+          @http.request(request).tap do |response|
+            @retry_count = 0
+            raise LockedResponseError if response.code == "423"
+
+            @worker_status = response["x-specwrk-status"].to_i if response["x-specwrk-status"]
+          end
+        end
+      rescue LockedResponseError
+        sleep rand
+        retry
+      rescue Net::ReadTimeout, Net::WriteTimeout => e
+        @retry_count ||= 0
+
+        raise e if @retry_count == ENV["SPECWRK_NETWORK_RETRIES"].to_i
+        @retry_count += 1
+
+        warn e
+        sleep @retry_count
+
+        retry
+      end
+    end
+
+    def http_compression?
+      ENV.fetch("SPECWRK_HTTP_COMPRESSION", "0") == "1"
+    end
 
-      retry
+    def http_compression_minimum_size
+      ENV.fetch("SPECWRK_HTTP_COMPRESSION_MINIMUM_SIZE", HTTP_COMPRESSION_MINIMUM_SIZE).to_i
     end
 
     def default_headers

data/lib/specwrk/hooks.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Specwrk
+  module Hooks
+    class << self
+      def register(name, &block)
+        raise ArgumentError, "a block is required" unless block
+
+        hooks[name] << block
+        block
+      end
+
+      def run(name, *objects)
+        hooks.fetch(name, []).dup.each { |hook| hook.call(*objects) }
+        nil
+      end
+
+      def load_file(file)
+        Kernel.load(file) if file && File.file?(file)
+      end
+
+      def reset!
+        @hooks = nil
+      end
+
+      private
+
+      def hooks
+        @hooks ||= Hash.new { |registry, name| registry[name] = [] }
+      end
+    end
+  end
+end

data/lib/specwrk/seed_loop.rb

@@ -6,6 +6,7 @@ require "specwrk/client"
 module Specwrk
   class SeedLoop
     def self.loop!(ipc)
+      Hooks.run(:before_seed)
       Client.wait_for_server!
 
       loop do
@@ -18,6 +19,7 @@ module Specwrk
 
         client = Client.new
         client.seed(examples, 0)
+        Hooks.run(:after_seed, examples)
         client.close
 
         ipc.write examples.length

data/lib/specwrk/store/pending_store.rb

@@ -19,6 +19,17 @@ module Specwrk
       @run_time_bucket_maximum ||= self[RUN_TIME_BUCKET_MAXIMUM_KEY]
     end
 
+    def update_run_time_bucket_maximum(calculated_run_time_bucket_maximum, target_bucket_timing_duration: 0)
+      target_bucket_timing_duration = target_bucket_timing_duration.to_f
+
+      if target_bucket_timing_duration.positive?
+        self.run_time_bucket_maximum = target_bucket_timing_duration
+      else
+        run_time_bucket_maximums = [run_time_bucket_maximum, calculated_run_time_bucket_maximum.to_f].compact
+        self.run_time_bucket_maximum = run_time_bucket_maximums.sum.to_f / run_time_bucket_maximums.length.to_f
+      end
+    end
+
     def max_retries=(val)
       @max_retries = self[MAX_RETRIES_KEY] = val
     end

data/lib/specwrk/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Specwrk
-  VERSION = "0.20.1"
+  VERSION = "0.21.0"
 end

data/lib/specwrk/web/app.rb

@@ -5,6 +5,7 @@ require "fileutils"
 
 require "webrick"
 require "rack"
+require "rack/deflater"
 
 # rack v3 or v2
 begin
@@ -67,6 +68,8 @@ module Specwrk
 
         def rackup
           Rack::Builder.new do
+            use Rack::Deflater, include: ["application/json"]
+
             if ENV["SPECWRK_SRV_VERBOSE"]
               use Rack::Runtime
               use Specwrk::Web::Logger, $stdout, %w[/health]

data/lib/specwrk/web/endpoints/base.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "json"
+require "zlib"
 
 require "specwrk/store"
 
@@ -9,6 +10,8 @@ module Specwrk
     module Endpoints
       class Base
         MUTEX = Mutex.new
+        InvalidGzipError = Class.new(StandardError)
+        UnsupportedContentEncodingError = Class.new(StandardError)
 
         attr_reader :started_at
 
@@ -32,6 +35,10 @@ module Specwrk
           end
         rescue Store::LockUnavailableError
           locked
+        rescue InvalidGzipError
+          [400, {"content-type" => "text/plain"}, ["Invalid gzip request body"]]
+        rescue UnsupportedContentEncodingError
+          [415, {"content-type" => "text/plain"}, ["Unsupported content encoding"]]
         end
 
         def with_response
@@ -75,7 +82,21 @@ module Specwrk
         end
 
         def body
-          @body ||= request.body.read
+          @body ||= begin
+            body = request.body.read
+            encoding = request.get_header("HTTP_CONTENT_ENCODING")&.strip&.downcase
+
+            case encoding
+            when nil, "", "identity"
+              body
+            when "gzip"
+              Zlib.gunzip(body)
+            else
+              raise UnsupportedContentEncodingError
+            end
+          rescue Zlib::Error
+            raise InvalidGzipError
+          end
         end
 
         def pending

data/lib/specwrk/web/endpoints/seed.rb

@@ -7,6 +7,7 @@ module Specwrk
     module Endpoints
       class Seed < Base
         def with_response
+          Hooks.run(:before_server_seed)
           examples_with_run_times
 
           pending.clear
@@ -16,13 +17,16 @@ module Specwrk
 
           pending.max_retries = payload.fetch(:max_retries, "0").to_i
 
-          new_run_time_bucket_maximums = [pending.run_time_bucket_maximum, @seeds_run_time_bucket_maximum.to_f].compact
-          pending.run_time_bucket_maximum = new_run_time_bucket_maximums.sum.to_f / new_run_time_bucket_maximums.length.to_f
+          pending.update_run_time_bucket_maximum(
+            @seeds_run_time_bucket_maximum,
+            target_bucket_timing_duration: payload.fetch(:target_bucket_timing_duration, 0)
+          )
 
           with_lock do
             pending.merge!(examples_with_run_times)
           end
 
+          Hooks.run(:after_server_seed, payload[:examples])
           ok
         end
 

data/lib/specwrk/worker/executor.rb

@@ -25,7 +25,10 @@ module Specwrk
         example_ids = examples.map { |example| example[:id] }
 
         options = RSpec::Core::ConfigurationOptions.new ["--format", "Specwrk::Worker::NullFormatter"] + example_ids
-        RSpec::Core::Runner.new(options).run($stderr, $stdout)
+        Hooks.run(:before_worker_examples_execute, examples)
+        RSpec::Core::Runner.new(options).run($stderr, $stdout).tap do
+          Hooks.run(:after_worker_examples_execute, examples)
+        end
       end
 
       # https://github.com/skroutz/rspecq/blob/341383ce3ca25f42fad5483cbb6a00ba1c405570/lib/rspecq/worker.rb#L208-L224

data/lib/specwrk/worker.rb

@@ -40,6 +40,7 @@ module Specwrk
         # Wait for the other processes (workers) on the same host to finish
         # This will cause workers to 'hang' until all work has been completed
         # TODO: break here if all the other worker processes on this host are done executing examples
+        $stdout.printf "W" unless ENV.fetch("SPECWRK_WAITING_OUTPUT", "1") == "0"
         sleep 0.5
       rescue WaitingForSeedError
         @seed_wait_count ||= 0

data/lib/specwrk.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "specwrk/version"
+require "specwrk/hooks"
 
 module Specwrk
   Error = Class.new(StandardError)
@@ -19,6 +20,46 @@ module Specwrk
     attr_accessor :force_quit, :net_http
     attr_reader :starting_pid
 
+    def before_seed(&block)
+      Hooks.register(:before_seed, &block)
+    end
+
+    def after_seed(&block)
+      Hooks.register(:after_seed, &block)
+    end
+
+    def before_server_seed(&block)
+      Hooks.register(:before_server_seed, &block)
+    end
+
+    def after_server_seed(&block)
+      Hooks.register(:after_server_seed, &block)
+    end
+
+    def before_worker_fork(&block)
+      Hooks.register(:before_worker_fork, &block)
+    end
+
+    def after_worker_fork(&block)
+      Hooks.register(:after_worker_fork, &block)
+    end
+
+    def before_worker_examples_execute(&block)
+      Hooks.register(:before_worker_examples_execute, &block)
+    end
+
+    def after_worker_examples_execute(&block)
+      Hooks.register(:after_worker_examples_execute, &block)
+    end
+
+    def before_worker_exit(&block)
+      Hooks.register(:before_worker_exit, &block)
+    end
+
+    def after_all_workers_exit(&block)
+      Hooks.register(:after_all_workers_exit, &block)
+    end
+
     def wait_for_pids_exit(pids)
       exited_pids = {}
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: specwrk
 version: !ruby/object:Gem::Version
-  version: 0.20.1
+  version: 0.21.0
 platform: ruby
 authors:
 - Daniel Westendorf
@@ -206,6 +206,7 @@ files:
 - README.md
 - RELEASING.md
 - Rakefile
+- Specwrk.hooks.rb
 - Specwrk.watchfile.rb
 - config.ru
 - docker/Dockerfile.server
@@ -220,6 +221,7 @@ files:
 - lib/specwrk/cli_reporter.rb
 - lib/specwrk/client.rb
 - lib/specwrk/hookable.rb
+- lib/specwrk/hooks.rb
 - lib/specwrk/ipc.rb
 - lib/specwrk/list_examples.rb
 - lib/specwrk/seed_loop.rb