@intentius/chant-lexicon-otel 0.124.46 → 0.124.48

package/src/components/receivers.ts

@@ -3,22 +3,13 @@
  */
 
 import { defineBuiltin } from "../define";
-import type { Duration, GRPCServerSettings, HTTPServerSettings, TLSClientSettings } from "./common";
+import type { Overlay, Require } from "./overlay";
+import type { FileLogReceiverSchemaConfig, HostMetricsReceiverSchemaConfig, OtlpReceiverSchemaConfig, PrometheusReceiverSchemaConfig } from "../generated/index";
+import type { Duration } from "./common";
 
 // ── otlp ─────────────────────────────────────────────────────────────
 
-export interface OtlpReceiverConfig {
-  protocols?: {
-    grpc?: GRPCServerSettings | null;
-    http?:
-      | (HTTPServerSettings & {
-          traces_url_path?: string;
-          metrics_url_path?: string;
-          logs_url_path?: string;
-        })
-      | null;
-  };
-}
+export type OtlpReceiverConfig = OtlpReceiverSchemaConfig;
 
 /** Receives OTLP over gRPC (default port 4317) and HTTP (default port 4318). */
 export const OtlpReceiver = defineBuiltin<OtlpReceiverConfig, "receiver", "otlp">({
@@ -154,21 +145,8 @@ export interface PrometheusScrapeConfig extends PrometheusProxySettings {
   metric_name_escaping_scheme?: "allow-utf-8" | "underscores" | "dots" | "values";
 }
 
-export interface PrometheusReceiverConfig {
-  config: {
-    global?: { scrape_interval?: Duration; scrape_timeout?: Duration; evaluation_interval?: Duration; external_labels?: Record<string, string> };
-    scrape_configs: PrometheusScrapeConfig[];
-  };
-  trim_metric_suffixes?: boolean;
-  use_start_time_metric?: boolean;
-  start_time_metric_regex?: string;
-  target_allocator?: {
-    endpoint: string;
-    interval?: Duration;
-    collector_id?: string;
-    tls?: TLSClientSettings;
-  };
-}
+/** The receiver refuses to start without a Prometheus `config`. */
+export type PrometheusReceiverConfig = Require<PrometheusReceiverSchemaConfig, "config">;
 
 /** Scrapes Prometheus endpoints with Prometheus's own scrape config. */
 export const PrometheusReceiver = defineBuiltin<PrometheusReceiverConfig, "receiver", "prometheus">({
@@ -179,6 +157,7 @@ export const PrometheusReceiver = defineBuiltin<PrometheusReceiverConfig, "recei
     const problems: string[] = [];
     const seen = new Set<string>();
     for (const job of c.config?.scrape_configs ?? []) {
+      if (job.job_name === undefined) continue;
       if (seen.has(job.job_name)) problems.push(`scrape job "${job.job_name}" is declared twice`);
       seen.add(job.job_name);
     }
@@ -188,7 +167,7 @@ export const PrometheusReceiver = defineBuiltin<PrometheusReceiverConfig, "recei
     return problems;
   },
   endpoints: (c) =>
-    (c.config?.scrape_configs ?? []).flatMap((job) => (job.static_configs ?? []).flatMap((s) => s.targets)),
+    (c.config?.scrape_configs ?? []).flatMap((job) => (job.static_configs ?? []).flatMap((s) => s.targets ?? [])),
 });
 
 // ── hostmetrics ──────────────────────────────────────────────────────
@@ -205,14 +184,16 @@ export type HostMetricsScraper =
   | "process"
   | "system";
 
-export interface HostMetricsReceiverConfig {
-  collection_interval?: Duration;
-  initial_delay?: Duration;
-  /** Host root when the collector runs in a container, e.g. `/hostfs`. */
-  root_path?: string;
-  /** Scraper name to its settings; `{}` enables a scraper with its defaults. */
-  scrapers: Partial<Record<HostMetricsScraper, Record<string, unknown>>>;
-}
+/**
+ * Upstream publishes no schema for the scraper packages
+ * (`internal/scraper/*scraper`), so `scrapers` is written here: scraper name
+ * to its settings, `{}` for a scraper's defaults. The receiver refuses to
+ * start with none.
+ */
+export type HostMetricsReceiverConfig = Overlay<
+  HostMetricsReceiverSchemaConfig,
+  { scrapers: Partial<Record<HostMetricsScraper, Record<string, unknown>>> }
+>;
 
 /** Scrapes CPU, memory, disk, filesystem, network and process metrics from the host. */
 export const HostMetricsReceiver = defineBuiltin<HostMetricsReceiverConfig, "receiver", "hostmetrics">({
@@ -232,29 +213,8 @@ export interface FileLogOperator {
   [key: string]: unknown;
 }
 
-export interface FileLogReceiverConfig {
-  include: string[];
-  exclude?: string[];
-  start_at?: "beginning" | "end";
-  include_file_name?: boolean;
-  include_file_path?: boolean;
-  include_file_name_resolved?: boolean;
-  include_file_path_resolved?: boolean;
-  poll_interval?: Duration;
-  max_concurrent_files?: number;
-  max_log_size?: string;
-  fingerprint_size?: string;
-  encoding?: string;
-  force_flush_period?: Duration;
-  delete_after_read?: boolean;
-  /** The id of a storage extension, so offsets survive a restart. */
-  storage?: string;
-  multiline?: { line_start_pattern?: string; line_end_pattern?: string; omit_pattern?: boolean };
-  operators?: FileLogOperator[];
-  attributes?: Record<string, string>;
-  resource?: Record<string, string>;
-  retry_on_failure?: { enabled?: boolean; initial_interval?: Duration; max_interval?: Duration; max_elapsed_time?: Duration };
-}
+/** The receiver refuses to start with no `include` pattern. */
+export type FileLogReceiverConfig = Require<FileLogReceiverSchemaConfig, "include">;
 
 /** Tails log files and parses them with stanza operators. */
 export const FileLogReceiver = defineBuiltin<FileLogReceiverConfig, "receiver", "filelog">({

package/src/components/sampling.ts

@@ -9,6 +9,8 @@
  */
 
 import { defineBuiltin } from "../define";
+import type { Overlay } from "./overlay";
+import type { LoadBalancingExporterSchemaConfig, ProbabilisticSamplerProcessorSchemaConfig, TailSamplingProcessorSchemaConfig } from "../generated/index";
 import type { Duration, ExporterHelperSettings, GRPCClientSettings } from "./common";
 
 // ── tail_sampling ────────────────────────────────────────────────────
@@ -167,19 +169,21 @@ export type TailSamplingPolicy = TailSamplingLeafPolicy | AndPolicy | DropPolicy
 
 export type TailSamplingPolicyType = TailSamplingPolicy["type"];
 
-export interface TailSamplingProcessorConfig {
-  /** How long after a trace's first span the decision is made. The collector's default is 30s; chant asks for it explicitly. */
-  decision_wait: Duration;
-  /** Policies, evaluated for every trace. A trace is sampled when any policy samples it and no `drop` policy drops it. */
-  policies: TailSamplingPolicy[];
-  num_traces?: number;
-  expected_new_traces_per_sec?: number;
-  decision_cache?: {
-    sampled_cache_size?: number;
-    non_sampled_cache_size?: number;
-  };
-  sample_on_first_match?: boolean;
-}
+/**
+ * Upstream writes a policy as one struct with every policy kind's settings as
+ * optional members beside `type`. Here a policy is a union tagged by `type`,
+ * so the settings the type needs are required and the checks below narrow on
+ * it. chant also asks for `decision_wait` explicitly.
+ */
+export type TailSamplingProcessorConfig = Overlay<
+  TailSamplingProcessorSchemaConfig,
+  {
+    /** How long after a trace's first span the decision is made. The collector's default is 30s; chant asks for it explicitly. */
+    decision_wait: Duration;
+    /** Policies, evaluated for every trace. A trace is sampled when any policy samples it and no `drop` policy drops it. */
+    policies: TailSamplingPolicy[];
+  }
+>;
 
 /**
  * Holds each trace for `decision_wait`, then samples it when a policy says so.
@@ -327,23 +331,7 @@ function subPolicyProblems(subs: ReadonlyArray<TailSamplingPolicy> | undefined,
 
 // ── probabilistic_sampler ────────────────────────────────────────────
 
-export interface ProbabilisticSamplerProcessorConfig {
-  /** Percent of traces or logs kept, 0 to 100. The collector's default is 0, which keeps nothing, so chant asks for it. */
-  sampling_percentage: number;
-  /** Salt for `hash_seed` mode. Collectors that sample the same data must share it. */
-  hash_seed?: number;
-  /** `hash_seed` (the default for logs), `proportional` (the default for traces) or `equalizing`. */
-  mode?: "hash_seed" | "proportional" | "equalizing";
-  /** Default true: an item without usable randomness is dropped. */
-  fail_closed?: boolean;
-  /** Hex digits of threshold precision, 1 to 14; default 4. */
-  sampling_precision?: number;
-  /** Logs only: sample on the trace id (default) or on `from_attribute` of the record. */
-  attribute_source?: "traceID" | "record";
-  from_attribute?: string;
-  /** Logs only: an attribute whose value overrides the sampling percentage for its record. */
-  sampling_priority?: string;
-}
+export type ProbabilisticSamplerProcessorConfig = ProbabilisticSamplerProcessorSchemaConfig;
 
 /** Head sampling: keeps a fixed percentage of traces or logs, decided per item without waiting for the rest of the trace. */
 export const ProbabilisticSamplerProcessor = defineBuiltin<
@@ -449,13 +437,12 @@ export type LoadBalancingRoutingKey = "traceID" | "service" | "attributes" | "re
 /** The otlp exporter settings used for every backend. The endpoint comes from the resolver, so it is not set here. */
 export type LoadBalancingOtlpConfig = Omit<GRPCClientSettings, "endpoint"> & ExporterHelperSettings;
 
-export type LoadBalancingExporterConfig = ExporterHelperSettings & {
-  protocol?: { otlp: LoadBalancingOtlpConfig };
-  resolver: LoadBalancingResolver;
-  routing_key?: LoadBalancingRoutingKey;
-  /** With `routing_key: attributes`, the span attributes to route on. */
-  routing_attributes?: string[];
-};
+/**
+ * Upstream writes the resolver as one struct with each resolver optional. The
+ * collector takes exactly one, so here the resolver is a union of the four,
+ * and it is required.
+ */
+export type LoadBalancingExporterConfig = Overlay<LoadBalancingExporterSchemaConfig, { resolver: LoadBalancingResolver }>;
 
 const RESOLVER_KEYS = ["static", "dns", "k8s", "aws_cloud_map"] as const;
 

package/src/config-hygiene.ts

@@ -5,8 +5,8 @@
  * so it runs on emitted YAML, on an imported file and on a config inside a
  * ConfigMap alike. `validateCollectorConfig` calls `configHygieneIssues`.
  *
- * Every list and version here is read from collector or collector-contrib
- * v0.130.0 (`COLLECTOR_PIN`); the lint rules page cites the file for each.
+ * Every list and version here is read from collector or collector-contrib at
+ * `COLLECTOR_PIN` (v0.162.0); the lint rules page cites the file for each.
  */
 
 import { parseComponentId, type CollectorConfig } from "./model";
@@ -85,10 +85,12 @@ function invertMatchPaths(value: unknown, path: string[], out: string[]): string
 
 /**
  * OTEL119: a field deprecated at or before the pin. The collector still
- * reads each of these at v0.130.0, and a later release drops them.
+ * parses each of these at v0.162.0 (`COLLECTOR_PIN`), and a later release
+ * drops them.
  *
  * - `invert_match: true` in a `tail_sampling` policy: inverted decisions are
- *   deprecated in contrib v0.126.0 (#39833) for a `drop` policy.
+ *   deprecated in contrib v0.126.0 (#39833) for a `drop` policy, and v0.155.0
+ *   removed the gate that kept them (#48976).
  * - `service.telemetry.metrics.address`: deprecated in core v0.111.0
  *   (#11205) for `readers`.
  * - `dimensions_cache_size` on `spanmetrics`: deprecated in contrib v0.125.0
@@ -107,7 +109,7 @@ function deprecatedFieldIssues(config: CollectorConfig): CollectorIssue[] {
           code: "OTEL119",
           severity: "warning",
           component: id,
-          message: `processor "${id}" policy ${name} sets ${path}; inverted decisions are deprecated since collector-contrib v0.126.0. Use a drop policy to keep the traces out instead`,
+          message: `processor "${id}" policy ${name} sets ${path}; inverted decisions are deprecated since collector-contrib v0.126.0, and v0.155.0 removed the gate that kept them. Use a drop policy to keep the traces out instead`,
         });
       }
     });
@@ -315,8 +317,9 @@ function deliveryIssues(config: CollectorConfig): CollectorIssue[] {
 /**
  * The exporters OTEL125 knows send one request per incoming batch unless
  * told otherwise: `otlp` and `otlphttp`, whose default `sending_queue` at
- * v0.130.0 has no `batch` (`exporterhelper/internal/queue_sender.go`,
- * `NewDefaultQueueConfig`). Other exporters may batch on their own, so they
+ * v0.162.0 has no `batch` (`exporterhelper/internal/queue_sender.go`,
+ * `NewDefaultQueueConfig`, while the alpha `pkg.exporterhelper.queueBatchEnabled`
+ * gate is off). Other exporters may batch on their own, so they
  * are not checked.
  */
 const UNBATCHED_EXPORTERS = new Set(["otlp", "otlphttp"]);
@@ -353,9 +356,9 @@ function batchIssues(config: CollectorConfig): CollectorIssue[] {
 // ── OTEL126, OTEL127: names checked against a fixed list ─────────────
 
 /**
- * The fields `k8sattributes` can extract at v0.130.0: the cases of
- * `Config.Validate` (`processor/k8sattributesprocessor/config.go`), with
- * the semconv v1.6.1 keys and `options.go` constants they name.
+ * The fields `k8sattributes` can extract at v0.162.0 (`COLLECTOR_PIN`): the
+ * cases of `Config.Validate` (`processor/k8sattributesprocessor/config.go`),
+ * with the semconv keys and `options.go` constants they name.
  */
 export const K8S_ATTRIBUTES_METADATA: readonly string[] = Object.freeze([
   "k8s.namespace.name",
@@ -375,12 +378,14 @@ export const K8S_ATTRIBUTES_METADATA: readonly string[] = Object.freeze([
   "k8s.job.name",
   "k8s.job.uid",
   "k8s.cronjob.name",
+  "k8s.cronjob.uid",
   "k8s.node.name",
   "k8s.node.uid",
   "k8s.container.name",
   "container.id",
   "container.image.name",
   "container.image.tag",
+  "container.image.tags",
   "service.namespace",
   "service.name",
   "service.version",
@@ -390,14 +395,22 @@ export const K8S_ATTRIBUTES_METADATA: readonly string[] = Object.freeze([
 ]);
 
 /**
- * The detectors `resourcedetection` knows at v0.130.0: the keys of the map
- * in `NewFactory` (`processor/resourcedetectionprocessor/factory.go`), as
- * each detector's `TypeStr` spells them.
+ * The detectors `resourcedetection` knows at v0.162.0 (`COLLECTOR_PIN`): the
+ * keys of the map in `NewFactory`
+ * (`processor/resourcedetectionprocessor/factory.go`), as each detector's
+ * `TypeStr` spells them. `k8snode` is the deprecated alias of `k8s_api`
+ * (v0.154.0); both still build.
  */
 export const RESOURCE_DETECTORS: readonly string[] = Object.freeze([
+  "akamai",
+  "alibaba_ecs",
   "aks",
   "azure",
+  "azureappservice",
+  "azurecontainerapps",
+  "azurefunctions",
   "consul",
+  "digitalocean",
   "docker",
   "ec2",
   "ecs",
@@ -407,11 +420,21 @@ export const RESOURCE_DETECTORS: readonly string[] = Object.freeze([
   "env",
   "gcp",
   "heroku",
+  "hetzner",
+  "ibmcloud_classic",
+  "ibmcloud_vpc",
+  "scaleway",
   "system",
   "openshift",
+  "nova",
+  "oraclecloud",
+  "k8s_api",
   "k8snode",
   "kubeadm",
   "dynatrace",
+  "tencent_cvm",
+  "upcloud",
+  "vultr",
 ]);
 
 /** OTEL126: `k8sattributes` `extract.metadata` names a field the processor can't extract, so the collector refuses the config. */

package/src/coverage.test.ts

@@ -0,0 +1,37 @@
+import { describe, expect, test } from "vitest";
+import { coverageReport, formatCoverage } from "./coverage";
+import { otelPlugin } from "./plugin";
+import { loadSnapshot } from "./spec/snapshot";
+
+describe("coverageReport against the distribution manifests", () => {
+  const report = coverageReport();
+
+  test("every built-in is in otelcol-contrib, and every one with a schema is generated", async () => {
+    expect(report.unaccountedKinds).toEqual([]);
+    expect(await otelPlugin.coverageReport!()).toMatchObject({ unaccountedKinds: [] });
+    expect(report.generated).toHaveLength(35);
+    expect(report.handWritten).toEqual(["ForwardConnector"]);
+  });
+
+  test("reports each distribution's components and what reaches them", () => {
+    const contrib = report.distributions.find((d) => d.distribution === "otelcol-contrib")!;
+    expect(contrib.components).toBe(242);
+    expect(contrib.withSchema).toBe(213);
+    expect(contrib.builtinMissing).toEqual([]);
+    expect(contrib.builtin.length + contrib.schemaNotBuiltin.length + contrib.noSchemaNotBuiltin.length).toBe(contrib.components);
+    const k8s = report.distributions.find((d) => d.distribution === "otelcol-k8s")!;
+    expect(k8s.components).toBe(69);
+    // The k8s distribution leaves out the cloud and vendor exporters.
+    expect(k8s.builtinMissing).toContain("exporter/googlecloud");
+    expect(formatCoverage(report)).toContain("otelcol-contrib v0.162.0: 242 components, 213 with a schema");
+  });
+
+  test("a built-in the distribution does not ship is unaccounted", () => {
+    const snapshot = loadSnapshot();
+    const without = {
+      ...snapshot,
+      distributions: { ...snapshot.distributions, "otelcol-contrib": snapshot.distributions["otelcol-contrib"].filter((c) => c.type !== "pprof" || c.kind !== "extension") },
+    };
+    expect(coverageReport(without).unaccountedKinds).toEqual([expect.stringContaining('PprofExtension: extension "pprof" is not in otelcol-contrib')]);
+  });
+});

package/src/coverage.ts

@@ -0,0 +1,121 @@
+/**
+ * Coverage of the otel lexicon against a distribution manifest (#3361).
+ *
+ * The question a collector lexicon answers is "which components of the binary
+ * I run does chant type?". The committed snapshot holds the `otelcol-contrib`
+ * and `otelcol-k8s` manifests' component index at the pinned releases, with
+ * each component's type and whether upstream publishes a `config.schema.yaml`
+ * for it. Each component is in one of three places:
+ *
+ * - a built-in, with its config type generated from the schema (or
+ *   hand-written when upstream publishes none);
+ * - not built in, reached through `defineComponent`, which carries its own pin;
+ * - a built-in the distribution does not ship, which is a lexicon defect.
+ *
+ * `unaccountedKinds` (what `check-lexicon` gates on) lists the defects: a
+ * built-in missing from the contrib manifest, or a built-in whose upstream
+ * schema exists but whose config type is not generated from it. Everything
+ * here is read from the snapshot, offline.
+ */
+
+import { BUILTIN_SPECS } from "./spec/builtins";
+import { loadSnapshot } from "./spec/snapshot";
+import { DISTRIBUTIONS, type DistributionName, type IndexedComponent, type OtelSpecSnapshot } from "./spec/fetch";
+import type { ComponentKind } from "./model";
+
+export interface DistributionCoverage {
+  distribution: DistributionName;
+  version: string;
+  /** Components the manifest lists. */
+  components: number;
+  /** Of those, how many ship a `config.schema.yaml`. */
+  withSchema: number;
+  /** Built-ins in this distribution, as `kind/type`. */
+  builtin: string[];
+  /** Built-ins this distribution does not ship, as `kind/type`. */
+  builtinMissing: string[];
+  /** Components with a schema chant does not build in, as `kind/type`; `defineComponent` reaches them. */
+  schemaNotBuiltin: string[];
+  /** Components without a schema chant does not build in, as `kind/type` (or the module when it has no type). */
+  noSchemaNotBuiltin: string[];
+}
+
+export interface OtelCoverageReport {
+  /** Built-ins whose config type is generated from upstream, as class names. */
+  generated: string[];
+  /** Built-ins with a hand-written config type, because upstream publishes no schema, as class names. */
+  handWritten: string[];
+  distributions: DistributionCoverage[];
+  /** The defects, for `check-lexicon`. */
+  unaccountedKinds: string[];
+}
+
+function label(c: { kind: ComponentKind; type?: string; module?: string }): string {
+  return `${c.kind}/${c.type ?? c.module}`;
+}
+
+function find(index: IndexedComponent[], kind: ComponentKind, type: string): IndexedComponent | undefined {
+  return index.find((c) => c.kind === kind && (c.type === type || c.deprecatedType === type));
+}
+
+/** The coverage report for a snapshot (the committed one by default). */
+export function coverageReport(snapshot: OtelSpecSnapshot = loadSnapshot()): OtelCoverageReport {
+  const contrib = snapshot.distributions["otelcol-contrib"];
+  const generated: string[] = [];
+  const handWritten: string[] = [];
+  const unaccounted: string[] = [];
+  for (const b of BUILTIN_SPECS) {
+    const hit = find(contrib, b.kind, b.type);
+    if (!hit) {
+      unaccounted.push(`${b.className}: ${b.kind} "${b.type}" is not in otelcol-contrib ${snapshot.versions["otelcol-contrib"]}`);
+      continue;
+    }
+    if (hit.schema && snapshot.schemas[hit.schema] !== undefined) generated.push(b.className);
+    else if (hit.schema) unaccounted.push(`${b.className}: upstream ships ${hit.schema} but the snapshot does not carry it; run \`just snapshot\``);
+    else handWritten.push(b.className);
+  }
+
+  const distributions = DISTRIBUTIONS.map((distribution): DistributionCoverage => {
+    const index = snapshot.distributions[distribution];
+    const builtinHits = new Set<IndexedComponent>();
+    const builtin: string[] = [];
+    const builtinMissing: string[] = [];
+    for (const b of BUILTIN_SPECS) {
+      const hit = find(index, b.kind, b.type);
+      if (hit) {
+        builtinHits.add(hit);
+        builtin.push(`${b.kind}/${b.type}`);
+      } else builtinMissing.push(`${b.kind}/${b.type}`);
+    }
+    const others = index.filter((c) => !builtinHits.has(c));
+    return {
+      distribution,
+      version: snapshot.versions[distribution],
+      components: index.length,
+      withSchema: index.filter((c) => c.schema).length,
+      builtin,
+      builtinMissing,
+      schemaNotBuiltin: others.filter((c) => c.schema).map(label),
+      noSchemaNotBuiltin: others.filter((c) => !c.schema).map(label),
+    };
+  });
+
+  return { generated, handWritten, distributions, unaccountedKinds: unaccounted };
+}
+
+/** The report as `coverage()` prints it. */
+export function formatCoverage(report: OtelCoverageReport): string {
+  const lines = [
+    `otel: ${report.generated.length + report.handWritten.length} built-in components, ${report.generated.length} with config types generated from upstream config.schema.yaml`,
+  ];
+  if (report.handWritten.length > 0) lines.push(`  hand-written (no upstream schema): ${report.handWritten.join(", ")}`);
+  for (const d of report.distributions) {
+    lines.push(
+      `${d.distribution} ${d.version}: ${d.components} components, ${d.withSchema} with a schema; ` +
+        `${d.builtin.length} built in, ${d.schemaNotBuiltin.length + d.noSchemaNotBuiltin.length} through defineComponent`,
+    );
+    if (d.builtinMissing.length > 0) lines.push(`  built-ins this distribution does not ship: ${d.builtinMissing.join(", ")}`);
+  }
+  for (const u of report.unaccountedKinds) lines.push(`  unaccounted: ${u}`);
+  return lines.join("\n");
+}

package/src/define.test.ts

@@ -94,12 +94,14 @@ describe("defineComponent", () => {
 
   test("sending_queue.blocking is reported; the collector reads block_on_overflow", () => {
     const otlp = new OtlpReceiver({ protocols: { grpc: {} } });
+    // @ts-expect-error: `blocking` is not an upstream field, which is what the check reports
     const old = new OtlpExporter({ endpoint: "backend:4317", sending_queue: { blocking: true } });
     const r = build([otlp, old, new Pipeline({ signal: "traces", receivers: [otlp], exporters: [old] })]);
     expect(r.diags.filter((d) => d.checkId === "OTEL107").map((d) => d.message)).toEqual([
       'exporter "otlp": sending_queue.blocking is not a collector setting; use sending_queue.block_on_overflow',
     ]);
 
+    // @ts-expect-error: `blocking` is not an upstream field, which is what the check reports
     const both = new OtlpExporter({ endpoint: "backend:4317", sending_queue: { blocking: true, block_on_overflow: true } });
     const r2 = build([otlp, both, new Pipeline({ signal: "traces", receivers: [otlp], exporters: [both] })]);
     expect(r2.diags.filter((d) => d.checkId === "OTEL107")).toHaveLength(1);

package/src/define.ts

@@ -12,9 +12,9 @@
  * ## Schema pinning
  *
  * Every definition carries a `pin`: the source its config type was written
- * against and the version of that source. Built-ins share `COLLECTOR_PIN`,
- * which moves only when this package does, so the chant lexicon version pins
- * them. A custom definition must name its own pin, typically the npm package
+ * against and the version of that source. Built-ins share `COLLECTOR_PIN`:
+ * their config types are generated from upstream `config.schema.yaml` at that
+ * release (`src/spec/`, #3361), so the chant lexicon version pins them. A custom definition must name its own pin, typically the npm package
  * (or Go module) that ships the component and the release its type follows,
  * optionally with a digest of the schema document. chant records the pin; it
  * does not fetch or verify the schema. The pin shows up in three places:
@@ -35,6 +35,7 @@
 import { createResource } from "@intentius/chant/runtime";
 import type { Declarable } from "@intentius/chant/declarable";
 import { canonicalComponentType, componentId, type ComponentKind, type ConnectorSignalPair } from "./model";
+import { OTELCOL_CONTRIB_VERSION } from "./spec/pin";
 
 /** Where a component's config schema comes from, and which version of it the type follows. */
 export interface SchemaPin {
@@ -47,12 +48,15 @@ export interface SchemaPin {
 }
 
 /**
- * The collector distribution the built-in config types follow. Bumping it is a
- * lexicon change like any other, released with this package.
+ * The collector distribution the built-in config types follow: the
+ * `otelcol-contrib` release whose manifest scopes them and whose component
+ * schemas they are generated from (`OTELCOL_CONTRIB_VERSION` in
+ * `src/spec/pin.ts`). Bumping it is a lexicon change like any other, released
+ * with this package, and it moves `COLLECTOR_IMAGE` with it.
  */
 export const COLLECTOR_PIN: SchemaPin = Object.freeze({
   source: "github.com/open-telemetry/opentelemetry-collector-contrib",
-  version: "v0.130.0",
+  version: OTELCOL_CONTRIB_VERSION,
 });
 
 /**