sidekiq-cronitor 2.0.0 → 3.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 77c9e01c256be04515fbd21f7e467fb28e632a37f94d639847c6af8ad6e9823b
-  data.tar.gz: 2c78645ae3fb16b98b52777b3b3124aaa76e6860fc606bee2bc2ab8696275663
+  metadata.gz: 7fdd6b7a4900b0b4325bdecbb6774f71748e20d81aa44969b4687e6ee833e4b2
+  data.tar.gz: f61d0a3051c15d95d000273bca3b2f127e70d16a28e2769a19bf976a4e47f088
 SHA512:
-  metadata.gz: 70c63ea8977ac11afe3991a1290950ed1deaa95c0147e8434fc3d0cf0fd4ed965d6d31354b150ae74e505497d7a5499023ea93f41a7eeca14fdddefc2a38a2c7
-  data.tar.gz: 6474a1e11df5373147b252fe327373e084f34abb60b6708f99c81df6b1c6d37643642228f1651fca7ddc4d9c0b988abec2f6a045f949f3e0a8e07dd5cc953b30
+  metadata.gz: 1f687f12236ef9af2041ff33a0ba5df7bdb378ee316ff84ce0c7ae298ab018a973ee168a88eadc07cc4a9d86a3d6ceca9d006a0a166c9f7e4d90462444e70720
+  data.tar.gz: b3d78f111182e36d322c1eaa41f7297b1bddcf286e8240780de2be6092ebd39c36ba9b708b4e013cde8fb8327c751f0a86e73d266951ea4978d5cd72e11c8f34

data/README.md

@@ -1,6 +1,9 @@
 # Sidekiq Cronitor
 
-Call a [Cronitor](https://cronitor.io) around your [Sidekiq](https://sidekiq.org) jobs.
+[Cronitor](https://cronitor.io/) provides dead simple monitoring for cron jobs, daemons, queue workers, websites, APIs, and anything else that can send or receive an HTTP request. The Cronitor Sidekiq library provides a drop in integration for monitoring any Sidekiq Job.
+
+
+#### NOTE: Version 3.0.0 changes the integration method from 2.x.x. This is a breaking change. You now add the middleware in the Sidekiq initializer. You can opt of out telemetry for specific jobs with a sidekiq_options (see below)
 
 ## Installation
 
@@ -19,43 +22,96 @@ bundle
 
 ## Usage
 
-Make sure you've got a Cronitor [API Key](https://cronitor.io/docs/api-overview) from [your settings](https://cronitor.io/settings) in your ENV as `CRONITOR_API_KEY` before starting Sidekiq:
+Configure `sidekiq-cronitor` with an [API Key](https://cronitor.io/docs/api-overview) from [your settings](https://cronitor.io/settings). You can use ENV variables to configure Cronitor:
 
 ```sh
-export CRONITOR_API_KEY='abcdef1234567890abcdef1234567890'
+export CRONITOR_API_KEY='api_key_123'
+export CRONITOR_ENVIRONMENT='development' #default: 'production'
+
 bundle exec sidekiq
 ```
 
-Any sidekiq worker you'd like to monitor just includes `Sidekiq::Cronitor` right after `Sidekiq::Worker`:
+Or declare the API key directly on the Cronitor module from within your application (e.g. the Sidekiq initializer).
 
 ```ruby
-class MyWorker
-  include Sidekiq::Worker
-  include Sidekiq::Cronitor
+require 'cronitor'
+Cronitor.api_key = 'api_key_123'
+Cronitor.environment = 'development' #default: 'production'
+```
 
-  def perform
-    # ...
+
+To monitor jobs insert the server middleware (most people do this in the Sidekiq initializer)
+
+```ruby
+Sidekiq.configure_server do |config|
+  config.server_middleware do |chain|
+    chain.add Sidekiq::Cronitor::ServerMiddleware
   end
 end
 ```
 
-By default this will look for an existing monitor named after your worker, `MyWorker` in the case above, and pings that. Otherwise it will try to create a new monitor with the worker's name, which you can configure rules for at a later time via your Cronitor dashboard.
 
-To use a monitor you've already created, you can configure the monitor's `key` directly:
+When this job is invoked, Cronitor will send telemetry pings with a `key` matching the name of your job class (`MyJob` in the example below). If no monitor exists it will create one on the first event. You can configure rules at a later time via the Cronitor dashboard, API, or [YAML config](https://github.com/cronitorio/cronitor-ruby#configuring-monitors) file.
+
+Optional: You can specify the monitor key directly using `sidekiq_options`:
 
 ```ruby
-class MyWorker
-  include Sidekiq::Worker
-  include Sidekiq::Cronitor
+class MyJob
+  include Sidekiq::Job
+  sidekiq_options cronitor_key: 'abc123'
+
+  def perform
+  end
+end
+```
+
 
-  sidekiq_options cronitor: { key: 'abc123' }
+To disable Cronitor for a specific job you can set the following option:
+
+```ruby
+class MyJob
+  include Sidekiq::Job
+  sidekiq_options cronitor_disabled: true
 
   def perform
-    # ...
   end
 end
 ```
 
+## Disabling For Some Jobs
+If you have an entire group or category of jobs you wish to disable monitoring on, it's easiest to create a base class with that option set and then have all your jobs inherit from that base class.
+
+```ruby
+  class UnmonitoredJob
+    include Sidekiq::Job
+    sidekiq_options cronitor_disabled: true
+  end
+
+  class NoInstrumentationJob < UnmonitoredJob
+    def perform
+    end
+  end
+```
+
+Note: Do NOT set a cronitor_key option on your base class or all your inherited jobs will report under the same job in Cronitor.
+
+## Job Monitoring
+If you are using Cronitor to monitor scheduled/periodic jobs and have jobs schedules already defined you can use rake tasks to upload the schedule to Cronitor for monitoring.
+
+In your projects Rakefile you can load the task to be available to you in your project.
+It might be a good idea to sync these schedules on every deploy
+
+```ruby
+  # your Rakefile, find the path to the gem
+  spec = Gem::Specification.find_by_name 'sidekiq-cronitor'
+  # if you are using sidekiq_scheduler this task should parse and upload the schedule.
+  load "#{spec.gem_dir}/lib/tasks/sidekiq_scheduler.rake"
+  # if you are using Sidekiq Pro Periodic Jobs this is an example script
+  # Note: this hasn't been tested on Sidekiq Pro yet
+  load "#{spec.gem_dir}/lib/tasks/periodic_jobs.rake"
+  # You only really need to load one of the rake files unless you are somehow running both systems
+```
+
 ## Development
 
 After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.

data/lib/sidekiq/cronitor/periodic_jobs.rb

@@ -0,0 +1,14 @@
+module Sidekiq::Cronitor
+  class PeriodicJobs
+    def self.sync_schedule!
+      monitors_payload = []
+      loops = Sidekiq::Periodic::LoopSet.new
+      loops.each do |lop|
+        job_key = lop.klass.sidekiq_options.fetch("cronitor_key", nil) || lop.klass.to_s
+        cronitor_disabled = lop.klass.sidekiq_options.fetch("cronitor_disabled", false)
+        monitors_payload << {key: job_key, schedule: lop.schedule, metadata: lop.options, platform: 'sidekiq', type: 'job' } unless cronitor_disabled
+      end
+      Cronitor::Monitor.put(monitors: monitors_payload)
+    end
+  end
+end

data/lib/sidekiq/cronitor/sidekiq_scheduler.rb

@@ -0,0 +1,21 @@
+module Sidekiq::Cronitor
+  class SidekiqScheduler
+    def self.sync_schedule!
+      monitors_payload = []
+      # go through the scheduled jobs and find cron defined ones
+      Sidekiq.get_schedule.each do |k, v|
+        # make sure the job has a cron or every definition, we skip non cron/every defined jobs for now
+        if !v["cron"].nil? || !v["every"].nil?
+          schedule = v["cron"] || v["every"]
+          # just in case an explicit job key has been set
+          job_klass = Object.const_get(v["class"])
+          job_key = job_klass.sidekiq_options.fetch("cronitor_key", nil) || v["class"]
+          # if monitoring for this job is turned off
+          cronitor_disabled = job_klass.sidekiq_options.fetch("cronitor_disabled", false)
+          monitors_payload << {key: job_key.to_s, schedule: schedule, platform: 'sidekiq', type: 'job' } unless cronitor_disabled
+        end
+      end
+      Cronitor::Monitor.put(monitors: monitors_payload)
+    end
+  end
+end

data/lib/sidekiq/cronitor/version.rb

@@ -1,5 +1,5 @@
 module Sidekiq
   module Cronitor
-    VERSION = '2.0.0'
+    VERSION = '3.1.1'
   end
 end

data/lib/sidekiq/cronitor.rb

@@ -3,75 +3,72 @@ require 'cronitor'
 
 require 'sidekiq/cronitor/version'
 
-module Sidekiq::Cronitor
-  def self.included(base)
-    unless base.ancestors.include?(Sidekiq::Worker)
-      raise ArgumentError, 'Sidekiq::Cronitor can only be included in a Sidekiq::Worker'
-    end
-
-    base.extend(ClassMethods)
-
-    # Automatically add sidekiq middleware when we're first included
-    Sidekiq.configure_server do |config|
-      unless config.server_middleware.exists?(Sidekiq::Cronitor::Middleware)
-        config.server_middleware.add(Sidekiq::Cronitor::Middleware)
-      end
-    end
-  end
-
-  def cronitor
-    self.class.cronitor
-  end
-
-  module ClassMethods
-    def cronitor
-      return @cronitor if defined?(@cronitor)
-
-      opts = sidekiq_options.fetch('cronitor', {})
-      key = opts.symbolize_keys.fetch(:key, name)
-
-      Sidekiq.logger.debug("[cronitor] initializing monitor: worker=#{name} key=#{key}")
-
-      begin
-        @cronitor = Cronitor::Monitor.new(key)
-      rescue Cronitor::Error => e
-        Sidekiq.logger.error("[cronitor] failed to initialize monitor: worker=#{name} error=#{e.message}")
+if defined? SidekiqScheduler
+  require 'sidekiq/cronitor/sidekiq_scheduler'
+end
 
-        @cronitor = nil
-      end
-    end
-  end
+if defined? Sidekiq::Periodic
+  require 'sidekiq/cronitor/periodic_jobs'
+end
 
-  class Middleware
+module Sidekiq::Cronitor
+  class ServerMiddleware
     def call(worker, message, queue)
       ping(worker: worker, state: 'run')
 
-      yield
+      result = yield
     rescue => e
       ping(worker: worker, state: 'fail', message: e.to_s)
 
       raise e
     else
       ping(worker: worker, state: 'complete')
+      result # to be consistent with client middleware, return results of yield
     end
 
     private
+    def cronitor(worker)
+      Cronitor::Monitor.new(job_key(worker))
+    end
+
+    def cronitor_disabled?(worker)
+      disabled = worker.class.sidekiq_options.fetch("cronitor_disabled", nil)
+      if disabled.nil?
+        options(worker).fetch(:disabled, false)
+      else
+        !!disabled
+      end
+    end
+
+    def job_key(worker)
+      worker.class.sidekiq_options.fetch("cronitor_key", nil) ||
+      options(worker).fetch(:key, worker.class.name)
+    end
+
+    def options(worker)
+      # eventually we will delete this method of passing options
+      # ultimately we want all cronitor options to be top level keys
+      opts = worker.class.sidekiq_options.fetch("cronitor", {})
+      # symbolize_keys is a rails helper, so only use it if it's defined
+      opts = opts.symbolize_keys if opts.respond_to?(:symbolize_keys)
+      opts
+    end
 
     def ping(worker:, state:, message: nil)
-      return unless has_cronitor?(worker)
+      return unless should_ping?(worker)
 
-      Sidekiq.logger.debug("[cronitor] ping: worker=#{worker.class.name} state=#{state} message=#{message}")
+      Sidekiq.logger.debug("[cronitor] ping: worker=#{job_key(worker)} state=#{state} message=#{message}")
 
-      worker.cronitor.ping(state: state)
+      cronitor(worker).ping(state: state)
     rescue Cronitor::Error => e
-      Sidekiq.logger.error("[cronitor] error during ping: worker=#{worker.class.name} error=#{e.message}")
+      Sidekiq.logger.error("[cronitor] error during ping: worker=#{job_key(worker)} error=#{e.message}")
     rescue => e
-      Sidekiq.logger.error("[cronitor] unexpected error: worker=#{worker.class.name} error=#{e.message}")
+      Sidekiq.logger.error("[cronitor] unexpected error: worker=#{job_key(worker)} error=#{e.message}")
       Sidekiq.logger.error(e.backtrace.first)
     end
 
-    def has_cronitor?(worker)
-      worker.is_a?(Sidekiq::Cronitor) && worker.respond_to?(:cronitor) && !worker.cronitor.api_key.nil?
+    def should_ping?(worker)
+      !cronitor(worker).api_key.nil? && !cronitor_disabled?(worker)
     end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: sidekiq-cronitor
 version: !ruby/object:Gem::Version
-  version: 2.0.0
+  version: 3.1.1
 platform: ruby
 authors:
 - Zeke Gabrielse
@@ -9,7 +9,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-05-11 00:00:00.000000000 Z
+date: 2022-04-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: sidekiq
@@ -107,6 +107,8 @@ files:
 - LICENSE
 - README.md
 - lib/sidekiq/cronitor.rb
+- lib/sidekiq/cronitor/periodic_jobs.rb
+- lib/sidekiq/cronitor/sidekiq_scheduler.rb
 - lib/sidekiq/cronitor/version.rb
 homepage: https://github.com/cronitor/sidekiq-cronitor
 licenses: