mudis 0.9.0 → 0.9.4

data/lib/mudis.rb

@@ -10,6 +10,7 @@ require_relative "mudis/persistence"
 require_relative "mudis/metrics"
 require_relative "mudis/namespace"
 require_relative "mudis/expiry"
+require_relative "mudis/bound"
 
 # Mudis is a thread-safe, in-memory, sharded, LRU cache with optional compression and expiry.
 # It is designed for high concurrency and performance within a Ruby application.
@@ -26,6 +27,8 @@ class Mudis # rubocop:disable Metrics/ClassLength
   @compress = false                             # Whether to compress values with Zlib
   @metrics = { hits: 0, misses: 0, evictions: 0, rejected: 0 } # Metrics tracking read/write behaviour
   @metrics_mutex = Mutex.new                    # Mutex for synchronizing access to metrics
+  @metrics_by_namespace = {}                    # Per-namespace metrics
+  @metrics_by_namespace_mutex = Mutex.new       # Mutex for synchronizing namespace metrics
   @max_value_bytes = nil                        # Optional size cap per value
   @stop_expiry = false                          # Signal for stopping expiry thread
   @max_ttl = nil                                # Optional maximum TTL for cache entries
@@ -34,13 +37,20 @@ class Mudis # rubocop:disable Metrics/ClassLength
   # --- Configuration Management ---
 
   class << self
-    attr_accessor :serializer, :compress, :hard_memory_limit, :max_ttl, :default_ttl
+    attr_accessor :serializer, :compress, :hard_memory_limit, :max_ttl, :default_ttl, :eviction_threshold
     attr_reader :max_bytes, :max_value_bytes
 
     # Configures Mudis with a block, allowing customization of settings
     def configure
-      yield(config)
+      new_config = config.dup
+      yield(new_config)
+
+      old_config = @config
+      @config = new_config
       apply_config!
+    rescue StandardError
+      @config = old_config
+      raise
     end
 
     # Returns the current configuration object
@@ -48,6 +58,15 @@ class Mudis # rubocop:disable Metrics/ClassLength
       @config ||= MudisConfig.new
     end
 
+    def bind(namespace:, default_ttl: nil, max_ttl: nil, max_value_bytes: nil)
+      Bound.new(
+        namespace: namespace,
+        default_ttl: default_ttl,
+        max_ttl: max_ttl,
+        max_value_bytes: max_value_bytes
+      )
+    end
+
     # Applies the current configuration to Mudis
     def apply_config! # rubocop:disable Metrics/AbcSize,Metrics/MethodLength
       validate_config!
@@ -57,6 +76,7 @@ class Mudis # rubocop:disable Metrics/ClassLength
       self.max_value_bytes = config.max_value_bytes
       self.hard_memory_limit = config.hard_memory_limit
       self.max_bytes = config.max_bytes
+      self.eviction_threshold = config.eviction_threshold
       self.max_ttl = config.max_ttl
       self.default_ttl = config.default_ttl
 
@@ -85,6 +105,9 @@ class Mudis # rubocop:disable Metrics/ClassLength
       raise ArgumentError, "max_value_bytes must be > 0" if config.max_value_bytes && config.max_value_bytes <= 0
 
       raise ArgumentError, "buckets must be > 0" if config.buckets && config.buckets <= 0
+      if config.eviction_threshold && (config.eviction_threshold <= 0 || config.eviction_threshold > 1)
+        raise ArgumentError, "eviction_threshold must be > 0 and <= 1"
+      end
       raise ArgumentError, "max_ttl must be > 0" if config.max_ttl && config.max_ttl <= 0
       raise ArgumentError, "default_ttl must be > 0" if config.default_ttl && config.default_ttl <= 0
     end
@@ -102,6 +125,7 @@ class Mudis # rubocop:disable Metrics/ClassLength
       @lru_tails     = Array.new(b) { nil }
       @lru_nodes     = Array.new(b) { {} }
       @current_bytes = Array.new(b, 0)
+      @inflight_mutexes = {}
 
       reset_metrics!
     end
@@ -111,7 +135,16 @@ class Mudis # rubocop:disable Metrics/ClassLength
       raise ArgumentError, "max_bytes must be > 0" if value.to_i <= 0
 
       @max_bytes = value
-      @threshold_bytes = (@max_bytes * 0.9).to_i
+      threshold = @eviction_threshold || 0.9
+      @threshold_bytes = (@max_bytes * threshold).to_i
+    end
+
+    def eviction_threshold=(value)
+      return @eviction_threshold = nil if value.nil?
+      raise ArgumentError, "eviction_threshold must be > 0 and <= 1" if value <= 0 || value > 1
+
+      @eviction_threshold = value
+      @threshold_bytes = (@max_bytes * @eviction_threshold).to_i
     end
 
     # Sets the maximum size for a single value in bytes, raising an error if invalid
@@ -141,9 +174,12 @@ class Mudis # rubocop:disable Metrics/ClassLength
   @lru_nodes = Array.new(buckets) { {} }        # Map of key => LRU node
   @current_bytes = Array.new(buckets, 0)        # Memory usage per bucket
   @max_bytes = 1_073_741_824                    # 1 GB global max cache size
-  @threshold_bytes = (@max_bytes * 0.9).to_i # Eviction threshold at 90%
+  @eviction_threshold = 0.9
+  @threshold_bytes = (@max_bytes * @eviction_threshold).to_i # Eviction threshold at 90%
   @expiry_thread = nil # Background thread for expiry cleanup
   @hard_memory_limit = false # Whether to enforce hard memory cap
+  @inflight_mutexes_lock = Mutex.new
+  @inflight_mutexes = {}
 
   # --- Core Cache Operations ---
 
@@ -155,13 +191,13 @@ class Mudis # rubocop:disable Metrics/ClassLength
 
     # Checks if a key exists and is not expired
     def exists?(key, namespace: nil)
-      key = namespaced_key(key, namespace)
-      !!read(key)
+      !!read(key, namespace: namespace)
     end
 
     # Reads and returns the value for a key, updating LRU and metrics
     def read(key, namespace: nil) # rubocop:disable Metrics/MethodLength,Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity
       key = namespaced_key(key, namespace)
+      ns = namespace || Thread.current[:mudis_namespace]
       raw_entry = nil
       idx = bucket_index(key)
       mutex = @mutexes[idx]
@@ -174,29 +210,31 @@ class Mudis # rubocop:disable Metrics/ClassLength
           raw_entry = nil
         end
 
-        store[key][:touches] = (store[key][:touches] || 0) + 1 if store[key]
+        if store[key]
+          store[key][:touches] = (store[key][:touches] || 0) + 1
+          promote_lru(idx, key)
+        end
 
-        metric(:hits) if raw_entry
-        metric(:misses) unless raw_entry
+        metric(:hits, namespace: ns) if raw_entry
+        metric(:misses, namespace: ns) unless raw_entry
       end
 
       return nil unless raw_entry
 
-      value = decompress_and_deserialize(raw_entry[:value])
-      promote_lru(idx, key)
-      value
+      decompress_and_deserialize(raw_entry[:value])
     end
 
     # Writes a value to the cache with optional expiry and LRU tracking
     def write(key, value, expires_in: nil, namespace: nil) # rubocop:disable Metrics/MethodLength,Metrics/CyclomaticComplexity,Metrics/AbcSize,Metrics/PerceivedComplexity
       key = namespaced_key(key, namespace)
+      ns = namespace || Thread.current[:mudis_namespace]
       raw = serializer.dump(value)
       raw = Zlib::Deflate.deflate(raw) if compress
       size = key.bytesize + raw.bytesize
       return if max_value_bytes && raw.bytesize > max_value_bytes
 
       if hard_memory_limit && current_memory_bytes + size > max_memory_bytes
-        metric(:rejected)
+        metric(:rejected, namespace: ns)
         return
       end
 
@@ -211,15 +249,18 @@ class Mudis # rubocop:disable Metrics/ClassLength
         evict_key(idx, key) if store[key]
 
         while @current_bytes[idx] + size > (@threshold_bytes / buckets) && @lru_tails[idx]
-          evict_key(idx, @lru_tails[idx].key)
-          metric(:evictions)
+          evict_key_name = @lru_tails[idx].key
+          evict_ns = store[evict_key_name] && store[evict_key_name][:namespace]
+          evict_key(idx, evict_key_name)
+          metric(:evictions, namespace: evict_ns)
         end
 
         store[key] = {
           value: raw,
           expires_at: expires_in ? Time.now + expires_in : nil,
           created_at: Time.now,
-          touches: 0
+          touches: 0,
+          namespace: ns
         }
 
         insert_lru(idx, key)
@@ -244,11 +285,38 @@ class Mudis # rubocop:disable Metrics/ClassLength
       new_value = yield(value)
       new_raw = serializer.dump(new_value)
       new_raw = Zlib::Deflate.deflate(new_raw) if compress
+      return if max_value_bytes && new_raw.bytesize > max_value_bytes
 
       mutex.synchronize do
-        old_size = key.bytesize + raw_entry[:value].bytesize
+        current_entry = store[key]
+        return nil unless current_entry
+
+        old_size = key.bytesize + current_entry[:value].bytesize
         new_size = key.bytesize + new_raw.bytesize
+
+        ns = current_entry[:namespace]
+
+        if hard_memory_limit && (current_memory_bytes - old_size + new_size) > max_memory_bytes
+          metric(:rejected, namespace: ns)
+          return
+        end
+
+        while (@current_bytes[idx] - old_size + new_size) > (@threshold_bytes / buckets) && @lru_tails[idx]
+          break if @lru_tails[idx].key == key
+
+          evict_key_name = @lru_tails[idx].key
+          evict_ns = store[evict_key_name] && store[evict_key_name][:namespace]
+          evict_key(idx, evict_key_name)
+          metric(:evictions, namespace: evict_ns)
+        end
+
         store[key][:value] = new_raw
+
+        # Refresh TTL on update. If no TTL applies, keep existing expiry (possibly nil).
+        now = Time.now
+        ttl = current_entry[:expires_at] ? (current_entry[:expires_at] - current_entry[:created_at]) : nil
+        store[key][:created_at] = now
+        store[key][:expires_at] = ttl ? now + ttl : nil
         @current_bytes[idx] += (new_size - old_size)
         promote_lru(idx, key)
       end
@@ -269,16 +337,13 @@ class Mudis # rubocop:disable Metrics/ClassLength
     # The block is executed to generate the value if it doesn't exist
     # Optionally accepts an expiration time
     # If force is true, it always fetches and writes the value
-    def fetch(key, expires_in: nil, force: false, namespace: nil)
-      key = namespaced_key(key, namespace)
-      unless force
-        cached = read(key)
-        return cached if cached
-      end
+    def fetch(key, expires_in: nil, force: false, namespace: nil, singleflight: false) # rubocop:disable Metrics/MethodLength
+      return fetch_without_lock(key, expires_in:, force:, namespace:) { yield } unless singleflight
 
-      value = yield
-      write(key, value, expires_in: expires_in)
-      value
+      lock_key = namespaced_key(key, namespace)
+      with_inflight_lock(lock_key) do
+        fetch_without_lock(key, expires_in:, force:, namespace:) { yield }
+      end
     end
 
     # Clears a specific key from the cache, a semantic synonym for delete
@@ -366,5 +431,33 @@ class Mudis # rubocop:disable Metrics/ClassLength
       val = compress ? Zlib::Inflate.inflate(raw) : raw
       serializer.load(val)
     end
+
+    def fetch_without_lock(key, expires_in:, force:, namespace:)
+      unless force
+        cached = read(key, namespace: namespace)
+        return cached if cached
+      end
+
+      value = yield
+      write(key, value, expires_in: expires_in, namespace: namespace)
+      value
+    end
+
+    def with_inflight_lock(lock_key)
+      entry = nil
+      @inflight_mutexes_lock.synchronize do
+        entry = (@inflight_mutexes[lock_key] ||= { mutex: Mutex.new, count: 0 })
+        entry[:count] += 1
+      end
+
+      entry[:mutex].synchronize { yield }
+    ensure
+      @inflight_mutexes_lock.synchronize do
+        next unless entry
+
+        entry[:count] -= 1
+        @inflight_mutexes.delete(lock_key) if entry[:count] <= 0
+      end
+    end
   end
 end

data/lib/mudis_client.rb

@@ -2,6 +2,7 @@
 
 require "socket"
 require "json"
+require "timeout"
 require_relative "mudis_ipc_config"
 
 # Thread-safe client for communicating with the MudisServer
@@ -25,28 +26,41 @@ class MudisClient
   # Send a request to the MudisServer and return the response
   # @param payload [Hash] The request payload
   # @return [Object] The response value from the server
-  def request(payload) # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
+  def request(payload) # rubocop:disable Metrics/MethodLength
     @mutex.synchronize do
-      sock = open_connection
-      sock.puts(JSON.dump(payload))
-      response = sock.gets
-      sock.close
-
-      return nil unless response
-
-      res = JSON.parse(response, symbolize_names: true)
-      raise res[:error] unless res[:ok]
-
-      res[:value]
-    rescue Errno::ENOENT, Errno::ECONNREFUSED
-      warn "[MudisClient] Cannot connect to MudisServer. Is it running?"
-      nil
-    rescue JSON::ParserError
-      warn "[MudisClient] Invalid JSON response from server"
-      nil
-    rescue IOError, SystemCallError => e
-      warn "[MudisClient] Connection error: #{e.message}"
-      nil
+      attempts = 0
+
+      begin
+        attempts += 1
+        response = nil
+
+        Timeout.timeout(MudisIPCConfig.timeout) do
+          sock = open_connection
+          sock.puts(JSON.dump(payload))
+          response = sock.gets
+          sock.close
+        end
+
+        return nil unless response
+
+        res = JSON.parse(response, symbolize_names: true)
+        raise res[:error] unless res[:ok]
+
+        res[:value]
+      rescue Errno::ENOENT, Errno::ECONNREFUSED, Timeout::Error
+        if attempts <= MudisIPCConfig.retries
+          retry
+        end
+
+        warn "[MudisClient] Cannot connect to MudisServer. Is it running?"
+        nil
+      rescue JSON::ParserError
+        warn "[MudisClient] Invalid JSON response from server"
+        nil
+      rescue IOError, SystemCallError => e
+        warn "[MudisClient] Connection error: #{e.message}"
+        nil
+      end
     end
   end
 
@@ -82,19 +96,44 @@ class MudisClient
     new_val
   end
 
-  # Retrieve metrics from the Mudis server
-  def metrics
-    command("metrics")
+  # Inspect metadata for a key
+  def inspect(key, namespace: nil)
+    command("inspect", key:, namespace:)
+  end
+
+  # Return keys for a namespace
+  def keys(namespace:)
+    command("keys", namespace:)
+  end
+
+  # Clear keys in a namespace
+  def clear_namespace(namespace:)
+    command("clear_namespace", namespace:)
+  end
+
+  # Return least touched keys
+  def least_touched(limit = 10)
+    command("least_touched", limit:)
   end
 
-  # Reset metrics on the Mudis server
-  def reset_metrics!
-    command("reset_metrics")
+  # Return all keys
+  def all_keys
+    command("all_keys")
   end
 
-  # Reset the Mudis server cache state
-  def reset!
-    command("reset")
+  # Return current memory usage
+  def current_memory_bytes
+    command("current_memory_bytes")
+  end
+
+  # Return max memory configured
+  def max_memory_bytes
+    command("max_memory_bytes")
+  end
+
+  # Retrieve metrics from the Mudis server
+  def metrics
+    command("metrics")
   end
 
   private
@@ -103,5 +142,4 @@ class MudisClient
   def command(cmd, **opts)
     request({ cmd:, **opts })
   end
-
 end

data/lib/mudis_config.rb

@@ -8,6 +8,7 @@ class MudisConfig
                 :max_value_bytes,
                 :hard_memory_limit,
                 :max_bytes,
+                :eviction_threshold,
                 :buckets,
                 :max_ttl,
                 :default_ttl,
@@ -23,6 +24,7 @@ class MudisConfig
     @max_value_bytes = nil                    # Max size per value (optional)
     @hard_memory_limit = false                # Enforce max_bytes as hard cap
     @max_bytes = 1_073_741_824                # 1 GB default max cache size
+    @eviction_threshold = 0.9                # Evict when bucket exceeds threshold
     @buckets = nil                            # use nil to signal fallback to ENV or default
     @max_ttl = nil                            # Max TTL for cache entries (optional)
     @default_ttl = nil                        # Default TTL for cache entries (optional)

data/lib/mudis_ipc_config.rb

@@ -5,9 +5,19 @@ module MudisIPCConfig
   SOCKET_PATH = "/tmp/mudis.sock"
   TCP_HOST = "127.0.0.1"
   TCP_PORT = 9876
+  DEFAULT_TIMEOUT = 1
+  DEFAULT_RETRIES = 1
 
   # Check if TCP mode should be used (Windows or forced via ENV)
   def self.use_tcp?
     ENV["MUDIS_FORCE_TCP"] == "true" || Gem.win_platform?
   end
+
+  def self.timeout
+    (ENV["MUDIS_IPC_TIMEOUT"] || DEFAULT_TIMEOUT).to_f
+  end
+
+  def self.retries
+    (ENV["MUDIS_IPC_RETRIES"] || DEFAULT_RETRIES).to_i
+  end
 end

data/lib/mudis_server.rb

@@ -13,14 +13,19 @@ class MudisServer
   # Define command handlers mapping
   # Each command maps to a lambda that takes a request hash and performs the corresponding Mudis operation.
   COMMANDS = {
-    "read"          => ->(r) { Mudis.read(r[:key], namespace: r[:namespace]) },
-    "write"         => ->(r) { Mudis.write(r[:key], r[:value], expires_in: r[:ttl], namespace: r[:namespace]) },
-    "delete"        => ->(r) { Mudis.delete(r[:key], namespace: r[:namespace]) },
-    "exists"        => ->(r) { Mudis.exists?(r[:key], namespace: r[:namespace]) },
-    "fetch"         => ->(r) { Mudis.fetch(r[:key], expires_in: r[:ttl], namespace: r[:namespace]) { r[:fallback] } },
-    "metrics"       => ->(_) { Mudis.metrics },
-    "reset_metrics" => ->(_) { Mudis.reset_metrics! },
-    "reset"         => ->(_) { Mudis.reset! }
+    "read" => ->(r) { Mudis.read(r[:key], namespace: r[:namespace]) },
+    "write" => ->(r) { Mudis.write(r[:key], r[:value], expires_in: r[:ttl], namespace: r[:namespace]) },
+    "delete" => ->(r) { Mudis.delete(r[:key], namespace: r[:namespace]) },
+    "exists" => ->(r) { Mudis.exists?(r[:key], namespace: r[:namespace]) },
+    "fetch" => ->(r) { Mudis.fetch(r[:key], expires_in: r[:ttl], namespace: r[:namespace]) { r[:fallback] } },
+    "inspect" => ->(r) { Mudis.inspect(r[:key], namespace: r[:namespace]) },
+    "keys" => ->(r) { Mudis.keys(namespace: r[:namespace]) },
+    "clear_namespace" => ->(r) { Mudis.clear_namespace(namespace: r[:namespace]) },
+    "least_touched" => ->(r) { Mudis.least_touched(r[:limit]) },
+    "all_keys" => ->(_) { Mudis.all_keys },
+    "current_memory_bytes" => ->(_) { Mudis.current_memory_bytes },
+    "max_memory_bytes" => ->(_) { Mudis.max_memory_bytes },
+    "metrics" => ->(_) { Mudis.metrics }
   }.freeze
 
   # Start the MudisServer
@@ -43,7 +48,7 @@ class MudisServer
   end
 
   # Start UNIX socket server (production mode for Linux/macOS)
-  def self.start_unix_server! # rubocop:disable Metrics/MethodLength
+  def self.start_unix_server!
     File.unlink(SOCKET_PATH) if File.exist?(SOCKET_PATH)
     server = UNIXServer.new(SOCKET_PATH)
     server.listen(128)

data/sig/mudis.rbs

@@ -14,6 +14,7 @@ class Mudis
     attr_reader max_value_bytes : Integer?
     attr_accessor max_ttl: Integer?
     attr_accessor default_ttl: Integer?
+    attr_accessor eviction_threshold: Float?
     
     def configure: () { (config: MudisConfig) -> void } -> void
     def config: () -> MudisConfig
@@ -21,6 +22,13 @@ class Mudis
     def validate_config!: () -> void
 
     def buckets: () -> Integer
+
+    def bind: (
+      namespace: String,
+      ?default_ttl: Integer?,
+      ?max_ttl: Integer?,
+      ?max_value_bytes: Integer?
+    ) -> Mudis::Bound
   end
 
   # Lifecycle
@@ -39,17 +47,19 @@ class Mudis
     String,
     ?expires_in: Integer,
     ?force: bool,
-    ?namespace: String
+    ?namespace: String,
+    ?singleflight: bool
   ) { () -> untyped } -> untyped
 
   def self.clear: (String, ?namespace: String) -> void
   def self.replace: (String, untyped, ?expires_in: Integer, ?namespace: String) -> void
   def self.inspect: (String, ?namespace: String) -> Hash[Symbol, untyped]?
-  def self.keys: (?namespace: String) -> Array[String]
-  def self.clear_namespace: (?namespace: String) -> void
+  def self.keys: (namespace: String) -> Array[String]
+  def self.clear_namespace: (namespace: String) -> void
+  def self.with_namespace: (namespace: String) { () -> untyped } -> untyped
 
   # Introspection & management
-  def self.metrics: () -> Hash[Symbol, untyped]
+  def self.metrics: (?namespace: String) -> Hash[Symbol, untyped]
   def self.cleanup_expired!: () -> void
   def self.all_keys: () -> Array[String]
   def self.current_memory_bytes: () -> Integer
@@ -59,4 +69,9 @@ class Mudis
   # State reset
   def self.reset!: () -> void
   def self.reset_metrics!: () -> void
+
+  # Persistence
+  def self.save_snapshot!: () -> void
+  def self.load_snapshot!: () -> void
+  def self.install_persistence_hook!: () -> void
 end

data/sig/mudis_bound.rbs

@@ -0,0 +1,25 @@
+class Mudis
+  class Bound
+    attr_reader namespace: String
+
+    def initialize: (
+      namespace: String,
+      ?default_ttl: Integer?,
+      ?max_ttl: Integer?,
+      ?max_value_bytes: Integer?
+    ) -> void
+
+    def read: (String) -> untyped?
+    def write: (String, untyped, ?expires_in: Integer?) -> void
+    def update: (String) { (untyped) -> untyped } -> void
+    def delete: (String) -> void
+    def exists?: (String) -> bool
+    def fetch: (String, ?expires_in: Integer?, ?force: bool, ?singleflight: bool) { () -> untyped } -> untyped?
+    def clear: (String) -> void
+    def replace: (String, untyped, ?expires_in: Integer?) -> void
+    def inspect: (String) -> Hash[Symbol, untyped]?
+    def keys: () -> Array[String]
+    def metrics: () -> Hash[Symbol, untyped]
+    def clear_namespace: () -> void
+  end
+end

data/sig/mudis_client.rbs

@@ -5,7 +5,7 @@ class MudisClient
 
   def open_connection: () -> (TCPSocket | UNIXSocket)
 
-  def request: (payload: { cmd: String, key?: String, value?: untyped, ttl?: Integer?, namespace?: String? }) -> untyped
+  def request: (payload: Hash[Symbol, untyped]) -> untyped
 
   def read: (key: String, namespace?: String?) -> untyped
 
@@ -17,9 +17,19 @@ class MudisClient
 
   def fetch: (key: String, expires_in?: Integer?, namespace?: String?, &block: { () -> untyped }) -> untyped
 
-  def metrics: () -> { reads: Integer, writes: Integer, deletes: Integer, exists: Integer }
+  def inspect: (key: String, namespace?: String?) -> Hash[Symbol, untyped]?
 
-  def reset_metrics!: () -> void
+  def keys: (namespace: String) -> Array[String]
 
-  def reset!: () -> void
-end
+  def clear_namespace: (namespace: String) -> void
+
+  def least_touched: (?Integer) -> Array[[String, Integer]]
+
+  def all_keys: () -> Array[String]
+
+  def current_memory_bytes: () -> Integer
+
+  def max_memory_bytes: () -> Integer
+
+  def metrics: () -> Hash[Symbol, untyped]
+end

data/sig/mudis_config.rbs

@@ -4,7 +4,12 @@ class MudisConfig
   attr_accessor max_value_bytes: Integer?
   attr_accessor hard_memory_limit: bool
   attr_accessor max_bytes: Integer
+  attr_accessor eviction_threshold: Float?
   attr_accessor max_ttl: Integer?
   attr_accessor default_ttl: Integer?
   attr_accessor buckets: Integer?
+  attr_accessor persistence_enabled: bool
+  attr_accessor persistence_path: String
+  attr_accessor persistence_format: Symbol
+  attr_accessor persistence_safe_write: bool
 end

data/sig/mudis_expiry.rbs

@@ -8,6 +8,6 @@ class Mudis
 
     private
 
-    def effective_ttl: (?expires_in: Integer?) -> Integer?
+    def effective_ttl: (Integer?) -> Integer?
   end
 end

data/sig/mudis_ipc_config.rbs

@@ -6,5 +6,13 @@ module MudisIPCConfig
 
   TCP_PORT: Integer
 
+  DEFAULT_TIMEOUT: Integer
+
+  DEFAULT_RETRIES: Integer
+
   def self.use_tcp?: () -> bool
+
+  def self.timeout: () -> Float
+
+  def self.retries: () -> Integer
 end

data/sig/mudis_lru.rbs

@@ -12,7 +12,7 @@ class Mudis
 
     def evict_key: (Integer, String) -> void
 
-    def insert_lru: (Integer, LRUNode) -> void
+    def insert_lru: (Integer, String) -> void
 
     def promote_lru: (Integer, String) -> void
 

data/sig/mudis_metrics.rbs

@@ -1,6 +1,6 @@
 class Mudis
   module Metrics
-    def metrics: () -> Hash[Symbol, untyped]
+    def metrics: (?namespace: String) -> Hash[Symbol, untyped]
 
     def reset_metrics!: () -> void
 

data/sig/mudis_persistence.rbs

@@ -8,12 +8,12 @@ class Mudis
 
     private
 
-    def snapshot_dump: () -> Hash[String, untyped]
+    def snapshot_dump: () -> Array[{ key: String, value: untyped, expires_in: Integer? }]
 
-    def snapshot_restore: (Hash[String, untyped]) -> void
+    def snapshot_restore: (Array[{ key: String, value: untyped, expires_in: Integer? }]) -> void
 
-    def safe_write_snapshot: (Hash[String, untyped]) -> void
+    def safe_write_snapshot: (Array[{ key: String, value: untyped, expires_in: Integer? }]) -> void
 
-    def read_snapshot: () -> Hash[String, untyped]
+    def read_snapshot: () -> Array[{ key: String, value: untyped, expires_in: Integer? }]
   end
 end