mudis 0.7.3 → 0.8.1
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- checksums.yaml +4 -4
- data/README.md +952 -863
- data/lib/mudis/version.rb +3 -3
- data/lib/mudis.rb +640 -521
- data/lib/mudis_client.rb +65 -65
- data/lib/mudis_config.rb +35 -25
- data/lib/mudis_proxy.rb +37 -37
- data/lib/mudis_server.rb +81 -81
- data/sig/mudis.rbs +56 -56
- data/sig/mudis_client.rbs +22 -22
- data/sig/mudis_config.rbs +10 -10
- data/sig/mudis_server.rbs +6 -6
- data/spec/eviction_spec.rb +29 -29
- data/spec/guardrails_spec.rb +138 -138
- data/spec/memory_guard_spec.rb +33 -33
- data/spec/metrics_spec.rb +34 -34
- data/spec/mudis_client_spec.rb +137 -137
- data/spec/mudis_server_spec.rb +94 -90
- data/spec/mudis_spec.rb +183 -183
- data/spec/namespace_spec.rb +69 -69
- data/spec/persistence_spec.rb +38 -0
- data/spec/reset_spec.rb +31 -31
- metadata +9 -3
data/README.md
CHANGED
|
@@ -1,863 +1,952 @@
|
|
|
1
|
-
|
|
2
|
-
|
|
3
|
-
[
|
|
2
|
+
|
|
3
|
+
[](https://www.jetbrains.com/ruby/)
|
|
4
|
+
|
|
5
|
+
[](https://badge.fury.io/rb/mudis)
|
|
6
|
+
[](LICENSE)
|
|
7
|
+
|
|
8
|
+
**Mudis** is a fast, thread-safe, in-memory, sharded LRU (Least Recently Used) cache for Ruby applications. Inspired by Redis, it provides value serialization, optional compression, per-key expiry, and metric tracking in a lightweight, dependency-free package that lives inside your Ruby process.
|
|
9
|
+
|
|
10
|
+
It’s ideal for scenarios where performance and process-local caching are critical, and where a full Redis setup is overkill or otherwise not possible/desirable.
|
|
11
|
+
|
|
12
|
+
Alternatively, Mudis can be upscaled with higher sharding and resources in a dedicated Rails/Hanami/Roda/etc app to provide a [Mudis Web Cache Server](#create-a-mudis-web-cache-server).
|
|
13
|
+
|
|
14
|
+
Mudis also works naturally in Hanami because it’s a pure Ruby in-memory cache. Whether used as a singleton within a process or via IPC in cluster mode, it preserves Hanami’s lightweight and modular architecture.
|
|
15
|
+
|
|
16
|
+
---
|
|
17
|
+
|
|
18
|
+
## Table of Contents
|
|
19
|
+
|
|
20
|
+
- [Why Another Caching Gem?](#why-another-caching-gem)
|
|
21
|
+
- [Similar Gems](#similar-gems)
|
|
22
|
+
- [Feature / Function Comparison](#feature--function-comparison)
|
|
23
|
+
- [Design](#design)
|
|
24
|
+
- [Internal Structure and Behaviour](#internal-structure-and-behaviour)
|
|
25
|
+
- [Write - Read - Eviction](#write---read---eviction)
|
|
26
|
+
- [Cache Key Lifecycle](#cache-key-lifecycle)
|
|
27
|
+
- [Features](#features)
|
|
28
|
+
- [Installation](#installation)
|
|
29
|
+
- [Configuration (Rails)](#configuration-rails)
|
|
30
|
+
- [Configuration (Hanami)](#configuration-hanami)
|
|
31
|
+
- [Start and Stop Exipry Thread](#start-and-stop-exipry-thread)
|
|
32
|
+
- [Starting Exipry Thread](#starting-exipry-thread)
|
|
33
|
+
- [Graceful Shutdown](#graceful-shutdown)
|
|
34
|
+
- [Basic Usage](#basic-usage)
|
|
35
|
+
- [Developer Utilities](#developer-utilities)
|
|
36
|
+
- [`Mudis.reset!`](#mudisreset)
|
|
37
|
+
- [`Mudis.reset_metrics!`](#mudisreset_metrics)
|
|
38
|
+
- [`Mudis.least_touched`](#mudisleast_touched)
|
|
39
|
+
- [`Mudis.keys(namespace:)`](#mudiskeysnamespace)
|
|
40
|
+
- [`Mudis.clear_namespace(namespace:)`](#mudisclear_namespacenamespace)
|
|
41
|
+
- [Rails Service Integration](#rails-service-integration)
|
|
42
|
+
- [Metrics](#metrics)
|
|
43
|
+
- [Advanced Configuration](#advanced-configuration)
|
|
44
|
+
- [Soft Persistence (Snapshots)](#soft-persistence-snapshots)
|
|
45
|
+
- [Inter-Process Caching (IPC Mode)](#inter-process-caching-ipc-mode)
|
|
46
|
+
- [Overview](#overview)
|
|
47
|
+
- [Setup (Puma)](#setup-puma)
|
|
48
|
+
- [Benchmarks](#benchmarks)
|
|
49
|
+
- [Known Limitations](#known-limitations)
|
|
50
|
+
- [Create a Mudis Web Cache Server](#create-a-mudis-web-cache-server)
|
|
51
|
+
- [Project Philosophy](#project-philosophy)
|
|
52
|
+
- [Roadmap](#roadmap)
|
|
53
|
+
|
|
54
|
+
---
|
|
55
|
+
|
|
56
|
+
### Why another Caching Gem?
|
|
57
|
+
|
|
58
|
+
There are plenty out there, in various states of maintenance and in many shapes and sizes. So why on earth do we need another? I needed a drop-in replacement for Kredis, and the reason I was interested in using Kredis was for the simplified API and keyed management it gave me in extension to Redis. But what I didn't really need was Redis. I needed an observable, fast, simple, easy to use, flexible and highly configurable, thread-safe and high performant caching system which didn't require too many dependencies or standing up additional services. So, Mudis was born. In its most rudimentary state it was extremely useful in my project, which was an API gateway connecting into mutliple micro-services and a wide selection of APIs. The majority of the data was cold and produced by repeat expensive queries across several domains. Mudis allowed for me to minimize the footprint of the gateway, and improve end user experience, and increase performance. So, yeah, there's a lot of these gems out there, but none which really met all my needs. I decided to provide Mudis for anyone else. If you use it, I'd be interested to know how and whether you got any benefit.
|
|
59
|
+
|
|
60
|
+
#### Similar Gems
|
|
61
|
+
|
|
62
|
+
- [FastCache](https://github.com/swoop-inc/fast_cache)
|
|
63
|
+
- [EasyCache](https://github.com/malvads/easycache)
|
|
64
|
+
- [MiniCache](https://github.com/derrickreimer/mini_cache)
|
|
65
|
+
- [Zache](https://github.com/yegor256/zache)
|
|
66
|
+
|
|
67
|
+
#### Feature / Function Comparison
|
|
68
|
+
|
|
69
|
+
| **Feature** | **Mudis** | **MemoryStore** (`Rails.cache`) | **FastCache** | **Zache** | **EasyCache** | **MiniCache** |
|
|
70
|
+
| -------------------------------------- | ---------------- | ------------------------------- | -------------- | ------------- | ------------- | -------------- |
|
|
71
|
+
| **LRU eviction strategy** | ✅ Per-bucket | ✅ Global | ✅ Global | ❌ | ❌ | ✅ Simplistic |
|
|
72
|
+
| **TTL expiry support** | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ |
|
|
73
|
+
| **Background expiry cleanup thread** | ✅ | ❌ (only on access) | ❌ | ✅ | ❌ | ❌ |
|
|
74
|
+
| **Thread safety** | ✅ Bucketed | ⚠️ Global lock | ✅ Fine-grained | ✅ | ⚠️ | ⚠️ |
|
|
75
|
+
| **Sharding (buckets)** | ✅ | ❌ | ✅ | ❌ | ❌ | ❌ |
|
|
76
|
+
| **Custom serializers** | ✅ | ✅ | ❌ | ❌ | ❌ | ❌ |
|
|
77
|
+
| **Compression (Zlib)** | ✅ | ✅ | ❌ | ❌ | ❌ | ❌ |
|
|
78
|
+
| **Hard memory cap** | ✅ | ❌ | ❌ | ❌ | ❌ | ❌ |
|
|
79
|
+
| **Max value size enforcement** | ✅ | ❌ | ❌ | ❌ | ❌ | ❌ |
|
|
80
|
+
| **Metrics (hits, misses, evictions)** | ✅ | ⚠️ Partial | ❌ | ❌ | ❌ | ❌ |
|
|
81
|
+
| **Fetch/update pattern** | ✅ Full | ✅ Standard | ⚠️ Partial | ✅ Basic | ✅ Basic | ✅ Basic |
|
|
82
|
+
| **Namespacing** | ✅ | ✅ | ❌ | ❌ | ❌ | ❌ |
|
|
83
|
+
| **Replace (if exists)** | ✅ | ✅ | ❌ | ❌ | ❌ | ❌ |
|
|
84
|
+
| **Clear/delete method** | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ |
|
|
85
|
+
| **Key inspection with metadata** | ✅ | ❌ | ❌ | ❌ | ❌ | ❌ |
|
|
86
|
+
| **Concurrency model** | ✅ | ❌ | ✅ | ❌ | ❌ | ❌ |
|
|
87
|
+
| **Maintenance level** | ✅ | ✅ | ✅ | ⚠️ | ⚠️ | ⚠️ |
|
|
88
|
+
| **Suitable for APIs or microservices** | ✅ | ⚠️ Limited | ✅ | ⚠️ Small apps | ⚠️ Small apps | ❌ |
|
|
89
|
+
| **Inter-process Caching** | ✅ | ❌ | ❌ | ❌ | ❌ | ❌ |
|
|
90
|
+
| **Warm boot data snapshot** | ✅ | ❌ | ❌ | ❌ | ❌ | ❌ |
|
|
91
|
+
|
|
92
|
+
---
|
|
93
|
+
|
|
94
|
+
## Design
|
|
95
|
+
|
|
96
|
+
#### Internal Structure and Behaviour
|
|
97
|
+
|
|
98
|
+
|
|
99
|
+
|
|
100
|
+
#### Write - Read - Eviction
|
|
101
|
+
|
|
102
|
+
|
|
103
|
+
|
|
104
|
+
#### Cache Key Lifecycle
|
|
105
|
+
|
|
106
|
+
|
|
107
|
+
|
|
108
|
+
---
|
|
109
|
+
|
|
110
|
+
## Features
|
|
111
|
+
|
|
112
|
+
- **Thread-safe**: Uses per-bucket mutexes for high concurrency.
|
|
113
|
+
- **Sharded**: Buckets data across multiple internal stores to minimize lock contention.
|
|
114
|
+
- **LRU Eviction**: Automatically evicts least recently used items as memory fills up.
|
|
115
|
+
- **Expiry Support**: Optional TTL per key with background cleanup thread.
|
|
116
|
+
- **Compression**: Optional Zlib compression for large values.
|
|
117
|
+
- **Metrics**: Tracks hits, misses, and evictions.
|
|
118
|
+
- **IPC Mode**: Shared cross-process caching for multi-process aplications.
|
|
119
|
+
- **Soft-persistence**: Data snapshot and reload.
|
|
120
|
+
|
|
121
|
+
---
|
|
122
|
+
|
|
123
|
+
## Installation
|
|
124
|
+
|
|
125
|
+
Add this line to your Gemfile:
|
|
126
|
+
|
|
127
|
+
```ruby
|
|
128
|
+
gem 'mudis'
|
|
129
|
+
```
|
|
130
|
+
|
|
131
|
+
Or install it manually:
|
|
132
|
+
|
|
133
|
+
```bash
|
|
134
|
+
gem install mudis
|
|
135
|
+
```
|
|
136
|
+
|
|
137
|
+
---
|
|
138
|
+
|
|
139
|
+
## Configuration (Rails)
|
|
140
|
+
|
|
141
|
+
In your Rails app, create an initializer:
|
|
142
|
+
|
|
143
|
+
```ruby
|
|
144
|
+
# config/initializers/mudis.rb
|
|
145
|
+
Mudis.configure do |c|
|
|
146
|
+
c.serializer = JSON # or Marshal | Oj
|
|
147
|
+
c.compress = true # Compress values using Zlib
|
|
148
|
+
c.max_value_bytes = 2_000_000 # Reject values > 2MB
|
|
149
|
+
c.hard_memory_limit = true # enforce hard memory limits
|
|
150
|
+
c.max_bytes = 1_073_741_824 # set maximum cache size
|
|
151
|
+
end
|
|
152
|
+
|
|
153
|
+
Mudis.start_expiry_thread(interval: 60) # Cleanup every 60s
|
|
154
|
+
|
|
155
|
+
at_exit do
|
|
156
|
+
Mudis.stop_expiry_thread
|
|
157
|
+
end
|
|
158
|
+
```
|
|
159
|
+
|
|
160
|
+
Or with direct setters:
|
|
161
|
+
|
|
162
|
+
```ruby
|
|
163
|
+
Mudis.serializer = JSON # or Marshal | Oj
|
|
164
|
+
Mudis.compress = true # Compress values using Zlib
|
|
165
|
+
Mudis.max_value_bytes = 2_000_000 # Reject values > 2MB
|
|
166
|
+
Mudis.hard_memory_limit = true # enforce hard memory limits
|
|
167
|
+
Mudis.max_bytes = 1_073_741_824 # set maximum cache size
|
|
168
|
+
|
|
169
|
+
Mudis.start_expiry_thread(interval: 60) # Cleanup every 60s
|
|
170
|
+
|
|
171
|
+
## set at exit hook
|
|
172
|
+
```
|
|
173
|
+
|
|
174
|
+
---
|
|
175
|
+
|
|
176
|
+
## Configuration (Hanami)
|
|
177
|
+
|
|
178
|
+
Mudis integrates seamlessly with [Hanami](https://hanamirb.org) applications. It provides the same configuration flexibility and thread-safe caching capabilities as in Rails, with minimal setup differences.
|
|
179
|
+
|
|
180
|
+
Create a boot file:
|
|
181
|
+
|
|
182
|
+
```ruby
|
|
183
|
+
# config/boot/mudis.rb
|
|
184
|
+
require "mudis"
|
|
185
|
+
|
|
186
|
+
Mudis.configure do |c|
|
|
187
|
+
c.serializer = JSON
|
|
188
|
+
c.compress = true
|
|
189
|
+
c.max_value_bytes = 2_000_000
|
|
190
|
+
c.hard_memory_limit = true
|
|
191
|
+
c.max_bytes = 1_073_741_824
|
|
192
|
+
end
|
|
193
|
+
|
|
194
|
+
Mudis.start_expiry_thread(interval: 60)
|
|
195
|
+
|
|
196
|
+
at_exit { Mudis.stop_expiry_thread }
|
|
197
|
+
```
|
|
198
|
+
|
|
199
|
+
Then require it from `config/app.rb`:
|
|
200
|
+
|
|
201
|
+
```ruby
|
|
202
|
+
# config/app.rb
|
|
203
|
+
require_relative "./boot/mudis"
|
|
204
|
+
|
|
205
|
+
module MyApp
|
|
206
|
+
class App < Hanami::App
|
|
207
|
+
end
|
|
208
|
+
end
|
|
209
|
+
```
|
|
210
|
+
|
|
211
|
+
This ensures Mudis is initialized and available globally throughout your Hanami application in the same as it would in Rails.
|
|
212
|
+
|
|
213
|
+
---
|
|
214
|
+
|
|
215
|
+
### Using Mudis with Hanami’s Dependency Container
|
|
216
|
+
|
|
217
|
+
You can register Mudis as a dependency in the Hanami container to access it via dependency injection:
|
|
218
|
+
|
|
219
|
+
```ruby
|
|
220
|
+
# config/container.rb
|
|
221
|
+
require "mudis"
|
|
222
|
+
|
|
223
|
+
MyApp::Container.register(:cache, Mudis)
|
|
224
|
+
```
|
|
225
|
+
|
|
226
|
+
Then use it inside your actions, repositories, or services:
|
|
227
|
+
|
|
228
|
+
```ruby
|
|
229
|
+
# apps/main/actions/users/show.rb
|
|
230
|
+
module Main
|
|
231
|
+
module Actions
|
|
232
|
+
module Users
|
|
233
|
+
class Show < Main::Action
|
|
234
|
+
include Deps[cache: "cache"]
|
|
235
|
+
|
|
236
|
+
def handle(req, res)
|
|
237
|
+
res[:user] = cache.fetch("user:#{req.params[:id]}", expires_in: 60) do
|
|
238
|
+
UserRepo.new.find(req.params[:id])
|
|
239
|
+
end
|
|
240
|
+
end
|
|
241
|
+
end
|
|
242
|
+
end
|
|
243
|
+
end
|
|
244
|
+
end
|
|
245
|
+
```
|
|
246
|
+
|
|
247
|
+
---
|
|
248
|
+
|
|
249
|
+
## Start and Stop Exipry Thread
|
|
250
|
+
|
|
251
|
+
The expiry thread is not triggered automatically when your application starts. You must add the start and stop in the respective process hooks.
|
|
252
|
+
|
|
253
|
+
### Starting Exipry Thread
|
|
254
|
+
|
|
255
|
+
To enable background expiration and removal, you must start the expiry thread at start up after configuration.
|
|
256
|
+
|
|
257
|
+
```ruby
|
|
258
|
+
Mudis.start_expiry_thread(interval: 60)
|
|
259
|
+
```
|
|
260
|
+
|
|
261
|
+
### Graceful Shutdown
|
|
262
|
+
|
|
263
|
+
Don’t forget to stop the expiry thread in your exit hook when your app exits:
|
|
264
|
+
|
|
265
|
+
```ruby
|
|
266
|
+
at_exit { Mudis.stop_expiry_thread }
|
|
267
|
+
```
|
|
268
|
+
|
|
269
|
+
---
|
|
270
|
+
|
|
271
|
+
## Basic Usage
|
|
272
|
+
|
|
273
|
+
```ruby
|
|
274
|
+
require 'mudis'
|
|
275
|
+
|
|
276
|
+
# Write a value with optional TTL
|
|
277
|
+
Mudis.write('user:123', { name: 'Alice' }, expires_in: 600)
|
|
278
|
+
|
|
279
|
+
# Read it back
|
|
280
|
+
Mudis.read('user:123') # => { "name" => "Alice" }
|
|
281
|
+
|
|
282
|
+
# Check if it exists
|
|
283
|
+
Mudis.exists?('user:123') # => true
|
|
284
|
+
|
|
285
|
+
# Atomically update
|
|
286
|
+
Mudis.update('user:123') { |data| data.merge(age: 30) }
|
|
287
|
+
|
|
288
|
+
# Delete a key
|
|
289
|
+
Mudis.delete('user:123')
|
|
290
|
+
```
|
|
291
|
+
|
|
292
|
+
### Developer Utilities
|
|
293
|
+
|
|
294
|
+
Mudis provides utility methods to help with test environments, console debugging, and dev tool resets.
|
|
295
|
+
|
|
296
|
+
#### `Mudis.reset!`
|
|
297
|
+
Clears the internal cache state. Including all keys, memory tracking, and metrics. Also stops the expiry thread.
|
|
298
|
+
|
|
299
|
+
```ruby
|
|
300
|
+
Mudis.write("foo", "bar")
|
|
301
|
+
Mudis.reset!
|
|
302
|
+
Mudis.read("foo") # => nil
|
|
303
|
+
```
|
|
304
|
+
|
|
305
|
+
- Wipe all buckets (@stores, @lru_nodes, @current_bytes)
|
|
306
|
+
- Reset all metrics (:hits, :misses, :evictions, :rejected)
|
|
307
|
+
- Stop any running background expiry thread
|
|
308
|
+
|
|
309
|
+
#### `Mudis.reset_metrics!`
|
|
310
|
+
|
|
311
|
+
Clears only the metric counters and preserves all cached values.
|
|
312
|
+
|
|
313
|
+
```ruby
|
|
314
|
+
Mudis.write("key", "value")
|
|
315
|
+
Mudis.read("key") # => "value"
|
|
316
|
+
Mudis.metrics # => { hits: 1, misses: 0, ... }
|
|
317
|
+
|
|
318
|
+
Mudis.reset_metrics!
|
|
319
|
+
Mudis.metrics # => { hits: 0, misses: 0, ... }
|
|
320
|
+
Mudis.read("key") # => "value" (still cached)
|
|
321
|
+
```
|
|
322
|
+
|
|
323
|
+
#### `Mudis.least_touched`
|
|
324
|
+
|
|
325
|
+
Returns the top `n` (or all) keys that have been read the fewest number of times, across all buckets. This is useful for identifying low-value cache entries that may be safe to remove or exclude from caching altogether.
|
|
326
|
+
|
|
327
|
+
Each result includes the full key and its access count.
|
|
328
|
+
|
|
329
|
+
```ruby
|
|
330
|
+
Mudis.least_touched
|
|
331
|
+
# => [["foo", 0], ["user:42", 1], ["product:123", 2], ...]
|
|
332
|
+
|
|
333
|
+
Mudis.least_touched(5)
|
|
334
|
+
# => returns top 5 least accessed keys
|
|
335
|
+
```
|
|
336
|
+
|
|
337
|
+
#### `Mudis.keys(namespace:)`
|
|
338
|
+
|
|
339
|
+
Returns all keys for a given namespace.
|
|
340
|
+
|
|
341
|
+
```ruby
|
|
342
|
+
Mudis.write("u1", "alpha", namespace: "users")
|
|
343
|
+
Mudis.write("u2", "beta", namespace: "users")
|
|
344
|
+
|
|
345
|
+
Mudis.keys(namespace: "users")
|
|
346
|
+
# => ["u1", "u2"]
|
|
347
|
+
|
|
348
|
+
```
|
|
349
|
+
|
|
350
|
+
#### `Mudis.clear_namespace(namespace:)`
|
|
351
|
+
|
|
352
|
+
Deletes all keys within a namespace.
|
|
353
|
+
|
|
354
|
+
```ruby
|
|
355
|
+
Mudis.clear_namespace("users")
|
|
356
|
+
Mudis.read("u1", namespace: "users") # => nil
|
|
357
|
+
```
|
|
358
|
+
|
|
359
|
+
---
|
|
360
|
+
|
|
361
|
+
## Rails Service Integration
|
|
362
|
+
|
|
363
|
+
For simplified or transient use in a controller, you can wrap your cache logic in a reusable thin class:
|
|
364
|
+
|
|
365
|
+
```ruby
|
|
366
|
+
class MudisService
|
|
367
|
+
attr_reader :cache_key, :namespace
|
|
368
|
+
|
|
369
|
+
# Initialize the service with a cache key and optional namespace
|
|
370
|
+
#
|
|
371
|
+
# @param cache_key [String] the base key to use
|
|
372
|
+
# @param namespace [String, nil] optional logical namespace
|
|
373
|
+
def initialize(cache_key, namespace: nil)
|
|
374
|
+
@cache_key = cache_key
|
|
375
|
+
@namespace = namespace
|
|
376
|
+
end
|
|
377
|
+
|
|
378
|
+
# Write a value to the cache
|
|
379
|
+
#
|
|
380
|
+
# @param data [Object] the value to cache
|
|
381
|
+
# @param expires_in [Integer, nil] optional TTL in seconds
|
|
382
|
+
def write(data, expires_in: nil)
|
|
383
|
+
Mudis.write(cache_key, data, expires_in: expires_in, namespace: namespace)
|
|
384
|
+
end
|
|
385
|
+
|
|
386
|
+
# Read the cached value or return default
|
|
387
|
+
#
|
|
388
|
+
# @param default [Object] fallback value if key is not present
|
|
389
|
+
def read(default: nil)
|
|
390
|
+
Mudis.read(cache_key, namespace: namespace) || default
|
|
391
|
+
end
|
|
392
|
+
|
|
393
|
+
# Update the cached value using a block
|
|
394
|
+
#
|
|
395
|
+
# @yieldparam current [Object] the current value
|
|
396
|
+
# @yieldreturn [Object] the updated value
|
|
397
|
+
def update
|
|
398
|
+
Mudis.update(cache_key, namespace: namespace) { |current| yield(current) }
|
|
399
|
+
end
|
|
400
|
+
|
|
401
|
+
# Delete the key from cache
|
|
402
|
+
def delete
|
|
403
|
+
Mudis.delete(cache_key, namespace: namespace)
|
|
404
|
+
end
|
|
405
|
+
|
|
406
|
+
# Return true if the key exists in cache
|
|
407
|
+
def exists?
|
|
408
|
+
Mudis.exists?(cache_key, namespace: namespace)
|
|
409
|
+
end
|
|
410
|
+
|
|
411
|
+
# Fetch from cache or compute and store it
|
|
412
|
+
#
|
|
413
|
+
# @param expires_in [Integer, nil] optional TTL
|
|
414
|
+
# @param force [Boolean] force recomputation
|
|
415
|
+
# @yield return value if key is missing
|
|
416
|
+
def fetch(expires_in: nil, force: false)
|
|
417
|
+
Mudis.fetch(cache_key, expires_in: expires_in, force: force, namespace: namespace) do
|
|
418
|
+
yield
|
|
419
|
+
end
|
|
420
|
+
end
|
|
421
|
+
|
|
422
|
+
# Inspect metadata for the current key
|
|
423
|
+
#
|
|
424
|
+
# @return [Hash, nil] metadata including :expires_at, :created_at, :size_bytes, etc.
|
|
425
|
+
def inspect_meta
|
|
426
|
+
Mudis.inspect(cache_key, namespace: namespace)
|
|
427
|
+
end
|
|
428
|
+
end
|
|
429
|
+
|
|
430
|
+
```
|
|
431
|
+
|
|
432
|
+
Use it like:
|
|
433
|
+
|
|
434
|
+
```ruby
|
|
435
|
+
cache = MudisService.new("user:42:profile", namespace: "users")
|
|
436
|
+
|
|
437
|
+
cache.write({ name: "Alice" }, expires_in: 300)
|
|
438
|
+
cache.read # => { "name" => "Alice" }
|
|
439
|
+
cache.exists? # => true
|
|
440
|
+
|
|
441
|
+
cache.update { |data| data.merge(age: 30) }
|
|
442
|
+
cache.fetch(expires_in: 60) { expensive_query }
|
|
443
|
+
cache.inspect_meta # => { key: "users:user:42:profile", ... }
|
|
444
|
+
```
|
|
445
|
+
|
|
446
|
+
*This pattern can also be applied in Hanami services using the registered Mudis dependency*
|
|
447
|
+
|
|
448
|
+
---
|
|
449
|
+
|
|
450
|
+
## Metrics
|
|
451
|
+
|
|
452
|
+
Track cache effectiveness and performance:
|
|
453
|
+
|
|
454
|
+
```ruby
|
|
455
|
+
Mudis.metrics
|
|
456
|
+
# => {
|
|
457
|
+
# hits: 15,
|
|
458
|
+
# misses: 5,
|
|
459
|
+
# evictions: 3,
|
|
460
|
+
# rejected: 0,
|
|
461
|
+
# total_memory: 45678,
|
|
462
|
+
# least_touched: [
|
|
463
|
+
# ["user:1", 0],
|
|
464
|
+
# ["post:5", 1],
|
|
465
|
+
# ...
|
|
466
|
+
# ],
|
|
467
|
+
# buckets: [
|
|
468
|
+
# { index: 0, keys: 12, memory_bytes: 12345, lru_size: 12 },
|
|
469
|
+
# ...
|
|
470
|
+
# ]
|
|
471
|
+
# }
|
|
472
|
+
|
|
473
|
+
```
|
|
474
|
+
|
|
475
|
+
Optionally, expose Mudis metrics from a controller or action for remote analysis and monitoring.
|
|
476
|
+
|
|
477
|
+
**Rails:**
|
|
478
|
+
|
|
479
|
+
```ruby
|
|
480
|
+
class MudisController < ApplicationController
|
|
481
|
+
def metrics
|
|
482
|
+
render json: { mudis: Mudis.metrics }
|
|
483
|
+
end
|
|
484
|
+
|
|
485
|
+
end
|
|
486
|
+
```
|
|
487
|
+
|
|
488
|
+
**Hanami:**
|
|
489
|
+
|
|
490
|
+
*Mudis Registered in the container*
|
|
491
|
+
|
|
492
|
+
```ruby
|
|
493
|
+
# apps/main/actions/metrics/show.rb
|
|
494
|
+
module Main::Actions::Metrics
|
|
495
|
+
class Show < Main::Action
|
|
496
|
+
include Deps[cache: "cache"]
|
|
497
|
+
|
|
498
|
+
def handle(*, res)
|
|
499
|
+
res.format = :json
|
|
500
|
+
res.body = { mudis: cache.metrics }.to_json
|
|
501
|
+
end
|
|
502
|
+
end
|
|
503
|
+
end
|
|
504
|
+
```
|
|
505
|
+
|
|
506
|
+
*Mudis not registered in the container*
|
|
507
|
+
|
|
508
|
+
```ruby
|
|
509
|
+
# apps/main/actions/metrics/show.rb
|
|
510
|
+
module Main::Actions::Metrics
|
|
511
|
+
class Show < Main::Action
|
|
512
|
+
def handle(*, res)
|
|
513
|
+
res.format = :json
|
|
514
|
+
res.body = { mudis: Mudis.metrics }.to_json
|
|
515
|
+
end
|
|
516
|
+
end
|
|
517
|
+
end
|
|
518
|
+
```
|
|
519
|
+
|
|
520
|
+
```ruby
|
|
521
|
+
# config/routes.rb
|
|
522
|
+
module Main
|
|
523
|
+
class Routes < Hanami::Routes
|
|
524
|
+
root { "OK" }
|
|
525
|
+
|
|
526
|
+
get "/metrics", to: "metrics.show"
|
|
527
|
+
end
|
|
528
|
+
end
|
|
529
|
+
```
|
|
530
|
+
|
|
531
|
+
---
|
|
532
|
+
|
|
533
|
+
## Advanced Configuration
|
|
534
|
+
|
|
535
|
+
| Setting | Description | Default |
|
|
536
|
+
|--------------------------|---------------------------------------------|--------------------|
|
|
537
|
+
| `Mudis.serializer` | JSON, Marshal, or Oj | `JSON` |
|
|
538
|
+
| `Mudis.compress` | Enable Zlib compression | `false` |
|
|
539
|
+
| `Mudis.max_value_bytes` | Max allowed size in bytes for a value | `nil` (no limit) |
|
|
540
|
+
| `Mudis.buckets` | Number of cache shards | `32` |
|
|
541
|
+
| `Mudis.start_expiry_thread` | Background TTL cleanup loop (every N sec) | Disabled by default|
|
|
542
|
+
| `Mudis.hard_memory_limit` | Enforce hard memory limits on key size and reject if exceeded | `false`|
|
|
543
|
+
| `Mudis.max_bytes` | Maximum allowed cache size | `1GB`|
|
|
544
|
+
| `Mudis.max_ttl` | Set the maximum permitted TTL | `nil` (no limit) |
|
|
545
|
+
| `Mudis.default_ttl` | Set the default TTL for fallback when none is provided | `nil` |
|
|
546
|
+
|
|
547
|
+
Buckets can also be set using a `MUDIS_BUCKETS` environment variable.
|
|
548
|
+
|
|
549
|
+
When setting `serializer`, be mindful of the below
|
|
550
|
+
|
|
551
|
+
| Serializer | Recommended for |
|
|
552
|
+
| ---------- | ------------------------------------- |
|
|
553
|
+
| `Marshal` | Ruby-only apps, speed-sensitive logic |
|
|
554
|
+
| `JSON` | Cross-language interoperability |
|
|
555
|
+
| `Oj` | API-heavy apps using JSON at scale |
|
|
556
|
+
|
|
557
|
+
---
|
|
558
|
+
|
|
559
|
+
## Soft Persistence (Snapshots)
|
|
560
|
+
|
|
561
|
+
Originally, Mudis was not designed to provide any form of persistence. But I recently had a situation where warm data recovery post-crash reboot was necessary.This could be achieved with a parallel service or peripheral worker, but I decided instead to address this challenge for my own purposes by expanding Mudis to optionally soft-persist its in-memory cache to disk between process restarts.
|
|
562
|
+
|
|
563
|
+
When enabled, it will automatically:
|
|
564
|
+
|
|
565
|
+
- **Save** a snapshot of the current cache at shutdown
|
|
566
|
+
- **Reload** it on startup
|
|
567
|
+
|
|
568
|
+
This feature is **off by default** to preserve existing configurations and can be enabled as below:
|
|
569
|
+
|
|
570
|
+
```ruby
|
|
571
|
+
Mudis.configure do |config|
|
|
572
|
+
config.persistence_enabled = true
|
|
573
|
+
config.persistence_path = "tmp/mudis_snapshot.dump"
|
|
574
|
+
config.persistence_format = :marshal # or :json
|
|
575
|
+
config.persistence_safe_write = true # atomic temp write + rename
|
|
576
|
+
end
|
|
577
|
+
|
|
578
|
+
## Optionally install the exit hook manually (usually automatic)
|
|
579
|
+
# Mudis.install_persistence_hook!
|
|
580
|
+
```
|
|
581
|
+
|
|
582
|
+
From your startup routine:
|
|
583
|
+
|
|
584
|
+
```ruby
|
|
585
|
+
# Restore snapshot on startup
|
|
586
|
+
Mudis.load_snapshot!
|
|
587
|
+
```
|
|
588
|
+
|
|
589
|
+
*This feature works identically in Rails, Hanami, and standalone Ruby scripts, as long as `Mudis.configure` is called prior to `Mudis.load_snapshot!`.*
|
|
590
|
+
|
|
591
|
+
### Behavior
|
|
592
|
+
|
|
593
|
+
| Operation | Description |
|
|
594
|
+
|------------|-------------|
|
|
595
|
+
| `save_snapshot!` | Dumps all non-expired cache entries to disk. |
|
|
596
|
+
| `load_snapshot!` | Reads snapshot and restores entries via normal write path. |
|
|
597
|
+
| `install_persistence_hook!` | Registers an `at_exit` hook to automatically save on process exit. |
|
|
598
|
+
|
|
599
|
+
#### Notes
|
|
600
|
+
|
|
601
|
+
- Disabled by default for backward compatibility.
|
|
602
|
+
- Uses Ruby’s `Marshal` by default for fastest serialization; `:json` also supported.
|
|
603
|
+
- Respects TTLs: expired entries are never written to disk.
|
|
604
|
+
- Thread-safe: snapshots are taken under shard-level locks.
|
|
605
|
+
- Safe write: when `persistence_safe_write = true`, Mudis writes to a temp file and renames it atomically.
|
|
606
|
+
|
|
607
|
+
#### Example Flow
|
|
608
|
+
|
|
609
|
+
|
|
610
|
+
|
|
611
|
+
1. On startup, `Mudis.load_snapshot!` repopulates the cache.
|
|
612
|
+
2. Your app uses the cache as normal (`write`, `read`, `fetch`, etc.).
|
|
613
|
+
3. When the process exits, `at_exit` automatically triggers `save_snapshot!`.
|
|
614
|
+
4. A file (e.g., `tmp/mudis_snapshot.dump`) holds your persisted cache.
|
|
615
|
+
|
|
616
|
+
#### Safety
|
|
617
|
+
|
|
618
|
+
If the snapshot file is **missing** or **corrupted**, Mudis will:
|
|
619
|
+
- Log a warning via `warn "[Mudis] Failed to load snapshot..."`, and
|
|
620
|
+
- Continue booting normally with an empty cache.
|
|
621
|
+
|
|
622
|
+
---
|
|
623
|
+
|
|
624
|
+
## Inter-Process Caching (IPC Mode)
|
|
625
|
+
|
|
626
|
+
While Mudis was originally designed as an in-process cache, it can also operate as a shared inter-process cache when running in environments that use concurrent processes (such as Puma in cluster mode). This is achieved through a local UNIX socket server that allows all workers to access a single, centralized Mudis instance. When running otherwise as a per process (worker) singleton you may encounter oddities or duplicate cache data.
|
|
627
|
+
|
|
628
|
+
### Overview
|
|
629
|
+
|
|
630
|
+
In IPC mode, Mudis runs as a singleton server within the master process.
|
|
631
|
+
|
|
632
|
+
Each worker connects to that server through a lightweight client (`MudisClient`) using a local UNIX domain socket (default: `/tmp/mudis.sock`).
|
|
633
|
+
All cache operations, e.g., read, write, delete, fetch, etc., are transparently proxied to the master process, which holds the authoritative cache state.
|
|
634
|
+
|
|
635
|
+
This design allows multiple workers to share the same cache without duplicating memory or losing synchronization, while retaining Mudis’ performance, configurability, and thread safety.
|
|
636
|
+
|
|
637
|
+
| **Benefit** | **Description** |
|
|
638
|
+
| --------------------------------- | ---------------------------------------------------------------------------------------- |
|
|
639
|
+
| **Shared Cache Across Processes** | All Puma workers share one Mudis instance via IPC. |
|
|
640
|
+
| **Zero External Dependencies** | No Redis, Memcached, or separate daemon required. |
|
|
641
|
+
| **Memory Efficient** | Cache data stored only once, not duplicated per worker. |
|
|
642
|
+
| **Full Feature Support** | All Mudis features (TTL, compression, metrics, etc.) work transparently. |
|
|
643
|
+
| **Safe & Local** | Communication is limited to the host system’s UNIX socket, ensuring isolation and speed. |
|
|
644
|
+
|
|
645
|
+
|
|
646
|
+
|
|
647
|
+
### Setup (Puma)
|
|
648
|
+
|
|
649
|
+
Enable IPC mode by adding the following to your Puma configuration:
|
|
650
|
+
|
|
651
|
+
```ruby
|
|
652
|
+
# config/puma.rb
|
|
653
|
+
preload_app!
|
|
654
|
+
|
|
655
|
+
before_fork do
|
|
656
|
+
require "mudis"
|
|
657
|
+
require "mudis_server"
|
|
658
|
+
|
|
659
|
+
# typical Mudis configuration
|
|
660
|
+
Mudis.configure do |c|
|
|
661
|
+
c.serializer = JSON
|
|
662
|
+
c.compress = true
|
|
663
|
+
c.max_value_bytes = 2_000_000
|
|
664
|
+
c.hard_memory_limit = true
|
|
665
|
+
c.max_bytes = 1_073_741_824
|
|
666
|
+
end
|
|
667
|
+
|
|
668
|
+
Mudis.start_expiry_thread(interval: 60)
|
|
669
|
+
MudisServer.start!
|
|
670
|
+
|
|
671
|
+
## any start up services or background workers
|
|
672
|
+
# which require the cache should be started here
|
|
673
|
+
at_exit { Mudis.stop_expiry_thread }
|
|
674
|
+
end
|
|
675
|
+
|
|
676
|
+
on_worker_boot do
|
|
677
|
+
require "mudis_client"
|
|
678
|
+
$mudis = MudisClient.new
|
|
679
|
+
require "mudis_proxy" # optionally require the default mudis proxy to invisibly patch Mudis
|
|
680
|
+
|
|
681
|
+
end
|
|
682
|
+
```
|
|
683
|
+
|
|
684
|
+
For more granular control over Mudis, adding a custom Proxy manually to `initializers` (Rails) or `boot` (Hanami) allows seamless use of the API as documented.
|
|
685
|
+
|
|
686
|
+
**Do not require `mudis_proxy` if following this method**
|
|
687
|
+
|
|
688
|
+
Example custom proxy:
|
|
689
|
+
|
|
690
|
+
```ruby
|
|
691
|
+
# config/<<initializers|boot>>/mudis_proxy.rb
|
|
692
|
+
if defined?($mudis) && $mudis
|
|
693
|
+
class Mudis
|
|
694
|
+
def self.read(*a, **k) = $mudis.read(*a, **k)
|
|
695
|
+
def self.write(*a, **k) = $mudis.write(*a, **k)
|
|
696
|
+
def self.delete(*a, **k) = $mudis.delete(*a, **k)
|
|
697
|
+
def self.fetch(*a, **k, &b) = $mudis.fetch(*a, **k, &b)
|
|
698
|
+
def self.metrics = $mudis.metrics
|
|
699
|
+
def self.reset_metrics! = $mudis.reset_metrics!
|
|
700
|
+
def self.reset! = $mudis.reset!
|
|
701
|
+
end
|
|
702
|
+
|
|
703
|
+
end
|
|
704
|
+
```
|
|
705
|
+
|
|
706
|
+
**Use IPC mode when:**
|
|
707
|
+
|
|
708
|
+
- Running Rails or Rack apps under Puma cluster or multi-process background job workers.
|
|
709
|
+
- You need cache consistency and memory efficiency without standing up Redis.
|
|
710
|
+
- You want to preserve Mudis’s observability, configurability, and in-process simplicity at a larger scale.
|
|
711
|
+
|
|
712
|
+
---
|
|
713
|
+
|
|
714
|
+
## Benchmarks
|
|
715
|
+
|
|
716
|
+
#### Serializer(s)
|
|
717
|
+
|
|
718
|
+
_100000 iterations_
|
|
719
|
+
|
|
720
|
+
| Serializer | Total Time (s) | Ops/sec |
|
|
721
|
+
|----------------|------------|----------------|
|
|
722
|
+
| oj | 0.1342 | 745320 |
|
|
723
|
+
| marshal | 0.3228 | 309824 |
|
|
724
|
+
| json | 0.9035 | 110682 |
|
|
725
|
+
| oj + zlib | 1.8050 | 55401 |
|
|
726
|
+
| marshal + zlib | 1.8057 | 55381 |
|
|
727
|
+
| json + zlib | 2.7949 | 35780 |
|
|
728
|
+
|
|
729
|
+
> If opting for OJ, you will need to install the dependency in your project and configure as needed.
|
|
730
|
+
|
|
731
|
+
#### Mudis vs Rails.cache
|
|
732
|
+
|
|
733
|
+
Mudis is marginally slower than `Rails.cache` by design; it trades raw speed for control, observability, and safety.
|
|
734
|
+
|
|
735
|
+
_10000 iterations of 1MB, Marshal (to match MemoryStore default), compression ON_
|
|
736
|
+
|
|
737
|
+
| Operation | `Rails.cache` | `Mudis` | Delta |
|
|
738
|
+
| --------- | ------------- | ----------- | --------- |
|
|
739
|
+
| Write | 2.139 ms/op | 2.417 ms/op | +0.278 ms |
|
|
740
|
+
| Read | 0.007 ms/op | 0.810 ms/op | +0.803 ms |
|
|
741
|
+
|
|
742
|
+
> For context: a typical database query or HTTP call takes 10–50ms. A difference of less than 1ms per operation is negligible for most apps.
|
|
743
|
+
|
|
744
|
+
#### **Why this overhead exists**
|
|
745
|
+
|
|
746
|
+
Mudis includes features that MemoryStore doesn’t:
|
|
747
|
+
|
|
748
|
+
| Feature | Mudis | Rails.cache (MemoryStore) |
|
|
749
|
+
| ------------------ | ---------------------- | --------------------------- |
|
|
750
|
+
| Per-key TTL expiry | ✅ | ⚠️ on access |
|
|
751
|
+
| True LRU eviction | ✅ | ❌ |
|
|
752
|
+
| Hard memory limits | ✅ | ❌ |
|
|
753
|
+
| Value compression | ✅ | ❌ |
|
|
754
|
+
| Thread safety | ✅ Bucket-level mutexes | ✅ Global mutex |
|
|
755
|
+
| Observability | ✅ | ❌ |
|
|
756
|
+
| Namespacing | ✅ | ❌ Manual scoping |
|
|
757
|
+
| IPC Aware | ✅ (if enabled) | ❌ Requires manual configuration and additional gems |
|
|
758
|
+
|
|
759
|
+
It will be down to the developer to decide if a fraction of a millisecond is worth
|
|
760
|
+
|
|
761
|
+
- Predictable eviction
|
|
762
|
+
- Configurable expiry
|
|
763
|
+
- Memory protection
|
|
764
|
+
- Namespace scoping
|
|
765
|
+
- Real-time metrics for hits, misses, evictions, memory usage
|
|
766
|
+
|
|
767
|
+
_10000 iterations of 1MB, Marshal (to match MemoryStore default), compression OFF (to match MemoryStore default)_
|
|
768
|
+
|
|
769
|
+
| Operation | `Rails.cache` | `Mudis` | Delta |
|
|
770
|
+
| --------- | ------------- | ----------- | ------------- |
|
|
771
|
+
| Write | 2.342 ms/op | 0.501 ms/op | **−1.841 ms** |
|
|
772
|
+
| Read | 0.007 ms/op | 0.011 ms/op | +0.004 ms |
|
|
773
|
+
|
|
774
|
+
With compression disabled, Mudis writes significanty faster and reads are virtually identical. Optimisation and configuration of Mudis will be determined by your individual needs.
|
|
775
|
+
|
|
776
|
+
#### Other Benchmarks
|
|
777
|
+
|
|
778
|
+
_10000 iterations of 512KB, JSON, compression OFF (to match MemoryStore default)_
|
|
779
|
+
|
|
780
|
+
| Operation | `Rails.cache` | `Mudis` | Delta |
|
|
781
|
+
| --------- | ------------- | ----------- | ------------- |
|
|
782
|
+
| Write | 1.291 ms/op | 0.32 ms/op | **−0.971 ms** |
|
|
783
|
+
| Read | 0.011 ms/op | 0.048 ms/op | +0.037 ms |
|
|
784
|
+
|
|
785
|
+
_10000 iterations of 512KB, JSON, compression ON_
|
|
786
|
+
|
|
787
|
+
| Operation | `Rails.cache` | `Mudis` | Delta |
|
|
788
|
+
| --------- | ------------- | ----------- | ------------- |
|
|
789
|
+
| Write | 1.11 ms/op | 1.16 ms/op | +0.05 ms |
|
|
790
|
+
| Read | 0.07 ms/op | 0.563 ms/op | +0.493 ms |
|
|
791
|
+
|
|
792
|
+
---
|
|
793
|
+
|
|
794
|
+
## Known Limitations
|
|
795
|
+
|
|
796
|
+
- Data is **non-persistent**; only soft-persistence is optionally provided.
|
|
797
|
+
- No SQL or equivallent query interface for cached data. Data is per Key retrieval only.
|
|
798
|
+
- Compression introduces CPU overhead.
|
|
799
|
+
|
|
800
|
+
---
|
|
801
|
+
|
|
802
|
+
## Create a Mudis Web Cache Server
|
|
803
|
+
|
|
804
|
+
### Minimal Setup
|
|
805
|
+
|
|
806
|
+
#### Example using Rails
|
|
807
|
+
|
|
808
|
+
- Create a new Rails API app:
|
|
809
|
+
|
|
810
|
+
```bash
|
|
811
|
+
rails new mudis-server --api
|
|
812
|
+
cd mudis-server
|
|
813
|
+
```
|
|
814
|
+
|
|
815
|
+
- Add mudis to your Gemfile
|
|
816
|
+
- Create Initializer: `config/initializers/mudis.rb`
|
|
817
|
+
- Define routes
|
|
818
|
+
|
|
819
|
+
```ruby
|
|
820
|
+
Rails.application.routes.draw do
|
|
821
|
+
get "/cache/:key", to: "cache#show"
|
|
822
|
+
post "/cache/:key", to: "cache#write"
|
|
823
|
+
delete "/cache/:key", to: "cache#delete"
|
|
824
|
+
get "/metrics", to: "cache#metrics"
|
|
825
|
+
end
|
|
826
|
+
```
|
|
827
|
+
|
|
828
|
+
- Create a `cache_controller` (with optional per caller/consumer namespace)
|
|
829
|
+
|
|
830
|
+
```ruby
|
|
831
|
+
class CacheController < ApplicationController
|
|
832
|
+
|
|
833
|
+
def show
|
|
834
|
+
key = params[:key]
|
|
835
|
+
ns = params[:namespace]
|
|
836
|
+
|
|
837
|
+
value = Mudis.read(key, namespace: ns)
|
|
838
|
+
if value.nil?
|
|
839
|
+
render json: { error: "not found" }, status: :not_found
|
|
840
|
+
else
|
|
841
|
+
render json: { value: value }
|
|
842
|
+
end
|
|
843
|
+
end
|
|
844
|
+
|
|
845
|
+
def write
|
|
846
|
+
key = params[:key]
|
|
847
|
+
ns = params[:namespace]
|
|
848
|
+
val = params[:value]
|
|
849
|
+
ttl = params[:expires_in]&.to_i
|
|
850
|
+
|
|
851
|
+
Mudis.write(key, val, expires_in: ttl, namespace: ns)
|
|
852
|
+
render json: { status: "written", key: key }
|
|
853
|
+
end
|
|
854
|
+
|
|
855
|
+
def delete
|
|
856
|
+
key = params[:key]
|
|
857
|
+
ns = params[:namespace]
|
|
858
|
+
|
|
859
|
+
Mudis.delete(key, namespace: ns)
|
|
860
|
+
render json: { status: "deleted" }
|
|
861
|
+
end
|
|
862
|
+
|
|
863
|
+
def metrics
|
|
864
|
+
render json: Mudis.metrics
|
|
865
|
+
end
|
|
866
|
+
end
|
|
867
|
+
```
|
|
868
|
+
|
|
869
|
+
- Test it
|
|
870
|
+
|
|
871
|
+
```bash
|
|
872
|
+
curl http://localhost:3000/cache/foo
|
|
873
|
+
curl -X POST http://localhost:3000/cache/foo -d 'value=bar&expires_in=60'
|
|
874
|
+
curl http://localhost:3000/metrics
|
|
875
|
+
|
|
876
|
+
# Write with namespace
|
|
877
|
+
curl -X POST "http://localhost:3000/cache/foo?namespace=orders" \
|
|
878
|
+
-d "value=123&expires_in=60"
|
|
879
|
+
|
|
880
|
+
# Read from namespace
|
|
881
|
+
curl "http://localhost:3000/cache/foo?namespace=orders"
|
|
882
|
+
|
|
883
|
+
# Delete from namespace
|
|
884
|
+
curl -X DELETE "http://localhost:3000/cache/foo?namespace=orders"
|
|
885
|
+
|
|
886
|
+
```
|
|
887
|
+
|
|
888
|
+
---
|
|
889
|
+
|
|
890
|
+
## Project Philosophy
|
|
891
|
+
|
|
892
|
+
Mudis is intended to be a minimal, thread-safe, in-memory cache designed specifically for Ruby applications. It focuses on:
|
|
893
|
+
|
|
894
|
+
- In-process caching
|
|
895
|
+
- Fine-grained memory and namespace control
|
|
896
|
+
- Observability and testing friendliness
|
|
897
|
+
- Minimal external dependencies
|
|
898
|
+
- Configurability without complexity
|
|
899
|
+
|
|
900
|
+
The primary use cases are:
|
|
901
|
+
|
|
902
|
+
- Per-service application caches
|
|
903
|
+
- Short-lived local caching inside background jobs or API layers
|
|
904
|
+
|
|
905
|
+
Mudis is not intended to be a general-purpose, distributed caching platform. You are, however, welcome to build on top of Mudis if you want its functionality in such projects. E.g.,
|
|
906
|
+
|
|
907
|
+
- mudis-web-cache-server – expose Mudis via HTTP, web sockets, hooks, etc
|
|
908
|
+
- mudis-broker – distributed key routing layer for coordinating multiple Mudis nodes
|
|
909
|
+
- mudis-activejob-store – adapter for using Mudis in job queues or retry buffers
|
|
910
|
+
|
|
911
|
+
---
|
|
912
|
+
|
|
913
|
+
## Roadmap
|
|
914
|
+
|
|
915
|
+
#### API Enhancements
|
|
916
|
+
|
|
917
|
+
- [x] bulk_read(keys, namespace:): Batch retrieval of multiple keys with a single method call
|
|
918
|
+
|
|
919
|
+
#### Safety & Policy Controls
|
|
920
|
+
|
|
921
|
+
- [x] max_ttl: Enforce a global upper bound on expires_in to prevent excessively long-lived keys
|
|
922
|
+
- [x] default_ttl: Provide a fallback TTL when one is not specified
|
|
923
|
+
|
|
924
|
+
#### Debugging
|
|
925
|
+
|
|
926
|
+
- [x] clear_namespace(namespace): Remove all keys in a namespace in one call
|
|
927
|
+
|
|
928
|
+
#### Refactor Mudis
|
|
929
|
+
|
|
930
|
+
- [x] Review Mudis for improved readability and reduce complexity in top-level functions
|
|
931
|
+
- [x] Enhanced guards
|
|
932
|
+
- [ ] Review for functionality gaps and enhance as needed
|
|
933
|
+
|
|
934
|
+
---
|
|
935
|
+
|
|
936
|
+
## License
|
|
937
|
+
|
|
938
|
+
MIT License © kiebor81
|
|
939
|
+
|
|
940
|
+
---
|
|
941
|
+
|
|
942
|
+
## Contributing
|
|
943
|
+
|
|
944
|
+
See [contributor's guide](CONTRIBUTING.md)
|
|
945
|
+
|
|
946
|
+
---
|
|
947
|
+
|
|
948
|
+
## Contact
|
|
949
|
+
|
|
950
|
+
For issues, suggestions, or feedback, please open a GitHub issue
|
|
951
|
+
|
|
952
|
+
---
|