CODEWITHSUNDEEP
ruby-on-railsruby-on-rails-3
Crashalot
Crashalot

Reputation: 34513

Keep value in memory across requests and across users in Rails controller? Use class variable?

We're on Rails 3.0.6.

We maintain a list of numbers that changes only once a month, but nearly every page request requires access to this list.

We store the list in the database.

Instead of hitting the database on every request and grabbing the list, we would like to grab the data once and stash it in memory for efficient access.

If we store the list in each user session, we still need to hit the database for each session.

Is there a way to only hit the database once and let the values persist in memory across all users and all sessions? We need access to the list from the controller. Should we define a class variable in the controller?

Thanks!

Upvotes: 4

Views: 3368

Answers (2)

Bradley Priest
Bradley Priest

Reputation: 7458

I think Rails.cache is the answer to your problem here. It's a simple interface with multiple backends, the default stores the cache in memory, but if you're already using Memcached, Redis or similar in your app you can plug it into those instead.

Try throwing something similar to this in your ApplicationController

def list_of_numbers
  @list_of_numbers ||= Rails.cache.fetch(:list_of_numbers, :expires_in => 24.hours) do
    # Read from database
  end
end

It will try to read from the cache, but if it doesn't find it, will do the intensive stuff and store it for next time

Upvotes: 8

Tom Harrison
Tom Harrison

Reputation: 14028

The pattern you're looking for is known as a singleton which is a simple way to cache stuff that doesn't change over time, for example, you'll often see something like this in application_controller.rb -- your code always calls the method

def current_user(user_id)
  @current_user ||= User.find user_id
end

When it does, it checks the instance variable @current_user and returns it if not nil, otherwise it does the database lookup and assigns the result to the instance variable, which it returns.

Your problem is similar, but broader, since it applies to all instances.

One solution is with a class variable, which is documented here http://www.ruby-doc.org/docs/ProgrammingRuby/html/tut_classes.html#S3 -- a similar solution to the one above applies here.

This might be a good solution in your case, but has some issues. In specific, (assuming this is a web app) depending on your configuration, you may have multiple instances of Rails loaded in different processes, and class variables only apply to their specific instance. The popular Passenger module (for Apache and Nginx) can be configured to allow class variables to be accessible to all of it's instances ... which works great if you have only one server.

But when you have multiple servers, things get a little tricky. Sure, you could use a class variable and accept that you'll have to make one hit to the database for each server. This works great except for the when that the variable ... varies! You'll need some way of invalidating the variable across all servers. Depending on how critical the it is, this could create various very gnarly and difficult to track down errors (I learned the hard way :-).

Enter memcached. This is a wonderful tool that is a general purpose caching tool. It's very lightweight, and very, very smart. In particular, it can create distributed caches across a cluster of servers -- the value is only ever stored once (thus avoiding the synchronization problem noted above) and each server knows which server to look on to find any given cache key. It even handles when servers go down and all sorts of other unpleasantries.

Setup is remarkably easy, and Rails almost assumes you'll use it for your various caching needs, and the Rails gem just makes it as simple as pie.

On the assumption that there will be other opportunities to cache stuff that might not be as simple as a value you can store in a class variable, that's probably the first place to start.

Upvotes: 3

Related Questions