sidekiq_queue_metrics 2.1.1 → 3.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8baa544934c8ad85fe77e15b8058d6b0d0e47f8e789ddf5077b24c2d0d59a197
-  data.tar.gz: 907c164a937d60b602c0700daa49113b7dcf3d710ac6473fc1a83ae3ef961638
+  metadata.gz: 9513e994c0d230463b79ed7a2d43e47b6159ea9d5ac36b3288d3da3b2f07f091
+  data.tar.gz: c6c488224f22b3b74038312c6ba273af65489aa04ccc1e68057389088aa682dc
 SHA512:
-  metadata.gz: 5fde602302fd8474d3ea9e3702a1266a37bd20bccf89d9f4be3b557255f8e9975d831b31dd5cc9f3a7ba65e9dbc04febc360b5a9129516b914ce07f21c063d63
-  data.tar.gz: ea67ac50f705404a421455f2cfda336f5ab29f756244d1a5a0d566b206ed10a55b7bf9c23939a7f2e557f102d5445226aed259a5d84d328b5b7a31c7f85c0d16
+  metadata.gz: df033456251c68174d066d57bdbdf6acd122554d03e601735b79c98524d573083e5b92880c18abe3516ede22f7d56eec682995e41f2b97c76f9bbe3b95b5b414
+  data.tar.gz: 855585c740c62a970edef6222d7d13cad47a02528e5856441b66f452de9137461c88c6d01c2c271ccb189338f65d63dbae985ea8a7ded80f3ea87084e2a8f78b

data/.gitignore

@@ -1,2 +1,3 @@
 .idea
 *.gem
+Gemfile.lock

data/.travis.yml

@@ -9,3 +9,4 @@ before_install:
 
 script:
 - "bundle exec rspec"
+- "SIDEKIQ_VERSION=4.2.10 bundle update && bundle exec rspec"

data/Gemfile

@@ -1,5 +1,9 @@
 source :rubygems
 
-gem 'sidekiq'
+sidekiq_version = ENV.fetch('SIDEKIQ_VERSION', '> 0')
+
+gemspec
+
+gem 'sidekiq', sidekiq_version
 gem 'eldritch'
-gem 'rspec'
+gem 'rspec'

data/lib/sidekiq_queue_metrics/configuration.rb

@@ -1,10 +1,22 @@
 module Sidekiq::QueueMetrics
+  def self.support_death_handlers?
+    Sidekiq::VERSION >= '5.1'
+  end
+
   def self.init(config)
     config.server_middleware do |chain|
       chain.add Sidekiq::QueueMetrics::JobSuccessMonitor
     end
 
-    config.death_handlers << Sidekiq::QueueMetrics::JobDeathMonitor.proc
+    config.on(:startup) { UpgradeManager.upgrade_if_needed }
+
+    if support_death_handlers?
+      config.death_handlers << Sidekiq::QueueMetrics::JobDeathMonitor.proc
+    else
+      config.server_middleware do |chain|
+        chain.add Sidekiq::QueueMetrics::JobDeathMiddleware
+      end
+    end
   end
 
   def self.storage_location=(key)
@@ -22,4 +34,4 @@ module Sidekiq::QueueMetrics
   def self.storage_location
     @storage_location
   end
-end
+end

data/lib/sidekiq_queue_metrics/helpers.rb

@@ -0,0 +1,43 @@
+module Sidekiq::QueueMetrics
+  module Helpers
+    FAILED_JOBS_KEY = 'failed_jobs'.freeze
+
+    def self.build_queue_stats_key(queue)
+      "#{stats_key}:#{queue}"
+    end
+
+    def self.build_failed_jobs_key(queue)
+      "#{FAILED_JOBS_KEY}:#{queue}"
+    end
+
+    def self.stats_key
+      Sidekiq::QueueMetrics.storage_location || 'queue_stats'
+    end
+
+    def self.convert_hash_values(original_hash, &block)
+      original_hash.reduce({}) do |result, (k,v)|
+        result[k] = case v
+          when Array then v
+          when Hash then convert_hash_values(v, &block)
+          else block.(v)
+          end
+
+        result
+      end
+    end
+
+    def self.build_metrics_for_view(last_metrics, current_metrics)
+      current_metrics.each_with_object({}) do |(queue, metric), new_queue_metrics|
+        new_queue_metrics[queue] = metric.each_with_object({}) do |(name, count), updated_metrics|
+          previous_metric_value = last_metrics[queue] ? last_metrics[queue][name] : nil
+          animate = !previous_metric_value.nil? && previous_metric_value != count
+
+          updated_metrics[name] = {
+            'count' => count,
+            'animate' => animate
+          }
+        end
+      end
+    end
+  end
+end

data/lib/sidekiq_queue_metrics/job_death_middleware.rb

@@ -0,0 +1,17 @@
+module Sidekiq::QueueMetrics
+  class JobDeathMiddleware
+    def call(worker, msg, queue)
+      call_dead_monitor(msg) if is_dead_job?(msg)
+
+      yield if block_given?
+    end
+
+    def is_dead_job?(msg)
+      msg.key?('retry_count') && msg['retry_count'] == 0
+    end
+
+    def call_dead_monitor(msg)
+      Sidekiq::QueueMetrics::JobDeathMonitor.proc.call(msg, msg['error_class'])
+    end
+  end
+end

data/lib/sidekiq_queue_metrics/monitor/job_death_monitor.rb

@@ -17,4 +17,4 @@ module Sidekiq::QueueMetrics
       'failed'
     end
   end
-end
+end

data/lib/sidekiq_queue_metrics/monitor/job_success_monitor.rb

@@ -11,4 +11,4 @@ module Sidekiq::QueueMetrics
       'processed'
     end
   end
-end
+end

data/lib/sidekiq_queue_metrics/monitor/monitor.rb

@@ -4,25 +4,11 @@ require 'sidekiq_queue_metrics/storage'
 module Sidekiq::QueueMetrics
   class Monitor
     def monitor(queue)
-      stats = existing_stats
-      stats[queue] ||= {}
-
-      if stats[queue][status_counter].nil?
-        stats[queue][status_counter] = 1
-      else
-        stats[queue][status_counter] += 1
-      end
-
-      Storage.set_stats(stats.to_json)
-    end
-
-    protected
-    def status_counter
+      Storage.increment_stat(queue, status_counter)
     end
 
-    private
-    def existing_stats
-      JSON.load(Storage.get_stats || '{}')
+    protected def status_counter
+      fail 'This method should be implemented by child monitors'
     end
   end
-end
+end

data/lib/sidekiq_queue_metrics/queue_metrics.rb

@@ -6,34 +6,34 @@ module Sidekiq::QueueMetrics
   class << self
     def fetch
       queues = []
-      success_and_failed_stats = enqueued_jobs =  scheduled_jobs = retry_stats = {}
+      enqueued_jobs = scheduled_jobs = retry_stats = {}
+
       together do
         async do
           queues = Sidekiq::Queue.all.map(&:name).map(&:to_s)
           queues.each {|queue| enqueued_jobs[queue] = fetch_enqueued_jobs(queue)}
         end
 
-        async {success_and_failed_stats = fetch_success_and_failed_stats}
         async {retry_stats = fetch_retry_stats}
         async {scheduled_jobs = fetch_scheduled_stats}
       end
 
-      queues.map do |queue|
-        stats = {'processed' => 0, 'failed' => 0}
-        if success_and_failed_stats.has_key?(queue)
-          stats['processed'] = val_or_default(success_and_failed_stats[queue]['processed'])
-          stats['failed'] = val_or_default(success_and_failed_stats[queue]['failed'])
-        end
+      queues.reduce({}) do |stats, queue|
+        stats[queue] = {
+          'enqueued' => val_or_default(enqueued_jobs[queue]),
+          'in_retry' => val_or_default(retry_stats[queue]),
+          'scheduled' => val_or_default(scheduled_jobs[queue])
+        }.merge(fetch_success_and_failed_stats(queue))
 
-        stats['enqueued'] = val_or_default(enqueued_jobs[queue])
-        stats['in_retry'] = val_or_default(retry_stats[queue])
-        stats['scheduled'] = val_or_default(scheduled_jobs[queue])
-        {queue => stats}
-      end.reduce({}, :merge)
+        stats
+      end
     end
 
-    def fetch_success_and_failed_stats
-      JSON.load(Storage.get_stats || '{}')
+    def fetch_success_and_failed_stats(queue)
+      default_metric_values = { 'processed' => 0, 'failed' => 0 }
+      default_metric_values.merge(
+        Sidekiq::QueueMetrics::Storage.get_stats(queue)
+      )
     end
 
     def fetch_enqueued_jobs(queue)
@@ -52,8 +52,7 @@ module Sidekiq::QueueMetrics
       Storage.failed_jobs(queue).reverse
     end
 
-    private
-    def val_or_default(val, default = 0)
+    private def val_or_default(val, default = 0)
       val || default
     end
   end

data/lib/sidekiq_queue_metrics/storage.rb

@@ -1,42 +1,38 @@
 module Sidekiq::QueueMetrics
   class Storage
-    FAILED_JOBS_KEY = 'failed_jobs'.freeze
-
     class << self
-      def set_stats(key = stats_key, value)
+      def increment_stat(queue, stat, value = 1)
         Sidekiq.redis_pool.with do |conn|
-          conn.set(key, value)
+          conn.hincrby(Helpers.build_queue_stats_key(queue), stat, value)
         end
       end
 
-      def get_stats(key = stats_key)
-        Sidekiq.redis_pool.with do |conn|
-          conn.get(key)
+      def get_stats(queue)
+        stats = Sidekiq.redis_pool.with do |conn|
+          conn.hgetall(Helpers.build_queue_stats_key(queue))
         end
+
+        Helpers.convert_hash_values(stats) { |value| value.to_i }
       end
 
       def add_failed_job(job, max_count = Sidekiq::QueueMetrics.max_recently_failed_jobs)
-        Sidekiq.redis_pool.with do |conn|
-          queue = job['queue']
-          failed_jobs = JSON.parse(conn.get("#{FAILED_JOBS_KEY}:#{queue}") || '[]')
+        queue = job['queue']
 
-          if failed_jobs.size >= max_count
-            (failed_jobs.size - max_count + 1).times {failed_jobs.shift}
-          end
+        Sidekiq.redis_pool.with do |conn|
+          failed_job_key_for_queue = Helpers.build_failed_jobs_key(queue)
 
-          conn.set("#{FAILED_JOBS_KEY}:#{queue}", (failed_jobs << job).to_json)
+          conn.lpush(failed_job_key_for_queue, Sidekiq.dump_json(job))
+          conn.rpop(failed_job_key_for_queue) if conn.llen(failed_job_key_for_queue) >= max_count
         end
       end
 
       def failed_jobs(queue)
-        Sidekiq.redis_pool.with do |conn|
-          JSON.parse(conn.get("#{FAILED_JOBS_KEY}:#{queue}") || '[]')
+        result = Sidekiq.redis_pool.with do |conn|
+          conn.lrange(Helpers.build_failed_jobs_key(queue), 0, -1)
         end
-      end
 
-      def stats_key
-        Sidekiq::QueueMetrics.storage_location || 'queue_stats'
+        result.map(&Sidekiq.method(:load_json))
       end
     end
   end
-end
+end

data/lib/sidekiq_queue_metrics/upgrade_manager.rb

@@ -0,0 +1,76 @@
+require 'redlock'
+
+module Sidekiq
+  module QueueMetrics
+    class UpgradeManager
+      def self.logger
+        @@logger ||= Logger.new(STDOUT)
+      end
+
+      # Check if an upgrade is needed and it's not already in progress.
+      # If it's in progress, it will block during that time waiting for the upgrade to complete.
+      #
+      # In case the lock is not released because the upgrade is taking too long
+      # it will raise an exception
+      #
+      # @raises [Redlock::LockError]
+      #
+      def self.upgrade_if_needed
+        acquire_lock do
+          return unless upgrade_needed?
+
+          v2_to_v3_upgrade
+        end
+      rescue Redlock::LockError
+        fail 'A long running upgrade is in progress. Try restarting the application once finished'
+      end
+
+      def self.v2_to_v3_upgrade
+        logger.info('Starting sidekiq_queue_metrics v3 upgrade')
+
+        Sidekiq.redis_pool.with do |conn|
+          old_collected_metrics = JSON.load(conn.get(Helpers.stats_key))
+          old_collected_metrics.each do |(queue, stats)|
+            logger.info("Upgrading #{queue} statistics")
+
+            stats.each { |(stat, value)| Sidekiq::QueueMetrics::Storage.increment_stat(queue, stat, value) }
+
+            failed_jobs_key = Helpers.build_failed_jobs_key(queue)
+
+            if conn.exists(failed_jobs_key) && conn.type(failed_jobs_key) == 'string'
+              temporal_failed_key = "_#{failed_jobs_key}"
+
+              failed_jobs = JSON.parse(conn.get(Helpers.build_failed_jobs_key(queue)) || '[]')
+
+              conn.rename(failed_jobs_key, temporal_failed_key)
+
+              failed_jobs.each { |job| Sidekiq::QueueMetrics::Storage::add_failed_job(job) }
+
+              conn.del(temporal_failed_key)
+            end
+          end
+
+          conn.del(Helpers.stats_key)
+        end
+
+        logger.info("Sucessfully upgraded")
+      end
+
+      def self.upgrade_needed?
+        Sidekiq.redis_pool.with { |conn| conn.exists(Helpers.stats_key) }
+      end
+
+      def self.acquire_lock(&block)
+        Sidekiq.redis_pool.with do |conn|
+          lock_manager = Redlock::Client.new([conn], {
+            retry_count:   5,
+            retry_delay:   500,
+            retry_jitter:  150,  # milliseconds
+            redis_timeout: 0.1   # seconds
+          })
+          lock_manager.lock!('sidekiq_queue_metrics:upgrade_lock', 10000, &block)
+        end
+      end
+    end
+  end
+end

data/lib/sidekiq_queue_metrics/version.rb

@@ -1,5 +1,5 @@
 module Sidekiq
   module QueueMetrics
-    VERSION = '2.1.1'
+    VERSION = '3.0.0'
   end
 end

data/lib/sidekiq_queue_metrics/views/queue_summary.erb

@@ -60,11 +60,11 @@
       <td><%= job['class'] %></td>
       <td><%= job['args'].join(', ') %></td>
       <td>
-        <a href="<%= "/sidekiq/queue_metrics/queues/#{@queue}/jobs/#{job['jid']}" %>">
+        <a href="<%= "#{root_path}queue_metrics/queues/#{@queue}/jobs/#{job['jid']}" %>">
           <%= relative_time(Time.at(job['enqueued_at'])) %>
         </a>
       </td>
       <td><%= job['error_message'] %></td>
     </tr>
   <% end %>
-</table>
+</table>

data/lib/sidekiq_queue_metrics/views/queues_stats.erb

@@ -59,7 +59,7 @@
     <thead>
     <tr>
       <th>
-        <a href="<%= "/sidekiq/queue_metrics/queues/#{queue}/summary" %>">
+        <a href="<%= "#{root_path}queue_metrics/queues/#{queue}/summary" %>">
           <span class="heading"><%= queue %></span>
         </a>
       </th>
@@ -73,4 +73,4 @@
       </tr>
     <% end %>
   </table>
-<% end %>
+<% end %>

data/lib/sidekiq_queue_metrics/web_extension.rb

@@ -5,17 +5,11 @@ module Sidekiq::QueueMetrics
 
       app.get "/queue_metrics" do
         queue_metrics = Sidekiq::QueueMetrics.fetch
-        @@last_metrics ||= queue_metrics
-
-        @queue_metrics = queue_metrics.each_with_object({}) do |queue_metric, new_queue_metrics|
-          queue, metric = queue_metric
-          new_queue_metrics[queue] = metric.each_with_object({}) do |current_metric, updated_metrics|
-            name, count = current_metric
-            updated_metrics[name] = {'count' => count, 'animate' => @@last_metrics[queue][name] != count}
-          end
-        end
 
+        @@last_metrics ||= queue_metrics
+        @queue_metrics = Helpers.build_metrics_for_view(@@last_metrics, queue_metrics)
         @@last_metrics = queue_metrics
+
         render(:erb, File.read(File.join(view_path, "queues_stats.erb")))
       end
 
@@ -35,4 +29,4 @@ module Sidekiq::QueueMetrics
       end
     end
   end
-end
+end

data/sidekiq_queue_metrics.gemspec

@@ -17,8 +17,11 @@ Gem::Specification.new do |s|
   s.test_files                  =   s.files.grep(%r{^(test|spec|features)/})
   s.require_paths               =   ["lib"]
 
-  s.add_dependency                  'sidekiq', '>= 5.1'
+  s.add_dependency                  'sidekiq'
   s.add_dependency                  'eldritch'
-  s.add_development_dependency      "bundler", "~> 1.5"
+  s.add_dependency                  'redlock'
+
+  s.add_development_dependency      'bundler', '~> 1.5'
   s.add_development_dependency      'rspec'
+  s.add_development_dependency      'fakeredis'
 end

data/spec/lib/sidekiq_queue_metrics/helpers_spec.rb

@@ -0,0 +1,107 @@
+describe Sidekiq::QueueMetrics::Helpers do
+  describe '.build_queue_stats_key' do
+    context 'with default storage location' do
+      it 'should return the name of the key where metrics are stored for a given queue' do
+        expect(subject.build_queue_stats_key('test')).to eql('queue_stats:test')
+      end
+    end
+
+    context 'with a different storage location' do
+      before { Sidekiq::QueueMetrics.storage_location = 'different_storage_location' }
+      after  { Sidekiq::QueueMetrics.storage_location = nil}
+
+      it 'should return the name of the key where metrics are stored for a given queue' do
+        expect(subject.build_queue_stats_key('test')).to eql('different_storage_location:test')
+      end
+    end
+  end
+
+  describe '.build_failed_jobs_key' do
+    it 'should return the name of the key where failed jobs are stored for a given queue' do
+      expect(subject.build_failed_jobs_key('test')).to eql('failed_jobs:test')
+    end
+  end
+
+  describe '.build_metrics_for_view' do
+    context 'when there is no changes' do
+      let(:last_metrics) {{
+        'mailer_queue' => {
+          'processed' => 3
+        }
+      }}
+      let(:current_metrics) {{
+        'mailer_queue' => {
+          'processed' => 3
+        }
+      }}
+
+      it 'should add an animate key and a count with the same metric value' do
+        expected_result = {
+          'mailer_queue' => {
+            'processed' => { 'count' => 3, 'animate' => false }
+          }
+        }
+
+        expect(
+          subject.build_metrics_for_view(last_metrics, current_metrics)
+        ).to eql(expected_result)
+      end
+    end
+
+    context 'when only values are changed' do
+      let(:last_metrics) {{
+        'mailer_queue' => {
+          'processed' => 3
+        }
+      }}
+      let(:current_metrics) {{
+        'mailer_queue' => {
+          'processed' => 4
+        }
+      }}
+
+      it 'should add an animate key and a count with the last metric value' do
+        expected_result = {
+          'mailer_queue' => {
+            'processed' => { 'count' => 4, 'animate' => true }
+          }
+        }
+
+        expect(
+          subject.build_metrics_for_view(last_metrics, current_metrics)
+        ).to eql(expected_result)
+      end
+    end
+
+    context' when a new queue is added' do
+      let(:last_metrics) {{
+        'mailer_queue' => {
+          'processed' => 3
+        }
+      }}
+      let(:current_metrics) {{
+        'mailer_queue' => {
+          'processed' => 4
+        },
+        'new_queue' => {
+          'failed' => 1
+        }
+      }}
+
+      it 'should add the new queue' do
+        expected_result = {
+          'mailer_queue' => {
+            'processed' => { 'count' => 4, 'animate' => true }
+          },
+          'new_queue' => {
+            'failed' => { 'count' => 1, 'animate' => false }
+          }
+        }
+
+        expect(
+          subject.build_metrics_for_view(last_metrics, current_metrics)
+        ).to eql(expected_result)
+      end
+    end
+  end
+end

data/spec/lib/sidekiq_queue_metrics/job_death_middleware_spec.rb

@@ -0,0 +1,39 @@
+describe Sidekiq::QueueMetrics::JobDeathMiddleware do
+  let(:redis_connection) { Redis.new }
+
+  before(:all) do
+    Sidekiq.redis = ConnectionPool.new { redis_connection }
+  end
+
+  before { redis_connection.flushall }
+
+  context 'when retry_count key is not present' do
+    it 'should call the job dead monitor' do
+      expect_any_instance_of(Sidekiq::QueueMetrics::JobDeathMonitor).not_to receive(:monitor)
+
+      subject.call(Class.new, {}, 'test_queue')
+    end
+  end
+
+  context 'when retry_count key is greater than 0' do
+    it 'should call the job dead monitor' do
+      expect_any_instance_of(Sidekiq::QueueMetrics::JobDeathMonitor).not_to receive(:monitor)
+
+      subject.call(Class.new, { 'retry_count' => 1 }, 'test_queue')
+    end
+  end
+
+  context 'when retry_count key is 0' do
+    it 'should call the job dead monitor' do
+      expect_any_instance_of(Sidekiq::QueueMetrics::JobDeathMonitor).to receive(:monitor).with({
+        'retry_count' => 0,
+        'error_class' => 'StandardError'
+      })
+
+      subject.call(Class.new, {
+        'retry_count' => 0,
+        'error_class' => 'StandardError'
+      }, 'test_queue')
+    end
+  end
+end

data/spec/lib/sidekiq_queue_metrics/monitor/job_death_monitor_spec.rb

@@ -1,53 +1,70 @@
 describe Sidekiq::QueueMetrics::JobDeathMonitor do
+  let(:redis_connection) { Redis.new }
+
+  before(:all) do
+    Sidekiq.redis = ConnectionPool.new { redis_connection }
+  end
+
+  before { redis_connection.flushall }
+
   describe '#call' do
     let(:job) {{'queue' => 'mailer_queue'}}
-    let(:exception) {double('exception')}
-    let(:monitor) {Sidekiq::QueueMetrics::JobDeathMonitor.proc}
+    let(:monitor) { Sidekiq::QueueMetrics::JobDeathMonitor.proc }
 
     context 'when stats does not exist' do
       it 'should create stats key and add stats of queue' do
-        expect(Sidekiq::QueueMetrics::Storage).to receive(:get_stats).and_return(nil)
-        expect(Sidekiq::QueueMetrics::Storage).to receive(:set_stats).with({mailer_queue: {failed: 1}}.to_json)
-        expect(Sidekiq::QueueMetrics::Storage).to receive(:add_failed_job).with(job)
+        monitor.call(job)
+
+        expect(
+          Sidekiq::QueueMetrics::Storage.get_stats('mailer_queue')
+        ).to eq({ 'failed' => 1 })
+      end
 
+      it 'should add the job to the failed jobs list' do
         monitor.call(job)
+
+        expect(
+          Sidekiq::QueueMetrics::Storage.failed_jobs('mailer_queue')
+        ).to eql([job])
       end
     end
 
     context 'when stats exists' do
       it 'should create a new queue when it does not exist' do
-        job_queue = {'queue' => 'job_queue'}
-        existing_stats = {mailer_queue: {failed: 1}}.to_json
-        expected_stats = {mailer_queue: {failed: 1}, job_queue: {failed: 1}}.to_json
+        Sidekiq::QueueMetrics::Storage.increment_stat('mailer_queue', 'failed')
 
-        expect(Sidekiq::QueueMetrics::Storage).to receive(:get_stats).and_return(existing_stats)
-        expect(Sidekiq::QueueMetrics::Storage).to receive(:set_stats).with(expected_stats)
-        expect(Sidekiq::QueueMetrics::Storage).to receive(:add_failed_job).with(job_queue)
+        job_queue = {'queue' => 'job_queue'}
 
         monitor.call(job_queue)
+
+        expect(
+          Sidekiq::QueueMetrics::Storage.get_stats('mailer_queue')
+        ).to eq({ 'failed' => 1 })
+
+        expect(
+          Sidekiq::QueueMetrics::Storage.get_stats('job_queue')
+        ).to eq({ 'failed' => 1 })
       end
 
       it 'should update existing queue' do
-        existing_stats = {mailer_queue: {failed: 1}}.to_json
-        expected_stats = {mailer_queue: {failed: 2}}.to_json
-
-        expect(Sidekiq::QueueMetrics::Storage).to receive(:get_stats).and_return(existing_stats)
-        expect(Sidekiq::QueueMetrics::Storage).to receive(:set_stats).with(expected_stats)
-        expect(Sidekiq::QueueMetrics::Storage).to receive(:add_failed_job).with(job)
+        Sidekiq::QueueMetrics::Storage.increment_stat('mailer_queue', 'failed')
 
         monitor.call(job)
+
+        expect(
+          Sidekiq::QueueMetrics::Storage.get_stats('mailer_queue')
+        ).to eq({ 'failed' => 2 })
       end
 
       it 'should create failed counter when other counters exists' do
-        existing_stats = {mailer_queue: {processed: 1}}.to_json
-        expected_stats = {mailer_queue: {processed: 1, failed: 1}}.to_json
-
-        expect(Sidekiq::QueueMetrics::Storage).to receive(:get_stats).and_return(existing_stats)
-        expect(Sidekiq::QueueMetrics::Storage).to receive(:set_stats).with(expected_stats)
-        expect(Sidekiq::QueueMetrics::Storage).to receive(:add_failed_job).with(job)
+        Sidekiq::QueueMetrics::Storage.increment_stat('mailer_queue', 'processed')
 
         monitor.call(job)
+
+        expect(
+          Sidekiq::QueueMetrics::Storage.get_stats('mailer_queue')
+        ).to eq({ 'processed' => 1, 'failed' => 1 })
       end
     end
   end
-end
+end

data/spec/lib/sidekiq_queue_metrics/monitor/job_success_monitor_spec.rb

@@ -1,48 +1,62 @@
 describe Sidekiq::QueueMetrics::JobSuccessMonitor do
+  let(:redis_connection) { Redis.new }
+
+  let(:worker) { double(:worker) }
+  let(:job) { double(:job) }
+
+  before(:all) do
+    Sidekiq.redis = ConnectionPool.new { redis_connection }
+  end
+
+  before { redis_connection.flushall }
+
   describe '#call' do
-    let(:job) {double('job')}
-    let(:worker) {double('worker')}
-    let(:monitor) {Sidekiq::QueueMetrics::JobSuccessMonitor.new}
+    let(:monitor) { Sidekiq::QueueMetrics::JobSuccessMonitor.new }
 
     context 'when stats does not exist' do
       it 'should create stats key and add stats of queue' do
-        expect(Sidekiq::QueueMetrics::Storage).to receive(:get_stats).and_return(nil)
-        expect(Sidekiq::QueueMetrics::Storage).to receive(:set_stats).with({mailer_queue: {processed: 1}}.to_json)
-
         monitor.call(worker, job, 'mailer_queue')
+
+        expect(
+          Sidekiq::QueueMetrics::Storage.get_stats('mailer_queue')
+        ).to eq({ 'processed' => 1 })
       end
     end
 
     context 'when stats exists' do
       it 'should create a new queue when it does not exist' do
-        existing_stats = {mailer_queue: {processed: 1}}.to_json
-        expected_stats = {mailer_queue: {processed: 1}, job_queue: {processed: 1}}.to_json
-
-        expect(Sidekiq::QueueMetrics::Storage).to receive(:get_stats).and_return(existing_stats)
-        expect(Sidekiq::QueueMetrics::Storage).to receive(:set_stats).with(expected_stats)
+        Sidekiq::QueueMetrics::Storage.increment_stat('mailer_queue', 'processed')
 
         monitor.call(worker, job, 'job_queue')
+
+        expect(
+          Sidekiq::QueueMetrics::Storage.get_stats('mailer_queue')
+        ).to eq({ 'processed' => 1 })
+
+        expect(
+          Sidekiq::QueueMetrics::Storage.get_stats('job_queue')
+        ).to eq({ 'processed' => 1 })
       end
 
       it 'should update existing queue' do
-        existing_stats = {mailer_queue: {processed: 1}}.to_json
-        expected_stats = {mailer_queue: {processed: 2}}.to_json
-
-        expect(Sidekiq::QueueMetrics::Storage).to receive(:get_stats).and_return(existing_stats)
-        expect(Sidekiq::QueueMetrics::Storage).to receive(:set_stats).with(expected_stats)
+        Sidekiq::QueueMetrics::Storage.increment_stat('mailer_queue', 'processed')
 
         monitor.call(worker, job, 'mailer_queue')
+
+        expect(
+          Sidekiq::QueueMetrics::Storage.get_stats('mailer_queue')
+        ).to eq({ 'processed' => 2 })
       end
 
       it 'should create failed counter when other counters exists' do
-        existing_stats = {mailer_queue: {failed: 1}}.to_json
-        expected_stats = {mailer_queue: {failed: 1, processed: 1}}.to_json
-
-        expect(Sidekiq::QueueMetrics::Storage).to receive(:get_stats).and_return(existing_stats)
-        expect(Sidekiq::QueueMetrics::Storage).to receive(:set_stats).with(expected_stats)
+        Sidekiq::QueueMetrics::Storage.increment_stat('mailer_queue', 'failed')
 
         monitor.call(worker, job, 'mailer_queue')
+
+        expect(
+          Sidekiq::QueueMetrics::Storage.get_stats('mailer_queue')
+        ).to eq({ 'processed' => 1, 'failed' => 1 })
       end
     end
   end
-end
+end

data/spec/lib/sidekiq_queue_metrics/queue_metrics_spec.rb

@@ -1,4 +1,38 @@
 describe Sidekiq::QueueMetrics do
+  let(:redis_connection) { Redis.new }
+
+  before(:all) do
+    Sidekiq.redis = ConnectionPool.new { redis_connection }
+  end
+
+  before { redis_connection.flushall }
+
+  describe '#init' do
+    if Sidekiq::QueueMetrics.support_death_handlers?
+      it 'attach the expected listeners for failed job' do
+        Sidekiq::QueueMetrics.init(Sidekiq)
+
+        expect(Sidekiq.death_handlers).to_not be_empty
+      end
+
+      it 'doesn\'t attach the JobDeathMiddleware to the server middleware chain' do
+        Sidekiq::QueueMetrics.init(Sidekiq)
+
+        expect(
+          Sidekiq.server_middleware.entries.select { |x| x.klass == Sidekiq::QueueMetrics::JobDeathMiddleware }
+        ).to be_empty
+      end
+    else
+      it 'attach the JobDeathMiddleware to the server middleware chain' do
+        Sidekiq::QueueMetrics.init(Sidekiq)
+
+        expect(
+          Sidekiq.server_middleware.entries.select { |x| x.klass == Sidekiq::QueueMetrics::JobDeathMiddleware }
+        ).not_to be_empty
+      end
+    end
+  end
+
   describe '#fetch' do
     before(:each) do
       queues = [OpenStruct.new(name: :mailer_queue), OpenStruct.new(name: :heavy_jobs_queue)]
@@ -6,13 +40,22 @@ describe Sidekiq::QueueMetrics do
     end
 
     it 'should fetch current queue stats' do
-      stats = {mailer_queue: {processed: 2, failed: 1}, heavy_jobs_queue: {processed: 1, failed: 0}}
-      jobs_in_retry_queue = [OpenStruct.new(queue: 'mailer_queue'), OpenStruct.new(queue: 'heavy_jobs_queue')]
-      scheduled_jobs = [OpenStruct.new(queue: 'mailer_queue'), OpenStruct.new(queue: 'heavy_jobs_queue')]
+      Sidekiq::QueueMetrics::Storage.increment_stat('mailer_queue', 'processed', 2)
+      Sidekiq::QueueMetrics::Storage.increment_stat('mailer_queue', 'failed')
+      Sidekiq::QueueMetrics::Storage.increment_stat('heavy_jobs_queue', 'processed')
+
+      jobs_in_retry_queue = [
+        OpenStruct.new(queue: 'mailer_queue'),
+        OpenStruct.new(queue: 'heavy_jobs_queue')
+      ]
+      scheduled_jobs = [
+        OpenStruct.new(queue: 'mailer_queue'),
+        OpenStruct.new(queue: 'heavy_jobs_queue')
+      ]
 
-      expect(Sidekiq::QueueMetrics::Storage).to receive(:get_stats).and_return(stats.to_json)
       expect(Sidekiq::RetrySet).to receive(:new).and_return(jobs_in_retry_queue)
       expect(Sidekiq::ScheduledSet).to receive(:new).and_return(scheduled_jobs)
+
       expect(Sidekiq::Queue).to receive(:new).with('mailer_queue').and_return(OpenStruct.new(size: 1))
       expect(Sidekiq::Queue).to receive(:new).with('heavy_jobs_queue').and_return(OpenStruct.new(size: 1))
 
@@ -32,12 +75,14 @@ describe Sidekiq::QueueMetrics do
     end
 
     it 'should have default value as zero' do
-      stats = {mailer_queue: {processed: 2}, heavy_jobs_queue: {failed: 1}}
+      Sidekiq::QueueMetrics::Storage.increment_stat('mailer_queue', 'processed', 2)
+      Sidekiq::QueueMetrics::Storage.increment_stat('heavy_jobs_queue', 'failed')
+
       scheduled_jobs = jobs_in_retry_queue = []
 
-      expect(Sidekiq::QueueMetrics::Storage).to receive(:get_stats).and_return(stats.to_json)
       expect(Sidekiq::RetrySet).to receive(:new).and_return(jobs_in_retry_queue)
       expect(Sidekiq::ScheduledSet).to receive(:new).and_return(scheduled_jobs)
+
       expect(Sidekiq::Queue).to receive(:new).with('mailer_queue').and_return(OpenStruct.new(size: 0))
       expect(Sidekiq::Queue).to receive(:new).with('heavy_jobs_queue').and_return(OpenStruct.new(size: 0))
 
@@ -53,7 +98,6 @@ describe Sidekiq::QueueMetrics do
     it 'should return Sidekiq::QueueMetrics for all sidekiq queues' do
       jobs_in_retry_queue = scheduled_jobs = []
 
-      expect(Sidekiq::QueueMetrics::Storage).to receive(:get_stats).and_return(nil)
       expect(Sidekiq::RetrySet).to receive(:new).and_return(jobs_in_retry_queue)
       expect(Sidekiq::ScheduledSet).to receive(:new).and_return(scheduled_jobs)
       expect(Sidekiq::Queue).to receive(:new).with('mailer_queue').and_return(OpenStruct.new(size: 0))
@@ -78,11 +122,14 @@ describe Sidekiq::QueueMetrics do
   describe '#failed_jobs' do
     it 'should return failed jobs for a queue' do
       queue = 'default_queue'
-      job_1 = double(:job)
-      job_2 = double(:job)
-      expect(Sidekiq::QueueMetrics::Storage).to receive(:failed_jobs).and_return([job_1, job_2])
 
-      expect(Sidekiq::QueueMetrics.failed_jobs(queue)).to eq([job_2, job_1])
+      job_1 = {'queue' => queue, 'args' => [1]}
+      job_2 = {'queue' => queue, 'args' => [2]}
+
+      Sidekiq::QueueMetrics::Storage.add_failed_job(job_1)
+      Sidekiq::QueueMetrics::Storage.add_failed_job(job_2)
+
+      expect(Sidekiq::QueueMetrics.failed_jobs(queue)).to eq([job_1, job_2])
     end
   end
-end
+end

data/spec/lib/sidekiq_queue_metrics/storage_spec.rb

@@ -1,82 +1,52 @@
 describe Sidekiq::QueueMetrics::Storage do
-  class MockRedisPool
-    attr_reader :conn
+  let(:redis_connection) { Redis.new }
+  let(:queue) { 'mailer_queue' }
+  let(:job) { {'queue' => queue, 'args' => [1]} }
 
-    def initialize(conn)
-      @conn = conn
-    end
-
-    def with
-      yield conn
-    end
+  before(:all) do
+    Sidekiq.redis = ConnectionPool.new { redis_connection }
   end
 
-  let(:mock_redis_conn) {double(:connection)}
-  let(:mock_redis_pool) {MockRedisPool.new(mock_redis_conn)}
+  before { redis_connection.flushall }
 
   describe '#add_failed_job' do
     it 'should add first failed job' do
-      job = {'queue' => 'mailer_queue'}
-      expect(Sidekiq).to receive(:redis_pool).and_return(mock_redis_pool)
-      expect(mock_redis_conn).to receive(:get).with("failed_jobs:mailer_queue").and_return(nil)
-
-      expect(mock_redis_conn).to receive(:set).with("failed_jobs:mailer_queue", [job].to_json)
-
-      Sidekiq::QueueMetrics::Storage.add_failed_job(job)
+      expect do
+        Sidekiq::QueueMetrics::Storage.add_failed_job(job)
+      end.to change{ Sidekiq::QueueMetrics::Storage.failed_jobs(queue).length }.from(0).to(1)
     end
 
     it 'should add failed job to existing jobs' do
-      key = "failed_jobs:mailer_queue"
-      new_job = {'queue' => 'mailer_queue', 'args' => [1]}
-      existing_jobs = [{'queue' => 'mailer_queue', 'args' => [2]}]
-
-      expect(Sidekiq).to receive(:redis_pool).and_return(mock_redis_pool)
-      expect(mock_redis_conn).to receive(:get).with(key).and_return(existing_jobs.to_json)
-
-      expect(mock_redis_conn).to receive(:set).with(key, [existing_jobs.first, new_job].to_json)
+      Sidekiq::QueueMetrics::Storage.add_failed_job(job)
 
-      Sidekiq::QueueMetrics::Storage.add_failed_job(new_job)
+      expect do
+        Sidekiq::QueueMetrics::Storage.add_failed_job({'queue' => queue, 'args' => [2]})
+      end.to change{ Sidekiq::QueueMetrics::Storage.failed_jobs(queue).length }.from(1).to(2)
     end
 
     it 'should delete old job when failed jobs limit has reached' do
-      key = "failed_jobs:mailer_queue"
-      new_job = {'queue' => 'mailer_queue', 'args' => [1]}
-      oldest_job = {'queue' => 'mailer_queue', 'args' => [2]}
-      older_job = {'queue' => 'mailer_queue', 'args' => [3]}
-
-      existing_jobs = [oldest_job, older_job]
-
-      expect(Sidekiq).to receive(:redis_pool).and_return(mock_redis_pool)
-      expect(mock_redis_conn).to receive(:get).with(key).and_return(existing_jobs.to_json)
-
-      expect(mock_redis_conn).to receive(:set).with(key, [older_job, new_job].to_json)
+      Sidekiq::QueueMetrics::Storage.add_failed_job(job)
+      Sidekiq::QueueMetrics::Storage.add_failed_job({'queue' => queue, 'args' => [2]})
 
-      Sidekiq::QueueMetrics::Storage.add_failed_job(new_job, 2)
+      expect do
+        Sidekiq::QueueMetrics::Storage.add_failed_job({'queue' => queue, 'args' => [3]}, 2)
+      end.to_not change { Sidekiq::QueueMetrics::Storage.failed_jobs(queue).length }
     end
   end
 
   describe '#failed_jobs' do
     context 'when failed jobs are not present' do
       it 'should return failed jobs for a given queue' do
-        queue = 'mailer_queue'
-        expect(Sidekiq).to receive(:redis_pool).and_return(mock_redis_pool)
-
-        expect(mock_redis_conn).to receive(:get).with("failed_jobs:#{queue}").and_return(nil)
-
         expect(Sidekiq::QueueMetrics::Storage.failed_jobs(queue)).to be_empty
       end
     end
 
     context 'when failed jobs are present' do
       it 'should return failed jobs for a given queue' do
-        queue = 'mailer_queue'
-        jobs = [{'queue' => 'mailer_queue', 'args' => [1]}]
-        expect(Sidekiq).to receive(:redis_pool).and_return(mock_redis_pool)
-
-        expect(mock_redis_conn).to receive(:get).with("failed_jobs:#{queue}").and_return(jobs.to_json)
+        Sidekiq::QueueMetrics::Storage.add_failed_job(job)
 
-        expect(Sidekiq::QueueMetrics::Storage.failed_jobs(queue)).to eq(jobs)
+        expect(Sidekiq::QueueMetrics::Storage.failed_jobs(queue)).to eq([job])
       end
     end
   end
-end
+end

data/spec/lib/sidekiq_queue_metrics/upgrade_manager_spec.rb

@@ -0,0 +1,87 @@
+describe Sidekiq::QueueMetrics::UpgradeManager do
+  let(:redis_connection) { Redis.new }
+
+  before(:all) do
+    Sidekiq.redis = ConnectionPool.new { redis_connection }
+  end
+
+  before { redis_connection.flushall }
+
+  describe 'upgrading to v3' do
+    let(:old_queue_stats) {{
+      'mailer_queue' => {
+        'failed' => 1,
+        'processed' => 3
+      },
+      'other_queue' => {
+        'failed' => 1,
+        'processed' => 143
+      }
+    }}
+
+    let(:failed_jobs_mailer_queue) {
+      [{ 'queue' => 'mailer_queue', 'args' => [1]}]
+    }
+
+    let(:failed_jobs_other_queue) {
+      [{ 'queue' => 'other_queue', 'args' => [2]}]
+    }
+
+    describe '.v2_to_v3_upgrade' do
+      before do
+        redis_connection.set(Sidekiq::QueueMetrics::Helpers.stats_key, JSON.generate(old_queue_stats))
+        redis_connection.set(Sidekiq::QueueMetrics::Helpers.build_failed_jobs_key('mailer_queue'), JSON.generate(failed_jobs_mailer_queue))
+        redis_connection.set(Sidekiq::QueueMetrics::Helpers.build_failed_jobs_key('other_queue'), JSON.generate(failed_jobs_other_queue))
+      end
+
+      it 'should delete the old stats key' do
+        Sidekiq::QueueMetrics::UpgradeManager.v2_to_v3_upgrade
+
+        expect(redis_connection.exists(Sidekiq::QueueMetrics::Helpers.stats_key)).to be_falsey
+      end
+
+      it 'should set the previous values into the new stats format' do
+        Sidekiq::QueueMetrics::UpgradeManager.v2_to_v3_upgrade
+
+        mailer_queue_stats = Sidekiq::QueueMetrics::Storage.get_stats('mailer_queue')
+        other_queue_stats = Sidekiq::QueueMetrics::Storage.get_stats('other_queue')
+
+        expect(mailer_queue_stats['processed']).to be(3)
+        expect(mailer_queue_stats['failed']).to be(1)
+
+        expect(other_queue_stats['processed']).to be(143)
+        expect(other_queue_stats['failed']).to be(1)
+      end
+
+      it 'should add the failed jobs into the same key with new format' do
+        Sidekiq::QueueMetrics::UpgradeManager.v2_to_v3_upgrade
+
+        expect(Sidekiq::QueueMetrics::Storage.failed_jobs('mailer_queue')).to eql(failed_jobs_mailer_queue)
+        expect(Sidekiq::QueueMetrics::Storage.failed_jobs('other_queue')).to eql(failed_jobs_other_queue)
+      end
+
+      it 'should delete temporal failed jobs keys' do
+        mailer_temporal_key =  "_#{Sidekiq::QueueMetrics::Helpers.build_failed_jobs_key('mailer_queue')}"
+        other_temporal_key  =  "_#{Sidekiq::QueueMetrics::Helpers.build_failed_jobs_key('other_queue')}"
+
+        Sidekiq::QueueMetrics::UpgradeManager.v2_to_v3_upgrade
+
+        expect(redis_connection.exists(mailer_temporal_key)).to be_falsey
+        expect(redis_connection.exists(other_temporal_key)).to be_falsey
+      end
+    end
+
+    describe '.upgrade_needed?' do
+      it 'should be true if the old queue stats key exists' do
+        redis_connection.set(Sidekiq::QueueMetrics::Helpers.stats_key, JSON.generate(old_queue_stats))
+
+        expect(Sidekiq::QueueMetrics::UpgradeManager.upgrade_needed?).to be_truthy
+      end
+
+      it 'should be false if the old queue stats key is not set' do
+        expect(Sidekiq::QueueMetrics::UpgradeManager.upgrade_needed?).to be_falsey
+      end
+    end
+  end
+end
+

data/spec/spec_helper.rb

@@ -15,6 +15,8 @@
 # See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
 #
 
+require 'fakeredis/rspec'
+
 require './lib/sidekiq_queue_metrics'
 
 RSpec.configure do |config|

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sidekiq_queue_metrics
 version: !ruby/object:Gem::Version
-  version: 2.1.1
+  version: 3.0.0
 platform: ruby
 authors:
 - Ajit Singh
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-06-11 00:00:00.000000000 Z
+date: 2019-11-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: sidekiq
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '5.1'
+        version: '0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '5.1'
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: eldritch
   requirement: !ruby/object:Gem::Requirement
@@ -38,6 +38,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: redlock
+  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
@@ -66,6 +80,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: fakeredis
+  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: 
 email: jeetsingh.ajit@gamil.com
 executables: []
@@ -76,26 +104,31 @@ files:
 - ".rspec"
 - ".travis.yml"
 - Gemfile
-- Gemfile.lock
 - LICENSE
 - README.md
 - lib/sidekiq_queue_metrics.rb
 - lib/sidekiq_queue_metrics/configuration.rb
+- lib/sidekiq_queue_metrics/helpers.rb
+- lib/sidekiq_queue_metrics/job_death_middleware.rb
 - lib/sidekiq_queue_metrics/monitor/job_death_monitor.rb
 - lib/sidekiq_queue_metrics/monitor/job_success_monitor.rb
 - lib/sidekiq_queue_metrics/monitor/monitor.rb
 - lib/sidekiq_queue_metrics/queue_metrics.rb
 - lib/sidekiq_queue_metrics/storage.rb
+- lib/sidekiq_queue_metrics/upgrade_manager.rb
 - lib/sidekiq_queue_metrics/version.rb
 - lib/sidekiq_queue_metrics/views/failed_job.erb
 - lib/sidekiq_queue_metrics/views/queue_summary.erb
 - lib/sidekiq_queue_metrics/views/queues_stats.erb
 - lib/sidekiq_queue_metrics/web_extension.rb
 - sidekiq_queue_metrics.gemspec
+- spec/lib/sidekiq_queue_metrics/helpers_spec.rb
+- spec/lib/sidekiq_queue_metrics/job_death_middleware_spec.rb
 - spec/lib/sidekiq_queue_metrics/monitor/job_death_monitor_spec.rb
 - spec/lib/sidekiq_queue_metrics/monitor/job_success_monitor_spec.rb
 - spec/lib/sidekiq_queue_metrics/queue_metrics_spec.rb
 - spec/lib/sidekiq_queue_metrics/storage_spec.rb
+- spec/lib/sidekiq_queue_metrics/upgrade_manager_spec.rb
 - spec/spec_helper.rb
 homepage: https://github.com/ajitsing/sidekiq_queue_metrics
 licenses:
@@ -116,14 +149,16 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.7.6
+rubygems_version: 3.0.4
 signing_key: 
 specification_version: 4
 summary: Records stats of each sidekiq queue and exposes APIs to retrieve them
 test_files:
+- spec/lib/sidekiq_queue_metrics/helpers_spec.rb
+- spec/lib/sidekiq_queue_metrics/job_death_middleware_spec.rb
 - spec/lib/sidekiq_queue_metrics/monitor/job_death_monitor_spec.rb
 - spec/lib/sidekiq_queue_metrics/monitor/job_success_monitor_spec.rb
 - spec/lib/sidekiq_queue_metrics/queue_metrics_spec.rb
 - spec/lib/sidekiq_queue_metrics/storage_spec.rb
+- spec/lib/sidekiq_queue_metrics/upgrade_manager_spec.rb
 - spec/spec_helper.rb

data/Gemfile.lock

@@ -1,42 +0,0 @@
-GEM
-  remote: http://rubygems.org/
-  specs:
-    concurrent-ruby (1.0.5)
-    connection_pool (2.2.2)
-    diff-lcs (1.3)
-    eldritch (1.1.3)
-      reentrant_mutex (~> 1.1.0)
-    rack (2.0.6)
-    rack-protection (2.0.3)
-      rack
-    redis (4.0.1)
-    reentrant_mutex (1.1.1)
-    rspec (3.7.0)
-      rspec-core (~> 3.7.0)
-      rspec-expectations (~> 3.7.0)
-      rspec-mocks (~> 3.7.0)
-    rspec-core (3.7.1)
-      rspec-support (~> 3.7.0)
-    rspec-expectations (3.7.0)
-      diff-lcs (>= 1.2.0, < 2.0)
-      rspec-support (~> 3.7.0)
-    rspec-mocks (3.7.0)
-      diff-lcs (>= 1.2.0, < 2.0)
-      rspec-support (~> 3.7.0)
-    rspec-support (3.7.1)
-    sidekiq (5.1.3)
-      concurrent-ruby (~> 1.0)
-      connection_pool (~> 2.2, >= 2.2.0)
-      rack-protection (>= 1.5.0)
-      redis (>= 3.3.5, < 5)
-
-PLATFORMS
-  ruby
-
-DEPENDENCIES
-  eldritch
-  rspec
-  sidekiq
-
-BUNDLED WITH
-   1.16.1