aws-sdk-rails 3.6.1 → 3.13.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 839c723ba30e8acd11e135351278a0422b4f7e6a09a364b8a3fda7d33aa2e899
-  data.tar.gz: af1ba6b6525f17e6a46cc16aa4ccbaaf8317860ddf5cd6128d3883c82660ee24
+  metadata.gz: 43528604142d01e2ddcddf37ae598a08c11744aa3a9ccc6757dbc7d1932d3546
+  data.tar.gz: 7977e087f6372fc8326193dad744f908cda1d2174fc6f817e9cfe48b286a5cfb
 SHA512:
-  metadata.gz: 8288a0c8551bc30cac782c7510a825fdcd9d8ba31bd1d2feda8c2a20ad29f569194237f686f191f1a57ee12eb91a08bb1c5b65b07519af5b62bd7f56ab3f79cb
-  data.tar.gz: d6835fc12e6a4a5bc9573b4c5b997a1df5d17e49c28ea2ea16e76f8ebc7b2c8c515026b0a48fb0b15eaab3ba22f1904782f553a03a784dcd665d71723ddd47bd
+  metadata.gz: 2ceda136ba4f7077b6608787528f2ae97b9ceb3169d9c67f101105e7e512dc8000cdb3bf09e5f96b786544bdb427eb15cc0df6571ecc544f5b1603c51cc034b8
+  data.tar.gz: 1fdb53b5fdc4a752643deb9e360988983ad939cce6ada4a8ce3bc68122959c44c7ca6f98d55987172c4d559d9d010ec652b482576bf12b4e496193b183aa236e

data/VERSION

@@ -1 +1 @@
-3.6.1
+3.13.0

data/bin/aws_sqs_active_job

@@ -1,4 +1,5 @@
 #!/usr/bin/env ruby
+# frozen_string_literal: true
 
 require_relative '../lib/aws/rails/sqs_active_job/poller'
 

data/lib/action_dispatch/session/dynamodb_store.rb

@@ -1,4 +1,7 @@
+# frozen_string_literal: true
+
 require 'aws-sessionstore-dynamodb'
+require 'action_dispatch/middleware/session/abstract_store'
 
 module ActionDispatch
   module Session
@@ -9,13 +12,16 @@ module ActionDispatch
     # This class will use the Rails secret_key_base unless otherwise provided.
     #
     # Configuration can also be provided in YAML files from Rails config, either
-    # in "config/session_store.yml" or "config/session_store/#{Rails.env}.yml".
+    # in "config/session_store.yml" or "config/session_store/#\\{Rails.env}.yml".
     # Configuration files that are environment-specific will take precedence.
     #
     # @see https://docs.aws.amazon.com/sdk-for-ruby/aws-sessionstore-dynamodb/api/Aws/SessionStore/DynamoDB/Configuration.html
     class DynamodbStore < Aws::SessionStore::DynamoDB::RackMiddleware
+      include StaleSessionCheck
+      include SessionObject
+
       def initialize(app, options = {})
-        options[:config_file] ||= config_file if config_file.exist?
+        options[:config_file] ||= config_file if File.exist?(config_file)
         options[:secret_key] ||= Rails.application.secret_key_base
         super
       end
@@ -24,7 +30,7 @@ module ActionDispatch
 
       def config_file
         file = Rails.root.join("config/dynamo_db_session_store/#{Rails.env}.yml")
-        file = Rails.root.join('config/dynamo_db_session_store.yml') unless file.exist?
+        file = Rails.root.join('config/dynamo_db_session_store.yml') unless File.exist?(file)
         file
       end
     end

data/lib/active_job/queue_adapters/amazon_sqs_adapter/params.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module ActiveJob
+  module QueueAdapters
+    class AmazonSqsAdapter
+      # == build request parameter of Aws::SQS::Client
+      class Params
+        class << self
+          def assured_delay_seconds(timestamp)
+            delay = (timestamp - Time.now.to_f).floor
+            delay = 0 if delay.negative?
+            raise ArgumentError, 'Unable to queue a job with a delay great than 15 minutes' if delay > 15.minutes
+
+            delay
+          end
+        end
+
+        def initialize(job, body)
+          @job = job
+          @body = body || job.serialize
+        end
+
+        def queue_url
+          @queue_url ||= Aws::Rails::SqsActiveJob.config.queue_url_for(@job.queue_name)
+        end
+
+        def entry
+          if Aws::Rails::SqsActiveJob.fifo?(queue_url)
+            default_entry.merge(options_for_fifo)
+          else
+            default_entry
+          end
+        end
+
+        private
+
+        def default_entry
+          {
+            message_body: Aws::Json.dump(@body),
+            message_attributes: message_attributes
+          }
+        end
+
+        def message_attributes
+          {
+            'aws_sqs_active_job_class' => {
+              string_value: @job.class.to_s,
+              data_type: 'String'
+            },
+            'aws_sqs_active_job_version' => {
+              string_value: Aws::Rails::VERSION,
+              data_type: 'String'
+            }
+          }
+        end
+
+        def options_for_fifo
+          options = {}
+          options[:message_deduplication_id] =
+            Digest::SHA256.hexdigest(Aws::Json.dump(deduplication_body))
+
+          message_group_id = @job.message_group_id if @job.respond_to?(:message_group_id)
+          message_group_id ||= Aws::Rails::SqsActiveJob.config.message_group_id
+
+          options[:message_group_id] = message_group_id
+          options
+        end
+
+        def deduplication_body
+          ex_dedup_keys = @job.excluded_deduplication_keys if @job.respond_to?(:excluded_deduplication_keys)
+          ex_dedup_keys ||= Aws::Rails::SqsActiveJob.config.excluded_deduplication_keys
+
+          @body.except(*ex_dedup_keys)
+        end
+      end
+    end
+  end
+end

data/lib/active_job/queue_adapters/amazon_sqs_adapter.rb

@@ -4,53 +4,49 @@ require 'aws-sdk-sqs'
 
 module ActiveJob
   module QueueAdapters
-
     class AmazonSqsAdapter
-
       def enqueue(job)
         _enqueue(job)
       end
 
-      def enqueue_at(job, timestamp, opts={})
-        delay = (timestamp - Time.now.to_f).floor
-        raise ArgumentError, 'Unable to queue a job with a delay great than 15 minutes' if delay > 15.minutes
-        _enqueue(job, delay_seconds: delay)
+      def enqueue_at(job, timestamp)
+        delay = Params.assured_delay_seconds(timestamp)
+        _enqueue(job, nil, delay_seconds: delay)
       end
 
-      private
-
-      def _enqueue(job, send_message_opts = {})
-        body = job.serialize
-        queue_url = Aws::Rails::SqsActiveJob.config.queue_url_for(job.queue_name)
-        send_message_opts[:queue_url] = queue_url
-        send_message_opts[:message_body] = Aws::Json.dump(body)
-        send_message_opts[:message_attributes] = message_attributes(job)
-
-        if Aws::Rails::SqsActiveJob.fifo?(queue_url)
-          # job_id is unique per initialization of job
-          # Remove it from message dup id to ensure run-once behavior
-          # with ActiveJob retries
-           send_message_opts[:message_deduplication_id] =
-             Digest::SHA256.hexdigest(
-               Aws::Json.dump(body.except('job_id'))
-             )
-
-           send_message_opts[:message_group_id] = Aws::Rails::SqsActiveJob.config.message_group_id
+      def enqueue_all(jobs)
+        enqueued_count = 0
+        jobs.group_by(&:queue_name).each do |queue_name, same_queue_jobs|
+          queue_url = Aws::Rails::SqsActiveJob.config.queue_url_for(queue_name)
+          base_send_message_opts = { queue_url: queue_url }
+
+          same_queue_jobs.each_slice(10) do |chunk|
+            entries = chunk.map do |job|
+              entry = Params.new(job, nil).entry
+              entry[:id] = job.job_id
+              entry[:delay_seconds] = Params.assured_delay_seconds(job.scheduled_at) if job.scheduled_at
+              entry
+            end
+
+            send_message_opts = base_send_message_opts.deep_dup
+            send_message_opts[:entries] = entries
+
+            send_message_batch_result = Aws::Rails::SqsActiveJob.config.client.send_message_batch(send_message_opts)
+            enqueued_count += send_message_batch_result.successful.count
+          end
         end
-        Aws::Rails::SqsActiveJob.config.client.send_message(send_message_opts)
+        enqueued_count
       end
 
-      def message_attributes(job)
-        {
-          'aws_sqs_active_job_class' => {
-            string_value: job.class.to_s,
-            data_type: 'String'
-          },
-          'aws_sqs_active_job_version' => {
-            string_value: Aws::Rails::VERSION,
-            data_type: 'String'
-          }
-        }
+      private
+
+      def _enqueue(job, body = nil, send_message_opts = {})
+        body ||= job.serialize
+        params = Params.new(job, body)
+        send_message_opts = send_message_opts.merge(params.entry)
+        send_message_opts[:queue_url] = params.queue_url
+
+        Aws::Rails::SqsActiveJob.config.client.send_message(send_message_opts)
       end
     end
 

data/lib/active_job/queue_adapters/amazon_sqs_async_adapter.rb

@@ -5,7 +5,6 @@ require 'concurrent'
 
 module ActiveJob
   module QueueAdapters
-
     # == Async adapter for Amazon SQS ActiveJob
     #
     # This adapter queues jobs asynchronously (ie non-blocking).  Error handler can be configured
@@ -15,22 +14,24 @@ module ActiveJob
     #
     # config.active_job.queue_adapter = :amazon_sqs_async
     class AmazonSqsAsyncAdapter < AmazonSqsAdapter
-
       private
 
-      def _enqueue(job, send_message_opts = {})
+      def _enqueue(job, body = nil, send_message_opts = {})
         # FIFO jobs must be queued in order, so do not queue async
         queue_url = Aws::Rails::SqsActiveJob.config.queue_url_for(job.queue_name)
         if Aws::Rails::SqsActiveJob.fifo?(queue_url)
-          super(job, send_message_opts)
+          super
         else
-          Concurrent::Promise
-          .execute { super(job, send_message_opts) }
-          .on_error do |e|
-            Rails.logger.error "Failed to queue job #{job}.  Reason: #{e}"
-            error_handler = Aws::Rails::SqsActiveJob.config.async_queue_error_handler
-            error_handler.call(e, job, send_message_opts) if error_handler
-          end
+          # Serialize is called here because the job’s locale needs to be
+          # determined in this thread and not in some other thread.
+          body = job.serialize
+          Concurrent::Promises
+            .future { super }
+            .rescue do |e|
+              Rails.logger.error "Failed to queue job #{job}. Reason: #{e}"
+              error_handler = Aws::Rails::SqsActiveJob.config.async_queue_error_handler
+              error_handler&.call(e, job, send_message_opts)
+            end
         end
       end
     end

data/lib/aws/rails/middleware/ebs_sqs_active_job_middleware.rb

@@ -11,7 +11,7 @@ module Aws
 
       def initialize(app)
         @app = app
-        @logger = ActiveSupport::Logger.new(STDOUT)
+        @logger = ::Rails.logger
       end
 
       def call(env)
@@ -20,11 +20,11 @@ module Aws
         # Pass through unless user agent is the SQS Daemon
         return @app.call(env) unless from_sqs_daemon?(request)
 
-        @logger.debug('aws-rails-sdk middleware detected call from Elastic Beanstalk SQS Daemon.')
+        @logger.debug('aws-sdk-rails middleware detected call from Elastic Beanstalk SQS Daemon.')
 
         # Only accept requests from this user agent if it is from localhost or a docker host in case of forgery.
         unless request.local? || sent_from_docker_host?(request)
-          @logger.warn("SQSD request detected from untrusted address #{request.remote_ip}; returning 403 forbidden.")
+          @logger.warn("SQSD request detected from untrusted address #{request.ip}; returning 403 forbidden.")
           return FORBIDDEN_RESPONSE
         end
 
@@ -81,11 +81,37 @@ module Aws
       end
 
       def sent_from_docker_host?(request)
-        app_runs_in_docker_container? && request.remote_ip == '172.17.0.1'
+        app_runs_in_docker_container? && default_gw_ips.include?(request.ip)
       end
 
       def app_runs_in_docker_container?
-        @app_runs_in_docker_container ||= `[ -f /proc/1/cgroup ] && cat /proc/1/cgroup` =~ /docker/
+        @app_runs_in_docker_container ||= in_docker_container_with_cgroup1? || in_docker_container_with_cgroup2?
+      end
+
+      def in_docker_container_with_cgroup1?
+        File.exist?('/proc/1/cgroup') && File.read('/proc/1/cgroup') =~ %r{/docker/}
+      end
+
+      def in_docker_container_with_cgroup2?
+        File.exist?('/proc/self/mountinfo') && File.read('/proc/self/mountinfo') =~ %r{/docker/containers/}
+      end
+
+      def default_gw_ips
+        default_gw_ips = ['172.17.0.1']
+
+        if File.exist?('/proc/net/route')
+          File.open('/proc/net/route').each_line do |line|
+            fields = line.strip.split
+            next if fields.size != 11
+
+            # Destination == 0.0.0.0 and Flags & RTF_GATEWAY != 0
+            if fields[1] == '00000000' && (fields[3].hex & 0x2) != 0
+              default_gw_ips << IPAddr.new_ntoh([fields[2].hex].pack('L')).to_s
+            end
+          end
+        end
+
+        default_gw_ips
       end
     end
   end

data/lib/aws/rails/notifications.rb

@@ -5,14 +5,12 @@ require 'active_support/notifications'
 
 module Aws
   module Rails
-
     # Instruments client operation calls for ActiveSupport::Notifications
     # Each client operation will produce an event with name:
     # <operation>.<service>.aws
     # @api private
     class Notifications < Seahorse::Client::Plugin
-
-      def add_handlers(handlers, config)
+      def add_handlers(handlers, _config)
         # This plugin needs to be first
         # which means it is called first in the stack, to start recording time,
         # and returns last
@@ -20,7 +18,6 @@ module Aws
       end
 
       class Handler < Seahorse::Client::Handler
-
         def call(context)
           event_name = "#{context.operation_name}.#{context.config.api.metadata['serviceId']}.aws"
           ActiveSupport::Notifications.instrument(event_name, context: context) do

data/lib/aws/rails/railtie.rb

@@ -10,6 +10,7 @@ module Aws
         # Initialization Actions
         Aws::Rails.use_rails_encrypted_credentials
         Aws::Rails.add_action_mailer_delivery_method
+        Aws::Rails.add_action_mailer_delivery_method(:sesv2)
         Aws::Rails.log_to_rails_logger
       end
 
@@ -28,11 +29,15 @@ module Aws
     #
     # @param [Symbol] name The name of the ActionMailer delivery method to
     #   register.
-    # @param [Hash] options The options you wish to pass on to the
-    #   Aws::SES::Client initialization method.
-    def self.add_action_mailer_delivery_method(name = :ses, options = {})
+    # @param [Hash] client_options The options you wish to pass on to the
+    #   Aws::SES[V2]::Client initialization method.
+    def self.add_action_mailer_delivery_method(name = :ses, client_options = {})
       ActiveSupport.on_load(:action_mailer) do
-        add_delivery_method(name, Aws::Rails::Mailer, options)
+        if name == :sesv2
+          add_delivery_method(name, Aws::Rails::Sesv2Mailer, client_options)
+        else
+          add_delivery_method(name, Aws::Rails::SesMailer, client_options)
+        end
       end
     end
 

data/lib/aws/rails/{mailer.rb → ses_mailer.rb}

@@ -15,25 +15,23 @@ module Aws
     #
     # Uses the AWS SDK for Ruby's credential provider chain when creating an SES
     # client instance.
-    class Mailer
+    class SesMailer
       # @param [Hash] options Passes along initialization options to
       #   [Aws::SES::Client.new](https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/SES/Client.html#initialize-instance_method).
       def initialize(options = {})
         @client = SES::Client.new(options)
+        @client.config.user_agent_frameworks << 'aws-sdk-rails'
       end
 
       # Rails expects this method to exist, and to handle a Mail::Message object
       # correctly. Called during mail delivery.
       def deliver!(message)
-        send_opts = {}
-        send_opts[:raw_message] = {}
-        send_opts[:raw_message][:data] = message.to_s
-
-        if message.respond_to?(:destinations)
-          send_opts[:destinations] = message.destinations
-        end
-
-        @client.send_raw_email(send_opts).tap do |response|
+        params = {
+          raw_message: { data: message.to_s },
+          source: message.smtp_envelope_from, # defaults to From header
+          destinations: message.smtp_envelope_to # defaults to destinations (To,Cc,Bcc)
+        }
+        @client.send_raw_email(params).tap do |response|
           message.header[:ses_message_id] = response.message_id
         end
       end
@@ -45,3 +43,7 @@ module Aws
     end
   end
 end
+
+# This is for backwards compatibility after introducing support for SESv2.
+# The old mailer is now replaced with the new SES (v1) mailer.
+Aws::Rails::Mailer = Aws::Rails::SesMailer

data/lib/aws/rails/sesv2_mailer.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require 'aws-sdk-sesv2'
+
+module Aws
+  module Rails
+    # Provides a delivery method for ActionMailer that uses Amazon Simple Email
+    # Service V2.
+    #
+    # Once you have an SESv2 delivery method you can configure Rails to
+    # use this for ActionMailer in your environment configuration
+    # (e.g. RAILS_ROOT/config/environments/production.rb)
+    #
+    #     config.action_mailer.delivery_method = :sesv2
+    #
+    # Uses the AWS SDK for Ruby's credential provider chain when creating an SESV2
+    # client instance.
+    class Sesv2Mailer
+      # @param [Hash] options Passes along initialization options to
+      #   [Aws::SESV2::Client.new](https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/SESV2/Client.html#initialize-instance_method).
+      def initialize(options = {})
+        @client = SESV2::Client.new(options)
+        @client.config.user_agent_frameworks << 'aws-sdk-rails'
+      end
+
+      # Rails expects this method to exist, and to handle a Mail::Message object
+      # correctly. Called during mail delivery.
+      def deliver!(message)
+        params = { content: { raw: { data: message.to_s } } }
+        # smtp_envelope_from will default to the From address *without* sender names.
+        # By omitting this param, SESv2 will correctly use sender names from the mail headers.
+        # We should only use smtp_envelope_from when it was explicitly set (instance variable set)
+        params[:from_email_address] = message.smtp_envelope_from if message.instance_variable_get(:@smtp_envelope_from)
+        params[:destination] = {
+          to_addresses: to_addresses(message),
+          cc_addresses: message.cc,
+          bcc_addresses: message.bcc
+        }
+
+        @client.send_email(params).tap do |response|
+          message.header[:ses_message_id] = response.message_id
+        end
+      end
+
+      # ActionMailer expects this method to be present and to return a hash.
+      def settings
+        {}
+      end
+
+      private
+
+      # smtp_envelope_to will default to the full destinations (To, Cc, Bcc)
+      # SES v2 API prefers each component split out into a destination hash.
+      # When smtp_envelope_to was set, use it explicitly for to_address only.
+      def to_addresses(message)
+        message.instance_variable_get(:@smtp_envelope_to) ? message.smtp_envelope_to : message.to
+      end
+    end
+  end
+end

data/lib/aws/rails/sqs_active_job/configuration.rb

@@ -3,7 +3,6 @@
 module Aws
   module Rails
     module SqsActiveJob
-
       # @return [Configuration] the (singleton) Configuration
       def self.config
         @config ||= Configuration.new
@@ -21,24 +20,26 @@ module Aws
       # Configuration for AWS SQS ActiveJob.
       # Use +Aws::Rails::SqsActiveJob.config+ to access the singleton config instance.
       class Configuration
-
         # Default configuration options
         # @api private
         DEFAULTS = {
-          max_messages:  10,
-          visibility_timeout: 120,
+          max_messages: 10,
           shutdown_timeout: 15,
+          retry_standard_errors: true, # TODO: Remove in next MV
           queues: {},
           logger: ::Rails.logger,
-          message_group_id: 'SqsActiveJobGroup'
-        }
+          message_group_id: 'SqsActiveJobGroup',
+          excluded_deduplication_keys: ['job_id']
+        }.freeze
 
         # @api private
         attr_accessor :queues, :max_messages, :visibility_timeout,
                       :shutdown_timeout, :client, :logger,
                       :async_queue_error_handler, :message_group_id
 
-        # Don't use this method directly: Confugration is a singleton class, use
+        attr_reader :excluded_deduplication_keys
+
+        # Don't use this method directly: Configuration is a singleton class, use
         # +Aws::Rails::SqsActiveJob.config+ to access the singleton config.
         #
         # @param [Hash] options
@@ -50,6 +51,8 @@ module Aws
         #    The max number of messages to poll for in a batch.
         #
         # @option options [Integer] :visibility_timeout
+        #   If unset, the visibility timeout configured on the
+        #   SQS queue will be used.
         #   The visibility timeout is the number of seconds
         #   that a message will not be processable by any other consumers.
         #   You should set this value to be longer than your expected job runtime
@@ -62,11 +65,21 @@ module Aws
         #   will not be deleted from the SQS queue and will be retryable after
         #   the visibility timeout.
         #
+        # @ option options [Boolean] :retry_standard_errors
+        #   If `true`, StandardErrors raised by ActiveJobs are left on the queue
+        #   and will be retried (pending the SQS Queue's redrive/DLQ/maximum receive settings).
+        #   This behavior overrides the standard Rails ActiveJob
+        #   [Retry/Discard for failed jobs](https://guides.rubyonrails.org/active_job_basics.html#retrying-or-discarding-failed-jobs)
+        #   behavior.  When set to `true` the retries provided by this will be
+        #   on top of any retries configured on the job with `retry_on`.
+        #   When `false`, retry behavior is fully configured
+        #   through `retry_on`/`discard_on` on the ActiveJobs.
+        #
         # @option options [ActiveSupport::Logger] :logger Logger to use
         #   for the poller.
         #
         # @option options [String] :config_file
-        #   Override file to load configuration from.  If not specified will
+        #   Override file to load configuration from. If not specified will
         #   attempt to load from config/aws_sqs_active_job.yml.
         #
         # @option options [String] :message_group_id (SqsActiveJobGroup)
@@ -80,18 +93,31 @@ module Aws
         #   +active_job.queue_adapter = :amazon_sqs_async+.  Called with:
         #   [error, job, job_options]
         #
-        # @option options [SQS::Client] :client SQS Client to use.  A default
+        # @option options [SQS::Client] :client SQS Client to use. A default
         #   client will be created if none is provided.
+        #
+        # @option options [Array] :excluded_deduplication_keys (['job_id'])
+        #   The type of keys stored in the array should be String or Symbol.
+        #   Using this option, job_id is implicitly added to the keys.
+
         def initialize(options = {})
-          options[:config_file] ||= config_file if config_file.exist?
+          options[:config_file] ||= config_file if File.exist?(config_file)
           options = DEFAULTS
-             .merge(file_options(options))
-             .merge(options)
+                    .merge(file_options(options))
+                    .merge(options)
           set_attributes(options)
         end
 
+        def excluded_deduplication_keys=(keys)
+          @excluded_deduplication_keys = keys.map(&:to_s) | ['job_id']
+        end
+
         def client
-          @client ||= Aws::SQS::Client.new(user_agent_suffix: user_agent)
+          @client ||= begin
+            client = Aws::SQS::Client.new
+            client.config.user_agent_frameworks << 'aws-sdk-rails'
+            client
+          end
         end
 
         # Return the queue_url for a given job_queue name
@@ -99,7 +125,7 @@ module Aws
           job_queue = job_queue.to_sym
           raise ArgumentError, "No queue defined for #{job_queue}" unless queues.key? job_queue
 
-          queues[job_queue.to_sym]
+          queues[job_queue]
         end
 
         # @api private
@@ -110,9 +136,9 @@ module Aws
         # @api private
         def to_h
           h = {}
-          self.instance_variables.each do |v|
-            v_sym = v.to_s.gsub('@', '').to_sym
-            val = self.instance_variable_get(v)
+          instance_variables.each do |v|
+            v_sym = v.to_s.delete('@').to_sym
+            val = instance_variable_get(v)
             h[v_sym] = val
           end
           h
@@ -122,8 +148,9 @@ module Aws
 
         # Set accessible attributes after merged options.
         def set_attributes(options)
-          options.keys.each do |opt_name|
+          options.each_key do |opt_name|
             instance_variable_set("@#{opt_name}", options[opt_name])
+            client.config.user_agent_frameworks << 'aws-sdk-rails' if opt_name == :client
           end
         end
 
@@ -138,24 +165,34 @@ module Aws
 
         def config_file
           file = ::Rails.root.join("config/aws_sqs_active_job/#{::Rails.env}.yml")
-          file = ::Rails.root.join('config/aws_sqs_active_job.yml') unless file.exist?
+          file = ::Rails.root.join('config/aws_sqs_active_job.yml') unless File.exist?(file)
           file
         end
 
         # Load options from YAML file
         def load_from_file(file_path)
-          require "erb"
-          opts = YAML.load(ERB.new(File.read(file_path)).result) || {}
+          opts = load_yaml(file_path) || {}
           opts.deep_symbolize_keys
         end
 
         # @return [String] Configuration path found in environment or YAML file.
         def config_file_path(options)
-          options[:config_file] || ENV["AWS_SQS_ACTIVE_JOB_CONFIG_FILE"]
+          options[:config_file] || ENV.fetch('AWS_SQS_ACTIVE_JOB_CONFIG_FILE', nil)
         end
 
-        def user_agent
-          "ft/aws-sdk-rails-activejob/#{Aws::Rails::VERSION}"
+        def load_yaml(file_path)
+          require 'erb'
+          source = ERB.new(File.read(file_path)).result
+
+          # Avoid incompatible changes with Psych 4.0.0
+          # https://bugs.ruby-lang.org/issues/17866
+          # rubocop:disable Security/YAMLLoad
+          begin
+            YAML.load(source, aliases: true) || {}
+          rescue ArgumentError
+            YAML.load(source) || {}
+          end
+          # rubocop:enable Security/YAMLLoad
         end
       end
     end