@intentius/chant-lexicon-otel 0.124.46 → 0.124.48

package/README.md

@@ -23,7 +23,7 @@ export { otlp, batch, backend, traces };
 | connectors | spanmetrics, servicegraph, routing, forward, count, sum, signaltometrics |
 | extensions | health_check, pprof, zpages, k8s_leader_elector |
 
-The config types follow the collector-contrib release in `COLLECTOR_PIN`.
+The config types are generated from upstream `config.schema.yaml` at the collector-contrib release in `COLLECTOR_PIN` (v0.162.0), scoped by the `otelcol-contrib` distribution manifest, with hand-written overlays where a schema falls short. `coverageReport()` says which components of `otelcol-contrib` and `otelcol-k8s` are built in.
 
 Sampling and routing: `tail_sampling` takes its policies as a discriminated union (`status_code`, `latency`, `probabilistic`, `and`, `composite` and the rest), and `loadbalancing` takes a `static`, `dns`, `k8s` or `aws_cloud_map` resolver. Content handling: `filter`, `transform` (OTTL statement groups per context) and `redaction`. Cluster metrics: `k8s_cluster` and `kubeletstats`.
 
@@ -58,7 +58,7 @@ Each connector supports fixed signal pairs (`spanmetrics`: traces to metrics). O
 
 ## Checks
 
-OTEL001 and OTEL002 run on source (id syntax, literal credentials). OTEL101 to OTEL109 and OTEL112 to OTEL127 run after a build: undeclared or unused components (a connector must be on both sides), empty pipelines, extension wiring, `memory_limiter` placement, id syntax, each component's own config rules, duplicate ids, missing schema pins, connector signal pairs, cycles through connectors, connector ids shared with a receiver or exporter, `routing` targets that don't receive from the connector, metrics split by a per-request GenAI id or content key, two started components listening on the same address, fields deprecated before the pinned release, literal credentials in the config, credentials sent in plaintext, zpages or pprof off loopback, detailed debug output beside a backend, an exporter's queue or retries turned off, a remote OTLP exporter with no batching, and k8sattributes fields or resourcedetection detectors the collector doesn't know. OTEL118 runs only in a build that stamps telemetry attribution, and warns about a processor that can remove or replace one of the attribution's resource attributes.
+OTEL001 and OTEL002 run on source (id syntax, literal credentials). OTEL101 to OTEL109 and OTEL112 to OTEL128 run after a build: undeclared or unused components (a connector must be on both sides), empty pipelines, extension wiring, `memory_limiter` placement, id syntax, each component's own config rules, duplicate ids, missing schema pins, connector signal pairs, cycles through connectors, connector ids shared with a receiver or exporter, `routing` targets that don't receive from the connector, metrics split by a per-request GenAI id or content key, two started components listening on the same address, fields deprecated before the pinned release, literal credentials in the config, credentials sent in plaintext, zpages or pprof off loopback, detailed debug output beside a backend, an exporter's queue or retries turned off, a remote OTLP exporter with no batching, and k8sattributes fields or resourcedetection detectors the collector doesn't know. OTEL128 runs only when the project declares a `Distribution` (an ocb builder manifest), and reports a component the config uses that the distribution doesn't build. OTEL118 runs only in a build that stamps telemetry attribution, and warns about a processor that can remove or replace one of the attribution's resource attributes.
 
 ## Plain-data API
 

package/dist/build/capability-plugin.d.ts

@@ -0,0 +1,10 @@
+import type { BuildSpec } from "@intentius/chant/components/component";
+import { type CapabilityPlugin } from "@intentius/chant/components/capability-plugin";
+import { type OcbBuildInput } from "./ocb-build.js";
+export declare const OTEL_VERB_FAMILIES: {
+    readonly build: readonly ["ocb-build"];
+};
+export declare const otelCapabilityPlugin: CapabilityPlugin;
+/** A component's `build` field for `ocb-build`: `build: ocbBuild({ config: "dist/builder-config.yaml" })`. */
+export declare function ocbBuild(input: OcbBuildInput): BuildSpec;
+//# sourceMappingURL=capability-plugin.d.ts.map

package/dist/build/capability-plugin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"capability-plugin.d.ts","sourceRoot":"","sources":["../../src/build/capability-plugin.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,uCAAuC,CAAC;AACvE,OAAO,EAAqB,KAAK,gBAAgB,EAAE,MAAM,+CAA+C,CAAC;AACzG,OAAO,EAAsB,KAAK,aAAa,EAAE,MAAM,aAAa,CAAC;AAErE,eAAO,MAAM,kBAAkB;aAC7B,KAAK,YAAG,WAAW;CACX,CAAC;AAEX,eAAO,MAAM,oBAAoB,EAAE,gBASlC,CAAC;AAEF,8GAA8G;AAC9G,wBAAgB,QAAQ,CAAC,KAAK,EAAE,aAAa,GAAG,SAAS,CAExD"}

package/dist/build/capability-plugin.js

@@ -0,0 +1,19 @@
+import { ownPackageVersion } from "@intentius/chant/components/capability-plugin";
+import { ocbBuildCapability } from "./ocb-build.js";
+export const OTEL_VERB_FAMILIES = {
+    build: ["ocb-build"],
+};
+export const otelCapabilityPlugin = {
+    name: "otel",
+    version: ownPackageVersion(import.meta.url),
+    capabilities() {
+        return [ocbBuildCapability];
+    },
+    families() {
+        return OTEL_VERB_FAMILIES;
+    },
+};
+/** A component's `build` field for `ocb-build`: `build: ocbBuild({ config: "dist/builder-config.yaml" })`. */
+export function ocbBuild(input) {
+    return { kind: "ocb-build", ...input };
+}

package/dist/build/ocb-build.d.ts

@@ -0,0 +1,38 @@
+/**
+ * `ocb-build`, the build verb for a custom collector (#3374): run the
+ * OpenTelemetry Collector Builder over the `builder-config.yaml` a
+ * `Distribution` writes, and hand the directory it generates on as a `dir`
+ * artifact. That directory holds the generated sources and the binary, so a
+ * `docker-build` step whose `context` is the directory (with a Dockerfile the
+ * component provides) builds the collector image, and the rest of the
+ * component's path (SBOM, sign, attest, publish by digest, deploy) is the
+ * one any image takes.
+ *
+ * The output directory is the manifest's `dist.output_path`. ocb's own
+ * default is a fresh temporary directory, which a later step could not name,
+ * so a manifest without one is refused before ocb runs.
+ */
+import type { Capability } from "@intentius/chant/components/capability";
+import { type ProcessRunner } from "@intentius/chant/components/verbs/process-runner";
+export interface OcbBuildInput {
+    /** The builder manifest, e.g. `dist/builder-config.yaml`. */
+    config: string;
+    /** The builder binary. Default: `ocb`. */
+    ocb?: string;
+    /** Generate the sources without compiling them (`--skip-compilation`). */
+    skipCompilation?: boolean;
+}
+export interface OcbBuildOutput {
+    /** The artifact kind: a directory, for `docker-build`'s `context`. */
+    kind: "dir";
+    /** The directory ocb wrote, the manifest's `dist.output_path` resolved against the manifest's directory. */
+    dir: string;
+    /** `sha256:` over the manifest's bytes: the same manifest names the same build. */
+    manifestDigest: string;
+}
+/** The output directory a manifest names, resolved the way ocb resolves it: relative to the working directory ocb runs in. */
+export declare function ocbOutputPath(manifestText: string, cwd: string): string | undefined;
+export declare function createOcbBuildCapability(runner?: ProcessRunner): Capability<OcbBuildInput, OcbBuildOutput>;
+/** Default `ocb-build` capability, backed by the real process runner. */
+export declare const ocbBuildCapability: Capability<OcbBuildInput, OcbBuildOutput>;
+//# sourceMappingURL=ocb-build.d.ts.map

package/dist/build/ocb-build.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ocb-build.d.ts","sourceRoot":"","sources":["../../src/build/ocb-build.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAMH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,wCAAwC,CAAC;AACzE,OAAO,EAAwC,KAAK,aAAa,EAAE,MAAM,kDAAkD,CAAC;AAE5H,MAAM,WAAW,aAAa;IAC5B,6DAA6D;IAC7D,MAAM,EAAE,MAAM,CAAC;IACf,0CAA0C;IAC1C,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,0EAA0E;IAC1E,eAAe,CAAC,EAAE,OAAO,CAAC;CAC3B;AAED,MAAM,WAAW,cAAc;IAC7B,sEAAsE;IACtE,IAAI,EAAE,KAAK,CAAC;IACZ,4GAA4G;IAC5G,GAAG,EAAE,MAAM,CAAC;IACZ,mFAAmF;IACnF,cAAc,EAAE,MAAM,CAAC;CACxB;AAED,8HAA8H;AAC9H,wBAAgB,aAAa,CAAC,YAAY,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAKnF;AAED,wBAAgB,wBAAwB,CAAC,MAAM,GAAE,aAAsC,GAAG,UAAU,CAAC,aAAa,EAAE,cAAc,CAAC,CAqBlI;AAED,yEAAyE;AACzE,eAAO,MAAM,kBAAkB,EAAE,UAAU,CAAC,aAAa,EAAE,cAAc,CAA8B,CAAC"}

package/dist/build/ocb-build.js

@@ -0,0 +1,49 @@
+/**
+ * `ocb-build`, the build verb for a custom collector (#3374): run the
+ * OpenTelemetry Collector Builder over the `builder-config.yaml` a
+ * `Distribution` writes, and hand the directory it generates on as a `dir`
+ * artifact. That directory holds the generated sources and the binary, so a
+ * `docker-build` step whose `context` is the directory (with a Dockerfile the
+ * component provides) builds the collector image, and the rest of the
+ * component's path (SBOM, sign, attest, publish by digest, deploy) is the
+ * one any image takes.
+ *
+ * The output directory is the manifest's `dist.output_path`. ocb's own
+ * default is a fresh temporary directory, which a later step could not name,
+ * so a manifest without one is refused before ocb runs.
+ */
+import { readFileSync } from "node:fs";
+import { createHash } from "node:crypto";
+import { dirname, isAbsolute, resolve } from "node:path";
+import { load } from "js-yaml";
+import { defaultProcessRunner, q, requireTool } from "@intentius/chant/components/verbs/process-runner";
+/** The output directory a manifest names, resolved the way ocb resolves it: relative to the working directory ocb runs in. */
+export function ocbOutputPath(manifestText, cwd) {
+    const doc = load(manifestText);
+    const out = doc?.dist?.output_path;
+    if (typeof out !== "string" || out.trim() === "")
+        return undefined;
+    return isAbsolute(out) ? out : resolve(cwd, out);
+}
+export function createOcbBuildCapability(runner = defaultProcessRunner()) {
+    return {
+        kind: "ocb-build",
+        async run(_ctx, input) {
+            const text = readFileSync(input.config, "utf8");
+            // ocb resolves output_path against its working directory; run it in the manifest's.
+            const cwd = dirname(resolve(input.config));
+            const dir = ocbOutputPath(text, cwd);
+            if (!dir) {
+                throw new Error(`ocb-build: ${input.config} sets no dist.output_path, so ocb would write to a temporary directory no later step can name. Set dist.output_path on the Distribution.`);
+            }
+            const ocb = input.ocb ?? "ocb";
+            await requireTool(runner, ocb, "build a custom collector from a Distribution");
+            const flags = input.skipCompilation ? " --skip-compilation" : "";
+            await runner.run(`${q(ocb)} --config ${q(resolve(input.config))}${flags}`, { cwd });
+            const manifestDigest = `sha256:${createHash("sha256").update(text).digest("hex")}`;
+            return { kind: "dir", dir, manifestDigest };
+        },
+    };
+}
+/** Default `ocb-build` capability, backed by the real process runner. */
+export const ocbBuildCapability = createOcbBuildCapability();

package/dist/clickhouse-tables.d.ts

@@ -0,0 +1,73 @@
+/**
+ * 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.js";
+/** 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[];
+}
+/** The columns each insert statement names, at v0.130.0. */
+export declare const CLICKHOUSE_EXPORTER_COLUMNS: {
+    readonly logs: readonly ["Timestamp", "TraceId", "SpanId", "TraceFlags", "SeverityText", "SeverityNumber", "ServiceName", "Body", "ResourceSchemaUrl", "ResourceAttributes", "ScopeSchemaUrl", "ScopeName", "ScopeVersion", "ScopeAttributes", "LogAttributes"];
+    readonly traces: readonly ["Timestamp", "TraceId", "SpanId", "ParentSpanId", "TraceState", "SpanName", "SpanKind", "ServiceName", "ResourceAttributes", "ScopeName", "ScopeVersion", "SpanAttributes", "Duration", "StatusCode", "StatusMessage", "Events", "Links"];
+    readonly gauge: readonly ["ResourceAttributes", "ResourceSchemaUrl", "ScopeName", "ScopeVersion", "ScopeAttributes", "ScopeDroppedAttrCount", "ScopeSchemaUrl", "ServiceName", "MetricName", "MetricDescription", "MetricUnit", "Attributes", "StartTimeUnix", "TimeUnix", "Value", "Flags", "Exemplars"];
+    readonly sum: readonly ["ResourceAttributes", "ResourceSchemaUrl", "ScopeName", "ScopeVersion", "ScopeAttributes", "ScopeDroppedAttrCount", "ScopeSchemaUrl", "ServiceName", "MetricName", "MetricDescription", "MetricUnit", "Attributes", "StartTimeUnix", "TimeUnix", "Value", "Flags", "Exemplars", "AggregationTemporality", "IsMonotonic"];
+    readonly summary: readonly ["ResourceAttributes", "ResourceSchemaUrl", "ScopeName", "ScopeVersion", "ScopeAttributes", "ScopeDroppedAttrCount", "ScopeSchemaUrl", "ServiceName", "MetricName", "MetricDescription", "MetricUnit", "Attributes", "StartTimeUnix", "TimeUnix", "Count", "Sum", "ValueAtQuantiles", "Flags"];
+    readonly histogram: readonly ["ResourceAttributes", "ResourceSchemaUrl", "ScopeName", "ScopeVersion", "ScopeAttributes", "ScopeDroppedAttrCount", "ScopeSchemaUrl", "ServiceName", "MetricName", "MetricDescription", "MetricUnit", "Attributes", "StartTimeUnix", "TimeUnix", "Count", "Sum", "BucketCounts", "ExplicitBounds", "Exemplars", "Flags", "Min", "Max", "AggregationTemporality"];
+    readonly exponential_histogram: readonly ["ResourceAttributes", "ResourceSchemaUrl", "ScopeName", "ScopeVersion", "ScopeAttributes", "ScopeDroppedAttrCount", "ScopeSchemaUrl", "ServiceName", "MetricName", "MetricDescription", "MetricUnit", "Attributes", "StartTimeUnix", "TimeUnix", "Count", "Sum", "Scale", "ZeroCount", "PositiveOffset", "PositiveBucketCounts", "NegativeOffset", "NegativeBucketCounts", "Exemplars", "Flags", "Min", "Max", "AggregationTemporality"];
+};
+/** The signals whose pipelines list exporter `id`. */
+export declare function exporterSignals(config: CollectorConfig, id: string): Set<string>;
+/**
+ * The tables one `clickhouse` exporter writes, for the signals whose
+ * pipelines use it. `raw` is its config block.
+ */
+export declare function clickhouseExporterTargets(id: string, raw: unknown, signals: ReadonlySet<string>): ClickHouseExporterTargets;
+/** Every `clickhouse` exporter a pipeline uses in `config`, with what it writes. */
+export declare function clickhouseExportersOf(config: CollectorConfig): ClickHouseExporterTargets[];
+//# sourceMappingURL=clickhouse-tables.d.ts.map

package/dist/clickhouse-tables.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"clickhouse-tables.d.ts","sourceRoot":"","sources":["../src/clickhouse-tables.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AAEH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AAG/C,oCAAoC;AACpC,MAAM,WAAW,uBAAuB;IACtC,2CAA2C;IAC3C,MAAM,EAAE,MAAM,GAAG,QAAQ,GAAG,SAAS,CAAC;IACtC,oFAAoF;IACpF,GAAG,EAAE,MAAM,CAAC;IACZ,8CAA8C;IAC9C,IAAI,EAAE,MAAM,CAAC;IACb,8CAA8C;IAC9C,OAAO,EAAE,SAAS,MAAM,EAAE,CAAC;CAC5B;AAED,6CAA6C;AAC7C,MAAM,WAAW,yBAAyB;IACxC,8DAA8D;IAC9D,EAAE,EAAE,MAAM,CAAC;IACX,QAAQ,EAAE,MAAM,CAAC;IACjB,qGAAqG;IACrG,YAAY,EAAE,OAAO,CAAC;IACtB,MAAM,EAAE,uBAAuB,EAAE,CAAC;IAClC,kHAAkH;IAClH,MAAM,EAAE,MAAM,EAAE,CAAC;CAClB;AAmBD,4DAA4D;AAC5D,eAAO,MAAM,2BAA2B;;;;;;;;CAyDc,CAAC;AA8BvD,sDAAsD;AACtD,wBAAgB,eAAe,CAAC,MAAM,EAAE,eAAe,EAAE,EAAE,EAAE,MAAM,GAAG,GAAG,CAAC,MAAM,CAAC,CAOhF;AAED;;;GAGG;AACH,wBAAgB,yBAAyB,CAAC,EAAE,EAAE,MAAM,EAAE,GAAG,EAAE,OAAO,EAAE,OAAO,EAAE,WAAW,CAAC,MAAM,CAAC,GAAG,yBAAyB,CAiC3H;AAED,oFAAoF;AACpF,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,eAAe,GAAG,yBAAyB,EAAE,CAS1F"}

package/dist/clickhouse-tables.js

@@ -0,0 +1,199 @@
+/**
+ * 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 { parseComponentId, pipelineSignal } from "./model.js";
+const METRIC_HEAD = [
+    "ResourceAttributes",
+    "ResourceSchemaUrl",
+    "ScopeName",
+    "ScopeVersion",
+    "ScopeAttributes",
+    "ScopeDroppedAttrCount",
+    "ScopeSchemaUrl",
+    "ServiceName",
+    "MetricName",
+    "MetricDescription",
+    "MetricUnit",
+    "Attributes",
+    "StartTimeUnix",
+    "TimeUnix",
+];
+/** 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",
+    ],
+};
+/** 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"],
+];
+const DEFAULT_DATABASE = "default";
+const DEFAULT_METRICS_PREFIX = "otel_metrics";
+const isRecord = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
+const str = (v) => (typeof v === "string" && v !== "" ? v : undefined);
+/** A value the collector expands from the environment or another config source. */
+const expanded = (v) => v.includes("${");
+/** The database in the endpoint DSN's path, or undefined when it has none or can't be read. */
+function dsnDatabase(endpoint) {
+    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, id) {
+    const out = new Set();
+    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, raw, signals) {
+    const c = isRecord(raw) ? raw : {};
+    const unread = [];
+    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 = [];
+    const add = (signal, key, name, columns) => {
+        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) => (isRecord(mt[type]) ? str(mt[type].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) {
+    const out = [];
+    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/dist/codegen/docs.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"docs.d.ts","sourceRoot":"","sources":["../../src/codegen/docs.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAkFH,wBAAsB,YAAY,CAAC,IAAI,CAAC,EAAE;IAAE,OAAO,CAAC,EAAE,OAAO,CAAA;CAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAuB9E"}
+{"version":3,"file":"docs.d.ts","sourceRoot":"","sources":["../../src/codegen/docs.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAoFH,wBAAsB,YAAY,CAAC,IAAI,CAAC,EAAE;IAAE,OAAO,CAAC,EAAE,OAAO,CAAA;CAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAuB9E"}

package/dist/codegen/docs.js

@@ -56,8 +56,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/dist/codegen/generate.d.ts

@@ -1,19 +1,38 @@
 /**
- * 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 type { GenerateResult } from "@intentius/chant/codegen/generate";
+import type { OtelSpecSnapshot } from "../spec/fetch.js";
 export type { GenerateResult };
+/** The upstream schema document behind each built-in, by class name, from the contrib index. */
+export declare function builtinSchemaDocs(snapshot: OtelSpecSnapshot): Map<string, string>;
+export interface OtelGenerated extends GenerateResult {
+    /** Built-in class name → its property tree. */
+    propertiesJSON: string;
+}
 export declare function generate(opts?: {
     verbose?: boolean;
     force?: boolean;
-}): Promise<GenerateResult>;
-/** Write the registry to src/generated/lexicon-otel.json, for tools that read it from there. */
-export declare function writeGeneratedFiles(result: GenerateResult): void;
+}): Promise<OtelGenerated>;
+/** Write the generated files to src/generated/. */
+export declare function writeGeneratedFiles(result: OtelGenerated): void;
 //# sourceMappingURL=generate.d.ts.map

package/dist/codegen/generate.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"generate.d.ts","sourceRoot":"","sources":["../../src/codegen/generate.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAKH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,mCAAmC,CAAC;AAGxE,YAAY,EAAE,cAAc,EAAE,CAAC;AAQ/B,wBAAsB,QAAQ,CAAC,IAAI,CAAC,EAAE;IAAE,OAAO,CAAC,EAAE,OAAO,CAAC;IAAC,KAAK,CAAC,EAAE,OAAO,CAAA;CAAE,GAAG,OAAO,CAAC,cAAc,CAAC,CAgBrG;AAED,gGAAgG;AAChG,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,cAAc,GAAG,IAAI,CAKhE"}
+{"version":3,"file":"generate.d.ts","sourceRoot":"","sources":["../../src/codegen/generate.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAKH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,mCAAmC,CAAC;AAKxE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAC;AAEtD,YAAY,EAAE,cAAc,EAAE,CAAC;AAS/B,gGAAgG;AAChG,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,gBAAgB,GAAG,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAQjF;AAED,MAAM,WAAW,aAAc,SAAQ,cAAc;IACnD,+CAA+C;IAC/C,cAAc,EAAE,MAAM,CAAC;CACxB;AAED,wBAAsB,QAAQ,CAAC,IAAI,CAAC,EAAE;IAAE,OAAO,CAAC,EAAE,OAAO,CAAC;IAAC,KAAK,CAAC,EAAE,OAAO,CAAA;CAAE,GAAG,OAAO,CAAC,aAAa,CAAC,CAyDpG;AAED,mDAAmD;AACnD,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,aAAa,GAAG,IAAI,CAO/D"}

package/dist/codegen/generate.js

@@ -1,43 +1,108 @@
 /**
- * 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 { BUILTIN_CATALOG, lexiconRegistry } from "../catalog.js";
+import { loadSnapshot } from "../spec/snapshot.js";
+import { assertPinnedSnapshot, assertSnapshotVersions } from "../spec/pin.js";
+import { generateTypes, propertyDocs } from "../spec/parse.js";
+import { BUILTIN_SPECS } from "../spec/builtins.js";
 /** 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.js";
 `;
+/** The upstream schema document behind each built-in, by class name, from the contrib index. */
+export function builtinSchemaDocs(snapshot) {
+    const out = new Map();
+    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 async function generate(opts) {
+    // 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.js");
+    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.js";',
+        "",
+        generated.declarations,
+        "// ── Built-in config types ──────────────────────────────────────────",
+        "",
+        aliases,
+    ].join("\n");
+    const properties = {};
+    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. */
+/** Write the generated files to src/generated/. */
 export function writeGeneratedFiles(result) {
     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);
 }