Class: Cache

Inherits:
Object
  • Object
show all
Defined in:
lib/object/cache.rb,
lib/object/cache/version.rb

Overview

Caching of objects in a Redis store

Constant Summary collapse

VERSION = 
'0.1.2'

Class Attribute Summary collapse

Class Method Summary collapse

Class Attribute Details

.backend ⇒ Object

Returns the value of attribute backend.



11
12
13
 
# File 'lib/object/cache.rb', line 11

def backend
  @backend
end

.default_key_prefix ⇒ Object

Returns the value of attribute default_key_prefix.



13
14
15
 
# File 'lib/object/cache.rb', line 13

def default_key_prefix
  @default_key_prefix
end

.default_ttl ⇒ Object

Returns the value of attribute default_ttl.



12
13
14
 
# File 'lib/object/cache.rb', line 12

def default_ttl
  @default_ttl
end

Class Method Details

.build_key(key, key_prefix, proc) ⇒ Object 



108
109
110
111
112
113
 
# File 'lib/object/cache.rb', line 108

def build_key(key, key_prefix, proc)
  hash   = Digest::SHA1.hexdigest([key, proc.source_location].flatten.join)[0..11]
  prefix = build_key_prefix(key_prefix, proc)

  [prefix, hash].compact.join('_')
end

.build_key_prefix(key_prefix, proc) ⇒ Object 



115
116
117
118
119
120
121
122
123
124
125
 
# File 'lib/object/cache.rb', line 115

def build_key_prefix(key_prefix, proc)
  case key_prefix
  when :method_name
    location = caller_locations.find { |l| proc.source_location.join == "#{l.path}#{l.lineno}" }
    location&.base_label
  when :class_name
    proc.binding.receiver.class.to_s
  else
    key_prefix
  end
end

.delete(key) ⇒ Object 



82
83
84
85
86
87
 
# File 'lib/object/cache.rb', line 82

def delete(key)
  return false unless include?(key)

  primary.del(key)
  true
end

.include?(key) ⇒ Boolean

Returns:

  • (Boolean) 


76
77
78
79
80
 
# File 'lib/object/cache.rb', line 76

def include?(key)
  replica.exists?(key)
rescue
  false
end

.new(key = nil, ttl: default_ttl, key_prefix: default_key_prefix, &block) ⇒ Object

new

Finds the correct value (based on the provided key) in the cache store, or calls the original code, and stores the result in cache.

The TTL of the cached content is provided with the optional ‘ttl` named argument. If left blank, the `DEFAULT_TTL` ttl value will be used.

The caching key will be determined by creating a SHA digest of the original code’s file location and line number within that file. This makes it easier to provide short caching keys like uid’s, or ids, and still receive a unique caching key under which the data is stored.

The cache key can optionally be left blank. This should **only be done** if the provided data by the method will never changes based on some form of input.

For example: caching an ‘Item` should always be done by providing a unique item identifier as the caching key, otherwise the cache will return the same item every time, even if a different one is stored the second time.

good:

Cache.new { 'hello world' } # stored object is always the same
Cache.new(item.id) { item } # stored item is namespaced using its id

bad:

Cache.new { item } # item is only stored once, and then always
                   # retrieved, even if it is a different item



47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
 
# File 'lib/object/cache.rb', line 47

def new(key = nil, ttl: default_ttl, key_prefix: default_key_prefix, &block)
  return yield unless replica

  begin
    key = build_key(key, key_prefix, block)

    if (cached_value = replica.get(key)).nil?
      yield.tap do |value|
        begin
          update_cache(key, value, ttl: ttl)
        rescue TypeError
          # if `TypeError` is raised, the data could not be Marshal dumped. In that
          # case, delete anything left in the cache store, and get the data without
          # caching.
          #
          delete(key)
        end
      end
    else
      begin
        Marshal.load(cached_value)
      rescue
        delete(key)
        yield
      end
    end
  end
end

.primary ⇒ Object 



95
96
97
 
# File 'lib/object/cache.rb', line 95

def primary
  backend.is_a?(Hash) ? backend[:primary] : backend
end

.replica ⇒ Object 



104
105
106
 
# File 'lib/object/cache.rb', line 104

def replica
  replicas.sample
end

.replicas ⇒ Object 



99
100
101
102
 
# File 'lib/object/cache.rb', line 99

def replicas
  replicas = backend.is_a?(Hash) ? backend[:replicas] : backend
  replicas.respond_to?(:sample) ? replicas : [replicas]
end

.update_cache(key, value, ttl: default_ttl) ⇒ Object 



89
90
91
92
93
 
# File 'lib/object/cache.rb', line 89

def update_cache(key, value, ttl: default_ttl)
  return unless primary && (value = Marshal.dump(value))

  ttl.to_i.zero? ? primary.set(key, value) : primary.setex(key, ttl.to_i, value)
end