Best way to create custom config options for my Rails app?

I need to create one config option for my Rails application. It can be the same for all environments. I found that if I set it in environment.rb, it's available in my views, which is exactly what I want...


AUDIOCAST_URI_FORMAT = http://blablalba/blabbitybla/yadda

Works great.

However, I'm a little uneasy. Is this a good way to do it? Is there a way that's more hip?


For general application configuration that doesn't need to be stored in a database table, I like to create a config.yml file within the config directory. For your example, it might look like this:

defaults: &defaults
  audiocast_uri_format: http://blablalba/blabbitybla/yadda

  <<: *defaults

  <<: *defaults

  <<: *defaults

This configuration file gets loaded from a custom initializer in config/initializers:

# Rails 2
APP_CONFIG = YAML.load_file("#{RAILS_ROOT}/config/config.yml")[RAILS_ENV]

# Rails 3+
APP_CONFIG = YAML.load_file(Rails.root.join('config/config.yml'))[Rails.env]

If you're using Rails 3, ensure you don't accidentally add a leading slash to your relative config path.

You can then retrieve the value using:

uri_format = APP_CONFIG['audiocast_uri_format']

See this Railscast for full details.

Rails 3 version of initialiser code is as follows (RAILS_ROOT & RAILS_ENV are deprecated)

APP_CONFIG = YAML.load_file(Rails.root.join('config', 'config.yml'))[Rails.env]

Also, Ruby 1.9.3 uses Psych which makes merge keys case sensitive so you'll need to change your config file to take that into account, e.g.

defaults: &DEFAULTS
  audiocast_uri_format: http://blablalba/blabbitybla/yadda




Rails >= 4.2

Just create a YAML file into config/ directory, for example: config/neo4j.yml.

Content of neo4j.yml can be somthing like below(For simplicity, I used default for all environments):

default: &default
  host: localhost
  port: 7474
  username: neo4j
  password: root

  <<: *default

  <<: *default

  <<: *default

in config/application.rb:

module MyApp
  class Application < Rails::Application
    config.neo4j = config_for(:neo4j)

Now, your custom config is accessible like below:

Rails.configuration.neo4j['host'] #=>localhost
Rails.configuration.neo4j['port'] #=>7474

More info

Rails official API document describes config_for method as:

Convenience for loading config/foo.yml for the current Rails env.

If you do not want to use a yaml file

As Rails official guide says:

You can configure your own code through the Rails configuration object with custom configuration under the config.x property.


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

These configuration points are then available through the configuration object:

Rails.configuration.x.payment_processing.schedule # => :daily
Rails.configuration.x.payment_processing.retries  # => 3
Rails.configuration.x.super_debugger              # => true
Rails.configuration.x.super_debugger.not_set      # => nil

Official Reference for config_for method | Official Rails Guide

Step 1: Create config/initializers/appconfig.rb

require 'ostruct'
require 'yaml'

all_config = YAML.load_file("#{Rails.root}/config/config.yml") || {}
env_config = all_config[Rails.env] || {}
AppConfig =

Step 2: Create config/config.yml

common: &common
    key: 'asdjhasxas'
    secret : 'xyz'
    key: 'asdjhasxas'
    secret : 'abx'

  <<: *common

  <<: *common

  <<: *common

Step 3: Get constants anywhere in the code

facebook_key = AppConfig.facebook['key']
twitter_key  = AppConfig.twitter['key']

I just wanted to update this for the latest cool stuff in Rails 4.2 and 5, you can now do this inside any of your config/**/*.rb files:

config.x.whatever = 42

(and that's a literal x in there, ie. the config.x. literally must be that, and then you can add whatever you want after the x)

...and this will be available in your app as:


See more here:

Just some extra info on this topic:

APP_CONFIG = YAML.load_file(Rails.root.join('config', 'config.yml'))[Rails.env].with_indifferent_access

".with_indifferent_access" allows you to access the values in the hash using a string key or with an equivalent symbol key.

eg. APP_CONFIG['audiocast_uri_format'] => 'http://blablalba/blabbitybla/yadda' APP_CONFIG[:audiocast_uri_format] => 'http://blablalba/blabbitybla/yadda'

Purely a convenience thing, but I prefer to have my keys represented as symbols.

I use something similar to John for Rails 3.0/3.1, but I have erb parse the file first:

APP_CONFIG = YAML.load('../config.yml', __FILE__)).read).result)[Rails.env]

This allows me to use ERB in my config if I need to, like reading heroku's redistogo url:

  <<: *default
  redis:                  <%= ENV['REDISTOGO_URL'] %>

Rails 4

To create a custom configuration yaml and load it (and make available to your app) similar to how database_configuration.

Create your *.yml, in my case I needed a redis configuration file.


default: &default
  host: localhost
  port: 6379

  <<: *default

  <<: *default

  <<: *default
  host: <%= ENV['ELASTICACHE_HOST'] %>
  port: <%= ENV['ELASTICACHE_PORT'] %>

Then load the configuration


module MyApp
  class Application < Rails::Application

    config.before_initialize do
      Rails.configuration.redis_configuration = YAML.load_file("#{Rails.root}/config/redis.yml")


Access the values:

Rails.configuration.redis_configuration[Rails.env] similar to how you can have access to your database.yml by Rails.configuration.database_configuration[Rails.env]

Building on Omer Aslam's elegant solution, I decided to convert the keys into symbols. The only change is:

all_config = YAML.load_file("#{Rails.root}/config/config.yml").with_indifferent_access || {}

This allows you to then reference values by symbols as keys, e.g.


This seems neater to my eyes.

(Posted as an answer as my reputation isn't high enough to comment on Omer's reply)

I like simpleconfig. It allows you to have per environment configuration.

see my response to Where is the best place to store application parameters : database, file, code...?

A variation to what you had in that it's a simple reference to another file. It sees that environment.rb isn't constantly updated and doesn't have a heap of app specific stuff in it. Though not a specific answer to your question of 'is it the Rails way?', perhaps there'll be some discussion there about that.

I prefer accessing settings through the global application stack. I avoid excess global variables in local scope.


MyAppName::Application.define_singleton_method("myconfig") {YAML.load_file("#{Rails.root}/config/myconfig.yml") || {}}

And access it with.


My way to load Settings before Rails initialize

Allows you to use settings in Rails initialization and configure settings per environment

# config/application.rb

mode = ENV['RAILS_ENV'] || 'development'
file = File.dirname(__FILE__).concat('/settings.yml')
Settings = YAML.load_file(file).fetch(mode)
Settings.define_singleton_method(:method_missing) {|name| self.fetch(name.to_s, nil)}

You could get settings in two ways: Settings['email'] or

My best way to custom config, with raise message when setting.yml is missing.

gets loaded from a custom initializer in config/initializers/custom_config.rb

setting_config = File.join(Rails.root,'config','setting.yml')
raise "#{setting_config} is missing!" unless File.exists? setting_config
config = YAML.load_file(setting_config)[Rails.env].symbolize_keys

@APP_ID = config[:app_id]
@APP_SECRET = config[:app_secret]

Create a YAML in config/setting.yml

  app_id: 433387212345678
  app_secret: f43df96fc4f65904083b679412345678

  app_id: 148166412121212
  app_secret: 7409bda8139554d11173a32222121212

  app_id: 148166412121212
  app_secret: 7409bda8139554d11173a32222121212

Need Your Help

gcc: How to ignore standard include paths?


I need to compile some files with a usage of modified versions of standard library headers. With Visual C++ compiler I will do this by usage of /X (Ignore Standard Include Paths) and /I (Additional

py2exe - No system module 'pywintypes'

python windows py2exe pywin32 anaconda

I'm trying to convert a simple Python script into a Windows executable. My script is: