123456789_123456789_123456789_123456789_123456789_

Class: ActiveSupport::Cache::MemoryStore

Relationships & Source Files
Super Chains via Extension / Inclusion / Inheritance
Class Chain:
self, Store
Instance Chain:
self, Store
Inherits: ActiveSupport::Cache::Store
Defined in: activesupport/lib/active_support/cache/memory_store.rb

Overview

A cache store implementation which stores everything into memory in the same process. If you’re running multiple Ruby on ::Rails server processes (which is the case if you’re using Phusion Passenger or puma clustered mode), then this means that ::Rails server process instances won’t be able to share cache data with each other and this may not be the most appropriate cache in that scenario.

This cache has a bounded size specified by the :size options to the initializer (default is 32Mb). When the cache exceeds the allotted size, a cleanup will occur which tries to prune the cache down to three quarters of the maximum size by removing the least recently used entries.

MemoryStore is thread-safe.

Constant Summary

Class Attribute Summary

Store - Inherited

.logger

Class Method Summary

Store - Inherited

.new

Creates a new cache.

Instance Attribute Summary

Store - Inherited

#logger, #options,
#silence?

Alias for Store#silence.

Instance Method Summary

Store - Inherited

#cleanup

Cleanups the cache by removing expired entries.
#clear

Clears the entire cache.
#decrement

Decrements an integer value in the cache.
#delete

Deletes an entry in the cache.
#delete_matched

Deletes all entries with keys matching the pattern.
#exist?

Returns true if the cache contains an entry for the given key.
#fetch

Fetches data from the cache, using the given key.
#fetch_multi

Fetches data from the cache, using the given keys.
#increment

Increments an integer value in the cache.
#mute

Silences the logger within a block.
#read

Reads data from the cache, using the given key.
#read_multi

Reads multiple values at once from the cache.
#silence,
#silence!

Silences the logger.
#write

Writes the value to the cache, with the key.
#write_multi

::ActiveSupport::Cache Storage API to write multiple values at once.
#key_matcher

Adds the namespace defined in the options to a pattern designed to match keys.

Constructor Details

.new(options = nil) ⇒ MemoryStore

[ GitHub ] 

  


# File 'activesupport/lib/active_support/cache/memory_store.rb', line 21



def initialize(options = nil)
  options ||= {}
  super(options)
  @data = {}
  @key_access = {}
  @max_size = options[:size] || 32.megabytes
  @max_prune_time = options[:max_prune_time] || 2
  @cache_size = 0
  @monitor = Monitor.new
  @pruning = false
end


  







Instance Attribute Details



  

    #pruning?  ⇒ Boolean  (readonly)
  



  

    

Returns true if the cache is currently being pruned.


  





  


  [ GitHub ]


  

  


# File 'activesupport/lib/active_support/cache/memory_store.rb', line 75



def pruning?
  @pruning
end


  







Instance Method Details



  

    #cleanup(options = nil)  
  



  

    

Preemptively iterates through all stored keys and removes the ones which have expired.


  



  [ GitHub ]


  

  


# File 'activesupport/lib/active_support/cache/memory_store.rb', line 43



def cleanup(options = nil)
  options = merged_options(options)
  instrument(:cleanup, size: @data.size) do
    keys = synchronize { @data.keys }
    keys.each do |key|
      entry = @data[key]
      delete_entry(key, options) if entry && entry.expired?
    end
  end
end


  








  

    #clear(options = nil)  
  



  

    

Delete all data stored in a given cache store.


  



  [ GitHub ]


  

  


# File 'activesupport/lib/active_support/cache/memory_store.rb', line 34



def clear(options = nil)
  synchronize do
    @data.clear
    @key_access.clear
    @cache_size = 0
  end
end


  








  

    #decrement(name, amount = 1, options = nil)  
  



  

    

Decrement an integer value in the cache.


  



  [ GitHub ]


  

  


# File 'activesupport/lib/active_support/cache/memory_store.rb', line 85



def decrement(name, amount = 1, options = nil)
  modify_value(name, -amount, options)
end


  








  

    #delete_matched(matcher, options = nil)  
  



  

    

Deletes cache entries if the cache key matches a given pattern.


  



  [ GitHub ]


  

  


# File 'activesupport/lib/active_support/cache/memory_store.rb', line 90



def delete_matched(matcher, options = nil)
  options = merged_options(options)
  instrument(:delete_matched, matcher.inspect) do
    matcher = key_matcher(matcher, options)
    keys = synchronize { @data.keys }
    keys.each do |key|
      delete_entry(key, options) if key.match(matcher)
    end
  end
end


  








  

    #increment(name, amount = 1, options = nil)  
  



  

    

Increment an integer value in the cache.


  



  [ GitHub ]


  

  


# File 'activesupport/lib/active_support/cache/memory_store.rb', line 80



def increment(name, amount = 1, options = nil)
  modify_value(name, amount, options)
end


  








  

    #prune(target_size, max_time = nil)  
  



  

    

To ensure entries fit within the specified memory prune the cache by removing the least recently accessed entries.


  



  [ GitHub ]


  

  


# File 'activesupport/lib/active_support/cache/memory_store.rb', line 56



def prune(target_size, max_time = nil)
  return if pruning?
  @pruning = true
  begin
    start_time = Time.now
    cleanup
    instrument(:prune, target_size, from: @cache_size) do
      keys = synchronize { @key_access.keys.sort { |a, b| @key_access[a].to_f <=> @key_access[b].to_f } }
      keys.each do |key|
        delete_entry(key, options)
        return if @cache_size <= target_size || (max_time && Time.now - start_time > max_time)
      end
    end
  ensure
    @pruning = false
  end
end