@intentius/chant-lexicon-prometheus 0.98.0 → 0.99.0

package/src/import/generator.ts

@@ -31,6 +31,8 @@ import type {
   RuleGroupConfig,
   TimeIntervalConfig,
 } from "../model";
+import { ALERTMANAGER_GLOBAL_FIELDS, RECEIVER_INTEGRATION_TYPES } from "../model";
+import { PROMETHEUS_PIN } from "../pin";
 import {
   ALERTMANAGER_RESOURCE_TYPE,
   RULE_FILE_RESOURCE_TYPE,
@@ -270,7 +272,24 @@ const LEXICON_NAMES = [
 
 /** Generate the TypeScript declaring one rule file. */
 export function generateRuleFileFiles(file: RuleFileConfig): GeneratedFile[] {
+  return generateRuleFile(file).files;
+}
+
+/** A rule group's declaration: the module and variable, and `rules` when it is an `Slo`'s group. */
+export interface GroupDeclaration {
+  readonly path: string;
+  readonly name: string;
+  readonly member?: "rules";
+}
+
+/**
+ * Generate the TypeScript declaring one rule file, and say where each of its
+ * groups is declared, in the file's order (#2962: a PrometheusRule's
+ * `spec.groups` refers to them).
+ */
+export function generateRuleFile(file: RuleFileConfig): { files: GeneratedFile[]; groups: GroupDeclaration[] } {
   const names = new Names(LEXICON_NAMES);
+  const declared = new Map<RuleGroupConfig, GroupDeclaration>();
   const slos: Array<{ group: RuleGroupConfig; props: NonNullable<ReturnType<typeof recognizeSlo>> }> = [];
   const groups: RuleGroupConfig[] = [];
   for (const g of file.groups) {
@@ -308,56 +327,45 @@ export function generateRuleFileFiles(file: RuleFileConfig): GeneratedFile[] {
       lines.push(`${ctor}${objectOf(entries, 0, ctor.length)});`);
       mod.block(lines);
       mod.exports.push(v);
+      declared.set(g, { path: mod.path, name: v });
     }
   }
 
   for (const [mod, items] of chunk(slos, "slos", "Service level objectives, each built by Slo() to its rule group")) {
     modules.push(mod);
     mod.use("Slo");
-    for (const { props } of items) {
+    for (const { group, props } of items) {
       const v = sloVars[slos.findIndex((s) => s.props === props)];
       const head = `const ${v} = Slo(`;
       mod.block([`${head}${tsLiteral(props, 0, head.length)});`]);
       mod.exports.push(v);
+      declared.set(group, { path: mod.path, name: v, member: "rules" });
     }
   }
 
-  return modules.map((m) => ({ path: m.path, content: m.render() }));
+  return {
+    files: modules.map((m) => ({ path: m.path, content: m.render() })),
+    groups: file.groups.map((g) => declared.get(g)!),
+  };
 }
 
 // ── alertmanager.yml ─────────────────────────────────────────────────
 
 /** Receiver fields the lexicon types, with the type each list is declared as. */
 const RECEIVER_FIELD_TYPES: Record<string, string> = {
-  webhook_configs: "WebhookConfig[]",
-  email_configs: "EmailConfig[]",
-  slack_configs: "SlackConfig[]",
-  pagerduty_configs: "PagerDutyConfig[]",
+  ...Object.fromEntries(Object.entries(RECEIVER_INTEGRATION_TYPES).map(([k, t]) => [k, `${t}[]`])),
   labels: "LabelSet",
 };
 
 /** `global:` fields the lexicon types. */
-const GLOBAL_FIELDS = new Set([
-  "resolve_timeout",
-  "smtp_from",
-  "smtp_smarthost",
-  "smtp_hello",
-  "smtp_auth_username",
-  "smtp_auth_password",
-  "smtp_auth_password_file",
-  "smtp_auth_secret",
-  "smtp_auth_secret_file",
-  "smtp_auth_identity",
-  "smtp_require_tls",
-  "slack_api_url",
-  "slack_api_url_file",
-  "pagerduty_url",
-  "http_config",
-]);
+const GLOBAL_FIELDS = new Set<string>(ALERTMANAGER_GLOBAL_FIELDS);
+
+const AM_VERSION = PROMETHEUS_PIN.alertmanager.version;
 
 /** A comment naming the fields carried as data, wrapped at the line limit. */
 function untypedComment(what: string, keys: string[]): string[] {
-  const text = `${what} ${keys.join(", ")} ${keys.length === 1 ? "is" : "are"} not typed by this lexicon, so ${keys.length === 1 ? "it is" : "they are"} carried as data.`;
+  const one = keys.length === 1;
+  const text = `${what} ${keys.join(", ")} ${one ? "is not a field" : "are not fields"} Alertmanager ${AM_VERSION} defines, so ${one ? "it is" : "they are"} carried as data, untyped.`;
   const lines: string[] = [];
   let cur = "//";
   for (const w of text.split(" ")) {

package/src/import/parser.test.ts

@@ -96,6 +96,19 @@ describe("parsePrometheusYaml", () => {
         opsgenie_configs: [{ api_key: "literal" }],
       },
     ]);
+    expect(parsed.warnings).toEqual([]);
+  });
+
+  test("a receiver or global key Alertmanager doesn't define is carried and named in a warning", () => {
+    const parsed = parsePrometheusYaml(
+      lines("global: { resolve_timeout: 5m, pigeon_loft: roof }", "receivers:", "  - name: chat", "    pigeon_configs: [{ loft: roof }]"),
+    );
+    if (parsed.kind !== "alertmanager") throw new Error("expected alertmanager.yml");
+    expect(parsed.config.receivers).toEqual([{ name: "chat", pigeon_configs: [{ loft: "roof" }] }]);
+    expect(parsed.warnings).toEqual([
+      "global: pigeon_loft is not a global field in Alertmanager v0.34.1; carried as data, untyped",
+      'receiver "chat": pigeon_configs is not a receiver field in Alertmanager v0.34.1; carried as data, untyped',
+    ]);
   });
 
   test("dates and times stay strings, as the Go loaders read them", () => {

package/src/import/parser.ts

@@ -21,6 +21,8 @@
 import * as jsYaml from "js-yaml";
 import type { TemplateIR, TemplateParser } from "@intentius/chant/import/parser";
 import {
+  ALERTMANAGER_GLOBAL_FIELDS,
+  RECEIVER_INTEGRATIONS,
   looksLikeAlertmanagerConfig,
   looksLikeRuleFile,
   type AlertmanagerConfig,
@@ -32,6 +34,7 @@ import {
   type RuleGroupConfig,
   type TimeIntervalConfig,
 } from "../model";
+import { PROMETHEUS_PIN } from "../pin";
 
 /** The IR resource type for a whole rule file. */
 export const RULE_FILE_RESOURCE_TYPE = "Prometheus::RuleFile";
@@ -264,12 +267,22 @@ function parseTimeIntervals(raw: unknown, at: string, warnings: string[]): TimeI
   return out;
 }
 
+const AM_VERSION = PROMETHEUS_PIN.alertmanager.version;
+const RECEIVER_KEYS = new Set<string>(["name", "labels", ...RECEIVER_INTEGRATIONS]);
+const GLOBAL_KEYS = new Set<string>(ALERTMANAGER_GLOBAL_FIELDS);
+
 function parseAlertmanager(doc: Record<string, unknown>, warnings: string[]): AlertmanagerConfig {
   for (const k of Object.keys(doc)) {
     if (!AM_SECTIONS.includes(k)) warnings.push(`top-level section "${k}" is not one chant declares; it is not carried`);
   }
   const config: AlertmanagerConfig = {};
-  if (isPlainObject(doc.global)) config.global = doc.global as AlertmanagerConfig["global"];
+  if (isPlainObject(doc.global)) {
+    config.global = doc.global as AlertmanagerConfig["global"];
+    const unknown = Object.keys(doc.global).filter((k) => !GLOBAL_KEYS.has(k));
+    if (unknown.length > 0) {
+      warnings.push(`global: ${unknown.join(", ")} ${unknown.length === 1 ? "is not a global field" : "are not global fields"} in Alertmanager ${AM_VERSION}; carried as data, untyped`);
+    }
+  }
   else if (doc.global !== undefined && doc.global !== null) warnings.push("global is not a mapping; it is not carried");
   const templates = stringList(doc.templates, "templates", warnings);
   if (templates) config.templates = templates;
@@ -288,6 +301,10 @@ function parseAlertmanager(doc: Record<string, unknown>, warnings: string[]): Al
         warnings.push(`receivers[${i}] has no name; it is not carried`);
         return;
       }
+      const unknown = Object.keys(r).filter((k) => !RECEIVER_KEYS.has(k));
+      if (unknown.length > 0) {
+        warnings.push(`receiver "${String(r.name)}": ${unknown.join(", ")} ${unknown.length === 1 ? "is not a receiver field" : "are not receiver fields"} in Alertmanager ${AM_VERSION}; carried as data, untyped`);
+      }
       receivers.push({ ...r, name: String(r.name) } as ReceiverConfig);
     });
     config.receivers = receivers;

package/src/import/roundtrip.test.ts

@@ -24,7 +24,7 @@ import { build } from "@intentius/chant/build";
 import { lintCommand } from "@intentius/chant/cli/commands/lint";
 import { prometheusSerializer } from "../serializer";
 import { amtoolCheckConfig, hasTool, promtoolCheckRules } from "../tools";
-import type { AlertmanagerConfig, RouteConfig, RuleFileConfig } from "../model";
+import { RECEIVER_INTEGRATION_TYPES, type AlertmanagerConfig, type RouteConfig, type RuleFileConfig } from "../model";
 import { PrometheusParser } from "./parser";
 import { PrometheusGenerator } from "./generator";
 import { builtFiles, exampleOutputs, pkgDir, read, sloOutputs, UPSTREAM, type BuiltFile } from "./testdata/fixtures";
@@ -256,10 +256,11 @@ describe("YAML -> TypeScript -> YAML", () => {
     expect(out.source).toContain('url_file: "/etc/alertmanager/secrets/default-webhook-url"');
     expect(out.source).toContain("description: '{{ template \"pagerduty.default.description\" . }}'");
     expect(out.source).toContain('summary: "{{ .GroupLabels.alertname }} in {{ .GroupLabels.cluster }}"');
-    // Integrations and global fields the lexicon does not type are carried as data, spread in.
-    expect(out.source).toContain("// Receiver \"oncall\": opsgenie_configs is not typed by this lexicon");
-    expect(out.source).toContain("...oncallUntyped,");
-    expect(out.source).toContain("...globalUntyped,");
+    // Every integration and global field is typed.
+    expect(out.source).toContain("const oncallOpsgenie: OpsGenieConfig[] = [");
+    expect(out.source).toContain("const dbChatMsteams: MSTeamsConfig[] = [");
+    expect(out.source).toContain('opsgenie_api_key_file: "/etc/alertmanager/secrets/opsgenie-key"');
+    expect(out.source).not.toContain("Untyped");
     // Deprecated spellings are rewritten, and each rewrite is named.
     expect(out.source).toContain(`matchers: ['severity="page"', 'service=~"^(api|web)$"']`);
     expect(out.source).toContain(`source_matchers: ['severity="page"']`);
@@ -270,20 +271,55 @@ describe("YAML -> TypeScript -> YAML", () => {
     expect(out.warnings.join("\n")).toContain("top-level mute_time_intervals (weekends)");
   });
 
+  /**
+   * What each upstream sample is expected to raise: literal credentials
+   * (Alertmanager's own examples write placeholder secrets inline), which
+   * PROM001 reports, and deprecated `match` spellings, which import warns
+   * about. A sample not listed raises nothing.
+   */
+  const UPSTREAM_EXPECT: Record<string, { prom001?: number; warnings?: number }> = {
+    "alertmanager-simple.yml": { prom001: 4 },
+    // smtp_auth_password, slack_api_url, three routing_keys, the VictorOps and Opsgenie api_keys, Pushover's token and user_key.
+    "alertmanager-conf-good.yml": { prom001: 9, warnings: 9 },
+    "alertmanager-opsgenie-default-apikey-file.yml": { warnings: 1 },
+    "alertmanager-rocketchat-default-token-file.yml": { warnings: 1 },
+    "alertmanager-victorops-default-apikey-file.yml": { warnings: 1 },
+    "alertmanager-wechat-default-api-secret-file.yml": { prom001: 1 },
+  };
+
+  test("an alertmanager.yml using every receiver integration", async () => {
+    const out = await expectRoundTrip(read("alertmanager-integrations.yml"));
+    expect(out.warnings).toEqual([]);
+    expect(out.source).not.toContain("Untyped");
+    for (const type of Object.values(RECEIVER_INTEGRATION_TYPES)) expect(out.source).toMatch(new RegExp(`: ${type}\\[\\] = `));
+    // Fields the common four integrations gained, and structured values, keep their types.
+    expect(out.source).toContain('message_text: "{{ .CommonLabels.alertname }}"');
+    expect(out.source).toContain('threading: { enabled: true, thread_by_date: "daily" }');
+    expect(out.source).toContain("chat_id: -1001234567890");
+    expect(out.source).toContain('description: { template: \'{{ template "jira.default.description" . }}\', enable_update: false }');
+    expect(out.source).toContain('http_headers: {');
+  });
+
   for (const file of UPSTREAM) {
     test(`upstream sample: ${file}`, async () => {
       const yaml = read("upstream", file);
-      // The Alertmanager example writes placeholder secrets inline, which PROM001 reports.
-      const out = await expectRoundTrip(yaml, file === "alertmanager-simple.yml" ? { lintRules: ["PROM001"] } : {});
-      expect(out.warnings).toEqual([]);
+      const expected = UPSTREAM_EXPECT[file] ?? {};
+      const out = await expectRoundTrip(yaml, expected.prom001 ? { lintRules: ["PROM001"] } : {});
+      expect(out.lint.output.match(/PROM001/g) ?? []).toHaveLength(expected.prom001 ?? 0);
+      expect(out.warnings).toHaveLength(expected.warnings ?? 0);
+      for (const w of out.warnings) expect(w).toMatch(/match(_re)? are written as/);
+      // Every integration and global field is typed: nothing is carried as untyped data.
+      expect(out.source).not.toContain("Untyped");
       if (file === "alertmanager-simple.yml") {
         expect(out.source).toContain('service_key: "<team-X-key>"');
         expect(out.source).toContain("const tracing: AlertmanagerTracingConfig = {");
-        expect(out.lint.output.match(/PROM001/g)).toHaveLength(4);
       }
       if (file === "alertmanager-route-labels.yml") {
         expect(out.source).toContain('reason: "database {{ .GroupLabels.database }}"');
       }
+      if (file === "alertmanager-sns-topic-arn.yml") {
+        expect(out.source).toContain("const snsApiNotificationsSns: SNSConfig[] = [");
+      }
     });
   }
 });
@@ -300,6 +336,7 @@ describe("upstream tools accept the re-emitted files", () => {
   const amFixtures = async (): Promise<BuiltFile[]> => [
     ...(await exampleOutputs()).filter((o) => o.name.endsWith("alertmanager.yml")),
     handWritten("alertmanager-full.yml"),
+    handWritten("alertmanager-integrations.yml"),
     ...UPSTREAM.filter((f) => f.startsWith("alertmanager-")).map(upstream),
   ];
 

package/src/import/testdata/alertmanager-full.yml

@@ -1,7 +1,7 @@
 # Deprecated spellings (match, match_re, source_match, the top-level
-# mute_time_intervals), integrations this lexicon does not type (opsgenie,
-# msteams), global fields outside the typed set, *_file credentials, Go
-# templates, a YAML anchor with a merge key, and one literal credential.
+# mute_time_intervals), integrations beside the common four (opsgenie,
+# msteams) and their global fields, *_file credentials, Go templates, a YAML
+# anchor with a merge key, and one literal credential.
 global:
   resolve_timeout: 5m
   smtp_smarthost: smtp.example.com:587

package/src/import/testdata/alertmanager-integrations.yml

@@ -0,0 +1,215 @@
+# Every receiver integration Alertmanager v0.34.1 defines, each with the
+# fields its struct lists beyond the destination, every credential read from
+# a *_file, and every global field that has a default for one of them.
+global:
+  resolve_timeout: 5m
+  http_config:
+    follow_redirects: true
+    enable_http2: false
+    http_headers:
+      X-Tenant:
+        values: [platform]
+      X-Api-Key:
+        files: [/etc/alertmanager/secrets/api-key-header]
+  jira_api_url: https://jira.example.com/rest/api/2/
+  smtp_from: alertmanager@example.com
+  smtp_smarthost: smtp.example.com:465
+  smtp_auth_username: alertmanager
+  smtp_auth_password_file: /etc/alertmanager/secrets/smtp-password
+  smtp_require_tls: false
+  smtp_force_implicit_tls: true
+  smtp_tls_config:
+    ca_file: /etc/alertmanager/tls/ca.pem
+    min_version: TLS12
+  slack_app_token_file: /etc/alertmanager/secrets/slack-app-token
+  slack_app_url: https://slack.com/api/chat.postMessage
+  opsgenie_api_url: https://api.eu.opsgenie.com/
+  opsgenie_api_key_file: /etc/alertmanager/secrets/opsgenie-key
+  wechat_api_url: https://qyapi.weixin.qq.com/cgi-bin/
+  wechat_api_secret_file: /etc/alertmanager/secrets/wechat-secret
+  wechat_api_corp_id: corp-1
+  victorops_api_url: https://alert.victorops.com/integrations/generic/20131114/alert/
+  victorops_api_key_file: /etc/alertmanager/secrets/victorops-key
+  telegram_api_url: https://api.telegram.org
+  telegram_bot_token_file: /etc/alertmanager/secrets/telegram-token
+  webex_api_url: https://webexapis.com/v1/messages
+  rocketchat_api_url: https://open.rocket.chat
+  rocketchat_token_file: /etc/alertmanager/secrets/rocketchat-token
+  rocketchat_token_id_file: /etc/alertmanager/secrets/rocketchat-token-id
+  mattermost_webhook_url_file: /etc/alertmanager/secrets/mattermost-url
+route:
+  receiver: chat
+  group_by: [alertname]
+  routes:
+    - matchers: ['team="ops"']
+      receiver: ops
+    - matchers: ['team="tickets"']
+      receiver: tickets
+    - matchers: ['team="mobile"']
+      receiver: mobile
+receivers:
+  - name: chat
+    slack_configs:
+      - channel: '#alerts'
+        message_text: '{{ .CommonLabels.alertname }}'
+        callback_id: alerts
+        image_url: https://example.com/graph.png
+        thumb_url: https://example.com/thumb.png
+        update_message: true
+        timeout: 10s
+        fields:
+          - title: Severity
+            value: '{{ .CommonLabels.severity }}'
+            short: true
+        actions:
+          - type: button
+            text: Runbook
+            url: '{{ .CommonAnnotations.runbook_url }}'
+            style: primary
+            confirm:
+              text: Open the runbook?
+              ok_text: 'Yes'
+              dismiss_text: 'No'
+    discord_configs:
+      - webhook_url_file: /etc/alertmanager/secrets/discord-url
+        title: '{{ .CommonLabels.alertname }}'
+        message: '{{ .CommonAnnotations.summary }}'
+        content: '<@&123456>'
+        username: alertmanager
+        avatar_url: https://example.com/avatar.png
+    msteams_configs:
+      - webhook_url_file: /etc/alertmanager/secrets/teams-url
+        title: '{{ .CommonLabels.alertname }}'
+        summary: '{{ .CommonAnnotations.summary }}'
+        text: '{{ .CommonAnnotations.description }}'
+    msteamsv2_configs:
+      - webhook_url_file: /etc/alertmanager/secrets/teams-workflow-url
+        title: '{{ .CommonLabels.alertname }}'
+        text: '{{ .CommonAnnotations.description }}'
+    mattermost_configs:
+      - channel: alerts
+        username: alertmanager
+        text: '{{ .CommonAnnotations.summary }}'
+        icon_emoji: ':rotating_light:'
+        attachments:
+          - title: '{{ .CommonLabels.alertname }}'
+            color: danger
+            fields:
+              - title: Severity
+                value: '{{ .CommonLabels.severity }}'
+                short: true
+        props:
+          card: '{{ .CommonAnnotations.description }}'
+        priority:
+          priority: urgent
+          requested_ack: true
+    webex_configs:
+      - room_id: room-1
+        message: '{{ .CommonAnnotations.summary }}'
+        http_config:
+          authorization:
+            credentials_file: /etc/alertmanager/secrets/webex-token
+    rocketchat_configs:
+      - channel: '#alerts'
+        title: '{{ .CommonLabels.alertname }}'
+        emoji: ':fire:'
+        short_fields: true
+        fields:
+          - title: Severity
+            value: '{{ .CommonLabels.severity }}'
+            short: true
+        actions:
+          - type: button
+            text: Silence
+            url: https://alertmanager.example.com/#/silences/new
+    telegram_configs:
+      - chat_id: -1001234567890
+        message_thread_id: 7
+        parse_mode: HTML
+        disable_notifications: false
+        message: '{{ .CommonAnnotations.summary }}'
+  - name: ops
+    email_configs:
+      - to: ops@example.com
+        force_implicit_tls: true
+        threading:
+          enabled: true
+          thread_by_date: daily
+    opsgenie_configs:
+      - message: '{{ .CommonLabels.alertname }}'
+        priority: P2
+        tags: 'team,ops'
+        details:
+          cluster: '{{ .CommonLabels.cluster }}'
+        responders:
+          - name: ops
+            type: team
+        update_alerts: true
+    victorops_configs:
+      - routing_key: ops
+        message_type: CRITICAL
+        entity_display_name: '{{ .CommonLabels.alertname }}'
+        custom_fields:
+          cluster: '{{ .CommonLabels.cluster }}'
+    pagerduty_configs:
+      - routing_key_file: /etc/alertmanager/secrets/pagerduty-key
+        timeout: 20s
+        details:
+          firing: '{{ .Alerts.Firing | len }}'
+    incidentio_configs:
+      - url: https://api.incident.io/v2/alert_events/http/01ABC
+        alert_source_token_file: /etc/alertmanager/secrets/incidentio-token
+        max_alerts: 20
+        timeout: 15s
+    webhook_configs:
+      - url_file: /etc/alertmanager/secrets/webhook-url
+        timeout: 5s
+        http_config:
+          oauth2:
+            client_id: alertmanager
+            client_secret_file: /etc/alertmanager/secrets/oauth-secret
+            token_url: https://auth.example.com/token
+            scopes: [alerts]
+  - name: tickets
+    jira_configs:
+      - project: OPS
+        issue_type: Bug
+        summary: '{{ template "jira.default.summary" . }}'
+        description:
+          template: '{{ template "jira.default.description" . }}'
+          enable_update: false
+        labels: [alertmanager]
+        priority: High
+        resolve_transition: Done
+        reopen_transition: Reopen
+        wont_fix_resolution: "Won't Fix"
+        reopen_duration: 1h
+        fields:
+          customfield_10001: ops
+        http_config:
+          basic_auth:
+            username: alertmanager
+            password_file: /etc/alertmanager/secrets/jira-password
+    sns_configs:
+      - topic_arn: arn:aws:sns:us-east-1:123456789012:alerts
+        subject: '{{ .CommonLabels.alertname }}'
+        sigv4:
+          region: us-east-1
+          role_arn: arn:aws:iam::123456789012:role/alertmanager
+        attributes:
+          team: ops
+  - name: mobile
+    pushover_configs:
+      - user_key_file: /etc/alertmanager/secrets/pushover-user
+        token_file: /etc/alertmanager/secrets/pushover-token
+        priority: '{{ if eq .Status "firing" }}2{{ else }}0{{ end }}'
+        retry: 1m
+        expire: 1h
+        ttl: 24h
+        sound: siren
+        html: true
+    wechat_configs:
+      - to_user: '@all'
+        agent_id: '1000002'
+        message_type: markdown
+        message: '{{ .CommonAnnotations.summary }}'

package/src/import/testdata/fixtures.ts

@@ -111,4 +111,12 @@ export const UPSTREAM = [
   "prometheus-alerting-templates.yml",
   "alertmanager-simple.yml",
   "alertmanager-route-labels.yml",
+  "alertmanager-conf-good.yml",
+  "alertmanager-mattermost-default-webhook-url-file.yml",
+  "alertmanager-opsgenie-default-apikey-file.yml",
+  "alertmanager-rocketchat-default-token-file.yml",
+  "alertmanager-sns-topic-arn.yml",
+  "alertmanager-telegram-default-bot-token-file.yml",
+  "alertmanager-victorops-default-apikey-file.yml",
+  "alertmanager-wechat-default-api-secret-file.yml",
 ];

package/src/import/testdata/upstream/alertmanager-conf-good.yml

@@ -0,0 +1,120 @@
+# Vendored from github.com/prometheus/alertmanager v0.34.1, config/testdata/conf.good.yml
+# (https://github.com/prometheus/alertmanager/blob/v0.34.1/config/testdata/conf.good.yml). Apache-2.0.
+# Unchanged below this header.
+global:
+  # The smarthost and SMTP sender used for mail notifications.
+  smtp_smarthost: 'localhost:25'
+  smtp_from: 'alertmanager@example.org'
+  smtp_auth_username: 'alertmanager'
+  smtp_auth_password: "multiline\nmysecret"
+  smtp_hello: "host.example.org"
+  slack_api_url: "http://mysecret.example.com/"
+  http_config:
+    proxy_url: 'http://127.0.0.1:1025'
+# The directory from which notification templates are read.
+templates:
+  - '/etc/alertmanager/template/*.tmpl'
+# The root route on which each incoming alert enters.
+route:
+  # The labels by which incoming alerts are grouped together. For example,
+  # multiple alerts coming in for cluster=A and alertname=LatencyHigh would
+  # be batched into a single group.
+  group_by: ['alertname', 'cluster', 'service']
+  # When a new group of alerts is created by an incoming alert, wait at
+  # least 'group_wait' to send the initial notification.
+  # This way ensures that you get multiple alerts for the same group that start
+  # firing shortly after another are batched together on the first
+  # notification.
+  group_wait: 30s
+  # When the first notification was sent, wait 'group_interval' to send a batch
+  # of new alerts that started firing for that group.
+  group_interval: 5m
+  # If an alert has successfully been sent, wait 'repeat_interval' to
+  # resend them.
+  repeat_interval: 3h
+  # A default receiver
+  receiver: team-X-mails
+  # All the above attributes are inherited by all child routes and can
+  # overwritten on each.
+
+  # The child route trees.
+  routes:
+    # This routes performs a regular expression match on alert labels to
+    # catch alerts that are related to a list of services.
+    - match_re:
+        service: ^(foo1|foo2|baz)$
+      receiver: team-X-mails
+      # The service has a sub-route for critical alerts, any alerts
+      # that do not match, i.e. severity != critical, fall-back to the
+      # parent node and are sent to 'team-X-mails'
+      routes:
+        - match:
+            severity: critical
+          receiver: team-X-pager
+    - match:
+        service: files
+      receiver: team-Y-mails
+      routes:
+        - match:
+            severity: critical
+          receiver: team-Y-pager
+    # This route handles all alerts coming from a database service. If there's
+    # no team to handle it, it defaults to the DB team.
+    - match:
+        service: database
+      receiver: team-DB-pager
+      # Also group alerts by affected database.
+      group_by: [alertname, cluster, database]
+      routes:
+        - match:
+            owner2: team-X
+          receiver: team-X-pager
+          continue: true
+        - match:
+            owner: team-Y
+          receiver: team-Y-pager
+          # continue: true
+# Inhibition rules allow to mute a set of alerts given that another alert is
+# firing.
+# We use this to mute any warning-level notifications if the same alert is
+# already critical.
+inhibit_rules:
+  - source_match:
+      severity: 'critical'
+    target_match:
+      severity: 'warning'
+    # Apply inhibition if the alertname is the same.
+    equal: ['alertname', 'cluster', 'service']
+receivers:
+  - name: 'team-X-mails'
+    email_configs:
+      - to: 'team-X+alerts@example.org'
+  - name: 'team-X-pager'
+    email_configs:
+      - to: 'team-X+alerts-critical@example.org'
+    pagerduty_configs:
+      - routing_key: "mysecret"
+  - name: 'team-Y-mails'
+    email_configs:
+      - to: 'team-Y+alerts@example.org'
+  - name: 'team-Y-pager'
+    pagerduty_configs:
+      - routing_key: "mysecret"
+  - name: 'team-DB-pager'
+    pagerduty_configs:
+      - routing_key: "mysecret"
+  - name: victorOps-receiver
+    victorops_configs:
+      - api_key: mysecret
+        routing_key: Sample_route
+  - name: opsGenie-receiver
+    opsgenie_configs:
+      - api_key: mysecret
+  - name: pushover-receiver
+    pushover_configs:
+      - token: mysecret
+        user_key: key
+  - name: slack-receiver
+    slack_configs:
+      - channel: '#my-channel'
+        image_url: 'http://some.img.com/img.png'

package/src/import/testdata/upstream/alertmanager-mattermost-default-webhook-url-file.yml

@@ -0,0 +1,16 @@
+# Vendored from github.com/prometheus/alertmanager v0.34.1, config/testdata/conf.mattermost-default-webhook-url-file.yml
+# (https://github.com/prometheus/alertmanager/blob/v0.34.1/config/testdata/conf.mattermost-default-webhook-url-file.yml). Apache-2.0.
+# Unchanged below this header.
+global:
+  mattermost_webhook_url_file: /global_file
+route:
+  receiver: team-X-mattermost
+
+receivers:
+  - name: team-X-mattermost
+    mattermost_configs:
+      - channel: team-X
+  - name: team-Y-mattermost
+    mattermost_configs:
+      - channel: team-Y
+        webhook_url_file: /override_file

package/src/import/testdata/upstream/alertmanager-opsgenie-default-apikey-file.yml

@@ -0,0 +1,27 @@
+# Vendored from github.com/prometheus/alertmanager v0.34.1, config/testdata/conf.opsgenie-default-apikey-file.yml
+# (https://github.com/prometheus/alertmanager/blob/v0.34.1/config/testdata/conf.opsgenie-default-apikey-file.yml). Apache-2.0.
+# Unchanged below this header.
+global:
+  opsgenie_api_key_file: '/global_file'
+route:
+  group_by: ['alertname', 'cluster', 'service']
+  group_wait: 30s
+  group_interval: 5m
+  repeat_interval: 3h
+  receiver: escalation-Y-opsgenie
+  routes:
+    - match:
+        service: foo
+      receiver: team-X-opsgenie
+receivers:
+  - name: 'team-X-opsgenie'
+    opsgenie_configs:
+      - responders:
+          - name: 'team-X'
+            type: 'team'
+  - name: 'escalation-Y-opsgenie'
+    opsgenie_configs:
+      - responders:
+          - name: 'escalation-Y'
+            type: 'escalation'
+        api_key_file: /override_file