refactor: use service-toolkit runtime helpers; drop local dupes

Replace hand-rolled copies with the shared toolkit modules
(service-toolkit-rust `runtime` feature):

- config:  local env_* readers now delegate to service_toolkit_rust::env
           (names kept for the fallback-chain call sites in load)
- main:    tracing init -> telemetry::init_tracing
- metrics: /metrics server -> metrics::serve (global registry)
- wal:     timestamp -> time::now_millis_u128

Drops now-unused deps: hyper, hyper-util, http-body-util,
tracing-subscriber. Builds + clippy clean (debug & release).

Author: THEROER

Cargo.lock

@@ -12,17 +12,13 @@ tokio = { version = "1", features = ["full"] }
 reqwest = { version = "0.12", features = ["json"] }
 tonic = "0.12"
 prost = "0.13"
-service-toolkit-rust = { git = "https://github.com/LeavePulse/service-toolkit.git", default-features = false, features = ["grpc"] }
+service-toolkit-rust = { git = "https://github.com/LeavePulse/service-toolkit.git", default-features = false, features = ["grpc", "runtime"] }
 serde = { version = "1", features = ["derive"] }
 serde_json = "1"
 redis = { version = "0.27", features = ["tokio-comp"] }
 prometheus = { version = "0.13", features = ["process"] }
-hyper = { version = "1", features = ["server", "http1"] }
-hyper-util = { version = "0.1", features = ["tokio"] }
-http-body-util = "0.1"
 sha2 = "0.10"
 tracing = "0.1"
-tracing-subscriber = { version = "0.3", features = ["env-filter", "json"] }
 dotenvy = "0.15"
 rand = "0.8"
 chrono = { version = "0.4", features = ["serde"] }

Cargo.toml

@@ -1,6 +1,10 @@
 //! Application configuration loaded from environment variables + .env file.
+//!
+//! The typed env readers below are thin aliases over
+//! `service_toolkit_rust::env` so the parsing logic lives in one place; the
+//! local names are kept for the many fallback-chain call sites in `load`.
 
-use std::env;
+use service_toolkit_rust::env as cfg;
 
 /// Server catalog API settings (server-service).
 #[derive(Debug, Clone)]
@@ -96,47 +100,34 @@ pub struct Settings {
     pub redis: RedisSettings,
 }
 
+// Thin aliases over the shared toolkit readers — kept so the fallback-chain
+// call sites in `load` (`.max(...)`, `or_else`) stay terse.
 fn env_str(key: &str, default: &str) -> String {
-    env::var(key).unwrap_or_else(|_| default.to_string())
+    cfg::str(key, default)
 }
 
 fn env_str_opt(key: &str) -> Option<String> {
-    env::var(key).ok().filter(|s| !s.is_empty())
+    cfg::str_opt(key)
 }
 
 fn env_u64(key: &str, default: u64) -> u64 {
-    env::var(key)
-        .ok()
-        .and_then(|v| v.parse().ok())
-        .unwrap_or(default)
+    cfg::u64(key, default)
 }
 
 fn env_usize(key: &str, default: usize) -> usize {
-    env::var(key)
-        .ok()
-        .and_then(|v| v.parse().ok())
-        .unwrap_or(default)
+    cfg::usize(key, default)
 }
 
 fn env_f64(key: &str, default: f64) -> f64 {
-    env::var(key)
-        .ok()
-        .and_then(|v| v.parse().ok())
-        .unwrap_or(default)
+    cfg::f64(key, default)
 }
 
 fn env_u16(key: &str, default: u16) -> u16 {
-    env::var(key)
-        .ok()
-        .and_then(|v| v.parse().ok())
-        .unwrap_or(default)
+    cfg::u16(key, default)
 }
 
 fn env_bool(key: &str, default: bool) -> bool {
-    env::var(key)
-        .ok()
-        .map(|v| matches!(v.to_lowercase().as_str(), "true" | "1" | "yes" | "on"))
-        .unwrap_or(default)
+    cfg::bool(key, default)
 }
 
 impl Settings {

src/config.rs

@@ -13,18 +13,12 @@ mod wal;
 
 use config::Settings;
 use tracing::info;
-use tracing_subscriber::EnvFilter;
 
 #[tokio::main]
 async fn main() {
     let settings = Settings::load();
 
-    // Initialize tracing.
-    let filter = EnvFilter::try_new(&settings.log_level).unwrap_or_else(|_| EnvFilter::new("info"));
-    tracing_subscriber::fmt()
-        .with_env_filter(filter)
-        .with_target(true)
-        .init();
+    service_toolkit_rust::telemetry::init_tracing(&settings.log_level);
 
     info!(
         service = %settings.service_name,

src/main.rs

@@ -1,20 +1,16 @@
-//! Prometheus metrics definitions and HTTP exporter.
+//! Prometheus metrics definitions. The `/metrics` HTTP exporter itself is
+//! served by the shared `service_toolkit_rust::metrics` helper over the
+//! process-global default registry these `register_*!` macros write to.
 
 use std::net::SocketAddr;
 use std::sync::LazyLock;
 
-use http_body_util::Full;
-use hyper::body::Bytes;
-use hyper::service::service_fn;
-use hyper::{Request, Response, StatusCode};
-use hyper_util::rt::TokioIo;
 use prometheus::{
-    Encoder, Gauge, GaugeVec, Histogram, HistogramOpts, IntCounter, IntCounterVec, IntGauge, Opts,
-    TextEncoder, register_gauge, register_gauge_vec, register_histogram, register_int_counter,
+    Gauge, GaugeVec, Histogram, HistogramOpts, IntCounter, IntCounterVec, IntGauge, Opts,
+    register_gauge, register_gauge_vec, register_histogram, register_int_counter,
     register_int_counter_vec, register_int_gauge,
 };
-use tokio::net::TcpListener;
-use tracing::{error, info};
+use tracing::info;
 
 // ---------------------------------------------------------------------------
 // Polling
@@ -280,59 +276,12 @@ pub fn init() {
     LazyLock::force(&BUFFER_EVICTED);
 }
 
-async fn handle_metrics(
-    _req: Request<hyper::body::Incoming>,
-) -> Result<Response<Full<Bytes>>, hyper::Error> {
-    let encoder = TextEncoder::new();
-    let metric_families = prometheus::gather();
-    let mut buffer = Vec::new();
-    if encoder.encode(&metric_families, &mut buffer).is_err() {
-        let resp = Response::builder()
-            .status(StatusCode::INTERNAL_SERVER_ERROR)
-            .body(Full::new(Bytes::from("Failed to encode metrics")))
-            .unwrap();
-        return Ok(resp);
-    }
-    let resp = Response::builder()
-        .status(StatusCode::OK)
-        .header("Content-Type", encoder.format_type())
-        .body(Full::new(Bytes::from(buffer)))
-        .unwrap();
-    Ok(resp)
-}
-
-/// Start the Prometheus metrics HTTP server on the given address.
+/// Start the Prometheus metrics HTTP server on the given address. Serves the
+/// process-global default registry via the shared toolkit helper.
 pub async fn start_metrics_server(host: &str, port: u16) {
     let addr: SocketAddr = format!("{host}:{port}")
         .parse()
         .unwrap_or_else(|_| SocketAddr::from(([0, 0, 0, 0], port)));
-
-    let listener = match TcpListener::bind(addr).await {
-        Ok(l) => l,
-        Err(e) => {
-            error!("Failed to bind metrics server on {addr}: {e}");
-            return;
-        }
-    };
-
     info!("Prometheus metrics server listening on {addr}");
-
-    loop {
-        let (stream, _) = match listener.accept().await {
-            Ok(v) => v,
-            Err(e) => {
-                error!("Metrics server accept error: {e}");
-                continue;
-            }
-        };
-        let io = TokioIo::new(stream);
-        tokio::spawn(async move {
-            if let Err(e) = hyper::server::conn::http1::Builder::new()
-                .serve_connection(io, service_fn(handle_metrics))
-                .await
-            {
-                error!("Metrics connection error: {e}");
-            }
-        });
-    }
+    service_toolkit_rust::metrics::serve(addr).await;
 }

src/metrics.rs

@@ -9,9 +9,9 @@
 use std::fs::{self, File, OpenOptions};
 use std::io::{self, BufReader, Read, Write};
 use std::path::{Path, PathBuf};
-use std::time::{SystemTime, UNIX_EPOCH};
 
 use serde_json::Value;
+use service_toolkit_rust::time::now_millis_u128;
 use tracing::{info, warn};
 
 use crate::metrics::{
@@ -162,10 +162,7 @@ impl WalBuffer {
         // Close current segment (drop flushes).
         self.current_segment = None;
 
-        let ts = SystemTime::now()
-            .duration_since(UNIX_EPOCH)
-            .unwrap_or_default()
-            .as_millis();
+        let ts = now_millis_u128();
         let path = self.dir.join(format!("buffer-{ts}.wal"));
 
         let file = OpenOptions::new().create(true).append(true).open(&path)?;