postburner 0.8.0 → 1.0.0.pre.1

data/README.md

@@ -1,365 +1,1346 @@
 # Postburner
-An ActiveRecord layer on top of [Backburner](https://github.com/nesquena/backburner) for inspecting and auditing the
-queue, especially for delayed jobs. It isn't meant to be outperform other queues, but be safe (and inspectable).
 
-It is meant to be complementary to [Backburner](https://github.com/nesquena/backburner). Use Backburner as the default
-ActiveJob processor for mailers, active storage, and the like. Use a
-`Postburner::Job` for things that you want to track. See [Comparison to Backburner](#comparison-to-backburner) for more.
+Fast Beanstalkd-backed job queue with **optional PostgreSQL audit trail** for ActiveJob.
 
-Postburner meant to be a replacement/upgrade for [Que](https://github.com/que-rb/que).
-If you need something faster, check out Que - we love it! Postburner is built for a slightly different purpose: to be
-simple, safe, and inspectable. All of which Que has (or can be added), but are included by default with some architecture
-differences. See [Comparison to Que](#comparison-to-que) for more.
+Postburner provides dual-mode job execution:
+- **Default jobs**: Fast execution via Beanstalkd only (no PostgreSQL overhead)
+- **Tracked jobs**: Full audit trail with logs, timing, errors, and statistics
 
-## Usage
+Built for production environments where you want fast background processing for most jobs, but comprehensive auditing for critical operations.
+
+## Features
+
+- **ActiveJob native** - Works seamlessly with Rails, ActionMailer, ActiveStorage
+- **Dual-mode execution** - Default or tracked (database backed)
+- **Rich audit trail** - Logs, timing, errors, retry tracking (tracked jobs only)
+- **ActiveRecord** - Query jobs with ActiveRecord (Tracked jobs only)
+- **Beanstalkd** - Fast, reliable queue separate from your database, peristent storage
+- **Process isolation** - Forking workers with optional threading for throughput
+- **Test-friendly** - Inline execution without Beanstalkd in tests
+
+## Quick Start
+
+**Installation:**
+
+```bash
+sudo apt-get install beanstalkd # OR brew install beanstalkd
+
+# Start beanstalkd (in-memory only)
+beanstalkd -l 127.0.0.1 -p 11300
+
+# OR with persistence (recommended for production)
+mkdir -p /var/lib/beanstalkd
+beanstalkd -l 127.0.0.1 -p 11300 -b /var/lib/beanstalkd
+```
 
 ```ruby
-class RunDonation < Postburner::Job
-  queue 'critical'
-  queue_priority 0 # 0 is highest priority
-  queue_max_job_retries 0 # don't retry
+# Gemfile
+gem 'postburner', '~> 1.0.0.pre.1'
+```
 
-  def perform(args)
-    # do long tasks here
-    # also have access to self.args
+```bash
+bundle install
+rails generate postburner:install
+rails db:migrate
+```
+
+**Configuration:**
+
+```ruby
+# config/application.rb
+config.active_job.queue_adapter = :postburner
+```
+
+```yaml
+# config/postburner.yml
+production:
+  beanstalk_url: <%= ENV['BEANSTALK_URL'] || 'beanstalk://localhost:11300' %>
+  worker_type: simple
+  queues:
+    default: {}
+    critical: {}
+    mailers: {}
+```
+
+**Usage:**
+
+```ruby
+# Default job (fast, no PostgreSQL overhead)
+class SendEmail < ApplicationJob
+  def perform(user_id)
+    UserMailer.welcome(user_id).deliver_now
   end
 end
 
-# RunDonation#create! is the `ActiveRecord` method, so it returns a model,
-# you can manipulate, add columns to the table to, reference with foreign
-# keys, etc.
-job = RunDonation.create!(args: {donation_id: 123})
-# NOTE Make sure use use an after_commit or after_save_commit, etc to avoid
-#      any race conditions of Postburner trying to process before a required
-#      database mutation is commited.
-job.queue!
-=> {:status=>"INSERTED", :id=>"1139"}
+# Default job with Beanstalkd configuration
+class SendEmail < ApplicationJob
+  include Postburner::Beanstalkd
+
+  queue_priority 100  # Custom priority
+  queue_ttr 300       # 5 minute timeout
+
+  def perform(user_id)
+    UserMailer.welcome(user_id).deliver_now
+  end
+end
+
+# Tracked job (full audit trail, includes Beanstalkd automatically)
+class ProcessPayment < ApplicationJob
+  include Postburner::Tracked  # ← Opt-in to tracking (includes Beanstalkd)
+
+  queue_priority 0  # Highest priority
+  queue_ttr 600     # 10 minute timeout
 
-# queue for later with `:at`
-RunDonation.create!(args: {donation_id: 123}).queue! at: Time.zone.now + 2.days
-=> {:status=>"INSERTED", :id=>"1140"}
+  def perform(payment_id)
+    log "Processing payment #{payment_id}"
+    Payment.find(payment_id).process!
+    log! "Payment processed successfully"
+  end
+end
 
-# queue for later with `:delay`
-#
-# `:delay` takes priority over `:at`takes priority over `:at` because the
-# beanstalkd protocol uses uses `delay`
-RunDonation.create!(args: {donation_id: 123}).queue! delay: 1.hour
-=> {:status=>"INSERTED", :id=>"1141"}
+# Run worker
+bin/postburner --config config/postburner.yml --env production
 ```
 
-### Mailers
+## Table of Contents
 
-```ruby
-j = Postburner::Mailer.
-  delivery(UserMailer, :welcome)
-  .with(name: 'Freddy')
+- [Why Beanstalkd?](#why-beanstalkd)
+- [Installation](#installation)
+- [Usage](#usage)
+  - [Standard Jobs](#standard-jobs)
+  - [Tracked Jobs](#tracked-jobs)
+  - [Postburner::Job](#postburnerjob)
+- [Workers](#workers)
+- [Configuration](#configuration)
+- [Queue Strategies](#queue-strategies)
+- [Testing](#testing)
+- [Job Management](#job-management)
+- [Beanstalkd Integration](#beanstalkd-integration)
+- [Web UI](#web-ui)
 
-j.queue!
-=> {:status=>"INSERTED", :id=>"1139"}
+## Why Beanstalkd?
+
+Beanstalkd is a simple, fast, and reliable queue system. It is a good choice for production environments where you want fast background processing for most jobs, but comprehensive auditing for critical operations.
+
+The [protocol](https://github.com/beanstalkd/beanstalkd/blob/master/doc/protocol.txt) reads more like a README than a protocol. Check it out and you will instantly understand how it works.
+
+### Binlogs
+
+Beanstalkd lets you persist jobs to disk in case of a crash or restart. Just restart beanstalkd and the jobs will be back in the queue.
+
+**Setup:**
+
+```bash
+# Create binlog directory
+sudo mkdir -p /var/lib/beanstalkd
+sudo chown beanstalkd:beanstalkd /var/lib/beanstalkd  # If running as service
+
+# Start beanstalkd with binlog persistence
+beanstalkd -l 127.0.0.1 -p 11300 -b /var/lib/beanstalkd
 ```
 
-### [Beaneater](https://github.com/beanstalkd/beaneater) and [beanstalkd](https://raw.githubusercontent.com/beanstalkd/beanstalkd/master/doc/protocol.txt) attributes and methods
-```ruby
-# get the beanstalkd job id
-job.bkid
-=> 1104
+**Configuration options:**
 
-# get the beaneater job, call any beaneater methods on this object
-job.beanstalk_job
+```bash
+# Basic persistence
+beanstalkd -b /var/lib/beanstalkd
 
-# get the beanstald stats
-job.beanstalk_job.stats
+# With custom binlog file size (default varies)
+beanstalkd -b /var/lib/beanstalkd -s 10485760  # 10MB per binlog file
 
-# kick the beanstalk job
-job.kick!
+# Reduce fsync frequency for better performance (trades safety for speed)
+beanstalkd -b /var/lib/beanstalkd -f 200  # fsync at most every 200ms (default: 50ms)
 
-# delete beankstalkd job, retain the job model
-job.delete!
+# Never fsync (maximum performance, higher risk of data loss on power failure)
+beanstalkd -b /var/lib/beanstalkd -F
+```
 
-# delete beankstalkd job, retain the job model, but set `removed_at` on model.
-job.remove!
+**Options:**
+- `-b <dir>` - Enable binlog persistence in specified directory
+- `-s <bytes>` - Maximum size of each binlog file (requires `-b`)
+- `-f <ms>` - Call fsync at most once every N milliseconds (requires `-b`, default: 50ms)
+- `-F` - Never call fsync (requires `-b`, maximum performance but higher data loss risk)
+
+**Note:** The fsync options control the trade-off between performance and safety. A power failure could result in loss of jobs added within the fsync interval.
+
+### Priority
+
+Priority controls the order in which jobs are processed from the queue. Beanstalkd always processes the highest priority (lowest number) jobs first.
+
+**Priority Range:** 0 to 4,294,967,295 (unsigned 32-bit integer)
+- `0` = Highest priority (processed first)
+- `4,294,967,295` = Lowest priority (processed last)
+- Default: `65536` (configurable in `config/postburner.yml`)
+
+When a worker reserves a job, Beanstalkd returns the highest priority job available in the tube. Jobs with the same priority are processed in FIFO order.
+
+**ActiveJob with Postburner::Beanstalkd:**
+
+```ruby
+class ProcessPayment < ApplicationJob
+  include Postburner::Beanstalkd
+
+  queue_as :critical
+  queue_priority 0  # Highest priority - processed immediately
+end
 
-# or simply remove the model, which will clean up the beanstalkd job in a before_destroy hook
-job.destroy # OR job.destroy!
-
-# get a cached Backburner connection and inspect it (or even use it directly)
-c = Postburner.connection
-c.beanstalk.tubes.to_a
-c.beanstalk.tubes.to_a.map{|t| c.tubes[t.name].peek(:buried)}
-c.beanstalk.tubes['ss.development.caching'].stats
-c.beanstalk.tubes['ss.development.caching'].peek(:buried).kick
-c.beanstalk.tubes['ss.development.caching'].kick(3)
-c.close
-
-# automatically close
-Postburner.connected do |connection|
-  # do stuff with connection
+class SendEmail < ApplicationJob
+  include Postburner::Beanstalkd
+
+  queue_as :mailers
+  queue_priority 1000  # Lower priority - processed after critical jobs
 end
 ```
 
-Read about the [beanstalkd protocol](https://raw.githubusercontent.com/beanstalkd/beanstalkd/master/doc/protocol.txt).
+**Postburner::Job:**
 
-### Basic model fields
 ```ruby
-# ActiveRecord primary key
-job.id
+class CriticalJob < Postburner::Job
+  queue 'critical'
+  queue_priority 0  # Highest priority
+
+  def perform(args)
+    # Critical business logic
+  end
+end
+
+class BackgroundTask < Postburner::Job
+  queue 'default'
+  queue_priority 5000  # Lower priority
+
+  def perform(args)
+    # Non-urgent background work
+  end
+end
+```
 
-# int id of the beankstalkd job
-job.bkid
+**Recommended Priority Ranges:**
 
-# string uuid
-job.sid
+| Priority Range | Use Case | Examples |
+|---------------|----------|----------|
+| 0-256 | Critical business operations | Payments, transactions, real-time notifications |
+| 256-4096 | High priority tasks | Password resets, order confirmations |
+| 4096-65536 | Standard background jobs | Email sending, data exports (65536 is default) |
+| 65536-262144 | Low priority maintenance | Cache warming, log cleanup |
+| 262144+ | Deferred/bulk operations | Analytics, batch reports |
 
-# ActiveRecord STI job subtype
-job.type
+**Configuration:**
 
-# jsonb arguments for use in job
-job.args
+Set default priority in `config/postburner.yml`:
 
-# time job should run - not intended to be changed
-# TODO run_at should be readonly after create
-job.run_at
+```yaml
+production:
+  default_priority: 65536  # Default for jobs without explicit priority
+  default_ttr: 300
 ```
 
-### Job statistics
+**Dynamic Priority (Postburner::Job only):**
+
 ```ruby
-# when job was inserted into beankstalkd
-job.queued_at
+class ProcessOrder < Postburner::Job
+  queue 'orders'
+  queue_priority 100  # Default
+
+  before_enqueue :adjust_priority
 
-# last time attempted
-job.attempting_at
+  def perform(args)
+    order = Order.find(args['order_id'])
+    order.process!
+  end
 
-# last time processing started
-job.processing_at
+  private
 
-# when completed
-job.processed_at
+  def adjust_priority
+    if args['urgent']
+      self.queue_priority = 0  # Override to highest priority
+    end
+  end
+end
 
-# when removed, may be nil
-job.removed_at
+# Usage
+ProcessOrder.create!(args: { 'order_id' => 123, 'urgent' => true }).queue!
+```
 
-# lag in ms from run_at/queued_at to attempting_at
-job.lag
+### Time to Run (TTR)
 
-# duration of processing in ms
-job.duration
+TTR (Time-to-Run) is the maximum duration in seconds that a worker has to process a reserved job before Beanstalkd automatically releases it back to the ready queue.
 
-# number of attempts
-job.attempt_count
+1. Worker reserves a job from Beanstalkd
+2. TTR countdown begins immediately upon reservation
+3. If job completes within TTR, worker deletes/buries the job (success)
+4. If TTR expires before completion, Beanstalkd automatically releases the job back to ready queue
+5. Another worker can then reserve and process the same job
 
-# number of errors (length of errata)
-job.error_count
+This mechanism protects against workers crashing or hanging—jobs won't be stuck indefinitely.
 
-# number of log entries (length of logs)
-job.log_count
+**TTR Range:** 1 to 4,294,967,295 seconds (unsigned 32-bit integer)
+- Minimum: `1` second (Beanstalkd silently increases 0 to 1)
+- Default: `300` seconds (5 minutes, configurable in `config/postburner.yml`)
 
-# array of attempting_at times
-job.attempts
+**ActiveJob with Postburner::Beanstalkd:**
 
-# array of errors
-job.errata
+```ruby
+class ProcessPayment < ApplicationJob
+  include Postburner::Beanstalkd
 
-# array of log messages
-job.logs
-```
+  queue_as :critical
+  queue_priority 0
+  queue_ttr 300  # 5 minutes to complete
+end
 
-### Job logging and exceptions
+class QuickEmail < ApplicationJob
+  include Postburner::Beanstalkd
 
-Optionally, you can:
-1. Add log messages to the job during processing to `logs`
-1. Add log your own exceptions to `errata`
+  queue_as :mailers
+  queue_ttr 60  # 1 minute for fast email jobs
+end
+
+class LongRunningReport < ApplicationJob
+  include Postburner::Beanstalkd
+
+  queue_as :reports
+  queue_ttr 3600  # 1 hour for complex reports
+end
+```
+
+**Postburner::Job:**
 
 ```ruby
-class RunDonation < Postburner::Job
-  queue 'critical'
-  queue_priority 0 # 0 is highest priority
-  queue_max_job_retries 0 # don't retry
+class DataImport < Postburner::Job
+  queue 'imports'
+  queue_ttr 1800  # 30 minutes (equivalent to queue_ttr)
 
   def perform(args)
-    # log at task, defaults to `:info`, but `:debug`, `:warning`, `:error`
-    log "Log bad condition...", level: :error
+    # Long-running import logic
+  end
+end
+```
 
-    begin
-      # danger
-    rescue Exception => e
-      log_exception e
+**Extending TTR with `extend!` (Touch Command):**
+
+For jobs that may take longer than expected, you can extend the TTR dynamically using `extend!`. This calls Beanstalkd's `touch` command, which resets the TTR countdown.
+
+**Available for:**
+- `Postburner::Job` subclasses (always available via `bk.extend!`)
+- `Postburner::Tracked` ActiveJob classes (includes `extend!` method)
+
+```ruby
+class ProcessImport < ApplicationJob
+  include Postburner::Tracked  # Includes Beanstalkd and enables extend!
+
+  queue_as :imports
+  queue_ttr 300  # 5 minutes initial TTR
+
+  def perform(file_id)
+    file = ImportFile.find(file_id)
+
+    file.each_batch(size: 100) do |batch|
+      batch.each do |row|
+        process_row(row)
+      end
+
+      extend!  # Reset TTR to 300 seconds from now
+      log "Processed batch, extended TTR"
     end
   end
 end
 ```
 
-### Optionally, mount the engine
+**For Postburner::Job (via `bk` accessor):**
 
 ```ruby
-mount Postburner::Engine => "/postburner"
+class LargeDataProcessor < Postburner::Job
+  queue 'processing'
+  queue_ttr 600  # 10 minutes
 
-# mount only for development inspection
-mount Postburner::Engine => "/postburner" if Rails.env.development?
+  def perform(args)
+    dataset = Dataset.find(args['dataset_id'])
+
+    dataset.each_chunk do |chunk|
+      process_chunk(chunk)
+
+      bk.extend!  # Reset TTR via beanstalkd job accessor
+      log "Chunk processed, TTR extended"
+    end
+  end
+end
+```
+
+**`extend!` and Beanstalkd `touch`**
+
+- Calls Beanstalkd's `touch` command on the reserved job
+- Resets the TTR countdown to the original TTR value from the current moment
+- Example: Job has `queue_ttr 300`. After 200 seconds, calling `extend!` gives you another 300 seconds (not just 100)
+- Can be called multiple times during job execution
+- Useful for iterative processing where each iteration is quick but total time is unpredictable
+
+**Configuration:**
+
+Set default TTR in `config/postburner.yml`:
+
+```yaml
+production:
+  default_priority: 65536
+  default_ttr: 300  # 5 minutes default for all jobs
 ```
 
-[Open the controller](https://guides.rubyonrails.org/engines.html#overriding-models-and-controllers)
-to add your own authentication or changes - or just create your own routes, controllers, and views.
+**Recommended TTR Values:**
+
+| Job Type | TTR | Reasoning |
+|----------|-----|-----------|
+| Email sending | 60-120s | Network operations, should be fast |
+| API calls | 30-60s | External services, fast or timeout |
+| File processing | 600-1800s | Variable based on file size, use `extend!` |
+| Reports | 1800-3600s | Complex queries and aggregations |
+| Imports/Exports | 3600s+ | Large datasets, use `extend!` in loops |
 
-[Override the views](https://guides.rubyonrails.org/engines.html#overriding-views) to make them
-prettier - or follow the suggestion above and use your own.
+**Best Practices:**
 
-## Known Issues
+1. **Set realistic TTR values** based on expected job duration plus buffer
+2. **Use `extend!` for iterative work** where total time is unpredictable but each iteration is bounded
+3. **Don't set TTR too high** - it delays recovery from crashed workers
+4. **Monitor TTR timeouts** - frequent timeouts indicate jobs need more time or optimization
+5. **For Default jobs** (ActiveJob without `Postburner::Beanstalkd`), include the module to set custom TTR
 
-1. Beaneater and/or Beanstalkd seems to transform a `tube` `name` with hyphens to
-   underscores upon instrospection of `stats`. See example. Reccommend using
-   names without hyphens / dashes.
+**What happens on TTR timeout:**
 
 ```ruby
-(main):001:0> Postburner.connection.tubes["backburner.worker.queue.cat-dog"].put("{}", delay: 1.week.to_i)
-=> {:status=>"INSERTED", :id=>"9"}
-irb(main):002:0> Postburner.connection.jobs.find(9)
-=> #<Beaneater::Job id=9 body="{}">
-irb(main):003:0> Postburner.connection.jobs.find(9).stats
-=> #<Beaneater::StatStruct id=9, tube="backburner.worker.queue.cat_dog", state="delayed", pri=65536, age=23, delay=604800, ttr=120, time_left=604776, file=0, reserves=0, timeouts=0, releases=0, buries=0, kicks=0>
-#
-# NOTE 'cat-dog' on line 1 and 'cat_dog' on line 3.
-#
+# Job starts processing
+job = ProcessImport.perform_later(file_id)
+
+# Worker crashes or hangs after 200 seconds
+# At 300 seconds (TTR), Beanstalkd automatically:
+# 1. Releases job back to ready queue
+# 2. Increments the job's reserve count
+# 3. Makes job available for another worker
+
+# Another worker picks up the job and retries
+# (ActiveJob retry_on/discard_on handlers still apply)
 ```
 
 ## Installation
 
-First [install beanstalkd](https://beanstalkd.github.io/download.html). On Debian-based systems, that goes like this:
+### 1. Install Beanstalkd
+
+First [install beanstalkd](https://beanstalkd.github.io/download.html):
+
 ```bash
 sudo apt-get install beanstalkd
+brew install beanstalkd # for macOS/Linux
+
+# Start beanstalkd (in-memory only)
+beanstalkd -l 127.0.0.1 -p 11300
+
+# OR with persistence (recommended for production)
+mkdir -p /var/lib/beanstalkd
+beanstalkd -l 127.0.0.1 -p 11300 -b /var/lib/beanstalkd
 ```
 
-Then add to your Gemfile.
+### 2. Add Gem
+
 ```ruby
-gem 'postburner'
+# Gemfile
+gem 'postburner', '~> 1.0.0.pre.1'
 ```
 
-Install...
 ```bash
-$ bundle
+bundle install
 ```
 
-After bundling, install the migration.
+### 3. Install Migration
+
+```bash
+rails generate postburner:install
+rails db:migrate
 ```
-# install migration, possible to edit and add attributes or indexes as needed.
-$ bundle exec rails g postburner:install
+
+This creates the `postburner_jobs` table for tracked jobs.
+
+### 4. Configure ActiveJob
+
+```ruby
+# config/application.rb
+config.active_job.queue_adapter = :postburner
+```
+
+### 5. Create Worker Configuration
+
+```bash
+cp config/postburner.yml.example config/postburner.yml
+```
+
+Edit `config/postburner.yml` for your environment (see [Configuration](#configuration)).
+
+## Usage
+
+### Default Jobs
+
+Default jobs execute quickly via Beanstalkd without PostgreSQL overhead. Perfect for emails, cache warming, notifications, etc.
+
+```ruby
+class SendWelcomeEmail < ApplicationJob
+  queue_as :mailers
+
+  def perform(user_id)
+    UserMailer.welcome(user_id).deliver_now
+  end
+end
+
+# Enqueue immediately
+SendWelcomeEmail.perform_later(123)
+
+# Enqueue with delay
+SendWelcomeEmail.set(wait: 1.hour).perform_later(123)
+
+# Enqueue at specific time
+SendWelcomeEmail.set(wait_until: Date.tomorrow.noon).perform_later(123)
 ```
 
-Inspect `XXX_create_postburner_jobs.rb`. (The template is [here](-/blob/master/lib/generators/postburner/install/templates/migrations/create_postburner_jobs.rb.erb)).The required attributes are in there, but add more if you would like to use them,
-or do it in a separate migration. By default, several indexes are added 
+**Overview:**
+- Fast execution (no database writes)
+- Low overhead
+- Standard ActiveJob retry_on/discard_on support
+- No audit trail
+- No logging or statistics
+
+#### Configuring Beanstalkd Priority and TTR
+
+For default jobs that need custom Beanstalkd configuration, include `Postburner::Beanstalkd`:
 
-Because `Postburner` is built on `Backburner`, add a `config/initializers/backburner.rb` with option found [here](https://github.com/nesquena/backburner#configuration).
 ```ruby
-Backburner.configure do |config|
-  config.beanstalk_url       = "beanstalk://127.0.0.1"
-  config.tube_namespace      = "some.app.production"
-  config.namespace_separator = "."
-  config.on_error            = lambda { |e| puts e }
-  config.max_job_retries     = 3 # default 0 retries
-  config.retry_delay         = 2 # default 5 seconds
-  config.retry_delay_proc    = lambda { |min_retry_delay, num_retries| min_retry_delay + (num_retries ** 3) }
-  config.default_priority    = 65536
-  config.respond_timeout     = 120
-  config.default_worker      = Backburner::Workers::Simple
-  config.logger              = Logger.new(STDOUT)
-  config.primary_queue       = "backburner-jobs"
-  config.priority_labels     = { :custom => 50, :useless => 1000 }
-  config.reserve_timeout     = nil
-  config.job_serializer_proc = lambda { |body| JSON.dump(body) }
-  config.job_parser_proc     = lambda { |body| JSON.parse(body) }
+class SendWelcomeEmail < ApplicationJob
+  include Postburner::Beanstalkd
+
+  queue_as :mailers
+  queue_priority 100    # Lower = higher priority (0 is highest)
+  queue_ttr 300         # Time-to-run in seconds (5 minutes)
+
+  def perform(user_id)
+    UserMailer.welcome(user_id).deliver_now
+  end
 end
 ```
 
-Finally, set `Backburner` for `ActiveJob`
+**Configuration options:**
+- `queue_priority` - Beanstalkd priority (0-4294967295, lower = higher priority)
+- `queue_ttr` - Time-to-run in seconds before job times out
+
+Jobs without `Postburner::Beanstalkd` use defaults from `config/postburner.yml`:
+- `default_priority: 65536`
+- `default_ttr: 300`
+
+### Tracked Jobs
+
+Tracked jobs store full execution details in PostgreSQL, providing comprehensive audit trails (i.e. logging, timing, errors, retry tracking) for critical operations.
+
+**Note:** `Postburner::Tracked` automatically includes `Postburner::Beanstalkd`, giving you access to `queue_priority`, `queue_ttr`, `bk`, and `extend!`.
+
+```ruby
+class ProcessPayment < ApplicationJob
+  include Postburner::Tracked  # ← Opt-in to PostgreSQL tracking (includes Beanstalkd)
+
+  queue_as :critical
+  queue_priority 0              # Highest priority (Beanstalkd included automatically)
+  queue_ttr 600                 # 10 minute timeout
+  retry_on StandardError, wait: :exponentially_longer, attempts: 5
+
+  def perform(payment_id)
+    payment = Payment.find(payment_id)
+
+    log "Starting payment processing for $#{payment.amount}"
+
+    begin
+      payment.charge!
+      log! "Payment charged successfully"
+    rescue PaymentError => e
+      log_exception!(e)
+      raise
+    end
+
+    log "Payment complete", level: :info
+  end
+end
 ```
-# config/application.rb
-config.active_job.queue_adapter = :backburner
+
+**Tracking provides:**
+- Complete execution history (queued_at, processing_at, processed_at)
+- Custom logs with `log` and `log!`
+- Exception tracking with `log_exception()` and `log_exception!()`
+- Timing statistics (lag, duration)
+- Retry attempts tracking
+- Query with ActiveRecord
+- Foreign key relationships
+- Beanstalkd operations via `bk` accessor
+- TTR extension via `extend!` method
+
+**Query tracked jobs:**
+
+```ruby
+# Find by state
+Postburner::TrackedJob.where(processed_at: nil)
+Postburner::TrackedJob.where.not(removed_at: nil)
+
+# Find with errors
+Postburner::TrackedJob.where("error_count > 0")
+
+# Statistics
+Postburner::TrackedJob.average(:duration)  # Average execution time
+Postburner::TrackedJob.maximum(:lag)       # Worst lag
+
+# Inspect execution
+job = Postburner::TrackedJob.last
+job.logs      # Array of log entries with timestamps
+job.errata    # Array of exceptions with backtraces
+job.attempts  # Array of attempt timestamps
+job.duration  # Execution time in milliseconds
+job.lag       # Queue lag in milliseconds
 ```
 
-Postburner may later provide an adapter, but we recommend using `Postburner::Job` classes
-directly.
+### Direct Postburner::Job Usage
 
-Add jobs to `app/jobs/`. There currently is no generator.
+Direct `Postburner::Job` subclasses are **always tracked**:
 
 ```ruby
-# app/jobs/run_donation.rb
 class RunDonation < Postburner::Job
   queue 'critical'
-  queue_priority 0 # 0 is highest priority
-  queue_max_job_retries 0 # don't retry
+  queue_priority 0
+  queue_max_job_retries 0
 
-  def process(args)
-    # do long tasks here
-    # also have access to self.args
+  def perform(args)
+    donation = Donation.find(args['donation_id'])
+    donation.process!
+    log "Processed donation #{donation.id}"
   end
 end
+
+# Create and enqueue
+job = RunDonation.create!(args: { 'donation_id' => 123 })
+job.queue!
+
+# With delay
+job.queue!(delay: 1.hour)
+
+# At specific time
+job.queue!(at: 2.days.from_now)
 ```
 
-### Comparison to Backburner
+#### Instance-Level Queue Configuration
 
-Compared to plain [Backburner](https://github.com/nesquena/backburner),
-Postburner adds:
-- Database Jobs for inspection, linking, auditing, removal (and deletion)
-- Direct access to associated [Beanstalk](https://beanstalkd.github.io/) (via [beaneater](https://github.com/beanstalkd/beaneater))
-- Job Statistics (lag, attempts, logs, tracked errors)
-- Convenience methods to clear tubes, stats, and connections for Beanstalk.
+Override queue priority and TTR per job instance for dynamic behavior:
 
-Otherwise, Postburner tries to be a super simple layer on `Backburner::Queue`
-and `ActiveRecord`. Every tool with either of those are available in
-`Postburner::Job`s.
+```ruby
+# Set priority during creation
+job = RunDonation.create!(
+  args: { 'donation_id' => 123 },
+  queue_priority: 1500,  # Override class-level priority
+  queue_ttr: 300         # Override class-level TTR
+)
+job.queue!
 
-Comes with a mountable interface that can be password protected with whatever
-authentication you use in your project.
+# Set dynamically after creation
+job = RunDonation.create!(args: { 'donation_id' => 456 })
+job.queue_priority = 2000
+job.queue_ttr = 300
+job.queue!
 
-### Comparison to Que
+# Use in before_enqueue callback for conditional behavior
+class ProcessOrder < Postburner::Job
+  queue 'orders'
+  queue_priority 100   # Default priority
+  queue_ttr 120  # Default TTR
 
-Postburner meant to be a replacement/upgrade for [Que](https://github.com/que-rb/que).
-However, if you need something faster and backed with ACID compliance, check out Que.  
+  before_enqueue :set_priority_based_on_urgency
 
-Postburner has some additional features such as retained jobs after processing,
-stats, per job logging, etc.
+  def perform(args)
+    order = Order.find(args['order_id'])
+    order.process!
+  end
 
-Postburner is meant to be simpler than `Que`. Que is incredible, but jobs should
-be simple so the logic and history can be transparent.
+  private
 
-## Contributing
-Submit a pull request. Follow conventions of the project. Be nice.
+  def set_priority_based_on_urgency
+    if args['express_shipping']
+      self.queue_priority = 0    # High priority for express orders
+      self.queue_ttr = 600       # Allow 10 minutes to complete
+    else
+      self.queue_priority = 1000 # Low priority for standard orders
+      self.queue_ttr = 120       # Standard 2 minute timeout
+    end
+  end
+end
 
-### V1 TODO
-- Basic tests
-- Add Authentication modules for engine mount.
+# Express order gets high priority automatically
+ProcessOrder.create!(args: { 'order_id' => 789, 'express_shipping' => true }).queue!
+```
+
+**Overview:**
+- Same as Tracked jobs
+- Access the ActiveRecord Postburner::Job directly.
+
+## Workers
+
+Postburner uses named worker configurations to support different deployment patterns. Each worker can have different fork/thread settings and process different queues, enabling flexible production deployments.
+
+### Named Workers Configuration
+
+Configure multiple named workers with different concurrency profiles:
+
+```yaml
+production:
+  beanstalk_url: <%= ENV['BEANSTALK_URL'] %>
+
+  workers:
+    # Heavy, memory-intensive jobs - more processes, fewer threads
+    imports:
+      default_forks: 4
+      default_threads: 1
+      default_gc_limit: 500
+      queues:
+        - imports
+        - data_processing
+
+    # General jobs - fewer processes, many threads
+    general:
+      default_forks: 2
+      default_threads: 100
+      default_gc_limit: 5000
+      queues:
+        - default
+        - mailers
+        - notifications
+```
+
+### Puma-Style Architecture
+
+The worker supports two modes based on fork configuration:
+- **`forks: 0`** - Single process with thread pools (development/staging)
+- **`forks: 1+`** - Multiple processes with thread pools (production, Puma-style)
+
+This gives you a natural progression from simple single-threaded development to high-concurrency production.
+
+### Configuration Examples
+
+**Development (single worker, single-threaded):**
+```yaml
+development:
+  beanstalk_url: beanstalk://localhost:11300
+
+  workers:
+    default:
+      # Defaults: forks=0, threads=1, gc_limit=nil
+      queues:
+        - default
+        - mailers
+```
+
+**Staging (single worker, multi-threaded):**
+```yaml
+staging:
+  beanstalk_url: beanstalk://localhost:11300
+
+  workers:
+    default:
+      default_threads: 10
+      default_gc_limit: 5000
+      queues:
+        - critical
+        - default
+        - mailers
+```
+
+**Production (multiple workers with different profiles):**
+```yaml
+production:
+  beanstalk_url: <%= ENV['BEANSTALK_URL'] %>
+
+  workers:
+    imports:
+      default_forks: 4      # 4 processes
+      default_threads: 1    # 1 thread per process = 4 concurrent jobs
+      default_gc_limit: 500
+      queues:
+        - imports
+        - data_processing
+
+    general:
+      default_forks: 2      # 2 processes
+      default_threads: 100  # 100 threads per process = 200 concurrent jobs
+      default_gc_limit: 5000
+      queues:
+        - default
+        - mailers
+        - notifications
+```
+
+### Running Workers
+
+**Single worker (auto-selected):**
+```bash
+bin/postburner
+```
+If only one worker is defined, it's automatically selected.
+
+**Multiple workers (must specify):**
+```bash
+bin/postburner --worker imports    # Run the 'imports' worker
+bin/postburner --worker general    # Run the 'general' worker
+```
+
+**Filter queues (override config):**
+```bash
+bin/postburner --worker general --queues default,mailers  # Only process specific queues
+```
 
-### V1+ TODO
-- Install generator
-  - Sub to backburner
-- Job generator
-  - Build file in app/jobs
-  - Inherit from Postburner::Job
-- Add before/after/around hooks
-- Add destroy, and remove actions on show page
-- Clear tubes.
-- Document how/when to use activerecord hooks
-- Document how/when to use backburner hooks
-- Document how/when to use postburner hooks
-- Add logging with Job.args in backburner logs
-- MAYBE - ActiveJob adapter
+### Running Workers in Separate Processes
+
+For production deployments, run different workers in separate OS processes for isolation and resource allocation:
+
+**Docker Compose example:**
+```yaml
+services:
+  # Process 1: Imports worker (forks=4, threads=1)
+  worker-imports:
+    build: .
+    command: bin/postburner --worker imports
+    environment:
+      RAILS_ENV: production
+      BEANSTALK_URL: beanstalk://beanstalkd:11300
+    depends_on:
+      - beanstalkd
+      - postgres
+
+  # Process 2: General worker (forks=2, threads=100)
+  worker-general:
+    build: .
+    command: bin/postburner --worker general
+    environment:
+      RAILS_ENV: production
+      BEANSTALK_URL: beanstalk://beanstalkd:11300
+    depends_on:
+      - beanstalkd
+      - postgres
+```
+
+**Procfile example (Heroku/Foreman):**
+```
+worker_imports: bin/postburner --worker imports
+worker_general: bin/postburner --worker general
+```
+
+### Worker Architecture
+
+**Single Process Mode (forks: 0):**
+```
+Main Process
+├─ Queue 'critical' Thread Pool (1 thread)
+├─ Queue 'default' Thread Pool (10 threads)
+└─ Queue 'mailers' Thread Pool (5 threads)
+```
 
+**Multi-Process Mode (forks: 1+):**
+```
+Parent Process
+├─ Fork 0 (queue: critical)
+│   └─ Thread 1
+├─ Fork 0 (queue: default)
+│   ├─ Thread 1-10
+├─ Fork 1 (queue: default)  # Puma-style: multiple forks of same queue
+│   ├─ Thread 1-10
+├─ Fork 2 (queue: default)
+│   └─ Thread 1-10
+├─ Fork 3 (queue: default)
+│   └─ Thread 1-10
+│   └─ Total: 40 concurrent jobs for 'default' (4 forks × 10 threads)
+└─ Fork 0 (queue: mailers)
+    └─ Thread 1-5
+```
 
-### Running in Development
+### Benefits
+
+**Single Process Mode (forks: 0):**
+- Simplest deployment
+- Easy debugging
+- Lower memory footprint
+- Best for development and moderate load
+
+**Multi-Process Mode (forks: 1+):**
+- Horizontal scaling per queue
+- Process isolation
+- Automatic memory cleanup via GC limits
+- Crash isolation (one fork down doesn't affect others)
+- Best for production high-volume workloads
+
+### GC Limits
+
+Set `default_gc_limit` per worker to automatically restart after processing N jobs.
+
+- Worker processes N jobs
+- Worker exits with code 99
+- In single-process mode (forks: 0): process manager restarts the entire process
+- In multi-process mode (forks: 1+): parent process automatically restarts just that fork
+
+```yaml
+production:
+  workers:
+    imports:
+      default_forks: 4
+      default_threads: 1
+      default_gc_limit: 500  # Restart after 500 jobs (memory-intensive)
+      queues:
+        - imports
+        - data_processing
+
+    general:
+      default_forks: 2
+      default_threads: 100
+      default_gc_limit: 5000  # Restart after 5000 jobs
+      queues:
+        - default
+        - mailers
+```
 
+**Why?**
+- Prevents memory bloat in long-running workers
+- Automatic cleanup without manual intervention
+- Works seamlessly with Docker and Kubernetes restarts
+
+## Configuration
+
+### YAML Configuration
+
+```yaml
+# config/postburner.yml
+default: &default
+  beanstalk_url: <%= ENV['BEANSTALK_URL'] || 'beanstalk://localhost:11300' %>
+
+development:
+  <<: *default
+  # Defaults: forks: 0, threads: 1, gc_limit: nil
+  queues:
+    default: {}
+    mailers: {}
+
+test:
+  <<: *default
+  # Defaults: forks: 0, threads: 1, gc_limit: nil
+  queues:
+    default: {}
+
+staging:
+  <<: *default
+  default_threads: 10      # Multi-threaded, single process
+  default_gc_limit: 5000
+  queues:
+    default: {}
+    mailers: {}
+
+production:
+  <<: *default
+  default_forks: 4         # Puma-style: multiple processes
+  default_threads: 10      # 10 threads per fork
+  default_gc_limit: 5000
+
+  queues:
+    critical:
+      forks: 1
+      threads: 1           # 1 concurrent job
+      gc_limit: 100
+
+    default:
+      forks: 4
+      threads: 10          # 40 total concurrent jobs (4 × 10)
+      gc_limit: 1000
+
+    mailers:
+      forks: 2
+      threads: 5           # 10 total email senders (2 × 5)
+      gc_limit: 500
 ```
-cd test/dummy
-bundle exec backburner
+
+### Queue Configuration Methods
+
+For `Postburner::Job` subclasses (and backwards compatibility):
+
+```ruby
+class CriticalJob < Postburner::Job
+  queue 'critical'                  # Beanstalkd tube name
+  queue_priority 0                  # Lower = higher priority (0 is highest)
+  queue_ttr 300                     # TTR (time-to-run) in seconds
+  queue_max_job_retries 3           # Max retry attempts
+  queue_retry_delay 5               # Fixed delay: 5 seconds between retries
+
+  def perform(args)
+    # ...
+  end
+end
 ```
 
-### Releasing
+**Exponential backoff with proc:**
 
-1. `gem bump -v minor -t`
-  Where <minor> can be: major|minor|patch|pre|release or a version number
-2. Edit `CHANGELOG.md` with details from `git log --oneline`
-3. `git commit --amend`
-4. `gem release -k nac -p`
-  Where <nac> is an authorized key with push capabilities.
+```ruby
+class BackgroundTask < Postburner::Job
+  queue 'default'
+  queue_max_job_retries 5
+  queue_retry_delay ->(retries) { 2 ** retries }  # 2s, 4s, 8s, 16s, 32s
 
+  def perform(args)
+    # ...
+  end
+end
+```
+
+### ActiveJob Configuration
+
+For ActiveJob classes, use standard ActiveJob configuration:
+
+```ruby
+class MyJob < ApplicationJob
+  include Postburner::Tracked  # Optional: for audit trail
+
+  queue_as :default
+
+  retry_on StandardError, wait: :exponentially_longer, attempts: 5
+  retry_on CustomError, wait: 10.seconds
+
+  discard_on ActiveJob::DeserializationError
+
+  def perform(user_id)
+    # ...
+  end
+end
+```
+
+## Callbacks
+
+Postburner provides lifecycle callbacks:
+
+```ruby
+class ProcessPayment < ApplicationJob
+  include Postburner::Tracked
+
+  before_enqueue :validate_payment
+  after_enqueue :send_confirmation
+
+  before_attempt :log_attempt       # Runs on every retry
+  after_attempt :update_metrics
+
+  before_processing :acquire_lock
+  after_processing :release_lock
+
+  after_processed :send_receipt     # Only on success
+
+  def perform(payment_id)
+    # ...
+  end
+
+  private
+
+  def validate_payment
+    raise "Invalid" unless payment_valid?
+  end
+
+  def send_receipt
+    PaymentMailer.receipt(arguments.first).deliver_later
+  end
+end
+```
+
+**Available callbacks:**
+- `before_enqueue`, `around_enqueue`, `after_enqueue` - When queued
+- `before_attempt`, `around_attempt`, `after_attempt` - Every execution (including retries)
+- `before_processing`, `around_processing`, `after_processing` - During execution
+- `after_processed` - Only after successful completion
+
+## Queue Strategies
+
+Postburner uses different strategies to control job execution. These affect `Postburner::Job` subclasses (not ActiveJob classes).
+
+| Strategy | When to Use | Behavior | Requires Beanstalkd |
+|----------|-------------|----------|---------------------|
+| **NiceQueue** (default) | Production | Async via Beanstalkd, gracefully re-queues premature jobs | Yes |
+| **Queue** | Production (strict) | Async via Beanstalkd, raises error on premature execution | Yes |
+| **TestQueue** | Testing with explicit time control | Inline execution, raises error for scheduled jobs | No |
+| **ImmediateTestQueue** | Testing with automatic time travel | Inline execution, auto time-travels for scheduled jobs | No |
+| **NullQueue** | Batch processing / deferred execution | Jobs created but not queued, manual execution | No |
+
+```ruby
+# Switch strategies
+Postburner.nice_async_strategy!           # Default production (NiceQueue)
+Postburner.async_strategy!                # Strict production (Queue)
+Postburner.inline_test_strategy!          # Testing (TestQueue)
+Postburner.inline_immediate_test_strategy! # Testing with time travel
+Postburner.null_strategy!                 # Deferred execution
+```
+
+**Note:** These strategies only affect `Postburner::Job` subclasses. ActiveJob classes execute according to the ActiveJob adapter configuration.
+
+## Testing
+
+Postburner provides test-friendly execution modes that don't require Beanstalkd.
+
+### Automatic Test Mode
+
+In Rails test environments, Postburner automatically uses inline execution:
+
+```ruby
+# test/test_helper.rb - automatic!
+Postburner.testing?  # => true in tests
+```
+
+### Testing Default Jobs (ActiveJob)
+
+Use standard ActiveJob test helpers:
+
+```ruby
+class MyTest < ActiveSupport::TestCase
+  test "job executes" do
+    SendEmail.perform_later(123)
+    # Job executes immediately in test mode
+  end
+
+  test "job with delay" do
+    travel 1.hour do
+      SendEmail.set(wait: 1.hour).perform_later(123)
+    end
+  end
+end
+```
+
+### Testing Tracked Jobs
+
+Tracked jobs create database records you can inspect:
+
+```ruby
+test "tracked job logs execution" do
+  ProcessPayment.perform_later(456)
+
+  job = Postburner::TrackedJob.last
+  assert job.processed_at.present?
+  assert_includes job.logs.map { |l| l[1]['message'] }, "Processing payment 456"
+end
+```
+
+### Testing Legacy Postburner::Job
+
+```ruby
+test "processes immediately" do
+  job = RunDonation.create!(args: { 'donation_id' => 123 })
+  job.queue!
+
+  assert job.reload.processed_at
+end
+
+test "scheduled job with time travel" do
+  job = RunDonation.create!(args: { 'donation_id' => 123 })
+
+  travel_to(2.hours.from_now) do
+    job.queue!(delay: 2.hours)
+    assert job.reload.processed_at
+  end
+end
+```
+
+## Job Management
+
+### Canceling Jobs
+
+**For Postburner::Job subclasses:**
+
+```ruby
+job = RunDonation.create!(args: { 'donation_id' => 123 })
+job.queue!(delay: 1.hour)
+
+# Soft delete (recommended) - removes from queue, sets removed_at
+job.remove!
+job.removed_at  # => 2025-11-19 12:34:56 UTC
+job.persisted?  # => true (still in database for audit)
+
+# Hard delete - removes from both queue and database
+job.destroy!
+
+# Delete from Beanstalkd only (keeps database record)
+job.delete!
+```
+
+**For tracked ActiveJob classes:**
+
+```ruby
+# Find the TrackedJob record
+job = Postburner::TrackedJob.find(123)
+job.remove!  # Cancel execution
+```
+
+### Retrying Buried Jobs
+
+Jobs that fail repeatedly get "buried" in Beanstalkd:
+
+```ruby
+job = Postburner::Job.find(123)
+job.kick!  # Moves buried job back to ready queue
+```
+
+### Inspecting Job State
+
+```ruby
+job = Postburner::TrackedJob.find(123)
+
+# Timestamps
+job.queued_at      # When queued to Beanstalkd
+job.run_at         # Scheduled execution time
+job.attempting_at  # First attempt started
+job.processing_at  # Current/last processing started
+job.processed_at   # Completed successfully
+job.removed_at     # Soft deleted
+
+# Statistics
+job.lag       # Milliseconds between scheduled and actual execution
+job.duration  # Milliseconds to execute
+job.attempt_count  # Number of attempts
+job.error_count    # Number of errors
+
+# Audit trail
+job.logs    # Array of log entries with timestamps
+job.errata  # Array of exceptions with backtraces
+job.attempts # Array of attempt timestamps
+```
+
+## Beanstalkd Integration
+
+Direct access to Beanstalkd for advanced operations:
+
+```ruby
+# Get Beanstalkd job ID
+job.bkid  # => 12345
+
+# Access Beaneater job object
+job.beanstalk_job.stats
+# => {"id"=>12345, "tube"=>"critical", "state"=>"ready", ...}
+
+# Connection management
+Postburner.connected do |conn|
+  conn.tubes.to_a  # List all tubes
+  conn.tubes['postburner.production.critical'].stats
+  conn.tubes['postburner.production.critical'].kick(10)  # Kick 10 buried jobs
+end
+```
+
+
+## Web UI
+
+Mount the inspection interface:
+
+```ruby
+# config/routes.rb
+mount Postburner::Engine => "/postburner"
+
+# Only in development
+mount Postburner::Engine => "/postburner" if Rails.env.development?
+```
+
+Add your own authentication:
+
+```ruby
+# config/routes.rb
+authenticate :user, ->(user) { user.admin? } do
+  mount Postburner::Engine => "/postburner"
+end
+```
+
+## Deployment
+
+### Docker
+
+```dockerfile
+# Dockerfile.worker
+FROM ruby:3.3
+
+WORKDIR /app
+COPY . .
+RUN bundle install
+
+CMD ["bundle", "exec", "postburner", "--config", "config/postburner.yml", "--env", "production"]
+```
+
+```yaml
+# docker-compose.yml
+services:
+  beanstalkd:
+    image: schickling/beanstalkd
+    command: ["-l", "0.0.0.0", "-p", "11300", "-b", "/var/lib/beanstalkd"]
+    ports:
+      - "11300:11300"
+    volumes:
+      - beanstalkd_data:/var/lib/beanstalkd
+
+  worker:
+    build:
+      context: .
+      dockerfile: Dockerfile.worker
+    depends_on:
+      - beanstalkd
+      - postgres
+    environment:
+      BEANSTALK_URL: beanstalk://beanstalkd:11300
+      DATABASE_URL: postgres://postgres@postgres/myapp_production
+
+volumes:
+  beanstalkd_data:
+```
+
+## Migration from v0.x
+
+Key changes in v1.0:
+
+### Removed
+- Backburner dependency
+- `config/initializers/backburner.rb`
+- Backburner worker (`bundle exec backburner`)
+
+### Added
+- ActiveJob adapter (first-class Rails integration)
+- Default jobs (Beanstalkd only, no PostgreSQL)
+- `bin/postburner` executable
+- `config/postburner.yml` configuration
+- Multiple worker types (Simple, Forking, ThreadsOnFork)
+
+### Migration Steps
+
+1. **Update Gemfile:**
+   ```ruby
+   gem 'postburner', '~> 1.0.0.pre.1'
+   ```
+
+2. **Remove Backburner config:**
+   ```bash
+   rm config/initializers/backburner.rb
+   ```
+
+3. **Create Postburner config:**
+   ```bash
+   cp config/postburner.yml.example config/postburner.yml
+   ```
+
+4. **Update ActiveJob adapter:**
+   ```ruby
+   # config/application.rb
+   config.active_job.queue_adapter = :postburner  # was :backburner
+   ```
+
+5. **Update worker command:**
+   ```bash
+   # Old
+   bundle exec backburner
+
+   # New
+   bundle exec postburner --config config/postburner.yml
+   ```
+
+6. **Existing Jobs:** Direct `Postburner::Job` subclasses continue to work without changes!
+
+## Contributing
+
+Submit a pull request. Follow project conventions. Be nice.
 
 ## License
+
 The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).