slatedb 0.2.0 → 0.4.4

data/lib/slatedb/database.rb

@@ -95,12 +95,44 @@ module SlateDb
       end
     end
 
+    # Get a key-value pair with SlateDB metadata.
+    #
+    # @param key [String] The key to look up
+    # @param durability_filter [String, nil] Filter by durability level ("remote" or "memory")
+    # @param dirty [Boolean, nil] Whether to include uncommitted data
+    # @param cache_blocks [Boolean, nil] Whether to cache blocks
+    # @return [Hash, nil] A hash with :key, :value, :seq, :create_ts, and :expire_ts, or nil if not found
+    #
+    # @example Inspect metadata
+    #   entry = db.get_key_value("mykey")
+    #   entry[:value] # => "myvalue"
+    #   entry[:seq]   # => sequence number
+    #
+    def get_key_value(key, durability_filter: nil, dirty: nil, cache_blocks: nil)
+      opts = {}
+      opts[:durability_filter] = durability_filter.to_s if durability_filter
+      opts[:dirty] = dirty unless dirty.nil?
+      opts[:cache_blocks] = cache_blocks unless cache_blocks.nil?
+
+      if opts.empty?
+        _get_key_value(key)
+      else
+        _get_key_value_with_options(key, opts)
+      end
+    end
+
+    alias get_entry get_key_value
+
     # Store a key-value pair.
     #
     # @param key [String] The key to store
     # @param value [String] The value to store
     # @param ttl [Integer, nil] Time-to-live in milliseconds
     # @param await_durable [Boolean] Whether to wait for durability (default: true)
+    # @param seqnum [Integer, nil] User-supplied sequence number for this write.
+    #   When provided (and non-zero), it is used instead of the internally
+    #   generated sequence number. It must be strictly greater than the current
+    #   maximum sequence number or the write fails. (Requires SlateDB >= 0.13.0)
     # @return [void]
     #
     # @example Basic put
@@ -112,10 +144,14 @@ module SlateDb
     # @example Put without waiting for durability
     #   db.put("mykey", "myvalue", await_durable: false)
     #
-    def put(key, value, ttl: nil, await_durable: nil)
+    # @example Put with an explicit sequence number
+    #   db.put("mykey", "myvalue", seqnum: 42)
+    #
+    def put(key, value, ttl: nil, await_durable: nil, seqnum: nil)
       opts = {}
       opts[:ttl] = ttl if ttl
       opts[:await_durable] = await_durable unless await_durable.nil?
+      opts[:seqnum] = seqnum if seqnum
 
       if opts.empty?
         _put(key, value)
@@ -128,6 +164,8 @@ module SlateDb
     #
     # @param key [String] The key to delete
     # @param await_durable [Boolean] Whether to wait for durability (default: true)
+    # @param seqnum [Integer, nil] User-supplied sequence number for this write.
+    #   See {#put} for semantics. (Requires SlateDB >= 0.13.0)
     # @return [void]
     #
     # @example Basic delete
@@ -136,11 +174,15 @@ module SlateDb
     # @example Delete without waiting for durability
     #   db.delete("mykey", await_durable: false)
     #
-    def delete(key, await_durable: nil)
-      if await_durable.nil?
+    def delete(key, await_durable: nil, seqnum: nil)
+      opts = {}
+      opts[:await_durable] = await_durable unless await_durable.nil?
+      opts[:seqnum] = seqnum if seqnum
+
+      if opts.empty?
         _delete(key)
       else
-        _delete_with_options(key, { await_durable: await_durable })
+        _delete_with_options(key, opts)
       end
     end
 
@@ -153,6 +195,7 @@ module SlateDb
     # @param read_ahead_bytes [Integer, nil] Number of bytes to read ahead
     # @param cache_blocks [Boolean, nil] Whether to cache blocks
     # @param max_fetch_tasks [Integer, nil] Maximum number of fetch tasks
+    # @param order [Symbol, String, nil] Iteration order (:asc/:ascending or :desc/:descending)
     # @return [Iterator] An iterator over key-value pairs
     #
     # @example Basic scan
@@ -171,13 +214,15 @@ module SlateDb
     #   end
     #
     def scan(start_key, end_key = nil, durability_filter: nil, dirty: nil,
-             read_ahead_bytes: nil, cache_blocks: nil, max_fetch_tasks: nil, &)
-      opts = {}
-      opts[:durability_filter] = durability_filter.to_s if durability_filter
-      opts[:dirty] = dirty unless dirty.nil?
-      opts[:read_ahead_bytes] = read_ahead_bytes if read_ahead_bytes
-      opts[:cache_blocks] = cache_blocks unless cache_blocks.nil?
-      opts[:max_fetch_tasks] = max_fetch_tasks if max_fetch_tasks
+             read_ahead_bytes: nil, cache_blocks: nil, max_fetch_tasks: nil, order: nil, &)
+      opts = scan_options(
+        durability_filter: durability_filter,
+        dirty: dirty,
+        read_ahead_bytes: read_ahead_bytes,
+        cache_blocks: cache_blocks,
+        max_fetch_tasks: max_fetch_tasks,
+        order: order
+      )
 
       iter = if opts.empty?
                _scan(start_key, end_key)
@@ -200,6 +245,12 @@ module SlateDb
     # @param read_ahead_bytes [Integer, nil] Number of bytes to read ahead
     # @param cache_blocks [Boolean, nil] Whether to cache blocks
     # @param max_fetch_tasks [Integer, nil] Maximum number of fetch tasks
+    # @param order [Symbol, String, nil] Iteration order (:asc/:ascending or :desc/:descending)
+    # @param from [String, nil] Inclusive lower bound suffix, appended to the
+    #   prefix, to start scanning from (e.g. prefix "user:" with from "100"
+    #   starts at "user:100"). Defaults to the start of the prefix.
+    # @param to [String, nil] Exclusive upper bound suffix, appended to the
+    #   prefix, to stop scanning at. Defaults to the end of the prefix.
     # @return [Iterator] An iterator over key-value pairs
     #
     # @example Scan all user keys
@@ -207,14 +258,23 @@ module SlateDb
     #     puts "#{key}: #{value}"
     #   end
     #
+    # @example Scan a sub-range within a prefix
+    #   # keys "user:100" (inclusive) up to "user:200" (exclusive)
+    #   db.scan_prefix("user:", from: "100", to: "200")
+    #
     def scan_prefix(prefix, durability_filter: nil, dirty: nil,
-                    read_ahead_bytes: nil, cache_blocks: nil, max_fetch_tasks: nil, &)
-      opts = {}
-      opts[:durability_filter] = durability_filter.to_s if durability_filter
-      opts[:dirty] = dirty unless dirty.nil?
-      opts[:read_ahead_bytes] = read_ahead_bytes if read_ahead_bytes
-      opts[:cache_blocks] = cache_blocks unless cache_blocks.nil?
-      opts[:max_fetch_tasks] = max_fetch_tasks if max_fetch_tasks
+                    read_ahead_bytes: nil, cache_blocks: nil, max_fetch_tasks: nil, order: nil,
+                    from: nil, to: nil, &)
+      opts = scan_options(
+        durability_filter: durability_filter,
+        dirty: dirty,
+        read_ahead_bytes: read_ahead_bytes,
+        cache_blocks: cache_blocks,
+        max_fetch_tasks: max_fetch_tasks,
+        order: order
+      )
+      opts[:subrange_from] = from if from
+      opts[:subrange_to] = to if to
 
       iter = if opts.empty?
                _scan_prefix(prefix)
@@ -229,10 +289,26 @@ module SlateDb
       end
     end
 
+    def scan_options(durability_filter:, dirty:, read_ahead_bytes:, cache_blocks:,
+                     max_fetch_tasks:, order:)
+      opts = {}
+      opts[:durability_filter] = durability_filter.to_s if durability_filter
+      opts[:dirty] = dirty unless dirty.nil?
+      opts[:read_ahead_bytes] = read_ahead_bytes if read_ahead_bytes
+      opts[:cache_blocks] = cache_blocks unless cache_blocks.nil?
+      opts[:max_fetch_tasks] = max_fetch_tasks if max_fetch_tasks
+      opts[:order] = order.to_s if order
+      opts
+    end
+
+    private :scan_options
+
     # Write a batch of operations atomically.
     #
     # @param batch [WriteBatch] The batch to write
     # @param await_durable [Boolean] Whether to wait for durability (default: true)
+    # @param seqnum [Integer, nil] User-supplied sequence number applied to the
+    #   batch. See {#put} for semantics. (Requires SlateDB >= 0.13.0)
     # @return [void]
     #
     # @example Write a batch
@@ -248,11 +324,15 @@ module SlateDb
     #     b.put("key2", "value2")
     #   end
     #
-    def write(batch, await_durable: nil)
-      if await_durable.nil?
+    def write(batch, await_durable: nil, seqnum: nil)
+      opts = {}
+      opts[:await_durable] = await_durable unless await_durable.nil?
+      opts[:seqnum] = seqnum if seqnum
+
+      if opts.empty?
         _write(batch)
       else
-        _write_with_options(batch, { await_durable: await_durable })
+        _write_with_options(batch, opts)
       end
     end
 
@@ -262,6 +342,8 @@ module SlateDb
     # @param value [String] The merge operand to apply
     # @param ttl [Integer, nil] Time-to-live in milliseconds
     # @param await_durable [Boolean] Whether to wait for durability (default: true)
+    # @param seqnum [Integer, nil] User-supplied sequence number for this write.
+    #   See {#put} for semantics. (Requires SlateDB >= 0.13.0)
     # @return [void]
     #
     # @example Merge with string concatenation operator
@@ -269,10 +351,11 @@ module SlateDb
     #   db.merge("key", "part1")
     #   db.merge("key", "part2")
     #
-    def merge(key, value, ttl: nil, await_durable: nil)
+    def merge(key, value, ttl: nil, await_durable: nil, seqnum: nil)
       opts = {}
       opts[:ttl] = ttl if ttl
       opts[:await_durable] = await_durable unless await_durable.nil?
+      opts[:seqnum] = seqnum if seqnum
 
       if opts.empty?
         _merge(key, value)
@@ -284,6 +367,8 @@ module SlateDb
     # Create and write a batch using a block.
     #
     # @param await_durable [Boolean] Whether to wait for durability (default: true)
+    # @param seqnum [Integer, nil] User-supplied sequence number applied to the
+    #   batch. See {#put} for semantics. (Requires SlateDB >= 0.13.0)
     # @yield [batch] Yields a WriteBatch to the block
     # @return [void]
     #
@@ -294,10 +379,10 @@ module SlateDb
     #     b.delete("old_key")
     #   end
     #
-    def batch(await_durable: nil)
+    def batch(await_durable: nil, seqnum: nil)
       b = WriteBatch.new
       yield b
-      write(b, await_durable: await_durable)
+      write(b, await_durable: await_durable, seqnum: seqnum)
     end
 
     # Begin a new transaction.
@@ -414,5 +499,12 @@ module SlateDb
       opts[:name] = name if name
       _create_checkpoint(opts)
     end
+
+    # Get database metrics registry.
+    #
+    # @return [Metrics] Metrics registry
+    def metrics
+      _metrics
+    end
   end
 end

data/lib/slatedb/metrics.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module SlateDb
+  class Metrics
+    # Get a metric value by name.
+    #
+    # @param name [String] Metric name
+    # @return [Integer, nil] Current value or nil if not found
+    def [](name)
+      get(name)
+    end
+
+    # Convert all metrics to a hash.
+    #
+    # @return [Hash] Map of metric name to value
+    def to_h
+      names.to_h { |metric_name| [metric_name, get(metric_name)] }
+    end
+  end
+end

data/lib/slatedb/reader.rb

@@ -7,10 +7,24 @@ module SlateDb
       #
       # @param path [String] The path identifier for the database
       # @param url [String, nil] Optional object store URL
-      # @param checkpoint_id [String, nil] Optional checkpoint UUID to read at
+      # @param checkpoint_id [String, nil] Optional checkpoint UUID to read at. When
+      #   given, the reader is pinned to that checkpoint and does not follow new writes.
+      # @param follow_latest [Boolean, nil] When true, the reader tails the latest
+      #   manifest without creating or maintaining its own checkpoint. This performs no
+      #   object-store writes but provides no protection from garbage collection, so it
+      #   is best suited to read-only or mirrored databases. Mutually exclusive with
+      #   +checkpoint_id+. When neither is set (the default), the reader manages its own
+      #   checkpoint and refreshes it periodically. (Requires SlateDB >= 0.15.0)
       # @param manifest_poll_interval [Integer, nil] Poll interval in milliseconds
       # @param checkpoint_lifetime [Integer, nil] Checkpoint lifetime in milliseconds
       # @param max_memtable_bytes [Integer, nil] Maximum memtable size in bytes
+      # @param cache_root [String, nil] Root folder for the reader's local on-disk
+      #   object-store cache. Setting this enables the cached object store; when it is
+      #   not set the cache (and `max_open_file_handles`) has no effect.
+      # @param max_open_file_handles [Integer, nil] Maximum number of file handles to keep
+      #   open in the reader's file-handle cache. When the limit is reached, the least
+      #   recently used handle is closed (default: 1000). Only takes effect when
+      #   `cache_root` is set. (Requires SlateDB >= 0.13.0)
       # @param merge_operator [Symbol, String, nil] Optional merge operator ("string_concat" or "concat")
       # @yield [reader] If a block is given, yields the reader and ensures it's closed
       # @return [Reader] The opened reader (or block result if block given)
@@ -28,13 +42,25 @@ module SlateDb
       # @example Open at a specific checkpoint
       #   reader = SlateDb::Reader.open("/tmp/mydb", checkpoint_id: "uuid-here")
       #
-      def open(path, url: nil, checkpoint_id: nil,
+      # @example Follow the latest state without managing a checkpoint
+      #   reader = SlateDb::Reader.open("/tmp/mydb", follow_latest: true)
+      #
+      # @example Enable the on-disk cache and cap its open file handles
+      #   reader = SlateDb::Reader.open("/tmp/mydb",
+      #                                 cache_root: "/var/cache/slatedb",
+      #                                 max_open_file_handles: 256)
+      #
+      def open(path, url: nil, checkpoint_id: nil, follow_latest: nil,
                manifest_poll_interval: nil, checkpoint_lifetime: nil,
-               max_memtable_bytes: nil, merge_operator: nil)
+               max_memtable_bytes: nil, cache_root: nil, max_open_file_handles: nil,
+               merge_operator: nil)
         opts = {}
+        opts[:follow_latest] = follow_latest unless follow_latest.nil?
         opts[:manifest_poll_interval] = manifest_poll_interval if manifest_poll_interval
         opts[:checkpoint_lifetime] = checkpoint_lifetime if checkpoint_lifetime
         opts[:max_memtable_bytes] = max_memtable_bytes if max_memtable_bytes
+        opts[:cache_root] = cache_root if cache_root
+        opts[:max_open_file_handles] = max_open_file_handles if max_open_file_handles
         opts[:merge_operator] = merge_operator.to_s if merge_operator
 
         reader = _open(path, url, checkpoint_id, opts)
@@ -112,16 +138,25 @@ module SlateDb
     # @param read_ahead_bytes [Integer, nil] Number of bytes to read ahead
     # @param cache_blocks [Boolean, nil] Whether to cache blocks
     # @param max_fetch_tasks [Integer, nil] Maximum number of fetch tasks
+    # @param from [String, nil] Inclusive lower bound suffix, appended to the
+    #   prefix, to start scanning from (e.g. prefix "user:" with from "100"
+    #   starts at "user:100"). Defaults to the start of the prefix.
+    # @param to [String, nil] Exclusive upper bound suffix, appended to the
+    #   prefix, to stop scanning at. Defaults to the end of the prefix.
     # @return [Iterator] An iterator over key-value pairs
     #
     def scan_prefix(prefix, durability_filter: nil, dirty: nil,
-                    read_ahead_bytes: nil, cache_blocks: nil, max_fetch_tasks: nil, &)
-      opts = {}
-      opts[:durability_filter] = durability_filter.to_s if durability_filter
-      opts[:dirty] = dirty unless dirty.nil?
-      opts[:read_ahead_bytes] = read_ahead_bytes if read_ahead_bytes
-      opts[:cache_blocks] = cache_blocks unless cache_blocks.nil?
-      opts[:max_fetch_tasks] = max_fetch_tasks if max_fetch_tasks
+                    read_ahead_bytes: nil, cache_blocks: nil, max_fetch_tasks: nil,
+                    from: nil, to: nil, &)
+      opts = {
+        durability_filter: durability_filter&.to_s,
+        dirty: dirty,
+        read_ahead_bytes: read_ahead_bytes,
+        cache_blocks: cache_blocks,
+        max_fetch_tasks: max_fetch_tasks,
+        subrange_from: from,
+        subrange_to: to
+      }.compact
 
       iter = if opts.empty?
                _scan_prefix(prefix)

data/lib/slatedb/snapshot.rb

@@ -59,16 +59,24 @@ module SlateDb
     # @param read_ahead_bytes [Integer, nil] Number of bytes to read ahead
     # @param cache_blocks [Boolean, nil] Whether to cache blocks
     # @param max_fetch_tasks [Integer, nil] Maximum number of fetch tasks
+    # @param from [String, nil] Inclusive lower bound suffix, appended to the
+    #   prefix, to start scanning from. Defaults to the start of the prefix.
+    # @param to [String, nil] Exclusive upper bound suffix, appended to the
+    #   prefix, to stop scanning at. Defaults to the end of the prefix.
     # @return [Iterator] An iterator over key-value pairs
     #
     def scan_prefix(prefix, durability_filter: nil, dirty: nil,
-                    read_ahead_bytes: nil, cache_blocks: nil, max_fetch_tasks: nil, &)
-      opts = {}
-      opts[:durability_filter] = durability_filter.to_s if durability_filter
-      opts[:dirty] = dirty unless dirty.nil?
-      opts[:read_ahead_bytes] = read_ahead_bytes if read_ahead_bytes
-      opts[:cache_blocks] = cache_blocks unless cache_blocks.nil?
-      opts[:max_fetch_tasks] = max_fetch_tasks if max_fetch_tasks
+                    read_ahead_bytes: nil, cache_blocks: nil, max_fetch_tasks: nil,
+                    from: nil, to: nil, &)
+      opts = {
+        durability_filter: durability_filter&.to_s,
+        dirty: dirty,
+        read_ahead_bytes: read_ahead_bytes,
+        cache_blocks: cache_blocks,
+        max_fetch_tasks: max_fetch_tasks,
+        subrange_from: from,
+        subrange_to: to
+      }.compact
 
       iter = if opts.empty?
                _scan_prefix(prefix)

data/lib/slatedb/transaction.rb

@@ -98,16 +98,24 @@ module SlateDb
     # @param read_ahead_bytes [Integer, nil] Number of bytes to read ahead
     # @param cache_blocks [Boolean, nil] Whether to cache blocks
     # @param max_fetch_tasks [Integer, nil] Maximum number of fetch tasks
+    # @param from [String, nil] Inclusive lower bound suffix, appended to the
+    #   prefix, to start scanning from. Defaults to the start of the prefix.
+    # @param to [String, nil] Exclusive upper bound suffix, appended to the
+    #   prefix, to stop scanning at. Defaults to the end of the prefix.
     # @return [Iterator] An iterator over key-value pairs
     #
     def scan_prefix(prefix, durability_filter: nil, dirty: nil,
-                    read_ahead_bytes: nil, cache_blocks: nil, max_fetch_tasks: nil, &)
-      opts = {}
-      opts[:durability_filter] = durability_filter.to_s if durability_filter
-      opts[:dirty] = dirty unless dirty.nil?
-      opts[:read_ahead_bytes] = read_ahead_bytes if read_ahead_bytes
-      opts[:cache_blocks] = cache_blocks unless cache_blocks.nil?
-      opts[:max_fetch_tasks] = max_fetch_tasks if max_fetch_tasks
+                    read_ahead_bytes: nil, cache_blocks: nil, max_fetch_tasks: nil,
+                    from: nil, to: nil, &)
+      opts = {
+        durability_filter: durability_filter&.to_s,
+        dirty: dirty,
+        read_ahead_bytes: read_ahead_bytes,
+        cache_blocks: cache_blocks,
+        max_fetch_tasks: max_fetch_tasks,
+        subrange_from: from,
+        subrange_to: to
+      }.compact
 
       iter = if opts.empty?
                _scan_prefix(prefix)
@@ -141,5 +149,34 @@ module SlateDb
     def mark_read(keys)
       _mark_read(Array(keys))
     end
+
+    # Commit the transaction.
+    #
+    # @param await_durable [Boolean, nil] Whether to wait for durability (default: true)
+    # @param seqnum [Integer, nil] User-supplied sequence number for the commit.
+    #   When provided (and non-zero), it is used instead of the internally
+    #   generated sequence number and must be strictly greater than the current
+    #   maximum sequence number. (Requires SlateDB >= 0.13.0)
+    # @return [void]
+    #
+    # @example Commit a transaction
+    #   txn = db.begin_transaction
+    #   txn.put("key", "value")
+    #   txn.commit
+    #
+    # @example Commit with an explicit sequence number
+    #   txn.commit(seqnum: 99)
+    #
+    def commit(await_durable: nil, seqnum: nil)
+      opts = {}
+      opts[:await_durable] = await_durable unless await_durable.nil?
+      opts[:seqnum] = seqnum if seqnum
+
+      if opts.empty?
+        _commit
+      else
+        _commit_with_options(opts)
+      end
+    end
   end
 end

data/lib/slatedb/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module SlateDb
-  VERSION = "0.2.0"
+  VERSION = "0.4.4"
 end

data/lib/slatedb.rb

@@ -18,3 +18,4 @@ require_relative "slatedb/transaction"
 require_relative "slatedb/snapshot"
 require_relative "slatedb/reader"
 require_relative "slatedb/admin"
+require_relative "slatedb/metrics"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: slatedb
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.4.4
 platform: ruby
 authors:
 - SlateDB Contributors
@@ -15,70 +15,70 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.9'
+        version: 0.9.128
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.9'
+        version: 0.9.128
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '13.0'
+        version: '13.4'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '13.0'
+        version: '13.4'
 - !ruby/object:Gem::Dependency
   name: rake-compiler
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.2'
+        version: '1.3'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.2'
+        version: '1.3'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.12'
+        version: '3.13'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.12'
+        version: '3.13'
 - !ruby/object:Gem::Dependency
   name: rubocop
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.21'
+        version: '1.86'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.21'
+        version: '1.86'
 description: A cloud-native embedded key-value store built on object storage
 email:
 - slatedb@example.com
@@ -98,6 +98,7 @@ files:
 - ext/slatedb/src/iterator.rs
 - ext/slatedb/src/lib.rs
 - ext/slatedb/src/merge_ops.rs
+- ext/slatedb/src/metrics.rs
 - ext/slatedb/src/reader.rs
 - ext/slatedb/src/runtime.rs
 - ext/slatedb/src/snapshot.rs
@@ -108,6 +109,7 @@ files:
 - lib/slatedb/admin.rb
 - lib/slatedb/database.rb
 - lib/slatedb/iterator.rb
+- lib/slatedb/metrics.rb
 - lib/slatedb/reader.rb
 - lib/slatedb/snapshot.rb
 - lib/slatedb/transaction.rb
@@ -128,14 +130,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 3.2.0
+      version: 3.3.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.2
+rubygems_version: 4.0.16
 specification_version: 4
 summary: Ruby bindings for SlateDB
 test_files: []