mirror of
https://github.com/fawney19/Aether.git
synced 2026-10-08 18:37:46 +08:00
refactor(workspace): enforce layered crate boundaries
This commit is contained in:
elky
@@ -0,0 +1,794 @@
|
||||
// Gateway-backed benchmark scenarios live outside the reusable testkit.
|
||||
use std::path::PathBuf;
|
||||
use std::sync::Arc;
|
||||
use std::time::{Duration, Instant};
|
||||
|
||||
use aether_data::driver::postgres::{
|
||||
DatabaseRecordId, PostgresLeaseClaimOptions, PostgresLeaseClaimSpec, PostgresLeaseRunnerConfig,
|
||||
PostgresPoolConfig,
|
||||
};
|
||||
use aether_data::PostgresBackend;
|
||||
use aether_runtime_state::{
|
||||
RedisClientConfig, RedisConsumerGroup, RedisConsumerName, RedisKeyspace, RedisLockLease,
|
||||
RedisLockRunner, RedisLockRunnerConfig, RedisStreamName, RedisStreamReclaimConfig,
|
||||
RedisStreamRunner, RedisStreamRunnerConfig,
|
||||
};
|
||||
use aether_testkit::{init_test_runtime_for, ManagedPostgresServer, ManagedRedisServer};
|
||||
use futures_util::stream::{self, StreamExt};
|
||||
use serde::Serialize;
|
||||
|
||||
#[derive(Debug, Clone)]
|
||||
struct DependencyPressureBaselineConfig {
|
||||
redis_lock_total: usize,
|
||||
redis_lock_concurrency: usize,
|
||||
redis_stream_total: usize,
|
||||
redis_stream_concurrency: usize,
|
||||
redis_reclaim_total: usize,
|
||||
redis_reclaim_min_idle: Duration,
|
||||
postgres_rows: usize,
|
||||
postgres_lease_cycles: usize,
|
||||
postgres_lease_concurrency: usize,
|
||||
postgres_lease_batch_size: usize,
|
||||
postgres_lease_ms: u64,
|
||||
timeout: Duration,
|
||||
output_path: Option<PathBuf>,
|
||||
redis_url: Option<String>,
|
||||
postgres_url: Option<String>,
|
||||
}
|
||||
|
||||
impl Default for DependencyPressureBaselineConfig {
|
||||
fn default() -> Self {
|
||||
Self {
|
||||
redis_lock_total: 1_000,
|
||||
redis_lock_concurrency: 20,
|
||||
redis_stream_total: 2_000,
|
||||
redis_stream_concurrency: 20,
|
||||
redis_reclaim_total: 256,
|
||||
redis_reclaim_min_idle: Duration::from_millis(100),
|
||||
postgres_rows: 512,
|
||||
postgres_lease_cycles: 128,
|
||||
postgres_lease_concurrency: 16,
|
||||
postgres_lease_batch_size: 16,
|
||||
postgres_lease_ms: 250,
|
||||
timeout: Duration::from_secs(10),
|
||||
output_path: None,
|
||||
redis_url: None,
|
||||
postgres_url: None,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone, Serialize)]
|
||||
struct OperationSummary {
|
||||
total_calls: usize,
|
||||
total_items: usize,
|
||||
failed_calls: usize,
|
||||
p50_ms: u64,
|
||||
p95_ms: u64,
|
||||
max_ms: u64,
|
||||
mean_ms: u64,
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone, Serialize)]
|
||||
struct RedisLockPressureReport {
|
||||
acquire: OperationSummary,
|
||||
renew: OperationSummary,
|
||||
release: OperationSummary,
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone, Serialize)]
|
||||
struct RedisStreamPressureReport {
|
||||
append: OperationSummary,
|
||||
read_group: OperationSummary,
|
||||
reclaim: OperationSummary,
|
||||
ack: OperationSummary,
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone, Serialize)]
|
||||
struct PostgresLeasePressureReport {
|
||||
claim: OperationSummary,
|
||||
renew: OperationSummary,
|
||||
release: OperationSummary,
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone, Serialize)]
|
||||
struct DependencyPressureBaselineReport {
|
||||
suite: &'static str,
|
||||
redis_url: String,
|
||||
postgres_url: String,
|
||||
redis_lock: RedisLockPressureReport,
|
||||
redis_stream: RedisStreamPressureReport,
|
||||
postgres_lease: PostgresLeasePressureReport,
|
||||
}
|
||||
|
||||
#[derive(Default)]
|
||||
struct SummaryCollector {
|
||||
latencies_ms: tokio::sync::Mutex<Vec<u64>>,
|
||||
total_items: std::sync::atomic::AtomicUsize,
|
||||
failed_calls: std::sync::atomic::AtomicUsize,
|
||||
total_calls: std::sync::atomic::AtomicUsize,
|
||||
}
|
||||
|
||||
impl SummaryCollector {
|
||||
async fn record(&self, elapsed: Duration, items: usize, failed: bool) {
|
||||
self.latencies_ms
|
||||
.lock()
|
||||
.await
|
||||
.push(elapsed.as_millis() as u64);
|
||||
self.total_calls
|
||||
.fetch_add(1, std::sync::atomic::Ordering::AcqRel);
|
||||
self.total_items
|
||||
.fetch_add(items, std::sync::atomic::Ordering::AcqRel);
|
||||
if failed {
|
||||
self.failed_calls
|
||||
.fetch_add(1, std::sync::atomic::Ordering::AcqRel);
|
||||
}
|
||||
}
|
||||
|
||||
async fn summarize(&self) -> OperationSummary {
|
||||
let mut latencies = self.latencies_ms.lock().await.clone();
|
||||
latencies.sort_unstable();
|
||||
let (p50_ms, p95_ms, max_ms, mean_ms) = summarize_latencies(&latencies);
|
||||
OperationSummary {
|
||||
total_calls: self.total_calls.load(std::sync::atomic::Ordering::Acquire),
|
||||
total_items: self.total_items.load(std::sync::atomic::Ordering::Acquire),
|
||||
failed_calls: self.failed_calls.load(std::sync::atomic::Ordering::Acquire),
|
||||
p50_ms,
|
||||
p95_ms,
|
||||
max_ms,
|
||||
mean_ms,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[tokio::main]
|
||||
async fn main() -> Result<(), Box<dyn std::error::Error>> {
|
||||
init_test_runtime_for("dependency-pressure-baseline");
|
||||
let config = parse_args(std::env::args().skip(1).collect())?;
|
||||
let report = run_suite(&config).await?;
|
||||
let raw = serde_json::to_string_pretty(&report)?;
|
||||
println!("{raw}");
|
||||
if let Some(path) = config.output_path.as_ref() {
|
||||
if let Some(parent) = path.parent() {
|
||||
std::fs::create_dir_all(parent)?;
|
||||
}
|
||||
std::fs::write(path, format!("{raw}\n"))?;
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
async fn run_suite(
|
||||
config: &DependencyPressureBaselineConfig,
|
||||
) -> Result<DependencyPressureBaselineReport, Box<dyn std::error::Error>> {
|
||||
let managed_redis = if config.redis_url.is_none() {
|
||||
Some(ManagedRedisServer::start().await?)
|
||||
} else {
|
||||
None
|
||||
};
|
||||
let managed_postgres = if config.postgres_url.is_none() {
|
||||
Some(ManagedPostgresServer::start().await?)
|
||||
} else {
|
||||
None
|
||||
};
|
||||
|
||||
let redis_url = config
|
||||
.redis_url
|
||||
.clone()
|
||||
.or_else(|| {
|
||||
managed_redis
|
||||
.as_ref()
|
||||
.map(|server| server.redis_url().to_string())
|
||||
})
|
||||
.expect("redis url should resolve");
|
||||
let postgres_url = config
|
||||
.postgres_url
|
||||
.clone()
|
||||
.or_else(|| {
|
||||
managed_postgres
|
||||
.as_ref()
|
||||
.map(|server| server.database_url().to_string())
|
||||
})
|
||||
.expect("postgres url should resolve");
|
||||
|
||||
let redis_config = RedisClientConfig {
|
||||
url: redis_url.clone(),
|
||||
key_prefix: Some(format!("aether-dependency-pressure-{}", std::process::id())),
|
||||
};
|
||||
let redis_keyspace = redis_config.keyspace();
|
||||
let postgres_backend = PostgresBackend::from_config(PostgresPoolConfig {
|
||||
database_url: postgres_url.clone(),
|
||||
min_connections: 1,
|
||||
max_connections: (config.postgres_lease_concurrency as u32).saturating_add(8),
|
||||
acquire_timeout_ms: config.timeout.as_millis() as u64,
|
||||
idle_timeout_ms: 60_000,
|
||||
max_lifetime_ms: 10 * 60_000,
|
||||
statement_cache_capacity: 128,
|
||||
require_ssl: false,
|
||||
})?;
|
||||
|
||||
bootstrap_postgres_lease_table(postgres_backend.pool_clone(), config).await?;
|
||||
|
||||
let lock_runner = RedisLockRunner::from_config(
|
||||
redis_config.clone(),
|
||||
RedisLockRunnerConfig {
|
||||
command_timeout_ms: Some(config.timeout.as_millis() as u64),
|
||||
default_ttl_ms: 5_000,
|
||||
},
|
||||
)
|
||||
.await?;
|
||||
let stream_runner = RedisStreamRunner::from_config(
|
||||
redis_config,
|
||||
RedisStreamRunnerConfig {
|
||||
command_timeout_ms: Some(config.timeout.as_millis() as u64),
|
||||
read_block_ms: Some(10),
|
||||
read_count: 64,
|
||||
},
|
||||
)
|
||||
.await?;
|
||||
let lease_runner = postgres_backend.lease_runner(PostgresLeaseRunnerConfig {
|
||||
statement_timeout_ms: Some(config.timeout.as_millis() as u64),
|
||||
lock_timeout_ms: Some(1_000),
|
||||
})?;
|
||||
|
||||
let redis_lock = benchmark_redis_lock(&redis_keyspace, &lock_runner, config).await?;
|
||||
let redis_stream = benchmark_redis_stream(&redis_keyspace, &stream_runner, config).await?;
|
||||
let postgres_lease = benchmark_postgres_lease(&lease_runner, config).await?;
|
||||
|
||||
Ok(DependencyPressureBaselineReport {
|
||||
suite: "dependency_pressure_baseline",
|
||||
redis_url,
|
||||
postgres_url,
|
||||
redis_lock,
|
||||
redis_stream,
|
||||
postgres_lease,
|
||||
})
|
||||
}
|
||||
|
||||
async fn bootstrap_postgres_lease_table(
|
||||
pool: sqlx::PgPool,
|
||||
config: &DependencyPressureBaselineConfig,
|
||||
) -> Result<(), Box<dyn std::error::Error>> {
|
||||
sqlx::query("DROP TABLE IF EXISTS baseline_lease_jobs")
|
||||
.execute(&pool)
|
||||
.await?;
|
||||
sqlx::query(
|
||||
"CREATE TABLE baseline_lease_jobs (
|
||||
id TEXT PRIMARY KEY,
|
||||
status TEXT NOT NULL,
|
||||
updated_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
|
||||
lease_owner TEXT,
|
||||
lease_expires_at TIMESTAMPTZ
|
||||
)",
|
||||
)
|
||||
.execute(&pool)
|
||||
.await?;
|
||||
|
||||
let mut builder = sqlx::QueryBuilder::new("INSERT INTO baseline_lease_jobs (id, status) ");
|
||||
builder.push_values(0..config.postgres_rows, |mut row, index| {
|
||||
row.push_bind(format!("job-{index:05}")).push_bind("ready");
|
||||
});
|
||||
builder.build().execute(&pool).await?;
|
||||
|
||||
Ok(())
|
||||
}
|
||||
|
||||
async fn benchmark_redis_lock(
|
||||
keyspace: &RedisKeyspace,
|
||||
runner: &RedisLockRunner,
|
||||
config: &DependencyPressureBaselineConfig,
|
||||
) -> Result<RedisLockPressureReport, Box<dyn std::error::Error>> {
|
||||
let acquire = Arc::new(SummaryCollector::default());
|
||||
let renew = Arc::new(SummaryCollector::default());
|
||||
let release = Arc::new(SummaryCollector::default());
|
||||
let next = Arc::new(std::sync::atomic::AtomicUsize::new(0));
|
||||
|
||||
stream::iter(0..config.redis_lock_concurrency)
|
||||
.for_each_concurrent(config.redis_lock_concurrency, |_| {
|
||||
let runner = runner.clone();
|
||||
let acquire = acquire.clone();
|
||||
let renew = renew.clone();
|
||||
let release = release.clone();
|
||||
let next = next.clone();
|
||||
let keyspace = keyspace.clone();
|
||||
async move {
|
||||
loop {
|
||||
let index = next.fetch_add(1, std::sync::atomic::Ordering::AcqRel);
|
||||
if index >= config.redis_lock_total {
|
||||
break;
|
||||
}
|
||||
let owner = format!("lock-owner-{index}");
|
||||
let key = keyspace.lock_key(&format!("dependency-pressure-{index}"));
|
||||
let acquire_started = Instant::now();
|
||||
match runner.try_acquire(&key, &owner, None).await {
|
||||
Ok(Some(lease)) => {
|
||||
acquire.record(acquire_started.elapsed(), 1, false).await;
|
||||
record_redis_lock_follow_up(&runner, &lease, &renew, &release).await;
|
||||
}
|
||||
Ok(None) => {
|
||||
acquire.record(acquire_started.elapsed(), 0, true).await;
|
||||
}
|
||||
Err(_) => {
|
||||
acquire.record(acquire_started.elapsed(), 0, true).await;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
})
|
||||
.await;
|
||||
|
||||
Ok(RedisLockPressureReport {
|
||||
acquire: acquire.summarize().await,
|
||||
renew: renew.summarize().await,
|
||||
release: release.summarize().await,
|
||||
})
|
||||
}
|
||||
|
||||
async fn record_redis_lock_follow_up(
|
||||
runner: &RedisLockRunner,
|
||||
lease: &RedisLockLease,
|
||||
renew: &SummaryCollector,
|
||||
release: &SummaryCollector,
|
||||
) {
|
||||
let renew_started = Instant::now();
|
||||
let renew_ok = runner.renew(lease, None).await.unwrap_or(false);
|
||||
renew
|
||||
.record(renew_started.elapsed(), usize::from(renew_ok), !renew_ok)
|
||||
.await;
|
||||
|
||||
let release_started = Instant::now();
|
||||
let release_ok = runner.release(lease).await.unwrap_or(false);
|
||||
release
|
||||
.record(
|
||||
release_started.elapsed(),
|
||||
usize::from(release_ok),
|
||||
!release_ok,
|
||||
)
|
||||
.await;
|
||||
}
|
||||
|
||||
async fn benchmark_redis_stream(
|
||||
keyspace: &RedisKeyspace,
|
||||
runner: &RedisStreamRunner,
|
||||
config: &DependencyPressureBaselineConfig,
|
||||
) -> Result<RedisStreamPressureReport, Box<dyn std::error::Error>> {
|
||||
let stream = keyspace.stream_name("dependency-pressure");
|
||||
let group = RedisConsumerGroup("dependency-group".to_string());
|
||||
let consumer_a = RedisConsumerName("consumer-a".to_string());
|
||||
let consumer_b = RedisConsumerName("consumer-b".to_string());
|
||||
runner
|
||||
.ensure_consumer_group(&stream, &group, "0-0")
|
||||
.await
|
||||
.map_err(std::io::Error::other)?;
|
||||
|
||||
let append = benchmark_redis_stream_append(runner, &stream, config).await?;
|
||||
let (read_group, drained_ids) =
|
||||
benchmark_redis_stream_read_group(runner, &stream, &group, &consumer_a, config).await?;
|
||||
let ack = SummaryCollector::default();
|
||||
benchmark_redis_stream_ack_into(&ack, runner, &stream, &group, &drained_ids).await?;
|
||||
let (reclaim, reclaimed_ids) =
|
||||
benchmark_redis_stream_reclaim(runner, &stream, &group, &consumer_a, &consumer_b, config)
|
||||
.await?;
|
||||
benchmark_redis_stream_ack_into(&ack, runner, &stream, &group, &reclaimed_ids).await?;
|
||||
|
||||
Ok(RedisStreamPressureReport {
|
||||
append,
|
||||
read_group,
|
||||
reclaim,
|
||||
ack: ack.summarize().await,
|
||||
})
|
||||
}
|
||||
|
||||
async fn benchmark_redis_stream_append(
|
||||
runner: &RedisStreamRunner,
|
||||
stream: &RedisStreamName,
|
||||
config: &DependencyPressureBaselineConfig,
|
||||
) -> Result<OperationSummary, Box<dyn std::error::Error>> {
|
||||
let collector = Arc::new(SummaryCollector::default());
|
||||
let next = Arc::new(std::sync::atomic::AtomicUsize::new(0));
|
||||
|
||||
stream::iter(0..config.redis_stream_concurrency)
|
||||
.for_each_concurrent(config.redis_stream_concurrency, |_| {
|
||||
let runner = runner.clone();
|
||||
let stream = stream.clone();
|
||||
let collector = collector.clone();
|
||||
let next = next.clone();
|
||||
async move {
|
||||
loop {
|
||||
let index = next.fetch_add(1, std::sync::atomic::Ordering::AcqRel);
|
||||
if index >= config.redis_stream_total {
|
||||
break;
|
||||
}
|
||||
let started = Instant::now();
|
||||
let result = runner
|
||||
.append_json(
|
||||
&stream,
|
||||
"payload",
|
||||
&serde_json::json!({
|
||||
"job_id": index,
|
||||
"kind": "dependency-pressure",
|
||||
}),
|
||||
)
|
||||
.await;
|
||||
collector
|
||||
.record(
|
||||
started.elapsed(),
|
||||
usize::from(result.is_ok()),
|
||||
result.is_err(),
|
||||
)
|
||||
.await;
|
||||
}
|
||||
}
|
||||
})
|
||||
.await;
|
||||
|
||||
Ok(collector.summarize().await)
|
||||
}
|
||||
|
||||
async fn benchmark_redis_stream_read_group(
|
||||
runner: &RedisStreamRunner,
|
||||
stream: &RedisStreamName,
|
||||
group: &RedisConsumerGroup,
|
||||
consumer: &RedisConsumerName,
|
||||
config: &DependencyPressureBaselineConfig,
|
||||
) -> Result<(OperationSummary, Vec<String>), Box<dyn std::error::Error>> {
|
||||
let collector = SummaryCollector::default();
|
||||
let mut ids = Vec::with_capacity(config.redis_stream_total);
|
||||
|
||||
while ids.len() < config.redis_stream_total {
|
||||
let started = Instant::now();
|
||||
match runner.read_group(stream, group, consumer).await {
|
||||
Ok(entries) => {
|
||||
let item_count = entries.len();
|
||||
ids.extend(entries.into_iter().map(|entry| entry.id));
|
||||
collector.record(started.elapsed(), item_count, false).await;
|
||||
}
|
||||
Err(_) => {
|
||||
collector.record(started.elapsed(), 0, true).await;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
Ok((collector.summarize().await, ids))
|
||||
}
|
||||
|
||||
async fn benchmark_redis_stream_reclaim(
|
||||
runner: &RedisStreamRunner,
|
||||
stream: &RedisStreamName,
|
||||
group: &RedisConsumerGroup,
|
||||
consumer_a: &RedisConsumerName,
|
||||
consumer_b: &RedisConsumerName,
|
||||
config: &DependencyPressureBaselineConfig,
|
||||
) -> Result<(OperationSummary, Vec<String>), Box<dyn std::error::Error>> {
|
||||
for index in 0..config.redis_reclaim_total {
|
||||
runner
|
||||
.append_json(
|
||||
stream,
|
||||
"payload",
|
||||
&serde_json::json!({
|
||||
"job_id": format!("reclaim-{index}"),
|
||||
"kind": "dependency-pressure",
|
||||
}),
|
||||
)
|
||||
.await
|
||||
.map_err(std::io::Error::other)?;
|
||||
}
|
||||
|
||||
let mut pending_ids = Vec::with_capacity(config.redis_reclaim_total);
|
||||
while pending_ids.len() < config.redis_reclaim_total {
|
||||
let entries = runner
|
||||
.read_group(stream, group, consumer_a)
|
||||
.await
|
||||
.map_err(std::io::Error::other)?;
|
||||
pending_ids.extend(entries.into_iter().map(|entry| entry.id));
|
||||
}
|
||||
|
||||
tokio::time::sleep(config.redis_reclaim_min_idle + Duration::from_millis(20)).await;
|
||||
|
||||
let collector = SummaryCollector::default();
|
||||
let mut reclaimed_ids = Vec::with_capacity(config.redis_reclaim_total);
|
||||
let mut next_start_id = "0-0".to_string();
|
||||
|
||||
while reclaimed_ids.len() < config.redis_reclaim_total {
|
||||
let started = Instant::now();
|
||||
match runner
|
||||
.claim_stale(
|
||||
stream,
|
||||
group,
|
||||
consumer_b,
|
||||
&next_start_id,
|
||||
RedisStreamReclaimConfig {
|
||||
min_idle_ms: config.redis_reclaim_min_idle.as_millis() as u64,
|
||||
count: 64,
|
||||
},
|
||||
)
|
||||
.await
|
||||
{
|
||||
Ok(result) => {
|
||||
next_start_id = result.next_start_id.clone();
|
||||
let item_count = result.entries.len();
|
||||
reclaimed_ids.extend(result.entries.into_iter().map(|entry| entry.id));
|
||||
collector.record(started.elapsed(), item_count, false).await;
|
||||
}
|
||||
Err(_) => {
|
||||
collector.record(started.elapsed(), 0, true).await;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
Ok((collector.summarize().await, reclaimed_ids))
|
||||
}
|
||||
|
||||
async fn benchmark_redis_stream_ack_into(
|
||||
collector: &SummaryCollector,
|
||||
runner: &RedisStreamRunner,
|
||||
stream: &RedisStreamName,
|
||||
group: &RedisConsumerGroup,
|
||||
ids: &[String],
|
||||
) -> Result<(), Box<dyn std::error::Error>> {
|
||||
for chunk in ids.chunks(64) {
|
||||
let started = Instant::now();
|
||||
match runner.ack(stream, group, chunk).await {
|
||||
Ok(acked) => {
|
||||
collector.record(started.elapsed(), acked, false).await;
|
||||
}
|
||||
Err(_) => {
|
||||
collector.record(started.elapsed(), 0, true).await;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
Ok(())
|
||||
}
|
||||
|
||||
async fn benchmark_postgres_lease(
|
||||
runner: &aether_data::driver::postgres::PostgresLeaseRunner,
|
||||
config: &DependencyPressureBaselineConfig,
|
||||
) -> Result<PostgresLeasePressureReport, Box<dyn std::error::Error>> {
|
||||
let spec = PostgresLeaseClaimSpec {
|
||||
table: "baseline_lease_jobs",
|
||||
id_column: "id",
|
||||
lease_owner_column: "lease_owner",
|
||||
lease_expires_at_column: "lease_expires_at",
|
||||
eligibility_predicate_sql: "status = 'ready'",
|
||||
order_by_sql: "id ASC",
|
||||
};
|
||||
let claim_options = PostgresLeaseClaimOptions {
|
||||
batch_size: config.postgres_lease_batch_size,
|
||||
lease_ms: config.postgres_lease_ms,
|
||||
};
|
||||
|
||||
let claim = Arc::new(SummaryCollector::default());
|
||||
let renew = Arc::new(SummaryCollector::default());
|
||||
let release = Arc::new(SummaryCollector::default());
|
||||
let next_cycle = Arc::new(std::sync::atomic::AtomicUsize::new(0));
|
||||
|
||||
stream::iter(0..config.postgres_lease_concurrency)
|
||||
.for_each_concurrent(config.postgres_lease_concurrency, |worker_index| {
|
||||
let runner = runner.clone();
|
||||
let spec = spec.clone();
|
||||
let claim = claim.clone();
|
||||
let renew = renew.clone();
|
||||
let release = release.clone();
|
||||
let next_cycle = next_cycle.clone();
|
||||
async move {
|
||||
let owner = format!("lease-owner-{worker_index}");
|
||||
loop {
|
||||
let cycle = next_cycle.fetch_add(1, std::sync::atomic::Ordering::AcqRel);
|
||||
if cycle >= config.postgres_lease_cycles {
|
||||
break;
|
||||
}
|
||||
|
||||
let claim_started = Instant::now();
|
||||
match runner.claim_ids(&spec, claim_options, &owner).await {
|
||||
Ok(ids) => {
|
||||
let item_count = ids.len();
|
||||
claim
|
||||
.record(claim_started.elapsed(), item_count, false)
|
||||
.await;
|
||||
if ids.is_empty() {
|
||||
tokio::time::sleep(Duration::from_millis(5)).await;
|
||||
continue;
|
||||
}
|
||||
record_postgres_lease_follow_up(
|
||||
&runner,
|
||||
&spec,
|
||||
&owner,
|
||||
&ids,
|
||||
config.postgres_lease_ms,
|
||||
&renew,
|
||||
&release,
|
||||
)
|
||||
.await;
|
||||
}
|
||||
Err(_) => {
|
||||
claim.record(claim_started.elapsed(), 0, true).await;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
})
|
||||
.await;
|
||||
|
||||
Ok(PostgresLeasePressureReport {
|
||||
claim: claim.summarize().await,
|
||||
renew: renew.summarize().await,
|
||||
release: release.summarize().await,
|
||||
})
|
||||
}
|
||||
|
||||
async fn record_postgres_lease_follow_up(
|
||||
runner: &aether_data::driver::postgres::PostgresLeaseRunner,
|
||||
spec: &PostgresLeaseClaimSpec,
|
||||
owner: &str,
|
||||
ids: &[DatabaseRecordId],
|
||||
lease_ms: u64,
|
||||
renew: &SummaryCollector,
|
||||
release: &SummaryCollector,
|
||||
) {
|
||||
let renew_started = Instant::now();
|
||||
match runner.renew_ids(spec, ids, owner, lease_ms).await {
|
||||
Ok(renewed) => {
|
||||
let item_count = renewed.len();
|
||||
renew
|
||||
.record(renew_started.elapsed(), item_count, false)
|
||||
.await;
|
||||
}
|
||||
Err(_) => {
|
||||
renew.record(renew_started.elapsed(), 0, true).await;
|
||||
}
|
||||
}
|
||||
|
||||
let release_started = Instant::now();
|
||||
match runner.release_ids(spec, ids, owner).await {
|
||||
Ok(released) => {
|
||||
let item_count = released.len();
|
||||
release
|
||||
.record(release_started.elapsed(), item_count, false)
|
||||
.await;
|
||||
}
|
||||
Err(_) => {
|
||||
release.record(release_started.elapsed(), 0, true).await;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn summarize_latencies(latencies: &[u64]) -> (u64, u64, u64, u64) {
|
||||
if latencies.is_empty() {
|
||||
return (0, 0, 0, 0);
|
||||
}
|
||||
let max_ms = *latencies.last().unwrap_or(&0);
|
||||
let mean_ms = latencies.iter().sum::<u64>() / latencies.len() as u64;
|
||||
let p50_ms = percentile(latencies, 50);
|
||||
let p95_ms = percentile(latencies, 95);
|
||||
(p50_ms, p95_ms, max_ms, mean_ms)
|
||||
}
|
||||
|
||||
fn percentile(latencies: &[u64], percentile: u8) -> u64 {
|
||||
if latencies.is_empty() {
|
||||
return 0;
|
||||
}
|
||||
let last_index = latencies.len() - 1;
|
||||
let rank = ((last_index as f64) * (percentile as f64 / 100.0)).round() as usize;
|
||||
latencies[rank.min(last_index)]
|
||||
}
|
||||
|
||||
fn parse_args(
|
||||
args: Vec<String>,
|
||||
) -> Result<DependencyPressureBaselineConfig, Box<dyn std::error::Error>> {
|
||||
let mut config = DependencyPressureBaselineConfig::default();
|
||||
let mut iter = args.into_iter();
|
||||
while let Some(arg) = iter.next() {
|
||||
match arg.as_str() {
|
||||
"--redis-lock-total" => {
|
||||
config.redis_lock_total = iter
|
||||
.next()
|
||||
.ok_or("missing value for --redis-lock-total")?
|
||||
.parse()?;
|
||||
}
|
||||
"--redis-lock-concurrency" => {
|
||||
config.redis_lock_concurrency = iter
|
||||
.next()
|
||||
.ok_or("missing value for --redis-lock-concurrency")?
|
||||
.parse()?;
|
||||
}
|
||||
"--redis-stream-total" => {
|
||||
config.redis_stream_total = iter
|
||||
.next()
|
||||
.ok_or("missing value for --redis-stream-total")?
|
||||
.parse()?;
|
||||
}
|
||||
"--redis-stream-concurrency" => {
|
||||
config.redis_stream_concurrency = iter
|
||||
.next()
|
||||
.ok_or("missing value for --redis-stream-concurrency")?
|
||||
.parse()?;
|
||||
}
|
||||
"--redis-reclaim-total" => {
|
||||
config.redis_reclaim_total = iter
|
||||
.next()
|
||||
.ok_or("missing value for --redis-reclaim-total")?
|
||||
.parse()?;
|
||||
}
|
||||
"--redis-reclaim-min-idle-ms" => {
|
||||
config.redis_reclaim_min_idle = Duration::from_millis(
|
||||
iter.next()
|
||||
.ok_or("missing value for --redis-reclaim-min-idle-ms")?
|
||||
.parse()?,
|
||||
);
|
||||
}
|
||||
"--postgres-rows" => {
|
||||
config.postgres_rows = iter
|
||||
.next()
|
||||
.ok_or("missing value for --postgres-rows")?
|
||||
.parse()?;
|
||||
}
|
||||
"--postgres-lease-cycles" => {
|
||||
config.postgres_lease_cycles = iter
|
||||
.next()
|
||||
.ok_or("missing value for --postgres-lease-cycles")?
|
||||
.parse()?;
|
||||
}
|
||||
"--postgres-lease-concurrency" => {
|
||||
config.postgres_lease_concurrency = iter
|
||||
.next()
|
||||
.ok_or("missing value for --postgres-lease-concurrency")?
|
||||
.parse()?;
|
||||
}
|
||||
"--postgres-lease-batch-size" => {
|
||||
config.postgres_lease_batch_size = iter
|
||||
.next()
|
||||
.ok_or("missing value for --postgres-lease-batch-size")?
|
||||
.parse()?;
|
||||
}
|
||||
"--postgres-lease-ms" => {
|
||||
config.postgres_lease_ms = iter
|
||||
.next()
|
||||
.ok_or("missing value for --postgres-lease-ms")?
|
||||
.parse()?;
|
||||
}
|
||||
"--timeout-ms" => {
|
||||
config.timeout = Duration::from_millis(
|
||||
iter.next()
|
||||
.ok_or("missing value for --timeout-ms")?
|
||||
.parse()?,
|
||||
);
|
||||
}
|
||||
"--output" => {
|
||||
config.output_path = Some(PathBuf::from(
|
||||
iter.next().ok_or("missing value for --output")?,
|
||||
));
|
||||
}
|
||||
"--redis-url" => {
|
||||
config.redis_url = Some(iter.next().ok_or("missing value for --redis-url")?);
|
||||
}
|
||||
"--postgres-url" => {
|
||||
config.postgres_url = Some(iter.next().ok_or("missing value for --postgres-url")?);
|
||||
}
|
||||
other => {
|
||||
return Err(format!("unknown argument: {other}").into());
|
||||
}
|
||||
}
|
||||
}
|
||||
validate_config(&config)?;
|
||||
Ok(config)
|
||||
}
|
||||
|
||||
fn validate_config(
|
||||
config: &DependencyPressureBaselineConfig,
|
||||
) -> Result<(), Box<dyn std::error::Error>> {
|
||||
if config.redis_lock_total == 0
|
||||
|| config.redis_lock_concurrency == 0
|
||||
|| config.redis_stream_total == 0
|
||||
|| config.redis_stream_concurrency == 0
|
||||
|| config.redis_reclaim_total == 0
|
||||
|| config.postgres_rows == 0
|
||||
|| config.postgres_lease_cycles == 0
|
||||
|| config.postgres_lease_concurrency == 0
|
||||
|| config.postgres_lease_batch_size == 0
|
||||
|| config.postgres_lease_ms == 0
|
||||
|| config.timeout.is_zero()
|
||||
{
|
||||
return Err("all dependency pressure baseline numeric settings must be positive".into());
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
Reference in New Issue
Block a user