@intentius/chant-lexicon-prometheus 0.105.1 → 0.106.3

package/src/catalog.ts

@@ -6,13 +6,14 @@
 
 import type { LexiconEntry } from "@intentius/chant/lsp/lexicon-providers";
 import { RULE_GROUP_TYPE } from "./rules";
+import { PROMETHEUS_CONFIG_TYPE, SCRAPE_CONFIG_TYPE } from "./prometheus-config";
 import { INHIBIT_RULE_TYPE, RECEIVER_TYPE, ROUTE_TYPE, SETTINGS_TYPE, TIME_INTERVAL_TYPE } from "./alertmanager";
 
 export interface CatalogEntry {
   className: string;
   entityType: string;
   /** The file the entity serializes into. */
-  file: "rule file" | "alertmanager.yml";
+  file: "rule file" | "prometheus.yml" | "alertmanager.yml";
   description: string;
 }
 
@@ -23,6 +24,18 @@ export const CATALOG: CatalogEntry[] = [
     file: "rule file",
     description: "A group of recording and alerting rules, evaluated together on one interval",
   },
+  {
+    className: "ScrapeConfig",
+    entityType: SCRAPE_CONFIG_TYPE,
+    file: "prometheus.yml",
+    description: "One scrape job: static or discovered targets, scrape settings, and relabelling",
+  },
+  {
+    className: "PrometheusConfig",
+    entityType: PROMETHEUS_CONFIG_TYPE,
+    file: "prometheus.yml",
+    description: "The global, alerting, rule_files, remote_write, remote_read and otlp sections of prometheus.yml",
+  },
   {
     className: "Route",
     entityType: ROUTE_TYPE,

package/src/composites/composites.test.ts

@@ -4,11 +4,12 @@
  */
 import { describe, expect, test } from "vitest";
 import { load } from "js-yaml";
-import { Slo, sloMetrics, sloPropsProblem, type SloProps } from "./slo";
+import { Slo, eventCount, sliExprProblem, sloMetrics, sloPropsProblem, type SloProps } from "./slo";
 import { ruleGroupConfig } from "../rules";
 import { ruleFileYaml } from "../build";
 import { validateRuleFile, validateSeverityRouting } from "../validate-config";
 import { hasTool, promtoolCheckRules } from "../tools";
+import { RuleEvaluator } from "../rule-eval";
 import type { AlertingRuleConfig, RecordingRuleConfig, RuleFileConfig } from "../model";
 
 const PROMTOOL = process.env.PROMTOOL ?? "promtool";
@@ -179,11 +180,52 @@ describe("the rules an Slo builds", () => {
     expect(alertsOf(direct)).toEqual([]);
     const rec = recordings(direct);
     expect(rec.map((r) => r.record)).toEqual(["slo:sli_error:ratio_rate28d", "slo:objective:ratio", "slo:error_budget:remaining"]);
-    expect(rec[0].expr).toBe("(sum(rate(e_total[28d])))\n/\n(sum(rate(t_total[28d])))");
+    expect(rec[0].expr).toBe(
+      "((sum(rate(e_total[28d]))) or 0 * ((sum(rate(t_total[28d]))) > 0))\n/\n((sum(rate(t_total[28d]))) > 0)",
+    );
     expect(sloMetrics(direct).group).toBe("slo-direct");
     expect(sloMetrics(direct).burnRates).toEqual([]);
   });
 
+  test("a window with no events records nothing, so a sparse SLI keeps a finite budget", () => {
+    const sparseProps: SloProps = {
+      name: "sparse",
+      objective: 0.9,
+      window: "1h",
+      sli: { errors: "sum(increase(e_total[{{window}}]))", total: "sum(increase(t_total[{{window}}]))" },
+      alerting: { page: { burnRates: [{ long: "30m", short: "5m", factor: 2 }] }, ticket: false },
+    };
+    const sparse = Slo(sparseProps);
+    const ratio = recordings(sparse)[0].expr;
+    expect(ratio).toBe("((sum(increase(e_total[5m]))) or 0 * ((sum(increase(t_total[5m]))) > 0))\n/\n((sum(increase(t_total[5m]))) > 0)");
+    const good = Slo({ ...sparseProps, name: "sparse-good", sli: { good: "sum(increase(g_total[{{window}}]))", total: "sum(increase(t_total[{{window}}]))" } });
+    expect(recordings(good)[0].expr).toBe(
+      "1 - (\n  ((sum(increase(g_total[5m]))) or 0 * ((sum(increase(t_total[5m]))) > 0))\n  /\n  ((sum(increase(t_total[5m]))) > 0)\n)",
+    );
+
+    // Counters that sit still except for two events at minute 20, one of them bad.
+    // Sampled every minute: the evaluator's range is (t - range, t], so a 5m range
+    // over 5m samples holds one point and increase() has nothing to subtract.
+    const ev = new RuleEvaluator([ruleGroupConfig(sparse.rules)]);
+    const MIN = 60_000;
+    let t = 0;
+    let e = 0;
+    for (let minute = 0; minute <= 50; minute += 1) {
+      if (minute === 20) {
+        t = 2;
+        e = 1;
+      }
+      ev.add({ __name__: "e_total" }, minute * MIN, e);
+      ev.add({ __name__: "t_total" }, minute * MIN, t);
+      ev.step(minute * MIN);
+    }
+    const at = (name: string) => ev.query(`${name}{slo="sparse"}`, 50 * MIN);
+    expect(at("slo:sli_error:ratio_rate5m")).toEqual([]); // minutes 30 to 50 saw no events
+    const budget = at("slo:error_budget:remaining");
+    expect(budget).toHaveLength(1);
+    expect(Number.isFinite(budget[0].value)).toBe(true);
+  });
+
   test.skipIf(!hasPromtool)("the same Slo renders inside the rule file promtool accepts", () => {
     const r = promtoolCheckRules(ruleFileYaml([slo.rules]), PROMTOOL);
     expect(r.ran).toBe(true);
@@ -251,3 +293,31 @@ describe("sloMetrics", () => {
     expect(sloMetrics(slo).errorRatio["1h"]).toBe("slo:sli_error:ratio_rate1h");
   });
 });
+
+describe("eventCount (#3548)", () => {
+  const sel = 'jobs_total{result="ok"}';
+
+  test("counts a series' first sample: the increase where the series existed, its own value where it did not", () => {
+    expect(eventCount(sel)).toBe(
+      'sum(clamp_min(jobs_total{result="ok"} - jobs_total{result="ok"} offset {{window}}, 0) or (jobs_total{result="ok"} unless jobs_total{result="ok"} offset {{window}}))',
+    );
+  });
+
+  test("takes a literal window for use outside an Slo", () => {
+    expect(eventCount("jobs_total", "1h")).toBe(
+      "sum(clamp_min(jobs_total - jobs_total offset 1h, 0) or (jobs_total unless jobs_total offset 1h))",
+    );
+  });
+
+  test("is an SLI expression an Slo accepts", () => {
+    expect(sliExprProblem(eventCount(sel))).toBeUndefined();
+    expect(sloPropsProblem({ ...orderAck, sli: { errors: eventCount('jobs_total{result="bad"}'), total: eventCount("jobs_total") } })).toBeUndefined();
+  });
+
+  test("rejects a selector with a range, an offset or a function, and an empty one", () => {
+    expect(() => eventCount("")).toThrow(/selector/);
+    expect(() => eventCount("jobs_total[5m]")).toThrow(/plain instant vector/);
+    expect(() => eventCount("jobs_total offset 5m")).toThrow(/plain instant vector/);
+    expect(() => eventCount("sum(jobs_total)")).toThrow(/plain instant vector/);
+  });
+});

package/src/composites/index.ts

@@ -7,6 +7,7 @@ export {
   sloMetrics,
   sloPropsProblem,
   sliExprProblem,
+  eventCount,
   DEFAULT_BURN_RATES,
   SLO_WINDOW_PLACEHOLDER,
 } from "./slo";

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 (`eventCount`, 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
@@ -337,6 +347,27 @@ export function sliExprProblem(expr: unknown): string | undefined {
   return undefined;
 }
 
+/**
+ * The number of events a counter saw over a window, counting a series' first
+ * sample. `rate()` and `increase()` need two samples in the range, so a counter
+ * that first appears inside the window reads as no events for the first one.
+ * This is the increase over the window where the series existed before it
+ * (never below 0, so a counter reset counts nothing), and the series' own
+ * value where it did not. Use it for `good`, `errors` and `total` of a sparse
+ * SLI; `window` defaults to the `{{window}}` placeholder an `Slo` fills in.
+ *
+ * `selector` is an instant vector selector, e.g. `jobs_total{result="ok"}`. It
+ * appears three times, so it must have no range and no `offset` of its own.
+ */
+export function eventCount(selector: string, window: string = SLO_WINDOW_PLACEHOLDER): string {
+  const sel = typeof selector === "string" ? selector.trim() : "";
+  if (sel === "") throw new Error("eventCount: selector must be an instant vector selector, e.g. jobs_total{result=\"ok\"}");
+  if (/\boffset\b/.test(sel) || /\[[^\]]*\]\s*$/.test(sel) || /^(sum|rate|increase)\b/.test(sel)) {
+    throw new Error(`eventCount: "${sel}" must be a plain instant vector selector, with no range, offset or function`);
+  }
+  return `sum(clamp_min(${sel} - ${sel} offset ${window}, 0) or (${sel} unless ${sel} offset ${window}))`;
+}
+
 function withWindow(expr: string, window: string): string {
   return expr.split(SLO_WINDOW_PLACEHOLDER).join(window);
 }
@@ -379,10 +410,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/embedded.test.ts

@@ -1,7 +1,7 @@
 import { describe, expect, test } from "vitest";
 import { embeddedDocument, type EmbeddedContent } from "@intentius/chant/import/embedded";
 import { prometheusPlugin } from "../plugin";
-import { alertmanagerImporter, ruleGroupsImporter } from "./embedded";
+import { alertmanagerImporter, prometheusConfigImporter, ruleGroupsImporter } from "./embedded";
 
 const GROUPS = [
   { name: "api", rules: [{ alert: "ApiDown", expr: "up{job=\"api\"} == 0", for: "5m" }] },
@@ -26,7 +26,7 @@ const site = (over: Partial<EmbeddedContent>): EmbeddedContent => ({
 
 describe("rule groups embedded in another lexicon's resource (#2962)", () => {
   test("the plugin registers the importers", () => {
-    expect(prometheusPlugin.embeddedImporters?.()).toEqual([ruleGroupsImporter, alertmanagerImporter]);
+    expect(prometheusPlugin.embeddedImporters?.()).toEqual([ruleGroupsImporter, alertmanagerImporter, prometheusConfigImporter]);
   });
 
   test("matches a PrometheusRule's groups and a rule file held as text; not an alertmanager.yml", () => {
@@ -103,3 +103,47 @@ describe("an alertmanager.yml embedded in another lexicon's resource (#3031)", (
     expect(out.warnings).toEqual([]);
   });
 });
+
+const PROMETHEUS = `global:
+  scrape_interval: 15s
+rule_files:
+  - /etc/prometheus/rules.yml
+scrape_configs:
+  - job_name: node
+    static_configs:
+      - targets: ["node:9100"]
+  - job_name: api
+    metrics_path: /metrics
+    static_configs:
+      - targets: ["api:8080"]
+`;
+
+describe("a prometheus.yml embedded in another lexicon's resource (#3365)", () => {
+  const configMap = (text: string) =>
+    site({ hostType: "K8s::Core::ConfigMap", location: 'ConfigMap prometheus data["prometheus.yml"]', text, document: embeddedDocument(text) });
+
+  test("matches a prometheus.yml held as text; not a rule file, an alertmanager.yml, nor a selected member", () => {
+    expect(prometheusConfigImporter.matches(configMap(PROMETHEUS))).toBe(true);
+    expect(prometheusConfigImporter.matches(configMap(RULE_FILE))).toBe(false);
+    expect(prometheusConfigImporter.matches(configMap(ALERTMANAGER))).toBe(false);
+    expect(prometheusConfigImporter.matches(configMap("storage:\n  path: /data\n"))).toBe(false);
+    expect(prometheusConfigImporter.matches(site({ document: { scrape_configs: [] }, select: "groups" }))).toBe(false);
+    expect(ruleGroupsImporter.matches(configMap(PROMETHEUS))).toBe(false);
+    expect(alertmanagerImporter.matches(configMap(PROMETHEUS))).toBe(false);
+  });
+
+  test("becomes prometheusConfigYaml over every declaration the standalone import writes", () => {
+    const out = prometheusConfigImporter.import(configMap(PROMETHEUS));
+    expect(out.files.map((f) => f.path)).toEqual(["scrape-configs.ts", "prometheus.ts"]);
+    expect(out.value).toEqual({
+      bindings: [
+        { from: "scrape-configs.ts", name: "node" },
+        { from: "scrape-configs.ts", name: "api" },
+        { from: "prometheus.ts", name: "prometheus" },
+      ],
+      shape: "list",
+      through: { from: "@intentius/chant-lexicon-prometheus", name: "prometheusConfigYaml" },
+    });
+    expect(out.warnings).toEqual([]);
+  });
+});