fix(checks): purge the remaining check-name-only keying

Surveyed every surface that correlated checks by bare name and scoped
each to the (source, check) identity:

- The snapshot rollup and its silenced-checks set now consult only the
  status row's own source (a status's checks all belong to one source);
  silenced_health_checks_for_server takes the source and the unused
  batch variant and silenced_refs_with_prefix are gone.
- The device-facing effective check map only overlays the requested
  source's own silences — a silence on another source's same-named
  check no longer tells this source to skip it.
- The server-detail checks table builds its skip-style set from the
  status source's silences only (the chips were already exact).
- The rule-editor sample takes (source, check) so another source's
  same-named payload can't seed the editor's variables.
- Issue::list_by_ref (the any-source ref lookup) lost its last caller
  with the attention rekey and is deleted.

Author: passcod

crates/database/src/issues.rs

@@ -2092,26 +2092,6 @@ impl Issue {
 			.collect())
 	}
 
-	/// Like [`Self::list_by_source_ref`], but matching the ref under any
-	/// source. Healthcheck refs (`health/<check>`) are keyed per reporting
-	/// source; consumers that correlate by check name alone use this.
-	pub async fn list_by_ref(
-		db: &mut AsyncPgConnection,
-		ref_: &str,
-		server_ids: &[Uuid],
-	) -> Result<Vec<Self>> {
-		use crate::schema::issues::dsl;
-		if server_ids.is_empty() {
-			return Ok(Vec::new());
-		}
-		dsl::issues
-			.select(Self::as_select())
-			.filter(dsl::ref_.eq(ref_).and(dsl::server_id.eq_any(server_ids)))
-			.load(db)
-			.await
-			.map_err(AppError::from)
-	}
-
 	/// Mark an issue as operator-resolved. Triggers incident-membership
 	/// re-evaluation (typically: leaves the incident).
 	pub async fn resolve(

crates/database/src/silenced_refs.rs

@@ -12,7 +12,7 @@
 //! source-reported checks, while the scoped-policy storage is keyed by
 //! bare check name. The mapping is applied on the way in and out.
 
-use std::collections::{BTreeSet, HashMap};
+use std::collections::BTreeSet;
 
 use commons_errors::Result;
 use diesel::prelude::*;
@@ -111,110 +111,37 @@ pub async fn is_silenced(
 	))
 }
 
-/// All refs silenced for this server under any source and starting with
-/// `ref_prefix`, combining the server's own silences with its group's.
-/// `group_id` is the server's current group; pass `None` if the server is
-/// ungrouped. Used to build the device-facing effective check-severity map.
-/// May contain duplicates when a ref is silenced at both scopes.
-pub async fn silenced_refs_with_prefix(
+/// Check names silenced for a server under one reporting source, at
+/// either server or group scope. `group_id` is the server's current
+/// group; pass `None` if ungrouped. A check's identity is the (source,
+/// check) pair, so a silence on another source's same-named check never
+/// applies.
+///
+/// This feeds [`crate::statuses::Status::health_state_ignoring`] (a
+/// status row's checks all belong to the row's one source) and the
+/// device-facing effective check map: a silenced check keeps recording
+/// results but is presented as skipped and doesn't count toward the
+/// server's health rollup.
+pub async fn silenced_health_checks_for_server(
 	db: &mut AsyncPgConnection,
 	server_id: Uuid,
 	group_id: Option<Uuid>,
-	ref_prefix: &str,
-) -> Result<Vec<String>> {
-	let mut refs: Vec<String> =
-		ScopedCheckPolicy::list_silences(db, PolicyScope::Server(server_id))
-			.await?
-			.into_iter()
-			.map(|p| check_to_ref(&p.source, &p.check_name))
-			.collect();
-	if let Some(gid) = group_id {
-		refs.extend(
-			ScopedCheckPolicy::list_silences(db, PolicyScope::Group(gid))
-				.await?
-				.into_iter()
-				.map(|p| check_to_ref(&p.source, &p.check_name)),
-		);
-	}
-	refs.retain(|r| r.starts_with(ref_prefix));
-	Ok(refs)
-}
-
-/// Healthcheck names silenced for each of the given `(server, group)`
-/// pairs, at either scope, whichever source they were silenced under.
-/// Pass each server's current group id (`None` for ungrouped). One batch
-/// query regardless of how many servers are asked about. Servers with no
-/// applicable silences are absent from the map.
-///
-/// This feeds [`crate::statuses::Status::health_state_ignoring`]: a
-/// silenced check keeps recording results but is presented as skipped
-/// and doesn't count toward the server's health rollup.
-pub async fn silenced_health_checks_for_servers(
-	db: &mut AsyncPgConnection,
-	servers: &[(Uuid, Option<Uuid>)],
-) -> Result<HashMap<Uuid, BTreeSet<String>>> {
+	source: &str,
+) -> Result<BTreeSet<String>> {
 	use crate::schema::scoped_check_policies::dsl;
 
-	let mut out: HashMap<Uuid, BTreeSet<String>> = HashMap::new();
-	if servers.is_empty() {
-		return Ok(out);
-	}
-
-	let server_ids: Vec<Uuid> = servers.iter().map(|(id, _)| *id).collect();
-	let group_ids: Vec<Uuid> = servers
-		.iter()
-		.filter_map(|(_, group)| *group)
-		.collect::<BTreeSet<_>>()
-		.into_iter()
-		.collect();
-
-	// Health rollups match by check name across every reporting source;
-	// canopy/manual silences aren't source-reported checks and don't
-	// belong in the ignore-set.
-	let rows: Vec<(Option<Uuid>, Option<Uuid>, String)> = dsl::scoped_check_policies
-		.select((dsl::server_id, dsl::server_group_id, dsl::check_name))
+	let rows: Vec<String> = dsl::scoped_check_policies
+		.select(dsl::check_name)
 		.filter(dsl::ceiling.eq("skipped"))
-		.filter(dsl::source.ne_all([CANOPY_SOURCE, MANUAL_SOURCE]))
+		.filter(dsl::source.eq(source))
 		.filter(
-			dsl::server_id
-				.eq_any(&server_ids)
-				.or(dsl::server_group_id.eq_any(&group_ids)),
+			dsl::server_id.eq(server_id).or(dsl::server_group_id
+				.is_not_distinct_from(group_id)
+				.and(dsl::server_group_id.is_not_null())),
 		)
 		.load(db)
 		.await?;
-
-	let mut by_group: HashMap<Uuid, Vec<String>> = HashMap::new();
-	for (server_id, group_id, check) in rows {
-		if let Some(sid) = server_id {
-			out.entry(sid).or_default().insert(check);
-		} else if let Some(gid) = group_id {
-			by_group.entry(gid).or_default().push(check);
-		}
-	}
-	for (server_id, group_id) in servers {
-		if let Some(checks) = group_id.as_ref().and_then(|g| by_group.get(g)) {
-			out.entry(*server_id)
-				.or_default()
-				.extend(checks.iter().cloned());
-		}
-	}
-
-	Ok(out)
-}
-
-/// Single-server variant of [`silenced_health_checks_for_servers`].
-/// `group_id` is the server's current group; pass `None` if ungrouped.
-pub async fn silenced_health_checks_for_server(
-	db: &mut AsyncPgConnection,
-	server_id: Uuid,
-	group_id: Option<Uuid>,
-) -> Result<BTreeSet<String>> {
-	Ok(
-		silenced_health_checks_for_servers(db, &[(server_id, group_id)])
-			.await?
-			.remove(&server_id)
-			.unwrap_or_default(),
-	)
+	Ok(rows.into_iter().collect())
 }
 
 impl ServerSilencedRef {

crates/database/src/statuses.rs

@@ -454,13 +454,16 @@ impl Status {
 		Ok(filed)
 	}
 
-	/// Most recent status row (across all servers) whose `health` array
-	/// contains an entry for `check_name`. Used by the rule-editor UI to
-	/// surface a realistic sample of the variables an operator can
-	/// predicate on (the check's extras, the status-level extras, and
-	/// the server's tags resolved up the group).
+	/// Most recent status row (across all servers) pushed by `source`
+	/// whose `health` array contains an entry for `check_name`. Used by
+	/// the rule-editor UI to surface a realistic sample of the variables
+	/// an operator can predicate on (the check's extras, the status-level
+	/// extras, and the server's tags resolved up the group). Scoped to
+	/// the check's own source — another source's same-named check may
+	/// carry entirely different fields.
 	pub async fn latest_for_check_name(
 		db: &mut AsyncPgConnection,
+		source: &str,
 		check_name: &str,
 	) -> Result<Option<Status>> {
 		use diesel::sql_types::{Text, Uuid as DUuid};
@@ -477,9 +480,11 @@ impl Status {
 		// express cleanly), then load the typed Status row by id.
 		let picked: Option<Picked> = sql_query(
 			"SELECT id FROM statuses \
-			 WHERE health @> jsonb_build_array(jsonb_build_object('check', $1::text)) \
+			 WHERE source = $1 \
+			 AND health @> jsonb_build_array(jsonb_build_object('check', $2::text)) \
 			 ORDER BY created_at DESC LIMIT 1",
 		)
+		.bind::<Text, _>(source)
 		.bind::<Text, _>(check_name)
 		.get_result(db)
 		.await

crates/database/tests/it/check_severity_map.rs

@@ -1,12 +1,13 @@
 //! Queries backing the device-facing effective check map:
 //! `CheckPolicy::ceiling_map_for_source` (static policy ceilings,
-//! ignoring conditional rules) and `silenced_refs::silenced_refs_with_prefix`
-//! (server- plus group-scope silences under a ref prefix).
+//! ignoring conditional rules) and
+//! `silenced_refs::silenced_health_checks_for_server` (server- plus
+//! group-scope silences under one reporting source).
 
 use commons_types::status::CheckResult;
 use database::check_policies::{CheckPolicy, IfLadder};
 use database::silenced_refs::{
-	ServerGroupSilencedRef, ServerSilencedRef, silenced_refs_with_prefix,
+	ServerGroupSilencedRef, ServerSilencedRef, silenced_health_checks_for_server,
 };
 use diesel::{sql_query, sql_types};
 use diesel_async::RunQueryDsl;
@@ -107,7 +108,7 @@ async fn ceiling_map_ignores_conditional_rules() {
 }
 
 #[tokio::test(flavor = "multi_thread")]
-async fn silenced_refs_with_prefix_combines_scopes_and_filters() {
+async fn silenced_checks_combine_scopes_and_stay_per_source() {
 	commons_tests::db::TestDb::run(async |mut conn, _| {
 		let group_id = insert_group(&mut conn).await;
 		let server_id = insert_server(&mut conn, Some(group_id)).await;
@@ -119,8 +120,9 @@ async fn silenced_refs_with_prefix_combines_scopes_and_filters() {
 		ServerGroupSilencedRef::add(&mut conn, group_id, "alertd", "health/groupwide", None)
 			.await
 			.expect("group silence");
-		// A silence under any source matches: healthcheck refs are keyed
-		// per reporting source, and this helper correlates by check name.
+		// None of these may leak into alertd's set: a check's identity is
+		// the (source, check) pair, so another source's silence never
+		// applies; nor do canopy's own silences or other servers'.
 		ServerSilencedRef::add(
 			&mut conn,
 			server_id,
@@ -130,31 +132,27 @@ async fn silenced_refs_with_prefix_combines_scopes_and_filters() {
 		)
 		.await
 		.expect("other-source silence");
-		// None of these may leak into the result: reserved-source silences
-		// present at their bare refs (outside the health/ namespace), and
-		// silences on other servers don't apply here at all.
 		ServerSilencedRef::add(&mut conn, server_id, "canopy", "reachability", None)
 			.await
 			.expect("canopy silence");
 		ServerSilencedRef::add(&mut conn, other_server_id, "alertd", "health/other", None)
 			.await
 			.expect("other-server silence");
 
-		let mut refs = silenced_refs_with_prefix(&mut conn, server_id, Some(group_id), "health/")
-			.await
-			.expect("refs");
-		refs.sort();
+		let checks =
+			silenced_health_checks_for_server(&mut conn, server_id, Some(group_id), "alertd")
+				.await
+				.expect("checks");
 		assert_eq!(
-			refs,
-			vec!["health/flaky", "health/groupwide", "health/other-source"]
+			checks.into_iter().collect::<Vec<_>>(),
+			vec!["flaky", "groupwide"]
 		);
 
 		// Ungrouped lookup only sees the server-scope silences.
-		let mut refs = silenced_refs_with_prefix(&mut conn, server_id, None, "health/")
+		let checks = silenced_health_checks_for_server(&mut conn, server_id, None, "alertd")
 			.await
-			.expect("refs without group");
-		refs.sort();
-		assert_eq!(refs, vec!["health/flaky", "health/other-source"]);
+			.expect("checks without group");
+		assert_eq!(checks.into_iter().collect::<Vec<_>>(), vec!["flaky"]);
 	})
 	.await
 }