chore: opentelemetry support

Cargo.toml

@@ -2,6 +2,7 @@
 members = [
   "atrium-client",
   "atrium-core",
+  "atrium-metrics",
   "atrium-server",
   "tests/behavior",
   "tests/toolkit",
@@ -18,6 +19,7 @@ version = "0.1.0"
 atrium = { path = "atrium-server" }
 atrium-client = { path = "atrium-client" }
 atrium-core = { path = "atrium-core" }
+atrium-metrics = { path = "atrium-metrics" }
 styled = { path = "crates/styled" }
 tests-toolkit = { path = "tests/toolkit" }
 
@@ -31,20 +33,41 @@ error-stack = { version = "0.5", default-features = false, features = [
   "std",
   "serde",
 ] }
+fastimer = { version = "0.8.0" }
 fastrace = { version = "0.7.9" }
+fastrace-opentelemetry = { version = "0.10.0" }
 foyer = { version = "0.16.0", features = ["nightly"] }
 humansize = { version = "2.1.3" }
 indent = { version = "0.1.1" }
 insta = { version = "1.42.2" }
+jiff = { version = "0.2", features = ["serde"] }
 local-ip-address = { version = "0.6.3" }
 log = { version = "0.4.27", features = ["kv"] }
-logforth = { version = "0.24.0", features = ["colored"] }
+logforth = { version = "0.24.0", features = [
+  "colored",
+  "fastrace",
+  "json",
+  "opentelemetry",
+  "rolling-file",
+] }
 mea = { version = "0.3.4" }
+opentelemetry = { version = "0.29.1", features = ["trace", "metrics"] }
+opentelemetry-otlp = { version = "0.29.0", features = [
+  "trace",
+  "metrics",
+  "grpc-tonic",
+] }
+opentelemetry_sdk = { version = "0.29.0", features = [
+  "trace",
+  "metrics",
+  "rt-tokio",
+] }
 poem = { version = "3.1.7" }
 pretty-hex = { version = "0.4.1" }
 pretty_assertions = { version = "1.4.1" }
 regex = { version = "1.11.1" }
 reqwest = { version = "0.12.15" }
+scopeguard = { version = "1.2" }
 serde = { version = "1.0", features = ["derive"] }
 serde_json = { version = "1.0" }
 tempfile = { version = "3.19.1" }

atrium-core/Cargo.toml

@@ -7,6 +7,7 @@ version.workspace = true
 [dependencies]
 error-stack = { workspace = true }
 foyer = { workspace = true }
+jiff = { workspace = true }
 serde = { workspace = true }
 thiserror = { workspace = true }
 tokio = { workspace = true }

atrium-core/src/config.rs

@@ -1,16 +1,28 @@
 use std::path::PathBuf;
 
+use jiff::SignedDuration;
 use serde::Deserialize;
 use serde::Serialize;
 
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct Config {
+    pub server: ServerConfig,
+    pub storage: StorageConfig,
+    pub telemetry: TelemetryConfig,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct ServerConfig {
     #[serde(default = "default_listen_addr")]
     pub listen_addr: String,
     #[serde(skip_serializing_if = "Option::is_none")]
     pub advertise_addr: Option<String>,
-    #[serde(default = "default_path")]
-    pub path: PathBuf,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct StorageConfig {
+    #[serde(default = "default_data_dir")]
+    pub data_dir: PathBuf,
     pub disk_capacity: u64,
     pub memory_capacity: u64,
 }
@@ -19,22 +31,139 @@ fn default_listen_addr() -> String {
     "0.0.0.0:7654".to_string()
 }
 
-fn default_path() -> PathBuf {
-    PathBuf::from("/usr/local/atrium")
+fn default_data_dir() -> PathBuf {
+    PathBuf::from("/var/lib/atrium")
 }
 
 pub fn data_path(base: impl Into<PathBuf>) -> PathBuf {
     base.into().join("data")
 }
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(deny_unknown_fields)]
+pub struct TelemetryConfig {
+    #[serde(default = "LogsConfig::disabled")]
+    pub logs: LogsConfig,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub traces: Option<TracesConfig>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub metrics: Option<MetricsConfig>,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(deny_unknown_fields)]
+pub struct LogsConfig {
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub file: Option<FileAppenderConfig>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub stderr: Option<StderrAppenderConfig>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub opentelemetry: Option<OpentelemetryAppenderConfig>,
+}
+
+impl LogsConfig {
+    pub fn disabled() -> Self {
+        Self {
+            file: None,
+            stderr: None,
+            opentelemetry: None,
+        }
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(deny_unknown_fields)]
+pub struct FileAppenderConfig {
+    pub filter: String,
+    pub dir: String,
+    pub max_files: usize,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(deny_unknown_fields)]
+pub struct StderrAppenderConfig {
+    pub filter: String,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(deny_unknown_fields)]
+pub struct OpentelemetryAppenderConfig {
+    pub filter: String,
+    pub otlp_endpoint: String,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(deny_unknown_fields)]
+pub struct TracesConfig {
+    pub capture_log_filter: String,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub opentelemetry: Option<OpentelemetryTracesConfig>,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(deny_unknown_fields)]
+pub struct OpentelemetryTracesConfig {
+    pub otlp_endpoint: String,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(deny_unknown_fields)]
+pub struct MetricsConfig {
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub opentelemetry: Option<OpentelemetryMetricsConfig>,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(deny_unknown_fields)]
+pub struct OpentelemetryMetricsConfig {
+    pub otlp_endpoint: String,
+    #[serde(default = "default_metrics_push_interval")]
+    pub push_interval: SignedDuration,
+}
+
+fn default_metrics_push_interval() -> SignedDuration {
+    SignedDuration::from_secs(30)
+}
 
 impl Default for Config {
     fn default() -> Self {
         Self {
-            listen_addr: default_listen_addr(),
-            advertise_addr: None,
-            path: default_path(),
-            disk_capacity: 512 * 1024,
-            memory_capacity: 1024 * 1024,
+            server: ServerConfig {
+                listen_addr: default_listen_addr(),
+                advertise_addr: None,
+            },
+            storage: StorageConfig {
+                data_dir: default_data_dir(),
+                disk_capacity: 512 * 1024 * 1024,
+                memory_capacity: 64 * 1024 * 1024,
+            },
+            telemetry: TelemetryConfig {
+                logs: LogsConfig {
+                    file: Some(FileAppenderConfig {
+                        filter: "INFO".to_string(),
+                        dir: "logs".to_string(),
+                        max_files: 64,
+                    }),
+                    stderr: Some(StderrAppenderConfig {
+                        filter: "INFO".to_string(),
+                    }),
+                    opentelemetry: Some(OpentelemetryAppenderConfig {
+                        filter: "INFO".to_string(),
+                        otlp_endpoint: "http://127.0.0.1:4317".to_string(),
+                    }),
+                },
+                traces: Some(TracesConfig {
+                    capture_log_filter: "INFO".to_string(),
+                    opentelemetry: Some(OpentelemetryTracesConfig {
+                        otlp_endpoint: "http://127.0.0.1:4317".to_string(),
+                    }),
+                }),
+                metrics: Some(MetricsConfig {
+                    opentelemetry: Some(OpentelemetryMetricsConfig {
+                        otlp_endpoint: "http://127.0.0.1:4317".to_string(),
+                        push_interval: SignedDuration::from_secs(30),
+                    }),
+                }),
+            },
         }
     }
 }

atrium-core/src/engine.rs

@@ -21,6 +21,7 @@ use crate::util::num_cpus;
 pub struct EngineError(pub String);
 
 pub struct FoyerEngine {
+    capacity: u64,
     inner: HybridCache<Vec<u8>, Vec<u8>>,
 }
 
@@ -53,7 +54,10 @@ impl FoyerEngine {
             .await
             .map_err(|err| report!(EngineError(err.to_string())))?;
 
-        Ok(FoyerEngine { inner: cache })
+        Ok(FoyerEngine {
+            capacity: disk_capacity,
+            inner: cache,
+        })
     }
 
     pub async fn get(&self, key: &[u8]) -> Option<Vec<u8>> {
@@ -73,6 +77,10 @@ impl FoyerEngine {
     pub fn delete(&self, key: &[u8]) {
         self.inner.remove(key);
     }
+
+    pub fn capacity(&self) -> u64 {
+        self.capacity
+    }
 }
 
 #[cfg(test)]

atrium-core/src/lib.rs

@@ -1,4 +1,4 @@
-pub use crate::config::Config;
+pub use crate::config::*;
 pub use crate::engine::FoyerEngine;
 
 mod config;

atrium-metrics/Cargo.toml

@@ -0,0 +1,9 @@
+[package]
+name = "atrium-metrics"
+
+edition.workspace = true
+version.workspace = true
+
+[dependencies]
+opentelemetry = { workspace = true }
+opentelemetry_sdk = { workspace = true }