background_worker 0.7.0 → 0.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 37f371795b57bf7461a9f02c9f74195daf9d3cb61328fd0eca5f69a2c61447b6
-  data.tar.gz: 393896f93efac8a56c0806a8664ea381fff12ff31a2e0e31c210d6a3480694b8
+  metadata.gz: 6354bdc8bc64824ab09d3b2666d1bfcab6c6b02f7b5c5e2cab58902e840eaf7b
+  data.tar.gz: 49f0ffc416005df1da66eb112852dc0eb8246978f3e477fdefdccda9eef3e0f5
 SHA512:
-  metadata.gz: dae022eecbd54ce73185739df605b3fa5ffd1efc12e411d86bd76f6bfac03f4e20616ac20ffdda04d7c3ef3c3d3d403dac69754a45b5ca9d6fb57daab2444acc
-  data.tar.gz: 0f9f04c606150a637744facdc4c9d9bb02ff1918d52b24fd92f5ebb47ec3606aab2e59567355422b485924352cc471f29e18d4be6438378e3ead11e0aeff3c96
+  metadata.gz: 306de71726dc7d080ce55e51617e926d84cc99b7abec077381ea820e4e2434c63c023e3ed97ac60f0bd15bf230af9533fb0b411544436e9ac4099bf7e2057d15
+  data.tar.gz: f5d75d708b036479a944632f6c38a8be872125ce6c7b8459b72f3f9266a9a2c2cd027aad93a1d59d8ff82d665dec05ef9101bf61b32cc83ab10bcd70a3e214be

data/CHANGELOG.md

@@ -1,7 +1,25 @@
 # Change Log
+
 All notable changes to this project will be documented in this file.  
 This project adheres to [Semantic Versioning](http://semver.org/).  
-This changelog adheres to [Keep a CHANGELOG](http://keepachangelog.com/).  
+This changelog adheres to [Keep a CHANGELOG](http://keepachangelog.com/).
+
+## 0.9.0
+
+- [PLAT-749] Rename `uid` as `job_id` and make it a base property of job.
+- [PLAT-759] Add callbacks
+- [PLAT-761] Extract logging concern
+- [PLAT-760] Extract status concern
+- [PLAT-762] Perform now and later will return job object
+- [PLAT-780] Fix callbacks
+
+## 0.8.1
+
+- Fix version
+
+## 0.8.0
+
+- [PLAT-747] Remove the ability to pass through `method_name`
 
 ## 0.7.0
 
@@ -24,14 +42,20 @@ This changelog adheres to [Keep a CHANGELOG](http://keepachangelog.com/).
 - [TT-6292] Support Rails 5.2 built-in redis cache, remove legacy supports
 
 ## 0.2.1
+
 ### Fixed
+
 - [RU-123] Worker disconnecting within transactions in rails 4+
 
 ## 0.2.0
+
 ### Added
+
 - [RU-79] Release connections after execution for Rails 4
 
 ## 0.1.0
+
 ### Added
+
 - [TT-1392] Changelog file
 - [TT-2141] Only verify connections for Rails 3

data/README.md

@@ -10,7 +10,7 @@ Start by making a worker class which extends from BackgroundWorker::Base
 
 ```ruby
     class MyWorker < BackgroundWorker::Base
-      def my_task(options={})
+      def perform(options={})
         report_progress('Starting')
         if options[:message].blank?
           report_failed("No message provided")
@@ -27,7 +27,7 @@ Then, when you want to perform a task in the background, use
 klass#perform_in_background which exists in Base:
 
 ```ruby
-    worker_id = MyWorker.perform_in_background(:my_task, message: "hello!")
+    worker_id = MyWorker.perform_later(message: "hello!")
 ```
 
 # Backgrounded
@@ -37,8 +37,8 @@ provide an #enqueue_with configuration like so:
 
 ```ruby
     BackgroundWorker.configure(
-      enqueue_with: -> klass, method_name, options {
-        Resque.enqueue(klass, method_name, options)
+      enqueue_with: -> klass, options {
+        Resque.enqueue(klass, options)
       }
     )
 ```

data/lib/background_worker/base.rb

@@ -1,88 +1,57 @@
-require 'background_worker/uid'
+require "active_support/callbacks"
 require 'background_worker/persistent_state'
 require 'background_worker/worker_execution'
+require 'background_worker/logging'
+require 'background_worker/state'
 
 module BackgroundWorker
   class Base
-    attr_accessor :uid, :state
+    include ActiveSupport::Callbacks
+    include BackgroundWorker::Logging
+    include BackgroundWorker::State
+    attr_accessor :job_id, :options
+    define_callbacks :perform
+    define_callbacks :enqueue
 
     def initialize(options = {})
-      @uid = options[:uid]
+      @options = options.symbolize_keys
+      @job_id = @options[:job_id] || SecureRandom.uuid
 
-      # Store state persistently, to enable status checkups & progress reporting
-      @state = BackgroundWorker::PersistentState.new(@uid, options.except(:uid))
       log("Created #{self.class}")
-      log("Options are: #{options.inspect}")
+      log("Options are: #{@options.inspect}")
     end
 
-    # Report progress...
-    def report_progress(message)
-      state.message = message
-      state.save
-    end
-
-    # Report a minor progress -- may get called a lot, so don't save it so often
-    def report_minor_progress(message)
-      state.message = message
-
-      # Only report minor events once per second
-      @last_report ||= Time.now - 2
-      time_elapsed =  Time.now - @last_report
-      return unless time_elapsed > 1
-
-      @last_report = Time.now
-      state.save
-    end
-
-    def report_successful(message = 'Finished successfully')
-      state.set_completed(message, :successful)
-    end
-
-    def report_failed(message = 'Failed', detailed_message = nil)
-      state.detailed_message = detailed_message
-      state.set_completed(message, :failed)
-    end
-
-    def logger
-      BackgroundWorker.logger
+    def perform_now(options)
+      run_callbacks :perform do
+        perform(options)
+      end
     end
 
-    def log(message, options = {})
-      severity = options.fetch(:severity, :info)
-      logger.send(severity, "uid=#{uid} #{message}")
+    def enqueue(klass)
+      run_callbacks :enqueue do
+        BackgroundWorker.enqueue(klass, options.merge(job_id: job_id))
+      end
     end
 
     class << self
       attr_reader :queue
-      def get_state_of(worker_id)
-        BackgroundWorker::PersistentState.get_state_of(worker_id)
-      end
 
       # Public method to do in background...
-      def perform_later(method_name, options = {})
-        opts = options.symbolize_keys
-
-        method_name = method_name.to_sym
-        opts[:uid] ||= BackgroundWorker::Uid.new(to_s, method_name).generate
-
-        # Store into shared-cache before kicking job off
-        BackgroundWorker::PersistentState.new(opts[:uid], opts.except(:uid))
-
+      def perform_later(options = {})
+        worker = new(options)
         # Enqueue to the background queue
-        BackgroundWorker.enqueue(self, method_name, opts)
-
-        opts[:uid]
+        worker.enqueue(self)
+        worker
       end
 
       # This method is called by the job runner
-      #
-      # It will just call your preferred method in the worker.
-      def perform_now(method_name, options = {})
+      def perform_now(options = {})
         BackgroundWorker.verify_active_connections! if BackgroundWorker.config.backgrounded
 
         worker = new(options)
-        execution = WorkerExecution.new(worker, method_name, options)
+        execution = WorkerExecution.new(worker, options)
         execution.call
+        worker
       ensure
         BackgroundWorker.release_connections! if BackgroundWorker.config.backgrounded
       end
@@ -90,6 +59,22 @@ module BackgroundWorker
       def queue_as(queue = nil)
         @queue = queue&.to_sym || :default
       end
+
+      def before_perform(*filters, &blk)
+        set_callback(:perform, :before, *filters, &blk)
+      end
+
+      def after_perform(*filters, &blk)
+        set_callback(:perform, :after, *filters, &blk)
+      end
+
+      def before_enqueue(*filters, &blk)
+        set_callback(:enqueue, :before, *filters, &blk)
+      end
+
+      def after_enqueue(*filters, &blk)
+        set_callback(:enqueue, :after, *filters, &blk)
+      end
     end
   end
 end

data/lib/background_worker/config.rb

@@ -27,8 +27,8 @@ module BackgroundWorker
       @after_exception.call(e)
     end
 
-    def foreground_enqueue(klass, method_name, opts)
-      klass.perform_now(method_name, opts)
+    def foreground_enqueue(klass, opts)
+      klass.perform_now(opts)
     end
 
     def default_after_exception(e)

data/lib/background_worker/logging.rb

@@ -0,0 +1,16 @@
+require 'active_support/concern'
+
+module BackgroundWorker
+  module Logging
+    extend ActiveSupport::Concern
+
+    def logger
+      BackgroundWorker.logger
+    end
+
+    def log(message, options = {})
+      severity = options.fetch(:severity, :info)
+      logger.send(severity, "job_id=#{job_id} #{message}")
+    end
+  end
+end

data/lib/background_worker/persistent_state.rb

@@ -7,12 +7,12 @@ module BackgroundWorker
   class PersistentState
     attr_accessor :message, :detailed_message, :status, :completed, :data
 
-    def initialize(worker_uid, data)
+    def initialize(job_id, data)
       @message = 'Waiting for task to queue...'
       @status = :processing
       @completed = false
 
-      @worker_uid = worker_uid
+      @job_id = job_id
       @data = data
       save
     end
@@ -27,13 +27,13 @@ module BackgroundWorker
 
     # Save persistently (well for an hour at least)
     def save
-      Rails.cache.write(@worker_uid, generate_persistent_hash, expires_in: 1.hour)
+      Rails.cache.write(@job_id, generate_persistent_hash, expires_in: 1.hour)
     end
 
     # Get a report out the queue
     # (was .get_report, then .progress)
-    def self.get_state_of(worker_uid)
-      Rails.cache.read(worker_uid)
+    def self.get_state_of(job_id)
+      Rails.cache.read(job_id)
     end
 
     private

data/lib/background_worker/state.rb

@@ -0,0 +1,47 @@
+require 'active_support/concern'
+
+module BackgroundWorker
+  module State
+    extend ActiveSupport::Concern
+    attr_accessor :state
+
+    # Report progress...
+    def report_progress(message)
+      state.message = message
+      state.save
+    end
+
+    # Report a minor progress -- may get called a lot, so don't save it so often
+    def report_minor_progress(message)
+      state.message = message
+
+      # Only report minor events once per second
+      @last_report ||= Time.now - 2
+      time_elapsed =  Time.now - @last_report
+      return unless time_elapsed > 1
+
+      @last_report = Time.now
+      state.save
+    end
+
+    def report_successful(message = 'Finished successfully')
+      state.set_completed(message, :successful)
+    end
+
+    def report_failed(message = 'Failed', detailed_message = nil)
+      state.detailed_message = detailed_message
+      state.set_completed(message, :failed)
+    end
+
+    def state
+      # Store state persistently, to enable status checkups & progress reporting
+      @state ||= BackgroundWorker::PersistentState.new(job_id, @options)
+    end
+
+    module ClassMethods
+      def get_state_of(job_id)
+        BackgroundWorker::PersistentState.get_state_of(job_id)
+      end
+    end
+  end
+end

data/lib/background_worker/version.rb

@@ -1,3 +1,3 @@
 module BackgroundWorker
-  VERSION = '0.7.0'
+  VERSION = '0.9.0'
 end

data/lib/background_worker/worker_execution.rb

@@ -2,15 +2,13 @@ module BackgroundWorker
   class WorkerExecution
     attr_reader :worker, :method_name, :options
 
-    def initialize(worker, method_name, options)
-      fail ArgumentError, "'uid' is required to identify worker" unless options[:uid].present?
+    def initialize(worker, options)
       @worker = worker
-      @method_name = method_name
       @options = options
     end
 
     def call
-      worker.send(method_name, options)
+      worker.perform_now(options)
       report_implicitly_successful unless completed?
 
     rescue StandardError => e

data/lib/background_worker.rb

@@ -8,15 +8,15 @@ module BackgroundWorker
   # eg:
   # BackgroundWorker.configure(
   #   logger: Rails.logger,
-  #   enqueue_with: -> klass, method_name, opts { Resque.enqueue(klass, method_name, opts) },
+  #   enqueue_with: -> klass, opts { Resque.enqueue(klass, opts) },
   #   after_exception: -> e { Airbrake.notify(e) }
   # )
   def self.configure(options)
     @config = Config.new(options)
   end
 
-  def self.enqueue(klass, method_name, options)
-    config.enqueue_with.call(klass, method_name, options)
+  def self.enqueue(klass, options)
+    config.enqueue_with.call(klass, options)
   end
 
   def self.logger

data/spec/base_spec.rb

@@ -18,7 +18,7 @@ describe BackgroundWorker::Base do
   let(:model_class) { Model = Class.new(ActiveRecord::Base) }
   let(:worker_class) {
     Class.new(BackgroundWorker::Base) do
-      def store_in_cache(opts)
+      def perform(opts)
         Rails.cache.store(opts[:value])
       end
     end
@@ -32,7 +32,7 @@ describe BackgroundWorker::Base do
 
   it 'should perform action and handle transactions/connections appropriately' do
     Model.transaction do
-      worker_class.perform_later(:store_in_cache, value: 42)
+      worker_class.perform_later(value: 42)
     end
     expect(cache).to have_received(:store).with(42)
   end
@@ -44,3 +44,51 @@ describe BackgroundWorker::Base do
     end
   end
 end
+
+describe BackgroundWorker::Base do
+  describe 'callbacks' do
+    let(:cache) { double(write: nil, read: nil, reconnect: nil, store: nil) }
+    let(:model_class) { Model = Class.new(ActiveRecord::Base) }
+
+    let(:worker_class) {
+      Class.new(BackgroundWorker::Base) do
+        def perform(opts)
+          Rails.cache.store(opts[:value])
+        end
+
+        before_perform do
+          Rails.cache.store('before_perform_action')
+        end
+
+        after_perform do
+          Rails.cache.store('after_perform_action')
+        end
+
+        before_enqueue do
+          Rails.cache.store('before_enqueue_action')
+        end
+
+        after_enqueue do
+          Rails.cache.store('after_enqueue_action')
+        end
+      end
+    }
+
+    before do
+      stub_const 'Model', model_class
+      stub_const 'Rails', double(cache: cache, env: 'production')
+      BackgroundWorker.configure(backgrounded: false)
+    end
+
+    it 'should call perform callbacks' do
+      Model.transaction do
+        worker_class.perform_later(value: 42)
+      end
+      expect(cache).to have_received(:store).with('before_enqueue_action')
+      expect(cache).to have_received(:store).with('before_perform_action')
+      expect(cache).to have_received(:store).with(42)
+      expect(cache).to have_received(:store).with('after_perform_action')
+      expect(cache).to have_received(:store).with('after_enqueue_action')
+    end
+  end
+end

data/spec/support/coverage_loader.rb

@@ -1,3 +1,3 @@
 require 'coverage/kit'
 
-Coverage::Kit.setup(minimum_coverage: 82.75)
+Coverage::Kit.setup(minimum_coverage: 84.60)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: background_worker
 version: !ruby/object:Gem::Version
-  version: 0.7.0
+  version: 0.9.0
 platform: ruby
 authors:
 - Michael Noack
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-09-07 00:00:00.000000000 Z
+date: 2022-09-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -152,15 +152,15 @@ files:
 - lib/background_worker.rb
 - lib/background_worker/base.rb
 - lib/background_worker/config.rb
+- lib/background_worker/logging.rb
 - lib/background_worker/persistent_state.rb
-- lib/background_worker/uid.rb
+- lib/background_worker/state.rb
 - lib/background_worker/version.rb
 - lib/background_worker/worker_execution.rb
 - spec/base_spec.rb
 - spec/schema.rb
 - spec/spec_helper.rb
 - spec/support/coverage_loader.rb
-- spec/uid_spec.rb
 homepage: http://github.com/sealink/background_worker
 licenses:
 - MIT
@@ -189,4 +189,3 @@ test_files:
 - spec/schema.rb
 - spec/spec_helper.rb
 - spec/support/coverage_loader.rb
-- spec/uid_spec.rb

data/lib/background_worker/uid.rb

@@ -1,25 +0,0 @@
-# Generates a unique identifier for a particular job identified by class_name/method
-module BackgroundWorker
-  class Uid
-    attr_reader :class_name, :method
-
-    def initialize(class_name, method)
-      @class_name = class_name
-      @method = method
-    end
-
-    def generate
-      "#{generate_uid_name}:#{generate_uid_hash}"
-    end
-
-    private
-
-    def generate_uid_hash
-      ::Digest::MD5.hexdigest("#{class_name}:#{method}:#{rand(1 << 64)}:#{Time.now}")
-    end
-
-    def generate_uid_name
-      "#{class_name.underscore}/#{method}".split('/').join(':')
-    end
-  end
-end

data/spec/uid_spec.rb

@@ -1,12 +0,0 @@
-require 'spec_helper'
-
-describe BackgroundWorker::Uid do
-  let(:class_name) { 'CopyWorker' }
-  let(:method) { 'make_copy' }
-  let(:uid_object) { BackgroundWorker::Uid.new(class_name, method) }
-
-  context '#generate' do
-    subject(:uid) { uid_object.generate }
-    it { is_expected.to match(/copy_worker:make_copy:[0-9a-f]{16}/) }
-  end
-end