use crate::credit::config::CreditConfig;
use crate::credit::error::{CreditConsumeResult, CreditError, CreditResult, CreditUsage};
#[cfg(feature = "metrics-prometheus")]
use crate::credit::metrics::CreditMetrics;
use crate::credit::storage::{CreditMeta, CreditMeterStorage};
#[cfg(any(feature = "db-sqlite", feature = "db-postgres", feature = "db-mysql"))]
use crate::credit::throttle::ActivityWriteThrottle;
#[cfg(any(feature = "db-sqlite", feature = "db-postgres", feature = "db-mysql"))]
use crate::credit::CreditConsumptionRecord;
use crate::dao::GarrisonDao;
use chrono::Utc;
use parking_lot::RwLock;
use std::sync::Arc;
pub struct CreditMeter {
dao: Arc<dyn GarrisonDao>,
config: Arc<RwLock<CreditConfig>>,
storage: CreditMeterStorage,
#[cfg(any(feature = "db-sqlite", feature = "db-postgres", feature = "db-mysql"))]
activity_throttle: Option<Arc<ActivityWriteThrottle<PersistContext>>>,
#[cfg(any(feature = "db-sqlite", feature = "db-postgres", feature = "db-mysql"))]
flush_loop_started: std::sync::atomic::AtomicBool,
#[cfg(feature = "listener")]
listener_manager: Option<Arc<crate::listener::GarrisonListenerManager>>,
#[cfg(feature = "metrics-prometheus")]
metrics: Option<Arc<CreditMetrics>>,
}
#[cfg(any(feature = "db-sqlite", feature = "db-postgres", feature = "db-mysql"))]
pub struct PersistContext {
pub(crate) dao: Arc<dyn GarrisonDao>,
pub(crate) tenant_id: i64,
pub(crate) resource: String,
pub(crate) cost: u64,
pub(crate) credits: u64,
pub(crate) total_consumed: u64,
pub(crate) cycle_start: i64,
}
#[cfg(any(feature = "db-sqlite", feature = "db-postgres", feature = "db-mysql"))]
impl std::fmt::Display for PersistContext {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(f, "tenant:{}::resource:{}", self.tenant_id, self.resource)
}
}
#[cfg(any(feature = "db-sqlite", feature = "db-postgres", feature = "db-mysql"))]
async fn activity_persist_write(
_key: String,
ctx: PersistContext,
) -> crate::error::GarrisonResult<()> {
ctx.dao
.insert_credit_consumption(
ctx.tenant_id,
&ctx.resource,
ctx.cost,
ctx.credits,
ctx.total_consumed,
ctx.cycle_start,
)
.await
}
impl CreditMeter {
pub fn new(dao: Arc<dyn GarrisonDao>, config: CreditConfig) -> Self {
let storage = CreditMeterStorage::new(dao.clone());
Self {
dao,
config: Arc::new(RwLock::new(config)),
storage,
#[cfg(any(feature = "db-sqlite", feature = "db-postgres", feature = "db-mysql"))]
activity_throttle: Some(Arc::new(ActivityWriteThrottle::new())),
#[cfg(any(feature = "db-sqlite", feature = "db-postgres", feature = "db-mysql"))]
flush_loop_started: std::sync::atomic::AtomicBool::new(false),
#[cfg(feature = "listener")]
listener_manager: None,
#[cfg(feature = "metrics-prometheus")]
metrics: None,
}
}
#[cfg(any(feature = "db-sqlite", feature = "db-postgres", feature = "db-mysql"))]
pub fn with_activity_throttle(
mut self,
throttle: Arc<ActivityWriteThrottle<PersistContext>>,
) -> Self {
self.activity_throttle = Some(throttle);
self
}
#[cfg(any(feature = "db-sqlite", feature = "db-postgres", feature = "db-mysql"))]
pub fn without_activity_throttle(mut self) -> Self {
self.activity_throttle = None;
self
}
#[cfg(any(feature = "db-sqlite", feature = "db-postgres", feature = "db-mysql"))]
pub fn spawn_activity_flush_loop(&self) -> bool {
let Some(throttle) = &self.activity_throttle else {
return false;
};
use std::sync::atomic::Ordering;
if self
.flush_loop_started
.compare_exchange(false, true, Ordering::AcqRel, Ordering::Acquire)
.is_err()
{
return false;
}
tokio::spawn({
let throttle = throttle.clone();
async move {
throttle.run_flush_loop(activity_persist_write).await;
}
});
true
}
#[cfg(any(feature = "db-sqlite", feature = "db-postgres", feature = "db-mysql"))]
pub fn activity_pending(&self) -> usize {
self.activity_throttle
.as_ref()
.map_or(0, |t| t.pending_len())
}
#[cfg(feature = "listener")]
pub fn with_listener_manager(
mut self,
lm: Arc<crate::listener::GarrisonListenerManager>,
) -> Self {
self.listener_manager = Some(lm);
self
}
#[cfg(feature = "metrics-prometheus")]
pub fn with_metrics(mut self, metrics: Arc<CreditMetrics>) -> Self {
self.metrics = Some(metrics);
self
}
pub async fn consume_credit(
&self,
tenant_id: i64,
resource: &str,
cost: u64,
) -> CreditResult<CreditConsumeResult> {
let config = self.config.read().clone();
let weight = config.schedule.weight_for(resource);
let credits = cost.checked_mul(weight).ok_or_else(|| {
CreditError::ConfigInvalid(format!(
"credit-credits-overflow::cost={}::weight={}",
cost, weight
))
})?;
self.check_and_reset_cycle(tenant_id).await?;
let now = Utc::now().naive_utc();
let window_start = self.storage.get_window_start(tenant_id).await?;
let cycle_end = config.cycle.cycle_end(window_start, now);
let ttl = (cycle_end - now.and_utc().timestamp()).max(1) as u64;
let denied_cycle_reset_at = cycle_end;
let credit_limit = config.credit_limit;
let current = self.storage.get_consumed(tenant_id).await?.unwrap_or(0);
if credit_limit != 0 && current.saturating_add(credits) > credit_limit {
return Ok(Self::denied_result(
credit_limit,
current,
credits,
denied_cycle_reset_at,
));
}
let new_count = if credits == 0 {
current
} else {
let n = self.storage.incr_consumed(tenant_id, credits, ttl).await?;
if credit_limit != 0 && n > credit_limit {
tracing::warn!(
tenant_id,
resource,
credits,
new_count = n,
credit_limit,
"{}",
crate::i18n::translate_detail(
"logs-credit-concurrent-over-limit-rollback",
&[]
)
);
self.storage.decr_consumed(tenant_id, credits).await;
return Ok(Self::denied_result(
credit_limit,
n.saturating_sub(credits),
credits,
denied_cycle_reset_at,
));
}
n
};
let allowed = credit_limit == 0 || new_count <= credit_limit;
let remaining = credit_limit.saturating_sub(new_count);
let usage_percent = if credit_limit == 0 {
0.0
} else {
(new_count as f64 / credit_limit as f64) * 100.0
};
let alerts_triggered: Vec<u8> = config
.alert_thresholds
.iter()
.filter(|&&t| usage_percent >= t as f64)
.copied()
.collect();
let actual_window_start = match &config.cycle {
crate::credit::cycle::CreditCycle::Rolling { .. } => {
match self.storage.get_window_start(tenant_id).await? {
Some(ts) => ts,
None => {
let ts = now.and_utc().timestamp();
self.storage.set_window_start(tenant_id, ts, ttl).await?;
ts
},
}
},
_ => config.cycle.cycle_start(window_start, now),
};
let cycle_reset_at = config.cycle.cycle_end(
match &config.cycle {
crate::credit::cycle::CreditCycle::Rolling { .. } => Some(actual_window_start),
_ => None,
},
now,
);
let meta = CreditMeta {
consumed: new_count,
limit: credit_limit,
window_start: actual_window_start,
window_end: cycle_reset_at,
cycle: config.cycle.clone(),
};
self.storage.set_meta(tenant_id, &meta, ttl).await?;
#[cfg(feature = "listener")]
self.broadcast_consumed_event(tenant_id, resource, cost, credits, new_count);
#[cfg(feature = "listener")]
for &threshold in &alerts_triggered {
self.broadcast_alert_event(
tenant_id,
threshold,
usage_percent,
new_count,
credit_limit,
);
}
#[cfg(feature = "metrics-prometheus")]
if let Some(ref metrics) = self.metrics {
let tid = tenant_id.to_string();
metrics.record_consumed(&tid, resource, credits);
metrics.set_remaining(&tid, remaining);
for &threshold in &alerts_triggered {
metrics.record_alert(&tid, threshold);
}
}
#[cfg(any(feature = "db-sqlite", feature = "db-postgres", feature = "db-mysql"))]
if config.persist_history {
match &self.activity_throttle {
Some(throttle) => {
let key = format!("{}:{}", tenant_id, resource);
throttle.record(
&key,
PersistContext {
dao: self.dao.clone(),
tenant_id,
resource: resource.to_string(),
cost,
credits,
total_consumed: new_count,
cycle_start: actual_window_start,
},
);
self.spawn_activity_flush_loop();
},
None => {
let dao = self.dao.clone();
let res = resource.to_string();
let cycle_start = actual_window_start;
tokio::spawn(async move {
if let Err(e) = dao
.insert_credit_consumption(
tenant_id,
&res,
cost,
credits,
new_count,
cycle_start,
)
.await
{
tracing::warn!(
tenant_id,
resource = %res,
error = %e,
"credit: async persist consumption record failed"
);
}
});
},
}
}
Ok(CreditConsumeResult {
allowed,
consumed_credits: credits,
total_consumed: new_count,
remaining,
usage_percent,
alerts_triggered,
cycle_reset_at,
})
}
fn denied_result(
credit_limit: u64,
consumed: u64,
credits: u64,
cycle_reset_at: i64,
) -> CreditConsumeResult {
let remaining = credit_limit.saturating_sub(consumed);
let usage_percent = if credit_limit == 0 {
0.0
} else {
(consumed as f64 / credit_limit as f64) * 100.0
};
CreditConsumeResult {
allowed: false,
consumed_credits: credits,
total_consumed: consumed,
remaining,
usage_percent,
alerts_triggered: Vec::new(),
cycle_reset_at,
}
}
pub async fn get_credit_usage(&self, tenant_id: i64) -> CreditResult<CreditUsage> {
let config = self.config.read().clone();
let now = Utc::now().naive_utc();
let consumed = self.storage.get_consumed(tenant_id).await?.unwrap_or(0);
let credit_limit = config.credit_limit;
let remaining = credit_limit.saturating_sub(consumed);
let usage_percent = if credit_limit == 0 {
0.0
} else {
(consumed as f64 / credit_limit as f64) * 100.0
};
let window_start = self.storage.get_window_start(tenant_id).await?;
let cycle_start = config.cycle.cycle_start(window_start, now);
let cycle_reset_at = config.cycle.cycle_end(window_start, now);
Ok(CreditUsage {
tenant_id,
consumed,
limit: credit_limit,
remaining,
usage_percent,
cycle_start,
cycle_reset_at,
cycle: config.cycle,
})
}
pub async fn reset_credit(&self, tenant_id: i64) -> CreditResult<()> {
self.storage.reset(tenant_id).await
}
pub async fn check_and_reset_cycle(&self, tenant_id: i64) -> CreditResult<bool> {
let config = self.config.read().clone();
let now = Utc::now().naive_utc();
let window_start = self.storage.get_window_start(tenant_id).await?;
if config.cycle.is_expired(window_start, now) {
self.storage.reset(tenant_id).await?;
if let crate::credit::cycle::CreditCycle::Rolling { .. } = &config.cycle {
let ws_key = format!("credit:{}:window_start", tenant_id);
if let Err(e) = self.dao.delete(&ws_key).await {
tracing::warn!(
tenant_id,
error = %e,
"{}",
crate::i18n::translate_detail(
"logs-credit-rolling-window-start-delete-failed",
&[]
)
);
}
}
Ok(true)
} else {
Ok(false)
}
}
#[cfg(any(feature = "db-sqlite", feature = "db-postgres", feature = "db-mysql"))]
pub async fn get_usage_history(
&self,
tenant_id: i64,
from_ts: i64,
to_ts: i64,
) -> CreditResult<Vec<CreditConsumptionRecord>> {
let records = self
.dao
.query_credit_consumption(tenant_id, from_ts, to_ts)
.await
.map_err(|e| CreditError::Dao(format!("credit-query-history::{}", e)))?;
Ok(records
.into_iter()
.map(|r| CreditConsumptionRecord {
tenant_id: r.0,
resource: r.1,
cost: r.2,
credits: r.3,
total_consumed: r.4,
cycle_start: r.5,
created_at: r.6,
})
.collect())
}
#[cfg(feature = "listener")]
fn broadcast_consumed_event(
&self,
tenant_id: i64,
resource: &str,
cost: u64,
credits: u64,
total_consumed: u64,
) {
if let Some(lm) = &self.listener_manager {
let event = crate::listener::GarrisonEvent::CreditConsumed {
tenant_id,
resource: resource.to_string(),
cost,
credits,
total_consumed,
request_context: None,
};
let lm = lm.clone();
tokio::spawn(async move {
lm.broadcast(&event).await;
});
}
}
#[cfg(feature = "listener")]
fn broadcast_alert_event(
&self,
tenant_id: i64,
threshold: u8,
usage_percent: f64,
total_consumed: u64,
credit_limit: u64,
) {
if let Some(lm) = &self.listener_manager {
let event = crate::listener::GarrisonEvent::CreditAlert {
tenant_id,
threshold,
usage_percent,
total_consumed,
credit_limit,
request_context: None,
};
let lm = lm.clone();
tokio::spawn(async move {
lm.broadcast(&event).await;
});
}
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::credit::config::CreditConfig;
use crate::credit::cycle::CreditCycle;
use crate::credit::schedule::CreditSchedule;
use crate::dao::tests::MockDao;
fn make_dao() -> Arc<dyn GarrisonDao> {
Arc::new(MockDao::new())
}
fn make_config(limit: u64) -> CreditConfig {
CreditConfig {
credit_limit: limit,
cycle: CreditCycle::Rolling { days: 30 },
schedule: CreditSchedule::default(),
alert_thresholds: vec![80, 90, 100],
persist_history: false,
}
}
#[tokio::test]
async fn test_consume_within_limit_allowed() {
let meter = CreditMeter::new(make_dao(), make_config(100));
let result = meter.consume_credit(42, "login", 5).await.unwrap();
assert!(result.allowed);
assert_eq!(result.consumed_credits, 5);
assert_eq!(result.total_consumed, 5);
assert_eq!(result.remaining, 95);
}
#[tokio::test]
async fn test_consume_exceeds_limit_denied() {
let meter = CreditMeter::new(make_dao(), make_config(10));
for _ in 0..10 {
let r = meter.consume_credit(42, "login", 1).await.unwrap();
assert!(r.allowed);
}
let result = meter.consume_credit(42, "login", 1).await.unwrap();
assert!(!result.allowed);
assert_eq!(result.remaining, 0);
}
#[tokio::test]
async fn test_consume_with_weight_schedule() {
let mut schedule = CreditSchedule::new();
schedule.insert("sms", 5).unwrap();
let config = CreditConfig {
credit_limit: 100,
cycle: CreditCycle::Rolling { days: 30 },
schedule,
alert_thresholds: vec![80],
persist_history: false,
};
let meter = CreditMeter::new(make_dao(), config);
let result = meter.consume_credit(42, "sms", 1).await.unwrap();
assert!(result.allowed);
assert_eq!(result.consumed_credits, 5);
assert_eq!(result.total_consumed, 5);
}
#[tokio::test]
async fn test_consume_triggers_alert_at_threshold() {
let meter = CreditMeter::new(make_dao(), make_config(10));
let result = meter.consume_credit(42, "login", 8).await.unwrap();
assert!(result.allowed);
assert!(
result.alerts_triggered.contains(&80),
"80% 应触发告警,alerts: {:?}",
result.alerts_triggered
);
}
#[tokio::test]
async fn test_consume_multiple_alert_thresholds() {
let meter = CreditMeter::new(make_dao(), make_config(10));
let result = meter.consume_credit(42, "login", 10).await.unwrap();
assert!(result.allowed);
assert!(result.alerts_triggered.contains(&80));
assert!(result.alerts_triggered.contains(&90));
assert!(result.alerts_triggered.contains(&100));
}
#[tokio::test]
async fn test_credit_limit_zero_unlimited() {
let meter = CreditMeter::new(make_dao(), make_config(0));
let result = meter.consume_credit(42, "login", 1000).await.unwrap();
assert!(result.allowed, "limit=0 应不限制");
}
#[tokio::test]
async fn test_get_credit_usage_returns_current_state() {
let meter = CreditMeter::new(make_dao(), make_config(100));
meter.consume_credit(42, "login", 10).await.unwrap();
let usage = meter.get_credit_usage(42).await.unwrap();
assert_eq!(usage.tenant_id, 42);
assert_eq!(usage.consumed, 10);
assert_eq!(usage.limit, 100);
assert_eq!(usage.remaining, 90);
}
#[tokio::test]
async fn test_reset_credit_clears_all() {
let meter = CreditMeter::new(make_dao(), make_config(100));
meter.consume_credit(42, "login", 50).await.unwrap();
meter.reset_credit(42).await.unwrap();
let usage = meter.get_credit_usage(42).await.unwrap();
assert_eq!(usage.consumed, 0);
}
#[tokio::test]
async fn test_consume_exactly_at_limit_allowed() {
let meter = CreditMeter::new(make_dao(), make_config(10));
let result = meter.consume_credit(42, "login", 10).await.unwrap();
assert!(result.allowed, "恰好到达限额应允许(<= 语义)");
assert_eq!(result.remaining, 0);
assert!((result.usage_percent - 100.0).abs() < f64::EPSILON);
}
#[tokio::test]
async fn test_consume_over_limit_usage_percent_and_remaining() {
let meter = CreditMeter::new(make_dao(), make_config(10));
meter.consume_credit(42, "login", 10).await.unwrap();
let result = meter.consume_credit(42, "login", 5).await.unwrap();
assert!(!result.allowed);
assert_eq!(result.remaining, 0, "remaining 应饱和为 0");
assert!(
(result.usage_percent - 100.0).abs() < f64::EPSILON,
"拒绝路径 usage 应基于已消费 10 → 100%,实际: {}",
result.usage_percent
);
assert_eq!(
result.total_consumed, 10,
"被拒绝的请求不应推高 total_consumed"
);
}
#[tokio::test]
async fn test_consume_denied_does_not_consume_quota() {
let meter = CreditMeter::new(make_dao(), make_config(10));
let r1 = meter.consume_credit(42, "login", 8).await.unwrap();
assert!(r1.allowed);
let denied = meter.consume_credit(42, "login", 5).await.unwrap();
assert!(!denied.allowed, "8+5 > 10 应拒绝");
assert_eq!(denied.remaining, 2, "拒绝路径 remaining 基于已消费 8 计算");
assert!(
(denied.usage_percent - 80.0).abs() < f64::EPSILON,
"拒绝路径 usage 应为 80%,实际: {}",
denied.usage_percent
);
assert!(denied.alerts_triggered.is_empty(), "拒绝路径不触发新告警");
let usage = meter.get_credit_usage(42).await.unwrap();
assert_eq!(usage.consumed, 8, "被拒绝的请求不应消耗配额");
let ok = meter.consume_credit(42, "login", 2).await.unwrap();
assert!(ok.allowed, "拒绝后剩余额度应可用");
assert_eq!(ok.total_consumed, 10);
}
#[tokio::test]
async fn test_consume_overflow_returns_config_invalid() {
let mut schedule = CreditSchedule::new();
schedule.insert("big", 2).unwrap();
let config = CreditConfig {
credit_limit: 100,
cycle: CreditCycle::Rolling { days: 30 },
schedule,
alert_thresholds: vec![80],
persist_history: false,
};
let meter = CreditMeter::new(make_dao(), config);
let result = meter.consume_credit(42, "big", u64::MAX).await;
let err = result.unwrap_err();
assert!(
format!("{}", err).contains("credit-credits-overflow"),
"溢出应返回 credit-credits-overflow 错误,实际: {}",
err
);
let usage = meter.get_credit_usage(42).await.unwrap();
assert_eq!(usage.consumed, 0, "溢出错误不应产生计数");
}
#[tokio::test]
async fn test_consume_zero_cost() {
let meter = CreditMeter::new(make_dao(), make_config(10));
let result = meter.consume_credit(42, "login", 0).await.unwrap();
assert!(result.allowed);
assert_eq!(result.consumed_credits, 0);
assert_eq!(result.total_consumed, 0);
assert_eq!(result.remaining, 10);
assert!(result.alerts_triggered.is_empty(), "0% 不应触发任何告警");
}
#[tokio::test]
async fn test_consume_unknown_resource_default_weight() {
let config = CreditConfig {
credit_limit: 10,
cycle: CreditCycle::Rolling { days: 30 },
schedule: CreditSchedule::new(),
alert_thresholds: vec![80],
persist_history: false,
};
let meter = CreditMeter::new(make_dao(), config);
let result = meter.consume_credit(42, "anything", 5).await.unwrap();
assert!(result.allowed);
assert_eq!(result.consumed_credits, 5, "默认权重 1 → credits=cost");
}
#[tokio::test]
async fn test_get_usage_limit_zero_usage_percent_zero() {
let meter = CreditMeter::new(make_dao(), make_config(0));
meter.consume_credit(42, "login", 1000).await.unwrap();
let usage = meter.get_credit_usage(42).await.unwrap();
assert_eq!(
usage.usage_percent, 0.0,
"limit=0 时 usage_percent 应为 0.0"
);
assert_eq!(usage.remaining, 0);
assert_eq!(usage.limit, 0);
}
#[tokio::test]
async fn test_get_credit_usage_fresh_tenant() {
let meter = CreditMeter::new(make_dao(), make_config(100));
let usage = meter.get_credit_usage(42).await.unwrap();
assert_eq!(usage.consumed, 0);
assert_eq!(usage.remaining, 100);
assert_eq!(usage.usage_percent, 0.0);
assert_eq!(usage.cycle, CreditCycle::Rolling { days: 30 });
}
#[tokio::test]
async fn test_consume_fixed_cycle_reset_at() {
let config = CreditConfig {
credit_limit: 100,
cycle: CreditCycle::Fixed { day_of_month: 15 },
schedule: CreditSchedule::default(),
alert_thresholds: vec![80],
persist_history: false,
};
let meter = CreditMeter::new(make_dao(), config);
let result = meter.consume_credit(42, "login", 1).await.unwrap();
let now_ts = Utc::now().timestamp();
assert!(
result.cycle_reset_at > now_ts,
"reset_at {} 应在未来(now {})",
result.cycle_reset_at,
now_ts
);
use chrono::TimeZone;
let reset = Utc.timestamp_opt(result.cycle_reset_at, 0).unwrap();
assert_eq!(chrono::Datelike::day(&reset), 15, "重置日应为配置的 15 号");
assert_eq!(
reset.time(),
chrono::NaiveTime::MIN,
"重置时间应为 00:00 UTC"
);
}
#[tokio::test]
async fn test_consume_rolling_cycle_reset_at() {
let meter = CreditMeter::new(make_dao(), make_config(100));
let result = meter.consume_credit(42, "login", 1).await.unwrap();
let window_start = meter
.storage
.get_window_start(42)
.await
.unwrap()
.expect("Rolling 首次消费应写入 window_start");
assert_eq!(result.cycle_reset_at, window_start + 30 * 86400);
}
#[tokio::test]
async fn test_check_and_reset_cycle_not_expired() {
let meter = CreditMeter::new(make_dao(), make_config(100));
meter.consume_credit(42, "login", 3).await.unwrap();
let reset = meter.check_and_reset_cycle(42).await.unwrap();
assert!(!reset, "未过期应返回 false");
let usage = meter.get_credit_usage(42).await.unwrap();
assert_eq!(usage.consumed, 3, "未过期不应清计数");
}
#[tokio::test]
async fn test_check_and_reset_cycle_expired() {
let meter = CreditMeter::new(make_dao(), make_config(100));
meter.consume_credit(42, "login", 3).await.unwrap();
let past = Utc::now().timestamp() - 31 * 86400;
meter
.storage
.set_window_start(42, past, 86400)
.await
.unwrap();
let reset = meter.check_and_reset_cycle(42).await.unwrap();
assert!(reset, "过期应返回 true");
assert!(
meter.storage.get_window_start(42).await.unwrap().is_none(),
"Rolling 过期重置应删除 window_start"
);
let usage = meter.get_credit_usage(42).await.unwrap();
assert_eq!(usage.consumed, 0, "过期重置应清零计数");
}
#[tokio::test]
async fn test_consume_after_cycle_expiry_starts_fresh() {
let meter = CreditMeter::new(make_dao(), make_config(100));
meter.consume_credit(42, "login", 50).await.unwrap();
let past = Utc::now().timestamp() - 31 * 86400;
meter
.storage
.set_window_start(42, past, 86400)
.await
.unwrap();
let result = meter.consume_credit(42, "login", 7).await.unwrap();
assert!(result.allowed);
assert_eq!(result.total_consumed, 7, "周期过期后应重新累计");
assert!(
meter.storage.get_window_start(42).await.unwrap().is_some(),
"重置后再次消费应重新写入 window_start"
);
}
#[tokio::test]
async fn test_consume_tenant_isolation() {
let meter = CreditMeter::new(make_dao(), make_config(100));
meter.consume_credit(1, "login", 10).await.unwrap();
meter.consume_credit(2, "login", 20).await.unwrap();
let usage1 = meter.get_credit_usage(1).await.unwrap();
let usage2 = meter.get_credit_usage(2).await.unwrap();
assert_eq!(usage1.consumed, 10);
assert_eq!(usage2.consumed, 20);
meter.reset_credit(1).await.unwrap();
assert_eq!(meter.get_credit_usage(1).await.unwrap().consumed, 0);
assert_eq!(meter.get_credit_usage(2).await.unwrap().consumed, 20);
}
#[cfg(feature = "listener")]
#[tokio::test]
async fn test_consume_broadcasts_events_via_listener_manager() {
use crate::error::GarrisonResult;
use crate::listener::{GarrisonEvent, GarrisonListener, GarrisonListenerManager};
use async_trait::async_trait;
use parking_lot::Mutex;
#[derive(Default)]
struct CapturingListener {
consumed: Mutex<Vec<(i64, String, u64, u64)>>,
alerts: Mutex<Vec<(i64, u8)>>,
}
#[async_trait]
impl GarrisonListener for CapturingListener {
async fn on_event(&self, event: &GarrisonEvent) -> GarrisonResult<()> {
match event {
GarrisonEvent::CreditConsumed {
tenant_id,
resource,
cost,
credits,
..
} => {
self.consumed
.lock()
.push((*tenant_id, resource.clone(), *cost, *credits));
},
GarrisonEvent::CreditAlert {
tenant_id,
threshold,
..
} => {
self.alerts.lock().push((*tenant_id, *threshold));
},
_ => {},
}
Ok(())
}
}
let listener = Arc::new(CapturingListener::default());
let lm = Arc::new(GarrisonListenerManager::new());
lm.register(listener.clone());
let meter = CreditMeter::new(make_dao(), make_config(10)).with_listener_manager(lm);
let result = meter.consume_credit(42, "login", 10).await.unwrap();
assert!(result.alerts_triggered.contains(&100));
let mut got_consumed = false;
let mut got_alert = false;
for _ in 0..40 {
got_consumed = !listener.consumed.lock().is_empty();
got_alert = !listener.alerts.lock().is_empty();
if got_consumed && got_alert {
break;
}
tokio::time::sleep(std::time::Duration::from_millis(50)).await;
}
assert!(got_consumed, "应广播 CreditConsumed 事件");
let consumed = listener.consumed.lock();
assert_eq!(consumed[0], (42, "login".to_string(), 10, 10));
assert!(got_alert, "应广播 CreditAlert 事件");
assert!(
listener
.alerts
.lock()
.iter()
.any(|&(t, th)| t == 42 && th == 100),
"应包含 threshold=100 的告警"
);
}
#[cfg(feature = "metrics-prometheus")]
#[tokio::test]
async fn test_consume_records_prometheus_metrics() {
use crate::credit::metrics::CreditMetrics;
let registry = prometheus::Registry::new();
let metrics = Arc::new(CreditMetrics::register_to(®istry).unwrap());
let meter = CreditMeter::new(make_dao(), make_config(10)).with_metrics(metrics.clone());
meter.consume_credit(42, "sms", 8).await.unwrap();
let output = prometheus::TextEncoder::new()
.encode_to_string(®istry.gather())
.unwrap();
assert!(
output.contains("garrison_credit_consumed_total{resource=\"sms\",tenant_id=\"42\"} 8"),
"应记录 consumed=8: {}",
output
);
assert!(
output.contains("garrison_credit_remaining{tenant_id=\"42\"} 2"),
"应记录 remaining=2: {}",
output
);
assert!(
output.contains("garrison_credit_alerts_total{tenant_id=\"42\",threshold=\"80\"} 1"),
"应记录 alert threshold=80: {}",
output
);
}
#[cfg(any(feature = "db-sqlite", feature = "db-postgres", feature = "db-mysql"))]
type HistoryRecord = (i64, String, u64, u64, u64, i64, i64);
#[cfg(any(feature = "db-sqlite", feature = "db-postgres", feature = "db-mysql"))]
struct HistoryTestDao {
inner: MockDao,
records: parking_lot::Mutex<Vec<HistoryRecord>>,
fail_insert: parking_lot::Mutex<bool>,
}
#[cfg(any(feature = "db-sqlite", feature = "db-postgres", feature = "db-mysql"))]
impl HistoryTestDao {
fn new() -> Self {
Self {
inner: MockDao::new(),
records: parking_lot::Mutex::new(Vec::new()),
fail_insert: parking_lot::Mutex::new(false),
}
}
fn set_fail_insert(&self, fail: bool) {
*self.fail_insert.lock() = fail;
}
fn push_record(
&self,
tenant_id: i64,
resource: &str,
cost: u64,
credits: u64,
total: u64,
cycle_start: i64,
created_at: i64,
) {
self.records.lock().push((
tenant_id,
resource.to_string(),
cost,
credits,
total,
cycle_start,
created_at,
));
}
}
#[cfg(any(feature = "db-sqlite", feature = "db-postgres", feature = "db-mysql"))]
#[async_trait::async_trait]
impl GarrisonDao for HistoryTestDao {
async fn get(&self, key: &str) -> crate::error::GarrisonResult<Option<String>> {
self.inner.get(key).await
}
async fn set(
&self,
key: &str,
value: &str,
ttl_seconds: u64,
) -> crate::error::GarrisonResult<()> {
self.inner.set(key, value, ttl_seconds).await
}
async fn update(&self, key: &str, value: &str) -> crate::error::GarrisonResult<()> {
self.inner.update(key, value).await
}
async fn expire(&self, key: &str, seconds: u64) -> crate::error::GarrisonResult<()> {
self.inner.expire(key, seconds).await
}
async fn delete(&self, key: &str) -> crate::error::GarrisonResult<()> {
self.inner.delete(key).await
}
async fn incr(&self, key: &str, ttl_seconds: u64) -> crate::error::GarrisonResult<u64> {
self.inner.incr(key, ttl_seconds).await
}
async fn decr(&self, key: &str) -> crate::error::GarrisonResult<u64> {
self.inner.decr(key).await
}
async fn set_if_absent(
&self,
key: &str,
value: &str,
ttl_seconds: u64,
) -> crate::error::GarrisonResult<bool> {
self.inner.set_if_absent(key, value, ttl_seconds).await
}
async fn rename(&self, old_key: &str, new_key: &str) -> crate::error::GarrisonResult<()> {
self.inner.rename(old_key, new_key).await
}
async fn get_and_delete(&self, key: &str) -> crate::error::GarrisonResult<Option<String>> {
self.inner.get_and_delete(key).await
}
async fn compare_and_swap(
&self,
key: &str,
expected: Option<&str>,
new_value: &str,
ttl_seconds: u64,
) -> crate::error::GarrisonResult<bool> {
self.inner
.compare_and_swap(key, expected, new_value, ttl_seconds)
.await
}
async fn insert_credit_consumption(
&self,
tenant_id: i64,
resource: &str,
cost: u64,
credits: u64,
total_consumed: u64,
cycle_start: i64,
) -> crate::error::GarrisonResult<()> {
if *self.fail_insert.lock() {
return Err(crate::error::GarrisonError::NotImplemented(
"injected insert failure".to_string(),
));
}
let created_at = Utc::now().timestamp();
self.records.lock().push((
tenant_id,
resource.to_string(),
cost,
credits,
total_consumed,
cycle_start,
created_at,
));
Ok(())
}
async fn query_credit_consumption(
&self,
tenant_id: i64,
from_ts: i64,
to_ts: i64,
) -> crate::error::GarrisonResult<Vec<(i64, String, u64, u64, u64, i64, i64)>> {
Ok(self
.records
.lock()
.iter()
.filter(|r| r.0 == tenant_id && r.6 >= from_ts && r.6 <= to_ts)
.cloned()
.collect())
}
}
#[cfg(any(feature = "db-sqlite", feature = "db-postgres", feature = "db-mysql"))]
#[tokio::test(start_paused = true)]
async fn test_consume_persist_history_writes_record() {
use std::time::Duration;
let dao = Arc::new(HistoryTestDao::new());
let config = CreditConfig {
persist_history: true,
..make_config(100)
};
let meter = CreditMeter::new(dao.clone(), config);
let result = meter.consume_credit(42, "login", 5).await.unwrap();
assert_eq!(result.consumed_credits, 5);
tokio::time::advance(Duration::from_secs(10)).await;
let mut written = false;
for _ in 0..200 {
if !dao.records.lock().is_empty() {
written = true;
break;
}
tokio::time::sleep(Duration::from_millis(1)).await;
}
assert!(written, "persist_history=true 窗口到期后应落库");
let records = dao.records.lock();
assert_eq!(records.len(), 1, "窗口内单次消费应恰好落库一条");
assert_eq!(records[0].0, 42);
assert_eq!(records[0].1, "login");
assert_eq!(records[0].2, 5, "cost 应为原始 cost");
assert_eq!(records[0].3, 5, "credits 应为 cost * weight");
assert_eq!(records[0].4, 5, "total_consumed 应为消费后累计");
}
#[cfg(any(feature = "db-sqlite", feature = "db-postgres", feature = "db-mysql"))]
#[tokio::test]
async fn test_consume_persist_history_without_throttle_writes_immediately() {
let dao = Arc::new(HistoryTestDao::new());
let config = CreditConfig {
persist_history: true,
..make_config(100)
};
let meter = CreditMeter::new(dao.clone(), config).without_activity_throttle();
let result = meter.consume_credit(42, "login", 5).await.unwrap();
assert_eq!(result.consumed_credits, 5);
let mut written = false;
for _ in 0..40 {
if !dao.records.lock().is_empty() {
written = true;
break;
}
tokio::time::sleep(std::time::Duration::from_millis(50)).await;
}
assert!(written, "关闭节流后应逐笔异步落库");
let records = dao.records.lock();
assert_eq!(records[0].2, 5, "cost 应为原始 cost");
assert_eq!(records[0].4, 5, "total_consumed 应为消费后累计");
}
#[cfg(any(feature = "db-sqlite", feature = "db-postgres", feature = "db-mysql"))]
#[tokio::test(start_paused = true)]
async fn test_consume_persist_history_disabled_skips_record() {
use std::time::Duration;
let dao = Arc::new(HistoryTestDao::new());
let meter = CreditMeter::new(dao.clone(), make_config(100));
meter.consume_credit(42, "login", 5).await.unwrap();
tokio::time::advance(Duration::from_secs(10)).await;
for _ in 0..64 {
tokio::task::yield_now().await;
}
assert!(
dao.records.lock().is_empty(),
"persist_history=false 不应写流水"
);
}
#[cfg(any(feature = "db-sqlite", feature = "db-postgres", feature = "db-mysql"))]
#[tokio::test(start_paused = true)]
async fn test_consume_persist_history_insert_error_is_non_blocking() {
use std::time::Duration;
let dao = Arc::new(HistoryTestDao::new());
dao.set_fail_insert(true);
let config = CreditConfig {
persist_history: true,
..make_config(100)
};
let meter = CreditMeter::new(dao.clone(), config);
let result = meter.consume_credit(42, "login", 5).await.unwrap();
assert!(result.allowed);
assert_eq!(result.total_consumed, 5);
tokio::time::advance(Duration::from_secs(10)).await;
for _ in 0..200 {
if meter.activity_pending() == 0 {
break;
}
tokio::time::sleep(Duration::from_millis(1)).await;
}
assert_eq!(meter.activity_pending(), 0, "失败条目应被 flush 清理");
assert!(dao.records.lock().is_empty(), "注入失败下不应有流水落库");
}
#[cfg(any(feature = "db-sqlite", feature = "db-postgres", feature = "db-mysql"))]
#[tokio::test]
async fn test_get_usage_history_maps_and_filters_records() {
let dao = Arc::new(HistoryTestDao::new());
dao.push_record(42, "login", 1, 1, 1, 1_000, 5_000);
dao.push_record(42, "sms", 2, 10, 11, 1_000, 6_000);
dao.push_record(43, "login", 1, 1, 1, 1_000, 5_500);
let meter = CreditMeter::new(dao, make_config(100));
let records = meter.get_usage_history(42, 4_500, 5_500).await.unwrap();
assert_eq!(
records.len(),
1,
"应只含 tenant=42 且 created_at ∈ [4500, 5500] 的记录"
);
let r = &records[0];
assert_eq!(r.tenant_id, 42);
assert_eq!(r.resource, "login");
assert_eq!(r.cost, 1);
assert_eq!(r.credits, 1);
assert_eq!(r.total_consumed, 1);
assert_eq!(r.cycle_start, 1_000);
assert_eq!(r.created_at, 5_000);
}
#[cfg(any(feature = "db-sqlite", feature = "db-postgres", feature = "db-mysql"))]
#[tokio::test]
async fn test_get_usage_history_not_implemented_returns_err() {
let meter = CreditMeter::new(make_dao(), make_config(100));
let result = meter.get_usage_history(42, 0, 1).await;
let err = result.unwrap_err();
assert!(
format!("{}", err).contains("credit-query-history::"),
"应包装为 credit-query-history 前缀错误: {}",
err
);
}
#[cfg(any(feature = "db-sqlite", feature = "db-postgres", feature = "db-mysql"))]
#[tokio::test(start_paused = true)]
async fn test_consume_persist_history_throttled_to_first_in_window() {
use crate::credit::throttle::ActivityWriteThrottle;
use std::time::Duration;
let dao = Arc::new(HistoryTestDao::new());
let throttle = Arc::new(ActivityWriteThrottle::with_limits(
100,
Duration::from_secs(10),
Duration::from_secs(3),
));
let config = CreditConfig {
persist_history: true,
..make_config(100)
};
let meter = CreditMeter::new(dao.clone(), config).with_activity_throttle(throttle);
assert!(meter.spawn_activity_flush_loop(), "flush 循环应启动");
assert!(
!meter.spawn_activity_flush_loop(),
"重复启动 flush 循环应幂等拒绝"
);
meter.consume_credit(42, "login", 7).await.unwrap();
for _ in 0..4 {
meter.consume_credit(42, "login", 1).await.unwrap();
}
tokio::time::advance(Duration::from_secs(1)).await;
for _ in 0..8 {
tokio::task::yield_now().await;
}
assert_eq!(dao.records.lock().len(), 0, "去抖窗口内不得落库");
tokio::time::advance(Duration::from_secs(10)).await;
let mut written = false;
for _ in 0..200 {
if !dao.records.lock().is_empty() {
written = true;
break;
}
tokio::time::sleep(Duration::from_millis(1)).await;
}
assert!(written, "窗口到期后应由后台 flush 循环落库");
let records = dao.records.lock();
assert_eq!(
records.len(),
1,
"窗口内 5 次同 key 消费应仅首次落库(计数=1)"
);
assert_eq!(
records[0].2, 7,
"落库应为窗口内首次消费的快照(cost=7),而非末次"
);
assert_eq!(records[0].4, 7, "total_consumed 亦应为首次快照");
}
#[cfg(any(feature = "db-sqlite", feature = "db-postgres", feature = "db-mysql"))]
#[tokio::test(start_paused = true)]
async fn test_consume_persist_history_throttle_keyed_by_tenant_resource() {
use crate::credit::throttle::ActivityWriteThrottle;
use std::time::Duration;
let dao = Arc::new(HistoryTestDao::new());
let throttle = Arc::new(ActivityWriteThrottle::with_limits(
100,
Duration::from_secs(10),
Duration::from_secs(3),
));
let config = CreditConfig {
persist_history: true,
..make_config(100)
};
let meter = CreditMeter::new(dao.clone(), config).with_activity_throttle(throttle);
meter.spawn_activity_flush_loop();
meter.consume_credit(42, "login", 1).await.unwrap();
meter.consume_credit(42, "sms", 1).await.unwrap();
meter.consume_credit(42, "login", 1).await.unwrap();
tokio::time::advance(Duration::from_secs(10)).await;
let mut written = false;
for _ in 0..200 {
if dao.records.lock().len() >= 2 {
written = true;
break;
}
tokio::time::sleep(Duration::from_millis(1)).await;
}
assert!(written, "两个 key 到期后均应落库");
let records = dao.records.lock();
assert_eq!(records.len(), 2, "不同 key 各自独立窗口,各落库 1 条");
let mut resources: Vec<&str> = records.iter().map(|r| r.1.as_str()).collect();
resources.sort_unstable();
assert_eq!(resources, vec!["login", "sms"]);
}
}