From dd945fd616f4ac61b64a4296d47ab31a3f69973f Mon Sep 17 00:00:00 2001
From: Alex Moinet <Alex.moinet@yahoo.co.uk>
Date: Wed, 11 Jul 2018 17:36:23 +0100
Subject: [PATCH 01/19] fix: Use sidekiq v3-style error handling (#434)

Ensures that an error handler is correctly assigned in
newer versions of sidekiq.
---
 features/sidekiq.feature            |  4 +-
 lib/bugsnag/integrations/sidekiq.rb | 53 +++++++++++++++--------
 spec/integrations/sidekiq_spec.rb   | 67 ++++++++++++++++++++++-------
 3 files changed, 88 insertions(+), 36 deletions(-)

diff --git a/features/sidekiq.feature b/features/sidekiq.feature
index 5bc603670..0231da576 100644
--- a/features/sidekiq.feature
+++ b/features/sidekiq.feature
@@ -18,6 +18,7 @@ Scenario Outline: An unhandled RuntimeError sends a report
   And the request contained the api key "a35a2a72bd230ac0aa0f52715bbdc6aa"
   And the event "unhandled" is true
   And the event "severity" is "error"
+  And the event "context" is "UnhandledError@default"
   And the event "severityReason.type" is "unhandledExceptionMiddleware"
   And the event "severityReason.attributes.framework" is "Sidekiq"
   And the exception "errorClass" equals "RuntimeError"
@@ -62,6 +63,7 @@ Scenario Outline: A handled RuntimeError can be notified
   And the request used payload v4 headers
   And the request contained the api key "a35a2a72bd230ac0aa0f52715bbdc6aa"
   And the event "unhandled" is false
+  And the event "context" is "HandledError@default"
   And the event "severity" is "warning"
   And the event "severityReason.type" is "handledException"
   And the exception "errorClass" equals "RuntimeError"
@@ -93,4 +95,4 @@ Scenario Outline: A handled RuntimeError can be notified
   | 2.5          | ~> 2            | false              |
   | 2.5          | ~> 3            | true               |
   | 2.5          | ~> 4            | true               |
-  | 2.5          | ~> 5            | true               |
\ No newline at end of file
+  | 2.5          | ~> 5            | true               |
diff --git a/lib/bugsnag/integrations/sidekiq.rb b/lib/bugsnag/integrations/sidekiq.rb
index 4f30a4f16..5566c8ee3 100644
--- a/lib/bugsnag/integrations/sidekiq.rb
+++ b/lib/bugsnag/integrations/sidekiq.rb
@@ -5,9 +5,11 @@ module Bugsnag
   # Extracts and attaches Sidekiq job and queue information to an error report
   class Sidekiq
 
-    FRAMEWORK_ATTRIBUTES = {
-      :framework => "Sidekiq"
-    }
+    unless const_defined?(:FRAMEWORK_ATTRIBUTES)
+      FRAMEWORK_ATTRIBUTES = {
+        :framework => "Sidekiq"
+      }
+    end
 
     def initialize
       Bugsnag.configuration.internal_middleware.use(Bugsnag::Middleware::Sidekiq)
@@ -19,31 +21,44 @@ def call(worker, msg, queue)
       begin
         # store msg/queue in thread local state to be read by Bugsnag::Middleware::Sidekiq
         Bugsnag.configuration.set_request_data :sidekiq, { :msg => msg, :queue => queue }
-
         yield
       rescue Exception => ex
-        raise ex if [Interrupt, SystemExit, SignalException].include? ex.class
-        Bugsnag.notify(ex, true) do |report|
-          report.severity = "error"
-          report.severity_reason = {
-            :type => Bugsnag::Report::UNHANDLED_EXCEPTION_MIDDLEWARE,
-            :attributes => FRAMEWORK_ATTRIBUTES
-          }
-        end
+        self.class.notify(ex) unless self.class.sidekiq_supports_error_handlers
         raise
       ensure
         Bugsnag.configuration.clear_request_data
       end
     end
+
+    def self.notify(exception)
+      return if [Interrupt, SystemExit, SignalException].include? exception.class
+      Bugsnag.notify(exception, true) do |report|
+        report.severity = "error"
+        report.severity_reason = {
+          :type => Bugsnag::Report::UNHANDLED_EXCEPTION_MIDDLEWARE,
+          :attributes => FRAMEWORK_ATTRIBUTES
+        }
+      end
+    end
+
+    def self.sidekiq_supports_error_handlers
+      Gem::Version.new(::Sidekiq::VERSION) >= Gem::Version.new('3.0.0')
+    end
+
+    def self.configure_server(server)
+      if Bugsnag::Sidekiq.sidekiq_supports_error_handlers
+        server.error_handlers << proc do |ex, _context|
+          Bugsnag::Sidekiq.notify(ex)
+        end
+      end
+
+      server.server_middleware do |chain|
+        chain.add ::Bugsnag::Sidekiq
+      end
+    end
   end
 end
 
 ::Sidekiq.configure_server do |config|
-  config.server_middleware do |chain|
-    if Gem::Version.new(Sidekiq::VERSION) >= Gem::Version.new('3.3.0')
-      chain.prepend ::Bugsnag::Sidekiq
-    else
-      chain.add ::Bugsnag::Sidekiq
-    end
-  end
+  Bugsnag::Sidekiq.configure_server(config)
 end
diff --git a/spec/integrations/sidekiq_spec.rb b/spec/integrations/sidekiq_spec.rb
index 3939d44bd..b83352883 100644
--- a/spec/integrations/sidekiq_spec.rb
+++ b/spec/integrations/sidekiq_spec.rb
@@ -9,26 +9,61 @@ def perform(value)
 end
 
 describe Bugsnag::Sidekiq do
-  before do
-    Sidekiq::Testing.inline!
-    Sidekiq::Testing.server_middleware do |chain|
-      chain.add Bugsnag::Sidekiq
+  # Integration testing v3 is handled by maze as sidekiq doesnt
+  # support error_handlers in testing mode
+  context "integration tests in v2" do
+    before do
+      Sidekiq::Testing.inline!
+      stub_const('Sidekiq::VERSION', '2.0.0')
+      Sidekiq::Testing.server_middleware do |chain|
+        chain.add ::Bugsnag::Sidekiq
+      end
+    end
+
+    it "works" do
+      begin
+        FailingWorker.perform_async(-0)
+        fail("shouldn't be here")
+      rescue
+      end
+
+      expect(Bugsnag).to have_sent_notification {|payload, headers|
+        event = get_event_from_payload(payload)
+        expect(event["metaData"]["sidekiq"]["msg"]["class"]).to eq("FailingWorker")
+        expect(event["metaData"]["sidekiq"]["msg"]["args"]).to eq([-0])
+        expect(event["metaData"]["sidekiq"]["msg"]["queue"]).to eq("default")
+        expect(event["severity"]).to eq("error")
+      }
     end
   end
 
-  it "works" do
-    begin
-      FailingWorker.perform_async(-0)
-      fail("shouldn't be here")
-    rescue
+  context "initializing the integrations" do
+    it "works in v2" do
+      config = double
+      expect(::Sidekiq).to receive(:configure_server).and_yield(config)
+      stub_const('Sidekiq::VERSION', '2.0.0')
+
+      chain = double
+      expect(config).to receive(:server_middleware).and_yield(chain)
+      expect(chain).to receive(:add).with(::Bugsnag::Sidekiq)
+
+      load './lib/bugsnag/integrations/sidekiq.rb'
     end
 
-    expect(Bugsnag).to have_sent_notification {|payload, headers|
-      event = get_event_from_payload(payload)
-      expect(event["metaData"]["sidekiq"]["msg"]["class"]).to eq("FailingWorker")
-      expect(event["metaData"]["sidekiq"]["msg"]["args"]).to eq([-0])
-      expect(event["metaData"]["sidekiq"]["msg"]["queue"]).to eq("default")
-      expect(event["severity"]).to eq("error")
-    }
+    it "works in v3" do
+      config = double
+      expect(::Sidekiq).to receive(:configure_server).and_yield(config)
+      stub_const('Sidekiq::VERSION', '3.0.0')
+
+      error_handlers = []
+      expect(config).to receive(:error_handlers).and_return(error_handlers)
+
+      chain = double
+      expect(config).to receive(:server_middleware).and_yield(chain)
+      expect(chain).to receive(:add).with(::Bugsnag::Sidekiq)
+
+      load './lib/bugsnag/integrations/sidekiq.rb'
+      expect(error_handlers.size).to eq(1)
+    end
   end
 end

From ddcdc1ce1e838b0a5ff135ed7707e0af580f58fc Mon Sep 17 00:00:00 2001
From: Manoj M J <manojmj92@gmail.com>
Date: Fri, 17 Aug 2018 12:08:59 +0530
Subject: [PATCH 02/19] Set the args data correctly DelayedJob plugin when the
 payload object is a custom class

---
 lib/bugsnag/integrations/delayed_job.rb |  2 ++
 spec/integrations/delayed_job_spec.rb   | 47 +++++++++++++++++++++++++
 2 files changed, 49 insertions(+)

diff --git a/lib/bugsnag/integrations/delayed_job.rb b/lib/bugsnag/integrations/delayed_job.rb
index e840f4df1..dcb4c269c 100644
--- a/lib/bugsnag/integrations/delayed_job.rb
+++ b/lib/bugsnag/integrations/delayed_job.rb
@@ -46,6 +46,8 @@ def error(job, error)
                 p[:args] = payload.args
               elsif payload.respond_to?(:to_h)
                 p[:args] = payload.to_h
+              elsif payload.respond_to?(:instance_values)
+                p[:args] = payload.instance_values
               end
 
               if payload.is_a?(::Delayed::PerformableMethod) && (object = payload.object)
diff --git a/spec/integrations/delayed_job_spec.rb b/spec/integrations/delayed_job_spec.rb
index 7c9b6435d..57bcf0772 100644
--- a/spec/integrations/delayed_job_spec.rb
+++ b/spec/integrations/delayed_job_spec.rb
@@ -4,6 +4,53 @@
 
 RSpec.describe ::Delayed::Plugins::Bugsnag do
   describe '#error' do
+    it 'should set the args data correctly when the payload_object is a custom class' do
+      class MyKlass
+        def initialize(my_argument)
+          @my_argument = my_argument
+        end
+
+        def perform
+        end
+      end
+
+      payload = Object.new
+      payload.extend(described_class::Notify)
+      job = double
+      allow(job).to receive_messages(
+        :id => "TEST",
+        :queue => "TEST_QUEUE",
+        :attempts => 0,
+        :max_attempts => 3,
+        :payload_object => MyKlass.new(123)
+      )
+
+      expect do
+        payload.error(job, '')
+      end.not_to raise_error
+
+      expect(Bugsnag).to have_sent_notification{ |payload, headers|
+        event = get_event_from_payload(payload)
+        expect(event["severity"]).to eq("error")
+        expect(event["severityReason"]).to eq({
+          "type" => "unhandledExceptionMiddleware",
+          "attributes" => {
+            "framework" => "DelayedJob"
+          }
+        })
+        expect(event["metaData"]["job"]).to eq({
+          "class" => job.class.name,
+          "id" => "TEST",
+          "queue" => "TEST_QUEUE",
+          "attempts" => "1 / 3",
+          "payload" => {
+            "class" => MyKlass.class.name,
+            "args" => { 'my_argument' => 123 }
+          }
+        })
+      }
+    end
+
     it 'should set metadata correctly with max_attempts' do
       payload = Object.new
       payload.extend(described_class::Notify)

From 435f87c28a56aff19561f7548692cdef79e7897e Mon Sep 17 00:00:00 2001
From: Manoj M J <manojmj92@gmail.com>
Date: Fri, 17 Aug 2018 13:07:18 +0530
Subject: [PATCH 03/19] test fix

---
 spec/integrations/delayed_job_spec.rb | 19 +++++++------------
 1 file changed, 7 insertions(+), 12 deletions(-)

diff --git a/spec/integrations/delayed_job_spec.rb b/spec/integrations/delayed_job_spec.rb
index 57bcf0772..bcf11fdc9 100644
--- a/spec/integrations/delayed_job_spec.rb
+++ b/spec/integrations/delayed_job_spec.rb
@@ -5,24 +5,19 @@
 RSpec.describe ::Delayed::Plugins::Bugsnag do
   describe '#error' do
     it 'should set the args data correctly when the payload_object is a custom class' do
-      class MyKlass
-        def initialize(my_argument)
-          @my_argument = my_argument
-        end
-
-        def perform
-        end
-      end
-
       payload = Object.new
       payload.extend(described_class::Notify)
       job = double
+      custom_class = double
+      allow(custom_class).to receive_messages(
+        :instance_values => { 'argument': 'value' }
+      )
       allow(job).to receive_messages(
         :id => "TEST",
         :queue => "TEST_QUEUE",
         :attempts => 0,
         :max_attempts => 3,
-        :payload_object => MyKlass.new(123)
+        :payload_object => custom_class
       )
 
       expect do
@@ -44,8 +39,8 @@ def perform
           "queue" => "TEST_QUEUE",
           "attempts" => "1 / 3",
           "payload" => {
-            "class" => MyKlass.class.name,
-            "args" => { 'my_argument' => 123 }
+            "class" => custom_class.class.name,
+            "args" => { 'argument': 'value' }
           }
         })
       }

From 92fc1d47bf969553916ef669905048f6621ccbc7 Mon Sep 17 00:00:00 2001
From: Manoj M J <manojmj92@gmail.com>
Date: Fri, 17 Aug 2018 13:41:18 +0530
Subject: [PATCH 04/19] fix

---
 spec/integrations/delayed_job_spec.rb | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/spec/integrations/delayed_job_spec.rb b/spec/integrations/delayed_job_spec.rb
index bcf11fdc9..c834b4510 100644
--- a/spec/integrations/delayed_job_spec.rb
+++ b/spec/integrations/delayed_job_spec.rb
@@ -40,7 +40,7 @@
           "attempts" => "1 / 3",
           "payload" => {
             "class" => custom_class.class.name,
-            "args" => { 'argument': 'value' }
+            "args" => { :argument => 'value' }
           }
         })
       }

From 212be1b04df73b7f4b229c4d65efc6a3321c0df5 Mon Sep 17 00:00:00 2001
From: Manoj M J <manojmj92@gmail.com>
Date: Fri, 17 Aug 2018 15:12:58 +0530
Subject: [PATCH 05/19] fix

---
 spec/integrations/delayed_job_spec.rb | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/spec/integrations/delayed_job_spec.rb b/spec/integrations/delayed_job_spec.rb
index c834b4510..c31a15f28 100644
--- a/spec/integrations/delayed_job_spec.rb
+++ b/spec/integrations/delayed_job_spec.rb
@@ -10,7 +10,7 @@
       job = double
       custom_class = double
       allow(custom_class).to receive_messages(
-        :instance_values => { 'argument': 'value' }
+        :instance_values => { 'argument' => 'value' }
       )
       allow(job).to receive_messages(
         :id => "TEST",
@@ -40,7 +40,7 @@
           "attempts" => "1 / 3",
           "payload" => {
             "class" => custom_class.class.name,
-            "args" => { :argument => 'value' }
+            "args" => { 'argument' => 'value' }
           }
         })
       }

From 49d4ef6131717828643930a4080c734e018e8e7e Mon Sep 17 00:00:00 2001
From: Simon Maynard <snmaynard@gmail.com>
Date: Wed, 24 Oct 2018 17:05:30 -0700
Subject: [PATCH 06/19] Start rewriting delayed job integration

---
 features/fixtures/delayed_job/Dockerfile      |  7 +-
 features/fixtures/delayed_job/Gemfile         |  4 -
 features/fixtures/delayed_job/app/.gitignore  | 21 +++++
 features/fixtures/delayed_job/app/Gemfile     | 56 ++++++++++++
 features/fixtures/delayed_job/app/README.md   | 24 ++++++
 features/fixtures/delayed_job/app/Rakefile    |  6 ++
 .../app/app/assets/config/manifest.js         |  3 +
 .../delayed_job/app/app/assets/images/.keep   |  0
 .../app/app/assets/javascripts/application.js | 16 ++++
 .../app/app/assets/javascripts/cable.js       | 13 +++
 .../app/app/assets/javascripts/channels/.keep |  0
 .../app/assets/stylesheets/application.css    | 15 ++++
 .../app/channels/application_cable/channel.rb |  4 +
 .../channels/application_cable/connection.rb  |  4 +
 .../app/controllers/application_controller.rb |  3 +
 .../app/app/controllers/concerns/.keep        |  0
 .../app/app/helpers/application_helper.rb     |  2 +
 .../app/app/jobs/application_job.rb           |  2 +
 .../app/app/mailers/application_mailer.rb     |  4 +
 .../app/app/models/application_record.rb      |  3 +
 .../delayed_job/app/app/models/concerns/.keep |  0
 .../delayed_job/app/app/models/test_model.rb  | 13 +++
 .../app/views/layouts/application.html.erb    | 14 +++
 .../app/app/views/layouts/mailer.html.erb     | 13 +++
 .../app/app/views/layouts/mailer.text.erb     |  1 +
 features/fixtures/delayed_job/app/config.ru   |  5 ++
 .../delayed_job/app/config/application.rb     | 15 ++++
 .../fixtures/delayed_job/app/config/boot.rb   |  3 +
 .../fixtures/delayed_job/app/config/cable.yml |  9 ++
 .../delayed_job/app/config/database.yml       | 25 ++++++
 .../delayed_job/app/config/environment.rb     |  5 ++
 .../app/config/environments/development.rb    | 54 ++++++++++++
 .../app/config/environments/production.rb     | 86 +++++++++++++++++++
 .../app/config/environments/test.rb           | 42 +++++++++
 .../application_controller_renderer.rb        |  8 ++
 .../app/config/initializers/assets.rb         | 11 +++
 .../initializers/backtrace_silencers.rb       |  7 ++
 .../app/config/initializers/bugsnag.rb        |  3 +
 .../config/initializers/cookies_serializer.rb |  5 ++
 .../initializers/filter_parameter_logging.rb  |  4 +
 .../app/config/initializers/inflections.rb    | 16 ++++
 .../app/config/initializers/mime_types.rb     |  4 +
 .../initializers/new_framework_defaults.rb    | 26 ++++++
 .../app/config/initializers/session_store.rb  |  3 +
 .../config/initializers/wrap_parameters.rb    | 14 +++
 .../delayed_job/app/config/locales/en.yml     | 23 +++++
 .../fixtures/delayed_job/app/config/puma.rb   | 47 ++++++++++
 .../fixtures/delayed_job/app/config/routes.rb |  3 +
 .../delayed_job/app/config/secrets.yml        | 22 +++++
 .../fixtures/delayed_job/app/config/spring.rb |  6 ++
 .../20181024232549_create_delayed_jobs.rb     | 22 +++++
 .../20181024232817_create_test_models.rb      |  8 ++
 .../fixtures/delayed_job/app/db/schema.rb     | 30 +++++++
 features/fixtures/delayed_job/app/db/seeds.rb |  7 ++
 .../fixtures/delayed_job/app/lib/assets/.keep |  0
 .../fixtures/delayed_job/app/lib/tasks/.keep  |  0
 features/fixtures/delayed_job/app/log/.keep   |  0
 .../fixtures/delayed_job/app/public/404.html  | 67 +++++++++++++++
 .../fixtures/delayed_job/app/public/422.html  | 67 +++++++++++++++
 .../fixtures/delayed_job/app/public/500.html  | 66 ++++++++++++++
 .../public/apple-touch-icon-precomposed.png   |  0
 .../app/public/apple-touch-icon.png           |  0
 .../delayed_job/app/public/favicon.ico        |  0
 .../delayed_job/app/public/robots.txt         |  5 ++
 .../delayed_job/app/test/controllers/.keep    |  0
 .../delayed_job/app/test/fixtures/.keep       |  0
 .../delayed_job/app/test/fixtures/files/.keep |  0
 .../app/test/fixtures/test_models.yml         | 11 +++
 .../delayed_job/app/test/helpers/.keep        |  0
 .../delayed_job/app/test/integration/.keep    |  0
 .../delayed_job/app/test/mailers/.keep        |  0
 .../delayed_job/app/test/models/.keep         |  0
 .../app/test/models/test_model_test.rb        |  7 ++
 .../delayed_job/app/test/test_helper.rb       | 10 +++
 features/fixtures/delayed_job/app/tmp/.keep   |  0
 lib/bugsnag/integrations/delayed_job.rb       | 76 ++++++++--------
 76 files changed, 1003 insertions(+), 47 deletions(-)
 delete mode 100644 features/fixtures/delayed_job/Gemfile
 create mode 100644 features/fixtures/delayed_job/app/.gitignore
 create mode 100644 features/fixtures/delayed_job/app/Gemfile
 create mode 100644 features/fixtures/delayed_job/app/README.md
 create mode 100644 features/fixtures/delayed_job/app/Rakefile
 create mode 100644 features/fixtures/delayed_job/app/app/assets/config/manifest.js
 create mode 100644 features/fixtures/delayed_job/app/app/assets/images/.keep
 create mode 100644 features/fixtures/delayed_job/app/app/assets/javascripts/application.js
 create mode 100644 features/fixtures/delayed_job/app/app/assets/javascripts/cable.js
 create mode 100644 features/fixtures/delayed_job/app/app/assets/javascripts/channels/.keep
 create mode 100644 features/fixtures/delayed_job/app/app/assets/stylesheets/application.css
 create mode 100644 features/fixtures/delayed_job/app/app/channels/application_cable/channel.rb
 create mode 100644 features/fixtures/delayed_job/app/app/channels/application_cable/connection.rb
 create mode 100644 features/fixtures/delayed_job/app/app/controllers/application_controller.rb
 create mode 100644 features/fixtures/delayed_job/app/app/controllers/concerns/.keep
 create mode 100644 features/fixtures/delayed_job/app/app/helpers/application_helper.rb
 create mode 100644 features/fixtures/delayed_job/app/app/jobs/application_job.rb
 create mode 100644 features/fixtures/delayed_job/app/app/mailers/application_mailer.rb
 create mode 100644 features/fixtures/delayed_job/app/app/models/application_record.rb
 create mode 100644 features/fixtures/delayed_job/app/app/models/concerns/.keep
 create mode 100644 features/fixtures/delayed_job/app/app/models/test_model.rb
 create mode 100644 features/fixtures/delayed_job/app/app/views/layouts/application.html.erb
 create mode 100644 features/fixtures/delayed_job/app/app/views/layouts/mailer.html.erb
 create mode 100644 features/fixtures/delayed_job/app/app/views/layouts/mailer.text.erb
 create mode 100644 features/fixtures/delayed_job/app/config.ru
 create mode 100644 features/fixtures/delayed_job/app/config/application.rb
 create mode 100644 features/fixtures/delayed_job/app/config/boot.rb
 create mode 100644 features/fixtures/delayed_job/app/config/cable.yml
 create mode 100644 features/fixtures/delayed_job/app/config/database.yml
 create mode 100644 features/fixtures/delayed_job/app/config/environment.rb
 create mode 100644 features/fixtures/delayed_job/app/config/environments/development.rb
 create mode 100644 features/fixtures/delayed_job/app/config/environments/production.rb
 create mode 100644 features/fixtures/delayed_job/app/config/environments/test.rb
 create mode 100644 features/fixtures/delayed_job/app/config/initializers/application_controller_renderer.rb
 create mode 100644 features/fixtures/delayed_job/app/config/initializers/assets.rb
 create mode 100644 features/fixtures/delayed_job/app/config/initializers/backtrace_silencers.rb
 create mode 100644 features/fixtures/delayed_job/app/config/initializers/bugsnag.rb
 create mode 100644 features/fixtures/delayed_job/app/config/initializers/cookies_serializer.rb
 create mode 100644 features/fixtures/delayed_job/app/config/initializers/filter_parameter_logging.rb
 create mode 100644 features/fixtures/delayed_job/app/config/initializers/inflections.rb
 create mode 100644 features/fixtures/delayed_job/app/config/initializers/mime_types.rb
 create mode 100644 features/fixtures/delayed_job/app/config/initializers/new_framework_defaults.rb
 create mode 100644 features/fixtures/delayed_job/app/config/initializers/session_store.rb
 create mode 100644 features/fixtures/delayed_job/app/config/initializers/wrap_parameters.rb
 create mode 100644 features/fixtures/delayed_job/app/config/locales/en.yml
 create mode 100644 features/fixtures/delayed_job/app/config/puma.rb
 create mode 100644 features/fixtures/delayed_job/app/config/routes.rb
 create mode 100644 features/fixtures/delayed_job/app/config/secrets.yml
 create mode 100644 features/fixtures/delayed_job/app/config/spring.rb
 create mode 100644 features/fixtures/delayed_job/app/db/migrate/20181024232549_create_delayed_jobs.rb
 create mode 100644 features/fixtures/delayed_job/app/db/migrate/20181024232817_create_test_models.rb
 create mode 100644 features/fixtures/delayed_job/app/db/schema.rb
 create mode 100644 features/fixtures/delayed_job/app/db/seeds.rb
 create mode 100644 features/fixtures/delayed_job/app/lib/assets/.keep
 create mode 100644 features/fixtures/delayed_job/app/lib/tasks/.keep
 create mode 100644 features/fixtures/delayed_job/app/log/.keep
 create mode 100644 features/fixtures/delayed_job/app/public/404.html
 create mode 100644 features/fixtures/delayed_job/app/public/422.html
 create mode 100644 features/fixtures/delayed_job/app/public/500.html
 create mode 100644 features/fixtures/delayed_job/app/public/apple-touch-icon-precomposed.png
 create mode 100644 features/fixtures/delayed_job/app/public/apple-touch-icon.png
 create mode 100644 features/fixtures/delayed_job/app/public/favicon.ico
 create mode 100644 features/fixtures/delayed_job/app/public/robots.txt
 create mode 100644 features/fixtures/delayed_job/app/test/controllers/.keep
 create mode 100644 features/fixtures/delayed_job/app/test/fixtures/.keep
 create mode 100644 features/fixtures/delayed_job/app/test/fixtures/files/.keep
 create mode 100644 features/fixtures/delayed_job/app/test/fixtures/test_models.yml
 create mode 100644 features/fixtures/delayed_job/app/test/helpers/.keep
 create mode 100644 features/fixtures/delayed_job/app/test/integration/.keep
 create mode 100644 features/fixtures/delayed_job/app/test/mailers/.keep
 create mode 100644 features/fixtures/delayed_job/app/test/models/.keep
 create mode 100644 features/fixtures/delayed_job/app/test/models/test_model_test.rb
 create mode 100644 features/fixtures/delayed_job/app/test/test_helper.rb
 create mode 100644 features/fixtures/delayed_job/app/tmp/.keep

diff --git a/features/fixtures/delayed_job/Dockerfile b/features/fixtures/delayed_job/Dockerfile
index f775c10e0..878a1fb53 100644
--- a/features/fixtures/delayed_job/Dockerfile
+++ b/features/fixtures/delayed_job/Dockerfile
@@ -4,9 +4,12 @@ FROM ruby:$ruby_version
 RUN mkdir -p /usr/src/app
 WORKDIR /usr/src/app
 
-COPY Gemfile /usr/src/app/
+COPY app/Gemfile /usr/src/app/
 RUN bundle install
 
-COPY . /usr/src/app
+COPY app/ /usr/src/app
+
+RUN bundle exec rails generate delayed_job:active_record
+RUN bundle exec rake db:migrate
 
 CMD ["bundle", "exec", "rails", "s", "-b", "0.0.0.0"]
diff --git a/features/fixtures/delayed_job/Gemfile b/features/fixtures/delayed_job/Gemfile
deleted file mode 100644
index f4ce89ea0..000000000
--- a/features/fixtures/delayed_job/Gemfile
+++ /dev/null
@@ -1,4 +0,0 @@
-source 'https://rubygems.org'
-
-gem 'bugsnag'
-gem 'delayed_job'
diff --git a/features/fixtures/delayed_job/app/.gitignore b/features/fixtures/delayed_job/app/.gitignore
new file mode 100644
index 000000000..bab620de0
--- /dev/null
+++ b/features/fixtures/delayed_job/app/.gitignore
@@ -0,0 +1,21 @@
+# See https://help.github.com/articles/ignoring-files for more about ignoring files.
+#
+# If you find yourself ignoring temporary files generated by your text editor
+# or operating system, you probably want to add a global ignore instead:
+#   git config --global core.excludesfile '~/.gitignore_global'
+
+# Ignore bundler config.
+/.bundle
+
+# Ignore the default SQLite database.
+/db/*.sqlite3
+/db/*.sqlite3-journal
+
+# Ignore all logfiles and tempfiles.
+/log/*
+/tmp/*
+!/log/.keep
+!/tmp/.keep
+
+# Ignore Byebug command history file.
+.byebug_history
diff --git a/features/fixtures/delayed_job/app/Gemfile b/features/fixtures/delayed_job/app/Gemfile
new file mode 100644
index 000000000..0f90e8e66
--- /dev/null
+++ b/features/fixtures/delayed_job/app/Gemfile
@@ -0,0 +1,56 @@
+source 'https://rubygems.org'
+
+git_source(:github) do |repo_name|
+  repo_name = "#{repo_name}/#{repo_name}" unless repo_name.include?("/")
+  "https://github.com/#{repo_name}.git"
+end
+
+gem 'bugsnag', path: '../../../../'
+gem 'delayed_job'
+gem 'delayed_job_active_record'
+
+# Bundle edge Rails instead: gem 'rails', github: 'rails/rails'
+gem 'rails', '~> 5.0.7'
+# Use sqlite3 as the database for Active Record
+gem 'sqlite3'
+# Use Puma as the app server
+gem 'puma', '~> 3.0'
+# Use SCSS for stylesheets
+gem 'sass-rails', '~> 5.0'
+# Use Uglifier as compressor for JavaScript assets
+gem 'uglifier', '>= 1.3.0'
+# Use CoffeeScript for .coffee assets and views
+gem 'coffee-rails', '~> 4.2'
+# See https://github.com/rails/execjs#readme for more supported runtimes
+# gem 'therubyracer', platforms: :ruby
+
+# Use jquery as the JavaScript library
+gem 'jquery-rails'
+# Turbolinks makes navigating your web application faster. Read more: https://github.com/turbolinks/turbolinks
+gem 'turbolinks', '~> 5'
+# Build JSON APIs with ease. Read more: https://github.com/rails/jbuilder
+gem 'jbuilder', '~> 2.5'
+# Use Redis adapter to run Action Cable in production
+# gem 'redis', '~> 3.0'
+# Use ActiveModel has_secure_password
+# gem 'bcrypt', '~> 3.1.7'
+
+# Use Capistrano for deployment
+# gem 'capistrano-rails', group: :development
+
+group :development, :test do
+  # Call 'byebug' anywhere in the code to stop execution and get a debugger console
+  gem 'byebug', platform: :mri
+end
+
+group :development do
+  # Access an IRB console on exception pages or by using <%= console %> anywhere in the code.
+  gem 'web-console', '>= 3.3.0'
+  gem 'listen', '~> 3.0.5'
+  # Spring speeds up development by keeping your application running in the background. Read more: https://github.com/rails/spring
+  gem 'spring'
+  gem 'spring-watcher-listen', '~> 2.0.0'
+end
+
+# Windows does not include zoneinfo files, so bundle the tzinfo-data gem
+gem 'tzinfo-data', platforms: [:mingw, :mswin, :x64_mingw, :jruby]
diff --git a/features/fixtures/delayed_job/app/README.md b/features/fixtures/delayed_job/app/README.md
new file mode 100644
index 000000000..7db80e4ca
--- /dev/null
+++ b/features/fixtures/delayed_job/app/README.md
@@ -0,0 +1,24 @@
+# README
+
+This README would normally document whatever steps are necessary to get the
+application up and running.
+
+Things you may want to cover:
+
+* Ruby version
+
+* System dependencies
+
+* Configuration
+
+* Database creation
+
+* Database initialization
+
+* How to run the test suite
+
+* Services (job queues, cache servers, search engines, etc.)
+
+* Deployment instructions
+
+* ...
diff --git a/features/fixtures/delayed_job/app/Rakefile b/features/fixtures/delayed_job/app/Rakefile
new file mode 100644
index 000000000..e85f91391
--- /dev/null
+++ b/features/fixtures/delayed_job/app/Rakefile
@@ -0,0 +1,6 @@
+# Add your own tasks in files placed in lib/tasks ending in .rake,
+# for example lib/tasks/capistrano.rake, and they will automatically be available to Rake.
+
+require_relative 'config/application'
+
+Rails.application.load_tasks
diff --git a/features/fixtures/delayed_job/app/app/assets/config/manifest.js b/features/fixtures/delayed_job/app/app/assets/config/manifest.js
new file mode 100644
index 000000000..b16e53d6d
--- /dev/null
+++ b/features/fixtures/delayed_job/app/app/assets/config/manifest.js
@@ -0,0 +1,3 @@
+//= link_tree ../images
+//= link_directory ../javascripts .js
+//= link_directory ../stylesheets .css
diff --git a/features/fixtures/delayed_job/app/app/assets/images/.keep b/features/fixtures/delayed_job/app/app/assets/images/.keep
new file mode 100644
index 000000000..e69de29bb
diff --git a/features/fixtures/delayed_job/app/app/assets/javascripts/application.js b/features/fixtures/delayed_job/app/app/assets/javascripts/application.js
new file mode 100644
index 000000000..b12018d09
--- /dev/null
+++ b/features/fixtures/delayed_job/app/app/assets/javascripts/application.js
@@ -0,0 +1,16 @@
+// This is a manifest file that'll be compiled into application.js, which will include all the files
+// listed below.
+//
+// Any JavaScript/Coffee file within this directory, lib/assets/javascripts, vendor/assets/javascripts,
+// or any plugin's vendor/assets/javascripts directory can be referenced here using a relative path.
+//
+// It's not advisable to add code directly here, but if you do, it'll appear at the bottom of the
+// compiled file. JavaScript code in this file should be added after the last require_* statement.
+//
+// Read Sprockets README (https://github.com/rails/sprockets#sprockets-directives) for details
+// about supported directives.
+//
+//= require jquery
+//= require jquery_ujs
+//= require turbolinks
+//= require_tree .
diff --git a/features/fixtures/delayed_job/app/app/assets/javascripts/cable.js b/features/fixtures/delayed_job/app/app/assets/javascripts/cable.js
new file mode 100644
index 000000000..71ee1e66d
--- /dev/null
+++ b/features/fixtures/delayed_job/app/app/assets/javascripts/cable.js
@@ -0,0 +1,13 @@
+// Action Cable provides the framework to deal with WebSockets in Rails.
+// You can generate new channels where WebSocket features live using the rails generate channel command.
+//
+//= require action_cable
+//= require_self
+//= require_tree ./channels
+
+(function() {
+  this.App || (this.App = {});
+
+  App.cable = ActionCable.createConsumer();
+
+}).call(this);
diff --git a/features/fixtures/delayed_job/app/app/assets/javascripts/channels/.keep b/features/fixtures/delayed_job/app/app/assets/javascripts/channels/.keep
new file mode 100644
index 000000000..e69de29bb
diff --git a/features/fixtures/delayed_job/app/app/assets/stylesheets/application.css b/features/fixtures/delayed_job/app/app/assets/stylesheets/application.css
new file mode 100644
index 000000000..0ebd7fe82
--- /dev/null
+++ b/features/fixtures/delayed_job/app/app/assets/stylesheets/application.css
@@ -0,0 +1,15 @@
+/*
+ * This is a manifest file that'll be compiled into application.css, which will include all the files
+ * listed below.
+ *
+ * Any CSS and SCSS file within this directory, lib/assets/stylesheets, vendor/assets/stylesheets,
+ * or any plugin's vendor/assets/stylesheets directory can be referenced here using a relative path.
+ *
+ * You're free to add application-wide styles to this file and they'll appear at the bottom of the
+ * compiled file so the styles you add here take precedence over styles defined in any other CSS/SCSS
+ * files in this directory. Styles in this file should be added after the last require_* statement.
+ * It is generally better to create a new file per style scope.
+ *
+ *= require_tree .
+ *= require_self
+ */
diff --git a/features/fixtures/delayed_job/app/app/channels/application_cable/channel.rb b/features/fixtures/delayed_job/app/app/channels/application_cable/channel.rb
new file mode 100644
index 000000000..d67269728
--- /dev/null
+++ b/features/fixtures/delayed_job/app/app/channels/application_cable/channel.rb
@@ -0,0 +1,4 @@
+module ApplicationCable
+  class Channel < ActionCable::Channel::Base
+  end
+end
diff --git a/features/fixtures/delayed_job/app/app/channels/application_cable/connection.rb b/features/fixtures/delayed_job/app/app/channels/application_cable/connection.rb
new file mode 100644
index 000000000..0ff5442f4
--- /dev/null
+++ b/features/fixtures/delayed_job/app/app/channels/application_cable/connection.rb
@@ -0,0 +1,4 @@
+module ApplicationCable
+  class Connection < ActionCable::Connection::Base
+  end
+end
diff --git a/features/fixtures/delayed_job/app/app/controllers/application_controller.rb b/features/fixtures/delayed_job/app/app/controllers/application_controller.rb
new file mode 100644
index 000000000..1c07694e9
--- /dev/null
+++ b/features/fixtures/delayed_job/app/app/controllers/application_controller.rb
@@ -0,0 +1,3 @@
+class ApplicationController < ActionController::Base
+  protect_from_forgery with: :exception
+end
diff --git a/features/fixtures/delayed_job/app/app/controllers/concerns/.keep b/features/fixtures/delayed_job/app/app/controllers/concerns/.keep
new file mode 100644
index 000000000..e69de29bb
diff --git a/features/fixtures/delayed_job/app/app/helpers/application_helper.rb b/features/fixtures/delayed_job/app/app/helpers/application_helper.rb
new file mode 100644
index 000000000..de6be7945
--- /dev/null
+++ b/features/fixtures/delayed_job/app/app/helpers/application_helper.rb
@@ -0,0 +1,2 @@
+module ApplicationHelper
+end
diff --git a/features/fixtures/delayed_job/app/app/jobs/application_job.rb b/features/fixtures/delayed_job/app/app/jobs/application_job.rb
new file mode 100644
index 000000000..a009ace51
--- /dev/null
+++ b/features/fixtures/delayed_job/app/app/jobs/application_job.rb
@@ -0,0 +1,2 @@
+class ApplicationJob < ActiveJob::Base
+end
diff --git a/features/fixtures/delayed_job/app/app/mailers/application_mailer.rb b/features/fixtures/delayed_job/app/app/mailers/application_mailer.rb
new file mode 100644
index 000000000..286b2239d
--- /dev/null
+++ b/features/fixtures/delayed_job/app/app/mailers/application_mailer.rb
@@ -0,0 +1,4 @@
+class ApplicationMailer < ActionMailer::Base
+  default from: 'from@example.com'
+  layout 'mailer'
+end
diff --git a/features/fixtures/delayed_job/app/app/models/application_record.rb b/features/fixtures/delayed_job/app/app/models/application_record.rb
new file mode 100644
index 000000000..10a4cba84
--- /dev/null
+++ b/features/fixtures/delayed_job/app/app/models/application_record.rb
@@ -0,0 +1,3 @@
+class ApplicationRecord < ActiveRecord::Base
+  self.abstract_class = true
+end
diff --git a/features/fixtures/delayed_job/app/app/models/concerns/.keep b/features/fixtures/delayed_job/app/app/models/concerns/.keep
new file mode 100644
index 000000000..e69de29bb
diff --git a/features/fixtures/delayed_job/app/app/models/test_model.rb b/features/fixtures/delayed_job/app/app/models/test_model.rb
new file mode 100644
index 000000000..c77dee930
--- /dev/null
+++ b/features/fixtures/delayed_job/app/app/models/test_model.rb
@@ -0,0 +1,13 @@
+class TestModel < ApplicationRecord
+  def self.print
+    puts "yo"
+  end
+
+  def self.fail
+    raise "uh oh"
+  end
+
+  def self.fail_with_args(a)
+    raise "uh oh"
+  end
+end
diff --git a/features/fixtures/delayed_job/app/app/views/layouts/application.html.erb b/features/fixtures/delayed_job/app/app/views/layouts/application.html.erb
new file mode 100644
index 000000000..1539732f8
--- /dev/null
+++ b/features/fixtures/delayed_job/app/app/views/layouts/application.html.erb
@@ -0,0 +1,14 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <title>App</title>
+    <%= csrf_meta_tags %>
+
+    <%= stylesheet_link_tag    'application', media: 'all', 'data-turbolinks-track': 'reload' %>
+    <%= javascript_include_tag 'application', 'data-turbolinks-track': 'reload' %>
+  </head>
+
+  <body>
+    <%= yield %>
+  </body>
+</html>
diff --git a/features/fixtures/delayed_job/app/app/views/layouts/mailer.html.erb b/features/fixtures/delayed_job/app/app/views/layouts/mailer.html.erb
new file mode 100644
index 000000000..cbd34d2e9
--- /dev/null
+++ b/features/fixtures/delayed_job/app/app/views/layouts/mailer.html.erb
@@ -0,0 +1,13 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
+    <style>
+      /* Email styles need to be inline */
+    </style>
+  </head>
+
+  <body>
+    <%= yield %>
+  </body>
+</html>
diff --git a/features/fixtures/delayed_job/app/app/views/layouts/mailer.text.erb b/features/fixtures/delayed_job/app/app/views/layouts/mailer.text.erb
new file mode 100644
index 000000000..37f0bddbd
--- /dev/null
+++ b/features/fixtures/delayed_job/app/app/views/layouts/mailer.text.erb
@@ -0,0 +1 @@
+<%= yield %>
diff --git a/features/fixtures/delayed_job/app/config.ru b/features/fixtures/delayed_job/app/config.ru
new file mode 100644
index 000000000..f7ba0b527
--- /dev/null
+++ b/features/fixtures/delayed_job/app/config.ru
@@ -0,0 +1,5 @@
+# This file is used by Rack-based servers to start the application.
+
+require_relative 'config/environment'
+
+run Rails.application
diff --git a/features/fixtures/delayed_job/app/config/application.rb b/features/fixtures/delayed_job/app/config/application.rb
new file mode 100644
index 000000000..7e42acd4d
--- /dev/null
+++ b/features/fixtures/delayed_job/app/config/application.rb
@@ -0,0 +1,15 @@
+require_relative 'boot'
+
+require 'rails/all'
+
+# Require the gems listed in Gemfile, including any gems
+# you've limited to :test, :development, or :production.
+Bundler.require(*Rails.groups)
+
+module App
+  class Application < Rails::Application
+    # Settings in config/environments/* take precedence over those specified here.
+    # Application configuration should go into files in config/initializers
+    # -- all .rb files in that directory are automatically loaded.
+  end
+end
diff --git a/features/fixtures/delayed_job/app/config/boot.rb b/features/fixtures/delayed_job/app/config/boot.rb
new file mode 100644
index 000000000..30f5120df
--- /dev/null
+++ b/features/fixtures/delayed_job/app/config/boot.rb
@@ -0,0 +1,3 @@
+ENV['BUNDLE_GEMFILE'] ||= File.expand_path('../Gemfile', __dir__)
+
+require 'bundler/setup' # Set up gems listed in the Gemfile.
diff --git a/features/fixtures/delayed_job/app/config/cable.yml b/features/fixtures/delayed_job/app/config/cable.yml
new file mode 100644
index 000000000..0bbde6f74
--- /dev/null
+++ b/features/fixtures/delayed_job/app/config/cable.yml
@@ -0,0 +1,9 @@
+development:
+  adapter: async
+
+test:
+  adapter: async
+
+production:
+  adapter: redis
+  url: redis://localhost:6379/1
diff --git a/features/fixtures/delayed_job/app/config/database.yml b/features/fixtures/delayed_job/app/config/database.yml
new file mode 100644
index 000000000..1c1a37ca8
--- /dev/null
+++ b/features/fixtures/delayed_job/app/config/database.yml
@@ -0,0 +1,25 @@
+# SQLite version 3.x
+#   gem install sqlite3
+#
+#   Ensure the SQLite 3 gem is defined in your Gemfile
+#   gem 'sqlite3'
+#
+default: &default
+  adapter: sqlite3
+  pool: 5
+  timeout: 5000
+
+development:
+  <<: *default
+  database: db/development.sqlite3
+
+# Warning: The database defined as "test" will be erased and
+# re-generated from your development database when you run "rake".
+# Do not set this db to the same as development or production.
+test:
+  <<: *default
+  database: db/test.sqlite3
+
+production:
+  <<: *default
+  database: db/production.sqlite3
diff --git a/features/fixtures/delayed_job/app/config/environment.rb b/features/fixtures/delayed_job/app/config/environment.rb
new file mode 100644
index 000000000..426333bb4
--- /dev/null
+++ b/features/fixtures/delayed_job/app/config/environment.rb
@@ -0,0 +1,5 @@
+# Load the Rails application.
+require_relative 'application'
+
+# Initialize the Rails application.
+Rails.application.initialize!
diff --git a/features/fixtures/delayed_job/app/config/environments/development.rb b/features/fixtures/delayed_job/app/config/environments/development.rb
new file mode 100644
index 000000000..6f7197045
--- /dev/null
+++ b/features/fixtures/delayed_job/app/config/environments/development.rb
@@ -0,0 +1,54 @@
+Rails.application.configure do
+  # Settings specified here will take precedence over those in config/application.rb.
+
+  # In the development environment your application's code is reloaded on
+  # every request. This slows down response time but is perfect for development
+  # since you don't have to restart the web server when you make code changes.
+  config.cache_classes = false
+
+  # Do not eager load code on boot.
+  config.eager_load = false
+
+  # Show full error reports.
+  config.consider_all_requests_local = true
+
+  # Enable/disable caching. By default caching is disabled.
+  if Rails.root.join('tmp/caching-dev.txt').exist?
+    config.action_controller.perform_caching = true
+
+    config.cache_store = :memory_store
+    config.public_file_server.headers = {
+      'Cache-Control' => 'public, max-age=172800'
+    }
+  else
+    config.action_controller.perform_caching = false
+
+    config.cache_store = :null_store
+  end
+
+  # Don't care if the mailer can't send.
+  config.action_mailer.raise_delivery_errors = false
+
+  config.action_mailer.perform_caching = false
+
+  # Print deprecation notices to the Rails logger.
+  config.active_support.deprecation = :log
+
+  # Raise an error on page load if there are pending migrations.
+  config.active_record.migration_error = :page_load
+
+  # Debug mode disables concatenation and preprocessing of assets.
+  # This option may cause significant delays in view rendering with a large
+  # number of complex assets.
+  config.assets.debug = true
+
+  # Suppress logger output for asset requests.
+  config.assets.quiet = true
+
+  # Raises error for missing translations
+  # config.action_view.raise_on_missing_translations = true
+
+  # Use an evented file watcher to asynchronously detect changes in source code,
+  # routes, locales, etc. This feature depends on the listen gem.
+  config.file_watcher = ActiveSupport::EventedFileUpdateChecker
+end
diff --git a/features/fixtures/delayed_job/app/config/environments/production.rb b/features/fixtures/delayed_job/app/config/environments/production.rb
new file mode 100644
index 000000000..37b0cc052
--- /dev/null
+++ b/features/fixtures/delayed_job/app/config/environments/production.rb
@@ -0,0 +1,86 @@
+Rails.application.configure do
+  # Settings specified here will take precedence over those in config/application.rb.
+
+  # Code is not reloaded between requests.
+  config.cache_classes = true
+
+  # Eager load code on boot. This eager loads most of Rails and
+  # your application in memory, allowing both threaded web servers
+  # and those relying on copy on write to perform better.
+  # Rake tasks automatically ignore this option for performance.
+  config.eager_load = true
+
+  # Full error reports are disabled and caching is turned on.
+  config.consider_all_requests_local       = false
+  config.action_controller.perform_caching = true
+
+  # Disable serving static files from the `/public` folder by default since
+  # Apache or NGINX already handles this.
+  config.public_file_server.enabled = ENV['RAILS_SERVE_STATIC_FILES'].present?
+
+  # Compress JavaScripts and CSS.
+  config.assets.js_compressor = :uglifier
+  # config.assets.css_compressor = :sass
+
+  # Do not fallback to assets pipeline if a precompiled asset is missed.
+  config.assets.compile = false
+
+  # `config.assets.precompile` and `config.assets.version` have moved to config/initializers/assets.rb
+
+  # Enable serving of images, stylesheets, and JavaScripts from an asset server.
+  # config.action_controller.asset_host = 'http://assets.example.com'
+
+  # Specifies the header that your server uses for sending files.
+  # config.action_dispatch.x_sendfile_header = 'X-Sendfile' # for Apache
+  # config.action_dispatch.x_sendfile_header = 'X-Accel-Redirect' # for NGINX
+
+  # Mount Action Cable outside main process or domain
+  # config.action_cable.mount_path = nil
+  # config.action_cable.url = 'wss://example.com/cable'
+  # config.action_cable.allowed_request_origins = [ 'http://example.com', /http:\/\/example.*/ ]
+
+  # Force all access to the app over SSL, use Strict-Transport-Security, and use secure cookies.
+  # config.force_ssl = true
+
+  # Use the lowest log level to ensure availability of diagnostic information
+  # when problems arise.
+  config.log_level = :debug
+
+  # Prepend all log lines with the following tags.
+  config.log_tags = [ :request_id ]
+
+  # Use a different cache store in production.
+  # config.cache_store = :mem_cache_store
+
+  # Use a real queuing backend for Active Job (and separate queues per environment)
+  # config.active_job.queue_adapter     = :resque
+  # config.active_job.queue_name_prefix = "app_#{Rails.env}"
+  config.action_mailer.perform_caching = false
+
+  # Ignore bad email addresses and do not raise email delivery errors.
+  # Set this to true and configure the email server for immediate delivery to raise delivery errors.
+  # config.action_mailer.raise_delivery_errors = false
+
+  # Enable locale fallbacks for I18n (makes lookups for any locale fall back to
+  # the I18n.default_locale when a translation cannot be found).
+  config.i18n.fallbacks = true
+
+  # Send deprecation notices to registered listeners.
+  config.active_support.deprecation = :notify
+
+  # Use default logging formatter so that PID and timestamp are not suppressed.
+  config.log_formatter = ::Logger::Formatter.new
+
+  # Use a different logger for distributed setups.
+  # require 'syslog/logger'
+  # config.logger = ActiveSupport::TaggedLogging.new(Syslog::Logger.new 'app-name')
+
+  if ENV["RAILS_LOG_TO_STDOUT"].present?
+    logger           = ActiveSupport::Logger.new(STDOUT)
+    logger.formatter = config.log_formatter
+    config.logger = ActiveSupport::TaggedLogging.new(logger)
+  end
+
+  # Do not dump schema after migrations.
+  config.active_record.dump_schema_after_migration = false
+end
diff --git a/features/fixtures/delayed_job/app/config/environments/test.rb b/features/fixtures/delayed_job/app/config/environments/test.rb
new file mode 100644
index 000000000..30587ef6d
--- /dev/null
+++ b/features/fixtures/delayed_job/app/config/environments/test.rb
@@ -0,0 +1,42 @@
+Rails.application.configure do
+  # Settings specified here will take precedence over those in config/application.rb.
+
+  # The test environment is used exclusively to run your application's
+  # test suite. You never need to work with it otherwise. Remember that
+  # your test database is "scratch space" for the test suite and is wiped
+  # and recreated between test runs. Don't rely on the data there!
+  config.cache_classes = true
+
+  # Do not eager load code on boot. This avoids loading your whole application
+  # just for the purpose of running a single test. If you are using a tool that
+  # preloads Rails for running tests, you may have to set it to true.
+  config.eager_load = false
+
+  # Configure public file server for tests with Cache-Control for performance.
+  config.public_file_server.enabled = true
+  config.public_file_server.headers = {
+    'Cache-Control' => 'public, max-age=3600'
+  }
+
+  # Show full error reports and disable caching.
+  config.consider_all_requests_local       = true
+  config.action_controller.perform_caching = false
+
+  # Raise exceptions instead of rendering exception templates.
+  config.action_dispatch.show_exceptions = false
+
+  # Disable request forgery protection in test environment.
+  config.action_controller.allow_forgery_protection = false
+  config.action_mailer.perform_caching = false
+
+  # Tell Action Mailer not to deliver emails to the real world.
+  # The :test delivery method accumulates sent emails in the
+  # ActionMailer::Base.deliveries array.
+  config.action_mailer.delivery_method = :test
+
+  # Print deprecation notices to the stderr.
+  config.active_support.deprecation = :stderr
+
+  # Raises error for missing translations
+  # config.action_view.raise_on_missing_translations = true
+end
diff --git a/features/fixtures/delayed_job/app/config/initializers/application_controller_renderer.rb b/features/fixtures/delayed_job/app/config/initializers/application_controller_renderer.rb
new file mode 100644
index 000000000..89d2efab2
--- /dev/null
+++ b/features/fixtures/delayed_job/app/config/initializers/application_controller_renderer.rb
@@ -0,0 +1,8 @@
+# Be sure to restart your server when you modify this file.
+
+# ActiveSupport::Reloader.to_prepare do
+#   ApplicationController.renderer.defaults.merge!(
+#     http_host: 'example.org',
+#     https: false
+#   )
+# end
diff --git a/features/fixtures/delayed_job/app/config/initializers/assets.rb b/features/fixtures/delayed_job/app/config/initializers/assets.rb
new file mode 100644
index 000000000..01ef3e663
--- /dev/null
+++ b/features/fixtures/delayed_job/app/config/initializers/assets.rb
@@ -0,0 +1,11 @@
+# Be sure to restart your server when you modify this file.
+
+# Version of your assets, change this if you want to expire all your assets.
+Rails.application.config.assets.version = '1.0'
+
+# Add additional assets to the asset load path
+# Rails.application.config.assets.paths << Emoji.images_path
+
+# Precompile additional assets.
+# application.js, application.css, and all non-JS/CSS in app/assets folder are already added.
+# Rails.application.config.assets.precompile += %w( search.js )
diff --git a/features/fixtures/delayed_job/app/config/initializers/backtrace_silencers.rb b/features/fixtures/delayed_job/app/config/initializers/backtrace_silencers.rb
new file mode 100644
index 000000000..59385cdf3
--- /dev/null
+++ b/features/fixtures/delayed_job/app/config/initializers/backtrace_silencers.rb
@@ -0,0 +1,7 @@
+# Be sure to restart your server when you modify this file.
+
+# You can add backtrace silencers for libraries that you're using but don't wish to see in your backtraces.
+# Rails.backtrace_cleaner.add_silencer { |line| line =~ /my_noisy_library/ }
+
+# You can also remove all the silencers if you're trying to debug a problem that might stem from framework code.
+# Rails.backtrace_cleaner.remove_silencers!
diff --git a/features/fixtures/delayed_job/app/config/initializers/bugsnag.rb b/features/fixtures/delayed_job/app/config/initializers/bugsnag.rb
new file mode 100644
index 000000000..c2aa28bc9
--- /dev/null
+++ b/features/fixtures/delayed_job/app/config/initializers/bugsnag.rb
@@ -0,0 +1,3 @@
+Bugsnag.configure do |config|
+  config.api_key = "0a336f52d5bc59451e518f3e682209c7"
+end
diff --git a/features/fixtures/delayed_job/app/config/initializers/cookies_serializer.rb b/features/fixtures/delayed_job/app/config/initializers/cookies_serializer.rb
new file mode 100644
index 000000000..5a6a32d37
--- /dev/null
+++ b/features/fixtures/delayed_job/app/config/initializers/cookies_serializer.rb
@@ -0,0 +1,5 @@
+# Be sure to restart your server when you modify this file.
+
+# Specify a serializer for the signed and encrypted cookie jars.
+# Valid options are :json, :marshal, and :hybrid.
+Rails.application.config.action_dispatch.cookies_serializer = :json
diff --git a/features/fixtures/delayed_job/app/config/initializers/filter_parameter_logging.rb b/features/fixtures/delayed_job/app/config/initializers/filter_parameter_logging.rb
new file mode 100644
index 000000000..4a994e1e7
--- /dev/null
+++ b/features/fixtures/delayed_job/app/config/initializers/filter_parameter_logging.rb
@@ -0,0 +1,4 @@
+# Be sure to restart your server when you modify this file.
+
+# Configure sensitive parameters which will be filtered from the log file.
+Rails.application.config.filter_parameters += [:password]
diff --git a/features/fixtures/delayed_job/app/config/initializers/inflections.rb b/features/fixtures/delayed_job/app/config/initializers/inflections.rb
new file mode 100644
index 000000000..ac033bf9d
--- /dev/null
+++ b/features/fixtures/delayed_job/app/config/initializers/inflections.rb
@@ -0,0 +1,16 @@
+# Be sure to restart your server when you modify this file.
+
+# Add new inflection rules using the following format. Inflections
+# are locale specific, and you may define rules for as many different
+# locales as you wish. All of these examples are active by default:
+# ActiveSupport::Inflector.inflections(:en) do |inflect|
+#   inflect.plural /^(ox)$/i, '\1en'
+#   inflect.singular /^(ox)en/i, '\1'
+#   inflect.irregular 'person', 'people'
+#   inflect.uncountable %w( fish sheep )
+# end
+
+# These inflection rules are supported but not enabled by default:
+# ActiveSupport::Inflector.inflections(:en) do |inflect|
+#   inflect.acronym 'RESTful'
+# end
diff --git a/features/fixtures/delayed_job/app/config/initializers/mime_types.rb b/features/fixtures/delayed_job/app/config/initializers/mime_types.rb
new file mode 100644
index 000000000..dc1899682
--- /dev/null
+++ b/features/fixtures/delayed_job/app/config/initializers/mime_types.rb
@@ -0,0 +1,4 @@
+# Be sure to restart your server when you modify this file.
+
+# Add new mime types for use in respond_to blocks:
+# Mime::Type.register "text/richtext", :rtf
diff --git a/features/fixtures/delayed_job/app/config/initializers/new_framework_defaults.rb b/features/fixtures/delayed_job/app/config/initializers/new_framework_defaults.rb
new file mode 100644
index 000000000..dd236b5fe
--- /dev/null
+++ b/features/fixtures/delayed_job/app/config/initializers/new_framework_defaults.rb
@@ -0,0 +1,26 @@
+# Be sure to restart your server when you modify this file.
+#
+# This file contains migration options to ease your Rails 5.0 upgrade.
+#
+# Read the Guide for Upgrading Ruby on Rails for more info on each option.
+
+Rails.application.config.action_controller.raise_on_unfiltered_parameters = true
+
+# Enable per-form CSRF tokens. Previous versions had false.
+Rails.application.config.action_controller.per_form_csrf_tokens = true
+
+# Enable origin-checking CSRF mitigation. Previous versions had false.
+Rails.application.config.action_controller.forgery_protection_origin_check = true
+
+# Make Ruby 2.4 preserve the timezone of the receiver when calling `to_time`.
+# Previous versions had false.
+ActiveSupport.to_time_preserves_timezone = true
+
+# Require `belongs_to` associations by default. Previous versions had false.
+Rails.application.config.active_record.belongs_to_required_by_default = true
+
+# Do not halt callback chains when a callback returns false. Previous versions had true.
+ActiveSupport.halt_callback_chains_on_return_false = false
+
+# Configure SSL options to enable HSTS with subdomains. Previous versions had false.
+Rails.application.config.ssl_options = { hsts: { subdomains: true } }
diff --git a/features/fixtures/delayed_job/app/config/initializers/session_store.rb b/features/fixtures/delayed_job/app/config/initializers/session_store.rb
new file mode 100644
index 000000000..878cce2be
--- /dev/null
+++ b/features/fixtures/delayed_job/app/config/initializers/session_store.rb
@@ -0,0 +1,3 @@
+# Be sure to restart your server when you modify this file.
+
+Rails.application.config.session_store :cookie_store, key: '_app_session'
diff --git a/features/fixtures/delayed_job/app/config/initializers/wrap_parameters.rb b/features/fixtures/delayed_job/app/config/initializers/wrap_parameters.rb
new file mode 100644
index 000000000..bbfc3961b
--- /dev/null
+++ b/features/fixtures/delayed_job/app/config/initializers/wrap_parameters.rb
@@ -0,0 +1,14 @@
+# Be sure to restart your server when you modify this file.
+
+# This file contains settings for ActionController::ParamsWrapper which
+# is enabled by default.
+
+# Enable parameter wrapping for JSON. You can disable this by setting :format to an empty array.
+ActiveSupport.on_load(:action_controller) do
+  wrap_parameters format: [:json]
+end
+
+# To enable root element in JSON for ActiveRecord objects.
+# ActiveSupport.on_load(:active_record) do
+#   self.include_root_in_json = true
+# end
diff --git a/features/fixtures/delayed_job/app/config/locales/en.yml b/features/fixtures/delayed_job/app/config/locales/en.yml
new file mode 100644
index 000000000..065395716
--- /dev/null
+++ b/features/fixtures/delayed_job/app/config/locales/en.yml
@@ -0,0 +1,23 @@
+# Files in the config/locales directory are used for internationalization
+# and are automatically loaded by Rails. If you want to use locales other
+# than English, add the necessary files in this directory.
+#
+# To use the locales, use `I18n.t`:
+#
+#     I18n.t 'hello'
+#
+# In views, this is aliased to just `t`:
+#
+#     <%= t('hello') %>
+#
+# To use a different locale, set it with `I18n.locale`:
+#
+#     I18n.locale = :es
+#
+# This would use the information in config/locales/es.yml.
+#
+# To learn more, please read the Rails Internationalization guide
+# available at http://guides.rubyonrails.org/i18n.html.
+
+en:
+  hello: "Hello world"
diff --git a/features/fixtures/delayed_job/app/config/puma.rb b/features/fixtures/delayed_job/app/config/puma.rb
new file mode 100644
index 000000000..c7f311f81
--- /dev/null
+++ b/features/fixtures/delayed_job/app/config/puma.rb
@@ -0,0 +1,47 @@
+# Puma can serve each request in a thread from an internal thread pool.
+# The `threads` method setting takes two numbers a minimum and maximum.
+# Any libraries that use thread pools should be configured to match
+# the maximum value specified for Puma. Default is set to 5 threads for minimum
+# and maximum, this matches the default thread size of Active Record.
+#
+threads_count = ENV.fetch("RAILS_MAX_THREADS") { 5 }.to_i
+threads threads_count, threads_count
+
+# Specifies the `port` that Puma will listen on to receive requests, default is 3000.
+#
+port        ENV.fetch("PORT") { 3000 }
+
+# Specifies the `environment` that Puma will run in.
+#
+environment ENV.fetch("RAILS_ENV") { "development" }
+
+# Specifies the number of `workers` to boot in clustered mode.
+# Workers are forked webserver processes. If using threads and workers together
+# the concurrency of the application would be max `threads` * `workers`.
+# Workers do not work on JRuby or Windows (both of which do not support
+# processes).
+#
+# workers ENV.fetch("WEB_CONCURRENCY") { 2 }
+
+# Use the `preload_app!` method when specifying a `workers` number.
+# This directive tells Puma to first boot the application and load code
+# before forking the application. This takes advantage of Copy On Write
+# process behavior so workers use less memory. If you use this option
+# you need to make sure to reconnect any threads in the `on_worker_boot`
+# block.
+#
+# preload_app!
+
+# The code in the `on_worker_boot` will be called if you are using
+# clustered mode by specifying a number of `workers`. After each worker
+# process is booted this block will be run, if you are using `preload_app!`
+# option you will want to use this block to reconnect to any threads
+# or connections that may have been created at application boot, Ruby
+# cannot share connections between processes.
+#
+# on_worker_boot do
+#   ActiveRecord::Base.establish_connection if defined?(ActiveRecord)
+# end
+
+# Allow puma to be restarted by `rails restart` command.
+plugin :tmp_restart
diff --git a/features/fixtures/delayed_job/app/config/routes.rb b/features/fixtures/delayed_job/app/config/routes.rb
new file mode 100644
index 000000000..787824f88
--- /dev/null
+++ b/features/fixtures/delayed_job/app/config/routes.rb
@@ -0,0 +1,3 @@
+Rails.application.routes.draw do
+  # For details on the DSL available within this file, see http://guides.rubyonrails.org/routing.html
+end
diff --git a/features/fixtures/delayed_job/app/config/secrets.yml b/features/fixtures/delayed_job/app/config/secrets.yml
new file mode 100644
index 000000000..7d01918eb
--- /dev/null
+++ b/features/fixtures/delayed_job/app/config/secrets.yml
@@ -0,0 +1,22 @@
+# Be sure to restart your server when you modify this file.
+
+# Your secret key is used for verifying the integrity of signed cookies.
+# If you change this key, all old signed cookies will become invalid!
+
+# Make sure the secret is at least 30 characters and all random,
+# no regular words or you'll be exposed to dictionary attacks.
+# You can use `rails secret` to generate a secure secret key.
+
+# Make sure the secrets in this file are kept private
+# if you're sharing your code publicly.
+
+development:
+  secret_key_base: 5bbdeedb5f00f9af930e144daef68828cbed84586a9e59880c0865e1759974a1b16f8f568d59da1e6d2891e40c06c9cdda35a897ab9e87048388b661c1b861d3
+
+test:
+  secret_key_base: 124f3db03c0ca01dc5e19e50e7993b7305dd05841a62c5c54886204f30679a96e514ce9aae9ef17b291510efc87de8d207f7511931e4f80b5f6e06160a74ef6e
+
+# Do not keep production secrets in the repository,
+# instead read values from the environment.
+production:
+  secret_key_base: <%= ENV["SECRET_KEY_BASE"] %>
diff --git a/features/fixtures/delayed_job/app/config/spring.rb b/features/fixtures/delayed_job/app/config/spring.rb
new file mode 100644
index 000000000..c9119b40c
--- /dev/null
+++ b/features/fixtures/delayed_job/app/config/spring.rb
@@ -0,0 +1,6 @@
+%w(
+  .ruby-version
+  .rbenv-vars
+  tmp/restart.txt
+  tmp/caching-dev.txt
+).each { |path| Spring.watch(path) }
diff --git a/features/fixtures/delayed_job/app/db/migrate/20181024232549_create_delayed_jobs.rb b/features/fixtures/delayed_job/app/db/migrate/20181024232549_create_delayed_jobs.rb
new file mode 100644
index 000000000..130a8d570
--- /dev/null
+++ b/features/fixtures/delayed_job/app/db/migrate/20181024232549_create_delayed_jobs.rb
@@ -0,0 +1,22 @@
+class CreateDelayedJobs < ActiveRecord::Migration[5.0]
+  def self.up
+    create_table :delayed_jobs, force: true do |table|
+      table.integer :priority, default: 0, null: false # Allows some jobs to jump to the front of the queue
+      table.integer :attempts, default: 0, null: false # Provides for retries, but still fail eventually.
+      table.text :handler,                 null: false # YAML-encoded string of the object that will do work
+      table.text :last_error                           # reason for last failure (See Note below)
+      table.datetime :run_at                           # When to run. Could be Time.zone.now for immediately, or sometime in the future.
+      table.datetime :locked_at                        # Set when a client is working on this object
+      table.datetime :failed_at                        # Set when all retries have failed (actually, by default, the record is deleted instead)
+      table.string :locked_by                          # Who is working on this object (if locked)
+      table.string :queue                              # The name of the queue this job is in
+      table.timestamps null: true
+    end
+
+    add_index :delayed_jobs, [:priority, :run_at], name: "delayed_jobs_priority"
+  end
+
+  def self.down
+    drop_table :delayed_jobs
+  end
+end
diff --git a/features/fixtures/delayed_job/app/db/migrate/20181024232817_create_test_models.rb b/features/fixtures/delayed_job/app/db/migrate/20181024232817_create_test_models.rb
new file mode 100644
index 000000000..e5388172e
--- /dev/null
+++ b/features/fixtures/delayed_job/app/db/migrate/20181024232817_create_test_models.rb
@@ -0,0 +1,8 @@
+class CreateTestModels < ActiveRecord::Migration[5.0]
+  def change
+    create_table :test_models do |t|
+
+      t.timestamps
+    end
+  end
+end
diff --git a/features/fixtures/delayed_job/app/db/schema.rb b/features/fixtures/delayed_job/app/db/schema.rb
new file mode 100644
index 000000000..f3b20a75a
--- /dev/null
+++ b/features/fixtures/delayed_job/app/db/schema.rb
@@ -0,0 +1,30 @@
+# This file is auto-generated from the current state of the database. Instead
+# of editing this file, please use the migrations feature of Active Record to
+# incrementally modify your database, and then regenerate this schema definition.
+#
+# Note that this schema.rb definition is the authoritative source for your
+# database schema. If you need to create the application database on another
+# system, you should be using db:schema:load, not running all the migrations
+# from scratch. The latter is a flawed and unsustainable approach (the more migrations
+# you'll amass, the slower it'll run and the greater likelihood for issues).
+#
+# It's strongly recommended that you check this file into your version control system.
+
+ActiveRecord::Schema.define(version: 20181024232549) do
+
+  create_table "delayed_jobs", force: :cascade do |t|
+    t.integer  "priority",   default: 0, null: false
+    t.integer  "attempts",   default: 0, null: false
+    t.text     "handler",                null: false
+    t.text     "last_error"
+    t.datetime "run_at"
+    t.datetime "locked_at"
+    t.datetime "failed_at"
+    t.string   "locked_by"
+    t.string   "queue"
+    t.datetime "created_at"
+    t.datetime "updated_at"
+    t.index ["priority", "run_at"], name: "delayed_jobs_priority"
+  end
+
+end
diff --git a/features/fixtures/delayed_job/app/db/seeds.rb b/features/fixtures/delayed_job/app/db/seeds.rb
new file mode 100644
index 000000000..1beea2acc
--- /dev/null
+++ b/features/fixtures/delayed_job/app/db/seeds.rb
@@ -0,0 +1,7 @@
+# This file should contain all the record creation needed to seed the database with its default values.
+# The data can then be loaded with the rails db:seed command (or created alongside the database with db:setup).
+#
+# Examples:
+#
+#   movies = Movie.create([{ name: 'Star Wars' }, { name: 'Lord of the Rings' }])
+#   Character.create(name: 'Luke', movie: movies.first)
diff --git a/features/fixtures/delayed_job/app/lib/assets/.keep b/features/fixtures/delayed_job/app/lib/assets/.keep
new file mode 100644
index 000000000..e69de29bb
diff --git a/features/fixtures/delayed_job/app/lib/tasks/.keep b/features/fixtures/delayed_job/app/lib/tasks/.keep
new file mode 100644
index 000000000..e69de29bb
diff --git a/features/fixtures/delayed_job/app/log/.keep b/features/fixtures/delayed_job/app/log/.keep
new file mode 100644
index 000000000..e69de29bb
diff --git a/features/fixtures/delayed_job/app/public/404.html b/features/fixtures/delayed_job/app/public/404.html
new file mode 100644
index 000000000..2be3af26f
--- /dev/null
+++ b/features/fixtures/delayed_job/app/public/404.html
@@ -0,0 +1,67 @@
+<!DOCTYPE html>
+<html>
+<head>
+  <title>The page you were looking for doesn't exist (404)</title>
+  <meta name="viewport" content="width=device-width,initial-scale=1">
+  <style>
+  .rails-default-error-page {
+    background-color: #EFEFEF;
+    color: #2E2F30;
+    text-align: center;
+    font-family: arial, sans-serif;
+    margin: 0;
+  }
+
+  .rails-default-error-page div.dialog {
+    width: 95%;
+    max-width: 33em;
+    margin: 4em auto 0;
+  }
+
+  .rails-default-error-page div.dialog > div {
+    border: 1px solid #CCC;
+    border-right-color: #999;
+    border-left-color: #999;
+    border-bottom-color: #BBB;
+    border-top: #B00100 solid 4px;
+    border-top-left-radius: 9px;
+    border-top-right-radius: 9px;
+    background-color: white;
+    padding: 7px 12% 0;
+    box-shadow: 0 3px 8px rgba(50, 50, 50, 0.17);
+  }
+
+  .rails-default-error-page h1 {
+    font-size: 100%;
+    color: #730E15;
+    line-height: 1.5em;
+  }
+
+  .rails-default-error-page div.dialog > p {
+    margin: 0 0 1em;
+    padding: 1em;
+    background-color: #F7F7F7;
+    border: 1px solid #CCC;
+    border-right-color: #999;
+    border-left-color: #999;
+    border-bottom-color: #999;
+    border-bottom-left-radius: 4px;
+    border-bottom-right-radius: 4px;
+    border-top-color: #DADADA;
+    color: #666;
+    box-shadow: 0 3px 8px rgba(50, 50, 50, 0.17);
+  }
+  </style>
+</head>
+
+<body class="rails-default-error-page">
+  <!-- This file lives in public/404.html -->
+  <div class="dialog">
+    <div>
+      <h1>The page you were looking for doesn't exist.</h1>
+      <p>You may have mistyped the address or the page may have moved.</p>
+    </div>
+    <p>If you are the application owner check the logs for more information.</p>
+  </div>
+</body>
+</html>
diff --git a/features/fixtures/delayed_job/app/public/422.html b/features/fixtures/delayed_job/app/public/422.html
new file mode 100644
index 000000000..c08eac0d1
--- /dev/null
+++ b/features/fixtures/delayed_job/app/public/422.html
@@ -0,0 +1,67 @@
+<!DOCTYPE html>
+<html>
+<head>
+  <title>The change you wanted was rejected (422)</title>
+  <meta name="viewport" content="width=device-width,initial-scale=1">
+  <style>
+  .rails-default-error-page {
+    background-color: #EFEFEF;
+    color: #2E2F30;
+    text-align: center;
+    font-family: arial, sans-serif;
+    margin: 0;
+  }
+
+  .rails-default-error-page div.dialog {
+    width: 95%;
+    max-width: 33em;
+    margin: 4em auto 0;
+  }
+
+  .rails-default-error-page div.dialog > div {
+    border: 1px solid #CCC;
+    border-right-color: #999;
+    border-left-color: #999;
+    border-bottom-color: #BBB;
+    border-top: #B00100 solid 4px;
+    border-top-left-radius: 9px;
+    border-top-right-radius: 9px;
+    background-color: white;
+    padding: 7px 12% 0;
+    box-shadow: 0 3px 8px rgba(50, 50, 50, 0.17);
+  }
+
+  .rails-default-error-page h1 {
+    font-size: 100%;
+    color: #730E15;
+    line-height: 1.5em;
+  }
+
+  .rails-default-error-page div.dialog > p {
+    margin: 0 0 1em;
+    padding: 1em;
+    background-color: #F7F7F7;
+    border: 1px solid #CCC;
+    border-right-color: #999;
+    border-left-color: #999;
+    border-bottom-color: #999;
+    border-bottom-left-radius: 4px;
+    border-bottom-right-radius: 4px;
+    border-top-color: #DADADA;
+    color: #666;
+    box-shadow: 0 3px 8px rgba(50, 50, 50, 0.17);
+  }
+  </style>
+</head>
+
+<body class="rails-default-error-page">
+  <!-- This file lives in public/422.html -->
+  <div class="dialog">
+    <div>
+      <h1>The change you wanted was rejected.</h1>
+      <p>Maybe you tried to change something you didn't have access to.</p>
+    </div>
+    <p>If you are the application owner check the logs for more information.</p>
+  </div>
+</body>
+</html>
diff --git a/features/fixtures/delayed_job/app/public/500.html b/features/fixtures/delayed_job/app/public/500.html
new file mode 100644
index 000000000..78a030af2
--- /dev/null
+++ b/features/fixtures/delayed_job/app/public/500.html
@@ -0,0 +1,66 @@
+<!DOCTYPE html>
+<html>
+<head>
+  <title>We're sorry, but something went wrong (500)</title>
+  <meta name="viewport" content="width=device-width,initial-scale=1">
+  <style>
+  .rails-default-error-page {
+    background-color: #EFEFEF;
+    color: #2E2F30;
+    text-align: center;
+    font-family: arial, sans-serif;
+    margin: 0;
+  }
+
+  .rails-default-error-page div.dialog {
+    width: 95%;
+    max-width: 33em;
+    margin: 4em auto 0;
+  }
+
+  .rails-default-error-page div.dialog > div {
+    border: 1px solid #CCC;
+    border-right-color: #999;
+    border-left-color: #999;
+    border-bottom-color: #BBB;
+    border-top: #B00100 solid 4px;
+    border-top-left-radius: 9px;
+    border-top-right-radius: 9px;
+    background-color: white;
+    padding: 7px 12% 0;
+    box-shadow: 0 3px 8px rgba(50, 50, 50, 0.17);
+  }
+
+  .rails-default-error-page h1 {
+    font-size: 100%;
+    color: #730E15;
+    line-height: 1.5em;
+  }
+
+  .rails-default-error-page div.dialog > p {
+    margin: 0 0 1em;
+    padding: 1em;
+    background-color: #F7F7F7;
+    border: 1px solid #CCC;
+    border-right-color: #999;
+    border-left-color: #999;
+    border-bottom-color: #999;
+    border-bottom-left-radius: 4px;
+    border-bottom-right-radius: 4px;
+    border-top-color: #DADADA;
+    color: #666;
+    box-shadow: 0 3px 8px rgba(50, 50, 50, 0.17);
+  }
+  </style>
+</head>
+
+<body class="rails-default-error-page">
+  <!-- This file lives in public/500.html -->
+  <div class="dialog">
+    <div>
+      <h1>We're sorry, but something went wrong.</h1>
+    </div>
+    <p>If you are the application owner check the logs for more information.</p>
+  </div>
+</body>
+</html>
diff --git a/features/fixtures/delayed_job/app/public/apple-touch-icon-precomposed.png b/features/fixtures/delayed_job/app/public/apple-touch-icon-precomposed.png
new file mode 100644
index 000000000..e69de29bb
diff --git a/features/fixtures/delayed_job/app/public/apple-touch-icon.png b/features/fixtures/delayed_job/app/public/apple-touch-icon.png
new file mode 100644
index 000000000..e69de29bb
diff --git a/features/fixtures/delayed_job/app/public/favicon.ico b/features/fixtures/delayed_job/app/public/favicon.ico
new file mode 100644
index 000000000..e69de29bb
diff --git a/features/fixtures/delayed_job/app/public/robots.txt b/features/fixtures/delayed_job/app/public/robots.txt
new file mode 100644
index 000000000..3c9c7c01f
--- /dev/null
+++ b/features/fixtures/delayed_job/app/public/robots.txt
@@ -0,0 +1,5 @@
+# See http://www.robotstxt.org/robotstxt.html for documentation on how to use the robots.txt file
+#
+# To ban all spiders from the entire site uncomment the next two lines:
+# User-agent: *
+# Disallow: /
diff --git a/features/fixtures/delayed_job/app/test/controllers/.keep b/features/fixtures/delayed_job/app/test/controllers/.keep
new file mode 100644
index 000000000..e69de29bb
diff --git a/features/fixtures/delayed_job/app/test/fixtures/.keep b/features/fixtures/delayed_job/app/test/fixtures/.keep
new file mode 100644
index 000000000..e69de29bb
diff --git a/features/fixtures/delayed_job/app/test/fixtures/files/.keep b/features/fixtures/delayed_job/app/test/fixtures/files/.keep
new file mode 100644
index 000000000..e69de29bb
diff --git a/features/fixtures/delayed_job/app/test/fixtures/test_models.yml b/features/fixtures/delayed_job/app/test/fixtures/test_models.yml
new file mode 100644
index 000000000..80aed36e3
--- /dev/null
+++ b/features/fixtures/delayed_job/app/test/fixtures/test_models.yml
@@ -0,0 +1,11 @@
+# Read about fixtures at http://api.rubyonrails.org/classes/ActiveRecord/FixtureSet.html
+
+# This model initially had no columns defined. If you add columns to the
+# model remove the '{}' from the fixture names and add the columns immediately
+# below each fixture, per the syntax in the comments below
+#
+one: {}
+# column: value
+#
+two: {}
+# column: value
diff --git a/features/fixtures/delayed_job/app/test/helpers/.keep b/features/fixtures/delayed_job/app/test/helpers/.keep
new file mode 100644
index 000000000..e69de29bb
diff --git a/features/fixtures/delayed_job/app/test/integration/.keep b/features/fixtures/delayed_job/app/test/integration/.keep
new file mode 100644
index 000000000..e69de29bb
diff --git a/features/fixtures/delayed_job/app/test/mailers/.keep b/features/fixtures/delayed_job/app/test/mailers/.keep
new file mode 100644
index 000000000..e69de29bb
diff --git a/features/fixtures/delayed_job/app/test/models/.keep b/features/fixtures/delayed_job/app/test/models/.keep
new file mode 100644
index 000000000..e69de29bb
diff --git a/features/fixtures/delayed_job/app/test/models/test_model_test.rb b/features/fixtures/delayed_job/app/test/models/test_model_test.rb
new file mode 100644
index 000000000..c2d2c2b6b
--- /dev/null
+++ b/features/fixtures/delayed_job/app/test/models/test_model_test.rb
@@ -0,0 +1,7 @@
+require 'test_helper'
+
+class TestModelTest < ActiveSupport::TestCase
+  # test "the truth" do
+  #   assert true
+  # end
+end
diff --git a/features/fixtures/delayed_job/app/test/test_helper.rb b/features/fixtures/delayed_job/app/test/test_helper.rb
new file mode 100644
index 000000000..92e39b2d7
--- /dev/null
+++ b/features/fixtures/delayed_job/app/test/test_helper.rb
@@ -0,0 +1,10 @@
+ENV['RAILS_ENV'] ||= 'test'
+require File.expand_path('../../config/environment', __FILE__)
+require 'rails/test_help'
+
+class ActiveSupport::TestCase
+  # Setup all fixtures in test/fixtures/*.yml for all tests in alphabetical order.
+  fixtures :all
+
+  # Add more helper methods to be used by all tests here...
+end
diff --git a/features/fixtures/delayed_job/app/tmp/.keep b/features/fixtures/delayed_job/app/tmp/.keep
new file mode 100644
index 000000000..e69de29bb
diff --git a/lib/bugsnag/integrations/delayed_job.rb b/lib/bugsnag/integrations/delayed_job.rb
index e840f4df1..5cb6e919d 100644
--- a/lib/bugsnag/integrations/delayed_job.rb
+++ b/lib/bugsnag/integrations/delayed_job.rb
@@ -5,35 +5,37 @@
   raise LoadError, "bugsnag requires delayed_job > 3.x"
 end
 
-unless defined? Delayed::Plugins::Bugsnag
-  module Delayed
-    module Plugins
-      class Bugsnag < Plugin
-
-        FRAMEWORK_ATTRIBUTES = {
-          :framework => "DelayedJob"
-        }
-
-        module Notify
-          def error(job, error)
+module Delayed
+  module Plugins
+    class Bugsnag <  ::Delayed::Plugin
+      callbacks do |lifecycle|
+        lifecycle.around(:invoke_job) do |job, *args, &block|
+          begin
+            block.call(job, *args)
+          rescue Exception => exception
             overrides = {
               :job => {
                 :class => job.class.name,
                 :id => job.id,
               },
-              :severity_reason => {
-                :type => ::Bugsnag::Report::UNHANDLED_EXCEPTION_MIDDLEWARE,
-                :attributes => FRAMEWORK_ATTRIBUTES,
-              },
             }
-            if job.respond_to?(:queue) && (queue = job.queue)
-              overrides[:job][:queue] = queue
+            overrides[:job][:priority] = job.priority if job.respond_to?(:priority)
+            overrides[:job][:run_at] = job.run_at if job.respond_to?(:run_at)
+            overrides[:job][:locked_at] = job.locked_at if job.respond_to?(:locked_at)
+            overrides[:job][:locked_by] = job.locked_by if job.respond_to?(:locked_by)
+            overrides[:job][:created_at] = job.created_at if job.respond_to?(:created_at)
+            overrides[:job][:queue] = job.queue if job.respond_to?(:queue)
+
+            if job.respond_to?('payload_object') && job.payload_object.respond_to?('job_data')
+              overrides[:job][:active_job] = job.payload_object.job_data
             end
+
             if job.respond_to?(:attempts)
               max_attempts = (job.respond_to?(:max_attempts) && job.max_attempts) || Delayed::Worker.max_attempts
               overrides[:job][:attempts] = "#{job.attempts + 1} / #{max_attempts}"
               # +1 as "attempts" is zero-based and does not include the current failed attempt
             end
+
             if payload = job.payload_object
               p = {
                 :class => payload.class.name,
@@ -54,43 +56,35 @@ def error(job, error)
                 }
                 p[:object][:id] = object.id if object.respond_to?(:id)
               end
-              add_active_job_details(p, payload)
+              if payload.respond_to?(:job_data) && payload.job_data.respond_to?(:[])
+                [:job_class, :arguments, :queue_name, :job_id].each do |key|
+                  if (value = payload.job_data[key.to_s])
+                    p[key] = value
+                  end
+                end
+              end
               overrides[:job][:payload] = p
             end
 
-            ::Bugsnag.notify(error, true) do |report|
+            ::Bugsnag.notify(exception, true) do |report|
               report.severity = "error"
               report.severity_reason = {
                 :type => ::Bugsnag::Report::UNHANDLED_EXCEPTION_MIDDLEWARE,
-                :attributes => FRAMEWORK_ATTRIBUTES
+                :attributes => {
+                  :framework => "DelayedJob"
+                }
               }
               report.meta_data.merge! overrides
             end
 
-            super if defined?(super)
-          end
-
-          def add_active_job_details(p, payload)
-            if payload.respond_to?(:job_data) && payload.job_data.respond_to?(:[])
-              [:job_class, :arguments, :queue_name, :job_id].each do |key|
-                if (value = payload.job_data[key.to_s])
-                  p[key] = value
-                end
-              end
-            end
-          end
-        end
-
-        callbacks do |lifecycle|
-          lifecycle.before(:invoke_job) do |job|
-            payload = job.payload_object
-            payload = payload.object if payload.is_a? Delayed::PerformableMethod
-            payload.extend Notify
+            raise
+          ensure
+            ::Bugsnag.configuration.clear_request_data
           end
         end
       end
     end
   end
-
-  Delayed::Worker.plugins << Delayed::Plugins::Bugsnag
 end
+
+Delayed::Worker.plugins << Delayed::Plugins::Bugsnag

From d425caa79e2bc3fdbb696bc0c13ea3e43e9e9d07 Mon Sep 17 00:00:00 2001
From: Simon Maynard <snmaynard@gmail.com>
Date: Thu, 25 Oct 2018 18:33:06 -0700
Subject: [PATCH 07/19] Wip maze tests

---
 features/delayed_job.feature                |  27 +++++
 features/fixtures/delayed_job/.dockerignore |   1 -
 features/fixtures/delayed_job/Dockerfile    |   2 +-
 features/fixtures/delayed_job/app/Gemfile   |   3 +-
 features/fixtures/docker-compose.yml        |   4 +-
 lib/bugsnag/integrations/delayed_job.rb     |   1 +
 spec/integrations/delayed_job_spec.rb       | 118 --------------------
 7 files changed, 32 insertions(+), 124 deletions(-)
 create mode 100644 features/delayed_job.feature
 delete mode 100644 features/fixtures/delayed_job/.dockerignore
 delete mode 100644 spec/integrations/delayed_job_spec.rb

diff --git a/features/delayed_job.feature b/features/delayed_job.feature
new file mode 100644
index 000000000..bf7d3394d
--- /dev/null
+++ b/features/delayed_job.feature
@@ -0,0 +1,27 @@
+Feature: Bugsnag detects errors in Delayed job workers
+
+Background:
+  Given I set environment variable "BUGSNAG_API_KEY" to "a35a2a72bd230ac0aa0f52715bbdc6aa"
+  Given I set environment variable "MAZE_API_KEY" to "a35a2a72bd230ac0aa0f52715bbdc6aa"
+  And I configure the bugsnag endpoint
+
+Scenario: An unhandled RuntimeError sends a report
+  And I set environment variable "RUBY_VERSION" to "2.5"
+  And I start the service "delayed_job"
+  And I run the command "bundle exec rails runner 'TestModel.delay.fail'" on the service "delayed_job"
+  And I wait for 1 seconds
+  Then I should receive a request
+  And the request used the Ruby notifier
+  And the request used payload v4 headers
+  And the request contained the api key "a35a2a72bd230ac0aa0f52715bbdc6aa"
+  And the event "unhandled" is true
+  And the event "severity" is "error"
+  And the event "context" is null
+  And the event "severityReason.type" is "unhandledExceptionMiddleware"
+  And the event "severityReason.attributes.framework" is "delayed_job"
+  And the exception "errorClass" equals "RuntimeError"
+  And the "file" of stack frame 0 equals "/usr/src/app.rb"
+  And the "lineNumber" of stack frame 0 equals 33
+  And the payload field "events.0.metaData.sidekiq" matches the JSON fixture in "features/fixtures/sidekiq/payloads/unhandled_metadata_ca_<created_at_present>.json"
+  And the event "metaData.sidekiq.msg.created_at" is a parsable timestamp in seconds
+  And the event "metaData.sidekiq.msg.enqueued_at" is a parsable timestamp in seconds
\ No newline at end of file
diff --git a/features/fixtures/delayed_job/.dockerignore b/features/fixtures/delayed_job/.dockerignore
deleted file mode 100644
index b844b143d..000000000
--- a/features/fixtures/delayed_job/.dockerignore
+++ /dev/null
@@ -1 +0,0 @@
-Gemfile.lock
diff --git a/features/fixtures/delayed_job/Dockerfile b/features/fixtures/delayed_job/Dockerfile
index 878a1fb53..c47e364ca 100644
--- a/features/fixtures/delayed_job/Dockerfile
+++ b/features/fixtures/delayed_job/Dockerfile
@@ -12,4 +12,4 @@ COPY app/ /usr/src/app
 RUN bundle exec rails generate delayed_job:active_record
 RUN bundle exec rake db:migrate
 
-CMD ["bundle", "exec", "rails", "s", "-b", "0.0.0.0"]
+CMD ["bundle", "exec", "rake", "jobs:work"]
diff --git a/features/fixtures/delayed_job/app/Gemfile b/features/fixtures/delayed_job/app/Gemfile
index 0f90e8e66..40cc3ac3c 100644
--- a/features/fixtures/delayed_job/app/Gemfile
+++ b/features/fixtures/delayed_job/app/Gemfile
@@ -5,9 +5,10 @@ git_source(:github) do |repo_name|
   "https://github.com/#{repo_name}.git"
 end
 
-gem 'bugsnag', path: '../../../../'
+gem 'bugsnag'#, path: '../../../../'
 gem 'delayed_job'
 gem 'delayed_job_active_record'
+gem 'therubyracer'
 
 # Bundle edge Rails instead: gem 'rails', github: 'rails/rails'
 gem 'rails', '~> 5.0.7'
diff --git a/features/fixtures/docker-compose.yml b/features/fixtures/docker-compose.yml
index 0f56b30ea..a2118dada 100644
--- a/features/fixtures/docker-compose.yml
+++ b/features/fixtures/docker-compose.yml
@@ -41,9 +41,7 @@ services:
     build:
       context: delayed_job
       args:
-        ruby_version: 2.0
-    depends_on:
-      - redis
+        ruby_version: 2.5
     environment:
       - endpoint
     restart: "no"
diff --git a/lib/bugsnag/integrations/delayed_job.rb b/lib/bugsnag/integrations/delayed_job.rb
index 5cb6e919d..e1f1899ce 100644
--- a/lib/bugsnag/integrations/delayed_job.rb
+++ b/lib/bugsnag/integrations/delayed_job.rb
@@ -11,6 +11,7 @@ class Bugsnag <  ::Delayed::Plugin
       callbacks do |lifecycle|
         lifecycle.around(:invoke_job) do |job, *args, &block|
           begin
+            Bugsnag.configuration.app_type = 'delayed_job'
             block.call(job, *args)
           rescue Exception => exception
             overrides = {
diff --git a/spec/integrations/delayed_job_spec.rb b/spec/integrations/delayed_job_spec.rb
deleted file mode 100644
index 7c9b6435d..000000000
--- a/spec/integrations/delayed_job_spec.rb
+++ /dev/null
@@ -1,118 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-RSpec.describe ::Delayed::Plugins::Bugsnag do
-  describe '#error' do
-    it 'should set metadata correctly with max_attempts' do
-      payload = Object.new
-      payload.extend(described_class::Notify)
-      job = double
-      allow(job).to receive_messages(
-        :id => "TEST",
-        :queue => "TEST_QUEUE",
-        :attempts => 0,
-        :max_attempts => 3,
-        :payload_object => {
-          :id => "PAYLOAD_ID",
-          :display_name => "PAYLOAD_DISPLAY_NAME",
-          :method_name => "PAYLOAD_METHOD_NAME",
-          :args => [
-            "SOME",
-            "TEST",
-            "ARGS"
-          ]
-        }
-      )
-
-      expect do
-        payload.error(job, '')
-      end.not_to raise_error
-
-      expect(Bugsnag).to have_sent_notification{ |payload, headers|
-        event = get_event_from_payload(payload)
-        expect(event["severity"]).to eq("error")
-        expect(event["severityReason"]).to eq({
-          "type" => "unhandledExceptionMiddleware",
-          "attributes" => {
-            "framework" => "DelayedJob"
-          }
-        })
-        expect(event["metaData"]["job"]).to eq({
-          "class" => job.class.name,
-          "id" => "TEST",
-          "queue" => "TEST_QUEUE",
-          "attempts" => "1 / 3",
-          "payload" => {
-            "class" => {}.class.name,
-            "args" => {
-              "id" => "PAYLOAD_ID",
-              "display_name" => "PAYLOAD_DISPLAY_NAME",
-              "method_name" => "PAYLOAD_METHOD_NAME",
-              "args" => [
-                "SOME",
-                "TEST",
-                "ARGS"
-              ]
-            }
-          }
-        })
-      }
-    end
-
-    it 'should set metadata correctly without max_attempts' do
-      payload = Object.new
-      payload.extend(described_class::Notify)
-      job = double
-      allow(job).to receive_messages(
-        :id => "TEST",
-        :queue => "TEST_QUEUE",
-        :attempts => 0,
-        :payload_object => {
-          :id => "PAYLOAD_ID",
-          :display_name => "PAYLOAD_DISPLAY_NAME",
-          :method_name => "PAYLOAD_METHOD_NAME",
-          :args => [
-            "SOME",
-            "TEST",
-            "ARGS"
-          ]
-        }
-      )
-
-      expect do
-        payload.error(job, '')
-      end.not_to raise_error
-
-      expect(Bugsnag).to have_sent_notification{ |payload, headers|
-        event = get_event_from_payload(payload)
-        expect(event["severity"]).to eq("error")
-        expect(event["severityReason"]).to eq({
-          "type" => "unhandledExceptionMiddleware",
-          "attributes" => {
-            "framework" => "DelayedJob"
-          }
-        })
-        expect(event["metaData"]["job"]).to eq({
-          "class" => job.class.name,
-          "id" => "TEST",
-          "queue" => "TEST_QUEUE",
-          "attempts" => "1 / #{Delayed::Worker.max_attempts}",
-          "payload" => {
-            "class" => {}.class.name,
-            "args" => {
-              "id" => "PAYLOAD_ID",
-              "display_name" => "PAYLOAD_DISPLAY_NAME",
-              "method_name" => "PAYLOAD_METHOD_NAME",
-              "args" => [
-                "SOME",
-                "TEST",
-                "ARGS"
-              ]
-            }
-          }
-        })
-      }
-    end
-  end
-end

From aa2d65d11777606115aca9c8d63ef7b7b22e6815 Mon Sep 17 00:00:00 2001
From: Alex Moinet <alex@bugsnag.com>
Date: Fri, 2 Nov 2018 11:25:45 +0000
Subject: [PATCH 08/19] DelayedJob Rewrite: Initial middleware move

---
 lib/bugsnag.rb                          |  1 +
 lib/bugsnag/integrations/delayed_job.rb | 57 +---------------------
 lib/bugsnag/middleware/delayed_job.rb   | 64 +++++++++++++++++++++++++
 3 files changed, 67 insertions(+), 55 deletions(-)
 create mode 100644 lib/bugsnag/middleware/delayed_job.rb

diff --git a/lib/bugsnag.rb b/lib/bugsnag.rb
index 00985b9eb..e217ec161 100644
--- a/lib/bugsnag.rb
+++ b/lib/bugsnag.rb
@@ -27,6 +27,7 @@
 require "bugsnag/middleware/rake"
 require "bugsnag/middleware/callbacks"
 require "bugsnag/middleware/classify_error"
+require "bugsnag/middleware/delayed_job"
 
 module Bugsnag
   LOCK = Mutex.new
diff --git a/lib/bugsnag/integrations/delayed_job.rb b/lib/bugsnag/integrations/delayed_job.rb
index e1f1899ce..b9566ea6f 100644
--- a/lib/bugsnag/integrations/delayed_job.rb
+++ b/lib/bugsnag/integrations/delayed_job.rb
@@ -12,61 +12,9 @@ class Bugsnag <  ::Delayed::Plugin
         lifecycle.around(:invoke_job) do |job, *args, &block|
           begin
             Bugsnag.configuration.app_type = 'delayed_job'
+            Bugsnag.configuration.set_request_data(:delayed_job, job)
             block.call(job, *args)
           rescue Exception => exception
-            overrides = {
-              :job => {
-                :class => job.class.name,
-                :id => job.id,
-              },
-            }
-            overrides[:job][:priority] = job.priority if job.respond_to?(:priority)
-            overrides[:job][:run_at] = job.run_at if job.respond_to?(:run_at)
-            overrides[:job][:locked_at] = job.locked_at if job.respond_to?(:locked_at)
-            overrides[:job][:locked_by] = job.locked_by if job.respond_to?(:locked_by)
-            overrides[:job][:created_at] = job.created_at if job.respond_to?(:created_at)
-            overrides[:job][:queue] = job.queue if job.respond_to?(:queue)
-
-            if job.respond_to?('payload_object') && job.payload_object.respond_to?('job_data')
-              overrides[:job][:active_job] = job.payload_object.job_data
-            end
-
-            if job.respond_to?(:attempts)
-              max_attempts = (job.respond_to?(:max_attempts) && job.max_attempts) || Delayed::Worker.max_attempts
-              overrides[:job][:attempts] = "#{job.attempts + 1} / #{max_attempts}"
-              # +1 as "attempts" is zero-based and does not include the current failed attempt
-            end
-
-            if payload = job.payload_object
-              p = {
-                :class => payload.class.name,
-              }
-              p[:id]           = payload.id           if payload.respond_to?(:id)
-              p[:display_name] = payload.display_name if payload.respond_to?(:display_name)
-              p[:method_name]  = payload.method_name  if payload.respond_to?(:method_name)
-
-              if payload.respond_to?(:args)
-                p[:args] = payload.args
-              elsif payload.respond_to?(:to_h)
-                p[:args] = payload.to_h
-              end
-
-              if payload.is_a?(::Delayed::PerformableMethod) && (object = payload.object)
-                p[:object] = {
-                  :class => object.class.name,
-                }
-                p[:object][:id] = object.id if object.respond_to?(:id)
-              end
-              if payload.respond_to?(:job_data) && payload.job_data.respond_to?(:[])
-                [:job_class, :arguments, :queue_name, :job_id].each do |key|
-                  if (value = payload.job_data[key.to_s])
-                    p[key] = value
-                  end
-                end
-              end
-              overrides[:job][:payload] = p
-            end
-
             ::Bugsnag.notify(exception, true) do |report|
               report.severity = "error"
               report.severity_reason = {
@@ -75,9 +23,7 @@ class Bugsnag <  ::Delayed::Plugin
                   :framework => "DelayedJob"
                 }
               }
-              report.meta_data.merge! overrides
             end
-
             raise
           ensure
             ::Bugsnag.configuration.clear_request_data
@@ -88,4 +34,5 @@ class Bugsnag <  ::Delayed::Plugin
   end
 end
 
+Bugsnag.configuration.internal_middleware.use(Bugsnag::Middleware::DelayedJob)
 Delayed::Worker.plugins << Delayed::Plugins::Bugsnag
diff --git a/lib/bugsnag/middleware/delayed_job.rb b/lib/bugsnag/middleware/delayed_job.rb
new file mode 100644
index 000000000..2ebe3e592
--- /dev/null
+++ b/lib/bugsnag/middleware/delayed_job.rb
@@ -0,0 +1,64 @@
+module Bugsnag::Middleware
+  ##
+  # Attaches delayed_job information to an error report
+  class DelayedJob
+    def initialize(bugsnag)
+      @bugsnag = bugsnag
+    end
+
+    def call(report)
+      job = report.request_data[:delayed_job]
+      if job
+        job_data = {}
+        job_data[:priority] = job.priority if job.respond_to?(:priority)
+        job_data[:run_at] = job.run_at if job.respond_to?(:run_at)
+        job_data[:locked_at] = job.locked_at if job.respond_to?(:locked_at)
+        job_data[:locked_by] = job.locked_by if job.respond_to?(:locked_by)
+        job_data[:created_at] = job.created_at if job.respond_to?(:created_at)
+        job_data[:queue] = job.queue if job.respond_to?(:queue)
+
+        if job.respond_to?('payload_object') && job.payload_object.respond_to?('job_data')
+          job_data[:active_job] = job.payload_object.job_data
+        end
+
+        if job.respond_to?(:attempts)
+          max_attempts = (job.respond_to?(:max_attempts) && job.max_attempts) || Delayed::Worker.max_attempts
+          job_data[:attempts] = "#{job.attempts + 1} / #{max_attempts}"
+          # +1 as "attempts" is zero-based and does not include the current failed attempt
+        end
+
+        if payload = job.payload_object
+          p = {
+            :class => payload.class.name,
+          }
+          p[:id]           = payload.id           if payload.respond_to?(:id)
+          p[:display_name] = payload.display_name if payload.respond_to?(:display_name)
+          p[:method_name]  = payload.method_name  if payload.respond_to?(:method_name)
+
+          if payload.respond_to?(:args)
+            p[:args] = payload.args
+          elsif payload.respond_to?(:to_h)
+            p[:args] = payload.to_h
+          end
+
+          if payload.is_a?(::Delayed::PerformableMethod) && (object = payload.object)
+            p[:object] = {
+              :class => object.class.name,
+            }
+            p[:object][:id] = object.id if object.respond_to?(:id)
+          end
+          if payload.respond_to?(:job_data) && payload.job_data.respond_to?(:[])
+            [:job_class, :arguments, :queue_name, :job_id].each do |key|
+              if (value = payload.job_data[key.to_s])
+                p[key] = value
+              end
+            end
+          end
+          job_data[:payload] = p
+        end
+        report.add_tab(:delayed_job, job_data)
+      end
+      @bugsnag.call(report)
+    end
+  end
+end

From 402666d683e0f9be0fa9892ab90efa81551d2a69 Mon Sep 17 00:00:00 2001
From: Alex Moinet <alex@bugsnag.com>
Date: Fri, 2 Nov 2018 14:57:49 +0000
Subject: [PATCH 09/19] DelayedJob Rewrite: Ensure original metaData is present
 in the same place

---
 lib/bugsnag/integrations/delayed_job.rb | 6 +++---
 lib/bugsnag/middleware/delayed_job.rb   | 7 +++++--
 2 files changed, 8 insertions(+), 5 deletions(-)

diff --git a/lib/bugsnag/integrations/delayed_job.rb b/lib/bugsnag/integrations/delayed_job.rb
index b9566ea6f..3595765d3 100644
--- a/lib/bugsnag/integrations/delayed_job.rb
+++ b/lib/bugsnag/integrations/delayed_job.rb
@@ -11,8 +11,9 @@ class Bugsnag <  ::Delayed::Plugin
       callbacks do |lifecycle|
         lifecycle.around(:invoke_job) do |job, *args, &block|
           begin
-            Bugsnag.configuration.app_type = 'delayed_job'
-            Bugsnag.configuration.set_request_data(:delayed_job, job)
+            ::Bugsnag.configuration.app_type = 'delayed_job'
+            ::Bugsnag.configuration.set_request_data(:delayed_job, job)
+            ::Bugsnag.configuration.internal_middleware.use(::Bugsnag::Middleware::DelayedJob)
             block.call(job, *args)
           rescue Exception => exception
             ::Bugsnag.notify(exception, true) do |report|
@@ -34,5 +35,4 @@ class Bugsnag <  ::Delayed::Plugin
   end
 end
 
-Bugsnag.configuration.internal_middleware.use(Bugsnag::Middleware::DelayedJob)
 Delayed::Worker.plugins << Delayed::Plugins::Bugsnag
diff --git a/lib/bugsnag/middleware/delayed_job.rb b/lib/bugsnag/middleware/delayed_job.rb
index 2ebe3e592..73da7a064 100644
--- a/lib/bugsnag/middleware/delayed_job.rb
+++ b/lib/bugsnag/middleware/delayed_job.rb
@@ -9,7 +9,10 @@ def initialize(bugsnag)
     def call(report)
       job = report.request_data[:delayed_job]
       if job
-        job_data = {}
+        job_data = {
+          :class => job.class.name,
+          :id => job.id
+        }
         job_data[:priority] = job.priority if job.respond_to?(:priority)
         job_data[:run_at] = job.run_at if job.respond_to?(:run_at)
         job_data[:locked_at] = job.locked_at if job.respond_to?(:locked_at)
@@ -56,7 +59,7 @@ def call(report)
           end
           job_data[:payload] = p
         end
-        report.add_tab(:delayed_job, job_data)
+        report.add_tab(:job, job_data)
       end
       @bugsnag.call(report)
     end

From 48b25384c2c7f44babc52d10a7464f59dda4d1fa Mon Sep 17 00:00:00 2001
From: Alex Moinet <alex@bugsnag.com>
Date: Fri, 2 Nov 2018 15:42:08 +0000
Subject: [PATCH 10/19] DelayedJob rewrite: Small refactor to fix rubocop

---
 lib/bugsnag/integrations/delayed_job.rb |  2 +-
 lib/bugsnag/middleware/delayed_job.rb   | 60 +++++++++++++------------
 2 files changed, 32 insertions(+), 30 deletions(-)

diff --git a/lib/bugsnag/integrations/delayed_job.rb b/lib/bugsnag/integrations/delayed_job.rb
index 3595765d3..7445a47ee 100644
--- a/lib/bugsnag/integrations/delayed_job.rb
+++ b/lib/bugsnag/integrations/delayed_job.rb
@@ -7,7 +7,7 @@
 
 module Delayed
   module Plugins
-    class Bugsnag <  ::Delayed::Plugin
+    class Bugsnag < ::Delayed::Plugin
       callbacks do |lifecycle|
         lifecycle.around(:invoke_job) do |job, *args, &block|
           begin
diff --git a/lib/bugsnag/middleware/delayed_job.rb b/lib/bugsnag/middleware/delayed_job.rb
index 73da7a064..88278e6dc 100644
--- a/lib/bugsnag/middleware/delayed_job.rb
+++ b/lib/bugsnag/middleware/delayed_job.rb
@@ -20,8 +20,9 @@ def call(report)
         job_data[:created_at] = job.created_at if job.respond_to?(:created_at)
         job_data[:queue] = job.queue if job.respond_to?(:queue)
 
-        if job.respond_to?('payload_object') && job.payload_object.respond_to?('job_data')
-          job_data[:active_job] = job.payload_object.job_data
+        if job.respond_to?('payload_object')
+          job_data[:active_job] = job.payload_object.job_data if job.payload_object.respond_to?('job_data')
+          job_data[:payload] = construct_job_payload(job.payload_object)
         end
 
         if job.respond_to?(:attempts)
@@ -30,38 +31,39 @@ def call(report)
           # +1 as "attempts" is zero-based and does not include the current failed attempt
         end
 
-        if payload = job.payload_object
-          p = {
-            :class => payload.class.name,
-          }
-          p[:id]           = payload.id           if payload.respond_to?(:id)
-          p[:display_name] = payload.display_name if payload.respond_to?(:display_name)
-          p[:method_name]  = payload.method_name  if payload.respond_to?(:method_name)
+        report.add_tab(:job, job_data)
+      end
+      @bugsnag.call(report)
+    end
 
-          if payload.respond_to?(:args)
-            p[:args] = payload.args
-          elsif payload.respond_to?(:to_h)
-            p[:args] = payload.to_h
-          end
+    def construct_job_payload(payload)
+      data = {
+        :class => payload.class.name
+      }
+      data[:id]           = payload.id           if payload.respond_to?(:id)
+      data[:display_name] = payload.display_name if payload.respond_to?(:display_name)
+      data[:method_name]  = payload.method_name  if payload.respond_to?(:method_name)
 
-          if payload.is_a?(::Delayed::PerformableMethod) && (object = payload.object)
-            p[:object] = {
-              :class => object.class.name,
-            }
-            p[:object][:id] = object.id if object.respond_to?(:id)
-          end
-          if payload.respond_to?(:job_data) && payload.job_data.respond_to?(:[])
-            [:job_class, :arguments, :queue_name, :job_id].each do |key|
-              if (value = payload.job_data[key.to_s])
-                p[key] = value
-              end
-            end
+      if payload.respond_to?(:args)
+        data[:args] = payload.args
+      elsif payload.respond_to?(:to_h)
+        data[:args] = payload.to_h
+      end
+
+      if payload.is_a?(::Delayed::PerformableMethod) && (object = payload.object)
+        data[:object] = {
+          :class => object.class.name
+        }
+        data[:object][:id] = object.id if object.respond_to?(:id)
+      end
+      if payload.respond_to?(:job_data) && payload.job_data.respond_to?(:[])
+        [:job_class, :arguments, :queue_name, :job_id].each do |key|
+          if (value = payload.job_data[key.to_s])
+            data[key] = value
           end
-          job_data[:payload] = p
         end
-        report.add_tab(:job, job_data)
       end
-      @bugsnag.call(report)
+      data
     end
   end
 end

From 513d63c12cc5410cb5e33351d93ab4f64c151e65 Mon Sep 17 00:00:00 2001
From: Alex Moinet <alex@bugsnag.com>
Date: Fri, 2 Nov 2018 16:25:37 +0000
Subject: [PATCH 11/19] DelayedJob rewrite: Fix maze issues.  Added exception
 for Lint/RescueException for delayed_job integration

---
 .rubocop_todo.yml                       | 1 +
 lib/bugsnag/integrations/delayed_job.rb | 2 +-
 2 files changed, 2 insertions(+), 1 deletion(-)

diff --git a/.rubocop_todo.yml b/.rubocop_todo.yml
index 2800bab80..253813a5c 100644
--- a/.rubocop_todo.yml
+++ b/.rubocop_todo.yml
@@ -244,6 +244,7 @@ Lint/RescueException:
     - 'lib/bugsnag/integrations/rake.rb'
     - 'lib/bugsnag/integrations/shoryuken.rb'
     - 'lib/bugsnag/integrations/sidekiq.rb'
+    - 'lib/bugsnag/integrations/delayed_job.rb'
 
 # Offense count: 6
 # Cop supports --auto-correct.
diff --git a/lib/bugsnag/integrations/delayed_job.rb b/lib/bugsnag/integrations/delayed_job.rb
index 7445a47ee..4b6893dea 100644
--- a/lib/bugsnag/integrations/delayed_job.rb
+++ b/lib/bugsnag/integrations/delayed_job.rb
@@ -25,7 +25,7 @@ class Bugsnag < ::Delayed::Plugin
                 }
               }
             end
-            raise
+            raise exception
           ensure
             ::Bugsnag.configuration.clear_request_data
           end

From 9ddae204583ff82951460398f254bf4176a3c0e3 Mon Sep 17 00:00:00 2001
From: Alex Moinet <alex@bugsnag.com>
Date: Tue, 6 Nov 2018 16:19:18 +0000
Subject: [PATCH 12/19] DelayedJob rewrite: Ensure middleware only added once

---
 lib/bugsnag/integrations/delayed_job.rb | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/lib/bugsnag/integrations/delayed_job.rb b/lib/bugsnag/integrations/delayed_job.rb
index 4b6893dea..16b232ea7 100644
--- a/lib/bugsnag/integrations/delayed_job.rb
+++ b/lib/bugsnag/integrations/delayed_job.rb
@@ -5,6 +5,8 @@
   raise LoadError, "bugsnag requires delayed_job > 3.x"
 end
 
+::Bugsnag.configuration.internal_middleware.use(::Bugsnag::Middleware::DelayedJob)
+
 module Delayed
   module Plugins
     class Bugsnag < ::Delayed::Plugin
@@ -13,7 +15,6 @@ class Bugsnag < ::Delayed::Plugin
           begin
             ::Bugsnag.configuration.app_type = 'delayed_job'
             ::Bugsnag.configuration.set_request_data(:delayed_job, job)
-            ::Bugsnag.configuration.internal_middleware.use(::Bugsnag::Middleware::DelayedJob)
             block.call(job, *args)
           rescue Exception => exception
             ::Bugsnag.notify(exception, true) do |report|

From 295526e68b6d5916adeba11de9e2bec9f116627d Mon Sep 17 00:00:00 2001
From: Alex Moinet <alex@bugsnag.com>
Date: Wed, 7 Nov 2018 14:00:22 +0000
Subject: [PATCH 13/19] DelayedJob Rewrite: Style concerns

---
 lib/bugsnag/middleware/delayed_job.rb | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/lib/bugsnag/middleware/delayed_job.rb b/lib/bugsnag/middleware/delayed_job.rb
index b83765833..50cd2492a 100644
--- a/lib/bugsnag/middleware/delayed_job.rb
+++ b/lib/bugsnag/middleware/delayed_job.rb
@@ -20,8 +20,8 @@ def call(report)
         job_data[:created_at] = job.created_at if job.respond_to?(:created_at)
         job_data[:queue] = job.queue if job.respond_to?(:queue)
 
-        if job.respond_to?('payload_object')
-          job_data[:active_job] = job.payload_object.job_data if job.payload_object.respond_to?('job_data')
+        if job.respond_to?(:payload_object)
+          job_data[:active_job] = job.payload_object.job_data if job.payload_object.respond_to?(:job_data)
           job_data[:payload] = construct_job_payload(job.payload_object)
         end
 

From d2fe2a936fe6539f3d8e9eb7436d88b50f037d70 Mon Sep 17 00:00:00 2001
From: Alex Moinet <alex@bugsnag.com>
Date: Wed, 7 Nov 2018 16:45:06 +0000
Subject: [PATCH 14/19] DelayedJob rewrite: Ensure context is set when payload
 is present

---
 features/delayed_job.feature                        | 13 ++++++++++---
 .../delayed_job/app/app/models/test_model.rb        |  2 +-
 lib/bugsnag/middleware/delayed_job.rb               |  4 +++-
 3 files changed, 14 insertions(+), 5 deletions(-)

diff --git a/features/delayed_job.feature b/features/delayed_job.feature
index db6357fed..4b3379d42 100644
--- a/features/delayed_job.feature
+++ b/features/delayed_job.feature
@@ -16,7 +16,7 @@ Scenario: An unhandled RuntimeError sends a report with arguments
   And the request contained the api key "a35a2a72bd230ac0aa0f52715bbdc6aa"
   And the event "unhandled" is true
   And the event "severity" is "error"
-  And the event "context" is "jobs:work"
+  And the event "context" is "fail_with_args"
   And the event "severityReason.type" is "unhandledExceptionMiddleware"
   And the event "severityReason.attributes.framework" is "DelayedJob"
   And the exception "errorClass" equals "RuntimeError"
@@ -31,7 +31,7 @@ Scenario: An unhandled RuntimeError sends a report with arguments
 Scenario: A handled exception sends a report
   Given I set environment variable "RUBY_VERSION" to "2.5"
   And I start the service "delayed_job"
-  And I run the command "bundle exec rails runner 'TestModel.delay.notify'" on the service "delayed_job"
+  And I run the command "bundle exec rails runner 'TestModel.delay.notify_with_args(\"Test\")'" on the service "delayed_job"
   And I wait for 5 seconds
   Then I should receive a request
   And the request used the Ruby notifier
@@ -39,6 +39,13 @@ Scenario: A handled exception sends a report
   And the request contained the api key "a35a2a72bd230ac0aa0f52715bbdc6aa"
   And the event "unhandled" is false
   And the event "severity" is "warning"
-  And the event "context" is "jobs:work"
+  And the event "context" is "notify_with_args"
   And the event "severityReason.type" is "handledException"
   And the exception "errorClass" equals "RuntimeError"
+  And the event "metaData.job.class" equals "Delayed::Backend::ActiveRecord::Job"
+  And the event "metaData.job.id" is not null
+  And the event "metaData.job.attempts" equals "1 / 1"
+  And the event "metaData.job.payload.display_name" equals "TestModel.notify_with_args"
+  And the event "metaData.job.payload.method_name" equals "notify_with_args"
+  And the payload field "events.0.metaData.job.payload.args" is an array with 1 element
+  And the payload field "events.0.metaData.job.payload.args.0" equals "Test"
diff --git a/features/fixtures/delayed_job/app/app/models/test_model.rb b/features/fixtures/delayed_job/app/app/models/test_model.rb
index b5c675c27..8eef9f181 100644
--- a/features/fixtures/delayed_job/app/app/models/test_model.rb
+++ b/features/fixtures/delayed_job/app/app/models/test_model.rb
@@ -4,7 +4,7 @@ def self.fail_with_args(a)
     raise "uh oh"
   end
 
-  def self.notify
+  def self.notify_with_args(a)
     Bugsnag.notify(RuntimeError.new("Handled exception"))
   end
 end
diff --git a/lib/bugsnag/middleware/delayed_job.rb b/lib/bugsnag/middleware/delayed_job.rb
index 50cd2492a..c6279eb1a 100644
--- a/lib/bugsnag/middleware/delayed_job.rb
+++ b/lib/bugsnag/middleware/delayed_job.rb
@@ -22,7 +22,9 @@ def call(report)
 
         if job.respond_to?(:payload_object)
           job_data[:active_job] = job.payload_object.job_data if job.payload_object.respond_to?(:job_data)
-          job_data[:payload] = construct_job_payload(job.payload_object)
+          payload_data = construct_job_payload(job.payload_object)
+          report.context = payload_data[:method_name] if payload_data.include?(:method_name)
+          job_data[:payload] = payload_data
         end
 
         if job.respond_to?(:attempts)

From 676db89afc086e0e04c0bf63ee2c602673b5ff69 Mon Sep 17 00:00:00 2001
From: Alex Moinet <alex@bugsnag.com>
Date: Thu, 8 Nov 2018 11:02:23 +0000
Subject: [PATCH 15/19] DelayedJob rewrite: Avoid creating unnecessary folders
 during tests

---
 features/support/env.rb | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/features/support/env.rb b/features/support/env.rb
index e837a8d9c..9c87e6159 100644
--- a/features/support/env.rb
+++ b/features/support/env.rb
@@ -21,11 +21,11 @@ def output_logs
 def install_fixture_gems
   gem_dir = File.expand_path('../../../', __FILE__)
   Dir.chdir(gem_dir) do
-    `rm bugsnag-*.gem`
+    `rm bugsnag-*.gem` unless Dir.glob('bugsnag-*.gem').empty?
     `gem build bugsnag.gemspec`
-    Dir.foreach('features/fixtures') do |entry|
+    Dir.entries('features/fixtures').reject { |entry| ['.', '..'].include?(entry) }.each do |entry|
       target_dir = "features/fixtures/#{entry}"
-      if File.directory? (target_dir)
+      if File.directory?(target_dir)
         `cp bugsnag-*.gem #{target_dir}`
         `gem unpack #{target_dir}/bugsnag-*.gem --target #{target_dir}/temp-bugsnag-lib`
       end

From 463370cfb3eff7654fb866dc635c47bf2cd5e587 Mon Sep 17 00:00:00 2001
From: Alex Moinet <alex@bugsnag.com>
Date: Thu, 8 Nov 2018 14:18:53 +0000
Subject: [PATCH 16/19] DelayedJob rewrite: Add class to delayed job context

---
 features/delayed_job.feature          | 4 ++--
 lib/bugsnag/middleware/delayed_job.rb | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/features/delayed_job.feature b/features/delayed_job.feature
index 4b3379d42..d165325d4 100644
--- a/features/delayed_job.feature
+++ b/features/delayed_job.feature
@@ -16,7 +16,7 @@ Scenario: An unhandled RuntimeError sends a report with arguments
   And the request contained the api key "a35a2a72bd230ac0aa0f52715bbdc6aa"
   And the event "unhandled" is true
   And the event "severity" is "error"
-  And the event "context" is "fail_with_args"
+  And the event "context" is "TestModel.fail_with_args"
   And the event "severityReason.type" is "unhandledExceptionMiddleware"
   And the event "severityReason.attributes.framework" is "DelayedJob"
   And the exception "errorClass" equals "RuntimeError"
@@ -39,7 +39,7 @@ Scenario: A handled exception sends a report
   And the request contained the api key "a35a2a72bd230ac0aa0f52715bbdc6aa"
   And the event "unhandled" is false
   And the event "severity" is "warning"
-  And the event "context" is "notify_with_args"
+  And the event "context" is "TestModel.notify_with_args"
   And the event "severityReason.type" is "handledException"
   And the exception "errorClass" equals "RuntimeError"
   And the event "metaData.job.class" equals "Delayed::Backend::ActiveRecord::Job"
diff --git a/lib/bugsnag/middleware/delayed_job.rb b/lib/bugsnag/middleware/delayed_job.rb
index c6279eb1a..adc1fd3fd 100644
--- a/lib/bugsnag/middleware/delayed_job.rb
+++ b/lib/bugsnag/middleware/delayed_job.rb
@@ -23,7 +23,7 @@ def call(report)
         if job.respond_to?(:payload_object)
           job_data[:active_job] = job.payload_object.job_data if job.payload_object.respond_to?(:job_data)
           payload_data = construct_job_payload(job.payload_object)
-          report.context = payload_data[:method_name] if payload_data.include?(:method_name)
+          report.context = payload_data[:display_name] if payload_data.include?(:display_name)
           job_data[:payload] = payload_data
         end
 

From 4daa728d7b89706a0a3beed73ccfcc440e9ad0ed Mon Sep 17 00:00:00 2001
From: Alex Moinet <alex@bugsnag.com>
Date: Thu, 8 Nov 2018 16:31:21 +0000
Subject: [PATCH 17/19] DelayedJob Rewrite: Update maze-tests to reflect
 maze-runner changes

---
 features/fixtures/docker-compose.yml  |  2 +-
 features/steps/ruby_notifier_steps.rb | 33 ---------------------------
 2 files changed, 1 insertion(+), 34 deletions(-)

diff --git a/features/fixtures/docker-compose.yml b/features/fixtures/docker-compose.yml
index 182d8184a..c91438c87 100644
--- a/features/fixtures/docker-compose.yml
+++ b/features/fixtures/docker-compose.yml
@@ -50,7 +50,7 @@ services:
       - MAZE_APP_VERSION
       - MAZE_AUTO_CAPTURE_SESSIONS
       - MAZE_AUTO_NOTIFY
-      - MAZE_ENDPOINT
+      - BUGSNAG_ENDPOINT
       - MAZE_IGNORE_CLASS
       - MAZE_IGNORE_MESSAGE
       - MAZE_META_DATA_FILTERS
diff --git a/features/steps/ruby_notifier_steps.rb b/features/steps/ruby_notifier_steps.rb
index 2832f00ac..d430d8c91 100644
--- a/features/steps/ruby_notifier_steps.rb
+++ b/features/steps/ruby_notifier_steps.rb
@@ -7,23 +7,6 @@
   }
 end
 
-When("I wait for the app to respond on port {string}") do |port|
-  max_attempts = ENV.include?('MAX_MAZE_CONNECT_ATTEMPTS')? ENV['MAX_MAZE_CONNECT_ATTEMPTS'].to_i : 10
-  attempts = 0
-  up = false
-  until (attempts >= max_attempts) || up
-    attempts += 1
-    begin
-      uri = URI("http://localhost:#{port}/")
-      response = Net::HTTP.get_response(uri)
-      up = (response.code == "200")
-    rescue EOFError
-    end
-    sleep 1
-  end
-  raise "App not ready in time!" unless up
-end
-
 When("I navigate to the route {string} on port {string}") do |route, port|
   steps %Q{
     When I open the URL "http://localhost:#{port}#{route}"
@@ -46,22 +29,6 @@
     When I set environment variable "#{env_var}" to "#{credentials}@#{current_ip}:#{MOCK_API_PORT}"
   }
 end
-
-Then("the request used payload v4 headers") do
-  steps %Q{
-    Then the "bugsnag-api-key" header is not null
-    And the "bugsnag-payload-version" header equals "4.0"
-    And the "bugsnag-sent-at" header is a timestamp
-  }
-end
-
-Then("the request contained the api key {string}") do |api_key|
-  steps %Q{
-    Then the "bugsnag-api-key" header equals "#{api_key}"
-    And the payload field "apiKey" equals "#{api_key}"
-  }
-end
-
 Then("the request used the Ruby notifier") do
   bugsnag_regex = /^http(s?):\/\/www.bugsnag.com/
   steps %Q{

From 24713c243c9f6b52c3919c9ee2cee889a702fe30 Mon Sep 17 00:00:00 2001
From: Alex Moinet <alex@bugsnag.com>
Date: Thu, 8 Nov 2018 16:32:06 +0000
Subject: [PATCH 18/19] DelayedJob Rewrite: Separated 'attempts' logically

---
 features/delayed_job.feature          | 6 ++++--
 lib/bugsnag/middleware/delayed_job.rb | 4 ++--
 2 files changed, 6 insertions(+), 4 deletions(-)

diff --git a/features/delayed_job.feature b/features/delayed_job.feature
index d165325d4..aa3f4a591 100644
--- a/features/delayed_job.feature
+++ b/features/delayed_job.feature
@@ -22,7 +22,8 @@ Scenario: An unhandled RuntimeError sends a report with arguments
   And the exception "errorClass" equals "RuntimeError"
   And the event "metaData.job.class" equals "Delayed::Backend::ActiveRecord::Job"
   And the event "metaData.job.id" is not null
-  And the event "metaData.job.attempts" equals "1 / 1"
+  And the event "metaData.job.attempt" equals 1
+  And the event "metaData.job.max_attempts" equals 1
   And the event "metaData.job.payload.display_name" equals "TestModel.fail_with_args"
   And the event "metaData.job.payload.method_name" equals "fail_with_args"
   And the payload field "events.0.metaData.job.payload.args" is an array with 1 element
@@ -44,7 +45,8 @@ Scenario: A handled exception sends a report
   And the exception "errorClass" equals "RuntimeError"
   And the event "metaData.job.class" equals "Delayed::Backend::ActiveRecord::Job"
   And the event "metaData.job.id" is not null
-  And the event "metaData.job.attempts" equals "1 / 1"
+  And the event "metaData.job.attempt" equals 1
+  And the event "metaData.job.max_attempts" equals 1
   And the event "metaData.job.payload.display_name" equals "TestModel.notify_with_args"
   And the event "metaData.job.payload.method_name" equals "notify_with_args"
   And the payload field "events.0.metaData.job.payload.args" is an array with 1 element
diff --git a/lib/bugsnag/middleware/delayed_job.rb b/lib/bugsnag/middleware/delayed_job.rb
index adc1fd3fd..0476e1ef9 100644
--- a/lib/bugsnag/middleware/delayed_job.rb
+++ b/lib/bugsnag/middleware/delayed_job.rb
@@ -28,9 +28,9 @@ def call(report)
         end
 
         if job.respond_to?(:attempts)
-          max_attempts = (job.respond_to?(:max_attempts) && job.max_attempts) || Delayed::Worker.max_attempts
-          job_data[:attempts] = "#{job.attempts + 1} / #{max_attempts}"
           # +1 as "attempts" is zero-based and does not include the current failed attempt
+          job_data[:attempt] = job.attempts + 1
+          job_data[:max_attempts] = (job.respond_to?(:max_attempts) && job.max_attempts) || Delayed::Worker.max_attempts
         end
 
         report.add_tab(:job, job_data)

From 29fd864e2aef6c8e998ede756dbbfd81f98b6b7f Mon Sep 17 00:00:00 2001
From: Alex Moinet <alex@bugsnag.com>
Date: Mon, 12 Nov 2018 14:12:35 +0000
Subject: [PATCH 19/19] v6.9.0

---
 CHANGELOG.md | 12 ++++++++++++
 VERSION      |  2 +-
 2 files changed, 13 insertions(+), 1 deletion(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 048b6deb9..fd65ce9bb 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,6 +1,18 @@
 Changelog
 =========
 
+## 6.9.0 (12 Nov 2018)
+
+### Enhancements
+
+* Ensure the correct error handler is used in newer versions of Sidekiq
+  | [#434](https://github.com/bugsnag/bugsnag-ruby/pull/434)
+
+* Rewrite Delayed::Job integration to fix potential issues and add more
+  collected data
+  | [#492](https://github.com/bugsnag/bugsnag-ruby/pull/492)
+  | [Simon Maynard](https://github.com/snmaynard)
+
 ## 6.8.0 (11 Jul 2018)
 
 This release includes general performance improvements to payload trimming and
diff --git a/VERSION b/VERSION
index e029aa99b..97f578152 100644
--- a/VERSION
+++ b/VERSION
@@ -1 +1 @@
-6.8.0
+6.9.0