sidekiq-antidote 1.0.0.alpha.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 052bc50b4ce029ead4b2a4e6253625cf9a82a9c4071be61945e76336d9d13f18
+  data.tar.gz: a12ac47db5f3edee4fba2e600b1da4029db87657a8bde540a7b3f2fb2c07911b
+SHA512:
+  metadata.gz: d9cf2a9e0db287b0b6c7d40a4fe99c7927dbb9aee9fdfd8efc06bdb81c91396f6b169271973746d2b543ac34673694c7894338d8c43d9f947f5f17659bafb4b8
+  data.tar.gz: 57d9306f0b40cbccd67a1cf9f5d7260ddb59098cf1078fca7aca4ae88df58b669e38e2a2dd6059cb4d1c48ecdbf35e2eb56ff55bcdf957f4955dca33f0dee102

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2023 Alexey Zapparov
+
+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.adoc

@@ -0,0 +1,104 @@
+= Sidekiq::Antidote
+
+
+== Installation
+
+Add this line to your application's Gemfile:
+
+    $ bundle add sidekiq-antidote
+
+Or install it yourself as:
+
+    $ gem install sidekiq-antidote
+
+
+== Usage
+
+[source, ruby]
+----
+require "sidekiq"
+require "sidekiq/antidote"
+
+Sidekiq::Antidote.configure do |config|
+  # Set redis key prefix.
+  # Default: nil
+  config.key_prefix = "my-app:"
+
+  # Set inhibitors cache refresh rate in seconds.
+  # Default: 5.0
+  config.refresh_rate = 10.0
+end
+----
+
+When running in forked environment (e.g., Puma web server), you also need to
+call `Sidekiq::Antidote.startup` on fork:
+
+[source, ruby]
+----
+# file: config/puma.rb
+on_worker_boot { Sidekiq::Antidote.startup }
+----
+
+=== Web UI
+
+Adding Antidote tab in Sidekiq web UI is as simple as:
+
+[source, ruby]
+----
+require "sidekiq/web"
+require "sidekiq/antidote/web"
+----
+
+
+== Supported Ruby Versions
+
+This library aims to support and is tested against the following Ruby versions:
+
+* Ruby 3.0.x
+* Ruby 3.1.x
+* Ruby 3.2.x
+
+If something doesn't work on one of these versions, it's a bug.
+
+This library may inadvertently work (or seem to work) on other Ruby versions,
+however support will only be provided for the versions listed above.
+
+If you would like this library to support another Ruby version or
+implementation, you may volunteer to be a maintainer. Being a maintainer
+entails making sure all tests run and pass on that implementation. When
+something breaks on your implementation, you will be responsible for providing
+patches in a timely fashion. If critical issues for a particular implementation
+exist at the time of a major release, support for that Ruby version may be
+dropped.
+
+
+== Supported Sidekiq Versions
+
+This library aims to support and work with following Sidekiq versions:
+
+* Sidekiq 7.0.x
+* Sidekiq 7.1.x
+* Sidekiq 7.2.x
+
+
+== Development
+
+  bundle install
+  bundle exec appraisal generate
+  bundle exec appraisal install
+  bundle exec rake
+
+
+== Contributing
+
+* Fork sidekiq-antidote
+* Make your changes
+* Ensure all tests pass (`bundle exec rake`)
+* Send a merge request
+* If we like them we'll merge them
+* If we've accepted a patch, feel free to ask for commit access!
+
+
+== Acknowledgement
+
+* Inspired by https://github.com/square/sidekiq-killswitch[sidekiq-killswitch]

data/lib/sidekiq/antidote/class_qualifier.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+require "forwardable"
+require "strscan"
+require "stringio"
+
+module Sidekiq
+  module Antidote
+    # Job display class pattern matcher. Some job classes may be represented by
+    # class and metehod name (e.g., `OnboardingMailer#welcome`) which is handled
+    # by this qualifier.
+    #
+    # ## Pattern Special Characters
+    #
+    # * `*` matches any number of alpha-numeric characters and underscores.
+    #   Examples: `Foo`, `FooBar`, `method_name`
+    # * `**` matches any number of components.
+    #   Examples: `Foo`, `Foo::Bar`, `Foo::Bar#method_name`
+    # * `{A,B,C}` matches literal `A`, `B`, or `C`.
+    class ClassQualifier
+      extend Forwardable
+
+      LITERAL = %r{(?:[a-z0-9_\#]|::)+}i
+      private_constant :LITERAL
+
+      WILDCARD = %r{\*+}
+      private_constant :WILDCARD
+
+      ALTERNATION = %r{\{[^*\{]+\}}
+      private_constant :ALTERNATION
+
+      # @return [String]
+      attr_reader :pattern
+      alias to_s pattern
+
+      # @return [Regexp]
+      attr_reader :regexp
+
+      # @!method match?(job_class)
+      #   @param job_class [String]
+      #   @return [Boolean]
+      def_delegator :regexp, :match?
+
+      # @param pattern [#to_s]
+      def initialize(pattern)
+        @pattern = pattern.to_s.strip.freeze
+        raise ArgumentError, "blank pattern" if @pattern.empty?
+
+        @regexp = build_regexp(@pattern)
+
+        freeze
+      end
+
+      # @param other [Object]
+      # @return [Boolean]
+      def eql?(other)
+        self.class == other.class && pattern == other.pattern
+      end
+      alias == eql?
+
+      private
+
+      def build_regexp(pattern)
+        scanner = StringScanner.new(pattern)
+        parts   = StringIO.new
+
+        until scanner.eos?
+          next if consume_literal(scanner, parts)
+          next if consume_wildcard(scanner, parts)
+          next if consume_alternation(scanner, parts)
+
+          raise ArgumentError, "invalid token #{scanner.peek(1)} at #{scanner.pos}: #{scanner.string.inspect}"
+        end
+
+        %r{\A#{parts.string}\z}i
+      end
+
+      def consume_literal(scanner, parts)
+        scanner.scan(LITERAL)&.then { parts << _1 }
+      end
+
+      def consume_wildcard(scanner, parts)
+        scanner.scan(WILDCARD)&.then do |wildcard|
+          case wildcard.length
+          when 1 then parts << "[a-z0-9_]*"
+          when 2 then parts << "(?:(?:\\#|::)?[a-z0-9_]+)*"
+          else
+            scanner.unscan
+            raise ArgumentError, "ambiguous wildcard #{wildcard} at #{scanner.pos}: #{scanner.string.inspect}"
+          end
+        end
+      end
+
+      def consume_alternation(scanner, parts)
+        scanner.scan(ALTERNATION)&.then do |alternation|
+          variants = alternation[1...-1].split(",").map { Regexp.escape(_1) }
+          parts << "(?:#{variants.join('|')})"
+        end
+      end
+    end
+  end
+end

data/lib/sidekiq/antidote/config.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module Sidekiq
+  module Antidote
+    class Config
+      REDIS_KEY = "sidekiq-antidote"
+      private_constant :REDIS_KEY
+
+      # Default refresh rate
+      REFRESH_RATE = 5.0
+
+      # @return [String?]
+      attr_reader :key_prefix
+
+      # @return [Float]
+      attr_reader :refresh_rate
+
+      # Fully qualified Redis key
+      #
+      # @example Without key prefix (default)
+      #   config.redis_key # => "sidekiq-antidote"
+      #
+      # @example With key prefix
+      #   config.key_prefix = "foobar:"
+      #   config.redis_key # => "foobar:sidekiq-antidote"
+      #
+      # @see #key_prefix
+      # @return [String]
+      attr_reader :redis_key
+
+      def initialize
+        @key_prefix   = nil
+        @redis_key    = REDIS_KEY
+        @refresh_rate = REFRESH_RATE
+      end
+
+      # Redis key prefix.
+      #
+      # @example
+      #   config.key_prefix = "foobar:"
+      #   config.redis_key # => "foobar:sidekiq-antidote"
+      #
+      # @see #redis_key
+      # @param value [String, nil] String that should be prepended to redis key
+      # @return [void]
+      def key_prefix=(value)
+        raise ArgumentError, "expected String, or nil; got #{value.class}" unless value.nil? || value.is_a?(String)
+
+        @redis_key  = [value, REDIS_KEY].compact.join.freeze
+        @key_prefix = value&.then(&:-@) # Don't freeze original String value if it was unfrozen
+      end
+
+      # Inhibitors cache refresh rate in seconds.
+      #
+      # @param value [Float] refresh interval in seconds
+      # @return [void]
+      def refresh_rate=(value)
+        unless value.is_a?(Float) && value.positive?
+          raise ArgumentError, "expected positive Float; got #{value.inspect}"
+        end
+
+        @refresh_rate = value
+      end
+    end
+  end
+end

data/lib/sidekiq/antidote/inhibitor.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require "securerandom"
+
+require_relative "./class_qualifier"
+
+module Sidekiq
+  module Antidote
+    # Single poison inhibition rule: class qualifier + treatment action.
+    class Inhibitor
+      TREATMENTS  = %w[skip kill].freeze
+
+      # @return [String]
+      attr_reader :id
+
+      # @return ["skip", "kill"]
+      attr_reader :treatment
+
+      # @return [ClassQualifier]
+      attr_reader :class_qualifier
+
+      # @param id [#to_s]
+      # @param treatment ["skip", "kill"]
+      # @param class_qualifier [#to_s]
+      def initialize(id:, treatment:, class_qualifier:)
+        @id              = -id.to_s
+        @treatment       = -treatment.to_s
+        @class_qualifier = ClassQualifier.new(class_qualifier.to_s)
+
+        raise ArgumentError, "invalid id: #{id.inspect}"               if @id.empty?
+        raise ArgumentError, "invalid treatment: #{treatment.inspect}" unless TREATMENTS.include?(@treatment)
+
+        freeze
+      end
+
+      def lethal?
+        "kill" == treatment
+      end
+
+      def match?(job_record)
+        class_qualifier.match?(job_record.display_class)
+      end
+
+      def to_s
+        "#{treatment} #{class_qualifier}"
+      end
+
+      def eql?(other)
+        self.class == other.class \
+          && id == other.id && treatment == other.treatment && class_qualifier == other.class_qualifier
+      end
+      alias == eql?
+    end
+  end
+end

data/lib/sidekiq/antidote/middlewares/client.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require_relative "./shared"
+
+module Sidekiq
+  module Antidote
+    module Middlewares
+      class Client
+        include Shared
+        include Sidekiq::ClientMiddleware
+
+        # @see https://github.com/sidekiq/sidekiq/wiki/Middleware
+        # @see https://github.com/sidekiq/sidekiq/wiki/Job-Format
+        def call(_, job_payload, _, _)
+          yield unless inhibit(job_payload)
+        end
+      end
+    end
+  end
+end

data/lib/sidekiq/antidote/middlewares/server.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require_relative "./shared"
+
+module Sidekiq
+  module Antidote
+    module Middlewares
+      class Server
+        include Shared
+        include Sidekiq::ServerMiddleware
+
+        # @see https://github.com/sidekiq/sidekiq/wiki/Middleware
+        # @see https://github.com/sidekiq/sidekiq/wiki/Job-Format
+        def call(_, job_payload, _)
+          yield unless inhibit(job_payload)
+        end
+      end
+    end
+  end
+end

data/lib/sidekiq/antidote/middlewares/shared.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require "sidekiq/api"
+
+module Sidekiq
+  module Antidote
+    module Middlewares
+      module Shared
+        private
+
+        # @return [true] if message was inhibited
+        # @return [false] otherwise
+        def inhibit(message)
+          job_record = Sidekiq::JobRecord.new(message)
+          inhibitor  = Antidote.remedy_for(job_record)
+          return false unless inhibitor
+
+          Antidote.log(:warn) { "I've got a poison! -- #{job_record.display_class}" }
+          Antidote.log(:warn) { "I've got a remedy! -- #{inhibitor}" }
+          DeadSet.new.kill(Sidekiq.dump_json(message)) if inhibitor.lethal?
+
+          true
+        end
+      end
+    end
+  end
+end

data/lib/sidekiq/antidote/remedy.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require "concurrent"
+
+module Sidekiq
+  module Antidote
+    # Eventually consistent list of inhibitors. Used by middlewares to avoid
+    # hitting Redis on every lookup.
+    class Remedy
+      include Enumerable
+
+      # @param refresh_rate [Float]
+      # @param repository [Repository]
+      def initialize(refresh_rate, repository:)
+        @inhibitors = [].freeze
+        @refresher  = Concurrent::TimerTask.new(execution_interval: refresh_rate, run_now: true) do
+          @inhibitors = repository.to_a.freeze
+        end
+      end
+
+      # @overload each
+      #   @return [Enumerator<Inhibitor>]
+      #
+      # @overload each(&block)
+      #   For a block { |inhibitor| ... }
+      #   @yieldparam inhibitor [Inhibitor]
+      #   @return [self]
+      def each(&block)
+        return to_enum __method__ unless block
+
+        start_refresher unless refresher_running?
+        @inhibitors.each(&block)
+
+        self
+      end
+
+      # Starts inhibitors list async poller.
+      #
+      # @return [self]
+      def start_refresher
+        @refresher.execute
+        self
+      end
+
+      # Stops inhibitors list async poller.
+      #
+      # @return [self]
+      def stop_refresher
+        @refresher.shutdown
+        self
+      end
+
+      # Returns whenever inhibitors list async poller is running.
+      #
+      # @return [Boolean]
+      def refresher_running?
+        @refresher.running?
+      end
+    end
+  end
+end

data/lib/sidekiq/antidote/repository.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+require_relative "./inhibitor"
+
+module Sidekiq
+  module Antidote
+    # Inhibitors repository
+    class Repository
+      include Enumerable
+
+      # @param redis_key [#to_s]
+      def initialize(redis_key)
+        @redis_key = -redis_key.to_s
+
+        freeze
+      end
+
+      # @overload each
+      #   @return [Enumerator<Inhibitor>]
+      #
+      # @overload each(&block)
+      #   For a block { |inhibitor| ... }
+      #   @yieldparam inhibitor [Inhibitor]
+      #   @return [self]
+      def each
+        return to_enum __method__ unless block_given?
+
+        broken_ids = []
+
+        redis("HGETALL", @redis_key).each do |id, payload|
+          inhibitor = deserialize(id, payload)
+          next yield inhibitor if inhibitor
+
+          broken_ids << id
+        end
+
+        delete(*broken_ids)
+        self
+      end
+
+      # @param treatment (see Inhibitor#initialize)
+      # @param class_qualifier (see Inhibitor#initialize)
+      # @raise [RuntimeError] when can't generate new inhibitor ID
+      # @return [Inhibitor]
+      def add(treatment:, class_qualifier:)
+        3.times do
+          inhibitor = Sidekiq::Antidote::Inhibitor.new(
+            id:              SecureRandom.hex(8),
+            treatment:       treatment,
+            class_qualifier: class_qualifier
+          )
+
+          return inhibitor if redis("HSETNX", @redis_key, *serialize(inhibitor)).to_i.positive?
+        end
+
+        raise "can't generate available ID"
+      end
+
+      # @param ids [Array<String>]
+      # @return [nil]
+      def delete(*ids)
+        redis("HDEL", @redis_key, *ids) unless ids.empty?
+        nil
+      end
+
+      private
+
+      def deserialize(id, payload)
+        treatment, class_qualifier = Sidekiq.load_json(payload)
+
+        Inhibitor.new(id: id, treatment: treatment, class_qualifier: class_qualifier)
+      rescue StandardError => e
+        Antidote.log(:error) { "failed deserializing inhibitor (#{payload.inspect}): #{e.message}" }
+        nil
+      end
+
+      def serialize(inhibitor)
+        [
+          inhibitor.id,
+          Sidekiq.dump_json([
+            inhibitor.treatment,
+            inhibitor.class_qualifier.pattern
+          ])
+        ]
+      end
+
+      def redis(...)
+        Sidekiq.redis { _1.call(...) }
+      end
+    end
+  end
+end

data/lib/sidekiq/antidote/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Sidekiq
+  module Antidote
+    VERSION = "1.0.0.alpha.1"
+  end
+end

data/lib/sidekiq/antidote/web.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require "sidekiq"
+require "sidekiq/web"
+
+module Sidekiq
+  module Antidote
+    module Web
+      VIEWS = Pathname.new(__dir__).join("../../../web/views").expand_path
+
+      def self.registered(app) # rubocop:disable Metrics/AbcSize,Metrics/MethodLength
+        app.get("/antidote") do
+          @inhibitors = Antidote.inhibitors
+
+          erb(VIEWS.join("index.html.erb").read)
+        end
+
+        app.get("/antidote/add") do
+          @treatment       = Sidekiq::Antidote::Inhibitor::TREATMENTS.first
+          @class_qualifier = ""
+
+          erb(VIEWS.join("add.html.erb").read)
+        end
+
+        app.post("/antidote/add") do
+          @treatment             = params[:treatment]
+          @treatment             = "skip" unless Sidekiq::Antidote::Inhibitor::TREATMENTS.include?(@treatment)
+          @class_qualifier       = params[:class_qualifier]
+          @class_qualifier_error = nil
+
+          begin
+            Sidekiq::Antidote::ClassQualifier.new(@class_qualifier)
+          rescue StandardError => e
+            @class_qualifier_error = e.message
+          end
+
+          if @class_qualifier_error
+            erb(VIEWS.join("add.html.erb").read)
+          else
+            Antidote.add(treatment: @treatment, class_qualifier: @class_qualifier)
+            redirect "#{root_path}antidote"
+          end
+        end
+
+        app.post("/antidote/:id/delete") do
+          Antidote.delete(route_params[:id])
+
+          redirect "#{root_path}antidote"
+        end
+      end
+    end
+  end
+end
+
+Sidekiq::Web.register(Sidekiq::Antidote::Web)
+Sidekiq::Web.tabs["Antidote"] = "antidote"
+Sidekiq::Web.locales << Pathname.new(__dir__).join("../../../web/locales").expand_path.to_s

data/lib/sidekiq/antidote.rb

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+require "sidekiq"
+require "sidekiq/api"
+
+require_relative "./antidote/config"
+require_relative "./antidote/inhibitor"
+require_relative "./antidote/middlewares/client"
+require_relative "./antidote/middlewares/server"
+require_relative "./antidote/remedy"
+require_relative "./antidote/repository"
+require_relative "./antidote/version"
+
+module Sidekiq
+  module Antidote
+    MUTEX = Mutex.new
+
+    @config     = Config.new.freeze
+    @repository = Repository.new(@config.redis_key)
+    @remedy     = Remedy.new(@config.refresh_rate, repository: @repository)
+
+    class << self
+      extend Forwardable
+
+      # @!method add(treatment:, class_qualifier:)
+      #   @param (see Repository#add)
+      #   @return (see Repository#add)
+      def_delegators :@repository, :add
+
+      # @!method delete(*ids)
+      #   @param (see Repository#delete)
+      #   @return (see Repository#delete)
+      def_delegators :@repository, :delete
+
+      # @!attribute [r] redis_key
+      #   @return [String]
+      def_delegators :@config, :redis_key
+
+      # @return [Array<Inhibitor>] Live list of inhibitors
+      def inhibitors
+        @repository.to_a
+      end
+
+      # @api internal
+      # @param job_record [Sidekiq::JobRecord]
+      # @return [Inhibitor, nil]
+      def remedy_for(job_record)
+        @remedy.find { _1.match?(job_record) }
+      end
+
+      # Yields `config` for a block.
+      #
+      # @example
+      #   Sidekiq::Antidote.configure do |config|
+      #     config.refresh_rate = 42.0
+      #   end
+      #
+      # @yieldparam config [Config]
+      def configure
+        MUTEX.synchronize do
+          config = @config.dup
+
+          yield config
+
+          @config     = config.freeze
+          @repository = Repository.new(@config.redis_key)
+
+          self
+        ensure
+          reinit_remedy
+        end
+      end
+
+      # Starts inhibitors poller.
+      #
+      # @return [self]
+      def startup
+        MUTEX.synchronize { reinit_remedy.start_refresher }
+
+        self
+      end
+
+      # Shutdown inhibitors poller.
+      #
+      # @return [self]
+      def shutdown
+        MUTEX.synchronize { @remedy.stop_refresher }
+
+        self
+      end
+
+      # @api internal
+      #
+      # @return [nil]
+      def log(severity)
+        Sidekiq.logger.public_send(severity) { "sidekiq-antidote: #{yield}" }
+        nil
+      end
+
+      private
+
+      def reinit_remedy
+        @remedy.stop_refresher
+        @remedy = Remedy.new(@config.refresh_rate, repository: @repository)
+      end
+    end
+  end
+
+  # TODO: How to test both configure_{client,server}?
+  configure_client do |config|
+    config.client_middleware do |chain|
+      chain.add Sidekiq::Antidote::Middlewares::Client
+    end
+  end
+
+  configure_server do |config|
+    config.on(:startup)  { Antidote.startup }
+    config.on(:shutdown) { Antidote.shutdown }
+
+    config.client_middleware do |chain|
+      chain.add Sidekiq::Antidote::Middlewares::Client
+    end
+
+    config.server_middleware do |chain|
+      chain.add Sidekiq::Antidote::Middlewares::Server
+    end
+  end
+end

data/web/locales/en.yml

@@ -0,0 +1,8 @@
+---
+en:
+  antidote.treatment: Treatment
+  antidote.qualifier: Job Class Pattern
+  antidote.actions: Actions
+  antidote.add: Add Inhibitor
+  antidote.submit: Submit
+  antidote.no_inhibitors: No inhibitors found

data/web/views/add.html.erb

@@ -0,0 +1,31 @@
+<div class="header-container">
+  <h1><a href="<%=root_path %>antidote">Antidote</a> / <%= t("antidote.add") %></h1>
+</div>
+
+<% if @error %>
+  <div class="alert alert-danger"><%= @error %></div>
+<% end %>
+
+<form id="antidote-inhibitor" action="<%=root_path %>antidote/add" method="post">
+  <%= csrf_tag %>
+  <div class="form-row">
+    <div class="form-group col-md-2">
+      <label for="antidote-inhibitor-treatment"><%= t("antidote.treatment") %></label>
+      <select id="antidote-inhibitor-treatment" name="treatment" class="form-control">
+        <% Sidekiq::Antidote::Inhibitor::TREATMENTS.each do |treatment| %>
+          <option <%= "selected" if treatment == @treatment %>><%= treatment %></option>
+        <% end %>
+      </select>
+    </div>
+    <div class="form-group col-md-10">
+      <label for="antidote-inhibitor-class-qualifier"><%= t("antidote.qualifier") %></label>
+      <input id="antidote-inhibitor-class-qualifier" type="text" class="form-control <%= "is-invalid" if @class_qualifier_error %>" name="class_qualifier" value="<%= @class_qualifier %>">
+      <% if @class_qualifier_error %>
+        <div id="antidote-inhibitor-class-qualifier-error" class="invalid-feedback"><%= @class_qualifier_error %></div>
+      <% end %>
+    </div>
+  </div>
+  <div class="form-row text-right">
+    <button id="antidote-inhibitor-submit" type="submit" class="btn"><%= t("antidote.submit") %></button>
+  </div>
+</form>

data/web/views/index.html.erb

@@ -0,0 +1,34 @@
+<div class="header-container">
+  <h1>Antidote</h1>
+  <div>
+    <a href="<%=root_path %>antidote/add" class="btn"><%= t("antidote.add") %></a>
+  </div>
+</div>
+
+<% if @inhibitors.empty? %>
+  <div class="alert alert-success"><%= t("antidote.no_inhibitors") %></div>
+<% else %>
+  <div class="table_container">
+    <table class="antidote table table-hover table-bordered table-striped">
+      <thead>
+        <th><%= t("antidote.treatment") %></th>
+        <th><%= t("antidote.qualifier") %></th>
+        <th><%= t("antidote.actions") %></th>
+      </thead>
+      <tbody>
+        <% @inhibitors.each do |inhibitor| %>
+          <tr id="antidote-inhibitor-<%= CGI.escape(inhibitor.id) %>">
+            <td><%= inhibitor.treatment %></td>
+            <td><%= inhibitor.class_qualifier.pattern %></td>
+            <td class="delete-confirm">
+              <form action="<%=root_path %>antidote/<%= CGI.escape(inhibitor.id) %>/delete" method="post">
+                <%= csrf_tag %>
+                <input class="btn btn-danger" type="submit" name="delete" value="<%= t("Delete") %>" data-confirm="<%= t("AreYouSureDeleteQueue") %>" />
+              </form>
+            </td>
+          </tr>
+        <% end  %>
+      </tbody>
+    </table>
+  </div>
+<% end %>

metadata

@@ -0,0 +1,92 @@
+--- !ruby/object:Gem::Specification
+name: sidekiq-antidote
+version: !ruby/object:Gem::Version
+  version: 1.0.0.alpha.1
+platform: ruby
+authors:
+- Alexey Zapparov
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2023-12-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: concurrent-ruby
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.2.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.2.0
+- !ruby/object:Gem::Dependency
+  name: sidekiq
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.0'
+description:
+email:
+- alexey@zapparov.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE.txt
+- README.adoc
+- lib/sidekiq/antidote.rb
+- lib/sidekiq/antidote/class_qualifier.rb
+- lib/sidekiq/antidote/config.rb
+- lib/sidekiq/antidote/inhibitor.rb
+- lib/sidekiq/antidote/middlewares/client.rb
+- lib/sidekiq/antidote/middlewares/server.rb
+- lib/sidekiq/antidote/middlewares/shared.rb
+- lib/sidekiq/antidote/remedy.rb
+- lib/sidekiq/antidote/repository.rb
+- lib/sidekiq/antidote/version.rb
+- lib/sidekiq/antidote/web.rb
+- web/locales/en.yml
+- web/views/add.html.erb
+- web/views/index.html.erb
+homepage: https://github.com/ixti/sidekiq-antidote
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/ixti/sidekiq-antidote
+  source_code_uri: https://github.com/ixti/sidekiq-antidote/tree/v1.0.0.alpha.1
+  bug_tracker_uri: https://github.com/ixti/sidekiq-antidote/issues
+  changelog_uri: https://github.com/ixti/sidekiq-antidote/blob/v1.0.0.alpha.1/CHANGES.md
+  rubygems_mfa_required: 'true'
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">"
+    - !ruby/object:Gem::Version
+      version: 1.3.1
+requirements: []
+rubygems_version: 3.4.10
+signing_key:
+specification_version: 4
+summary: Sidekiq poison-pill instant remedy
+test_files: []