@intentius/chant-lexicon-prometheus 0.105.1 → 0.106.1

package/src/composites/slo.ts

@@ -14,6 +14,16 @@
  *   pair's factor: the long window keeps a short spike from paging, the
  *   short window stops the alert soon after the burn does.
  *
+ * An SLI that sees no events in a window (a sparse one: a job that runs a few
+ * times a day) records no ratio for that window, where good/total would be
+ * 0/0 and record NaN. The SLO window's ratio is an average of the shortest
+ * recorded ratio, and one NaN in a range keeps `avg_over_time` NaN for the
+ * whole window, so the idle windows are left out and the average covers only
+ * the windows that had events. The SLI expressions are the caller's: `rate()`
+ * over a counter that first appears inside the range sees one sample and
+ * counts nothing, so a sparse SLI should count events as an increase that
+ * includes a series' first sample (see the SLOs page).
+ *
  * Both kinds share a group because Prometheus evaluates a group's rules in
  * order: the alerts read the ratios recorded in the same evaluation. In
  * separate groups they would read the previous evaluation's, and with an
@@ -379,10 +389,18 @@ function metricsOf(r: Resolved): SloMetrics {
 function recordingRules(r: Resolved, m: SloMetrics): RecordingRule[] {
   const { props } = r;
   const sli = props.sli as { good?: string; errors?: string; total: string };
-  const ratio = (w: string) =>
-    sli.errors !== undefined
-      ? `(${withWindow(sli.errors, w)})\n/\n(${withWindow(sli.total, w)})`
-      : `1 - (\n  (${withWindow(sli.good!, w)})\n  /\n  (${withWindow(sli.total, w)})\n)`;
+  // A window with no events records nothing: `total > 0` drops the idle
+  // window's 0/0 NaN, and the SLO window's average then covers only the
+  // windows that had events. The numerator falls back to `0 * total`, so a
+  // window whose events were all good (or all bad) still records 0 (or 1)
+  // where its own series is absent.
+  const ratio = (w: string) => {
+    const total = `(${withWindow(sli.total, w)}) > 0`;
+    const some = (expr: string) => `((${expr}) or 0 * (${total}))`;
+    return sli.errors !== undefined
+      ? `${some(withWindow(sli.errors, w))}\n/\n(${total})`
+      : `1 - (\n  ${some(withWindow(sli.good!, w))}\n  /\n  (${total})\n)`;
+  };
   const labels = { slo: props.name };
   const rules: RecordingRule[] = [];
   const alertWindows = m.windows.slice(0, -1);

package/src/config-model.ts

@@ -0,0 +1,327 @@
+/**
+ * The plain-data model of `prometheus.yml`: global settings, scrape configs,
+ * relabelling, service discovery, Alertmanager targets and remote storage.
+ *
+ * Written by hand against Prometheus v3.15.0 (`config/config.go` and
+ * `discovery/*`), field names in the file's own snake_case. SchemaStore's
+ * `prometheus.json` is not used to generate these: it is strict about unknown
+ * keys and behind v3.15.0 (no `runtime`, `otlp` or `tracing`, 11 of about 20
+ * `global` keys, 24 of 32 discovery kinds), so types generated from it would
+ * reject configs Prometheus accepts.
+ *
+ * Six discovery kinds are typed: kubernetes, file, http, dns, ec2 and consul.
+ * Any other `<kind>_sd_configs` key is carried as untyped data.
+ */
+
+import type { HttpClientConfig } from "./integrations";
+import type { LabelSet } from "./model";
+
+/** One `static_configs` entry: fixed targets and the labels they share. */
+export interface StaticConfig {
+  /** `host:port` addresses to scrape (or, under `alerting`, to send alerts to). */
+  targets: string[];
+  labels?: LabelSet;
+}
+
+/** The actions a relabel step can take. */
+export type RelabelAction =
+  | "replace"
+  | "lowercase"
+  | "uppercase"
+  | "keep"
+  | "drop"
+  | "keepequal"
+  | "dropequal"
+  | "hashmod"
+  | "labelmap"
+  | "labeldrop"
+  | "labelkeep";
+
+/** One `relabel_configs` / `metric_relabel_configs` / `write_relabel_configs` step. */
+export interface RelabelConfig {
+  /** Labels whose values are joined with `separator` and matched against `regex`. */
+  source_labels?: string[];
+  /** Defaults to `;`. */
+  separator?: string;
+  target_label?: string;
+  /** An RE2 regex, anchored. Defaults to `(.*)`. */
+  regex?: string;
+  modulus?: number;
+  /** Defaults to `$1`. */
+  replacement?: string;
+  /** Defaults to `replace`. */
+  action?: RelabelAction;
+}
+
+// ── Service discovery ───────────────────────────────────────────────
+
+/** `kubernetes_sd_configs` entry. */
+export interface KubernetesSDConfig extends HttpClientConfig {
+  role: "pod" | "service" | "endpoints" | "endpointslice" | "node" | "ingress";
+  kubeconfig_file?: string;
+  api_server?: string;
+  namespaces?: { own_namespace?: boolean; names?: string[] };
+  selectors?: Array<{ role: string; label?: string; field?: string }>;
+  attach_metadata?: { node?: boolean; namespace?: boolean };
+}
+
+/** `file_sd_configs` entry: target files Prometheus re-reads. */
+export interface FileSDConfig {
+  /** Paths or globs of YAML and JSON target files. */
+  files: string[];
+  refresh_interval?: string;
+}
+
+/** `http_sd_configs` entry: targets fetched from a URL. */
+export interface HttpSDConfig extends HttpClientConfig {
+  url: string;
+  refresh_interval?: string;
+}
+
+/** `dns_sd_configs` entry. */
+export interface DnsSDConfig {
+  names: string[];
+  /** `SRV` (default), `A`, `AAAA`, `MX` or `NS`. */
+  type?: "SRV" | "A" | "AAAA" | "MX" | "NS";
+  /** Required for every type but `SRV`. */
+  port?: number;
+  refresh_interval?: string;
+}
+
+/** `ec2_sd_configs` entry. */
+export interface Ec2SDConfig extends HttpClientConfig {
+  region?: string;
+  endpoint?: string;
+  /** A credential: prefer the environment or an instance role. */
+  access_key?: string;
+  secret_key?: string;
+  profile?: string;
+  role_arn?: string;
+  refresh_interval?: string;
+  port?: number;
+  filters?: Array<{ name: string; values: string[] }>;
+}
+
+/** `consul_sd_configs` entry. */
+export interface ConsulSDConfig extends HttpClientConfig {
+  server?: string;
+  /** A credential. */
+  token?: string;
+  datacenter?: string;
+  namespace?: string;
+  partition?: string;
+  scheme?: "http" | "https";
+  username?: string;
+  password?: string;
+  allow_stale?: boolean;
+  services?: string[];
+  tags?: string[];
+  tag_separator?: string;
+  node_meta?: Record<string, string>;
+  refresh_interval?: string;
+  filter?: string;
+}
+
+/** The service discovery lists of a scrape config or an Alertmanager target group. */
+export interface ServiceDiscoveryConfigs {
+  kubernetes_sd_configs?: KubernetesSDConfig[];
+  file_sd_configs?: FileSDConfig[];
+  http_sd_configs?: HttpSDConfig[];
+  dns_sd_configs?: DnsSDConfig[];
+  ec2_sd_configs?: Ec2SDConfig[];
+  consul_sd_configs?: ConsulSDConfig[];
+  /** Any other discovery kind (`azure_sd_configs`, `gce_sd_configs`, ...), carried as written. */
+  [other: `${string}_sd_configs`]: unknown[] | undefined;
+}
+
+/** The discovery kinds typed above. */
+export const TYPED_SD_KINDS = Object.freeze([
+  "kubernetes_sd_configs",
+  "file_sd_configs",
+  "http_sd_configs",
+  "dns_sd_configs",
+  "ec2_sd_configs",
+  "consul_sd_configs",
+]);
+
+// ── Scrape configs ──────────────────────────────────────────────────
+
+/** Limits and histogram settings that exist both in `global` and per scrape config. */
+export interface ScrapeDefaults {
+  scrape_interval?: string;
+  scrape_timeout?: string;
+  /** e.g. `PrometheusProto`, `OpenMetricsText1.0.0`, `PrometheusText0.0.4`. */
+  scrape_protocols?: string[];
+  body_size_limit?: string;
+  sample_limit?: number;
+  label_limit?: number;
+  label_name_length_limit?: number;
+  label_value_length_limit?: number;
+  target_limit?: number;
+  keep_dropped_targets?: number;
+  always_scrape_classic_histograms?: boolean;
+  convert_classic_histograms_to_nhcb?: boolean;
+  metric_name_validation_scheme?: "utf8" | "legacy";
+  metric_name_escaping_scheme?: "allow-utf-8" | "underscores" | "dots" | "values";
+  native_histogram_bucket_limit?: number;
+  native_histogram_min_bucket_factor?: number;
+}
+
+/** One scrape job. */
+export interface ScrapeJobConfig extends ScrapeDefaults, HttpClientConfig, ServiceDiscoveryConfigs {
+  /** Unique across the file; the `job` label on every target. */
+  job_name: string;
+  honor_labels?: boolean;
+  honor_timestamps?: boolean;
+  track_timestamps_staleness?: boolean;
+  fallback_scrape_protocol?: string;
+  /** Defaults to `/metrics`. */
+  metrics_path?: string;
+  /** `http` (default) or `https`. */
+  scheme?: "http" | "https";
+  /** URL query parameters sent with every scrape. */
+  params?: Record<string, string[]>;
+  enable_compression?: boolean;
+  static_configs?: StaticConfig[];
+  relabel_configs?: RelabelConfig[];
+  metric_relabel_configs?: RelabelConfig[];
+}
+
+// ── Top-level sections ──────────────────────────────────────────────
+
+/** `global:`. */
+export interface PrometheusGlobalConfig extends ScrapeDefaults {
+  evaluation_interval?: string;
+  rule_query_offset?: string;
+  /** Labels added to every series sent to remote storage and every alert. */
+  external_labels?: LabelSet;
+  query_log_file?: string;
+  scrape_failure_log_file?: string;
+}
+
+/** One `alerting.alertmanagers` entry. */
+export interface AlertmanagerTarget extends HttpClientConfig, ServiceDiscoveryConfigs {
+  timeout?: string;
+  api_version?: "v2";
+  path_prefix?: string;
+  scheme?: "http" | "https";
+  relabel_configs?: RelabelConfig[];
+  alert_relabel_configs?: RelabelConfig[];
+  static_configs?: StaticConfig[];
+}
+
+/** `alerting:`. */
+export interface PrometheusAlertingConfig {
+  alert_relabel_configs?: RelabelConfig[];
+  alertmanagers?: AlertmanagerTarget[];
+}
+
+/** `remote_write[].queue_config`. */
+export interface QueueConfig {
+  capacity?: number;
+  max_shards?: number;
+  min_shards?: number;
+  max_samples_per_send?: number;
+  batch_send_deadline?: string;
+  min_backoff?: string;
+  max_backoff?: string;
+  retry_on_http_429?: boolean;
+  sample_age_limit?: string;
+}
+
+/** One `remote_write` entry. */
+export interface RemoteWriteConfig extends HttpClientConfig {
+  url: string;
+  name?: string;
+  remote_timeout?: string;
+  headers?: Record<string, string>;
+  write_relabel_configs?: RelabelConfig[];
+  send_exemplars?: boolean;
+  send_native_histograms?: boolean;
+  queue_config?: QueueConfig;
+  metadata_config?: { send?: boolean; send_interval?: string; max_samples_per_send?: number };
+  sigv4?: {
+    region?: string;
+    access_key?: string;
+    secret_key?: string;
+    profile?: string;
+    role_arn?: string;
+  };
+  azuread?: Record<string, unknown>;
+  google_iam?: Record<string, unknown>;
+}
+
+/** One `remote_read` entry. */
+export interface RemoteReadConfig extends HttpClientConfig {
+  url: string;
+  name?: string;
+  remote_timeout?: string;
+  headers?: Record<string, string>;
+  read_recent?: boolean;
+  required_matchers?: LabelSet;
+  filter_external_labels?: boolean;
+}
+
+/** `otlp:`: how OTLP metrics pushed to Prometheus become series. */
+export interface OtlpConfig {
+  promote_all_resource_attributes?: boolean;
+  promote_resource_attributes?: string[];
+  ignore_resource_attributes?: string[];
+  translation_strategy?: "UnderscoreEscapingWithSuffixes" | "UnderscoreEscapingWithoutSuffixes" | "NoUTF8EscapingWithSuffixes" | "NoTranslation";
+  keep_identifying_resource_attributes?: boolean;
+  convert_histograms_to_nhcb?: boolean;
+}
+
+/** The sections of a `prometheus.yml` besides its scrape jobs. */
+export interface PrometheusConfigSections {
+  global?: PrometheusGlobalConfig;
+  alerting?: PrometheusAlertingConfig;
+  /** Paths or globs of rule files, relative to the config file. */
+  rule_files?: string[];
+  /** Paths or globs of files holding more `scrape_configs`. */
+  scrape_config_files?: string[];
+  remote_write?: RemoteWriteConfig[];
+  remote_read?: RemoteReadConfig[];
+  otlp?: OtlpConfig;
+  /** TSDB and exemplar settings, carried as written. */
+  storage?: Record<string, unknown>;
+  /** Where Prometheus sends its own traces, carried as written. */
+  tracing?: Record<string, unknown>;
+  /** Go runtime settings (`gogc`), carried as written. */
+  runtime?: Record<string, unknown>;
+}
+
+/** A whole `prometheus.yml`. */
+export interface PrometheusConfigFile extends PrometheusConfigSections {
+  scrape_configs?: ScrapeJobConfig[];
+}
+
+/** Top-level keys of `prometheus.yml`, in the order Prometheus documents them. */
+export const PROMETHEUS_CONFIG_SECTIONS = Object.freeze([
+  "global",
+  "alerting",
+  "rule_files",
+  "scrape_config_files",
+  "scrape_configs",
+  "remote_write",
+  "remote_read",
+  "otlp",
+  "storage",
+  "tracing",
+  "runtime",
+]);
+
+const GLOBAL_ONLY_KEYS = ["scrape_interval", "scrape_timeout", "evaluation_interval", "external_labels", "rule_query_offset", "query_log_file"];
+
+/** True when a parsed document has the shape of a `prometheus.yml`. */
+export function looksLikePrometheusConfig(value: unknown): value is PrometheusConfigFile {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
+  const v = value as Record<string, unknown>;
+  if ("apiVersion" in v || "kind" in v || "groups" in v || "route" in v || "receivers" in v) return false;
+  if (PROMETHEUS_CONFIG_SECTIONS.some((k) => k !== "global" && k !== "runtime" && k !== "storage" && k !== "tracing" && k in v)) {
+    return true;
+  }
+  // `global:` alone is Alertmanager's too; only Prometheus's own keys settle it.
+  const g = v.global;
+  return typeof g === "object" && g !== null && GLOBAL_ONLY_KEYS.some((k) => k in g);
+}

package/src/detect.ts

@@ -1,12 +1,13 @@
 /**
  * Template detection for the prometheus lexicon: a parsed document is ours
- * when it is shaped like a rule file (`groups:` of named rule lists) or an
- * `alertmanager.yml` (`route:` or `receivers:` at the top level). Kept free
+ * when it is shaped like a rule file (`groups:` of named rule lists), an
+ * `alertmanager.yml` (`route:` or `receivers:` at the top level) or a
+ * `prometheus.yml` (`scrape_configs:`, `remote_write:` and the like). Kept free
  * of the plugin and the TypeScript compiler so it bundles for edge runtimes,
  * like the other lexicons' `detect` modules.
  */
-import { looksLikeAlertmanagerConfig, looksLikeRuleFile } from "./model";
+import { looksLikeAlertmanagerConfig, looksLikePrometheusConfig, looksLikeRuleFile } from "./model";
 
 export function detectTemplate(data: unknown): boolean {
-  return looksLikeRuleFile(data) || looksLikeAlertmanagerConfig(data);
+  return looksLikeRuleFile(data) || looksLikeAlertmanagerConfig(data) || looksLikePrometheusConfig(data);
 }

package/src/generated/lexicon-prometheus.json

@@ -9,6 +9,11 @@
     "kind": "resource",
     "lexicon": "prometheus"
   },
+  "PrometheusConfig": {
+    "resourceType": "Prometheus::Config::PrometheusConfig",
+    "kind": "resource",
+    "lexicon": "prometheus"
+  },
   "Receiver": {
     "resourceType": "Prometheus::Alertmanager::Receiver",
     "kind": "resource",
@@ -24,6 +29,11 @@
     "kind": "resource",
     "lexicon": "prometheus"
   },
+  "ScrapeConfig": {
+    "resourceType": "Prometheus::Config::ScrapeConfig",
+    "kind": "resource",
+    "lexicon": "prometheus"
+  },
   "TimeInterval": {
     "resourceType": "Prometheus::Alertmanager::TimeInterval",
     "kind": "resource",

package/src/import/generator.ts

@@ -24,6 +24,8 @@ import type { GeneratedFile, TypeScriptGenerator } from "@intentius/chant/import
 import type { TemplateIR } from "@intentius/chant/import/parser";
 import type {
   AlertmanagerConfig,
+  PrometheusConfigFile,
+  ScrapeJobConfig,
   InhibitRuleConfig,
   ReceiverConfig,
   RouteConfig,
@@ -35,8 +37,10 @@ import { ALERTMANAGER_GLOBAL_FIELDS, RECEIVER_INTEGRATION_TYPES } from "../model
 import { PROMETHEUS_PIN } from "../pin";
 import {
   ALERTMANAGER_RESOURCE_TYPE,
+  PROMETHEUS_RESOURCE_TYPE,
   RULE_FILE_RESOURCE_TYPE,
   type AlertmanagerResourceProperties,
+  type PrometheusResourceProperties,
   type RuleFileResourceProperties,
 } from "./parser";
 import { recognizeSlo } from "./slo";
@@ -259,6 +263,22 @@ const LEXICON_NAMES = [
   "TimeInterval",
   "TimePeriodConfig",
   "InhibitRule",
+  "ScrapeConfig",
+  "ScrapeConfigProps",
+  "PrometheusConfig",
+  "StaticConfig",
+  "RelabelConfig",
+  "PrometheusGlobalConfig",
+  "PrometheusAlertingConfig",
+  "RemoteWriteConfig",
+  "RemoteReadConfig",
+  "OtlpConfig",
+  "KubernetesSDConfig",
+  "FileSDConfig",
+  "HttpSDConfig",
+  "DnsSDConfig",
+  "Ec2SDConfig",
+  "ConsulSDConfig",
   "AlertmanagerSettings",
   "AlertmanagerGlobalConfig",
   "AlertmanagerTracingConfig",
@@ -579,6 +599,104 @@ export function generateAlertmanager(config: AlertmanagerConfig): { files: Gener
   };
 }
 
+// ── prometheus.yml ───────────────────────────────────────────────────
+
+/** The type each hoisted scrape config field is declared as; others use `ScrapeConfigProps["field"]`. */
+const SCRAPE_FIELD_TYPES: Record<string, string> = {
+  static_configs: "StaticConfig[]",
+  relabel_configs: "RelabelConfig[]",
+  metric_relabel_configs: "RelabelConfig[]",
+  params: "Record<string, string[]>",
+  kubernetes_sd_configs: "KubernetesSDConfig[]",
+  file_sd_configs: "FileSDConfig[]",
+  http_sd_configs: "HttpSDConfig[]",
+  dns_sd_configs: "DnsSDConfig[]",
+  ec2_sd_configs: "Ec2SDConfig[]",
+  consul_sd_configs: "ConsulSDConfig[]",
+};
+
+/** The type each top-level section is declared as. */
+const SECTION_TYPES: Record<string, string> = {
+  global: "PrometheusGlobalConfig",
+  alerting: "PrometheusAlertingConfig",
+  remote_write: "RemoteWriteConfig[]",
+  remote_read: "RemoteReadConfig[]",
+  otlp: "OtlpConfig",
+  storage: "Record<string, unknown>",
+  tracing: "Record<string, unknown>",
+  runtime: "Record<string, unknown>",
+};
+
+/** Generate the TypeScript declaring one `prometheus.yml`. */
+export function generatePrometheusConfigFiles(config: PrometheusConfigFile): GeneratedFile[] {
+  const names = new Names([...LEXICON_NAMES, ...Object.keys(SECTION_TYPES)]);
+  const modules: Module[] = [];
+
+  for (const [mod, items] of chunk(config.scrape_configs ?? [], "scrape-configs", "Scrape jobs: where Prometheus pulls metrics from")) {
+    modules.push(mod);
+    mod.use("ScrapeConfig");
+    for (const job of items as ScrapeJobConfig[]) {
+      const v = names.claim(job.job_name, "Scrape", "scrape");
+      const lines: string[] = [];
+      const entries: Array<[string, string]> = [["job_name", stringLiteral(job.job_name)]];
+      for (const [key, value] of Object.entries(job)) {
+        if (key === "job_name" || value === undefined) continue;
+        if (!needsHoist(value)) {
+          entries.push([key, tsLiteral(value, 2, 4 + key.length)]);
+          continue;
+        }
+        const known = SCRAPE_FIELD_TYPES[key];
+        const type = known ?? (key.endsWith("_sd_configs") ? undefined : `ScrapeConfigProps["${key}"]`);
+        const c = names.claim(`${v} ${key.replace(/_configs$/, "")}`, "Config", "scrape");
+        if (type) {
+          if (type.startsWith("ScrapeConfigProps")) mod.types.add("ScrapeConfigProps");
+          else if (!type.startsWith("Record<")) mod.types.add(type.replace(/\[\]$/, ""));
+          const head = `const ${c}: ${type} = `;
+          lines.push(`${head}${tsLiteral(value, 0, head.length)};`);
+        } else {
+          lines.push(`// ${key} is not a discovery kind the lexicon types, so it is carried as data, untyped.`);
+          const head = `const ${c} = `;
+          lines.push(`${head}${tsLiteral(value, 0, head.length)};`);
+        }
+        entries.push([key, c]);
+      }
+      const ctor = `const ${v} = new ScrapeConfig(`;
+      lines.push(`${ctor}${objectOf(entries, 0, ctor.length)});`);
+      mod.block(lines);
+      mod.exports.push(v);
+    }
+  }
+
+  const sectionKeys = Object.keys(config).filter((k) => k !== "scrape_configs");
+  if (sectionKeys.length > 0) {
+    const mod = new Module("prometheus.ts", "The prometheus.yml sections besides the scrape jobs");
+    modules.push(mod);
+    mod.use("PrometheusConfig");
+    const lines: string[] = [];
+    const entries: Array<[string, string]> = [];
+    for (const key of sectionKeys) {
+      const value = (config as Record<string, unknown>)[key];
+      const type = SECTION_TYPES[key];
+      if (!type || !needsHoist(value)) {
+        entries.push([key, tsLiteral(value, 2, 4 + key.length)]);
+        continue;
+      }
+      if (!type.startsWith("Record<")) mod.types.add(type.replace(/\[\]$/, ""));
+      const c = names.claim(key.replace(/_/g, " "), "Config", "prometheus");
+      const head = `const ${c}: ${type} = `;
+      lines.push(`${head}${tsLiteral(value, 0, head.length)};`);
+      entries.push([key, c]);
+    }
+    const v = names.claim("prometheus", "Settings", "prometheus");
+    const ctor = `const ${v} = new PrometheusConfig(`;
+    lines.push(`${ctor}${objectOf(entries, 0, ctor.length)});`);
+    mod.block(lines);
+    mod.exports.push(v);
+  }
+
+  return modules.map((m) => ({ path: m.path, content: m.render() }));
+}
+
 /** The rule file and `alertmanager.yml` TypeScript generator `chant import` runs. */
 export class PrometheusGenerator implements TypeScriptGenerator {
   generate(ir: TemplateIR): GeneratedFile[] {
@@ -586,6 +704,8 @@ export class PrometheusGenerator implements TypeScriptGenerator {
     for (const r of ir.resources) {
       if (r.type === RULE_FILE_RESOURCE_TYPE) {
         files.push(...generateRuleFileFiles((r.properties as unknown as RuleFileResourceProperties).file));
+      } else if (r.type === PROMETHEUS_RESOURCE_TYPE) {
+        files.push(...generatePrometheusConfigFiles((r.properties as unknown as PrometheusResourceProperties).config));
       } else if (r.type === ALERTMANAGER_RESOURCE_TYPE) {
         files.push(...generateAlertmanagerFiles((r.properties as unknown as AlertmanagerResourceProperties).config));
       }

package/src/import/parser.test.ts

@@ -11,9 +11,9 @@ describe("parsePrometheusYaml", () => {
   });
 
   test("rejects a document that is neither, and one that is not a mapping", () => {
-    expect(() => parsePrometheusYaml("receivers:\n  otlp: {}\n")).toThrow(/neither a Prometheus rule file/);
+    expect(() => parsePrometheusYaml("receivers:\n  otlp: {}\n")).toThrow(/is not a Prometheus rule file .*an alertmanager\.yml .*or a prometheus\.yml/);
     expect(() => parsePrometheusYaml("- a\n- b\n")).toThrow(/YAML mapping/);
-    expect(() => parsePrometheusYaml("")).toThrow(/neither/);
+    expect(() => parsePrometheusYaml("")).toThrow(/is not a Prometheus rule file/);
   });
 
   test("a rule's values are strings, label values included, and a group's limit a number", () => {