resque 2.0.0 → 2.6.0

data/README.markdown

@@ -2,12 +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)
+[![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
@@ -20,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
@@ -36,19 +42,15 @@ 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.
 
+### Note on the future of Resque
 
-The Blog Post
--------------
-
-For the backstory, philosophy, and history of Resque's beginnings,
-please see [the blog post][0].
-
+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!
 
-Overview
---------
-
-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:
@@ -108,10 +110,219 @@ 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
+
+When INTERVAL is set to 0 it will run until the queue is empty and then
+shutdown the worker, instead of waiting for new jobs.
+
+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
 ----
@@ -138,8 +349,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:
@@ -184,7 +394,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/`
@@ -193,7 +403,7 @@ 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
@@ -217,57 +427,89 @@ 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
+-------------
 
-If we've installed Resque as a Rails plugin, we might run this command
-from our RAILS_ROOT:
+#### Redis
 
-    $ QUEUE=file_serve rake environment resque:work
+You may want to change the Redis host and port Resque connects to, or
+set various other options at startup.
 
-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:
+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.
 
-``` ruby
-task "resque:setup" => :environment
-```
+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: <%= ENV['REDIS_URL'] %>
 
-GitHub's setup task looks like this:
+And our initializer:
 
 ``` ruby
-task "resque:setup" => :environment do
-  Grit::Git.git_timeout = 10.minutes
-end
+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]
 ```
 
-We don't want the `git_timeout` as high as 10 minutes in our web app,
-but in the Resque workers it's fine.
+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"
+```
 
-### Logging
+#### Logging
 
 Workers support basic logging to STDOUT.
 
@@ -285,14 +527,33 @@ If you want Resque to log to a file, in Rails do:
 Resque.logger = Logger.new(Rails.root.join('log', "#{Rails.env}_resque.log"))
 ```
 
-### Storing Statistics
- Resque allows to store count of processed and failed jobs.
+#### Namespaces
 
- By default it will store it in Redis using the keys `stats:processed` and `stats:failed`.
+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.
 
- Some apps would want another stats store, or even a null store:
+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.
 
- ```ruby
+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.
+
+#### Storing Statistics
+ Resque allows to store count of processed and failed jobs.
+
+ By default it will store it in Redis using the keys `stats:processed` and `stats:failed`.
+
+ Some apps would want another stats store, or even a null store:
+
+ ```ruby
 # config/initializers/resque.rb
 class NullDataStore
   def stat(stat)
@@ -312,91 +573,65 @@ end
 Resque.stat_data_store = NullDataStore.new
 ```
 
-### 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 environment 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 environment 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 environment resque:work
-
-### 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:
+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
@@ -437,8 +672,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:
 
@@ -459,7 +699,7 @@ waiting for work on:
     92099 resque: Waiting for file_serve,warm_cache
 
 
-### Signals
+#### Signals
 
 Resque workers respond to a few different signals:
 
@@ -479,9 +719,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
@@ -503,11 +743,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
@@ -523,7 +793,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:
 
@@ -540,363 +810,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.rake:
-
-```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: <%= ENV['REDIS_URL'] %>
-
-And our initializer:
-
-``` ruby
-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]
-```
-
-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
 -----------
 
@@ -926,26 +839,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
 ----
@@ -954,21 +868,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