@intentius/chant-lexicon-otel 0.100.0 → 0.101.0

package/src/components/extensions.test.ts

@@ -0,0 +1,70 @@
+import { describe, expect, test } from "vitest";
+import { load } from "js-yaml";
+import type { Declarable } from "@intentius/chant/declarable";
+import { collectorYaml } from "../collector";
+import { validateCollectorEntities } from "../validate-config";
+import { COLLECTOR_PIN } from "../define";
+import { Pipeline, Service } from "../pipeline";
+import { DebugExporter } from "./exporters";
+import { K8sClusterReceiver } from "./k8s-receivers";
+import { K8sLeaderElectorExtension, type K8sLeaderElectorExtensionConfig } from "./extensions";
+
+function problems(component: Declarable): string[] {
+  return validateCollectorEntities([component])
+    .filter((i) => i.code === "OTEL107")
+    .map((i) => i.message.replace(/^\w+ "[^"]+": /, ""));
+}
+
+const lease = { lease_name: "otel-k8s-cluster", lease_namespace: "observability" };
+
+describe("k8s_leader_elector extension", () => {
+  test("is a built-in pinned to the collector release", () => {
+    expect(K8sLeaderElectorExtension.definition.kind).toBe("extension");
+    expect(K8sLeaderElectorExtension.definition.type).toBe("k8s_leader_elector");
+    expect(K8sLeaderElectorExtension.definition.builtin).toBe(true);
+    expect(K8sLeaderElectorExtension.definition.pin).toBe(COLLECTOR_PIN);
+  });
+
+  test("a k8s_cluster receiver names it by componentId", () => {
+    const elector = new K8sLeaderElectorExtension({ name: "cluster", auth_type: "serviceAccount", ...lease, lease_duration: "20s" });
+    const cluster = new K8sClusterReceiver({ k8s_leader_elector: elector.componentId });
+    const debug = new DebugExporter({});
+    const yaml = collectorYaml([
+      cluster,
+      elector,
+      debug,
+      new Pipeline({ signal: "metrics", receivers: [cluster], exporters: [debug] }),
+      new Service({ extensions: [elector] }),
+    ]);
+    expect(load(yaml)).toMatchObject({
+      receivers: { k8s_cluster: { k8s_leader_elector: "k8s_leader_elector/cluster" } },
+      extensions: {
+        "k8s_leader_elector/cluster": { auth_type: "serviceAccount", lease_name: "otel-k8s-cluster", lease_namespace: "observability", lease_duration: "20s" },
+      },
+      service: { extensions: ["k8s_leader_elector/cluster"] },
+    });
+    expect(problems(elector)).toEqual([]);
+  });
+
+  test("needs lease_name and lease_namespace", () => {
+    expect(problems(new K8sLeaderElectorExtension({ lease_name: "", lease_namespace: "obs" }))).toEqual([
+      "lease_name and lease_namespace must be set",
+    ]);
+    expect(problems(new K8sLeaderElectorExtension({} as K8sLeaderElectorExtensionConfig))).toEqual([
+      "lease_name and lease_namespace must be set",
+    ]);
+  });
+
+  test("checks the durations the way client-go's leader elector does", () => {
+    expect(problems(new K8sLeaderElectorExtension({ ...lease, lease_duration: "10s" }))).toEqual([
+      "lease_duration must be greater than renew_deadline",
+    ]);
+    expect(problems(new K8sLeaderElectorExtension({ ...lease, renew_deadline: "2400ms" }))).toEqual([
+      "renew_deadline must be greater than 1.2 times retry_period",
+    ]);
+    expect(problems(new K8sLeaderElectorExtension({ ...lease, retry_period: "0s" }))).toEqual(["retry_period must be positive"]);
+    expect(problems(new K8sLeaderElectorExtension({ ...lease, lease_duration: "1m30s", renew_deadline: "1m", retry_period: "5s" }))).toEqual([]);
+    // A value this can't read (an env reference) is left to the collector.
+    expect(problems(new K8sLeaderElectorExtension({ ...lease, lease_duration: "${env:LEASE}" }))).toEqual([]);
+  });
+});

package/src/components/extensions.ts

@@ -1,9 +1,10 @@
 /**
- * Built-in extensions: health_check, pprof, zpages.
+ * Built-in extensions: health_check, pprof, zpages, k8s_leader_elector.
  */
 
 import { defineBuiltin } from "../define";
-import type { TLSServerSettings } from "./common";
+import { goDurationMs, type Duration, type TLSServerSettings } from "./common";
+import type { K8sAuthType } from "./k8s-receivers";
 
 export interface HealthCheckExtensionConfig {
   /** Default `localhost:13133`. */
@@ -49,3 +50,60 @@ export const ZPagesExtension = defineBuiltin<ZPagesExtensionConfig, "extension",
   description: "Serves zPages for live debugging of receivers and exporters",
   endpoints: (c) => [c.endpoint ?? "localhost:55679"],
 });
+
+// ── k8s_leader_elector ───────────────────────────────────────────────
+//
+// Typed against extension/k8sleaderelector at COLLECTOR_PIN
+// (collector-contrib v0.130.0): config.go, factory.go, leader_elector.go and README.md at that tag,
+// https://github.com/open-telemetry/opentelemetry-collector-contrib/tree/v0.130.0/extension/k8sleaderelector
+// The config squashes internal/k8sconfig's APIConfig (`auth_type`, `context`).
+// Upstream marks it alpha. It ships in the otelcol-contrib and otelcol-k8s
+// distributions at v0.130.0.
+
+export interface K8sLeaderElectorExtensionConfig {
+  /** How to reach the Kubernetes API. Default `serviceAccount`. */
+  auth_type?: K8sAuthType;
+  /** With `auth_type: kubeConfig`, the kubeconfig context to use instead of the current one. */
+  context?: string;
+  /** The Lease object the replicas compete for. Required. */
+  lease_name: string;
+  /** The namespace of the Lease. Required. */
+  lease_namespace: string;
+  /** How long a lease is held without renewal. Default `15s`. */
+  lease_duration?: Duration;
+  /** How long the leader keeps retrying a renewal before giving up the lease; less than `lease_duration`. Default `10s`. */
+  renew_deadline?: Duration;
+  /** How long to wait between attempts to acquire or renew. Default `2s`. */
+  retry_period?: Duration;
+}
+
+/**
+ * Elects one leader among collector replicas through a Kubernetes Lease, so a
+ * receiver that names it (`k8s_cluster`'s `k8s_leader_elector`) collects only
+ * in the replica holding the lease. The collector's ServiceAccount needs
+ * access to `leases` in `coordination.k8s.io` in `lease_namespace`.
+ */
+export const K8sLeaderElectorExtension = defineBuiltin<K8sLeaderElectorExtensionConfig, "extension", "k8s_leader_elector">({
+  kind: "extension",
+  type: "k8s_leader_elector",
+  description: "Elects one leader among collector replicas through a Kubernetes Lease",
+  validate: (c) => {
+    const problems: string[] = [];
+    // config.go Validate.
+    if (!c.lease_name || !c.lease_namespace) problems.push("lease_name and lease_namespace must be set");
+    // client-go's leaderelection.NewLeaderElector, which leader_elector.go calls when the extension starts.
+    const lease = goDurationMs(c.lease_duration, 15_000);
+    const renew = goDurationMs(c.renew_deadline, 10_000);
+    const retry = goDurationMs(c.retry_period, 2_000);
+    for (const [key, ms] of [["lease_duration", lease], ["renew_deadline", renew], ["retry_period", retry]] as const) {
+      if (ms !== undefined && ms <= 0) problems.push(`${key} must be positive`);
+    }
+    if (lease !== undefined && renew !== undefined && lease > 0 && renew > 0 && lease <= renew) {
+      problems.push("lease_duration must be greater than renew_deadline");
+    }
+    if (renew !== undefined && retry !== undefined && renew > 0 && retry > 0 && renew <= 1.2 * retry) {
+      problems.push("renew_deadline must be greater than 1.2 times retry_period");
+    }
+    return problems;
+  },
+});

package/src/components/processors.test.ts

@@ -0,0 +1,54 @@
+import { describe, expect, test } from "vitest";
+import { load } from "js-yaml";
+import type { Declarable } from "@intentius/chant/declarable";
+import { collectorYaml } from "../collector";
+import { validateCollectorEntities } from "../validate-config";
+import { COLLECTOR_PIN } from "../define";
+import { Pipeline } from "../pipeline";
+import { DebugExporter } from "./exporters";
+import { SumConnector } from "./connectors";
+import { OtlpReceiver } from "./receivers";
+import { DeltaToCumulativeProcessor, type DeltaToCumulativeProcessorConfig } from "./processors";
+
+function problems(component: Declarable): string[] {
+  return validateCollectorEntities([component])
+    .filter((i) => i.code === "OTEL107")
+    .map((i) => i.message.replace(/^\w+ "[^"]+": /, ""));
+}
+
+describe("deltatocumulative processor", () => {
+  test("is a built-in pinned to the collector release", () => {
+    expect(DeltaToCumulativeProcessor.definition.kind).toBe("processor");
+    expect(DeltaToCumulativeProcessor.definition.type).toBe("deltatocumulative");
+    expect(DeltaToCumulativeProcessor.definition.builtin).toBe(true);
+    expect(DeltaToCumulativeProcessor.definition.pin).toBe(COLLECTOR_PIN);
+  });
+
+  test("sits in a metrics pipeline after a delta-emitting connector", () => {
+    const otlp = new OtlpReceiver({ protocols: { grpc: {} } });
+    const sum = new SumConnector({ spans: { "tokens": { source_attribute: "gen_ai.usage.input_tokens" } } });
+    const d2c = new DeltaToCumulativeProcessor({ max_stale: "10m", max_streams: 1000 });
+    const debug = new DebugExporter({});
+    const config = load(
+      collectorYaml([
+        otlp,
+        new Pipeline({ signal: "traces", receivers: [otlp], exporters: [sum] }),
+        new Pipeline({ signal: "metrics", receivers: [sum], processors: [d2c], exporters: [debug] }),
+      ]),
+    ) as any;
+    expect(config.processors.deltatocumulative).toEqual({ max_stale: "10m", max_streams: 1000 });
+    expect(config.service.pipelines.metrics.processors).toEqual(["deltatocumulative"]);
+  });
+
+  test.each<[string, DeltaToCumulativeProcessorConfig, string[]]>([
+    ["defaults", {}, []],
+    ["set", { max_stale: "1h", max_streams: 0 }, []],
+    ["zero max_stale", { max_stale: "0s" }, ['max_stale must be a positive duration (got "0s")']],
+    ["bare zero max_stale", { max_stale: "0" }, ['max_stale must be a positive duration (got "0")']],
+    ["negative max_stale", { max_stale: "-5m" }, ['max_stale must be a positive duration (got "-5m")']],
+    ["negative max_streams", { max_streams: -1 }, ["max_streams must be a whole number, 0 or more (got -1)"]],
+    ["fractional max_streams", { max_streams: 1.5 }, ["max_streams must be a whole number, 0 or more (got 1.5)"]],
+  ])("checks what config.go Validate checks: %s", (_label, config, expected) => {
+    expect(problems(new DeltaToCumulativeProcessor(config))).toEqual(expected);
+  });
+});

package/src/components/processors.ts

@@ -1,10 +1,10 @@
 /**
  * Built-in processors: batch, memory_limiter, resource, attributes,
- * k8sattributes, resourcedetection.
+ * k8sattributes, resourcedetection, deltatocumulative.
  */
 
 import { defineBuiltin } from "../define";
-import type { AttributeAction, Duration } from "./common";
+import { goDurationMs, type AttributeAction, type Duration } from "./common";
 
 // ── batch ────────────────────────────────────────────────────────────
 
@@ -210,3 +210,42 @@ export const ResourceDetectionProcessor = defineBuiltin<
   description: "Detects cloud, container and host resource attributes",
   validate: (c) => (c.detectors?.length ? [] : ["detectors is empty, so nothing is detected"]),
 });
+
+// ── deltatocumulative ────────────────────────────────────────────────
+//
+// Typed against processor/deltatocumulativeprocessor at COLLECTOR_PIN
+// (collector-contrib v0.130.0): config.go, factory.go and README.md at that tag,
+// https://github.com/open-telemetry/opentelemetry-collector-contrib/tree/v0.130.0/processor/deltatocumulativeprocessor
+// Upstream marks it alpha for metrics. It ships in the otelcol-contrib and
+// otelcol-k8s distributions at v0.130.0, and keeps every stream's running
+// total in memory, so one collector instance must see all of a stream's
+// deltas for its totals to be right.
+
+export interface DeltaToCumulativeProcessorConfig {
+  /** How long a stream that receives no samples is kept before it is dropped. Positive. Default `5m`. */
+  max_stale?: Duration;
+  /** The most streams tracked at once; samples of new streams past it are dropped. Not negative. Default unlimited. */
+  max_streams?: number;
+}
+
+/**
+ * Turns delta metrics into cumulative ones by keeping a running total per
+ * stream. Exporters that read only cumulative data, such as
+ * `prometheusremotewrite`, need it after connectors that emit deltas (`sum`,
+ * `count`, `signaltometrics`). Cumulative metrics pass through unchanged.
+ */
+export const DeltaToCumulativeProcessor = defineBuiltin<DeltaToCumulativeProcessorConfig, "processor", "deltatocumulative">({
+  kind: "processor",
+  type: "deltatocumulative",
+  description: "Converts delta metrics to cumulative by keeping a running total per stream",
+  validate: (c) => {
+    // config.go Validate.
+    const problems: string[] = [];
+    const stale = goDurationMs(c.max_stale, 5 * 60_000);
+    if (stale !== undefined && stale <= 0) problems.push(`max_stale must be a positive duration (got ${JSON.stringify(c.max_stale)})`);
+    if (c.max_streams !== undefined && (!Number.isInteger(c.max_streams) || c.max_streams < 0)) {
+      problems.push(`max_streams must be a whole number, 0 or more (got ${c.max_streams})`);
+    }
+    return problems;
+  },
+});

package/src/components/receivers.ts

@@ -35,6 +35,11 @@ export const OtlpReceiver = defineBuiltin<OtlpReceiverConfig, "receiver", "otlp"
     if (c.protocols && "http" in c.protocols) out.push(c.protocols.http?.endpoint ?? "localhost:4318");
     return out;
   },
+  // The HTTP receiver takes protobuf and JSON bodies on the same port.
+  protocols: (c) => [
+    ...(c.protocols && "grpc" in c.protocols ? ["grpc"] : []),
+    ...(c.protocols && "http" in c.protocols ? ["http/protobuf", "http/json"] : []),
+  ],
 });
 
 // ── prometheus ───────────────────────────────────────────────────────

package/src/composites/catalog.test.ts

@@ -0,0 +1,38 @@
+/**
+ * The composite catalog matches what this lexicon exports (#2662).
+ *
+ * `catalog.ts` is generated by `npm run generate:composite-catalogs` and is
+ * what `chant serve mcp` lists.
+ */
+
+import { describe, expect, test } from "vitest";
+import { isCompositeDefinition } from "@intentius/chant";
+import * as composites from "./index";
+import { compositeCatalog } from "./catalog";
+import { otelPlugin } from "../plugin";
+
+const exported = Object.entries(composites)
+  .filter(([, value]) => isCompositeDefinition(value))
+  .map(([name]) => name)
+  .sort();
+const catalogued = compositeCatalog.map((entry) => entry.name).sort();
+
+describe("the otel composite catalog", () => {
+  test("every exported composite has an entry, and every entry names an exported composite", () => {
+    expect(exported).toEqual(["NodeAgent"]);
+    expect(catalogued, "regenerate with `npm run generate:composite-catalogs -- otel`").toEqual(exported);
+  });
+
+  test("every entry says what it is and names the components it bundles", () => {
+    for (const entry of compositeCatalog) {
+      expect(entry.lexicon, entry.name).toBe("otel");
+      expect(entry.description.length, entry.name).toBeGreaterThan(0);
+      expect(entry.bundles, entry.name).toContain("Pipeline");
+      expect(entry.bundles, entry.name).toContain("OtlpReceiver");
+    }
+  });
+
+  test("the plugin contributes it", () => {
+    expect(otelPlugin.composites?.()).toBe(compositeCatalog);
+  });
+});

package/src/composites/catalog.ts

@@ -0,0 +1,81 @@
+// Generated by scripts/generate-composite-catalogs.ts (#2662) from this
+// lexicon's composite exports. Do not edit by hand: run
+// `npm run generate:composite-catalogs`. catalog.test.ts holds it to the exports.
+import type { CompositeEntry } from "@intentius/chant/lexicon";
+
+export const compositeCatalog: CompositeEntry[] = [
+  {
+    "name": "NodeAgent",
+    "lexicon": "otel",
+    "description": "The collector config of a per-node Kubernetes agent.",
+    "bundles": [
+      "BatchProcessor",
+      "FileLogReceiver",
+      "HealthCheckExtension",
+      "HostMetricsReceiver",
+      "K8sAttributesProcessor",
+      "KubeletStatsReceiver",
+      "MemoryLimiterProcessor",
+      "OtlpReceiver",
+      "Pipeline",
+      "ResourceDetectionProcessor",
+      "ResourceProcessor"
+    ],
+    "params": [
+      {
+        "name": "exporters",
+        "type": "Exporter[]",
+        "required": true,
+        "description": "Where traces and logs go: usually the gateway (the k8s lexicon's `gatewayExporter()`), or an OTLP backend."
+      },
+      {
+        "name": "metricExporters",
+        "type": "Exporter[]",
+        "required": false,
+        "description": "Where metrics go, e.g. a `prometheus` exporter for a scrape on each node."
+      },
+      {
+        "name": "clusterName",
+        "type": "string",
+        "required": false,
+        "description": "Sets `k8s.cluster.name` on everything the agent sends."
+      },
+      {
+        "name": "nodeNameEnv",
+        "type": "string",
+        "required": false,
+        "description": "The environment variable holding this node's name, set from `spec.nodeName` (default `K8S_NODE_NAME`)."
+      },
+      {
+        "name": "hostMetrics",
+        "type": "boolean | { interval?: Duration; rootPath?: string }",
+        "required": false,
+        "description": "Node CPU, memory, load, filesystem and network from the host root at `/hostfs` (default: on, every 30s)."
+      },
+      {
+        "name": "containerLogs",
+        "type": "boolean | { selfContainer?: string }",
+        "required": false,
+        "description": "Container logs from `/var/log/pods` (default: on)."
+      },
+      {
+        "name": "kubeletStats",
+        "type": "boolean | { interval?: Duration }",
+        "required": false,
+        "description": "Pod and container resource metrics from this node's kubelet (default: off)."
+      },
+      {
+        "name": "memoryLimitMib",
+        "type": "number",
+        "required": false,
+        "description": "`memory_limiter`'s hard limit in MiB (default 400; the spike limit is a quarter of it)."
+      },
+      {
+        "name": "healthCheck",
+        "type": "boolean",
+        "required": false,
+        "description": "Serve `health_check` on 0.0.0.0:13133 (default: on)."
+      }
+    ]
+  }
+];

package/src/composites/composites.test.ts

@@ -0,0 +1,138 @@
+/**
+ * The `NodeAgent` composite: validation, defaults, the switches, and that the
+ * config it declares passes the lexicon's own config checks.
+ */
+import { describe, expect, test } from "vitest";
+import { load } from "js-yaml";
+import type { Declarable } from "@intentius/chant/declarable";
+import { NodeAgent, nodeAgentPropsProblem, type NodeAgentProps } from "./index";
+import { OtlpExporter, PrometheusExporter } from "../components/exporters";
+import { collectorYaml } from "../collector";
+import { validateCollectorConfig } from "../validate-config";
+import type { CollectorConfig } from "../model";
+
+const gateway = new OtlpExporter({ name: "gateway", endpoint: "otel-gateway.observability.svc:4317", tls: { insecure: true } });
+const base: NodeAgentProps = { exporters: [gateway] };
+
+/** A section of the built config, read loosely: the assertions name the keys they expect. */
+type Loose = Record<string, any>; // eslint-disable-line @typescript-eslint/no-explicit-any
+
+function configOf(props: NodeAgentProps): CollectorConfig {
+  const agent = NodeAgent(props);
+  return load(collectorYaml(Object.values(agent.members) as Declarable[])) as CollectorConfig;
+}
+
+describe("NodeAgent validation", () => {
+  test("needs at least one exporter", () => {
+    expect(() => NodeAgent({ exporters: [] })).toThrow(/NodeAgent: exporters must name at least one exporter/);
+    expect(nodeAgentPropsProblem({ ...base, metricExporters: [] })).toMatch(/metricExporters/);
+  });
+
+  test("rejects a memory limit that is not a positive whole number, and a node env var that is not a name", () => {
+    expect(() => NodeAgent({ ...base, memoryLimitMib: 0 })).toThrow(/memoryLimitMib/);
+    expect(() => NodeAgent({ ...base, memoryLimitMib: 1.5 })).toThrow(/memoryLimitMib/);
+    expect(() => NodeAgent({ ...base, nodeNameEnv: "NODE-NAME" })).toThrow(/not an environment variable name/);
+    expect(nodeAgentPropsProblem(base)).toBeUndefined();
+  });
+});
+
+describe("NodeAgent defaults", () => {
+  const config = configOf(base);
+
+  test("the config passes every config check", () => {
+    expect(validateCollectorConfig(config)).toEqual([]);
+  });
+
+  test("OTLP, host metrics and container logs in; memory_limiter first and batch last", () => {
+    expect(Object.keys(config.receivers ?? {}).sort()).toEqual(["filelog", "hostmetrics", "otlp"]);
+    const pipelines = config.service?.pipelines ?? {};
+    expect(Object.keys(pipelines).sort()).toEqual(["logs", "metrics", "traces"]);
+    for (const p of Object.values(pipelines)) {
+      expect(p.processors).toEqual(["memory_limiter", "k8sattributes", "resourcedetection", "batch"]);
+      expect(p.exporters).toEqual(["otlp/gateway"]);
+    }
+    expect(pipelines.metrics.receivers).toEqual(["otlp", "hostmetrics"]);
+    expect(pipelines.logs.receivers).toEqual(["filelog", "otlp"]);
+    expect(pipelines.traces.receivers).toEqual(["otlp"]);
+  });
+
+  test("k8sattributes keeps to this node's pods and matches log records by pod uid", () => {
+    const k8s = config.processors?.k8sattributes as Loose;
+    expect(k8s.filter).toEqual({ node_from_env_var: "K8S_NODE_NAME" });
+    expect(k8s.extract.metadata).toContain("k8s.pod.uid");
+    expect(k8s.pod_association.map((a: Loose) => a.sources[0].name ?? a.sources[0].from)).toEqual(["k8s.pod.ip", "k8s.pod.uid", "connection"]);
+  });
+
+  test("the agent's own container logs are left out", () => {
+    const filelog = config.receivers?.filelog as Loose;
+    expect(filelog.include).toEqual(["/var/log/pods/*/*/*.log"]);
+    expect(filelog.exclude).toEqual(["/var/log/pods/*/otel-collector/*.log"]);
+    expect(filelog.operators).toEqual([{ type: "container", id: "container-parser" }]);
+  });
+
+  test("memory_limiter defaults to 400 MiB with a quarter of it as spike limit, and health_check is served", () => {
+    expect(config.processors?.memory_limiter).toMatchObject({ limit_mib: 400, spike_limit_mib: 100 });
+    expect(config.service?.extensions).toEqual(["health_check"]);
+    expect(config.extensions?.health_check).toEqual({ endpoint: "0.0.0.0:13133" });
+  });
+
+  test("no tail sampling and no kubeletstats", () => {
+    expect(config.processors?.tail_sampling).toBeUndefined();
+    expect(config.receivers?.kubeletstats).toBeUndefined();
+  });
+});
+
+describe("NodeAgent options", () => {
+  test("clusterName adds a resource processor before batch", () => {
+    const config = configOf({ ...base, clusterName: "prod-eu-1" });
+    expect(config.service?.pipelines?.traces.processors).toEqual(["memory_limiter", "k8sattributes", "resourcedetection", "resource", "batch"]);
+    expect(config.processors?.resource).toEqual({ attributes: [{ key: "k8s.cluster.name", value: "prod-eu-1", action: "upsert" }] });
+    expect(validateCollectorConfig(config)).toEqual([]);
+  });
+
+  test("metricExporters sends metrics elsewhere", () => {
+    const scrape = new PrometheusExporter({ endpoint: "0.0.0.0:8889" });
+    const config = configOf({ ...base, metricExporters: [scrape] });
+    expect(config.service?.pipelines?.metrics.exporters).toEqual(["prometheus"]);
+    expect(config.service?.pipelines?.traces.exporters).toEqual(["otlp/gateway"]);
+    expect(validateCollectorConfig(config)).toEqual([]);
+  });
+
+  test("kubeletStats reads this node's kubelet with the service account, named by the node env var", () => {
+    const config = configOf({ ...base, kubeletStats: { interval: "1m" }, nodeNameEnv: "NODE_NAME" });
+    expect(config.receivers?.kubeletstats).toEqual({
+      collection_interval: "1m",
+      auth_type: "serviceAccount",
+      endpoint: "https://${env:NODE_NAME}:10250",
+      insecure_skip_verify: true,
+      node: "${env:NODE_NAME}",
+    });
+    expect(config.service?.pipelines?.metrics.receivers).toEqual(["otlp", "hostmetrics", "kubeletstats"]);
+    expect((config.processors?.k8sattributes as Loose).filter).toEqual({ node_from_env_var: "NODE_NAME" });
+    expect(validateCollectorConfig(config)).toEqual([]);
+  });
+
+  test("host metrics, container logs and health_check can be turned off; OTLP stays", () => {
+    const agent = NodeAgent({ ...base, hostMetrics: false, containerLogs: false, healthCheck: false });
+    expect(Object.keys(agent.members).sort()).toEqual([
+      "batch",
+      "k8sAttributes",
+      "logs",
+      "memoryLimiter",
+      "metrics",
+      "otlp",
+      "resourceDetection",
+      "traces",
+    ]);
+    const config = configOf({ ...base, hostMetrics: false, containerLogs: false, healthCheck: false });
+    expect(Object.keys(config.receivers ?? {})).toEqual(["otlp"]);
+    expect(config.service?.extensions).toBeUndefined();
+    expect(validateCollectorConfig(config)).toEqual([]);
+  });
+
+  test("host metrics and container logs take their own settings", () => {
+    const config = configOf({ ...base, hostMetrics: { interval: "1m", rootPath: "/host" }, containerLogs: { selfContainer: "agent" } });
+    expect(config.receivers?.hostmetrics).toMatchObject({ collection_interval: "1m", root_path: "/host" });
+    expect((config.receivers?.filelog as Loose).exclude).toEqual(["/var/log/pods/*/agent/*.log"]);
+  });
+});

package/src/composites/index.ts

@@ -0,0 +1,6 @@
+/**
+ * otel lexicon composites: declarations that expand to a collector config's components and pipelines.
+ */
+
+export { NodeAgent, nodeAgentPropsProblem } from "./node-agent";
+export type { NodeAgentProps, NodeAgentMembers, NodeAgentInstance } from "./node-agent";