Class: Parse::Cache::Redis

Inherits:
Object
  • Object
show all
Defined in:
lib/parse/cache/redis.rb

Overview

Ergonomic Redis cache builder for Parse Stack. Composes a ConnectionPool of Moneta-Redis stores and carries an optional namespace that Parse::Client will pick up automatically — there is no need to also pass cache_namespace: to Parse.setup when using this wrapper.

Usage:

Parse.setup(
cache: Parse::Cache::Redis.new(
  url: "redis://localhost:6379/0",
  namespace: "app_x",
  pool_size: 10,
),
expires: 60,
...
)

The instance is a Moneta-compatible store (it delegates the four methods the Faraday caching middleware uses — [], key?, delete, store — to a pooled backend), so it can be passed directly to Parse.setup(cache:) / Parse::Client.new(cache:).

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(url:, namespace: nil, pool_size: 5, pool_timeout: 5, **moneta_options) ⇒ Redis

Returns a new instance of Redis.

Parameters:

  • url (String) —

    Redis URL (e.g. "redis://localhost:6379/0").

  • namespace (String, nil) (defaults to: nil) —

    optional key prefix so multiple Parse apps can share one Redis without colliding. When non-nil, the namespace is automatically forwarded to the caching middleware as cache_namespace:.

  • pool_size (Integer) (defaults to: 5) —

    number of pooled Moneta-Redis stores. Defaults to 5 (the Puma default thread count).

    Sizing math (per Faraday request):

    • cache hit: key? + [] = 2 checkouts
    • GET miss + successful store: key? + 3 variant deletes (anonymous + master-key sibling + final key) + 1 store in on_complete = up to 5 checkouts
    • non-GET write (POST/PUT/DELETE): 3 variant deletes = 3 checkouts

    The worst case (5) is on the write-through-after-miss path, not the hit path. Rule of thumb: start at pool_size = RAILS_MAX_THREADS, then bump it up if you observe ConnectionPool::TimeoutError in parse.cache.error notifications (the middleware swallows that error into a passthrough request rather than raising to the caller).

  • pool_timeout (Numeric) (defaults to: 5) —

    seconds to wait for a backend checkout before raising ConnectionPool::TimeoutError. Defaults to 5s. The caching middleware catches that error and falls back to a passthrough request rather than raising to the caller.

  • moneta_options (Hash) —

    extra options passed through to Moneta.new(:Redis, ...) (e.g. :db, :connect_timeout). expires: true is set automatically so per-key TTLs supplied by the caching middleware (the :expires Faraday option) are honored by Redis. Pass expires: false here to opt out — but note that doing so causes cached responses to live forever, which is rarely what you want for a session-token-scoped response cache.



73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
 
# File 'lib/parse/cache/redis.rb', line 73

def initialize(url:, namespace: nil, pool_size: 5, pool_timeout: 5, **moneta_options)
  @url = url
  @namespace = normalize_namespace(namespace)
  @pool_size = pool_size
  @pool_timeout = pool_timeout
  # Default expires: true so per-call `expires:` (the TTL the
  # Faraday caching middleware passes on store) is honored. The
  # Moneta-Redis adapter ignores per-call expires unless the
  # store was constructed with this flag. Without it, cached
  # session-scoped REST responses outlive their token's
  # validity. Callers can still pass `expires: false` to opt out.
  merged_options = { expires: true }.merge(moneta_options)
  @moneta_options = merged_options
  @closed = false
  @pool = Pool.new(size: pool_size, timeout: pool_timeout) do
    Moneta.new(:Redis, { url: url }.merge(merged_options))
  end
end

Instance Attribute Details

#namespace ⇒ String? (readonly)

Returns cache key namespace prefix (or nil if not set).

Returns:

  • (String, nil) —

    cache key namespace prefix (or nil if not set).



32
33
34
 
# File 'lib/parse/cache/redis.rb', line 32

def namespace
  @namespace
end

#pool_size ⇒ Integer (readonly)

Returns pool size.

Returns:

  • (Integer) —

    pool size.



35
36
37
 
# File 'lib/parse/cache/redis.rb', line 35

def pool_size
  @pool_size
end

#url ⇒ String (readonly)

Returns Redis connection URL.

Returns:

  • (String) —

    Redis connection URL.



38
39
40
 
# File 'lib/parse/cache/redis.rb', line 38

def url
  @url
end

Instance Method Details

#[](key) ⇒ Object 



92
93
94
 
# File 'lib/parse/cache/redis.rb', line 92

def [](key)
  @pool[key]
end

#clear(scope: nil) ⇒ Object

Clear cached entries belonging to this wrapper. Required for Parse::Client#clear_cache! compatibility.

Namespace-scoped when a namespace is set: the wrapper walks <namespace>:* via Redis SCAN and DELs the matching keys, leaving other tenants on the same DB untouched. When no namespace is configured the wrapper falls back to FLUSHDB on the backing DB — same blast radius as previous versions, but only for unnamespaced deployments. To opt into the wide FLUSHDB explicitly (e.g. ops tooling), call #flush_db!.

Parameters:

  • scope (String, nil) (defaults to: nil) —

    explicit namespace prefix to scan-delete. When provided, overrides the wrapper's configured @namespace and SCAN-deletes <scope>:* regardless of how the wrapper was built. This is the safe escape hatch for tenants that share a non- namespaced wrapper but still want to evict only their own keys without FLUSHDB-ing siblings (and without wiping parse-stack:foc:v1:* create-lock keys that live on the same DB). The scope must be a non-empty String; the trailing : is added automatically and any trailing : in the input is stripped so "tenant_x" and "tenant_x:" are equivalent.



142
143
144
145
146
147
148
149
150
151
152
 
# File 'lib/parse/cache/redis.rb', line 142

def clear(scope: nil)
  if scope
    prefix = validate_scope!(scope)
    delete_keys_matching!("#{prefix}:*")
  elsif @namespace
    delete_keys_matching!("#{@namespace}:*")
  else
    @pool.clear
  end
  self
end

#close ⇒ Object

Close all pooled connections. Safe to call multiple times.



164
165
166
167
168
 
# File 'lib/parse/cache/redis.rb', line 164

def close
  return if @closed
  @closed = true
  @pool.close
end

#create(key, value, options = {}) ⇒ Object

Atomic SETNX. Required so Parse::CreateLock can acquire cross-process locks when this wrapper is the configured cache / synchronize_create_store. Returns true only when the key did not already exist.



112
113
114
 
# File 'lib/parse/cache/redis.rb', line 112

def create(key, value, options = {})
  @pool.create(key, value, options)
end

#delete(key) ⇒ Object 



100
101
102
 
# File 'lib/parse/cache/redis.rb', line 100

def delete(key)
  @pool.delete(key)
end

#flush_db! ⇒ Object

Issue FLUSHDB on the backing Redis DB, regardless of whether a namespace is configured. Evicts every key on the selected DB, including unrelated tenants — use only for ops tooling that owns the whole DB.



158
159
160
161
 
# File 'lib/parse/cache/redis.rb', line 158

def flush_db!
  @pool.clear
  self
end

#increment(key, amount = 1, options = {}) ⇒ Object

Atomic counter increment. Forwarded for Moneta surface parity.



117
118
119
 
# File 'lib/parse/cache/redis.rb', line 117

def increment(key, amount = 1, options = {})
  @pool.increment(key, amount, options)
end

#key?(key) ⇒ Boolean

Returns:

  • (Boolean) 


96
97
98
 
# File 'lib/parse/cache/redis.rb', line 96

def key?(key)
  @pool.key?(key)
end

#store(key, value, options = {}) ⇒ Object 



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

def store(key, value, options = {})
  @pool.store(key, value, options)
end