Cache Active Model Records in Rails 3
Record Cache transparently stores Records in a Cache Store to retrieve those Records from the store when queried using Active Model. Cache invalidation is performed automatically when Records are created, updated or destroyed. Currently only Active Record is supported, but more data stores may be added in the future.
Add the following line to your Gemfile:
# --- Version Store # All Workers that use the Record Cache should point to the same Version Store # E.g. a MemCached cluster or a Redis Store (defaults to Rails.cache) RecordCache::Base.version_store = Rails.cache # --- Record Stores # Register Cache Stores for the Records themselves # Note: A different Cache Store could be used per Model, but in most configurations the following 2 stores will suffice: # The :local store is used to keep records in Worker memory RecordCache::Base.register_store(:local, ActiveSupport::Cache.lookup_store(:memory_store)) # The :shared store is used to share Records between multiple Workers RecordCache::Base.register_store(:shared, Rails.cache) # Different logger # RecordCache::Base.logger = Logger.new(STDOUT)
Define the Caching Strategy in your models.
Typical Example: /app/models/person.rb:
class Person < ActiveRecord::Base cache_records :store => :shared, :key => "pers" end
Example with Index Cache: /app/models/permission.rb:
class Permission < ActiveRecord::Base cache_records :store => :shared, :key => "perm", :index => [:person_id] belongs_to :person end
Example with Full Table Cache: /app/models/priority.rb:
class Priority < ActiveRecord::Base cache_records :store => :local, :key => "prio", :full_table => true end
The following options are available:
@see Initializer section above how to define named Cache Stores
Using shorter cache keys will improve performance as less data is sent to the Cache Stores
Choose a different column as the unqiue index column in case it is not
has_manyrelations will lead to queries like:
SELECT * FROM permissions WHERE permission.person_id = 10As Record Cache only caches records by ID, this query would always hit the DB. If an index is set on person_id (like in the example above), Record Cache will keep track of the Permission IDs per Person ID. Using that information the query will be translated to:
SELECT * FROM permissions WHERE permission.id IN (14,15,...)and the permissions can be retrieved from cache. Note: The administration overhead for the Permission IDs per Person ID leads to more calls to the Version Store and the Record Store. Whether or not it is profitable to add specific indexes for has_many relations will differ per use-case.
Use this option in case this table is small, is only rarely updated and needs to be retrieved as a whole in most cases. For example to fill a Language or Country drop-down.
To switch off Record Cache during the tests, add the following line to /config/environments/test.rb:
But it is also possible (and preferable during Integration Tests) to keep the Record Cache switched on. To make sure the cache is invalidated for all updated Records after each test/scenario, require the resettable_version_store and reset the Version Store after each test/scenario.
RSpec 2 example, in spec/spec_helper.rb:
require 'record_cache/test/resettable_version_store' RSpec.configure do |config| config.after(:each) do RecordCache::Base.version_store.reset! end end
Cucumber example, in features/support/env.rb:
require 'record_cache/test/resettable_version_store' After do |scenario| RecordCache::Base.version_store.reset! end
This gem is dependent on Rails 3
Only Active Record is supported as a data store.
All servers that host Workers should be time-synchronized (otherwise the Version Store may return stale results).
Record Cache sorting mimics the MySQL sort order being case-insensitive and using collation. If you need a different sort order, check out the code in
update_allto modify attributes used in the :index option will lead to stale results.
(Uncommon) If you have a model (A) with a
has_many :autosave => truerelation to another model (B) that defines a
:counter_cacheback to model A, the
<model B>_countattribute will contain stale results. To solve this, add an after_save hook to model A and update the
<model B>_countattribute there in case the
has_manyrelation was loaded.
The combination of Mongrel (Rack) and the Dalli
:threadsafe => falseoption will lead to the following errors in your log file:
undefined methodconstantize’ for 0:Fixnum`. This is because Mongrel creates multiple threads. To overcome this, set thread_save to true, or consider using a different webserver like Unicorn.
Nested transactions: When using nested transactions, Rails will also call the after_commit hook of records that were updated within a nested transaction that was rolled back. This will cause the cache to contain updates that are not in the database. To overcome this, skip using nested transactions, or disable record cache and manually invalidate all records that were possibly updated within the nested transactions.
Each query is parsed and sent to Record Cache before it is executed to check if the query is cacheable. A query is cacheable if:
it contains at least one
where(:id => ...)or
where(<indexed attribute> => ...)clause, and
it contains zero or more
where(<attribute> => <single value>)clauses on attributes in the same model, and
it has no
limit(...)defined, or is limited to 1 record and has exactly one id in the
where(:id => ...)clause, and
it has no
order(...)clause, or it is sorted on single attributes using ASC and DESC only
it has no joins, calculations, group by, etc. clauses
When the query is accepted by Record Cache, all requested records will be retrieved and cached as follows:
The Version Store is called to retrieve the current version for each ID using a
A new version will be generated (using the current timestamp) for each ID unknown to the Version Store.
The Record Store is called to retrieve the latest data for each ID using a
The data of the missing records is retrieved directly from the Data Store (single query) and are subsequently cached in the Record Store.
The data of all records is deserialized to Active Model records.
The other (simple)
where(<attribute> => <single value>)clauses are applied, if applicable.
order(...)clause is applied, if applicable.
The Version Store is called to retrieve the current version for the group (key
A new version will be generated (using the current timestamp) in case the current version is unknown to the Version Store.
The Record Store is called to retrieve the latest set of IDs in this group (key
In case the IDs are missing, the IDs (only) will be retrieved from the Data Store (single query) and subsequently cached in the Record Store.
The IDs are passed as an ID query to the id-based-cache (see above).
after_commit, :on => :create/:update/:destroy hooks are used to inform the Record Cache of changes to the cached records.
:create: add a new version to the Version Store and cache the record in the Records Store
:update: similar to :create
:destroy: remove the record from the Version Store
:create: increment Version Store for each index that contains the indexed attribute value of this record. In case the IDs in this group are cached and fresh, add the ID of the new record to the group and store the updated list of IDs in the Records Store.
:update: For each index that is included in the changed attribute, apply the :destoy logic to the old value and the :create logic to the new value.
:destroy: increment Version Store for each index that contains the indexed attribute value of this record. In case the IDs in this group are current cached and fresh, remove the ID of the record from the group and store the updated list of IDs in the Records Store.
update_all method of Active Record Relation is also overridden to make sure that mass-updates are processed correctly, e.g. used by the
:counter_cache. As the details of the change are not known, all records that match the IDs mentioned in the update_all statement are invalidated by
removing them from the Version Store.
has_many relations, the
after_commit hooks are not triggered on add and remove. Whether this is a bug or feature I do not know, but
for Active Record the Has Many Association is patched to invalidate the Index Cache of the referenced (reflection) Record in case it has
an :index on the reverse
$ bundle # run the specs (requires ruby 1.9.3) $ appraisal rake # run the specs for a particular version (supported are rails-30 and rails-31) $ appraisal rails-30 rake # run a single spec $ appraisal rails-30 rspec ./spec/lib/strategy/base_spec.rb:61
Deploying the gem:
# Don't forget to update the version in lib/record_cache/version.rb $ git tag -a v0.1.1 -m 'version 0.1.1' $ git push origin master --tags $ gem update --system $ gem build record-cache.gemspec $ gem push record-cache-0.1.1.gem
Debugging the gem:
Switch on DEBUG logging (
config.log_level = :debug in development.rb) to get more information on cache hits and misses.
First version, with the following Strategies:
- Request Cache
- ID Cache
- Index Cache
Added support for Rails 3.1
Refactoring: Moved Serialization, Sorting and Filtering to separate Util class.
Now it is possible to re-use MySQL style sorting (with collation) in your own app, e.g. by calling
- "\u0000" is also used by Arel as a parameter query binding marker.
- https://github.com/orslumen/record-cache/issues/2: bypassing record_cache when selecting rows with lock
- Release Notes ;)
- Ruby 1.9 fixes, has_one support, Remove Freeze for Dalli encoding (Bryan Mundie https://github.com/orslumen/record-cache/pull/3)
- :unique_index option
- :full_table option
- Appraisal - working with different Rails versions
- Travis CI - continuous integration service (Robin Roestenburg https://github.com/orslumen/record-cache/pull/33)
- Rails 3.1 and 3.2 support
- Replace request_cache in favor of ActiveRecord::QueryCache (Lawrence Pit https://github.com/orslumen/record-cache/pull/11)
- Possibility to set a custom logger
- Select queries within a transaction will automatically bypass the cache
- No more increment calls to the Version Store (only set and delete)
- Support for Dalli's +multi+ method to pipeline multiple cache writes (when storing multiple fresh records in the cache, or outdating multiple records after update_all)
- Updated tests to RSpec 3
- Fix deserialization of records with serialized attributes, see https://github.com/orslumen/record-cache/issues/19
- Ruby 2 fix
Copyright (c) 2011-2014 Orslumen, released under the MIT license