@momentumcms/plugins-otel 0.0.1 → 0.1.2

package/CHANGELOG.md

@@ -1,3 +1,15 @@
+## 0.1.2 (2026-02-16)
+
+### 🩹 Fixes
+
+- **release:** centralize manifestRootsToUpdate to update both source and dist ([2b8f832](https://github.com/DonaldMurillo/momentum-cms/commit/2b8f832))
+- **create-app:** fix Angular SSR, Analog builds, and CJS/ESM compatibility ([28d4d0a](https://github.com/DonaldMurillo/momentum-cms/commit/28d4d0a))
+
+### ❤️ Thank You
+
+- Claude Opus 4.6
+- Donald Murillo @DonaldMurillo
+
 ## 0.1.1 (2026-02-16)
 
 This was a version bump only for plugins-otel to align it with other projects, there were no code changes.

package/index.js

@@ -0,0 +1,327 @@
+// libs/plugins/otel/src/lib/otel-plugin.ts
+import { trace, SpanStatusCode } from "@opentelemetry/api";
+
+// libs/logger/src/lib/log-level.ts
+var LOG_LEVEL_VALUES = {
+  debug: 0,
+  info: 1,
+  warn: 2,
+  error: 3,
+  fatal: 4,
+  silent: 5
+};
+function shouldLog(messageLevel, configuredLevel) {
+  return LOG_LEVEL_VALUES[messageLevel] >= LOG_LEVEL_VALUES[configuredLevel];
+}
+
+// libs/logger/src/lib/ansi-colors.ts
+var ANSI = {
+  reset: "\x1B[0m",
+  bold: "\x1B[1m",
+  dim: "\x1B[2m",
+  // Foreground colors
+  red: "\x1B[31m",
+  green: "\x1B[32m",
+  yellow: "\x1B[33m",
+  blue: "\x1B[34m",
+  magenta: "\x1B[35m",
+  cyan: "\x1B[36m",
+  white: "\x1B[37m",
+  gray: "\x1B[90m",
+  // Background colors
+  bgRed: "\x1B[41m",
+  bgYellow: "\x1B[43m"
+};
+function colorize(text, ...codes) {
+  if (codes.length === 0)
+    return text;
+  return `${codes.join("")}${text}${ANSI.reset}`;
+}
+function supportsColor() {
+  if (process.env["FORCE_COLOR"] === "1")
+    return true;
+  if (process.env["NO_COLOR"] !== void 0)
+    return false;
+  if (process.env["TERM"] === "dumb")
+    return false;
+  return process.stdout.isTTY === true;
+}
+
+// libs/logger/src/lib/formatters.ts
+var LEVEL_COLORS = {
+  debug: [ANSI.dim, ANSI.gray],
+  info: [ANSI.cyan],
+  warn: [ANSI.yellow],
+  error: [ANSI.red],
+  fatal: [ANSI.bold, ANSI.white, ANSI.bgRed]
+};
+function padLevel(level) {
+  return level.toUpperCase().padEnd(5);
+}
+function formatTimestamp(date) {
+  const y = date.getFullYear();
+  const mo = String(date.getMonth() + 1).padStart(2, "0");
+  const d = String(date.getDate()).padStart(2, "0");
+  const h = String(date.getHours()).padStart(2, "0");
+  const mi = String(date.getMinutes()).padStart(2, "0");
+  const s = String(date.getSeconds()).padStart(2, "0");
+  const ms = String(date.getMilliseconds()).padStart(3, "0");
+  return `${y}-${mo}-${d} ${h}:${mi}:${s}.${ms}`;
+}
+function formatData(data) {
+  const entries = Object.entries(data);
+  if (entries.length === 0)
+    return "";
+  return " " + entries.map(([k, v]) => `${k}=${typeof v === "string" ? v : JSON.stringify(v)}`).join(" ");
+}
+function prettyFormatter(entry) {
+  const useColor = supportsColor();
+  const level = entry.level;
+  const ts = formatTimestamp(entry.timestamp);
+  const levelStr = padLevel(entry.level);
+  const ctx = `[${entry.context}]`;
+  const msg = entry.message;
+  const enrichmentStr = entry.enrichments ? formatData(entry.enrichments) : "";
+  const dataStr = entry.data ? formatData(entry.data) : "";
+  const extra = `${enrichmentStr}${dataStr}`;
+  if (useColor) {
+    const colors = LEVEL_COLORS[level];
+    const coloredLevel = colorize(levelStr, ...colors);
+    const coloredCtx = colorize(ctx, ANSI.magenta);
+    const coloredTs = colorize(ts, ANSI.gray);
+    return `${coloredTs} ${coloredLevel} ${coloredCtx} ${msg}${extra}
+`;
+  }
+  return `${ts} ${levelStr} ${ctx} ${msg}${extra}
+`;
+}
+function jsonFormatter(entry) {
+  const output = {
+    timestamp: entry.timestamp.toISOString(),
+    level: entry.level,
+    context: entry.context,
+    message: entry.message
+  };
+  if (entry.enrichments && Object.keys(entry.enrichments).length > 0) {
+    Object.assign(output, entry.enrichments);
+  }
+  if (entry.data && Object.keys(entry.data).length > 0) {
+    output["data"] = entry.data;
+  }
+  return JSON.stringify(output) + "\n";
+}
+
+// libs/logger/src/lib/logger-config.types.ts
+function resolveLoggingConfig(config) {
+  return {
+    level: config?.level ?? "info",
+    format: config?.format ?? "pretty",
+    timestamps: config?.timestamps ?? true,
+    output: config?.output ?? ((msg) => {
+      process.stdout.write(msg);
+    }),
+    errorOutput: config?.errorOutput ?? ((msg) => {
+      process.stderr.write(msg);
+    })
+  };
+}
+
+// libs/logger/src/lib/logger.ts
+var ERROR_LEVELS = /* @__PURE__ */ new Set(["warn", "error", "fatal"]);
+var MomentumLogger = class _MomentumLogger {
+  static {
+    this.enrichers = [];
+  }
+  constructor(context, config) {
+    this.context = context;
+    this.config = isResolvedConfig(config) ? config : resolveLoggingConfig(config);
+    this.formatter = this.config.format === "json" ? jsonFormatter : prettyFormatter;
+  }
+  debug(message, data) {
+    this.log("debug", message, data);
+  }
+  info(message, data) {
+    this.log("info", message, data);
+  }
+  warn(message, data) {
+    this.log("warn", message, data);
+  }
+  error(message, data) {
+    this.log("error", message, data);
+  }
+  fatal(message, data) {
+    this.log("fatal", message, data);
+  }
+  /**
+   * Creates a child logger with a sub-context.
+   * e.g., `Momentum:DB` → `Momentum:DB:Migrate`
+   */
+  child(subContext) {
+    return new _MomentumLogger(`${this.context}:${subContext}`, this.config);
+  }
+  /**
+   * Registers a global enricher that adds extra fields to all log entries.
+   */
+  static registerEnricher(enricher) {
+    _MomentumLogger.enrichers.push(enricher);
+  }
+  /**
+   * Removes a previously registered enricher.
+   */
+  static removeEnricher(enricher) {
+    const index = _MomentumLogger.enrichers.indexOf(enricher);
+    if (index >= 0) {
+      _MomentumLogger.enrichers.splice(index, 1);
+    }
+  }
+  /**
+   * Clears all registered enrichers. Primarily for testing.
+   */
+  static clearEnrichers() {
+    _MomentumLogger.enrichers.length = 0;
+  }
+  log(level, message, data) {
+    if (!shouldLog(level, this.config.level))
+      return;
+    const enrichments = this.collectEnrichments();
+    const entry = {
+      timestamp: /* @__PURE__ */ new Date(),
+      level,
+      context: this.context,
+      message,
+      data,
+      enrichments: Object.keys(enrichments).length > 0 ? enrichments : void 0
+    };
+    const formatted = this.formatter(entry);
+    if (ERROR_LEVELS.has(level)) {
+      this.config.errorOutput(formatted);
+    } else {
+      this.config.output(formatted);
+    }
+  }
+  collectEnrichments() {
+    const result = {};
+    for (const enricher of _MomentumLogger.enrichers) {
+      Object.assign(result, enricher.enrich());
+    }
+    return result;
+  }
+};
+function isResolvedConfig(config) {
+  if (!config)
+    return false;
+  return typeof config.level === "string" && typeof config.format === "string" && typeof config.timestamps === "boolean" && // eslint-disable-next-line @typescript-eslint/consistent-type-assertions -- type guard narrows union
+  typeof config.output === "function" && // eslint-disable-next-line @typescript-eslint/consistent-type-assertions -- type guard narrows union
+  typeof config.errorOutput === "function";
+}
+
+// libs/plugins/otel/src/lib/otel-plugin.ts
+var OtelLogEnricher = class {
+  enrich() {
+    const span = trace.getActiveSpan();
+    if (!span) {
+      return {};
+    }
+    const spanContext = span.spanContext();
+    return {
+      traceId: spanContext.traceId,
+      spanId: spanContext.spanId
+    };
+  }
+};
+function otelPlugin(config = {}) {
+  const { serviceName = "momentum-cms", enrichLogs = true, attributes = {}, operations } = config;
+  let tracer;
+  let enricher = null;
+  return {
+    name: "otel",
+    onInit({ collections, logger }) {
+      tracer = trace.getTracer(serviceName);
+      logger.info(`OpenTelemetry tracing enabled (service: ${serviceName})`);
+      if (enrichLogs) {
+        enricher = new OtelLogEnricher();
+        MomentumLogger.registerEnricher(enricher);
+        logger.info("Log enricher registered for trace/span IDs");
+      }
+      for (const collection of collections) {
+        injectTracingHooks(collection, tracer, attributes, operations);
+      }
+      logger.info(`Tracing hooks injected into ${collections.length} collections`);
+    },
+    onShutdown({ logger }) {
+      if (enricher) {
+        MomentumLogger.removeEnricher(enricher);
+        enricher = null;
+      }
+      logger.info("OpenTelemetry plugin shut down");
+    }
+  };
+}
+function injectTracingHooks(collection, tracer, attributes, operationFilter) {
+  collection.hooks = collection.hooks ?? {};
+  const beforeChangeHook = (args) => {
+    const operation = args.operation ?? "create";
+    if (operationFilter && !operationFilter.includes(operation)) {
+      return args.data;
+    }
+    const span = tracer.startSpan(`${collection.slug}.${operation}`, {
+      attributes: {
+        "momentum.collection": collection.slug,
+        "momentum.operation": operation,
+        ...attributes
+      }
+    });
+    if (args.data) {
+      args.data["__otelSpan"] = span;
+    }
+    return args.data;
+  };
+  const afterChangeHook = (args) => {
+    const doc = args.doc ?? args.data ?? {};
+    const span = doc["__otelSpan"];
+    if (span && typeof span === "object" && "end" in span) {
+      const typedSpan = span;
+      typedSpan.setStatus({ code: SpanStatusCode.OK });
+      typedSpan.end();
+    }
+    if (args.doc) {
+      delete args.doc["__otelSpan"];
+    }
+  };
+  const beforeDeleteHook = (args) => {
+    if (operationFilter && !operationFilter.includes("delete")) {
+      return;
+    }
+    const span = tracer.startSpan(`${collection.slug}.delete`, {
+      attributes: {
+        "momentum.collection": collection.slug,
+        "momentum.operation": "delete",
+        "momentum.documentId": args.doc?.["id"] ? String(args.doc["id"]) : "unknown",
+        ...attributes
+      }
+    });
+    if (args.doc) {
+      args.doc["__otelSpan"] = span;
+    }
+  };
+  const afterDeleteHook = (args) => {
+    const doc = args.doc ?? {};
+    const span = doc["__otelSpan"];
+    if (span && typeof span === "object" && "end" in span) {
+      const typedSpan = span;
+      typedSpan.setStatus({ code: SpanStatusCode.OK });
+      typedSpan.end();
+    }
+  };
+  const existingBeforeChange = collection.hooks.beforeChange ?? [];
+  collection.hooks.beforeChange = [beforeChangeHook, ...existingBeforeChange];
+  const existingAfterChange = collection.hooks.afterChange ?? [];
+  collection.hooks.afterChange = [...existingAfterChange, afterChangeHook];
+  const existingBeforeDelete = collection.hooks.beforeDelete ?? [];
+  collection.hooks.beforeDelete = [beforeDeleteHook, ...existingBeforeDelete];
+  const existingAfterDelete = collection.hooks.afterDelete ?? [];
+  collection.hooks.afterDelete = [...existingAfterDelete, afterDeleteHook];
+}
+export {
+  otelPlugin
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@momentumcms/plugins-otel",
-  "version": "0.0.1",
+  "version": "0.1.2",
   "description": "OpenTelemetry observability plugin for Momentum CMS",
   "license": "MIT",
   "author": "Momentum CMS Contributors",
@@ -24,14 +24,14 @@
   "engines": {
     "node": ">=18"
   },
-  "type": "commonjs",
   "main": "./index.cjs",
   "types": "./src/index.d.ts",
   "peerDependencies": {
-    "@momentumcms/core": "0.0.1",
-    "@momentumcms/logger": "0.0.1",
-    "@momentumcms/plugins-core": "0.0.1",
+    "@momentumcms/core": "0.1.2",
+    "@momentumcms/logger": "0.1.2",
+    "@momentumcms/plugins-core": "0.1.2",
     "@opentelemetry/api": "^1.0.0"
   },
-  "dependencies": {}
+  "dependencies": {},
+  "module": "./index.js"
 }