//! Named, persistable bundles of parsing/indexing rules and dashboards for a CLI app. //! Ticket 049 folded profile storage inline into `Settings` (`settings.json`) instead of a separate //! `profiles.json`; this module still owns the `Profile`/`Dashboard`/declaration data model, plus the //! CRUD methods on `Settings` (`impl Settings` below `ProfileError`) that used to live on the //! now-removed `ProfileStore`. #![allow(dead_code)] use std::collections::hash_map::DefaultHasher; use std::collections::BTreeMap; use std::fmt; use std::fs; use std::hash::{Hash, Hasher}; use std::io; use std::path::Path; use std::time::{SystemTime, UNIX_EPOCH}; use serde::{Deserialize, Serialize}; use crate::data_value::MetricPrimitiveKind; use crate::engine::{DeclareMetricRequest, DeclareParamRequest, EngineHandle, EngineMessage}; use crate::settings::Settings; use tokio::sync::oneshot; /// Name of the profile that always exists and can't be deleted (see `Settings::ensure_default_profile`). pub const DEFAULT_PROFILE_NAME: &str = "Default"; /// Mirrors `data_value::MetricPrimitiveKind` with `Serialize`/`Deserialize` so profiles can round-trip through JSON, since the engine-internal type only derives `Serialize`. #[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)] #[serde(rename_all = "lowercase")] pub enum ProfileMetricPrimitiveKind { String, Number, Timestamp, /// Mirrors `MetricPrimitiveKind::Duration`. Duration, /// Mirrors `MetricPrimitiveKind::Boolean`. Boolean, } impl From for ProfileMetricPrimitiveKind { fn from(kind: MetricPrimitiveKind) -> Self { match kind { MetricPrimitiveKind::String => ProfileMetricPrimitiveKind::String, MetricPrimitiveKind::Number => ProfileMetricPrimitiveKind::Number, MetricPrimitiveKind::Timestamp => ProfileMetricPrimitiveKind::Timestamp, MetricPrimitiveKind::Duration => ProfileMetricPrimitiveKind::Duration, MetricPrimitiveKind::Boolean => ProfileMetricPrimitiveKind::Boolean, } } } impl From for MetricPrimitiveKind { fn from(kind: ProfileMetricPrimitiveKind) -> Self { match kind { ProfileMetricPrimitiveKind::String => MetricPrimitiveKind::String, ProfileMetricPrimitiveKind::Number => MetricPrimitiveKind::Number, ProfileMetricPrimitiveKind::Timestamp => MetricPrimitiveKind::Timestamp, ProfileMetricPrimitiveKind::Duration => MetricPrimitiveKind::Duration, ProfileMetricPrimitiveKind::Boolean => MetricPrimitiveKind::Boolean, } } } /// A stored param declaration, matching `DeclareParamRequest`'s shape (== `data_value::ParamDeclaration`). #[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] pub struct ParamDeclarationRecord { pub name: String, pub message_match_regex: String, pub capture_group: String, /// See `crate::data_value::ParamDeclaration::json_field_path`; `#[serde(default)]` /// so profiles saved before this field existed still load as plain regex-capture-group params. #[serde(default)] pub json_field_path: Option, pub kind: ProfileMetricPrimitiveKind, /// See `crate::data_value::ParamDeclaration::elapsed_since_last`; `#[serde(default)]` so /// profiles saved before ticket 038 (where a `Duration`-kind value param implicitly meant this) /// still load — `migrate_duration_value_params` below converts those. #[serde(default)] pub elapsed_since_last: bool, } impl From<&DeclareParamRequest> for ParamDeclarationRecord { fn from(request: &DeclareParamRequest) -> Self { ParamDeclarationRecord { name: request.name.clone(), message_match_regex: request.message_match_regex.clone(), capture_group: request.capture_group.clone(), json_field_path: request.json_field_path.clone(), kind: request.kind.into(), elapsed_since_last: request.elapsed_since_last, } } } impl From<&ParamDeclarationRecord> for DeclareParamRequest { fn from(record: &ParamDeclarationRecord) -> Self { DeclareParamRequest { name: record.name.clone(), message_match_regex: record.message_match_regex.clone(), capture_group: record.capture_group.clone(), json_field_path: record.json_field_path.clone(), kind: record.kind.into(), elapsed_since_last: record.elapsed_since_last, // A profile only ever stores manually-declared params (see `record_param_declaration`). auto_derived: false, } } } /// Pre-037 role of an inline metric param matcher — a label identifying a bucket, or the (at most /// one) value that becomes the event's captured value. Kept only so `LegacyMetricParamRecord` can /// still deserialize a profile saved before params were unified into standalone `ParamDeclaration`s /// referenced by name; see `migrate_legacy_metric_params`. #[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, Default)] #[serde(rename_all = "lowercase")] enum LegacyParamRole { #[default] Label, Value, } /// Pre-037 inline metric param matcher shape (formerly `data_value::RegexToMetricPrimitiveMatcher`), /// kept only to support migrating profiles saved before ticket 037 unified params — see /// `migrate_legacy_metric_params`. Never produced when serializing a record built from a /// `DeclareMetricRequest`. #[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] struct LegacyMetricParamRecord { param_name: String, capture_group: String, #[serde(default)] json_field_path: Option, kind: ProfileMetricPrimitiveKind, #[serde(default)] role: LegacyParamRole, } /// A stored metric declaration, matching `DeclareMetricRequest`'s shape. `legacy_params` is only /// ever populated by deserializing a pre-037 profile file (old key name `"params"`) — see /// `migrate_legacy_metric_params`, which converts it into `label_params`/`value_param` plus any /// implicitly-created standalone params, and empties it back out so a subsequent save never writes /// the old shape again. #[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] pub struct MetricDeclarationRecord { pub name: String, pub message_match_regex: String, /// Names of standalone `ParamDeclarationRecord`s used as this metric's bucket labels. #[serde(default)] pub label_params: Vec, /// Name of the standalone `ParamDeclarationRecord` (if any) whose value becomes this metric's bucket value. #[serde(default)] pub value_param: Option, /// See `crate::engine::DeclareMetricRequest::matched_labels`; `#[serde(default)]` so older profiles still load. #[serde(default)] pub matched_labels: Option>, /// See `crate::engine::DeclareMetricRequest::unmatched_labels`; `#[serde(default)]` so older profiles still load. #[serde(default)] pub unmatched_labels: Option>, #[serde(default, rename = "params", skip_serializing_if = "Vec::is_empty")] legacy_params: Vec, } impl From<&DeclareMetricRequest> for MetricDeclarationRecord { fn from(request: &DeclareMetricRequest) -> Self { MetricDeclarationRecord { name: request.name.clone(), message_match_regex: request.message_match_regex.clone(), label_params: request.label_params.clone(), value_param: request.value_param.clone(), matched_labels: request.matched_labels.clone(), unmatched_labels: request.unmatched_labels.clone(), legacy_params: Vec::new(), } } } impl From<&MetricDeclarationRecord> for DeclareMetricRequest { fn from(record: &MetricDeclarationRecord) -> Self { DeclareMetricRequest { name: record.name.clone(), message_match_regex: record.message_match_regex.clone(), label_params: record.label_params.clone(), value_param: record.value_param.clone(), matched_labels: record.matched_labels.clone(), unmatched_labels: record.unmatched_labels.clone(), } } } /// Migrates every metric in `profile` still carrying pre-037 inline matchers /// (`MetricDeclarationRecord::legacy_params`, deserialized from an old profile file's `"params"` /// key) into the unified shape: each matcher becomes a reference to a standalone /// `ParamDeclarationRecord`, resolved by reusing an existing declared param of the exact same name /// and shape (regex/capture-group-or-json-field-path/kind) when one exists, or else creating a new /// one implicitly named `.` (added to `profile.params`). Deterministic /// naming means re-running this on an already-migrated profile is a no-op, and running it twice on /// the same legacy data produces the same result. Returns whether anything changed, so the caller /// can decide whether to persist the migration. fn migrate_legacy_metric_params(profile: &mut Profile) -> bool { let mut migrated = false; for metric_index in 0..profile.metrics.len() { if profile.metrics[metric_index].legacy_params.is_empty() { continue; } let metric_name = profile.metrics[metric_index].name.clone(); let message_match_regex = profile.metrics[metric_index].message_match_regex.clone(); let legacy = std::mem::take(&mut profile.metrics[metric_index].legacy_params); let mut label_params = Vec::new(); let mut value_param = None; for matcher in &legacy { let param_name = resolve_or_create_legacy_param(profile, &metric_name, &message_match_regex, matcher); match matcher.role { LegacyParamRole::Label => label_params.push(param_name), LegacyParamRole::Value => value_param = Some(param_name), } } profile.metrics[metric_index].label_params = label_params; profile.metrics[metric_index].value_param = value_param; migrated = true; } migrated } /// Resolves one legacy matcher to a standalone param name, reusing an existing declared param of /// the same bare name and shape, or else creating `.` on `profile.params`. fn resolve_or_create_legacy_param( profile: &mut Profile, metric_name: &str, message_match_regex: &str, matcher: &LegacyMetricParamRecord, ) -> String { if let Some(existing) = profile.params.iter().find(|p| p.name == matcher.param_name) { if existing.message_match_regex == message_match_regex && existing.capture_group == matcher.capture_group && existing.json_field_path == matcher.json_field_path && existing.kind == matcher.kind { return existing.name.clone(); } } let implicit_name = format!("{metric_name}.{}", matcher.param_name); if !profile.params.iter().any(|p| p.name == implicit_name) { profile.params.push(ParamDeclarationRecord { name: implicit_name.clone(), message_match_regex: message_match_regex.to_string(), capture_group: matcher.capture_group.clone(), json_field_path: matcher.json_field_path.clone(), kind: matcher.kind, // Pre-037, a Value-role Duration matcher implicitly meant "elapsed time since the // previous same-labeled event" (ticket 038's now-explicit `elapsed_since_last`) — carry // that meaning forward rather than dropping it into a meaningless literal-parse matcher. elapsed_since_last: matcher.role == LegacyParamRole::Value && matcher.kind == ProfileMetricPrimitiveKind::Duration, }); } implicit_name } /// Migrates every already-declared `Duration`-kind param that's referenced as some metric's /// `value_param` into the explicit `elapsed_since_last` extractor (ticket 038). Before ticket 038, a /// `Duration`-kind value param implicitly meant "elapsed time since the previous same-labeled /// event" (see `crate::engine::apply_metric_to_log`'s pre-038 history) — this migration makes that /// meaning explicit so `Duration` kind no longer has a role-dependent special case. Only params /// actually referenced as *some* metric's value param are converted: a `Duration`-kind param used /// purely as a label param already meant a literal parsed millisecond count, and keeps meaning that. /// Runs after `migrate_legacy_metric_params` (which populates `value_param` from pre-037 /// `legacy_params` and already sets `elapsed_since_last` correctly for those via /// `resolve_or_create_legacy_param`), so this only has new work to do for profiles saved between /// ticket 037 and ticket 038 landing, where `value_param` already pointed at a bare `Duration`-kind /// param straight from the unified shape. Returns whether anything changed. fn migrate_duration_value_params(profile: &mut Profile) -> bool { let value_param_names: std::collections::HashSet<&str> = profile.metrics.iter().filter_map(|metric| metric.value_param.as_deref()).collect(); let mut migrated = false; for param in &mut profile.params { if !param.elapsed_since_last && param.kind == ProfileMetricPrimitiveKind::Duration && value_param_names.contains(param.name.as_str()) { param.elapsed_since_last = true; migrated = true; } } migrated } /// A chart type a dashboard panel can render; kept in sync with the frontend's `'bar' | 'line' | 'pie'` union (see `webapp/src/lib/api.ts`). #[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)] #[serde(rename_all = "lowercase")] pub enum ChartType { Bar, Line, Pie, } /// One panel within a dashboard: a PromQL query plus how to chart its result. #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)] pub struct Panel { pub id: String, pub title: String, pub promql: String, pub chart_type: ChartType, } /// A named set of panels, saved as part of a profile. #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)] pub struct Dashboard { pub id: String, pub name: String, #[serde(default)] pub panels: Vec, } /// Generates an id by hashing a seed (dashboard/panel name) with the current time, avoiding a `uuid` dependency for what's otherwise an opaque string. fn generate_id(seed: &str) -> String { let mut hasher = DefaultHasher::new(); seed.hash(&mut hasher); let nanos = SystemTime::now() .duration_since(UNIX_EPOCH) .map(|d| d.as_nanos()) .unwrap_or(0); nanos.hash(&mut hasher); format!("{:016x}", hasher.finish()) } impl Dashboard { pub fn new(name: String) -> Dashboard { let id = generate_id(&name); Dashboard { id, name, panels: Vec::new() } } } /// Name of the metric seeded into a brand-new `Default` profile, used to drive its starter dashboard's two panels. const SEEDED_METRIC_NAME: &str = "log_category"; const SEEDED_METRIC_LABEL: &str = "category"; /// A counter that splits every line into `category="error"`/`"other"` via `matched_labels`/`unmatched_labels` rather than a captured param, so case variants like "ERROR" collapse into one series; the `regex` crate lacks the lookaround needed to express "didn't match" any other way. fn seeded_error_split_metric() -> MetricDeclarationRecord { MetricDeclarationRecord { name: SEEDED_METRIC_NAME.to_string(), message_match_regex: r"(?i)error".to_string(), label_params: Vec::new(), value_param: None, matched_labels: Some(BTreeMap::from([(SEEDED_METRIC_LABEL.to_string(), "error".to_string())])), unmatched_labels: Some(BTreeMap::from([(SEEDED_METRIC_LABEL.to_string(), "other".to_string())])), legacy_params: Vec::new(), } } /// The starter dashboard seeded into a brand-new `Default` profile: a line chart and a pie chart, both querying the seeded error-split counter. fn seeded_default_dashboard() -> Dashboard { let mut dashboard = Dashboard::new("Overview".to_string()); dashboard.panels = vec![ Panel { id: generate_id("error-volume-line"), title: "Error vs. non-error volume".to_string(), promql: format!("sum(rate({SEEDED_METRIC_NAME}[1m])) by ({SEEDED_METRIC_LABEL})"), chart_type: ChartType::Line, }, Panel { id: generate_id("error-volume-pie"), title: "Error vs. non-error ratio".to_string(), promql: SEEDED_METRIC_NAME.to_string(), chart_type: ChartType::Pie, }, ]; dashboard } /// A named bundle of parsing/indexing rules for a particular CLI app, plus any saved dashboards. #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)] pub struct Profile { pub name: String, #[serde(default)] pub params: Vec, #[serde(default)] pub metrics: Vec, #[serde(default)] pub dashboards: Vec, } impl Profile { pub fn new(name: String) -> Profile { Profile { name, params: Vec::new(), metrics: Vec::new(), dashboards: Vec::new(), } } } /// Replays every param/metric declaration stored in `profile` into `engine` (used on startup and in tests); any rejected declaration or send/recv failure is logged to stderr and skipped rather than panicking. pub async fn load_into_engine(engine: &EngineHandle, profile: &Profile) { for record in &profile.params { let (respond_to, response) = oneshot::channel(); let request: DeclareParamRequest = record.into(); let name = request.name.clone(); if engine .send(EngineMessage::DeclareParam { request, respond_to }) .await .is_err() { eprintln!("warning: engine unavailable while loading profile '{}'", profile.name); return; } match response.await { Ok(Ok(())) => {} Ok(Err(err)) => eprintln!( "warning: profile '{}' param declaration '{name}' rejected by engine: {err}", profile.name ), Err(_) => eprintln!( "warning: engine dropped response while declaring param '{name}' from profile '{}'", profile.name ), } } for record in &profile.metrics { let (respond_to, response) = oneshot::channel(); let request: DeclareMetricRequest = record.into(); let name = request.name.clone(); if engine .send(EngineMessage::DeclareMetric { request, respond_to }) .await .is_err() { eprintln!("warning: engine unavailable while loading profile '{}'", profile.name); return; } match response.await { Ok(Ok(())) => {} Ok(Err(err)) => eprintln!( "warning: profile '{}' metric declaration '{name}' rejected by engine: {err}", profile.name ), Err(_) => eprintln!( "warning: engine dropped response while declaring metric '{name}' from profile '{}'", profile.name ), } } } /// Error returned by `Settings`'s profile-related mutations and lookups. #[derive(Debug)] pub enum ProfileError { /// No profile with the given name exists. NotFound, /// A profile with the given name already exists. DuplicateName, /// The `Default` profile can't be deleted — there must always be at least one profile to fall back to. CannotDeleteDefault, /// Underlying I/O failure reading/writing the profile store or settings file. Io(io::Error), } impl fmt::Display for ProfileError { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { match self { ProfileError::NotFound => write!(f, "no profile with that name"), ProfileError::DuplicateName => write!(f, "a profile with that name already exists"), ProfileError::CannotDeleteDefault => write!(f, "the Default profile cannot be deleted"), ProfileError::Io(err) => write!(f, "I/O error: {err}"), } } } impl std::error::Error for ProfileError {} impl From for ProfileError { fn from(err: io::Error) -> Self { ProfileError::Io(err) } } /// Reads a legacy pre-049 `profiles.json` file (back when profiles lived in a separate file rather /// than inline in `settings.json`) for `Settings::migrate_legacy_profiles_file`. Returns `None` if /// the file doesn't exist or can't be read/parsed — treated as "nothing to migrate" rather than /// failing settings load. pub(crate) fn load_legacy_profile_store(path: &Path) -> Option> { let contents = fs::read_to_string(path).ok()?; match serde_json::from_str::>(&contents) { Ok(profiles) => Some(profiles), Err(err) => { eprintln!( "warning: failed to parse legacy profile store at {}: {err}; skipping migration", path.display() ); None } } } /// Turns any pre-unification/pre-explicit-duration metric or param shapes still present in /// `profiles` into their current form; used by `Settings::load` on every startup (previously done /// by the now-removed `ProfileStore::load`, before ticket 049 folded profile storage into /// `settings.json`). Returns whether anything changed, so the caller can decide whether to /// re-persist. /// /// Ticket 037: turn any pre-unification inline metric matchers into standalone param references. /// Deterministic naming makes this idempotent, so it's safe to run on every load; persisting the /// result isn't required for correctness (migration re-runs identically next time), but it's done /// here anyway so the on-disk file only carries the legacy `"params"` shape once, on the very next /// save. /// /// Ticket 038: follows on immediately after — once `migrate_legacy_metric_params` has resolved /// every metric's `value_param`, convert any `Duration`-kind param still referenced that way into /// the explicit `elapsed_since_last` extractor, so a profile saved either before 037 (inline /// matchers) or between 037 and 038 (bare `value_param` reference) ends up behaving identically /// under the new, explicit shape. pub(crate) fn migrate_legacy_profile_shapes(profiles: &mut [Profile]) -> bool { let mut any_migrated = false; for profile in profiles { let legacy_migrated = migrate_legacy_metric_params(profile); let duration_migrated = migrate_duration_value_params(profile); if legacy_migrated || duration_migrated { any_migrated = true; } } any_migrated } /// Profile CRUD, previously on the standalone `ProfileStore` (removed by ticket 049): every mutation /// here reads/writes `self.profiles` directly and persists via `Settings::save`, so `settings.json` is /// the single source of truth instead of a separate file kept in sync alongside it. impl Settings { pub fn profile(&self, name: &str) -> Option<&Profile> { self.profiles.iter().find(|p| p.name == name) } /// Creates a new profile named `name`, persisting settings, copying the active profile's /// params/metrics/dashboards as a starting point rather than starting blank. Fails with /// `DuplicateName` if the name exists. pub fn create_profile(&mut self, settings_path: &Path, name: String) -> Result<(), ProfileError> { if self.profile(&name).is_some() { return Err(ProfileError::DuplicateName); } let mut profile = Profile::new(name.clone()); if let Some(active) = self.active_profile.as_deref().and_then(|n| self.profile(n)) { profile.params = active.params.clone(); profile.metrics = active.metrics.clone(); profile.dashboards = active.dashboards.clone(); } self.profiles.push(profile); self.save(settings_path)?; Ok(()) } /// Deletes the profile named `name`, persisting settings, clearing `active_profile` if it was /// active. Fails with `NotFound`, or `CannotDeleteDefault` for the `Default` profile. pub fn delete_profile(&mut self, settings_path: &Path, name: &str) -> Result<(), ProfileError> { if name == DEFAULT_PROFILE_NAME { return Err(ProfileError::CannotDeleteDefault); } let index = self.profiles.iter().position(|p| p.name == name).ok_or(ProfileError::NotFound)?; self.profiles.remove(index); if self.active_profile.as_deref() == Some(name) { self.active_profile = None; } self.save(settings_path)?; Ok(()) } /// Ensures a `Default` profile exists (seeding a starter dashboard/metric only on first /// creation), and falls back to active if nothing else is. Called once on startup before anything /// else touches profiles. pub fn ensure_default_profile(&mut self, settings_path: &Path) -> Result<(), ProfileError> { if self.profile(DEFAULT_PROFILE_NAME).is_none() { let mut profile = Profile::new(DEFAULT_PROFILE_NAME.to_string()); profile.metrics.push(seeded_error_split_metric()); profile.dashboards.push(seeded_default_dashboard()); self.profiles.push(profile); } if self.active_profile.is_none() { self.active_profile = Some(DEFAULT_PROFILE_NAME.to_string()); } self.save(settings_path)?; Ok(()) } /// Sets (or clears, with `None`) the active profile. Fails with `NotFound` if `name` is `Some` /// and no such profile exists. Doesn't itself reload declarations into a running engine — that /// happens on next startup via `load_into_engine`. pub fn set_active_profile( &mut self, settings_path: &Path, name: Option, ) -> Result<(), ProfileError> { if let Some(name) = &name { if self.profile(name).is_none() { return Err(ProfileError::NotFound); } } self.active_profile = name; self.save(settings_path)?; Ok(()) } /// Empties `profile_name`'s stored param declarations, persisting settings — the counterpart to /// `record_param_declaration` for `DELETE /api/params` (ticket 052). A profile only ever stores /// manually-declared params (auto-derived ones live only in the engine, never persisted here), so /// this is enough to keep the whole set from reappearing on next load; the engine-side clear /// re-derives whatever auto params the retained log text still supports. pub fn clear_param_declarations( &mut self, settings_path: &Path, profile_name: &str, ) -> Result<(), ProfileError> { let profile = self .profiles .iter_mut() .find(|p| p.name == profile_name) .ok_or(ProfileError::NotFound)?; profile.params.clear(); self.save(settings_path)?; Ok(()) } /// Records/updates a declared param into `profile_name`'s stored declarations (matched by param /// name), persisting settings. Intended to be called by the HTTP API alongside declaring against /// the engine, so declarations survive a restart. pub fn record_param_declaration( &mut self, settings_path: &Path, profile_name: &str, request: &DeclareParamRequest, ) -> Result<(), ProfileError> { let profile = self .profiles .iter_mut() .find(|p| p.name == profile_name) .ok_or(ProfileError::NotFound)?; let record: ParamDeclarationRecord = request.into(); match profile.params.iter_mut().find(|r| r.name == record.name) { Some(existing) => *existing = record, None => profile.params.push(record), } self.save(settings_path)?; Ok(()) } /// Records/updates a declared metric into `profile_name`'s stored declarations (matched by metric /// name), persisting settings; same integration intent as `record_param_declaration`. /// /// `promoted_params` is any of the metric's referenced `label_params`/`value_param` that live /// only as auto-derived engine state (see `crate::engine::auto_declare_params`) rather than a /// persisted profile param — the caller (`ApiState::persist_metric_declaration`) resolves these /// against the live engine before calling in. Without persisting them alongside the metric, a /// restart would replay the metric before any log line re-derives its auto params, and the /// engine would reject it as referencing an undeclared param. Each is added only if `profile /// .params` doesn't already have an entry of that name, so an existing (e.g. manually-declared) /// param is never clobbered. pub fn record_metric_declaration( &mut self, settings_path: &Path, profile_name: &str, request: &DeclareMetricRequest, promoted_params: &[ParamDeclarationRecord], ) -> Result<(), ProfileError> { let profile = self .profiles .iter_mut() .find(|p| p.name == profile_name) .ok_or(ProfileError::NotFound)?; for param in promoted_params { if !profile.params.iter().any(|p| p.name == param.name) { profile.params.push(param.clone()); } } let record: MetricDeclarationRecord = request.into(); match profile.metrics.iter_mut().find(|r| r.name == record.name) { Some(existing) => *existing = record, None => profile.metrics.push(record), } self.save(settings_path)?; Ok(()) } /// Same as `record_metric_declaration`, for an in-place edit that may rename the metric: drops /// any persisted record under `old_name` first (when it differs from the new name) so a rename /// doesn't leave a stale duplicate declaration behind, then upserts by the new name as usual. /// `promoted_params` has the same meaning as in `record_metric_declaration`. pub fn record_metric_declaration_update( &mut self, settings_path: &Path, profile_name: &str, old_name: &str, request: &DeclareMetricRequest, promoted_params: &[ParamDeclarationRecord], ) -> Result<(), ProfileError> { let profile = self .profiles .iter_mut() .find(|p| p.name == profile_name) .ok_or(ProfileError::NotFound)?; if old_name != request.name { profile.metrics.retain(|r| r.name != old_name); } for param in promoted_params { if !profile.params.iter().any(|p| p.name == param.name) { profile.params.push(param.clone()); } } let record: MetricDeclarationRecord = request.into(); match profile.metrics.iter_mut().find(|r| r.name == record.name) { Some(existing) => *existing = record, None => profile.metrics.push(record), } self.save(settings_path)?; Ok(()) } /// Removes `name`'s persisted metric declaration from `profile_name` (ticket 051), so it doesn't /// reappear from `settings.json` on the next restart. A no-op (not an error) if the profile has /// no record under that name — matches `Settings::remove_css`'s sibling calls in spirit, but /// deleting an already-gone declaration is fine here since the caller (the API layer) has /// already confirmed against the live engine index whether the metric existed at all. pub fn remove_metric_declaration( &mut self, settings_path: &Path, profile_name: &str, name: &str, ) -> Result<(), ProfileError> { let profile = self .profiles .iter_mut() .find(|p| p.name == profile_name) .ok_or(ProfileError::NotFound)?; profile.metrics.retain(|r| r.name != name); self.save(settings_path)?; Ok(()) } /// Lists the dashboards saved on `profile_name`; fails with `NotFound` if it doesn't exist. pub fn list_dashboards(&self, profile_name: &str) -> Result<&[Dashboard], ProfileError> { let profile = self.profile(profile_name).ok_or(ProfileError::NotFound)?; Ok(&profile.dashboards) } /// Creates a new, empty dashboard named `name` on `profile_name`, persisting settings; fails /// with `NotFound` if the profile doesn't exist. pub fn create_dashboard( &mut self, settings_path: &Path, profile_name: &str, name: String, ) -> Result { let profile = self .profiles .iter_mut() .find(|p| p.name == profile_name) .ok_or(ProfileError::NotFound)?; let dashboard = Dashboard::new(name); profile.dashboards.push(dashboard.clone()); self.save(settings_path)?; Ok(dashboard) } /// Replaces the dashboard identified by `dashboard_id` with `dashboard`, persisting settings; /// `dashboard.id` is forced to `dashboard_id` so a caller can't change a dashboard's identity /// through this call. pub fn save_dashboard( &mut self, settings_path: &Path, profile_name: &str, dashboard_id: &str, mut dashboard: Dashboard, ) -> Result { let profile = self .profiles .iter_mut() .find(|p| p.name == profile_name) .ok_or(ProfileError::NotFound)?; let existing = profile .dashboards .iter_mut() .find(|d| d.id == dashboard_id) .ok_or(ProfileError::NotFound)?; dashboard.id = dashboard_id.to_string(); *existing = dashboard.clone(); self.save(settings_path)?; Ok(dashboard) } /// Deletes the dashboard identified by `dashboard_id` from `profile_name`, persisting settings; /// fails with `NotFound` if either doesn't exist. pub fn delete_dashboard( &mut self, settings_path: &Path, profile_name: &str, dashboard_id: &str, ) -> Result<(), ProfileError> { let profile = self .profiles .iter_mut() .find(|p| p.name == profile_name) .ok_or(ProfileError::NotFound)?; let index = profile .dashboards .iter() .position(|d| d.id == dashboard_id) .ok_or(ProfileError::NotFound)?; profile.dashboards.remove(index); self.save(settings_path)?; Ok(()) } } #[cfg(test)] mod tests { use super::*; use crate::data_value::MetricPrimitiveKind; use crate::dto::LogsParams; use crate::engine::{EngineMessage, EngineQuery, EngineResponse, IngestedLine}; use crate::timestamp::Timestamp; use tokio::sync::mpsc; fn param_request(name: &str, pattern: &str, capture_group: &str) -> DeclareParamRequest { DeclareParamRequest { name: name.to_string(), message_match_regex: pattern.to_string(), capture_group: capture_group.to_string(), json_field_path: None, kind: MetricPrimitiveKind::String, elapsed_since_last: false, auto_derived: false, } } fn metric_request(name: &str, pattern: &str, param_name: &str) -> DeclareMetricRequest { DeclareMetricRequest { name: name.to_string(), message_match_regex: pattern.to_string(), matched_labels: None, unmatched_labels: None, label_params: vec![param_name.to_string()], value_param: None, } } async fn ask(engine: &EngineHandle, query: EngineQuery) -> EngineResponse { let (respond_to, response) = oneshot::channel(); engine.send(EngineMessage::Query { query, respond_to }).await.unwrap(); response.await.unwrap() } #[test] fn create_list_get_delete_round_trip() { let dir = tempfile::tempdir().unwrap(); let settings_path = dir.path().join("settings.json"); let mut settings = Settings::default(); settings.create_profile(&settings_path, "web".to_string()).unwrap(); settings.create_profile(&settings_path, "worker".to_string()).unwrap(); assert_eq!(settings.profiles.len(), 2); assert!(settings.profile("web").is_some()); let dup = settings.create_profile(&settings_path, "web".to_string()); assert!(matches!(dup, Err(ProfileError::DuplicateName))); // Reload from disk: profiles persisted. let reloaded_settings = Settings::load(&settings_path); assert_eq!(reloaded_settings.profiles.len(), 2); assert!(reloaded_settings.profile("web").is_some()); assert!(reloaded_settings.profile("worker").is_some()); settings.delete_profile(&settings_path, "worker").unwrap(); assert!(settings.profile("worker").is_none()); assert_eq!(settings.profiles.len(), 1); let missing = settings.delete_profile(&settings_path, "worker"); assert!(matches!(missing, Err(ProfileError::NotFound))); } #[test] fn ensure_default_creates_default_and_activates_it_once() { let dir = tempfile::tempdir().unwrap(); let settings_path = dir.path().join("settings.json"); let mut settings = Settings::default(); settings.ensure_default_profile(&settings_path).unwrap(); assert!(settings.profile(DEFAULT_PROFILE_NAME).is_some()); assert_eq!(settings.active_profile, Some(DEFAULT_PROFILE_NAME.to_string())); // Idempotent: doesn't duplicate the profile or clobber an already-active (non-Default) profile. settings.create_profile(&settings_path, "web".to_string()).unwrap(); settings.set_active_profile(&settings_path, Some("web".to_string())).unwrap(); settings.ensure_default_profile(&settings_path).unwrap(); assert_eq!(settings.profiles.iter().filter(|p| p.name == DEFAULT_PROFILE_NAME).count(), 1); assert_eq!(settings.active_profile, Some("web".to_string())); } #[test] fn ensure_default_seeds_starter_dashboard_only_on_creation() { let dir = tempfile::tempdir().unwrap(); let settings_path = dir.path().join("settings.json"); let mut settings = Settings::default(); settings.ensure_default_profile(&settings_path).unwrap(); let default_profile = settings.profile(DEFAULT_PROFILE_NAME).unwrap(); assert_eq!(default_profile.metrics.len(), 1); assert_eq!(default_profile.metrics[0].name, SEEDED_METRIC_NAME); assert_eq!( default_profile.metrics[0].matched_labels, Some(BTreeMap::from([(SEEDED_METRIC_LABEL.to_string(), "error".to_string())])) ); assert_eq!( default_profile.metrics[0].unmatched_labels, Some(BTreeMap::from([(SEEDED_METRIC_LABEL.to_string(), "other".to_string())])) ); assert_eq!(default_profile.dashboards.len(), 1); let dashboard = &default_profile.dashboards[0]; assert_eq!(dashboard.panels.len(), 2); assert!(dashboard .panels .iter() .any(|p| p.chart_type == ChartType::Line && p.promql.contains(SEEDED_METRIC_NAME))); assert!(dashboard.panels.iter().any(|p| p.chart_type == ChartType::Pie && p.promql == SEEDED_METRIC_NAME)); // Reload (simulating a restart) and ensure_default again: must not re-seed or duplicate. let mut reloaded = Settings::load(&settings_path); reloaded.ensure_default_profile(&settings_path).unwrap(); let default_profile = reloaded.profile(DEFAULT_PROFILE_NAME).unwrap(); assert_eq!(default_profile.metrics.len(), 1); assert_eq!(default_profile.dashboards.len(), 1); } #[tokio::test] async fn seeded_metric_renders_real_error_vs_other_data() { use crate::engine::{self, EngineMessage, EngineQuery, EngineResponse, IngestedLine}; use crate::timestamp::Timestamp; use tokio::sync::mpsc; let dir = tempfile::tempdir().unwrap(); let settings_path = dir.path().join("settings.json"); let mut settings = Settings::default(); settings.ensure_default_profile(&settings_path).unwrap(); let default_profile = settings.profile(DEFAULT_PROFILE_NAME).unwrap().clone(); let (engine_tx, engine_rx) = mpsc::channel(128); let settings_handle = std::sync::Arc::new(std::sync::Mutex::new(settings.clone())); tokio::spawn(engine::run(engine_rx, settings_handle)); load_into_engine(&engine_tx, &default_profile).await; for (sequence, text) in [(0u64, "all good"), (1, "an ERROR happened"), (2, "fine again")] { engine_tx .send(EngineMessage::Ingest(IngestedLine { sequence, timestamp: Timestamp::from_millis(sequence as i64), text: text.to_string(), })) .await .unwrap(); } let response = ask( &engine_tx, EngineQuery::Promql { query: SEEDED_METRIC_NAME.to_string(), start_ms: None, end_ms: None }, ) .await; let EngineResponse::Promql(Ok(mut series)) = response else { panic!("expected a successful Promql response"); }; series.sort_by(|a, b| a.labels.get(SEEDED_METRIC_LABEL).cmp(&b.labels.get(SEEDED_METRIC_LABEL))); assert_eq!(series.len(), 2); assert_eq!(series[0].labels.get(SEEDED_METRIC_LABEL).map(String::as_str), Some("error")); assert_eq!(series[0].points.len(), 1); assert_eq!(series[1].labels.get(SEEDED_METRIC_LABEL).map(String::as_str), Some("other")); assert_eq!(series[1].points.len(), 2); } #[test] fn default_profile_cannot_be_deleted() { let dir = tempfile::tempdir().unwrap(); let settings_path = dir.path().join("settings.json"); let mut settings = Settings::default(); settings.ensure_default_profile(&settings_path).unwrap(); let err = settings.delete_profile(&settings_path, DEFAULT_PROFILE_NAME); assert!(matches!(err, Err(ProfileError::CannotDeleteDefault))); assert!(settings.profile(DEFAULT_PROFILE_NAME).is_some()); } #[test] fn create_copies_the_active_profile() { let dir = tempfile::tempdir().unwrap(); let settings_path = dir.path().join("settings.json"); let mut settings = Settings::default(); settings.create_profile(&settings_path, "web".to_string()).unwrap(); let param_req = param_request("level", r"level=(?P\w+)", "level"); settings.record_param_declaration(&settings_path, "web", ¶m_req).unwrap(); settings.create_dashboard(&settings_path, "web", "Overview".to_string()).unwrap(); settings.set_active_profile(&settings_path, Some("web".to_string())).unwrap(); settings.create_profile(&settings_path, "web-copy".to_string()).unwrap(); let copy = settings.profile("web-copy").unwrap().clone(); assert_eq!(copy.params, settings.profile("web").unwrap().params); assert_eq!(copy.dashboards, settings.profile("web").unwrap().dashboards); // With no active profile, new profiles start empty as before. settings.set_active_profile(&settings_path, None).unwrap(); settings.create_profile(&settings_path, "blank".to_string()).unwrap(); let blank = settings.profile("blank").unwrap(); assert!(blank.params.is_empty()); assert!(blank.dashboards.is_empty()); } #[test] fn set_active_updates_and_persists_settings() { let dir = tempfile::tempdir().unwrap(); let settings_path = dir.path().join("settings.json"); let mut settings = Settings::default(); settings.create_profile(&settings_path, "web".to_string()).unwrap(); settings.create_profile(&settings_path, "worker".to_string()).unwrap(); settings.set_active_profile(&settings_path, Some("web".to_string())).unwrap(); assert_eq!(settings.active_profile, Some("web".to_string())); // Switching to another known profile works and persists. settings.set_active_profile(&settings_path, Some("worker".to_string())).unwrap(); let reloaded = Settings::load(&settings_path); assert_eq!(reloaded.active_profile, Some("worker".to_string())); // Setting an unknown profile active is rejected, leaving the previous value. let err = settings.set_active_profile(&settings_path, Some("ghost".to_string())); assert!(matches!(err, Err(ProfileError::NotFound))); assert_eq!(settings.active_profile, Some("worker".to_string())); // Clearing the active profile works. settings.set_active_profile(&settings_path, None).unwrap(); assert_eq!(settings.active_profile, None); } #[test] fn record_param_and_metric_declarations_persist_into_profile() { let dir = tempfile::tempdir().unwrap(); let settings_path = dir.path().join("settings.json"); let mut settings = Settings::default(); settings.create_profile(&settings_path, "web".to_string()).unwrap(); let param_req = param_request("level", r"level=(?P\w+)", "level"); settings.record_param_declaration(&settings_path, "web", ¶m_req).unwrap(); let metric_req = metric_request("requests", r"duration=(?P\d+)", "duration"); settings.record_metric_declaration(&settings_path, "web", &metric_req, &[]).unwrap(); let profile = settings.profile("web").unwrap(); assert_eq!(profile.params.len(), 1); assert_eq!(profile.params[0].name, "level"); assert_eq!(profile.metrics.len(), 1); assert_eq!(profile.metrics[0].name, "requests"); // Re-declaring the same name updates in place rather than duplicating. let param_req_v2 = param_request("level", r"lvl=(?P\w+)", "level"); settings.record_param_declaration(&settings_path, "web", ¶m_req_v2).unwrap(); let profile = settings.profile("web").unwrap(); assert_eq!(profile.params.len(), 1); assert_eq!(profile.params[0].message_match_regex, r"lvl=(?P\w+)"); // Reload from disk: recorded declarations survive a restart. let reloaded = Settings::load(&settings_path); let profile = reloaded.profile("web").unwrap(); assert_eq!(profile.params.len(), 1); assert_eq!(profile.metrics.len(), 1); } #[test] fn remove_metric_declaration_drops_it_and_does_not_reappear_after_restart() { let dir = tempfile::tempdir().unwrap(); let settings_path = dir.path().join("settings.json"); let mut settings = Settings::default(); settings.create_profile(&settings_path, "web".to_string()).unwrap(); let metric_req = metric_request("requests", r"duration=(?P\d+)", "duration"); settings.record_metric_declaration(&settings_path, "web", &metric_req, &[]).unwrap(); assert_eq!(settings.profile("web").unwrap().metrics.len(), 1); settings.remove_metric_declaration(&settings_path, "web", "requests").unwrap(); assert!(settings.profile("web").unwrap().metrics.is_empty()); // Removing an unknown metric name is a harmless no-op, not an error. settings.remove_metric_declaration(&settings_path, "web", "never-declared").unwrap(); // Reload from disk: the removal itself survives a restart (ticket 051's acceptance criterion). let reloaded = Settings::load(&settings_path); assert!(reloaded.profile("web").unwrap().metrics.is_empty()); } /// Acceptance criterion: declaring params/metrics, "restarting" (reloading settings from disk), and replaying into a fresh engine reproduces the same declarations and still ingests lines, without re-declaring by hand. #[tokio::test] async fn profile_round_trip_reproduces_declarations_in_fresh_engine() { let dir = tempfile::tempdir().unwrap(); let settings_path = dir.path().join("settings.json"); let mut settings = Settings::default(); // Declare directly into a profile, as the HTTP API will do via the `record_*_declaration` hooks. settings.create_profile(&settings_path, "web".to_string()).unwrap(); settings .record_param_declaration( &settings_path, "web", ¶m_request("level", r"level=(?P\w+)", "level"), ) .unwrap(); // A metric now references params by name (ticket 037), so "duration" must be declared as a // standalone param before the metric below can reference it as a label param. settings .record_param_declaration( &settings_path, "web", ¶m_request("duration", r"request duration=(?P\d+)", "duration"), ) .unwrap(); settings .record_metric_declaration( &settings_path, "web", &metric_request("requests", r"request duration=(?P\d+)", "duration"), &[], ) .unwrap(); settings.set_active_profile(&settings_path, Some("web".to_string())).unwrap(); // Simulate a restart: drop everything in memory, reload from disk. drop(settings); let settings = Settings::load(&settings_path); let active_name = settings.active_profile.clone().unwrap(); let profile = settings.profile(&active_name).unwrap().clone(); // Spawn a fresh engine and replay the profile's declarations into it. let (engine_tx, engine_rx) = mpsc::channel(16); let settings_handle = std::sync::Arc::new(std::sync::Mutex::new(settings.clone())); tokio::spawn(crate::engine::run(engine_rx, settings_handle)); load_into_engine(&engine_tx, &profile).await; // Ingest a line and confirm the engine works with the replayed declarations (no re-declaration needed). engine_tx .send(EngineMessage::Ingest(IngestedLine { sequence: 0, timestamp: Timestamp::from_millis(0), text: "level=info request duration=42".to_string(), })) .await .unwrap(); let params = match ask(&engine_tx, EngineQuery::ParamDeclarations).await { EngineResponse::ParamDeclarations(params) => params, _ => panic!("unexpected response"), }; assert_eq!(params.len(), 2); let level = params.iter().find(|p| p.name == "level").unwrap(); assert_eq!(level.message_match_regex, r"level=(?P\w+)"); assert_eq!(level.capture_group, "level"); assert!(matches!(level.kind, MetricPrimitiveKind::String)); let metrics = match ask(&engine_tx, EngineQuery::MetricDeclarations).await { EngineResponse::MetricDeclarations(metrics) => metrics, _ => panic!("unexpected response"), }; assert_eq!(metrics.len(), 1); assert_eq!(metrics[0].name, "requests"); assert_eq!(metrics[0].message_match_regex, r"request duration=(?P\d+)"); assert_eq!(metrics[0].label_params, vec!["duration".to_string()]); let logs = match ask( &engine_tx, EngineQuery::Logs(LogsParams { since_sequence: None, start_ms: None, end_ms: None, limit: None, filter: None, sort_by: None, sort_missing_fallback: None, }), ) .await { EngineResponse::Logs(logs) => logs, _ => panic!("unexpected response"), }; assert_eq!(logs.len(), 1); assert_eq!(logs[0].text, "level=info request duration=42"); } /// Acceptance criterion: a dashboard (with a panel) survives reloading settings from disk. #[test] fn dashboard_create_save_delete_round_trip_and_persists_across_reload() { let dir = tempfile::tempdir().unwrap(); let settings_path = dir.path().join("settings.json"); let mut settings = Settings::default(); settings.create_profile(&settings_path, "web".to_string()).unwrap(); let dashboard = settings.create_dashboard(&settings_path, "web", "Overview".to_string()).unwrap(); assert_eq!(dashboard.name, "Overview"); assert!(dashboard.panels.is_empty()); let mut with_panel = dashboard.clone(); with_panel.panels.push(Panel { id: "panel-1".to_string(), title: "Requests".to_string(), promql: r#"requests{path="/a"}"#.to_string(), chart_type: ChartType::Line, }); let saved = settings .save_dashboard(&settings_path, "web", &dashboard.id, with_panel) .unwrap(); assert_eq!(saved.panels.len(), 1); assert_eq!(saved.id, dashboard.id); // Simulate a restart: drop and reload from disk. drop(settings); let mut reloaded = Settings::load(&settings_path); let dashboards = reloaded.list_dashboards("web").unwrap(); assert_eq!(dashboards.len(), 1); assert_eq!(dashboards[0].name, "Overview"); assert_eq!(dashboards[0].panels.len(), 1); assert_eq!(dashboards[0].panels[0].promql, r#"requests{path="/a"}"#); // Deleting removes it, and that too persists. reloaded.delete_dashboard(&settings_path, "web", &dashboard.id).unwrap(); assert!(reloaded.list_dashboards("web").unwrap().is_empty()); let reloaded_again = Settings::load(&settings_path); assert!(reloaded_again.list_dashboards("web").unwrap().is_empty()); // Unknown profile/dashboard both fail with NotFound. assert!(matches!( reloaded_again.list_dashboards("ghost"), Err(ProfileError::NotFound) )); } /// Writes a pre-037 `settings.json` (with an inline `profiles` array whose metrics carry legacy /// `"params"` matchers rather than `label_params`/`value_param`) directly to disk, bypassing /// `Settings`/`Profile` entirely so this doesn't accidentally exercise the current /// (post-migration) shape. `profiles_json` is the raw JSON array of profiles. fn write_legacy_settings_json(settings_path: &Path, profiles_json: &str) { fs::create_dir_all(settings_path.parent().unwrap()).unwrap(); let contents = format!( r#"{{"color_scheme":"system","css_entries":[],"custom_theme_id":null,"profiles":{profiles_json},"active_profile":null,"max_logs":null,"alert_rules":[],"ntfy_topic":null,"ntfy_server":null}}"# ); fs::write(settings_path, contents).unwrap(); } /// Acceptance criterion: a profile saved before ticket 037 (inline `param_name`/`capture_group`/ /// `kind`/`role` matchers embedded in the metric) loads with those matchers turned into /// standalone param declarations referenced by name, and the metric still ingests identically. #[test] fn migrates_legacy_inline_metric_params_into_standalone_declarations() { let dir = tempfile::tempdir().unwrap(); let settings_path = dir.path().join("settings.json"); write_legacy_settings_json( &settings_path, r#"[ { "name": "legacy", "params": [], "metrics": [ { "name": "requests", "message_match_regex": "request path=(?P\\S+) duration=(?P\\d+)", "params": [ { "param_name": "path", "capture_group": "path", "kind": "string", "role": "label" }, { "param_name": "duration", "capture_group": "duration", "kind": "number", "role": "value" } ] } ], "dashboards": [] } ]"#, ); let settings = Settings::load(&settings_path); let profile = settings.profile("legacy").unwrap(); // No pre-existing bare "path"/"duration" param, so implicit ones were created, named after the metric. assert_eq!(profile.params.len(), 2); let path_param = profile.params.iter().find(|p| p.name == "requests.path").unwrap(); assert_eq!(path_param.message_match_regex, profile.metrics[0].message_match_regex); assert_eq!(path_param.capture_group, "path"); assert!(matches!(path_param.kind, ProfileMetricPrimitiveKind::String)); let duration_param = profile.params.iter().find(|p| p.name == "requests.duration").unwrap(); assert!(matches!(duration_param.kind, ProfileMetricPrimitiveKind::Number)); assert_eq!(profile.metrics.len(), 1); assert_eq!(profile.metrics[0].label_params, vec!["requests.path".to_string()]); assert_eq!(profile.metrics[0].value_param, Some("requests.duration".to_string())); // The migration is persisted, so the on-disk file no longer carries the legacy "params" shape. let reloaded_raw = fs::read_to_string(&settings_path).unwrap(); assert!(!reloaded_raw.contains("param_name")); // Replaying into a fresh engine behaves identically to before migration: the metric still ingests and buckets. let profile = profile.clone(); let (engine_tx, engine_rx) = mpsc::channel(16); let settings_handle = std::sync::Arc::new(std::sync::Mutex::new(Settings::default())); tokio::runtime::Runtime::new().unwrap().block_on(async { tokio::spawn(crate::engine::run(engine_rx, settings_handle)); load_into_engine(&engine_tx, &profile).await; engine_tx .send(EngineMessage::Ingest(IngestedLine { sequence: 0, timestamp: Timestamp::from_millis(0), text: "request path=/a duration=42".to_string(), })) .await .unwrap(); let EngineResponse::MetricDeclarations(metrics) = ask(&engine_tx, EngineQuery::MetricDeclarations).await else { panic!("unexpected response"); }; assert_eq!(metrics.len(), 1); assert_eq!(metrics[0].label_params, vec!["requests.path".to_string()]); }); } /// Acceptance criterion (ticket 038): a pre-037 legacy profile whose inline `Value`-role matcher /// used `kind: "duration"` (the old "elapsed time since previous event" special case) migrates /// into a standalone param with the new explicit `elapsed_since_last: true` extractor, not just a /// bare `Duration`-kind param that would now (post-038) mean a literal parsed millisecond count. #[test] fn migrates_legacy_value_role_duration_matcher_into_elapsed_since_last_param() { let dir = tempfile::tempdir().unwrap(); let settings_path = dir.path().join("settings.json"); write_legacy_settings_json( &settings_path, r#"[ { "name": "legacy", "params": [], "metrics": [ { "name": "login_gap", "message_match_regex": "user=(?P\\S+) logged in", "params": [ { "param_name": "user", "capture_group": "user", "kind": "string", "role": "label" }, { "param_name": "gap", "capture_group": "user", "kind": "duration", "role": "value" } ] } ], "dashboards": [] } ]"#, ); let settings = Settings::load(&settings_path); let profile = settings.profile("legacy").unwrap(); let gap_param = profile.params.iter().find(|p| p.name == "login_gap.gap").unwrap(); assert!(matches!(gap_param.kind, ProfileMetricPrimitiveKind::Duration)); assert!(gap_param.elapsed_since_last); assert_eq!(profile.metrics[0].value_param, Some("login_gap.gap".to_string())); } /// Acceptance criterion (ticket 038): a profile saved after ticket 037 landed but before ticket /// 038 — so it already carries the unified `label_params`/`value_param` shape rather than legacy /// inline matchers, with a bare `Duration`-kind param referenced as a metric's `value_param` — is /// migrated the same way: the param gains `elapsed_since_last: true` so its behavior is unchanged /// (elapsed time since the previous same-labeled event) under the new explicit extractor. #[test] fn migrates_post_037_bare_duration_value_param_into_elapsed_since_last() { let dir = tempfile::tempdir().unwrap(); let settings_path = dir.path().join("settings.json"); write_legacy_settings_json( &settings_path, r#"[ { "name": "legacy", "params": [ { "name": "user", "message_match_regex": "user=(?P\\S+) logged in", "capture_group": "user", "kind": "string" }, { "name": "gap", "message_match_regex": "user=(?P\\S+) logged in", "capture_group": "user", "kind": "duration" } ], "metrics": [ { "name": "login_gap", "message_match_regex": "user=(?P\\S+) logged in", "label_params": ["user"], "value_param": "gap" } ], "dashboards": [] } ]"#, ); let settings = Settings::load(&settings_path); let profile = settings.profile("legacy").unwrap(); let gap_param = profile.params.iter().find(|p| p.name == "gap").unwrap(); assert!(gap_param.elapsed_since_last); // A Duration-kind param not referenced as any value_param is left untouched (still a literal parse). assert!(!profile.params.iter().find(|p| p.name == "user").unwrap().elapsed_since_last); } /// When a bare-named param already declared on the profile matches a legacy matcher's shape /// exactly (same regex/capture-group/kind), migration reuses it by name instead of creating a /// redundant `.` declaration. #[test] fn migration_reuses_an_existing_matching_bare_named_param() { let dir = tempfile::tempdir().unwrap(); let settings_path = dir.path().join("settings.json"); write_legacy_settings_json( &settings_path, r#"[ { "name": "legacy", "params": [ { "name": "path", "message_match_regex": "request path=(?P\\S+)", "capture_group": "path", "kind": "string" } ], "metrics": [ { "name": "requests", "message_match_regex": "request path=(?P\\S+)", "params": [ { "param_name": "path", "capture_group": "path", "kind": "string", "role": "label" } ] } ], "dashboards": [] } ]"#, ); let settings = Settings::load(&settings_path); let profile = settings.profile("legacy").unwrap(); // Reused the existing "path" declaration rather than creating "requests.path". assert_eq!(profile.params.len(), 1); assert_eq!(profile.params[0].name, "path"); assert_eq!(profile.metrics[0].label_params, vec!["path".to_string()]); } /// Migration is idempotent: loading an already-migrated (or never-legacy) profile a second time /// doesn't change anything or re-trigger a save. #[test] fn migration_is_a_noop_on_an_already_migrated_profile() { let dir = tempfile::tempdir().unwrap(); let settings_path = dir.path().join("settings.json"); let mut settings = Settings::default(); settings.create_profile(&settings_path, "web".to_string()).unwrap(); settings .record_param_declaration( &settings_path, "web", ¶m_request("path", r"path=(?P\S+)", "path"), ) .unwrap(); settings .record_metric_declaration(&settings_path, "web", &metric_request("requests", r"path=(?P\S+)", "path"), &[]) .unwrap(); let before = settings.profile("web").unwrap().clone(); let reloaded = Settings::load(&settings_path); let after = reloaded.profile("web").unwrap().clone(); assert_eq!(before, after); } /// Acceptance criterion: a metric declared against a param that only exists as auto-derived /// engine state (not yet a persisted profile param) still ingests correctly after a simulated /// restart, because `record_metric_declaration`'s `promoted_params` persists that param into the /// profile alongside the metric. Without this, `load_into_engine` would reject the metric on /// restart since declarations replay before any log line re-derives the auto param. #[tokio::test] async fn metric_referencing_auto_derived_param_survives_restart_via_promotion() { let dir = tempfile::tempdir().unwrap(); let settings_path = dir.path().join("settings.json"); let mut settings = Settings::default(); settings.create_profile(&settings_path, "web".to_string()).unwrap(); settings.set_active_profile(&settings_path, Some("web".to_string())).unwrap(); // Simulate the auto-derive path: ingest a line carrying a logfmt key before any param is // manually declared, so `dx` only exists as engine-internal auto-derived state. let (engine_tx, engine_rx) = mpsc::channel(16); let settings_handle = std::sync::Arc::new(std::sync::Mutex::new(settings.clone())); tokio::spawn(crate::engine::run(engine_rx, settings_handle)); engine_tx .send(EngineMessage::Ingest(IngestedLine { sequence: 0, timestamp: Timestamp::from_millis(0), text: "dx=1 moved".to_string(), })) .await .unwrap(); // Declare a metric referencing the auto-derived "dx" param — this succeeds live (the param // exists in the engine), mirroring the interactive-declare flow that hit this bug. let metric_req = metric_request("direction_x", r"dx=(?P\S+) moved", "dx"); let (respond_to, response) = oneshot::channel(); engine_tx .send(EngineMessage::DeclareMetric { request: metric_req.clone(), respond_to }) .await .unwrap(); response.await.unwrap().unwrap(); // Promote "dx" from its live (auto-derived) engine state, as `ApiState::persist_metric_declaration` does. let EngineResponse::ParamDeclarations(live_params) = ask(&engine_tx, EngineQuery::ParamDeclarations).await else { panic!("unexpected response"); }; let dx = live_params.iter().find(|p| p.name == "dx").unwrap(); assert!(dx.auto_derived); let promoted = ParamDeclarationRecord { name: dx.name.clone(), message_match_regex: dx.message_match_regex.clone(), capture_group: dx.capture_group.clone(), json_field_path: dx.json_field_path.clone(), kind: dx.kind.into(), elapsed_since_last: dx.elapsed_since_last, }; settings.record_metric_declaration(&settings_path, "web", &metric_req, &[promoted]).unwrap(); // Simulate a restart: drop everything, reload from disk into a *fresh* engine with no prior ingestion. drop(settings); let reloaded_settings = Settings::load(&settings_path); let profile = reloaded_settings.profile("web").unwrap().clone(); assert_eq!(profile.params.len(), 1); assert_eq!(profile.params[0].name, "dx"); let (fresh_engine_tx, fresh_engine_rx) = mpsc::channel(16); let fresh_settings_handle = std::sync::Arc::new(std::sync::Mutex::new(Settings::default())); tokio::spawn(crate::engine::run(fresh_engine_rx, fresh_settings_handle)); load_into_engine(&fresh_engine_tx, &profile).await; let EngineResponse::MetricDeclarations(metrics) = ask(&fresh_engine_tx, EngineQuery::MetricDeclarations).await else { panic!("unexpected response"); }; assert_eq!(metrics.len(), 1); assert_eq!(metrics[0].name, "direction_x"); } }