feat(persistence): implement RocksDB provider (#20071)

Co-authored-by: Dan Cline <[email protected]>

Author: duyquang6

.github/workflows/lint.yml

@@ -98,7 +98,7 @@ jobs:
       matrix:
         partition: [1, 2]
         total_partitions: [2]
-    timeout-minutes: 30
+    timeout-minutes: 60
     steps:
       - uses: actions/checkout@v6
       - uses: rui314/setup-mold@v1

Cargo.lock

@@ -652,6 +652,9 @@ c-kzg = "2.1.5"
 # config
 toml = "0.8"
 
+# rocksdb
+rocksdb = { version = "0.24" }
+
 # otlp obs
 opentelemetry_sdk = "0.31"
 opentelemetry = "0.31"

Cargo.toml

@@ -62,6 +62,10 @@ tokio = { workspace = true, features = ["sync"], optional = true }
 # parallel utils
 rayon.workspace = true
 
+[target.'cfg(unix)'.dependencies]
+# rocksdb: jemalloc is recommended production workload
+rocksdb = { workspace = true, features = ["jemalloc"] }
+
 [dev-dependencies]
 reth-db = { workspace = true, features = ["test-utils"] }
 reth-primitives-traits = { workspace = true, features = ["arbitrary", "test-utils"] }

crates/storage/provider/Cargo.toml

@@ -29,6 +29,13 @@ pub use blockchain_provider::BlockchainProvider;
 mod consistent;
 pub use consistent::ConsistentProvider;
 
+// RocksDB currently only supported on Unix platforms
+// Windows support is planned for future releases
+#[cfg(unix)]
+mod rocksdb;
+#[cfg(unix)]
+pub use rocksdb::{RocksDBBuilder, RocksDBProvider};
+
 /// Helper trait to bound [`NodeTypes`] so that combined with database they satisfy
 /// [`ProviderNodeTypes`].
 pub trait NodeTypesForProvider

crates/storage/provider/src/providers/mod.rs

@@ -0,0 +1,91 @@
+use std::{collections::HashMap, time::Duration};
+
+use itertools::Itertools;
+use metrics::{Counter, Histogram};
+use reth_db::Tables;
+use reth_metrics::Metrics;
+use strum::{EnumIter, IntoEnumIterator};
+
+const ROCKSDB_TABLES: &[&str] = &[Tables::TransactionHashNumbers.name()];
+
+/// Metrics for the `RocksDB` provider.
+#[derive(Debug)]
+pub(crate) struct RocksDBMetrics {
+    operations: HashMap<(&'static str, RocksDBOperation), RocksDBOperationMetrics>,
+}
+
+impl Default for RocksDBMetrics {
+    fn default() -> Self {
+        let mut operations = ROCKSDB_TABLES
+            .iter()
+            .copied()
+            .cartesian_product(RocksDBOperation::iter())
+            .map(|(table, operation)| {
+                (
+                    (table, operation),
+                    RocksDBOperationMetrics::new_with_labels(&[
+                        ("table", table),
+                        ("operation", operation.as_str()),
+                    ]),
+                )
+            })
+            .collect::<HashMap<_, _>>();
+
+        // Add special "Batch" entry for batch write operations
+        operations.insert(
+            ("Batch", RocksDBOperation::BatchWrite),
+            RocksDBOperationMetrics::new_with_labels(&[
+                ("table", "Batch"),
+                ("operation", RocksDBOperation::BatchWrite.as_str()),
+            ]),
+        );
+
+        Self { operations }
+    }
+}
+
+impl RocksDBMetrics {
+    /// Records operation metrics with the given operation label and table name.
+    pub(crate) fn record_operation(
+        &self,
+        operation: RocksDBOperation,
+        table: &'static str,
+        duration: Duration,
+    ) {
+        let metrics =
+            self.operations.get(&(table, operation)).expect("operation metrics should exist");
+
+        metrics.calls_total.increment(1);
+        metrics.duration_seconds.record(duration.as_secs_f64());
+    }
+}
+
+/// `RocksDB` operations that are tracked
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, EnumIter)]
+pub(crate) enum RocksDBOperation {
+    Get,
+    Put,
+    Delete,
+    BatchWrite,
+}
+
+impl RocksDBOperation {
+    const fn as_str(&self) -> &'static str {
+        match self {
+            Self::Get => "get",
+            Self::Put => "put",
+            Self::Delete => "delete",
+            Self::BatchWrite => "batch-write",
+        }
+    }
+}
+
+/// Metrics for a specific `RocksDB` operation on a table
+#[derive(Metrics, Clone)]
+#[metrics(scope = "rocksdb.provider")]
+pub(crate) struct RocksDBOperationMetrics {
+    /// Total number of calls
+    calls_total: Counter,
+    /// Duration of operations
+    duration_seconds: Histogram,
+}

crates/storage/provider/src/providers/rocksdb/metrics.rs

@@ -0,0 +1,5 @@
+//! [`RocksDBProvider`] implementation
+
+mod metrics;
+mod provider;
+pub use provider::{RocksDBBuilder, RocksDBProvider};