journaled 3.1.0 → 4.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d758f3a24c9170a8b7585c330c59a80483ac763640ad847e229f16123d6f9f1b
-  data.tar.gz: adb70f763fd7daffcdc89a02898846a55132461f6329a67d787ce7fd10f73257
+  metadata.gz: bfdabb8b24bdfdf23c4f77ec819f03e89a4a0239ed997368eb1f07ac0bc2cd5b
+  data.tar.gz: 97eeec1dfa22f7b683f23e322eb663e6fae4b47e0c2786690c4f44166b8cca51
 SHA512:
-  metadata.gz: 346e26235e8de20fc34e0a888b2d3bf98189d73aaa9968db4af9addcf04b8c8577bb0f8e31d5443d85549f0da6c6defae8f554d328fc328732ae029a90704e2f
-  data.tar.gz: 1be21eed56a1ac95e27e13712831bd45fe0c4e8cf3b896b19e7ad9037b924a9d6543828ddb6d2112cbd25aa77aa464e7e99fd4fd8a4288a89c7d11ad2836915b
+  metadata.gz: 78c8b888f9c00a084e8d60c2f271d56a9a188f60287cb30edfbadc7a4f9fc1c3fc3210c763e757658a0040fb57f6f94f1a713fc1f95942db801e2e114dd50ec3
+  data.tar.gz: f0e56609680ecfc3e1f3f3a9d2ba801515762311307f0a208757a70a82ff7c37ba6af040f8ee5a64ebbf7a08a910579c27d65e940680b2406383b8eca022f323

data/README.md

@@ -18,22 +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. 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`
+    - `:delayed_job` (via `delayed_job_active_record`)
+    - `:que`
+    - `:good_job`
+    - `:delayed`
 
-Ensure that your queue adapter is not configured to delete jobs on failure.
+    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.**
+    **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.
@@ -51,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:
@@ -88,11 +91,9 @@ 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)
 
@@ -149,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:
@@ -178,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
@@ -317,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

@@ -4,37 +4,23 @@ rescue LoadError
   puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
 end
 
-require 'rdoc/task'
-
-RDoc::Task.new(:rdoc) do |rdoc|
-  rdoc.rdoc_dir = 'rdoc'
-  rdoc.title    = 'Journaled'
-  rdoc.options << '--line-numbers'
-  rdoc.rdoc_files.include('README.rdoc')
-  rdoc.rdoc_files.include('lib/**/*.rb')
-end
-
-APP_RAKEFILE = File.expand_path('spec/dummy/Rakefile', __dir__)
-load 'rails/tasks/engine.rake'
-
 Bundler::GemHelper.install_tasks
 
-if %w(development test).include? Rails.env
-  require 'rspec/core'
-  require 'rspec/core/rake_task'
-  RSpec::Core::RakeTask.new
+require 'rubocop/rake_task'
+RuboCop::RakeTask.new
 
-  require 'rubocop/rake_task'
-  RuboCop::RakeTask.new
+require 'rspec/core'
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec)
 
-  task(:default).clear
+def default_task
   if ENV['APPRAISAL_INITIALIZED'] || ENV['CI']
-    task default: %i(rubocop spec)
+    %i(rubocop spec)
   else
     require 'appraisal'
     Appraisal::Task.new
-    task default: :appraisal
+    %i(appraisal)
   end
-
-  task 'db:test:prepare' => 'db:setup'
 end
+
+task(:default).clear.enhance(default_task)

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/delivery_job.rb

@@ -12,15 +12,24 @@ module Journaled
       raise KinesisTemporaryFailure
     end
 
-    def perform(serialized_event:, partition_key:, app_name:)
+    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
-      @app_name = app_name
+      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.stream_name(app_name:)
+    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
@@ -37,7 +46,7 @@ module Journaled
 
     private
 
-    attr_reader :serialized_event, :partition_key, :app_name
+    attr_reader :serialized_event, :partition_key, :stream_name
 
     def journal!
       kinesis_client.put_record record if Journaled.enabled?
@@ -45,7 +54,7 @@ module Journaled
 
     def record
       {
-        stream_name: self.class.stream_name(app_name: app_name),
+        stream_name: stream_name,
         data: serialized_event,
         partition_key: partition_key,
       }

data/app/models/concerns/journaled/changes.rb

@@ -39,8 +39,8 @@ module Journaled::Changes
       end
     end
 
-    def update_columns(attributes, force: false)
-      unless force || self.class.journaled_attribute_names.empty?
+    def update_columns(attributes, opts = { force: false })
+      unless opts[:force] || self.class.journaled_attribute_names.empty?
         conflicting_journaled_attribute_names = self.class.journaled_attribute_names & attributes.keys.map(&:to_sym)
         raise(<<~ERROR) if conflicting_journaled_attribute_names.present?
           #update_columns aborted by Journaled::Changes due to journaled attributes:
@@ -56,7 +56,7 @@ module Journaled::Changes
   end
 
   class_methods do
-    def journal_changes_to(*attribute_names, as:, enqueue_with: {}) # rubocop:disable Naming/UncommunicativeMethodParamName
+    def journal_changes_to(*attribute_names, as:, enqueue_with: {}) # rubocop:disable Naming/MethodParameterName
       if attribute_names.empty? || attribute_names.any? { |n| !n.is_a?(Symbol) }
         raise "one or more symbol attribute_name arguments is required"
       end
@@ -69,8 +69,8 @@ module Journaled::Changes
     end
 
     if Rails::VERSION::MAJOR > 5 || (Rails::VERSION::MAJOR == 5 && Rails::VERSION::MINOR >= 2)
-      def delete(id_or_array, force: false)
-        if force || journaled_attribute_names.empty?
+      def delete(id_or_array, opts = { force: false })
+        if opts[:force] || journaled_attribute_names.empty?
           where(primary_key => id_or_array).delete_all(force: true)
         else
           raise(<<~ERROR)

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

@@ -2,27 +2,27 @@ class Journaled::Change
   include Journaled::Event
 
   attr_reader :table_name,
-    :record_id,
-    :database_operation,
-    :logical_operation,
-    :changes,
-    :journaled_app_name,
-    :journaled_enqueue_opts,
-    :actor
+              :record_id,
+              :database_operation,
+              :logical_operation,
+              :changes,
+              :journaled_stream_name,
+              :journaled_enqueue_opts,
+              :actor
 
   journal_attributes :table_name,
-    :record_id,
-    :database_operation,
-    :logical_operation,
-    :changes,
-    :actor
+                     :record_id,
+                     :database_operation,
+                     :logical_operation,
+                     :changes,
+                     :actor
 
   def initialize(table_name:,
                  record_id:,
                  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

@@ -1,5 +1,6 @@
 class Journaled::ChangeWriter
   attr_reader :model, :change_definition
+
   delegate :attribute_names, :logical_operation, to: :change_definition
 
   def initialize(model:, change_definition:)
@@ -27,7 +28,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,
     )
@@ -52,16 +53,16 @@ class Journaled::ChangeWriter
   private
 
   def pluck_changed_values(change_hash, index:)
-    change_hash.each_with_object({}) do |(k, v), result|
-      result[k] = v[index]
+    change_hash.transform_values do |v|
+      v[index]
     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,23 +25,29 @@ class Journaled::Writer
   end
 
   def journal!
-    base_event_json_schema_validator.validate! serialized_event
-    json_schema_validator.validate! serialized_event
+    validate!
     Journaled::DeliveryJob
       .set(journaled_enqueue_opts.reverse_merge(priority: Journaled.job_priority))
-      .perform_later(delivery_perform_args)
+      .perform_later(**delivery_perform_args)
   end
 
   private
 
   attr_reader :journaled_event
+
   delegate(*EVENT_METHOD_NAMES, to: :journaled_event)
 
+  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
 
@@ -49,12 +55,8 @@ class Journaled::Writer
     @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/relation_change_protection.rb

@@ -1,14 +1,15 @@
 module Journaled::RelationChangeProtection
-  def update_all(updates, force: false) # rubocop:disable Metrics/AbcSize, Metrics/PerceivedComplexity
-    unless force || !@klass.respond_to?(:journaled_attribute_names) || @klass.journaled_attribute_names.empty?
-      conflicting_journaled_attribute_names = if updates.is_a?(Hash)
-                                                @klass.journaled_attribute_names & updates.keys.map(&:to_sym)
-                                              elsif updates.is_a?(String)
-                                                @klass.journaled_attribute_names.select do |a|
-                                                  updates.match?(/\b(?<!')#{a}(?!')\b/)
-                                                end
-                                              else
-                                                raise "unsupported type '#{updates.class}' for 'updates'"
+  def update_all(updates, opts = { force: false }) # rubocop:disable Metrics/AbcSize
+    unless opts[:force] || !@klass.respond_to?(:journaled_attribute_names) || @klass.journaled_attribute_names.empty?
+      conflicting_journaled_attribute_names = case updates
+                                                when Hash
+                                                  @klass.journaled_attribute_names & updates.keys.map(&:to_sym)
+                                                when String
+                                                  @klass.journaled_attribute_names.select do |a|
+                                                    updates.match?(/\b(?<!')#{a}(?!')\b/)
+                                                  end
+                                                else
+                                                  raise "unsupported type '#{updates.class}' for 'updates'"
                                               end
       raise(<<~ERROR) if conflicting_journaled_attribute_names.present?
         .update_all aborted by Journaled::Changes due to journaled attributes:

data/lib/journaled/version.rb

@@ -1,3 +1,3 @@
 module Journaled
-  VERSION = "3.1.0".freeze
+  VERSION = "4.2.0".freeze
 end

data/lib/journaled.rb

@@ -1,14 +1,14 @@
 require "aws-sdk-kinesis"
 require "active_job"
 require "json-schema"
-require "request_store"
 
 require "journaled/engine"
+require "journaled/current"
 
 module Journaled
   SUPPORTED_QUEUE_ADAPTERS = %w(delayed delayed_job good_job que).freeze
 
-  mattr_accessor :default_app_name
+  mattr_accessor :default_stream_name
   mattr_accessor(:job_priority) { 20 }
   mattr_accessor(:http_idle_timeout) { 5 }
   mattr_accessor(:http_open_timeout) { 2 }
@@ -20,7 +20,7 @@ module Journaled
   end
 
   def enabled?
-    !['0', 'false', false, 'f', ''].include?(ENV.fetch('JOURNALED_ENABLED', !development_or_test?))
+    ['0', 'false', false, 'f', ''].exclude?(ENV.fetch('JOURNALED_ENABLED', !development_or_test?))
   end
 
   def schema_providers
@@ -51,5 +51,17 @@ module Journaled
     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.ru

@@ -1,4 +1,4 @@
 # This file is used by Rack-based servers to start the application.
 
-require ::File.expand_path('../config/environment', __FILE__)
+require ::File.expand_path('config/environment', __dir__)
 run Rails.application