slatedb 0.2.0 → 0.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0026c9e2a5afd6e0d7fa35c10b037791910a2438cf0bcec73c9935db557c9a85
-  data.tar.gz: 140bdf13e24d576e87165a63f31e3a0130244f36ea1278da7da5e6703347f7c5
+  metadata.gz: 9e7afb38b40ead3216b671173af52bf1a30215979f8e850dbb1e4f7dabf823f3
+  data.tar.gz: '03923c7ffdd47ba2ea9d846e98af2f66ce8fc1287e3ed3e99d21e5c27db05a8b'
 SHA512:
-  metadata.gz: ae8fe00e7069801bfdf8cf90ea48bfee6a60ed1413cdbc8bef5b9a083744436a0b3d3c1e46ef51c5cbd5de85bd46c6c332ec4b016ffd6482a729fa0b3a50e531
-  data.tar.gz: 5e60f6509c2eae4c948751d941f6cd7389dae8e43e241d02d559c47251b26383c6a59fcedb50133d54759d9d791a9f07079f6eed37106a386358094f2f3a5b7e
+  metadata.gz: d693ec11b74c8eea9722a270f48ccf8d209f21138a24dac54fbfa5d8242e23233982ea1f94aa31a667d4c0902c524213d20a9872fb6fb538685446d0efbb4fd1
+  data.tar.gz: 2e1b75894800650de82f8671bd07eefc678b6cfaaf6259245fbf854f8faaa0b8651f5c0ba1f07f4be5a8b0d85b2b54ca19177d2801a1f0f91400dde42202477a

data/README.md

@@ -138,6 +138,34 @@ db.put("key", "value", ttl: 60_000)  # expires in 60 seconds
 
 # Don't wait for durability
 db.put("key", "value", await_durable: false)
+
+# Supply an explicit sequence number (SlateDB >= 0.13.0)
+db.put("key", "value", seqnum: 42)
+```
+
+#### User-Supplied Sequence Numbers
+
+By default SlateDB assigns a monotonically increasing sequence number to every
+write. Since SlateDB 0.13.0 you can instead supply your own via `seqnum:`. The
+value must be **strictly greater** than the current maximum sequence number, or
+the write is rejected with `SlateDb::InvalidArgumentError`. This is useful when
+replaying an external log or coordinating sequence numbers across systems.
+
+```ruby
+db.put("key", "value", seqnum: 1_000)
+db.delete("old", seqnum: 1_001)
+db.merge("counter", "5", seqnum: 1_002)        # requires a merge operator
+db.write(batch, seqnum: 1_003)                 # applied across the batch
+db.batch(seqnum: 1_004) { |b| b.put("k", "v") }
+
+# The sequence number is reflected in the stored record
+db.put("key", "value", seqnum: 2_000)
+db.get_key_value("key")[:seq]  # => 2000
+
+# On a transaction it is supplied at commit time
+txn = db.begin_transaction
+txn.put("k", "v")
+txn.commit(seqnum: 3_000)
 ```
 
 #### Get Options
@@ -151,11 +179,37 @@ db.get("key", durability_filter: "remote")
 db.get("key", dirty: true)
 ```
 
+#### Key-Value Metadata
+
+SlateDB can return the full key-value record, including storage metadata:
+
+```ruby
+db.put("key", "value")
+entry = db.get_key_value("key")
+# => { key: "key", value: "value", seq: 1, create_ts: 1_765_000_000_000, expire_ts: nil }
+
+entry[:value]     # => "value"
+entry[:seq]       # SlateDB sequence number
+entry[:create_ts] # creation timestamp in milliseconds
+entry[:expire_ts] # expiration timestamp in milliseconds, or nil
+
+# Alias for the same API
+db.get_entry("key")
+
+# The same read options accepted by #get are supported
+db.get_key_value("key", durability_filter: "memory", cache_blocks: false)
+```
+
+Missing keys return `nil`, matching `#get`.
+
 #### Delete Options
 
 ```ruby
 # Don't wait for durability
 db.delete("key", await_durable: false)
+
+# Supply an explicit sequence number (SlateDB >= 0.13.0)
+db.delete("key", seqnum: 42)
 ```
 
 ### Scanning
@@ -173,6 +227,11 @@ db.scan("a", "z").each do |key, value|
   puts "#{key}: #{value}"
 end
 
+# Scan in descending key order
+db.scan("a", "z", order: :desc).each do |key, value|
+  puts "#{key}: #{value}"
+end
+
 # Use Enumerable methods
 keys = db.scan("user:").map { |k, v| k }
 users = db.scan("user:").select { |k, v| v.include?("active") }
@@ -196,6 +255,11 @@ db.scan_prefix("order:") do |key, value|
   puts "#{key}: #{value}"
 end
 
+# Prefix scans can also run in descending key order
+db.scan_prefix("user:", order: :desc).each do |key, value|
+  puts "#{key}: #{value}"
+end
+
 # Works with transactions, snapshots, and readers too
 db.transaction do |txn|
   txn.scan_prefix("item:").each do |k, v|
@@ -429,6 +493,16 @@ SlateDb::Reader.open("/tmp/mydb",
                      checkpoint_id: "uuid-here") do |reader|
   reader.get("key")
 end
+
+# Enable the reader's on-disk cache and cap its open file handles
+# (max_open_file_handles, added in SlateDB 0.13.0, only takes effect when
+# cache_root is set, since that is what enables the cached object store).
+SlateDb::Reader.open("/tmp/mydb",
+                     url: "s3://bucket/path",
+                     cache_root: "/var/cache/slatedb",
+                     max_open_file_handles: 256) do |reader|
+  reader.get("key")
+end
 ```
 
 ### Admin Operations
@@ -527,7 +601,7 @@ Exception hierarchy:
 
 ## Requirements
 
-- Ruby 3.1+
+- Ruby 3.3+
 - Rust toolchain (for building from source)
 
 ## Development

data/ext/slatedb/Cargo.toml

@@ -11,12 +11,13 @@ name = "slatedb"
 crate-type = ["cdylib"]
 
 [dependencies]
-slatedb = "0.10"
+slatedb = "0.13.1"
 magnus = { version = "0.8.2", features = ["rb-sys"] }
-rb-sys = { version = "0.9.123", features = ["stable-api-compiled-fallback"] }
-tokio = { version = "1.47.2", features = ["rt-multi-thread", "sync"] }
-bytes = "1.11.0"
-url = "2.5.7"
-once_cell = "1.21.3"
+rb-sys = { version = "0.9.128", features = ["stable-api-compiled-fallback"] }
+tokio = { version = "1.52.3", features = ["rt-multi-thread", "sync"] }
+bytes = "1.11.1"
+serde_json = "1.0.145"
+url = "2.5.8"
+once_cell = "1.21.4"
 log = "0.4.29"
-uuid = "1.19.0"
+uuid = "1.23.1"

data/ext/slatedb/src/admin.rs

@@ -43,10 +43,18 @@ impl Admin {
     /// # Returns
     /// JSON string of the manifest, or None if no manifests exist.
     pub fn read_manifest(&self, id: Option<u64>) -> Result<Option<String>, Error> {
-        block_on(async { self.inner.read_manifest(id).await }).map_err(|e| {
+        let manifest = block_on(async { self.inner.read_manifest(id).await }).map_err(|e| {
             let ruby = Ruby::get().expect("Ruby runtime not available");
             Error::new(ruby.exception_runtime_error(), format!("{}", e))
-        })
+        })?;
+
+        match manifest {
+            Some(manifest) => Ok(Some(serde_json::to_string(&manifest).map_err(|e| {
+                let ruby = Ruby::get().expect("Ruby runtime not available");
+                Error::new(ruby.exception_runtime_error(), format!("{}", e))
+            })?)),
+            None => Ok(None),
+        }
     }
 
     /// List manifests within an optional [start, end) range as JSON.
@@ -65,7 +73,12 @@ impl Admin {
             (None, None) => 0..u64::MAX,
         };
 
-        block_on(async { self.inner.list_manifests(range).await }).map_err(|e| {
+        let manifests = block_on(async { self.inner.list_manifests(range).await }).map_err(|e| {
+            let ruby = Ruby::get().expect("Ruby runtime not available");
+            Error::new(ruby.exception_runtime_error(), format!("{}", e))
+        })?;
+
+        serde_json::to_string(&manifests).map_err(|e| {
             let ruby = Ruby::get().expect("Ruby runtime not available");
             Error::new(ruby.exception_runtime_error(), format!("{}", e))
         })
@@ -236,6 +249,7 @@ impl Admin {
                     default_opts.compacted_options,
                 ),
                 compactions_options: default_opts.compactions_options,
+                detach_options: default_opts.detach_options,
             }
         };
 

data/ext/slatedb/src/database.rs

@@ -1,4 +1,5 @@
-use std::sync::Arc;
+use std::collections::HashMap;
+use std::sync::{Arc, Mutex};
 
 use magnus::prelude::*;
 use magnus::{function, method, Error, RHash, Ruby};
@@ -6,11 +7,12 @@ use slatedb::config::{
     DurabilityLevel, MergeOptions, PutOptions, ReadOptions, ScanOptions, Ttl, WriteOptions,
 };
 use slatedb::object_store::memory::InMemory;
-use slatedb::{Db, IsolationLevel};
+use slatedb::{Db, IsolationLevel, IterationOrder, KeyValue};
 
 use crate::errors::invalid_argument_error;
 use crate::iterator::Iterator;
 use crate::merge_ops::{parse_merge_operator, parse_merge_operator_proc};
+use crate::metrics::Metrics;
 use crate::runtime::block_on_result;
 use crate::snapshot::Snapshot;
 use crate::transaction::Transaction;
@@ -23,9 +25,69 @@ use crate::write_batch::WriteBatch;
 #[magnus::wrap(class = "SlateDb::Database", free_immediately, size)]
 pub struct Database {
     inner: Arc<Db>,
+    metrics: Arc<Mutex<HashMap<String, i64>>>,
 }
 
 impl Database {
+    fn increment_metric(&self, name: &str) {
+        let mut metrics = self.metrics.lock().expect("metrics mutex poisoned");
+        *metrics.entry(name.to_string()).or_insert(0) += 1;
+    }
+
+    fn key_value_to_hash(kv: KeyValue) -> Result<RHash, Error> {
+        let ruby = Ruby::get().expect("Ruby runtime not available");
+        let hash = ruby.hash_new();
+        hash.aset(
+            ruby.to_symbol("key"),
+            String::from_utf8_lossy(&kv.key).to_string(),
+        )?;
+        hash.aset(
+            ruby.to_symbol("value"),
+            String::from_utf8_lossy(&kv.value).to_string(),
+        )?;
+        hash.aset(ruby.to_symbol("seq"), kv.seq)?;
+        hash.aset(ruby.to_symbol("create_ts"), kv.create_ts)?;
+        hash.aset(ruby.to_symbol("expire_ts"), kv.expire_ts)?;
+        Ok(hash)
+    }
+
+    fn read_options_from_kwargs(kwargs: &RHash) -> Result<ReadOptions, Error> {
+        let mut opts = ReadOptions::default();
+
+        if let Some(df) = get_optional::<String>(kwargs, "durability_filter")? {
+            opts.durability_filter = match df.as_str() {
+                "remote" => DurabilityLevel::Remote,
+                "memory" => DurabilityLevel::Memory,
+                other => {
+                    return Err(invalid_argument_error(&format!(
+                        "invalid durability_filter: {} (expected 'remote' or 'memory')",
+                        other
+                    )))
+                }
+            };
+        }
+
+        if let Some(dirty) = get_optional::<bool>(kwargs, "dirty")? {
+            opts.dirty = dirty;
+        }
+
+        if let Some(cb) = get_optional::<bool>(kwargs, "cache_blocks")? {
+            opts.cache_blocks = cb;
+        }
+
+        Ok(opts)
+    }
+
+    fn write_options_from_kwargs(kwargs: &RHash) -> Result<WriteOptions, Error> {
+        let await_durable = get_optional::<bool>(kwargs, "await_durable")?.unwrap_or(true);
+        let seqnum = get_optional::<u64>(kwargs, "seqnum")?.unwrap_or(0);
+
+        Ok(WriteOptions {
+            await_durable,
+            seqnum,
+        })
+    }
+
     /// Open a database at the given path.
     ///
     /// # Arguments
@@ -37,8 +99,7 @@ impl Database {
     /// A new Database instance
     pub fn open(path: String, url: Option<String>, kwargs: RHash) -> Result<Self, Error> {
         // Try string-based merge operator first, then proc-based
-        let merge_operator = parse_merge_operator(&kwargs)?
-            .or(parse_merge_operator_proc(&kwargs)?);
+        let merge_operator = parse_merge_operator(&kwargs)?.or(parse_merge_operator_proc(&kwargs)?);
 
         let db = block_on_result(async {
             let object_store: Arc<dyn slatedb::object_store::ObjectStore> =
@@ -58,6 +119,7 @@ impl Database {
 
         Ok(Self {
             inner: Arc::new(db),
+            metrics: Arc::new(Mutex::new(HashMap::new())),
         })
     }
 
@@ -77,6 +139,7 @@ impl Database {
 
         let result =
             block_on_result(async { self.inner.get_with_options(key.as_bytes(), &opts).await })?;
+        self.increment_metric("db.get.count");
 
         Ok(result.map(|b| String::from_utf8_lossy(&b).to_string()))
     }
@@ -94,31 +157,64 @@ impl Database {
             return Err(invalid_argument_error("key cannot be empty"));
         }
 
-        let mut opts = ReadOptions::default();
+        let opts = Self::read_options_from_kwargs(&kwargs)?;
 
-        // Parse durability_filter
-        if let Some(df) = get_optional::<String>(&kwargs, "durability_filter")? {
-            opts.durability_filter = match df.as_str() {
-                "remote" => DurabilityLevel::Remote,
-                "memory" => DurabilityLevel::Memory,
-                other => {
-                    return Err(invalid_argument_error(&format!(
-                        "invalid durability_filter: {} (expected 'remote' or 'memory')",
-                        other
-                    )))
-                }
-            };
+        let result =
+            block_on_result(async { self.inner.get_with_options(key.as_bytes(), &opts).await })?;
+        self.increment_metric("db.get_with_options.count");
+
+        Ok(result.map(|b| String::from_utf8_lossy(&b).to_string()))
+    }
+
+    /// Get a key-value pair with metadata by key.
+    ///
+    /// # Arguments
+    /// * `key` - The key to look up
+    ///
+    /// # Returns
+    /// A Hash with key, value, seq, create_ts, and expire_ts, or nil if not found
+    pub fn get_key_value(&self, key: String) -> Result<Option<RHash>, Error> {
+        if key.is_empty() {
+            return Err(invalid_argument_error("key cannot be empty"));
         }
 
-        // Parse dirty
-        if let Some(dirty) = get_optional::<bool>(&kwargs, "dirty")? {
-            opts.dirty = dirty;
+        let opts = ReadOptions::default();
+        let result = block_on_result(async {
+            self.inner
+                .get_key_value_with_options(key.as_bytes(), &opts)
+                .await
+        })?;
+        self.increment_metric("db.get_key_value.count");
+
+        result.map(Self::key_value_to_hash).transpose()
+    }
+
+    /// Get a key-value pair with metadata by key with options.
+    ///
+    /// # Arguments
+    /// * `key` - The key to look up
+    /// * `kwargs` - Keyword arguments (durability_filter, dirty, cache_blocks)
+    ///
+    /// # Returns
+    /// A Hash with key, value, seq, create_ts, and expire_ts, or nil if not found
+    pub fn get_key_value_with_options(
+        &self,
+        key: String,
+        kwargs: RHash,
+    ) -> Result<Option<RHash>, Error> {
+        if key.is_empty() {
+            return Err(invalid_argument_error("key cannot be empty"));
         }
 
-        let result =
-            block_on_result(async { self.inner.get_with_options(key.as_bytes(), &opts).await })?;
+        let opts = Self::read_options_from_kwargs(&kwargs)?;
+        let result = block_on_result(async {
+            self.inner
+                .get_key_value_with_options(key.as_bytes(), &opts)
+                .await
+        })?;
+        self.increment_metric("db.get_key_value_with_options.count");
 
-        Ok(result.map(|b| String::from_utf8_lossy(&b).to_string()))
+        result.map(Self::key_value_to_hash).transpose()
     }
 
     /// Get a value by key as raw bytes.
@@ -137,6 +233,7 @@ impl Database {
 
         let result =
             block_on_result(async { self.inner.get_with_options(key.as_bytes(), &opts).await })?;
+        self.increment_metric("db.get_bytes.count");
 
         Ok(result.map(|b| b.to_vec()))
     }
@@ -155,6 +252,7 @@ impl Database {
 
         let write_opts = WriteOptions {
             await_durable: true,
+            seqnum: 0,
         };
 
         block_on_result(async {
@@ -162,6 +260,7 @@ impl Database {
                 .put_with_options(key.as_bytes(), value.as_bytes(), &put_opts, &write_opts)
                 .await
         })?;
+        self.increment_metric("db.put.count");
 
         Ok(())
     }
@@ -171,7 +270,7 @@ impl Database {
     /// # Arguments
     /// * `key` - The key to store
     /// * `value` - The value to store
-    /// * `kwargs` - Keyword arguments (ttl, await_durable)
+    /// * `kwargs` - Keyword arguments (ttl, await_durable, seqnum)
     pub fn put_with_options(&self, key: String, value: String, kwargs: RHash) -> Result<(), Error> {
         if key.is_empty() {
             return Err(invalid_argument_error("key cannot be empty"));
@@ -187,14 +286,14 @@ impl Database {
         };
 
         // Parse await_durable
-        let await_durable = get_optional::<bool>(&kwargs, "await_durable")?.unwrap_or(true);
-        let write_opts = WriteOptions { await_durable };
+        let write_opts = Self::write_options_from_kwargs(&kwargs)?;
 
         block_on_result(async {
             self.inner
                 .put_with_options(key.as_bytes(), value.as_bytes(), &put_opts, &write_opts)
                 .await
         })?;
+        self.increment_metric("db.put_with_options.count");
 
         Ok(())
     }
@@ -210,6 +309,7 @@ impl Database {
 
         let write_opts = WriteOptions {
             await_durable: true,
+            seqnum: 0,
         };
 
         block_on_result(async {
@@ -217,6 +317,7 @@ impl Database {
                 .delete_with_options(key.as_bytes(), &write_opts)
                 .await
         })?;
+        self.increment_metric("db.delete.count");
 
         Ok(())
     }
@@ -225,20 +326,20 @@ impl Database {
     ///
     /// # Arguments
     /// * `key` - The key to delete
-    /// * `kwargs` - Keyword arguments (await_durable)
+    /// * `kwargs` - Keyword arguments (await_durable, seqnum)
     pub fn delete_with_options(&self, key: String, kwargs: RHash) -> Result<(), Error> {
         if key.is_empty() {
             return Err(invalid_argument_error("key cannot be empty"));
         }
 
-        let await_durable = get_optional::<bool>(&kwargs, "await_durable")?.unwrap_or(true);
-        let write_opts = WriteOptions { await_durable };
+        let write_opts = Self::write_options_from_kwargs(&kwargs)?;
 
         block_on_result(async {
             self.inner
                 .delete_with_options(key.as_bytes(), &write_opts)
                 .await
         })?;
+        self.increment_metric("db.delete_with_options.count");
 
         Ok(())
     }
@@ -325,6 +426,18 @@ impl Database {
         if let Some(mft) = get_optional::<usize>(&kwargs, "max_fetch_tasks")? {
             opts.max_fetch_tasks = mft;
         }
+        if let Some(order) = get_optional::<String>(&kwargs, "order")? {
+            opts.order = match order.as_str() {
+                "ascending" | "asc" => IterationOrder::Ascending,
+                "descending" | "desc" => IterationOrder::Descending,
+                other => {
+                    return Err(invalid_argument_error(&format!(
+                        "invalid order: {} (expected 'asc' or 'desc')",
+                        other
+                    )))
+                }
+            };
+        }
 
         let start_bytes = start.into_bytes();
         let end_bytes = end_key.map(|e| e.into_bytes());
@@ -408,6 +521,18 @@ impl Database {
         if let Some(mft) = get_optional::<usize>(&kwargs, "max_fetch_tasks")? {
             opts.max_fetch_tasks = mft;
         }
+        if let Some(order) = get_optional::<String>(&kwargs, "order")? {
+            opts.order = match order.as_str() {
+                "ascending" | "asc" => IterationOrder::Ascending,
+                "descending" | "desc" => IterationOrder::Descending,
+                other => {
+                    return Err(invalid_argument_error(&format!(
+                        "invalid order: {} (expected 'asc' or 'desc')",
+                        other
+                    )))
+                }
+            };
+        }
 
         let iter = block_on_result(async {
             self.inner
@@ -432,10 +557,9 @@ impl Database {
     ///
     /// # Arguments
     /// * `batch` - The WriteBatch to write
-    /// * `kwargs` - Keyword arguments (await_durable)
+    /// * `kwargs` - Keyword arguments (await_durable, seqnum)
     pub fn write_with_options(&self, batch: &WriteBatch, kwargs: RHash) -> Result<(), Error> {
-        let await_durable = get_optional::<bool>(&kwargs, "await_durable")?.unwrap_or(true);
-        let write_opts = WriteOptions { await_durable };
+        let write_opts = Self::write_options_from_kwargs(&kwargs)?;
 
         let batch_inner = batch.take()?;
 
@@ -462,6 +586,7 @@ impl Database {
 
         let write_opts = WriteOptions {
             await_durable: true,
+            seqnum: 0,
         };
 
         block_on_result(async {
@@ -478,8 +603,13 @@ impl Database {
     /// # Arguments
     /// * `key` - The key to merge into
     /// * `value` - The merge operand to apply
-    /// * `kwargs` - Keyword arguments (ttl, await_durable)
-    pub fn merge_with_options(&self, key: String, value: String, kwargs: RHash) -> Result<(), Error> {
+    /// * `kwargs` - Keyword arguments (ttl, await_durable, seqnum)
+    pub fn merge_with_options(
+        &self,
+        key: String,
+        value: String,
+        kwargs: RHash,
+    ) -> Result<(), Error> {
         if key.is_empty() {
             return Err(invalid_argument_error("key cannot be empty"));
         }
@@ -492,8 +622,7 @@ impl Database {
             },
         };
 
-        let await_durable = get_optional::<bool>(&kwargs, "await_durable")?.unwrap_or(true);
-        let write_opts = WriteOptions { await_durable };
+        let write_opts = Self::write_options_from_kwargs(&kwargs)?;
 
         block_on_result(async {
             self.inner
@@ -548,8 +677,8 @@ impl Database {
     pub fn create_checkpoint(&self, kwargs: RHash) -> Result<RHash, Error> {
         use slatedb::config::{CheckpointOptions, CheckpointScope};
 
-        let lifetime = get_optional::<u64>(&kwargs, "lifetime")?
-            .map(std::time::Duration::from_millis);
+        let lifetime =
+            get_optional::<u64>(&kwargs, "lifetime")?.map(std::time::Duration::from_millis);
         let name = get_optional::<String>(&kwargs, "name")?;
 
         let options = CheckpointOptions {
@@ -578,6 +707,11 @@ impl Database {
         Ok(())
     }
 
+    /// Return the database metrics registry.
+    pub fn metrics(&self) -> Result<Metrics, Error> {
+        Ok(Metrics::new(self.metrics.clone()))
+    }
+
     /// Close the database.
     pub fn close(&self) -> Result<(), Error> {
         block_on_result(async { self.inner.close().await })?;
@@ -595,6 +729,11 @@ pub fn define_database_class(ruby: &Ruby, module: &magnus::RModule) -> Result<()
     // Instance methods - simple versions
     class.define_method("_get", method!(Database::get, 1))?;
     class.define_method("_get_with_options", method!(Database::get_with_options, 2))?;
+    class.define_method("_get_key_value", method!(Database::get_key_value, 1))?;
+    class.define_method(
+        "_get_key_value_with_options",
+        method!(Database::get_key_value_with_options, 2),
+    )?;
     class.define_method("get_bytes", method!(Database::get_bytes, 1))?;
     class.define_method("_put", method!(Database::put, 2))?;
     class.define_method("_put_with_options", method!(Database::put_with_options, 3))?;
@@ -633,6 +772,7 @@ pub fn define_database_class(ruby: &Ruby, module: &magnus::RModule) -> Result<()
         method!(Database::create_checkpoint, 1),
     )?;
     class.define_method("flush", method!(Database::flush, 0))?;
+    class.define_method("_metrics", method!(Database::metrics, 0))?;
     class.define_method("close", method!(Database::close, 0))?;
 
     Ok(())

data/ext/slatedb/src/iterator.rs

@@ -98,7 +98,10 @@ impl Iterator {
         let result = block_on(async {
             let mut guard = inner.lock().await;
             match guard.as_mut() {
-                Some(iter) => iter.seek(key.as_bytes()).await.map_err(IteratorError::Slate),
+                Some(iter) => iter
+                    .seek(key.as_bytes())
+                    .await
+                    .map_err(IteratorError::Slate),
                 None => Err(IteratorError::Closed),
             }
         });

data/ext/slatedb/src/lib.rs

@@ -21,6 +21,7 @@ mod database;
 mod errors;
 mod iterator;
 mod merge_ops;
+mod metrics;
 mod reader;
 mod runtime;
 mod snapshot;
@@ -46,6 +47,7 @@ fn init(ruby: &Ruby) -> Result<(), Error> {
     snapshot::define_snapshot_class(ruby, &module)?;
     reader::define_reader_class(ruby, &module)?;
     admin::define_admin_class(ruby, &module)?;
+    metrics::define_metrics_class(ruby, &module)?;
 
     Ok(())
 }

data/ext/slatedb/src/merge_ops.rs

@@ -149,9 +149,7 @@ impl RubyProcMergeOperator {
             "Ruby merge operator called from non-Ruby thread, using fallback concatenation. \
              This can happen during background compaction."
         );
-        let mut result = existing_value
-            .map(|v| v.to_vec())
-            .unwrap_or_default();
+        let mut result = existing_value.map(|v| v.to_vec()).unwrap_or_default();
         result.extend_from_slice(new_value);
         Ok(Bytes::from(result))
     }