@intentius/chant-lexicon-otel 0.100.0 → 0.101.0

package/src/lint/post-synth/otel-helpers.ts

@@ -8,16 +8,32 @@ import type { SerializerResult } from "@intentius/chant/serializer";
 import { loadAll } from "js-yaml";
 import type { Declarable } from "@intentius/chant/declarable";
 import { looksLikeCollectorConfig, type CollectorConfig } from "../../model";
+import { configMapCollectorConfigs, describeConfigMapConfig } from "../../configmap";
 import { validateCollectorConfig, validateCollectorEntities, type CollectorIssueCode, type CollectorIssue } from "../../validate-config";
 
+/** Where a collector config was found in the build output. */
+export interface FoundCollectorConfig {
+  /** The lexicon output, or the output file, the config came from. */
+  source: string;
+  config: CollectorConfig;
+  /** Set when the config is a value in a Kubernetes ConfigMap (chant #2930). */
+  configMap?: { namespace: string; name: string; key: string };
+}
+
 /**
- * Every collector config in the output: the otel lexicon's own, and any YAML
- * document shaped like one. Parsed with js-yaml rather than `ctx.docs`,
- * because collector configs are written with flow lists (`[otlp, batch]`)
- * that core's small YAML reader keeps as strings.
+ * Every collector config in the output: the otel lexicon's own, any YAML
+ * document shaped like one, and any ConfigMap data value that parses as one
+ * (how `OtelCollector`, `OtelCollectorGateway` and `GkeOtelCollector` carry
+ * theirs). Parsed with js-yaml rather than `ctx.docs`, because collector
+ * configs are written with flow lists (`[otlp, batch]`) that core's small
+ * YAML reader keeps as strings.
+ *
+ * `chant build` hands each lexicon's checks only that lexicon's output, so
+ * the otel checks see ConfigMaps only in a context that includes k8s output.
+ * The k8s lexicon's WK8604 runs the same config checks over its own output.
  */
-export function collectorConfigs(ctx: PostSynthContext): Array<{ source: string; config: CollectorConfig }> {
-  const out: Array<{ source: string; config: CollectorConfig }> = [];
+export function collectorConfigs(ctx: PostSynthContext): FoundCollectorConfig[] {
+  const out: FoundCollectorConfig[] = [];
   for (const [lexicon, output] of ctx.outputs) {
     const texts: Array<[string, string]> =
       typeof output === "string"
@@ -35,6 +51,10 @@ export function collectorConfigs(ctx: PostSynthContext): Array<{ source: string;
         if (typeof doc !== "object" || doc === null || Array.isArray(doc)) continue;
         if ((lexicon === "otel" && source === lexicon) || looksLikeCollectorConfig(doc)) {
           out.push({ source, config: doc as CollectorConfig });
+          continue;
+        }
+        for (const { config, ...configMap } of configMapCollectorConfigs(doc)) {
+          out.push({ source, config, configMap });
         }
       }
     }
@@ -42,22 +62,34 @@ export function collectorConfigs(ctx: PostSynthContext): Array<{ source: string;
   return out;
 }
 
-function toDiagnostic(issue: CollectorIssue, source?: string): PostSynthDiagnostic {
+function toDiagnostic(issue: CollectorIssue, found?: Omit<FoundCollectorConfig, "config">): PostSynthDiagnostic {
+  const where = found?.configMap ? describeConfigMapConfig(found.configMap) : found && found.source !== "otel" ? found.source : undefined;
   return {
     checkId: issue.code,
     severity: issue.severity,
-    message: source && source !== "otel" ? `${source}: ${issue.message}` : issue.message,
+    message: where ? `${where}: ${issue.message}` : issue.message,
     ...(issue.component ? { entity: issue.component } : issue.pipeline ? { entity: issue.pipeline } : {}),
     lexicon: "otel",
   };
 }
 
-/** Diagnostics for one config-level code (OTEL101-OTEL106, OTEL112) across every collector config in the output. */
+/**
+ * Every config-level diagnostic (OTEL101-OTEL106, OTEL112-OTEL117 and any later
+ * config check) over the collector configs in the output. `configMapsOnly`
+ * keeps the configs held in ConfigMaps, which is what WK8604 reads.
+ */
+export function collectorConfigDiagnostics(ctx: PostSynthContext, opts: { configMapsOnly?: boolean } = {}): PostSynthDiagnostic[] {
+  return collectorConfigs(ctx)
+    .filter((found) => !opts.configMapsOnly || found.configMap)
+    .flatMap(({ config, ...found }) => validateCollectorConfig(config).map((i) => toDiagnostic(i, found)));
+}
+
+/** Diagnostics for one config-level code (OTEL101-OTEL106, OTEL112-OTEL117) across every collector config in the output. */
 export function configDiagnostics(ctx: PostSynthContext, code: CollectorIssueCode): PostSynthDiagnostic[] {
-  return collectorConfigs(ctx).flatMap(({ source, config }) =>
+  return collectorConfigs(ctx).flatMap(({ config, ...found }) =>
     validateCollectorConfig(config)
       .filter((i) => i.code === code)
-      .map((i) => toDiagnostic(i, source)),
+      .map((i) => toDiagnostic(i, found)),
   );
 }
 

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

@@ -0,0 +1,17 @@
+/**
+ * OTEL113: Pipelines form a cycle through connectors
+ *
+ * A connector carries data from the pipeline that lists it as an exporter to the pipeline that lists it as a receiver. When those hops lead back to a pipeline already on the path (traces/a feeds traces/b through one connector and traces/b feeds traces/a through another, or one pipeline lists the same `forward` connector on both sides), the collector refuses to start. The check walks the `edges` `collectorTopology()` returns and names one cycle per group of pipelines caught in it.
+ */
+
+import type { PostSynthCheck, PostSynthContext, PostSynthDiagnostic } from "@intentius/chant/lint/post-synth";
+import { configDiagnostics } from "./otel-helpers";
+
+export const otel113: PostSynthCheck = {
+  id: "OTEL113",
+  description: "Pipelines form a cycle through connectors",
+
+  check(ctx: PostSynthContext): PostSynthDiagnostic[] {
+    return configDiagnostics(ctx, "OTEL113");
+  },
+};

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

@@ -0,0 +1,17 @@
+/**
+ * OTEL114: A connector id is also declared as a receiver or exporter
+ *
+ * A pipeline names a connector the same way it names a receiver or an exporter, so the collector refuses a config where a connector id is also declared under `receivers` or `exporters`, whether or not any pipeline uses it.
+ */
+
+import type { PostSynthCheck, PostSynthContext, PostSynthDiagnostic } from "@intentius/chant/lint/post-synth";
+import { configDiagnostics } from "./otel-helpers";
+
+export const otel114: PostSynthCheck = {
+  id: "OTEL114",
+  description: "A connector id is also declared as a receiver or exporter",
+
+  check(ctx: PostSynthContext): PostSynthDiagnostic[] {
+    return configDiagnostics(ctx, "OTEL114");
+  },
+};

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

@@ -0,0 +1,17 @@
+/**
+ * OTEL115: A routing connector routes to a pipeline that does not receive from it
+ *
+ * Every pipeline a `routing` connector names in `table[].pipelines` or `default_pipelines` must list that connector in its receivers. The connector can only hand data to the pipelines it feeds, and the collector refuses to start when a route names any other pipeline or one that does not exist.
+ */
+
+import type { PostSynthCheck, PostSynthContext, PostSynthDiagnostic } from "@intentius/chant/lint/post-synth";
+import { configDiagnostics } from "./otel-helpers";
+
+export const otel115: PostSynthCheck = {
+  id: "OTEL115",
+  description: "A routing connector routes to a pipeline that does not receive from it",
+
+  check(ctx: PostSynthContext): PostSynthDiagnostic[] {
+    return configDiagnostics(ctx, "OTEL115");
+  },
+};

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

@@ -0,0 +1,17 @@
+/**
+ * OTEL116: A connector splits metrics by a high-cardinality GenAI attribute
+ *
+ * `gen_ai.conversation.id`, `gen_ai.response.id`, `gen_ai.tool.call.id`, `session.id`, `user.id`, `enduser.id` and the other keys in `GENAI_HIGH_CARDINALITY_ATTRIBUTES` take a new value per response, conversation or user, and the content keys (`gen_ai.input.messages` and the rest of `GENAI_CONTENT_ATTRIBUTES`) are unbounded. Used as a metric attribute in `spanmetrics` or `servicegraph` dimensions, `sum` or `count` attributes, or `signaltometrics` attributes or `include_resource_attributes`, each value starts new time series. The collector accepts such a config without a warning.
+ */
+
+import type { PostSynthCheck, PostSynthContext, PostSynthDiagnostic } from "@intentius/chant/lint/post-synth";
+import { configDiagnostics } from "./otel-helpers";
+
+export const otel116: PostSynthCheck = {
+  id: "OTEL116",
+  description: "A connector splits metrics by a high-cardinality GenAI attribute",
+
+  check(ctx: PostSynthContext): PostSynthDiagnostic[] {
+    return configDiagnostics(ctx, "OTEL116");
+  },
+};

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

@@ -0,0 +1,17 @@
+/**
+ * OTEL117: Two components the collector starts listen on the same address
+ *
+ * A receiver or exporter a pipeline lists, an extension in `service.extensions`, and the collector's own metrics endpoint (`localhost:8888` unless `service.telemetry.metrics` says otherwise) each bind an address when the collector starts. Two on the same port, on the same host or with either on a wildcard host (`0.0.0.0`, `::`), make the second bind fail with "address already in use", and the collector exits. `otelcol validate` does not bind, so it accepts such a config. The listeners checked are the otlp, zipkin and jaeger receivers, the prometheus exporter, and the health_check, zpages and pprof extensions, with their defaults at the pinned collector release.
+ */
+
+import type { PostSynthCheck, PostSynthContext, PostSynthDiagnostic } from "@intentius/chant/lint/post-synth";
+import { configDiagnostics } from "./otel-helpers";
+
+export const otel117: PostSynthCheck = {
+  id: "OTEL117",
+  description: "Two components the collector starts listen on the same address",
+
+  check(ctx: PostSynthContext): PostSynthDiagnostic[] {
+    return configDiagnostics(ctx, "OTEL117");
+  },
+};

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

@@ -10,8 +10,21 @@ import { otel106 } from "./otel106";
 import { otel107 } from "./otel107";
 import { otel108 } from "./otel108";
 import { otel109 } from "./otel109";
-import { BatchProcessor, DebugExporter, FileLogReceiver, MemoryLimiterProcessor, OtlpReceiver } from "../../components";
+import { otel116 } from "./otel116";
+import { otel117 } from "./otel117";
+import {
+  BatchProcessor,
+  DebugExporter,
+  FileLogReceiver,
+  MemoryLimiterProcessor,
+  OtlpReceiver,
+  SignalToMetricsConnector,
+  type SignalToMetricsConnectorConfig,
+} from "../../components";
 import { defineComponent } from "../../define";
+import { collectorConfigDiagnostics, collectorConfigs } from "./otel-helpers";
+import { GENAI_CONTENT_ATTRIBUTES, GENAI_HIGH_CARDINALITY_ATTRIBUTES } from "../../genai";
+import { dump } from "js-yaml";
 import { Pipeline } from "../../pipeline";
 
 const GOOD = `receivers:
@@ -162,6 +175,24 @@ describe("entity-level checks", () => {
     expect(otel107.check(makePostSynthCtx("otel", "", entities([limiter, otlp, new BatchProcessor({})])))).toEqual([]);
   });
 
+  test("OTEL107: a signaltometrics entry names exactly one metric type, with a value", () => {
+    const good = new SignalToMetricsConnector({
+      name: "good",
+      spans: [{ name: "span.duration", unit: "ms", histogram: { value: "Milliseconds(end_time - start_time)" } }],
+    });
+    const bad = new SignalToMetricsConnector({
+      name: "bad",
+      spans: [{ name: "both", sum: { value: "1" }, gauge: { value: "1" } }, { name: "nothing" }, { name: "h", histogram: { count: "1" } }],
+    } as unknown as SignalToMetricsConnectorConfig);
+    const diags = otel107.check(makePostSynthCtx("otel", "", entities([good, bad])));
+    expect(diags.map((d) => d.entity)).toEqual(["signaltometrics/bad", "signaltometrics/bad", "signaltometrics/bad"]);
+    expect(diags.map((d) => d.message.replace(/^.*?\): /, ""))).toEqual([
+      "name exactly one metric type (sum, gauge, histogram or exponential_histogram); found sum and gauge",
+      "name exactly one metric type (sum, gauge, histogram or exponential_histogram); found none",
+      "histogram.value is missing",
+    ]);
+  });
+
   test("OTEL108 flags duplicate component and pipeline ids", () => {
     const a = new DebugExporter({});
     const b = new DebugExporter({ verbosity: "detailed" });
@@ -182,3 +213,194 @@ describe("entity-level checks", () => {
     expect(diags.map((d) => d.checkId)).toEqual(["OTEL109"]);
   });
 });
+
+describe("collector configs in Kubernetes ConfigMaps (chant #2930)", () => {
+  const manifests = (...docs: object[]) => docs.map((d) => dump(d, { lineWidth: -1 })).join("---\n");
+  const configMap = (data: Record<string, string>) => ({ apiVersion: "v1", kind: "ConfigMap", metadata: { name: "otel-agent-config", namespace: "observability" }, data });
+
+  test("collectorConfigs reads each ConfigMap value that parses as a config, with its namespace, name and key", () => {
+    const ctx = makePostSynthCtx("k8s", manifests(configMap({ "config.yaml": GOOD, "notes.txt": "not a config" }), { apiVersion: "v1", kind: "Service", metadata: { name: "x" } }));
+    const found = collectorConfigs(ctx);
+    expect(found.map((f) => [f.source, f.configMap])).toEqual([["k8s", { namespace: "observability", name: "otel-agent-config", key: "config.yaml" }]]);
+    expect(found[0]?.config.service?.pipelines?.traces?.processors).toEqual(["memory_limiter", "batch"]);
+  });
+
+  test("a config-level check reports a ConfigMap config's issue, naming the ConfigMap and key", () => {
+    const broken = GOOD.replace("exporters: [debug]", "exporters: [debug, otlp/backend]");
+    const diags = otel101.check(makePostSynthCtx("k8s", manifests(configMap({ "config.yaml": broken }))));
+    expect(diags.map((d) => d.checkId)).toEqual(["OTEL101"]);
+    expect(diags[0].message).toMatch(/^ConfigMap observability\/otel-agent-config, key config\.yaml: /);
+  });
+});
+
+
+describe("OTEL116 high-cardinality GenAI attributes as metric attributes", () => {
+  /** A config whose connectors split metrics by the given keys, in every field OTEL116 reads. */
+  function connectorsSplitBy(key: string) {
+    return {
+      receivers: { otlp: { protocols: { grpc: {} } } },
+      exporters: { debug: {} },
+      connectors: {
+        spanmetrics: {
+          dimensions: [{ name: key }],
+          calls_dimensions: [{ name: key }],
+          histogram: { dimensions: [{ name: key }] },
+          events: { enabled: true, dimensions: [{ name: key }] },
+        },
+        servicegraph: { dimensions: [key] },
+        count: { spans: { "genai.calls": { attributes: [{ key }] } } },
+        "sum/genai": { spans: { "genai.tokens": { source_attribute: "gen_ai.usage.input_tokens", attributes: [{ key, default_value: "none" }] } } },
+        signaltometrics: {
+          spans: [{ name: "gen_ai.client.operation.duration", histogram: { value: "Seconds(end_time - start_time)" }, attributes: [{ key }], include_resource_attributes: [{ key }] }],
+        },
+      },
+      service: {
+        pipelines: {
+          traces: { receivers: ["otlp"], exporters: ["spanmetrics", "servicegraph", "count", "sum/genai", "signaltometrics"] },
+          metrics: { receivers: ["spanmetrics", "servicegraph", "count", "sum/genai", "signaltometrics"], exporters: ["debug"] },
+        },
+      },
+    };
+  }
+  const FIELDS = [
+    ["spanmetrics", "dimensions"],
+    ["spanmetrics", "calls_dimensions"],
+    ["spanmetrics", "histogram.dimensions"],
+    ["spanmetrics", "events.dimensions"],
+    ["servicegraph", "dimensions"],
+    ["count", "spans.genai.calls.attributes"],
+    ["sum/genai", "spans.genai.tokens.attributes"],
+    ["signaltometrics", "spans[0] (gen_ai.client.operation.duration).attributes"],
+    ["signaltometrics", "spans[0] (gen_ai.client.operation.duration).include_resource_attributes"],
+  ];
+  const run = (config: object, lexicon = "otel") => otel116.check(makePostSynthCtx(lexicon, dump(config, { lineWidth: -1 })));
+
+  test.each(GENAI_HIGH_CARDINALITY_ATTRIBUTES.map((k) => [k]))("reports %s in every connector field", (key) => {
+    const diags = run(connectorsSplitBy(key));
+    expect(diags.map((d) => [d.entity, d.message.match(/\((.+)\);/)?.[1]])).toEqual(FIELDS);
+    expect(diags.every((d) => d.checkId === "OTEL116" && d.severity === "warning")).toBe(true);
+    expect(diags[0].message).toContain(`"${key}"`);
+    expect(diags[0].message).toContain("new value per request");
+  });
+
+  test.each([...GENAI_CONTENT_ATTRIBUTES, "gen_ai.prompt.0.content"].map((k) => [k]))("reports content key %s as unbounded and sensitive", (key) => {
+    const diags = run(connectorsSplitBy(key));
+    expect(diags).toHaveLength(FIELDS.length);
+    expect(diags[0].message).toContain("unbounded and sensitive");
+  });
+
+  test.each(["gen_ai.request.model", "gen_ai.provider.name", "gen_ai.prompt.name", "error.type"].map((k) => [k]))("passes bounded key %s", (key) => {
+    expect(run(connectorsSplitBy(key))).toEqual([]);
+  });
+
+  test("passes the v1.41.1 client metrics' attributes, and an empty include_resource_attributes", () => {
+    const semconv = ["gen_ai.operation.name", "gen_ai.provider.name", "gen_ai.request.model", "gen_ai.response.model", "server.address", "server.port", "error.type", "gen_ai.token.type"];
+    const config = {
+      ...connectorsSplitBy("gen_ai.request.model"),
+      connectors: {
+        signaltometrics: {
+          spans: [
+            {
+              name: "gen_ai.client.token.usage",
+              histogram: { value: 'attributes["gen_ai.usage.input_tokens"]' },
+              attributes: semconv.map((key) => ({ key, optional: true })),
+              include_resource_attributes: [],
+            },
+          ],
+        },
+      },
+      service: { pipelines: { traces: { receivers: ["otlp"], exporters: ["signaltometrics"] }, metrics: { receivers: ["signaltometrics"], exporters: ["debug"] } } },
+    };
+    expect(run(config)).toEqual([]);
+  });
+
+  test("WK8604's entry point reports it for a config in a ConfigMap", () => {
+    const configMap = { apiVersion: "v1", kind: "ConfigMap", metadata: { name: "otel-agent-config", namespace: "observability" }, data: { "config.yaml": dump(connectorsSplitBy("gen_ai.conversation.id")) } };
+    const diags = collectorConfigDiagnostics(makePostSynthCtx("k8s", dump(configMap, { lineWidth: -1 })), { configMapsOnly: true }).filter((d) => d.checkId === "OTEL116");
+    expect(diags).toHaveLength(FIELDS.length);
+    expect(diags[0].message).toMatch(/^ConfigMap observability\/otel-agent-config, key config\.yaml: connector "spanmetrics" splits metrics by "gen_ai\.conversation\.id"/);
+  });
+});
+
+describe("OTEL117 two started components on one address", () => {
+  const run = (config: object) => otel117.check(makePostSynthCtx("otel", dump(config)));
+  const otlpOnly = { receivers: ["otlp"], exporters: ["debug"] };
+
+  test("reports a prometheus exporter on the collector's own default metrics port", () => {
+    const diags = run({
+      receivers: { otlp: { protocols: { grpc: { endpoint: "0.0.0.0:4317" } } } },
+      exporters: { prometheus: { endpoint: "0.0.0.0:8888" } },
+      service: { pipelines: { metrics: { receivers: ["otlp"], exporters: ["prometheus"] } } },
+    });
+    expect(diags).toHaveLength(1);
+    expect(diags[0]).toMatchObject({ checkId: "OTEL117", severity: "error" });
+    expect(diags[0].message).toContain('exporter "prometheus" (endpoint) listens on 0.0.0.0:8888');
+    expect(diags[0].message).toContain("the collector's own metrics (service.telemetry.metrics, by default) on localhost:8888");
+  });
+
+  test("reports two otlp receivers left on the default grpc port", () => {
+    const diags = run({
+      receivers: { otlp: { protocols: { grpc: {} } }, "otlp/2": { protocols: { grpc: {}, http: { endpoint: "0.0.0.0:4319" } } } },
+      exporters: { debug: {} },
+      service: { pipelines: { traces: { receivers: ["otlp"], exporters: ["debug"] }, logs: { receivers: ["otlp/2"], exporters: ["debug"] } } },
+    });
+    expect(diags.map((d) => d.message)).toEqual([
+      expect.stringMatching(/^receiver "otlp" \(protocols\.grpc\.endpoint\) listens on localhost:4317 and receiver "otlp\/2" \(protocols\.grpc\.endpoint\) on localhost:4317/),
+    ]);
+  });
+
+  test("a wildcard host overlaps a specific host on the same port, and an extension counts", () => {
+    const diags = run({
+      receivers: { zipkin: { endpoint: "127.0.0.1:13133" } },
+      exporters: { debug: {} },
+      extensions: { health_check: { endpoint: "0.0.0.0:13133" } },
+      service: { extensions: ["health_check"], pipelines: { traces: { receivers: ["zipkin"], exporters: ["debug"] } } },
+    });
+    expect(diags).toHaveLength(1);
+    expect(diags[0].message).toContain('extension "health_check" (endpoint) on 0.0.0.0:13133');
+  });
+
+  test("passes different hosts on one port, UDP beside TCP, and telemetry moved off 8888 or turned off", () => {
+    const base = {
+      receivers: {
+        otlp: { protocols: { grpc: { endpoint: "10.0.0.1:4317" }, http: { endpoint: "0.0.0.0:6831" } } },
+        "otlp/b": { protocols: { grpc: { endpoint: "10.0.0.2:4317" } } },
+        jaeger: { protocols: { thrift_compact: {} } },
+      },
+      exporters: { prometheus: { endpoint: "0.0.0.0:8888" } },
+    };
+    const pipelines = { traces: { receivers: ["otlp", "otlp/b", "jaeger"], exporters: ["prometheus"] } };
+    const reader = { pull: { exporter: { prometheus: { host: "0.0.0.0", port: 8889 } } } };
+    expect(run({ ...base, service: { telemetry: { metrics: { readers: [reader] } }, pipelines } })).toEqual([]);
+    expect(run({ ...base, service: { telemetry: { metrics: { level: "none" } }, pipelines } })).toEqual([]);
+  });
+
+  test("a component nothing starts doesn't count, nor does an endpoint the collector connects to", () => {
+    expect(
+      run({
+        receivers: { otlp: { protocols: { grpc: {} } }, "otlp/unused": { protocols: { grpc: {} } }, kubeletstats: { endpoint: "localhost:4317" } },
+        exporters: { debug: {}, prometheus: { endpoint: "localhost:8888" }, otlp: { endpoint: "localhost:4317" } },
+        extensions: { zpages: { endpoint: "localhost:4317" } },
+        service: { pipelines: { traces: otlpOnly, metrics: { receivers: ["kubeletstats"], exporters: ["otlp"] } } },
+      }),
+    ).toEqual([]);
+  });
+
+  test("reads the telemetry reader's address when one is set", () => {
+    const diags = run({
+      receivers: { otlp: { protocols: { http: { endpoint: "0.0.0.0:9000" } } } },
+      exporters: { debug: {} },
+      service: { telemetry: { metrics: { readers: [{ pull: { exporter: { prometheus: { host: "0.0.0.0", port: 9000 } } } }] } }, pipelines: { logs: { receivers: ["otlp"], exporters: ["debug"] } } },
+    });
+    expect(diags).toHaveLength(1);
+    expect(diags[0].message).toContain("service.telemetry.metrics.readers[0]");
+  });
+
+  test("WK8604's entry point reports it for a config in a ConfigMap", () => {
+    const config = { receivers: { otlp: { protocols: { grpc: {} } } }, exporters: { prometheus: { endpoint: ":8888" } }, service: { pipelines: { metrics: { receivers: ["otlp"], exporters: ["prometheus"] } } } };
+    const configMap = { apiVersion: "v1", kind: "ConfigMap", metadata: { name: "otel-agent-config", namespace: "observability" }, data: { "config.yaml": dump(config) } };
+    const diags = collectorConfigDiagnostics(makePostSynthCtx("k8s", dump(configMap, { lineWidth: -1 })), { configMapsOnly: true }).filter((d) => d.checkId === "OTEL117");
+    expect(diags).toHaveLength(1);
+    expect(diags[0].message).toMatch(/^ConfigMap observability\/otel-agent-config, key config\.yaml: exporter "prometheus"/);
+  });
+});

package/src/lint/post-synth/testdata/otel113-fail.yaml

@@ -0,0 +1,23 @@
+# OTEL113 failing fixture: traces/a feeds traces/b through forward/ab, and
+# traces/b feeds traces/a back through forward/ba.
+receivers:
+  otlp:
+    protocols:
+      grpc:
+        endpoint: 127.0.0.1:4317
+
+exporters:
+  debug: {}
+
+connectors:
+  forward/ab: {}
+  forward/ba: {}
+
+service:
+  pipelines:
+    traces/a:
+      receivers: [otlp, forward/ba]
+      exporters: [forward/ab]
+    traces/b:
+      receivers: [forward/ab]
+      exporters: [forward/ba, debug]

package/src/lint/post-synth/testdata/otel113-pass.yaml

@@ -0,0 +1,21 @@
+# OTEL113 passing fixture: the same two pipelines chained one way only.
+receivers:
+  otlp:
+    protocols:
+      grpc:
+        endpoint: 127.0.0.1:4317
+
+exporters:
+  debug: {}
+
+connectors:
+  forward/ab: {}
+
+service:
+  pipelines:
+    traces/a:
+      receivers: [otlp]
+      exporters: [forward/ab]
+    traces/b:
+      receivers: [forward/ab]
+      exporters: [debug]

package/src/lint/post-synth/testdata/otel114-fail.yaml

@@ -0,0 +1,25 @@
+# OTEL114 failing fixture: the id "datadog" is declared both as a receiver and
+# as a connector. collector-contrib ships a receiver and a connector of that
+# type, so the real collector gets as far as comparing the ids.
+receivers:
+  otlp:
+    protocols:
+      grpc:
+        endpoint: 127.0.0.1:4317
+  datadog:
+    endpoint: 127.0.0.1:8126
+
+exporters:
+  debug: {}
+
+connectors:
+  datadog: {}
+
+service:
+  pipelines:
+    traces:
+      receivers: [otlp]
+      exporters: [datadog]
+    metrics:
+      receivers: [datadog]
+      exporters: [debug]

package/src/lint/post-synth/testdata/otel114-pass.yaml

@@ -0,0 +1,23 @@
+# OTEL114 passing fixture: the connector is renamed datadog/connector.
+receivers:
+  otlp:
+    protocols:
+      grpc:
+        endpoint: 127.0.0.1:4317
+  datadog:
+    endpoint: 127.0.0.1:8126
+
+exporters:
+  debug: {}
+
+connectors:
+  datadog/connector: {}
+
+service:
+  pipelines:
+    traces:
+      receivers: [otlp, datadog]
+      exporters: [datadog/connector]
+    metrics:
+      receivers: [datadog/connector]
+      exporters: [debug]

package/src/lint/post-synth/testdata/otel115-fail.yaml

@@ -0,0 +1,29 @@
+# OTEL115 failing fixture: the routing connector's default_pipelines names
+# traces/other, which receives from otlp rather than from the connector.
+receivers:
+  otlp:
+    protocols:
+      grpc:
+        endpoint: 127.0.0.1:4317
+
+exporters:
+  debug: {}
+
+connectors:
+  routing:
+    default_pipelines: [traces/other]
+    table:
+      - statement: route() where attributes["tenant"] == "acme"
+        pipelines: [traces/acme]
+
+service:
+  pipelines:
+    traces/in:
+      receivers: [otlp]
+      exporters: [routing]
+    traces/acme:
+      receivers: [routing]
+      exporters: [debug]
+    traces/other:
+      receivers: [otlp]
+      exporters: [debug]

package/src/lint/post-synth/testdata/otel115-pass.yaml

@@ -0,0 +1,29 @@
+# OTEL115 passing fixture: both routes lead to pipelines that receive from the
+# routing connector.
+receivers:
+  otlp:
+    protocols:
+      grpc:
+        endpoint: 127.0.0.1:4317
+
+exporters:
+  debug: {}
+
+connectors:
+  routing:
+    default_pipelines: [traces/other]
+    table:
+      - statement: route() where attributes["tenant"] == "acme"
+        pipelines: [traces/acme]
+
+service:
+  pipelines:
+    traces/in:
+      receivers: [otlp]
+      exporters: [routing]
+    traces/acme:
+      receivers: [routing]
+      exporters: [debug]
+    traces/other:
+      receivers: [routing]
+      exporters: [debug]

package/src/plugin.test.ts

@@ -29,6 +29,11 @@ describe("otel plugin", () => {
       "OTEL108",
       "OTEL109",
       "OTEL112",
+      "OTEL113",
+      "OTEL114",
+      "OTEL115",
+      "OTEL116",
+      "OTEL117",
     ]);
     for (const id of ids) expect(id.startsWith("OTEL")).toBe(true);
   });
@@ -53,4 +58,17 @@ describe("otel plugin", () => {
     expect(otelPlugin.mcpTools!().map((t) => t.name)).toEqual(["otel:diff"]);
     expect(otelPlugin.mcpResources!().map((r) => r.uri)).toEqual(["otel:resource-catalog"]);
   });
+
+  it("reports the collector topology for the graph, and nothing for a project without one", async () => {
+    const { OtlpReceiver, DebugExporter } = await import("./components");
+    const { Pipeline } = await import("./pipeline");
+    expect(otelPlugin.graphMeta!(new Map())).toBeUndefined();
+    expect(otelPlugin.graphMeta!(new Map([["other", { lexicon: "k8s", entityType: "Pod" } as never]]))).toBeUndefined();
+    const otlp = new OtlpReceiver({ protocols: { grpc: { endpoint: "0.0.0.0:4317" } } });
+    const debug = new DebugExporter({});
+    const meta = otelPlugin.graphMeta!(new Map<string, never>([["otlp", otlp as never], ["debug", debug as never], ["p", new Pipeline({ signal: "traces", receivers: [otlp], exporters: [debug] }) as never]]));
+    const collector = meta!.collector as { pipelines: { id: string }[]; exporters: { id: string; signals: string[] }[] };
+    expect(collector.pipelines.map((p) => p.id)).toEqual(["traces"]);
+    expect(collector.exporters.map((e) => [e.id, e.signals])).toEqual([["debug", ["traces"]]]);
+  });
 });