resque 1.27.4 → 2.5.0

data/README.markdown

@@ -2,13 +2,17 @@ Resque
 ======
 
 [![Gem Version](https://badge.fury.io/rb/resque.svg)](https://rubygems.org/gems/resque)
-[![Build Status](https://travis-ci.org/resque/resque.svg)](https://travis-ci.org/resque/resque)
-[![Coverage Status](https://coveralls.io/repos/github/resque/resque/badge.svg?branch=1-x-stable)](https://coveralls.io/r/resque/resque?branch=1-x-stable)
+[![Build Status](https://github.com/resque/resque/actions/workflows/ci.yml/badge.svg)](https://github.com/resque/resque/actions/workflows/ci.yml)
+
+Introduction
+------------
 
 Resque (pronounced like "rescue") is a Redis-backed library for creating
 background jobs, placing those jobs on multiple queues, and processing
 them later.
 
+For the backstory, philosophy, and history of Resque's beginnings, please see [the blog post](http://github.com/blog/542-introducing-resque) (2009).
+
 Background jobs can be any Ruby class or module that responds to
 `perform`. Your existing classes can easily be converted to background
 jobs or you can create new classes specifically to do work. Or, you
@@ -21,10 +25,11 @@ three parts:
 2. A Rake task for starting a worker which processes jobs
 3. A Sinatra app for monitoring queues, jobs, and workers.
 
-Resque workers can be distributed between multiple machines,
-support priorities, are resilient to memory bloat / "leaks," are
-optimized for REE (but work on MRI and JRuby), tell you what they're
-doing, and expect failure.
+Resque workers can be  given multiple queues (a "queue list"),
+distributed between multiple machines,
+run anywhere with network access to the Redis server,
+support priorities, are resilient to memory bloat / "leaks,"
+tell you what they're doing, and expect failure.
 
 Resque queues are persistent; support constant time, atomic push and
 pop (thanks to Redis); provide visibility into their contents; and
@@ -34,19 +39,18 @@ The Resque frontend tells you what workers are doing, what workers are
 not doing, what queues you're using, what's in those queues, provides
 general usage stats, and helps you track failures.
 
+Resque now supports Ruby 2.3.0 and above.
+We will also only be supporting Redis 3.0 and above going forward.
 
-The Blog Post
--------------
-
-For the backstory, philosophy, and history of Resque's beginnings,
-please see [the blog post][0].
-
+### Note on the future of Resque
 
-Overview
---------
+Would you like to be involved in Resque? Do you have thoughts about what
+Resque should be and do going forward? There's currently an [open discussion here](https://github.com/resque/resque/issues/1759)
+on just that topic, so please feel free to join in. We'd love to hear your thoughts
+and/or have people volunteer to be a part of the project!
 
-Resque allows you to create jobs and place them on a queue, then,
-later, pull those jobs off the queue and process them.
+Example
+-------
 
 Resque jobs are Ruby classes (or modules) which respond to the
 `perform` method. Here's an example:
@@ -106,10 +110,216 @@ This starts one Resque worker and tells it to work off the
 find any more, at which point it will sleep for a small period and
 repeatedly poll the queue for more jobs.
 
-Workers can be given multiple queues (a "queue list") and run on
-multiple machines. In fact they can be run anywhere with network
-access to the Redis server.
+Installation
+------------
+
+Add the gem to your Gemfile:
+
+    gem 'resque'
+
+Next, install it with Bundler:
+
+    $ bundle
+
+#### Rack
+
+In your Rakefile, or some other file in `lib/tasks` (ex: `lib/tasks/resque.rake`), load the resque rake tasks:
+
+``` ruby
+require 'resque'
+require 'resque/tasks'
+require 'your/app' # Include this line if you want your workers to have access to your application
+```
+
+#### Rails
+
+To make resque specific changes, you can override the `resque:setup` job in `lib/tasks` (ex: `lib/tasks/resque.rake`). GitHub's setup task looks like this:
+
+``` ruby
+task "resque:setup" => :environment do
+  Grit::Git.git_timeout = 10.minutes
+end
+```
+
+We don't want the `git_timeout` as high as 10 minutes in our web app,
+but in the Resque workers it's fine.
+
+Running Workers
+---------------
+
+Resque workers are rake tasks that run forever. They basically do this:
+
+``` ruby
+start
+loop do
+  if job = reserve
+    job.process
+  else
+    sleep 5 # Polling frequency = 5
+  end
+end
+shutdown
+```
+
+Starting a worker is simple:
+
+    $ QUEUE=* rake resque:work
+
+Or, you can start multiple workers:
+
+    $ COUNT=2 QUEUE=* rake resque:workers
+
+This will spawn two Resque workers, each in its own process. Hitting
+ctrl-c should be sufficient to stop them all.
+
+#### Priorities and Queue Lists
+
+Resque doesn't support numeric priorities but instead uses the order
+of queues you give it. We call this list of queues the "queue list."
+
+Let's say we add a `warm_cache` queue in addition to our `file_serve`
+queue. We'd now start a worker like so:
+
+    $ QUEUES=file_serve,warm_cache rake resque:work
+
+When the worker looks for new jobs, it will first check
+`file_serve`. If it finds a job, it'll process it then check
+`file_serve` again. It will keep checking `file_serve` until no more
+jobs are available. At that point, it will check `warm_cache`. If it
+finds a job it'll process it then check `file_serve` (repeating the
+whole process).
+
+In this way you can prioritize certain queues. At GitHub we start our
+workers with something like this:
+
+    $ QUEUES=critical,archive,high,low rake resque:work
+
+Notice the `archive` queue - it is specialized and in our future
+architecture will only be run from a single machine.
+
+At that point we'll start workers on our generalized background
+machines with this command:
+
+    $ QUEUES=critical,high,low rake resque:work
+
+And workers on our specialized archive machine with this command:
+
+    $ QUEUE=archive rake resque:work
+
+#### Running All Queues
+
+If you want your workers to work off of every queue, including new
+queues created on the fly, you can use a splat:
+
+    $ QUEUE=* rake resque:work
+
+Queues will be processed in alphabetical order.
+
+Or, prioritize some queues above `*`:
+
+    # QUEUE=critical,* rake resque:work
+
+#### Running All Queues Except for Some
+
+If you want your workers to work off of all queues except for some,
+you can use negation:
+
+    $ QUEUE=*,!low rake resque:work
+
+Negated globs also work. The following will instruct workers to work
+off of all queues except those beginning with `file_`:
+
+    $ QUEUE=*,!file_* rake resque:work
+
+Note that the order in which negated queues are specified does not
+matter, so `QUEUE=*,!file_*` and `QUEUE=!file_*,*` will have the same
+effect.
+
+#### Process IDs (PIDs)
+
+There are scenarios where it's helpful to record the PID of a resque
+worker process.  Use the PIDFILE option for easy access to the PID:
+
+    $ PIDFILE=./resque.pid QUEUE=file_serve rake resque:work
+
+#### Running in the background
+
+There are scenarios where it's helpful for
+the resque worker to run itself in the background (usually in combination with
+PIDFILE).  Use the BACKGROUND option so that rake will return as soon as the
+worker is started.
+
+    $ PIDFILE=./resque.pid BACKGROUND=yes QUEUE=file_serve rake resque:work
+
+#### Polling frequency
+
+You can pass an INTERVAL option which is a float representing the polling frequency.
+The default is 5 seconds, but for a semi-active app you may want to use a smaller value.
+
+    $ INTERVAL=0.1 QUEUE=file_serve rake resque:work
+
+The Front End
+-------------
+
+Resque comes with a Sinatra-based front end for seeing what's up with
+your queue.
+
+![The Front End](https://camo.githubusercontent.com/64d150a243987ffbc33f588bd6d7722a0bb8d69a/687474703a2f2f7475746f7269616c732e6a756d7073746172746c61622e636f6d2f696d616765732f7265737175655f6f766572766965772e706e67)
+
+#### Standalone
+
+If you've installed Resque as a gem running the front end standalone is easy:
+
+    $ resque-web
+
+It's a thin layer around `rackup` so it's configurable as well:
+
+    $ resque-web -p 8282
+
+If you have a Resque config file you want evaluated just pass it to
+the script as the final argument:
+
+    $ resque-web -p 8282 rails_root/config/initializers/resque.rb
+
+You can also set the namespace directly using `resque-web`:
+
+    $ resque-web -p 8282 -N myapp
+
+or set the Redis connection string if you need to do something like select a different database:
+
+    $ resque-web -p 8282 -r localhost:6379:2
+
+#### Passenger
+
+Using Passenger? Resque ships with a `config.ru` you can use. See
+Phusion's guide:
+
+Apache: <https://www.phusionpassenger.com/library/deploy/apache/deploy/ruby/>
+Nginx: <https://www.phusionpassenger.com/library/deploy/nginx/deploy/ruby/>
+
+#### Rack::URLMap
+
+If you want to load Resque on a subpath, possibly alongside other
+apps, it's easy to do with Rack's `URLMap`:
+
+``` ruby
+require 'resque/server'
+
+run Rack::URLMap.new \
+  "/"       => Your::App.new,
+  "/resque" => Resque::Server.new
+```
+
+Check `examples/demo/config.ru` for a functional example (including
+HTTP basic auth).
+
+#### Rails
+
+You can also mount Resque on a subpath in your existing Rails app by adding `require 'resque/server'` to the top of your routes file or in an initializer then adding this to `routes.rb`:
 
+``` ruby
+mount Resque::Server.new, :at => "/resque"
+```
 
 Jobs
 ----
@@ -136,8 +346,7 @@ mention "foreground" and "background" because they make conceptual
 sense. You could easily be spidering sites and sticking data which
 needs to be crunched later into a queue.
 
-
-### Persistence
+#### Persistence
 
 Jobs are persisted to queues as JSON objects. Let's take our `Archive`
 example from above. We'll run the following code to create a job:
@@ -182,7 +391,7 @@ If your jobs were run against marshaled objects, they could
 potentially be operating on a stale record with out-of-date information.
 
 
-### send_later / async
+#### send_later / async
 
 Want something like DelayedJob's `send_later` or the ability to use
 instance methods instead of just methods for jobs? See the `examples/`
@@ -191,12 +400,12 @@ directory for goodies.
 We plan to provide first class `async` support in a future release.
 
 
-### Failure
+#### Failure
 
 If a job raises an exception, it is logged and handed off to the
 `Resque::Failure` module. Failures are logged either locally in Redis
 or using some different backend. To see exceptions while developing,
-use VERBOSE env variable, see details below under Logging.
+see details below under Logging.
 
 For example, Resque ships with Airbrake support. To configure it, put
 the following into an initialisation file or into your rake job:
@@ -215,64 +424,98 @@ Keep this in mind when writing your jobs: you may want to throw
 exceptions you would not normally throw in order to assist debugging.
 
 
-Workers
--------
+#### Rails example
 
-Resque workers are rake tasks that run forever. They basically do this:
+If you are using ActiveJob here's how your job definition will look:
 
 ``` ruby
-start
-loop do
-  if job = reserve
-    job.process
-  else
-    sleep 5 # Polling frequency = 5
+class ArchiveJob < ApplicationJob
+  queue_as :file_serve
+
+  def perform(repo_id, branch = 'master')
+    repo = Repository.find(repo_id)
+    repo.create_archive(branch)
+  end
+end
+```
+
+``` ruby
+class Repository
+  def async_create_archive(branch)
+    ArchiveJob.perform_later(self.id, branch)
   end
 end
-shutdown
 ```
 
-Starting a worker is simple. Here's our example from earlier:
+It is important to run `ArchiveJob.perform_later(self.id, branch)` rather than `Resque.enqueue(Archive, self.id, branch)`.
+Otherwise Resque will process the job without actually doing anything.
+Even if you put an obviously buggy line like `0/0` in the `perform` method,
+the job will still succeed.
 
-    $ QUEUE=file_serve rake resque:work
 
-By default Resque won't know about your application's
-environment. That is, it won't be able to find and run your jobs - it
-needs to load your application into memory.
+Configuration
+-------------
+
+#### Redis
+
+You may want to change the Redis host and port Resque connects to, or
+set various other options at startup.
+
+Resque has a `redis` setter which can be given a string or a Redis
+object. This means if you're already using Redis in your app, Resque
+can re-use the existing connection.
+
+String: `Resque.redis = 'localhost:6379'`
+
+Redis: `Resque.redis = $redis`
+
+For our rails app we have a `config/initializers/resque.rb` file where
+we load `config/resque.yml` by hand and set the Redis information
+appropriately.
 
-If we've installed Resque as a Rails plugin, we might run this command
-from our RAILS_ROOT:
+Here's our `config/resque.yml`:
 
-    $ QUEUE=file_serve rake environment resque:work
+    development: localhost:6379
+    test: localhost:6379
+    staging: redis1.se.github.com:6379
+    fi: localhost:6379
+    production: <%= ENV['REDIS_URL'] %>
 
-This will load the environment before starting a worker. Alternately
-we can define a `resque:setup` task with a dependency on the
-`environment` rake task:
+And our initializer:
 
 ``` ruby
-task "resque:setup" => :environment
+rails_root = ENV['RAILS_ROOT'] || File.dirname(__FILE__) + '/../..'
+rails_env = ENV['RAILS_ENV'] || 'development'
+config_file = rails_root + '/config/resque.yml'
+
+resque_config = YAML::load(ERB.new(IO.read(config_file)).result)
+Resque.redis = resque_config[rails_env]
 ```
 
-GitHub's setup task looks like this:
+Easy peasy! Why not just use `RAILS_ROOT` and `RAILS_ENV`? Because
+this way we can tell our Sinatra app about the config file:
+
+    $ RAILS_ENV=production resque-web rails_root/config/initializers/resque.rb
+
+Now everyone is on the same page.
+
+Also, you could disable jobs queueing by setting 'inline' attribute.
+For example, if you want to run all jobs in the same process for cucumber, try:
 
 ``` ruby
-task "resque:setup" => :environment do
-  Grit::Git.git_timeout = 10.minutes
-end
+Resque.inline = ENV['RAILS_ENV'] == "cucumber"
 ```
 
-We don't want the `git_timeout` as high as 10 minutes in our web app,
-but in the Resque workers it's fine.
-
+#### Logging
 
-### Logging
+Workers support basic logging to STDOUT.
 
-Workers support basic logging to STDOUT. If you start them with the
-`VERBOSE` env variable set, they will print basic debugging
-information. You can also set the `VVERBOSE` (very verbose) env
-variable.
+You can control the logging threshold using `Resque.logger.level`:
 
-    $ VVERBOSE=1 QUEUE=file_serve rake environment resque:work
+```ruby
+# config/initializers/resque.rb
+Resque.logger.level = Logger::DEBUG
+```
 
 If you want Resque to log to a file, in Rails do:
 
@@ -281,91 +524,111 @@ If you want Resque to log to a file, in Rails do:
 Resque.logger = Logger.new(Rails.root.join('log', "#{Rails.env}_resque.log"))
 ```
 
-### Process IDs (PIDs)
-
-There are scenarios where it's helpful to record the PID of a resque
-worker process.  Use the PIDFILE option for easy access to the PID:
+#### Namespaces
 
-    $ PIDFILE=./resque.pid QUEUE=file_serve rake environment resque:work
-
-### Running in the background
+If you're running multiple, separate instances of Resque you may want
+to namespace the keyspaces so they do not overlap. This is not unlike
+the approach taken by many memcached clients.
 
-(Only supported with ruby >= 1.9). There are scenarios where it's helpful for
-the resque worker to run itself in the background (usually in combination with
-PIDFILE).  Use the BACKGROUND option so that rake will return as soon as the
-worker is started.
+This feature is provided by the [redis-namespace](http://github.com/resque/redis-namespace) library, which
+Resque uses by default to separate the keys it manages from other keys
+in your Redis server.
 
-    $ PIDFILE=./resque.pid BACKGROUND=yes QUEUE=file_serve \
-        rake environment resque:work
+Simply use the `Resque.redis.namespace` accessor:
 
-### Polling frequency
-
-You can pass an INTERVAL option which is a float representing the polling frequency.
-The default is 5 seconds, but for a semi-active app you may want to use a smaller value.
+``` ruby
+Resque.redis.namespace = "resque:GitHub"
+```
 
-    $ INTERVAL=0.1 QUEUE=file_serve rake environment resque:work
+We recommend sticking this in your initializer somewhere after Redis
+is configured.
 
-### Priorities and Queue Lists
+#### Storing Statistics
+ Resque allows to store count of processed and failed jobs.
 
-Resque doesn't support numeric priorities but instead uses the order
-of queues you give it. We call this list of queues the "queue list."
+ By default it will store it in Redis using the keys `stats:processed` and `stats:failed`.
 
-Let's say we add a `warm_cache` queue in addition to our `file_serve`
-queue. We'd now start a worker like so:
+ Some apps would want another stats store, or even a null store:
 
-    $ QUEUES=file_serve,warm_cache rake resque:work
-
-When the worker looks for new jobs, it will first check
-`file_serve`. If it finds a job, it'll process it then check
-`file_serve` again. It will keep checking `file_serve` until no more
-jobs are available. At that point, it will check `warm_cache`. If it
-finds a job it'll process it then check `file_serve` (repeating the
-whole process).
-
-In this way you can prioritize certain queues. At GitHub we start our
-workers with something like this:
+ ```ruby
+# config/initializers/resque.rb
+class NullDataStore
+  def stat(stat)
+    0
+  end
 
-    $ QUEUES=critical,archive,high,low rake resque:work
+  def increment_stat(stat, by)
+  end
 
-Notice the `archive` queue - it is specialized and in our future
-architecture will only be run from a single machine.
+  def decrement_stat(stat, by)
+  end
 
-At that point we'll start workers on our generalized background
-machines with this command:
+  def clear_stat(stat)
+  end
+end
 
-    $ QUEUES=critical,high,low rake resque:work
+Resque.stat_data_store = NullDataStore.new
+```
 
-And workers on our specialized archive machine with this command:
+Plugins and Hooks
+-----------------
 
-    $ QUEUE=archive rake resque:work
+For a list of available plugins see
+<https://github.com/resque/resque/wiki/plugins>.
 
+If you'd like to write your own plugin, or want to customize Resque
+using hooks (such as `Resque.after_fork`), see
+[docs/HOOKS.md](http://github.com/resque/resque/blob/master/docs/HOOKS.md).
 
-### Running All Queues
 
-If you want your workers to work off of every queue, including new
-queues created on the fly, you can use a splat:
+Additional Information
+----------------------
 
-    $ QUEUE=* rake resque:work
+#### Resque vs DelayedJob
 
-Queues will be processed in alphabetical order.
+How does Resque compare to DelayedJob, and why would you choose one
+over the other?
 
+* Resque supports multiple queues
+* DelayedJob supports finer grained priorities
+* Resque workers are resilient to memory leaks / bloat
+* DelayedJob workers are extremely simple and easy to modify
+* Resque requires Redis
+* DelayedJob requires ActiveRecord
+* Resque can only place JSONable Ruby objects on a queue as arguments
+* DelayedJob can place _any_ Ruby object on its queue as arguments
+* Resque includes a Sinatra app for monitoring what's going on
+* DelayedJob can be queried from within your Rails app if you want to
+  add an interface
 
-### Running Multiple Workers
+If you're doing Rails development, you already have a database and
+ActiveRecord. DelayedJob is super easy to setup and works great.
+GitHub used it for many months to process almost 200 million jobs.
 
-At GitHub we use god to start and stop multiple workers. A sample god
-configuration file is included under `examples/god`. We recommend this
-method.
+Choose Resque if:
 
-If you'd like to run multiple workers in development mode, you can do
-so using the `resque:workers` rake task:
+* You need multiple queues
+* You don't care / dislike numeric priorities
+* You don't need to persist every Ruby object ever
+* You have potentially huge queues
+* You want to see what's going on
+* You expect a lot of failure / chaos
+* You can setup Redis
+* You're not running short on RAM
 
-    $ COUNT=5 QUEUE=* rake resque:workers
+Choose DelayedJob if:
 
-This will spawn five Resque workers, each in its own process. Hitting
-ctrl-c should be sufficient to stop them all.
+* You like numeric priorities
+* You're not doing a gigantic amount of jobs each day
+* Your queue stays small and nimble
+* There is not a lot failure / chaos
+* You want to easily throw anything on the queue
+* You don't want to setup Redis
 
+In no way is Resque a "better" DelayedJob, so make sure you pick the
+tool that's best for your app.
 
-### Forking
+#### Forking
 
 On certain platforms, when a Resque worker reserves a job it
 immediately forks a child process. The child processes the job then
@@ -406,8 +669,13 @@ complicated.
 
 Workers instead handle their own state.
 
+#### `at_exit` Callbacks
+
+Resque uses `Kernel#exit!` for exiting its workers' child processes. So any `at_exit` callback defined in your application won't be executed when the job is finished and the child process exits.
+
+You can alter this behavior by setting the `RUN_AT_EXIT_HOOKS` environment variable.
 
-### Parents and Children
+#### Parents and Children
 
 Here's a parent / child pair doing some work:
 
@@ -428,7 +696,7 @@ waiting for work on:
     92099 resque: Waiting for file_serve,warm_cache
 
 
-### Signals
+#### Signals
 
 Resque workers respond to a few different signals:
 
@@ -448,9 +716,9 @@ If you want to kill a stale or stuck child and shutdown, use `TERM`
 
 If you want to stop processing jobs, but want to leave the worker running
 (for example, to temporarily alleviate load), use `USR2` to stop processing,
-then `CONT` to start it again.
+then `CONT` to start it again. It's also possible to [pause all workers](#pausing-all-workers).
 
-#### Signals on Heroku
+#### Heroku
 
 When shutting down processes, Heroku sends every process a TERM signal at the
 same time. By default this causes an immediate shutdown of any running job
@@ -458,6 +726,11 @@ leading to frequent `Resque::TermException` errors.  For short running jobs, a s
 solution is to give a small amount of time for the job to finish
 before killing it.
 
+Resque doesn't handle this out of the box (for both cedar-14 and heroku-16), you need to
+install the [`resque-heroku-signals`](https://github.com/iloveitaly/resque-heroku-signals)
+addon which adds the required signal handling to make the behavior described above work.
+Related issue: https://github.com/resque/resque/issues/1559
+
 To accomplish this set the following environment variables:
 
 * `RESQUE_PRE_SHUTDOWN_TIMEOUT` - The time between the parent receiving a shutdown signal (TERM by default) and it sending that signal on to the child process. Designed to give the child process
@@ -467,11 +740,41 @@ time to complete before being forced to die.
 
 * `RESQUE_TERM_TIMEOUT` - By default you have a few seconds to handle `Resque::TermException` in your job. `RESQUE_TERM_TIMEOUT` and `RESQUE_PRE_SHUTDOWN_TIMEOUT` must be lower than the [heroku dyno timeout](https://devcenter.heroku.com/articles/limits#exit-timeout).
 
-### Mysql::Error: MySQL server has gone away
+#### Pausing all workers
+
+Workers will not process pending jobs if the Redis key `pause-all-workers` is set with the string value "true".
+
+``` ruby
+Resque.redis.set('pause-all-workers', 'true')
+```
+
+Nothing happens to jobs that are already being processed by workers.
+
+Unpause by removing the Redis key `pause-all-workers`.
+
+``` ruby
+Resque.redis.del('pause-all-workers')
+```
+
+#### Monitoring
+
+##### god
+
+If you're using god to monitor Resque, we have provided example
+configs in `examples/god/`. One is for starting / stopping workers,
+the other is for killing workers that have been running too long.
+
+##### monit
+
+If you're using monit, `examples/monit/resque.monit` is provided free
+of charge. This is **not** used by GitHub in production, so please
+send patches for any tweaks or improvements you can make to it.
+
+#### Mysql::Error: MySQL server has gone away
 
 If your workers remain idle for too long they may lose their MySQL connection. Depending on your version of Rails, we recommend the following:
 
-#### Rails 3.x
+##### Rails
 In your `perform` method, add the following line:
 
 ``` ruby
@@ -487,7 +790,7 @@ The Rails doc says the following about `verify_active_connections!`:
 
     Verify active connections and remove and disconnect connections associated with stale threads.
 
-#### Rails 4.x
+##### Rails 4.x
 
 In your `perform` method, instead of `verify_active_connections!`, use:
 
@@ -504,362 +807,6 @@ From the Rails docs on [`clear_active_connections!`](http://api.rubyonrails.org/
 
     Returns any connections in use by the current thread back to the pool, and also returns connections to the pool cached by threads that are no longer alive.
 
-
-
-The Front End
--------------
-
-Resque comes with a Sinatra-based front end for seeing what's up with
-your queue.
-
-![The Front End](https://camo.githubusercontent.com/64d150a243987ffbc33f588bd6d7722a0bb8d69a/687474703a2f2f7475746f7269616c732e6a756d7073746172746c61622e636f6d2f696d616765732f7265737175655f6f766572766965772e706e67)
-
-### Standalone
-
-If you've installed Resque as a gem running the front end standalone is easy:
-
-    $ resque-web
-
-It's a thin layer around `rackup` so it's configurable as well:
-
-    $ resque-web -p 8282
-
-If you have a Resque config file you want evaluated just pass it to
-the script as the final argument:
-
-    $ resque-web -p 8282 rails_root/config/initializers/resque.rb
-
-You can also set the namespace directly using `resque-web`:
-
-    $ resque-web -p 8282 -N myapp
-
-or set the Redis connection string if you need to do something like select a different database:
-
-    $ resque-web -p 8282 -r localhost:6379:2
-
-### Passenger
-
-Using Passenger? Resque ships with a `config.ru` you can use. See
-Phusion's guide:
-
-Apache: <https://www.phusionpassenger.com/library/deploy/apache/deploy/ruby/>
-Nginx: <https://www.phusionpassenger.com/library/deploy/nginx/deploy/ruby/>
-
-### Rack::URLMap
-
-If you want to load Resque on a subpath, possibly alongside other
-apps, it's easy to do with Rack's `URLMap`:
-
-``` ruby
-require 'resque/server'
-
-run Rack::URLMap.new \
-  "/"       => Your::App.new,
-  "/resque" => Resque::Server.new
-```
-
-Check `examples/demo/config.ru` for a functional example (including
-HTTP basic auth).
-
-### Rails 3
-
-You can also mount Resque on a subpath in your existing Rails 3 app by adding `require 'resque/server'` to the top of your routes file or in an initializer then adding this to `routes.rb`:
-
-``` ruby
-mount Resque::Server.new, :at => "/resque"
-```
-
-
-Resque vs DelayedJob
---------------------
-
-How does Resque compare to DelayedJob, and why would you choose one
-over the other?
-
-* Resque supports multiple queues
-* DelayedJob supports finer grained priorities
-* Resque workers are resilient to memory leaks / bloat
-* DelayedJob workers are extremely simple and easy to modify
-* Resque requires Redis
-* DelayedJob requires ActiveRecord
-* Resque can only place JSONable Ruby objects on a queue as arguments
-* DelayedJob can place _any_ Ruby object on its queue as arguments
-* Resque includes a Sinatra app for monitoring what's going on
-* DelayedJob can be queried from within your Rails app if you want to
-  add an interface
-
-If you're doing Rails development, you already have a database and
-ActiveRecord. DelayedJob is super easy to setup and works great.
-GitHub used it for many months to process almost 200 million jobs.
-
-Choose Resque if:
-
-* You need multiple queues
-* You don't care / dislike numeric priorities
-* You don't need to persist every Ruby object ever
-* You have potentially huge queues
-* You want to see what's going on
-* You expect a lot of failure / chaos
-* You can setup Redis
-* You're not running short on RAM
-
-Choose DelayedJob if:
-
-* You like numeric priorities
-* You're not doing a gigantic amount of jobs each day
-* Your queue stays small and nimble
-* There is not a lot failure / chaos
-* You want to easily throw anything on the queue
-* You don't want to setup Redis
-
-In no way is Resque a "better" DelayedJob, so make sure you pick the
-tool that's best for your app.
-
-Resque Dependencies
--------------------
-
-    $ gem install bundler
-    $ bundle install
-
-
-Installing Resque
------------------
-
-### In a Rack app, as a gem
-
-First install the gem.
-
-    $ gem install resque
-
-Next include it in your application.
-
-``` ruby
-require 'resque'
-```
-
-Now start your application:
-
-    rackup config.ru
-
-That's it! You can now create Resque jobs from within your app.
-
-To start a worker, create a Rakefile in your app's root (or add this
-to an existing Rakefile):
-
-``` ruby
-require 'your/app'
-require 'resque/tasks'
-```
-
-If you're using Rails 5.x, include the following in lib/tasks/resque.rb:
-
-```ruby
-require 'resque/tasks'
-task 'resque:setup' => :environment
-```
-
-Now:
-
-    $ QUEUE=* rake resque:work
-
-Alternately you can define a `resque:setup` hook in your Rakefile if you
-don't want to load your app every time rake runs.
-
-
-### In a Rails 2.x app, as a gem
-
-First install the gem.
-
-    $ gem install resque
-
-Next include it in your application.
-
-    $ cat config/initializers/load_resque.rb
-    require 'resque'
-
-Now start your application:
-
-    $ ./script/server
-
-That's it! You can now create Resque jobs from within your app.
-
-To start a worker, add this to your Rakefile in `RAILS_ROOT`:
-
-``` ruby
-require 'resque/tasks'
-```
-
-Now:
-
-    $ QUEUE=* rake environment resque:work
-
-Don't forget you can define a `resque:setup` hook in
-`lib/tasks/whatever.rake` that loads the `environment` task every time.
-
-
-### In a Rails 2.x app, as a plugin
-
-    $ ./script/plugin install git://github.com/resque/resque
-
-That's it! Resque will automatically be available when your Rails app
-loads.
-
-To start a worker:
-
-    $ QUEUE=* rake environment resque:work
-
-Don't forget you can define a `resque:setup` hook in
-`lib/tasks/whatever.rake` that loads the `environment` task every time.
-
-
-### In a Rails 3.x or 4.x app, as a gem
-
-First include it in your Gemfile.
-
-    $ cat Gemfile
-    ...
-    gem 'resque'
-    ...
-
-Next install it with Bundler.
-
-    $ bundle install
-
-Now start your application:
-
-    $ rails server
-
-That's it! You can now create Resque jobs from within your app.
-
-To start a worker, add this to a file in `lib/tasks` (ex:
-`lib/tasks/resque.rake`):
-
-``` ruby
-require 'resque/tasks'
-```
-
-Now:
-
-    $ QUEUE=* rake environment resque:work
-
-Don't forget you can define a `resque:setup` hook in
-`lib/tasks/whatever.rake` that loads the `environment` task every time.
-
-
-Configuration
--------------
-
-You may want to change the Redis host and port Resque connects to, or
-set various other options at startup.
-
-Resque has a `redis` setter which can be given a string or a Redis
-object. This means if you're already using Redis in your app, Resque
-can re-use the existing connection.
-
-String: `Resque.redis = 'localhost:6379'`
-
-Redis: `Resque.redis = $redis`
-
-For our rails app we have a `config/initializers/resque.rb` file where
-we load `config/resque.yml` by hand and set the Redis information
-appropriately.
-
-Here's our `config/resque.yml`:
-
-    development: localhost:6379
-    test: localhost:6379
-    staging: redis1.se.github.com:6379
-    fi: localhost:6379
-    production: redis1.ae.github.com:6379
-
-And our initializer:
-
-``` ruby
-rails_root = ENV['RAILS_ROOT'] || File.dirname(__FILE__) + '/../..'
-rails_env = ENV['RAILS_ENV'] || 'development'
-
-resque_config = YAML.load_file(rails_root + '/config/resque.yml')
-Resque.redis = resque_config[rails_env]
-```
-
-Easy peasy! Why not just use `RAILS_ROOT` and `RAILS_ENV`? Because
-this way we can tell our Sinatra app about the config file:
-
-    $ RAILS_ENV=production resque-web rails_root/config/initializers/resque.rb
-
-Now everyone is on the same page.
-
-Also, you could disable jobs queueing by setting 'inline' attribute.
-For example, if you want to run all jobs in the same process for cucumber, try:
-
-``` ruby
-Resque.inline = ENV['RAILS_ENV'] == "cucumber"
-```
-
-
-Plugins and Hooks
------------------
-
-For a list of available plugins see
-<http://wiki.github.com/resque/resque/plugins>.
-
-If you'd like to write your own plugin, or want to customize Resque
-using hooks (such as `Resque.after_fork`), see
-[docs/HOOKS.md](http://github.com/resque/resque/blob/master/docs/HOOKS.md).
-
-
-Namespaces
-----------
-
-If you're running multiple, separate instances of Resque you may want
-to namespace the keyspaces so they do not overlap. This is not unlike
-the approach taken by many memcached clients.
-
-This feature is provided by the [redis-namespace][rs] library, which
-Resque uses by default to separate the keys it manages from other keys
-in your Redis server.
-
-Simply use the `Resque.redis.namespace` accessor:
-
-``` ruby
-Resque.redis.namespace = "resque:GitHub"
-```
-
-We recommend sticking this in your initializer somewhere after Redis
-is configured.
-
-
-Demo
-----
-
-Resque ships with a demo Sinatra app for creating jobs that are later
-processed in the background.
-
-Try it out by looking at the README, found at `examples/demo/README.markdown`.
-
-
-Monitoring
-----------
-
-### god
-
-If you're using god to monitor Resque, we have provided example
-configs in `examples/god/`. One is for starting / stopping workers,
-the other is for killing workers that have been running too long.
-
-### monit
-
-If you're using monit, `examples/monit/resque.monit` is provided free
-of charge. This is **not** used by GitHub in production, so please
-send patches for any tweaks or improvements you can make to it.
-
-
-Questions
----------
-
-Please add them to the [FAQ](https://github.com/resque/resque/wiki/FAQ) or open an issue on this repo.
-
-
 Development
 -----------
 
@@ -889,26 +836,27 @@ it:
 If you get an error requiring any of the dependencies, you may have
 failed to install them or be seeing load path issues.
 
+#### Demo
+Resque ships with a demo Sinatra app for creating jobs that are later
+processed in the background.
 
-Contributing
-------------
+Try it out by looking at the README, found at `examples/demo/README.markdown`.
+
+#### Contributing
 
 Read [CONTRIBUTING.md](CONTRIBUTING.md) first.
 
 Once you've made your great commits:
 
-1. [Fork][1] Resque
+1. [Fork](http://help.github.com/forking/) Resque
 2. Create a topic branch - `git checkout -b my_branch`
 3. Push to your branch - `git push origin my_branch`
 4. Create a [Pull Request](http://help.github.com/pull-requests/) from your branch
-5. That's it!
-
-
-Mailing List
-------------
 
-This mailing list is no longer maintained. The archive can be found at <http://librelist.com/browser/resque/>.
+Questions
+---------
 
+Please add them to the [FAQ](https://github.com/resque/resque/wiki/FAQ) or open an issue on this repo.
 
 Meta
 ----
@@ -917,21 +865,11 @@ Meta
 * Home: <http://github.com/resque/resque>
 * Docs: <http://rubydoc.info/gems/resque>
 * Bugs: <http://github.com/resque/resque/issues>
-* List: <resque@librelist.com>
-* Chat: <irc://irc.freenode.net/resque>
-* Gems: <http://gemcutter.org/gems/resque>
-
-This project uses [Semantic Versioning][sv].
+* Gems: <https://rubygems.org/gems/resque>
 
+This project uses [Semantic Versioning](http://semver.org/)
 
 Author
 ------
 
 Chris Wanstrath :: chris@ozmm.org :: @defunkt
-
-[0]: http://github.com/blog/542-introducing-resque
-[1]: http://help.github.com/forking/
-[2]: http://github.com/resque/resque/issues
-[sv]: http://semver.org/
-[rs]: http://github.com/resque/redis-namespace
-[cb]: http://wiki.github.com/resque/resque/contributing