Files
crank/crates/crank-observability/tests/prometheus.rs
T
bsodfather 54ce770682
CI / Rust Checks (pull_request) Failing after 13m41s
CI / UI Checks (pull_request) Skipped
CI / Frontend E2E (pull_request) Skipped
CI / Community Image Smoke (pull_request) Skipped
CI / Deploy (pull_request) Skipped
Community Release / release (push) Failing after 13m33s
feat(epic3): deliver the accepted Epic 3 scope through Story 3.17
Recovery delivery of the accumulated, TL-accepted Epic 3 work that had never been
committed to Git (stories 3.6-3.17, see the crank board). Story 3.18 is not accepted
yet and is deliberately excluded: its logging surface, its capability registration,
its oracle projections and its tests are not part of this tree.

Accepted scope
- 3.6 typed static Resource Drafts; 3.7 publication and exact binding of static
  Resource Versions; 3.8 MCP discovery/read and revocation of static Resources;
- 3.9 Resource import/export in API and UI plus TLS dependency maintenance;
  3.10 REST-backed Resource templates; 3.11 shared REST read runtime and the MCP
  revision/capability foundation;
- 3.12 parameterised Prompt Drafts with preview; 3.13 Prompt publication and exact
  version binding to Agents; 3.14 MCP prompts; 3.15 Prompt import/export;
- 3.16 composite Prompts with published Resources (dependency content scan plus
  dynamic read through the accepted 3.11 runtime, admin preview and MCP prompts/get);
- 3.17 bounded MCP completion suggestions from typed published schemas and the
  resources/list admission fix for bound template publications.

Accepted evidence being reused (unchanged code paths)
- 3.16 candidate: core 7, admin-api 22, registry 4, mcp-server 4, UI 6; one final
  `just verify` run 1651 passed / 0 failed / 2 ignored.
- 3.17 candidate: full run 1672 passed / 0 failed / 2 ignored, QA targeted reruns and
  a real MCP Inspector 2.12.0 client smoke.

Delivery engineering in this commit
- CI: one event per change (feature branches are gated by their pull request, push
  runs only on main), story events run the changed packages, the full workspace suite
  stays the feature/release gate; no cache/sharding without a measured runner check.
- Release: the packaged archives, checksums and SBOM are now uploaded to the Gitea
  release entry of the tag instead of dying with the runner workspace.

Not included on purpose: Story 3.18 work, build caches, runtime databases, local
credentials and scratch evidence.

Refs: crank kanban t_e39d7263; baseline 1b6db09bd1.
2026-10-25 09:08:22 +00:00

312 lines
11 KiB
Rust

use std::net::{IpAddr, Ipv4Addr, SocketAddr};
use axum::{
body::{Body, to_bytes},
http::{Request, StatusCode, header},
};
use crank_observability::{
DURATION_BUCKETS_SECONDS, MetricsConfig, MetricsConfigError, MetricsSurface, ServiceIdentity,
metric_schema,
};
use tokio::io::{AsyncReadExt, AsyncWriteExt};
use tower::ServiceExt;
fn identity() -> ServiceIdentity {
ServiceIdentity::try_new("admin-api", "0.3.1", "test").expect("valid identity")
}
#[test]
fn loopback_is_allowed_without_a_token() {
let config = MetricsConfig::new(
true,
SocketAddr::new(IpAddr::V4(Ipv4Addr::LOCALHOST), 9464),
None,
)
.expect("loopback metrics must be safe by default");
assert_eq!(config.bind_addr().to_string(), "127.0.0.1:9464");
assert!(!config.requires_authentication());
}
#[test]
fn disabled_config_remains_disabled_without_auth_side_effects() {
let config = MetricsConfig::new(
false,
SocketAddr::new(IpAddr::V4(Ipv4Addr::UNSPECIFIED), 9464),
None,
)
.expect("disabled listener does not require a token");
assert!(!config.enabled());
}
#[tokio::test]
async fn bind_collision_returns_a_typed_safe_error() {
let listener = tokio::net::TcpListener::bind((Ipv4Addr::LOCALHOST, 0))
.await
.unwrap();
let address = listener.local_addr().unwrap();
let config = MetricsConfig::new(true, address, None).unwrap();
let error = match MetricsSurface::for_test(config, identity())
.unwrap()
.bind()
.await
{
Ok(_) => panic!("occupied port must fail closed"),
Err(error) => error,
};
assert_eq!(error.to_string(), "failed to bind metrics listener");
}
#[tokio::test]
async fn default_service_ports_bind_and_serve_real_metrics_listeners() {
for (service, port) in [("admin-api", 9464), ("mcp-server", 9465)] {
let config = MetricsConfig::new(
true,
SocketAddr::new(IpAddr::V4(Ipv4Addr::LOCALHOST), port),
None,
)
.expect("default loopback metrics config");
let identity =
ServiceIdentity::try_new(service, "0.3.1", "test").expect("valid service identity");
let server = MetricsSurface::for_test(config, identity)
.expect("metrics surface")
.bind()
.await
.expect("default metrics port must bind");
assert_eq!(server.local_addr().expect("local address").port(), port);
let task = tokio::spawn(server.serve());
let response = raw_get(port, "/metrics").await;
assert!(response.starts_with("HTTP/1.1 200 OK"), "{response}");
assert!(response.contains("content-type: text/plain"));
task.abort();
let _ = task.await;
}
}
#[test]
fn non_loopback_without_a_token_is_rejected_without_secret_data() {
let error = MetricsConfig::new(
true,
SocketAddr::new(IpAddr::V4(Ipv4Addr::UNSPECIFIED), 9464),
None,
)
.expect_err("external metrics must require authentication");
assert!(matches!(
error,
MetricsConfigError::MissingTokenForExternalBind
));
assert!(!error.to_string().contains("token="));
}
#[test]
fn metrics_surface_rejects_an_unregistered_process_identity() {
let config = MetricsConfig::new(
true,
SocketAddr::new(IpAddr::V4(Ipv4Addr::LOCALHOST), 9464),
None,
)
.unwrap();
let identity = ServiceIdentity::try_new("user-controlled", "0.3.1", "test").unwrap();
assert!(MetricsSurface::for_test(config, identity).is_err());
}
#[test]
fn schema_is_closed_and_uses_fixed_duration_buckets() {
let schema = metric_schema();
let names: Vec<_> = schema.iter().map(|metric| metric.name).collect();
assert!(names.contains(&"crank_http_requests_total"));
assert!(names.contains(&"crank_http_request_duration_seconds"));
assert!(names.contains(&"crank_mcp_requests_total"));
assert!(names.contains(&"crank_mcp_active_sessions"));
assert!(names.contains(&"crank_mcp_active_streams"));
assert!(names.contains(&"crank_tool_invocations_total"));
assert!(names.contains(&"crank_runtime_inflight"));
assert!(names.contains(&"crank_runtime_cache_total"));
assert!(names.contains(&"crank_idempotency_total"));
assert!(names.contains(&"crank_confirmation_total"));
assert!(names.contains(&"crank_db_pool_connections"));
assert!(names.contains(&"crank_catalog_tools"));
assert!(names.contains(&"crank_invocation_history_lost_total"));
assert!(names.contains(&"crank_telemetry_export_failures_total"));
for metric in schema {
for forbidden in [
"workspace",
"agent_id",
"operation_id",
"request_id",
"trace_id",
"correlation_id",
"url",
"error_message",
"text",
] {
assert!(
!metric.labels.contains(&forbidden),
"{} exposes forbidden label {forbidden}",
metric.name
);
}
}
assert_eq!(
DURATION_BUCKETS_SECONDS,
&[
0.005, 0.01, 0.025, 0.05, 0.1, 0.25, 0.5, 1.0, 2.5, 5.0, 10.0, 30.0, 60.0
]
);
}
#[tokio::test]
async fn external_surface_protects_both_routes_and_exposes_nothing_else() {
let token = "metrics-canary-secret";
let config = MetricsConfig::new(
true,
SocketAddr::new(IpAddr::V4(Ipv4Addr::UNSPECIFIED), 9464),
Some(token.to_owned()),
)
.expect("external metrics with token");
let surface = MetricsSurface::for_test(config, identity()).expect("test metrics surface");
let app = surface.router();
for path in ["/metrics", "/health"] {
let unauthorized = app
.clone()
.oneshot(Request::get(path).body(Body::empty()).expect("request"))
.await
.expect("response");
assert_eq!(unauthorized.status(), StatusCode::UNAUTHORIZED);
let authorized = app
.clone()
.oneshot(
Request::get(path)
.header(header::AUTHORIZATION, format!("bEaReR {token}"))
.body(Body::empty())
.expect("request"),
)
.await
.expect("response");
assert_eq!(authorized.status(), StatusCode::OK);
let body = to_bytes(authorized.into_body(), 1024 * 1024)
.await
.expect("bounded body");
assert!(!String::from_utf8_lossy(&body).contains(token));
}
for authorization in [None, Some(format!("Bearer {token}"))] {
let mut request = Request::get("/api/operations");
if let Some(authorization) = authorization {
request = request.header(header::AUTHORIZATION, authorization);
}
let absent = app
.clone()
.oneshot(request.body(Body::empty()).expect("request"))
.await
.expect("response");
assert_eq!(absent.status(), StatusCode::NOT_FOUND);
}
}
async fn raw_get(port: u16, path: &str) -> String {
let mut stream = tokio::net::TcpStream::connect((Ipv4Addr::LOCALHOST, port))
.await
.expect("metrics listener connection");
stream
.write_all(
format!("GET {path} HTTP/1.1\r\nHost: 127.0.0.1:{port}\r\nConnection: close\r\n\r\n")
.as_bytes(),
)
.await
.expect("metrics request");
let mut response = Vec::new();
stream
.read_to_end(&mut response)
.await
.expect("metrics response");
String::from_utf8(response).expect("utf-8 response")
}
/// Story 3.6 — process-global binding: случаи, требующие другого состояния,
/// исполняются в fresh child того же тест-бинаря (никакого global reset).
fn route_to_child(role: &str, test: &str) -> bool {
const ROLE_ENV: &str = "CRANK_OBS_TEST_ROLE";
match std::env::var(ROLE_ENV).ok().as_deref() {
Some(actual) if actual == role => false,
Some(actual) => panic!("child for {test} runs with role {actual}, expected {role}"),
None => {
let output =
std::process::Command::new(std::env::current_exe().expect("current test binary"))
.args([test, "--exact", "--nocapture"])
.env(ROLE_ENV, role)
.output()
.expect("re-executed observability child");
assert!(
output.status.success(),
"child {role}/{test} failed:\nstdout:\n{}\nstderr:\n{}",
String::from_utf8_lossy(&output.stdout),
String::from_utf8_lossy(&output.stderr)
);
true
}
}
}
/// TD-B7 — recorder identity обязана совпадать с уже опубликованным binding.
#[test]
fn recorder_identity_must_match_binding() {
if route_to_child("admin_api", "recorder_identity_must_match_binding") {
return;
}
crank_metrics::bind_metric_service(crank_metrics::MetricService::AdminApi)
.expect("admin binding");
let mismatched = ServiceIdentity::try_new("mcp-server", "0.3.1", "test").expect("identity");
let error = crank_observability::init(crank_observability::ObservabilityConfig::new(
mismatched,
"off",
crank_observability::RedactionLimits::default(),
))
.expect_err("mismatched recorder identity must be terminal");
assert!(!error.to_string().is_empty());
assert_eq!(
crank_metrics::bound_metric_service(),
Some(crank_metrics::MetricService::AdminApi),
"провал установки recorder не меняет binding"
);
}
/// TD-E7 — `MetricsSurface::for_test` строит локальный renderer и никогда не
/// меняет process binding.
#[test]
fn metrics_surface_never_rebinds_service() {
if route_to_child("mcp_surface", "metrics_surface_never_rebinds_service") {
return;
}
crank_metrics::bind_metric_service(crank_metrics::MetricService::McpServer)
.expect("mcp binding");
let config = MetricsConfig::new(
true,
SocketAddr::new(IpAddr::V4(Ipv4Addr::LOCALHOST), 9464),
None,
)
.expect("loopback metrics config");
let admin_identity = ServiceIdentity::try_new("admin-api", "0.3.1", "test").expect("identity");
let mcp_surface = MetricsSurface::for_test(config.clone(), admin_identity)
.expect("local renderer for another service is allowed");
assert_eq!(
crank_metrics::bound_metric_service(),
Some(crank_metrics::MetricService::McpServer),
"for_test не может менять процессный binding"
);
let own_identity = ServiceIdentity::try_new("mcp-server", "0.3.1", "test").expect("identity");
let _ = MetricsSurface::for_test(config, own_identity).expect("own surface");
assert_eq!(
crank_metrics::bound_metric_service(),
Some(crank_metrics::MetricService::McpServer)
);
let _ = mcp_surface;
}