sidekiq-error-groups 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 62c658e2afd9ef643352622f3298122194db22fbe9a620e528d436328b84370e
+  data.tar.gz: 8646512a57ae85bbc03e4717f39dba749e4ebb0d372bbd213383a417e8fd0552
+SHA512:
+  metadata.gz: 4464480cf1b46762345ee2f01691528d9ac6601872af14b3f3f5a6333f047f9512c36e940388578d2b2c9f7706bad9e122887db10cc3ae13dcd90edbaa135b66
+  data.tar.gz: a1f7c3243b44bb54c9f317e2cd946aa5690c20d4a1531ca8924d2728a94ae48a58bad8094d14e447912c3ff5fb0931a6f8345e508ef2b44ff0fe698e18597fe9

data/CHANGELOG.md

@@ -0,0 +1,9 @@
+## [Unreleased]
+
+## [0.1.0] - 2026-10-06
+
+- Initial release: "Error groups" tab for the Sidekiq Web UI (Sidekiq 6, 7 and 8).
+- Group failed jobs by error class, by job class, or by the pair of them (default),
+  switchable from the UI, the CLI (`--group-by`) and `Sidekiq::ErrorGroups.config`.
+- Per-group retry/delete/kill actions, scoped to whichever half of the key is given.
+- Ruby API, `rake sidekiq:error_groups` and the `sidekiq-error-groups` CLI.

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2026 r3cha
+
+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,238 @@
+# sidekiq-error-groups
+
+[![Gem Version](https://img.shields.io/gem/v/sidekiq-error-groups.svg)](https://rubygems.org/gems/sidekiq-error-groups)
+[![CI](https://github.com/r3cha/sidekiq-error-groups/actions/workflows/ci.yml/badge.svg)](https://github.com/r3cha/sidekiq-error-groups/actions/workflows/ci.yml)
+[![Sidekiq](https://img.shields.io/badge/sidekiq-6.0%20%E2%80%93%208.x-b1003e.svg)](https://github.com/sidekiq/sidekiq)
+[![License: MIT](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE.txt)
+
+An **Error groups** tab for the Sidekiq Web UI: retrying and dead jobs grouped by error
+class, by job class, or by the pair of them — with retry, kill and delete scoped to one
+group.
+
+![The Error groups tab, grouped by error class and job class](https://raw.githubusercontent.com/r3cha/sidekiq-error-groups/main/doc/screenshot-groups.png)
+
+## Why
+
+Sidekiq's **Retries** and **Dead** pages are flat lists sorted by time. With 20 000 failed
+jobs they cannot answer the only question that matters — *what broke?* — and the bulk
+actions are all-or-nothing.
+
+And grouping by error class alone is not enough either. `Net::OpenTimeout` in
+`FetchInventoryJob` is a flaky warehouse API; the same `Net::OpenTimeout` in
+`DeliverWebhookJob` is a flaky customer endpoint. Two problems, two decisions. Pairing the
+error class with the job class keeps them apart, so you can retry one and leave the other
+alone. That is the default grouping; the other two are one click away.
+
+Nothing is stored and nothing is instrumented: the tab reads the very same retry and dead
+sets Sidekiq already keeps, so it works on failures that happened before you installed it.
+
+## Installation
+
+```ruby
+# Gemfile
+gem "sidekiq-error-groups"
+```
+
+Require the Web extension where the Web UI is mounted — `config/routes.rb` in Rails, or
+your rackup file. **Not** in an initializer: Sidekiq worker processes should not load the
+Web UI.
+
+```ruby
+# config/routes.rb
+require "sidekiq/web"
+require "sidekiq/error_groups/web"
+
+Rails.application.routes.draw do
+  mount Sidekiq::Web => "/sidekiq"
+end
+```
+
+That is the whole setup. A new "Error groups" tab appears next to Retries and Dead.
+
+## The tab
+
+**Index** — one row per group, with a `Group by: error class · job · error class + job`
+switch. Each row carries the totals per set, when the group first and last failed, and the
+message of its most recent failure. When the grouping leaves something out, it comes back
+as a breakdown column: job classes when grouping by error, error classes when grouping by
+job.
+
+![Grouped by error class, with the affected job classes as a breakdown](https://raw.githubusercontent.com/r3cha/sidekiq-error-groups/main/doc/screenshot-by-error.png)
+
+**Group page** — the numbers for that group, the message and backtrace of the most recent
+failure, the three bulk actions, and a paginated list of the jobs linking back to their
+regular Sidekiq pages.
+
+![A single group: counts, backtrace, bulk actions and the affected jobs](https://raw.githubusercontent.com/r3cha/sidekiq-error-groups/main/doc/screenshot-group.png)
+
+| Action | Effect |
+|---|---|
+| Retry all in group | pushes every job of this group back to its queue (retries **and** dead) |
+| Kill all in group | moves this group's retrying jobs to the dead set |
+| Delete all in group | deletes every job of this group (retries **and** dead) |
+
+Each action asks for confirmation, stays inside the group it was fired from, and reports
+how many jobs it touched.
+
+## Ruby API
+
+```ruby
+summary = Sidekiq::ErrorGroups.summary        # grouped by error class + job class
+summary.total          # => 72   failed jobs in the scanned sets
+summary.group_by       # => :error_job
+summary.truncated?     # => false (true when max_scan stopped the scan early)
+
+summary.groups.each do |group|
+  group.error_class    # => "Net::OpenTimeout"
+  group.job_class      # => "FetchInventoryJob"
+  group.count          # => 8
+  group.retry_count    # => 8
+  group.dead_count     # => 0
+  group.first_failed_at
+  group.last_failed_at
+  group.sample         # => the group's most recent failed job
+end
+```
+
+Other groupings, and the breakdown of whatever is not in the key:
+
+```ruby
+Sidekiq::ErrorGroups.summary(group_by: :error)   # one row per error class
+Sidekiq::ErrorGroups.summary(group_by: :job)     # one row per job class
+Sidekiq::ErrorGroups.summary(sets: [:dead])      # dead jobs only
+
+group = Sidekiq::ErrorGroups.groups(group_by: :job).first
+group.error_classes    # => {"Net::OpenTimeout" => 5, "Net::ReadTimeout" => 5}
+group.breakdown        # => [["Net::OpenTimeout", 5], ["Net::ReadTimeout", 5]]
+```
+
+One group's jobs, paginated (`page.group` carries the whole-group numbers, not just the
+page's):
+
+```ruby
+page = Sidekiq::ErrorGroups.jobs("Net::OpenTimeout", job_class: "FetchInventoryJob", page: 1)
+page.jobs.first.jid
+```
+
+Bulk actions, scoped to whichever half of the key you pass:
+
+```ruby
+Sidekiq::ErrorGroups.retry_all("Net::OpenTimeout", job_class: "FetchInventoryJob")
+Sidekiq::ErrorGroups.delete_all("ActiveRecord::RecordNotFound", sets: [:dead])
+Sidekiq::ErrorGroups.kill_all(job_class: "WarmCacheJob", limit: 100)
+```
+
+An action with neither half raises `ArgumentError` rather than quietly touching every
+failed job. Jobs carrying no `error_class` are grouped under
+`Sidekiq::ErrorGroups::Selector::UNKNOWN` and displayed as "(no error class)".
+
+## Rake and CLI
+
+```bash
+bundle exec rake sidekiq:error_groups    # GROUP_BY=error_job SETS=retry,dead LIMIT=20 MAX_SCAN=10000
+```
+
+```
+$ sidekiq-error-groups --group-by job
+Failed jobs grouped by job class — 72 job(s) (retry: 62, dead: 10), 7 group(s)
+
+JOB                TOTAL  RETRY  DEAD  LAST FAILURE             ERRORS
+-----------------  -----  -----  ----  -----------------------  ----------------------------------------------------------
+ChargeCardJob      30     30     0     2026-10-06 08:48:05 UTC  PaymentGateway::DeclinedError (26), …RateLimitedError (4)
+DeliverWebhookJob  10     10     0     2026-10-06 08:46:12 UTC  Net::OpenTimeout (5), Net::ReadTimeout (5)
+SyncUserJob        9      9      0     2026-10-06 08:30:41 UTC  ActiveRecord::RecordNotFound (9)
+```
+
+```bash
+sidekiq-error-groups                                   # the default table
+sidekiq-error-groups --group-by error                  # or job, or error_job
+sidekiq-error-groups --json | jq .                     # machine readable
+sidekiq-error-groups --error "Net::OpenTimeout"        # the jobs of one error class
+sidekiq-error-groups --job FetchInventoryJob           # the jobs of one worker
+sidekiq-error-groups --error "Net::OpenTimeout" --job FetchInventoryJob
+sidekiq-error-groups -r ./config/environment           # load the app first
+sidekiq-error-groups --redis-url redis://localhost:6379/1
+```
+
+The CLI is read-only on purpose: bulk retry/delete/kill live in the Ruby API and in the Web
+UI, where there is a confirmation step.
+
+## Configuration
+
+Everything is optional.
+
+```ruby
+Sidekiq::ErrorGroups.configure do |config|
+  config.group_by = :error_job   # :error, :job or :error_job (default)
+  config.sets = %i[retry dead]   # which sets to scan, default both
+  config.max_scan = 10_000       # max jobs read per set, the safety valve for huge sets
+  config.action_batch_size = 1_000
+  config.top_breakdown = 3       # entries listed in the breakdown column
+  config.per_page = 25           # jobs per page on the group page
+  config.backtrace_lines = 10
+  config.cache_ttl = 0           # seconds to keep a summary in process memory, 0 = off
+end
+```
+
+### Performance
+
+Grouping means reading the sets, so the work is linear in their size. Iteration goes
+through `Sidekiq::JobSet#each`, which paginates the sorted set inside Redis, and stops
+after `max_scan` jobs per set. When that limit kicks in, the UI, the CLI and
+`Summary#truncated?` all say so — the numbers are then a lower bound. Raise `max_scan` for
+exact numbers on large installations, or set `cache_ttl` to avoid rescanning on every page
+load.
+
+Bulk actions deliberately ignore `max_scan`: a "retry all in group" must not silently skip
+jobs. They work in batches of `action_batch_size`, re-scanning the set between batches,
+because mutating a sorted set while iterating it is not safe.
+
+## Compatibility
+
+Ruby 2.7+ and Sidekiq 6.0 through 8.x. The Web UI extension API changed three times in that
+range; the gem shims all of it and CI runs the full matrix.
+
+| Sidekiq | Registration used | Views |
+|---|---|---|
+| 8.x | `Sidekiq::Web.configure { \|c\| c.register(...) }` | `web/views` (current UI markup) |
+| 7.3–7.x | `Sidekiq::Web.register(ext, name:, tab:, index:)` | `web/views/legacy` |
+| 6.0–7.2 | `Sidekiq::Web.register(ext)` + `Sidekiq::Web.tabs[...]` | `web/views/legacy` |
+
+Only Sidekiq APIs present in every supported version are used (`Sidekiq::RetrySet`,
+`Sidekiq::DeadSet`, `JobSet#each`, `SortedEntry#item/score/retry/delete/kill`), and Redis is
+never addressed directly — which keeps both redis-rb (Sidekiq 6) and redis-client
+(Sidekiq 7+) happy. Groups are addressed with `error_class`/`job_class` query parameters
+rather than path segments, which every Sidekiq router version handles unchanged.
+
+Locales: English and Russian.
+
+## Development
+
+```bash
+bin/setup
+bundle exec rake                 # tests + rubocop
+```
+
+The core is tested against in-memory fakes and needs nothing running. The Web UI tests
+drive a real `Sidekiq::Web` through `rack-test` and need Redis; they skip themselves when
+`REDIS_URL` (default `redis://localhost:6379/15`) is unreachable.
+
+The whole version matrix:
+
+```bash
+for f in gemfiles/*.gemfile; do BUNDLE_GEMFILE=$f bundle install && BUNDLE_GEMFILE=$f bundle exec rake test; done
+```
+
+Looking at the UI by hand:
+
+```bash
+bundle exec ruby test/dummy/seed.rb                             # create failed jobs
+bundle exec rackup test/dummy/config.ru -p 9292                 # current UI
+BUNDLE_GEMFILE=gemfiles/sidekiq_6.5.gemfile bundle exec rackup test/dummy/config.ru -p 9293  # legacy UI
+```
+
+Bug reports and pull requests are welcome — see [CONTRIBUTING.md](CONTRIBUTING.md).
+
+## License
+
+[MIT](LICENSE.txt)

data/exe/sidekiq-error-groups

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "sidekiq/error_groups/cli"
+
+exit Sidekiq::ErrorGroups::CLI.run(ARGV)

data/lib/sidekiq/error_groups/actions.rb

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+module Sidekiq
+  module ErrorGroups
+    # Bulk retry/delete/kill restricted to a single group: one error class, one
+    # job class, or the pair of them.
+    #
+    # Mutating a sorted set while `Sidekiq::JobSet#each` walks it is not safe, so
+    # every pass works in two phases: collect a batch of matching jobs, then act
+    # on it. Each action removes the job from the set, so repeated passes make
+    # progress until nothing matches any more.
+    module Actions
+      OPERATIONS = {
+        retry: :retry!,
+        delete: :delete!,
+        kill: :kill!
+      }.freeze
+
+      # Killing means "move to the dead set", which only makes sense for jobs
+      # that are still being retried.
+      SUPPORTED_SETS = {
+        retry: %i[retry dead],
+        delete: %i[retry dead],
+        kill: %i[retry]
+      }.freeze
+
+      Result = Struct.new(:operation, :selector, :counts, keyword_init: true) do
+        def total
+          counts.values.sum
+        end
+
+        def error_class
+          selector.error_class
+        end
+
+        def job_class
+          selector.job_class
+        end
+
+        def to_h
+          {operation: operation, **selector.to_h, counts: counts, total: total}
+        end
+      end
+
+      module_function
+
+      def call(error_class = nil, operation:, job_class: nil, sets: nil, limit: nil, sources: nil)
+        operation = operation.to_sym
+        method = OPERATIONS.fetch(operation) do
+          raise ArgumentError, "unknown operation: #{operation}, expected one of #{OPERATIONS.keys.join(", ")}"
+        end
+
+        selector = Selector.build(error_class: error_class, job_class: job_class)
+        requested = Config.normalize_sets(sets || ErrorGroups.config.sets)
+        counts = {}
+
+        (requested & SUPPORTED_SETS.fetch(operation)).each do |kind|
+          counts[kind] = process(kind, selector, method, limit, sources)
+        end
+
+        ErrorGroups.reset_cache!
+        Result.new(operation: operation, selector: selector, counts: counts)
+      end
+
+      def retry_all(error_class = nil, **kwargs)
+        call(error_class, operation: :retry, **kwargs)
+      end
+
+      def delete_all(error_class = nil, **kwargs)
+        call(error_class, operation: :delete, **kwargs)
+      end
+
+      def kill_all(error_class = nil, **kwargs)
+        call(error_class, operation: :kill, **kwargs)
+      end
+
+      # @api private
+      def process(kind, selector, method, limit, sources)
+        set = Scanner.source_for(kind, sources)
+        batch_size = ErrorGroups.config.action_batch_size
+        done = 0
+
+        loop do
+          take = batch_size
+          if limit
+            remaining = limit - done
+            break if remaining <= 0
+
+            take = [batch_size, remaining].min
+          end
+
+          batch = collect(set, kind, selector, take)
+          break if batch.empty?
+
+          size_before = Scanner.size_of(set)
+          batch.each { |job| job.public_send(method) }
+          done += batch.size
+
+          break if batch.size < take
+          # The set did not shrink, so another pass would collect the very same
+          # jobs again. Stop instead of spinning forever.
+          break if Scanner.size_of(set) == size_before
+        end
+
+        done
+      end
+
+      # @api private
+      def collect(set, kind, selector, take)
+        batch = []
+
+        set.each do |entry|
+          job = Job.new(kind, entry)
+          next unless selector.matches?(job)
+
+          batch << job
+          break if batch.size >= take
+        end
+
+        batch
+      end
+    end
+  end
+end

data/lib/sidekiq/error_groups/aggregator.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Sidekiq
+  module ErrorGroups
+    # Builds a {Sidekiq::ErrorGroups::Summary} out of the retry/dead sets.
+    class Aggregator
+      def self.call(**kwargs)
+        new(**kwargs).call
+      end
+
+      def initialize(sets: nil, group_by: nil, max_scan: nil, sources: nil)
+        @sets = Config.normalize_sets(sets || ErrorGroups.config.sets)
+        @group_by = Config.normalize_group_by(group_by || ErrorGroups.config.group_by)
+        @max_scan = max_scan.nil? ? ErrorGroups.config.max_scan : max_scan
+        @sources = sources
+      end
+
+      def call
+        groups = {}
+
+        scanned, sizes = Scanner.scan(sets: @sets, max_scan: @max_scan, sources: @sources) do |job|
+          selector = Selector.for(job, @group_by)
+          (groups[selector.key] ||= Group.new(selector)).add(job)
+        end
+
+        Summary.new(groups: sort(groups.values), group_by: @group_by, scanned: scanned, set_sizes: sizes)
+      end
+
+      private
+
+      # Biggest problem first; ties broken by recency, then alphabetically so the
+      # output is stable between requests.
+      def sort(groups)
+        groups.sort_by do |group|
+          [-group.count, -(group.last_failed_at&.to_f || 0), group.selector.to_s]
+        end
+      end
+    end
+  end
+end

data/lib/sidekiq/error_groups/cli.rb

@@ -0,0 +1,155 @@
+# frozen_string_literal: true
+
+require "optparse"
+require "json"
+require_relative "../error_groups"
+
+module Sidekiq
+  module ErrorGroups
+    # `sidekiq-error-groups` executable: prints the same summary the Web UI tab
+    # shows. Read-only on purpose — bulk retry/delete/kill live in the Ruby API
+    # and in the Web UI, where there is a confirmation step.
+    class CLI
+      BANNER = "Usage: sidekiq-error-groups [options]"
+
+      def self.run(argv, out: $stdout, err: $stderr)
+        new(argv).run(out: out, err: err)
+      end
+
+      def initialize(argv)
+        @argv = argv
+        @options = {
+          sets: nil, group_by: nil, limit: nil, max_scan: nil, json: false,
+          requires: [], error_class: nil, job_class: nil, show: false, page: 1
+        }
+      end
+
+      def run(out: $stdout, err: $stderr)
+        parse!
+        boot!
+        out.puts(@options[:show] ? render_group : render_summary)
+        0
+      rescue OptionParser::ParseError, ArgumentError => e
+        err.puts("sidekiq-error-groups: #{e.message}")
+        1
+      rescue StandardError => e
+        err.puts("sidekiq-error-groups: #{e.class}: #{e.message}")
+        1
+      end
+
+      private
+
+      def parser
+        @parser ||= OptionParser.new do |opts|
+          opts.banner = BANNER
+
+          opts.on("-u", "--redis-url URL", "Redis URL (defaults to REDIS_URL)") { |v| @options[:redis_url] = v }
+          opts.on("-s", "--sets LIST", "Job sets to scan, default retry,dead") { |v| @options[:sets] = v.split(",") }
+          opts.on("-b", "--group-by MODE", "error, job or error_job (default #{ErrorGroups.config.group_by})") do |v|
+            @options[:group_by] = v
+          end
+          opts.on("-l", "--limit N", Integer, "Show only the N largest groups") { |v| @options[:limit] = v }
+          opts.on("-m", "--max-scan N", Integer,
+            "Max jobs to read per set, default #{ErrorGroups.config.max_scan}") do |v|
+            @options[:max_scan] = v
+          end
+          opts.on("-e", "--error ERROR_CLASS", "List the jobs of one error class") do |v|
+            @options[:error_class] = v
+            @options[:show] = true
+          end
+          opts.on("-g", "--job JOB_CLASS", "List the jobs of one job class") do |v|
+            @options[:job_class] = v
+            @options[:show] = true
+          end
+          opts.on("-p", "--page N", Integer, "Page for --error/--job, default 1") { |v| @options[:page] = v }
+          opts.on("-j", "--json", "Print JSON instead of a table") { @options[:json] = true }
+          opts.on("-r", "--require PATH", "Require a file first, e.g. ./config/environment") do |v|
+            @options[:requires] << v
+          end
+          opts.on("-V", "--version", "Print version and exit") do
+            puts "sidekiq-error-groups #{VERSION} (sidekiq #{Sidekiq::VERSION})"
+            exit 0
+          end
+          opts.on("-h", "--help", "Print this help") do
+            puts opts
+            exit 0
+          end
+        end
+      end
+
+      def parse!
+        parser.parse!(@argv)
+      end
+
+      def boot!
+        @options[:requires].each { |path| require File.expand_path(path) }
+
+        url = @options[:redis_url]
+        Sidekiq.configure_client do |config|
+          config.redis = {url: url} if url
+          # Keep stdout clean: the report goes there, Sidekiq's own chatter does not.
+          config.logger = Sidekiq::Logger.new($stderr, level: :warn)
+        end
+      end
+
+      def render_summary
+        summary = ErrorGroups.summary(
+          sets: @options[:sets], group_by: @options[:group_by], max_scan: @options[:max_scan], refresh: true
+        )
+        return JSON.pretty_generate(summary.to_h) if @options[:json]
+
+        Formatter.render(summary, limit: @options[:limit])
+      end
+
+      def render_group
+        error_class = @options[:error_class]
+        error_class = Selector::UNKNOWN if error_class == Formatter::NO_ERROR_CLASS
+
+        page = ErrorGroups.jobs(
+          error_class,
+          job_class: @options[:job_class],
+          sets: @options[:sets],
+          max_scan: @options[:max_scan],
+          page: @options[:page],
+          per_page: @options[:limit]
+        )
+        return JSON.pretty_generate(page_to_h(page)) if @options[:json]
+
+        format_group(page)
+      end
+
+      def page_to_h(page)
+        {
+          **page.selector.to_h,
+          total: page.total,
+          page: page.page,
+          pages: page.pages,
+          truncated: page.truncated,
+          jobs: page.jobs.map(&:to_h)
+        }
+      end
+
+      def format_group(page)
+        lines = ["#{selector_label(page.selector)} — #{page.total} job(s), page #{page.page}/#{page.pages}"]
+        lines << "Only the first #{page.scanned} job(s) were scanned (max_scan)." if page.truncated
+        lines << ""
+
+        page.jobs.each do |job|
+          lines << "#{Formatter.timestamp(job.last_failure_at)}  [#{job.set}] #{job.display_class} " \
+                   "#{Formatter.error_class_label(job.error_class)} " \
+                   "jid=#{job.jid} queue=#{job.queue} retries=#{job.retry_count}"
+          lines << "  #{job.error_message}" unless job.error_message.empty?
+        end
+        lines << "(no jobs on this page)" if page.jobs.empty?
+        lines.join("\n")
+      end
+
+      def selector_label(selector)
+        [
+          selector.error_class && Formatter.error_class_label(selector.error_class),
+          selector.job_class
+        ].compact.join(" · ")
+      end
+    end
+  end
+end

data/lib/sidekiq/error_groups/compat.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Sidekiq
+  module ErrorGroups
+    # Sidekiq changed its Web UI extension API several times between 6.0 and 8.x.
+    # Every version check in this gem goes through here, so the differences stay
+    # in one place.
+    module Compat
+      module_function
+
+      def sidekiq_version
+        @sidekiq_version ||= Gem::Version.new(Sidekiq::VERSION)
+      end
+
+      def at_least?(version)
+        sidekiq_version >= Gem::Version.new(version)
+      end
+
+      # Web UI rewritten: `Sidekiq::Web.configure`, `route_params(:key)`,
+      # `url_params("key")` and a brand new markup/CSS.
+      def sidekiq_8?
+        at_least?("8.0.0")
+      end
+
+      # `Sidekiq::Web.register` gained the `name:`/`tab:`/`index:` keywords.
+      def sidekiq_73?
+        at_least?("7.3.0")
+      end
+
+      # Reset memoized state, used by the test suite.
+      def reset!
+        @sidekiq_version = nil
+      end
+    end
+  end
+end