backburner 1.8.0 → 1.9.0

data/.github/workflows/github-release.yml

@@ -1,58 +0,0 @@
-# Creates the GitHub release page for a tag that already exists, with GitHub's generated notes (merged
-# PRs and new contributors since the previous release) after a link to that version's CHANGELOG.md.
-# release.yml runs it after it publishes; "Run workflow" here (with the tag) creates the page for an
-# earlier release. A tag that already has a release is left alone, so running it twice is harmless.
-# A tag that isn't the newest vX.Y.Z tag is created with --latest=false; the API otherwise marks every
-# new release as Latest.
-
-name: github-release
-run-name: github release ${{ inputs.tag }}
-
-on:
-  workflow_dispatch:
-    inputs:
-      tag:
-        description: 'An existing tag, e.g. v1.2.0'
-        required: true
-        type: string
-  workflow_call:
-    inputs:
-      tag:
-        required: true
-        type: string
-
-permissions:
-  contents: read
-
-jobs:
-  release-page:
-    if: github.repository == 'nesquena/backburner'
-    runs-on: ubuntu-latest
-    permissions:
-      contents: write   # creates the release
-    steps:
-      - name: Create the GitHub release
-        shell: bash -eo pipefail {0}
-        env:
-          TAG: ${{ inputs.tag }}
-          CHANGELOG: CHANGELOG.md
-          GH_TOKEN: ${{ github.token }}
-        run: |
-          [[ "$TAG" =~ ^v[0-9]+\.[0-9]+\.[0-9]+$ ]] || { echo "::error::'$TAG' is not a tag like v1.2.3"; exit 1; }
-          if gh release view "$TAG" --repo "$GITHUB_REPOSITORY" >/dev/null 2>&1; then
-            echo "$TAG already has a release; leaving it alone"
-            exit 0
-          fi
-          # Compare with the newest vX.Y.Z tag rather than the "Latest" release, so a failed lookup stops the
-          # step (pipefail) instead of letting an older tag become Latest
-          newest=$(gh api --paginate "repos/$GITHUB_REPOSITORY/git/matching-refs/tags/v" --jq '.[].ref' |
-            sed 's#^refs/tags/##' | grep -E '^v[0-9]+\.[0-9]+\.[0-9]+$' | sort -V | tail -n 1)
-          flags=()
-          if [ "$newest" != "$TAG" ]; then
-            echo "$TAG is not the newest tag ($newest): not marking it as latest"
-            flags=(--latest=false)
-          fi
-          # --verify-tag: refuse rather than create the tag. With --generate-notes, GitHub puts these notes
-          # before the generated ones.
-          gh release create "$TAG" --repo "$GITHUB_REPOSITORY" --verify-tag --title "$TAG" --generate-notes "${flags[@]}" \
-            --notes "What changed, and what to do when upgrading: [$CHANGELOG](https://github.com/$GITHUB_REPOSITORY/blob/$TAG/$CHANGELOG)."

data/.github/workflows/release.yml

@@ -1,221 +0,0 @@
-# Publishes a backburner release to rubygems.org with trusted publishing, gated by the "release"
-# environment: the owner approves each publish.
-#
-# Usual path: merge the release PR (the version in lib/backburner/version.rb and the CHANGELOG.md
-# heading stamped with the date, e.g. "## Version 1.8.0 (Nov 1 2026)"), then "Run workflow" on master
-# with the version. build checks the version, that the changelog's first heading is that version with
-# a date, and the branch, and builds the gem reproducibly; publish waits for approval, pushes the gem
-# with short-lived trusted-publishing credentials, then creates the tag vX.Y.Z on the built commit.
-# Pushing a vX.Y.Z tag on a master commit runs the same checks. "Re-run failed jobs" (not "Re-run all
-# jobs", which rebuilds) resumes a release that stopped partway.
-# If the gem is pushed but the tag step keeps failing, push the tag by hand at the built commit: that
-# tag push's run skips the push (same sum).
-# Then github-release.yml creates the GitHub release page for the tag (it can also be run by hand for
-# an earlier tag).
-#
-# Dry run: tick dry_run to check the wiring. Everything runs except the changelog checks, the tag, the
-# push and the release page; the credential exchange fails unless the trusted publisher is set up.
-#
-# The "release" environment's protection rules are the ONLY gate on publishing (required reviewer, no
-# admin bypass, deployments only from master and v*.*.* tags): RubyGems trusts any run of this file
-# that uses that environment, and a branch or tag can carry its own modified copy of it. The trusted
-# publisher on rubygems.org must name the environment. Before approving a deployment, check
-# who started the run, the event, that the commit is the release PR's merge commit, and the build
-# log's "is on master" line. Reject any run you won't approve: a waiting run blocks the next one.
-# A deployment rule for X.Y-stable lets anyone with write access create such a branch carrying its own
-# copy of this file: add one only for a maintenance release, and remove it after.
-
-name: release
-run-name: release ${{ inputs.version || github.ref_name }}${{ inputs.dry_run && ' (dry run)' || '' }}
-
-on:
-  push:
-    tags: ['v[0-9]+.[0-9]+.[0-9]+']
-  workflow_dispatch:
-    inputs:
-      version:
-        description: 'Version to release (already in the version file of this branch), e.g. 1.2.0'
-        required: true
-        type: string
-      dry_run:
-        description: 'Dry run: check, build and exchange credentials, but create no tag and push nothing'
-        required: false
-        type: boolean
-        default: false
-
-permissions:
-  contents: read
-
-concurrency:
-  group: release
-  cancel-in-progress: false
-
-jobs:
-  build:
-    if: github.repository == 'nesquena/backburner'
-    runs-on: ubuntu-latest
-    env:
-      TRUNK: master
-      TAG_PREFIX: v
-      GEMS: 'backburner:.'
-      VERSION_FILE: lib/backburner/version.rb
-      CHANGELOG: CHANGELOG.md
-      CHANGELOG_HEADING: '^## '
-      CHANGELOG_TOP: '^## Version ([0-9]+\.[0-9]+\.[0-9]+)( |$)'
-    outputs:
-      version: ${{ steps.check.outputs.version }}
-      tag: ${{ steps.check.outputs.tag }}
-    steps:
-      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
-        with:
-          fetch-depth: 0
-          submodules: true
-          persist-credentials: false
-      - uses: ruby/setup-ruby@de492cf36cbab201753d720ce4f4e336cd688c94 # v1.336.0
-        with:
-          ruby-version: '3.3'
-      - name: Check the version
-        id: check
-        shell: bash -eo pipefail {0}
-        env:
-          INPUT_VERSION: ${{ inputs.version }}
-          DRY_RUN: ${{ inputs.dry_run }}
-        run: |
-          if [ "$GITHUB_EVENT_NAME" = workflow_dispatch ]; then
-            version="$INPUT_VERSION"
-            [[ "$version" =~ ^[0-9]+\.[0-9]+\.[0-9]+$ ]] || { echo "::error::the version input is not a plain version like 1.2.3"; exit 1; }
-            case "$GITHUB_REF" in
-              "refs/heads/$TRUNK"|"refs/heads/${version%.*}-stable") ;;
-              *) echo "::error::run this on $TRUNK or ${version%.*}-stable, not $GITHUB_REF"; exit 1 ;;
-            esac
-            tag="$TAG_PREFIX$version"
-            tagged=$(git ls-remote origin "refs/tags/$tag*" | awk -v t="refs/tags/$tag" '$2 == t || $2 == t "^{}" { print $1 }')
-            [ -z "$tagged" ] || echo "$tagged" | grep -qx "$GITHUB_SHA" ||
-              { echo "::error::tag $tag already exists at another commit"; exit 1; }
-          else
-            tag="$GITHUB_REF_NAME"
-            version="${tag#"$TAG_PREFIX"}"
-            [[ "$tag" == "$TAG_PREFIX"* && "$version" =~ ^[0-9]+\.[0-9]+\.[0-9]+$ ]] || { echo "::error::tag $tag is not ${TAG_PREFIX}X.Y.Z"; exit 1; }
-          fi
-          file_version=$(ruby -e 'puts File.binread(ENV["VERSION_FILE"])[/\bVERSION\s*=\s*["\x27]([^"\x27]+)/, 1]')
-          [ "$version" = "$file_version" ] || { echo "::error::version $version but $VERSION_FILE says $file_version"; exit 1; }
-          if [ "$DRY_RUN" = true ]; then
-            echo "::warning::dry run: not checking $CHANGELOG"
-          else
-            heading=$(grep -m1 -E "$CHANGELOG_HEADING" "$CHANGELOG") || { echo "::error::$CHANGELOG has no heading matching '$CHANGELOG_HEADING'"; exit 1; }
-            top=$(echo "$heading" | sed -nE "s/$CHANGELOG_TOP.*/\1/p")
-            [ "$top" = "$version" ] || { echo "::error::$CHANGELOG starts with '$heading', not release $version: merge the release PR first, and nothing after it"; exit 1; }
-            rest="${heading#*"$version"}"
-            [[ "$rest" =~ (19|20)[0-9][0-9] ]] && ! echo "$rest" | grep -qiwE 'unreleased|tbd|tba' ||
-              { echo "::error::$CHANGELOG's '$heading' isn't stamped with a date yet"; exit 1; }
-          fi
-          series="${version%.*}-stable"
-          on=""
-          for b in "$series" "$TRUNK"; do
-            git merge-base --is-ancestor "$GITHUB_SHA" "refs/remotes/origin/$b" 2>/dev/null && on="$b"
-          done
-          [ -n "$on" ] || { echo "::error::$version ($GITHUB_SHA) is not on $TRUNK or $series"; exit 1; }
-          echo "version=$version" >> "$GITHUB_OUTPUT"
-          echo "tag=$tag" >> "$GITHUB_OUTPUT"
-          echo "$version ($GITHUB_SHA) is on $on"
-      - name: Build the gems
-        shell: bash -eo pipefail {0}
-        env:
-          VERSION: ${{ steps.check.outputs.version }}
-        run: |
-          SOURCE_DATE_EPOCH=$(git log -1 --format=%ct "$GITHUB_SHA"); export SOURCE_DATE_EPOCH
-          mkdir dist
-          for spec in $GEMS; do
-            g="${spec%%:*}"; dir="${spec#*:}"; [ "$dir" = "$spec" ] && dir=.
-            out="$GITHUB_WORKSPACE/dist/$g-$VERSION.gem"
-            (cd "$dir" && gem build "$g.gemspec" --output "$out")
-            [ "$(gem spec "$out" name)" = "--- $g" ] && [ "$(gem spec "$out" version | sed -n 's/^version: //p')" = "$VERSION" ] ||
-              { echo "::error::$out is not $g $VERSION:"; gem spec "$out" name; gem spec "$out" version; exit 1; }
-            echo "$g" >> dist/ORDER
-          done
-          echo "SOURCE_DATE_EPOCH=$SOURCE_DATE_EPOCH (ruby $(ruby -e 'print RUBY_VERSION'), rubygems $(gem -v))"
-          (cd dist && sha256sum *.gem > SHA256SUMS && cat ORDER SHA256SUMS)
-      - uses: actions/upload-artifact@cf430e030ddbb5b0abf93d22962f4752f3646cd9 # v7.0.2
-        with:
-          name: gems-${{ steps.check.outputs.version }}
-          path: dist/
-          if-no-files-found: error
-
-  publish:
-    needs: build
-    runs-on: ubuntu-latest
-    environment: release
-    permissions:
-      contents: write   # creates the tag on a dispatched release
-      id-token: write   # the RubyGems trusted-publishing exchange
-    steps:
-      - name: Refuse a stale run (the tag is somewhere else)
-        shell: bash -eo pipefail {0}
-        env:
-          TAG: ${{ needs.build.outputs.tag }}
-        run: |
-          tagged=$(git ls-remote "https://github.com/$GITHUB_REPOSITORY" "refs/tags/$TAG*" |
-            awk -v t="refs/tags/$TAG" '$2 == t || $2 == t "^{}" { print $1 }')
-          if [ -z "$tagged" ] && [ "$GITHUB_EVENT_NAME" = workflow_dispatch ]; then
-            echo "tag $TAG will be created at $GITHUB_SHA"
-          else
-            echo "$tagged" | grep -qx "$GITHUB_SHA" || { echo "::error::tag $TAG is not at $GITHUB_SHA (now: ${tagged:-gone}); this run is stale"; exit 1; }
-          fi
-      - uses: actions/download-artifact@9000827ccba6bdab643e8b6fd33ac0654aef8333 # v8.0.2
-        with:
-          name: gems-${{ needs.build.outputs.version }}
-          path: dist
-      - name: Check the sums
-        working-directory: dist
-        run: sha256sum -c SHA256SUMS
-      - uses: ruby/setup-ruby@de492cf36cbab201753d720ce4f4e336cd688c94 # v1.336.0
-        with:
-          ruby-version: '3.3'
-      - uses: rubygems/configure-rubygems-credentials@dc5a8d8553e6ee01fc26761a49e99e733d17954a # v2.1.0
-      - name: Dry run ends here
-        if: inputs.dry_run
-        run: echo "Credentials exchange succeeded, so the trusted publisher works. No tag created, nothing pushed."
-      - name: Push the gems
-        if: ${{ !inputs.dry_run }}
-        shell: bash -eo pipefail {0}
-        working-directory: dist
-        env:
-          VERSION: ${{ needs.build.outputs.version }}
-        run: |
-          while read -r g; do
-            sum=$(sha256sum "$g-$VERSION.gem" | cut -d' ' -f1)
-            published=$(curl -fsS "https://rubygems.org/api/v1/versions/$g.json" 2>/dev/null |
-              ruby -rjson -e 'b = $stdin.read; v = (b.empty? ? [] : JSON.parse(b)).find { |x| x["number"] == ENV["VERSION"] && x["platform"] == "ruby" }; print v ? v["sha"].to_s : ""' || true)
-            if [ -z "$published" ]; then
-              gem push "$g-$VERSION.gem" </dev/null
-            elif [ "$published" = "$sum" ]; then
-              echo "$g $VERSION is already on rubygems.org with this sum; skipping"
-            else
-              echo "::error::$g $VERSION is already on rubygems.org with sha256 $published, not this build's $sum"; exit 1
-            fi
-          done < ORDER
-      - name: Create the tag
-        if: github.event_name == 'workflow_dispatch' && !inputs.dry_run
-        shell: bash -eo pipefail {0}
-        env:
-          TAG: ${{ needs.build.outputs.tag }}
-          GH_TOKEN: ${{ github.token }}
-        run: |
-          tagged=$(git ls-remote "https://github.com/$GITHUB_REPOSITORY" "refs/tags/$TAG*" |
-            awk -v t="refs/tags/$TAG" '$2 == t || $2 == t "^{}" { print $1 }')
-          if [ -z "$tagged" ]; then
-            gh api "repos/$GITHUB_REPOSITORY/git/refs" -f ref="refs/tags/$TAG" -f sha="$GITHUB_SHA"
-          elif echo "$tagged" | grep -qx "$GITHUB_SHA"; then
-            echo "tag $TAG is already at $GITHUB_SHA"
-          else
-            echo "::error::tag $TAG is not at $GITHUB_SHA (now: $tagged)"; exit 1
-          fi
-
-  release-page:
-    needs: [build, publish]
-    if: ${{ !inputs.dry_run }}
-    permissions:
-      contents: write   # github-release.yml creates the release
-    uses: ./.github/workflows/github-release.yml
-    with:
-      tag: ${{ needs.build.outputs.tag }}

data/.gitignore

@@ -1,17 +0,0 @@
-*.gem
-*.rbc
-.bundle
-.config
-.yardoc
-Gemfile.lock
-InstalledFiles
-_yardoc
-coverage
-doc/
-lib/bundler/man
-pkg
-rdoc
-spec/reports
-test/tmp
-test/version_tmp
-tmp

data/CONTRIBUTING.md

@@ -1,37 +0,0 @@
-We love pull requests. Here's a quick guide:
-
-1. Fork the repo.
-
-2. Run the tests. We only take pull requests with passing tests, and it's great
-to know that you have a clean slate: `bundle && rake test`
-
-3. Add a test for your change. Only refactoring and documentation changes
-require no new tests. If you are adding functionality or fixing a bug, we need
-a test!
-
-4. Make the test pass.
-
-5. Push to your fork and submit a pull request.
-
-At this point you're waiting on us. We like to at least comment on, if not
-accept, pull requests within three business days (and, typically, one business
-day). We may suggest some changes or improvements or alternatives.
-
-Some things that will increase the chance that your pull request is accepted:
-
-* Use Rails idioms and helpers
-* Include tests that fail without your code, and pass with it
-* Update the documentation and README for anything affected by your contribution
-
-Syntax:
-
-* Two spaces, no tabs.
-* No trailing whitespace. Blank lines should not have any space.
-* Prefer &&/|| over and/or.
-* MyClass.my_method(my_arg) not my_method( my_arg ) or my_method my_arg.
-* a = b and not a=b.
-* Follow the conventions you see used in the source already.
-
-And in case we didn't emphasize it enough: we love tests!
-
-NOTE: Adapted from https://raw.github.com/thoughtbot/factory_girl_rails/master/CONTRIBUTING.md

data/Gemfile

@@ -1,7 +0,0 @@
-source 'https://rubygems.org'
-
-# Specify your gem's dependencies in backburner.gemspec
-gemspec
-
-# Test against an older Active Job (and the Active Support it needs), as CI does: ACTIVEJOB_VERSION=7.1 bundle install
-gem 'activejob', "~> #{ENV['ACTIVEJOB_VERSION']}.0" unless ENV['ACTIVEJOB_VERSION'].to_s.empty?

data/Rakefile

@@ -1,17 +0,0 @@
-#!/usr/bin/env rake
-require "bundler/gem_tasks"
-require 'rake/testtask'
-# require 'yard'
-
-task :test do
-  Rake::TestTask.new do |t|
-    t.libs.push "lib"
-    t.test_files = FileList[File.expand_path('../test/**/*_test.rb', __FILE__)]
-    t.verbose = true
-  end
-end
-
-task :default => :test
-
-# task :doc do
-#  YARD::CLI::Yardoc.new.run

data/TODO

@@ -1,4 +0,0 @@
-- 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

data/backburner.gemspec

@@ -1,31 +0,0 @@
-# -*- encoding: utf-8 -*-
-require File.expand_path('../lib/backburner/version', __FILE__)
-
-Gem::Specification.new do |s|
-  s.authors       = ["Nathan Esquenazi"]
-  s.email         = ["nesquena@gmail.com"]
-  s.description   = %q{Beanstalk background job processing made easy}
-  s.summary       = %q{Reliable beanstalk background job processing made easy for Ruby and Sinatra}
-  s.homepage      = "http://github.com/nesquena/backburner"
-
-  s.files         = `git ls-files`.split($\)
-  s.executables   = s.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
-  s.test_files    = s.files.grep(%r{^(test|spec|features)/})
-  s.name          = "backburner"
-  s.require_paths = ["lib"]
-  s.version       = Backburner::VERSION
-  s.license       = 'MIT'
-  s.required_ruby_version = '>= 2.7'
-
-  s.add_runtime_dependency 'beaneater', '~> 1.0'
-  s.add_runtime_dependency 'dante', '> 0.1.5'
-  s.add_runtime_dependency 'concurrent-ruby', '~> 1.0', '>= 1.0.1'
-  s.add_runtime_dependency 'logger' # a bundled gem (no longer a default one) since Ruby 4.0
-
-  s.add_development_dependency 'rake'
-  s.add_development_dependency 'minitest', '5.1.0'
-  s.add_development_dependency 'mutex_m' # minitest 5.1.0 requires it; a bundled gem (not a default one) since Ruby 3.4
-  s.add_development_dependency 'mocha'
-  s.add_development_dependency 'activejob', '>= 6.0'
-  s.add_development_dependency 'activesupport', '>= 6.0'
-end

data/examples/custom.rb

@@ -1,25 +0,0 @@
-$:.unshift "lib"
-require 'backburner'
-
-# Define ruby job
-class TestJob
-  include Backburner::Queue
-  # queue "test-job"
-
-  def self.perform(value, user)
-    puts "[TestJob] Running perform with args: [#{value}, #{user}]"
-  end
-end
-
-# Configure Backburner
-Backburner.configure do |config|
-  config.beanstalk_url = "beanstalk://127.0.0.1"
-  config.tube_namespace = "demo.production"
-end
-
-# Enqueue tasks
-Backburner.enqueue TestJob, 5, 3
-Backburner.enqueue TestJob, 10, 6
-
-# Work tasks using threaded worker
-Backburner.work("test-job", :worker => Backburner::Workers::ThreadsOnFork)

data/examples/demo.rb

@@ -1,60 +0,0 @@
-$:.unshift "lib"
-require 'backburner'
-
-module Tester
-  class TestJob
-    include Backburner::Queue
-    queue "test.job"
-
-    def self.perform(value, user)
-      p [value, user]
-    end
-  end
-
-  class UserModel
-    include Backburner::Performable
-
-    attr_accessor :id, :name
-
-    def self.first
-      self.find(3, "John")
-    end
-
-    def self.find(id, name="Fetched")
-      self.new(id, name)
-    end
-
-    def initialize(id, name)
-      @id, @name = id, name
-    end
-
-    def hello(x, y)
-      puts "Instance #{x} and #{y} and my id is #{id}"
-    end
-
-    def self.foo(x, y)
-      puts "Class #{x} and #{y}"
-    end
-  end
-end
-
-# connection = Backburner::Connection.new("beanstalk://127.0.0.1")
-
-Backburner.configure do |config|
-  config.beanstalk_url = "beanstalk://127.0.0.1"
-  config.tube_namespace = "myblog.production"
-end
-
-# p Backburner.configuration.beanstalk_url
-# p Backburner::Worker.connection
-
-Backburner.enqueue Tester::TestJob, 5, 3
-Backburner.enqueue Tester::TestJob, 10, 6
-@user = Tester::UserModel.first
-@user.async.hello("foo", "bar")
-Tester::UserModel.async.foo("bar", "baz")
-
-Backburner.default_queues.concat([Tester::TestJob.queue, Tester::UserModel.queue])
-Backburner.work
-# Backburner.work("test.job")
-# Backburner.work("tester/user-model")

data/examples/god.rb

@@ -1,46 +0,0 @@
-God.watch do |w|
-  w.name   = "backburner-worker-1"
-  w.dir    = '/path/to/app/dir'
-  w.env = { 'PADRINO_ENV' => 'production', 'QUEUES' => 'newsletter-sender,push-message' }
-  w.group    = 'backburner-workers'
-  w.interval = 30.seconds
-  w.start = "bundle exec rake -f Rakefile backburner:work"
-  w.log   = "/var/log/god/backburner-worker-1.log"
-
-  # restart if memory gets too high
-  w.transition(:up, :restart) do |on|
-    on.condition(:memory_usage) do |c|
-      c.above = 50.megabytes
-      c.times = 3
-    end
-  end
-
-  # determine the state on startup
-  w.transition(:init, { true => :up, false => :start }) do |on|
-    on.condition(:process_running) do |c|
-      c.running = true
-    end
-  end
-
-  # determine when process has finished starting
-  w.transition([:start, :restart], :up) do |on|
-    on.condition(:process_running) do |c|
-      c.running = true
-      c.interval = 5.seconds
-    end
-
-    # failsafe
-    on.condition(:tries) do |c|
-      c.times = 5
-      c.transition = :start
-      c.interval = 5.seconds
-    end
-  end
-
-  # start if process is not running
-  w.transition(:up, :start) do |on|
-    on.condition(:process_running) do |c|
-      c.running = false
-    end
-  end
-end

data/examples/hooked.rb

@@ -1,87 +0,0 @@
-$:.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/examples/retried.rb

@@ -1,31 +0,0 @@
-$:.unshift "lib"
-require 'backburner'
-
-$error = 0
-
-class User
-  include Backburner::Performable
-  attr_accessor :id, :name
-
-  def self.foo(x, y)
-    $error += 1
-    raise "fail #{$error}" unless $error > 3
-    puts "User #foo args [#{x}, #{y}] Success!!"
-  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 = 3
-  config.retry_delay     = 0
-end
-
-# Enqueue tasks
-User.async(:queue => "retried").foo("bar", "baz")
-
-# Run work
-# Backburner.default_queues << "user"
-Backburner.work