@intentius/chant-lexicon-otel 0.124.46 → 0.124.49

package/src/clickhouse-tables.ts

@@ -0,0 +1,223 @@
+/**
+ * The ClickHouse tables a `clickhouse` exporter writes (#4397), read from its
+ * config the way the exporter reads it at `COLLECTOR_PIN` (contrib v0.130.0).
+ * OTEL129 and the otel lexicon's `workspaceLinks` hook share this, so the
+ * check in one build root and the link across workspace members agree on
+ * which tables and columns an exporter needs.
+ *
+ * Sources in opentelemetry-collector-contrib at v0.130.0,
+ * `exporter/clickhouseexporter/`:
+ *
+ * - Default names: `createDefaultConfig` and `buildMetricTableNames` in
+ *   `config.go`. The exponential histogram table is
+ *   `otel_metrics_exponential_histogram` there; the README says
+ *   `otel_metrics_exp_histogram`, and the code is what runs.
+ * - Database: `Config.database()` in `config.go`. `database` wins unless it
+ *   is `default`, then the endpoint DSN's database, then `default`.
+ * - Columns: the column lists of the insert statements in
+ *   `internal/sqltemplates/*_insert.sql`. A `Nested` field such as
+ *   `Events.Timestamp` is listed under its column, `Events`.
+ * - Which tables a signal touches: each signal's exporter writes only its own
+ *   tables (`exporter_logs.go`, `exporter_traces.go`, `exporter_metrics.go`),
+ *   and only when a pipeline of that signal uses the exporter.
+ * - `create_schema` defaults to true and makes the exporter run
+ *   `CREATE TABLE IF NOT EXISTS` for its tables at start.
+ *
+ * The trace-id lookup table and its materialized view, which the traces
+ * exporter creates beside the traces table when `create_schema` is true, are
+ * not written by the exporter: the view fills the table from the traces
+ * table's inserts. They are not part of what an exporter needs here.
+ */
+
+import type { CollectorConfig } from "./model";
+import { parseComponentId, pipelineSignal } from "./model";
+
+/** One table an exporter writes. */
+export interface ClickHouseExporterTable {
+  /** The signal whose pipeline writes it. */
+  signal: "logs" | "traces" | "metrics";
+  /** The config key that names it: `logs_table_name`, `metrics_tables.gauge.name`. */
+  key: string;
+  /** The table, as the exporter resolves it. */
+  name: string;
+  /** The columns its insert statement names. */
+  columns: readonly string[];
+}
+
+/** What one `clickhouse` exporter writes. */
+export interface ClickHouseExporterTargets {
+  /** The exporter's id: `clickhouse` or `clickhouse/<name>`. */
+  id: string;
+  database: string;
+  /** Whether the exporter creates its database and tables at start (`create_schema`, default true). */
+  createSchema: boolean;
+  tables: ClickHouseExporterTable[];
+  /** Values chant can't read without the environment, such as `${env:CH_DB}`: the tables they name are left out. */
+  unread: string[];
+}
+
+const METRIC_HEAD = [
+  "ResourceAttributes",
+  "ResourceSchemaUrl",
+  "ScopeName",
+  "ScopeVersion",
+  "ScopeAttributes",
+  "ScopeDroppedAttrCount",
+  "ScopeSchemaUrl",
+  "ServiceName",
+  "MetricName",
+  "MetricDescription",
+  "MetricUnit",
+  "Attributes",
+  "StartTimeUnix",
+  "TimeUnix",
+] as const;
+
+/** The columns each insert statement names, at v0.130.0. */
+export const CLICKHOUSE_EXPORTER_COLUMNS = {
+  logs: [
+    "Timestamp",
+    "TraceId",
+    "SpanId",
+    "TraceFlags",
+    "SeverityText",
+    "SeverityNumber",
+    "ServiceName",
+    "Body",
+    "ResourceSchemaUrl",
+    "ResourceAttributes",
+    "ScopeSchemaUrl",
+    "ScopeName",
+    "ScopeVersion",
+    "ScopeAttributes",
+    "LogAttributes",
+  ],
+  traces: [
+    "Timestamp",
+    "TraceId",
+    "SpanId",
+    "ParentSpanId",
+    "TraceState",
+    "SpanName",
+    "SpanKind",
+    "ServiceName",
+    "ResourceAttributes",
+    "ScopeName",
+    "ScopeVersion",
+    "SpanAttributes",
+    "Duration",
+    "StatusCode",
+    "StatusMessage",
+    "Events",
+    "Links",
+  ],
+  gauge: [...METRIC_HEAD, "Value", "Flags", "Exemplars"],
+  sum: [...METRIC_HEAD, "Value", "Flags", "Exemplars", "AggregationTemporality", "IsMonotonic"],
+  summary: [...METRIC_HEAD, "Count", "Sum", "ValueAtQuantiles", "Flags"],
+  histogram: [...METRIC_HEAD, "Count", "Sum", "BucketCounts", "ExplicitBounds", "Exemplars", "Flags", "Min", "Max", "AggregationTemporality"],
+  exponential_histogram: [
+    ...METRIC_HEAD,
+    "Count",
+    "Sum",
+    "Scale",
+    "ZeroCount",
+    "PositiveOffset",
+    "PositiveBucketCounts",
+    "NegativeOffset",
+    "NegativeBucketCounts",
+    "Exemplars",
+    "Flags",
+    "Min",
+    "Max",
+    "AggregationTemporality",
+  ],
+} as const satisfies Record<string, readonly string[]>;
+
+/** The metric types in `metrics_tables`, with the suffix each default name takes. */
+const METRIC_TYPES = [
+  ["gauge", "_gauge"],
+  ["sum", "_sum"],
+  ["summary", "_summary"],
+  ["histogram", "_histogram"],
+  ["exponential_histogram", "_exponential_histogram"],
+] as const;
+
+const DEFAULT_DATABASE = "default";
+const DEFAULT_METRICS_PREFIX = "otel_metrics";
+
+const isRecord = (v: unknown): v is Record<string, unknown> => typeof v === "object" && v !== null && !Array.isArray(v);
+const str = (v: unknown): string | undefined => (typeof v === "string" && v !== "" ? v : undefined);
+/** A value the collector expands from the environment or another config source. */
+const expanded = (v: string) => v.includes("${");
+
+/** The database in the endpoint DSN's path, or undefined when it has none or can't be read. */
+function dsnDatabase(endpoint: string | undefined): string | undefined {
+  if (!endpoint || expanded(endpoint)) return undefined;
+  try {
+    const path = new URL(endpoint).pathname.replace(/^\/+/, "");
+    return path === "" ? undefined : decodeURIComponent(path);
+  } catch {
+    return undefined;
+  }
+}
+
+/** The signals whose pipelines list exporter `id`. */
+export function exporterSignals(config: CollectorConfig, id: string): Set<string> {
+  const out = new Set<string>();
+  for (const [pid, p] of Object.entries(config.service?.pipelines ?? {})) {
+    const exporters = isRecord(p) && Array.isArray(p.exporters) ? p.exporters : [];
+    if (exporters.includes(id)) out.add(pipelineSignal(pid));
+  }
+  return out;
+}
+
+/**
+ * The tables one `clickhouse` exporter writes, for the signals whose
+ * pipelines use it. `raw` is its config block.
+ */
+export function clickhouseExporterTargets(id: string, raw: unknown, signals: ReadonlySet<string>): ClickHouseExporterTargets {
+  const c = isRecord(raw) ? raw : {};
+  const unread: string[] = [];
+
+  let database = DEFAULT_DATABASE;
+  const configured = str(c.database);
+  if (configured && expanded(configured)) unread.push(`database ${configured}`);
+  else if (configured && configured !== DEFAULT_DATABASE) database = configured;
+  else {
+    const endpoint = str(c.endpoint);
+    if (endpoint && expanded(endpoint)) unread.push(`endpoint ${endpoint}, whose path may name the database`);
+    database = dsnDatabase(endpoint) ?? DEFAULT_DATABASE;
+  }
+  if (unread.length > 0) return { id, database, createSchema: c.create_schema !== false, tables: [], unread };
+
+  const tables: ClickHouseExporterTable[] = [];
+  const add = (signal: ClickHouseExporterTable["signal"], key: string, name: string, columns: readonly string[]) => {
+    if (expanded(name)) unread.push(`${key} ${name}`);
+    else tables.push({ signal, key, name, columns });
+  };
+  if (signals.has("logs")) add("logs", "logs_table_name", str(c.logs_table_name) ?? "otel_logs", CLICKHOUSE_EXPORTER_COLUMNS.logs);
+  if (signals.has("traces")) add("traces", "traces_table_name", str(c.traces_table_name) ?? "otel_traces", CLICKHOUSE_EXPORTER_COLUMNS.traces);
+  if (signals.has("metrics")) {
+    const mt = isRecord(c.metrics_tables) ? c.metrics_tables : {};
+    const nameOf = (type: string) => (isRecord(mt[type]) ? str((mt[type] as Record<string, unknown>).name) : undefined);
+    // The deprecated metrics_table_name is a prefix, used only when no metrics_tables name is set.
+    const anySet = METRIC_TYPES.some(([type]) => nameOf(type) !== undefined);
+    const prefix = !anySet ? (str(c.metrics_table_name) ?? DEFAULT_METRICS_PREFIX) : DEFAULT_METRICS_PREFIX;
+    for (const [type, suffix] of METRIC_TYPES) {
+      add("metrics", `metrics_tables.${type}.name`, nameOf(type) ?? `${prefix}${suffix}`, CLICKHOUSE_EXPORTER_COLUMNS[type]);
+    }
+  }
+  return { id, database, createSchema: c.create_schema !== false, tables, unread };
+}
+
+/** Every `clickhouse` exporter a pipeline uses in `config`, with what it writes. */
+export function clickhouseExportersOf(config: CollectorConfig): ClickHouseExporterTargets[] {
+  const out: ClickHouseExporterTargets[] = [];
+  for (const [id, raw] of Object.entries(config.exporters ?? {})) {
+    if (parseComponentId(id)?.type !== "clickhouse") continue;
+    const signals = exporterSignals(config, id);
+    if (signals.size === 0) continue;
+    out.push(clickhouseExporterTargets(id, raw, signals));
+  }
+  return out;
+}

package/src/codegen/docs.ts

@@ -59,8 +59,10 @@ on the same address (OTEL117), and a literal credential in source (OTEL002)
 or in the config (OTEL120). Others report deprecated fields (OTEL119),
 credentials sent in plaintext (OTEL121), zpages or pprof off loopback
 (OTEL122), detailed debug output beside a backend (OTEL123), delivery and
-batching settings (OTEL124, OTEL125), and k8sattributes fields or
-resourcedetection detectors the collector doesn't know (OTEL126, OTEL127). In
+batching settings (OTEL124, OTEL125), k8sattributes fields or
+resourcedetection detectors the collector doesn't know (OTEL126, OTEL127),
+and, when the project declares a \`Distribution\`, a component the config uses
+that the distribution doesn't build (OTEL128). In
 a build that stamps telemetry attribution, OTEL118 reports a processor that can
 drop or overwrite one of the attribution's resource attributes.
 `;

package/src/codegen/generate.ts

@@ -1,50 +1,126 @@
 /**
- * The otel lexicon's "generation" step.
+ * The otel lexicon's generation step (#3361).
  *
- * There is no upstream schema to fetch: the collector defines each
- * component's config as a Go struct, and publishes no machine-readable schema
- * for the set as a whole. The built-in types are written by hand against the
- * collector release named in `COLLECTOR_PIN` (src/define.ts), and this step
- * derives the registry from them, so the packaged `dist/meta.json` can never
- * disagree with the classes the package exports.
+ * The built-in components' config types are generated from upstream
+ * `config.schema.yaml`, the documents `schemagen` writes next to each
+ * component's `config.go`, at the collector-contrib release `COLLECTOR_PIN`
+ * names and scoped by the `otelcol-contrib` distribution manifest. Generation
+ * reads the committed snapshot (`src/spec/otel-schemas.snapshot.json`, refreshed
+ * by `just snapshot`), refuses one that does not match `OTEL_SPEC_PIN`, and
+ * writes, into the gitignored `src/generated/`:
+ *
+ * - `index.ts`: a type alias per schema definition the built-ins reach, and
+ *   `<ClassName>SchemaConfig` for each built-in that has a schema. The
+ *   hand-written `defineBuiltin` files build their config types on these,
+ *   overlaying only what a schema lacks (see `src/components/overlay.ts`);
+ * - `properties.json`: each built-in's property tree with upstream's
+ *   descriptions, for LSP completion and hover;
+ * - `lexicon-otel.json`: the registry, derived from the exported classes.
+ *
+ * A built-in with no upstream schema (`forward`, which has no config) keeps its
+ * hand-written type.
  */
 
 import { dirname, join } from "path";
 import { fileURLToPath } from "url";
 import { mkdirSync, writeFileSync } from "fs";
 import type { GenerateResult } from "@intentius/chant/codegen/generate";
-import { BUILTIN_CATALOG, lexiconRegistry } from "../catalog";
+import { loadSnapshot } from "../spec/snapshot";
+import { assertPinnedSnapshot, assertSnapshotVersions } from "../spec/pin";
+import { generateTypes, propertyDocs, type PropertyDoc } from "../spec/parse";
+import { BUILTIN_SPECS } from "../spec/builtins";
+import type { OtelSpecSnapshot } from "../spec/fetch";
 
 export type { GenerateResult };
 
 /** The packaged types entry re-exports the compiled declarations, which carry every config type. */
-const TYPES_DTS = `// The otel lexicon's entity classes and config types are hand-written in
-// src/ and compiled to dist/index.d.ts; this entry re-exports them.
+const TYPES_DTS = `// The otel lexicon's entity classes and config types are compiled to
+// dist/index.d.ts (config types generated from upstream config.schema.yaml);
+// this entry re-exports them.
 export * from "../index";
 `;
 
-export async function generate(opts?: { verbose?: boolean; force?: boolean }): Promise<GenerateResult> {
+/** The upstream schema document behind each built-in, by class name, from the contrib index. */
+export function builtinSchemaDocs(snapshot: OtelSpecSnapshot): Map<string, string> {
+  const out = new Map<string, string>();
+  const index = snapshot.distributions["otelcol-contrib"];
+  for (const b of BUILTIN_SPECS) {
+    const hit = index.find((c) => c.kind === b.kind && (c.type === b.type || c.deprecatedType === b.type));
+    if (hit?.schema && snapshot.schemas[hit.schema]) out.set(b.className, hit.schema);
+  }
+  return out;
+}
+
+export interface OtelGenerated extends GenerateResult {
+  /** Built-in class name → its property tree. */
+  propertiesJSON: string;
+}
+
+export async function generate(opts?: { verbose?: boolean; force?: boolean }): Promise<OtelGenerated> {
+  // The registry is derived from the classes, which import the generated
+  // types; types are erased at runtime, so this import does not need them.
+  const { BUILTIN_CATALOG, lexiconRegistry } = await import("../catalog");
+  const snapshot = loadSnapshot();
+  assertSnapshotVersions(snapshot.versions);
+  assertPinnedSnapshot(snapshot);
+
+  const roots = builtinSchemaDocs(snapshot);
+  const generated = generateTypes(snapshot.schemas, [...new Set(roots.values())]);
+  const aliases = [...roots]
+    .sort(([a], [b]) => a.localeCompare(b))
+    .map(([className, doc]) => `/** \`${className}\`'s config, from \`${doc}\`. */\nexport type ${className}SchemaConfig = ${generated.roots.get(doc)};\n`)
+    .join("\n");
+
+  const unresolved = [...generated.unresolved.keys()].sort();
+  const indexTS = [
+    "// Generated by `npm run generate` from src/spec/otel-schemas.snapshot.json. Do not edit.",
+    `// Versions: ${Object.entries(snapshot.versions).map(([k, v]) => `${k} ${v}`).join(", ")}.`,
+    ...(unresolved.length > 0
+      ? ["// Upstream publishes no schema for these $refs, so they are typed `unknown`:", ...unresolved.map((u) => `//   ${u}`)]
+      : []),
+    "",
+    'import type { Duration } from "../components/common";',
+    "",
+    generated.declarations,
+    "// ── Built-in config types ──────────────────────────────────────────",
+    "",
+    aliases,
+  ].join("\n");
+
+  const properties: Record<string, Record<string, PropertyDoc>> = {};
+  let propertyCount = 0;
+  for (const [className, doc] of [...roots].sort(([a], [b]) => a.localeCompare(b))) {
+    properties[className] = propertyDocs(snapshot.schemas, doc);
+    propertyCount += Object.keys(properties[className]).length;
+  }
+
   const registry = lexiconRegistry();
-  const lexiconJSON = `${JSON.stringify(registry, null, 2)}\n`;
-  const components = BUILTIN_CATALOG.filter((c) => c.type !== undefined).length;
   if (opts?.verbose) {
-    console.error(`otel: ${components} built-in components, plus Pipeline and Service (${BUILTIN_CATALOG.length} entities)`);
+    const components = BUILTIN_CATALOG.filter((c) => c.type !== undefined).length;
+    console.error(
+      `otel: ${components} built-in components, ${roots.size} typed from upstream config.schema.yaml ` +
+        `(${snapshot.versions["otelcol-contrib"]}), plus Pipeline and Service (${BUILTIN_CATALOG.length} entities)`,
+    );
+    if (unresolved.length > 0) console.error(`otel: ${unresolved.length} upstream $refs have no schema and are typed unknown`);
   }
   return {
-    lexiconJSON,
+    lexiconJSON: `${JSON.stringify(registry, null, 2)}\n`,
     typesDTS: TYPES_DTS,
-    indexTS: "",
+    indexTS,
+    propertiesJSON: `${JSON.stringify(properties)}\n`,
     resources: BUILTIN_CATALOG.length,
-    properties: 0,
+    properties: propertyCount,
     enums: 0,
     warnings: [],
   };
 }
 
-/** Write the registry to src/generated/lexicon-otel.json, for tools that read it from there. */
-export function writeGeneratedFiles(result: GenerateResult): void {
+/** Write the generated files to src/generated/. */
+export function writeGeneratedFiles(result: OtelGenerated): void {
   const pkgDir = dirname(dirname(dirname(fileURLToPath(import.meta.url))));
   const dir = join(pkgDir, "src", "generated");
   mkdirSync(dir, { recursive: true });
   writeFileSync(join(dir, "lexicon-otel.json"), result.lexiconJSON);
+  writeFileSync(join(dir, "index.ts"), result.indexTS);
+  writeFileSync(join(dir, "properties.json"), result.propertiesJSON);
 }

package/src/components/common.ts

@@ -176,8 +176,10 @@ export interface QueueSettings {
 }
 
 /** Problems in the `sending_queue` of an exporter's `exporterhelper` settings. */
-export function queueIssues(c: ExporterHelperSettings): string[] {
-  const q = c.sending_queue;
+export function queueIssues(c: { sending_queue?: unknown }): string[] {
+  // `blocking` is not an upstream field; reading it through the hand-written
+  // shape is how a config that sets it anyway gets told so.
+  const q = c.sending_queue as QueueSettings | null | undefined;
   if (!q) return [];
   const issues: string[] = [];
   if (q.blocking !== undefined) {

package/src/components/connectors.ts

@@ -9,8 +9,9 @@
  */
 
 import { defineBuiltin } from "../define";
+import type { Overlay, Require } from "./overlay";
+import type { CountConnectorSchemaConfig, RoutingConnectorSchemaConfig, ServiceGraphConnectorSchemaConfig, SignalToMetricsConnectorSchemaConfig, SpanMetricsConnectorSchemaConfig, SumConnectorSchemaConfig } from "../generated/index";
 import type { ConnectorSignalPair } from "../model";
-import type { Duration } from "./common";
 
 const SAME_SIGNAL: ConnectorSignalPair[] = [
   { from: "traces", to: "traces" },
@@ -27,39 +28,7 @@ export interface SpanMetricsDimension {
   default?: string;
 }
 
-export interface SpanMetricsConnectorConfig {
-  /** Extra dimensions on every metric, beyond service.name, span.name, span.kind and status.code. */
-  dimensions?: SpanMetricsDimension[];
-  /** Extra dimensions on the calls metric only. */
-  calls_dimensions?: SpanMetricsDimension[];
-  /** Default dimensions to leave out. */
-  exclude_dimensions?: string[];
-  resource_metrics_cache_size?: number;
-  /** Resource attributes that key the metrics' resource, so a restart doesn't start a new series. */
-  resource_metrics_key_attributes?: string[];
-  aggregation_temporality?: "AGGREGATION_TEMPORALITY_CUMULATIVE" | "AGGREGATION_TEMPORALITY_DELTA";
-  histogram?: {
-    disable?: boolean;
-    unit?: "ms" | "s";
-    /** Explicit bucket boundaries. Set this or `exponential`, not both. */
-    explicit?: { buckets?: Duration[] };
-    exponential?: { max_size?: number };
-    /** Extra dimensions on the duration histogram only. */
-    dimensions?: SpanMetricsDimension[];
-  };
-  /** How often metrics are emitted (default 60s). */
-  metrics_flush_interval?: Duration;
-  /** Drop a series not updated for this long. */
-  metrics_expiration?: Duration;
-  metric_timestamp_cache_size?: number;
-  /** Prefix for the emitted metric names (default `traces.span.metrics`). */
-  namespace?: string;
-  exemplars?: { enabled?: boolean; max_per_data_point?: number };
-  /** Also count span events. Needs `dimensions` when enabled. */
-  events?: { enabled?: boolean; dimensions?: SpanMetricsDimension[] };
-  include_instrumentation_scope?: string[];
-  aggregation_cardinality_limit?: number;
-}
+export type SpanMetricsConnectorConfig = SpanMetricsConnectorSchemaConfig;
 
 /** Turns spans into request, error and duration (RED) metrics. */
 export const SpanMetricsConnector = defineBuiltin<SpanMetricsConnectorConfig, "connector", "spanmetrics">({
@@ -77,6 +46,8 @@ export const SpanMetricsConnector = defineBuiltin<SpanMetricsConnectorConfig, "c
     }
     const reserved = new Set(["service.name", "span.name", "span.kind", "status.code"]);
     for (const d of c.dimensions ?? []) {
+      // A dimension names one attribute or matches several by `glob`.
+      if (d.name === undefined) continue;
       if (reserved.has(d.name)) problems.push(`dimensions: "${d.name}" is already a default dimension`);
       reserved.add(d.name);
     }
@@ -86,21 +57,7 @@ export const SpanMetricsConnector = defineBuiltin<SpanMetricsConnectorConfig, "c
 
 // ── servicegraph ─────────────────────────────────────────────────────
 
-export interface ServiceGraphConnectorConfig {
-  latency_histogram_buckets?: Duration[];
-  /** Span attributes added as dimensions on the edge metrics. */
-  dimensions?: string[];
-  /** How long an unpaired client or server span waits for its other half. */
-  store?: { ttl?: Duration; max_items?: number };
-  cache_loop?: Duration;
-  store_expiration_loop?: Duration;
-  /** Attributes that name the peer when only one side of a call is instrumented. */
-  virtual_node_peer_attributes?: string[];
-  virtual_node_extra_label?: boolean;
-  metrics_flush_interval?: Duration;
-  /** Attributes that name the database for a database call edge. */
-  database_name_attributes?: string[];
-}
+export type ServiceGraphConnectorConfig = ServiceGraphConnectorSchemaConfig;
 
 /** Builds service-to-service edge metrics from paired client and server spans. */
 export const ServiceGraphConnector = defineBuiltin<ServiceGraphConnectorConfig, "connector", "servicegraph">({
@@ -113,7 +70,12 @@ export const ServiceGraphConnector = defineBuiltin<ServiceGraphConnectorConfig,
 // ── routing ──────────────────────────────────────────────────────────
 
 export interface RoutingTableItem {
-  /** The OTTL context the condition runs in. `request` routes on request metadata such as headers. */
+  /**
+   * The OTTL context the condition runs in. `request` routes on request
+   * metadata such as headers; it is deprecated since collector-contrib
+   * v0.156.0 for `otelcol.client.metadata[...]` and `otelcol.grpc.metadata[...]`
+   * paths, which work in every context.
+   */
   context?: "resource" | "span" | "metric" | "datapoint" | "log" | "request";
   /** An OTTL `route() where ...` statement. Set this or `condition`, not both. */
   statement?: string;
@@ -123,12 +85,8 @@ export interface RoutingTableItem {
   pipelines: string[];
 }
 
-export interface RoutingConnectorConfig {
-  table: RoutingTableItem[];
-  /** Pipelines for data no route matches. */
-  default_pipelines?: string[];
-  error_mode?: "ignore" | "silent" | "propagate";
-}
+/** The connector refuses to start with no routing table. */
+export type RoutingConnectorConfig = Require<RoutingConnectorSchemaConfig, "table">;
 
 /** Sends each item to the pipelines whose route matches it. */
 export const RoutingConnector = defineBuiltin<RoutingConnectorConfig, "connector", "routing">({
@@ -172,14 +130,7 @@ export interface CountMetricInfo {
 }
 
 /** Each key is the name of a metric to emit. */
-export interface CountConnectorConfig {
-  spans?: Record<string, CountMetricInfo>;
-  spanevents?: Record<string, CountMetricInfo>;
-  metrics?: Record<string, CountMetricInfo>;
-  datapoints?: Record<string, CountMetricInfo>;
-  logs?: Record<string, CountMetricInfo>;
-  profiles?: Record<string, CountMetricInfo>;
-}
+export type CountConnectorConfig = CountConnectorSchemaConfig;
 
 /** Counts spans, span events, metrics, data points or log records, as metrics. */
 export const CountConnector = defineBuiltin<CountConnectorConfig, "connector", "count">({
@@ -229,13 +180,7 @@ export interface SumMetricInfo {
  * while an exporter that needs cumulative input wants a `deltatocumulative`
  * processor in front of it.
  */
-export interface SumConnectorConfig {
-  spans?: Record<string, SumMetricInfo>;
-  spanevents?: Record<string, SumMetricInfo>;
-  metrics?: Record<string, SumMetricInfo>;
-  datapoints?: Record<string, SumMetricInfo>;
-  logs?: Record<string, SumMetricInfo>;
-}
+export type SumConnectorConfig = SumConnectorSchemaConfig;
 
 /** Sums a numeric attribute of spans, span events, data points or log records, as metrics. */
 export const SumConnector = defineBuiltin<SumConnectorConfig, "connector", "sum">({
@@ -383,12 +328,20 @@ export type SignalToMetricsMetric = SignalToMetricsMetricBase &
  * exporter that needs cumulative input (Prometheus remote write) wants a
  * `deltatocumulative` processor in front of it.
  */
-export interface SignalToMetricsConnectorConfig {
-  spans?: SignalToMetricsMetric[];
-  datapoints?: SignalToMetricsMetric[];
-  logs?: SignalToMetricsMetric[];
-  profiles?: SignalToMetricsMetric[];
-}
+/**
+ * Upstream writes a metric as one struct with `sum`, `gauge`, `histogram` and
+ * `exponential_histogram` all optional; the connector takes exactly one, so
+ * here each entry is a union with one metric type set.
+ */
+export type SignalToMetricsConnectorConfig = Overlay<
+  SignalToMetricsConnectorSchemaConfig,
+  {
+    spans?: SignalToMetricsMetric[];
+    datapoints?: SignalToMetricsMetric[];
+    logs?: SignalToMetricsMetric[];
+    profiles?: SignalToMetricsMetric[];
+  }
+>;
 
 /** One entry of a `signaltometrics` config, with where it sits. */
 export interface SignalToMetricsEntry {