cogworker 0.2.1 → 0.3.0

data/lib/cogworker/web/routes/history.rb

@@ -33,19 +33,35 @@ module Cogworker
             end
           end
 
-          # Polled from the browser (see `grid_script`'s `refreshRows`) to
-          # keep the grid live without a full-page/htmx fragment reload,
-          # which would tear down and rebuild the AG Grid instance (and lose
-          # its sort/filter/scroll state) on every tick.
+          # The grid's Infinite Row Model datasource (`grid_script`'s
+          # `getRows`) — one block of rows per call, sorted/filtered
+          # server-side by `Web::HistoryQuery`, so the page never ships
+          # every retained entry to the browser. Also what live updates
+          # re-hit (`refreshInfiniteCache`), for just the blocks on screen.
           app.get('/history/data') do
             status = History::STATUSES.include?(params['status']) ? params['status'] : 'all'
-            jid = params['jid'].to_s
-            entries, = Cogworker::History::Storage.page(status, 1, Cogworker::History.max_entries)
-            entries = entries.select { |e| e['jid'] == jid } unless jid.empty?
-            [200, { 'content-type' => 'application/json' }, [JSON.generate(entries)]]
+            query = Cogworker::Web::HistoryQuery.new(
+              status: status, jid: params['jid'].to_s,
+              sort: Routes::History.parse_json_param(params['sort'], []),
+              filters: Routes::History.parse_json_param(params['filter'], {})
+            )
+            start = params['start'].to_i
+            rows, total = query.fetch(start, params['end'].to_i - start)
+            [200, { 'content-type' => 'application/json' }, [JSON.generate('rows' => rows, 'total' => total)]]
           end
         end
 
+        # A malformed/missing `sort`/`filter` param just means "none" rather
+        # than a 500 — it's built by our own script, but still user input.
+        def parse_json_param(raw, fallback)
+          return fallback if raw.nil? || raw.empty?
+
+          parsed = JSON.parse(raw)
+          parsed.is_a?(fallback.class) ? parsed : fallback
+        rescue JSON::ParserError
+          fallback
+        end
+
         def ag_grid_head(script_name)
           js, grid_css, theme_css = AG_GRID_ASSETS.map { |rel| Layout.path(script_name, "assets/#{rel}") }
           <<~HTML
@@ -55,12 +71,11 @@ module Cogworker
           HTML
         end
 
-        # Loads up to `Cogworker::History.max_entries` rows for the chosen
-        # filter in one shot and hands them to AG Grid, which does its own
-        # client-side sorting/per-column filtering/quick-search/pagination
-        # from there — retention (`max_entries`) already bounds this to a
-        # size AG Grid handles comfortably, so there's no need for the
-        # gem's own server-side paging on top of it.
+        # Renders just the grid shell — rows are fetched block by block
+        # from `GET /history/data` (AG Grid's Infinite Row Model), with
+        # sorting, per-column filtering and pagination all done server-side
+        # (`Web::HistoryQuery`), so page weight no longer grows with
+        # `History.max_entries`.
         #
         # `jid` (optional — empty string means "not filtering") narrows this
         # down to one job's own run history across every retry attempt (a
@@ -69,12 +84,10 @@ module Cogworker
         # history, which only shows its *failures*, capped to the last few —
         # see `Routes::Jobs#attempts_section`, which links here).
         def render_content(script_name, status, jid = '')
-          entries, = Cogworker::History::Storage.page(status, 1, Cogworker::History.max_entries)
-          entries = entries.select { |e| e['jid'] == jid } unless jid.empty?
           <<~HTML
             <div style="display: flex; flex-direction: column; gap: 16px;">
               #{page_header(script_name, status, jid)}
-              #{grid(entries, script_name, status, jid)}
+              #{grid(script_name, status, jid)}
             </div>
           HTML
         end
@@ -111,7 +124,7 @@ module Cogworker
           HTML
         end
 
-        def grid(entries, script_name, status, jid)
+        def grid(script_name, status, jid)
           <<~HTML
             <div id="history-grid" class="ag-theme-alpine" style="height: 70vh; width: 100%;"></div>
 
@@ -123,11 +136,11 @@ module Cogworker
               <pre id="history-backtrace-content" class="mono" style="margin: 0; font-size: 12px; line-height: 1.6; white-space: pre-wrap; max-height: 60vh; overflow-y: auto; background: var(--color-bg); border: 1px solid var(--color-divider); border-radius: var(--radius-sm); padding: var(--space-3);"></pre>
             </dialog>
 
-            #{grid_script(entries, script_name, status, jid)}
+            #{grid_script(script_name, status, jid)}
           HTML
         end
 
-        def grid_script(entries, script_name, status, jid)
+        def grid_script(script_name, status, jid)
           query = "status=#{status}"
           query += "&jid=#{CGI.escape(jid)}" unless jid.empty?
           data_url = Layout.path(script_name, "history/data?#{query}")
@@ -135,25 +148,18 @@ module Cogworker
             <script>
               (function () {
                 var dataUrl = #{Layout.json_for_script(data_url)};
-                var rowData = #{Layout.json_for_script(entries)};
-                var backtraces = {};
                 // The dialog leads with the error itself (class + message)
                 // and only then the backtrace — the grid's own Error column
                 // can be too narrow/truncated to read the full message, and
                 // clicking through to "just the backtrace" without it loses
-                // the one thing you're usually trying to look up.
-                function indexBacktraces() {
-                  backtraces = {};
-                  rowData.forEach(function (row) {
-                    if (!row.backtrace) return;
-                    var header = (row.error_class || 'Error') + ': ' + (row.error_message || '');
-                    backtraces[row.jid] = header + '\\n\\n' + row.backtrace.join('\\n');
-                  });
-                }
-                indexBacktraces();
-
-                window.cogworkerShowHistoryBacktrace = function (jid) {
-                  document.getElementById('history-backtrace-content').textContent = backtraces[jid] || '(no backtrace)';
+                // the one thing you're usually trying to look up. Takes the
+                // row itself (not a jid lookup): every retry attempt of one
+                // job shares its jid but has its own backtrace.
+                window.cogworkerShowHistoryBacktrace = function (row) {
+                  var text = row && row.backtrace
+                    ? (row.error_class || 'Error') + ': ' + (row.error_message || '') + '\\n\\n' + row.backtrace.join('\\n')
+                    : '(no backtrace)';
+                  document.getElementById('history-backtrace-content').textContent = text;
                   document.getElementById('history-backtrace-dialog').showModal();
                 };
 
@@ -167,7 +173,10 @@ module Cogworker
                 // it builds from a plain string/DOM node.
                 var cssVar = function (name) { return getComputedStyle(document.documentElement).getPropertyValue(name).trim(); };
 
+                // Infinite Row Model: a row whose block is still loading has
+                // no `data` yet — every getter/renderer below guards for it.
                 function statusCellRenderer(p) {
+                  if (!p.value) return '';
                   var ok = p.value === 'success';
                   var bg = cssVar(ok ? '--color-success-800' : '--color-danger-800');
                   var fg = cssVar(ok ? '--color-success-100' : '--color-danger-100');
@@ -185,18 +194,19 @@ module Cogworker
                 }
 
                 function errorValueGetter(p) {
+                  if (!p.data) return '';
                   return p.data.error_class ? (p.data.error_class + ': ' + p.data.error_message) : '';
                 }
 
                 function errorCellRenderer(p) {
-                  if (!p.data.backtrace) return p.value || '';
+                  if (!p.data || !p.data.backtrace) return p.value || '';
                   var span = document.createElement('span');
                   span.textContent = p.value;
                   span.style.color = cssVar('--color-danger-300');
                   span.style.textDecoration = 'underline';
                   span.style.cursor = 'pointer';
                   span.title = 'Click to view backtrace';
-                  span.addEventListener('click', function () { window.cogworkerShowHistoryBacktrace(p.data.jid); });
+                  span.addEventListener('click', function () { window.cogworkerShowHistoryBacktrace(p.data); });
                   return span;
                 }
 
@@ -218,33 +228,73 @@ module Cogworker
                   return parts.join(' ');
                 }
 
+                // Sorting/filtering run server-side (`Web::HistoryQuery`,
+                // keyed by each column's `colId`), so every `colId` here
+                // must match one of its `COLUMNS` — and compute the same
+                // value there as `valueGetter`/`valueFormatter` show here.
+                // Status has no column filter: the All/Success/Failed
+                // switch above already picks which ZSET is read at all.
+                var textFilter = { filter: 'agTextColumnFilter', filterParams: { buttons: ['reset'], debounceMs: 400 } };
                 var columnDefs = [
-                  { field: 'finished_at', headerName: 'Finished', sort: 'desc', minWidth: 170,
-                    valueFormatter: function (p) { return window.cogworkerFormatTime(new Date(p.value * 1000)); } },
-                  { field: 'class', headerName: 'Class' },
-                  { field: 'queue', headerName: 'Queue' },
-                  { field: 'jid', headerName: 'JID', minWidth: 160 },
-                  { field: 'args', headerName: 'Args', minWidth: 200,
-                    valueFormatter: function (p) { return JSON.stringify(p.value); } },
-                  { field: 'status', headerName: 'Status', cellRenderer: statusCellRenderer, maxWidth: 120 },
-                  { headerName: 'Duration', maxWidth: 160,
-                    // `valueGetter` stays a plain millisecond Integer — AG
-                    // Grid sorts/filters on that raw value, `valueFormatter`
-                    // only changes what's *displayed*, so numeric sort order
-                    // ("23ms" before "1m 5s") stays correct regardless of
-                    // formatting.
-                    valueGetter: function (p) { return Math.round((p.data.finished_at - p.data.started_at) * 1000); },
-                    valueFormatter: function (p) { return formatDuration(p.value); } },
-                  { headerName: 'Error', minWidth: 260, valueGetter: errorValueGetter, cellRenderer: errorCellRenderer }
+                  { colId: 'finished_at', field: 'finished_at', headerName: 'Finished', sort: 'desc', minWidth: 170, filter: false,
+                    valueFormatter: function (p) { return p.value == null ? '' : window.cogworkerFormatTime(new Date(p.value * 1000)); } },
+                  Object.assign({ colId: 'class', field: 'class', headerName: 'Class' }, textFilter),
+                  Object.assign({ colId: 'queue', field: 'queue', headerName: 'Queue' }, textFilter),
+                  Object.assign({ colId: 'jid', field: 'jid', headerName: 'JID', minWidth: 160 }, textFilter),
+                  Object.assign({ colId: 'args', field: 'args', headerName: 'Args', minWidth: 200,
+                    valueFormatter: function (p) { return p.data ? JSON.stringify(p.value) : ''; } }, textFilter),
+                  { colId: 'status', field: 'status', headerName: 'Status', cellRenderer: statusCellRenderer, maxWidth: 120, filter: false },
+                  { colId: 'duration', headerName: 'Duration', maxWidth: 160,
+                    filter: 'agNumberColumnFilter', filterParams: { buttons: ['reset'], debounceMs: 400 },
+                    // `valueGetter` stays a plain millisecond Integer (the
+                    // same unit the number filter compares against server-
+                    // side), `valueFormatter` only changes what's displayed.
+                    valueGetter: function (p) { return p.data ? Math.round((p.data.finished_at - p.data.started_at) * 1000) : null; },
+                    valueFormatter: function (p) { return p.value == null ? '' : formatDuration(p.value); } },
+                  Object.assign({ colId: 'error', headerName: 'Error', minWidth: 260, valueGetter: errorValueGetter,
+                    cellRenderer: errorCellRenderer }, textFilter)
                 ];
 
+                function blockUrl(params) {
+                  return dataUrl +
+                    '&start=' + params.startRow + '&end=' + params.endRow +
+                    '&sort=' + encodeURIComponent(JSON.stringify(params.sortModel || [])) +
+                    '&filter=' + encodeURIComponent(JSON.stringify(params.filterModel || {}));
+                }
+
+                var datasource = {
+                  getRows: function (params) {
+                    fetch(blockUrl(params), { headers: { 'Accept': 'application/json' } })
+                      .then(function (r) { if (!r.ok) throw new Error(r.status); return r.json(); })
+                      .then(function (data) { params.successCallback(data.rows, data.total); })
+                      .catch(function () { params.failCallback(); });
+                  }
+                };
+
                 var gridApi = agGrid.createGrid(document.getElementById('history-grid'), {
                   columnDefs: columnDefs,
-                  rowData: rowData,
-                  defaultColDef: { sortable: true, filter: true, resizable: true, flex: 1 },
+                  rowModelType: 'infinite',
+                  datasource: datasource,
+                  // One block == one page, and only that one block cached:
+                  // `refreshInfiniteCache()` (the live poll below) re-fetches
+                  // *every* cached block, so a bigger cache meant one extra
+                  // request per page visited on every tick. Paging back to an
+                  // earlier page costs a fresh request instead — fine, and
+                  // it's fresher anyway.
+                  cacheBlockSize: #{Cogworker::Web.history_per_page},
+                  maxBlocksInCache: 1,
+                  defaultColDef: { sortable: true, resizable: true, flex: 1 },
                   pagination: true,
                   paginationPageSize: #{Cogworker::Web.history_per_page},
-                  paginationPageSizeSelector: [10, 25, 50, 100]
+                  paginationPageSizeSelector: [10, 25, 50, 100],
+                  // Keeps block size == page size when the viewer picks a
+                  // different page size — otherwise one page would span
+                  // several blocks, more than the 1-block cache holds.
+                  onPaginationChanged: function (e) {
+                    if (!e.newPageSize) return;
+                    var size = e.api.paginationGetPageSize();
+                    if (e.api.getGridOption('cacheBlockSize') !== size) e.api.setGridOption('cacheBlockSize', size);
+                  }
                 });
 
                 if (window.matchMedia && window.matchMedia('(prefers-color-scheme: dark)').matches) {
@@ -253,19 +303,12 @@ module Cogworker
 
                 // AG Grid isn't htmx-swapped (unlike Workers/Stats/Overview), so
                 // it needs its own poll — gated by the same global toggle —
-                // that replaces just `rowData` in place rather than
-                // reloading the fragment and tearing the grid instance down.
+                // that re-fetches just the cached blocks in place (current
+                // sort/filter/page kept) rather than reloading the fragment
+                // and tearing the grid instance down.
                 function refreshRows() {
                   if (!window.cogworkerLiveUpdate) return;
-                  fetch(dataUrl, { headers: { 'Accept': 'application/json' } })
-                    .then(function (r) { return r.ok ? r.json() : null; })
-                    .then(function (data) {
-                      if (!data) return;
-                      rowData = data;
-                      indexBacktraces();
-                      gridApi.setGridOption('rowData', rowData);
-                    })
-                    .catch(function () {});
+                  gridApi.refreshInfiniteCache();
                 }
                 setInterval(refreshRows, #{Cogworker::Web.live_update_interval * 1000});
               })();

data/lib/cogworker/web/routes/jobs.rb

@@ -14,9 +14,9 @@ module Cogworker
       # retry timeline, last error, actions) in place of `Routes::Dead`'s
       # flat rows. (*`Routes::Queues`' own queue-level browsing survives
       # separately, as `Routes::Overview` layout B — this tab is the
-      # cross-queue, cross-status view; the two overlap a little on purpose,
-      # the same way a real Sidekiq-style admin wants both "what's in this
-      # queue" and "find this one job wherever it is".)
+      # cross-queue, cross-status view; the two overlap a little on purpose:
+      # an operator wants both "what's in this queue" and "find this one job
+      # wherever it is".)
       #
       # `?status=`/`?q=`/`?selected=` are plain query params, read fresh on
       # every request and carried through the self-poll and every action's
@@ -67,7 +67,7 @@ module Cogworker
             Jobs.respond(self, params)
           end
 
-          # Same "graduate back onto its queue" move `Routes::Dead#retry`/
+          # Same "graduate back onto its queue" move `/jobs/dead/retry` below/
           # `Cogworker::Scheduled#graduate` make — `zrem` winning (not
           # losing) gates it so two tabs retrying the same entry at once
           # can't both requeue it; the `redis` gem's `#zrem` returns a
@@ -76,11 +76,7 @@ module Cogworker
           app.post('/jobs/retrying/retry_now') do
             raw = params['raw']
             Cogworker.config.redis do |c|
-              if c.zrem(RedisKeys::RETRY, raw)
-                job = JSON.parse(raw)
-                c.sadd(RedisKeys::QUEUES, job['queue'])
-                c.lpush(RedisKeys.queue(job['queue']), raw)
-              end
+              JobUtil.claim_and_requeue(c, RedisKeys::RETRY, raw)
             end
             Jobs.respond(self, params)
           end
@@ -102,11 +98,7 @@ module Cogworker
           app.post('/jobs/dead/retry') do
             raw = params['raw']
             Cogworker.config.redis do |c|
-              if c.zrem(RedisKeys::DEAD, raw)
-                job = JSON.parse(raw)
-                c.sadd(RedisKeys::QUEUES, job['queue'])
-                c.lpush(RedisKeys.queue(job['queue']), raw)
-              end
+              JobUtil.claim_and_requeue(c, RedisKeys::DEAD, raw)
             end
             Jobs.respond(self, params)
           end
@@ -254,15 +246,23 @@ module Cogworker
           when :scheduled
             delete_button('scheduled', script_name, row, params)
           when :retrying
-            retry_now_button('retrying', script_name, row, params) + delete_button('retrying', script_name, row,
-                                                                                    params)
+            retry_html = requeueable?(row) ? retry_now_button('retrying', script_name, row, params) : ''
+            retry_html + delete_button('retrying', script_name, row, params)
           when :dead
-            retry_button('dead', script_name, row, params) + delete_button('dead', script_name, row, params)
+            retry_html = requeueable?(row) ? retry_button('dead', script_name, row, params) : ''
+            retry_html + delete_button('dead', script_name, row, params)
           else
             ''
           end
         end
 
+        # No Retry for an entry that can't go back on a queue (no queue of
+        # its own) or that would only fail straight back into Dead (an
+        # unparseable payload's wrapper) — Delete is all that makes sense.
+        def requeueable?(row)
+          row[:klass] != JobUtil::UNPARSEABLE_CLASS && !JobUtil.requeueable(row[:raw].to_s).nil?
+        end
+
         def delete_button(bucket, script_name, row, params, extra: {})
           action = Layout.path(script_name, "jobs/#{bucket}/delete")
           form_with_extra(action, 'raw', row[:raw], 'delete', params, variant: :danger, icon: 'trash', extra: extra)

data/lib/cogworker/web/routes/overview.rb

@@ -125,8 +125,8 @@ module Cogworker
           end
 
           # `raw` is the exact JSON string the job entry was pushed with —
-          # same "raw" identity `Routes::Dead`/`Routes::Retries` already key
-          # their own per-row delete off — so `Queue#delete` can `LREM` it
+          # same "raw" identity `Routes::Jobs`' dead/retrying actions already
+          # key their own per-row delete off — so `Queue#delete` can `LREM` it
           # back out of the list.
           app.post('/overview/:name/delete') do
             name = url_params('name')
@@ -167,15 +167,9 @@ module Cogworker
         def retry_all(name)
           entries = Cogworker.config.redis { |c| c.zrange(RedisKeys::RETRY, 0, -1) }
           entries.each do |raw|
-            job = JSON.parse(raw)
-            next unless job['queue'] == name
+            next unless JobUtil.requeueable(raw)&.fetch('queue') == name
 
-            Cogworker.config.redis do |c|
-              if c.zrem(RedisKeys::RETRY, raw)
-                c.sadd(RedisKeys::QUEUES, job['queue'])
-                c.lpush(RedisKeys.queue(job['queue']), raw)
-              end
-            end
+            Cogworker.config.redis { |c| JobUtil.claim_and_requeue(c, RedisKeys::RETRY, raw) }
           end
         end
 
@@ -447,8 +441,8 @@ module Cogworker
         # `processed`/`failed`. Shared between the initial render
         # (`throughput_section`, baked into the page) and `/overview/
         # throughput_data` (what the chart's own poll re-fetches from then
-        # on), so the two can never drift apart — same pattern `Routes::
-        # Stats#chart_data_payload` already uses for its own chart.
+        # on), so the two can never drift apart — same pattern
+        # `runs_per_day_payload` above uses for the Runs-per-day chart.
         def throughput_payload
           series = Cogworker::Throughput.series
           {

data/lib/cogworker/web/routes/schedules.rb

@@ -52,12 +52,12 @@ module Cogworker
           end
 
           app.post('/schedules/:pjid/disable') do
-            Cogworker.config.redis { |c| c.sadd(RedisKeys::PERIODIC_DISABLED, url_params('pjid')) }
+            Cogworker.config.redis { |c| c.sadd?(RedisKeys::PERIODIC_DISABLED, url_params('pjid')) }
             Routes::Schedules.respond(self)
           end
 
           app.post('/schedules/:pjid/enable') do
-            Cogworker.config.redis { |c| c.srem(RedisKeys::PERIODIC_DISABLED, url_params('pjid')) }
+            Cogworker.config.redis { |c| c.srem?(RedisKeys::PERIODIC_DISABLED, url_params('pjid')) }
             Routes::Schedules.respond(self)
           end
         end

data/lib/cogworker/web.rb

@@ -20,7 +20,7 @@ module Cogworker
     # Every built-in tab lives under here; touching each constant once
     # forces Zeitwerk to load that file (and run its
     # `Cogworker::Web.register(...)` bottom-of-file side effect) — nothing
-    # else ever references `Routes::Queues` etc. by name, so without this
+    # else ever references `Routes::Overview` etc. by name, so without this
     # they would simply never load.
     BUILT_IN_ROUTE_NAMES = %i[Overview Jobs Schedules Workers History SaveSession].freeze
     DEFAULT_TIME_FORMAT = '%Y-%m-%d %H:%M:%S'
@@ -94,8 +94,20 @@ module Cogworker
         @tabs ||= {}
       end
 
+      # The built-in session cookie's signing secret. The gem itself never
+      # reads the session — it's there for an auth middleware added via
+      # `.use` — but a random per-process default means each Puma worker
+      # signs with its own key, so that middleware's session doesn't survive
+      # a request landing on a different worker. Set it explicitly
+      # (`Cogworker::Web.session_secret = ...`, at least 64 characters) or
+      # via `COGWORKER_SESSION_SECRET` for any multi-process deployment.
       def session_secret
-        @session_secret ||= SecureRandom.hex(32)
+        @session_secret ||= ENV.fetch('COGWORKER_SESSION_SECRET') { SecureRandom.hex(32) }
+      end
+
+      def session_secret=(secret)
+        @session_secret = secret
+        @app = nil
       end
 
       # How every `Layout.time_tag` timestamp is rendered — a Ruby
@@ -132,10 +144,11 @@ module Cogworker
       end
 
       # How often (in seconds) every auto-refreshing tab polls while the
-      # global live-update toggle is on — both the htmx-polled Busy/Stats/
-      # Queues tabs (`Layout.poll_div`'s `hx-trigger="every Ns [...]"`) and
-      # History's own AG Grid `refreshRows()` JS poll share this one value,
-      # so there's a single knob rather than one per tab. Set this from your
+      # global live-update toggle is on — the htmx-polled Overview/Jobs/
+      # Schedules/Workers tabs (`Layout.poll_div`'s `hx-trigger="every Ns
+      # [...]"`), History's AG Grid poll and Overview's Chart.js polls all
+      # share this one value, so there's a single knob rather than one per
+      # tab. Set this from your
       # own init file/config.ru, e.g. `Cogworker::Web.live_update_interval = 10`.
       def live_update_interval
         @live_update_interval ||= DEFAULT_LIVE_UPDATE_INTERVAL
@@ -237,10 +250,10 @@ module Cogworker
         builder.use(Rack::Session::Cookie, secret: session_secret, key: 'cogworker.session')
         # No `cache_control:` (no `immutable`/long `max-age`): these files
         # are plain, unfingerprinted paths that *do* change — every time
-        # this gem's Tailwind bundle gets rebuilt, or on any gem upgrade —
+        # a vendored stylesheet/script gets edited, or on any gem upgrade —
         # and `immutable` previously told browsers to keep serving a stale
         # cached copy under the old URL for up to a year with no
-        # revalidation at all (caught by hand: a real edit to tailwind.css
+        # revalidation at all (caught by hand: a real edit to a vendored stylesheet
         # didn't show up in an already-open tab until a hard reload).
         # `Rack::Static`/`Rack::Files` already sends `Last-Modified` and
         # honors conditional GETs by default, which is all that's needed

data/lib/cogworker.rb

@@ -2,6 +2,9 @@
 
 require 'socket'
 require 'securerandom'
+# `Time#iso8601` (Logging, Web::Layout.time_tag) only moved into core in
+# Ruby 3.4; on 3.1-3.3 it needs the stdlib extension loaded explicitly.
+require 'time'
 require 'zeitwerk'
 
 # Redis-backed background job processing: worker DSL, periodic (cron)
@@ -85,7 +88,8 @@ module Cogworker
     end
 
     # No-op: exists so calling code doesn't need to change, but this gem
-    # simply never coerces job args, so there is nothing to toggle.
+    # simply never coerces job args, so there is nothing to toggle — see
+    # README "Job arguments".
     def strict_args!(_value = true)
       true
     end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: cogworker
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.3.0
 platform: ruby
 authors:
 - vdonec
@@ -224,10 +224,12 @@ files:
 - lib/cogworker/logging.rb
 - lib/cogworker/manager.rb
 - lib/cogworker/middleware/chain.rb
+- lib/cogworker/owned_key.rb
 - lib/cogworker/periodic/claim.lua
 - lib/cogworker/periodic/entry.rb
 - lib/cogworker/periodic/manager.rb
 - lib/cogworker/periodic/release_middleware.rb
+- lib/cogworker/periodic/running_lock.rb
 - lib/cogworker/periodic/ticker.rb
 - lib/cogworker/process.rb
 - lib/cogworker/process_set.rb
@@ -236,6 +238,7 @@ files:
 - lib/cogworker/queue.rb
 - lib/cogworker/redis_connection.rb
 - lib/cogworker/redis_keys.rb
+- lib/cogworker/reliable_fetch.rb
 - lib/cogworker/scheduled.rb
 - lib/cogworker/signals.rb
 - lib/cogworker/stats.rb
@@ -246,6 +249,7 @@ files:
 - lib/cogworker/status/worker.rb
 - lib/cogworker/swarm.rb
 - lib/cogworker/testing.rb
+- lib/cogworker/testing/empty_queue_error.rb
 - lib/cogworker/throughput.rb
 - lib/cogworker/unique_jobs.rb
 - lib/cogworker/unique_jobs/client_middleware.rb
@@ -263,6 +267,7 @@ files:
 - lib/cogworker/web/assets/nocturne/styles.css
 - lib/cogworker/web/assets/phosphor/Phosphor.woff2
 - lib/cogworker/web/assets/phosphor/style.css
+- lib/cogworker/web/history_query.rb
 - lib/cogworker/web/layout.rb
 - lib/cogworker/web/router.rb
 - lib/cogworker/web/routes/history.rb