@intentius/chant-lexicon-otel 0.124.30 → 0.124.32

package/dist/collector.js

@@ -0,0 +1,150 @@
+/**
+ * Declared entities -> `CollectorConfig` -> YAML.
+ *
+ * The serializer runs this over a build's entities, and a composite in another
+ * lexicon (the k8s `GkeOtelCollector`, which puts the YAML in a ConfigMap)
+ * runs it over the entities it creates. Both get the same config and the same
+ * text.
+ */
+import { definitionFor, isOTelComponent } from "./define.js";
+import { SECTION_OF } from "./model.js";
+import { isPipelineEntity, isServiceEntity } from "./pipeline.js";
+import { emitCollectorYaml } from "./yaml.js";
+import { semconvUsage } from "./semconv.js";
+function entityList(entities) {
+    return entities instanceof Map ? [...entities.values()] : [...entities];
+}
+/** A config value with component entities turned into ids and `undefined` keys dropped. */
+function plain(value) {
+    if (value === undefined)
+        return undefined;
+    if (isOTelComponent(value))
+        return value.componentId;
+    if (Array.isArray(value))
+        return value.map(plain);
+    if (typeof value === "object" && value !== null) {
+        const toJSON = value.toJSON;
+        if (typeof toJSON === "function")
+            return plain(toJSON.call(value));
+        const out = {};
+        for (const [k, v] of Object.entries(value)) {
+            if (v !== undefined)
+                out[k] = plain(v);
+        }
+        return out;
+    }
+    return value;
+}
+/** A component's config, as it appears under its id: its props without `name`. */
+export function componentConfig(component) {
+    const { name: _name, ...rest } = (component.props ?? {});
+    return plain(rest);
+}
+function refId(ref) {
+    if (isOTelComponent(ref))
+        return ref.componentId;
+    return String(ref);
+}
+/** Build the collector config for a set of declared entities. Non-otel entities are ignored. */
+export function buildCollectorConfig(entities) {
+    const all = entityList(entities).filter((e) => e && e.lexicon === "otel");
+    const warnings = [];
+    const components = [];
+    const byId = new Map();
+    const pipelines = [];
+    let service;
+    const addComponent = (c) => {
+        const key = `${c.componentKind}:${c.componentId}`;
+        const existing = byId.get(key);
+        if (existing === c)
+            return;
+        if (existing) {
+            warnings.push(`otel: two ${c.componentKind}s declare the id "${c.componentId}"; the first one is emitted`);
+            return;
+        }
+        byId.set(key, c);
+        components.push(c);
+    };
+    for (const e of all) {
+        if (isOTelComponent(e))
+            addComponent(e);
+        else if (isPipelineEntity(e))
+            pipelines.push(e);
+        else if (isServiceEntity(e)) {
+            if (service)
+                warnings.push("otel: more than one Service is declared; the first one is used");
+            else
+                service = e;
+        }
+    }
+    // A component a pipeline or the service references by entity is part of the
+    // config even when the caller didn't list it: it carries its own config.
+    for (const p of pipelines) {
+        for (const ref of [...(p.props.receivers ?? []), ...(p.props.processors ?? []), ...(p.props.exporters ?? [])]) {
+            if (isOTelComponent(ref))
+                addComponent(ref);
+        }
+    }
+    for (const ref of service?.props.extensions ?? []) {
+        if (isOTelComponent(ref))
+            addComponent(ref);
+    }
+    const config = {};
+    for (const c of components) {
+        const section = SECTION_OF[c.componentKind];
+        const bucket = (config[section] ?? (config[section] = {}));
+        bucket[c.componentId] = componentConfig(c);
+    }
+    const pipelineMap = {};
+    for (const p of pipelines) {
+        if (p.pipelineId in pipelineMap) {
+            warnings.push(`otel: two pipelines declare the id "${p.pipelineId}"; the first one is emitted`);
+            continue;
+        }
+        const entry = { receivers: (p.props.receivers ?? []).map(refId) };
+        const processors = (p.props.processors ?? []).map(refId);
+        if (processors.length > 0)
+            entry.processors = processors;
+        entry.exporters = (p.props.exporters ?? []).map(refId);
+        pipelineMap[p.pipelineId] = entry;
+    }
+    const extensions = service?.props.extensions
+        ? service.props.extensions.map(refId)
+        : components.filter((c) => c.componentKind === "extension").map((c) => c.componentId);
+    if (pipelines.length > 0 || extensions.length > 0 || service?.props.telemetry) {
+        config.service = {};
+        if (extensions.length > 0)
+            config.service.extensions = extensions;
+        if (service?.props.telemetry)
+            config.service.telemetry = plain(service.props.telemetry);
+        if (pipelines.length > 0)
+            config.service.pipelines = pipelineMap;
+    }
+    const header = [];
+    for (const c of components) {
+        const def = definitionFor(c.entityType);
+        if (!def || def.builtin)
+            continue;
+        const pin = def.pin;
+        const digest = pin?.digest ? ` ${pin.digest}` : "";
+        header.push(`chant: ${c.componentKind} ${c.componentId} schema ${pin?.source ?? "(unpinned)"}@${pin?.version ?? "(unpinned)"}${digest}`);
+    }
+    for (const use of semconvUsage(config)) {
+        const digest = use.digest ? ` ${use.digest}` : "";
+        header.push(`chant: semconv ${use.namespace} ${use.source}@${use.version}${digest} (${use.components.join(", ")})`);
+    }
+    return { config, header, warnings, components, pipelines, service };
+}
+/** Collector YAML for a set of declared entities, exactly as the serializer emits it. */
+export function collectorYaml(entities) {
+    const built = buildCollectorConfig(entities);
+    return emitCollectorYaml(built.config, { header: built.header });
+}
+/**
+ * The collector config object for a set of declared entities, for a host that
+ * holds the config as an object rather than as text: the OpenTelemetry
+ * Operator's `OpenTelemetryCollector` `spec.config` (v1beta1).
+ */
+export function collectorConfig(entities) {
+    return buildCollectorConfig(entities).config;
+}

package/dist/components/common.js

@@ -0,0 +1,50 @@
+/**
+ * Settings shared by many collector components (the collector's `config*`
+ * packages: configtls, configgrpc, confighttp, configretry, exporterhelper).
+ * Keys use the collector's own snake_case spelling, since they are emitted
+ * unchanged.
+ */
+const GO_DURATION_UNITS = { ns: 1e-6, us: 1e-3, "µs": 1e-3, "μs": 1e-3, ms: 1, s: 1e3, m: 60e3, h: 3600e3 };
+/** A Go duration in milliseconds, `fallback` when unset, or undefined when it isn't one this can read. */
+export function goDurationMs(d, fallback) {
+    if (d === undefined)
+        return fallback;
+    if (typeof d === "number")
+        return d / 1e6;
+    // time.ParseDuration takes a bare "0" without a unit.
+    if (/^[+-]?0$/.test(d.trim()))
+        return 0;
+    const m = d.trim().match(/^([+-]?)((?:\d+(?:\.\d*)?|\.\d+)(?:ns|us|µs|μs|ms|s|m|h))+$/);
+    if (!m)
+        return undefined;
+    let total = 0;
+    for (const part of d.trim().matchAll(/(\d+(?:\.\d*)?|\.\d+)(ns|us|µs|μs|ms|s|m|h)/g)) {
+        total += Number(part[1]) * GO_DURATION_UNITS[part[2]];
+    }
+    return m[1] === "-" ? -total : total;
+}
+/** Problems in the `sending_queue` of an exporter's `exporterhelper` settings. */
+export function queueIssues(c) {
+    const q = c.sending_queue;
+    if (!q)
+        return [];
+    const issues = [];
+    if (q.blocking !== undefined) {
+        issues.push(q.block_on_overflow !== undefined
+            ? "sending_queue.blocking is set next to block_on_overflow; remove blocking, the collector reads block_on_overflow"
+            : "sending_queue.blocking is not a collector setting; use sending_queue.block_on_overflow");
+    }
+    const b = q.batch;
+    if (!b)
+        return issues;
+    if (q.enabled === false)
+        issues.push("sending_queue.batch is set but sending_queue.enabled is false; batching runs in the queue");
+    if (b.min_size !== undefined && b.min_size < 0)
+        issues.push("sending_queue.batch.min_size is negative");
+    if (b.max_size !== undefined && b.max_size < 0)
+        issues.push("sending_queue.batch.max_size is negative");
+    if (b.max_size !== undefined && b.max_size !== 0 && b.min_size !== undefined && b.max_size < b.min_size) {
+        issues.push(`sending_queue.batch.max_size (${b.max_size}) is below min_size (${b.min_size}); the collector rejects this`);
+    }
+    return issues;
+}

package/dist/components/connectors.js

@@ -0,0 +1,242 @@
+/**
+ * Built-in connectors: spanmetrics, servicegraph, routing, forward, count, sum,
+ * signaltometrics.
+ *
+ * A connector is an exporter in one pipeline and a receiver in another. Put
+ * the same entity in `exporters` of the pipeline that feeds it and in
+ * `receivers` of the pipeline it feeds. `connects` lists the signal pairs each
+ * connector's factory registers; OTEL112 checks pipelines against them.
+ */
+import { defineBuiltin } from "../define.js";
+const SAME_SIGNAL = [
+    { from: "traces", to: "traces" },
+    { from: "metrics", to: "metrics" },
+    { from: "logs", to: "logs" },
+];
+/** Turns spans into request, error and duration (RED) metrics. */
+export const SpanMetricsConnector = defineBuiltin({
+    kind: "connector",
+    type: "spanmetrics",
+    description: "Turns spans into call-count and duration metrics per service, span name, kind and status",
+    connects: [{ from: "traces", to: "metrics" }],
+    validate: (c) => {
+        const problems = [];
+        if (c.histogram?.explicit && c.histogram?.exponential) {
+            problems.push("histogram: set explicit or exponential buckets, not both");
+        }
+        if (c.events?.enabled && (c.events.dimensions ?? []).length === 0) {
+            problems.push("events: enabled needs at least one dimension");
+        }
+        const reserved = new Set(["service.name", "span.name", "span.kind", "status.code"]);
+        for (const d of c.dimensions ?? []) {
+            if (reserved.has(d.name))
+                problems.push(`dimensions: "${d.name}" is already a default dimension`);
+            reserved.add(d.name);
+        }
+        return problems;
+    },
+});
+/** Builds service-to-service edge metrics from paired client and server spans. */
+export const ServiceGraphConnector = defineBuiltin({
+    kind: "connector",
+    type: "servicegraph",
+    description: "Builds service-to-service request and latency metrics from paired client and server spans",
+    connects: [{ from: "traces", to: "metrics" }],
+});
+/** Sends each item to the pipelines whose route matches it. */
+export const RoutingConnector = defineBuiltin({
+    kind: "connector",
+    type: "routing",
+    description: "Routes traces, metrics or logs to pipelines by OTTL condition",
+    connects: SAME_SIGNAL,
+    validate: (c) => {
+        const problems = [];
+        if ((c.table ?? []).length === 0)
+            problems.push("table is empty");
+        (c.table ?? []).forEach((item, i) => {
+            if (!item.statement && !item.condition)
+                problems.push(`table[${i}]: set a condition or a statement`);
+            if (item.statement && item.condition)
+                problems.push(`table[${i}]: set a condition or a statement, not both`);
+            if (item.context === "request" && !item.condition)
+                problems.push(`table[${i}]: the request context needs a condition`);
+            if ((item.pipelines ?? []).length === 0)
+                problems.push(`table[${i}]: no pipelines`);
+        });
+        return problems;
+    },
+});
+/** Passes data unchanged from one pipeline to another of the same signal. */
+export const ForwardConnector = defineBuiltin({
+    kind: "connector",
+    type: "forward",
+    description: "Passes data unchanged to another pipeline of the same signal",
+    connects: SAME_SIGNAL,
+});
+/** Counts spans, span events, metrics, data points or log records, as metrics. */
+export const CountConnector = defineBuiltin({
+    kind: "connector",
+    type: "count",
+    description: "Counts spans, span events, metrics, data points or log records and emits the counts as metrics",
+    connects: [
+        { from: "traces", to: "metrics" },
+        { from: "metrics", to: "metrics" },
+        { from: "logs", to: "metrics" },
+        { from: "profiles", to: "metrics" },
+    ],
+    validate: (c) => {
+        const problems = [];
+        for (const [section, metrics] of Object.entries(c)) {
+            for (const [name, info] of Object.entries(metrics ?? {})) {
+                if (name === "")
+                    problems.push(`${section}: metric name missing`);
+                if (section === "metrics" && (info?.attributes ?? []).length > 0) {
+                    problems.push(`metrics.${name}: attributes are not supported when counting metrics`);
+                }
+            }
+        }
+        return problems;
+    },
+});
+/** Sums a numeric attribute of spans, span events, data points or log records, as metrics. */
+export const SumConnector = defineBuiltin({
+    kind: "connector",
+    type: "sum",
+    description: "Sums a numeric attribute of spans, span events, data points or log records and emits the sums as metrics",
+    connects: [
+        { from: "traces", to: "metrics" },
+        { from: "metrics", to: "metrics" },
+        { from: "logs", to: "metrics" },
+    ],
+    validate: (c) => {
+        const problems = [];
+        let total = 0;
+        for (const [section, metrics] of Object.entries(c)) {
+            for (const [name, info] of Object.entries(metrics ?? {})) {
+                total++;
+                if (name === "")
+                    problems.push(`${section}: metric name missing`);
+                if (!info?.source_attribute)
+                    problems.push(`${section}.${name}: source_attribute is missing`);
+                if (section === "metrics" && (info?.attributes ?? []).length > 0) {
+                    problems.push(`${section}.${name}: attributes are not supported when summing metrics`);
+                }
+                (info?.attributes ?? []).forEach((a, i) => {
+                    if (!a.key)
+                        problems.push(`${section}.${name}.attributes[${i}]: key is missing`);
+                });
+                // At the pinned release the connector adds each value once per
+                // attribute key (sumconnector summer.increment), so two keys double
+                // every sum.
+                if ((info?.attributes ?? []).length > 1) {
+                    problems.push(`${section}.${name}: more than one attribute multiplies each sum by the number of attributes in the pinned collector; split by one attribute`);
+                }
+            }
+        }
+        if (total === 0)
+            problems.push("no metric is configured, so the connector emits nothing");
+        return problems;
+    },
+});
+// ── signaltometrics ──────────────────────────────────────────────────
+//
+// Typed against connector/signaltometricsconnector at COLLECTOR_PIN
+// (collector-contrib v0.130.0): config/config.go and README.md at that tag,
+// https://github.com/open-telemetry/opentelemetry-collector-contrib/tree/v0.130.0/connector/signaltometricsconnector
+// The collector type is `signaltometrics`. Upstream marks every signal pair
+// alpha. At v0.130.0 there is no span event section; spans, data points,
+// logs and profiles each take a list of metrics.
+/** The input sections of a `signaltometrics` connector, one per signal it reads. */
+export const SIGNAL_TO_METRICS_SIGNALS = ["spans", "datapoints", "logs", "profiles"];
+/** The metric types a `signaltometrics` entry can produce. Each entry names exactly one. */
+export const SIGNAL_TO_METRICS_TYPES = ["sum", "gauge", "histogram", "exponential_histogram"];
+/**
+ * The connector's default explicit histogram bounds, used when `histogram`
+ * sets no `buckets`. They are plain numbers in whatever unit `value` returns,
+ * not durations.
+ */
+export const SIGNAL_TO_METRICS_DEFAULT_BUCKETS = Object.freeze([
+    2, 4, 6, 8, 10, 50, 100, 200, 400, 800, 1000, 1400, 2000, 5000, 10000, 15000,
+]);
+/** Every metric entry of a `signaltometrics` config, in section order. Reads untyped config too. */
+export function signalToMetricsEntries(config) {
+    const out = [];
+    for (const signal of SIGNAL_TO_METRICS_SIGNALS) {
+        const list = config?.[signal];
+        if (!Array.isArray(list))
+            continue;
+        list.forEach((metric, index) => {
+            const m = (metric ?? {});
+            const types = SIGNAL_TO_METRICS_TYPES.filter((t) => m[t] !== undefined && m[t] !== null);
+            out.push({ signal, index, metric: m, types });
+        });
+    }
+    return out;
+}
+const GROK_KEY_SELECTOR = /ExtractGrokPatterns\([^)]*\)\s*\[[^\]]+\]/;
+/** The checks config/config.go makes at v0.130.0 that need no OTTL parser, plus increasing buckets. */
+function validateSignalToMetrics(c) {
+    const problems = [];
+    const entries = signalToMetricsEntries(c);
+    if (entries.length === 0) {
+        problems.push("no metric is configured under spans, datapoints, logs or profiles; the collector refuses the connector");
+    }
+    for (const { signal, index, metric, types } of entries) {
+        const m = metric;
+        const at = m.name ? `${signal}[${index}] (${m.name})` : `${signal}[${index}]`;
+        if (!m.name)
+            problems.push(`${at}: name is missing`);
+        if (types.length !== 1) {
+            problems.push(`${at}: name exactly one metric type (sum, gauge, histogram or exponential_histogram); ${types.length === 0 ? "found none" : `found ${types.join(" and ")}`}`);
+        }
+        for (const t of types) {
+            const body = m[t];
+            if (typeof body?.value !== "string" || body.value === "")
+                problems.push(`${at}: ${t}.value is missing`);
+        }
+        const buckets = m.histogram?.buckets;
+        if (Array.isArray(buckets) && buckets.some((b, i) => i > 0 && !(b > buckets[i - 1]))) {
+            problems.push(`${at}: histogram.buckets must increase`);
+        }
+        const maxSize = m.exponential_histogram?.max_size;
+        if (typeof maxSize === "number" && maxSize !== 0 && (maxSize < 2 || maxSize > 16384)) {
+            problems.push(`${at}: exponential_histogram.max_size must be between 2 and 16384`);
+        }
+        const gauge = m.gauge?.value;
+        if (typeof gauge === "string" && gauge.includes("ExtractGrokPatterns") && !GROK_KEY_SELECTOR.test(gauge)) {
+            problems.push(`${at}: gauge.value with ExtractGrokPatterns needs one key selector, ExtractGrokPatterns(...)["key"]`);
+        }
+        const seen = new Set();
+        (m.attributes ?? []).forEach((a, i) => {
+            if (!a?.key) {
+                problems.push(`${at}: attributes[${i}]: key is missing`);
+                return;
+            }
+            if (a.default_value !== undefined && a.optional) {
+                problems.push(`${at}: attributes "${a.key}": set default_value or optional, not both`);
+            }
+            if (seen.has(a.key))
+                problems.push(`${at}: attributes "${a.key}" is listed twice`);
+            seen.add(a.key);
+        });
+    }
+    return problems;
+}
+/**
+ * Builds metrics from spans, data points, logs or profiles, each with the
+ * name, type, unit, attributes and conditions you choose. A histogram, sum or
+ * gauge takes its value from an OTTL expression, such as an attribute or the
+ * span's duration.
+ */
+export const SignalToMetricsConnector = defineBuiltin({
+    kind: "connector",
+    type: "signaltometrics",
+    description: "Builds named sum, gauge and histogram metrics from spans, data points, logs or profiles, with values and conditions in OTTL",
+    connects: [
+        { from: "traces", to: "metrics" },
+        { from: "metrics", to: "metrics" },
+        { from: "logs", to: "metrics" },
+        { from: "profiles", to: "metrics" },
+    ],
+    validate: validateSignalToMetrics,
+});

package/dist/components/exporters.js

@@ -0,0 +1,57 @@
+/**
+ * Built-in exporters: otlp, otlphttp, debug, prometheus, googlecloud.
+ */
+import { defineBuiltin } from "../define.js";
+import { queueIssues } from "./common.js";
+/** Sends OTLP over gRPC to another collector or a backend. */
+export const OtlpExporter = defineBuiltin({
+    kind: "exporter",
+    type: "otlp",
+    description: "Sends traces, metrics and logs over OTLP gRPC",
+    validate: (c) => [...(c.endpoint ? [] : ["endpoint is empty"]), ...queueIssues(c)],
+    endpoints: (c) => (c.endpoint ? [c.endpoint] : []),
+    protocols: () => ["grpc"],
+});
+/** Sends OTLP over HTTP. `endpoint` gets `/v1/traces` etc. appended; the per-signal endpoints are used as given. */
+export const OtlpHttpExporter = defineBuiltin({
+    kind: "exporter",
+    type: "otlphttp",
+    description: "Sends traces, metrics and logs over OTLP HTTP",
+    validate: (c) => [
+        ...(c.endpoint || c.traces_endpoint || c.metrics_endpoint || c.logs_endpoint
+            ? []
+            : ["set endpoint, or at least one of traces_endpoint, metrics_endpoint and logs_endpoint"]),
+        ...queueIssues(c),
+    ],
+    endpoints: (c) => [c.endpoint, c.traces_endpoint, c.metrics_endpoint, c.logs_endpoint].filter((e) => typeof e === "string" && e !== ""),
+    protocols: (c) => [c.encoding === "json" ? "http/json" : "http/protobuf"],
+});
+/** Writes telemetry to the collector's console, for debugging. */
+export const DebugExporter = defineBuiltin({
+    kind: "exporter",
+    type: "debug",
+    description: "Writes telemetry to the collector's console, for debugging",
+    endpoints: () => ["console"],
+});
+/** Serves metrics on an endpoint Prometheus scrapes. */
+export const PrometheusExporter = defineBuiltin({
+    kind: "exporter",
+    type: "prometheus",
+    description: "Serves metrics on an endpoint for Prometheus to scrape",
+    validate: (c) => (c.endpoint ? [] : ["endpoint is empty, so there is nothing to scrape"]),
+    endpoints: (c) => (c.endpoint ? [c.endpoint] : []),
+});
+/**
+ * Sends traces to Cloud Trace, metrics to Cloud Monitoring and logs to Cloud
+ * Logging. With no endpoint overrides its topology endpoint is
+ * `googlecloud://projects/<project>`, naming where the data lands.
+ */
+export const GoogleCloudExporter = defineBuiltin({
+    kind: "exporter",
+    type: "googlecloud",
+    description: "Sends traces to Cloud Trace, metrics to Cloud Monitoring and logs to Cloud Logging",
+    endpoints: (c) => {
+        const overrides = [c.trace?.endpoint, c.metric?.endpoint, c.log?.endpoint].filter((e) => typeof e === "string" && e !== "");
+        return [`googlecloud://projects/${c.project ?? "(detected)"}`, ...overrides];
+    },
+});

package/dist/components/extensions.js

@@ -0,0 +1,58 @@
+/**
+ * Built-in extensions: health_check, pprof, zpages, k8s_leader_elector.
+ */
+import { defineBuiltin } from "../define.js";
+import { goDurationMs } from "./common.js";
+/** Serves an HTTP health endpoint for liveness and readiness probes. */
+export const HealthCheckExtension = defineBuiltin({
+    kind: "extension",
+    type: "health_check",
+    description: "Serves an HTTP health endpoint for liveness and readiness probes",
+    endpoints: (c) => [`${c.endpoint ?? "localhost:13133"}${c.path ?? "/"}`],
+});
+/** Serves Go's net/http/pprof profiling endpoints. */
+export const PprofExtension = defineBuiltin({
+    kind: "extension",
+    type: "pprof",
+    description: "Serves Go pprof profiling endpoints",
+    endpoints: (c) => [c.endpoint ?? "localhost:1777"],
+});
+/** Serves in-process zPages for live debugging of pipelines. */
+export const ZPagesExtension = defineBuiltin({
+    kind: "extension",
+    type: "zpages",
+    description: "Serves zPages for live debugging of receivers and exporters",
+    endpoints: (c) => [c.endpoint ?? "localhost:55679"],
+});
+/**
+ * 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({
+    kind: "extension",
+    type: "k8s_leader_elector",
+    description: "Elects one leader among collector replicas through a Kubernetes Lease",
+    validate: (c) => {
+        const problems = [];
+        // 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, 15000);
+        const renew = goDurationMs(c.renew_deadline, 10000);
+        const retry = goDurationMs(c.retry_period, 2000);
+        for (const [key, ms] of [["lease_duration", lease], ["renew_deadline", renew], ["retry_period", retry]]) {
+            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/dist/components/filtering.js

@@ -0,0 +1,106 @@
+/**
+ * Built-in processors that drop, rewrite or redact telemetry: filter,
+ * transform, redaction.
+ *
+ * `filter` and `transform` take OTTL. chant types the structure around it
+ * (which signal, which context, which list) and keeps each OTTL condition or
+ * statement as a string; the collector parses them when it loads the config.
+ */
+import { defineBuiltin } from "../define.js";
+/** Drops spans, span events, metrics, data points and log records that match OTTL conditions. */
+export const FilterProcessor = defineBuiltin({
+    kind: "processor",
+    type: "filter",
+    description: "Drops spans, metrics and logs that match OTTL conditions",
+    validate: (c) => {
+        const lists = [
+            ["traces.span", c.traces?.span],
+            ["traces.spanevent", c.traces?.spanevent],
+            ["metrics.metric", c.metrics?.metric],
+            ["metrics.datapoint", c.metrics?.datapoint],
+            ["logs.log_record", c.logs?.log_record],
+        ];
+        const problems = [];
+        for (const [path, list] of lists) {
+            (list ?? []).forEach((cond, i) => {
+                if (typeof cond !== "string" || cond.trim() === "")
+                    problems.push(`${path}[${i}] is an empty condition`);
+            });
+        }
+        const legacy = [
+            ["traces", !!(c.traces?.span || c.traces?.spanevent), !!(c.spans?.include || c.spans?.exclude)],
+            ["metrics", !!(c.metrics?.metric || c.metrics?.datapoint), !!(c.metrics?.include || c.metrics?.exclude)],
+            ["logs", !!c.logs?.log_record, !!(c.logs?.include || c.logs?.exclude)],
+        ];
+        for (const [signal, ottl, matchBlocks] of legacy) {
+            if (ottl && matchBlocks)
+                problems.push(`${signal} mixes OTTL conditions with include/exclude, which the collector rejects`);
+        }
+        if (lists.every(([, list]) => !list || list.length === 0) && legacy.every(([, , matchBlocks]) => !matchBlocks)) {
+            problems.push("no condition is set for any signal, so the processor drops nothing");
+        }
+        return problems;
+    },
+});
+const TRANSFORM_CONTEXTS = {
+    trace_statements: ["resource", "scope", "span", "spanevent"],
+    metric_statements: ["resource", "scope", "metric", "datapoint"],
+    log_statements: ["resource", "scope", "log"],
+};
+/** Rewrites telemetry with OTTL statements, grouped per signal and context. */
+export const TransformProcessor = defineBuiltin({
+    kind: "processor",
+    type: "transform",
+    description: "Rewrites spans, metrics and logs with OTTL statements, grouped by context",
+    validate: (c) => {
+        const problems = [];
+        let total = 0;
+        for (const field of Object.keys(TRANSFORM_CONTEXTS)) {
+            const allowed = TRANSFORM_CONTEXTS[field];
+            (c[field] ?? []).forEach((entry, i) => {
+                if (typeof entry === "string") {
+                    if (entry.trim() === "")
+                        problems.push(`${field}[${i}] is an empty statement`);
+                    else
+                        total++;
+                    return;
+                }
+                if (entry.context !== undefined && !allowed.includes(entry.context)) {
+                    problems.push(`${field}[${i}] has context "${entry.context}"; ${field} runs in ${allowed.join(", ")}`);
+                }
+                if (!entry.statements || entry.statements.length === 0) {
+                    problems.push(`${field}[${i}] has no statements`);
+                }
+                total += entry.statements?.length ?? 0;
+            });
+        }
+        if (total === 0)
+            problems.push("no statement is set for any signal, so the processor changes nothing");
+        return problems;
+    },
+});
+/** Deletes attributes whose keys aren't allowed, and masks or hashes values that match blocked patterns. */
+export const RedactionProcessor = defineBuiltin({
+    kind: "processor",
+    type: "redaction",
+    description: "Deletes attributes not on an allow list and masks or hashes values that match block patterns",
+    validate: (c) => {
+        const problems = [];
+        if (c.allow_all_keys !== true && c.allowed_keys === undefined) {
+            problems.push("neither allow_all_keys nor allowed_keys is set, so every attribute is deleted; set allow_all_keys: true to keep keys, or allowed_keys: [] if deleting all is intended");
+        }
+        if (c.allow_all_keys === true && c.allowed_keys !== undefined && c.allowed_keys.length > 0) {
+            problems.push("allowed_keys has no effect while allow_all_keys is true");
+        }
+        for (const field of ["blocked_key_patterns", "blocked_values", "allowed_values"]) {
+            (c[field] ?? []).forEach((p, i) => {
+                if (typeof p !== "string" || p === "")
+                    problems.push(`${field}[${i}] is an empty pattern`);
+            });
+        }
+        if (c.hash_function !== undefined && !c.blocked_values?.length && !c.blocked_key_patterns?.length) {
+            problems.push("hash_function is set but nothing is blocked, so nothing is hashed");
+        }
+        return problems;
+    },
+});

package/dist/components/index.js

@@ -0,0 +1,9 @@
+export * from "./common.js";
+export * from "./receivers.js";
+export * from "./k8s-receivers.js";
+export * from "./processors.js";
+export * from "./filtering.js";
+export * from "./exporters.js";
+export * from "./connectors.js";
+export * from "./extensions.js";
+export * from "./sampling.js";