journaled 2.5.0 → 4.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 895598e96b01aad6c51bd55355c5d7d0fab963b97326c2943bcb76450dd7cdb7
-  data.tar.gz: 61073882361fbb34ca243d8cc4dbedb494f798bcaaf2bde124f820eb8e175439
+  metadata.gz: 88602263644ea51719a18c5ee3e719d2c13a9e69049e1f20a52a44edc38a0835
+  data.tar.gz: c7cafdb9f305e51c3590d09815d5d6f909db496866c774ab442ffaa334be927c
 SHA512:
-  metadata.gz: 4564bc7e637fc2d032ee00b1f2b9e21282d65a531ae758ac374f863b1964100c3ea755db1e558c43d3503a74b995ffc310bb6343f255591357bf4d7ffe556e54
-  data.tar.gz: b456385727f88392465553ff9c63f313902536a9a13cae00fae011e40c7afb2490f3f5ff5fb1012346c18cedfb5cfabcbd20ed2dcaf1cd039dc27551d756647c
+  metadata.gz: 6bf229efd53882ed50931c964c1564b01603fa22ea2083b8a6039d0a0ed972d2cdc7bfc5913a9e9539d7dd023294c2a226963e2e2a526bf857926afe3e0c76c0
+  data.tar.gz: cf7b28c58c40c9ee8348df60095a7b544c0a8b0ea448ffa20021aceda61ae2feda61110ef9685756d4bac7d3d887e12a181f1840d435b2d2f85aeba5d8a52e45

data/README.md

@@ -1,16 +1,16 @@
 # Journaled
 
-A Rails engine to durably deliver schematized events to Amazon Kinesis via DelayedJob.
+A Rails engine to durably deliver schematized events to Amazon Kinesis via ActiveJob.
 
 More specifically, `journaled` is composed of three opinionated pieces:
 schema definition/validation via JSON Schema, transactional enqueueing
-via Delayed::Job (specifically `delayed_job_active_record`), and event
+via ActiveJob (specifically, via a DB-backed queue adapter), and event
 transmission via Amazon Kinesis. Our current use-cases include
 transmitting audit events for durable storage in S3 and/or analytical
 querying in Amazon Redshift.
 
 Journaled provides an at-least-once event delivery guarantee assuming
-Delayed::Job is configured not to delete jobs on failure.
+ActiveJob's queue adapter is not configured to delete jobs on failure.
 
 Note: Do not use the journaled gem to build an event sourcing solution
 as it does not guarantee total ordering of events. It's possible we'll
@@ -18,11 +18,24 @@ add scoped ordering capability at a future date (and would gladly
 entertain pull requests), but it is presently only designed to provide a
 durable, eventually consistent record that discrete events happened.
 
+**See [upgrades](#upgrades) below if you're upgrading from an older `journaled` version!**
+
 ## Installation
 
-1. [Install `delayed_job_active_record`](https://github.com/collectiveidea/delayed_job_active_record#installation)
-if you haven't already.
+1. If you haven't already,
+[configure ActiveJob](https://guides.rubyonrails.org/active_job_basics.html)
+to use one of the following queue adapters:
+
+    - `:delayed_job` (via `delayed_job_active_record`)
+    - `:que`
+    - `:good_job`
+    - `:delayed`
 
+    Ensure that your queue adapter is not configured to delete jobs on failure.
+
+    **If you launch your application in production mode and the gem detects that
+    `ActiveJob::Base.queue_adapter` is not in the above list, it will raise an exception
+    and prevent your application from performing unsafe journaling.**
 
 2. To integrate Journaled into your application, simply include the gem in your
 app's Gemfile.
@@ -40,20 +53,21 @@ app's Gemfile.
     require 'journaled/rspec'
     ```
 
-3. You will also need to define the following environment variables to allow Journaled to publish events to your AWS Kinesis event stream:
+3. You will need to set the following config in an initializer to allow Journaled to publish events to your AWS Kinesis event stream:
 
-    * `JOURNALED_STREAM_NAME`
+    ```ruby
+    Journaled.default_stream_name = "my_app_#{Rails.env}_events"
+    ```
 
-    Special case: if your `Journaled::Event` objects override the
-    `#journaled_app_name` method to a non-nil value e.g. `my_app`, you will
-    instead need to provide a corresponding
-    `[upcased_app_name]_JOURNALED_STREAM_NAME` variable for each distinct
-    value, e.g. `MY_APP_JOURNALED_STREAM_NAME`. You can provide a default value
-    for all `Journaled::Event`s in an initializer like this:
+    You may also define a `#journaled_stream_name` method on `Journaled::Event` instances:
 
     ```ruby
-    Journaled.default_app_name = 'my_app'
-    ```
+    def journaled_stream_name
+      "my_app_#{Rails.env}_alternate_events"
+    end
+    ````
+
+3. You may also need to define environment variables to allow Journaled to publish events to your AWS Kinesis event stream:
 
     You may optionally define the following ENV vars to specify AWS
     credentials outside of the locations that the AWS SDK normally looks:
@@ -77,17 +91,17 @@ app's Gemfile.
 
 Journaling provides a number of different configuation options that can be set in Ruby using an initializer. Those values are:
 
-#### `Journaled.default_app_name`
+#### `Journaled.default_stream_name `
 
-  This is described in the proceeding paragraph and is used to specify which app name to use, which corresponds to which Journaled Stream to send events too.
-  This is the default value for events that do NOT specify their own `#journaled_app_name`. For events that define their own `#journaled_app_name` method, that will take precedence over this default.
-  Ex: `Journaled.default_app_name = 'my_app'`
+  This is described in the "Installation" section above, and is used to specify which stream name to use.
 
 #### `Journaled.job_priority` (default: 20)
 
-  This can be used to configure what `priority` the Delayed Jobs are enqueued with. This will be applied to all the Journaled::Devivery jobs that are created by this application.
+  This can be used to configure what `priority` the ActiveJobs are enqueued with. This will be applied to all the `Journaled::DeliveryJob`s that are created by this application.
   Ex: `Journaled.job_priority = 14`
 
+  _Note that job priority is only supported on Rails 6.0+. Prior Rails versions will ignore this parameter and enqueue jobs with the underlying ActiveJob adapter's default priority._
+
 #### `Journaled.http_idle_timeout` (default: 1 second)
 
   The number of seconds a persistent connection is allowed to sit idle before it should no longer be used.
@@ -100,9 +114,9 @@ Journaling provides a number of different configuation options that can be set i
 
   The number of seconds before the :http_handler should timeout while waiting for a HTTP response.
 
-#### DJ `enqueue` options
+#### ActiveJob `set` options
 
-Both model-level directives accept additional options to be passed into DelayedJob's `enqueue` method:
+Both model-level directives accept additional options to be passed into ActiveJob's `set` method:
 
 ```ruby
 # For change journaling:
@@ -136,8 +150,8 @@ class ApplicationController < ActionController::Base
 end
 ```
 
-Your authenticated entity must respond to `#to_global_id`, which
-ActiveRecords do by default.
+Your authenticated entity must respond to `#to_global_id`, which ActiveRecords do by default.
+This feature relies on `ActiveSupport::CurrentAttributes` under the hood.
 
 Every time any of the specified attributes is modified, or a `User`
 record is created or destroyed, an event will be sent to Kinesis with the following attributes:
@@ -165,6 +179,40 @@ journaling. Note that the less-frequently-used methods `toggle`,
 `increment*`, `decrement*`, and `update_counters` are not intercepted at
 this time.
 
+### Tagged Events
+
+Events may be optionally marked as "tagged." This will add a `tags` field, intended for tracing and
+auditing purposes.
+
+```ruby
+class MyEvent
+  include Journaled::Event
+
+  journal_attributes :attr_1, :attr_2, tagged: true
+end
+```
+
+You may then use `Journaled.tag!` and `Journaled.tagged` inside of your
+`ApplicationController` and `ApplicationJob` classes (or anywhere else!) to tag
+all events with request and job metadata:
+
+```ruby
+class ApplicationController < ActionController::Base
+  before_action do
+    Journaled.tag!(request_id: request.request_id, current_user_id: current_user&.id)
+  end
+end
+
+class ApplicationJob < ActiveJob::Base
+  around_perform do |job, perform|
+    Journaled.tagged(job_id: job.id) { perform.call }
+  end
+end
+```
+
+This feature relies on `ActiveSupport::CurrentAttributes` under the hood, so these tags are local to
+the current thread, and will be cleared at the end of each request request/job.
+
 #### Testing
 
 If you use RSpec (and have required `journaled/rspec` in your
@@ -304,6 +352,49 @@ Returns one of the following in order of preference:
 In order for this to be most useful, you must configure your controller
 as described in [Change Journaling](#change-journaling) above.
 
+## Upgrades
+
+Since this gem relies on background jobs (which can remain in the queue across
+code releases), this gem generally aims to support jobs enqueued by the prior
+gem version.
+
+As such, **we always recommend upgrading only one major version at a time.**
+
+### Upgrading from 3.1.0
+
+Versions of Journaled prior to 4.0 relied directly on environment variables for stream names, but now stream names are configured directly.
+When upgrading, you can use the following configuration to maintain the previous behavior:
+
+```ruby
+Journaled.default_stream_name = ENV['JOURNALED_STREAM_NAME']
+```
+
+If you previously specified a `Journaled.default_app_name`, you would have required a more precise environment variable name (substitute `{{upcase_app_name}}`):
+
+```ruby
+Journaled.default_stream_name = ENV["{{upcase_app_name}}_JOURNALED_STREAM_NAME"]
+```
+
+And if you had defined any `journaled_app_name` methods on `Journaled::Event` instances, you can replace them with the following:
+
+```ruby
+def journaled_stream_name
+  ENV['{{upcase_app_name}}_JOURNALED_STREAM_NAME']
+end
+```
+
+When upgrading from 3.1 or below, `Journaled::DeliveryJob` will handle any jobs that remain in the queue by accepting an `app_name` argument. **This behavior will be removed in version 5.0**, so it is recommended to upgrade one major version at a time.
+
+### Upgrading from 2.5.0
+
+Versions of Journaled prior to 3.0 relied direclty on `delayed_job` and a "performable" class called `Journaled::Delivery`.
+In 3.0, this was superceded by an ActiveJob class called `Journaled::DeliveryJob`, but the `Journaled::Delivery` class was not removed until 4.0.
+
+Therefore, when upgrading from 2.5.0 or below, it is recommended to first upgrade to 3.1.0 (to allow any `Journaled::Delivery` jobs to finish working off) before upgrading to 4.0+.
+
+The upgrade to 3.1.0 will require a working ActiveJob config. ActiveJob can be configured globally by setting `ActiveJob::Base.queue_adapter`, or just for Journaled jobs by setting `Journaled::DeliveryJob.queue_adapter`.
+The `:delayed_job` queue adapter will allow you to continue relying on `delayed_job`. You may also consider switching your app(s) to [`delayed`](https://github.com/Betterment/delayed) and using the `:delayed` queue adapter.
+
 ## Future improvements & issue tracking
 Suggestions for enhancements to this engine are currently being tracked via Github Issues. Please feel free to open an
 issue for a desired feature, as well as for any observed bugs.

data/Rakefile

@@ -28,7 +28,13 @@ if %w(development test).include? Rails.env
   RuboCop::RakeTask.new
 
   task(:default).clear
-  task default: %i(rubocop spec)
+  if ENV['APPRAISAL_INITIALIZED'] || ENV['CI']
+    task default: %i(rubocop spec)
+  else
+    require 'appraisal'
+    Appraisal::Task.new
+    task default: :appraisal
+  end
 
   task 'db:test:prepare' => 'db:setup'
 end

data/app/controllers/concerns/journaled/actor.rb

@@ -2,11 +2,14 @@ module Journaled::Actor
   extend ActiveSupport::Concern
 
   included do
-    class_attribute :_journaled_actor_method_name, instance_accessor: false, instance_predicate: false
-    before_action do
-      RequestStore.store[:journaled_actor_proc] = self.class._journaled_actor_method_name &&
-        -> { send(self.class._journaled_actor_method_name) }
-    end
+    class_attribute :_journaled_actor_method_name, instance_writer: false
+    before_action :_set_journaled_actor_proc, if: :_journaled_actor_method_name?
+  end
+
+  private
+
+  def _set_journaled_actor_proc
+    Journaled::Current.journaled_actor_proc = -> { send(self.class._journaled_actor_method_name) }
   end
 
   class_methods do

data/app/jobs/journaled/application_job.rb

@@ -0,0 +1,4 @@
+module Journaled
+  class ApplicationJob < Journaled.job_base_class_name.constantize
+  end
+end

data/app/jobs/journaled/delivery_job.rb

@@ -0,0 +1,105 @@
+module Journaled
+  class DeliveryJob < ApplicationJob
+    DEFAULT_REGION = 'us-east-1'.freeze
+
+    rescue_from(Aws::Kinesis::Errors::InternalFailure, Aws::Kinesis::Errors::ServiceUnavailable, Aws::Kinesis::Errors::Http503Error) do |e|
+      Rails.logger.error "Kinesis Error - Server Error occurred - #{e.class}"
+      raise KinesisTemporaryFailure
+    end
+
+    rescue_from(Seahorse::Client::NetworkingError) do |e|
+      Rails.logger.error "Kinesis Error - Networking Error occurred - #{e.class}"
+      raise KinesisTemporaryFailure
+    end
+
+    UNSPECIFIED = Object.new
+    private_constant :UNSPECIFIED
+
+    def perform(serialized_event:, partition_key:, stream_name: UNSPECIFIED, app_name: UNSPECIFIED)
+      @serialized_event = serialized_event
+      @partition_key = partition_key
+      if app_name != UNSPECIFIED
+        @stream_name = self.class.legacy_computed_stream_name(app_name: app_name)
+      elsif stream_name != UNSPECIFIED && !stream_name.nil?
+        @stream_name = stream_name
+      else
+        raise(ArgumentError, 'missing keyword: stream_name')
+      end
+
+      journal!
+    end
+
+    def self.legacy_computed_stream_name(app_name:)
+      env_var_name = [app_name&.upcase, 'JOURNALED_STREAM_NAME'].compact.join('_')
+      ENV.fetch(env_var_name)
+    end
+
+    def kinesis_client_config
+      {
+        region: ENV.fetch('AWS_DEFAULT_REGION', DEFAULT_REGION),
+        retry_limit: 0,
+        http_idle_timeout: Journaled.http_idle_timeout,
+        http_open_timeout: Journaled.http_open_timeout,
+        http_read_timeout: Journaled.http_read_timeout,
+      }.merge(credentials)
+    end
+
+    private
+
+    attr_reader :serialized_event, :partition_key, :stream_name
+
+    def journal!
+      kinesis_client.put_record record if Journaled.enabled?
+    end
+
+    def record
+      {
+        stream_name: stream_name,
+        data: serialized_event,
+        partition_key: partition_key,
+      }
+    end
+
+    def kinesis_client
+      Aws::Kinesis::Client.new(kinesis_client_config)
+    end
+
+    def credentials
+      if ENV.key?('JOURNALED_IAM_ROLE_ARN')
+        {
+          credentials: iam_assume_role_credentials,
+        }
+      else
+        legacy_credentials_hash_if_present
+      end
+    end
+
+    def legacy_credentials_hash_if_present
+      if ENV.key?('RUBY_AWS_ACCESS_KEY_ID')
+        {
+          access_key_id: ENV.fetch('RUBY_AWS_ACCESS_KEY_ID'),
+          secret_access_key: ENV.fetch('RUBY_AWS_SECRET_ACCESS_KEY'),
+        }
+      else
+        {}
+      end
+    end
+
+    def sts_client
+      Aws::STS::Client.new({
+        region: ENV.fetch('AWS_DEFAULT_REGION', DEFAULT_REGION),
+      }.merge(legacy_credentials_hash_if_present))
+    end
+
+    def iam_assume_role_credentials
+      @iam_assume_role_credentials ||= Aws::AssumeRoleCredentials.new(
+        client: sts_client,
+        role_arn: ENV.fetch('JOURNALED_IAM_ROLE_ARN'),
+        role_session_name: "JournaledAssumeRoleAccess",
+      )
+    end
+
+    class KinesisTemporaryFailure < NotTrulyExceptionalError
+    end
+  end
+end

data/app/models/journaled/actor_uri_provider.rb

@@ -8,8 +8,7 @@ class Journaled::ActorUriProvider
   private
 
   def actor_global_id_uri
-    actor = RequestStore.store[:journaled_actor_proc]&.call
-    actor.to_global_id.to_s if actor
+    Journaled::Current.actor&.to_global_id&.to_s
   end
 
   def fallback_global_id_uri

data/app/models/journaled/change.rb

@@ -6,7 +6,7 @@ class Journaled::Change
     :database_operation,
     :logical_operation,
     :changes,
-    :journaled_app_name,
+    :journaled_stream_name,
     :journaled_enqueue_opts,
     :actor
 
@@ -22,7 +22,7 @@ class Journaled::Change
                  database_operation:,
                  logical_operation:,
                  changes:,
-                 journaled_app_name:,
+                 journaled_stream_name:,
                  journaled_enqueue_opts:,
                  actor:)
     @table_name = table_name
@@ -30,7 +30,7 @@ class Journaled::Change
     @database_operation = database_operation
     @logical_operation = logical_operation
     @changes = changes
-    @journaled_app_name = journaled_app_name
+    @journaled_stream_name = journaled_stream_name
     @journaled_enqueue_opts = journaled_enqueue_opts
     @actor = actor
   end

data/app/models/journaled/change_writer.rb

@@ -27,7 +27,7 @@ class Journaled::ChangeWriter
       database_operation: database_operation,
       logical_operation: logical_operation,
       changes: JSON.dump(changes),
-      journaled_app_name: journaled_app_name,
+      journaled_stream_name: journaled_stream_name,
       journaled_enqueue_opts: model.journaled_enqueue_opts,
       actor: actor_uri,
     )
@@ -57,11 +57,11 @@ class Journaled::ChangeWriter
     end
   end
 
-  def journaled_app_name
-    if model.class.respond_to?(:journaled_app_name)
-      model.class.journaled_app_name
+  def journaled_stream_name
+    if model.class.respond_to?(:journaled_stream_name)
+      model.class.journaled_stream_name
     else
-      Journaled.default_app_name
+      Journaled.default_stream_name
     end
   end
 end

data/app/models/journaled/event.rb

@@ -35,16 +35,22 @@ module Journaled::Event
     event_type
   end
 
-  def journaled_app_name
-    Journaled.default_app_name
+  def journaled_stream_name
+    Journaled.default_stream_name
+  end
+
+  def tagged?
+    false
   end
 
   private
 
   class_methods do
-    def journal_attributes(*args, enqueue_with: {})
+    def journal_attributes(*args, enqueue_with: {}, tagged: false)
       journaled_attributes.concat(args)
       journaled_enqueue_opts.merge!(enqueue_with)
+
+      include Tagged if tagged
     end
 
     def journaled_attributes
@@ -61,4 +67,20 @@ module Journaled::Event
 
     journal_attributes :id, :event_type, :created_at
   end
+
+  module Tagged
+    extend ActiveSupport::Concern
+
+    included do
+      journaled_attributes << :tags
+    end
+
+    def tags
+      Journaled::Current.tags
+    end
+
+    def tagged?
+      true
+    end
+  end
 end

data/app/models/journaled/writer.rb

@@ -3,7 +3,7 @@ class Journaled::Writer
     journaled_schema_name
     journaled_partition_key
     journaled_attributes
-    journaled_app_name
+    journaled_stream_name
     journaled_enqueue_opts
   ).freeze
 
@@ -25,9 +25,10 @@ class Journaled::Writer
   end
 
   def journal!
-    base_event_json_schema_validator.validate! serialized_event
-    json_schema_validator.validate! serialized_event
-    Journaled.enqueue!(journaled_delivery, journaled_enqueue_opts)
+    validate!
+    Journaled::DeliveryJob
+      .set(journaled_enqueue_opts.reverse_merge(priority: Journaled.job_priority))
+      .perform_later(delivery_perform_args)
   end
 
   private
@@ -35,24 +36,26 @@ class Journaled::Writer
   attr_reader :journaled_event
   delegate(*EVENT_METHOD_NAMES, to: :journaled_event)
 
-  def journaled_delivery
-    @journaled_delivery ||= Journaled::Delivery.new(
+  def validate!
+    schema_validator('base_event').validate! serialized_event
+    schema_validator('tagged_event').validate! serialized_event if journaled_event.tagged?
+    schema_validator(journaled_schema_name).validate! serialized_event
+  end
+
+  def delivery_perform_args
+    {
       serialized_event: serialized_event,
       partition_key: journaled_partition_key,
-      app_name: journaled_app_name,
-    )
+      stream_name: journaled_stream_name,
+    }
   end
 
   def serialized_event
     @serialized_event ||= journaled_attributes.to_json
   end
 
-  def json_schema_validator
-    @json_schema_validator ||= Journaled::JsonSchemaModel::Validator.new(journaled_schema_name)
-  end
-
-  def base_event_json_schema_validator
-    @base_event_json_schema_validator ||= Journaled::JsonSchemaModel::Validator.new('base_event')
+  def schema_validator(schema_name)
+    Journaled::JsonSchemaModel::Validator.new(schema_name)
   end
 
   def respond_to_all?(object, method_names)

data/journaled_schemas/tagged_event.json

@@ -0,0 +1,14 @@
+{
+  "type": "object",
+  "title": "tagged_event",
+  "additionalProperties": true,
+  "required": [
+    "tags"
+  ],
+  "properties": {
+    "tags": {
+      "type": "object",
+      "additionalProperties": true
+    }
+  }
+}

data/lib/journaled/current.rb

@@ -0,0 +1,18 @@
+module Journaled
+  class Current < ActiveSupport::CurrentAttributes
+    attribute :tags
+    attribute :journaled_actor_proc
+
+    def tags=(value)
+      super(value.freeze)
+    end
+
+    def tags
+      attributes[:tags] ||= {}.freeze
+    end
+
+    def actor
+      journaled_actor_proc&.call
+    end
+  end
+end

data/lib/journaled/engine.rb

@@ -1,4 +1,9 @@
 module Journaled
   class Engine < ::Rails::Engine
+    config.after_initialize do
+      ActiveSupport.on_load(:active_job) do
+        Journaled.detect_queue_adapter! unless Journaled.development_or_test?
+      end
+    end
   end
 end

data/lib/journaled/version.rb

@@ -1,3 +1,3 @@
 module Journaled
-  VERSION = "2.5.0".freeze
+  VERSION = "4.1.0".freeze
 end

data/lib/journaled.rb

@@ -1,17 +1,19 @@
 require "aws-sdk-kinesis"
-require "delayed_job"
+require "active_job"
 require "json-schema"
-require "request_store"
 
 require "journaled/engine"
-require 'journaled/enqueue'
+require "journaled/current"
 
 module Journaled
-  mattr_accessor :default_app_name
+  SUPPORTED_QUEUE_ADAPTERS = %w(delayed delayed_job good_job que).freeze
+
+  mattr_accessor :default_stream_name
   mattr_accessor(:job_priority) { 20 }
   mattr_accessor(:http_idle_timeout) { 5 }
   mattr_accessor(:http_open_timeout) { 2 }
   mattr_accessor(:http_read_timeout) { 60 }
+  mattr_accessor(:job_base_class_name) { 'ActiveJob::Base' }
 
   def development_or_test?
     %w(development test).include?(Rails.env)
@@ -33,5 +35,33 @@ module Journaled
     Journaled::ActorUriProvider.instance.actor_uri
   end
 
-  module_function :development_or_test?, :enabled?, :schema_providers, :commit_hash, :actor_uri
+  def detect_queue_adapter!
+    adapter = job_base_class_name.constantize.queue_adapter_name
+    unless SUPPORTED_QUEUE_ADAPTERS.include?(adapter)
+      raise <<~MSG
+        Journaled has detected an unsupported ActiveJob queue adapter: `:#{adapter}`
+
+        Journaled jobs must be enqueued transactionally to your primary database.
+
+        Please install the appropriate gems and set `queue_adapter` to one of the following:
+        #{SUPPORTED_QUEUE_ADAPTERS.map { |a| "- `:#{a}`" }.join("\n")}
+
+        Read more at https://github.com/Betterment/journaled
+      MSG
+    end
+  end
+
+  def self.tagged(**tags)
+    existing_tags = Current.tags
+    tag!(tags)
+    yield
+  ensure
+    Current.tags = existing_tags
+  end
+
+  def self.tag!(**tags)
+    Current.tags = Current.tags.merge(tags)
+  end
+
+  module_function :development_or_test?, :enabled?, :schema_providers, :commit_hash, :actor_uri, :detect_queue_adapter!
 end

data/spec/dummy/config/application.rb

@@ -1,10 +1,9 @@
 require File.expand_path('boot', __dir__)
 
 require "active_record/railtie"
+require "active_job/railtie"
 require "active_model/railtie"
 require "action_controller/railtie"
-require "action_mailer/railtie"
-require "sprockets/railtie"
 
 Bundler.require(*Rails.groups)
 require "journaled"