sidekiq 8.1.1 → 8.1.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4fb090d79e2cf2b320fdd47ee55a574a68a46b77a23db27b849ddb6f54acb00a
-  data.tar.gz: 4863ef28ecdd8ad2cd868caf2f47cc9302b8eb88f4ff9da4f2b5641beca50d88
+  metadata.gz: 1e36b05d6e25f174a0ff8b8a21b4c097a108e4ccf98af88a56ae767cfea1186a
+  data.tar.gz: c58b4f89a1466bac6c9de05cf5ea2aee0152ac42184946b4d1646c6938b351a8
 SHA512:
-  metadata.gz: 4ba71a2c43cec613337119cd29830339e213a8f876db4db84c62ac67890ee020ab841a4f7fe478f7f0fcd135571b885e54c9af12998ea6947ac51b543d52b42c
-  data.tar.gz: 9cabfc243aacec3c57c697b83374a5b934cc985c1e4ee86185a6faba7fe18f6540e3fa0b203c5dbfc0e22c03513f66e973be4152d8c8e12db29e97e21a94360f
+  metadata.gz: 3b8690078001bb93fc6e4fb8fe4d52091d89c317d8dcef56d24247882f4c85dbe986a05ae5451aaf70b9ff25c4acbc89b2d15e909763550bbcb13f36e73b2f7f
+  data.tar.gz: 3cabd5a3a2861af5faf70c5f67d8eb93c578d58cb7825dc063e350f30ef37dc3e2c51060a58dcf2fca9915df1bb7fcbfd00d81996ba651c29882c8432545b03a

data/Changes.md

@@ -2,16 +2,63 @@
 
 [Sidekiq Changes](https://github.com/sidekiq/sidekiq/blob/main/Changes.md) | [Sidekiq Pro Changes](https://github.com/sidekiq/sidekiq/blob/main/Pro-Changes.md) | [Sidekiq Enterprise Changes](https://github.com/sidekiq/sidekiq/blob/main/Ent-Changes.md)
 
+8.1.6
+----------
+
+- Fix reported thread/memory leak when jobs fail [#7006]
+- Users can limit data displayed on Busy page with the `only` parameter `/busy?only=(jobs|processes)` [#6992]
+- Replace Rack::Utils usage with standard library APIs
+- Several minor fixes from AI scanners.
+
+8.1.5
+----------
+
+- Fix sub-second precision when computing the `retry_for` deadline [#7003]
+- Identify Sidekiq connnections in Redis with `CLIENT SETINFO` [#6986]
+- Fix edge case where Web UI could show an empty Batch set [#6987]
+
+8.1.4
+----------
+
+- The TTIN signal is undeprecated as the INFO signal is not supported on Linux
+- Show iteration job state on Busy page [#6978]
+
+8.1.3
+----------
+
+- Fix edge case leading to duplicate, concurrent execution [#6379]
+  If 2 Capsules process jobs from the same queue, long-running
+  jobs could run in parallel during process shutdown.
+- [SECURITY] Remove as much YAML usage as possible. [#6950]
+  Localization files in `web/locales` are now manually parsed.
+  Sidekiq::CLI will now only require YAML if you use a `-C` .yml file.
+
+8.1.2
+----------
+
+- Initial release for `kiq`, Sidekiq's official terminal UI:
+```
+bundle exec kiq
+```
+Use REDIS_URL or REDIS_PROVIDER to point `kiq` to Redis.
+- Mutation during iteration in `SortedSet#each` caused it to miss half of the jobs [#6936]
+- Fix edge case resulting in nil crash on /busy page [#6954]
+
 8.1.1
 ----------
 
-- Add new `Sidekiq.testing!(mode)` API [#6931]
-Requiring code should not enable process-wide changes.
+- **DEPRECATION** `require 'sidekiq/testing'` and
+  `require 'sidekiq/testing/inline'`.
+  Add new `Sidekiq.testing!(mode)` API [#6931]
+  Requiring code should not enable process-wide changes.
 ```ruby
 # Old, implicit
 require "sidekiq/testing"
+require "sidekiq/testing/inline"
 # New, more explicit
+require "sidekiq"
 Sidekiq.testing!(:fake)
+Sidekiq.testing!(:inline)
 ```
 - Fix race condition with Stop button in UI [#6935]
 - Fix javascript error handler [#6893]

data/README.md

@@ -90,7 +90,7 @@ Useful resources:
 * The [Sidekiq tag](https://stackoverflow.com/questions/tagged/sidekiq) on Stack Overflow has lots of useful Q & A.
 
 Every Thursday morning is Sidekiq Office Hour: I video chat and answer questions.
-See the [Sidekiq support page](https://sidekiq.org/support.html) for details.
+See the [Sidekiq support page](https://sidekiq.org/support/) for details.
 
 Contributing
 -----------------

data/bin/kiq

@@ -0,0 +1,17 @@
+#!/usr/bin/env ruby
+
+# This requires the default gemset so Sidekiq Pro
+# and Sidekiq Enterprise can load any code extensions.
+Bundler.require(:default, :tui)
+
+require_relative "../lib/sidekiq/tui"
+
+# Run any load hooks registered during Bundler.require
+Sidekiq.loader.run_load_hooks(:tui)
+
+tt = Sidekiq::TUI.new(Sidekiq.default_configuration)
+
+RatatuiRuby.run do |tui|
+  tt.prepare(tui)
+  tt.run_loop
+end

data/lib/active_job/queue_adapters/sidekiq_adapter.rb

@@ -63,19 +63,19 @@ begin
         def enqueue(job)
           # NB: Active Job only serializes keys it recognizes. We
           # cannot set arbitrary key/values here.
-          wrapper = Sidekiq::ActiveJob::Wrapper.set(
-            wrapped: job.class,
-            queue: job.queue_name
-          )
+          options = {wrapped: job.class, queue: job.queue_name}
+          options[:profile] = job.profile if job.respond_to?(:profile) && !job.profile.nil?
+
+          wrapper = Sidekiq::ActiveJob::Wrapper.set(options)
           job.provider_job_id = wrapper.perform_async(job.serialize)
         end
 
         # @api private
         def enqueue_at(job, timestamp)
-          job.provider_job_id = Sidekiq::ActiveJob::Wrapper.set(
-            wrapped: job.class,
-            queue: job.queue_name
-          ).perform_at(timestamp, job.serialize)
+          options = {wrapped: job.class, queue: job.queue_name}
+          options[:profile] = job.profile if job.respond_to?(:profile) && !job.profile.nil?
+
+          job.provider_job_id = Sidekiq::ActiveJob::Wrapper.set(options).perform_at(timestamp, job.serialize)
         end
 
         # @api private

data/lib/sidekiq/api.rb

@@ -478,6 +478,10 @@ module Sidekiq
       self["jid"]
     end
 
+    def iterable_state
+      @iterable_state ||= Sidekiq::IterableJobQuery.new(jid)[jid]
+    end
+
     def bid
       self["bid"]
     end
@@ -657,38 +661,8 @@ module Sidekiq
 
     private
 
-    def remove_job
-      Sidekiq.redis do |conn|
-        results = conn.multi { |transaction|
-          transaction.zrange(parent.name, score, score, "BYSCORE")
-          transaction.zremrangebyscore(parent.name, score, score)
-        }.first
-
-        if results.size == 1
-          yield results.first
-        else
-          # multiple jobs with the same score
-          # find the one with the right JID and push it
-          matched, nonmatched = results.partition { |message|
-            if message.index(jid)
-              msg = Sidekiq.load_json(message)
-              msg["jid"] == jid
-            else
-              false
-            end
-          }
-
-          msg = matched.first
-          yield msg if msg
-
-          # push the rest back onto the sorted set
-          conn.multi do |transaction|
-            nonmatched.each do |message|
-              transaction.zadd(parent.name, score.to_f.to_s, message)
-            end
-          end
-        end
-      end
+    def remove_job(&)
+      parent.remove_job(self, &)
     end
   end
 
@@ -857,6 +831,46 @@ module Sidekiq
       nil
     end
 
+    def remove_job(entry)
+      score = entry.score
+      jid = entry.jid
+      Sidekiq.redis do |conn|
+        results = conn.multi { |transaction|
+          transaction.zrange(name, score, score, "BYSCORE")
+          transaction.zremrangebyscore(name, score, score)
+        }.first
+
+        if results.size == 1
+          yield results.first
+          @_size -= 1
+        else
+          # multiple jobs with the same score
+          # find the one with the right JID and push it
+          matched, nonmatched = results.partition { |message|
+            if message.index(jid)
+              msg = Sidekiq.load_json(message)
+              msg["jid"] == jid
+            else
+              false
+            end
+          }
+
+          msg = matched.first
+          if msg
+            yield msg
+            @_size -= 1
+          end
+
+          # push the rest back onto the sorted set
+          conn.multi do |transaction|
+            nonmatched.each do |message|
+              transaction.zadd(name, score.to_f.to_s, message)
+            end
+          end
+        end
+      end
+    end
+
     # :nodoc:
     # @api private
     def delete_by_value(name, value)
@@ -1030,19 +1044,20 @@ module Sidekiq
         # you'll be happier this way
         conn.pipelined do |pipeline|
           procs.each do |key|
-            pipeline.hmget(key, "info", "busy", "beat", "quiet", "rss", "rtt_us")
+            pipeline.hmget(key, "info", "concurrency", "busy", "beat", "quiet", "rss", "rtt_us")
           end
         end
       }
 
-      result.each do |info, busy, beat, quiet, rss, rtt_us|
+      result.each do |info, concurrency, busy, beat, quiet, rss, rtt_us|
         # If a process is stopped between when we query Redis for `procs` and
         # when we query for `result`, we will have an item in `result` that is
         # composed of `nil` values.
         next if info.nil?
 
         hash = Sidekiq.load_json(info)
-        yield Process.new(hash.merge("busy" => busy.to_i,
+        yield Process.new(hash.merge("concurrency" => concurrency.to_i,
+          "busy" => busy.to_i,
           "beat" => beat.to_f,
           "quiet" => quiet,
           "rss" => rss.to_i,
@@ -1386,6 +1401,66 @@ module Sidekiq
       Sidekiq.redis { |c| c.hget(key, "data") }
     end
   end
+
+  # Persisted iteration state from Redis for jobs using Sidekiq::IterableJob.
+  class IterableJobQuery
+    def initialize(jids)
+      @cache = bulk_fetch(jids)
+    end
+
+    def [](jid)
+      @cache[jid]
+    end
+
+    private
+
+    # Bulk-fetch iteration state for multiple JIDs in a single Redis pipeline.
+    # Returns a Hash of { jid => IterableJobState } for JIDs that have iteration state.
+    def bulk_fetch(jids)
+      raise ArgumentError unless jids
+      jids_to_fetch = Array(jids).compact.uniq
+      return {} if jids_to_fetch.empty?
+
+      results = Sidekiq.redis do |conn|
+        conn.pipelined do |pipe|
+          jids_to_fetch.each { |jid| pipe.hgetall("it-#{jid}") }
+        end
+      end
+
+      # TODO Requires Ruby 4
+      # states = ::Hash.new(capacity: jids_to_fetch.size)
+      states = {}
+      jids_to_fetch.each_with_index do |jid, i|
+        raw = results[i]
+        next if raw.nil? || raw.empty?
+
+        states[jid] = State.new(jid, raw)
+      end
+      states
+    end
+
+    State = Struct.new(:jid, :raw) do
+      def executions
+        raw["ex"].to_i
+      end
+
+      def runtime
+        raw["rt"].to_f
+      end
+
+      def cursor
+        @cursor ||= begin
+          Sidekiq.load_json(raw["c"])
+        rescue JSON::ParserError
+          @raw["c"]
+        end
+      end
+
+      def cancelled
+        raw["cancelled"]&.to_i
+      end
+    end
+  end
 end
 
 Sidekiq.loader.run_load_hooks(:api)

data/lib/sidekiq/capsule.rb

@@ -51,7 +51,6 @@ module Sidekiq
     end
 
     def stop
-      fetcher&.bulk_requeue([])
     end
 
     # Sidekiq checks queues in three modes:

data/lib/sidekiq/cli.rb

@@ -2,7 +2,6 @@
 
 $stdout.sync = true
 
-require "yaml"
 require "optparse"
 require "erb"
 require "fileutils"
@@ -201,9 +200,7 @@ module Sidekiq # :nodoc:
         cli.logger.info "Received TSTP, no longer accepting new work"
         cli.launcher.quiet
       },
-      # deprecated, use INFO
       "TTIN" => ->(cli) {
-        cli.logger.error { "DEPRECATED: Please use the INFO signal for backtraces, support for TTIN will be removed in Sidekiq 9.0." }
         Thread.list.each do |thread|
           cli.logger.warn "Thread TID-#{(thread.object_id ^ ::Process.pid).to_s(36)} #{thread.name}"
           if thread.backtrace
@@ -214,6 +211,7 @@ module Sidekiq # :nodoc:
         end
       },
       "INFO" => ->(cli) {
+        cli.logger.error { "DEPRECATED: the INFO signal does not work on Linux, use TTIN instead." }
         Thread.list.each do |thread|
           cli.logger.warn "Thread TID-#{(thread.object_id ^ ::Process.pid).to_s(36)} #{thread.name}"
           if thread.backtrace
@@ -409,6 +407,7 @@ module Sidekiq # :nodoc:
     def parse_config(path)
       erb = ERB.new(File.read(path), trim_mode: "-")
       erb.filename = File.expand_path(path)
+      require "yaml"
       opts = YAML.safe_load(erb.result, permitted_classes: [Symbol], aliases: true) || {}
 
       if opts.respond_to? :deep_symbolize_keys!

data/lib/sidekiq/client.rb

@@ -117,6 +117,11 @@ module Sidekiq
     # larger than 1000 but YMMV based on network quality, size of job args, etc.
     # A large number of jobs can cause a bit of Redis command processing latency.
     #
+    # Accepts an `:at` option to schedule the jobs for future execution. It
+    # accepts either a single Numeric timestamp (or seconds-from-now) applied
+    # to every job, or an Array of Numeric values with the same size as `args`
+    # to schedule each job at its corresponding time.
+    #
     # Accepts an additional `:spread_interval` option (in seconds) to randomly spread
     # the jobs schedule times over the specified interval.
     #
@@ -132,12 +137,14 @@ module Sidekiq
     #   push_bulk('class' => MyJob, 'args' => (1..100_000).to_a, batch_size: 1_000)
     #
     def push_bulk(items)
-      batch_size = items.delete(:batch_size) || items.delete("batch_size") || 1_000
       args = items["args"]
       at = items.delete("at") || items.delete(:at)
       raise ArgumentError, "Job 'at' must be a Numeric or an Array of Numeric timestamps" if at && (Array(at).empty? || !Array(at).all? { |entry| entry.is_a?(Numeric) })
       raise ArgumentError, "Job 'at' Array must have same size as 'args' Array" if at.is_a?(Array) && at.size != args.size
 
+      # Use a smaller batch size by default for scheduled jobs since adding to sorted sets is more costly.
+      batch_size = items.delete(:batch_size) || items.delete("batch_size") || (at ? 100 : 1_000)
+
       jid = items.delete("jid")
       raise ArgumentError, "Explicitly passing 'jid' when pushing more than one job is not supported" if jid && args.size > 1
 

data/lib/sidekiq/component.rb

@@ -57,6 +57,9 @@ module Sidekiq
     end
 
     def tid
+      # We XOR with PID to ensure Thread IDs changes after fork.
+      # I'm unclear why we don't multiply the two values to better guarantee
+      # a unique value but it's been this way for quite a while now. #3685
       Thread.current["sidekiq_tid"] ||= (Thread.current.object_id ^ ::Process.pid).to_s(36)
     end
 

data/lib/sidekiq/config.rb

@@ -255,7 +255,7 @@ module Sidekiq
     # Register a proc to handle any error which occurs within the Sidekiq process.
     #
     #   Sidekiq.configure_server do |config|
-    #     config.error_handlers << proc {|ex,ctx_hash| MyErrorService.notify(ex, ctx_hash) }
+    #     config.error_handlers << proc {|ex,ctx_hash,config| MyErrorService.notify(ex, ctx_hash) }
     #   end
     #
     # The default error handler logs errors to @logger.
@@ -297,15 +297,11 @@ module Sidekiq
       @logger = logger
     end
 
-    private def parameter_size(handler)
-      target = handler.is_a?(Proc) ? handler : handler.method(:call)
-      target.parameters.size
-    end
-
     # INTERNAL USE ONLY
     def handle_exception(ex, ctx = {})
-      if @options[:error_handlers].size == 0
-        p ["!!!!!", ex]
+      if @options[:error_handlers].empty?
+        logger.error { "No error handlers configured, logging exception directly" }
+        logger.error { ex }
       end
       @options[:error_handlers].each do |handler|
         handler.call(ex, ctx, self)

data/lib/sidekiq/job.rb

@@ -196,7 +196,7 @@ module Sidekiq
 
       def set(options)
         hash = options.transform_keys(&:to_s)
-        interval = hash.delete("wait_until") || @opts.delete("wait")
+        interval = hash.delete("wait_until") || hash.delete("wait")
         @opts.merge!(hash)
         at(interval) if interval
         self
@@ -313,6 +313,11 @@ module Sidekiq
       #
       # +items+ must be an Array of Arrays.
       #
+      # The +:at+ option schedules the jobs for future execution. It accepts
+      # either a single Numeric timestamp (or seconds-from-now) applied to every
+      # job, or an Array of Numeric values with the same size as +items+ to
+      # schedule each job at its corresponding time.
+      #
       # For finer-grained control, use `Sidekiq::Client.push_bulk` directly.
       #
       # Example (3 Redis round trips):
@@ -325,6 +330,14 @@ module Sidekiq
       #
       #     SomeJob.perform_bulk([[1], [2], [3]])
       #
+      # Scheduling every job 60 seconds from now (single Numeric +:at+):
+      #
+      #     SomeJob.perform_bulk([[1], [2], [3]], at: 60)
+      #
+      # Scheduling each job at its own time (Array +:at+):
+      #
+      #     SomeJob.perform_bulk([[1], [2]], at: [Time.now.to_f + 30, Time.now.to_f + 60])
+      #
       def perform_bulk(*args, **kwargs)
         Setter.new(self, {}).perform_bulk(*args, **kwargs)
       end

data/lib/sidekiq/job_retry.rb

@@ -211,7 +211,7 @@ module Sidekiq
       if item.is_a?(Float)
         Time.at(item)
       else
-        Time.at(item / 1000, item % 1000)
+        Time.at(item / 1000, item % 1000, :millisecond)
       end
     end
 

data/lib/sidekiq/launcher.rb

@@ -176,6 +176,7 @@ module Sidekiq
             transaction.sadd("processes", [key])
             transaction.exists(key)
             transaction.hset(key, "info", to_json,
+              "concurrency", @config.total_concurrency,
               "busy", curstate.size,
               "beat", Time.now.to_f,
               "rtt_us", rtt,
@@ -257,7 +258,6 @@ module Sidekiq
         "started_at" => Time.now.to_f,
         "pid" => ::Process.pid,
         "tag" => @config[:tag] || "",
-        "concurrency" => @config.total_concurrency,
         "capsules" => @config.capsules.each_with_object({}) { |(name, cap), memo|
           memo[name] = cap.to_h
         },

data/lib/sidekiq/manager.rb

@@ -69,12 +69,13 @@ module Sidekiq
     def processor_result(processor, reason = nil)
       @plock.synchronize do
         @workers.delete(processor)
-        unless @done
+        if !@done && @count > @workers.size
           p = Processor.new(@config, &method(:processor_result))
           @workers << p
           p.start
         end
       end
+      nil
     end
 
     def stopped?

data/lib/sidekiq/paginator.rb

@@ -23,7 +23,8 @@ module Sidekiq
         elsif key.start_with?("queue:")
           type = TYPE_CACHE[key] = "list"
         else
-          type = TYPE_CACHE[key] = conn.type(key)
+          type = conn.type(key)
+          TYPE_CACHE[key] = type unless type == "none"
         end
         rev = opts && opts[:reverse]
 
@@ -62,7 +63,12 @@ module Sidekiq
       pageidx = current_page - 1
       starting = pageidx * page_size
       items = items.to_a
-      [current_page, items.size, items[starting, page_size]]
+      total_size = items.size
+      if starting > total_size
+        starting = 0
+        current_page = 1
+      end
+      [current_page, total_size, items[starting, page_size]]
     end
   end
 end

data/lib/sidekiq/profiler.rb

@@ -21,7 +21,7 @@ module Sidekiq
       return yield unless job["profile"]
 
       token = job["profile"]
-      type = job["class"]
+      type = job["wrapped"] || job["class"]
       jid = job["jid"]
       started_at = Time.now
 

data/lib/sidekiq/redis_client_adapter.rb

@@ -41,8 +41,8 @@ module Sidekiq
       # this allows us to use methods like `conn.hmset(...)` instead of having to use
       # redis-client's native `conn.call("hmset", ...)`
       def method_missing(*args, &block)
-        warn("[sidekiq#5788] Redis has deprecated the `#{args.first}`command, called at #{caller(1..1)}") if DEPRECATED_COMMANDS.include?(args.first)
-        @client.call(*args, *block)
+        warn("[sidekiq#5788] Redis has deprecated the `#{args.first}` command, called at #{caller(1..1)}") if DEPRECATED_COMMANDS.include?(args.first)
+        @client.call(*args, &block)
       end
       ruby2_keywords :method_missing if respond_to?(:ruby2_keywords, true)
 
@@ -107,6 +107,10 @@ module Sidekiq
       # on by default.
       opts[:reconnect_attempts] ||= 1
 
+      # Identify ourselves to Redis via CLIENT SETINFO so connections
+      # are distinguishable in CLIENT LIST / CLIENT INFO output.
+      opts[:driver_info] ||= "sidekiq_v#{Sidekiq::VERSION}"
+
       opts
     end
   end

data/lib/sidekiq/scheduled.rb

@@ -117,9 +117,7 @@ module Sidekiq
       private
 
       def wait
-        @sleeper.pop(timeout: random_poll_interval)
-      rescue Timeout::Error
-        # TODO move to exception: false
+        @sleeper.pop(timeout: random_poll_interval, exception: false)
       rescue => ex
         # if poll_interval_average hasn't been calculated yet, we can
         # raise an error trying to reach Redis.
@@ -225,8 +223,7 @@ module Sidekiq
         total += INITIAL_WAIT unless @config[:poll_interval_average]
         total += (5 * rand)
 
-        @sleeper.pop(timeout: total)
-      rescue Timeout::Error
+        @sleeper.pop(timeout: total, exception: false)
       ensure
         # periodically clean out the `processes` set in Redis which can collect
         # references to dead processes over time. The process count affects how

data/lib/sidekiq/testing.rb

@@ -1,2 +1,3 @@
+require "sidekiq"
 Sidekiq.testing!(:fake)
 warn('⛔️ `require "sidekiq/testing"` is deprecated and will be removed in Sidekiq 9.0. See https://sidekiq.org/wiki/Testing#new-api')

data/lib/sidekiq/tui/controls.rb

@@ -0,0 +1,53 @@
+module Sidekiq
+  class TUI
+    module Controls
+      # Defines data for input handling and for displaying controls.
+      # :code is the key code for input handling.
+      # :display and :description are shown in the controls area, with different
+      #   styling between them. If :display is omitted, :code is displayed instead.
+      # :action is a lambda to execute when the control is triggered.
+      # :refresh means the action requires immediate refreshing of data
+      #
+      # Conventions: dangerous/irreversible actions should use UPPERCASE codes.
+      # The Shift button means "I'm sure".
+      GLOBAL = [
+        {code: "?", display: "?", description: "Help", action: ->(tui, tab) { tui.show_help }},
+        {code: "left", display: "←/→", description: "Select Tab", action: ->(tui, tab) { tui.navigate(:left) }, refresh: true},
+        {code: "right", action: ->(tui, tab) { tui.navigate(:right) }, refresh: true},
+        {code: "q", description: "Quit", action: ->(tui, tab) { :quit }},
+        {code: "c", modifiers: ["ctrl"], action: ->(tui, tab) { :quit }}
+      ].freeze
+
+      SHARED = {
+        pageable: [
+          {code: "h", display: "h/l", description: "Prev/Next Page",
+           action: ->(tui, tab) { tab.prev_page }, refresh: true},
+          {code: "l", action: ->(tui, tab) { tab.next_page }, refresh: true}
+        ],
+        selectable: [
+          {code: "k", display: "j/k", description: "Prev/Next Row",
+           action: ->(tui, tab) { tab.navigate_row(:up) }},
+          {code: "j", action: ->(tui, tab) { tab.navigate_row(:down) }},
+          {code: "x", description: "Select", action: ->(tui, tab) { tab.toggle_select }},
+          {code: "A", modifiers: ["shift"], display: "A", description: "Select All",
+           action: ->(tui, tab) { tab.toggle_select(:all) }}
+        ],
+        filterable: [
+          {code: "/", display: "/", description: "Filter", action: ->(tui, tab) { tab.start_filtering }},
+          {code: "backspace", action: ->(tui, tab) { tab.remove_last_char_from_filter }, refresh: true},
+          {code: "enter", action: ->(tui, tab) { tab.stop_filtering }, refresh: true},
+          {code: "esc", action: ->(tui, tab) { tab.stop_and_clear_filtering }, refresh: true}
+        ]
+      }.freeze
+
+      # Returns an array of symbols for functionality which this tab implements
+      def features
+        []
+      end
+
+      def controls
+        GLOBAL + SHARED.slice(*features).values.flatten
+      end
+    end
+  end
+end