wurk 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: ccc98d05b27f80d2950f50c1a6275c4118bf335094a35442dd9a527cc11d3b90
+  data.tar.gz: 44689a145f4e136572a6c896c6aecbcf53b48444f76d74d4e204412ade2f6417
+SHA512:
+  metadata.gz: 031d251be8efbd5a640f062e6fe8cd95705cc60e814a88f237500312c839cc3200f5fa868408904cf2614dffd0cd5e8ee9d1966d802846a000ea578c285af606
+  data.tar.gz: b0c73f74ced829f68b730861bd4f9c9976ba5693d2adf17378e0433f7b3b910acbf1944d1988eb640db7d2494c16baad2609d7729ab3998f814b87a9d0e77ca1

data/CHANGELOG.md

@@ -0,0 +1,43 @@
+# Changelog
+
+All notable changes to Wurk are recorded here. Format: [Keep a Changelog](https://keepachangelog.com/en/1.1.0/). Versioning: [Semantic Versioning](https://semver.org/).
+
+## [Unreleased]
+
+### Added
+- `Sidekiq::Testing` drop-in: `inline!` / `fake!` / `disable!` (global or block-scoped), the in-memory `Sidekiq::Queues` store, and the `Worker`/`Job` test helpers (`.jobs`, `.clear`, `.drain`, `.perform_one`, `.process_job`, `.drain_all`, `.clear_all`) + `Sidekiq::EmptyQueueError`.
+
+## [0.0.1] - 2026-06-01
+
+First public (pre-1.0) release. Wurk is a 100% API-compatible drop-in replacement for Sidekiq + Sidekiq Pro + Sidekiq Enterprise — same Redis key schema, same job JSON, same Ruby DSL — with fork-based real parallelism, the full Pro + Enterprise feature set in one free gem (no license check), and a precompiled React dashboard.
+
+### Runtime
+- Fork-based Swarm: parent forks N children with PID supervision, rolling restart (SIGUSR1), graceful drain (SIGTERM/SIGINT) to `shutdown_timeout`, and global pause/resume (SIGTSTP/SIGCONT).
+- Reliable fetcher — atomic `BLMOVE` from the main queue to a per-process private list — with orphan reclamation on boot; Processor runs the middleware chain; Manager owns the thread pool, lifecycle, and heartbeat.
+- Scheduled-set and retry pollers; EVALSHA-cached Lua on the hot paths; per-fork Redis pool over redis-client; Redis-outage client buffer.
+- `reliable_push` opt-in `:raise` overflow policy with a background drainer.
+- Cluster leader election with periodic firing consolidated onto the leader.
+- StatsD metrics across hot paths; liveness HTTP endpoint for Kubernetes probes; expired-job counter for `expires_in`.
+
+### Batches
+- Sidekiq Pro Batch API: `on(:success/:complete/:death)` callbacks, live progress, nested batches, autoflush + linger, nested death cascade, and per-callback rescue.
+
+### Limiters
+- Enterprise rate limiters — concurrent, bucket, window, leaky, and points — each exposing a uniform live `#status` (`used`/`limit`/`reset_at`/`available?`); concurrent additionally reports metric counters. Includes a poison-pill brake.
+
+### Periodic
+- Cron loops (sidekiq-cron compatible): schedule parsing with timezone/DST handling, leader-gated firing, pause/resume, enqueue-now, and fire history.
+
+### Encryption
+- Transparent job-payload encryption with key rotation and graceful failure modes (a decryption failure degrades rather than crashing the worker).
+
+### Dashboard
+- Precompiled React + TypeScript SPA mounted under the engine — consumers never run Node. Tabs: queues, retries, scheduled, dead, busy, processes, batches (+ per-batch detail), limiters, periodic, metrics, and search. SSE live updates, read-only mode, pagination, i18n with host-app override, and a dark default theme.
+
+### Compat
+- `Sidekiq::*` aliases for every public `Wurk::*` class (`Sidekiq::Worker`, `Sidekiq::Batch`, `Sidekiq::Limiter`, `Sidekiq.configure_server`, …) — the drop-in contract.
+- ActiveJob adapter, `IterableJob`, embedded mode, and a standalone `exe/wurk` runner.
+- Sidekiq client/server middleware contract; third-party ecosystem suites (sidekiq-cron, sidekiq-unique-jobs, sidekiq-scheduler, sidekiq-status, sidekiq-failures, sidekiq-throttled) pass against Wurk.
+
+[Unreleased]: https://github.com/developerz-ai/wurk/compare/v0.0.1...HEAD
+[0.0.1]: https://github.com/developerz-ai/wurk/releases/tag/v0.0.1

data/CONTRIBUTING.md

@@ -0,0 +1,73 @@
+# Contributing to Wurk
+
+Thanks for helping make Wurk better. This guide covers local setup, the test
+layers, and the conventions a change has to follow to merge.
+
+## Setup
+
+```sh
+git clone https://github.com/developerz-ai/wurk
+cd wurk
+bundle install
+```
+
+You'll need a local **Redis ≥ 7.0** running (tests use real Redis, never a mock).
+Node is only needed if you touch the dashboard frontend (`frontend/`); the
+precompiled bundle is committed under `vendor/assets/`.
+
+## Running the tests
+
+| Task | Command |
+|---|---|
+| Full suite (parallel) | `bin/rake test` |
+| A single file | `bin/rake test TEST=test/path/to/file_test.rb` |
+| A single test by name | `bin/rake test TEST=test/foo_test.rb TESTOPTS="--name=/pattern/"` |
+| Parity suite (oracles lifted from Sidekiq) | `bin/rake test:parity` |
+| Ecosystem compatibility | `bin/rake test:ecosystem` |
+| Coverage gate | `COVERAGE=1 bin/rake test` |
+| Benchmarks | `bin/rake bench` |
+| Lint | `bundle exec rubocop` |
+
+Test layers:
+
+- **unit** — plain Ruby classes in isolation.
+- **engine** — boots the dummy Rails app in `test/dummy/`.
+- **integration** — real forks + real Redis.
+- **parity** (`test/parity/`) — tests lifted from upstream Sidekiq, SHA-pinned.
+  These are **oracles**: if Wurk diverges, Wurk is wrong unless the divergence
+  is explicitly documented as intentional.
+- **ecosystem** — third-party Sidekiq gem suites run against Wurk.
+
+Never mock Redis in integration or parity tests. Each test uses a unique Redis
+key namespace so the parallel runner stays safe.
+
+## Conventions
+
+These are non-negotiable — they're what keep Wurk a true drop-in:
+
+- **Wire-compat is sacred.** Never change a Redis key, JSON field, or
+  sorted-set score format. If an optimization would break compatibility, drop
+  the optimization.
+- **SOLID, especially SRP.** One reason to change per class — Manager owns
+  lifecycle, Fetcher owns the Redis pop, Processor owns middleware + perform,
+  Client owns enqueue.
+- **Match the spec.** Any public Sidekiq surface must match
+  `docs/target/sidekiq-{free,pro,ent}.md` exactly.
+- **Frozen string literals everywhere**; per-fork Redis pools (never share a
+  socket across a fork).
+- **Comments explain non-obvious _why_**, never restate the code.
+- **Coverage**: line coverage on `lib/` must stay ≥ 90% (the gate blocks PRs
+  below it). Branch coverage is tracked and ratcheting toward 90%.
+
+## Pull requests
+
+1. Branch off `main`.
+2. Keep the change focused; add tests at the right layer.
+3. Run `bin/rake test`, `bin/rake test:parity`, `bin/rake test:ecosystem`, and `bundle exec rubocop` locally.
+4. Open the PR — CI runs the matrix (Ruby 3.2/3.3/3.4 × Rails 7.2/8.0), the
+   coverage gate, the parity job, and benchmarks. The bench bot comments
+   per-benchmark deltas; a real regression fails the check.
+5. Don't `--no-verify` past a failing hook — fix the hook.
+
+By contributing you agree your work is licensed under the project's
+[MIT License](LICENSE).

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 developerz.ai
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,137 @@
+# Wurk ⚡
+
+**A 100% drop-in replacement for Sidekiq + Sidekiq Pro + Sidekiq Enterprise. Free forever. Faster.**
+
+[![Gem Version](https://img.shields.io/gem/v/wurk.svg)](https://rubygems.org/gems/wurk)
+[![CI](https://github.com/developerz-ai/wurk/actions/workflows/test.yml/badge.svg)](https://github.com/developerz-ai/wurk/actions/workflows/test.yml)
+[![Coverage gate](https://img.shields.io/badge/coverage%20gate-line%20%E2%89%A590%25-brightgreen.svg)](https://github.com/developerz-ai/wurk/actions/workflows/test.yml)
+[![Ruby](https://img.shields.io/badge/ruby-%E2%89%A5%203.2-CC342D.svg)](https://www.ruby-lang.org)
+[![License: MIT](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE)
+
+Wurk is wire-compatible with Sidekiq — same Redis keys, same job JSON, same Ruby DSL. Swap one line in your `Gemfile` and your existing jobs, batches, limiters, cron entries, and live Redis data keep working untouched. The Pro and Enterprise feature sets ship in the same free gem, with no license check and no tiers.
+
+## Install
+
+```ruby
+# Gemfile
+gem "wurk"
+```
+
+```diff
+# ...or drop in over an existing Sidekiq stack — delete these, add one line:
+- gem "sidekiq"
+- gem "sidekiq-pro", source: "https://gems.contribsys.com/"
+- gem "sidekiq-ent", source: "https://enterprise.contribsys.com/"
++ gem "wurk"
+```
+
+`bundle install && restart`. That's it — `Sidekiq::Worker`, `Sidekiq::Batch`, `Sidekiq::Limiter`, `Sidekiq.configure_server`, and friends all resolve to Wurk.
+
+## Feature matrix
+
+Everything below is in the one free gem. The "Sidekiq tier" column is only there to show what you'd otherwise pay for.
+
+| Area | What you get | Sidekiq tier |
+|---|---|---|
+| **Runtime** | Fork-based real parallelism, reliable `BLMOVE` fetch, PID supervision, rolling restarts, graceful drain, scheduled/retry pollers | OSS + Pro |
+| **Batches** | `Sidekiq::Batch` with `on(:success/:complete/:death)` callbacks, nested batches, progress | Pro |
+| **Limiters** | Concurrent, bucket, window, leaky, and points rate limiters via `Sidekiq::Limiter` | Enterprise |
+| **Periodic** | Cron/periodic jobs, leader-elected so each tick fires exactly once across the cluster | Enterprise |
+| **Encryption** | Transparent AES-256-GCM job-argument encryption with zero-downtime key rotation | Enterprise |
+| **Dashboard** | Mountable Rails engine, precompiled React SPA (no Node needed), live SSE, charts, host-app auth hook | OSS + Pro/Ent |
+
+Plus Wurk extras: a worker topology DSL, a Kubernetes liveness/readiness listener, and opt-in AI dashboard panes (anomaly detection, NL queries, backlog forecasting).
+
+## Documentation
+
+- **[Getting started & architecture](https://github.com/developerz-ai/wurk/blob/main/docs/idea/01-overview.md)** — how the swarm, manager, fetcher, and processor fit together.
+- **[Migrating from Sidekiq](#migrating-from-sidekiq)** — the one-line swap and what to expect.
+- **API reference (parity specs):** [Sidekiq OSS](https://github.com/developerz-ai/wurk/blob/main/docs/target/sidekiq-free.md) · [Pro](https://github.com/developerz-ai/wurk/blob/main/docs/target/sidekiq-pro.md) · [Enterprise](https://github.com/developerz-ai/wurk/blob/main/docs/target/sidekiq-ent.md) — the authoritative surface Wurk matches exactly.
+- **[Securing the dashboard](https://github.com/developerz-ai/wurk/blob/main/docs/dashboard.md)** · **[Metrics history](https://github.com/developerz-ai/wurk/blob/main/docs/metrics-history.md)**
+- **Live demo:** [wurk.demo.developerz.ai](https://wurk.demo.developerz.ai)
+
+## Requirements
+
+| Component | Minimum |
+|---|---|
+| Ruby | `>= 3.2.0` |
+| Redis | `>= 7.0.0` |
+
+JRuby, TruffleRuby, and Windows fall back to threads-only mode (no fork) — behaviorally equivalent to stock Sidekiq.
+
+## The dashboard
+
+Mount the engine wherever you like:
+
+```ruby
+# config/routes.rb
+mount Wurk::Engine => "/wurk"
+```
+
+The precompiled SPA ships inside the gem, so consumers never run Node. Gate it behind your app's auth with one line — see **[Securing the dashboard](https://github.com/developerz-ai/wurk/blob/main/docs/dashboard.md)** for Devise/Warden/Sorcery recipes:
+
+```ruby
+Wurk::Web.use(Rack::Auth::Basic, "Wurk") { |user, pass| user == ENV["WURK_USER"] && pass == ENV["WURK_PASS"] }
+```
+
+Ship a viewer-only board (e.g. a public demo) with no auth code at all by setting `WURK_WEB_READ_ONLY=1` — every mutating request returns 403 and the SPA hides destructive actions.
+
+## Encryption
+
+A drop-in for `Sidekiq::Enterprise::Crypto`. It encrypts the **last** positional argument of a job with AES-256-GCM — the client middleware seals it on push, the server middleware opens it before `perform`. Earlier args stay plaintext so you can still triage on `user_id`.
+
+```ruby
+# config/initializers/wurk.rb — point at any key source (file, ENV, KMS)
+Sidekiq::Enterprise::Crypto.enable(active_version: 1) do |version|
+  File.binread("config/crypto/secret.#{Rails.env}.#{version}.key") # exactly 32 bytes
+end
+```
+
+```ruby
+class ChargeCardJob
+  include Sidekiq::Job
+  sidekiq_options encrypt: true
+
+  def perform(user_id, secret_bag) # secret_bag arrives already decrypted
+    Payments.charge(user_id, secret_bag["pan"], secret_bag["cvv"])
+  end
+end
+```
+
+Keys rotate without downtime — keep every still-in-flight version resolvable so old jobs decrypt, then bump `active_version`. A job that can't be decrypted (key rotated away, corrupt ciphertext) goes **straight to the dead set in under a second** rather than crash-looping through 25 retries, with the still-encrypted payload preserved for replay. The dashboard renders encrypted args as `"<encrypted>"`; cleartext is never written to Redis.
+
+## Kubernetes probes
+
+Opt in to a thin HTTP listener for liveness/readiness:
+
+```ruby
+Wurk.configure_server do |config|
+  config.health_check(port: 7433)
+end
+```
+
+| Path | Meaning |
+|---|---|
+| `/live` | 200 while the Launcher is running; 503 once `stop`/`quiet` is called. |
+| `/ready` | 200 only when Redis is reachable **and** the heartbeat fired within `ready_window` (default 30s); 503 otherwise. |
+
+Knobs: `health_check(port:, bind: "0.0.0.0", ready_window: 30)`. In swarm mode only the first child to `start` binds the port.
+
+## Migrating from Sidekiq
+
+```diff
+- gem "sidekiq"
+- gem "sidekiq-pro", source: "https://gems.contribsys.com/"
+- gem "sidekiq-ent", source: "https://enterprise.contribsys.com/"
++ gem "wurk"
+```
+
+`bundle install && restart`. Wurk reads and writes the same Redis schema, so a rolling deploy can run Sidekiq and Wurk against the same Redis during the cutover. Third-party gems (sidekiq-cron, sidekiq-unique-jobs, sidekiq-scheduler, sidekiq-status, sidekiq-failures, sidekiq-throttled, …) are exercised by running their own upstream suites against Wurk in the [`ecosystem` CI job](https://github.com/developerz-ai/wurk/blob/main/.github/workflows/ecosystem.yml) (see [`test/ecosystem/`](https://github.com/developerz-ai/wurk/tree/main/test/ecosystem)).
+
+## Contributing
+
+Issues and pull requests are welcome — see **[CONTRIBUTING.md](https://github.com/developerz-ai/wurk/blob/main/CONTRIBUTING.md)** for the dev setup, test layers, and conventions, and **[SECURITY.md](https://github.com/developerz-ai/wurk/blob/main/SECURITY.md)** to report a vulnerability.
+
+## License
+
+MIT. See [LICENSE](https://github.com/developerz-ai/wurk/blob/main/LICENSE).

data/SECURITY.md

@@ -0,0 +1,39 @@
+# Security Policy
+
+## Supported versions
+
+Wurk follows semantic versioning. Security fixes land on the latest minor
+release line.
+
+| Version | Supported |
+|---|---|
+| 1.x | ✅ |
+| < 1.0 | ❌ |
+
+## Reporting a vulnerability
+
+**Please do not open a public issue for security vulnerabilities.**
+
+Report privately through GitHub's
+[**Report a vulnerability**](https://github.com/developerz-ai/wurk/security/advisories/new)
+form (Security → Advisories). This opens a private advisory only the
+maintainers can see.
+
+Please include:
+
+- a description of the issue and its impact,
+- the affected version(s),
+- steps to reproduce or a proof of concept,
+- any suggested remediation.
+
+## What to expect
+
+- **Acknowledgement** within 3 business days.
+- An initial assessment and severity within 7 days.
+- Coordinated disclosure: we'll agree on a timeline with you, ship a patched
+  release, and credit you in the advisory and `CHANGELOG.md` unless you prefer
+  to remain anonymous.
+
+Because Wurk is wire-compatible with Sidekiq and runs your job code with access
+to Redis, reports about deserialization, the dashboard's auth surface, or
+argument encryption are especially welcome.

data/app/controllers/wurk/api/pagination.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module Wurk
+  module Api
+    # Pagination helpers shared by every listing endpoint. The contract:
+    #   * `?count=` page size (default 25, clamped to 1..200)
+    #   * `?page=`  0-indexed page number
+    #   * `?substr=` case-insensitive klass/jid filter on the page
+    #
+    # Helpers expect an Enumerable that yields whatever JSON-shaped Hash the
+    # caller built; substr filtering and slicing happen after serialization so
+    # filters work on the same fields the UI reads.
+    module Pagination
+      DEFAULT_PAGE_SIZE = 25
+      MAX_PAGE_SIZE = 200
+
+      module_function
+
+      def window(params)
+        {
+          page: [params[:page].to_i, 0].max,
+          count: clamp_int(params[:count], 1, MAX_PAGE_SIZE, DEFAULT_PAGE_SIZE),
+          substr: params[:substr].to_s
+        }
+      end
+
+      def clamp_int(value, min, max, default)
+        Integer(value, 10).clamp(min, max)
+      rescue ::ArgumentError, ::TypeError
+        default
+      end
+
+      def clamp_float(value, min, max, default)
+        Float(value).clamp(min, max)
+      rescue ::ArgumentError, ::TypeError
+        default
+      end
+
+      # Iterates `enumerable` and collects up to `count` payloads from the
+      # requested page after substr filtering. `block` maps each member to a
+      # JSON Hash; nil from the block skips the member entirely.
+      def slice(enumerable, page)
+        results = []
+        offset = page[:page] * page[:count]
+        idx = 0
+        enumerable.each do |member|
+          if idx >= offset
+            payload = yield(member)
+            if payload && match?(payload, page[:substr])
+              results << payload
+              break if results.size >= page[:count]
+            end
+          end
+          idx += 1
+        end
+        results
+      end
+
+      def match?(payload, substr)
+        return true if substr.nil? || substr.empty?
+
+        needle = substr.downcase
+        payload[:klass].to_s.downcase.include?(needle) || payload[:jid].to_s.downcase.include?(needle)
+      end
+    end
+  end
+end

data/app/controllers/wurk/api/serializers.rb

@@ -0,0 +1,131 @@
+# frozen_string_literal: true
+
+module Wurk
+  module Api
+    # Pure mapping from inspector objects → JSON-shaped Hashes for the
+    # dashboard SPA. Keeping the serializers out of the controller lets the
+    # action methods stay tiny and lets future endpoints share the same
+    # field shapes without re-implementing them.
+    module Serializers
+      module_function
+
+      # Wire-shape consumed by the React dashboard's landing page + SSE feed.
+      # Field names match the SPA's `StatsSnapshot` interface in
+      # frontend/src/hooks/useSSE.ts — keep them in sync. The canonical
+      # Sidekiq-compatible accessors on Wurk::Stats use `_size` suffixes;
+      # this serializer renames them for the dashboard's wire shape only.
+      def stats_payload(stats)
+        {
+          processed: stats.processed,
+          failed: stats.failed,
+          expired: stats.expired,
+          enqueued: stats.enqueued,
+          busy: stats.workers_size,
+          scheduled: stats.scheduled_size,
+          retries: stats.retry_size,
+          dead: stats.dead_size,
+          processes: stats.processes_size,
+          latency: stats.default_queue_latency,
+          queues: stats.queue_summaries.map { |q| queue_summary(q) }
+        }
+      end
+
+      def queue_summary(summary)
+        { name: summary.name, size: summary.size, latency: summary.latency, paused: summary.paused? }
+      end
+
+      def job_record(record)
+        {
+          jid: record.jid,
+          klass: record.display_class,
+          args: record.display_args,
+          queue: record.queue,
+          enqueued_at: record.enqueued_at&.to_f,
+          created_at: record.created_at&.to_f
+        }
+      end
+
+      def sorted_entry(entry)
+        job_record(entry).merge(
+          score: entry.score,
+          at: entry.at.to_f,
+          error_class: entry['error_class'],
+          error_message: entry['error_message'],
+          retry_count: entry['retry_count']
+        )
+      end
+
+      def process_row(process)
+        {
+          identity: process.identity,
+          hostname: process['hostname'],
+          pid: process['pid'],
+          tag: process.tag,
+          concurrency: process['concurrency'],
+          busy: process['busy'],
+          beat: process['beat'],
+          quiet: process.stopping?,
+          rss: process['rss'],
+          rtt_us: process['rtt_us'],
+          labels: process.labels,
+          queues: process.queues,
+          version: process.version,
+          embedded: process.embedded?
+        }
+      end
+
+      def limiter_row(name, meta)
+        {
+          name: name,
+          type: meta['type'].to_s,
+          fingerprint: meta['fingerprint'].to_s,
+          options: parse_options(meta['options']),
+          status: limiter_status(name, meta)
+        }
+      end
+
+      # Reconstruct the limiter (read-only, `register: false`) just to read
+      # its uniform `{ used, limit, reset_at, available? }` status for the
+      # Limits tab. Best-effort: a malformed meta hash yields nil rather than
+      # 500-ing the whole list.
+      def limiter_status(name, meta)
+        limiter = ::Wurk::Limiter.build(name, meta['type'], parse_options(meta['options']))
+        limiter&.status
+      rescue StandardError
+        nil
+      end
+
+      def cron_row(loop_obj, now_epoch)
+        {
+          lid: loop_obj.lid,
+          schedule: loop_obj.schedule,
+          klass: loop_obj.klass,
+          queue: loop_obj.queue,
+          tz: loop_obj.tz_name,
+          paused: loop_obj.paused?,
+          args: loop_obj.args,
+          last_fire_at: loop_obj.last_fired_at,
+          next_fire_at: loop_obj.next_fire_at(now_epoch)
+        }
+      end
+
+      def metric_row(klass, totals)
+        { klass: klass, processed: totals[:p], failed: totals[:f], runtime_ms: totals[:ms] }
+      end
+
+      # One point in a cluster-total time-series (Wurk::Metrics::Query.history).
+      # `at` is epoch seconds at the bucket start.
+      def history_point(row)
+        { at: row[:at], processed: row[:p], failed: row[:f], runtime_ms: row[:ms] }
+      end
+
+      def parse_options(raw)
+        return {} if raw.nil? || raw.to_s.empty?
+
+        ::JSON.parse(raw)
+      rescue ::JSON::ParserError
+        {}
+      end
+    end
+  end
+end