sidekiq-resque_status 0.0.3

data/.gitignore

@@ -0,0 +1,18 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+.DS_Store
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/.rvmrc

@@ -0,0 +1 @@
+rvm use ruby-1.9.3-p194@sidekiq

data/CHANGELOG.md

@@ -0,0 +1,3 @@
+## v0.0.3
+
+* Initial release

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in sidekiq-resque_status.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2012 Thomas Dmytryk
+
+MIT License
+
+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,66 @@
+# Sidekiq::ResqueStatus
+
+Sidekiq-resque_status is a Sidekiq plug-in that will allow you to manage and check the progress of your resque jobs and sidekiq workers under the same place: the resque web-ui interface. Sidekiq and Resque are two different queuing system and depending on the type of jobs you have to process you might want to use one or the other. These two queuing system have their own web interface. This gem allow you, in case you are using both queuing system in one project, to group them under the resque web-ui. 
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'sidekiq-resque_status'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install sidekiq-resque_status
+
+## Usage
+
+# Personalize your worker:
+
+To add Sidekiq worker to your resque web-ui you just need inherit your worker class with SidekiqWorkerWithStatus
+
+		class SleepingJob < SidekiqWorkerWithStatus
+		  def perform(*args)
+		    sleep args[0] || 0.1
+		  end
+		end 
+
+# Set up your Sidekiq connection base on your Resque one
+	
+In order for sidekiq-resque_status to work properly you need to tell sidekiq to use the same connection as Resque (same namespace, same url).
+You can do so by creating a config file (such as sidekiq_config.rb) and doing:
+
+		Sidekiq.configure_server do |config|
+		  config.redis = {:namespace => Resque.redis.namespace, :url => url }
+		end
+
+		Sidekiq.configure_client do |config|
+		  config.redis = { :namespace => Resque.redis.namespace, :url => url }
+		end	
+
+# Add the sidekiq-resque_status middleware to the Sidekiq server and client middleware
+
+		Sidekiq.configure_server do |config|
+		  config.server_middleware do |chain|
+		    chain.add Sidekiq::Status::ServerMiddleware
+		    chain.add Sidekiq::Middleware::Server::Stats::ResqueLike
+		  end
+		end
+
+		Sidekiq.configure_client do |config|
+		  config.client_middleware do |chain|
+		    chain.add Sidekiq::Status::ClientMiddleware
+		    chain.add Sidekiq::Middleware::Client::Stats::ResqueLike
+		  end
+		end	
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Added some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,2 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"

data/lib/sidekiq-resque_status.rb

@@ -0,0 +1,187 @@
+require 'sidekiq'
+require 'sidekiq-status'
+require 'sidekiq-resque_status/version'
+require 'sidekiq-resque_status/sidekiq_worker_with_status'
+
+Dir["#{File.dirname(__FILE__)}/sidekiq-resque_status/middleware/**/*.rb"].each { |f| require f }
+Dir["#{File.dirname(__FILE__)}/sidekiq-resque_status/sidekiq/**/*.rb"].each { |f| require f }
+
+module Sidekiq
+  module ResqueStatus
+
+    ###
+    # => This method will be called by the client middleware before enqueing a job.
+    # => It stores information on the current job.
+    # => These information will be display by resque web-ui each time a user is browsing:
+    #   - the statuses page (provided by resque-status)
+    #   - the job_stats page (provided by resque-job-stats)
+    ###
+    def enqueue_job(worker, msg, queue)
+      now = Time.now.utc + 1
+
+      # Resque Job Stats equivalent
+      increment_stat("stats:jobs:#{worker.name}:enqueued", now)        
+
+      # Status set to queued
+      status_hash = { :time => now.to_i, :class => worker.name, :retry => false, :name => "#{worker.name}(#{msg['args']})", :status => "queued", :uuid => msg['jid'], :args => msg['args']}
+      update_status("status:#{msg['jid']}", "queued", status_hash)
+
+      # Add the job id to the _statuses key
+      redis.zadd("_statuses", now.to_i, msg['jid'])
+    end
+
+    ###
+    # => This method will be called by the server middleware before processing a job.
+    # => It makes sure we are not loosing any information at the beggining of the process.
+    # => It updates information on the current job.
+    # => These information will be display by resque web-ui each time a user is browsing:
+    #   - the statuses page (provided by resque-status)
+    #   - the job_stats page (provided by resque-job-stats)
+    ###
+    def job_in_progress(worker, msg, queue)
+      # When resqueue web re-enqueue a job we need to make sure worker.jid and msg[jid] are defined
+      worker.jid ||= msg['jid'] ||= msg['args'].first['jid'] if msg['args'] && msg['args'].is_a?(Array)
+
+      # Set status to working
+      status_hash = set_missing_values(worker, msg, queue)
+      status_hash = update_status("status:#{msg['jid']}", "working", status_hash)
+    end
+
+    ###
+    # => This method will be called by the server middleware after processing a job.
+    # => It adds a description of the processed jobs.
+    # => It updates information on the current job.
+    # => These information will be display by resque web-ui each time a user is browsing:
+    #   - the statuses page (provided by resque-status)
+    #   - the job_stats page (provided by resque-job-stats)
+    #   - the queues page (provided by resque-web)
+    ###
+    def job_completed(worker, msg, queue, duration = 0)
+      status_hash = complete_options(worker.to_process || 1, worker.processed || 1, duration, worker.description)
+      status_hash = set_missing_values(worker, msg, queue, status_hash)
+
+      # Status set to completed
+      hash = update_status("status:#{msg['jid']}", "completed", status_hash) || {}
+      time = hash["time"] || hash["run_at"]
+      now = time ? Time.at(time.to_i) : Time.now.utc
+
+      # Resque job Stats equivalent
+      increment_stat("stats:jobs:#{msg['jid']}:timeseries:performed", now)
+      increment_stat("stats:jobs:#{worker.class.name}:performed", now)
+
+      # Set duration
+      redis.rpush("stats:jobs:#{worker.class.name}:duration", duration) 
+      redis.rpush("stats:jobs:#{msg['jid']}:duration", duration) 
+
+      # remove job from the queue tab
+      redis.lpop("queue:#{queue}")
+    end
+
+    ###
+    # => This method will be called by the server middleware each time a job failed.
+    # => It adds a complete description of the failure. 
+    # => It updates information on the current job.
+    # => It makes sure the job can be replay.
+    # => These information will be display by resque web-ui each time a user is browsing:
+    #   - the failed page (provided by resque-web)
+    ###
+    def job_failed(worker, msg, queue, error)
+      hash = merge_value("status:#{msg['jid']}", {"status" => "failed", "message" => error.message})
+      update_status("status:#{msg['jid']}", "failed", hash)
+
+      # pass the jid into args hash to replay the job
+      args = msg['args'].is_a?(Array) && msg['args'].first.is_a?(Hash) ? [msg['args'].first.merge({'jid' => msg['jid']})] : msg['args']
+
+      failed_message = {
+                          :failed_at => Time.now.rfc2822,
+                          :payload => {"class" => worker.class.name, "args" => args},
+                          :class => worker.class.name,
+                          :exception => error.class.name,
+                          :error => error.message,
+                          :backtrace => error.backtrace, 
+                          :worker => queue,
+                          :queue => queue, 
+                          :args => args,
+                          :jid => msg['jid']
+                        }
+      # Push the failed information into redis
+      redis.rpush('failed', MultiJson.dump(failed_message))
+
+      # Increment failed statistics for job Stats 
+      increment_stat("stats:jobs:#{worker.class.name}:failed", Time.now)  
+      increment_expire_key("stat:failed")
+    end
+
+    private
+
+    ###
+    # => Return the redis connection
+    ###
+    def redis
+      @redis ||= Sidekiq.redis {|conn| conn}
+    end
+
+    ###
+    # => Return hash containing some statistics about the processed job
+    ###
+    def complete_options(total_to_process, total_processed, duration = 0, message = nil)
+      average = (duration/total_processed rescue 0).round(1)
+      time = duration.round(1)
+
+      message ||= "processed #{total_processed} in A: #{average} T: #{time}"
+      {"status" => "completed", :total => total_to_process, :num => total_processed, :message => message}
+    end
+
+    ###
+    # => Increment a given key and set an expiration date
+    ###
+    def increment_expire_key(key, duration = nil)
+      redis.expire(key, duration) if duration
+      redis.incr(key)
+    end
+
+    ###
+    # => Build Hourly, Daily and Global statistics that will be used by resque-job-stats
+    ###
+    def increment_stat(key, now)
+      # Increment global stats
+      increment_expire_key(key)
+
+      # Increment hourly stats
+      increment_expire_key(key + ":#{now.hour}:#{now.min}:#{now.sec}", 3660)
+
+      # Increment daily stats
+      increment_expire_key(key + ":#{now.hour}:#{now.min}", 900000)
+    end
+
+    ###
+    # => Update the status of a job and add more information to it if requested
+    ###
+    def update_status(key, status, hash = nil)
+      status_hash = merge_value(key, {"status" => status}) || {}
+      status_hash.merge!(hash) if hash
+
+      redis.set(key, MultiJson.dump(status_hash)) 
+      redis.expire(key, 260000)
+      status_hash
+    end
+
+    ###
+    # => Get the value of a key and merge it 
+    ###
+    def merge_value(key,hash)
+      value = redis.get(key)
+      MultiJson.load(value).merge(hash) if value
+    end
+
+    ###
+    # => Ensure we always get track of the important informations concerning the worker
+    ###
+    def set_missing_values(worker, msg, queue, status_hash = {})
+      status_hash['jid'] = msg['jid'] if status_hash['jid'].nil?
+      status_hash['queue'] = queue if status_hash['queue'].nil?
+      status_hash['class'] = worker.class.name if status_hash['class'].nil?
+      status_hash
+    end
+  end
+end

data/lib/sidekiq-resque_status/middleware/client/resque_like.rb

@@ -0,0 +1,17 @@
+module Sidekiq
+  module Middleware
+    module Client
+      module Stats
+        class ResqueLike
+          include Sidekiq::ResqueStatus
+          # Store information on the current enqueued job into redis
+
+          def call(worker, msg, queue)
+            enqueue_job(worker, msg, queue)
+            yield
+          end
+        end
+      end
+    end
+  end
+end 

data/lib/sidekiq-resque_status/middleware/server/resque_like.rb

@@ -0,0 +1,24 @@
+module Sidekiq
+  module Middleware
+    module Server
+      module Stats
+        class ResqueLike
+          include Sidekiq::ResqueStatus
+          # Update the status, and add other information (such as the job description) into redis
+
+          def call(worker, msg, queue)
+            begin
+              job_in_progress(worker, msg, queue)
+              start_time = Time.now
+              yield
+              job_completed(worker, msg, queue, Time.now-start_time)
+            rescue Exception => error
+              job_failed(worker, msg, queue, error)
+            end
+          end
+        end
+      end
+    end
+  end
+end
+    

data/lib/sidekiq-resque_status/sidekiq/processor.rb

@@ -0,0 +1,35 @@
+module Sidekiq
+
+  # Monkey patch to overide the run_at attribute (Time instead of unix timestamp)
+  # and remove the failed key incrementation
+  class Processor
+    private
+    def stats(worker, msg, queue)
+      redis do |conn|
+        conn.multi do
+          conn.sadd('workers', self)
+          conn.setex("worker:#{self}:started", EXPIRY, Time.now.to_s)
+          hash = {:queue => queue, :payload => msg, :run_at => Time.now }
+          conn.setex("worker:#{self}", EXPIRY, Sidekiq.dump_json(hash))
+        end
+      end
+
+      dying = false
+      begin
+        yield
+      rescue Exception
+        dying = true
+        raise
+      ensure
+        redis do |conn|
+          conn.multi do
+            conn.srem("workers", self)
+            conn.del("worker:#{self}")
+            conn.del("worker:#{self}:started")
+            conn.incrby("stat:processed", 1)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/sidekiq-resque_status/sidekiq_worker_with_status.rb

@@ -0,0 +1,6 @@
+class SidekiqWorkerWithStatus
+	include Sidekiq::Worker 
+  include Sidekiq::ResqueStatus
+
+  attr_accessor :processed, :to_process, :description
+end 

data/lib/sidekiq-resque_status/version.rb

@@ -0,0 +1,5 @@
+module Sidekiq
+  module ResqueStatus
+    VERSION = "0.0.3"
+  end
+end

data/sidekiq-resque_status.gemspec

@@ -0,0 +1,28 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/sidekiq-resque_status/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ['Thomas Dmytryk']
+  gem.email         = ['thomas@fanhattan.com', 'thomas.dmytryk@supinfo.com']
+  gem.description   = %q{sidekiq-resque_status is a Sidekiq plugin that allows to see statuses of Sidekiq workers using the Resque web interface}
+  gem.summary       = %q{sidekiq-resque_status is an extension to the Sidekiq queue system. It has been created to centralize Resque jobs statuses and Sidekiq workers statuses inside the resque-web interface.}
+  gem.homepage      = ''
+  gem.license       = 'MIT'
+
+  gem.files         = `git ls-files`.split($\)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.name          = 'sidekiq-resque_status'
+  gem.require_paths = ['lib']
+  gem.version       = Sidekiq::ResqueStatus::VERSION
+
+  gem.add_runtime_dependency("activesupport", '~> 3.2.11')
+
+  gem.add_dependency 'sidekiq', '~> 2.6.4'
+  gem.add_dependency 'sidekiq-status'
+  gem.add_dependency 'multi_json', '~> 1'
+
+
+  gem.add_development_dependency 'rspec'
+  gem.add_development_dependency 'minitest', '~> 4'
+end

data/spec/sidekiq-resque_status/test_middleware.rb

@@ -0,0 +1,98 @@
+require 'spec_helper'
+require 'minitest/unit'
+require 'minitest/pride'
+require 'minitest/autorun'
+
+require 'sidekiq'
+require 'sidekiq/fetch'
+require 'sidekiq/redis_connection'
+require 'sidekiq/processor' 
+
+
+REDIS = Sidekiq::RedisConnection.create(:url => "redis://localhost/15", :namespace => 'test')
+
+class TestMiddleware < MiniTest::Unit::TestCase
+  describe 'middleware chain' do
+    before do
+      $errors = []
+      Sidekiq.redis = REDIS
+      Sidekiq.redis { |conn| conn.flushall }
+      sleep 0.1
+    end
+
+    let!(:redis) { Sidekiq.redis { |conn| conn } }
+    let!(:job_id) { '987654321' }
+
+    def process_job(msg)
+     boss = MiniTest::Mock.new
+     processor = Sidekiq::Processor.new(boss)
+     actor = MiniTest::Mock.new
+     actor.expect(:processor_done, nil, [processor])
+     boss.expect(:async, actor, [])
+     processor.process(Sidekiq::BasicFetch::UnitOfWork.new('queue:default', msg))
+    end
+
+    Sidekiq.server_middleware do |chain|
+      # should only add once, second should be ignored
+      chain.add Sidekiq::Status::ServerMiddleware
+      chain.add Sidekiq::Middleware::Server::Stats::ResqueLike 
+    end
+
+    describe "Processing a valid job" do
+      it "should add completed status information using jid" do
+        msg = '{ "class": "' + SleepingJob.name + '", "args": [null], "jid": "' + job_id + '" }'
+        process_job(msg)
+
+        status = redis.get("status:#{job_id}")
+        status.should_not be_nil
+        status = MultiJson.load(status)
+
+        status['status'].should == 'completed' 
+        status['class'].should == SleepingJob.name
+        status['queue'].should == 'default'
+        status['jid'].should == job_id 
+      end
+    end
+
+    describe "Processing a failing job" do
+      let!(:msg) { '{ "class": "' + FailingJob.name + '", "args": [0], "jid": "' + job_id + '" }'} 
+
+      it "should update job status to failed status" do
+        process_job(msg)
+
+        status = redis.get("status:#{job_id}")
+        status.should_not be_nil
+        status = MultiJson.load(status)
+
+        status['status'].should == 'failed' 
+        status['class'].should == FailingJob.name
+        status['jid'].should == job_id
+      end
+
+      it "should add failed information" do
+        process_job(msg)
+        
+        detailed_status = redis.lindex('failed', 0)
+        detailed_status.should_not be_nil
+        detailed_status = MultiJson.load(detailed_status)
+
+        detailed_status['failed_at'].should == Time.now.rfc2822
+        detailed_status['class'].should == FailingJob.name
+        detailed_status['jid'].should == job_id
+        detailed_status['args'].should == [0]
+        detailed_status['exception'].should == StandardError.name
+        detailed_status['error'].should == "This job is supposed to failed."
+        detailed_status['backtrace'].should_not be_nil
+        detailed_status['payload'].should == { 'class' => FailingJob.name, 'args' => [0] }
+      end
+
+      it "should increment the number of failed jobs" do
+        nb_failed, nb_job_failed = redis.get("stat:failed").to_i, redis.get("stats:jobs:#{FailingJob.name}:failed").to_i
+        process_job(msg)
+        
+        redis.get("stat:failed").to_i.should == nb_failed + 1
+        redis.get("stats:jobs:#{FailingJob.name}:failed").to_i  == nb_job_failed + 1
+      end
+    end
+  end
+end

data/spec/sidekiq-resque_status_spec.rb

@@ -0,0 +1,21 @@
+require 'spec_helper'
+require 'sidekiq/testing/inline'
+
+describe Sidekiq::ResqueStatus do
+
+  let!(:redis) { Sidekiq.redis { |conn| conn } }
+
+  # Clean Redis before each test
+  # Seems like flushall has no effect on recently published messages,
+  # so we should wait till they expire
+  before { redis.flushall; sleep 0.1 }
+
+  describe "Enqueuing a job" do
+    it "should increment the number of enqueued jobs" do
+      nb_enqueued = redis.get("stats:jobs:#{SleepingJob.name}:enqueued").to_i
+      SleepingJob.perform_async(1)
+
+      redis.get("stats:jobs:#{SleepingJob.name}:enqueued").to_i.should == nb_enqueued + 1
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,17 @@
+require 'sidekiq-resque_status'
+Dir["#{File.dirname(__FILE__)}/support/*.rb"].each { |f| require f }
+
+# Add Sidekiq-status and sidekiq-resque_status to the server and client middleware
+Sidekiq.configure_server do |config|
+  config.server_middleware do |chain|
+    chain.add Sidekiq::Status::ServerMiddleware
+    chain.add Sidekiq::Middleware::Server::Stats::ResqueLike
+  end
+end
+
+Sidekiq.configure_client do |config|
+  config.client_middleware do |chain|
+    chain.add Sidekiq::Status::ClientMiddleware
+    chain.add Sidekiq::Middleware::Client::Stats::ResqueLike
+  end
+end

data/spec/support/failing_job.rb

@@ -0,0 +1,6 @@
+class FailingJob < SidekiqWorkerWithStatus
+	
+  def perform(*args)
+    raise StandardError, 'This job is supposed to failed.'
+  end
+end

data/spec/support/sleeping_job.rb

@@ -0,0 +1,6 @@
+class SleepingJob < SidekiqWorkerWithStatus
+	
+  def perform(*args)
+    sleep args[0] || 0.1
+  end
+end

metadata

@@ -0,0 +1,170 @@
+--- !ruby/object:Gem::Specification
+name: sidekiq-resque_status
+version: !ruby/object:Gem::Version
+  version: 0.0.3
+  prerelease: 
+platform: ruby
+authors:
+- Thomas Dmytryk
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-01-11 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 3.2.11
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 3.2.11
+- !ruby/object:Gem::Dependency
+  name: sidekiq
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.6.4
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.6.4
+- !ruby/object:Gem::Dependency
+  name: sidekiq-status
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: multi_json
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '4'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '4'
+description: sidekiq-resque_status is a Sidekiq plugin that allows to see statuses
+  of Sidekiq workers using the Resque web interface
+email:
+- thomas@fanhattan.com
+- thomas.dmytryk@supinfo.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rvmrc
+- CHANGELOG.md
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- lib/sidekiq-resque_status.rb
+- lib/sidekiq-resque_status/middleware/client/resque_like.rb
+- lib/sidekiq-resque_status/middleware/server/resque_like.rb
+- lib/sidekiq-resque_status/sidekiq/processor.rb
+- lib/sidekiq-resque_status/sidekiq_worker_with_status.rb
+- lib/sidekiq-resque_status/version.rb
+- sidekiq-resque_status.gemspec
+- spec/sidekiq-resque_status/test_middleware.rb
+- spec/sidekiq-resque_status_spec.rb
+- spec/spec_helper.rb
+- spec/support/failing_job.rb
+- spec/support/sleeping_job.rb
+homepage: ''
+licenses:
+- MIT
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: sidekiq-resque_status is an extension to the Sidekiq queue system. It has
+  been created to centralize Resque jobs statuses and Sidekiq workers statuses inside
+  the resque-web interface.
+test_files:
+- spec/sidekiq-resque_status/test_middleware.rb
+- spec/sidekiq-resque_status_spec.rb
+- spec/spec_helper.rb
+- spec/support/failing_job.rb
+- spec/support/sleeping_job.rb