skiplock 1.0.16 → 1.0.17

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7e9881d695e3f1a6241e3d86ca7844dff77ea3ba2b7431d70546a685dd1829a3
-  data.tar.gz: e9e2957e874d1a878f9302d4d08244830cf6abb7e9d9c6dc0970a2347344c0b7
+  metadata.gz: d9533e3df15a24e784000c160588b96207271986bf927bff095752e556c3376a
+  data.tar.gz: dcc40ab796f55fc41363d671d5e4f73600c58c468d7c4543e496fad38c3e9a8a
 SHA512:
-  metadata.gz: 7d5045bc4dcee7ebab3838f7970a0ed681cda2756736491df734a60eb04d0b4a2a4525073e52e59df43a6ef2cd1f11ade191002de1be53ad01b0169f8b21687d
-  data.tar.gz: 75b542459110cbc57ac2ea1dd19a9f3431f1c9d744871c64e0543cdd61a76d87ab3e5c946bef1cab43d2401b2970f17d3d7c35019ed8647a3d96a98f8f5e6a2e
+  metadata.gz: 0a0c21835b52f749022d7f3a135f041d122425defffaf6aebb6d8510d4dd0836aed2fb9977daff9e7d3bf2547e139d2dd3ea49f5f55a869ce851c93aaeb56a12
+  data.tar.gz: d94c6801c82e1bddb12cff0152b71e8554d03de4d28f51ec0d742807311adecca1b3b142aeadf3cd5e81336416b03206d81848f6da6abf8e0f8c726631a5d898

data/README.md

@@ -51,7 +51,7 @@ The library is quite small compared to other PostgreSQL job queues (eg. *delay_j
     # config/skiplock.yml (default settings)
     ---
     min_threads: 1
-    max_threads: 5
+    max_threads: 10
     max_retries: 20
     logfile: skiplock.log
     loglevel: info
@@ -70,8 +70,8 @@ The library is quite small compared to other PostgreSQL job queues (eg. *delay_j
     - **logfile** (*string*): filename for skiplock logs; empty logfile will disable logging
     - **loglevel** (*string*): sets logging level (`debug, info, warn, error, fatal, unknown`)
     - **notification** (*string*): sets the library to be used for notifying errors and exceptions (`auto, airbrake, bugsnag, exception_notification, custom`); using `auto` will detect library if available.  See `Notification system` for more details
-    - **extensions** (*boolean*): enable or disable the class method extension.  See `ClassMethod extension` for more details
-    - **purge_completion** (*boolean*): when set to **true** will delete jobs after they were completed successfully; if set to **false** then the completed jobs should be purged periodically to maximize performance (eg. clean up old jobs after 3 months)
+    - **extensions** (*multi*): enable or disable the class method extension.  See `ClassMethod extension` for more details
+    - **purge_completion** (*boolean*): when set to **true** will delete jobs after they were completed successfully; if set to **false** then the completed jobs should be purged periodically to maximize performance (eg. clean up old jobs after 3 months); queued jobs can manually override using `purge` option
     - **queues** (*hash*): defines the set of queues with priorities; lower priority takes precedence
     - **workers** (*integer*) sets the maximum number of processes when running in standalone mode using the `skiplock` executable; setting this to **0** will enable **async mode**
 
@@ -89,6 +89,7 @@ The library is quite small compared to other PostgreSQL job queues (eg. *delay_j
       -r, --max-retries NUM            Number of maxixum retries
       -t, --max-threads NUM            Number of maximum threads
       -T, --min-threads NUM            Number of minimum threads
+      -v, --version                    Show version information
       -w, --workers NUM                Number of workers
       -h, --help                       Show this message
     ```
@@ -99,19 +100,26 @@ Inside the Rails application:
     ```ruby
     MyJob.perform_later
     ```
-- Skiplock supports all ActiveJob features
+- Skiplock supports all ActiveJob features and options
     ```ruby
     MyJob.set(queue: 'my_queue', wait: 5.minutes, priority: 10).perform_later(1,2,3)
+    MyJob.set(wait_until: Day.tomorrow.noon).perform_later(1,2,3)
+    ```
+- Skiplock supports custom options which override the global `Skiplock` configuration options for specified jobs
+    - **purge** (*boolean*): whether to remove this job after it has ran successfully
+    - **max_retries** (*integer*): set maximum retry attempt for this job
+    ```ruby
+    MyJob.set(purge: false, max_retries: 5).perform_later(1,2,3)
     ```
 Outside the Rails application:
 - queue the jobs by inserting the job records directly to the database table
     ```sql
     INSERT INTO skiplock.jobs(job_class) VALUES ('MyJob');
     ```
-- with scheduling, priority, queue and arguments
+- with scheduling, priority, queue, arguments and custom options
     ```sql
     INSERT INTO skiplock.jobs(job_class, queue_name, priority, scheduled_at, data)
-      VALUES ('MyJob', 'my_queue', 10, NOW() + INTERVAL '5 min', '{"arguments":[1,2,3]}');
+      VALUES ('MyJob', 'my_queue', 10, NOW() + INTERVAL '5 min', '{"arguments":[1,2,3],"options":{"purge":false,"max_retries":5}}');
     ```
 ## Queue priority vs Job priority
 *Why do queues use priorities when jobs already have priorities?*
@@ -165,15 +173,21 @@ If the `retry_on` block is not defined, then the built-in retry system of `Skipl
   # config/initializers/skiplock.rb
   Skiplock.on_error do |ex, previous|
     if ex.backtrace != previous.try(:backtrace)
-      # sends custom email on new exceptions only
+      # sends text message using Amazon SNS on new exceptions only
       # the same repeated exceptions will only be sent once to avoid SPAM
       # NOTE: exceptions generated from Job executions will not provide 'previous' exceptions
+      sms = Aws::SNS::Client.new(region: 'us-west-2', access_key_id: Rails.application.credentials[:aws][:access_key_id], secret_access_key: Rails.application.credentials[:aws][:secret_access_key])
+      sms.publish({ phone_number: '+122233334444', message: "Exception: #{ex.message}"[0..130] })
     end
   end
   # supports multiple 'on_error' event callbacks
 ```
 ## ClassMethod extension
-`Skiplock` can add extension to allow all class methods to be performed as a background job; it is disabled in the default configuration.  To enable, edit the `config/skiplock.yml` configuration file and change `extensions` to `true`.
+`Skiplock` can add extension to allow class methods to be performed as a background job; it is disabled in the default configuration.  To enable globally for all classes and modules, edit the `config/skiplock.yml` configuration file and change `extensions` to `true`; this can expose remote execution if the `skiplock.jobs` database table is not secured properly.  To enable extension for specific classes and modules only then set the configuration to an array of names of the classes and modules eg. `['MyClass', 'MyModule']`
+- An example of remote execution if the extension is enabled globally (ie: configuration is set to `true`) and attacker can insert `skiplock.jobs`
+  ```sql
+  INSERT INTO skiplock.jobs(job_class, data) VALUES ('Skiplock::Extension::ProxyJob', '{"arguments":["---\n- !ruby/module ''Kernel''\n- :system\n- - rm -rf /tmp/*\n"]}');
+  ```
 - Queue class method `generate_thumbnails` of class `Image` as background job to run as soon as possible
   ```ruby
   Image.skiplock.generate_thumbnails(height: 100, ratio: true)
@@ -188,24 +202,25 @@ If the `retry_on` block is not defined, then the built-in retry system of `Skipl
   ```
 
 ## Fault tolerant
-`Skiplock` ensures that jobs will be executed sucessfully only once even if database connection is lost during or after the job was dispatched.  Successful jobs are marked as completed or removed (with `purge_completion` turned on), and failed or interrupted jobs are marked for retry.
+`Skiplock` ensures that jobs will be executed sucessfully only once even if database connection is lost during or after the job was dispatched.  Successful jobs are marked as completed or removed (with `purge_completion` global configuration or `purge` job option); failed or interrupted jobs are marked for retry.
 
 However, when the database connection is dropped for any reasons and the commit is lost, `Skiplock` will then save the commit data to local disk (as `tmp/skiplock/<job_id>`) and synchronize with the database when the connection resumes.
 
-This also protects in-progress jobs that were terminated abruptly during a graceful shutdown with timeout; they will be queued for retry.
+This also protects long running in-progress jobs that are terminated abruptly during a graceful shutdown with timeout; these will be queued for retry.
 
 ## Scalability
 `Skiplock` can scale both vertically and horizontally.  To scale vertically, simply increase the number of `Skiplock` workers per host.  To scale horizontally, simply deploy `Skiplock` to multiple hosts sharing the same PostgreSQL database.
 
-## Statistics and counters
+## Statistics, analytics and counters
 The `skiplock.workers` database table contains all the `Skiplock` workers running on all the hosts.  Active worker will update its timestamp column (`updated_at`) every minute; and dispatched jobs would be associated with the running workers.  At any given time, a list of active workers running a list of jobs can be determined using the database table.
 
-The `skiplock.counters` database table contains all historical job dispatches, completions, expiries, failures and retries.  The counters are recorded by dates; so it's possible to get statistical data for any given day or range of dates.
+The `skiplock.jobs` database table contains all the `Skiplob` jobs.  Each job's successful execution stores the result to its `data['result']` field column.  If job completions are not purged then their execution results can be used for analytic purposes.
 
+The `skiplock.counters` database table contains all the counters for job dispatches, completions, expiries, failures and retries.  The counters are recorded by dates; so it's possible to get statistical data for any given day or range of dates.
   - **completions**: numbers of jobs completed successfully
   - **dispatches**: number of jobs dispatched for the first time (**retries** are not counted here)
-  - **expiries**: number of jobs exceeded `max_retry` and still failed to complete
-  - **failures**: number of jobs interrupted by graceful shutdown or errors (exceptions)
+  - **expiries**: number of jobs exceeded `max_retries` and still failed to complete
+  - **failures**: number of jobs interrupted by graceful shutdown or unable to complete due to errors (exceptions)
   - **retries**: number of jobs dispatched for retrying
 
 Code examples of gathering counters information:

data/lib/generators/skiplock/templates/migration.rb.erb

@@ -56,7 +56,7 @@ class CreateSkiplockSchema < ActiveRecord::Migration<%= "[#{ActiveRecord::VERSIO
             INSERT INTO skiplock.counters (day,completions) VALUES (NOW(),1) ON CONFLICT (day) DO UPDATE SET completions = skiplock.counters.completions + 1;
           ELSIF (record.expired_at IS NOT NULL) THEN
             INSERT INTO skiplock.counters (day,expiries) VALUES (NOW(),1) ON CONFLICT (day) DO UPDATE SET expiries = skiplock.counters.expiries + 1;
-          ELSIF (record.executions > 0) THEN
+          ELSIF (TG_OP = 'UPDATE' AND OLD.running = TRUE AND NEW.running = FALSE) THEN
             INSERT INTO skiplock.counters (day,failures) VALUES (NOW(),1) ON CONFLICT (day) DO UPDATE SET failures = skiplock.counters.failures + 1;
           END IF;
           PERFORM pg_notify('skiplock::jobs', CONCAT(TG_OP,',',record.id::TEXT,',',record.worker_id::TEXT,',',record.job_class,',',record.queue_name,',',record.running::TEXT,',',CAST(EXTRACT(EPOCH FROM record.expired_at) AS FLOAT)::TEXT,',',CAST(EXTRACT(EPOCH FROM record.finished_at) AS FLOAT)::TEXT,',',CAST(EXTRACT(EPOCH FROM CASE WHEN record.scheduled_at IS NULL THEN record.updated_at ELSE record.scheduled_at END) AS FLOAT)::TEXT));

data/lib/skiplock/cron.rb

@@ -6,7 +6,7 @@ module Skiplock
       ActiveJob::Base.descendants.each do |j|
         next unless j.const_defined?('CRON')
         cron = j.const_get('CRON')
-        job = Job.find_by('job_class = ? AND cron IS NOT NULL', j.name) || Job.new(job_class: j.name, cron: cron, locale: I18n.locale, timezone: Time.zone.name)
+        job = Job.find_by('job_class = ? AND cron IS NOT NULL', j.name) || Job.new(job_class: j.name, queue_name: j.queue_as, cron: cron, locale: I18n.locale, timezone: Time.zone.name)
         time = self.next_schedule_at(cron)
         if time
           job.cron = cron

data/lib/skiplock/job.rb

@@ -4,21 +4,6 @@ module Skiplock
     attr_accessor :activejob_retry
     belongs_to :worker, inverse_of: :jobs, required: false
 
-    # resynchronize jobs that could not commit to database and retry any abandoned jobs
-    def self.cleanup(purge_completion: true, max_retries: 20)
-      Dir.mkdir('tmp/skiplock') unless Dir.exist?('tmp/skiplock')
-      Dir.glob('tmp/skiplock/*').each do |f|
-        job_from_db = self.find_by(id: File.basename(f), running: true)
-        disposed = true
-        if job_from_db
-          job, ex = YAML.load_file(f) rescue nil
-          disposed = job.dispose(ex, purge_completion: purge_completion, max_retries: max_retries) if job
-        end
-        (File.delete(f) rescue nil) if disposed
-      end
-      self.where(running: true).where.not(worker_id: Worker.ids).update_all(running: false, worker_id: nil)
-    end
-
     def self.dispatch(purge_completion: true, max_retries: 20)
       job = nil
       self.connection.transaction do
@@ -35,44 +20,61 @@ module Skiplock
 
     def self.enqueue_at(activejob, timestamp)
       timestamp = Time.at(timestamp) if timestamp
-      if Thread.current[:skiplock_dispatch_job].try(:id) == activejob.job_id
-        Thread.current[:skiplock_dispatch_job].activejob_retry = true
-        Thread.current[:skiplock_dispatch_job].executions = activejob.executions
-        Thread.current[:skiplock_dispatch_job].exception_executions = activejob.exception_executions
-        Thread.current[:skiplock_dispatch_job].scheduled_at = timestamp
-        Thread.current[:skiplock_dispatch_job]
+      if Thread.current[:skiplock_job].try(:id) == activejob.job_id
+        Thread.current[:skiplock_job].activejob_retry = true
+        Thread.current[:skiplock_job].executions = activejob.executions
+        Thread.current[:skiplock_job].exception_executions = activejob.exception_executions
+        Thread.current[:skiplock_job].scheduled_at = timestamp
+        Thread.current[:skiplock_job]
       else
+        options = activejob.instance_variable_get('@skiplock_options') || {}
         serialize = activejob.serialize
-        self.create!(serialize.slice(*self.column_names).merge('id' => serialize['job_id'], 'data' => { 'arguments' => serialize['arguments'] }, 'scheduled_at' => timestamp))
+        self.create!(serialize.slice(*self.column_names).merge('id' => serialize['job_id'], 'data' => { 'arguments' => serialize['arguments'], 'options' => options }, 'scheduled_at' => timestamp))
       end
     end
 
+    # resynchronize jobs that could not commit to database and retry any abandoned jobs
+    def self.flush
+      Dir.mkdir('tmp/skiplock') unless Dir.exist?('tmp/skiplock')
+      Dir.glob('tmp/skiplock/*').each do |f|
+        disposed = true
+        if self.exists?(id: File.basename(f), running: true)
+          job = Marshal.load(File.binread(f)) rescue nil
+          disposed = job.dispose if job.is_a?(Skiplock::Job)
+        end
+        (File.delete(f) rescue nil) if disposed
+      end
+      self.where(running: true).where.not(worker_id: Worker.ids).update_all(running: false, worker_id: nil)
+      true
+    end
+
     def self.reset_retry_schedules
-      self.where('scheduled_at > NOW() AND executions IS NOT NULL AND expired_at IS NULL AND finished_at IS NULL').update_all(scheduled_at: nil, updated_at: Time.now)
+      self.where('scheduled_at > NOW() AND executions > 0 AND expired_at IS NULL AND finished_at IS NULL').update_all(scheduled_at: nil, updated_at: Time.now)
     end
 
-    def dispose(ex, purge_completion: true, max_retries: 20)
-      yaml = [self, ex].to_yaml
+    def dispose
+      return unless @max_retries
+      dump = Marshal.dump(self)
       purging = false
       self.running = false
       self.worker_id = nil
       self.updated_at = Time.now > self.updated_at ? Time.now : self.updated_at + 1 # in case of clock drifting
-      if ex
-        self.exception_executions ||= {}
-        self.exception_executions["[#{ex.class.name}]"] = self.exception_executions["[#{ex.class.name}]"].to_i + 1 unless self.activejob_retry
-        if self.executions.to_i >= max_retries || self.activejob_retry
+      if @exception
+        self.exception_executions["[#{@exception.class.name}]"] = self.exception_executions["[#{@exception.class.name}]"].to_i + 1 unless self.activejob_retry
+        if (self.executions.to_i >= @max_retries + 1) || self.activejob_retry
           self.expired_at = Time.now
         else
           self.scheduled_at = Time.now + (5 * 2**self.executions.to_i)
         end
-        Skiplock.on_errors.each { |p| p.call(ex) }
       elsif self.finished_at
         if self.cron
-          self.data ||= {}
-          self.data['crons'] = (self.data['crons'] || 0) + 1
-          self.data['last_cron_at'] = Time.now.utc.to_s
+          self.data['cron'] ||= {}
+          self.data['cron']['executions'] = self.data['cron']['executions'].to_i + 1
+          self.data['cron']['last_finished_at'] = self.finished_at.utc.to_s
           next_cron_at = Cron.next_schedule_at(self.cron)
           if next_cron_at
+            # update job to record completions counter before resetting finished_at to nil
+            self.update_columns(self.attributes.slice(*self.changes.keys))
             self.finished_at = nil
             self.executions = nil
             self.exception_executions = nil
@@ -81,13 +83,13 @@ module Skiplock
             Skiplock.logger.error("[Skiplock] ERROR: Invalid CRON '#{self.cron}' for Job #{self.job_class}") if Skiplock.logger
             purging = true
           end
-        elsif purge_completion
+        elsif @purge == true
           purging = true
         end
       end
       purging ? self.delete : self.update_columns(self.attributes.slice(*self.changes.keys))
     rescue Exception => e
-      File.write("tmp/skiplock/#{self.id}", yaml) rescue nil
+      File.binwrite("tmp/skiplock/#{self.id}", dump) rescue nil
       if Skiplock.logger
         Skiplock.logger.error(e.to_s)
         Skiplock.logger.error(e.backtrace.join("\n"))
@@ -97,25 +99,31 @@ module Skiplock
     end
 
     def execute(purge_completion: true, max_retries: 20)
+      raise 'Job has already been completed' if self.finished_at
       Skiplock.logger.info("[Skiplock] Performing #{self.job_class} (#{self.id}) from queue '#{self.queue_name || 'default'}'...") if Skiplock.logger
       self.data ||= {}
+      self.data.delete('result')
       self.exception_executions ||= {}
       self.activejob_retry = false
+      @max_retries = (self.data['options'].key?('max_retries') ? self.data['options']['max_retries'].to_i : max_retries) rescue max_retries
+      @max_retries = 20 if @max_retries < 0 || @max_retries > 20
+      @purge = (self.data['options'].key?('purge') ? self.data['options']['purge'] : purge_completion) rescue purge_completion
       job_data = self.attributes.slice('job_class', 'queue_name', 'locale', 'timezone', 'priority', 'executions', 'exception_executions').merge('job_id' => self.id, 'enqueued_at' => self.updated_at, 'arguments' => (self.data['arguments'] || []))
       self.executions = self.executions.to_i + 1
-      Thread.current[:skiplock_dispatch_job] = self
+      Thread.current[:skiplock_job] = self
       start_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
       begin
-        ActiveJob::Base.execute(job_data)
-        self.finished_at = Time.now unless self.activejob_retry
+        self.data['result'] = ActiveJob::Base.execute(job_data)
       rescue Exception => ex
+        @exception = ex
+        Skiplock.on_errors.each { |p| p.call(@exception) }
       end
       if Skiplock.logger
-        if ex || self.activejob_retry
+        if @exception || self.activejob_retry
           Skiplock.logger.error("[Skiplock] Job #{self.job_class} (#{self.id}) was interrupted by an exception#{ ' (rescued and retried by ActiveJob)' if self.activejob_retry }")
-          if ex
-            Skiplock.logger.error(ex.to_s)
-            Skiplock.logger.error(ex.backtrace.join("\n"))
+          if @exception
+            Skiplock.logger.error(@exception.to_s)
+            Skiplock.logger.error(@exception.backtrace.join("\n"))
           end
         else
           end_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
@@ -128,7 +136,8 @@ module Skiplock
         end
       end
     ensure
-      self.dispose(ex, purge_completion: purge_completion, max_retries: max_retries)
+      self.finished_at ||= Time.now if self.data.key?('result') && !self.activejob_retry
+      self.dispose
     end
   end
 end

data/lib/skiplock/manager.rb

@@ -6,13 +6,12 @@ module Skiplock
       @config.symbolize_keys!
       @config.transform_values! {|v| v.is_a?(String) ? v.downcase : v}
       @config.merge!(config)
-      @config[:hostname] = `hostname -f`.strip
+      @hostname = Socket.gethostname
       configure
       setup_logger
-      Module.__send__(:include, Skiplock::Extension) if @config[:extensions] == true
       if (caller.any?{ |l| l =~ %r{/rack/} } && @config[:workers] == 0)
-        cleanup_workers
-        @worker = create_worker
+        Worker.cleanup(@hostname)
+        @worker = Worker.generate(capacity: @config[:max_threads], hostname: @hostname)
         @worker.start(**@config)
         at_exit { @worker.shutdown }
       end
@@ -28,8 +27,8 @@ module Skiplock
       @config[:workers] = 1 if @config[:workers] <= 0
       @config[:standalone] = true
       banner
-      cleanup_workers
-      @worker = create_worker
+      Worker.cleanup(@hostname)
+      @worker = Worker.generate(capacity: @config[:max_threads], hostname: @hostname)
       @parent_id = Process.pid
       @shutdown = false
       Signal.trap('INT') { @shutdown = true }
@@ -38,7 +37,7 @@ module Skiplock
       (@config[:workers] - 1).times do |n|
         fork do
           sleep 1
-          worker = create_worker(master: false)
+          worker = Worker.generate(capacity: @config[:max_threads], hostname: @hostname, master: false)
           worker.start(worker_num: n + 1, **@config)
           loop do
             sleep 0.5
@@ -81,22 +80,6 @@ module Skiplock
       @logger.warn "[Skiplock] Custom notification has no registered 'on_error' callback" if Skiplock.on_errors.count == 0
     end
 
-    def cleanup_workers
-      Rails.application.eager_load! if Rails.env.development?
-      delete_ids = []
-      Worker.where(hostname: @config[:hostname]).each do |worker|
-        sid = Process.getsid(worker.pid) rescue nil
-        delete_ids << worker.id if worker.sid != sid || worker.updated_at < 10.minutes.ago
-      end
-      Worker.where(id: delete_ids).delete_all if delete_ids.count > 0
-    end
-
-    def create_worker(master: true)
-      Worker.create!(pid: Process.pid, sid: Process.getsid(), master: master, hostname: @config[:hostname], capacity: @config[:max_threads])
-    rescue
-      Worker.create!(pid: Process.pid, sid: Process.getsid(), master: false, hostname: @config[:hostname], capacity: @config[:max_threads])
-    end
-
     def configure
       @config[:graceful_shutdown] = 300 if @config[:graceful_shutdown] > 300
       @config[:graceful_shutdown] = nil if @config[:graceful_shutdown] < 0
@@ -137,21 +120,27 @@ module Skiplock
       else
         @config[:notification] = 'custom'
       end
+      Rails.application.eager_load! if Rails.env.development?
+      if @config[:extensions] == true
+        Module.__send__(:include, Skiplock::Extension)
+      elsif @config[:extensions].is_a?(Array)
+        @config[:extensions].each { |n| n.constantize.__send__(:extend, Skiplock::Extension) if n.safe_constantize }
+      end
       Skiplock.on_errors.freeze unless Skiplock.on_errors.frozen?
     end
 
     def setup_logger
-      @config[:loglevel] = 'info' unless ['debug','info','warn','error','fatal','unknown'].include?(@config[:loglevel].to_s)
+      @config[:loglevel] = 'info' unless ['debug','info','warn','error','fatal','unknown'].include?(@config[:loglevel].to_s.downcase)
       @logger = ActiveSupport::Logger.new(STDOUT)
-      @logger.level = @config[:loglevel].to_sym
+      @logger.level = @config[:loglevel].downcase.to_sym
       Skiplock.logger = @logger
       if @config[:logfile].to_s.length > 0
         @logger.extend(ActiveSupport::Logger.broadcast(::Logger.new(File.join(Rails.root, 'log', @config[:logfile].to_s), 'daily')))
         ActiveJob::Base.logger = nil
       end
     rescue Exception => ex
-      puts "Exception with logger: #{ex.to_s}"
-      puts ex.backtrace.join("\n")
+      @logger.error "Exception with logger: #{ex.to_s}"
+      @logger.error ex.backtrace.join("\n")
       Skiplock.on_errors.each { |p| p.call(ex) }
     end
   end

data/lib/skiplock/patch.rb

@@ -0,0 +1,8 @@
+module Skiplock
+  module Patch
+    def enqueue(options = {})
+      self.instance_variable_set('@skiplock_options', options)
+      super
+    end
+  end
+end

data/lib/skiplock/version.rb

@@ -1,4 +1,4 @@
 module Skiplock
-  VERSION = Version = '1.0.16'
+  VERSION = Version = '1.0.17'
 end
 

data/lib/skiplock/worker.rb

@@ -3,18 +3,32 @@ module Skiplock
     self.implicit_order_column = 'created_at'
     has_many :jobs, inverse_of: :worker
 
+    def self.cleanup(hostname = nil)
+      delete_ids = []
+      self.where(hostname: hostname || Socket.gethostname).each do |worker|
+        sid = Process.getsid(worker.pid) rescue nil
+        delete_ids << worker.id if worker.sid != sid || worker.updated_at < 10.minutes.ago
+      end
+      self.where(id: delete_ids).delete_all if delete_ids.count > 0
+    end
+
+    def self.generate(capacity:, hostname:, master: true)
+      self.create!(pid: Process.pid, sid: Process.getsid(), master: master, hostname: hostname, capacity: capacity)
+    rescue
+      self.create!(pid: Process.pid, sid: Process.getsid(), master: false, hostname: hostname, capacity: capacity)
+    end
+
     def start(worker_num: 0, **config)
-      @config = config
-      @queues_order_query = @config[:queues].map { |q,v| "WHEN queue_name = '#{q}' THEN #{v}" }.join(' ') if @config[:queues].is_a?(Hash) && @config[:queues].count > 0
-      @next_schedule_at = Time.now.to_f
-      @executor = Concurrent::ThreadPoolExecutor.new(min_threads: @config[:min_threads] + 1, max_threads: @config[:max_threads] + 1, max_queue: @config[:max_threads], idletime: 60, auto_terminate: true, fallback_policy: :discard)
       if self.master
-        Job.cleanup(purge_completion: @config[:purge_completion], max_retries: @config[:max_retries])
+        Job.flush
         Cron.setup
       end
+      @config = config
+      @queues_order_query = @config[:queues].map { |q,v| "WHEN queue_name = '#{q}' THEN #{v}" }.join(' ') if @config[:queues].is_a?(Hash) && @config[:queues].count > 0
       @running = true
-      Process.setproctitle("skiplock-#{self.master ? 'master[0]' : 'worker[' + worker_num.to_s + ']'}") if @config[:standalone]
+      @executor = Concurrent::ThreadPoolExecutor.new(min_threads: @config[:min_threads] + 1, max_threads: @config[:max_threads] + 1, max_queue: @config[:max_threads], idletime: 60, auto_terminate: true, fallback_policy: :discard)
       @executor.post { run }
+      Process.setproctitle("skiplock-#{self.master ? 'master[0]' : 'worker[' + worker_num.to_s + ']'}") if @config[:standalone]
     end
 
     def shutdown
@@ -39,6 +53,7 @@ module Skiplock
     def run
       error = false
       listen = false
+      next_schedule_at = Time.now.to_f
       timestamp = Process.clock_gettime(Process::CLOCK_MONOTONIC)
       while @running
         Rails.application.reloader.wrap do
@@ -53,17 +68,17 @@ module Skiplock
                 @connection.reconnect!
                 sleep(0.5)
                 @connection.exec_query('LISTEN "skiplock::jobs"')
-                @next_schedule_at = Time.now.to_f
+                next_schedule_at = Time.now.to_f
               end
-              Job.cleanup if self.master
+              Job.flush if self.master
               error = false
             end
-            if Time.now.to_f >= @next_schedule_at && @executor.remaining_capacity > 0
+            if Time.now.to_f >= next_schedule_at && @executor.remaining_capacity > 0
               job = get_next_available_job
               if job.try(:running)
                 @executor.post { Rails.application.reloader.wrap { job.execute(purge_completion: @config[:purge_completion], max_retries: @config[:max_retries]) } }
               else
-                @next_schedule_at = (job ? job.scheduled_at.to_f : Float::INFINITY)
+                next_schedule_at = (job ? job.scheduled_at.to_f : Float::INFINITY)
               end
             end
             job_notifications = []
@@ -77,7 +92,7 @@ module Skiplock
               job_notifications.each do |n|
                 op, id, worker_id, job_class, queue_name, running, expired_at, finished_at, scheduled_at = n.split(',')
                 next if op == 'DELETE' || running == 'true' || expired_at.to_f > 0 || finished_at.to_f > 0
-                @next_schedule_at = scheduled_at.to_f if scheduled_at.to_f < @next_schedule_at
+                next_schedule_at = scheduled_at.to_f if scheduled_at.to_f < next_schedule_at
               end
             end
             if Process.clock_gettime(Process::CLOCK_MONOTONIC) - timestamp > 60

data/lib/skiplock.rb

@@ -6,11 +6,12 @@ require 'skiplock/cron'
 require 'skiplock/extension'
 require 'skiplock/job'
 require 'skiplock/manager'
+require 'skiplock/patch'
 require 'skiplock/worker'
 require 'skiplock/version'
 
 module Skiplock
-  DEFAULT_CONFIG = { 'extensions' => false, 'logfile' => 'skiplock.log', 'loglevel' => 'info', 'graceful_shutdown' => 15, 'min_threads' => 1, 'max_threads' => 5, 'max_retries' => 20, 'notification' => 'custom', 'purge_completion' => true, 'queues' => { 'default' => 100, 'mailers' => 999 }, 'workers' => 0 }.freeze
+  DEFAULT_CONFIG = { 'extensions' => false, 'logfile' => 'skiplock.log', 'loglevel' => 'info', 'graceful_shutdown' => 15, 'min_threads' => 1, 'max_threads' => 10, 'max_retries' => 20, 'notification' => 'custom', 'purge_completion' => true, 'queues' => { 'default' => 100, 'mailers' => 999 }, 'workers' => 0 }.freeze
 
   def self.logger=(l)
     @logger = l
@@ -33,4 +34,5 @@ module Skiplock
   def self.table_name_prefix
     'skiplock.'
   end
-end
+end
+ActiveJob::Base.__send__(:include, Skiplock::Patch)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: skiplock
 version: !ruby/object:Gem::Version
-  version: 1.0.16
+  version: 1.0.17
 platform: ruby
 authors:
 - Tin Vo
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-09-10 00:00:00.000000000 Z
+date: 2021-09-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activejob
@@ -87,6 +87,7 @@ files:
 - lib/skiplock/extension.rb
 - lib/skiplock/job.rb
 - lib/skiplock/manager.rb
+- lib/skiplock/patch.rb
 - lib/skiplock/version.rb
 - lib/skiplock/worker.rb
 homepage: https://github.com/vtt/skiplock