@intentius/chant-lexicon-grafana 0.124.30 → 0.124.32

package/dist/composites/catalog.js

@@ -0,0 +1,306 @@
+export const compositeCatalog = [
+    {
+        "name": "AgentDashboard",
+        "lexicon": "grafana",
+        "description": "A dashboard for agents instrumented with GenAI spans.",
+        "bundles": [
+            "Dashboard"
+        ],
+        "params": [
+            {
+                "name": "genAi",
+                "type": "GenAiMetrics | { metrics: GenAiMetrics }",
+                "required": false,
+                "description": "The preset's metrics: `genAiMetrics(options)` with the options the collector was built with, or `genAiComponents(options)`."
+            },
+            {
+                "name": "rules",
+                "type": "GenAiRulesInstance | RuleGroupEntity | GenAiRuleMetrics",
+                "required": false,
+                "description": "Read the series a prometheus `GenAiRules` records instead of the preset's metrics."
+            },
+            {
+                "name": "quantile",
+                "type": "number",
+                "required": false,
+                "description": "The latency quantile per model and per tool (default 0.95)."
+            },
+            {
+                "name": "datasource",
+                "type": "DatasourceInput<\"prometheus\">",
+                "required": true,
+                "description": "The Prometheus the metrics are queried from: a declared `Datasource`, or `{ type: \"prometheus\", uid }` for one declared elsewhere."
+            },
+            {
+                "name": "title",
+                "type": "string",
+                "required": false
+            },
+            {
+                "name": "uid",
+                "type": "string",
+                "required": false,
+                "description": "The dashboard uid."
+            },
+            {
+                "name": "description",
+                "type": "string",
+                "required": false
+            },
+            {
+                "name": "tags",
+                "type": "string[]",
+                "required": false
+            },
+            {
+                "name": "folder",
+                "type": "string | FolderEntity",
+                "required": false,
+                "description": "The Grafana folder to provision it into: a path, or a `Folder` to pin its uid."
+            },
+            {
+                "name": "time",
+                "type": "{ from: string; to: string }",
+                "required": false,
+                "description": "Initial time range."
+            },
+            {
+                "name": "refresh",
+                "type": "string",
+                "required": false,
+                "description": "Auto-refresh interval, e.g. `30s`."
+            },
+            {
+                "name": "links",
+                "type": "DashboardLinkInput[]",
+                "required": false
+            }
+        ]
+    },
+    {
+        "name": "RedDashboard",
+        "lexicon": "grafana",
+        "description": "A RED dashboard (rate, errors, duration) per service, built from a `spanmetrics` connector declaration.",
+        "bundles": [
+            "Dashboard"
+        ],
+        "params": [
+            {
+                "name": "spanMetrics",
+                "type": "OTelComponent<\"connector\", \"spanmetrics\", SpanMetricsConnectorConfig> | SpanMetricsNames",
+                "required": true,
+                "description": "The `spanmetrics` connector the metrics come from, or the names `spanMetricsNames()` returned for it."
+            },
+            {
+                "name": "exporter",
+                "type": "OTelComponent<\"exporter\", \"prometheus\", PrometheusExporterConfig> | PrometheusNaming",
+                "required": false,
+                "description": "The `prometheus` exporter that serves them, when its `namespace` or `add_metric_suffixes` changes the names."
+            },
+            {
+                "name": "quantiles",
+                "type": "number[]",
+                "required": false,
+                "description": "Duration quantiles, one panel each (default p50, p95 and p99)."
+            },
+            {
+                "name": "spanKinds",
+                "type": "SpanKind[]",
+                "required": false,
+                "description": "The span kinds the queries count (default server and consumer spans)."
+            },
+            {
+                "name": "datasource",
+                "type": "DatasourceInput<\"prometheus\">",
+                "required": true,
+                "description": "The Prometheus the metrics are queried from: a declared `Datasource`, or `{ type: \"prometheus\", uid }` for one declared elsewhere."
+            },
+            {
+                "name": "title",
+                "type": "string",
+                "required": false
+            },
+            {
+                "name": "uid",
+                "type": "string",
+                "required": false,
+                "description": "The dashboard uid."
+            },
+            {
+                "name": "description",
+                "type": "string",
+                "required": false
+            },
+            {
+                "name": "tags",
+                "type": "string[]",
+                "required": false
+            },
+            {
+                "name": "folder",
+                "type": "string | FolderEntity",
+                "required": false,
+                "description": "The Grafana folder to provision it into: a path, or a `Folder` to pin its uid."
+            },
+            {
+                "name": "time",
+                "type": "{ from: string; to: string }",
+                "required": false,
+                "description": "Initial time range."
+            },
+            {
+                "name": "refresh",
+                "type": "string",
+                "required": false,
+                "description": "Auto-refresh interval, e.g. `30s`."
+            },
+            {
+                "name": "links",
+                "type": "DashboardLinkInput[]",
+                "required": false
+            }
+        ]
+    },
+    {
+        "name": "SloAlertRules",
+        "lexicon": "grafana",
+        "description": "Grafana-managed burn-rate alerts for an `Slo`: one rule per window pair, with the labels and annotations the `Slo`'s Prometheus alerts carry.",
+        "bundles": [
+            "AlertRuleGroup"
+        ],
+        "params": [
+            {
+                "name": "slo",
+                "type": "SloInstance | RuleGroupEntity | SloMetrics",
+                "required": true,
+                "description": "The `Slo(...)` the rules alert on, its rule group, or what `sloMetrics()` returned for it."
+            },
+            {
+                "name": "datasource",
+                "type": "DatasourceInput<\"prometheus\">",
+                "required": true,
+                "description": "The Prometheus holding the `Slo`'s recorded series: a declared `Datasource`, an `ExternalDatasource`, or `{ type: \"prometheus\", uid }`."
+            },
+            {
+                "name": "folder",
+                "type": "string",
+                "required": true,
+                "description": "The Grafana folder the rules are stored in, by title."
+            },
+            {
+                "name": "group",
+                "type": "string",
+                "required": false,
+                "description": "The rule group's name."
+            },
+            {
+                "name": "interval",
+                "type": "string",
+                "required": false,
+                "description": "How often the rules are evaluated, a multiple of 10s."
+            },
+            {
+                "name": "contactPoint",
+                "type": "ContactPointEntity | string",
+                "required": false,
+                "description": "Send the alerts straight to this contact point."
+            },
+            {
+                "name": "for",
+                "type": "string",
+                "required": false,
+                "description": "How long a pair must hold before its alert fires."
+            },
+            {
+                "name": "labels",
+                "type": "Record<string, string>",
+                "required": false,
+                "description": "More labels on every rule, e.g. `team`."
+            },
+            {
+                "name": "annotations",
+                "type": "Record<string, string>",
+                "required": false,
+                "description": "More annotations on every rule, e.g. `runbook_url`."
+            },
+            {
+                "name": "noDataState",
+                "type": "NoDataState",
+                "required": false,
+                "description": "What no data does."
+            },
+            {
+                "name": "execErrState",
+                "type": "ExecErrState",
+                "required": false,
+                "description": "What a query error does."
+            }
+        ]
+    },
+    {
+        "name": "SloDashboard",
+        "lexicon": "grafana",
+        "description": "A dashboard for one SLO: the SLI over its window against the objective, the error budget left, and each burn-rate alert's two windows with the rate it fires...",
+        "bundles": [
+            "Dashboard"
+        ],
+        "params": [
+            {
+                "name": "slo",
+                "type": "SloInstance | RuleGroupEntity | SloMetrics",
+                "required": true,
+                "description": "The `Slo(...)` the dashboard reads, its rule group, or what `sloMetrics()` returned for it."
+            },
+            {
+                "name": "datasource",
+                "type": "DatasourceInput<\"prometheus\">",
+                "required": true,
+                "description": "The Prometheus the metrics are queried from: a declared `Datasource`, or `{ type: \"prometheus\", uid }` for one declared elsewhere."
+            },
+            {
+                "name": "title",
+                "type": "string",
+                "required": false
+            },
+            {
+                "name": "uid",
+                "type": "string",
+                "required": false,
+                "description": "The dashboard uid."
+            },
+            {
+                "name": "description",
+                "type": "string",
+                "required": false
+            },
+            {
+                "name": "tags",
+                "type": "string[]",
+                "required": false
+            },
+            {
+                "name": "folder",
+                "type": "string | FolderEntity",
+                "required": false,
+                "description": "The Grafana folder to provision it into: a path, or a `Folder` to pin its uid."
+            },
+            {
+                "name": "time",
+                "type": "{ from: string; to: string }",
+                "required": false,
+                "description": "Initial time range."
+            },
+            {
+                "name": "refresh",
+                "type": "string",
+                "required": false,
+                "description": "Auto-refresh interval, e.g. `30s`."
+            },
+            {
+                "name": "links",
+                "type": "DashboardLinkInput[]",
+                "required": false
+            }
+        ]
+    }
+];

package/dist/composites/index.js

@@ -0,0 +1,8 @@
+/**
+ * Grafana lexicon composites: dashboards built from the declarations they
+ * read, so renaming a metric at its source moves it in the panels.
+ */
+export { RedDashboard, redQueries, RED_DEFAULT_SPAN_KINDS } from "./red-dashboard.js";
+export { SloDashboard, sloQueries } from "./slo-dashboard.js";
+export { AgentDashboard, agentQueries, agentRuleQueries } from "./agent-dashboard.js";
+export { SloAlertRules, sloAlertQueries } from "./slo-alert-rules.js";

package/dist/composites/red-dashboard.js

@@ -0,0 +1,135 @@
+/**
+ * `RedDashboard`: rate, errors and duration per service, from a
+ * `spanmetrics` connector declaration.
+ *
+ * The metric names come from the connector's config through the otel
+ * lexicon's `spanMetricsNames()`: its namespace, its histogram unit, the
+ * default dimensions it keeps, and optionally the `prometheus` exporter's
+ * namespace. Renaming the connector's namespace moves every query here.
+ *
+ * The queries count server and consumer spans only by default, the spans
+ * that handle a request or a message, so a service's outgoing calls and
+ * its internal spans don't inflate its rate or dilute its error ratio.
+ */
+import { Composite } from "@intentius/chant/composite";
+import { RED_DEFAULT_SPAN_KINDS as SHARED_DEFAULT_SPAN_KINDS, spanMetricsNames, spanMetricsRedQueries, } from "@intentius/chant-lexicon-otel/metric-names";
+import { Dashboard } from "../dashboard.js";
+import { Row, TimeSeriesPanel } from "../panels.js";
+import { PromQuery } from "../query.js";
+import { QueryVariable } from "../variables.js";
+import { slugUid } from "../util.js";
+import { dashboardProps, durationUnit, legend, quantileName, requireDatasource, selector } from "./shared.js";
+/** The kinds `RedDashboard` counts unless told otherwise: the spans that serve a request or consume a message. */
+export const RED_DEFAULT_SPAN_KINDS = SHARED_DEFAULT_SPAN_KINDS;
+const DEFAULT_QUANTILES = [0.5, 0.95, 0.99];
+function cap(s) {
+    return s.charAt(0).toUpperCase() + s.slice(1);
+}
+function isNames(x) {
+    return typeof x === "object" && x !== null && "calls" in x && "labels" in x && "errorStatus" in x;
+}
+/**
+ * The PromQL the RED dashboard runs, from the connector's names. Exposed for
+ * tests and for panels of your own. `spanKinds` defaults to server and
+ * consumer spans; `[]` counts every kind. The expressions come from the otel
+ * lexicon's `spanMetricsRedQueries()`, which the prometheus lexicon's
+ * `RedAlerts` reads too.
+ */
+export function redQueries(names, quantiles = DEFAULT_QUANTILES, serviceFilter = "$service", spanKinds) {
+    const q = spanMetricsRedQueries(names, { range: "$__rate_interval", quantiles, serviceMatch: serviceFilter, spanKinds, owner: "RedDashboard" });
+    return {
+        rate: q.rate,
+        errorRatio: q.errorRatio,
+        duration: q.duration,
+        services: `label_values(${selector(names.calls.prometheus, q.kindMatchers)}, ${q.service})`,
+    };
+}
+/** "server and consumer spans", for panel descriptions. */
+function kindsText(names, kinds) {
+    const counted = kinds ?? (names.labels.spanKind ? RED_DEFAULT_SPAN_KINDS : []);
+    if (counted.length === 0)
+        return "spans";
+    const words = [...new Set(counted)].map((k) => k.replace(/^SPAN_KIND_/, "").toLowerCase());
+    return `${words.length > 1 ? `${words.slice(0, -1).join(", ")} and ${words[words.length - 1]}` : words[0]} spans`;
+}
+/**
+ * A RED dashboard (rate, errors, duration) per service, built from a
+ * `spanmetrics` connector declaration.
+ *
+ * @example
+ * ```ts
+ * import { SpanMetricsConnector } from "@intentius/chant-lexicon-otel";
+ * import { Datasource, RedDashboard } from "@intentius/chant-lexicon-grafana";
+ *
+ * export const spans = new SpanMetricsConnector({ namespace: "shop", histogram: { unit: "s" } });
+ * export const prometheus = new Datasource({ name: "Prometheus", type: "prometheus", url: "http://prometheus:9090" });
+ * export const red = RedDashboard({ spanMetrics: spans, datasource: prometheus });
+ * ```
+ */
+export const RedDashboard = Composite((props) => {
+    requireDatasource("RedDashboard", props.datasource);
+    if (!props.spanMetrics)
+        throw new Error("RedDashboard: spanMetrics is required (a spanmetrics connector)");
+    const names = isNames(props.spanMetrics) ? props.spanMetrics : spanMetricsNames(props.spanMetrics, props.exporter);
+    const quantiles = props.quantiles ?? DEFAULT_QUANTILES;
+    for (const q of quantiles) {
+        if (!(typeof q === "number" && q > 0 && q < 1))
+            throw new Error(`RedDashboard: a quantile must be between 0 and 1, got ${String(q)}`);
+    }
+    const q = redQueries(names, quantiles, "$service", props.spanKinds);
+    const counted = kindsText(names, props.spanKinds);
+    const svc = names.labels.service;
+    const ds = props.datasource;
+    const service = new QueryVariable({
+        name: "service",
+        label: "Service",
+        datasource: ds,
+        query: q.services,
+        multi: true,
+        includeAll: true,
+        allValue: ".*",
+        refresh: "onTimeRangeChange",
+        sort: 1,
+    });
+    const rate = new TimeSeriesPanel({
+        title: "Rate",
+        description: `${cap(counted)} per second by service, from ${names.calls.prometheus}.`,
+        datasource: ds,
+        gridPos: { w: 12, h: 8 },
+        targets: [new PromQuery({ expr: q.rate, legendFormat: legend(svc) })],
+        fieldConfig: { defaults: { unit: "reqps" } },
+    });
+    const errors = new TimeSeriesPanel({
+        title: "Errors",
+        description: `Share of ${counted} with ${names.labels.statusCode}="${names.errorStatus}", by service.`,
+        datasource: ds,
+        gridPos: { w: 12, h: 8 },
+        targets: [new PromQuery({ expr: q.errorRatio, legendFormat: legend(svc) })],
+        fieldConfig: { defaults: { unit: "percentunit", min: 0 } },
+    });
+    const rows = [new Row({ title: "Rate and errors", panels: [rate, errors] })];
+    if (names.duration && q.duration.length > 0) {
+        const width = Math.max(6, Math.floor(24 / q.duration.length));
+        const unit = durationUnit(names.duration.unit);
+        const panels = q.duration.map((d) => new TimeSeriesPanel({
+            title: `Duration ${quantileName(d.quantile)}`,
+            description: `${quantileName(d.quantile)} duration of ${counted} by service, from ${names.duration.prometheus}.`,
+            datasource: ds,
+            gridPos: { w: width, h: 8 },
+            targets: [new PromQuery({ expr: d.expr, legendFormat: legend(svc) })],
+            fieldConfig: { defaults: { unit } },
+        }));
+        rows.push(new Row({ title: "Duration", panels }));
+    }
+    const dashboard = new Dashboard({
+        ...dashboardProps(props, {
+            title: "Services: rate, errors, duration",
+            uid: slugUid(`red-${names.namespace || "spans"}`),
+            description: `Rate, errors and duration per service from the ${names.namespace || "unprefixed"} span metrics.`,
+            tags: ["red", "spanmetrics"],
+        }),
+        variables: [service],
+        panels: rows,
+    });
+    return { dashboard };
+}, "RedDashboard");

package/dist/composites/shared.js

@@ -0,0 +1,74 @@
+/**
+ * What the dashboard composites share: the dashboard-level props they all
+ * take, a PromQL selector builder, and the field configs they reuse.
+ */
+import { promErrorRatio, promNumber, promQuantile, promSelector, promSumRate, } from "@intentius/chant-lexicon-otel/metric-names";
+// The PromQL builders live in the otel lexicon's metric-names, next to the
+// names they read, so the prometheus lexicon's RedAlerts builds the same
+// expressions without importing grafana. Here they default the range to
+// Grafana's `$__rate_interval`.
+/** `metric{a="x", b=~"y"}`; just `metric` with no matchers. */
+export function selector(metric, matchers) {
+    return promSelector(metric, matchers);
+}
+/** `sum by (labels) (rate(sel[range]))`, or `sum (...)` with no labels. */
+export function sumRate(sel, by, range = "$__rate_interval") {
+    return promSumRate(sel, by, range);
+}
+/**
+ * `errors / all` as rates summed by `by`, with the numerator padded to zero:
+ * `(errors or all * 0) / all`. A group with calls but no error series gets
+ * 0 instead of dropping out of the result, so a panel shows 0% rather than
+ * "No data" for a service that has had no errors.
+ */
+export function errorRatio(errorSel, allSel, by) {
+    return promErrorRatio(errorSel, allSel, by, "$__rate_interval");
+}
+/** `histogram_quantile(q, sum by (le, labels) (rate(bucket[range])))`. */
+export function quantile(q, bucketSel, by) {
+    return promQuantile(q, bucketSel, by, "$__rate_interval");
+}
+/** A number as PromQL and Grafana thresholds write it, without float noise. */
+export function num(n) {
+    return promNumber(n);
+}
+/** `p95` for 0.95, `p99.9` for 0.999. */
+export function quantileName(q) {
+    return `p${num(q * 100)}`;
+}
+/** Legend text naming the label, `{{service_name}}`. */
+export function legend(...labels) {
+    return labels.map((l) => `{{${l}}}`).join(" ");
+}
+/** Grafana's unit id for a spanmetrics histogram unit (`ms` or `s`). */
+export function durationUnit(unit) {
+    return unit === "s" ? "s" : "ms";
+}
+/** Absolute thresholds from a base colour and `[value, colour]` steps. */
+export function thresholds(base, steps) {
+    return { mode: "absolute", steps: [{ value: null, color: base }, ...steps.map(([value, color]) => ({ value, color }))] };
+}
+/** The props a composite passes to `Dashboard`, from the options and its own defaults. */
+export function dashboardProps(o, defaults) {
+    return {
+        title: o.title ?? defaults.title,
+        uid: o.uid ?? defaults.uid,
+        description: o.description ?? defaults.description,
+        tags: o.tags ?? defaults.tags,
+        time: o.time ?? { from: "now-6h", to: "now" },
+        ...(o.refresh !== undefined ? { refresh: o.refresh } : { refresh: "1m" }),
+        graphTooltip: "sharedCrosshair",
+        ...(o.folder !== undefined ? { folder: o.folder } : {}),
+        ...(o.links !== undefined ? { links: o.links } : {}),
+    };
+}
+/** Throw unless a Prometheus datasource was passed. */
+export function requireDatasource(composite, ds) {
+    if (ds === undefined || ds === null)
+        throw new Error(`${composite}: datasource is required (a Prometheus Datasource or { type: "prometheus", uid })`);
+    const type = ds.datasourceType ??
+        ds.pluginType ??
+        ds.type;
+    if (type !== "prometheus")
+        throw new Error(`${composite}: datasource must be a Prometheus datasource, got ${String(type)}`);
+}

package/dist/composites/slo-alert-rules.js

@@ -0,0 +1,96 @@
+/**
+ * `SloAlertRules`: an `Slo`'s multiwindow, multi-burn-rate alerts as
+ * Grafana-managed alert rules, for teams that page from Grafana rather
+ * than from Prometheus and Alertmanager.
+ *
+ * The windows, factors, thresholds and labels come from the prometheus
+ * lexicon's `sloMetrics()`, the same numbers the `Slo`'s own Prometheus
+ * alerts use. Each burn-rate pair becomes one rule that reads the two
+ * error ratios the `Slo` records (`slo:sli_error:ratio_rate<window>`) as
+ * instant Prometheus queries, and a math expression that holds while both
+ * are above the pair's threshold:
+ *
+ *     A = slo:sli_error:ratio_rate1h{slo="checkout"}
+ *     B = slo:sli_error:ratio_rate5m{slo="checkout"}
+ *     C = $A > 0.0144 && $B > 0.0144        (condition)
+ *
+ * So the `Slo`'s rule group must be loaded into the Prometheus the rules
+ * query: the recording rules are what make a 3-day window cheap to
+ * evaluate every minute.
+ */
+import { Composite } from "@intentius/chant/composite";
+import { sloMetrics } from "@intentius/chant-lexicon-prometheus/composites/slo";
+import { AlertRule, AlertRuleGroup, MathExpression, } from "../alerting.js";
+import { PromQuery } from "../query.js";
+import { slugUid } from "../util.js";
+import { num, requireDatasource } from "./shared.js";
+function isMetrics(x) {
+    return typeof x === "object" && x !== null && "errorBudgetRemaining" in x && "burnRates" in x && "selector" in x;
+}
+/** A rule uid for one pair: the SLO's name cut to fit, then the windows, at most 40 characters. */
+function pairUid(name, long, short) {
+    const suffix = `-${long}-${short}`.toLowerCase();
+    return `${slugUid(`slo ${name}`).slice(0, 40 - suffix.length).replace(/-$/, "")}${suffix}`;
+}
+/** The queries and condition of each burn-rate rule, from `sloMetrics()`. Exposed for tests and for rules of your own. */
+export function sloAlertQueries(m) {
+    return m.burnRates.map((b) => ({
+        ...b,
+        uid: pairUid(m.name, b.long, b.short),
+        longExpr: `${b.longRecord}${m.selector}`,
+        shortExpr: `${b.shortRecord}${m.selector}`,
+        condition: `$A > ${num(b.threshold)} && $B > ${num(b.threshold)}`,
+    }));
+}
+/**
+ * Grafana-managed burn-rate alerts for an `Slo`: one rule per window pair,
+ * with the labels and annotations the `Slo`'s Prometheus alerts carry.
+ *
+ * @example
+ * ```ts
+ * import { Slo } from "@intentius/chant-lexicon-prometheus";
+ * import { SloAlertRules } from "@intentius/chant-lexicon-grafana";
+ *
+ * export const checkout = Slo({ name: "checkout", objective: 0.999, window: "30d", sli: { ... } });
+ * export const checkoutAlerts = SloAlertRules({ slo: checkout, datasource: prometheus, folder: "SLOs" });
+ * ```
+ */
+export const SloAlertRules = Composite((props) => {
+    requireDatasource("SloAlertRules", props.datasource);
+    if (!props.slo)
+        throw new Error("SloAlertRules: slo is required (an Slo(...) declaration)");
+    if (typeof props.folder !== "string" || props.folder.trim() === "")
+        throw new Error("SloAlertRules: folder is required (the Grafana folder title)");
+    const m = isMetrics(props.slo) ? props.slo : sloMetrics(props.slo);
+    const pairs = sloAlertQueries(m);
+    if (pairs.length === 0) {
+        throw new Error(`SloAlertRules: the Slo "${m.name}" has alerting turned off, so it has no burn-rate windows to alert on`);
+    }
+    const ds = props.datasource;
+    const budget = num(m.errorBudget);
+    const rules = pairs.map((p) => new AlertRule({
+        title: `SLO ${m.name} error budget burn ${p.long}/${p.short} (${p.severity})`,
+        uid: p.uid,
+        data: [
+            new PromQuery({ datasource: ds, expr: p.longExpr, instant: true, range: false }),
+            new PromQuery({ datasource: ds, expr: p.shortExpr, instant: true, range: false }),
+            new MathExpression({ expression: p.condition }),
+        ],
+        condition: "C",
+        noDataState: props.noDataState ?? "OK",
+        execErrState: props.execErrState ?? "Error",
+        ...(props.for !== undefined ? { for: props.for } : {}),
+        labels: { ...(props.labels ?? {}), ...p.labels },
+        annotations: {
+            summary: `SLO ${m.name} is burning its error budget more than ${num(p.factor)}x too fast (${p.long} and ${p.short} windows)`,
+            description: `The error ratio over both the last ${p.long} and the last ${p.short} is above ${num(p.threshold)} ` +
+                `(${num(p.factor)} times the ${budget} budget of a ${num(m.objective)} objective). ` +
+                `At that rate the ${m.window} error budget is gone in ${p.exhaustsIn}.`,
+            ...(props.annotations ?? {}),
+        },
+        ...(props.contactPoint !== undefined ? { notification_settings: { receiver: props.contactPoint } } : {}),
+    }));
+    return {
+        rules: new AlertRuleGroup({ name: props.group ?? m.group, folder: props.folder, interval: props.interval ?? "1m", rules }),
+    };
+}, "SloAlertRules");