@intentius/chant-lexicon-otel 0.100.0 → 0.102.0

package/src/import/testdata/signaltometrics.yaml

@@ -0,0 +1,83 @@
+# A signaltometrics connector (collector-contrib v0.130.0) building metrics
+# from spans, logs and data points: explicit and exponential histograms, a
+# sum and a gauge, with attributes, resource attributes and conditions.
+
+receivers:
+  otlp:
+    protocols:
+      grpc:
+        endpoint: 0.0.0.0:4317
+processors:
+  batch: {}
+exporters:
+  debug:
+    verbosity: basic
+  prometheus:
+    endpoint: 0.0.0.0:8889
+connectors:
+  signaltometrics/genai:
+    spans:
+      - name: gen_ai.client.operation.duration
+        description: GenAI operation duration
+        unit: s
+        conditions:
+          - attributes["gen_ai.operation.name"] != nil
+        attributes:
+          - key: gen_ai.operation.name
+          - key: gen_ai.request.model
+            default_value: unknown
+          - key: error.type
+            optional: true
+        include_resource_attributes:
+          - key: service.name
+        histogram:
+          buckets: [0.01, 0.02, 0.04, 0.08, 0.16, 0.32, 0.64, 1.28, 2.56, 5.12, 10.24, 20.48, 40.96, 81.92]
+          value: Double(Microseconds(end_time - start_time)) / 1000000.0
+      - name: gen_ai.client.token.usage
+        description: Input tokens used
+        unit: "{token}"
+        conditions:
+          - attributes["gen_ai.usage.input_tokens"] != nil
+        attributes:
+          - key: gen_ai.request.model
+            default_value: unknown
+          - key: gen_ai.token.type
+            default_value: input
+        histogram:
+          buckets: [1, 4, 16, 64, 256, 1024, 4096, 16384, 65536, 262144, 1048576, 4194304, 16777216, 67108864]
+          value: attributes["gen_ai.usage.input_tokens"]
+      - name: span.count
+        description: Spans, adjusted for sampling
+        sum:
+          value: Int(AdjustedCount())
+      - name: span.duration.exponential
+        unit: us
+        exponential_histogram:
+          max_size: 80
+          value: Microseconds(end_time - start_time)
+    logs:
+      - name: logrecord.count
+        sum:
+          value: "1"
+    datapoints:
+      - name: datapoint.last
+        conditions:
+          - metric.type == 1
+        gauge:
+          value: value_double
+service:
+  pipelines:
+    traces:
+      receivers: [otlp]
+      processors: [batch]
+      exporters: [debug, signaltometrics/genai]
+    logs:
+      receivers: [otlp]
+      exporters: [signaltometrics/genai]
+    metrics:
+      receivers: [otlp]
+      exporters: [signaltometrics/genai]
+    metrics/genai:
+      receivers: [signaltometrics/genai]
+      processors: [batch]
+      exporters: [prometheus]

package/src/index.ts

@@ -47,6 +47,7 @@ export {
 export * from "./model";
 export { buildCollectorConfig, collectorYaml, componentConfig, type BuiltCollector } from "./collector";
 export { emitCollectorYaml, type EmitOptions } from "./yaml";
+export { configMapCollectorConfigs, describeConfigMapConfig, parseCollectorConfig, type ConfigMapCollectorConfig } from "./configmap";
 export {
   validateCollectorConfig,
   validateCollectorEntities,
@@ -65,6 +66,9 @@ export {
 } from "./topology";
 export { semconvUsage, SEMCONV_VOCABULARIES, type SemconvVocabulary } from "./semconv";
 
+// Composites
+export { NodeAgent, nodeAgentPropsProblem, type NodeAgentProps, type NodeAgentMembers, type NodeAgentInstance } from "./composites";
+
 // What the platform collector composites (docker, k8s, fly) share
 export {
   otlpCollector,
@@ -85,16 +89,28 @@ export {
   GENAI_CONTENT_ATTRIBUTES,
   GENAI_CONTENT_EVENTS,
   GENAI_INDEXED_CONTENT_PATTERN,
+  GENAI_HIGH_CARDINALITY_ATTRIBUTES,
+  genAiCardinalityRisk,
   GENAI_SPAN_METRIC_DIMENSIONS,
   GENAI_TOKEN_DIMENSIONS,
   GENAI_DURATION_BUCKETS,
   GENAI_UNKNOWN_MODEL,
+  GENAI_PROVIDER_DIMENSIONS,
+  GENAI_CLIENT_METRIC_NAMES,
+  GENAI_CLIENT_METRIC_ATTRIBUTES,
+  GENAI_CLIENT_DURATION_BUCKETS,
+  GENAI_CLIENT_TOKEN_BUCKETS,
+  GENAI_TOKEN_TYPES,
+  DELTA_READY_EXPORTERS,
+  genAiNeedsDeltaToCumulative,
   type GenAiPipelineOptions,
   type GenAiComponentsOptions,
   type GenAiComponents,
   type GenAiMetricsOptions,
   type GenAiMetrics,
   type GenAiMetric,
+  type GenAiClientMetrics,
+  type GenAiClientMetricsSource,
 } from "./genai";
 
 // Metric names as Prometheus serves them, for dashboards and SLOs built from a declaration

package/src/init-templates.test.ts

@@ -0,0 +1,72 @@
+import { describe, expect, test } from "vitest";
+import { mkdtempSync, rmSync, writeFileSync, mkdirSync } from "fs";
+import { join } from "path";
+import { load } from "js-yaml";
+import { build } from "@intentius/chant/build";
+import { lintCommand } from "@intentius/chant/cli/commands/lint";
+import { runPostSynthChecks } from "@intentius/chant/lint/post-synth";
+import { otelPlugin } from "./plugin";
+import { postSynthChecks } from "./lint/post-synth";
+import { TEMPLATE_NAMES } from "./init-templates";
+import type { CollectorConfig } from "./model";
+
+async function buildTemplate(name: string | undefined): Promise<{ dir: string; result: Awaited<ReturnType<typeof build>> }> {
+  const set = otelPlugin.initTemplates!(name);
+  const dir = mkdtempSync(join(import.meta.dirname, "..", ".init-template-"));
+  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);
+  return { dir, result: await build(join(dir, "src"), [otelPlugin.serializer]) };
+}
+
+function configOf(result: Awaited<ReturnType<typeof build>>): CollectorConfig {
+  return load(result.outputs.get("otel") as string) as CollectorConfig;
+}
+
+// Every template builds with the otel lexicon alone, and its output passes
+// every OTEL check and lints with nothing to report.
+describe("init templates", () => {
+  test.each([undefined, ...TEMPLATE_NAMES])("%s builds, lints clean and passes every check", async (name) => {
+    const { dir, result } = await buildTemplate(name);
+    try {
+      expect(result.errors).toEqual([]);
+      expect(result.outputs.get("otel")).toBeTruthy();
+      expect(runPostSynthChecks(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 k8s-agent template sends traces and logs to the gateway and serves metrics on the node", async () => {
+    const { dir, result } = await buildTemplate("k8s-agent");
+    try {
+      const config = configOf(result);
+      const pipelines = config.service?.pipelines ?? {};
+      expect(pipelines.traces.exporters).toEqual(["otlp/gateway"]);
+      expect(pipelines.logs.exporters).toEqual(["otlp/gateway"]);
+      expect(pipelines.metrics.exporters).toEqual(["prometheus"]);
+      expect(pipelines.metrics.receivers).toEqual(["otlp", "hostmetrics", "kubeletstats"]);
+      expect(config.processors?.resource).toEqual({ attributes: [{ key: "k8s.cluster.name", value: "my-cluster", action: "upsert" }] });
+    } finally {
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
+
+  test("the genai template derives the conventions' client metrics and removes content", async () => {
+    const { dir, result } = await buildTemplate("genai");
+    try {
+      const config = configOf(result);
+      expect(Object.keys(config.connectors ?? {})).toContain("signaltometrics/genai_client");
+      expect(config.service?.pipelines?.traces?.processors).toContain("transform/genai_content");
+      expect(config.service?.pipelines?.["metrics/genai"]?.exporters).toEqual(["prometheus"]);
+    } finally {
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
+
+  test("an unknown template name falls back to the default", () => {
+    expect(otelPlugin.initTemplates!("no-such-template")).toBe(otelPlugin.initTemplates!());
+  });
+});

package/src/init-templates.ts

@@ -0,0 +1,148 @@
+/**
+ * `chant init --lexicon otel` scaffolds.
+ *
+ * - default: OTLP in, `memory_limiter` and `batch`, traces to an OTLP
+ *   backend and logs to `debug`, with a `health_check`.
+ * - `k8s-agent`: the config a per-node agent runs as a Kubernetes DaemonSet
+ *   (`NodeAgent`): OTLP from the node's pods, host metrics and container
+ *   logs, Kubernetes metadata on all of it, traces and logs on to a gateway
+ *   and metrics served for Prometheus to scrape on each node.
+ * - `genai`: a collector for an agent service instrumented with the
+ *   OpenTelemetry GenAI conventions (`genAiPipeline`): prompt and completion
+ *   content removed, RED and token metrics and the conventions' client
+ *   metrics derived from every GenAI span, traces to Tempo.
+ *
+ * Each template builds with the otel lexicon alone, which is all
+ * `chant init --lexicon otel` installs.
+ */
+import type { InitTemplateSet } from "@intentius/chant/lexicon";
+
+// ── default ────────────────────────────────────────────────────────────
+
+const DEFAULT_COLLECTOR = `/**
+ * A collector: OTLP in, batched, traces out to an OTLP backend and logs to
+ * the collector's own output. \`chant build\` writes the config
+ * \`otelcol --config\` reads.
+ *
+ * Nested settings are named consts typed with the lexicon's config types, so
+ * each constructor stays flat.
+ */
+import {
+  OtlpReceiver,
+  MemoryLimiterProcessor,
+  BatchProcessor,
+  OtlpExporter,
+  DebugExporter,
+  HealthCheckExtension,
+  Pipeline,
+  type OtlpReceiverConfig,
+  type TLSClientSettings,
+  type QueueSettings,
+} from "@intentius/chant-lexicon-otel";
+
+const protocols: OtlpReceiverConfig["protocols"] = {
+  grpc: { endpoint: "0.0.0.0:4317" },
+  http: { endpoint: "0.0.0.0:4318" },
+};
+const otlp = new OtlpReceiver({ protocols });
+
+const memoryLimiter = new MemoryLimiterProcessor({ check_interval: "1s", limit_percentage: 80, spike_limit_percentage: 20 });
+const batch = new BatchProcessor({ timeout: "5s" });
+
+// Point this at your tracing backend. \`otlp/backend\`: the instance name leaves room for a second otlp exporter.
+const plaintext: TLSClientSettings = { insecure: true };
+const queue: QueueSettings = { enabled: true, queue_size: 5000 };
+const backend = new OtlpExporter({ name: "backend", endpoint: "tempo:4317", tls: plaintext, sending_queue: queue });
+
+const debug = new DebugExporter({ verbosity: "basic" });
+
+const health = new HealthCheckExtension({ endpoint: "0.0.0.0:13133" });
+
+const traces = new Pipeline({ signal: "traces", receivers: [otlp], processors: [memoryLimiter, batch], exporters: [backend] });
+const logs = new Pipeline({ signal: "logs", receivers: [otlp], processors: [memoryLimiter, batch], exporters: [debug] });
+
+export { otlp, memoryLimiter, batch, backend, debug, health, traces, logs };
+`;
+
+// ── k8s-agent ──────────────────────────────────────────────────────────
+
+const AGENT_EXPORTERS = `/**
+ * Where the agent sends what it collects: traces and logs to the gateway
+ * collectors, metrics served on each node for Prometheus to scrape.
+ */
+import { OtlpExporter, PrometheusExporter, type RetrySettings, type TLSClientSettings } from "@intentius/chant-lexicon-otel";
+
+// The gateway Service. With the k8s lexicon's OtelCollectorGateway, use its gatewayExporter() instead.
+const inCluster: TLSClientSettings = { insecure: true };
+const retry: RetrySettings = { enabled: true, max_elapsed_time: "300s" };
+const gateway = new OtlpExporter({ name: "gateway", endpoint: "otel-gateway.observability.svc:4317", tls: inCluster, retry_on_failure: retry });
+
+// Resource attributes (k8s.namespace.name, k8s.pod.name, ...) become metric labels.
+const asLabels = { enabled: true };
+const scrape = new PrometheusExporter({ endpoint: "0.0.0.0:8889", resource_to_telemetry_conversion: asLabels });
+
+export { gateway, scrape };
+`;
+
+const AGENT = `/**
+ * The config each node's collector runs. The pod needs the node name in
+ * K8S_NODE_NAME (from spec.nodeName), the host root mounted read-only at
+ * /hostfs, /var/log/pods mounted read-only, and a service account that can
+ * read pods, namespaces, nodes and replicasets (and nodes/stats, for kubelet
+ * stats). Pass \`Object.values(agent.members)\` as the k8s lexicon's
+ * OtelCollector \`config\` to run it as a DaemonSet: it adds all of these,
+ * worked out from the config.
+ */
+import { NodeAgent } from "@intentius/chant-lexicon-otel";
+import { gateway, scrape } from "./exporters";
+
+export const agent = NodeAgent({
+  exporters: [gateway],
+  metricExporters: [scrape],
+  clusterName: "my-cluster",
+  kubeletStats: true,
+});
+`;
+
+// ── genai ──────────────────────────────────────────────────────────────
+
+const GENAI_COLLECTOR = `/**
+ * A collector for an agent service instrumented with the OpenTelemetry GenAI
+ * conventions. Prompts, completions and tool payloads are removed before
+ * anything leaves the collector. Every GenAI span also becomes call, error,
+ * duration and token metrics, and the conventions' own client metrics
+ * (gen_ai.client.operation.duration, gen_ai.client.token.usage), served for
+ * Prometheus to scrape. Traces go to Tempo.
+ */
+import { genAiPipeline, OtlpExporter, PrometheusExporter, type TLSClientSettings } from "@intentius/chant-lexicon-otel";
+
+const plaintext: TLSClientSettings = { insecure: true };
+const tempo = new OtlpExporter({ name: "tempo", endpoint: "tempo:4317", tls: plaintext });
+
+const prometheus = new PrometheusExporter({ endpoint: "0.0.0.0:8889" });
+
+// Content stays out unless keepContent: true is set here. Card-number-like values are masked in whatever is left.
+const cardNumbers = ["\\\\b[0-9]{13,16}\\\\b"];
+
+export const collector = genAiPipeline({
+  traceExporters: [tempo],
+  metricExporters: [prometheus],
+  clientMetrics: "derive",
+  maskValues: cardNumbers,
+});
+`;
+
+export const DEFAULT_TEMPLATE: InitTemplateSet = {
+  src: { "collector.ts": DEFAULT_COLLECTOR },
+};
+
+export const K8S_AGENT_TEMPLATE: InitTemplateSet = {
+  src: { "exporters.ts": AGENT_EXPORTERS, "agent.ts": AGENT },
+};
+
+export const GENAI_TEMPLATE: InitTemplateSet = {
+  src: { "collector.ts": GENAI_COLLECTOR },
+};
+
+/** The template names `chant init --lexicon otel --template <name>` takes, besides the default. */
+export const TEMPLATE_NAMES = ["k8s-agent", "genai"] as const;

package/src/lint/audit-catalog.ts

@@ -2,7 +2,7 @@
  * The otel lexicon's chant audit catalog, contributed via
  * `otelPlugin.auditCatalog()` (#687, #1346).
  *
- * OTEL101-OTEL106 and OTEL112 read the emitted collector YAML, so they are
+ * OTEL101-OTEL106 and OTEL112-OTEL117 read the emitted collector YAML, so they are
  * `yamlBased`.
  * OTEL107-OTEL109 read the declared entities (a component's definition, its
  * schema pin), which a standalone YAML file does not carry, so they are
@@ -108,4 +108,44 @@ export const otelAuditCatalog: Record<string, RuleMeta> = {
     "Feed the connector from, and receive from it into, pipelines of the signals it supports (spanmetrics: traces in, metrics out).",
     { category: "correctness" },
   ),
+  OTEL113: auditRule(
+    "OTEL113",
+    "merge-worthy",
+    "guidance",
+    "Pipelines form a cycle through connectors",
+    "Break the cycle the message names: drop one connector hop, or send that pipeline's data to an exporter instead of back upstream.",
+    { category: "correctness" },
+  ),
+  OTEL114: auditRule(
+    "OTEL114",
+    "merge-worthy",
+    "guidance",
+    "Connector id also declared as a receiver or exporter",
+    'Give the connector, or the receiver or exporter, its own name (e.g. "datadog/connector") and update the pipelines that list it.',
+    { category: "correctness" },
+  ),
+  OTEL115: auditRule(
+    "OTEL115",
+    "merge-worthy",
+    "guidance",
+    "Routing connector routes to a pipeline that does not receive from it",
+    "List the routing connector in the receivers of every pipeline its table and default_pipelines name, or remove the pipeline from the route.",
+    { category: "correctness" },
+  ),
+  OTEL116: auditRule(
+    "OTEL116",
+    "merge-worthy",
+    "guidance",
+    "Connector splits metrics by a high-cardinality GenAI attribute",
+    "Remove the conversation, response, tool call, session or user id, or the content key, from the connector's dimensions or attributes. Keep it on spans and logs, where a per-request value costs nothing extra.",
+    { category: "efficiency" },
+  ),
+  OTEL117: auditRule(
+    "OTEL117",
+    "merge-worthy",
+    "guidance",
+    "Two started components listen on the same address",
+    "Give one of them another port, or a specific host that doesn't overlap the other's. The collector's own metrics listen on localhost:8888 unless service.telemetry.metrics sets a reader or level none.",
+    { category: "correctness" },
+  ),
 };

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

@@ -0,0 +1,207 @@
+/**
+ * OTEL113-OTEL115 against the fixtures in testdata/: each failing fixture
+ * trips its own rule and nothing else, each passing fixture trips nothing.
+ *
+ * Where `otelcol-contrib` is on PATH (or `OTELCOL_BIN` names a contrib build),
+ * `otelcol validate` confirms the collector refuses each failing fixture and
+ * accepts each passing one. Without it those tests skip; CI does not install it.
+ */
+
+import { describe, expect, test } from "vitest";
+import { spawnSync } from "child_process";
+import { readFileSync } from "fs";
+import { join } from "path";
+import { load } from "js-yaml";
+import { makePostSynthCtx } from "@intentius/chant-test-utils";
+import type { PostSynthCheck } from "@intentius/chant/lint/post-synth";
+import { validateCollectorConfig } from "../../validate-config";
+import type { CollectorConfig } from "../../model";
+import { otel113 } from "./otel113";
+import { otel114 } from "./otel114";
+import { otel115 } from "./otel115";
+
+const fixture = (name: string) => readFileSync(join(import.meta.dirname, "testdata", name), "utf-8");
+
+const RULES: Array<[string, PostSynthCheck]> = [
+  ["OTEL113", otel113],
+  ["OTEL114", otel114],
+  ["OTEL115", otel115],
+];
+
+function findOtelcol(): string | undefined {
+  const candidates = [process.env.OTELCOL_BIN, "otelcol-contrib"].filter((c): c is string => !!c);
+  for (const bin of candidates) {
+    const r = spawnSync(bin, ["--version"], { encoding: "utf-8" });
+    if (r.status === 0) return bin;
+  }
+  return undefined;
+}
+
+const OTELCOL = findOtelcol();
+
+function otelcolValidate(file: string): { ok: boolean; output: string } {
+  const r = spawnSync(OTELCOL!, ["validate", `--config=${join(import.meta.dirname, "testdata", file)}`], {
+    encoding: "utf-8",
+    timeout: 60_000,
+  });
+  return { ok: r.status === 0, output: `${r.stdout ?? ""}${r.stderr ?? ""}` };
+}
+
+describe.each(RULES)("%s fixtures", (id, check) => {
+  const lower = id.toLowerCase();
+
+  test("the failing fixture trips this rule and no other", () => {
+    const yaml = fixture(`${lower}-fail.yaml`);
+    const diags = check.check(makePostSynthCtx("otel", yaml));
+    expect(diags).toHaveLength(1);
+    expect(diags[0]).toMatchObject({ checkId: id, severity: "error", lexicon: "otel" });
+    expect(validateCollectorConfig(load(yaml) as CollectorConfig).map((i) => i.code)).toEqual([id]);
+  });
+
+  test("the passing fixture trips nothing", () => {
+    const yaml = fixture(`${lower}-pass.yaml`);
+    expect(check.check(makePostSynthCtx("otel", yaml))).toEqual([]);
+    expect(validateCollectorConfig(load(yaml) as CollectorConfig)).toEqual([]);
+  });
+
+  test.skipIf(!OTELCOL)("otelcol validate refuses the failing fixture", () => {
+    const { ok, output } = otelcolValidate(`${lower}-fail.yaml`);
+    expect(ok, output).toBe(false);
+  });
+
+  test.skipIf(!OTELCOL)("otelcol validate accepts the passing fixture", () => {
+    const { ok, output } = otelcolValidate(`${lower}-pass.yaml`);
+    expect(ok, output).toBe(true);
+  });
+});
+
+describe("OTEL113 connector cycles", () => {
+  const config = (pipelines: string): CollectorConfig =>
+    load(`receivers: {otlp: {protocols: {grpc: {}}}}
+exporters: {debug: {}}
+connectors: {forward: {}, forward/2: {}, spanmetrics: {}}
+service:
+  pipelines:
+${pipelines}`) as CollectorConfig;
+  const cycles = (c: CollectorConfig) => validateCollectorConfig(c).filter((i) => i.code === "OTEL113");
+
+  test("names the cycle hop by hop", () => {
+    const [issue] = cycles(load(fixture("otel113-fail.yaml")) as CollectorConfig);
+    expect(issue.pipeline).toBe("traces/a");
+    expect(issue.message).toContain("traces/a -> forward/ab -> traces/b -> forward/ba -> traces/a");
+  });
+
+  test("flags a pipeline that feeds itself through one connector", () => {
+    const issues = cycles(
+      config(`    traces:
+      receivers: [otlp, forward]
+      exporters: [forward, debug]`),
+    );
+    expect(issues).toHaveLength(1);
+    expect(issues[0].message).toContain("traces -> forward -> traces");
+  });
+
+  test("reports one cycle per group of pipelines, however many paths it holds", () => {
+    const issues = cycles(
+      config(`    traces/a:
+      receivers: [otlp, forward/2]
+      exporters: [forward]
+    traces/b:
+      receivers: [forward]
+      exporters: [forward/2]
+    traces/c:
+      receivers: [forward]
+      exporters: [forward/2]`),
+    );
+    expect(issues.map((i) => i.pipeline)).toEqual(["traces/a"]);
+  });
+
+  test("a fan-out with no way back is not a cycle", () => {
+    expect(
+      cycles(
+        config(`    traces:
+      receivers: [otlp]
+      exporters: [forward, spanmetrics]
+    traces/2:
+      receivers: [forward]
+      exporters: [debug]
+    metrics:
+      receivers: [spanmetrics]
+      exporters: [debug]`),
+      ),
+    ).toEqual([]);
+  });
+
+  test("an edge the connector cannot make does not close a cycle", () => {
+    // spanmetrics only goes traces to metrics, so metrics -> spanmetrics -> traces is no edge (OTEL112 reports it).
+    expect(
+      cycles(
+        config(`    traces:
+      receivers: [otlp, spanmetrics]
+      exporters: [spanmetrics]
+    metrics:
+      receivers: [spanmetrics]
+      exporters: [debug]`),
+      ),
+    ).toEqual([]);
+  });
+});
+
+describe("OTEL114 connector id collisions", () => {
+  test("flags a connector that shares its id with an exporter", () => {
+    const issues = validateCollectorConfig({
+      receivers: { otlp: {} },
+      exporters: { "forward/x": {}, debug: {} },
+      connectors: { "forward/x": {} },
+      service: { pipelines: { traces: { receivers: ["otlp"], exporters: ["debug"] } } },
+    }).filter((i) => i.code === "OTEL114");
+    expect(issues).toHaveLength(1);
+    expect(issues[0].component).toBe("forward/x");
+    expect(issues[0].message).toContain("declared exporter");
+  });
+
+  test("names the receiver in the message", () => {
+    const [issue] = validateCollectorConfig(load(fixture("otel114-fail.yaml")) as CollectorConfig);
+    expect(issue.message).toContain('connector "datadog" has the same id as a declared receiver');
+  });
+});
+
+describe("OTEL115 routing targets", () => {
+  const routes = (c: CollectorConfig) => validateCollectorConfig(c).filter((i) => i.code === "OTEL115");
+
+  test("names where the target came from", () => {
+    const [issue] = routes(load(fixture("otel115-fail.yaml")) as CollectorConfig);
+    expect(issue).toMatchObject({ pipeline: "traces/other", component: "routing" });
+    expect(issue.message).toContain("(default_pipelines)");
+    expect(issue.message).toContain("does not list");
+  });
+
+  test("flags a target pipeline that does not exist, once however often it is named", () => {
+    const config = load(fixture("otel115-pass.yaml")) as any;
+    config.connectors.routing.table.push(
+      { statement: 'route() where attributes["tenant"] == "b"', pipelines: ["traces/missing"] },
+      { statement: 'route() where attributes["tenant"] == "c"', pipelines: ["traces/missing"] },
+    );
+    const issues = routes(config);
+    expect(issues).toHaveLength(1);
+    expect(issues[0].message).toContain('"traces/missing" (table[1].pipelines), which is not declared');
+  });
+
+  test("checks named routing connectors and leaves other connectors alone", () => {
+    const issues = routes({
+      receivers: { otlp: {} },
+      exporters: { debug: {} },
+      connectors: {
+        "routing/tenants": { table: [{ pipelines: ["traces/nowhere"] }] },
+        "forward": { table: [{ pipelines: ["traces/nowhere"] }] },
+      },
+      service: {
+        pipelines: {
+          traces: { receivers: ["otlp"], exporters: ["routing/tenants", "forward"] },
+          "traces/out": { receivers: ["routing/tenants", "forward"], exporters: ["debug"] },
+        },
+      },
+    });
+    expect(issues.map((i) => i.component)).toEqual(["routing/tenants"]);
+  });
+});

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

@@ -10,6 +10,11 @@ import { otel107 } from "./otel107";
 import { otel108 } from "./otel108";
 import { otel109 } from "./otel109";
 import { otel112 } from "./otel112";
+import { otel113 } from "./otel113";
+import { otel114 } from "./otel114";
+import { otel115 } from "./otel115";
+import { otel116 } from "./otel116";
+import { otel117 } from "./otel117";
 
 export const postSynthChecks: PostSynthCheck[] = [
   otel101,
@@ -22,4 +27,9 @@ export const postSynthChecks: PostSynthCheck[] = [
   otel108,
   otel109,
   otel112,
+  otel113,
+  otel114,
+  otel115,
+  otel116,
+  otel117,
 ];