@intentius/chant-lexicon-grafana 0.99.0 → 0.100.0

package/src/index.ts

@@ -14,6 +14,12 @@ export {
   isDatasourceEntity,
   isExternalDatasource,
   isDatasourceDeclaration,
+  DatasourceProvisioning,
+  DATASOURCE_PROVISIONING_TYPE,
+  isDatasourceProvisioningEntity,
+  type DatasourceProvisioningProps,
+  type DatasourceProvisioningEntity,
+  type DeletedDatasource,
   type ExternalDatasourceProps,
   type ExternalDatasourceEntity,
   type ExternalDatasourceConstructor,
@@ -25,6 +31,64 @@ export {
   type KnownDatasourceType,
 } from "./datasource";
 
+// Typed datasource settings (jsonData, secureJsonData keys) per plugin
+export {
+  JSONDATA_LINKS,
+  TRACING_DATASOURCE_TYPES,
+  TRACE_TO_LOGS_DATASOURCE_TYPES,
+  TRACE_TO_METRICS_DATASOURCE_TYPES,
+  type JsonDataLink,
+  type LinkedDatasource,
+  type TracingDatasourceType,
+  type TraceToLogsDatasourceType,
+  type TraceToMetricsDatasourceType,
+  type TypedDatasourceType,
+  type DatasourceJsonData,
+  type DatasourceSecureJsonData,
+  type DatasourceJsonDataTypes,
+  type DatasourceSecureJsonKeys,
+  type CommonJsonData,
+  type HttpJsonData,
+  type HttpSecureJsonKey,
+  type PrometheusJsonData,
+  type ExemplarTraceIdDestination,
+  type LokiJsonData,
+  type DerivedFieldConfig,
+  type TempoJsonData,
+  type TraceToLogsTag,
+  type TraceToLogsOptions,
+  type TraceToLogsOptionsV2,
+  type TraceToMetricsOptions,
+  type TraceToProfilesOptions,
+  type ElasticsearchJsonData,
+  type ElasticsearchDataLink,
+  type ElasticsearchSecureJsonKey,
+  type AwsAuthJsonData,
+  type AwsAuthSecureJsonKey,
+  type CloudWatchJsonData,
+  type CloudWatchLogGroup,
+  type CloudWatchSecureJsonKey,
+  type AzureCloudName,
+  type AzureCredentials,
+  type AzureMonitorJsonData,
+  type AzureMonitorSecureJsonKey,
+  type GoogleAuthJsonData,
+  type GoogleAuthSecureJsonKey,
+  type CloudMonitoringJsonData,
+  type CloudMonitoringSecureJsonKey,
+  type BigQueryJsonData,
+  type BigQuerySecureJsonKey,
+  type PyroscopeJsonData,
+  type PyroscopeSecureJsonKey,
+  type SqlJsonData,
+  type PostgresJsonData,
+  type PostgresSecureJsonKey,
+  type MySQLJsonData,
+  type MySQLSecureJsonKey,
+  type MSSQLJsonData,
+  type MSSQLSecureJsonKey,
+} from "./datasource-settings";
+
 // Dashboards and provisioning
 export {
   Dashboard,
@@ -39,8 +103,14 @@ export {
   type DashboardLinkInput,
   type DashboardProviderProps,
   type DashboardProviderEntity,
+  type DashboardEntityProps,
+  type DashboardProviderEntityProps,
 } from "./dashboard";
 
+// Folders and annotations
+export { Folder, FOLDER_TYPE, isFolderEntity, folderLevels, type FolderProps, type FolderEntity } from "./folder";
+export { annotationJson, ANNOTATION_REF_ID, type AnnotationInput } from "./annotations";
+
 // Grafana-managed alerting
 export {
   AlertRuleGroup,
@@ -179,6 +249,15 @@ export {
   PromQuery,
   TempoQuery,
   LokiQuery,
+  ElasticsearchQuery,
+  CloudWatchQuery,
+  AzureMonitorQuery,
+  CloudMonitoringQuery,
+  BigQueryQuery,
+  PyroscopeQuery,
+  PostgresQuery,
+  MySQLQuery,
+  MSSQLQuery,
   defineQuery,
   registeredQueries,
   queryDefinitionFor,
@@ -186,6 +265,8 @@ export {
   QUERY_TYPE_PREFIX,
   type DatasourceInput,
   type QueryModel,
+  type Loosen,
+  type MergedModel,
   type QueryProps,
   type QueryDefinition,
   type QueryEntity,
@@ -193,8 +274,30 @@ export {
   type PromQueryEntity,
   type TempoQueryEntity,
   type LokiQueryEntity,
+  type ElasticsearchQueryEntity,
+  type CloudWatchQueryEntity,
+  type AzureMonitorQueryEntity,
+  type CloudMonitoringQueryEntity,
+  type BigQueryQueryEntity,
+  type PyroscopeQueryEntity,
+  type PostgresQueryEntity,
+  type MySQLQueryEntity,
+  type MSSQLQueryEntity,
 } from "./query";
 
+// Hand-written query models for datasources with no schema
+export type {
+  SqlQueryModel,
+  SqlBuilderQuery,
+  SqlQueryFormat,
+  SqlExpressionType,
+  SqlProperty,
+  SqlFunctionExpression,
+  SqlFunctionParameterExpression,
+  SqlGroupByExpression,
+  SqlPropertyExpression,
+} from "./query-models";
+
 // Variables
 export {
   QueryVariable,
@@ -219,6 +322,17 @@ export {
   type DatasourceVariableProps,
   type ConstantVariableProps,
   type TextboxVariableProps,
+  AdhocVariable,
+  GroupByVariable,
+  SwitchVariable,
+  MULTI_VALUE_KINDS,
+  type AdhocVariableProps,
+  type GroupByVariableProps,
+  type SwitchVariableProps,
+  type AdhocFilter,
+  type VariableKeyOption,
+  type VariableQueryObject,
+  type PrometheusVariableQuery,
 } from "./variables";
 
 // The generated schema types and their pin
@@ -251,7 +365,7 @@ export {
   type ReducerId,
 } from "./transformations";
 
-// Plain-data API: render, check and detect without a build
+// Plain-data API: render and detect without a build
 export {
   buildGrafana,
   grafanaFiles,
@@ -267,6 +381,7 @@ export {
   externalDatasourceRecord,
   provisionedProvider,
   datasourcesYaml,
+  datasourceFileSettings,
   dashboardProvidersYaml,
   GRID_COLUMNS,
   DATASOURCES_FILE,
@@ -278,24 +393,19 @@ export {
   type ProvisionedDatasource,
   type ExternalDatasourceRecord,
   type ProvisionedProvider,
+  type DatasourceFileSettings,
   type DashboardJson,
   type PanelJson,
   type RowPanelJson,
   type VariableModel,
   type DataSourceRef,
 } from "./build";
-export {
-  validateGrafanaOutput,
-  issuesFor,
-  knownDatasourcesOf,
-  variableReferences,
-  type GrafanaIssue,
-  type GrafanaIssueCode,
-  type GrafanaArtifacts,
-  type DashboardDoc,
-} from "./validate-output";
+// The checks as plain functions (validateGrafanaOutput, validateDashboardSchema)
+// are on the `@intentius/chant-lexicon-grafana/validation` subpath (#2958), so
+// declaring dashboards does not load them.
 export {
   datasourceUses,
+  variableReferences,
   resolveDatasourceRef,
   knownDatasources,
   type DatasourceUse,
@@ -303,7 +413,6 @@ export {
   type KnownDatasource,
   type DatasourceRefJson,
 } from "./datasource-refs";
-export { validateDashboardSchema, validateExpressionSchema, type SchemaProblem } from "./schema-validate";
 export { looksLikeDashboard, looksLikeDatasourceProvisioning, looksLikeDashboardProvisioning, looksLikeAlertingProvisioning } from "./detect";
 export { slugUid, isValidUid, UID_PATTERN, type DeepPartial, type PropsOf } from "./util";
 
@@ -357,7 +466,7 @@ export { bindGrafana, classifyGrafanaFailure, GrafanaBindingError } from "./api/
 export { grafanaApply } from "./op/builders";
 export { applyGrafana, planFromDashboards, GRAFANA_APPLY_KINDS } from "./api/apply";
 export type { GrafanaApplyPlan, GrafanaApplyOutcome, DashboardPlan, BuiltDashboardInput } from "./api/apply";
-export { folderUidFor, foldersForDashboards, type FolderPlan } from "./api/folders";
+export { folderUidFor, foldersForDashboards, resolveFolders, liveFolderPath, type FolderPlan, type ResolvedFolders } from "./api/folders";
 
 // The Grafana RBAC actions a service account needs to observe, apply and prune.
 export { GrafanaActions, grafanaActionsFor, type GrafanaAccessLevel } from "./actions/index";

package/src/init-templates.test.ts

@@ -0,0 +1,74 @@
+import { describe, expect, test } from "vitest";
+import { mkdtempSync, rmSync, writeFileSync, mkdirSync } from "fs";
+import { join } from "path";
+import { build } from "@intentius/chant/build";
+import type { Serializer } from "@intentius/chant/serializer";
+import { lintCommand } from "@intentius/chant/cli/commands/lint";
+import { runPostSynthChecks } from "@intentius/chant/lint/post-synth";
+import { k8sPlugin } from "@intentius/chant-lexicon-k8s";
+import { prometheusPlugin } from "@intentius/chant-lexicon-prometheus";
+import { grafanaPlugin } from "./plugin";
+import { postSynthChecks } from "./lint/post-synth";
+
+// Every template builds with the lexicons its chant.config.ts names, and its
+// output passes every GRAF check, and the other lexicon's checks, with
+// nothing to report.
+const cases: Array<[string | undefined, Serializer[], string[]]> = [
+  [undefined, [grafanaPlugin.serializer], ["grafana"]],
+  ["red", [grafanaPlugin.serializer], ["grafana"]],
+  ["k8s-pods", [k8sPlugin.serializer, grafanaPlugin.serializer], ["k8s", "grafana"]],
+  ["slo", [prometheusPlugin.serializer, grafanaPlugin.serializer], ["prometheus", "grafana"]],
+];
+
+describe("init templates", () => {
+  test.each(cases)("%s builds, lints clean and passes every check", async (name, serializers, outputs) => {
+    const set = grafanaPlugin.initTemplates!(name);
+    const dir = mkdtempSync(join(import.meta.dirname, "..", ".init-template-"));
+    try {
+      mkdirSync(join(dir, "src"));
+      for (const [file, text] of Object.entries(set.src)) writeFileSync(join(dir, "src", file), text);
+      for (const [file, text] of Object.entries(set.root ?? {})) writeFileSync(join(dir, file), text);
+      const result = await build(join(dir, "src"), serializers);
+      expect(result.errors).toEqual([]);
+      for (const lexicon of outputs) expect(result.outputs.get(lexicon), lexicon).toBeTruthy();
+
+      expect(runPostSynthChecks(postSynthChecks, result)).toEqual([]);
+      const other = name === "k8s-pods" ? k8sPlugin : name === "slo" ? prometheusPlugin : undefined;
+      if (other) {
+        expect(runPostSynthChecks(other.postSynthChecks!(), result)).toEqual([]);
+      }
+
+      const lint = await lintCommand({ path: join(dir, "src"), format: "stylish", fix: false });
+      expect(lint.errorCount + lint.warningCount, lint.output).toBe(0);
+    } finally {
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
+
+  test("the RED template puts its dashboard in the pinned folder and counts served spans only", async () => {
+    const dir = mkdtempSync(join(import.meta.dirname, "..", ".init-template-"));
+    try {
+      mkdirSync(join(dir, "src"));
+      for (const [file, text] of Object.entries(grafanaPlugin.initTemplates!("red").src)) writeFileSync(join(dir, "src", file), text);
+      const result = await build(join(dir, "src"), [grafanaPlugin.serializer]);
+      const out = result.outputs.get("grafana") as { primary: string; files: Record<string, string> };
+      const index = JSON.parse(out.primary) as { dashboards: Array<{ uid: string; folderUid?: string }>; datasources: unknown[] };
+      expect(index.dashboards).toEqual([expect.objectContaining({ uid: "services-red", folderUid: "observability" })]);
+      // An ExternalDatasource is checked against, never provisioned.
+      expect(index.datasources).toEqual([]);
+      const dashboard = Object.entries(out.files).find(([path]) => path.endsWith("services-red.json"))![1];
+      expect(dashboard).toContain("SPAN_KIND_SERVER|SPAN_KIND_CONSUMER");
+    } finally {
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
+
+  test("the k8s-pods and slo templates build every lexicon their config names", () => {
+    for (const name of ["k8s-pods", "slo"]) {
+      const set = grafanaPlugin.initTemplates!(name);
+      expect(set.root?.["chant.config.ts"]).toContain('"grafana"');
+      expect(set.scripts?.build).toBe("chant build src");
+    }
+    expect(grafanaPlugin.initTemplates!("no-such-template")).toBe(grafanaPlugin.initTemplates!());
+  });
+});

package/src/init-templates.ts

@@ -0,0 +1,349 @@
+/**
+ * `chant init --lexicon grafana` scaffolds.
+ *
+ * - default: a Prometheus datasource and a job overview dashboard with a
+ *   typed variable, in a folder.
+ * - `red`: rate, errors and duration per service from the OpenTelemetry
+ *   collector's span metrics, over a Prometheus Grafana already has
+ *   (`ExternalDatasource`), in a pinned `Folder`.
+ * - `k8s-pods`: CPU, memory, restarts and pod phase per namespace, delivered
+ *   as ConfigMaps the Grafana Helm chart's sidecar loads, from the `/k8s`
+ *   subpath. Builds with the k8s lexicon.
+ * - `slo`: an SLO's recording rules, its dashboard and its burn-rate alerts
+ *   as Grafana-managed rules. Builds with the prometheus lexicon.
+ *
+ * The otel, prometheus and k8s lexicons these import are dependencies of
+ * the grafana lexicon, so they are installed with it. The templates that
+ * build with a second lexicon ship their own `chant.config.ts` and a build
+ * script without `--lexicon`, so every lexicon's output and checks run.
+ */
+import type { InitTemplateSet } from "@intentius/chant/lexicon";
+
+// ── default ────────────────────────────────────────────────────────────
+
+const DEFAULT_DATASOURCES = `/**
+ * The datasource the dashboards query, declared in the same build root so
+ * GRAF101 and GRAF102 check every panel's reference against it.
+ */
+import { Datasource } from "@intentius/chant-lexicon-grafana";
+
+const prometheus = new Datasource({ name: "Prometheus", type: "prometheus", url: "http://prometheus:9090", isDefault: true });
+
+export { prometheus };
+`;
+
+const DEFAULT_DASHBOARD = `/**
+ * One dashboard: which of a job's targets are up, and how long their
+ * scrapes take. Panels without a gridPos are laid out left to right.
+ */
+import { Dashboard, PromQuery, QueryVariable, StatPanel, TimeSeriesPanel } from "@intentius/chant-lexicon-grafana";
+import { prometheus } from "./datasources";
+
+const jobQuery = { query: "label_values(up, job)", qryType: 1 as const, label: "job", metric: "up" };
+const job = new QueryVariable({ name: "job", label: "Job", datasource: prometheus, query: jobQuery, refresh: "onTimeRangeChange", sort: 1 });
+
+const up = new PromQuery({ expr: 'sum(up{job="$job"})', instant: true });
+const targetsUp = new StatPanel({ title: "Targets up", datasource: prometheus, targets: [up] });
+
+const scrape = new PromQuery({ expr: 'avg by (instance) (scrape_duration_seconds{job="$job"})', legendFormat: "{{instance}}" });
+const seconds = { defaults: { unit: "s" } };
+const scrapeDuration = new TimeSeriesPanel({ title: "Scrape duration", datasource: prometheus, targets: [scrape], fieldConfig: seconds });
+
+const lastHour = { from: "now-1h", to: "now" };
+
+const overview = new Dashboard({
+  title: "Overview",
+  uid: "overview",
+  tags: ["chant"],
+  time: lastHour,
+  refresh: "30s",
+  variables: [job],
+  panels: [targetsUp, scrapeDuration],
+  folder: "Services",
+});
+
+export { overview };
+`;
+
+// ── red ────────────────────────────────────────────────────────────────
+
+const RED_DATASOURCES = `/**
+ * The Prometheus the dashboard reads, one Grafana already has. It is checked
+ * against (GRAF101, GRAF102) and never provisioned: set \`uid\` to its uid,
+ * from Connections > Data sources in Grafana.
+ */
+import { ExternalDatasource } from "@intentius/chant-lexicon-grafana";
+
+const prometheus = new ExternalDatasource({ type: "prometheus", uid: "prometheus", name: "Prometheus" });
+
+export { prometheus };
+`;
+
+const RED_DASHBOARD = `/**
+ * Rate, errors and duration per service, from the span metrics the
+ * OpenTelemetry collector's \`spanmetrics\` connector writes. The metric and
+ * label names come from the connector's settings, so change them here to
+ * match your collector (or pass the connector itself, if the collector is
+ * declared with the otel lexicon) and every query follows.
+ */
+import { Folder, RedDashboard, type SpanKind } from "@intentius/chant-lexicon-grafana";
+import { spanMetricsNames } from "@intentius/chant-lexicon-otel";
+import { prometheus } from "./datasources";
+
+const milliseconds = { unit: "ms" };
+const connector = { namespace: "traces.span.metrics", histogram: milliseconds };
+const names = spanMetricsNames(connector);
+
+// The spans that serve a request or consume a message, so a service's own
+// outgoing calls don't count toward its rate. [] counts every kind.
+const served: SpanKind[] = ["SPAN_KIND_SERVER", "SPAN_KIND_CONSUMER"];
+
+// A Folder pins the uid, for links and alert rules that name it.
+const observability = new Folder({ title: "Observability", uid: "observability" });
+
+const services = RedDashboard({ spanMetrics: names, datasource: prometheus, spanKinds: served, folder: observability, uid: "services-red" });
+
+export { observability, services };
+`;
+
+// ── k8s-pods ───────────────────────────────────────────────────────────
+
+const K8S_CONFIG = `import type { ChantConfig } from "@intentius/chant";
+
+// The dashboard and the ConfigMaps that deliver it share one build root: the
+// grafana output is checked by the GRAF checks, the ConfigMaps are applied
+// with kubectl.
+export default { lexicons: ["k8s", "grafana"] } satisfies ChantConfig;
+`;
+
+const K8S_DATASOURCES = `/**
+ * The Prometheus that scrapes cAdvisor and kube-state-metrics, as Grafana
+ * reaches it inside the cluster.
+ */
+import { Datasource } from "@intentius/chant-lexicon-grafana";
+
+const prometheus = new Datasource({
+  name: "Prometheus",
+  type: "prometheus",
+  uid: "prometheus",
+  url: "http://prometheus-server.monitoring.svc:80",
+  isDefault: true,
+});
+
+export { prometheus };
+`;
+
+const K8S_VARIABLES = `/**
+ * Which namespace, and which of its pods. Queries use them as $namespace
+ * and $pod; \`pod\` takes several values, or all of them.
+ */
+import { QueryVariable } from "@intentius/chant-lexicon-grafana";
+import { prometheus } from "./datasources";
+
+const namespace = new QueryVariable({
+  name: "namespace",
+  label: "Namespace",
+  datasource: prometheus,
+  query: "label_values(kube_pod_info, namespace)",
+  refresh: "onTimeRangeChange",
+  sort: 1,
+});
+
+const pod = new QueryVariable({
+  name: "pod",
+  label: "Pod",
+  datasource: prometheus,
+  query: 'label_values(kube_pod_info{namespace="$namespace"}, pod)',
+  refresh: "onTimeRangeChange",
+  sort: 1,
+  multi: true,
+  includeAll: true,
+});
+
+export { namespace, pod };
+`;
+
+const K8S_QUERIES = `/**
+ * PromQL over cAdvisor (container_*) and kube-state-metrics (kube_*).
+ */
+import { PromQuery } from "@intentius/chant-lexicon-grafana";
+
+const scope = 'namespace="$namespace", pod=~"$pod"';
+
+const cpu = new PromQuery({
+  expr: \`sum by (pod) (rate(container_cpu_usage_seconds_total{\${scope}, container!=""}[$__rate_interval]))\`,
+  legendFormat: "{{pod}}",
+});
+
+const memory = new PromQuery({
+  expr: \`sum by (pod) (container_memory_working_set_bytes{\${scope}, container!=""})\`,
+  legendFormat: "{{pod}}",
+});
+
+const restarts = new PromQuery({
+  expr: \`sum by (pod) (increase(kube_pod_container_status_restarts_total{\${scope}}[1h]))\`,
+  legendFormat: "{{pod}}",
+});
+
+const phase = new PromQuery({
+  expr: \`sum by (pod, phase) (kube_pod_status_phase{\${scope}}) > 0\`,
+  instant: true,
+  format: "table",
+});
+
+export { cpu, memory, restarts, phase };
+`;
+
+const K8S_DASHBOARD = `/**
+ * Pods in a namespace: what they use, how often they restart, and which
+ * phase each is in.
+ */
+import { Dashboard, TablePanel, TimeSeriesPanel, transformation } from "@intentius/chant-lexicon-grafana";
+import { prometheus } from "./datasources";
+import { namespace, pod } from "./variables";
+import { cpu, memory, restarts, phase } from "./queries";
+
+const cores = { defaults: { unit: "suffix: cores" } };
+const cpuPanel = new TimeSeriesPanel({ title: "CPU", datasource: prometheus, targets: [cpu], fieldConfig: cores });
+
+const bytes = { defaults: { unit: "bytes" } };
+const memoryPanel = new TimeSeriesPanel({ title: "Memory working set", datasource: prometheus, targets: [memory], fieldConfig: bytes });
+
+const count = { defaults: { unit: "short", decimals: 0 } };
+const restartPanel = new TimeSeriesPanel({ title: "Restarts in the last hour", datasource: prometheus, targets: [restarts], fieldConfig: count });
+
+// The query returns one row per pod with its phase; drop the time and value columns.
+const hidden = { Time: true, Value: true };
+const renamed = { pod: "Pod", phase: "Phase" };
+const phaseColumns = [transformation("organize", { excludeByName: hidden, renameByName: renamed })];
+const phasePanel = new TablePanel({ title: "Pod phase", datasource: prometheus, targets: [phase], transformations: phaseColumns });
+
+const pods = new Dashboard({
+  title: "Kubernetes pods",
+  uid: "k8s-pods",
+  tags: ["chant", "kubernetes"],
+  refresh: "30s",
+  variables: [namespace, pod],
+  panels: [cpuPanel, memoryPanel, restartPanel, phasePanel],
+  folder: "Kubernetes",
+});
+
+export { pods };
+`;
+
+const K8S_DELIVERY = `/**
+ * The dashboard and the datasource as ConfigMaps, labelled the way the
+ * Grafana Helm chart's sidecar (also in kube-prometheus-stack) finds them:
+ * \`grafana_dashboard: "1"\` and \`grafana_datasource: "1"\`, the folder in the
+ * \`k8s-sidecar-target-directory\` annotation. \`kubectl apply -f\` the k8s
+ * output into the namespace Grafana watches.
+ */
+import { GrafanaConfigMaps } from "@intentius/chant-lexicon-grafana/k8s";
+import { prometheus } from "./datasources";
+import { pods } from "./dashboard";
+
+/** The namespace Grafana's sidecar watches for ConfigMaps. */
+export const GRAFANA_NAMESPACE = "monitoring";
+
+const delivered = [prometheus, pods];
+const labels = { "app.kubernetes.io/part-of": "grafana" };
+
+const grafanaConfigMaps = GrafanaConfigMaps({ entities: delivered, namespace: GRAFANA_NAMESPACE, labels });
+
+export { grafanaConfigMaps };
+`;
+
+// ── slo ────────────────────────────────────────────────────────────────
+
+const SLO_CONFIG = `import type { ChantConfig } from "@intentius/chant";
+
+// The SLO's Prometheus rules, and the Grafana dashboard and alert rules that
+// read what they record, share one build root: GRAF108 and GRAF112 check the
+// queries against the datasource declared here.
+export default { lexicons: ["prometheus", "grafana"] } satisfies ChantConfig;
+`;
+
+const SLO_DATASOURCES = `/**
+ * The Prometheus that evaluates the SLO's recording rules.
+ */
+import { Datasource } from "@intentius/chant-lexicon-grafana";
+
+const prometheus = new Datasource({ name: "Prometheus", type: "prometheus", uid: "prometheus", url: "http://prometheus:9090", isDefault: true });
+
+export { prometheus };
+`;
+
+const SLO_DECLARATION = `/**
+ * The SLO: 99.9% of checkout requests answer without a 5xx over 30 days.
+ * The prometheus lexicon builds its recording rules; the dashboard and the
+ * alert rules read the series they record, by the same names.
+ */
+import { Slo } from "@intentius/chant-lexicon-prometheus";
+
+const sli = {
+  errors: 'sum(rate(http_requests_total{job="checkout",code=~"5.."}[{{window}}]))',
+  total: 'sum(rate(http_requests_total{job="checkout"}[{{window}}]))',
+};
+const team = { team: "payments" };
+
+const checkout = Slo({
+  name: "checkout",
+  objective: 0.999,
+  window: "30d",
+  description: "Checkout requests answer without a 5xx.",
+  sli,
+  labels: team,
+});
+
+export { checkout };
+`;
+
+const SLO_DASHBOARD = `/**
+ * The SLO's dashboard (SLI against the objective, error budget left, each
+ * burn-rate pair against the rate it fires at), and the same burn rates as
+ * Grafana-managed alert rules in the same folder.
+ */
+import { SloAlertRules, SloDashboard } from "@intentius/chant-lexicon-grafana";
+import { prometheus } from "./datasources";
+import { checkout } from "./slo";
+
+const checkoutSlo = SloDashboard({ slo: checkout, datasource: prometheus, folder: "SLOs" });
+
+const team = { team: "payments" };
+const runbook = { runbook_url: "https://runbooks.example.com/checkout-slo" };
+const checkoutBurn = SloAlertRules({ slo: checkout, datasource: prometheus, folder: "SLOs", labels: team, annotations: runbook });
+
+export { checkoutSlo, checkoutBurn };
+`;
+
+// Build every lexicon the config names, not just grafana.
+const ALL_LEXICONS = { build: "chant build src", dev: "chant build src --watch" };
+
+export const DEFAULT_TEMPLATE: InitTemplateSet = {
+  src: { "datasources.ts": DEFAULT_DATASOURCES, "dashboard.ts": DEFAULT_DASHBOARD },
+};
+
+export const RED_TEMPLATE: InitTemplateSet = {
+  src: { "datasources.ts": RED_DATASOURCES, "red.ts": RED_DASHBOARD },
+};
+
+export const K8S_PODS_TEMPLATE: InitTemplateSet = {
+  src: {
+    "datasources.ts": K8S_DATASOURCES,
+    "variables.ts": K8S_VARIABLES,
+    "queries.ts": K8S_QUERIES,
+    "dashboard.ts": K8S_DASHBOARD,
+    "k8s.ts": K8S_DELIVERY,
+  },
+  root: { "chant.config.ts": K8S_CONFIG },
+  scripts: ALL_LEXICONS,
+};
+
+export const SLO_TEMPLATE: InitTemplateSet = {
+  src: { "datasources.ts": SLO_DATASOURCES, "slo.ts": SLO_DECLARATION, "dashboards.ts": SLO_DASHBOARD },
+  root: { "chant.config.ts": SLO_CONFIG },
+  scripts: ALL_LEXICONS,
+};
+
+/** The template names `chant init --lexicon grafana --template <name>` takes, besides the default. */
+export const TEMPLATE_NAMES = ["red", "k8s-pods", "slo"] as const;

package/src/lint/audit-catalog.ts

@@ -2,7 +2,7 @@
  * The grafana lexicon's chant audit catalog, contributed via
  * `grafanaPlugin.auditCatalog()` (#687, #1346).
  *
- * GRAF101-GRAF109, GRAF111-GRAF114 and GRAF115 read the emitted dashboard
+ * GRAF101-GRAF110, GRAF111-GRAF114 and GRAF115 read the emitted dashboard
  * JSON and provisioning files (alerting included), so
  * they fire on an audit of files chant didn't build too, and are
  * `yamlBased`. GRAF001 and GRAF002 read TypeScript source, so they are
@@ -101,6 +101,14 @@ export const grafanaAuditCatalog: Record<string, RuleMeta> = {
     "Give each dashboard provider its own path; set foldersFromFilesStructure: true (and no folder) on the provider when dashboards declare a folder; for a nested folder, run Grafana 13.1 or later or use a single-level folder.",
     { category: "correctness" },
   ),
+  GRAF110: auditRule(
+    "GRAF110",
+    "merge-worthy",
+    "guidance",
+    "Panel or row repeats over a variable that cannot give it more than one value",
+    "Repeat over a query, custom, datasource or group by variable, and set multi or includeAll on a query, custom or datasource one; Grafana shows a panel repeated over anything else once.",
+    { category: "correctness" },
+  ),
   GRAF111: auditRule(
     "GRAF111",
     "merge-worthy",

package/src/lint/post-synth/graf101.ts

@@ -1,5 +1,5 @@
 /**
- * GRAF101: A panel, query or variable uses a datasource no Datasource or ExternalDatasource in the build declares
+ * GRAF101: A panel, query, variable or annotation uses a datasource no Datasource or ExternalDatasource in the build declares, or one the build deletes
  *
  * Grafana shows "datasource not found" on the panel. Typed references cannot go wrong this way, so it mostly catches a { type, uid } ref or a hand-edited dashboard. A datasource variable whose plugin type no declared datasource has is an error too. A panel with queries and no datasource at all is a warning: Grafana sends them to its default datasource. This check joins dashboards against the datasources of the same build root (chant #1939): declare one that exists in Grafana but is provisioned elsewhere with ExternalDatasource, which the check counts and the build never provisions. A build that declares no datasource at all gets one warning per dashboard that references any, since nothing can be checked.
  */
@@ -9,7 +9,7 @@ import { grafanaDiagnostics } from "./grafana-helpers";
 
 export const graf101: PostSynthCheck = {
   id: "GRAF101",
-  description: "A panel, query or variable uses a datasource no Datasource or ExternalDatasource in the build declares",
+  description: "A panel, query, variable or annotation uses a datasource no Datasource or ExternalDatasource in the build declares, or one the build deletes",
 
   check(ctx: PostSynthContext): PostSynthDiagnostic[] {
     return grafanaDiagnostics(ctx, "GRAF101");