sidekiq-trackable_batch 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 481de84af018a7ec43c03b21926afe9d6137a4f6
+  data.tar.gz: e66a84c45a80d3967ba501bdd13473de1e5acaf4
+SHA512:
+  metadata.gz: 5b0bdb501e87521a24dc509826c75ac5b7bc325398eabae7f5e672e5d0538356141608ab03627343bac66039569018a0afc8169c46e9722594eb45192c10dd6b
+  data.tar.gz: cb023a9f50ec07250c7d9e4f4ea20dc210592fa9ed8a6d09e40a5cbe6ab7f59d5462afe49993bff56deccc5a1ec852d234742b5dcfd2b799386e1ecdd57846d1

data/CHANGELOG.md

@@ -0,0 +1,3 @@
+## 0.1.0
+
+- Initial release!

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2017 darrhiggs
+
+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,126 @@
+# Sidekiq::TrackableBatch
+
+`Sidekiq::TrackableBatch` is an extension to `Sidekiq::Batch` that provides access to detailed, up-to-date progress information about a `Sidekiq::Batch` as it runs.
+
+## Installation
+
+Add the following to your application's Gemfile:
+
+```ruby
+gem 'sidekiq-trackable_batch'
+#	and either
+gem 'sidekiq-pro'
+#	or
+gem 'sidekiq-batch' # currently unsupported
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install sidekiq-trackable_batch
+
+## Usage
+
+Add a `.max` to existing workers:
+```ruby
+class MyWorker
+  def self.max; 42; end # some (total) amount of work
+end
+```
+
+Update the class' `#perform` method to use `#update_status`:
+```ruby
+def perform(*args)
+  # do some work
+  update_status(value: 21) # made available through Sidekiq::Worker
+  # maybe do some more work
+  update_status(value: self.class.max, status_text: 'Done')
+end
+```
+
+Create a batch using `Sidekiq::TrackableBatch`:
+```ruby
+trackable_batch = Sidekiq::TrackableBatch.new
+#  set callbacks & description etc as required
+trackable_batch.jobs
+  5.times { MyWorker.perform_async }
+end
+```
+
+Track your batch:
+```ruby
+Sidekiq::TrackableBatch::Tracking(trackable_batch).to_h
+# => { max: 210, value: 105 }
+```
+
+All `Sidekiq::Batch` features should continue to work as before:
+```ruby
+Sidekiq::Batch::Status.new(trackable_batch.bid)
+trackable_batch.invalidate_all
+# …
+```
+
+### Really Complex Workflows with Batches
+
+`Sidekiq::TrackableBatch` is constrained by all jobs having to be exposed to the batch during initialization. To fulfil this constraint, an updated DSL has been provided to allow nested batch creation that requires ordered execution:
+```ruby
+trackable_batch = Sidekiq::TrackableBatch.new do # Pass a block
+  # The :update callback has the same API as existing
+  # Sidekiq::Batch callbacks 
+  on(:update, OrderStatusNotifier, order_id: order.id)
+  
+  # updates can be pushed to another queue other than the default
+  self.update_queue = 'priority'
+
+  # The DSL consists of three (aliased) chainable methods:
+  # #start_with, #then and #finally. As with a callback, a target
+  # can be passed (#on_update is called by default). 
+  # A block can be passed for inline declaration.
+  start_with('pick', 'Fulfilment#pick', products: order.products)
+  .then('pack', 'Fulfilment#pack', boxes: order.boxes)
+  .finally('ship', 'Fulfilment#ship', boxes: order.boxes)
+  # The first argument will be set as the batch's description.
+  
+  # Optionally set an initial state
+  initial_status(status_text: 'Order sent for picking')
+  
+   # Sidekiq::Batch methods are also available 
+   on(:complete, 'Fulfilment#fulfilment_complete', order_id: order.id)
+end
+```
+All commands, their arguments and return values are documented, and available on [rdoc.info][docs] 
+
+## DEMO
+
+Check out the [demo app][da] ([source][dar]) to see how the [Really Complex Workflows with Batches][rcwwb] example would be created in a Rails 5 app using `Sidekiq::TrackableBatch`. The app specifically demonstrates how batch updates can be consumed through the use of the new `:update` callback, and uses ActionCable to asynchronously stream these updates to a client.
+
+## Caveats
+- ActiveJob is unsupported. [(wiki)][saj#c]
+- #update_status only accepts strings to be set for anything except the value.
+
+## TODOS
+- Integrate with sidekiq UI.
+- Provide mountable rack middleware à la Sidekiq Pro.
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `bundle exec appraisal rake` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/sidekiq-trackable_batch.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).
+
+[da]: https://sidekiq-trackable-batch-demo.herokuapp.com/
+[dar]: https://github.com/darrhiggs/sidekiq_trackable_batch_demo_app
+[docs]: TODO
+[rcwwb]: https://github.com/mperham/sidekiq/wiki/Really-Complex-Workflows-with-Batches
+[saj#c]: https://github.com/mperham/sidekiq/wiki/Active-Job#commercial-features

data/lib/sidekiq/overrides/client.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+require 'sidekiq/client'
+
+module Sidekiq
+  # @api private
+  class Client
+    alias _raw_push raw_push
+
+    def raw_push(payload)
+      if Thread.current[:tbatch]
+        Thread.current[:tbatch].job_list << payload.pop
+        true
+      else
+        _raw_push(payload)
+      end
+    end
+  end
+end

data/lib/sidekiq/overrides/worker.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+require 'sidekiq/trackable_batch/persistance'
+
+module Sidekiq
+  # Provides access to #update_status in classes that include Sidekiq::Worker
+  module Worker
+    include Sidekiq::TrackableBatch::Persistance
+    # @private
+    alias _update_status update_status
+
+    # @example Update a batch's status
+    #   class MyWorker
+    #     include Sidekiq::Worker
+    #     def max; 100; end
+    #     def perform(*)
+    #       update_status(value: 100, more: 'info')
+    #     end
+    #   end
+    #
+    # @param [Hash] updates The changes to be persisted to the
+    #   {TrackableBatch}'s current status
+    # @option updates [Numeric] :value Amount to increment the
+    #   current value by.
+    # @option updates [String] * Any other key and value updates. (optional)
+    def update_status(**updates)
+      _update_status(batch, **updates)
+    end
+  end
+end

data/lib/sidekiq/trackable_batch/initializer.rb

@@ -0,0 +1,2 @@
+# frozen_string_literal: true
+Sidekiq::TrackableBatch::Scripting.load_script

data/lib/sidekiq/trackable_batch/messages.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+# @private
+class Messages
+  def initialize
+    @messages = []
+  end
+
+  def <<(msg)
+    @messages << msg
+  end
+
+  def max_sum
+    @messages.reduce(0) { |memo, msg| memo + msg['max'] }
+  end
+
+  def empty?
+    @messages.empty?
+  end
+
+  def to_json
+    @messages.map(&:to_json)
+  end
+
+  def clear
+    @messages.clear
+  end
+end

data/lib/sidekiq/trackable_batch/middleware.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+module Sidekiq
+  class TrackableBatch < Batch
+    module Middleware
+      # @api private
+      class Client
+        def call(worker_class, msg, _queue, _redis_pool)
+          trackable_batch = Thread.current[:tbatch]
+          if trackable_batch
+            msg['max'] = Object.const_get(worker_class).max
+            out = yield
+            trackable_batch.register_job(out) if out
+            return out
+          end
+          yield
+        end
+      end
+    end
+  end
+end
+
+Sidekiq.configure_client do |config|
+  config.client_middleware do |chain|
+    chain.add Sidekiq::TrackableBatch::Middleware::Client
+  end
+end

data/lib/sidekiq/trackable_batch/persistance.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+require 'sidekiq/trackable_batch/scripting'
+
+module Sidekiq
+  class TrackableBatch < Sidekiq::Batch
+    # @api private
+    # Interface for Redis persistance
+    module Persistance
+      include Scripting
+
+      private
+
+      def get_status(bid)
+        connection { |c| c.hgetall keys(bid)[:status] }
+      end
+
+      def get_jobs(bid)
+        connection { |c| c.smembers keys(bid)[:jobs] }
+      end
+
+      def persist_batch(batch)
+        status = get_status(batch.bid)
+        new_max = batch.messages.max_sum + status['max'].to_i
+
+        connection do |c|
+          keys = keys(batch.bid)
+          c.multi do
+            c.hset keys[:status], :max, new_max
+            c.expire keys[:status], TTL
+
+            unless batch.messages.empty?
+              c.sadd keys[:jobs], batch.messages.to_json
+              c.expire keys[:jobs], TTL
+            end
+
+            if batch.update_listeners
+              c.set keys[:update_listeners], batch.update_listeners.to_json
+              c.expire keys[:update_listeners], TTL
+              if batch.update_queue
+                c.set keys[:update_queue], batch.update_queue
+                c.expire keys[:update_queue], TTL
+              end
+            end
+
+            c.hgetall keys[:status]
+          end
+        end
+      end
+
+      # Updates the status of a {TrackableBatch} with provided updates.
+      # - If the key `value` is provided the value will be incremented by that amount.
+      # - All other keys will create or replace a string value equal to the key's value.
+      # Also enqueues any update callbacks that have been registered.
+      def update_status(batch, updates = {})
+        parent_bid = batch.parent_bid
+        keys = if parent_bid
+                 [
+                   keys(parent_bid)[:status],
+                   keys(batch.bid)[:status],
+                   keys(parent_bid)[:update_listeners],
+                   keys(parent_bid)[:update_queue]
+                 ]
+               else
+                 [
+                   nil,
+                   keys(batch.bid)[:status],
+                   keys(batch.bid)[:update_listeners],
+                   keys(batch.bid)[:update_queue]
+                 ]
+               end
+
+        update_queue, update_listeners = Sidekiq.load_json(
+          connection do |c|
+            c.evalsha(
+              @@sha,
+              keys: keys,
+              argv: [updates.delete(:value), Sidekiq.dump_json(updates), TTL]
+            )
+          end
+        )
+
+        return unless update_listeners
+
+        Thread.new do # clean thread
+          Sidekiq::Client.push_bulk(
+            'queue' => update_queue,
+            'class' => Sidekiq::TrackableBatch::UpdateNotifier,
+            'args' => update_listeners.map do |update_listener|
+              target, args = update_listener.first
+              [parent_bid || batch.bid, target, args]
+            end
+          )
+        end.join
+      end
+
+      def keys(bid)
+        {
+          jobs: "TB:#{bid}:JOBS",
+          status: "TB:#{bid}:STATUS",
+          update_listeners: "TB:#{bid}:UPDATE_LISTENERS",
+          update_queue: "TB:#{bid}:UPDATE_QUEUE"
+        }
+      end
+
+      def connection
+        Sidekiq.redis do |connection|
+          yield connection
+        end
+      end
+    end
+  end
+end

data/lib/sidekiq/trackable_batch/scripting.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+module Sidekiq
+  class TrackableBatch < Sidekiq::Batch
+    # @api private
+    module Scripting
+      SCRIPT = <<-LUA
+        local function hgetall(key)
+          local out = redis.call('HGETALL', key)
+          local result = {}
+          for i = 1, #out, 2 do
+            result[out[i]] = out[i + 1]
+          end
+          return result
+        end
+
+        local function merge_flat_dicts(base, updates)
+          local ret = {}
+          for k,v in pairs(base) do ret[k] = v end
+          for k,v in pairs(updates) do ret[k] = v end
+          return ret
+        end
+
+        local function dict_to_array(dict)
+          local ret = {}
+          for k,v in pairs(dict) do
+            table.insert(ret, k)
+            table.insert(ret, tostring(v))
+          end
+          return ret
+        end
+
+        local function update_batch_status(key, next_value, other_updates, ttl)
+          local other_updates = cjson.decode(other_updates)
+          local status = hgetall(key)
+          if tonumber(next_value) ~= nil then
+            redis.pcall('HSET', key, 'value', tonumber(status['value'] or 0) + tonumber(next_value))
+          end
+          if next(other_updates) ~= nil then
+            local status = hgetall(key)
+            redis.pcall('HMSET', key, unpack(dict_to_array(merge_flat_dicts(status, other_updates))))
+          end
+          redis.pcall('EXPIRE', key, ttl)
+        end
+
+        local parent_key, batch_key, update_listeners_key, update_queue_key = unpack(KEYS);
+        local next_value, other_updates, ttl = unpack(ARGV);
+
+        local ret = {}
+
+        update_batch_status(batch_key, next_value, other_updates, ttl)
+        if parent_key then update_batch_status(parent_key, next_value, other_updates, ttl) end
+
+        ret[1] = redis.pcall('GET', update_queue_key)
+
+        local update_listeners = redis.pcall('GET', update_listeners_key)
+        if update_listeners then
+          ret[2] = cjson.decode(update_listeners)
+        end
+
+        return cjson.encode(ret)
+      LUA
+      class << self
+        def load_script
+          Sidekiq.redis do |c|
+            @@sha = c.script(:load, SCRIPT)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/sidekiq/trackable_batch/stage.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+module Sidekiq
+  class TrackableBatch < Batch
+    # @api private
+    class Stage < TrackableBatch
+      attr_reader :job_list
+
+      def initialize(description, target, **kwargs, &block)
+        self.description = description
+        if target.respond_to?(:include?) && target.include?('#')
+          @target = target
+        end
+        @kwargs = kwargs
+        @block = block
+        @job_list = []
+        super(&nil)
+      end
+
+      def setup(enclosing_batch)
+        if @target
+          klass, method = @target.split('#')
+          Object.const_get(klass).new.send(method, self, **@kwargs)
+        end
+        instance_exec(**@kwargs, &@block) if @block
+        job_list.each { |job| enclosing_batch.register_job(job) }
+      end
+    end
+  end
+end

data/lib/sidekiq/trackable_batch/success_callback.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+require 'sidekiq/trackable_batch/persistance'
+
+module Sidekiq
+  class TrackableBatch < Batch
+    # @api private
+    class SuccessCallback
+      include Persistance
+
+      def on_success(_, next_stage_bid)
+        jobs = get_jobs(next_stage_bid)
+        Sidekiq::Client.new.raw_push(
+          jobs.map { |j| Sidekiq.load_json(j) }
+        )
+      end
+    end
+  end
+end

data/lib/sidekiq/trackable_batch/tracking.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+require 'sidekiq/trackable_batch/persistance'
+
+module Sidekiq
+  class TrackableBatch < Batch
+    # Access TrackableBatch progress data (status).
+    class Tracking
+      include Persistance
+
+      # @param (see TrackableBatch#initialize)
+      def initialize(bid)
+        @bid = bid
+      end
+
+      # Get the current status of a {TrackableBatch} as a hash. (network request)
+      # @return [Hash] the {TrackableBatch}'s current status
+      def to_h
+        status = get_status(@bid).reduce({}) { |m, (k, v)| m.merge k.to_sym => v }
+        {
+          max: status.delete(:max).to_i,
+          value: status[:value] ? status.delete(:value).to_i : nil,
+          **status
+        }
+      end
+    end
+  end
+end

data/lib/sidekiq/trackable_batch/update_notifier.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+module Sidekiq
+  class TrackableBatch < Batch
+    # @api private
+    class UpdateNotifier
+      include Sidekiq::Worker
+
+      def perform(bid, target, args)
+        tracking = Tracking.new(bid).to_h
+        klass, method = target.split('#')
+        Object.const_get(klass).new.send(
+          method || :on_update,
+          tracking,
+          args.reduce({}) { |m, (k, v)| m.merge k.to_sym => v }
+        )
+      end
+    end
+  end
+end

data/lib/sidekiq/trackable_batch/workflow.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+module Sidekiq
+  class TrackableBatch < Batch
+    # @api private
+    class Workflow
+      attr_reader :stages
+
+      def initialize(enclosing_batch)
+        @enclosing_batch = enclosing_batch
+        @stages = []
+      end
+
+      def <<(stage)
+        @stages << stage
+      end
+
+      def stage(name)
+        @stages.detect { |stage| stage.description == name }
+      end
+
+      def start
+        Sidekiq::Client.new.raw_push(@stages.first.job_list)
+      end
+
+      def setup(&block)
+        @enclosing_batch.instance_eval(&block)
+        setup_callbacks
+        setup_jobs
+      end
+
+      private
+
+      def setup_jobs
+        @enclosing_batch.jobs do
+          @stages.each do |stage|
+            stage.setup(@enclosing_batch)
+          end
+        end
+      end
+
+      def setup_callbacks
+        @stages.each_cons(2) do |stage, next_stage|
+          stage.on(:success, SuccessCallback, next_stage.bid)
+        end
+      end
+    end
+  end
+end

data/lib/sidekiq/trackable_batch.rb

@@ -0,0 +1,170 @@
+# frozen_string_literal: true
+begin
+  require 'sidekiq-pro'
+rescue LoadError
+  begin
+    require 'sidekiq/batch'
+  rescue LoadError
+    raise LoadError, 'Neither Sidekiq::Pro nor Sidekiq::Batch are available. ' \
+      'Ensure one of these libraries is made available to ' \
+      'Sidekiq::TrackableBatch'
+  end
+end
+
+require 'sidekiq/overrides/client'
+require 'sidekiq/overrides/worker'
+require 'sidekiq/trackable_batch/middleware'
+require 'sidekiq/trackable_batch/messages'
+require 'sidekiq/trackable_batch/persistance'
+require 'sidekiq/trackable_batch/stage'
+require 'sidekiq/trackable_batch/success_callback'
+require 'sidekiq/trackable_batch/tracking'
+require 'sidekiq/trackable_batch/update_notifier'
+require 'sidekiq/trackable_batch/workflow'
+
+module Sidekiq
+  # Interface for creating and tracking Sidekiq TrackableBatches
+  class TrackableBatch < Batch
+    include Persistance
+
+    # Time to live for data persisted to redis (30 Days)
+    TTL = 60 * 60 * 24 * 30
+
+    class << self
+      # Track a {TrackableBatch}
+      # @param trackable_batch [TrackableBatch] Instance
+      # @return [Tracking] Instance
+      def track(trackable_batch)
+        Tracking.new(trackable_batch.bid)
+      end
+    end
+
+    attr_reader :messages, :update_listeners, :workflow
+    attr_accessor :update_queue
+
+    # Create a new TrackableBatch
+    # @param bid [String] An existing Batch ID
+    def initialize(bid = nil, &block)
+      @reopened = bid
+      @messages = Messages.new
+      super(bid)
+      return unless block_given?
+      @workflow = Workflow.new(self)
+      @workflow.setup(&block)
+      @workflow.start
+    end
+
+    # @private
+    # @return [true, false]
+    def reopened?
+      !@reopened.nil?
+    end
+
+    # @private
+    def register_job(msg)
+      @messages << msg
+    end
+
+    # Register a callback for a {TrackableBatch}'s status updates
+    #
+    # @example Using a class that responds to #on_update
+    #   trackable_batch = Sidekiq::TrackableBatch.new
+    #   trackable_batch.on(:update, Klass)
+    #
+    # @example Using a string to set a specific callback method.
+    #   trackable_batch = Sidekiq::TrackableBatch.new do
+    #     on(:update, 'Klass#not_on_update', more: 'information')
+    #   end
+    #
+    # @param [Symbol] event The name of the event
+    # @param [Class, String] target The class and an optionally declared update method
+    #   (defaults to #on_update)
+    # @param [Hash] options Any extra information required to be passed to the callback
+    def on(event, target, options = {})
+      if event == :update
+        @update_listeners ||= []
+        @update_listeners << { target => options }
+      else
+        super
+      end
+    end
+
+    # Chainable DSL for creating a Sidekiq::TrackableBatch with nested
+    # batches that require ordered execution.
+    #
+    # @example
+    #   class Klass
+    #     def pack(nested_batch)
+    #       nested_batch.jobs do
+    #         MyWorker.perform_async
+    #       end
+    #     end
+    #
+    #     def ship(nested_batch, options)
+    #       nested_batch.jobs do
+    #         MyWorker.perform_async(options)
+    #       end
+    #     end
+    #   end
+    #
+    #   trackable_batch = Sidekiq::TrackableBatch.new do
+    #     start_with('Pick', options: :get, passed: :along) do |options|
+    #       jobs do
+    #         MyWorker.perform_async(options[:passed])
+    #       end
+    #     end
+    #     .then('Pack', 'Klass#pack')
+    #     .finally('Ship', 'Klass#ship', here: :also)
+    #   end
+    #
+    # @param [String] description The nested batch's description
+    # @param [String] target Class and method to call to setup the nested batch
+    #   (required if no block is provided)
+    # @param [Hash] args Arguments to be forwarded to block or target
+    # @param [Block] block Block that executes in the context of the nested batch
+    #   (required if no target is provided)
+    #
+    # @return receiver
+    def then(description, target = nil, **args, &block)
+      raise ArgumentError unless target || block
+      @workflow << Stage.new(description, target, **args, &block)
+      self
+    end
+    alias start_with then
+    alias finally then
+
+    # @param (see Sidekiq::Batch#jobs)
+    # @return [Array<String>] A list of JIDs for work that has been enqueued
+    def jobs
+      Thread.current[:parent_tbatch] = Thread.current[:tbatch]
+      Thread.current[:tbatch] = self
+      @jids = super
+      persist
+      @jids
+    ensure
+      Thread.current[:tbatch] = Thread.current[:parent_tbatch]
+      Thread.current[:parent_tbatch] = nil
+    end
+
+    # Set extra information in a batch's initial status
+    # @example Add some status text to a batch before any work is performed
+    #   trackable_batch = Sidekiq::TrackableBatch.new
+    #   trackable_batch.initial_status(status_text: 'Starting')
+    #   tracking = Sidekiq::TrackableBatch.track(trackable_batch)
+    #   tracking.to_h # => { max: nil, value: nil, status_text: 'Starting' }
+    #
+    # @param options [Hash]
+    def initial_status(options = {})
+      update_status(self, options)
+    end
+
+    private
+
+    def persist
+      persist_batch(self)
+      @messages.clear
+    end
+  end
+end
+
+require 'sidekiq/trackable_batch/initializer'

metadata

@@ -0,0 +1,144 @@
+--- !ruby/object:Gem::Specification
+name: sidekiq-trackable_batch
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- darrhiggs
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2017-07-06 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: sidekiq
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.14'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.14'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: appraisal
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.1'
+- !ruby/object:Gem::Dependency
+  name: redcarpet
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Access detailed & up-to-date progress information for `Sidekiq::Batch`
+email:
+- darrhiggs+os@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
+- lib/sidekiq/overrides/client.rb
+- lib/sidekiq/overrides/worker.rb
+- lib/sidekiq/trackable_batch.rb
+- lib/sidekiq/trackable_batch/initializer.rb
+- lib/sidekiq/trackable_batch/messages.rb
+- lib/sidekiq/trackable_batch/middleware.rb
+- lib/sidekiq/trackable_batch/persistance.rb
+- lib/sidekiq/trackable_batch/scripting.rb
+- lib/sidekiq/trackable_batch/stage.rb
+- lib/sidekiq/trackable_batch/success_callback.rb
+- lib/sidekiq/trackable_batch/tracking.rb
+- lib/sidekiq/trackable_batch/update_notifier.rb
+- lib/sidekiq/trackable_batch/workflow.rb
+homepage: https://github.com/darrhiggs/sidekiq-trackable_batch
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.12
+signing_key: 
+specification_version: 4
+summary: Detailed `Sidekiq::Batch` progress
+test_files: []