Configuring Rails Applications

This guide covers the configuration and initialization features available to Rails applications.

After reading this guide, you will know:

How to adjust the behavior of your Rails applications.
How to add additional code to be run at application start time.

1. Locations for Initialization Code

Rails offers four standard spots to place initialization code:

config/application.rb
Environment-specific configuration files
Initializers
After-initializers

2. Running Code Before Rails

In the rare event that your application needs to run some code before Rails itself is loaded, put it above the call torequire "rails/all" inconfig/application.rb.

3. Configuring Rails Components

In general, the work of configuring Rails means configuring the components of Rails, as well as configuring Rails itself. The configuration fileconfig/application.rb and environment-specific configuration files (such asconfig/environments/production.rb) allow you to specify the various settings that you want to pass down to all of the components.

For example, you could add this setting toconfig/application.rb file:

config.time_zone="Central Time (US & Canada)"

This is a setting for Rails itself. If you want to pass settings to individual Rails components, you can do so via the sameconfig object inconfig/application.rb:

config.active_record.schema_format=:ruby

Rails will use that particular setting to configure Active Record.

Use the public configuration methods over calling directly to the associated class. e.g.Rails.application.config.action_mailer.options instead ofActionMailer::Base.options.

If you need to apply configuration directly to a class, use alazy load hook in an initializer to avoid autoloading the class before initialization has completed. This will break because autoloading during initialization cannot be safely repeated when the app reloads.

3.1. Versioned Default Values

config.load_defaults loads default configuration values for a target version and all versions prior. For example,config.load_defaults 6.1 will load defaults for all versions up to and including version 6.1.

Below are the default values associated with each target version. In cases of conflicting values, newer versions take precedence over older versions.

3.1.6. Default Values for Target Version 6.1

3.1.7. Default Values for Target Version 6.0

config.action_dispatch.use_cookies_with_metadata:true
config.action_mailer.delivery_job:"ActionMailer::MailDeliveryJob"
config.action_view.default_enforce_utf8:false
config.active_record.collection_cache_versioning:true
config.active_storage.queues.analysis::active_storage_analysis
config.active_storage.queues.purge::active_storage_purge

3.1.8. Default Values for Target Version 5.2

config.action_controller.default_protect_from_forgery:true
config.action_dispatch.use_authenticated_cookie_encryption:true
config.action_view.form_with_generates_ids:true
config.active_record.cache_versioning:true
config.active_support.hash_digest_class:OpenSSL::Digest::SHA1
config.active_support.use_authenticated_message_encryption:true

3.1.9. Default Values for Target Version 5.1

3.1.10. Default Values for Target Version 5.0

config.action_controller.forgery_protection_origin_check:true
config.action_controller.per_form_csrf_tokens:true
config.active_record.belongs_to_required_by_default:true
config.ssl_options:{ hsts: { subdomains: true } }

3.2. Rails General Configuration

The following configuration methods are to be called on aRails::Railtie object, such as a subclass ofRails::Engine orRails::Application.

3.2.1.`config.add_autoload_paths_to_load_path`

Says whether autoload paths have to be added to$LOAD_PATH. It is recommended to be set tofalse in:zeitwerk mode early, inconfig/application.rb. Zeitwerk uses absolute paths internally, and applications running in:zeitwerk mode do not needrequire_dependency, so models, controllers, jobs, etc. do not need to be in$LOAD_PATH. Setting this tofalse saves Ruby from checking these directories when resolvingrequire calls with relative paths, and saves Bootsnap work and RAM, since it does not need to build an index for them.

The default value depends on theconfig.load_defaults target version:

Starting with version	The default value is
(original)	`true`
7.1	`false`

Thelib directory is not affected by this flag, it is added to$LOAD_PATH always.

3.2.2.`config.after_initialize`

Takes a block which will be runafter Rails has finished initializing the application. That includes the initialization of the framework itself, engines, and all the application's initializers inconfig/initializers. Note that this blockwill be run for rake tasks. Useful for configuring values set up by other initializers:

config.after_initializedoActionView::Base.sanitized_allowed_tags.delete"div"end

3.2.3.`config.after_routes_loaded`

Takes a block which will be run after Rails has finished loading the application routes. This block will also be run whenever routes are reloaded.

config.after_routes_loadeddo# Code that does something with Rails.application.routesend

3.2.4.`config.allow_concurrency`

Controls whether requests should be handled concurrently. This should onlybe set tofalse if application code is not thread safe. Defaults totrue.

3.2.5.`config.asset_host`

Sets the host for the assets. Useful when CDNs are used for hosting assets, or when you want to work around the concurrency constraints built-in in browsers using different domain aliases. Shorter version ofconfig.action_controller.asset_host.

3.2.6.`config.assume_ssl`

Makes application believe that all requests are arriving over SSL. This is useful when proxying through a load balancer that terminates SSL, the forwarded request will appear as though it's HTTP instead of HTTPS to the application. This makes redirects and cookie security target HTTP instead of HTTPS. This middleware makes the server assume that the proxy already terminated SSL, and that the request really is HTTPS.

3.2.7.`config.autoflush_log`

Enables writing log file output immediately instead of buffering. Defaults totrue.

3.2.8.`config.autoload_lib(ignore:)`

This method addslib toconfig.autoload_paths andconfig.eager_load_paths.

Normally, thelib directory has subdirectories that should not be autoloaded or eager loaded. Please, pass their name relative tolib in the requiredignore keyword argument. For example,

config.autoload_lib(ignore:%w(assets tasks generators))

Please, see more details in theautoloading guide.

3.2.9.`config.autoload_lib_once(ignore:)`

The methodconfig.autoload_lib_once is similar toconfig.autoload_lib, except that it addslib toconfig.autoload_once_paths instead.

By callingconfig.autoload_lib_once, classes and modules inlib can be autoloaded, even from application initializers, but won't be reloaded.

3.2.10.`config.autoload_once_paths`

Accepts an array of paths from which Rails will autoload constants that won't be wiped per request. Relevant if reloading is enabled, which it is by default in thedevelopment environment. Otherwise, all autoloading happens only once. All elements of this array must also be inautoload_paths. Default is an empty array.

3.2.11.`config.autoload_paths`

Accepts an array of paths from which Rails will autoload constants. Default is an empty array. SinceRails 6, it is not recommended to adjust this. SeeAutoloading and Reloading Constants.

3.2.12.`config.beginning_of_week`

Sets the default beginning of week for theapplication. Accepts a valid day of week as a symbol (e.g.:monday).

3.2.13.`config.cache_classes`

Old setting equivalent to!config.enable_reloading. Supported for backwards compatibility.

3.2.14.`config.cache_store`

Configures which cache store to use for Rails caching. Options include one of the symbols:memory_store,:file_store,:mem_cache_store,:null_store,:redis_cache_store, or an object that implements the cache API. Defaults to:file_store. SeeCache Stores for per-store configuration options.

3.2.15.`config.colorize_logging`

Specifies whether or not to use ANSI color codes when logging information. Defaults totrue.

3.2.16.`config.consider_all_requests_local`

Is a flag. Iftrue then any error will cause detailed debugging information to be dumped in the HTTP response, and theRails::Info controller will show the application runtime context in/rails/info/properties.true by default in the development and test environments, andfalse in production. For finer-grained control, set this tofalse and implementshow_detailed_exceptions? in controllers to specify which requests should provide debugging information on errors.

3.2.17.`config.console`

Allows you to set the class that will be used as console when you runbin/rails console. It's best to run it in theconsole block:

consoledo# this block is called only when running console,# so we can safely require pry hererequire"pry"config.console=Pryend

3.2.18.`config.content_security_policy_nonce_auto`

SeeAdding a Nonce in the Security Guide

3.2.19.`config.content_security_policy_nonce_directives`

SeeAdding a Nonce in the Security Guide

3.2.20.`config.content_security_policy_nonce_generator`

SeeAdding a Nonce in the Security Guide

3.2.21.`config.content_security_policy_report_only`

SeeReporting Violations in the SecurityGuide

3.2.22.`config.credentials.content_path`

The path of the encrypted credentials file.

Defaults toconfig/credentials/#{Rails.env}.yml.enc if it exists, orconfig/credentials.yml.enc otherwise.

In order for thebin/rails credentials commands to recognize this value,it must be set inconfig/application.rb orconfig/environments/#{Rails.env}.rb.

3.2.23.`config.credentials.key_path`

The path of the encrypted credentials key file.

Defaults toconfig/credentials/#{Rails.env}.key if it exists, orconfig/master.key otherwise.

In order for thebin/rails credentials commands to recognize this value,it must be set inconfig/application.rb orconfig/environments/#{Rails.env}.rb.

3.2.24.`config.debug_exception_response_format`

Sets the format used in responses when errors occur in the development environment. Defaults to:api for API only apps and:default for normal apps.

3.2.25.`config.disable_sandbox`

Controls whether or not someone can start a console in sandbox mode. This is helpful to avoid a long running session of sandbox console, that could lead a database server to run out of memory. Defaults tofalse.

3.2.26.`config.dom_testing_default_html_version`

Controls whether an HTML4 parser or an HTML5 parser is used by default by the test helpers in Action View, Action Dispatch, andrails-dom-testing.

The default value depends on theconfig.load_defaults target version:

Starting with version	The default value is
(original)	`:html4`
7.1	`:html5` (see NOTE)

Nokogiri's HTML5 parser is not supported on JRuby, so on JRuby platforms Rails will fall back to:html4.

3.2.27.`config.eager_load`

Whentrue, eager loads all registeredconfig.eager_load_namespaces. This includes your application, engines, Rails frameworks, and any other registered namespace.

3.2.28.`config.eager_load_namespaces`

Registers namespaces that are eager loaded whenconfig.eager_load is set totrue. All namespaces in the list must respond to theeager_load! method.

3.2.29.`config.eager_load_paths`

Accepts an array of paths from which Rails will eager load on boot ifconfig.eager_load is true. Defaults to every folder in theapp directory of the application.

3.2.30.`config.enable_reloading`

Ifconfig.enable_reloading is true, application classes and modules are reloaded in between web requests if they change. Defaults totrue in thedevelopment environment, andfalse in theproduction environment.

The predicateconfig.reloading_enabled? is also defined.

3.2.31.`config.encoding`

Sets up the application-wide encoding. Defaults to UTF-8.

3.2.32.`config.exceptions_app`

Sets the exceptions application invoked by theShowException middleware when an exception happens.Defaults toActionDispatch::PublicExceptions.new(Rails.public_path).

3.2.33.`config.file_watcher`

Is the class used to detect file updates in the file system whenconfig.reload_classes_only_on_change istrue. Rails ships withActiveSupport::FileUpdateChecker, the default, andActiveSupport::EventedFileUpdateChecker. Custom classes must conform to theActiveSupport::FileUpdateChecker API.

UsingActiveSupport::EventedFileUpdateChecker depends on thelisten gem:

group:developmentdogem"listen","~> 3.5"end

On Linux and macOS no additional gems are needed, but some are requiredfor *BSD andfor Windows.

Note thatsome setups are unsupported.

3.2.34.`config.filter_parameters`

Used for filtering out the parameters that you don't want shown in the logs,such as passwords or credit card numbers. It also filters out sensitive valuesof database columns when calling#inspect on an Active Record object. Bydefault, Rails filters out passwords by adding the following filters inconfig/initializers/filter_parameter_logging.rb.

Rails.application.config.filter_parameters+=[:passw,:email,:secret,:token,:_key,:crypt,:salt,:certificate,:otp,:ssn,:cvv,:cvc]

Parameters filter works by partial matching regular expression.

3.2.35.`config.filter_redirect`

Used for filtering out redirect urls from application logs.

Rails.application.config.filter_redirect+=["s3.amazonaws.com",/private-match/]

The redirect filter works by testing that urls include strings or match regularexpressions.

3.2.36.`config.force_ssl`

Forces all requests to be served over HTTPS, and sets "https://" as the default protocol when generating URLs. Enforcement of HTTPS is handled by theActionDispatch::SSL middleware, which can be configured viaconfig.ssl_options.

3.2.37.`config.helpers_paths`

Defines an array of additional paths to load view helpers.

3.2.38.`config.host_authorization`

Accepts a hash of options to configure theHostAuthorizationmiddleware

3.2.39.`config.hosts`

An array of strings, regular expressions, orIPAddr used to validate theHost header. Used by theHostAuthorizationmiddleware to help prevent DNS rebindingattacks.

3.2.40.`config.javascript_path`

Sets the path where your app's JavaScript lives relative to theapp directory and the default value isjavascript.An app's configuredjavascript_path will be excluded fromautoload_paths.

3.2.41.`config.log_file_size`

Defines the maximum size of the Rails log file in bytes. Defaults to104_857_600 (100 MiB) in development and test, and unlimited in all other environments.

3.2.42.`config.log_formatter`

Defines the formatter of the Rails logger. This option defaults to an instance ofActiveSupport::Logger::SimpleFormatter for all environments. If you are setting a value forconfig.logger you must manually pass the value of your formatter to your logger before it is wrapped in anActiveSupport::TaggedLogging instance, Rails will not do it for you.

3.2.43.`config.log_level`

Defines the verbosity of the Rails logger. This option defaults to:debug for all environments except production, where it defaults to:info. The available log levels are::debug,:info,:warn,:error,:fatal, and:unknown.

3.2.44.`config.log_tags`

Accepts a list of methods that therequest object responds to, aProc that accepts therequest object, or something that responds toto_s. This makes it easy to tag log lines with debug information like subdomain and request id - both very helpful in debugging multi-user production applications.

3.2.45.`config.logger`

Is the logger that will be used forRails.logger and any related Rails logging such asActiveRecord::Base.logger. It defaults to an instance ofActiveSupport::TaggedLogging that wraps an instance ofActiveSupport::Logger which outputs a log to thelog/ directory. You can supply a custom logger, to get full compatibility you must follow these guidelines:

To support a formatter, you must manually assign a formatter from theconfig.log_formatter value to the logger.
To support tagged logs, the log instance must be wrapped withActiveSupport::TaggedLogging.
To support silencing, the logger must includeActiveSupport::LoggerSilence module. TheActiveSupport::Logger class already includes these modules.

classMyLogger<::LoggerincludeActiveSupport::LoggerSilenceendmylogger=MyLogger.new(STDOUT)mylogger.formatter=config.log_formatterconfig.logger=ActiveSupport::TaggedLogging.new(mylogger)

3.2.46.`config.middleware`

Allows you to configure the application's middleware. This is covered in depth in theConfiguring Middleware section below.

3.2.47.`config.precompile_filter_parameters`

Whentrue, will precompileconfig.filter_parametersusingActiveSupport::ParameterFilter.precompile_filters.

The default value depends on theconfig.load_defaults target version:

Starting with version	The default value is
(original)	`false`
7.1	`true`

3.2.48.`config.public_file_server.enabled`

Configures whether Rails should serve static files from the public directory.Defaults totrue.

If the server software (e.g. NGINX or Apache) should serve static files instead,set this value tofalse.

3.2.49.`config.railties_order`

Allows manually specifying the order that Railties/Engines are loaded. Thedefault value is[:all].

config.railties_order=[Blog::Engine,:main_app,:all]

3.2.50.`config.rake_eager_load`

Whentrue, eager load the application when running Rake tasks. Defaults tofalse.

3.2.51.`config.relative_url_root`

Can be used to tell Rails that you aredeploying to a subdirectory. The defaultisENV['RAILS_RELATIVE_URL_ROOT'].

3.2.52.`config.reload_classes_only_on_change`

Enables or disables reloading of classes only when tracked files change. By default tracks everything on autoload paths and is set totrue. Ifconfig.enable_reloading isfalse, this option is ignored.

3.2.53.`config.require_master_key`

Causes the app to not boot if a master key hasn't been made available throughENV["RAILS_MASTER_KEY"] or theconfig/master.key file.

3.2.54.`config.sandbox_by_default`

Whentrue, rails console starts in sandbox mode. To start rails console in non-sandbox mode,--no-sandbox must be specified. This is helpful to avoid accidental writing to the production database. Defaults tofalse.

3.2.55.`config.secret_key_base`

The fallback for specifying the input secret for an application's key generator.It is recommended to leave this unset, and instead to specify asecret_key_baseinconfig/credentials.yml.enc. See thesecret_key_base API documentationfor more information and alternative configuration methods.

3.2.56.`config.server_timing`

Whentrue, adds theServerTiming middlewareto the middleware stack. Defaults tofalse, but is set totrue in thedefault generatedconfig/environments/development.rb file.

3.2.57.`config.session_options`

Additional options passed toconfig.session_store. You should useconfig.session_store to set this instead of modifying it yourself.

config.session_store:cookie_store,key:"_your_app_session"config.session_options# => {key: "_your_app_session"}

3.2.58.`config.session_store`

Specifies what class to use to store the session. Possible values are:cache_store,:cookie_store,:mem_cache_store, a custom store, or:disabled.:disabled tells Rails not to deal with sessions.

This setting is configured via a regular method call, rather than a setter. This allows additional options to be passed:

config.session_store:cookie_store,key:"_your_app_session"

If a custom store is specified as a symbol, it will be resolved to theActionDispatch::Session namespace:

# use ActionDispatch::Session::MyCustomStore as the session storeconfig.session_store:my_custom_store

The default store is a cookie store with the application name as the session key.

3.2.59.`config.silence_healthcheck_path`

Specifies the path of the health check that should be silenced in the logs. UsesRails::Rack::SilenceRequest to implement the silencing. All in service of keeping health checks from clogging the production logs, especially for early-stage applications.

config.silence_healthcheck_path = "/up"

3.2.60.`config.ssl_options`

Configuration options for theActionDispatch::SSL middleware.

The default value depends on theconfig.load_defaults target version:

Starting with version	The default value is
(original)	`{}`
5.0	`{ hsts: { subdomains: true } }`

3.2.61.`config.time_zone`

Sets the default time zone for the application and enables time zone awareness for Active Record.

3.2.62.`config.x`

Used to easily add nested custom configuration to the application config object

config.x.payment_processing.schedule=:dailyRails.configuration.x.payment_processing.schedule# => :daily

SeeCustom Configuration

3.2.63.`config.yjit`

Enables YJIT as of Ruby 3.3, to bring sizeable performance improvements. If you aredeploying to a memory constrained environment you may want to set this tofalse.Additionally, you can pass a hash to configure YJIT options such as{ stats: true }.

Starting with version	The default value is
(original)	`false`
7.2	`true`
8.1	`!Rails.env.local?`

3.3. Configuring Assets

3.3.1.`config.assets.css_compressor`

Defines the CSS compressor to use. It is set by default bysass-rails. The unique alternative value at the moment is:yui, which uses theyui-compressor gem.

3.3.2.`config.assets.js_compressor`

Defines the JavaScript compressor to use. Possible values are:terser,:closure,:uglifier, and:yui, which require the use of theterser,closure-compiler,uglifier, oryui-compressor gems respectively.

3.3.3.`config.assets.gzip`

A flag that enables the creation of gzipped version of compiled assets, along with non-gzipped assets. Set totrue by default.

3.3.4.`config.assets.paths`

Contains the paths which are used to look for assets. Appending paths to this configuration option will cause those paths to be used in the search for assets.

3.3.5.`config.assets.precompile`

Allows you to specify additional assets (other thanapplication.css andapplication.js) which are to be precompiled whenbin/rails assets:precompile is run.

3.3.6.`config.assets.unknown_asset_fallback`

Allows you to modify the behavior of the asset pipeline when an asset is not in the pipeline, if you use sprockets-rails 3.2.0 or newer.

The default value depends on theconfig.load_defaults target version:

Starting with version	The default value is
(original)	`true`
5.1	`false`

3.3.7.`config.assets.prefix`

Defines the prefix where assets are served from. Defaults to/assets.

3.3.8.`config.assets.manifest`

Defines the full path to be used for the asset precompiler's manifest file. Defaults to a file namedmanifest-<random>.json in theconfig.assets.prefix directory within the public folder.

3.3.9.`config.assets.digest`

Enables the use of SHA256 fingerprints in asset names. Set totrue by default.

3.3.10.`config.assets.debug`

Disables the concatenation and compression of assets.

3.3.11.`config.assets.version`

Is an option string that is used in SHA256 hash generation. This can be changed to force all files to be recompiled.

3.3.12.`config.assets.compile`

Is a boolean that can be used to turn on live Sprockets compilation in production.

3.3.13.`config.assets.logger`

Accepts a logger conforming to the interface of Log4r or the default RubyLogger class. Defaults to the same configured atconfig.logger. Settingconfig.assets.logger tofalse will turn off served assets logging.

3.3.14.`config.assets.quiet`

Disables logging of assets requests. Set totrue by default inconfig/environments/development.rb.

3.4. Configuring Generators

Rails allows you to alter what generators are used with theconfig.generators method. This method takes a block:

config.generatorsdo|g|g.orm:active_recordg.test_framework:test_unitend

The full set of methods that can be used in this block are as follows:

force_plural allows pluralized model names. Defaults tofalse.
helper defines whether or not to generate helpers. Defaults totrue.
integration_tool defines which integration tool to use to generate integration tests. Defaults to:test_unit.
system_tests defines which integration tool to use to generate system tests. Defaults to:test_unit.
orm defines which orm to use. Defaults tofalse and will use Active Record by default.
resource_controller defines which generator to use for generating a controller when usingbin/rails generate resource. Defaults to:controller.
resource_route defines whether a resource route definition should be generatedor not. Defaults totrue.
scaffold_controller different fromresource_controller, defines which generator to use for generating ascaffolded controller when usingbin/rails generate scaffold. Defaults to:scaffold_controller.
test_framework defines which test framework to use. Defaults tofalse and will use minitest by default.
template_engine defines which template engine to use, such as ERB or Haml. Defaults to:erb.
apply_rubocop_autocorrect_after_generate! applies RuboCop's autocorrect feature after Rails generators are run.

3.5. Configuring Middleware

Every Rails application comes with a standard set of middleware which it uses in this order in the development environment:

3.5.1.`ActionDispatch::HostAuthorization`

Prevents against DNS rebinding and otherHost header attacks.It is included in the development environment by default with the following configuration:

Rails.application.config.hosts=[IPAddr.new("0.0.0.0/0"),# All IPv4 addresses.IPAddr.new("::/0"),# All IPv6 addresses."localhost",# The localhost reserved domain.ENV["RAILS_DEVELOPMENT_HOSTS"]# Additional comma-separated hosts for development.]

In other environmentsRails.application.config.hosts is empty and noHost header checks will be done. If you want to guard against headerattacks on production, you have to manually permit the allowed hostswith:

Rails.application.config.hosts<<"product.com"

The host of a request is checked against thehosts entries with the caseoperator (#===), which letshosts support entries of typeRegexp,Proc andIPAddr to name a few. Here is an example with a regexp.

# Allow requests from subdomains like `www.product.com` and# `beta1.product.com`.Rails.application.config.hosts<</.*\.product\.com/

The provided regexp will be wrapped with both anchors (\A and\z) so itmust match the entire hostname./product.com/, for example, once anchored,would fail to matchwww.product.com.

A special case is supported that allows you to permit the domain and all sub-domains:

# Allow requests from the domain itself `product.com` and subdomains like `www.product.com` and `beta1.product.com`.Rails.application.config.hosts<<".product.com"

You can exclude certain requests from Host Authorization checks by settingconfig.host_authorization.exclude:

# Exclude requests for the /healthcheck/ path from host checkingRails.application.config.host_authorization={exclude:->(request){request.path.include?("healthcheck")}}

When a request comes to an unauthorized host, a default Rack applicationwill run and respond with403 Forbidden. This can be customized by settingconfig.host_authorization.response_app. For example:

Rails.application.config.host_authorization={response_app:->envdo[400,{"Content-Type"=>"text/plain"},["Bad Request"]]end}

3.5.2.`ActionDispatch::ServerTiming`

Adds theServer-Timing header to the response, which includes performancemetrics from the server. This data can be viewed by inspecting the response inthe Network panel of the browser's Developer Tools. Most browsers provide aTiming tab that visualizes the data.

3.5.3.`ActionDispatch::SSL`

Forces every request to be served using HTTPS. Enabled ifconfig.force_ssl is set totrue. Options passed to this can be configured by settingconfig.ssl_options.

3.5.4.`ActionDispatch::Static`

Is used to serve static assets. Disabled ifconfig.public_file_server.enabled isfalse. Setconfig.public_file_server.index_name if you need to serve a static directory index file that is not namedindex. For example, to servemain.html instead ofindex.html for directory requests, setconfig.public_file_server.index_name to"main".

3.5.5.`ActionDispatch::Executor`

Allows thread safe code reloading. Disabled ifconfig.allow_concurrency isfalse, which causesRack::Lock to be loaded.Rack::Lock wraps the app in mutex so it can only be called by a single thread at a time.

3.5.6.`ActiveSupport::Cache::Strategy::LocalCache`

Serves as a basic memory backed cache. This cache is not thread safe and is intended only for serving as a temporary memory cache for a single thread.

3.5.7.`Rack::Runtime`

Sets anX-Runtime header, containing the time (in seconds) taken to execute the request.

3.5.8.`Rails::Rack::Logger`

Notifies the logs that the request has begun. After request is complete, flushes all the logs.

3.5.9.`ActionDispatch::ShowExceptions`

Rescues any exception returned by the application and renders nice exception pages if the request is local or ifconfig.consider_all_requests_local is set totrue. Ifconfig.action_dispatch.show_exceptions is set to:none, exceptions will be raised regardless.

3.5.10.`ActionDispatch::RequestId`

Makes a unique X-Request-Id header available to the response and enables theActionDispatch::Request#uuid method. Configurable withconfig.action_dispatch.request_id_header.

3.5.11.`ActionDispatch::RemoteIp`

Checks for IP spoofing attacks and gets validclient_ip from request headers. Configurable with theconfig.action_dispatch.ip_spoofing_check, andconfig.action_dispatch.trusted_proxies options.

3.5.12.`Rack::Sendfile`

Intercepts responses whose body is being served from a file and replaces it with a server specific X-Sendfile header. Configurable withconfig.action_dispatch.x_sendfile_header.

3.5.13.`ActionDispatch::Callbacks`

Runs the prepare callbacks before serving the request.

3.5.14.`ActionDispatch::Cookies`

Sets cookies for the request.

3.5.15.`ActionDispatch::Session::CookieStore`

Is responsible for storing the session in cookies. An alternate middleware can be used for this by changingconfig.session_store.

3.5.16.`ActionDispatch::Flash`

Sets up theflash keys. Only available ifconfig.session_store is set to a value.

3.5.17.`Rack::MethodOverride`

Allows the method to be overridden ifparams[:_method] is set. This is the middleware which supports the PATCH, PUT, and DELETE HTTP method types.

3.5.18.`Rack::Head`

Returns an empty body for all HEAD requests. It leaves all other requests unchanged.

3.5.19. Adding Custom Middleware

Besides these usual middleware, you can add your own by using theconfig.middleware.use method:

config.middleware.useMagical::Unicorns

This will put theMagical::Unicorns middleware on the end of the stack. You can useinsert_before if you wish to add a middleware before another.

config.middleware.insert_beforeRack::Head,Magical::Unicorns

Or you can insert a middleware to exact position by using indexes. For example, if you want to insertMagical::Unicorns middleware on top of the stack, you can do it, like so:

config.middleware.insert_before0,Magical::Unicorns

There's alsoinsert_after which will insert a middleware after another:

config.middleware.insert_afterRack::Head,Magical::Unicorns

Middlewares can also be completely swapped out and replaced with others:

config.middleware.swapActionController::Failsafe,Lifo::Failsafe

Middlewares can be moved from one place to another:

config.middleware.move_beforeActionDispatch::Flash,Magical::Unicorns

This will move theMagical::Unicorns middleware beforeActionDispatch::Flash. You can also move it after:

config.middleware.move_afterActionDispatch::Flash,Magical::Unicorns

They can also be removed from the stack completely:

config.middleware.deleteRack::MethodOverride

3.6. Configuring i18n

All these configuration options are delegated to theI18n library.

3.6.1.`config.i18n.available_locales`

Defines the permitted available locales for the app. Defaults to all locale keys found in locale files, usually only:en on a new application.

3.6.2.`config.i18n.default_locale`

Sets the default locale of an application used for i18n. Defaults to:en.

3.6.3.`config.i18n.enforce_available_locales`

Ensures that all locales passed through i18n must be declared in theavailable_locales list, raising anI18n::InvalidLocale exception when setting an unavailable locale. Defaults totrue. It is recommended not to disable this option unless strongly required, since this works as a security measure against setting any invalid locale from user input.

3.6.4.`config.i18n.load_path`

Sets the path Rails uses to look for locale files. Defaults toconfig/locales/**/*.{yml,rb}.

3.6.5.`config.i18n.raise_on_missing_translations`

Determines whether an error should be raised for missing translations. Iftrue, views and controllers raiseI18n::MissingTranslationData. If:strict, models also raise the error. This defaults tofalse.

3.6.6.`config.i18n.fallbacks`

Sets fallback behavior for missing translations. Here are 3 usage examples for this option:

You can set the option totrue for using default locale as fallback, like so:
```
config.i18n.fallbacks=true
```
Or you can set an array of locales as fallback, like so:
```
config.i18n.fallbacks=[:tr,:en]
```
Or you can set different fallbacks for locales individually. For example, if you want to use:tr for:az and:de,:en for:da as fallbacks, you can do it, like so:
```
config.i18n.fallbacks={az: :tr,da:[:de,:en]}#orconfig.i18n.fallbacks.map={az: :tr,da:[:de,:en]}
```

3.7. Configuring Active Model

3.7.1.`config.active_model.i18n_customize_full_message`

Controls whether theError#full_message format can be overridden in an i18n locale file. Defaults tofalse.

When set totrue,full_message will look for a format at the attribute and model level of the locale files. The default format is"%{attribute} %{message}", whereattribute is the name of the attribute, andmessage is the validation-specific message. The following example overrides the format for allPerson attributes, as well as the format for a specificPerson attribute (age).

classPersonincludeActiveModel::Validationsattr_accessor:name,:agevalidates:name,:age,presence:trueend

en:activemodel:# or activerecord:errors:models:person:# Override the format for all Person attributes:format:"Invalid%{attribute}(%{message})"attributes:age:# Override the format for the age attribute:format:"%{message}"blank:"Pleasefillinyour%{attribute}"

irb>person=Person.new.tap(&:valid?)irb>person.errors.full_messages=>["Invalid Name (can't be blank)","Please fill in your Age"]irb>person.errors.messages=>{:name=>["can't be blank"],:age=>["Please fill in your Age"]}

3.8. Configuring Active Record

config.active_record includes a variety of configuration options:

3.8.1.`config.active_record.logger`

Accepts a logger conforming to the interface of Log4r or the default Ruby Logger class, which is then passed on to any new database connections made. You can retrieve this logger by callinglogger on either an Active Record model class or an Active Record model instance. Set tonil to disable logging.

3.8.2.`config.active_record.primary_key_prefix_type`

Lets you adjust the naming for primary key columns. By default, Rails assumes that primary key columns are namedid (and this configuration option doesn't need to be set). There are two other choices:

:table_name would make the primary key for the Customer classcustomerid.
:table_name_with_underscore would make the primary key for the Customer classcustomer_id.

3.8.3.`config.active_record.table_name_prefix`

Lets you set a global string to be prepended to table names. If you set this tonorthwest_, then the Customer class will look fornorthwest_customers as its table. The default is an empty string.

3.8.4.`config.active_record.table_name_suffix`

Lets you set a global string to be appended to table names. If you set this to_northwest, then the Customer class will look forcustomers_northwest as its table. The default is an empty string.

3.8.5.`config.active_record.schema_migrations_table_name`

Lets you set a string to be used as the name of the schema migrations table.

3.8.6.`config.active_record.internal_metadata_table_name`

Lets you set a string to be used as the name of the internal metadata table.

3.8.7.`config.active_record.protected_environments`

Lets you set an array of names of environments where destructive actions should be prohibited.

3.8.8.`config.active_record.pluralize_table_names`

Specifies whether Rails will look for singular or plural table names in the database. If set totrue (the default), then the Customer class will use thecustomers table. If set tofalse, then the Customer class will use thecustomer table.

Some Rails generators and installers (notablyactive_storage:installandaction_text:install) create tables with plural names regardless of thissetting. If you setpluralize_table_names tofalse, you will need tomanually rename those tables after installation to maintain consistency.This limitation exists because these installers use fixed table namesin their migrations for compatibility reasons.

3.8.9.`config.active_record.default_timezone`

Determines whether to useTime.local (if set to:local) orTime.utc (if set to:utc) when pulling dates and times from the database. The default is:utc.

3.8.10.`config.active_record.schema_format`

Controls the format for dumping the database schema to a file. The options are:ruby (the default) for a database-independent version that depends on migrations, or:sql for a set of (potentially database-dependent) SQL statements. This can be overridden per-database by settingschema_format in your database configuration.

3.8.11.`config.active_record.error_on_ignored_order`

Specifies if an error should be raised if the order of a query is ignored during a batch query. The options aretrue (raise error) orfalse (warn). Default isfalse.

3.8.12.`config.active_record.timestamped_migrations`

Controls whether migrations are numbered with serial integers or with timestamps. The default istrue, to use timestamps, which are preferred if there are multiple developers working on the same application.

3.8.13.`config.active_record.automatically_invert_plural_associations`

Controls whether Active Record will automatically look for inverse relations with a pluralized name.

Example:

classPost<ApplicationRecordhas_many:commentsendclassComment<ApplicationRecordbelongs_to:postend

In the above case Active Record used to only look for a:comment (singular) association inPost, and won't find it.

With this option enabled, it will also look for a:comments association. In the vast majority of caseshaving the inverse association discovered is beneficial as it can prevent some useless queries, butit may cause backward compatibility issues with legacy code that doesn't expect it.

This behavior can be disabled on a per-model basis:

classComment<ApplicationRecordself.automatically_invert_plural_associations=falsebelongs_to:postend

And on a per-association basis:

classComment<ApplicationRecordself.automatically_invert_plural_associations=truebelongs_to:post,inverse_of:nilend

Starting with version	The default value is
(original)	`false`

3.8.14.`config.active_record.validate_migration_timestamps`

Controls whether to validate migration timestamps. When set, an error will be raised if thetimestamp prefix for a migration is more than a day ahead of the timestamp associated with thecurrent time. This is done to prevent forward-dating of migration files, which can impact migrationgeneration and other migration commands.config.active_record.timestamped_migrations must be set totrue.

The default value depends on theconfig.load_defaults target version:

Starting with version	The default value is
(original)	`false`
7.2	`true`

3.8.15.`config.active_record.db_warnings_action`

Controls the action to be taken when an SQL query produces a warning. The following options are available:

:ignore - Database warnings will be ignored. This is the default.
:log - Database warnings will be logged viaActiveRecord.logger at the:warn level.
:raise - Database warnings will be raised asActiveRecord::SQLWarning.
:report - Database warnings will be reported to subscribers of Rails' error reporter.

Custom proc - A custom proc can be provided. It should accept aSQLWarning error object.

For example:

config.active_record.db_warnings_action=->(warning)do# Report to custom exception reporting serviceBugsnag.notify(warning.message)do|notification|notification.add_metadata(:warning_code,warning.code)notification.add_metadata(:warning_level,warning.level)endend

3.8.16.`config.active_record.db_warnings_ignore`

Specifies an allowlist of warning codes and messages that will be ignored, regardless of the configureddb_warnings_action.The default behavior is to report all warnings. Warnings to ignore can be specified as Strings or Regexps. For example:

config.active_record.db_warnings_action=:raise# The following warnings will not be raisedconfig.active_record.db_warnings_ignore=[/Invalid utf8mb4 character string/,"An exact warning message","1062",# MySQL Error 1062: Duplicate entry]

3.8.17.`config.active_record.migration_strategy`

Controls the strategy class used to perform schema statement methods in a migration. The default classdelegates to the connection adapter. Custom strategies should inherit fromActiveRecord::Migration::ExecutionStrategy,or may inherit fromDefaultStrategy, which will preserve the default behavior for methods that aren't implemented:

classCustomMigrationStrategy<ActiveRecord::Migration::DefaultStrategydefdrop_table(*)raise"Dropping tables is not supported!"endendconfig.active_record.migration_strategy=CustomMigrationStrategy

3.8.18.`config.active_record.schema_versions_formatter`

Controls the formatter class used by schema dumper to format versions information. Custom class can be providedto change the default behavior:

classCustomSchemaVersionsFormatterdefinitialize(connection)@connection=connectionenddefformat(versions)# Special sorting of versions to reduce the likelihood of conflicts.sorted_versions=versions.sort{|a,b|b.to_s.reverse<=>a.to_s.reverse}sql=+"INSERT INTO schema_migrations (version) VALUES\n"sql<<sorted_versions.map{|v|"(#{@connection.quote(v)})"}.join(",\n")sql<<";"sqlendendconfig.active_record.schema_versions_formatter=CustomSchemaVersionsFormatter

3.8.19.`config.active_record.lock_optimistically`

Controls whether Active Record will use optimistic locking and istrue by default.

3.8.20.`config.active_record.cache_timestamp_format`

Controls the format of the timestamp value in the cache key. Default is:usec.

3.8.21.`config.active_record.record_timestamps`

Is a boolean value which controls whether or not timestamping ofcreate andupdate operations on a model occur. The default value istrue.

3.8.22.`config.active_record.partial_inserts`

Is a boolean value and controls whether or not partial writes are used when creating new records (i.e. whether inserts only set attributes that are different from the default).

The default value depends on theconfig.load_defaults target version:

Starting with version	The default value is
(original)	`true`
7.0	`false`

3.8.23.`config.active_record.partial_updates`

Is a boolean value and controls whether or not partial writes are used when updating existing records (i.e. whether updates only set attributes that are dirty). Note that when using partial updates, you should also use optimistic lockingconfig.active_record.lock_optimistically since concurrent updates may write attributes based on a possibly stale read state. The default value istrue.

3.8.24.`config.active_record.maintain_test_schema`

Is a boolean value which controls whether Active Record should try to keep your test database schema up-to-date withdb/schema.rb (ordb/structure.sql) when you run your tests. The default istrue.

3.8.25.`config.active_record.dump_schema_after_migration`

Is a flag which controls whether or not schema dump should happen(db/schema.rb ordb/structure.sql) when you run migrations. This is set tofalse inconfig/environments/production.rb which is generated by Rails. Thedefault value istrue if this configuration is not set.

3.8.26.`config.active_record.dump_schemas`

Controls which database schemas will be dumped when callingdb:schema:dump.The options are:schema_search_path (the default) which dumps any schemas listed inschema_search_path,:all which always dumps all schemas regardless of theschema_search_path,or a string of comma separated schemas.

3.8.27.`config.active_record.before_committed_on_all_records`

Enable before_committed! callbacks on all enrolled records in a transaction.The previous behavior was to only run the callbacks on the first copy of a recordif there were multiple copies of the same record enrolled in the transaction.

Starting with version	The default value is
(original)	`false`
7.1	`true`

3.8.28.`config.active_record.belongs_to_required_by_default`

Is a boolean value and controls whether a record fails validation ifbelongs_to association is not present.

The default value depends on theconfig.load_defaults target version:

Starting with version	The default value is
(original)	`nil`
5.0	`true`

3.8.29.`config.active_record.belongs_to_required_validates_foreign_key`

Enable validating only parent-related columns for presence when the parent is mandatory.The previous behavior was to validate the presence of the parent record, which performed an extra queryto get the parent every time the child record was updated, even when parent has not changed.

Starting with version	The default value is
(original)	`true`
7.1	`false`

3.8.30.`config.active_record.marshalling_format_version`

When set to7.1, enables a more efficient serialization of Active Record instance withMarshal.dump.

This changes the serialization format, so models serialized thisway cannot be read by older (< 7.1) versions of Rails. However, messages thatuse the old format can still be read, regardless of whether this optimization isenabled.

Starting with version	The default value is
(original)	`6.1`
7.1	`7.1`

3.8.31.`config.active_record.action_on_strict_loading_violation`

Enables raising or logging an exception if strict_loading is set on anassociation. The default value is:raise in all environments. It can bechanged to:log to send violations to the logger instead of raising.

3.8.32.`config.active_record.strict_loading_by_default`

Is a boolean value that either enables or disables strict_loading mode bydefault. Defaults tofalse.

3.8.33.`config.active_record.strict_loading_mode`

Sets the mode in which strict loading is reported. Defaults to:all. It can bechanged to:n_plus_one_only to only report when loading associations that willlead to an N + 1 query.

3.8.34.`config.active_record.index_nested_attribute_errors`

Allows errors for nestedhas_many relationships to be displayed with an indexas well as the error. Defaults tofalse.

3.8.35.`config.active_record.use_schema_cache_dump`

Enables users to get schema cache information fromdb/schema_cache.yml(generated bybin/rails db:schema:cache:dump), instead of having to send aquery to the database to get this information. Defaults totrue.

3.8.36.`config.active_record.cache_versioning`

Indicates whether to use a stable#cache_key method that is accompanied by achanging version in the#cache_version method.

The default value depends on theconfig.load_defaults target version:

Starting with version	The default value is
(original)	`false`
5.2	`true`

3.8.37.`config.active_record.collection_cache_versioning`

Enables the same cache key to be reused when the object being cached of typeActiveRecord::Relation changes by moving the volatile information (maxupdated at and count) of the relation's cache key into the cache version tosupport recycling cache key.

The default value depends on theconfig.load_defaults target version:

Starting with version	The default value is
(original)	`false`
6.0	`true`

3.8.38.`config.active_record.has_many_inversing`

Enables setting the inverse record when traversingbelongs_to tohas_manyassociations.

The default value depends on theconfig.load_defaults target version:

Starting with version	The default value is
(original)	`false`
6.1	`true`

3.8.39.`config.active_record.automatic_scope_inversing`

Enables automatically inferring theinverse_of for associations with a scope.

The default value depends on theconfig.load_defaults target version:

Starting with version	The default value is
(original)	`false`
7.0	`true`

3.8.40.`config.active_record.destroy_association_async_job`

Allows specifying the job that will be used to destroy the associated records in background. It defaults toActiveRecord::DestroyAssociationAsyncJob.

3.8.41.`config.active_record.destroy_association_async_batch_size`

Allows specifying the maximum number of records that will be destroyed in a background job by thedependent: :destroy_async association option. All else equal, a lower batch size will enqueue more, shorter-running background jobs, while a higher batch size will enqueue fewer, longer-running background jobs. This option defaults tonil, which will cause all dependent records for a given association to be destroyed in the same background job.

3.8.42.`config.active_record.queues.destroy`

Allows specifying the Active Job queue to use for destroy jobs. When this optionisnil, purge jobs are sent to the default Active Job queue (seeconfig.active_job.default_queue_name). It defaults tonil.

3.8.43.`config.active_record.enumerate_columns_in_select_statements`

Whentrue, will always include column names inSELECT statements, and avoid wildcardSELECT * FROM ... queries. This avoids prepared statement cache errors when adding columns to a PostgreSQL database for example. Defaults tofalse.

3.8.44.`config.active_record.verify_foreign_keys_for_fixtures`

Ensures all foreign key constraints are valid after fixtures are loaded in tests. Supported by PostgreSQL and SQLite only.

The default value depends on theconfig.load_defaults target version:

Starting with version	The default value is
(original)	`false`
7.0	`true`

3.8.45.`config.active_record.raise_on_assign_to_attr_readonly`

Enable raising on assignment to attr_readonly attributes. The previousbehavior would allow assignment but silently not persist changes to thedatabase.

Starting with version	The default value is
(original)	`false`
7.1	`true`

3.8.46.`config.active_record.run_commit_callbacks_on_first_saved_instances_in_transaction`

When multiple Active Record instances change the same record within a transaction, Rails runsafter_commit orafter_rollback callbacks for only one of them. This option specifies how Rails chooses which instance receives the callbacks.

Whentrue, transactional callbacks are run on the first instance to save, even though its instance state may be stale.

Whenfalse, transactional callbacks are run on the instances with the freshest instance state. Those instances are chosen as follows:

In general, run transactional callbacks on the last instance to save a given record within the transaction.
There are two exceptions:
- If the record is created within the transaction, then updated by another instance,after_create_commit callbacks will be run on the second instance. This is instead of theafter_update_commit callbacks that would naively be run based on that instance’s state.
- If the record is destroyed within the transaction, thenafter_destroy_commit callbacks will be fired on the last destroyed instance, even if a stale instance subsequently performed an update (which will have affected 0 rows).

The default value depends on theconfig.load_defaults target version:

Starting with version	The default value is
(original)	`true`
7.1	`false`

3.8.47.`config.active_record.default_column_serializer`

The serializer implementation to use if none is explicitly specified for a givencolumn.

Historicallyserialize andstore while allowing to use alternative serializerimplementations, would useYAML by default, but it's not a very efficient formatand can be the source of security vulnerabilities if not carefully employed.

As such it is recommended to prefer stricter, more limited formats for databaseserialization.

Unfortunately there isn't really any suitable defaults available in Ruby's standardlibrary.JSON could work as a format, but thejson gems will cast unsupportedtypes to strings which may lead to bugs.

The default value depends on theconfig.load_defaults target version:

Starting with version	The default value is
(original)	`YAML`
7.1	`nil`

3.8.48.`config.active_record.run_after_transaction_callbacks_in_order_defined`

Whentrue,after_commit callbacks are executed in the order they are defined in a model. Whenfalse, they are executed in reverse order.

All other callbacks are always executed in the order they are defined in a model (unless you useprepend: true).

The default value depends on theconfig.load_defaults target version:

Starting with version	The default value is
(original)	`false`
7.1	`true`

3.8.49.`config.active_record.query_log_tags_enabled`

Specifies whether or not to enable adapter-level query comments. Defaults tofalse, but is set totrue in the default generatedconfig/environments/development.rb file.

When this is set totrue database prepared statements will be automatically disabled.

3.8.50.`config.active_record.query_log_tags`

Define anArray specifying the key/value tags to be inserted in an SQL comment. Defaults to[ :application, :controller, :action, :job ]. The available tags are::application,:controller,:namespaced_controller,:action,:job, and:source_location.

Calculating the:source_location of a query can be slow, so you should consider its impact if using it in a production environment.

3.8.51.`config.active_record.query_log_tags_format`

ASymbol specifying the formatter to use for tags. Valid values are:sqlcommenter and:legacy.

The default value depends on theconfig.load_defaults target version:

Starting with version	The default value is
(original)	`:legacy`
7.1	`:sqlcommenter`

3.8.52.`config.active_record.cache_query_log_tags`

Specifies whether or not to enable caching of query log tags. For applicationsthat have a large number of queries, caching query log tags can provide aperformance benefit when the context does not change during the lifetime of therequest or job execution. Defaults tofalse.

3.8.53.`config.active_record.query_log_tags_prepend_comment`

Specifies whether or not to prepend query log tags comment to the query.

By default comments are appended at the end of the query. Certain databases, such as MySQL willtruncate the query text. This is the case for slow query logs and the results of queryingsome InnoDB internal tables where the length of the query is more than 1024 bytes.In order to not lose the log tags comments from the queries, you can prepend the comments using this option.

Defaults tofalse.

3.8.54.`config.active_record.schema_cache_ignored_tables`

Define the list of table that should be ignored when generating the schemacache. It accepts anArray of strings, representing the table names, orregular expressions.

3.8.55.`config.active_record.verbose_query_logs`

Specifies if source locations of methods that call database queries should be logged below relevant queries. By default, the flag istrue in development andfalse in all other environments.

3.8.56.`config.active_record.sqlite3_adapter_strict_strings_by_default`

Specifies whether the SQLite3Adapter should be used in a strict strings mode.The use of a strict strings mode disables double-quoted string literals.

SQLite has some quirks around double-quoted string literals.It first tries to consider double-quoted strings as identifier names, but if they don't existit then considers them as string literals. Because of this, typos can silently go unnoticed.For example, it is possible to create an index for a non existing column.SeeSQLite documentation for more details.

The default value depends on theconfig.load_defaults target version:

Starting with version	The default value is
(original)	`false`
7.1	`true`

3.8.57.`config.active_record.postgresql_adapter_decode_dates`

Specifies whether the PostgresqlAdapter should decode date columns.

ActiveRecord::Base.connection.select_value("select '2024-01-01'::date").class#=> Date

The default value depends on theconfig.load_defaults target version:

Starting with version	The default value is
(original)	`false`
7.2	`true`

3.8.58.`config.active_record.async_query_executor`

Specifies how asynchronous queries are pooled.

It defaults tonil, which meansload_async is disabled and instead directly executes queries in the foreground.For queries to actually be performed asynchronously, it must be set to either:global_thread_pool or:multi_thread_pool.

:global_thread_pool will use a single pool for all databases the application connects to. This is the preferred configurationfor applications with only a single database, or applications which only ever query one database shard at a time.

:multi_thread_pool will use one pool per database, and each pool size can be configured individually indatabase.yml through themax_threads andmin_threads properties. This can be useful to applications regularly querying multiple databases at a time, and that need to more precisely define the max concurrency.

3.8.59.`config.active_record.global_executor_concurrency`

Used in conjunction withconfig.active_record.async_query_executor = :global_thread_pool, defines how many asynchronousqueries can be executed concurrently.

Defaults to4.

This number must be considered in accordance with the database connection pool size configured indatabase.yml. The connection poolshould be large enough to accommodate both the foreground threads (ie. web server or job worker threads) and background threads.

For each process, Rails will create one global query executor that uses this many threads to process async queries. Thus, the pool sizeshould be at leastthread_count + global_executor_concurrency + 1. For example, if your web server has a maximum of 3 threads,andglobal_executor_concurrency is set to 4, then your pool size should be at least 8.

3.8.60.`config.active_record.yaml_column_permitted_classes`

Defaults to[Symbol]. Allows applications to include additional permitted classes tosafe_load() on theActiveRecord::Coders::YAMLColumn.

3.8.61.`config.active_record.use_yaml_unsafe_load`

Defaults tofalse. Allows applications to opt into usingunsafe_load on theActiveRecord::Coders::YAMLColumn.

3.8.62.`config.active_record.raise_int_wider_than_64bit`

Defaults totrue. Determines whether to raise an exception or not whenthe PostgreSQL adapter is provided an integer that is wider than signed64bit representation.

3.8.63.`config.active_record.generate_secure_token_on`

Controls when to generate a value forhas_secure_token declarations. Bydefault, generate the value when the model is initialized:

classUser<ApplicationRecordhas_secure_tokenendrecord=User.newrecord.token# => "fwZcXX6SkJBJRogzMdciS7wf"

Withconfig.active_record.generate_secure_token_on = :create, generate thevalue when the model is created:

# config/application.rbconfig.active_record.generate_secure_token_on=:create# app/models/user.rbclassUser<ApplicationRecordhas_secure_tokenon: :createendrecord=User.newrecord.token# => nilrecord.save!record.token# => "fwZcXX6SkJBJRogzMdciS7wf"

Starting with version	The default value is
(original)	`:create`
7.1	`:initialize`

3.8.64.`config.active_record.permanent_connection_checkout`

Controls whetherActiveRecord::Base.connection raises an error, emits a deprecation warning, or neither.

ActiveRecord::Base.connection checkouts a database connection from the pool and keeps it leased until the end ofthe request or job. This behavior can be undesirable in environments that use many more threads or fibers than thereis available connections.

This configuration can be used to track down and eliminate code that callsActiveRecord::Base.connection andmigrate it to useActiveRecord::Base.with_connection instead.

The value can be set to:disallowed,:deprecated, ortrue to respectively raise an error, emit a deprecationwarning, or neither.

Starting with version	The default value is
(original)	`true`

3.8.65.`config.active_record.database_cli`

Controls which CLI tool will be used for accessing the database when runningbin/rails dbconsole. By defaultthe standard tool for the database will be used (e.g.psql for PostgreSQL andmysql for MySQL). The optiontakes a hash which specifies the tool per-database system, and an array can be used where fallback options arerequired:

# config/application.rbconfig.active_record.database_cli={postgresql:"pgcli",mysql:%w[ mycli mysql ]}

3.8.66.`config.active_record.use_legacy_signed_id_verifier`

Controls whether signed IDs are generated and verified using legacy options. Can be set to:

:generate_and_verify (default) - Generate and verify signed IDs using the following legacy options:
```
{digest:"SHA256",serializer:JSON,url_safe:true}
```
:verify - Generate and verify signed IDs using options fromRails.application.message_verifiers, but fall back to verifying with the same options as:generate_and_verify.
false - Generate and verify signed IDs using options fromRails.application.message_verifiers only.

The purpose of this setting is to provide a smooth transition to a unified configuration for all message verifiers. Having a unified configuration makes it more straightforward to rotate secrets and upgrade signing algorithms.

Setting this to false may cause old signed IDs to become unreadable ifRails.application.message_verifiers is not properly configured. UseMessageVerifiers#rotate orMessageVerifiers#prepend to configureRails.application.message_verifiers with the appropriate options, such as:digest and:url_safe.

3.8.67.`ActiveRecord::ConnectionAdapters::Mysql2Adapter.emulate_booleans` and`ActiveRecord::ConnectionAdapters::TrilogyAdapter.emulate_booleans`

Controls whether the Active Record MySQL adapter will consider alltinyint(1) columns as booleans. Defaults totrue.

3.8.68.`ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.create_unlogged_tables`

Controls whether database tables created by PostgreSQL should be "unlogged", which can speedup performance but adds a risk of data loss if the database crashes. It ishighly recommended that you do not enable this in a production environment.Defaults tofalse in all environments.

To enable this for tests:

# config/environments/test.rbActiveSupport.on_load(:active_record_postgresqladapter)doself.create_unlogged_tables=trueend

3.8.69.`ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.datetime_type`

Controls what native type the Active Record PostgreSQL adapter should use when you calldatetime ina migration or schema. It takes a symbol which must correspond to one of theconfiguredNATIVE_DATABASE_TYPES. The default is:timestamp, meaningt.datetime in a migration will create a "timestamp without time zone" column.

To use "timestamp with time zone":

# config/application.rbActiveSupport.on_load(:active_record_postgresqladapter)doself.datetime_type=:timestamptzend

You should runbin/rails db:migrate to rebuild your schema.rb if you change this.

3.8.70.`ActiveRecord::SchemaDumper.ignore_tables`

Accepts an array of tables that shouldnot be included in any generated schema file.

3.8.71.`ActiveRecord::SchemaDumper.fk_ignore_pattern`

Allows setting a different regular expression that will be used to decidewhether a foreign key's name should be dumped to db/schema.rb or not. Bydefault, foreign key names starting withfk_rails_ are not exported to thedatabase schema dump. Defaults to/^fk_rails_[0-9a-f]{10}$/.

3.8.72.`config.active_record.encryption.add_to_filter_parameters`

Enables automatic filtering of encrypted attributes oninspect.

The default value istrue.

3.8.73.`config.active_record.encryption.hash_digest_class`

Sets the digest algorithm used by Active Record Encryption.

The default value depends on theconfig.load_defaults target version:

Starting with version	The default value is
(original)	`OpenSSL::Digest::SHA1`
7.1	`OpenSSL::Digest::SHA256`

3.8.74.`config.active_record.encryption.support_sha1_for_non_deterministic_encryption`

Enables support for decrypting existing data encrypted using a SHA-1 digest class. Whenfalse,it will only support the digest configured inconfig.active_record.encryption.hash_digest_class.

The default value depends on theconfig.load_defaults target version:

Starting with version	The default value is
(original)	`true`
7.1	`false`

3.8.75.`config.active_record.encryption.compressor`

Sets the compressor used by Active Record Encryption. The default value isZlib.

You can use your own compressor by setting this to a class that responds todeflate andinflate.

3.8.76.`config.active_record.protocol_adapters`

When using a URL to configure the database connection, this option provides a mapping from the protocol to the underlyingdatabase adapter. For example, this means the environment can specifyDATABASE_URL=mysql://localhost/database and Rails will mapmysql to themysql2 adapter, but the application can also override these mappings:

config.active_record.protocol_adapters.mysql="trilogy"

If no mapping is found, the protocol is used as the adapter name.

3.8.77.`config.active_record.deprecated_associations_options`

If present, this has to be a hash with keys:mode and/or:backtrace:

config.active_record.deprecated_associations_options={mode: :notify,backtrace:true}

In:warn mode, accessing the deprecated association is reported by theActive Record logger. This is the default mode.
In:raise mode, usage raises anActiveRecord::DeprecatedAssociationErrorwith a similar message and a clean backtrace in the exception object.
In:notify mode, adeprecated_association.active_record Active Supportnotification is published. Please, see details about its payload in theActive Support Instrumentation guide.

Backtraces are disabled by default. If:backtrace is true, warnings include aclean backtrace in the message, and notifications have a:backtrace key in thepayload with an array of cleanThread::Backtrace::Location objects. Exceptionsalways have a clean stack trace.

Clean backtraces are computed using the Active Record backtrace cleaner.

3.8.78.`config.active_record.raise_on_missing_required_finder_order_columns`

Raises an error when order dependent finder methods (e.g.#first,#second) are called withoutorder valueson the relation, and the model does not have any order columns (implicit_order_column,query_constraints, orprimary_key) to fall back on.

The default value depends on theconfig.load_defaults target version:

Starting with version	The default value is
(original)	`false`
8.1	`true`

3.9. Configuring Action Controller

config.action_controller includes a number of configuration settings:

3.9.1.`config.action_controller.asset_host`

Sets the host for the assets. Useful when CDNs are used for hosting assets rather than the application server itself. You should only use this if you have a different configuration for Action Mailer, otherwise useconfig.asset_host.

3.9.2.`config.action_controller.perform_caching`

Configures whether the application should perform the caching features provided by the Action Controller component. Set tofalse in the development environment,true in production. If it's not specified, the default will betrue.

3.9.3.`config.action_controller.default_static_extension`

Configures the extension used for cached pages. Defaults to.html.

3.9.4.`config.action_controller.include_all_helpers`

Configures whether all view helpers are available everywhere or are scoped to the corresponding controller. If set tofalse,UsersHelper methods are only available for views rendered as part ofUsersController. Iftrue,UsersHelper methods are available everywhere. The default configuration behavior (when this option is not explicitly set totrue orfalse) is that all view helpers are available to each controller.

3.9.5.`config.action_controller.logger`

Accepts a logger conforming to the interface of Log4r or the default Ruby Logger class, which is then used to log information from Action Controller. Set tonil to disable logging.

3.9.6.`config.action_controller.request_forgery_protection_token`

Sets the token parameter name for RequestForgery. Callingprotect_from_forgery sets it to:authenticity_token by default.

3.9.7.`config.action_controller.allow_forgery_protection`

Enables or disables CSRF protection. By default this isfalse in the test environment andtrue in all other environments.

3.9.8.`config.action_controller.forgery_protection_origin_check`

Configures whether the HTTPOrigin header should be checked against the site's origin as an additional CSRF defense.

The default value depends on theconfig.load_defaults target version:

Starting with version	The default value is
(original)	`false`
5.0	`true`

3.9.9.`config.action_controller.per_form_csrf_tokens`

Configures whether CSRF tokens are only valid for the method/action they were generated for.

The default value depends on theconfig.load_defaults target version:

Starting with version	The default value is
(original)	`false`
5.0	`true`

3.9.10.`config.action_controller.default_protect_from_forgery`

Determines whether forgery protection is added onActionController::Base.

The default value depends on theconfig.load_defaults target version:

Starting with version	The default value is
(original)	`false`
5.2	`true`

3.9.11.`config.action_controller.relative_url_root`

Can be used to tell Rails that you aredeploying to a subdirectory. The default isconfig.relative_url_root.

3.9.12.`config.action_controller.permit_all_parameters`

Sets all the parameters for mass assignment to be permitted by default. The default value isfalse.

3.9.13.`config.action_controller.action_on_unpermitted_parameters`

Controls behavior when parameters that are not explicitly permitted are found. The default value is:log in test and development environments,false otherwise. The values can be:

false to take no action
:log to emit anActiveSupport::Notifications.instrument event on theunpermitted_parameters.action_controller topic and log at the DEBUG level
:raise to raise aActionController::UnpermittedParameters exception

3.9.14.`config.action_controller.always_permitted_parameters`

Sets a list of permitted parameters that are permitted by default. The default values are['controller', 'action'].

3.9.15.`config.action_controller.enable_fragment_cache_logging`

Determines whether to log fragment cache reads and writes in verbose format as follows:

Read fragment views/v1/2914079/v1/2914079/recordings/70182313-20160225015037000000/d0bdf2974e1ef6d31685c3b392ad0b74 (0.6ms)Rendered messages/_message.html.erb in 1.2 ms [cache hit]Write fragment views/v1/2914079/v1/2914079/recordings/70182313-20160225015037000000/3b4e249ac9d168c617e32e84b99218b5 (1.1ms)Rendered recordings/threads/_thread.html.erb in 1.5 ms [cache miss]

By default it is set tofalse which results in following output:

Rendered messages/_message.html.erb in 1.2 ms [cache hit]Rendered recordings/threads/_thread.html.erb in 1.5 ms [cache miss]

3.9.16.`config.action_controller.raise_on_missing_callback_actions`

Raises anAbstractController::ActionNotFound when the action specified in callback's:only or:except options is missing in the controller.

Starting with version	The default value is
(original)	`false`
7.1	`true` (development and test),`false` (other envs)

3.9.17.`config.action_controller.raise_on_open_redirects`

Protect an application from unintentionally redirecting to an external host(also known as an "open redirect") by making external redirects opt-in.

When this configuration is set totrue, anActionController::Redirecting::UnsafeRedirectError will be raised when a URLwith an external host is passed toredirect_to. If an open redirect shouldbe allowed, thenallow_other_host: true can be added to the call toredirect_to.

Starting with version	The default value is
(original)	`false`

3.9.18.`config.action_controller.action_on_open_redirect`

Controls how Rails handles open redirect attempts (redirects to external hosts).

Note: This configuration replaces the deprecatedconfig.action_controller.raise_on_open_redirectsoption, which will be removed in a future Rails version. The new configuration provides moreflexible control over open redirect protection.

When set to:log, Rails will log a warning when an open redirect is detected.When set to:notify, Rails will publish anopen_redirect.action_controllernotification event. When set to:raise, Rails will raise anActionController::Redirecting::UnsafeRedirectError.

Ifraise_on_open_redirects is set totrue, it will take precedenceover this configuration for backward compatibility, effectively forcing:raisebehavior.

The default value depends on theconfig.load_defaults target version:

Starting with version	The default value is
(original)	`:log`
7.0	`:raise`

3.9.19.`config.action_controller.action_on_path_relative_redirect`

Controls how Rails handles paths relative URL redirects.

When set to:log (default), Rails will log a warning when a path relative URL redirectis detected. When set to:notify, Rails will publish anunsafe_redirect.action_controller notification event. When set to:raise, Railswill raise anActionController::Redirecting::UnsafeRedirectError.

This helps detect potentially unsafe redirects that could be exploited for openredirect attacks.

The default value depends on theconfig.load_defaults target version:

Starting with version	The default value is
(original)	`:log`
8.1	`:raise`

3.9.20.`config.action_controller.log_query_tags_around_actions`

Determines whether controller context for query tags will be automaticallyupdated via anaround_filter. The default value istrue.

3.9.21.`config.action_controller.wrap_parameters_by_default`

Before Rails 7.0, new applications were generated with an initializer namedwrap_parameters.rb that enabled parameter wrapping inActionController::Basefor JSON requests.

Setting this configuration value totrue has the same behavior as theinitializer, allowing applications to remove the initializer if they do not wishto customize parameter wrapping behavior.

Regardless of this value, applications can continue to customize the parameterwrapping behavior as before in an initializer or per controller.

SeeParamsWrapper for more information on parameterwrapping.

The default value depends on theconfig.load_defaults target version:

Starting with version	The default value is
(original)	`false`
7.0	`true`

3.9.22.`config.action_controller.allowed_redirect_hosts`

Specifies a list of allowed hosts for redirects.redirect_to will allow redirects to them without raising anUnsafeRedirectError error.

3.9.23.`ActionController::Base.wrap_parameters`

Configures theParamsWrapper. This can be called atthe top level, or on individual controllers.

3.9.24.`config.action_controller.escape_json_responses`

Configures the JSON renderer to escape HTML entities and Unicode characters that are invalid in JavaScript.

This is useful if you relied on the JSON response having those characters escaped to embed the JSON document in<script> tags in HTML.

This is mainly for compatibility when upgrading Rails applications, otherwise you can use the:escape option forrender json: in specific controller actions.

Starting with version	The default value is
(original)	`true`
8.1	`false`

3.10. Configuring Action Dispatch

3.10.1.`config.action_dispatch.cookies_serializer`

Specifies which serializer to use for cookies. Accepts the same values asconfig.active_support.message_serializer,plus:hybrid which is an alias for:json_allow_marshal.

The default value depends on theconfig.load_defaults target version:

Starting with version	The default value is
(original)	`:marshal`
7.0	`:json`

3.10.2.`config.action_dispatch.debug_exception_log_level`

Configures the log level used by theActionDispatch::DebugExceptionsmiddleware when logging uncaught exceptions during requests.

The default value depends on theconfig.load_defaults target version:

Starting with version	The default value is
(original)	`:fatal`
7.1	`:error`

3.10.3.`config.action_dispatch.default_headers`

Is a hash with HTTP headers that are set by default in each response.

The default value depends on theconfig.load_defaults target version:

Starting with version The default value is

(original)

Starting with version	The default value is
(original)	`{ "X-Frame-Options" => "SAMEORIGIN", "X-XSS-Protection" => "1; mode=block", "X-Content-Type-Options" => "nosniff", "X-Download-Options" => "noopen", "X-Permitted-Cross-Domain-Policies" => "none", "Referrer-Policy" => "strict-origin-when-cross-origin" }`
7.0	`{ "X-Frame-Options" => "SAMEORIGIN", "X-XSS-Protection" => "0", "X-Content-Type-Options" => "nosniff", "X-Download-Options" => "noopen", "X-Permitted-Cross-Domain-Policies" => "none", "Referrer-Policy" => "strict-origin-when-cross-origin" }`
7.1	`{ "X-Frame-Options" => "SAMEORIGIN", "X-XSS-Protection" => "0", "X-Content-Type-Options" => "nosniff", "X-Permitted-Cross-Domain-Policies" => "none", "Referrer-Policy" => "strict-origin-when-cross-origin" }`

{
  "X-Frame-Options" => "SAMEORIGIN",
  "X-XSS-Protection" => "1; mode=block",
  "X-Content-Type-Options" => "nosniff",
  "X-Download-Options" => "noopen",
  "X-Permitted-Cross-Domain-Policies" => "none",
  "Referrer-Policy" => "strict-origin-when-cross-origin"
}

7.0

{
  "X-Frame-Options" => "SAMEORIGIN",
  "X-XSS-Protection" => "0",
  "X-Content-Type-Options" => "nosniff",
  "X-Download-Options" => "noopen",
  "X-Permitted-Cross-Domain-Policies" => "none",
  "Referrer-Policy" => "strict-origin-when-cross-origin"
}

7.1

{
  "X-Frame-Options" => "SAMEORIGIN",
  "X-XSS-Protection" => "0",
  "X-Content-Type-Options" => "nosniff",
  "X-Permitted-Cross-Domain-Policies" => "none",
  "Referrer-Policy" => "strict-origin-when-cross-origin"
}

3.10.4.`config.action_dispatch.default_charset`

Specifies the default character set for all renders. Defaults tonil.

3.10.5.`config.action_dispatch.tld_length`

Sets the TLD (top-level domain) length for the application. Defaults to1.

3.10.6.`config.action_dispatch.domain_extractor`

Configures the domain extraction strategy used by Action Dispatch for parsing host names into domain and subdomain components. This must be an object that responds todomain_from(host, tld_length) andsubdomains_from(host, tld_length) methods.

Defaults toActionDispatch::Http::URL::DomainExtractor, which provides the standard domain parsing logic. You can provide a custom extractor to implement specialized domain parsing behavior:

classCustomDomainExtractordefself.domain_from(host,tld_length)# Custom domain extraction logicenddefself.subdomains_from(host,tld_length)# Custom subdomain extraction logicendendconfig.action_dispatch.domain_extractor=CustomDomainExtractor

3.10.7.`config.action_dispatch.ignore_accept_header`

Is used to determine whether to ignore accept headers from a request. Defaults tofalse.

3.10.8.`config.action_dispatch.x_sendfile_header`

Specifies server specific X-Sendfile header. This is useful for accelerated file sending from server. For example it can be set to 'X-Sendfile' for Apache.

3.10.9.`config.action_dispatch.http_auth_salt`

Sets the HTTP Auth salt value. Defaultsto'http authentication'.

3.10.10.`config.action_dispatch.signed_cookie_salt`

Sets the signed cookies salt value.Defaults to'signed cookie'.

3.10.11.`config.action_dispatch.encrypted_cookie_salt`

Sets the encrypted cookies salt value. Defaults to'encrypted cookie'.

3.10.12.`config.action_dispatch.encrypted_signed_cookie_salt`

Sets the signed encrypted cookies salt value. Defaults to'signed encryptedcookie'.

3.10.13.`config.action_dispatch.authenticated_encrypted_cookie_salt`

Sets the authenticated encrypted cookie salt. Defaults to'authenticatedencrypted cookie'.

3.10.14.`config.action_dispatch.encrypted_cookie_cipher`

Sets the cipher to be used for encrypted cookies. This defaults to"aes-256-gcm".

3.10.15.`config.action_dispatch.signed_cookie_digest`

Sets the digest to be used for signed cookies. This defaults to"SHA1".

3.10.16.`config.action_dispatch.cookies_rotations`

Allows rotating secrets, ciphers, and digests for encrypted and signed cookies.

3.10.17.`config.action_dispatch.use_authenticated_cookie_encryption`

Controls whether signed and encrypted cookies use the AES-256-GCM cipher or theolder AES-256-CBC cipher.

The default value depends on theconfig.load_defaults target version:

Starting with version	The default value is
(original)	`false`
5.2	`true`

3.10.18.`config.action_dispatch.use_cookies_with_metadata`

Enables writing cookies with the purpose metadata embedded.

The default value depends on theconfig.load_defaults target version:

Starting with version	The default value is
(original)	`false`
6.0	`true`

3.10.19.`config.action_dispatch.perform_deep_munge`

Configures whetherdeep_munge method should be performed on the parameters.SeeSecurity Guide for moreinformation. It defaults totrue.

3.10.20.`config.action_dispatch.rescue_responses`

Configures what exceptions are assigned to an HTTP status. It accepts a hash and you can specify pairs of exception/status.

# It's good to use #[]= or #merge! to respect the default valuesconfig.action_dispatch.rescue_responses["MyAuthenticationError"]=:unauthorized

UseActionDispatch::ExceptionWrapper.rescue_responses to observe the configuration. By default, it is defined as:

{"ActionController::RoutingError"=>:not_found,"AbstractController::ActionNotFound"=>:not_found,"ActionController::MethodNotAllowed"=>:method_not_allowed,"ActionController::UnknownHttpMethod"=>:method_not_allowed,"ActionController::NotImplemented"=>:not_implemented,"ActionController::UnknownFormat"=>:not_acceptable,"ActionDispatch::Http::MimeNegotiation::InvalidType"=>:not_acceptable,"ActionController::MissingExactTemplate"=>:not_acceptable,"ActionController::InvalidAuthenticityToken"=>:unprocessable_entity,"ActionController::InvalidCrossOriginRequest"=>:unprocessable_entity,"ActionDispatch::Http::Parameters::ParseError"=>:bad_request,"ActionController::BadRequest"=>:bad_request,"ActionController::ParameterMissing"=>:bad_request,"Rack::QueryParser::ParameterTypeError"=>:bad_request,"Rack::QueryParser::InvalidParameterError"=>:bad_request,"ActiveRecord::RecordNotFound"=>:not_found,"ActiveRecord::StaleObjectError"=>:conflict,"ActiveRecord::RecordInvalid"=>:unprocessable_entity,"ActiveRecord::RecordNotSaved"=>:unprocessable_entity}

Any exceptions that are not configured will be mapped to 500 Internal Server Error.

3.10.21.`config.action_dispatch.cookies_same_site_protection`

Configures the default value of theSameSite attribute when setting cookies.When set tonil, theSameSite attribute is not added. To allow the value oftheSameSite attribute to be configured dynamically based on the request, aproc may be specified. For example:

config.action_dispatch.cookies_same_site_protection=->(request)do:strictunlessrequest.user_agent=="TestAgent"end

The default value depends on theconfig.load_defaults target version:

Starting with version	The default value is
(original)	`nil`
6.1	`:lax`

3.10.22.`config.action_dispatch.ssl_default_redirect_status`

Configures the default HTTP status code used when redirecting non-GET/HEADrequests from HTTP to HTTPS in theActionDispatch::SSL middleware.

The default value depends on theconfig.load_defaults target version:

Starting with version	The default value is
(original)	`307`
6.1	`308`

3.10.23.`config.action_dispatch.log_rescued_responses`

Enables logging those unhandled exceptions configured inrescue_responses. Itdefaults totrue.

3.10.24.`config.action_dispatch.show_exceptions`

Theconfig.action_dispatch.show_exceptions configuration controls how Action Pack (specifically theActionDispatch::ShowExceptions middleware) handles exceptions raised while responding to requests.

Setting the value to:all configures Action Pack to rescue from exceptions and render corresponding error pages. For example, Action Pack would rescue from anActiveRecord::RecordNotFound exception and render the contents ofpublic/404.html with a404 Not found status code.

Setting the value to:rescuable configures Action Pack to rescue from exceptions defined inconfig.action_dispatch.rescue_responses, and raise all others. For example, Action Pack would rescue fromActiveRecord::RecordNotFound, but would raise aNoMethodError.

Setting the value to:none configures Action Pack to raise all exceptions.

:all - render error pages for all exceptions
:rescuable - render error pages for exceptions declared byconfig.action_dispatch.rescue_responses
:none - raise all exceptions

Starting with version	The default value is
(original)	`true`
7.1	`:all`

3.10.25.`config.action_dispatch.strict_freshness`

Configures whether theActionDispatch::ETag middleware should prefer theETag header over theLast-Modified header when both are present in the response.

If set totrue, when both headers are present only theETag is considered as specified by RFC 7232 section 6.

If set tofalse, when both headers are present, both headers are checked and both need to match for the response to be considered fresh.

Starting with version	The default value is
(original)	`false`
8.0	`true`

3.10.26.`config.action_dispatch.always_write_cookie`

Cookies will be written at the end of a request if they marked as insecure, if the request is made over SSL, or if the request is made to an onion service.

If set totrue, cookies will be written even if this criteria is not met.

This defaults totrue indevelopment, andfalse in all other environments.

3.10.27.`config.action_dispatch.verbose_redirect_logs`

Specifies if source locations of redirects should be logged below relevant log lines. By default, the flag istrue in development andfalse in all other environments.

3.10.28.`ActionDispatch::Callbacks.before`

Takes a block of code to run before the request.

3.10.29.`ActionDispatch::Callbacks.after`

Takes a block of code to run after the request.

3.11. Configuring Action View

config.action_view includes a small number of configuration settings:

3.11.1.`config.action_view.cache_template_loading`

Controls whether or not templates should be reloaded on each request. Defaults to!config.enable_reloading.

3.11.2.`config.action_view.field_error_proc`

Provides an HTML generator for displaying errors that come from Active Model. The block is evaluated withinthe context of an Action View template. The default is

Proc.new{|html_tag,instance|content_tag:div,html_tag,class:"field_with_errors"}

3.11.3.`config.action_view.default_form_builder`

Tells Rails which form builder to use by default. The default isActionView::Helpers::FormBuilder. If you want your form builder class to beloaded after initialization (so it's reloaded on each request in development),you can pass it as aString.

3.11.4.`config.action_view.logger`

Accepts a logger conforming to the interface of Log4r or the default Ruby Logger class, which is then used to log information from Action View. Set tonil to disable logging.

3.11.5.`config.action_view.erb_trim_mode`

Controls if certain ERB syntax should trim. It defaults to'-', which turns on trimming of tail spaces and newline when using<%= -%> or<%= =%>. Setting this to anything else will turn off trimming support.

3.11.6.`config.action_view.frozen_string_literal`

Compiles the ERB template with the# frozen_string_literal: true magic comment, making all string literals frozen and saving allocations. Set totrue to enable it for all views.

3.11.7.`config.action_view.embed_authenticity_token_in_remote_forms`

Allows you to set the default behavior forauthenticity_token in forms withremote: true. By default it's set tofalse, which means that remote formswill not includeauthenticity_token, which is helpful when you'refragment-caching the form. Remote forms get the authenticity from themetatag, so embedding is unnecessary unless you support browsers withoutJavaScript. In such case you can either passauthenticity_token: true as aform option or set this config setting totrue.

3.11.8.`config.action_view.prefix_partial_path_with_controller_namespace`

Determines whether or not partials are looked up from a subdirectory in templates rendered from namespaced controllers. For example, consider a controller namedAdmin::ArticlesController which renders this template:

<%=render@article%>

The default setting istrue, which uses the partial at/admin/articles/_article.erb. Setting the value tofalse would render/articles/_article.erb, which is the same behavior as rendering from a non-namespaced controller such asArticlesController.

3.11.9.`config.action_view.automatically_disable_submit_tag`

Determines whethersubmit_tag should automatically disable on click, thisdefaults totrue.

3.11.10.`config.action_view.debug_missing_translation`

Determines whether to wrap the missing translations key in a<span> tag or not. This defaults totrue.

3.11.11.`config.action_view.form_with_generates_remote_forms`

Determines whetherform_with generates remote forms or not.

The default value depends on theconfig.load_defaults target version:

Starting with version	The default value is
5.1	`true`
6.1	`false`

3.11.12.`config.action_view.form_with_generates_ids`

Determines whetherform_with generates ids on inputs.

The default value depends on theconfig.load_defaults target version:

Starting with version	The default value is
(original)	`false`
5.2	`true`

3.11.13.`config.action_view.default_enforce_utf8`

Determines whether forms are generated with a hidden tag that forces older versions of Internet Explorer to submit forms encoded in UTF-8.

The default value depends on theconfig.load_defaults target version:

Starting with version	The default value is
(original)	`true`
6.0	`false`

3.11.14.`config.action_view.image_loading`

Specifies a default value for theloading attribute of<img> tags rendered by theimage_tag helper. For example, when set to"lazy",<img> tags rendered byimage_tag will includeloading="lazy", whichinstructs the browser to wait until an image is near the viewport to load it. (This value can still be overridden per image by passing e.g.loading: "eager" toimage_tag.) Defaults tonil.

3.11.15.`config.action_view.image_decoding`

Specifies a default value for thedecoding attribute of<img> tags rendered by theimage_tag helper. Defaults tonil.

3.11.16.`config.action_view.annotate_rendered_view_with_filenames`

Determines whether to annotate rendered view with template file names. This defaults tofalse.

3.11.17.`config.action_view.preload_links_header`

Determines whetherjavascript_include_tag andstylesheet_link_tag will generate alink header that preload assets.

The default value depends on theconfig.load_defaults target version:

Starting with version	The default value is
(original)	`nil`
6.1	`true`

3.11.18.`config.action_view.button_to_generates_button_tag`

Whenfalse,button_to will render a<button> or an<input> inside a<form> depending on how content is passed (<form> omitted for brevity):

<%=button_to"Content","/"%># =><inputtype="submit"value="Content"><%=button_to"/"do%>  Content<%end%># =><buttontype="submit">Content</button>

Setting this value totrue makesbutton_to generate a<button> tag insidethe<form> in both cases.

The default value depends on theconfig.load_defaults target version:

Starting with version	The default value is
(original)	`false`
7.0	`true`

3.11.19.`config.action_view.apply_stylesheet_media_default`

Determines whetherstylesheet_link_tag will renderscreen as the defaultvalue for themedia attribute when it's not provided.

The default value depends on theconfig.load_defaults target version:

Starting with version	The default value is
(original)	`true`
7.0	`false`

3.11.20.`config.action_view.prepend_content_exfiltration_prevention`

Determines whether or not theform_tag andbutton_to helpers will produce HTML tags prepended with browser-safe (but technically invalid) HTML that guarantees their contents cannot be captured by any preceding unclosed tags. The default value isfalse.

3.11.21.`config.action_view.sanitizer_vendor`

Configures the set of HTML sanitizers used by Action View by settingActionView::Helpers::SanitizeHelper.sanitizer_vendor. The default value depends on theconfig.load_defaults target version:

Starting with version	The default value is	Which parses markup as
(original)	`Rails::HTML4::Sanitizer`	HTML4
7.1	`Rails::HTML5::Sanitizer` (see NOTE)	HTML5

Rails::HTML5::Sanitizer is not supported on JRuby, so on JRuby platforms Rails will fall back toRails::HTML4::Sanitizer.

3.11.22.`config.action_view.remove_hidden_field_autocomplete`

When enabled, hidden inputs generated byform_tag,token_tag,method_tag, and the hidden parameter fields included inbutton_to forms will omit theautocomplete="off" attribute.

The default value depends on theconfig.load_defaults target version:

Starting with version	The default value is
(original)	`false`
8.1	`true`

3.11.23.`config.action_view.render_tracker`

Configures the strategy for tracking dependencies between Action View templates.

Starting with version	The default value is
(original)	`:regex`
8.1	`:ruby`

3.12. Configuring Action Mailbox

config.action_mailbox provides the following configuration options:

3.12.1.`config.action_mailbox.logger`

Contains the logger used by Action Mailbox. It accepts a logger conforming to the interface of Log4r or the default Ruby Logger class. The default isRails.logger.

config.action_mailbox.logger=ActiveSupport::Logger.new(STDOUT)

3.12.2.`config.action_mailbox.incinerate_after`

Accepts anActiveSupport::Duration indicating how long after processingActionMailbox::InboundEmail records should be destroyed. It defaults to30.days.

# Incinerate inbound emails 14 days after processing.config.action_mailbox.incinerate_after=14.days

3.12.3.`config.action_mailbox.queues.incineration`

Accepts a symbol indicating the Active Job queue to use for incineration jobs.When this option isnil, incineration jobs are sent to the default Active Jobqueue (seeconfig.active_job.default_queue_name).

The default value depends on theconfig.load_defaults target version:

Starting with version	The default value is
(original)	`:action_mailbox_incineration`
6.1	`nil`

3.12.4.`config.action_mailbox.queues.routing`

Accepts a symbol indicating the Active Job queue to use for routing jobs. Whenthis option isnil, routing jobs are sent to the default Active Job queue (seeconfig.active_job.default_queue_name).

The default value depends on theconfig.load_defaults target version:

Starting with version	The default value is
(original)	`:action_mailbox_routing`
6.1	`nil`

3.12.5.`config.action_mailbox.storage_service`

Accepts a symbol indicating the Active Storage service to use for uploading emails. When this option isnil, emails are uploaded to the default Active Storage service (seeconfig.active_storage.service).

3.13. Configuring Action Mailer

There are a number of settings available onconfig.action_mailer:

3.13.1.`config.action_mailer.asset_host`

3.13.2.`config.action_mailer.logger`

Accepts a logger conforming to the interface of Log4r or the default Ruby Logger class, which is then used to log information from Action Mailer. Set tonil to disable logging.

3.13.3.`config.action_mailer.smtp_settings`

Allows detailed configuration for the:smtp delivery method. It accepts a hash of options, which can include any of these options:

:address - Allows you to use a remote mail server. Just change it from its default "localhost" setting.
:port - On the off chance that your mail server doesn't run on port 25, you can change it.
:domain - If you need to specify a HELO domain, you can do it here.
:user_name - If your mail server requires authentication, set the username in this setting.
:password - If your mail server requires authentication, set the password in this setting.
:authentication - If your mail server requires authentication, you need to specify the authentication type here. This is a symbol and one of:plain,:login,:cram_md5.
:enable_starttls - Use STARTTLS when connecting to your SMTP server and fail if unsupported. It defaults tofalse.
:enable_starttls_auto - Detects if STARTTLS is enabled in your SMTP server and starts to use it. It defaults totrue.
:openssl_verify_mode - When using TLS, you can set how OpenSSL checks the certificate. This is useful if you need to validate a self-signed and/or a wildcard certificate. This can be the name of one of the OpenSSL verify constants,'none' or'peer' - or the constant directlyOpenSSL::SSL::VERIFY_NONE orOpenSSL::SSL::VERIFY_PEER, respectively.
:ssl/:tls - Enables the SMTP connection to use SMTP/TLS (SMTPS: SMTP over direct TLS connection).
:open_timeout - Number of seconds to wait while attempting to open a connection.
:read_timeout - Number of seconds to wait until timing-out a read(2) call.

Additionally, it is possible to pass anyconfiguration optionMail::SMTP respects.

3.13.4.`config.action_mailer.smtp_timeout`

Prior to version 2.8.0, themail gem did not configure any default timeoutsfor its SMTP requests. This configuration enables applications to configuredefault values for both:open_timeout and:read_timeout in themail gem sothat requests do not end up stuck indefinitely.

The default value depends on theconfig.load_defaults target version:

Starting with version	The default value is
(original)	`nil`
7.0	`5`

3.13.5.`config.action_mailer.sendmail_settings`

Allows detailed configuration for the:sendmail delivery method. It accepts a hash of options, which can include any of these options:

:location - The location of the sendmail executable. Defaults to/usr/sbin/sendmail.
:arguments - The command line arguments. Defaults to%w[ -i ].

3.13.6.`config.action_mailer.file_settings`

Configures the:file delivery method. It accepts a hash of options, which can include:

:location - The location where files are saved. Defaults to"#{Rails.root}/tmp/mails".
:extension - The file extension. Defaults to the empty string.

3.13.7.`config.action_mailer.raise_delivery_errors`

Specifies whether to raise an error if email delivery cannot be completed. It defaults totrue.

3.13.8.`config.action_mailer.delivery_method`

Defines the delivery method and defaults to:smtp. See theconfiguration section in the Action Mailer guide for more info.

3.13.9.`config.action_mailer.perform_deliveries`

Specifies whether mail will actually be delivered and istrue by default. It can be convenient to set it tofalse for testing.

3.13.10.`config.action_mailer.default_options`

Configures Action Mailer defaults. Use to set options likefrom orreply_to for every mailer. These default to:

{mime_version:"1.0",charset:"UTF-8",content_type:"text/plain",parts_order:["text/plain","text/enriched","text/html"]}

Assign a hash to set additional options:

config.action_mailer.default_options={from:"noreply@example.com"}

3.13.11.`config.action_mailer.observers`

Registers observers which will be notified when mail is delivered.

config.action_mailer.observers=["MailObserver"]

3.13.12.`config.action_mailer.interceptors`

Registers interceptors which will be called before mail is sent.

config.action_mailer.interceptors=["MailInterceptor"]

3.13.13.`config.action_mailer.preview_interceptors`

Registers interceptors which will be called before mail is previewed.

config.action_mailer.preview_interceptors=["MyPreviewMailInterceptor"]

3.13.14.`config.action_mailer.preview_paths`

Specifies the locations of mailer previews. Appending paths to this configuration option will cause those paths to be used in the search for mailer previews.

config.action_mailer.preview_paths<<"#{Rails.root}/lib/mailer_previews"

3.13.15.`config.action_mailer.show_previews`

Enable or disable mailer previews. By default this istrue in development.

config.action_mailer.show_previews=false

3.13.16.`config.action_mailer.perform_caching`

Specifies whether the mailer templates should perform fragment caching or not. If it's not specified, the default will betrue.

3.13.17.`config.action_mailer.deliver_later_queue_name`

Specifies the Active Job queue to use for the default delivery job (seeconfig.action_mailer.delivery_job). When this option is set tonil, deliveryjobs are sent to the default Active Job queue (seeconfig.active_job.default_queue_name).

Mailer classes can override this to use a different queue. Note that this only applies when using the default delivery job. If your mailer is using a custom job, its queue will be used.

Ensure that your Active Job adapter is also configured to process the specified queue, otherwise delivery jobs may be silently ignored.

The default value depends on theconfig.load_defaults target version:

Starting with version	The default value is
(original)	`:mailers`
6.1	`nil`

3.13.18.`config.action_mailer.delivery_job`

Specifies delivery job for mail.

The default value depends on theconfig.load_defaults target version:

Starting with version	The default value is
(original)	`ActionMailer::MailDeliveryJob`
6.0	`"ActionMailer::MailDeliveryJob"`

3.14. Configuring Active Support

There are a few configuration options available in Active Support:

3.14.1.`config.active_support.bare`

Enables or disables the loading ofactive_support/all when booting Rails. Defaults tonil, which meansactive_support/all is loaded.

3.14.2.`config.active_support.test_order`

Sets the order in which the test cases are executed. Possible values are:random and:sorted. Defaults to:random.

3.14.3.`config.active_support.escape_html_entities_in_json`

Enables or disables the escaping of HTML entities in JSON serialization. Defaults totrue.

3.14.4.`config.active_support.use_standard_json_time_format`

Enables or disables serializing dates to ISO 8601 format. Defaults totrue.

3.14.5.`config.active_support.time_precision`

Sets the precision of JSON encoded time values. Defaults to3.

3.14.6.`config.active_support.hash_digest_class`

Allows configuring the digest class to use to generate non-sensitive digests, such as the ETag header.

The default value depends on theconfig.load_defaults target version:

Starting with version	The default value is
(original)	`OpenSSL::Digest::MD5`
5.2	`OpenSSL::Digest::SHA1`
7.0	`OpenSSL::Digest::SHA256`

3.14.7.`config.active_support.key_generator_hash_digest_class`

Allows configuring the digest class to use to derive secrets from the configured secret base, such as for encrypted cookies.

The default value depends on theconfig.load_defaults target version:

Starting with version	The default value is
(original)	`OpenSSL::Digest::SHA1`
7.0	`OpenSSL::Digest::SHA256`

3.14.8.`config.active_support.use_authenticated_message_encryption`

Specifies whether to use AES-256-GCM authenticated encryption as the default cipher for encrypting messages instead of AES-256-CBC.

The default value depends on theconfig.load_defaults target version:

Starting with version	The default value is
(original)	`false`
5.2	`true`

3.14.9.`config.active_support.message_serializer`

Specifies the default serializer used byActiveSupport::MessageEncryptorandActiveSupport::MessageVerifier instances. To make migrating betweenserializers easier, the provided serializers include a fallback mechanism tosupport multiple deserialization formats:

Serializer	Serialize and deserialize	Fallback deserialize
`:marshal`	`Marshal`	`ActiveSupport::JSON`,`ActiveSupport::MessagePack`
`:json`	`ActiveSupport::JSON`	`ActiveSupport::MessagePack`
`:json_allow_marshal`	`ActiveSupport::JSON`	`ActiveSupport::MessagePack`,`Marshal`
`:message_pack`	`ActiveSupport::MessagePack`	`ActiveSupport::JSON`
`:message_pack_allow_marshal`	`ActiveSupport::MessagePack`	`ActiveSupport::JSON`,`Marshal`

Marshal is a potential vector for deserialization attacks in caseswhere a message signing secret has been leaked.If possible, choose aserializer that does not supportMarshal.

The:message_pack and:message_pack_allow_marshal serializers supportroundtripping some Ruby types that are not supported by JSON, such asSymbol.They can also provide improved performance and smaller payload sizes. However,they require themsgpack gem.

Each of the above serializers will emit amessage_serializer_fallback.active_supportevent notification when they fall back to an alternate deserialization format,allowing you to track how often such fallbacks occur.

Alternatively, you can specify any serializer object that responds todump andload methods. For example:

config.active_support.message_serializer=YAML

The default value depends on theconfig.load_defaults target version:

Starting with version	The default value is
(original)	`:marshal`
7.1	`:json_allow_marshal`

3.14.10.`config.active_support.use_message_serializer_for_metadata`

Whentrue, enables a performance optimization that serializes message data andmetadata together. This changes the message format, so messages serialized thisway cannot be read by older (< 7.1) versions of Rails. However, messages thatuse the old format can still be read, regardless of whether this optimization isenabled.

The default value depends on theconfig.load_defaults target version:

Starting with version	The default value is
(original)	`false`
7.1	`true`

3.14.11.`config.active_support.cache_format_version`

Specifies which serialization format to use for the cache. Possible values are7.0, and7.1.

7.0 serializes cache entries more efficiently.

7.1 further improves efficiency, and allows expired and version-mismatchedcache entries to be detected without deserializing their values. It alsoincludes an optimization for bare string values such as view fragments.

All formats are backward and forward compatible, meaning cache entries writtenin one format can be read when using another format. This behavior makes iteasy to migrate between formats without invalidating the entire cache.

The default value depends on theconfig.load_defaults target version:

Starting with version	The default value is
7.0	`7.0`
7.1	`7.1`

3.14.12.`config.active_support.deprecation`

Configures the behavior of deprecation warnings. SeeDeprecation::Behavior for a description of theavailable options.

In the default generatedconfig/environments files, this is set to:log fordevelopment and:stderr for test, and it is omitted for production in favor ofconfig.active_support.report_deprecations.

3.14.13.`config.active_support.disallowed_deprecation`

Configures the behavior of disallowed deprecation warnings. SeeDeprecation::Behavior for a description of theavailable options.

This option is intended for development and test. For production, favorconfig.active_support.report_deprecations.

3.14.14.`config.active_support.disallowed_deprecation_warnings`

Configures deprecation warnings that the Application considers disallowed. This allows, for example, specific deprecations to be treated as hard failures.

3.14.15.`config.active_support.report_deprecations`

Whenfalse, disables all deprecation warnings, including disallowed deprecations, from theapplication’s deprecators. This includes all the deprecations from Rails and other gems that may add their deprecator to the collection of deprecators, but may not prevent all deprecation warnings emitted from ActiveSupport::Deprecation.

In the default generatedconfig/environments files, this is set tofalse for production.

3.14.16.`config.active_support.isolation_level`

Configures the locality of most of Rails internal state. If you use a fiber based server or job processor (e.g.falcon), you should set it to:fiber. Otherwise it is best to use:thread locality. Defaults to:thread.

3.14.17.`config.active_support.executor_around_test_case`

Configure the test suite to callRails.application.executor.wrap around test cases.This makes test cases behave closer to an actual request or job.Several features that are normally disabled in test, such as Active Record query cacheand asynchronous queries will then be enabled.

The default value depends on theconfig.load_defaults target version:

Starting with version	The default value is
(original)	`false`
7.0	`true`

3.14.18.`ActiveSupport::Logger.silencer`

Is set tofalse to disable the ability to silence logging in a block. The default istrue.

3.14.19.`ActiveSupport::Cache::Store.logger`

Specifies the logger to use within cache store operations.

3.14.20.`ActiveSupport.utc_to_local_returns_utc_offset_times`

ConfiguresActiveSupport::TimeZone.utc_to_local to return a time with a UTCoffset instead of a UTC time incorporating that offset.

The default value depends on theconfig.load_defaults target version:

Starting with version	The default value is
(original)	`false`
6.1	`true`

3.14.21.`config.active_support.raise_on_invalid_cache_expiration_time`

Specifies whether anArgumentError should be raised ifRails.cachefetch orwriteare given an invalidexpires_at orexpires_in time.

Options aretrue andfalse. Iffalse, the exception will be reportedashandled and logged instead.

The default value depends on theconfig.load_defaults target version:

Starting with version	The default value is
(original)	`false`
7.1	`true`

3.14.22.`config.active_support.event_reporter_context_store`

Configures a custom context store for the Event Reporter. The context store is used to manage metadata that should be attached to every event emitted by the reporter.

By default, the Event Reporter usesActiveSupport::EventContext which stores context in fiber-local storage.

To use a custom context store, set this config to a class that implements the context store interface:

# config/application.rbconfig.active_support.event_reporter_context_store=CustomContextStoreclassCustomContextStoreclass<<selfdefcontext# Return the context hashenddefset_context(context_hash)# Append context_hash to the existing context storeenddefclear# Clear the stored contextendendend

Defaults tonil, which means the defaultActiveSupport::EventContext store is used.

3.14.23.`config.active_support.escape_js_separators_in_json`

Specifies whether LINE SEPARATOR (U+2028) and PARAGRAPH SEPARATOR (U+2029) are escaped when generating JSON.

Historically these characters were not valid inside JavaScript literal strings but that changed in ECMAScript 2019.As such it's no longer a concern in modern browsers:https://caniuse.com/mdn-javascript_builtins_json_json_superset.

The default value depends on theconfig.load_defaults target version:

Starting with version	The default value is
(original)	`true`
8.1	`false`

3.15. Configuring Active Job

config.active_job provides the following configuration options:

3.15.1.`config.active_job.queue_adapter`

Sets the adapter for the queuing backend. The default adapter is:async. For an up-to-date list of built-in adapters see theActiveJob::QueueAdapters API documentation.

# Be sure to have the adapter's gem in your Gemfile# and follow the adapter's specific installation# and deployment instructions.config.active_job.queue_adapter=:sidekiq

3.15.2.`config.active_job.default_queue_name`

Can be used to change the default queue name. By default this is"default".

config.active_job.default_queue_name=:medium_priority

3.15.3.`config.active_job.queue_name_prefix`

Allows you to set an optional, non-blank, queue name prefix for all jobs. By default it is blank and not used.

The following configuration would queue the given job on theproduction_high_priority queue when run in production:

config.active_job.queue_name_prefix=Rails.env

classGuestsCleanupJob<ActiveJob::Basequeue_as:high_priority#....end

3.15.4.`config.active_job.queue_name_delimiter`

Has a default value of'_'. Ifqueue_name_prefix is set, thenqueue_name_delimiter joins the prefix and the non-prefixed queue name.

The following configuration would queue the provided job on thevideo_server.low_priority queue:

# prefix must be set for delimiter to be usedconfig.active_job.queue_name_prefix="video_server"config.active_job.queue_name_delimiter="."

classEncoderJob<ActiveJob::Basequeue_as:low_priority#....end

3.15.5.`config.active_job.logger`

Accepts a logger conforming to the interface of Log4r or the default Ruby Logger class, which is then used to log information from Active Job. You can retrieve this logger by callinglogger on either an Active Job class or an Active Job instance. Set tonil to disable logging.

3.15.6.`config.active_job.custom_serializers`

Allows to set custom argument serializers. Defaults to[].

3.15.7.`config.active_job.log_arguments`

Controls if the arguments of a job are logged. Defaults totrue.

3.15.8.`config.active_job.verbose_enqueue_logs`

Specifies if source locations of methods that enqueue background jobs should be logged below relevant enqueue log lines. By default, the flag istrue in development andfalse in all other environments.

3.15.9.`config.active_job.retry_jitter`

Controls the amount of "jitter" (random variation) applied to the delay time calculated when retrying failed jobs.

The default value depends on theconfig.load_defaults target version:

Starting with version	The default value is
(original)	`0.0`
6.1	`0.15`

3.15.10.`config.active_job.log_query_tags_around_perform`

Determines whether job context for query tags will be automatically updated viaanaround_perform. The default value istrue.

3.16. Configuring Action Cable

3.16.1.`config.action_cable.url`

Accepts a string for the URL for where you are hosting your Action Cableserver. You would use this option if you are running Action Cable servers thatare separated from your main application.

3.16.2.`config.action_cable.mount_path`

Accepts a string for where to mount Action Cable, as part of the main serverprocess. Defaults to/cable. You can set this as nil to not mount ActionCable as part of your normal Rails server.

You can find more detailed configuration options in theAction Cable Overview.

3.16.3.`config.action_cable.precompile_assets`

Determines whether the Action Cable assets should be added to the asset pipeline precompilation. Ithas no effect if Sprockets is not used. The default value istrue.

3.16.4.`config.action_cable.allow_same_origin_as_host`

Determines whether an origin matching the cable server itself will be permitted.The default value istrue.

Set to false to disable automatic access for same-origin requests, and strictly allowonly the configured origins.

3.16.5.`config.action_cable.allowed_request_origins`

Determines the request origins which will be accepted by the cable server.The default value is/https?:\/\/localhost:\d+/ in thedevelopment environment.

3.17. Configuring Active Storage

config.active_storage provides the following configuration options:

3.17.1.`config.active_storage.variant_processor`

Accepts a symbol:mini_magick,:vips, or:disabled specifying whether or not variant transformations and blob analysis will be performed with MiniMagick or ruby-vips.

The default value depends on theconfig.load_defaults target version:

Starting with version	The default value is
(original)	`:mini_magick`
7.0	`:vips`

3.17.2.`config.active_storage.analyzers`

Accepts an array of classes indicating the analyzers available for Active Storage blobs.By default, this is defined as:

config.active_storage.analyzers=[ActiveStorage::Analyzer::ImageAnalyzer::Vips,ActiveStorage::Analyzer::ImageAnalyzer::ImageMagick,ActiveStorage::Analyzer::VideoAnalyzer,ActiveStorage::Analyzer::AudioAnalyzer]

The image analyzers can extract width and height of an image blob; the video analyzer can extract width, height, duration, angle, aspect ratio, and presence/absence of video/audio channels of a video blob; the audio analyzer can extract duration and bit rate of an audio blob.

If you want to disable analyzers, you can set this to an empty array:

config.active_storage.analyzers=[]

3.17.3.`config.active_storage.previewers`

Accepts an array of classes indicating the image previewers available in Active Storage blobs.By default, this is defined as:

config.active_storage.previewers=[ActiveStorage::Previewer::PopplerPDFPreviewer,ActiveStorage::Previewer::MuPDFPreviewer,ActiveStorage::Previewer::VideoPreviewer]

PopplerPDFPreviewer andMuPDFPreviewer can generate a thumbnail from the first page of a PDF blob;VideoPreviewer from the relevant frame of a video blob.

3.17.4.`config.active_storage.paths`

Accepts a hash of options indicating the locations of previewer/analyzer commands. The default is{}, meaning the commands will be looked for in the default path. Can include any of these options:

:ffprobe - The location of the ffprobe executable.
:mutool - The location of the mutool executable.
:ffmpeg - The location of the ffmpeg executable.

config.active_storage.paths[:ffprobe]="/usr/local/bin/ffprobe"

3.17.5.`config.active_storage.variable_content_types`

Accepts an array of strings indicating the content types that Active Storagecan transform through the variant processor.By default, this is defined as:

config.active_storage.variable_content_types=%w(image/png image/gif image/jpeg image/tiff image/bmp image/vnd.adobe.photoshop image/vnd.microsoft.icon image/webp image/avif image/heic image/heif)

3.17.6.`config.active_storage.web_image_content_types`

Accepts an array of strings regarded as web image content types in whichvariants can be processed without being converted to the fallback PNG format.For example, if you want to useAVIF variants in your application you can addimage/avif to this array.

The default value depends on theconfig.load_defaults target version:

Starting with version	The default value is
(original)	`%w(image/png image/jpeg image/gif)`
7.2	`%w(image/png image/jpeg image/gif image/webp)`

3.17.7.`config.active_storage.content_types_to_serve_as_binary`

Accepts an array of strings indicating the content types that Active Storage will always serve as an attachment, rather than inline.By default, this is defined as:

config.active_storage.content_types_to_serve_as_binary=%w(text/html image/svg+xml application/postscript application/x-shockwave-flash text/xml application/xml application/xhtml+xml application/mathml+xml text/cache-manifest)

3.17.8.`config.active_storage.content_types_allowed_inline`

Accepts an array of strings indicating the content types that Active Storage allows to serve as inline.By default, this is defined as:

config.active_storage.content_types_allowed_inline=%w(image/webp image/avif image/png image/gif image/jpeg image/tiff image/vnd.adobe.photoshop image/vnd.microsoft.icon application/pdf)

3.17.9.`config.active_storage.queues.analysis`

Accepts a symbol indicating the Active Job queue to use for analysis jobs. Whenthis option isnil, analysis jobs are sent to the default Active Job queue(seeconfig.active_job.default_queue_name).

The default value depends on theconfig.load_defaults target version:

Starting with version	The default value is
6.0	`:active_storage_analysis`
6.1	`nil`

3.17.10.`config.active_storage.queues.mirror`

Accepts a symbol indicating the Active Job queue to use for direct uploadmirroring jobs. When this option isnil, mirroring jobs are sent to thedefault Active Job queue (seeconfig.active_job.default_queue_name). Thedefault isnil.

3.17.11.`config.active_storage.queues.preview_image`

Accepts a symbol indicating the Active Job queue to use for preprocessingpreviews of images. When this option isnil, jobs are sent to the defaultActive Job queue (seeconfig.active_job.default_queue_name). The defaultisnil.

3.17.12.`config.active_storage.queues.purge`

Accepts a symbol indicating the Active Job queue to use for purge jobs. Whenthis option isnil, purge jobs are sent to the default Active Job queue (seeconfig.active_job.default_queue_name).

The default value depends on theconfig.load_defaults target version:

Starting with version	The default value is
6.0	`:active_storage_purge`
6.1	`nil`

3.17.13.`config.active_storage.queues.transform`

Accepts a symbol indicating the Active Job queue to use for preprocessingvariants. When this option isnil, jobs are sent to the default Active Jobqueue (seeconfig.active_job.default_queue_name). The default isnil.

3.17.14.`config.active_storage.logger`

Can be used to set the logger used by Active Storage. Accepts a logger conforming to the interface of Log4r or the default Ruby Logger class.

config.active_storage.logger=ActiveSupport::Logger.new(STDOUT)

3.17.15.`config.active_storage.service_urls_expire_in`

Determines the default expiry of URLs generated by:

The default is 5 minutes.

3.17.16.`config.active_storage.urls_expire_in`

Determines the default expiry of URLs in the Rails application generated by Active Storage. The default is nil.

3.17.17.`config.active_storage.touch_attachment_records`

Directs ActiveStorage::Attachments to touch its corresponding record when updated. The default is true.

3.17.18.`config.active_storage.routes_prefix`

Can be used to set the route prefix for the routes served by Active Storage. Accepts a string that will be prepended to the generated routes.

config.active_storage.routes_prefix="/files"

The default is/rails/active_storage.

3.17.19.`config.active_storage.track_variants`

Determines whether variants are recorded in the database.

The default value depends on theconfig.load_defaults target version:

Starting with version	The default value is
(original)	`false`
6.1	`true`

3.17.20.`config.active_storage.draw_routes`

Can be used to toggle Active Storage route generation. The default istrue.

3.17.21.`config.active_storage.resolve_model_to_route`

Can be used to globally change how Active Storage files are delivered.

Allowed values are:

:rails_storage_redirect: Redirect to signed, short-lived service URLs.
:rails_storage_proxy: Proxy files by downloading them.

The default is:rails_storage_redirect.

3.17.22.`config.active_storage.video_preview_arguments`

Can be used to alter the way ffmpeg generates video preview images.

The default value depends on theconfig.load_defaults target version:

Starting with version The default value is

(original) "-y -vframes 1 -f image2"

7.0

"-vf 'select=eq(n\\,0)+eq(key\\,1)+gt(scene\\,0.015)"¹
+ ",loop=loop=-1:size=2,trim=start_frame=1'"²
+ " -frames:v 1 -f image2"

Select the first video frame, plus keyframes, plus frames that meet the scene change threshold.
Use the first video frame as a fallback when no other frames meet the criteria by looping the first (one or) two selected frames, then dropping the first looped frame.

3.17.23.`config.active_storage.multiple_file_field_include_hidden`

In Rails 7.1 and beyond, Active Storagehas_many_attached relationships willdefault toreplacing the current collection instead ofappending to it. Thusto support submitting anempty collection, whenmultiple_file_field_include_hiddenistrue, thefile_fieldhelper will render an auxiliary hidden field, similar to the auxiliary fieldrendered by thecheckboxhelper.

The default value depends on theconfig.load_defaults target version:

Starting with version	The default value is
(original)	`false`
7.0	`true`

3.17.24.`config.active_storage.precompile_assets`

Determines whether the Active Storage assets should be added to the asset pipeline precompilation. Ithas no effect if Sprockets is not used. The default value istrue.

3.18. Configuring Action Text

3.18.1.`config.action_text.attachment_tag_name`

Accepts a string for the HTML tag used to wrap attachments. Defaults to"action-text-attachment".

3.18.2.`config.action_text.sanitizer_vendor`

Configures the HTML sanitizer used by Action Text by settingActionText::ContentHelper.sanitizer to an instance of the class returned from the vendor's.safe_list_sanitizer method. The default value depends on theconfig.load_defaults target version:

Starting with version	The default value is	Which parses markup as
(original)	`Rails::HTML4::Sanitizer`	HTML4
7.1	`Rails::HTML5::Sanitizer` (see NOTE)	HTML5

Rails::HTML5::Sanitizer is not supported on JRuby, so on JRuby platforms Rails will fall back toRails::HTML4::Sanitizer.

3.18.3.`Regexp.timeout`

See Ruby's documentation forRegexp.timeout=.

3.19. Configuring a Database

Just about every Rails application will interact with a database. You can connect to the database by setting an environment variableENV['DATABASE_URL'] or by using a configuration file calledconfig/database.yml.

Using theconfig/database.yml file you can specify all the information needed to access your database:

development:adapter:postgresqldatabase:blog_developmentpool:5

This will connect to the database namedblog_development using thepostgresql adapter. This same information can be stored in a URL and provided via an environment variable like this:

ENV["DATABASE_URL"]# => "postgresql://localhost/blog_development?pool=5"

Theconfig/database.yml file contains sections for three different environments in which Rails can run by default:

Thedevelopment environment is used on your development/local computer as you interact manually with the application.
Thetest environment is used when running automated tests.
Theproduction environment is used when you deploy your application for the world to use.

If you wish, you can manually specify a URL inside of yourconfig/database.yml

development:url:postgresql://localhost/blog_development?pool=5

Theconfig/database.yml file can contain ERB tags<%= %>. Anything in the tags will be evaluated as Ruby code. You can use this to pull out data from an environment variable or to perform calculations to generate the needed connection information.

When using aENV['DATABASE_URL'] or aurl key in yourconfig/database.ymlfile, Rails allows mapping the protocol in the URL to a database adapter thatcan be configured from within the application. This allows the adapter to beconfigured without modifying the URL set in the deployment environment. See:config.active_record.protocol_adapters.

You don't have to update the database configurations manually. If you look at the options of the application generator, you will see that one of the options is named--database. This option allows you to choose an adapter from a list of the most used relational databases. You can even run the generator repeatedly:cd .. && rails new blog --database=mysql. When you confirm the overwriting of theconfig/database.yml file, your application will be configured for MySQL instead of SQLite. Detailed examples of the common database connections are below.

3.20. Connection Preference

Since there are two ways to configure your connection (usingconfig/database.yml or using an environment variable) it is important to understand how they can interact.

If you have an emptyconfig/database.yml file but yourENV['DATABASE_URL'] is present, then Rails will connect to the database via your environment variable:

$catconfig/database.yml$echo$DATABASE_URLpostgresql://localhost/my_database

If you have aconfig/database.yml but noENV['DATABASE_URL'] then this file will be used to connect to your database:

$catconfig/database.ymldevelopment:  adapter: postgresql  database: my_database  host: localhost$echo$DATABASE_URL

If you have bothconfig/database.yml andENV['DATABASE_URL'] set then Rails will merge the configuration together. To better understand this we must see some examples.

When duplicate connection information is provided the environment variable will take precedence:

$catconfig/database.ymldevelopment:  adapter: sqlite3  database: NOT_my_database  host: localhost$echo$DATABASE_URLpostgresql://localhost/my_database$bin/railsrunner'puts ActiveRecord::Base.configurations.inspect'#<ActiveRecord::DatabaseConfigurations:0x00007fc8eab02880 @configurations=[  #<ActiveRecord::DatabaseConfigurations::UrlConfig:0x00007fc8eab020b0    @env_name="development", @spec_name="primary",    @config={"adapter"=>"postgresql","database"=>"my_database","host"=>"localhost"}    @url="postgresql://localhost/my_database">  ]

Here the adapter, host, and database match the information inENV['DATABASE_URL'].

If non-duplicate information is provided you will get all unique values, environment variable still takes precedence in cases of any conflicts.

$catconfig/database.ymldevelopment:  adapter: sqlite3  pool: 5$echo$DATABASE_URLpostgresql://localhost/my_database$bin/railsrunner'puts ActiveRecord::Base.configurations.inspect'#<ActiveRecord::DatabaseConfigurations:0x00007fc8eab02880 @configurations=[  #<ActiveRecord::DatabaseConfigurations::UrlConfig:0x00007fc8eab020b0    @env_name="development", @spec_name="primary",    @config={"adapter"=>"postgresql","database"=>"my_database","host"=>"localhost","pool"=>5}    @url="postgresql://localhost/my_database">  ]

Since pool is not in theENV['DATABASE_URL'] provided connection information its information is merged in. Sinceadapter is duplicate, theENV['DATABASE_URL'] connection information wins.

The only way to explicitly not use the connection information inENV['DATABASE_URL'] is to specify an explicit URL connection using the"url" sub key:

$catconfig/database.ymldevelopment:  url: sqlite3:NOT_my_database$echo$DATABASE_URLpostgresql://localhost/my_database$bin/railsrunner'puts ActiveRecord::Base.configurations.inspect'#<ActiveRecord::DatabaseConfigurations:0x00007fc8eab02880 @configurations=[  #<ActiveRecord::DatabaseConfigurations::UrlConfig:0x00007fc8eab020b0    @env_name="development", @spec_name="primary",    @config={"adapter"=>"sqlite3","database"=>"NOT_my_database"}    @url="sqlite3:NOT_my_database">  ]

Here the connection information inENV['DATABASE_URL'] is ignored, note the different adapter and database name.

Since it is possible to embed ERB in yourconfig/database.yml it is best practice to explicitly show you are using theENV['DATABASE_URL'] to connect to your database. This is especially useful in production since you should not commit secrets like your database password into your source control (such as Git).

$catconfig/database.ymlproduction:  url: <%= ENV['DATABASE_URL'] %>

Now the behavior is clear, that we are only using the connection information inENV['DATABASE_URL'].

3.20.1. Configuring an SQLite3 Database

Rails comes with built-in support forSQLite3, which is a lightweight serverless database application. While Rails better configures SQLite for production workloads, a busy production environment may overload SQLite. Rails defaults to using an SQLite database when creating a new project because it is a zero configuration database that just works, but you can always change it later.

Here's the section of the default configuration file (config/database.yml) with connection information for the development environment:

development:adapter:sqlite3database:storage/development.sqlite3pool:5timeout:5000

SQLite extensions are supported when usingsqlite3 gem v2.4.0 or later by configuringextensions:

development:adapter:sqlite3extensions:-SQLean::UUID# module name responding to `.to_path`-.sqlpkg/nalgeon/crypto/crypto.so# or a filesystem path-<%= AppExtensions.location %># or ruby code returning a path

Many useful features can be added to SQLite through extensions. You may wish to browse theSQLite extension hub or use gems likesqlpkg-ruby andsqlean-ruby that simplify extension management.

Other configuration options are described in theSQLite3Adapter documentation.

3.20.2. Configuring a MySQL or MariaDB Database

If you choose to use MySQL or MariaDB instead of the shipped SQLite3 database, yourconfig/database.yml will look a little different. Here's the development section:

development:adapter:mysql2encoding:utf8mb4database:blog_developmentpool:5username:rootpassword:socket:/tmp/mysql.sock

If your development database has a root user with an empty password, this configuration should work for you. Otherwise, change the username and password in thedevelopment section as appropriate.

If your MySQL version is 5.5 or 5.6 and want to use theutf8mb4 character set by default, please configure your MySQL server to support the longer key prefix by enablinginnodb_large_prefix system variable.

Advisory Locks are enabled by default on MySQL and are used to make database migrations concurrent safe. You can disable advisory locks by settingadvisory_locks tofalse:

production:adapter:mysql2advisory_locks:false

3.20.3. Configuring a PostgreSQL Database

If you choose to use PostgreSQL, yourconfig/database.yml will be customized to use PostgreSQL databases:

development:adapter:postgresqlencoding:unicodedatabase:blog_developmentpool:5

By default Active Record uses a database feature called advisory locks. You might need to disable this feature if you're using an external connection pooler like PgBouncer:

production:adapter:postgresqladvisory_locks:false

If enabled, Active Record will create up to1000 prepared statements per database connection by default. To modify this behavior you can setstatement_limit to a different value:

production:adapter:postgresqlstatement_limit:200

The more prepared statements in use: the more memory your database will require. If your PostgreSQL database is hitting memory limits, try loweringstatement_limit or disabling prepared statements.

3.20.4. Configuring an SQLite3 Database for JRuby Platform

If you choose to use SQLite3 and are using JRuby, yourconfig/database.yml will look a little different. Here's the development section:

development:adapter:jdbcsqlite3database:storage/development.sqlite3

3.20.5. Configuring a MySQL or MariaDB Database for JRuby Platform

If you choose to use MySQL or MariaDB and are using JRuby, yourconfig/database.yml will look a little different. Here's the development section:

development:adapter:jdbcmysqldatabase:blog_developmentusername:rootpassword:

3.20.6. Configuring a PostgreSQL Database for JRuby Platform

If you choose to use PostgreSQL and are using JRuby, yourconfig/database.yml will look a little different. Here's the development section:

development:adapter:jdbcpostgresqlencoding:unicodedatabase:blog_developmentusername:blogpassword:

Change the username and password in thedevelopment section as appropriate.

3.20.7. Configuring Metadata Storage

By default Rails will store information about your Rails environment and schemain an internal table namedar_internal_metadata.

To turn this off per connection, setuse_metadata_table in your databaseconfiguration. This is useful when working with a shared database and/ordatabase user that cannot create tables.

development:adapter:postgresqluse_metadata_table:false

3.20.8. Configuring Retry Behavior

By default, Rails will automatically reconnect to the database server and retry certain queriesif something goes wrong. Only safely retryable (idempotent) queries will be retried. The numberof retries can be specified in your the database configuration viaconnection_retries, or disabledby setting the value to 0. The default number of retries is 1.

development:adapter:mysql2connection_retries:3

The database config also allows aretry_deadline to be configured. If aretry_deadline is configured,an otherwise-retryable query willnot be retried if the specified time has elapsed while the query wasfirst tried. For example, aretry_deadline of 5 seconds means that if 5 seconds have passed since a querywas first attempted, we won't retry the query, even if it is idempotent and there areconnection_retries left.

This value defaults to nil, meaning that all retryable queries are retried regardless of time elapsed.The value for this config should be specified in seconds.

development:adapter:mysql2retry_deadline:5# Stop retrying queries after 5 seconds

3.20.9. Configuring Query Cache

By default, Rails automatically caches the result sets returned by queries. If Rails encounters the same queryagain for that request or job, it will use the cached result set as opposed to running the query againstthe database again.

The query cache is stored in memory, and to avoid using too much memory, it automatically evicts the least recentlyused queries when reaching a threshold. By default the threshold is100, but can be configured in thedatabase.yml.

development:adapter:mysql2query_cache:200

To entirely disable query caching, it can be set tofalse

development:adapter:mysql2query_cache:false

3.21. Creating Rails Environments

By default Rails ships with three environments: "development", "test", and "production". While these are sufficient for most use cases, there are circumstances when you want more environments.

Imagine you have a server which mirrors the production environment but is only used for testing. Such a server is commonly called a "staging server". To define an environment called "staging" for this server, just create a file calledconfig/environments/staging.rb. Since this is a production-like environment, you could copy the contents ofconfig/environments/production.rb as a starting point and make the necessary changes from there. It's also possible to require and extend other environment configurations like this:

# config/environments/staging.rbrequire_relative"production"Rails.application.configuredo# Staging overridesend

That environment is no different than the default ones, start a server withbin/rails server -e staging, a console withbin/rails console -e staging,Rails.env.staging? works, etc.

3.22. Deploy to a Subdirectory (relative URL root)

By default Rails expects that your application is running at the root(e.g./). This section explains how to run your application inside a directory.

Let's assume we want to deploy our application to "/app1". Rails needs to knowthis directory to generate the appropriate routes:

config.relative_url_root="/app1"

alternatively you can set theRAILS_RELATIVE_URL_ROOT environmentvariable.

Rails will now prepend "/app1" when generating links.

3.22.1. Using Passenger

Passenger makes it easy to run your application in a subdirectory. You can find the relevant configuration in thePassenger manual.

3.22.2. Using a Reverse Proxy

Deploying your application using a reverse proxy has definite advantages over traditional deploys. They allow you to have more control over your server by layering the components required by your application.

Many modern web servers can be used as a proxy server to balance third-party elements such as caching servers or application servers.

One such application server you can use isUnicorn to run behind a reverse proxy.

In this case, you would need to configure the proxy server (NGINX, Apache, etc) to accept connections from your application server (Unicorn). By default Unicorn will listen for TCP connections on port 8080, but you can change the port or configure it to use sockets instead.

You can find more information in theUnicorn readme and understand thephilosophy behind it.

Once you've configured the application server, you must proxy requests to it by configuring your web server appropriately. For example your NGINX config may include:

upstreamapplication_server{server0.0.0.0:8080;}server{listen80;server_namelocalhost;root/root/path/to/your_app/public;try_files$uri/index.html$uri.html@app;location@app{proxy_set_headerX-Forwarded-For$proxy_add_x_forwarded_for;proxy_set_headerHost$http_host;proxy_redirectoff;proxy_passhttp://application_server;}# some other configuration}

Be sure to read theNGINX documentation for the most up-to-date information.

4. Rails Environment Settings

Some parts of Rails can also be configured externally by supplying environment variables. The following environment variables are recognized by various parts of Rails:

ENV["RAILS_ENV"] defines the Rails environment (production, development, test, and so on) that Rails will run under.
ENV["RAILS_RELATIVE_URL_ROOT"] is used by the routing code to recognize URLs when youdeploy your application to a subdirectory.
ENV["RAILS_CACHE_ID"] andENV["RAILS_APP_VERSION"] are used to generate expanded cache keys in Rails' caching code. This allows you to have multiple separate caches from the same application.

5. Using Initializer Files

After loading the framework and any gems in your application, Rails turns toloading initializers. An initializer is any Ruby file stored underconfig/initializers in your application. You can use initializers to holdconfiguration settings that should be made after all of the frameworks and gemsare loaded, such as options to configure settings for these parts.

The files inconfig/initializers (and any subdirectories ofconfig/initializers) are sorted and loaded one by one as part oftheload_config_initializers initializer.

If an initializer has code that relies on code in another initializer, you cancombine them into a single initializer instead. This makes the dependencies moreexplicit, and can help surface new concepts within your application. Rails alsosupports numbering of initializer file names, but this can lead to file namechurn. Explicitly loading initializers withrequire is not recommended, sinceit will cause the initializer to get loaded twice.

There is no guarantee that your initializers will run after all the geminitializers, so any initialization code that depends on a given gem having beeninitialized should go into aconfig.after_initialize block.

6. Load Hooks

Rails code can often be referenced on load of an application. Rails is responsible for the load order of these frameworks, so when you load frameworks, such asActiveRecord::Base, prematurely you are violating an implicit contract your application has with Rails. Moreover, by loading code such asActiveRecord::Base on boot of your application you are loading entire frameworks which may slow down your boot time and could cause conflicts with load order and boot of your application.

Load and configuration hooks are the API that allow you to hook into this initialization process without violating the load contract with Rails. This will also mitigate boot performance degradation and avoid conflicts.

6.1. Avoid Loading Rails Frameworks

Since Ruby is a dynamic language, some code will cause different Rails frameworks to load. Take this snippet for instance:

ActiveRecord::Base.include(MyActiveRecordHelper)

This snippet means that when this file is loaded, it will encounterActiveRecord::Base. This encounter causes Ruby to look for the definition of that constant and will require it. This causes the entire Active Record framework to be loaded on boot.

ActiveSupport.on_load is a mechanism that can be used to defer the loading of code until it is actually needed. The snippet above can be changed to:

ActiveSupport.on_load(:active_record)doincludeMyActiveRecordHelperend

This new snippet will only includeMyActiveRecordHelper whenActiveRecord::Base is loaded.

6.2. When are Hooks called?

In the Rails framework these hooks are called when a specific library is loaded. For example, whenActionController::Base is loaded, the:action_controller_base hook is called. This means that allActiveSupport.on_load calls with:action_controller_base hooks will be called in the context ofActionController::Base (that meansself will be anActionController::Base).

6.3. Modifying Code to Use Load Hooks

Modifying code is generally straightforward. If you have a line of code that refers to a Rails framework such asActiveRecord::Base you can wrap that code in a load hook.

Modifying calls toinclude

ActiveRecord::Base.include(MyActiveRecordHelper)

becomes

ActiveSupport.on_load(:active_record)do# self refers to ActiveRecord::Base here,# so we can call .includeincludeMyActiveRecordHelperend

Modifying calls toprepend

ActionController::Base.prepend(MyActionControllerHelper)

becomes

ActiveSupport.on_load(:action_controller_base)do# self refers to ActionController::Base here,# so we can call .prependprependMyActionControllerHelperend

Modifying calls to class methods

ActiveRecord::Base.include_root_in_json=true

becomes

ActiveSupport.on_load(:active_record)do# self refers to ActiveRecord::Base hereself.include_root_in_json=trueend

6.4. Available Load Hooks

These are the load hooks you can use in your own code. To hook into the initialization process of one of the following classes use the available hook.

Class	Hook
`ActionCable`	`action_cable`
`ActionCable::Channel::Base`	`action_cable_channel`
`ActionCable::Connection::Base`	`action_cable_connection`
`ActionCable::Connection::TestCase`	`action_cable_connection_test_case`
`ActionController::API`	`action_controller_api`
`ActionController::API`	`action_controller`
`ActionController::Base`	`action_controller_base`
`ActionController::Base`	`action_controller`
`ActionController::TestCase`	`action_controller_test_case`
`ActionDispatch::IntegrationTest`	`action_dispatch_integration_test`
`ActionDispatch::Response`	`action_dispatch_response`
`ActionDispatch::Request`	`action_dispatch_request`
`ActionDispatch::SystemTestCase`	`action_dispatch_system_test_case`
`ActionMailbox::Base`	`action_mailbox`
`ActionMailbox::InboundEmail`	`action_mailbox_inbound_email`
`ActionMailbox::Record`	`action_mailbox_record`
`ActionMailbox::TestCase`	`action_mailbox_test_case`
`ActionMailer::Base`	`action_mailer`
`ActionMailer::TestCase`	`action_mailer_test_case`
`ActionText::Content`	`action_text_content`
`ActionText::Record`	`action_text_record`
`ActionText::RichText`	`action_text_rich_text`
`ActionText::EncryptedRichText`	`action_text_encrypted_rich_text`
`ActionView::Base`	`action_view`
`ActionView::TestCase`	`action_view_test_case`
`ActiveJob::Base`	`active_job`
`ActiveJob::TestCase`	`active_job_test_case`
`ActiveModel::Model`	`active_model`
`ActiveModel::Translation`	`active_model_translation`
`ActiveRecord::Base`	`active_record`
`ActiveRecord::DatabaseConfigurations`	`active_record_database_configurations`
`ActiveRecord::Encryption`	`active_record_encryption`
`ActiveRecord::TestFixtures`	`active_record_fixtures`
`ActiveRecord::ConnectionAdapters::PostgreSQLAdapter`	`active_record_postgresqladapter`
`ActiveRecord::ConnectionAdapters::Mysql2Adapter`	`active_record_mysql2adapter`
`ActiveRecord::ConnectionAdapters::TrilogyAdapter`	`active_record_trilogyadapter`
`ActiveRecord::ConnectionAdapters::SQLite3Adapter`	`active_record_sqlite3adapter`
`ActiveStorage::Attachment`	`active_storage_attachment`
`ActiveStorage::VariantRecord`	`active_storage_variant_record`
`ActiveStorage::Blob`	`active_storage_blob`
`ActiveStorage::Record`	`active_storage_record`
`ActiveSupport::TestCase`	`active_support_test_case`
`i18n`	`i18n`

7. Initialization Events

Rails has 5 initialization events which can be hooked into (listed in the order that they are run):

before_configuration: This is run when the application class inherits fromRails::Application inconfig/application.rb. Before the class body is executed. Engines may use this hook to run code before the application itself gets configured.
before_initialize: This is run directly before the initialization process of the application occurs with the:bootstrap_hook initializer near the beginning of the Rails initialization process.
to_prepare: Run after the initializers are run for all Railties (including the application itself) and after the middleware stack is built, but before eager loading. More importantly, will run upon every code reload indevelopment, but only once (during boot-up) inproduction andtest.
before_eager_load: This is run directly before eager loading occurs, which is the default behavior for theproduction environment and not for thedevelopment environment.
after_initialize: Run directly after the initialization of the application, after the application initializers inconfig/initializers are run.

To define an event for these hooks, use the block syntax within aRails::Application,Rails::Railtie orRails::Engine subclass:

moduleYourAppclassApplication<Rails::Applicationconfig.before_initializedo# initialization code goes hereendendend

Alternatively, you can also do it through theconfig method on theRails.application object:

Rails.application.config.before_initializedo# initialization code goes hereend

Some parts of your application, notably routing, are not yet set up at the point where theafter_initialize block is called.

7.1.`Rails::Railtie#initializer`

Rails has several initializers that run on startup that are all defined by using theinitializer method fromRails::Railtie. Here's an example of theset_helpers_path initializer from Action Controller:

initializer"action_controller.set_helpers_path"do|app|ActionController::Helpers.helpers_path=app.helpers_pathsend

Theinitializer method takes three arguments with the first being the name for the initializer and the second being an options hash (not shown here) and the third being a block. The:before key in the options hash can be specified to specify which initializer this new initializer must run before, and the:after key will specify which initializer to run this initializerafter.

Initializers defined using theinitializer method will be run in the order they are defined in, with the exception of ones that use the:before or:after methods.

You may put your initializer before or after any other initializer in the chain, as long as it is logical. Say you have 4 initializers called "one" through "four" (defined in that order) and you define "four" to gobefore "two" butafter "three", that just isn't logical and Rails will not be able to determine your initializer order.

The block argument of theinitializer method is the instance of the application itself, and so we can access the configuration on it by using theconfig method as done in the example.

BecauseRails::Application inherits fromRails::Railtie (indirectly), you can use theinitializer method inconfig/application.rb to define initializers for the application.

7.2. Initializers

Below is a comprehensive list of all the initializers found in Rails in the order that they are defined (and therefore run in, unless otherwise stated).

load_environment_hook: Serves as a placeholder so that:load_environment_config can be defined to run before it.
load_active_support: Optionally requiresactive_support/all ifconfig.active_support.bare is un-truthful, which is the default.
initialize_logger: Initializes the logger (anActiveSupport::BroadcastLogger object) for the application and makes it accessible atRails.logger, provided that no initializer inserted before this point has definedRails.logger.
initialize_cache: IfRails.cache isn't set yet, initializes the cache by referencing the value inconfig.cache_store and stores the outcome asRails.cache. If this object responds to themiddleware method, its middleware is inserted beforeRack::Runtime in the middleware stack.
set_clear_dependencies_hook: This initializer - which runs only ifconfig.enable_reloading is set totrue - usesActionDispatch::Callbacks.after to remove the constants which have been referenced during the request from the object space so that they will be reloaded during the following request.
bootstrap_hook: Runs all configuredbefore_initialize blocks.
i18n.callbacks: In the development environment, sets up ato_prepare callback which will callI18n.reload! if any of the locales have changed since the last request. In production this callback will only run on the first request.
active_support.deprecation_behavior: Sets up deprecation reporting behavior forRails.application.deprecators based onconfig.active_support.report_deprecations,config.active_support.deprecation,config.active_support.disallowed_deprecation, andconfig.active_support.disallowed_deprecation_warnings.
active_support.initialize_time_zone: Sets the default time zone for the application based on theconfig.time_zone setting, which defaults to "UTC".
active_support.initialize_beginning_of_week: Sets the default beginning of week for the application based onconfig.beginning_of_week setting, which defaults to:monday.
active_support.set_configs: Sets up Active Support by using the settings inconfig.active_support bysend'ing the method names as setters toActiveSupport and passing the values through.
action_dispatch.configure: Configures theActionDispatch::Http::URL.tld_length to be set to the value ofconfig.action_dispatch.tld_length.
action_view.set_configs: Sets up Action View by using the settings inconfig.action_view bysend'ing the method names as setters toActionView::Base and passing the values through.
action_controller.assets_config: Initializes theconfig.action_controller.assets_dir to the app's public directory if not explicitly configured.
action_controller.set_helpers_path: Sets Action Controller'shelpers_path to the application'shelpers_path.
action_controller.parameters_config: Configures strong parameters options forActionController::Parameters.
action_controller.set_configs: Sets up Action Controller by using the settings inconfig.action_controller bysend'ing the method names as setters toActionController::Base and passing the values through.
action_controller.compile_config_methods: Initializes methods for the config settings specified so that they are quicker to access.
active_record.initialize_timezone: SetsActiveRecord::Base.time_zone_aware_attributes totrue, as well as settingActiveRecord::Base.default_timezone to UTC. When attributes are read from the database, they will be converted into the time zone specified byTime.zone.
active_record.logger: SetsActiveRecord::Base.logger - if it's not already set - toRails.logger.
active_record.migration_error: Configures middleware to check for pending migrations.
active_record.check_schema_cache_dump: Loads the schema cache dump if configured and available.
active_record.set_configs: Sets up Active Record by using the settings inconfig.active_record bysend'ing the method names as setters toActiveRecord::Base and passing the values through.
active_record.initialize_database: Loads the database configuration (by default) fromconfig/database.yml and establishes a connection for the current environment.
active_record.log_runtime: IncludesActiveRecord::Railties::ControllerRuntime andActiveRecord::Railties::JobRuntime which are responsible for reporting the time taken by Active Record calls for the request back to the logger.
active_record.set_reloader_hooks: Resets all reloadable connections to the database ifconfig.enable_reloading is set totrue.
active_record.add_watchable_files: Addsschema.rb andstructure.sql files to watchable files.
active_job.logger: SetsActiveJob::Base.logger - if it's not already set -toRails.logger.
active_job.set_configs: Sets up Active Job by using the settings inconfig.active_job bysend'ing the method names as setters toActiveJob::Base and passing the values through.
action_mailer.logger: SetsActionMailer::Base.logger - if it's not already set - toRails.logger.
action_mailer.set_configs: Sets up Action Mailer by using the settings inconfig.action_mailer bysend'ing the method names as setters toActionMailer::Base and passing the values through.
action_mailer.compile_config_methods: Initializes methods for the config settings specified so that they are quicker to access.
set_load_path: This initializer runs beforebootstrap_hook. Adds pathsspecified byconfig.paths.load_paths to$LOAD_PATH. And unless you setconfig.add_autoload_paths_to_load_path tofalse, it will also add allautoload paths specified byconfig.autoload_paths,config.eager_load_paths,config.autoload_once_paths.
set_autoload_paths: This initializer runs beforebootstrap_hook. Adds all sub-directories ofapp and paths specified byconfig.autoload_paths,config.eager_load_paths andconfig.autoload_once_paths toActiveSupport::Dependencies.autoload_paths.
add_routing_paths: Loads (by default) allconfig/routes.rb files (in the application and railties, including engines) and sets up the routes for the application.
add_locales: Adds the files inconfig/locales (from the application, railties, and engines) toI18n.load_path, making available the translations in these files.
add_view_paths: Adds the directoryapp/views from the application, railties, and engines to the lookup path for view files for the application.
add_mailer_preview_paths: Adds the directorytest/mailers/previews from the application, railties, and engines to the lookup path for mailer preview files for the application.
load_environment_config: This initializer runs beforeload_environment_hook. Loads theconfig/environments file for the current environment.
prepend_helpers_path: Adds the directoryapp/helpers from the application, railties, and engines to the lookup path for helpers for the application.
load_config_initializers: Loads all Ruby files fromconfig/initializers in the application, railties, and engines. The files in this directory can be used to hold configuration settings that should be made after all of the frameworks are loaded.
engines_blank_point: Provides a point-in-initialization to hook into if you wish to do anything before engines are loaded. After this point, all railtie and engine initializers are run.
add_generator_templates: Finds templates for generators atlib/templates for the application, railties, and engines, and adds these to theconfig.generators.templates setting, which will make the templates available for all generators to reference.
ensure_autoload_once_paths_as_subset: Ensures that theconfig.autoload_once_paths only contains paths fromconfig.autoload_paths. If it contains extra paths, then an exception will be raised.
add_to_prepare_blocks: The block for everyconfig.to_prepare call in the application, a railtie, or engine is added to theto_prepare callbacks for Action Dispatch which will be run per request in development, or before the first request in production.
add_builtin_route: If the application is running under the development environment then this will append the route forrails/info/properties to the application routes. This route provides the detailed information such as Rails and Ruby version forpublic/index.html in a default Rails application.
build_middleware_stack: Builds the middleware stack for the application, returning an object which has acall method which takes a Rack environment object for the request.
eager_load!: Ifconfig.eager_load istrue, runs theconfig.before_eager_load hooks and then callseager_load! which will load allconfig.eager_load_namespaces.
finisher_hook: Provides a hook for after the initialization of process of the application is complete, as well as running all theconfig.after_initialize blocks for the application, railties, and engines.
set_routes_reloader_hook: Configures Action Dispatch to reload the routes file usingActiveSupport::Callbacks.to_run.
disable_dependency_loading: Disables the automatic dependency loading if theconfig.eager_load is set totrue.

8. Database Pooling

Active Record database connections are managed byActiveRecord::ConnectionAdapters::ConnectionPool which ensures that a connection pool synchronizes the amount of thread access to a limited number of database connections. This limit defaults to 5 and can be configured indatabase.yml.

development:adapter:sqlite3database:storage/development.sqlite3pool:5timeout:5000

Since the connection pooling is handled inside of Active Record by default, all application servers (Thin, Puma, Unicorn, etc.) should behave the same. The database connection pool is initially empty. As demand for connections increases it will create them until it reaches the connection pool limit.

Any one request will check out a connection the first time it requires access to the database. At the end of the request it will check the connection back in. This means that the additional connection slot will be available again for the next request in the queue.

If you try to use more connections than are available, Active Record will blockyou and wait for a connection from the pool. If it cannot get a connection, atimeout error similar to that given below will be thrown.

ActiveRecord::ConnectionTimeoutError - could not obtain a database connection within 5.000 seconds (waited 5.000 seconds)

If you get the above error, you might want to increase the size of theconnection pool by incrementing thepool option indatabase.yml

If you are running in a multi-threaded environment, there could be a chance that several threads may be accessing multiple connections simultaneously. So depending on your current request load, you could very well have multiple threads contending for a limited number of connections.

9. Custom Configuration

You can configure your own code through the Rails configuration object withcustom configuration under either theconfig.x namespace, orconfig directly.The key difference between these two is that you should be usingconfig.x if youare definingnested configuration (ex:config.x.nested.hi), and justconfig forsingle level configuration (ex:config.hello).

config.x.payment_processing.schedule=:dailyconfig.x.payment_processing.retries=3config.super_debugger=true

These configuration points are then available through the configuration object:

Rails.configuration.x.payment_processing.schedule# => :dailyRails.configuration.x.payment_processing.retries# => 3Rails.configuration.x.payment_processing.not_set# => nilRails.configuration.super_debugger# => true

You can also useRails::Application.config_for to load whole configuration files:

# config/payment.ymlproduction:environment:productionmerchant_id:production_merchant_idpublic_key:production_public_keyprivate_key:production_private_keydevelopment:environment:sandboxmerchant_id:development_merchant_idpublic_key:development_public_keyprivate_key:development_private_key

# config/application.rbmoduleMyAppclassApplication<Rails::Applicationconfig.payment=config_for(:payment)endend

Rails.configuration.payment["merchant_id"]# => production_merchant_id or development_merchant_id

Rails::Application.config_for supports ashared configuration to group commonconfigurations. The shared configuration will be merged into the environmentconfiguration.

# config/example.ymlshared:foo:bar:baz:1development:foo:bar:qux:2

# development environmentRails.application.config_for(:example)[:foo][:bar]#=> { baz: 1, qux: 2 }

10. Search Engines Indexing

Sometimes, you may want to prevent some pages of your application to be visibleon search sites like Google, Bing, Yahoo, or Duck Duck Go. The robots that indexthese sites will first analyze thehttp://your-site.com/robots.txt file toknow which pages it is allowed to index.

Rails creates this file for you inside the/public folder. By default, it allowssearch engines to index all pages of your application. If you want to blockindexing on all pages of your application, use this:

User-agent: *Disallow: /

To block just specific pages, it's necessary to use a more complex syntax. Learnit on theofficial documentation.

Movatterモバイル変換