#[cfg(feature = "metrics-prometheus")]
use std::time::Duration;
#[cfg(feature = "metrics-prometheus")]
#[derive(Clone)]
pub struct AccountMetrics {
credential_verify_duration: prometheus::HistogramVec,
policy_validate_duration: prometheus::HistogramVec,
lockout_triggered_total: prometheus::CounterVec,
authflow_execute_duration: prometheus::HistogramVec,
}
#[cfg(feature = "metrics-prometheus")]
impl AccountMetrics {
pub fn new() -> Self {
use std::sync::OnceLock;
static INSTANCE: OnceLock<AccountMetrics> = OnceLock::new();
INSTANCE.get_or_init(Self::init_default).clone()
}
fn init_default() -> Self {
match Self::register_to(prometheus::default_registry()) {
Ok(m) => m,
Err(e) => {
tracing::warn!(
error = %e,
"{}",
crate::i18n::translate_detail(
"logs-metrics-already-registered",
&[("arg0", "AccountMetrics")]
)
);
Self::build().expect("AccountMetrics: static metric opts are valid (unreachable)")
},
}
}
pub fn register_to(registry: &prometheus::Registry) -> Result<Self, prometheus::Error> {
let metrics = Self::build()?;
registry.register(Box::new(metrics.credential_verify_duration.clone()))?;
registry.register(Box::new(metrics.policy_validate_duration.clone()))?;
registry.register(Box::new(metrics.lockout_triggered_total.clone()))?;
registry.register(Box::new(metrics.authflow_execute_duration.clone()))?;
Ok(metrics)
}
fn build() -> Result<Self, prometheus::Error> {
let buckets = vec![0.001, 0.005, 0.01, 0.05, 0.1, 0.5, 1.0, 5.0];
let credential_verify_duration = prometheus::HistogramVec::new(
prometheus::HistogramOpts::new(
"garrison_credential_verify_duration_seconds",
"Credential verify duration in seconds",
)
.buckets(buckets.clone()),
&["credential_type"],
)?;
let policy_validate_duration = prometheus::HistogramVec::new(
prometheus::HistogramOpts::new(
"garrison_policy_validate_duration_seconds",
"Password policy rule validate duration in seconds",
)
.buckets(buckets.clone()),
&["rule_name"],
)?;
let lockout_triggered_total = prometheus::CounterVec::new(
prometheus::Opts::new(
"garrison_lockout_triggered_total",
"Total number of lockout triggered (temporary|permanent)",
),
&["lockout_type"],
)?;
let authflow_execute_duration = prometheus::HistogramVec::new(
prometheus::HistogramOpts::new(
"garrison_authflow_execute_duration_seconds",
"Authentication flow execute duration in seconds",
)
.buckets(buckets),
&["flow_name"],
)?;
Ok(Self {
credential_verify_duration,
policy_validate_duration,
lockout_triggered_total,
authflow_execute_duration,
})
}
pub fn observe_credential_verify(&self, credential_type: &str, duration: Duration) {
self.credential_verify_duration
.with_label_values(&[credential_type])
.observe(duration.as_secs_f64());
}
pub fn observe_policy_validate(&self, rule_name: &str, duration: Duration) {
self.policy_validate_duration
.with_label_values(&[rule_name])
.observe(duration.as_secs_f64());
}
pub fn record_lockout(&self, permanent: bool) {
let label = if permanent { "permanent" } else { "temporary" };
self.lockout_triggered_total
.with_label_values(&[label])
.inc();
}
pub fn observe_authflow_execute(&self, flow_name: &str, duration: Duration) {
self.authflow_execute_duration
.with_label_values(&[flow_name])
.observe(duration.as_secs_f64());
}
pub fn gather(&self) -> String {
use prometheus::core::Collector;
use prometheus::Encoder;
let mut metric_families = Vec::new();
metric_families.extend(self.credential_verify_duration.collect());
metric_families.extend(self.policy_validate_duration.collect());
metric_families.extend(self.lockout_triggered_total.collect());
metric_families.extend(self.authflow_execute_duration.collect());
let mut buffer = Vec::new();
let encoder = prometheus::TextEncoder::new();
match encoder.encode(&metric_families, &mut buffer) {
Ok(()) => String::from_utf8_lossy(&buffer).into_owned(),
Err(e) => {
tracing::warn!(error = %e, "AccountMetrics::gather prometheus encode failed");
format!("# garrison account-metrics gather encode failed: {e}")
},
}
}
}
#[cfg(feature = "metrics-prometheus")]
impl Default for AccountMetrics {
fn default() -> Self {
Self::new()
}
}
#[cfg(feature = "metrics-prometheus")]
impl std::fmt::Debug for AccountMetrics {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("AccountMetrics")
.field("credential_verify_duration", &"HistogramVec")
.field("policy_validate_duration", &"HistogramVec")
.field("lockout_triggered_total", &"CounterVec")
.field("authflow_execute_duration", &"HistogramVec")
.finish()
}
}
#[cfg(not(feature = "metrics-prometheus"))]
pub type AccountMetrics = ();
#[cfg(all(test, feature = "metrics-prometheus"))]
mod tests {
use super::*;
use serial_test::serial;
#[test]
#[serial]
fn account_metrics_register_to_custom_registry() {
let registry = prometheus::Registry::new();
let metrics = AccountMetrics::register_to(®istry).expect("注册到自定义 registry 失败");
metrics.observe_credential_verify("password", Duration::from_millis(1));
metrics.observe_policy_validate("length", Duration::from_millis(1));
metrics.record_lockout(false);
metrics.observe_authflow_execute("login", Duration::from_millis(1));
let gathered = prometheus::TextEncoder::new()
.encode_to_string(®istry.gather())
.expect("encode 失败");
assert!(
gathered.contains("garrison_credential_verify_duration_seconds"),
"missing credential_verify_duration: {}",
gathered
);
assert!(
gathered.contains("garrison_policy_validate_duration_seconds"),
"missing policy_validate_duration: {}",
gathered
);
assert!(
gathered.contains("garrison_lockout_triggered_total"),
"missing lockout_triggered_total: {}",
gathered
);
assert!(
gathered.contains("garrison_authflow_execute_duration_seconds"),
"missing authflow_execute_duration: {}",
gathered
);
}
#[test]
#[serial]
fn credential_verify_duration_registered_and_observed() {
let registry = prometheus::Registry::new();
let metrics = AccountMetrics::register_to(®istry).unwrap();
metrics.observe_credential_verify("password", Duration::from_millis(5));
metrics.observe_credential_verify("password", Duration::from_millis(10));
metrics.observe_credential_verify("totp", Duration::from_millis(3));
let output = prometheus::TextEncoder::new()
.encode_to_string(®istry.gather())
.unwrap();
assert!(
output.contains("garrison_credential_verify_duration_seconds"),
"missing metric name: {}",
output
);
assert!(
output.contains("credential_type=\"password\""),
"missing password label: {}",
output
);
assert!(
output.contains("credential_type=\"totp\""),
"missing totp label: {}",
output
);
assert!(
output.contains(
"garrison_credential_verify_duration_seconds_count{credential_type=\"password\"} 2"
),
"password count should be 2: {}",
output
);
}
#[test]
#[serial]
fn policy_validate_duration_registered_and_observed() {
let registry = prometheus::Registry::new();
let metrics = AccountMetrics::register_to(®istry).unwrap();
metrics.observe_policy_validate("length", Duration::from_millis(2));
metrics.observe_policy_validate("complexity", Duration::from_millis(4));
let output = prometheus::TextEncoder::new()
.encode_to_string(®istry.gather())
.unwrap();
assert!(
output.contains("garrison_policy_validate_duration_seconds"),
"missing metric name: {}",
output
);
assert!(
output.contains("rule_name=\"length\""),
"missing length label: {}",
output
);
assert!(
output.contains("rule_name=\"complexity\""),
"missing complexity label: {}",
output
);
assert!(
output.contains(
"garrison_policy_validate_duration_seconds_count{rule_name=\"length\"} 1"
),
"length count should be 1: {}",
output
);
}
#[test]
#[serial]
fn lockout_triggered_total_registered_and_recorded() {
let registry = prometheus::Registry::new();
let metrics = AccountMetrics::register_to(®istry).unwrap();
metrics.record_lockout(false); metrics.record_lockout(false); metrics.record_lockout(true);
let output = prometheus::TextEncoder::new()
.encode_to_string(®istry.gather())
.unwrap();
assert!(
output.contains("garrison_lockout_triggered_total"),
"missing metric name: {}",
output
);
assert!(
output.contains("lockout_type=\"temporary\""),
"missing temporary label: {}",
output
);
assert!(
output.contains("lockout_type=\"permanent\""),
"missing permanent label: {}",
output
);
assert!(
output.contains("garrison_lockout_triggered_total{lockout_type=\"temporary\"} 2"),
"temporary count should be 2: {}",
output
);
assert!(
output.contains("garrison_lockout_triggered_total{lockout_type=\"permanent\"} 1"),
"permanent count should be 1: {}",
output
);
}
#[test]
#[serial]
fn authflow_execute_duration_registered_and_observed() {
let registry = prometheus::Registry::new();
let metrics = AccountMetrics::register_to(®istry).unwrap();
metrics.observe_authflow_execute("login", Duration::from_millis(50));
metrics.observe_authflow_execute("mfa", Duration::from_millis(20));
let output = prometheus::TextEncoder::new()
.encode_to_string(®istry.gather())
.unwrap();
assert!(
output.contains("garrison_authflow_execute_duration_seconds"),
"missing metric name: {}",
output
);
assert!(
output.contains("flow_name=\"login\""),
"missing login label: {}",
output
);
assert!(
output.contains("flow_name=\"mfa\""),
"missing mfa label: {}",
output
);
assert!(
output.contains(
"garrison_authflow_execute_duration_seconds_count{flow_name=\"login\"} 1"
),
"login count should be 1: {}",
output
);
}
#[test]
#[serial]
fn duplicate_register_returns_already_reg_error() {
let registry = prometheus::Registry::new();
let _m1 = AccountMetrics::register_to(®istry).expect("首次注册失败");
let result = AccountMetrics::register_to(®istry);
assert!(result.is_err(), "重复注册应返回错误");
match result {
Err(prometheus::Error::AlreadyReg) => {},
Err(e) => panic!("期望 AlreadyReg 错误,实际: {:?}", e),
Ok(_) => panic!("期望错误,实际成功"),
}
}
#[test]
#[serial]
fn account_metrics_clone_shared_underlying_state() {
let registry = prometheus::Registry::new();
let m1 = AccountMetrics::register_to(®istry).expect("注册失败");
let m2 = m1.clone();
m1.record_lockout(false);
m2.record_lockout(false);
let output = prometheus::TextEncoder::new()
.encode_to_string(®istry.gather())
.unwrap();
assert!(
output.contains("garrison_lockout_triggered_total{lockout_type=\"temporary\"} 2"),
"clone 应共享底层 Counter: {}",
output
);
}
#[test]
#[serial]
fn account_metrics_debug_impl() {
let registry = prometheus::Registry::new();
let metrics = AccountMetrics::register_to(®istry).expect("注册失败");
let debug_str = format!("{:?}", metrics);
assert!(debug_str.contains("AccountMetrics"));
assert!(debug_str.contains("HistogramVec"));
assert!(debug_str.contains("CounterVec"));
}
#[test]
#[serial]
fn gather_returns_non_empty_string() {
let registry = prometheus::Registry::new();
let metrics = AccountMetrics::register_to(®istry).expect("注册失败");
metrics.observe_credential_verify("password", std::time::Duration::from_millis(10));
let output = metrics.gather();
assert!(!output.is_empty(), "gather() 应返回非空字符串");
}
#[test]
#[serial]
fn default_creates_instance() {
let metrics = AccountMetrics::default();
metrics.observe_authflow_execute("test_flow", std::time::Duration::from_micros(100));
}
}
#[cfg(all(test, not(feature = "metrics-prometheus")))]
mod tests_no_feature {
use super::*;
#[test]
fn no_feature_account_metrics_is_unit() {
let _: AccountMetrics = ();
}
}