@intentius/chant-lexicon-otel 0.124.30 → 0.124.32

package/dist/validate.js

@@ -0,0 +1,85 @@
+/**
+ * Validate the otel lexicon's own artifacts: every built-in class is in the
+ * registry, every built-in definition carries the collector pin, and every
+ * built-in constructs and serializes.
+ */
+import { BUILTIN_CATALOG, lexiconRegistry } from "./catalog.js";
+import * as components from "./components/index.js";
+import { COLLECTOR_PIN } from "./define.js";
+import { collectorYaml } from "./collector.js";
+/** Every entity class the package must keep exporting. */
+export const REQUIRED_NAMES = [
+    "OtlpReceiver",
+    "PrometheusReceiver",
+    "HostMetricsReceiver",
+    "FileLogReceiver",
+    "K8sClusterReceiver",
+    "KubeletStatsReceiver",
+    "BatchProcessor",
+    "MemoryLimiterProcessor",
+    "ResourceProcessor",
+    "AttributesProcessor",
+    "K8sAttributesProcessor",
+    "ResourceDetectionProcessor",
+    "FilterProcessor",
+    "TransformProcessor",
+    "RedactionProcessor",
+    "TailSamplingProcessor",
+    "ProbabilisticSamplerProcessor",
+    "DeltaToCumulativeProcessor",
+    "OtlpExporter",
+    "OtlpHttpExporter",
+    "DebugExporter",
+    "PrometheusExporter",
+    "GoogleCloudExporter",
+    "LoadBalancingExporter",
+    "SpanMetricsConnector",
+    "ServiceGraphConnector",
+    "RoutingConnector",
+    "ForwardConnector",
+    "CountConnector",
+    "SumConnector",
+    "SignalToMetricsConnector",
+    "HealthCheckExtension",
+    "PprofExtension",
+    "ZPagesExtension",
+    "K8sLeaderElectorExtension",
+    "Pipeline",
+    "Service",
+];
+export async function validate() {
+    const checks = [];
+    const registry = lexiconRegistry();
+    const missing = REQUIRED_NAMES.filter((n) => !(n in registry));
+    checks.push(missing.length === 0
+        ? { name: "required-names", ok: true }
+        : { name: "required-names", ok: false, error: `Missing required names: ${missing.join(", ")}` });
+    // The list names every entity the registry has, so a new built-in is held to it from the start.
+    const unlisted = Object.keys(registry).filter((n) => !REQUIRED_NAMES.includes(n));
+    checks.push(unlisted.length === 0
+        ? { name: "required-names-complete", ok: true }
+        : { name: "required-names-complete", ok: false, error: `In the registry but not in REQUIRED_NAMES: ${unlisted.join(", ")}` });
+    const classes = Object.entries(components).filter((e) => typeof e[1] === "function" && "definition" in e[1]);
+    const unpinned = classes.filter(([, c]) => c.definition.pin !== COLLECTOR_PIN || !c.definition.builtin).map(([n]) => n);
+    checks.push(unpinned.length === 0
+        ? { name: "builtins-pinned", ok: true }
+        : { name: "builtins-pinned", ok: false, error: `Not pinned to the collector release: ${unpinned.join(", ")}` });
+    const broken = [];
+    for (const [name, Cls] of classes) {
+        try {
+            const yaml = collectorYaml([new Cls({})]);
+            if (!yaml.includes(Cls.definition.type))
+                broken.push(name);
+        }
+        catch (err) {
+            broken.push(`${name} (${err instanceof Error ? err.message : String(err)})`);
+        }
+    }
+    checks.push(broken.length === 0
+        ? { name: "builtins-serialize", ok: true }
+        : { name: "builtins-serialize", ok: false, error: `Failed to serialize: ${broken.join(", ")}` });
+    checks.push(BUILTIN_CATALOG.length === Object.keys(registry).length
+        ? { name: "catalog-matches-registry", ok: true }
+        : { name: "catalog-matches-registry", ok: false, error: "catalog and registry disagree" });
+    return { success: checks.every((c) => c.ok), checks };
+}

package/dist/yaml.js

@@ -0,0 +1,157 @@
+/**
+ * The collector YAML emitter.
+ *
+ * Its style is the one collector configs are usually written in, and the one
+ * the k8s lexicon's `GkeOtelCollector` wrote by hand before it moved onto this
+ * lexicon:
+ *
+ * - top-level sections in the order receivers, processors, exporters,
+ *   connectors, extensions, service, separated by a blank line;
+ * - two-space indent;
+ * - a list of scalars in flow style (`receivers: [otlp, batch]`), any other
+ *   list in block style with `- ` indented under its key;
+ * - strings plain where YAML reads them back as the same string, double-quoted
+ *   otherwise (`"true"`, `"8080"`, `"a: b"`, `"${env:X}"` inside a flow list).
+ *
+ * The output always parses back to the value it was given.
+ */
+const SECTION_ORDER = ["receivers", "processors", "exporters", "connectors", "extensions", "service"];
+const RESERVED = new Set(["true", "false", "null", "yes", "no", "on", "off", "y", "n", "~"]);
+const LEADING_INDICATOR = /^[-?:,[\]{}#&*!|>'"%@`]/;
+function isPlainObject(v) {
+    return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+function isScalar(v) {
+    return v === null || typeof v === "string" || typeof v === "number" || typeof v === "boolean";
+}
+/** True when `s` can be written unquoted and still read back as the string `s`. */
+export function isPlainSafe(s, flow) {
+    if (s === "")
+        return false;
+    if (/^\s|\s$/.test(s))
+        return false;
+    if (/[\n\r\t\u0000-\u001f\u007f]/.test(s))
+        return false;
+    if (RESERVED.has(s.toLowerCase()))
+        return false;
+    if (!Number.isNaN(Number(s)))
+        return false;
+    if (/^[-+]?\.(inf|nan)$/i.test(s))
+        return false;
+    if (/^0[xob]/i.test(s))
+        return false;
+    if (/^\d+(:\d+)+$/.test(s))
+        return false;
+    if (LEADING_INDICATOR.test(s))
+        return false;
+    if (s.includes(": ") || s.includes(" #") || s.endsWith(":"))
+        return false;
+    if (flow && /[,[\]{}]/.test(s))
+        return false;
+    return true;
+}
+function scalar(v, flow) {
+    if (v === null)
+        return "null";
+    if (typeof v === "boolean")
+        return v ? "true" : "false";
+    if (typeof v === "number")
+        return Number.isFinite(v) ? String(v) : JSON.stringify(String(v));
+    if (typeof v === "string")
+        return isPlainSafe(v, flow) ? v : JSON.stringify(v);
+    return JSON.stringify(String(v));
+}
+function key(k) {
+    return isPlainSafe(k, false) ? k : JSON.stringify(k);
+}
+function emitMap(obj, indent, out) {
+    const pad = " ".repeat(indent);
+    for (const [k, v] of Object.entries(obj)) {
+        if (v === undefined)
+            continue;
+        const kk = key(k);
+        if (v === null) {
+            out.push(`${pad}${kk}:`);
+        }
+        else if (isPlainObject(v)) {
+            if (Object.values(v).every((x) => x === undefined)) {
+                out.push(`${pad}${kk}: {}`);
+            }
+            else {
+                out.push(`${pad}${kk}:`);
+                emitMap(v, indent + 2, out);
+            }
+        }
+        else if (Array.isArray(v)) {
+            emitList(kk, v, indent, out);
+        }
+        else {
+            out.push(`${pad}${kk}: ${scalar(v, false)}`);
+        }
+    }
+}
+function emitList(kk, list, indent, out) {
+    const pad = " ".repeat(indent);
+    if (list.length === 0) {
+        out.push(`${pad}${kk}: []`);
+        return;
+    }
+    if (list.every((x) => isScalar(x))) {
+        out.push(`${pad}${kk}: [${list.map((x) => scalar(x, true)).join(", ")}]`);
+        return;
+    }
+    out.push(`${pad}${kk}:`);
+    for (const item of list)
+        emitItem(item, indent + 2, out);
+}
+function emitItem(item, indent, out) {
+    const pad = " ".repeat(indent);
+    if (isPlainObject(item) && Object.values(item).some((x) => x !== undefined)) {
+        const lines = [];
+        emitMap(item, indent + 2, lines);
+        lines[0] = `${pad}- ${lines[0].slice(indent + 2)}`;
+        out.push(...lines);
+    }
+    else if (isPlainObject(item)) {
+        out.push(`${pad}- {}`);
+    }
+    else if (Array.isArray(item)) {
+        if (item.length === 0) {
+            out.push(`${pad}- []`);
+        }
+        else if (item.every((x) => isScalar(x))) {
+            out.push(`${pad}- [${item.map((x) => scalar(x, true)).join(", ")}]`);
+        }
+        else {
+            out.push(`${pad}-`);
+            for (const inner of item)
+                emitItem(inner, indent + 2, out);
+        }
+    }
+    else {
+        out.push(`${pad}- ${scalar(item, false)}`);
+    }
+}
+/** Print a collector config as YAML. Empty sections are left out. */
+export function emitCollectorYaml(config, options = {}) {
+    const blocks = [];
+    if (options.header && options.header.length > 0) {
+        blocks.push(options.header.map((l) => `# ${l}`).join("\n"));
+    }
+    const cfg = config;
+    const known = new Set(SECTION_ORDER);
+    const order = [...SECTION_ORDER, ...Object.keys(cfg).filter((k) => !known.has(k))];
+    for (const section of order) {
+        const value = cfg[section];
+        if (value === undefined)
+            continue;
+        if (isPlainObject(value) && Object.values(value).every((x) => x === undefined))
+            continue;
+        const lines = [];
+        emitMap({ [section]: value }, 0, lines);
+        blocks.push(lines.join("\n"));
+    }
+    if (blocks.length === 0)
+        return "";
+    return `${blocks.join("\n\n")}\n`;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@intentius/chant-lexicon-otel",
-  "version": "0.124.30",
+  "version": "0.124.32",
   "description": "OpenTelemetry Collector lexicon for chant — typed receivers, processors, exporters, connectors, extensions and pipelines, serialized to collector YAML",
   "license": "Apache-2.0",
   "homepage": "https://intentius.io/chant",
@@ -34,27 +34,27 @@
     ".": {
       "development": "./src/index.ts",
       "types": "./dist/index.d.ts",
-      "default": "./src/index.ts"
+      "default": "./dist/index.js"
     },
     "./*": {
       "development": "./src/*.ts",
       "types": "./dist/*.d.ts",
-      "default": "./src/*.ts"
+      "default": "./dist/*.js"
     },
     "./op/activities": {
       "development": "./src/op/activities/index.ts",
       "types": "./dist/op/activities/index.d.ts",
-      "default": "./src/op/activities/index.ts"
+      "default": "./dist/op/activities/index.js"
     },
     "./op/activity-contracts": {
       "development": "./src/op/activity-contracts.ts",
       "types": "./dist/op/activity-contracts.d.ts",
-      "default": "./src/op/activity-contracts.ts"
+      "default": "./dist/op/activity-contracts.js"
     },
     "./lint/post-synth": {
       "development": "./src/lint/post-synth/index.ts",
       "types": "./dist/lint/post-synth/index.d.ts",
-      "default": "./src/lint/post-synth/index.ts"
+      "default": "./dist/lint/post-synth/index.js"
     },
     "./manifest": "./dist/manifest.json",
     "./meta": "./dist/meta.json",
@@ -66,7 +66,7 @@
     "validate": "tsx src/validate-cli.ts",
     "docs": "tsx src/codegen/docs-cli.ts",
     "prepack": "npm run generate && npm run bundle && npm run validate && npm run build",
-    "build": "../../scripts/tsc7.sh -p tsconfig.build.json && tsc-alias -p tsconfig.build.json && find dist -type f \\( -name \"*.js\" -o -name \"*.js.map\" \\) -delete"
+    "build": "../../scripts/tsc7.sh -p tsconfig.build.json --sourceMap false && tsc-alias -p tsconfig.build.json"
   },
   "dependencies": {
     "js-yaml": "^4.3.1",
@@ -79,6 +79,6 @@
     "typescript": "^5.9.3"
   },
   "peerDependencies": {
-    "@intentius/chant": "^0.124.30"
+    "@intentius/chant": "^0.124.32"
   }
 }

package/src/codegen/package.ts

@@ -4,7 +4,7 @@
 
 import { readFileSync } from "fs";
 import { join, dirname } from "path";
-import { fileURLToPath } from "url";
+import { moduleSourceDir } from "@intentius/chant/module-source";
 import {
   packagePipeline,
   collectSkills,
@@ -17,7 +17,7 @@ import { otelSkills } from "../skill-defs";
 export type { PackageOptions, PackageResult };
 
 // src/codegen/package.ts -> src/
-const srcDir = dirname(dirname(fileURLToPath(import.meta.url)));
+const srcDir = dirname(moduleSourceDir(import.meta.url));
 
 export async function packageLexicon(opts: PackageOptions = {}): Promise<PackageResult> {
   const pkgJson = JSON.parse(readFileSync(join(srcDir, "..", "package.json"), "utf-8"));