sidekiq-tasks 0.1.8 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9d5973e69de00ba6c53592cda231856f13bb1c18795d67938121573eb40526c2
-  data.tar.gz: 7f58c1afbff9bc66e1e6c742cc0dc1a74dd7415201977aca021cca445a32fc5c
+  metadata.gz: 8fee03d24fdcc9755f8fadb9915b39127fac89ba1f4447a7d822998b9a64c102
+  data.tar.gz: 8a6c5940eae17706522c7f584c392779a0b2c513848fa49cab8206c2a5af5473
 SHA512:
-  metadata.gz: b1c7bd390583a1456694330def614d4a85b26a23b0c18af9cd4bea9711fe55e13ded4617ecf60a20afd58a53e258c363d2f2c49ffaafd87af3d3662e3b596c8b
-  data.tar.gz: 683d90b2c4fd4e0c648ada7fbd13116c27da624745783ed77f70336c52efe4519acea5daf8425e25df36cc044ab213fd04fa35e0ba2c8098cbb888e2fe0aa534
+  metadata.gz: b85eb95f150f99c0de282d0ac6fb1356a984f0cdc7d5a485baf1a9fdb7963346156a9e4c224d1cd22476002efd34bb8ed18bbf1252d762cbd25c8b41623557b4
+  data.tar.gz: 51ca1179d3232c84139c8ef380290aa5e9bd8f3b97b21e92a54165fcee0376a1a42b207ec9029510f086b35e2ec69aa091685f89d343a3eb38c31296d8600709

data/CHANGELOG.md

@@ -1,5 +1,12 @@
 ## Changelog
 
+### [1.0.0] - 2026-03-13
+
+- Add configurable `storage` option with support for custom backends (default: Redis).
+- Add configurable `current_user` option to track who enqueued each task.
+- Add configurable `history_limit` option (default: 10).
+- Add sortable columns (`name`, `last_enqueued`) in the tasks list.
+
 ### [0.1.8] - 2026-03-06
 
 - Replace deprecated `webdrivers` gem with `selenium-webdriver`.

data/README.md

@@ -227,12 +227,38 @@ end
 
 ## Execution history
 
-Each task keeps a history of its last 10 executions, stored in Redis. The task detail page displays for each execution:
+Each task keeps a history of its last executions (default: 10, stored in Redis). The task detail page displays for each execution:
 
 - The enqueue, start, and finish timestamps
 - The arguments passed
 - The error message if the execution failed
 
+You can configure the history limit:
+
+```ruby
+Sidekiq::Tasks.configure do |config|
+  config.history_limit = 25
+end
+```
+
+You can also use a custom storage backend. See the [Custom Storage Guide](docs/custom_storage.md) for more details.
+
+## Current user
+
+You can configure a `current_user` proc to track who enqueued each task.
+The proc receives the Rack `env` and should return a Hash identifying the user:
+
+```ruby
+Sidekiq::Tasks.configure do |config|
+  config.current_user = ->(env) do
+    user = env["warden"].user(:admin_user)
+    {id: user.id, email: user.email}
+  end
+end
+```
+
+When configured, an "Enqueued by" column appears in the task history table.
+
 ## Development
 
 After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.

data/docs/custom_storage.md

@@ -0,0 +1,95 @@
+# Custom Storage Guide
+
+This guide walks you through implementing a custom storage backend using ActiveRecord in a Rails application.
+
+## Step 1: Generate the model and run the migration
+
+```bash
+rails generate model TaskExecution \
+  task_name:string:index \
+  jid:string:index \
+  args:jsonb \
+  enqueued_at:datetime \
+  executed_at:datetime \
+  finished_at:datetime \
+  error:string \
+  user:jsonb
+
+rails db:migrate
+```
+
+## Step 2: Configure the initializer
+
+In `config/initializers/sidekiq_tasks.rb`:
+
+```ruby
+class ActiveRecordStorage < Sidekiq::Tasks::Storage::Base
+  def last_enqueue_at
+    TaskExecution.where(task_name: task_name).order(enqueued_at: :desc).pick(:enqueued_at)
+  end
+
+  def history
+    TaskExecution
+      .where(task_name: task_name)
+      .order(enqueued_at: :desc)
+      .limit(history_limit)
+      .select(:jid, :task_name, :args, :enqueued_at, :executed_at, :finished_at, :error, :user)
+      .map(&:attributes)
+  end
+
+  def store_enqueue(jid, args, user: nil)
+    TaskExecution.create!(
+      task_name: task_name,
+      jid: jid,
+      args: args,
+      enqueued_at: Time.now,
+      user: user
+    )
+  end
+
+  def store_execution(jid, time_key)
+    TaskExecution.find_by(jid: jid)&.update!(time_key => Time.now)
+  end
+
+  def store_execution_error(jid, error)
+    message = truncate_message("#{error.class}: #{error.message}", ERROR_MESSAGE_MAX_LENGTH)
+    TaskExecution.find_by(jid: jid)&.update!(error: message)
+  end
+end
+
+Sidekiq::Tasks.configure do |config|
+  config.storage = ActiveRecordStorage
+end
+```
+
+> [!NOTE]
+> The `history_limit` config is passed to each storage instance. The default Redis storage uses it to trim old entries. Custom storage implementations receive it via the `history_limit` accessor and can use it as needed (e.g. as a SQL `LIMIT`) or ignore it entirely.
+
+## History entry format
+
+The `history` method must return an array of hashes with the following keys:
+
+| Key             | Type          | Description                          |
+|-----------------|---------------|--------------------------------------|
+| `"jid"`         | String        | The Sidekiq job ID                   |
+| `"task_name"`   | String        | The task name                        |
+| `"args"`        | Hash          | The arguments passed to the task     |
+| `"enqueued_at"` | Time          | When the task was enqueued           |
+| `"executed_at"` | Time \| nil   | When the task started executing      |
+| `"finished_at"` | Time \| nil   | When the task finished executing     |
+| `"error"`       | String \| nil | Error message if execution failed    |
+| `"user"`        | Hash \| nil   | User who enqueued the task           |
+
+## Migrating from Redis
+
+After switching to a custom storage, you can clean up the old Redis history:
+
+```bash
+redis-cli --scan --pattern "task:*" | xargs redis-cli del
+```
+
+Or from a Rails console:
+
+```ruby
+Sidekiq.redis { |conn| conn.keys("task:*").each { |key| conn.del(key) } }
+```

data/lib/sidekiq/tasks/config.rb

@@ -15,14 +15,21 @@ module Sidekiq
         ),
       ].freeze
 
+      DEFAULT_STORAGE = Sidekiq::Tasks::Storage::Redis
+
+      DEFAULT_HISTORY_LIMIT = 10
+
       include Sidekiq::Tasks::Validations
 
-      attr_reader :strategies, :sidekiq_options, :authorization
+      attr_reader :strategies, :sidekiq_options, :authorization, :history_limit, :current_user, :storage
 
       def initialize
         @sidekiq_options = DEFAULT_SIDEKIQ_OPTIONS
         @strategies = DEFAULT_STRATEGIES
+        @storage = DEFAULT_STORAGE
         @authorization = ->(_env) { true }
+        @history_limit = DEFAULT_HISTORY_LIMIT
+        @current_user = nil
       end
 
       # @see https://github.com/sidekiq/sidekiq/wiki/Advanced-Options#jobs
@@ -45,11 +52,31 @@ module Sidekiq
         @strategies = strategies
       end
 
+      def storage=(storage_class)
+        validate_subclass!(storage_class, Sidekiq::Tasks::Storage::Base, "storage")
+
+        @storage = storage_class
+      end
+
+      def history_limit=(limit)
+        validate_class!(limit, [Integer], "history_limit")
+
+        raise Sidekiq::Tasks::ArgumentError, "'history_limit' must be greater than 0" if limit <= 0
+
+        @history_limit = limit
+      end
+
       def authorization=(authorization_proc)
         validate_class!(authorization_proc, [Proc], "authorization")
 
         @authorization = authorization_proc
       end
+
+      def current_user=(current_user_proc)
+        validate_class!(current_user_proc, [Proc], "current_user")
+
+        @current_user = current_user_proc
+      end
     end
   end
 end

data/lib/sidekiq/tasks/storage/base.rb

@@ -0,0 +1,73 @@
+module Sidekiq
+  module Tasks
+    module Storage
+      class Base
+        ERROR_MESSAGE_MAX_LENGTH = 255
+
+        attr_reader :task_name, :history_limit
+
+        def initialize(task_name, history_limit: nil)
+          @task_name = task_name
+          @history_limit = history_limit
+        end
+
+        # Returns the last enqueue time for the task.
+        #
+        # @abstract Subclasses must implement this method.
+        # @return [Time, NilClass] The last enqueue time or nil.
+        # @raise [NotImplementedError] If the method is not implemented in a subclass.
+        def last_enqueue_at
+          raise NotImplementedError, "Storage must implement #last_enqueue_at"
+        end
+
+        # Returns the execution history for the task.
+        #
+        # @abstract Subclasses must implement this method.
+        # @return [Array<Hash>] The execution history entries.
+        # @raise [NotImplementedError] If the method is not implemented in a subclass.
+        def history
+          raise NotImplementedError, "Storage must implement #history"
+        end
+
+        # Stores enqueue information for the task.
+        #
+        # @abstract Subclasses must implement this method.
+        # @param jid [String] The Sidekiq job ID.
+        # @param args [Hash] The arguments passed to the task.
+        # @param user [Hash, NilClass] The user who enqueued the task.
+        # @raise [NotImplementedError] If the method is not implemented in a subclass.
+        def store_enqueue(_jid, _args, user: nil)
+          raise NotImplementedError, "Storage must implement #store_enqueue"
+        end
+
+        # Stores execution time for a specific history entry.
+        #
+        # @abstract Subclasses must implement this method.
+        # @param jid [String] The Sidekiq job ID.
+        # @param time_key [String] The time key to store (e.g. "executed_at", "finished_at").
+        # @raise [NotImplementedError] If the method is not implemented in a subclass.
+        def store_execution(_jid, _time_key)
+          raise NotImplementedError, "Storage must implement #store_execution"
+        end
+
+        # Stores an execution error for a specific history entry.
+        #
+        # @abstract Subclasses must implement this method.
+        # @param jid [String] The Sidekiq job ID.
+        # @param error [Exception] The error that occurred during execution.
+        # @raise [NotImplementedError] If the method is not implemented in a subclass.
+        def store_execution_error(_jid, _error)
+          raise NotImplementedError, "Storage must implement #store_execution_error"
+        end
+
+        protected
+
+        def truncate_message(message, max_length)
+          return message if message.length <= max_length
+
+          "#{message[0...(max_length - 3)]}..."
+        end
+      end
+    end
+  end
+end

data/lib/sidekiq/tasks/storage/redis.rb

@@ -0,0 +1,89 @@
+module Sidekiq
+  module Tasks
+    module Storage
+      class Redis < Base
+        JID_PREFIX = "task".freeze
+        def jid_key
+          "#{JID_PREFIX}:#{task_name}"
+        end
+
+        def history_key
+          "#{jid_key}:history"
+        end
+
+        def last_enqueue_at
+          stored_time("last_enqueue_at")
+        end
+
+        def history
+          raw_entries = Sidekiq.redis { |conn| conn.lrange(history_key, 0, -1) }
+
+          return [] unless raw_entries
+
+          raw_entries.map do |raw|
+            entry = Sidekiq.load_json(raw)
+            ["enqueued_at", "executed_at", "finished_at"].each do |key|
+              entry[key] = Time.at(entry[key]) if entry[key]
+            end
+            entry
+          end
+        end
+
+        def store_history(jid, task_args, time, user: nil)
+          Sidekiq.redis do |conn|
+            task_trace = {jid: jid, task_name: task_name, args: task_args, enqueued_at: time.to_f}
+            task_trace[:user] = user if user
+            conn.lpush(history_key, Sidekiq.dump_json(task_trace))
+            conn.ltrim(history_key, 0, history_limit - 1)
+          end
+        end
+
+        def store_enqueue(jid, args, user: nil)
+          time = Time.now.to_f
+          store_time(time, "last_enqueue_at")
+          store_history(jid, args, time, user: user)
+        end
+
+        def store_execution(jid, time_key)
+          update_history_entry(jid) do |entry|
+            entry.merge(time_key => Time.now.to_f)
+          end
+        end
+
+        def store_execution_error(jid, error)
+          update_history_entry(jid) do |entry|
+            error_message = truncate_message("#{error.class}: #{error.message}", ERROR_MESSAGE_MAX_LENGTH)
+            entry.merge("error" => error_message)
+          end
+        end
+
+        private
+
+        def store_time(time, time_key)
+          Sidekiq.redis { |conn| conn.hset(jid_key, time_key, time.to_f) }
+        end
+
+        def stored_time(time_key)
+          timestamp = Sidekiq.redis { |conn| conn.hget(jid_key, time_key) }
+
+          [nil, ""].include?(timestamp) ? nil : Time.at(timestamp.to_f)
+        end
+
+        def update_history_entry(jid)
+          Sidekiq.redis do |conn|
+            entries = conn.lrange(history_key, 0, -1)
+
+            entries.each_with_index do |raw, index|
+              entry = Sidekiq.load_json(raw)
+              next unless entry["jid"] == jid
+
+              updated_entry = yield(entry)
+              conn.lset(history_key, index, Sidekiq.dump_json(updated_entry))
+              break
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/sidekiq/tasks/storage.rb

@@ -1,101 +1,8 @@
 module Sidekiq
   module Tasks
-    class Storage
-      JID_PREFIX = "task".freeze
-      HISTORY_LIMIT = 10
-      ERROR_MESSAGE_MAX_LENGTH = 255
-
-      attr_reader :task_name
-
-      def initialize(task_name)
-        @task_name = task_name
-      end
-
-      def jid_key
-        "#{JID_PREFIX}:#{task_name}"
-      end
-
-      def history_key
-        "#{jid_key}:history"
-      end
-
-      def last_enqueue_at
-        stored_time("last_enqueue_at")
-      end
-
-      def history
-        raw_entries = Sidekiq.redis { |conn| conn.lrange(history_key, 0, -1) }
-
-        return [] unless raw_entries
-
-        raw_entries.map do |raw|
-          entry = Sidekiq.load_json(raw)
-          %w[enqueued_at executed_at finished_at].each do |key|
-            entry[key] = Time.at(entry[key]) if entry[key]
-          end
-          entry
-        end
-      end
-
-      def store_history(jid, task_args, time)
-        Sidekiq.redis do |conn|
-          task_trace = {jid: jid, name: task_name, args: task_args, enqueued_at: time.to_f}
-          conn.lpush(history_key, Sidekiq.dump_json(task_trace))
-          conn.ltrim(history_key, 0, HISTORY_LIMIT - 1)
-        end
-      end
-
-      def store_enqueue(jid, args)
-        time = Time.now.to_f
-        store_time(time, "last_enqueue_at")
-        store_history(jid, args, time)
-      end
-
-      def store_execution(jid, time_key)
-        update_history_entry(jid) do |entry|
-          entry.merge(time_key => Time.now.to_f)
-        end
-      end
-
-      def store_execution_error(jid, error)
-        update_history_entry(jid) do |entry|
-          error_message = truncate_message("#{error.class}: #{error.message}", ERROR_MESSAGE_MAX_LENGTH)
-          entry.merge("error" => error_message)
-        end
-      end
-
-      private
-
-      def truncate_message(message, max_length)
-        return message if message.length <= max_length
-
-        "#{message[0...(max_length - 3)]}..."
-      end
-
-      def store_time(time, time_key)
-        Sidekiq.redis { |conn| conn.hset(jid_key, time_key, time.to_f) }
-      end
-
-      def stored_time(time_key)
-        timestamp = Sidekiq.redis { |conn| conn.hget(jid_key, time_key) }
-
-        [nil, ""].include?(timestamp) ? nil : Time.at(timestamp.to_f)
-      end
-
-      def update_history_entry(jid)
-        Sidekiq.redis do |conn|
-          entries = conn.lrange(history_key, 0, -1)
-
-          entries.each_with_index do |raw, index|
-            entry = Sidekiq.load_json(raw)
-            next unless entry["jid"] == jid
-
-            updated_entry = yield(entry)
-            conn.lset(history_key, index, Sidekiq.dump_json(updated_entry))
-            break
-          end
-        end
-      end
+    module Storage
+      autoload :Base, "sidekiq/tasks/storage/base"
+      autoload :Redis, "sidekiq/tasks/storage/redis"
     end
   end
 end

data/lib/sidekiq/tasks/task.rb

@@ -22,10 +22,10 @@ module Sidekiq
         validate_class!(strategy, [Sidekiq::Tasks::Strategies::Base], "strategy")
       end
 
-      def enqueue(params = {})
+      def enqueue(params = {}, user: nil)
         jid = strategy.enqueue_task(name, params)
 
-        storage.store_enqueue(jid, params)
+        storage.store_enqueue(jid, params, user: user)
       end
 
       def execute(params = {}, jid: nil)
@@ -33,7 +33,7 @@ module Sidekiq
 
         begin
           strategy.execute_task(name, params)
-        rescue => e
+        rescue StandardError, SystemExit => e
           storage.store_execution(jid, "finished_at")
           storage.store_execution_error(jid, e)
           raise
@@ -43,7 +43,7 @@ module Sidekiq
       end
 
       def storage
-        @_storage ||= Sidekiq::Tasks::Storage.new(name)
+        @_storage ||= Sidekiq::Tasks.config.storage.new(name, history_limit: Sidekiq::Tasks.config.history_limit)
       end
     end
   end

data/lib/sidekiq/tasks/validations.rb

@@ -32,6 +32,14 @@ module Sidekiq
               "'#{name}' must be one of #{expected_values.map(&:inspect).join(" or ")} but received #{value.inspect}"
       end
       module_function :validate_expected_values!
+
+      def validate_subclass!(klass, base_class, name = nil)
+        return if klass.is_a?(Class) && klass <= base_class
+
+        raise Sidekiq::Tasks::ArgumentError,
+              "'#{name}' must be a class inheriting from #{base_class.name} but received #{klass.inspect}"
+      end
+      module_function :validate_subclass!
     end
   end
 end

data/lib/sidekiq/tasks/version.rb

@@ -2,6 +2,6 @@
 
 module Sidekiq
   module Tasks
-    VERSION = "0.1.8"
+    VERSION = "1.0.0"
   end
 end

data/lib/sidekiq/tasks/web/extension.rb

@@ -2,6 +2,7 @@ require "sidekiq/tasks/web/helpers/application_helper"
 require "sidekiq/tasks/web/helpers/tag_helper"
 require "sidekiq/tasks/web/helpers/task_helper"
 require "sidekiq/tasks/web/helpers/pagination_helper"
+require "sidekiq/tasks/web/helpers/sort_helper"
 require "sidekiq/tasks/web/search"
 require "sidekiq/tasks/web/pagination"
 require "sidekiq/tasks/web/params"
@@ -15,11 +16,12 @@ module Sidekiq
           app.helpers(Sidekiq::Tasks::Web::Helpers::TagHelper)
           app.helpers(Sidekiq::Tasks::Web::Helpers::TaskHelper)
           app.helpers(Sidekiq::Tasks::Web::Helpers::PaginationHelper)
+          app.helpers(Sidekiq::Tasks::Web::Helpers::SortHelper)
 
           app.get "/tasks" do
             authorize!
 
-            @search = Sidekiq::Tasks::Web::Search.new(fetch_params(:count, :page, :filter))
+            @search = Sidekiq::Tasks::Web::Search.new(fetch_params(:count, :page, :filter, :sort, :direction))
 
             erb(read_view(:tasks), locals: {search: @search})
           end
@@ -29,7 +31,22 @@ module Sidekiq
 
             @task = find_task!(env["rack.route_params"][:name])
 
-            erb(read_view(:task), locals: {task: @task})
+            history = @task.history
+            per_page = 10
+            page = [fetch_param("page").to_i, 1].max
+            total_pages = [(history.size.to_f / per_page).ceil, 1].max
+            history_entries = history.slice((page - 1) * per_page, per_page) || []
+
+            erb(
+              read_view(:task),
+              locals: {
+                task: @task,
+                history_entries: history_entries,
+                history_page: page,
+                history_total_pages: total_pages,
+                history_total_count: history.size,
+              }
+            )
           rescue Sidekiq::Tasks::NotFoundError
             throw :halt, [404, {Rack::CONTENT_TYPE => "text/plain"}, ["Task not found"]]
           end
@@ -44,7 +61,8 @@ module Sidekiq
             task = find_task!(env["rack.route_params"][:name])
             args = Sidekiq::Tasks::Web::Params.new(task, fetch_param("args")).permit!
 
-            task.enqueue(args)
+            current_user = Sidekiq::Tasks.config.current_user&.call(env)
+            task.enqueue(args, user: current_user)
 
             redirect(task_url(root_path, task))
           rescue Sidekiq::Tasks::ArgumentError => e

data/lib/sidekiq/tasks/web/helpers/pagination_helper.rb

@@ -6,22 +6,29 @@ module Sidekiq
           extend self
           include Sidekiq::Tasks::Web::Helpers::TagHelper
 
-          def pagination_link(root_path, link, search)
+          def pagination_base_url(search, root_path)
+            query_params = {
+              filter: search.filter.to_s,
+              count: search.count,
+              sort: search.sort,
+              direction: search.direction,
+            }
+
+            "#{root_path}tasks?#{URI.encode_www_form(query_params)}"
+          end
+
+          def build_pagination_link(link, base_url)
+            separator = base_url.include?("?") ? "&" : "?"
+
             build_tag(:li, class: "st-page-item") do
               build_tag(
                 :a,
                 link[:text],
                 class: build_classes("st-page-link", disabled: link[:disabled], active: link[:active]),
-                href: pagination_url(root_path, search, link[:page])
+                href: "#{base_url}#{separator}page=#{link[:page]}"
               )
             end
           end
-
-          private
-
-          def pagination_url(root_path, search, page)
-            "#{root_path}tasks?filter=#{ERB::Util.url_encode(search.filter)}&count=#{search.count}&page=#{page}"
-          end
         end
       end
     end

data/lib/sidekiq/tasks/web/helpers/sort_helper.rb

@@ -0,0 +1,26 @@
+module Sidekiq
+  module Tasks
+    module Web
+      module Helpers
+        module SortHelper
+          extend self
+
+          def sort_header_url(search, root_path, column)
+            next_direction = search.toggle_direction(column)
+
+            query_params = {filter: search.filter.to_s, count: search.count}
+            query_params.merge!(sort: column, direction: next_direction) if next_direction
+
+            "#{root_path}tasks?#{URI.encode_www_form(query_params)}"
+          end
+
+          def sort_header_classes(search, column)
+            css = "st-sortable"
+            css += " st-sorted-#{search.direction}" if search.sorted_by?(column)
+            css
+          end
+        end
+      end
+    end
+  end
+end

data/lib/sidekiq/tasks/web/search.rb

@@ -3,6 +3,8 @@ module Sidekiq
     module Web
       class Search
         DEFAULT_COUNT = 15
+        SORT_COLUMNS = ["name", "last_enqueued"].freeze
+        SORT_DIRECTIONS = ["asc", "desc"].freeze
 
         def self.count_options
           (0..3).map { |index| DEFAULT_COUNT * (2**index) }
@@ -15,7 +17,7 @@ module Sidekiq
         end
 
         def tasks
-          @_tasks ||= filtered_collection.sort_by(&:file).slice(offset, count) || []
+          @_tasks ||= sorted_collection.slice(offset, count) || []
         end
 
         def filtered_collection
@@ -40,6 +42,25 @@ module Sidekiq
           requested_page.positive? ? requested_page : 1
         end
 
+        def sort
+          SORT_COLUMNS.include?(params[:sort]) ? params[:sort] : SORT_COLUMNS.first
+        end
+
+        def direction
+          SORT_DIRECTIONS.include?(params[:direction]) ? params[:direction] : SORT_DIRECTIONS.first
+        end
+
+        def toggle_direction(column)
+          return "asc" unless sort == column
+          return "desc" if direction == "asc"
+
+          nil
+        end
+
+        def sorted_by?(column)
+          sort == column
+        end
+
         def total_pages
           (filtered_collection.size.to_f / count).ceil
         end
@@ -47,6 +68,28 @@ module Sidekiq
         def offset
           (page - 1) * count
         end
+
+        private
+
+        def sorted_collection
+          sorted = filtered_collection.sort_by { |task| sort_value(task) }
+          direction == "desc" ? sorted.reverse : sorted
+        end
+
+        def sort_value(task)
+          case sort
+          when "name"
+            task.name.to_s.downcase
+          when "last_enqueued"
+            sort_value_for_time(task.last_enqueue_at)
+          end
+        end
+
+        def sort_value_for_time(time)
+          return time.to_f if time
+
+          direction == "asc" ? Float::INFINITY : -Float::INFINITY
+        end
       end
     end
   end

data/lib/sidekiq/tasks.rb

@@ -3,6 +3,7 @@
 require "rake"
 
 require_relative "tasks/errors"
+require_relative "tasks/storage"
 require_relative "tasks/strategies"
 require_relative "tasks/validations"
 require_relative "tasks/version"
@@ -12,7 +13,6 @@ module Sidekiq
     autoload :Config, "sidekiq/tasks/config"
     autoload :Job, "sidekiq/tasks/job"
     autoload :Set, "sidekiq/tasks/set"
-    autoload :Storage, "sidekiq/tasks/storage"
     autoload :Task, "sidekiq/tasks/task"
     autoload :TaskMetadata, "sidekiq/tasks/task_metadata"
 

data/web/assets/tasks/css/components/tables.css

@@ -22,6 +22,7 @@
 
 .st-table-container {
   overflow: auto;
+  max-width: 100%;
 }
 
 .st-table {
@@ -64,9 +65,42 @@
   border-radius: 2px;
   padding: 0.2em 0.4em;
   border-radius: 0.2em;
+  display: block;
+  max-width: 200px;
+  overflow: auto;
 }
 
 .st-table .st-desc-cell {
   white-space: pre-wrap;
   word-wrap: break-word;
 }
+
+.st-sortable {
+  color: inherit;
+  text-decoration: none;
+  cursor: pointer;
+}
+
+.st-sortable:hover {
+  text-decoration: underline;
+}
+
+.st-sorted-asc::after,
+.st-sorted-desc::after {
+  content: "";
+  display: inline-block;
+  margin-left: 5px;
+  width: 0;
+  height: 0;
+  vertical-align: middle;
+  border-left: 4px solid transparent;
+  border-right: 4px solid transparent;
+}
+
+.st-sorted-asc::after {
+  border-bottom: 4px solid currentColor;
+}
+
+.st-sorted-desc::after {
+  border-top: 4px solid currentColor;
+}

data/web/locales/en.yml

@@ -25,4 +25,5 @@ en:
   running: "Running"
   success: "Success"
   failure: "Failure"
+  enqueued_by: "Enqueued by"
   task_time: "%m/%d/%y %H:%M:%S"

data/web/locales/fr.yml

@@ -25,4 +25,5 @@ fr:
   running: "En cours"
   success: "Succès"
   failure: "Echec"
+  enqueued_by: "Lancée par"
   task_time: "%d/%m/%y %H:%M:%S"

data/web/views/_pagination.erb

@@ -1,14 +1,14 @@
-<% if search.total_pages > 1 %>
+<% if total_pages > 1 %>
   <div class="st-pagination-wrapper">
     <div>
       <small class="st-text-primary">
-        <%= search.tasks.size %> / <%= Sidekiq::Tasks.tasks.size %>
+        <%= displayed_count %> / <%= total_count %>
       </small>
     </div>
 
     <ul class="st-pagination">
-      <% Sidekiq::Tasks::Web::Pagination.new(search.page, search.total_pages).links.each do |link| %>
-        <%= pagination_link(root_path, link, search) %>
+      <% Sidekiq::Tasks::Web::Pagination.new(page, total_pages).links.each do |link| %>
+        <%= build_pagination_link(link, base_url) %>
       <% end %>
     </ul>
   </div>

data/web/views/task.erb

@@ -6,7 +6,7 @@
   <% end %>
 <% else %>
   <% add_to_head do %>
-    <link href="<%= root_path %>tasks/css/ext.css" media="screen" rel="stylesheet" type="text/css"/>
+    <link href="<%= root_path %>tasks/css/ext.css" media="screen" rel="stylesheet" type="text/css">
   <% end %>
 <% end %>
 
@@ -42,7 +42,7 @@
 </header>
 
 <div class="st-table-container">
-  <% if task.history.empty? %>
+  <% if history_entries.empty? %>
     <p><%= t("no_history") %></p>
   <% else %>
     <table class="st-table">
@@ -50,6 +50,9 @@
       <tr>
         <th><%= t("jid") %></th>
         <th><%= t("args") %></th>
+        <% if Sidekiq::Tasks.config.current_user %>
+          <th><%= t("enqueued_by") %></th>
+        <% end %>
         <th><%= t("enqueued") %></th>
         <th><%= t("executed") %></th>
         <th><%= t("duration") %></th>
@@ -57,12 +60,17 @@
       </tr>
       </thead>
       <tbody>
-        <% task.history.each do |jid_history| %>
+        <% history_entries.each do |jid_history| %>
           <tr>
             <td><%= jid_history["jid"] %></td>
             <td>
               <code><%= jid_history["args"] %></code>
             </td>
+            <% if Sidekiq::Tasks.config.current_user %>
+              <td>
+                <code><%= jid_history["user"] || "-" %></code>
+              </td>
+            <% end %>
             <td>
               <%= jid_history["enqueued_at"] ? jid_history["enqueued_at"].strftime(t("task_time")) : "-" %>
             </td>
@@ -77,13 +85,24 @@
                 :span,
                 t(task_status(jid_history).to_s).capitalize,
                 class: "st-status-badge #{task_status(jid_history)}",
-                "data-tooltip": jid_history["error"],
+                "data-tooltip": jid_history["error"]
               ) %>
             </td>
           </tr>
         <% end %>
       </tbody>
     </table>
+
+    <%= erb(
+      read_view(:_pagination),
+      locals: {
+        displayed_count: history_entries.size,
+        total_count: history_total_count,
+        page: history_page,
+        total_pages: history_total_pages,
+        base_url: task_url(root_path, task),
+      }
+    ) %>
   <% end %>
 </div>
 
@@ -100,7 +119,7 @@
     <% task.args.each do |arg| %>
       <div class="st-form-group">
         <label for="<%= arg %>" class="st-label"><%= arg %></label>
-        <input type="text" id="<%= arg %>" class="st-input" name="args[<%= arg %>]"/>
+        <input type="text" id="<%= arg %>" class="st-input" name="args[<%= arg %>]" autocomplete="off">
       </div>
     <% end %>
   </div>
@@ -109,7 +128,15 @@
     <label for="envConfirmationInput" class="st-label">
       <%= t("env_confirmation", current_env: current_env) %>
     </label>
-    <input type="text" id="envConfirmationInput" class="st-input" name="env_confirmation" data-current-env="<%= current_env %>" required/>
+    <input
+      type="text"
+      id="envConfirmationInput"
+      class="st-input"
+      name="env_confirmation"
+      data-current-env="<%= current_env %>"
+      autocomplete="off"
+      required
+    >
   </div>
 
   <button type="submit" class="st-button" id="submitBtn" disabled>

data/web/views/tasks.erb

@@ -6,18 +6,22 @@
   <% end %>
 <% else %>
   <% add_to_head do %>
-    <link href="<%= root_path %>tasks/css/ext.css" media="screen" rel="stylesheet" type="text/css"/>
+    <link href="<%= root_path %>tasks/css/ext.css" media="screen" rel="stylesheet" type="text/css">
   <% end %>
 <% end %>
 
 <header class="st-header">
   <form action="<%= root_path %>tasks" method="get" class="st-search-form">
+    <input type="hidden" name="sort" value="<%= @search.sort %>">
+    <input type="hidden" name="direction" value="<%= @search.direction %>">
+
     <input
       name="filter"
       class="st-input"
       type="text"
       value="<%= Rack::Utils.escape_html(@search.filter.to_s) %>"
       placeholder="<%= t("search") %>"
+      autocomplete="off"
     >
 
     <select name="count" class="st-select">
@@ -41,9 +45,23 @@
     <table class="st-table">
       <thead>
         <tr>
-          <th><%= t("name") %></th>
+          <th>
+            <a
+              href="<%= sort_header_url(@search, root_path, "name") %>"
+              class="<%= sort_header_classes(@search, "name") %>"
+            >
+              <%= t("name") %>
+            </a>
+          </th>
           <th><%= t("description") %></th>
-          <th><%= t("last_enqueued") %></th>
+          <th>
+            <a
+              href="<%= sort_header_url(@search, root_path, "last_enqueued") %>"
+              class="<%= sort_header_classes(@search, "last_enqueued") %>"
+            >
+              <%= t("last_enqueued") %>
+            </a>
+          </th>
         </tr>
       </thead>
       <tbody>
@@ -62,6 +80,15 @@
       </tbody>
     </table>
 
-    <%= erb(read_view(:_pagination), locals: {search: @search}) %>
+    <%= erb(
+      read_view(:_pagination),
+      locals: {
+        displayed_count: @search.tasks.size,
+        total_count: Sidekiq::Tasks.tasks.size,
+        page: @search.page,
+        total_pages: @search.total_pages,
+        base_url: pagination_base_url(@search, root_path),
+      }
+    ) %>
   <% end %>
 </div>

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: sidekiq-tasks
 version: !ruby/object:Gem::Version
-  version: 0.1.8
+  version: 1.0.0
 platform: ruby
 authors:
 - Victor
@@ -236,6 +236,7 @@ files:
 - LICENSE.txt
 - README.md
 - Rakefile
+- docs/custom_storage.md
 - docs/task.png
 - lib/sidekiq-tasks.rb
 - lib/sidekiq/tasks.rb
@@ -244,6 +245,8 @@ files:
 - lib/sidekiq/tasks/job.rb
 - lib/sidekiq/tasks/set.rb
 - lib/sidekiq/tasks/storage.rb
+- lib/sidekiq/tasks/storage/base.rb
+- lib/sidekiq/tasks/storage/redis.rb
 - lib/sidekiq/tasks/strategies.rb
 - lib/sidekiq/tasks/strategies/base.rb
 - lib/sidekiq/tasks/strategies/rake_task.rb
@@ -260,6 +263,7 @@ files:
 - lib/sidekiq/tasks/web/extension.rb
 - lib/sidekiq/tasks/web/helpers/application_helper.rb
 - lib/sidekiq/tasks/web/helpers/pagination_helper.rb
+- lib/sidekiq/tasks/web/helpers/sort_helper.rb
 - lib/sidekiq/tasks/web/helpers/tag_helper.rb
 - lib/sidekiq/tasks/web/helpers/task_helper.rb
 - lib/sidekiq/tasks/web/pagination.rb