backburner 0.1.2 → 0.2.0

data/CHANGELOG.md

@@ -1,6 +1,10 @@
 # CHANGELOG
 
-## Version 0.1.3 (Unreleased)
+## Version 0.2.1 (Unreleased)
+
+## Version 0.2.0 (Nov 7th 2012)
+
+ * Add new plugin hooks feature (see HOOKS.md)
 
 ## Version 0.1.2 (Nov 7th 2012)
 

data/HOOKS.md

@@ -0,0 +1,56 @@
+# Backburner Hooks
+
+You can customize Backburner or write plugins using its hook API. 
+In many cases you can use a hook rather than mess around with Backburner's internals.
+
+## Job Hooks 
+
+Hooks are transparently adapted from [Resque](https://github.com/defunkt/resque/blob/master/docs/HOOKS.md), so
+if you are familiar with their hook API, now you can use nearly the same ones with beanstalkd and backburner!
+
+There are a variety of hooks available that are triggered during the lifecycle of a job:
+
+* `before_enqueue`: Called with the job args before a job is placed on the queue.
+  If the hook returns `false`, the job will not be placed on the queue.
+
+* `after_enqueue`: Called with the job args after a job is placed on the queue.
+  Any exception raised propagates up to the code which queued the job.
+
+* `before_perform`: Called with the job args before perform. If a hook returns false,
+  the job is aborted. Other exceptions are treated like regular job exceptions.
+
+* `after_perform`: Called with the job args after it performs. Uncaught
+  exceptions will be treated like regular job exceptions.
+
+* `around_perform`: Called with the job args. It is expected to yield in order
+	to perform the job (but is not required to do so). It may handle exceptions
+	thrown by perform, but uncaught exceptions will be treated like regular job exceptions.
+
+* `on_failure`: Called with the exception and job args if any exception occurs
+  while performing the job (or hooks).
+
+Hooks are just methods prefixed with the hook type. For example:
+
+```ruby
+class SomeJob
+  def self.before_perform_log_job(*args)
+    Logger.info "About to perform #{self} with #{args.inspect}"
+  end
+
+  def self.on_failure_bury(e, *args)
+    Logger.info "Performing #{self} caused an exception (#{e})"
+    self.bury
+  end
+
+  def self.perform(*args)
+    # ...
+  end
+end
+```
+
+You can also setup modules to create compose-able and reusable hooks for your jobs.
+
+## Worker Hooks
+
+Coming soon. What do you need here? Just let me know!
+

data/README.md

@@ -83,20 +83,20 @@ Backburner is extremely simple to setup. Just configure basic settings for backb
 
 ```ruby
 Backburner.configure do |config|
-  config.beanstalk_url = ["beanstalk://127.0.0.1", "beanstalk://127.0.0.1:11301"]
-  config.tube_namespace = "some.app.production"
-  config.on_error = lambda { |e| puts e }
+  config.beanstalk_url    = ["beanstalk://127.0.0.1", "beanstalk://127.0.0.1:11301"]
+  config.tube_namespace   = "some.app.production"
+  config.on_error         = lambda { |e| puts e }
   config.max_job_retries  = 3 # default 0 retries
   config.retry_delay      = 2 # default 5 seconds
   config.default_priority = 65536
   config.respond_timeout  = 120
-  config.logger = Logger.new(STDOUT)
+  config.logger           = Logger.new(STDOUT)
 end
 ```
 
  * The `beanstalk_url` supports a string such as 'beanstalk://127.0.0.1' or an array of addresses.
  * The `tube_namespace` is the prefix used for all tubes related to this backburner queue.
- * The `on_error` is a callback that gets invoked with the error whenever a job fails.
+ * The `on_error` is a callback that gets invoked with the error whenever any job in the system fails.
  * The `max_job_retries` determines how many times to retry a job before burying
  * The `retry_delay` determines the base time to wait (in secs) between retries
  * The `logger` is the logger object written to when backburner wants to report info or errors.
@@ -231,6 +231,14 @@ Backburner.default_queues << NewsletterJob.queue
 
 The `default_queues` stores the specific list of queues that should be processed by default by a worker.
 
+### Hooks
+
+Backburner is highly extensible and can be tailored to your needs by using various hooks that
+can be triggered across the job processing lifecycle. 
+Often using hooks is much easier then trying to monkey patch the externals. 
+
+Check out [HOOKS.md](HOOKS.md) for a detailed overview on using hooks.
+
 ### Failures
 
 When a job fails in backburner (usually because an exception was raised), the job will be released 

data/TODO

@@ -1,6 +1,4 @@
 - Custom front-end in sinatra for viewing beanstalk jobs
   - Refer to https://github.com/denniskuczynski/beanstalkd_view
 - Fork jobs to control memory
-  - https://github.com/michaeldwan/stalker/commit/386267690a7c03e11d1a8b7b6f08b7c9c7cd2c0d
-- Add hooks
   - https://github.com/michaeldwan/stalker/commit/386267690a7c03e11d1a8b7b6f08b7c9c7cd2c0d

data/examples/hooked.rb

@@ -0,0 +1,87 @@
+$:.unshift "lib"
+require 'backburner'
+
+$fail = 0
+class User
+  include Backburner::Performable
+
+  # Called with the job args before a job is placed on the queue.
+  # !! If the hook returns `false`, the job will not be placed on the queue.
+  def self.before_enqueue_foo(*args)
+    puts "[before_enqueue] Just about to enqueue #{self} with #{args.inspect}"
+  end
+
+  # Called with the job args after a job is placed on the queue.
+  # !! Any exception raised propagates up to the code which queued the job.
+  def self.after_enqueue_foo(*args)
+    puts "[after_enqueue] Finished enqueuing #{self} with #{args.inspect}"
+  end
+
+  # Called with the job args before perform. If it raises
+  #  `Backburner::Job::DontPerform`, the job is aborted. Other exceptions
+  #  are treated like regular job exceptions.
+  def self.before_perform_foo(*args)
+    puts "[before_perform] Just about to perform #{self} with #{args.inspect}"
+  end
+
+  # Called with the job args after it performs. Uncaught
+  #   exceptions will be treated like regular job exceptions.
+  def self.after_perform_foo(*args)
+    puts "[after_perform] Just finished performing #{self} with #{args.inspect}"
+  end
+
+  # Called with the job args. It is expected to yield in order
+  #   to perform the job (but is not required to do so). It may handle exceptions
+  #   thrown by perform, but uncaught exceptions will be treated like regular job exceptions.
+  def self.around_perform_bar(*args)
+    puts "[around_perform_bar before] About to perform #{self} with #{args.inspect}"
+    yield
+    puts "[around_perform_bar after] Just after performing #{self} with #{args.inspect}"
+  end
+
+  # Called with the job args. It is expected to yield in order
+  #   to perform the job (but is not required to do so). It may handle exceptions
+  #   thrown by perform, but uncaught exceptions will be treated like regular job exceptions.
+  def self.around_perform_cat(*args)
+    puts "[around_perform_cat before] About to perform #{self} with #{args.inspect}"
+    yield
+    puts "[around_perform_cat after] Just after performing #{self} with #{args.inspect}"
+  end
+
+  # Called with the job args. It is expected to yield in order
+  #   to perform the job (but is not required to do so). It may handle exceptions
+  #   thrown by perform, but uncaught exceptions will be treated like regular job exceptions.
+  def self.around_perform_foo(*args)
+    puts "[around_perform_foo before] About to perform #{self} with #{args.inspect}"
+    yield
+    puts "[around_perform_foo after] Just after performing #{self} with #{args.inspect}"
+  end
+
+  # Called with the exception and job args if any exception occurs
+  #  while performing the job (or hooks).
+  def self.on_failure_foo(ex, *args)
+    puts "[on_failure] Failure #{ex.inspect} occurred for job #{self} with #{args.inspect}"
+  end
+
+  def self.foo
+    $fail += 1
+    raise "Fail!" if $fail == 1
+    puts "This is the job running successfully!!"
+  end
+end
+
+# Configure Backburner
+Backburner.configure do |config|
+  config.beanstalk_url = "beanstalk://127.0.0.1"
+  config.tube_namespace = "demo.production"
+  config.on_error = lambda { |e| puts "HEY!!! #{e.class}" }
+  config.max_job_retries = 1
+  config.retry_delay     = 0
+end
+
+# Enqueue tasks
+User.async.foo
+
+# Run work
+# Backburner.default_queues << "user"
+Backburner.work

data/lib/backburner.rb

@@ -7,6 +7,7 @@ require 'backburner/helpers'
 require 'backburner/configuration'
 require 'backburner/logger'
 require 'backburner/connection'
+require 'backburner/hooks'
 require 'backburner/performable'
 require 'backburner/worker'
 require 'backburner/queue'

data/lib/backburner/hooks.rb

@@ -0,0 +1,51 @@
+module Backburner
+  module Hooks
+    # Triggers all method hooks that match the given event type with specified arguments.
+    #
+    # @example
+    #   invoke_hook_events(:before_enqueue, 'some', 'args')
+    #   invoke_hook_events(:after_perform, 5)
+    #
+    def invoke_hook_events(event, *args)
+      res = find_hook_events(event).map { |e| send(e, *args) }
+      return false if res.any? { |result| result == false }
+      res
+    end
+
+    # Triggers all method hooks that match given around event type. Used for 'around' hooks
+    # that stack over the original task cumulatively onto one another.
+    #
+    # The final block will be the one that actually invokes the
+    # original task after calling all other around blocks.
+    #
+    # @example
+    #   around_hook_events(:around_perform) { job.perform }
+    #
+    def around_hook_events(event, *args, &block)
+      raise "Please pass a block to hook events!" unless block_given?
+      around_hooks = find_hook_events(event).reverse
+      aggregate_filter = Proc.new { |&blk| blk.call }
+      around_hooks.each do |ah|
+        prior_around_filter = aggregate_filter
+        aggregate_filter = Proc.new do |&blk|
+          method(ah).call(*args) do
+            prior_around_filter.call(&blk)
+          end
+        end
+      end
+      aggregate_filter.call(&block)
+    end
+
+    protected
+
+    # Returns all methods that match given hook type
+    #
+    # @example
+    #   find_hook_events(:before_enqueue)
+    #   # => ['before_enqueue_foo', 'before_enqueue_bar']
+    #
+    def find_hook_events(event)
+      (self.methods - Object.methods).grep(/^#{event}/).sort
+    end
+  end # Hooks
+end # Backburner

data/lib/backburner/job.rb

@@ -40,8 +40,19 @@ module Backburner
     #   @task.process
     #
     def process
-      timeout_job_after(task.ttr - 1) { job_class.perform(*args) }
+      # Invoke before hook and stop if false
+      res = job_class.invoke_hook_events(:before_perform, *args)
+      return false unless res
+      # Execute the job
+      job_class.around_hook_events(:around_perform, *args) do
+        timeout_job_after(task.ttr - 1) { job_class.perform(*args) }
+      end
       task.delete
+      # Invoke after perform hook
+      job_class.invoke_hook_events(:after_perform, *args)
+    rescue => e
+      job_class.invoke_hook_events(:on_failure, e, *args)
+      raise e
     end
 
     protected

data/lib/backburner/queue.rb

@@ -2,6 +2,7 @@ module Backburner
   module Queue
     def self.included(base)
       base.send(:extend, Backburner::Helpers)
+      base.send(:extend, Backburner::Hooks)
       base.extend ClassMethods
       Backburner::Worker.known_queue_classes << base
     end
@@ -35,5 +36,5 @@ module Backburner
         end
       end
     end # ClassMethods
-  end # Job
+  end # Queue
 end # Backburner

data/lib/backburner/version.rb

@@ -1,3 +1,3 @@
 module Backburner
-  VERSION = "0.1.2"
+  VERSION = "0.2.0"
 end

data/lib/backburner/worker.rb

@@ -24,8 +24,12 @@ module Backburner
       delay = [0, opts[:delay].to_i].max
       ttr   = opts[:ttr] || Backburner.configuration.respond_timeout
       tube  = connection.tubes[expand_tube_name(opts[:queue]  || job_class)]
+      res = job_class.invoke_hook_events(:before_enqueue, *args)
+      return false unless res # stop if hook is false
       data = { :class => job_class.name, :args => args }
       tube.put data.to_json, :pri => pri, :delay => delay, :ttr => ttr
+      job_class.invoke_hook_events(:after_enqueue, *args)
+      return true
     end
 
     # Starts processing jobs in the specified tube_names

data/test/fixtures/hooked.rb

@@ -0,0 +1,114 @@
+$hooked_fail_count = 0
+class HookFailError < RuntimeError; end
+
+class HookedObjectBeforeEnqueueFail
+  include Backburner::Performable
+
+  def self.before_enqueue_abe(*args)
+    puts "!!before_enqueue_foo!! #{args.inspect}"
+  end
+
+  def self.before_enqueue_bar(*args)
+    return false
+  end
+end
+
+
+class HookedObjectAfterEnqueueFail
+  extend Backburner::Hooks
+
+  def self.after_enqueue_abe(*args)
+    puts "!!after_enqueue_foo!! #{args.inspect}"
+  end
+
+  def self.after_enqueue_bar(*args)
+    raise HookFailError, "Fail HookedObjectAfterEnqueueFail"
+  end
+end
+
+class HookedObjectBeforePerformFail
+  include Backburner::Performable
+
+  def self.before_perform_abe(*args)
+    puts "!!before_perform_foo!! #{args.inspect}"
+  end
+
+  def self.before_perform_foo(*args)
+    return false
+  end
+
+  def self.foo(x)
+    puts "Fail ran!!"
+    raise HookFailError, "HookedObjectJobFailure on foo!"
+  end
+end
+
+class HookedObjectAfterPerformFail
+  extend Backburner::Hooks
+
+  def self.after_perform_abe(*args)
+    puts "!!after_perform_foo!! #{args.inspect}"
+  end
+
+  def self.after_perform_bar(*args)
+    raise HookFailError, "Fail HookedObjectAfterEnqueueFail"
+  end
+end
+
+class HookedObjectJobFailure
+  extend Backburner::Hooks
+
+  def self.foo(x)
+    raise HookFailError, "HookedObjectJobFailure on foo!"
+  end
+end
+
+class HookedObjectSuccess
+  include Backburner::Performable
+
+  def self.before_enqueue_foo(*args)
+    puts "!!before_enqueue_foo!! #{args.inspect}"
+  end
+
+  def self.before_enqueue_bar(*args)
+    puts "!!before_enqueue_bar!! #{args.inspect}"
+  end
+
+  def self.after_enqueue_foo(*args)
+    puts "!!after_enqueue_foo!! #{args.inspect}"
+  end
+
+  def self.after_enqueue_bar(*args)
+    puts "!!after_enqueue_bar!! #{args.inspect}"
+  end
+
+  def self.before_perform_foo(*args)
+    puts "!!before_perform_foo!! #{args.inspect}"
+  end
+
+  def self.after_perform_foo(*args)
+    puts "!!after_perform_foo!! #{args.inspect}"
+  end
+
+  def self.around_perform_bar(*args)
+    puts "!!BEGIN around_perform_bar!! #{args.inspect}"
+    yield
+    puts "!!END around_perform_bar!! #{args.inspect}"
+  end
+
+  def self.around_perform_cat(*args)
+    puts "!!BEGIN around_perform_cat!! #{args.inspect}"
+    yield
+    puts "!!END around_perform_cat!! #{args.inspect}"
+  end
+
+  def self.on_failure_foo(ex, *args)
+    puts "!!on_failure_foo!! #{ex.inspect} #{args.inspect}"
+  end
+
+  def self.foo(x)
+    $hooked_fail_count += 1
+    raise HookFailError, "Fail!" if $hooked_fail_count == 1
+    puts "This is the job running successfully!! #{x.inspect}"
+  end
+end # HookedObjectSuccess

data/test/fixtures/test_jobs.rb

@@ -0,0 +1,27 @@
+$worker_test_count = 0
+$worker_success = false
+
+class TestJob
+  include Backburner::Queue
+  queue_priority 1000
+  def self.perform(x, y); $worker_test_count += x + y; end
+end
+
+class TestFailJob
+  include Backburner::Queue
+  def self.perform(x, y); raise RuntimeError; end
+end
+
+class TestRetryJob
+  include Backburner::Queue
+  def self.perform(x, y)
+    $worker_test_count += 1
+    raise RuntimeError unless $worker_test_count > 2
+    $worker_success = true
+  end
+end
+
+class TestAsyncJob
+  include Backburner::Performable
+  def self.foo(x, y); $worker_test_count = x * y; end
+end

data/test/hooks_test.rb

@@ -0,0 +1,90 @@
+require File.expand_path('../test_helper', __FILE__)
+require File.expand_path('../fixtures/hooked', __FILE__)
+
+describe "Backburner::Hooks module" do
+  before do
+    $hooked_fail_count = 0
+  end
+
+  describe "for invoke_hook_events method" do
+    describe "with before_enqueue" do
+      it "should support successful invocation" do
+        out = silenced { @res = HookedObjectSuccess.invoke_hook_events(:before_enqueue, 5, 6) }
+        assert_equal [nil, nil], @res
+        assert_match /!!before_enqueue_foo!! \[5\, 6\]/, out
+        assert_match /!!before_enqueue_bar!! \[5\, 6\]/, out
+      end
+
+      it "should support fail case" do
+        out = silenced { @res = HookedObjectBeforeEnqueueFail.invoke_hook_events(:before_enqueue, 5, 6) }
+        assert_equal false, @res
+        assert_match /!!before_enqueue_foo!! \[5\, 6\]/, out
+      end
+    end # before_enqueue
+
+    describe "with after_enqueue" do
+      it "should support successful invocation" do
+        out = silenced { HookedObjectSuccess.invoke_hook_events(:after_enqueue, 7, 8) }
+        assert_match /!!after_enqueue_foo!! \[7\, 8\]/, out
+        assert_match /!!after_enqueue_bar!! \[7\, 8\]/, out
+      end
+
+      it "should support fail case" do
+        assert_raises(HookFailError) do
+          silenced { @res = HookedObjectAfterEnqueueFail.invoke_hook_events(:after_enqueue, 5, 6) }
+        end
+      end
+    end # after_enqueue
+
+    describe "with before_perform" do
+      it "should support successful invocation" do
+        out = silenced { HookedObjectSuccess.invoke_hook_events(:before_perform, 1, 2) }
+        assert_match /!!before_perform_foo!! \[1\, 2\]/, out
+      end
+
+      it "should support fail case" do
+        out = silenced { @res = HookedObjectBeforePerformFail.invoke_hook_events(:before_perform, 5, 6) }
+        assert_equal false, @res
+        assert_match /!!before_perform_foo!! \[5\, 6\]/, out
+      end
+    end # before_perform
+
+    describe "with after_perform" do
+      it "should support successful invocation" do
+        out = silenced { HookedObjectSuccess.invoke_hook_events(:after_perform, 3, 4) }
+        assert_match /!!after_perform_foo!! \[3\, 4\]/, out
+      end
+
+      it "should support fail case" do
+        assert_raises(HookFailError) do
+          silenced { @res = HookedObjectAfterPerformFail.invoke_hook_events(:after_perform, 5, 6) }
+        end
+      end
+    end # after_perform
+
+    describe "with on_failure" do
+      it "should support successful invocation" do
+        out = silenced { HookedObjectSuccess.invoke_hook_events(:on_failure, RuntimeError, 10) }
+        assert_match /!!on_failure_foo!! RuntimeError \[10\]/, out
+      end
+    end # on_failure
+  end # invoke_hook_events
+
+  describe "for around_hook_events method" do
+    describe "with around_perform" do
+      it "should support successful invocation" do
+        out = silenced do
+          HookedObjectSuccess.around_hook_events(:around_perform, 7, 8) {
+            puts "!!FIRED!!"
+          }
+        end
+        assert_match /BEGIN.*?bar.*BEGIN.*cat.*FIRED.*END.*cat.*END.*bar/m, out
+        assert_match /!!BEGIN around_perform_bar!! \[7\, 8\]/, out
+        assert_match /!!BEGIN around_perform_cat!! \[7\, 8\]/, out
+        assert_match /!!FIRED!!/, out
+        assert_match /!!END around_perform_cat!! \[7\, 8\]/, out
+        assert_match /!!END around_perform_bar!! \[7\, 8\]/, out
+      end
+    end # successful
+  end # around_hook_events
+end # Hooks

data/test/worker_test.rb

@@ -1,32 +1,6 @@
 require File.expand_path('../test_helper', __FILE__)
-
-$worker_test_count = 0
-$worker_success = false
-
-class TestJob
-  include Backburner::Queue
-  queue_priority 1000
-  def self.perform(x, y); $worker_test_count += x + y; end
-end
-
-class TestFailJob
-  include Backburner::Queue
-  def self.perform(x, y); raise RuntimeError; end
-end
-
-class TestRetryJob
-  include Backburner::Queue
-  def self.perform(x, y)
-    $worker_test_count += 1
-    raise RuntimeError unless $worker_test_count > 2
-    $worker_success = true
-  end
-end
-
-class TestAsyncJob
-  include Backburner::Performable
-  def self.foo(x, y); $worker_test_count = x * y; end
-end
+require File.expand_path('../fixtures/test_jobs', __FILE__)
+require File.expand_path('../fixtures/hooked', __FILE__)
 
 describe "Backburner::Worker module" do
   before do
@@ -258,6 +232,79 @@ describe "Backburner::Worker module" do
       assert_equal true, $worker_success
     end # retrying, succeeds
 
+    it "should support event hooks without retry" do
+      $hooked_fail_count = 0
+      clear_jobs!('foo.bar.events')
+      out = silenced(2) do
+        HookedObjectSuccess.async(:queue => 'foo.bar.events').foo(5)
+        worker = Backburner::Worker.new('foo.bar.events')
+        worker.prepare
+        worker.work_one_job
+      end
+      assert_match /before_enqueue.*after_enqueue.*Working 1 queues/m, out
+      assert_match /!!before_enqueue_bar!! \[nil, :foo, 5\]/, out
+      assert_match /!!after_enqueue_bar!! \[nil, :foo, 5\]/, out
+      assert_match /!!before_perform_foo!! \[nil, "foo", 5\]/, out
+      assert_match /!!BEGIN around_perform_bar!! \[nil, "foo", 5\]/, out
+      assert_match /!!BEGIN around_perform_cat!! \[nil, "foo", 5\]/, out
+      assert_match /!!on_failure_foo!!.*HookFailError/, out
+      assert_match /attempt 1 of 1, burying/, out
+    end # event hooks, no retry
+
+    it "should support event hooks with retry" do
+      $hooked_fail_count = 0
+      clear_jobs!('foo.bar.events.retry')
+      Backburner.configure { |config| config.max_job_retries = 1; config.retry_delay = 0 }
+      out = silenced(2) do
+        HookedObjectSuccess.async(:queue => 'foo.bar.events.retry').foo(5)
+        worker = Backburner::Worker.new('foo.bar.events.retry')
+        worker.prepare
+        2.times do
+          worker.work_one_job
+        end
+      end
+      assert_match /before_enqueue.*after_enqueue.*Working 1 queues/m, out
+      assert_match /!!before_enqueue_bar!! \[nil, :foo, 5\]/, out
+      assert_match /!!after_enqueue_bar!! \[nil, :foo, 5\]/, out
+      assert_match /!!before_perform_foo!! \[nil, "foo", 5\]/, out
+      assert_match /!!BEGIN around_perform_bar!! \[nil, "foo", 5\]/, out
+      assert_match /!!BEGIN around_perform_cat!! \[nil, "foo", 5\]/, out
+      assert_match /!!on_failure_foo!!.*HookFailError/, out
+      assert_match /!!on_failure_foo!!.*retrying.*around_perform_bar.*around_perform_cat/m, out
+      assert_match /attempt 1 of 2, retrying/, out
+      assert_match /!!before_perform_foo!! \[nil, "foo", 5\]/, out
+      assert_match /!!END around_perform_bar!! \[nil, "foo", 5\]/, out
+      assert_match /!!END around_perform_cat!! \[nil, "foo", 5\]/, out
+      assert_match /!!after_perform_foo!! \[nil, "foo", 5\]/, out
+      assert_match /Finished HookedObjectSuccess/, out
+    end # event hooks, with retry
+
+    it "should support event hooks with stopping enqueue" do
+      $hooked_fail_count = 0
+      clear_jobs!('foo.bar.events.retry2')
+      out = silenced(2) do
+        HookedObjectBeforeEnqueueFail.async(:queue => 'foo.bar.events.retry2').foo(5)
+      end
+      expanded_tube = [Backburner.configuration.tube_namespace, 'foo.bar.events.retry2'].join(".")
+      assert_nil Backburner::Worker.connection.tubes[expanded_tube].peek(:ready)
+    end # stopping enqueue
+
+    it "should support event hooks with stopping perform" do
+      $hooked_fail_count = 0
+      clear_jobs!('foo.bar.events.retry3')
+      expanded_tube = [Backburner.configuration.tube_namespace, 'foo.bar.events.retry3'].join(".")
+      out = silenced(2) do
+        HookedObjectBeforePerformFail.async(:queue => 'foo.bar.events.retry3').foo(10)
+        worker = Backburner::Worker.new('foo.bar.events.retry3')
+        worker.prepare
+        worker.work_one_job
+      end
+      assert_match /!!before_perform_foo!! \[nil, "foo", 10\]/, out
+      assert_match /before_perform_foo.*Finished/m, out
+      refute_match(/Fail ran!!/, out)
+      refute_match(/HookFailError/, out)
+    end # stopping perform
+
     after do
       Backburner.configure { |config| config.max_job_retries = 0; config.retry_delay = 5 }
     end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: backburner
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.2.0
   prerelease: 
 platform: ruby
 authors:
@@ -103,6 +103,7 @@ files:
 - .travis.yml
 - CHANGELOG.md
 - Gemfile
+- HOOKS.md
 - LICENSE
 - README.md
 - Rakefile
@@ -112,6 +113,7 @@ files:
 - examples/custom.rb
 - examples/demo.rb
 - examples/god.rb
+- examples/hooked.rb
 - examples/retried.rb
 - examples/simple.rb
 - lib/backburner.rb
@@ -119,6 +121,7 @@ files:
 - lib/backburner/configuration.rb
 - lib/backburner/connection.rb
 - lib/backburner/helpers.rb
+- lib/backburner/hooks.rb
 - lib/backburner/job.rb
 - lib/backburner/logger.rb
 - lib/backburner/performable.rb
@@ -128,7 +131,10 @@ files:
 - lib/backburner/worker.rb
 - test/back_burner_test.rb
 - test/connection_test.rb
+- test/fixtures/hooked.rb
+- test/fixtures/test_jobs.rb
 - test/helpers_test.rb
+- test/hooks_test.rb
 - test/job_test.rb
 - test/logger_test.rb
 - test/performable_test.rb
@@ -162,7 +168,10 @@ summary: Reliable beanstalk background job processing made easy for Ruby and Sin
 test_files:
 - test/back_burner_test.rb
 - test/connection_test.rb
+- test/fixtures/hooked.rb
+- test/fixtures/test_jobs.rb
 - test/helpers_test.rb
+- test/hooks_test.rb
 - test/job_test.rb
 - test/logger_test.rb
 - test/performable_test.rb