From 8b0afd9bcfb8c035741208498d71d294fcb9bf8a Mon Sep 17 00:00:00 2001 From: Yingjie Shang Date: Tue, 17 Sep 2024 08:27:22 +0800 Subject: [PATCH 1/7] Instrument RustyVault with Prometheus --- Cargo.toml | 3 ++ src/cli/command/server.rs | 28 ++++++---- src/http/metrics.rs | 24 +++++++++ src/http/mod.rs | 2 + src/lib.rs | 1 + src/metrics/http_metrics.rs | 72 ++++++++++++++++++++++++++ src/metrics/manager.rs | 20 ++++++++ src/metrics/middleware.rs | 41 +++++++++++++++ src/metrics/mod.rs | 8 +++ src/metrics/system_metrics.rs | 96 +++++++++++++++++++++++++++++++++++ 10 files changed, 286 insertions(+), 9 deletions(-) create mode 100644 src/http/metrics.rs create mode 100644 src/metrics/http_metrics.rs create mode 100644 src/metrics/manager.rs create mode 100644 src/metrics/middleware.rs create mode 100644 src/metrics/mod.rs create mode 100644 src/metrics/system_metrics.rs diff --git a/Cargo.toml b/Cargo.toml index fa23586..b35f607 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -58,6 +58,9 @@ glob = "0.3" serde_asn1_der = "0.8" base64 = "0.22" ipnetwork = "0.20" +prometheus-client = "0.22.3" +tokio = "1.40.0" +sysinfo = "0.31.4" # optional dependencies openssl = { version = "0.10.64", optional = true } diff --git a/src/cli/command/server.rs b/src/cli/command/server.rs index d3020d1..515b9f3 100644 --- a/src/cli/command/server.rs +++ b/src/cli/command/server.rs @@ -7,7 +7,7 @@ use std::{ sync::{Arc, RwLock}, }; -use actix_web::{middleware, web, App, HttpResponse, HttpServer}; +use actix_web::{middleware::{self, from_fn}, web, App, HttpResponse, HttpServer}; use anyhow::format_err; use clap::ArgMatches; use openssl::{ @@ -17,12 +17,7 @@ use openssl::{ use sysexits::ExitCode; use crate::{ - cli::config, - core::Core, - errors::RvError, - http, - storage, - EXIT_CODE_INSUFFICIENT_PARAMS, EXIT_CODE_LOAD_CONFIG_FAILURE, EXIT_CODE_OK, + cli::config, core::Core, errors::RvError, http, metrics::{manager::MetricsManager, middleware::metrics_midleware}, storage, EXIT_CODE_INSUFFICIENT_PARAMS, EXIT_CODE_LOAD_CONFIG_FAILURE, EXIT_CODE_OK }; pub const WORK_DIR_PATH_DEFAULT: &str = "/tmp/rusty_vault"; @@ -113,7 +108,15 @@ pub fn main(config_path: &str) -> Result<(), RvError> { let barrier = storage::barrier_aes_gcm::AESGCMBarrier::new(Arc::clone(&backend)); - let core = Arc::new(RwLock::new(Core { physical: backend, barrier: Arc::new(barrier), ..Default::default() })); + let metrics_manager = Arc::new(RwLock::new(MetricsManager::new())); + let system_metrics = Arc::clone(&metrics_manager.read().unwrap().system_metrics); + + + let core = Arc::new(RwLock::new(Core { + physical: backend, + barrier: Arc::new(barrier), + ..Default::default() + })); { let mut c = core.write()?; @@ -123,7 +126,9 @@ pub fn main(config_path: &str) -> Result<(), RvError> { let mut http_server = HttpServer::new(move || { App::new() .wrap(middleware::Logger::default()) + .wrap(from_fn(metrics_midleware)) .app_data(web::Data::new(Arc::clone(&core))) + .app_data(web::Data::new(Arc::clone(&metrics_manager))) .configure(http::init_service) .default_service(web::to(|| HttpResponse::NotFound())) }) @@ -182,7 +187,12 @@ pub fn main(config_path: &str) -> Result<(), RvError> { log::info!("rusty_vault server starts, waiting for request..."); - server.block_on(async { http_server.run().await })?; + server.block_on(async { + tokio::spawn(async { + system_metrics.start_collecting().await; + }); + http_server.run().await + })?; let _ = server.run(); Ok(()) diff --git a/src/http/metrics.rs b/src/http/metrics.rs new file mode 100644 index 0000000..382ffc0 --- /dev/null +++ b/src/http/metrics.rs @@ -0,0 +1,24 @@ +use std::sync::{Arc, RwLock}; + +use actix_web::{web, HttpResponse}; +use prometheus_client::encoding::text::encode; +use crate::metrics::manager::MetricsManager; + +pub async fn metrics_handler(metrics_manager: web::Data>>) -> HttpResponse { + let m = metrics_manager.read().unwrap(); + let registry = m.registry.lock().unwrap(); + + let mut buffer = String::new(); + if let Err(e) = encode(&mut buffer, ®istry) { + eprintln!("Failed to encode metrics: {}", e); + return HttpResponse::InternalServerError().finish(); + } + + HttpResponse::Ok() + .content_type("text/plain; version=0.0.4") + .body(buffer) +} + +pub fn init_metrics_service(cfg: &mut web::ServiceConfig){ + cfg.service(web::resource("/metrics").route(web::get().to(metrics_handler))); +} diff --git a/src/http/mod.rs b/src/http/mod.rs index 417e72d..7c30e6c 100644 --- a/src/http/mod.rs +++ b/src/http/mod.rs @@ -21,6 +21,7 @@ use crate::{core::Core, errors::RvError, logical::Request}; pub mod logical; pub mod sys; +pub mod metrics; pub const AUTH_COOKIE_NAME: &str = "token"; pub const AUTH_HEADER_NAME: &str = "X-RustyVault-Token"; @@ -101,6 +102,7 @@ pub fn request_on_connect_handler(conn: &dyn Any, ext: &mut Extensions) { pub fn init_service(cfg: &mut web::ServiceConfig) { sys::init_sys_service(cfg); logical::init_logical_service(cfg); + metrics::init_metrics_service(cfg); } impl ResponseError for RvError { diff --git a/src/lib.rs b/src/lib.rs index c7723dc..050d34e 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -38,6 +38,7 @@ pub mod router; pub mod shamir; pub mod storage; pub mod utils; +pub mod metrics; #[cfg(feature = "storage_mysql")] pub mod schema; diff --git a/src/metrics/http_metrics.rs b/src/metrics/http_metrics.rs new file mode 100644 index 0000000..a5926ba --- /dev/null +++ b/src/metrics/http_metrics.rs @@ -0,0 +1,72 @@ +use std::fmt::Write; + +use prometheus_client::encoding::{EncodeLabelSet, EncodeLabelValue, LabelValueEncoder}; +use prometheus_client::metrics::counter::Counter; +use prometheus_client::metrics::family::Family; +use prometheus_client::metrics::histogram::{linear_buckets, Histogram}; +use prometheus_client::registry::Registry; + +#[derive(Clone, Copy, Debug, Hash, PartialEq, Eq)] +pub enum MetricsMethod { + GET, + POST, + PUT, + DELETE, + OTHER, +} + +impl EncodeLabelValue for MetricsMethod { + fn encode(&self, writer: &mut LabelValueEncoder<'_>) -> Result<(), std::fmt::Error> { + match self { + MetricsMethod::GET => writer.write_str("get"), + MetricsMethod::POST => writer.write_str("post"), + MetricsMethod::PUT => writer.write_str("put"), + MetricsMethod::DELETE => writer.write_str("delete"), + MetricsMethod::OTHER => writer.write_str("other"), + } + } +} + +#[derive(Clone, Debug, Hash, PartialEq, Eq, EncodeLabelSet)] +pub struct HttpLabel { + pub path: String, + pub method: MetricsMethod, + pub status: u16, +} + +#[derive(Clone)] +pub struct HttpMetrics { + requests: Family, + histogram: Family, +} + +impl HttpMetrics { + pub fn new(registry: &mut Registry) -> Self { + let requests = Family::::default(); + let histogram = Family::::new_with_constructor(|| { + Histogram::new(linear_buckets(0.1, 0.1, 10)) + }); + + registry.register( + "http_request_count", + "Number of HTTP requests received, labeled by method and status", + requests.clone(), + ); + + registry.register( + "http_request_duration_seconds", + "Duration of HTTP requests, labeled by method and status", + histogram.clone(), + ); + + Self { requests, histogram } + } + + pub fn increment_request_count(&self, label:&HttpLabel) { + self.requests.get_or_create(label).inc(); + } + + pub fn observe_duration(&self, label:&HttpLabel, duration: f64,) { + self.histogram.get_or_create(label).observe(duration); + } +} diff --git a/src/metrics/manager.rs b/src/metrics/manager.rs new file mode 100644 index 0000000..d0fef5a --- /dev/null +++ b/src/metrics/manager.rs @@ -0,0 +1,20 @@ +use crate::metrics::http_metrics::HttpMetrics; +use crate::metrics::system_metrics::SystemMetrics; +use prometheus_client::registry::Registry; +use std::sync::{Arc, Mutex}; + +#[derive(Clone)] +pub struct MetricsManager { + pub registry: Arc>, + pub system_metrics: Arc, + pub http_metrics: Arc, +} + +impl MetricsManager { + pub fn new() -> Self { + let registry = Arc::new(Mutex::new(Registry::default())); + let system_metrics = Arc::new(SystemMetrics::new(&mut registry.lock().unwrap())); + let http_metrics = Arc::new(HttpMetrics::new(&mut registry.lock().unwrap())); + MetricsManager { registry, system_metrics, http_metrics } + } +} diff --git a/src/metrics/middleware.rs b/src/metrics/middleware.rs new file mode 100644 index 0000000..745f470 --- /dev/null +++ b/src/metrics/middleware.rs @@ -0,0 +1,41 @@ +use std::{sync::{Arc, RwLock}, time::Instant}; + +use actix_web::{ + body::MessageBody, + dev::{ServiceRequest, ServiceResponse}, + http::Method, + middleware::Next, + web::Data, + Error, +}; +use crate::metrics::http_metrics::HttpLabel; + +use super::{http_metrics::MetricsMethod, manager::MetricsManager}; + +pub async fn metrics_midleware( + req: ServiceRequest, + next: Next, +) -> Result, Error> { + let start_time = Instant::now(); + let path = req.path().to_string(); + let method = match *req.method() { + Method::GET => MetricsMethod::GET, + Method::POST => MetricsMethod::POST, + Method::PUT => MetricsMethod::PUT, + Method::DELETE => MetricsMethod::DELETE, + _ => MetricsMethod::OTHER, + }; + + let res = next.call(req).await?; + + let status = res.status().as_u16(); + let label = HttpLabel{path, method, status}; + if let Some(m) = res.request().app_data::>>>(){ + let metrics_manager = m.read().unwrap(); + metrics_manager.http_metrics.increment_request_count(&label); + let duration = start_time.elapsed().as_secs_f64(); + metrics_manager.http_metrics.observe_duration(&label, duration); + } + + Ok(res) +} diff --git a/src/metrics/mod.rs b/src/metrics/mod.rs new file mode 100644 index 0000000..949db54 --- /dev/null +++ b/src/metrics/mod.rs @@ -0,0 +1,8 @@ +//! The `rusty_vault::metriccs` is a module that utilize Prometheus to capture system metrics defines 'backend' and relevant data +//! defines 'manager' and relevant data structures such as `SystemMetrics` and `HttpMetrics` +//! +//! The 'manager' holds the Prometheus registry +pub mod middleware; +pub mod manager; +pub mod system_metrics; +pub mod http_metrics; \ No newline at end of file diff --git a/src/metrics/system_metrics.rs b/src/metrics/system_metrics.rs new file mode 100644 index 0000000..2574b90 --- /dev/null +++ b/src/metrics/system_metrics.rs @@ -0,0 +1,96 @@ +use std::sync::{atomic::AtomicU64, Arc, Mutex}; +use prometheus_client::metrics::gauge::Gauge; +use prometheus_client::registry::Registry; +use sysinfo::{Disks, Networks, System}; +use tokio::time::{self, Duration}; + +pub struct SystemMetrics { + system: Arc>, + cpu_usage: Gauge, + total_memory: Gauge, + used_memory: Gauge, + free_memory: Gauge, + total_disk_available: Gauge, + total_disk_space: Gauge, + network_in: Gauge, + network_out: Gauge, + load_avg: Gauge, +} + +impl SystemMetrics { + pub fn new(registry: &mut Registry) -> Self { + let cpu_usage = Gauge::::default(); + + let total_memory = Gauge::::default(); + let used_memory = Gauge::::default(); + let free_memory = Gauge::::default(); + + let total_disk_space = Gauge::::default(); + let total_disk_available = Gauge::::default(); + + let network_in = Gauge::::default(); + let network_out = Gauge::::default(); + let load_avg = Gauge::::default(); + + registry.register("cpu_usage_percent", "CPU usage percent", cpu_usage.clone()); + + registry.register("total_memory", "Total memory", total_memory.clone()); + registry.register("used_memory", "Used memory", used_memory.clone()); + registry.register("free_memory", "Free memory", free_memory.clone()); + + registry.register("total_disk_space", "Total disk space", total_disk_space.clone()); + registry.register("total_disk_available", "Total disk available", total_disk_available.clone()); + + registry.register("network_in_bytes", "Incoming network traffic in bytes", network_in.clone()); + registry.register("network_out_bytes", "Outgoing network traffic in bytes", network_out.clone()); + + registry.register("load_average", "System load average", load_avg.clone()); + + let system = Arc::new(Mutex::new(System::new_all())); + + Self { system, cpu_usage, total_memory, used_memory, free_memory, total_disk_available, total_disk_space, network_in, network_out, load_avg } + } + + pub async fn start_collecting(self: Arc) { + let mut interval = time::interval(Duration::from_secs(5)); + + loop { + interval.tick().await; + self.collect_metrics(); + } + } + + fn collect_metrics(&self) { + let mut sys = self.system.lock().unwrap(); + sys.refresh_all(); + + self.cpu_usage.set(sys.global_cpu_usage() as f64); + + self.total_memory.set(sys.total_memory() as f64); + self.used_memory.set(sys.used_memory() as f64); + self.free_memory.set(sys.free_memory() as f64); + + let mut total_available_space = 0; + let mut total_disk_space = 0; + + for disk in Disks::new_with_refreshed_list().list() { + total_available_space += disk.available_space(); + total_disk_space += disk.total_space(); + } + self.total_disk_available.set(total_available_space as f64); + self.total_disk_space.set(total_disk_space as f64); + + let mut total_network_in = 0; + let mut total_network_out = 0; + + for (_, n) in Networks::new_with_refreshed_list().list() { + total_network_in += n.received(); + total_network_out += n.transmitted(); + } + + self.network_in.set(total_network_in as f64); + self.network_out.set(total_network_out as f64); + + self.load_avg.set(System::load_average().one as f64); + } +} From 0650b99d0f3a2c787542b5d72556163a41c25f37 Mon Sep 17 00:00:00 2001 From: Yingjie Shang Date: Wed, 18 Sep 2024 12:13:58 +0800 Subject: [PATCH 2/7] Format server.rs and http_metrics.rs --- src/cli/command/server.rs | 13 ++++++++++--- src/metrics/http_metrics.rs | 9 ++++----- 2 files changed, 14 insertions(+), 8 deletions(-) diff --git a/src/cli/command/server.rs b/src/cli/command/server.rs index 515b9f3..592fbf2 100644 --- a/src/cli/command/server.rs +++ b/src/cli/command/server.rs @@ -7,7 +7,10 @@ use std::{ sync::{Arc, RwLock}, }; -use actix_web::{middleware::{self, from_fn}, web, App, HttpResponse, HttpServer}; +use actix_web::{ + middleware::{self, from_fn}, + web, App, HttpResponse, HttpServer, +}; use anyhow::format_err; use clap::ArgMatches; use openssl::{ @@ -17,7 +20,12 @@ use openssl::{ use sysexits::ExitCode; use crate::{ - cli::config, core::Core, errors::RvError, http, metrics::{manager::MetricsManager, middleware::metrics_midleware}, storage, EXIT_CODE_INSUFFICIENT_PARAMS, EXIT_CODE_LOAD_CONFIG_FAILURE, EXIT_CODE_OK + cli::config, + core::Core, + errors::RvError, + http, + metrics::{manager::MetricsManager, middleware::metrics_midleware}, + storage, EXIT_CODE_INSUFFICIENT_PARAMS, EXIT_CODE_LOAD_CONFIG_FAILURE, EXIT_CODE_OK, }; pub const WORK_DIR_PATH_DEFAULT: &str = "/tmp/rusty_vault"; @@ -111,7 +119,6 @@ pub fn main(config_path: &str) -> Result<(), RvError> { let metrics_manager = Arc::new(RwLock::new(MetricsManager::new())); let system_metrics = Arc::clone(&metrics_manager.read().unwrap().system_metrics); - let core = Arc::new(RwLock::new(Core { physical: backend, barrier: Arc::new(barrier), diff --git a/src/metrics/http_metrics.rs b/src/metrics/http_metrics.rs index a5926ba..c0f4a94 100644 --- a/src/metrics/http_metrics.rs +++ b/src/metrics/http_metrics.rs @@ -43,9 +43,8 @@ pub struct HttpMetrics { impl HttpMetrics { pub fn new(registry: &mut Registry) -> Self { let requests = Family::::default(); - let histogram = Family::::new_with_constructor(|| { - Histogram::new(linear_buckets(0.1, 0.1, 10)) - }); + let histogram = + Family::::new_with_constructor(|| Histogram::new(linear_buckets(0.1, 0.1, 10))); registry.register( "http_request_count", @@ -62,11 +61,11 @@ impl HttpMetrics { Self { requests, histogram } } - pub fn increment_request_count(&self, label:&HttpLabel) { + pub fn increment_request_count(&self, label: &HttpLabel) { self.requests.get_or_create(label).inc(); } - pub fn observe_duration(&self, label:&HttpLabel, duration: f64,) { + pub fn observe_duration(&self, label: &HttpLabel, duration: f64) { self.histogram.get_or_create(label).observe(duration); } } From ed1043c4e8105b61c3c90069b98e18836d45693a Mon Sep 17 00:00:00 2001 From: Yingjie Shang Date: Wed, 18 Sep 2024 12:15:36 +0800 Subject: [PATCH 3/7] Replace eprintln! with log::error! --- src/http/metrics.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/http/metrics.rs b/src/http/metrics.rs index 382ffc0..c556d66 100644 --- a/src/http/metrics.rs +++ b/src/http/metrics.rs @@ -10,7 +10,7 @@ pub async fn metrics_handler(metrics_manager: web::Data Date: Thu, 19 Sep 2024 19:06:07 +0800 Subject: [PATCH 4/7] Add support for setting data collection interval from config file --- src/cli/command/server.rs | 2 +- src/cli/config.rs | 2 ++ src/metrics/manager.rs | 4 ++-- src/metrics/system_metrics.rs | 21 +++++++++++++++++---- 4 files changed, 22 insertions(+), 7 deletions(-) diff --git a/src/cli/command/server.rs b/src/cli/command/server.rs index 592fbf2..79afd09 100644 --- a/src/cli/command/server.rs +++ b/src/cli/command/server.rs @@ -116,7 +116,7 @@ pub fn main(config_path: &str) -> Result<(), RvError> { let barrier = storage::barrier_aes_gcm::AESGCMBarrier::new(Arc::clone(&backend)); - let metrics_manager = Arc::new(RwLock::new(MetricsManager::new())); + let metrics_manager = Arc::new(RwLock::new(MetricsManager::new(config.collection_interval))); let system_metrics = Arc::clone(&metrics_manager.read().unwrap().system_metrics); let core = Arc::new(RwLock::new(Core { diff --git a/src/cli/config.rs b/src/cli/config.rs index 6d701bf..f788ca2 100644 --- a/src/cli/config.rs +++ b/src/cli/config.rs @@ -36,6 +36,8 @@ pub struct Config { pub daemon_user: String, #[serde(default)] pub daemon_group: String, + #[serde(default)] + pub collection_interval: u64, } /// A struct that contains several configurable options for networking stuffs diff --git a/src/metrics/manager.rs b/src/metrics/manager.rs index d0fef5a..1fb285e 100644 --- a/src/metrics/manager.rs +++ b/src/metrics/manager.rs @@ -11,9 +11,9 @@ pub struct MetricsManager { } impl MetricsManager { - pub fn new() -> Self { + pub fn new(collection_interval: u64) -> Self { let registry = Arc::new(Mutex::new(Registry::default())); - let system_metrics = Arc::new(SystemMetrics::new(&mut registry.lock().unwrap())); + let system_metrics = Arc::new(SystemMetrics::new(&mut registry.lock().unwrap(), collection_interval)); let http_metrics = Arc::new(HttpMetrics::new(&mut registry.lock().unwrap())); MetricsManager { registry, system_metrics, http_metrics } } diff --git a/src/metrics/system_metrics.rs b/src/metrics/system_metrics.rs index 2574b90..5d5d60a 100644 --- a/src/metrics/system_metrics.rs +++ b/src/metrics/system_metrics.rs @@ -1,11 +1,12 @@ -use std::sync::{atomic::AtomicU64, Arc, Mutex}; use prometheus_client::metrics::gauge::Gauge; use prometheus_client::registry::Registry; +use std::sync::{atomic::AtomicU64, Arc, Mutex}; use sysinfo::{Disks, Networks, System}; use tokio::time::{self, Duration}; pub struct SystemMetrics { system: Arc>, + collection_interval: u64, cpu_usage: Gauge, total_memory: Gauge, used_memory: Gauge, @@ -18,7 +19,7 @@ pub struct SystemMetrics { } impl SystemMetrics { - pub fn new(registry: &mut Registry) -> Self { + pub fn new(registry: &mut Registry, collection_interval: u64) -> Self { let cpu_usage = Gauge::::default(); let total_memory = Gauge::::default(); @@ -48,11 +49,23 @@ impl SystemMetrics { let system = Arc::new(Mutex::new(System::new_all())); - Self { system, cpu_usage, total_memory, used_memory, free_memory, total_disk_available, total_disk_space, network_in, network_out, load_avg } + Self { + system, + collection_interval, + cpu_usage, + total_memory, + used_memory, + free_memory, + total_disk_available, + total_disk_space, + network_in, + network_out, + load_avg, + } } pub async fn start_collecting(self: Arc) { - let mut interval = time::interval(Duration::from_secs(5)); + let mut interval = time::interval(Duration::from_secs(self.collection_interval)); loop { interval.tick().await; From 0e64a284029036b55d0a3ea33d8dd675a8eea18f Mon Sep 17 00:00:00 2001 From: Yingjie Shang Date: Thu, 19 Sep 2024 19:17:51 +0800 Subject: [PATCH 5/7] Add LIST operation to http metrics. --- src/metrics/http_metrics.rs | 2 ++ 1 file changed, 2 insertions(+) diff --git a/src/metrics/http_metrics.rs b/src/metrics/http_metrics.rs index c0f4a94..287f51a 100644 --- a/src/metrics/http_metrics.rs +++ b/src/metrics/http_metrics.rs @@ -12,6 +12,7 @@ pub enum MetricsMethod { POST, PUT, DELETE, + LIST, OTHER, } @@ -22,6 +23,7 @@ impl EncodeLabelValue for MetricsMethod { MetricsMethod::POST => writer.write_str("post"), MetricsMethod::PUT => writer.write_str("put"), MetricsMethod::DELETE => writer.write_str("delete"), + MetricsMethod::LIST => writer.write_str("list"), MetricsMethod::OTHER => writer.write_str("other"), } } From fd29cf33da38d5f3d5cdeb40adb99a13c0a136a3 Mon Sep 17 00:00:00 2001 From: Yingjie Shang Date: Mon, 23 Sep 2024 15:06:55 +0800 Subject: [PATCH 6/7] Add default value to collection_interval. --- src/cli/config.rs | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/src/cli/config.rs b/src/cli/config.rs index f788ca2..af1f122 100644 --- a/src/cli/config.rs +++ b/src/cli/config.rs @@ -36,10 +36,14 @@ pub struct Config { pub daemon_user: String, #[serde(default)] pub daemon_group: String, - #[serde(default)] + #[serde(default = "default_collection_interval")] pub collection_interval: u64, } +fn default_collection_interval() -> u64 { + 15 +} + /// A struct that contains several configurable options for networking stuffs #[derive(Debug, Clone, Serialize, Deserialize)] pub struct Listener { From 7fcceb843ad55b65f18020336ee7265566a37a87 Mon Sep 17 00:00:00 2001 From: Yingjie Shang Date: Mon, 23 Sep 2024 16:08:29 +0800 Subject: [PATCH 7/7] Add LIST operation in metrics middleware. --- src/metrics/middleware.rs | 1 + 1 file changed, 1 insertion(+) diff --git a/src/metrics/middleware.rs b/src/metrics/middleware.rs index 745f470..a4b59c8 100644 --- a/src/metrics/middleware.rs +++ b/src/metrics/middleware.rs @@ -20,6 +20,7 @@ pub async fn metrics_midleware( let path = req.path().to_string(); let method = match *req.method() { Method::GET => MetricsMethod::GET, + _ if req.method().to_string() == "LIST" => MetricsMethod::LIST, Method::POST => MetricsMethod::POST, Method::PUT => MetricsMethod::PUT, Method::DELETE => MetricsMethod::DELETE,