#![forbid(unsafe_code)]
pub const TARGET_RUNTIME: &str = "ftui.runtime";
pub const TARGET_RUNTIME_LOG: &str = "ftui.runtime.log";
pub const TARGET_EFFECT: &str = "ftui.effect";
pub const TARGET_PROCESS: &str = "ftui.process";
pub const TARGET_RESIZE: &str = "ftui.decision.resize";
pub const TARGET_VOI: &str = "ftui.voi";
pub const TARGET_BOCPD: &str = "ftui.bocpd";
pub const TARGET_EPROCESS: &str = "ftui.eprocess";
pub const TARGET_GUARDRAILS: &str = "ftui.guardrails";
pub const TARGET_A11Y: &str = "ftui.a11y";
pub const TARGET_WIDTH_CACHE: &str = "ftui.text.width_cache";
pub const TARGET_LOCALE: &str = "ftui.runtime.locale";
pub mod span {
pub const PROGRAM_INIT: &str = "ftui.program.init";
pub const PROGRAM_UPDATE: &str = "ftui.program.update";
pub const PROGRAM_VIEW: &str = "ftui.program.view";
pub const PROGRAM_SUBSCRIPTIONS: &str = "ftui.program.subscriptions";
pub const PROGRAM_SHUTDOWN: &str = "ftui.program.shutdown";
pub const PROGRAM_ERROR: &str = "ftui.program.error";
pub const RENDER_FRAME: &str = "ftui.render.frame";
pub const RENDER_DIFF: &str = "ftui.render.diff";
pub const RENDER_DIFF_COMPUTE: &str = "ftui.render.diff_compute";
pub const RENDER_PRESENT: &str = "ftui.render.present";
pub const RENDER_EMIT: &str = "ftui.render.emit";
pub const RENDER_FLUSH: &str = "ftui.render.flush";
pub const RENDER_SCROLL_REGION: &str = "ftui.render.scroll_region";
pub const INPUT_EVENT: &str = "ftui.input.event";
pub const INPUT_MACRO: &str = "ftui.input.macro";
}
pub mod decision {
pub const DEGRADATION: &str = "ftui.decision.degradation";
pub const FALLBACK: &str = "ftui.decision.fallback";
pub const RESIZE: &str = "ftui.decision.resize";
pub const SCREEN_MODE: &str = "ftui.decision.screen_mode";
}
pub mod event {
pub const RUNTIME_STARTUP: &str = "runtime.startup";
pub const EFFECT_QUEUE_SHUTDOWN: &str = "effect_queue.shutdown";
pub const SPAWN_EXECUTOR_SHUTDOWN: &str = "spawn_executor.shutdown";
pub const SUBSCRIPTION_STOP_ALL: &str = "subscription.stop_all";
pub const SUBSCRIPTION_STOP: &str = "subscription.stop";
pub const EFFECT_COMMAND: &str = "effect.command";
pub const EFFECT_SUBSCRIPTION: &str = "effect.subscription";
pub const QUEUE_DROP: &str = "effect_queue.drop";
pub const EFFECT_TIMEOUT: &str = "effect.timeout";
pub const EFFECT_PANIC: &str = "effect.panic";
}
pub mod evidence {
pub const A11Y_ANNOUNCEMENT: &str = "a11y_announcement";
pub const A11Y_TREE: &str = "a11y_tree";
pub const BOCPD: &str = "bocpd";
pub const BUDGET_DECISION: &str = "budget_decision";
pub const CAPABILITY_DECISION: &str = "capability_decision";
pub const CERTIFICATE_DECISION: &str = "certificate_decision";
pub const CONFIG: &str = "config";
pub const CYCLE_TIME_PERCENTILES: &str = "cycle_time_percentiles";
pub const DECISION: &str = "decision";
pub const DECISION_EVIDENCE: &str = "decision_evidence";
pub const DIFF_DECISION: &str = "diff_decision";
pub const DIFF_REGIME_TRANSITION: &str = "diff_regime_transition";
pub const EFFECT_QUEUE_SELECT: &str = "effect_queue_select";
pub const FAIRNESS_CONFIG: &str = "fairness_config";
pub const FAIRNESS_DECISION: &str = "fairness_decision";
pub const GUARDRAIL_SNAPSHOT: &str = "guardrail_snapshot";
pub const INLINE_STRATEGY: &str = "inline_strategy";
pub const INLINE_STRATEGY_FALLBACK: &str = "inline_strategy_fallback";
pub const REGIME_TRANSITION: &str = "regime_transition";
pub const SUMMARY: &str = "summary";
pub const TASK_EXECUTOR_BACKEND: &str = "task_executor_backend";
pub const TASK_EXECUTOR_BACKPRESSURE: &str = "task_executor_backpressure";
pub const TASK_EXECUTOR_COMPLETE: &str = "task_executor_complete";
pub const TASK_EXECUTOR_PANIC: &str = "task_executor_panic";
pub const VOI_DECISION: &str = "voi_decision";
pub const VOI_OBSERVE: &str = "voi_observe";
pub const WIDGET_REFRESH: &str = "widget_refresh";
pub const WIDTH_CACHE_STATS: &str = "width_cache_stats";
}
pub mod metric {
pub const EFFECTS_COMMAND_TOTAL: &str = "effects_command_total";
pub const EFFECTS_SUBSCRIPTION_TOTAL: &str = "effects_subscription_total";
pub const EFFECTS_EXECUTED_TOTAL: &str = "effects_executed_total";
pub const EFFECTS_QUEUE_ENQUEUED: &str = "effects_queue_enqueued";
pub const EFFECTS_QUEUE_PROCESSED: &str = "effects_queue_processed";
pub const EFFECTS_QUEUE_DROPPED: &str = "effects_queue_dropped";
pub const EFFECTS_QUEUE_HIGH_WATER: &str = "effects_queue_high_water";
pub const EFFECTS_QUEUE_IN_FLIGHT: &str = "effects_queue_in_flight";
}
pub mod field {
pub const ELAPSED_US: &str = "elapsed_us";
pub const DURATION_US: &str = "duration_us";
pub const SUB_ID: &str = "sub_id";
pub const COMMAND_TYPE: &str = "command_type";
pub const REQUESTED_LANE: &str = "requested_lane";
pub const RESOLVED_LANE: &str = "resolved_lane";
pub const ROLLOUT_POLICY: &str = "rollout_policy";
pub const TIMEOUT_MS: &str = "timeout_ms";
pub const PENDING_HANDLES: &str = "pending_handles";
pub const REASON: &str = "reason";
}
pub const SCHEMA_VERSION: &str = "1.0.0";
pub const ALL_TARGETS: &[&str] = &[
TARGET_RUNTIME,
TARGET_RUNTIME_LOG,
TARGET_EFFECT,
TARGET_PROCESS,
TARGET_RESIZE,
TARGET_VOI,
TARGET_BOCPD,
TARGET_EPROCESS,
TARGET_GUARDRAILS,
TARGET_A11Y,
TARGET_WIDTH_CACHE,
TARGET_LOCALE,
];
pub const ALL_SPANS: &[&str] = &[
span::PROGRAM_INIT,
span::PROGRAM_UPDATE,
span::PROGRAM_VIEW,
span::PROGRAM_SUBSCRIPTIONS,
span::PROGRAM_SHUTDOWN,
span::PROGRAM_ERROR,
span::RENDER_FRAME,
span::RENDER_DIFF,
span::RENDER_DIFF_COMPUTE,
span::RENDER_PRESENT,
span::RENDER_EMIT,
span::RENDER_FLUSH,
span::RENDER_SCROLL_REGION,
span::INPUT_EVENT,
span::INPUT_MACRO,
];
pub const ALL_DECISIONS: &[&str] = &[
decision::DEGRADATION,
decision::FALLBACK,
decision::RESIZE,
decision::SCREEN_MODE,
];
pub const ALL_EVENTS: &[&str] = &[
event::RUNTIME_STARTUP,
event::EFFECT_QUEUE_SHUTDOWN,
event::SPAWN_EXECUTOR_SHUTDOWN,
event::SUBSCRIPTION_STOP_ALL,
event::SUBSCRIPTION_STOP,
event::EFFECT_COMMAND,
event::EFFECT_SUBSCRIPTION,
event::QUEUE_DROP,
event::EFFECT_TIMEOUT,
event::EFFECT_PANIC,
];
pub const ALL_METRICS: &[&str] = &[
metric::EFFECTS_COMMAND_TOTAL,
metric::EFFECTS_SUBSCRIPTION_TOTAL,
metric::EFFECTS_EXECUTED_TOTAL,
metric::EFFECTS_QUEUE_ENQUEUED,
metric::EFFECTS_QUEUE_PROCESSED,
metric::EFFECTS_QUEUE_DROPPED,
metric::EFFECTS_QUEUE_HIGH_WATER,
metric::EFFECTS_QUEUE_IN_FLIGHT,
];
pub const ALL_EVIDENCE_EVENTS: &[&str] = &[
evidence::A11Y_ANNOUNCEMENT,
evidence::A11Y_TREE,
evidence::BOCPD,
evidence::BUDGET_DECISION,
evidence::CAPABILITY_DECISION,
evidence::CERTIFICATE_DECISION,
evidence::CONFIG,
evidence::CYCLE_TIME_PERCENTILES,
evidence::DECISION,
evidence::DECISION_EVIDENCE,
evidence::DIFF_DECISION,
evidence::DIFF_REGIME_TRANSITION,
evidence::EFFECT_QUEUE_SELECT,
evidence::FAIRNESS_CONFIG,
evidence::FAIRNESS_DECISION,
evidence::GUARDRAIL_SNAPSHOT,
evidence::INLINE_STRATEGY,
evidence::INLINE_STRATEGY_FALLBACK,
evidence::REGIME_TRANSITION,
evidence::SUMMARY,
evidence::TASK_EXECUTOR_BACKEND,
evidence::TASK_EXECUTOR_BACKPRESSURE,
evidence::TASK_EXECUTOR_COMPLETE,
evidence::TASK_EXECUTOR_PANIC,
evidence::VOI_DECISION,
evidence::VOI_OBSERVE,
evidence::WIDGET_REFRESH,
evidence::WIDTH_CACHE_STATS,
];
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn schema_version_is_semver() {
let parts: Vec<&str> = SCHEMA_VERSION.split('.').collect();
assert_eq!(parts.len(), 3, "schema version must be semver");
for part in &parts {
assert!(
part.parse::<u32>().is_ok(),
"each semver component must be a number: {part}"
);
}
}
#[test]
fn all_targets_are_dotted() {
for target in ALL_TARGETS {
assert!(
target.contains('.'),
"target should be dotted namespace: {target}"
);
assert!(
target.starts_with("ftui."),
"target should start with ftui.: {target}"
);
}
}
#[test]
fn all_events_have_dotted_names() {
for event in ALL_EVENTS {
assert!(event.contains('.'), "event name should be dotted: {event}");
}
}
#[test]
fn all_metrics_are_snake_case() {
for metric in ALL_METRICS {
assert!(
metric.chars().all(|c| c.is_ascii_lowercase() || c == '_'),
"metric name should be snake_case: {metric}"
);
}
}
#[test]
fn no_duplicate_targets() {
let mut seen = std::collections::HashSet::new();
for target in ALL_TARGETS {
assert!(seen.insert(target), "duplicate target: {target}");
}
}
#[test]
fn no_duplicate_events() {
let mut seen = std::collections::HashSet::new();
for event in ALL_EVENTS {
assert!(seen.insert(event), "duplicate event: {event}");
}
}
#[test]
fn no_duplicate_metrics() {
let mut seen = std::collections::HashSet::new();
for metric in ALL_METRICS {
assert!(seen.insert(metric), "duplicate metric: {metric}");
}
}
#[test]
fn all_spans_are_dotted_and_unique() {
let mut seen = std::collections::HashSet::new();
for span in ALL_SPANS {
assert!(
span.starts_with("ftui."),
"span should start with ftui.: {span}"
);
assert!(seen.insert(span), "duplicate span: {span}");
}
for decision in ALL_DECISIONS {
assert!(
decision.starts_with("ftui.decision."),
"decision event should start with ftui.decision.: {decision}"
);
}
}
#[test]
fn no_stray_target_literals() {
use std::path::{Path, PathBuf};
let root = Path::new(env!("CARGO_MANIFEST_DIR"))
.join("../..")
.canonicalize()
.expect("workspace root");
let allowlist_path = root.join("docs/telemetry-target-literal-allowlist.txt");
let allowlist: Vec<PathBuf> = std::fs::read_to_string(&allowlist_path)
.map(|text| {
text.lines()
.map(str::trim)
.filter(|line| !line.is_empty() && !line.starts_with('#'))
.map(|line| root.join(line))
.collect()
})
.unwrap_or_default();
let this_file = root.join("crates/ftui-runtime/src/telemetry_schema.rs");
let showcase_app = root.join("crates/ftui-demo-showcase/src/app.rs");
let core_lib = root.join("crates/ftui-core/src/lib.rs");
fn collect(dir: &Path, out: &mut Vec<PathBuf>) {
let Ok(entries) = std::fs::read_dir(dir) else {
return;
};
for entry in entries.flatten() {
let path = entry.path();
if path.is_dir() {
collect(&path, out);
} else if path.extension().is_some_and(|ext| ext == "rs") {
out.push(path);
}
}
}
let mut files = Vec::new();
for dir in [
"crates/ftui-runtime/src",
"crates/ftui-runtime/tests",
"crates/ftui-core/src",
"crates/ftui-render/src",
"crates/ftui-demo-showcase/src",
] {
collect(&root.join(dir), &mut files);
}
assert!(
files.len() > 50,
"source scan found too few files: {}",
files.len()
);
let is_literal = |line: &str| -> bool {
let trimmed = line.trim_start();
if trimmed.starts_with("//") {
return false;
}
let mut rest = trimmed;
while let Some(idx) = rest.find("\"ftui.") {
let after = &rest[idx + "\"".len()..];
let name_len = after
.bytes()
.take_while(|b| {
b.is_ascii_lowercase() || b.is_ascii_digit() || *b == b'.' || *b == b'_'
})
.count();
if after.as_bytes().get(name_len) == Some(&b'"') {
return true;
}
rest = &after[name_len..];
}
false
};
let is_definition = |line: &str| -> bool {
let trimmed = line.trim_start();
(trimmed.starts_with("pub const ")
|| trimmed.starts_with("pub(crate) const ")
|| trimmed.starts_with("const "))
&& trimmed.contains(": &str = \"ftui.")
};
let mut offenders = Vec::new();
for file in files {
if file == this_file || allowlist.contains(&file) {
continue;
}
let Ok(text) = std::fs::read_to_string(&file) else {
continue;
};
for (idx, line) in text.lines().enumerate() {
if !is_literal(line) {
continue;
}
if (file == showcase_app || file == core_lib) && is_definition(line) {
continue;
}
offenders.push(format!(
"{}:{}: {}",
file.strip_prefix(&root).unwrap_or(&file).display(),
idx + 1,
line.trim()
));
}
}
assert!(
offenders.is_empty(),
"tracing targets and span names must use telemetry_schema constants:\n{}",
offenders.join("\n")
);
}
#[test]
fn core_width_cache_target_matches_schema() {
assert_eq!(
TARGET_WIDTH_CACHE,
ftui_core::text_width::TARGET_WIDTH_CACHE
);
}
#[test]
fn all_targets_include_guardrails_and_a11y() {
assert!(ALL_TARGETS.contains(&TARGET_GUARDRAILS));
assert!(ALL_TARGETS.contains(&TARGET_A11Y));
}
#[test]
fn all_targets_unique_and_prefixed() {
let mut seen = std::collections::HashSet::new();
for target in ALL_TARGETS {
assert!(
target.starts_with("ftui."),
"target must start with ftui.: {target}"
);
assert!(seen.insert(target), "duplicate target: {target}");
}
}
#[test]
fn all_evidence_events_unique_and_snake_case() {
let mut seen = std::collections::HashSet::new();
for event in ALL_EVIDENCE_EVENTS {
assert!(
event
.chars()
.all(|c| c.is_ascii_lowercase() || c.is_ascii_digit() || c == '_'),
"evidence event must be snake_case: {event}"
);
assert!(seen.insert(event), "duplicate evidence event: {event}");
}
}
#[test]
fn schema_events_match_constants() {
let root = std::path::Path::new(env!("CARGO_MANIFEST_DIR"))
.join("../..")
.canonicalize()
.expect("workspace root");
let schema_path = root.join("tests/e2e/lib/e2e_evidence_schema.json");
let text = std::fs::read_to_string(&schema_path).expect("e2e_evidence_schema.json");
let json: serde_json::Value = serde_json::from_str(&text).expect("valid json");
let events_obj = json
.get("events")
.and_then(|v| v.as_object())
.expect("events object");
let schema_keys: std::collections::BTreeSet<&str> =
events_obj.keys().map(String::as_str).collect();
let const_keys: std::collections::BTreeSet<&str> =
ALL_EVIDENCE_EVENTS.iter().copied().collect();
assert_eq!(
schema_keys, const_keys,
"evidence schema events must match ALL_EVIDENCE_EVENTS"
);
}
}