sidekiq-heartbeat_monitor 1.0.1.3 → 1.0.3.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 32691642cb604f14ad8fcc6cadc317a8a356d201
-  data.tar.gz: af0b75205599503299429ac630db2b38b0f27191
+SHA256:
+  metadata.gz: 950196b2ee9086c4602b7f096e4232ce711c4c6497e3c03c32e826b1e45a3ff0
+  data.tar.gz: 87a287d6d732765595cc8d7bee466938c3ad0f781d2446c757d909f06c01147e
 SHA512:
-  metadata.gz: 0fe5aa64d312740c5ab8b2b39f7c89c08b83a73a23bd541df09687cae39f435e48e3580aa4ed19e8f18106697d50f49b6bf353c945d52ae56e37f114889c8239
-  data.tar.gz: 0dcdbceba1da143d423b1b9c4d191b61d54460bf469055939d9135e26c1f08ea6f9a5723e18e30054e01f1a6bc2938f8aae2ab47e3627320ee716ffd00797f82
+  metadata.gz: 20f6ca5e135ec7217e54739f75c6409bb01711158a2afda20c2cf428aae1842057c8741d273ef186fc96bd1a720edbcd27ec9eb7e796dd878439d256e380918f
+  data.tar.gz: 104b87bce693e0908e2c4caf9285eadd6bc8e2600b220559465010df1b7db1f8d06960db3b3643b159f95b34da0a2f4766a06174b966f9cd3b4ca9339c24bc1d

data/README.md

@@ -21,6 +21,14 @@ Or install it yourself as:
 
 **Configuration is required - see the Configuration section below**
 
+### (Optional) Install Cron Task
+The gem will automatically try to install your cron task when you run your sidekiq server, however if for some reason it does not install the cron task
+then you can install it manually using the available rake task command:
+```
+rake sidekiq::heartbeat_monitor:install
+```
+
+
 ### Requirements
 1. [Dont Repeat For Gem](https://www.github.com/jayelkaake/dont_repeat_for) - To allow you to only send notifications every so often.
 2. Redis
@@ -73,5 +81,10 @@ Bug reports and pull requests are welcome on GitHub at https://github.com/jayelk
 This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to
 adhere to the [Contributor Covenant](contributor-covenant.org) code of conduct.
 
+### Supported versions
+Battle-tested @ [Fera.ai](https://www.fera.ai) with:
+* Ruby 2.4 - 2.6.7 (but up to 3.0 should be fine)
+* Sidekiq 3-5
+
 ### License
 The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).

data/lib/sidekiq/heartbeat_monitor.rb

@@ -1,29 +1,42 @@
 require "sidekiq"
 require 'sidekiq/heartbeat_monitor/version'
 require 'sidekiq/heartbeat_monitor/config'
+require 'sidekiq/heartbeat_monitor/util'
 require 'sidekiq/heartbeat_monitor/scheduler'
 require 'sidekiq/heartbeat_monitor/worker'
+require 'sidekiq/heartbeat_monitor/test_worker'
+
+require 'sidekiq/heartbeat_monitor/railtie' if defined?(Rails)
+
 
 module Sidekiq
   module HeartbeatMonitor
-    def self.configure(*args, &block)
-      Config.configure(*args, &block)
-    end
+    def self.configure(options = {})
+      options = options.symbolize_keys
+      global_options = options.except(:queues)
 
-    def self.send_backed_up_alert(*args, &block)
-      Config.send_backed_up_alert(*args, &block)
+      @global_config = Config.new(**global_options)
+
+      @queue_config = {}
+      options[:queues].to_a.each do |queue_name, queue_options|
+        @queue_config[queue_name.to_s] = Config.new(**global_options.deep_merge(queue_options))
+      end
     end
 
-    def self.send_slowed_down_alert(*args, &block)
-      Config.send_slowed_down_alert(*args, &block)
+    def self.config(queue = nil)
+      return @global_config if queue.blank?
+
+      queue_name = queue.is_a?(String) || queue.is_a?(Symbol) ? queue.to_s : queue.name.to_s
+      @queue_config.to_h[queue_name] || @global_config
     end
 
-    def self.send_test!
-      test_queue = Sidekiq::Queue.new('test')
+    def self.send_test!(queue_name = nil)
+      test_queue = Sidekiq::Queue.new(queue_name || 'test')
 
       send_backed_up_alert("Test backed up alert!", test_queue)
       send_slowed_down_alert("Test slowed down alert!", test_queue)
     end
+
   end
 end
 

data/lib/sidekiq/heartbeat_monitor/config.rb

@@ -2,73 +2,127 @@ require 'sidekiq/cron/job'
 module Sidekiq
   module HeartbeatMonitor
     class Config
-      class << self
-        def configure(max_queue_size: nil, on_backed_up: nil, on_slowed_down: nil, dont_repeat_for: nil, slack_notifier_url: nil)
-          @max_queue_size = max_queue_size unless max_queue_size.nil?
+      attr_accessor :max_queue_size, :max_heartbeat_delay
 
-          @dont_repeat_for = dont_repeat_for unless dont_repeat_for.nil?
+      ##
+      # @param max_queue_size [Integer]       The maximum queue size (default: 5000 or SIDEKIQ_MONITOR_MAX_QUEUE_SIZE environment value)
+      # @param on_backed_up [Proc|Array<Proc>]        On backed up run this or these procs
+      # @param on_slowed_down [Proc|Array<Proc>]      On slowed down run this or these procs
+      # @param dont_repeat_for [Integer]     The don't repeat for (optional, default: 5.minutes)
+      # @param slack_notifier_url [String]  The slack notifier url (optional)
+      # @param max_heartbeat_delay [Integer] The maximum heartbeat delay (default: 5 minute, max: 5 days)
+      def initialize(max_queue_size: nil, on_backed_up: nil, on_slowed_down: nil, dont_repeat_for: nil, slack_notifier_url: nil, max_heartbeat_delay: nil)
+        @max_queue_size = max_queue_size ||  ENV.fetch('SIDEKIQ_MONITOR_MAX_QUEUE_SIZE', 5000).to_i
 
-          @on_backed_up = (on_backed_up.is_a?(Enumerable) ? on_backed_up : [on_backed_up]) unless on_backed_up.nil?
-          @on_slowed_down = (on_slowed_down.is_a?(Enumerable) ? on_slowed_down : [on_slowed_down]) unless on_slowed_down.nil?
+        @dont_repeat_for = dont_repeat_for unless dont_repeat_for.nil?
 
-          if slack_notifier_url.present?
-            @notifier = Slack::Notifier.new(slack_notifier_url)
+        @max_heartbeat_delay = max_heartbeat_delay || 5.minutes
 
-            slack_notifier_callback = [-> (msg, queue) { @notifier.ping(msg) }]
+        @on_backed_up = (on_backed_up.is_a?(Enumerable) ? on_backed_up : [on_backed_up]) unless on_backed_up.nil?
+        @on_slowed_down = (on_slowed_down.is_a?(Enumerable) ? on_slowed_down : [on_slowed_down]) unless on_slowed_down.nil?
 
-            @on_backed_up = @on_backed_up.to_a + slack_notifier_callback
-            @on_slowed_down = @on_slowed_down.to_a + slack_notifier_callback
-          end
+        setup_slack_notifier!(slack_notifier_url) if slack_notifier_url.present?
+
+        install_cron_job!
+      end
+
+      def send_test!
+        test_queue = Sidekiq::Queue.new('test')
+        send_backed_up_alert("Test backed up alert!", test_queue)
+        send_slowed_down_alert("Test slowed down alert!", test_queue)
+      end
 
-          unless Sidekiq::Cron::Job.find("sidekiq_monitor").present?
-            Sidekiq::Cron::Job.create(
-              name: 'sidekiq_monitor', 
-              cron: '*/15 * * * * *', 
-              klass: Sidekiq::HeartbeatMonitor::Scheduler
-            )
+      def send_backed_up_alert!(message, q)
+        if @on_backed_up.blank?
+          puts ("WARNING: No 'on_backed_up' callback defined for sidekiq-heartbeat_monitor but one of the queues are backed up: #{message}")
+          return
+        end
+
+        if @dont_repeat_for.nil?
+          @on_backed_up.to_a.each { |alert| alert.call(message, q) }
+        else
+          DontRepeatFor.new(@dont_repeat_for, "Sidekiq/HeartbeatMonitor/#{q.name}/send_backed_up_alert") do
+            @on_backed_up.to_a.each { |alert| alert.call(message, q) }
           end
         end
+      end
 
-        def send_test!
-          test_queue = Sidekiq::Queue.new('test')
-          send_backed_up_alert("Test backed up alert!", test_queue)
-          send_slowed_down_alert("Test slowed down alert!", test_queue)
+      def send_slowed_down_alert!(message, q)
+        if @on_slowed_down.blank?
+          puts ("WARNING: No 'on_slowed_down' callback defined for sidekiq-heartbeat_monitor but one of the queues are backed up: #{message}")
+          return
         end
 
-        def send_backed_up_alert(message, q)
-          if @on_backed_up.blank?
-            puts ("WARNING: No 'on_backed_up' callback defined for sidekiq-heartbeat_monitor but one of the queues are backed up: #{message}")
-            return
+        if @dont_repeat_for.nil?
+          @on_slowed_down.to_a.each { |alert| alert.call(message, q) }
+        else
+          DontRepeatFor.new(@dont_repeat_for, "Sidekiq/HeartbeatMonitor/#{q.name}/send_slowed_down_alert") do
+            @on_slowed_down.to_a.each { |alert| alert.call(message, q) }
           end
+        end
+      end
 
-          if @dont_repeat_for.nil?
-            @on_backed_up.to_a.each { |alert| alert.call(message, q) }
-          else
-            DontRepeatFor.new(@dont_repeat_for, "Sidekiq/HeartbeatMonitor/#{q.name}/send_backed_up_alert") do
-              @on_backed_up.to_a.each { |alert| alert.call(message, q) }
+      def self.install_cron_job!(output: false)
+        job = Sidekiq::Cron::Job.find("sidekiq_monitor")
+
+        target_job = Sidekiq::Cron::Job.new(
+          name: 'sidekiq_monitor', 
+          cron: '* * * * *', 
+          klass: Sidekiq::HeartbeatMonitor::Scheduler
+        )
+
+        if job.present?
+          if job.cron != target_job.cron && job.klass.to_s != target_job.klass
+            unless job.destroy
+              puts "ERROR: An existing cron job was found with the same name but incorrect configuration. An attempt to delete it (to create a new, correctly configured one) failed." if output
+              return false
             end
-          end
-        end
 
-        def send_slowed_down_alert(message, q)
-          if @on_slowed_down.blank?
-            puts ("WARNING: No 'on_slowed_down' callback defined for sidekiq-heartbeat_monitor but one of the queues are backed up: #{message}")
-            return
+            if target_job.save
+              puts "SUCCESS: An existing crob job was found that had the same name but had outdated configuration, so it was deleted and a new one was installed successfully." if output
+              true
+            else
+              puts "ERROR: Sidekiq heartbeat monitor found an existing cron job with the same name but it is configured incorrectly. It was deleted, but a new one could not be created. Run this command again to try adding it manually again and please ensure you can programmatically add sidekiq cron jobs as well." if output
+              false
+            end
+          else
+            puts "SUCCESS: Sidekiq heartbeat monitor cron job already exists and appears to be configured properly so nothing was changed."  if output
+            true
           end
-
-          if @dont_repeat_for.nil?
-            @on_slowed_down.to_a.each { |alert| alert.call(message, q) }
+        else
+          if target_job.save
+            puts "SUCCESS: New cron task was installed successfully." if output
+            true
           else
-            DontRepeatFor.new(@dont_repeat_for, "Sidekiq/HeartbeatMonitor/#{q.name}/send_slowed_down_alert") do
-              @on_slowed_down.to_a.each { |alert| alert.call(message, q) }
-            end
+            puts "ERROR: New cron task could not be saved for some reason. Please ensure you can programmatically add sidekiq cron jobs and try again." if output
+            false
           end
         end
+      end
 
-        def max_queue_size
-          @max_queue_size || ENV.fetch('SIDEKIQ_MONITOR_MAX_QUEUE_SIZE', 5000).to_i
-        end
+      private
+
+      def setup_slack_notifier!(slack_notifier_url)
+        @notifier = Slack::Notifier.new(slack_notifier_url)
+
+        slack_notifier_callback = [-> (msg, queue) { @notifier.ping(msg) }]
+
+        @on_backed_up = @on_backed_up.to_a + slack_notifier_callback
+        @on_slowed_down = @on_slowed_down.to_a + slack_notifier_callback
+      end
+
+      def install_cron_job!
+        # Only install the cron job if we're running as a sidekiq server
+        return unless Sidekiq.server?
+
+        self.class.install_cron_job!
+
+      rescue Redis::CannotConnectError
+        # If we failed to connect at this point then likely Redis is not yet configured at this point in initialization, 
+        # so we should just abort
+        false
       end
+
     end
   end
 end

data/lib/sidekiq/heartbeat_monitor/railtie.rb

@@ -0,0 +1,15 @@
+require 'sidekiq/heartbeat_monitor'
+require 'rails'
+
+module Sidekiq
+  module HeartbeatMonitor
+    class Railtie < ::Rails::Railtie
+      railtie_name :sidekiq_heartbeat_monitor
+
+      rake_tasks do
+        path = File.expand_path(__dir__)
+        Dir.glob("#{path}/tasks/**/*.rake").each { |f| load f }
+      end
+    end
+  end
+end

data/lib/sidekiq/heartbeat_monitor/scheduler.rb

@@ -1,37 +1,55 @@
 module Sidekiq
   module HeartbeatMonitor
     class Scheduler
+      TIME_BETWEEN_HEARTBEATS = 60
+
       include Sidekiq::Worker
+      include Sidekiq::HeartbeatMonitor::Util
       sidekiq_options retry: 0
 
       ##
       # Checks to see if queues are backed up by 1000 or more jobs and also schedules the heartbeat job.
       def perform
-        Sidekiq::Queue.all.each do |q|
-          check_queue_size(q, Sidekiq::HeartbeatMonitor::Config.max_queue_size)
-
-          Sidekiq::HeartbeatMonitor::Worker.client_push(
-            'class' => Sidekiq::HeartbeatMonitor::Worker, 
-            'args'  => [q.name, 15], 
-            'queue' => q.name
-          )
+        Sidekiq.redis do |redis|
+          Sidekiq::Queue.all.each do |q|
+            queue_config = Sidekiq::HeartbeatMonitor.config(q)
+            next if queue_config.nil?
+            
+            check_queue_size!(q, queue_config)
+
+            key = "Sidekiq:HeartbeatMonitor:Worker-#{q.name}.enqueued_at"
+
+            last_enqueued_at = redis.get(key).to_i
+
+            if last_enqueued_at > 577997505 # Enqueued after Jan 2, 2020 when this code was written
+              time_since_enqueued = Time.now.to_i - last_enqueued_at
+              if (time_since_enqueued - TIME_BETWEEN_HEARTBEATS) > queue_config.max_heartbeat_delay
+                queue_config.send_slowed_down_alert!("⚠️ _#{q.name}_ queue is taking longer than #{format_time_str(time_since_enqueued)} to reach jobs.", q)
+              else
+                next
+              end
+            end
+
+            redis.set(key, Time.now.to_i, ex: 1.week)
+
+            Sidekiq::HeartbeatMonitor::Worker.client_push(
+              'class' => Sidekiq::HeartbeatMonitor::Worker, 
+              'args'  => [q.name], 
+              'queue' => q.name
+            )
+          end
+
         end
       end
 
-      def check_queue_size(q, max_queue_size)
+      def check_queue_size!(q, queue_config)
+        max_queue_size = queue_config.max_queue_size
+
         if q.size > max_queue_size
-          send_server_alert("⚠️ Queue #{q.name} has more than #{max_queue_size} jobs waiting to be processed. Current size is #{q.size}", q)
+         queue_config.send_backed_up_alert!("⚠️ _#{q.name}_ queue has more than #{max_queue_size} jobs waiting to be processed. Current size is #{q.size}", q)
         end
       end
 
-      ##
-      # @param msg [String] Message to post
-      # @param queue_name [Sidekiq::Queue] Queue we're concerned with
-      def send_server_alert(msg, q)
-        Sidekiq::HeartbeatMonitor::Config.send_backed_up_alert(msg, q)
-
-        true
-      end
     end
   end
 end

data/lib/sidekiq/heartbeat_monitor/tasks/install.rake

@@ -0,0 +1,9 @@
+namespace :sidekiq do
+  namespace :heartbeat_monitor do
+
+    desc "Install sidekiq heartbeat monitor gem heartbeat cron task."
+    task :install => :environment do
+      Sidekiq::HeartbeatMonitor::Config.install_cron_job!(output: true)
+    end
+  end
+end

data/lib/sidekiq/heartbeat_monitor/test_worker.rb

@@ -0,0 +1,21 @@
+module Sidekiq
+  module HeartbeatMonitor
+    ##
+    # Used for testing purposes to ensure that the system is working properly.
+    class TestWorker
+
+      include Sidekiq::Worker
+
+      sidekiq_options retry: 0
+
+      def perform(wait_time = 1.second)
+        puts "Internal test worker started and will continue for the next #{wait_time} seconds." if wait_time > 3.seconds
+
+        sleep(wait_time)
+
+        puts "Internal test worker finished after #{wait_time} seconds." if wait_time > 3.seconds
+      end
+
+    end
+  end
+end

data/lib/sidekiq/heartbeat_monitor/util.rb

@@ -0,0 +1,33 @@
+
+module Sidekiq
+  module HeartbeatMonitor
+    module Util
+
+      ##
+      # Nicely formats a seconds string.
+      # Example 1: 100.seconds => "1 min 40 sec"
+      # Example 2: 13.hours => "13 hr"
+      # 
+      # @param total_seconds [String]  Total number of seconds to format nicely.
+      # @return [String] A string representation of the time.
+      def format_time_str(total_seconds)
+        remaining_sec = total_seconds
+
+        hours = (remaining_sec - (remaining_sec % 3600)) / 3600
+        remaining_sec -= hours * 3600
+
+        minutes = (remaining_sec - (remaining_sec % 60)) / 60
+        remaining_sec -= minutes * 60
+
+        seconds = remaining_sec
+
+        nice_backed_up_str = "#{seconds} sec" if seconds > 0 || (minutes < 1 && hours < 1)
+        nice_backed_up_str = "#{minutes} min #{nice_backed_up_str}" if minutes > 0 || (seconds > 0 && hours > 0)
+        nice_backed_up_str = "#{hours} hr #{nice_backed_up_str}" if hours > 0
+
+        nice_backed_up_str.strip
+      end
+
+    end
+  end
+end

data/lib/sidekiq/heartbeat_monitor/version.rb

@@ -1,5 +1,5 @@
 module Sidekiq
     module HeartbeatMonitor
-        VERSION = '1.0.1.3'
+        VERSION = '1.0.3.2'
     end
 end

data/lib/sidekiq/heartbeat_monitor/worker.rb

@@ -1,45 +1,35 @@
 module Sidekiq
   module HeartbeatMonitor
     class Worker
-
       include Sidekiq::Worker
+      include Sidekiq::HeartbeatMonitor::Util
+      
       sidekiq_options retry: 0
 
       ##
       # Runs every x seconds and ensures that the time between jobs is consistent and
       # @param queue_name [String] Name of the queue that this heartbeat is running on.
-      def perform(queue_name, secs_between_beats = 15)
-        current_run_at = Time.now.utc.to_i
-        last_run_at = redis.get("Sidekiq/HeartbeatMonitor/Worker/#{queue_name}.last_run_at").to_i
+      def perform(queue_name)
+        Sidekiq.redis do |redis|
+          q = Sidekiq::Queue.all.find{ |q| q.name.to_s == queue_name.to_s }
+          queue_config = Sidekiq::HeartbeatMonitor.config(q)
+          return if queue_config.nil?
 
-        if last_run_at > 0
-          time_since_last_run = current_run_at - last_run_at
-          if time_since_last_run > (5.minutes + secs_between_beats)
-            sec_backed_up = time_since_last_run - secs_between_beats
+          key = "Sidekiq:HeartbeatMonitor:Worker-#{queue_name}.enqueued_at"
+          enqueued_at = redis.get(key).to_i
 
-            send_server_alert("⚠️ queue #{queue_name} took > #{sec_backed_up}s to reach job.", queue_name)
-          end
-        end
-
-        redis.set("Sidekiq/HeartbeatMonitor/Worker/#{queue_name}.last_run_at", current_run_at, ex: 1.hour)
-      end
+          return if enqueued_at < 1577997505 # Enqueued before Jan 2, 2020 when this code was written
 
-      ##
-      # @param msg [String] Message to post
-      # @param queue_name [String] Queue we're concerned with
-      def send_server_alert(msg, queue_name)
-        queue = Sidekiq::Queue.all.find{ |q| q.name.to_s == queue_name.to_s }
+          time_since_enqueued = Time.now.to_i - enqueued_at
 
-        Sidekiq::HeartbeatMonitor::Config.send_slowed_down_alert(msg, queue)
+          if time_since_enqueued > queue_config.max_heartbeat_delay
+            queue_config.send_slowed_down_alert!("⚠️ _#{queue_name}_ queue took #{format_time_str(time_since_enqueued)} to reach job.", q)
+          end
 
-        true
+          redis.del(key)
+        end
       end
 
-      private
-
-      def redis
-        @@redis = defined?($redis) ? $redis : Redis.new
-      end
 
     end
   end

data/sidekiq-heartbeat_monitor.gemspec

@@ -31,12 +31,13 @@ Gem::Specification.new do |spec|
   spec.add_dependency "sidekiq-cron", ">= 0.6"
   spec.add_dependency "dont_repeat_for", ">= 1"
   spec.add_dependency "slack-notifier", ">= 0.5"
+  spec.add_dependency "dotenv", ">= 1.0"
 
   spec.add_development_dependency "rails", ">= 4"
 
   spec.add_development_dependency "bundler"
   spec.add_development_dependency "temping", "~> 3.3"
-  spec.add_development_dependency "rake", "~> 10"
+  spec.add_development_dependency "rake", ">= 12.3.3"
   spec.add_development_dependency "rspec", '~> 3.4'
   spec.add_development_dependency "sqlite3", '~> 1.3'
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sidekiq-heartbeat_monitor
 version: !ruby/object:Gem::Version
-  version: 1.0.1.3
+  version: 1.0.3.2
 platform: ruby
 authors:
 - Jay El-Kaake
-autorequire: 
+autorequire:
 bindir: exe
 cert_chain: []
-date: 2019-12-31 00:00:00.000000000 Z
+date: 2021-06-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: sidekiq
@@ -66,6 +66,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0.5'
+- !ruby/object:Gem::Dependency
+  name: dotenv
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.0'
 - !ruby/object:Gem::Dependency
   name: rails
   requirement: !ruby/object:Gem::Requirement
@@ -112,16 +126,16 @@ dependencies:
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '10'
+        version: 12.3.3
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '10'
+        version: 12.3.3
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
@@ -169,7 +183,11 @@ files:
 - bin/setup
 - lib/sidekiq/heartbeat_monitor.rb
 - lib/sidekiq/heartbeat_monitor/config.rb
+- lib/sidekiq/heartbeat_monitor/railtie.rb
 - lib/sidekiq/heartbeat_monitor/scheduler.rb
+- lib/sidekiq/heartbeat_monitor/tasks/install.rake
+- lib/sidekiq/heartbeat_monitor/test_worker.rb
+- lib/sidekiq/heartbeat_monitor/util.rb
 - lib/sidekiq/heartbeat_monitor/version.rb
 - lib/sidekiq/heartbeat_monitor/worker.rb
 - sidekiq-heartbeat_monitor.gemspec
@@ -177,7 +195,7 @@ homepage: https://www.github.com/jayelkaake/sidekiq-heartbeat_monitor
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -192,9 +210,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.6.10
-signing_key: 
+rubygems_version: 3.0.9
+signing_key:
 specification_version: 4
 summary: Makes it easy to monitor your sidekiq queues, especially with Slack.
 test_files: []