@intentius/chant-lexicon-prometheus 0.105.1 → 0.106.3

package/src/import/embedded.ts

@@ -16,12 +16,19 @@
  * ConfigMap then holds the config as the serializer writes it: the same
  * config, with Alertmanager's deprecated spellings rewritten as the
  * standalone import rewrites them.
+ *
+ * A `prometheus.yml` held as text in a ConfigMap is imported exactly as
+ * `chant import prometheus.yml` would import it, and becomes
+ * `prometheusConfigYaml([...])` over every scrape job and the sections
+ * besides them. The ConfigMap then holds the config as the serializer
+ * writes it: scrape jobs sorted by name, sections in Prometheus's order.
  */
 
 import type { EmbeddedContentImporter, EmbeddedImport } from "@intentius/chant/import/embedded";
 import { looksLikeAlertmanagerConfig, looksLikeRuleFile } from "../model";
+import { looksLikePrometheusConfig } from "../config-model";
 import { parsePrometheusYaml } from "./parser";
-import { generateAlertmanager, generateRuleFile } from "./generator";
+import { generateAlertmanager, generatePrometheusConfig, generateRuleFile } from "./generator";
 
 const PACKAGE = "@intentius/chant-lexicon-prometheus";
 
@@ -74,3 +81,27 @@ export const alertmanagerImporter: EmbeddedContentImporter = {
     };
   },
 };
+
+export const prometheusConfigImporter: EmbeddedContentImporter = {
+  what: "a prometheus.yml",
+
+  matches(content) {
+    return content.select === undefined && typeof content.text === "string" && looksLikePrometheusConfig(content.document);
+  },
+
+  import(content): EmbeddedImport {
+    const parsed = parsePrometheusYaml(content.text!);
+    if (parsed.kind !== "prometheus") throw new Error("this is not a prometheus.yml");
+    const { files, declarations } = generatePrometheusConfig(parsed.config);
+    if (declarations.length === 0) throw new Error("the import declared nothing");
+    return {
+      files,
+      value: {
+        bindings: declarations.map((d) => ({ from: d.path, name: d.name })),
+        shape: "list",
+        through: { from: PACKAGE, name: "prometheusConfigYaml" },
+      },
+      warnings: parsed.warnings,
+    };
+  },
+};

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,122 @@ 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[] {
+  return generatePrometheusConfig(config).files;
+}
+
+/** A declaration a `prometheus.yml` import exports: its module and variable. */
+export interface PrometheusConfigDeclaration {
+  readonly path: string;
+  readonly name: string;
+}
+
+/**
+ * Generate the TypeScript declaring one `prometheus.yml`, and list every
+ * declaration it exports, module by module (a ConfigMap holding the file
+ * becomes `prometheusConfigYaml([...])` over them).
+ */
+export function generatePrometheusConfig(config: PrometheusConfigFile): { files: GeneratedFile[]; declarations: PrometheusConfigDeclaration[] } {
+  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 {
+    files: modules.map((m) => ({ path: m.path, content: m.render() })),
+    declarations: modules.flatMap((m) => m.exports.map((name) => ({ path: m.path, name }))),
+  };
+}
+
 /** The rule file and `alertmanager.yml` TypeScript generator `chant import` runs. */
 export class PrometheusGenerator implements TypeScriptGenerator {
   generate(ir: TemplateIR): GeneratedFile[] {
@@ -586,6 +722,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", () => {

package/src/import/parser.ts

@@ -1,5 +1,5 @@
 /**
- * Rule file or `alertmanager.yml` -> `TemplateIR`, for `chant import`.
+ * Rule file, `prometheus.yml` or `alertmanager.yml` -> `TemplateIR`, for `chant import`.
  *
  * Either file is one document whose parts name each other (a route names a
  * receiver and time intervals), so the IR carries the whole file as one
@@ -24,7 +24,9 @@ import {
   ALERTMANAGER_GLOBAL_FIELDS,
   RECEIVER_INTEGRATIONS,
   looksLikeAlertmanagerConfig,
+  looksLikePrometheusConfig,
   looksLikeRuleFile,
+  PROMETHEUS_CONFIG_SECTIONS,
   type AlertmanagerConfig,
   type InhibitRuleConfig,
   type ReceiverConfig,
@@ -32,8 +34,11 @@ import {
   type RuleConfig,
   type RuleFileConfig,
   type RuleGroupConfig,
+  type PrometheusConfigFile,
+  type ScrapeJobConfig,
   type TimeIntervalConfig,
 } from "../model";
+import { TYPED_SD_KINDS } from "../model";
 import { PROMETHEUS_PIN } from "../pin";
 
 /** The IR resource type for a whole rule file. */
@@ -41,6 +46,14 @@ export const RULE_FILE_RESOURCE_TYPE = "Prometheus::RuleFile";
 /** The IR resource type for a whole `alertmanager.yml`. */
 export const ALERTMANAGER_RESOURCE_TYPE = "Prometheus::Alertmanager::Config";
 
+/** The IR resource type for a whole `prometheus.yml`. */
+export const PROMETHEUS_RESOURCE_TYPE = "Prometheus::Config";
+
+/** `properties` of the `Prometheus::Config` resource. */
+export interface PrometheusResourceProperties {
+  config: PrometheusConfigFile;
+}
+
 /** `properties` of the `Prometheus::RuleFile` resource. */
 export interface RuleFileResourceProperties {
   file: RuleFileConfig;
@@ -54,7 +67,8 @@ export interface AlertmanagerResourceProperties {
 /** What the parser read. */
 export type ParsedPrometheusFile =
   | { kind: "rules"; file: RuleFileConfig; warnings: string[] }
-  | { kind: "alertmanager"; config: AlertmanagerConfig; warnings: string[] };
+  | { kind: "alertmanager"; config: AlertmanagerConfig; warnings: string[] }
+  | { kind: "prometheus"; config: PrometheusConfigFile; warnings: string[] };
 
 // YAML 1.2 core types plus `<<` merge keys, which Alertmanager configs use to
 // share notifier settings. The default schema would also turn an unquoted
@@ -324,6 +338,52 @@ function parseAlertmanager(doc: Record<string, unknown>, warnings: string[]): Al
   return config;
 }
 
+// ── prometheus.yml ──────────────────────────────────────────────────
+
+function parsePrometheusConfig(doc: Record<string, unknown>, warnings: string[]): PrometheusConfigFile {
+  const config: Record<string, unknown> = {};
+  for (const k of Object.keys(doc)) {
+    if (!PROMETHEUS_CONFIG_SECTIONS.includes(k)) warnings.push(`top-level section "${k}" is not one Prometheus ${PROM_VERSION} defines; it is not carried`);
+  }
+  const jobNames = new Set<string>();
+  for (const key of PROMETHEUS_CONFIG_SECTIONS) {
+    const v = doc[key];
+    if (v === undefined || v === null) continue;
+    if (key === "rule_files" || key === "scrape_config_files") {
+      const list = stringList(v, key, warnings);
+      if (list) config[key] = list;
+    } else if (key === "scrape_configs") {
+      if (!Array.isArray(v)) {
+        warnings.push("scrape_configs is not a list; it is not carried");
+        continue;
+      }
+      const jobs: ScrapeJobConfig[] = [];
+      v.forEach((raw, i) => {
+        if (!isPlainObject(raw) || typeof raw.job_name !== "string") {
+          warnings.push(`scrape_configs[${i}] has no job_name; it is not carried`);
+          return;
+        }
+        if (jobNames.has(raw.job_name)) warnings.push(`scrape_configs: job_name "${raw.job_name}" is used more than once; Prometheus rejects that`);
+        jobNames.add(raw.job_name);
+        const sd = Object.keys(raw).filter((k) => k.endsWith("_sd_configs") && !TYPED_SD_KINDS.includes(k));
+        if (sd.length > 0) warnings.push(`job "${raw.job_name}": ${sd.join(", ")} ${sd.length === 1 ? "is" : "are"} carried as data, untyped`);
+        jobs.push(raw as unknown as ScrapeJobConfig);
+      });
+      config.scrape_configs = jobs;
+    } else if (key === "remote_write" || key === "remote_read") {
+      if (Array.isArray(v)) config[key] = v;
+      else warnings.push(`${key} is not a list; it is not carried`);
+    } else if (isPlainObject(v)) {
+      config[key] = v;
+    } else {
+      warnings.push(`${key} is not a mapping; it is not carried`);
+    }
+  }
+  return config as PrometheusConfigFile;
+}
+
+const PROM_VERSION = PROMETHEUS_PIN.prometheus.version;
+
 // ── entry points ────────────────────────────────────────────────────
 
 /** Parse a rule file or `alertmanager.yml`, telling them apart by shape. */
@@ -331,16 +391,17 @@ export function parsePrometheusYaml(content: string): ParsedPrometheusFile {
   const warnings: string[] = [];
   const doc = content.trim() === "" ? {} : jsYaml.load(content, { schema: YAML_SCHEMA });
   if (!isPlainObject(doc)) {
-    throw new Error("a Prometheus rule file or alertmanager.yml is a YAML mapping; this document is not one");
+    throw new Error("a Prometheus rule file, alertmanager.yml or prometheus.yml is a YAML mapping; this document is not one");
   }
   if (looksLikeRuleFile(doc)) return { kind: "rules", file: parseRuleFile(doc, warnings), warnings };
   if (looksLikeAlertmanagerConfig(doc)) return { kind: "alertmanager", config: parseAlertmanager(doc, warnings), warnings };
+  if (looksLikePrometheusConfig(doc)) return { kind: "prometheus", config: parsePrometheusConfig(doc, warnings), warnings };
   if ("groups" in doc) {
     // A rule file with a malformed group still imports; the bad parts are named.
     return { kind: "rules", file: parseRuleFile(doc, warnings), warnings };
   }
   throw new Error(
-    "this YAML is neither a Prometheus rule file (groups: of named rule lists) nor an alertmanager.yml (route: or receivers:)",
+    "this YAML is not a Prometheus rule file (groups: of named rule lists), an alertmanager.yml (route: or receivers:) or a prometheus.yml (scrape_configs: and the like)",
   );
 }
 
@@ -349,7 +410,13 @@ export class PrometheusParser implements TemplateParser {
   parse(content: string): TemplateIR {
     const parsed = parsePrometheusYaml(content);
     const resource =
-      parsed.kind === "rules"
+      parsed.kind === "prometheus"
+        ? {
+            logicalId: "prometheus",
+            type: PROMETHEUS_RESOURCE_TYPE,
+            properties: { config: parsed.config } satisfies PrometheusResourceProperties as unknown as Record<string, unknown>,
+          }
+        : parsed.kind === "rules"
         ? {
             logicalId: "ruleFile",
             type: RULE_FILE_RESOURCE_TYPE,

package/src/import/prometheus-roundtrip.test.ts

@@ -0,0 +1,148 @@
+/**
+ * `prometheus.yml` through `chant import`: YAML -> TypeScript -> `chant build`
+ * -> YAML must give back the same file (key order and quoting aside), the
+ * generated source must lint clean, and `promtool check config` must accept
+ * both the fixture and what comes back, when `promtool` is on PATH (or
+ * `PROMTOOL` names it).
+ */
+
+import { describe, expect, test } from "vitest";
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "fs";
+import { join } from "path";
+import { load } from "js-yaml";
+import { build } from "@intentius/chant/build";
+import { lintCommand } from "@intentius/chant/cli/commands/lint";
+import { prometheusSerializer, PROMETHEUS_FILE } from "../serializer";
+import { hasTool, promtoolCheckConfig } from "../tools";
+import { PrometheusParser } from "./parser";
+import { PrometheusGenerator } from "./generator";
+import { pkgDir, read } from "./testdata/fixtures";
+import type { SerializerResult } from "@intentius/chant/serializer";
+
+const PROMTOOL = hasTool(process.env.PROMTOOL ?? "promtool");
+
+/** The `prometheus.yml` of one build output: the primary output, or the file beside a rule file. */
+function prometheusYml(out: string | SerializerResult | undefined): string {
+  if (out === undefined || typeof out === "string") return out ?? "";
+  return out.files?.[PROMETHEUS_FILE] ?? out.primary;
+}
+
+function projectDir(): string {
+  const dir = mkdtempSync(join(pkgDir, ".roundtrip-tmp-"));
+  mkdirSync(join(dir, "src"));
+  writeFileSync(join(dir, "chant.config.ts"), 'export default { lexicons: ["prometheus"] };\n');
+  writeFileSync(join(dir, "package.json"), '{ "name": "prometheus-config-roundtrip", "private": true, "type": "module" }\n');
+  return dir;
+}
+
+async function importAndBuild(yaml: string) {
+  const dir = projectDir();
+  try {
+    const srcDir = join(dir, "src");
+    const ir = new PrometheusParser().parse(yaml);
+    const files: string[] = [];
+    const sources: string[] = [];
+    for (const file of new PrometheusGenerator().generate(ir)) {
+      writeFileSync(join(srcDir, file.path), file.content);
+      files.push(file.path);
+      sources.push(`// ${file.path}\n${file.content}`);
+    }
+    const result = await build(srcDir, [prometheusSerializer]);
+    const lint = await lintCommand({ path: srcDir, format: "stylish" });
+    return {
+      files,
+      source: sources.join("\n"),
+      warnings: ir.warnings ?? [],
+      yaml: prometheusYml(result.outputs.get("prometheus")),
+      buildErrors: result.errors,
+      lint: { errorCount: lint.errorCount, warningCount: lint.warningCount, output: lint.output },
+    };
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+}
+
+type Doc = Record<string, unknown> & { scrape_configs?: Array<{ job_name: string }> };
+
+/** A parsed prometheus.yml with the scrape jobs sorted by name, the one order the serializer changes. */
+function normalize(yaml: string): Doc {
+  const doc = (load(yaml) ?? {}) as Doc;
+  if (doc.scrape_configs) doc.scrape_configs = [...doc.scrape_configs].sort((a, b) => a.job_name.localeCompare(b.job_name));
+  return doc;
+}
+
+/** Files the fixture's rule_files glob and promtool's checks read. */
+const COMPANIONS = { "rules/a.yml": "groups:\n  - name: g\n    rules:\n      - record: a:b\n        expr: sum(up)\n" };
+
+describe("prometheus.yml: YAML -> TypeScript -> YAML", () => {
+  test("a config using every typed section and discovery kind", async () => {
+    const fixture = read("prometheus-full.yml");
+    const out = await importAndBuild(fixture);
+    expect(out.buildErrors).toEqual([]);
+    expect(normalize(out.yaml)).toEqual(normalize(fixture));
+    if (out.lint.errorCount + out.lint.warningCount > 0) console.log(out.lint.output);
+    expect(out.lint.errorCount).toBe(0);
+    expect(out.lint.warningCount).toBe(0);
+
+    expect(out.files).toEqual(["scrape-configs-1.ts", "scrape-configs-2.ts", "prometheus.ts"]);
+    expect(out.source).toContain("new ScrapeConfig(");
+    expect(out.source).toContain("new PrometheusConfig(");
+    expect(out.source).toMatch(/: StaticConfig\[\] = /);
+    expect(out.source).toMatch(/: RelabelConfig\[\] = /);
+    expect(out.source).toMatch(/: KubernetesSDConfig\[\] = /);
+    expect(out.source).toMatch(/: FileSDConfig\[\] = /);
+    expect(out.source).toMatch(/: HttpSDConfig\[\] = /);
+    expect(out.source).toMatch(/: DnsSDConfig\[\] = /);
+    expect(out.source).toMatch(/: Ec2SDConfig\[\] = /);
+    expect(out.source).toMatch(/: ConsulSDConfig\[\] = /);
+    expect(out.source).toMatch(/: RemoteWriteConfig\[\] = /);
+    expect(out.source).toMatch(/: RemoteReadConfig\[\] = /);
+    expect(out.source).toMatch(/: PrometheusGlobalConfig = /);
+    expect(out.source).toMatch(/: PrometheusAlertingConfig = /);
+    expect(out.source).toMatch(/: OtlpConfig = /);
+
+    // The one discovery kind the lexicon does not type is named, and kept.
+    expect(out.source).toContain("docker_sd_configs is not a discovery kind the lexicon types");
+    expect(out.warnings).toHaveLength(1);
+    expect(out.warnings[0]).toContain("docker_sd_configs");
+  });
+
+  test("the config terragucci emits is a fixed point", async () => {
+    const yaml = `global:
+  scrape_interval: 5s
+scrape_configs:
+  - job_name: otel-collector
+    static_configs:
+      - targets:
+          - otel-collector:8889
+`;
+    const out = await importAndBuild(yaml);
+    expect(out.buildErrors).toEqual([]);
+    expect(out.yaml).toBe(yaml);
+    expect(out.warnings).toEqual([]);
+    expect(out.lint.errorCount + out.lint.warningCount, out.lint.output).toBe(0);
+    expect(out.files).toEqual(["scrape-configs.ts", "prometheus.ts"]);
+  });
+
+  test("scrape jobs only: no PrometheusConfig is declared", async () => {
+    const out = await importAndBuild("scrape_configs:\n  - job_name: a\n    static_configs:\n      - targets:\n          - a:1\n");
+    expect(out.files).toEqual(["scrape-configs.ts"]);
+    expect(out.source).not.toContain("PrometheusConfig(");
+  });
+
+  test("a rule file is still a rule file", async () => {
+    const ir = new PrometheusParser().parse("groups:\n  - name: g\n    rules:\n      - record: a:b\n        expr: sum(up)\n");
+    expect(ir.resources[0].type).toBe("Prometheus::RuleFile");
+  });
+});
+
+describe("promtool check config", () => {
+  test.skipIf(!PROMTOOL)("accepts the fixture and the file imported from it", async () => {
+    const fixture = read("prometheus-full.yml");
+    const before = promtoolCheckConfig(fixture, COMPANIONS);
+    expect(before.ok, before.output).toBe(true);
+    const out = await importAndBuild(fixture);
+    const after = promtoolCheckConfig(out.yaml, COMPANIONS);
+    expect(after.ok, after.output).toBe(true);
+  }, 60_000);
+});

package/src/import/slo.ts

@@ -41,6 +41,21 @@ function same(a: unknown, b: unknown): boolean {
 /** The SLI expressions a recorded error ratio was built from, with the window put back as `{{window}}`. */
 function sliFrom(expr: string, window: string): SloProps["sli"] | undefined {
   const unwindow = (s: string) => s.split(`[${window}]`).join(`[${SLO_WINDOW_PLACEHOLDER}]`);
+  // Since #3548 a window with no events records nothing: `((E) or 0 * ((T) > 0)) / ((T) > 0)`, and the good/total form
+  // as `1 - (((G) or 0 * ((T) > 0)) / ((T) > 0))`.
+  const idle = (head: string, divide: string, tail: string, key: "errors" | "good"): SloProps["sli"] | undefined => {
+    if (!expr.startsWith(head) || !expr.endsWith(tail)) return undefined;
+    const body = expr.slice(head.length, expr.length - tail.length);
+    const orAt = body.indexOf(") or 0 * ((");
+    const divAt = body.indexOf(`) > 0))${divide}((`);
+    if (orAt === -1 || divAt < orAt) return undefined;
+    const total = body.slice(divAt + `) > 0))${divide}((`.length);
+    return { [key]: unwindow(body.slice(0, orAt)), total: unwindow(total) } as SloProps["sli"];
+  };
+  const idleErrors = idle("((", "\n/\n", ") > 0)", "errors");
+  if (idleErrors) return idleErrors;
+  const idleGood = idle("1 - (\n  ((", "\n  /\n  ", ") > 0)\n)", "good");
+  if (idleGood) return idleGood;
   const goodHead = "1 - (\n  (";
   const goodTail = ")\n)";
   if (expr.startsWith(goodHead) && expr.endsWith(goodTail)) {