@momentumcms/plugins-otel 0.5.3 → 0.5.5

package/index.cjs

@@ -58,10 +58,10 @@ var ANSI = {
   bgRed: "\x1B[41m",
   bgYellow: "\x1B[43m"
 };
-function colorize(text, ...codes) {
+function colorize(text2, ...codes) {
   if (codes.length === 0)
-    return text;
-  return `${codes.join("")}${text}${ANSI.reset}`;
+    return text2;
+  return `${codes.join("")}${text2}${ANSI.reset}`;
 }
 function supportsColor() {
   if (process.env["FORCE_COLOR"] === "1")
@@ -84,14 +84,14 @@ var LEVEL_COLORS = {
 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");
+function formatTimestamp(date2) {
+  const y = date2.getFullYear();
+  const mo = String(date2.getMonth() + 1).padStart(2, "0");
+  const d = String(date2.getDate()).padStart(2, "0");
+  const h = String(date2.getHours()).padStart(2, "0");
+  const mi = String(date2.getMinutes()).padStart(2, "0");
+  const s = String(date2.getSeconds()).padStart(2, "0");
+  const ms = String(date2.getMilliseconds()).padStart(3, "0");
   return `${y}-${mo}-${d} ${h}:${mi}:${s}.${ms}`;
 }
 function formatData(data) {
@@ -241,7 +241,929 @@ function isResolvedConfig(config) {
   typeof config.errorOutput === "function";
 }
 
+// libs/logger/src/lib/logger-singleton.ts
+var loggerInstance = null;
+var ROOT_CONTEXT = "Momentum";
+function getMomentumLogger() {
+  if (!loggerInstance) {
+    loggerInstance = new MomentumLogger(ROOT_CONTEXT);
+  }
+  return loggerInstance;
+}
+function createLogger(context) {
+  return getMomentumLogger().child(context);
+}
+
+// libs/plugins/otel/src/lib/metrics/metrics-store.ts
+var MetricsStore = class {
+  constructor(maxSpans = 100) {
+    this.startTime = Date.now();
+    this.recentSpans = [];
+    this.collectionMetrics = /* @__PURE__ */ new Map();
+    this.activeRequests = 0;
+    // HTTP request metrics
+    this.totalRequests = 0;
+    this.totalDurationMs = 0;
+    this.errorCount = 0;
+    this.byMethod = /* @__PURE__ */ new Map();
+    this.byStatusCode = /* @__PURE__ */ new Map();
+    this.maxSpans = maxSpans;
+  }
+  recordSpan(span) {
+    this.recentSpans.push(span);
+    if (this.recentSpans.length > this.maxSpans) {
+      this.recentSpans.shift();
+    }
+  }
+  recordCollectionOperation(collection, operation, durationMs) {
+    let entry = this.collectionMetrics.get(collection);
+    if (!entry) {
+      entry = { creates: 0, updates: 0, deletes: 0, totalDurationMs: 0, operationCount: 0 };
+      this.collectionMetrics.set(collection, entry);
+    }
+    if (operation === "create")
+      entry.creates++;
+    else if (operation === "update")
+      entry.updates++;
+    else if (operation === "delete")
+      entry.deletes++;
+    entry.totalDurationMs += durationMs;
+    entry.operationCount++;
+  }
+  recordHttpRequest(method, statusCode, durationMs) {
+    this.totalRequests++;
+    this.totalDurationMs += durationMs;
+    if (statusCode >= 400)
+      this.errorCount++;
+    const methodUpper = method.toUpperCase();
+    this.byMethod.set(methodUpper, (this.byMethod.get(methodUpper) ?? 0) + 1);
+    const statusKey = String(statusCode);
+    this.byStatusCode.set(statusKey, (this.byStatusCode.get(statusKey) ?? 0) + 1);
+  }
+  incrementActiveRequests() {
+    this.activeRequests++;
+  }
+  decrementActiveRequests() {
+    this.activeRequests = Math.max(0, this.activeRequests - 1);
+  }
+  getSnapshotData() {
+    const collectionMetrics = this.buildCollectionMetrics();
+    const topSpans = [...this.recentSpans].sort((a, b) => b.durationMs - a.durationMs).slice(0, 5);
+    return {
+      totalRequests: this.totalRequests,
+      errorCount: this.errorCount,
+      avgDurationMs: this.totalRequests > 0 ? Math.round(this.totalDurationMs / this.totalRequests) : 0,
+      memoryUsageMb: Math.round(process.memoryUsage().heapUsed / 1024 / 1024),
+      byMethod: Object.fromEntries(this.byMethod),
+      byStatusCode: Object.fromEntries(this.byStatusCode),
+      collectionMetrics,
+      topSpans
+    };
+  }
+  restore(snapshot) {
+    this.totalRequests = snapshot.totalRequests;
+    this.errorCount = snapshot.errorCount;
+    this.totalDurationMs = snapshot.avgDurationMs * snapshot.totalRequests;
+    this.byMethod.clear();
+    for (const [method, count] of Object.entries(snapshot.byMethod)) {
+      this.byMethod.set(method, count);
+    }
+    this.byStatusCode.clear();
+    for (const [status, count] of Object.entries(snapshot.byStatusCode)) {
+      this.byStatusCode.set(status, count);
+    }
+    this.collectionMetrics.clear();
+    for (const cm of snapshot.collectionMetrics) {
+      const totalOps = cm.creates + cm.updates + cm.deletes;
+      this.collectionMetrics.set(cm.collection, {
+        creates: cm.creates,
+        updates: cm.updates,
+        deletes: cm.deletes,
+        totalDurationMs: cm.avgDurationMs * totalOps,
+        operationCount: totalOps
+      });
+    }
+  }
+  buildCollectionMetrics() {
+    return Array.from(this.collectionMetrics.entries()).map(
+      ([collection, entry]) => ({
+        collection,
+        creates: entry.creates,
+        updates: entry.updates,
+        deletes: entry.deletes,
+        avgDurationMs: entry.operationCount > 0 ? Math.round(entry.totalDurationMs / entry.operationCount) : 0
+      })
+    );
+  }
+  getSummary() {
+    const collectionMetrics = this.buildCollectionMetrics();
+    return {
+      uptime: Math.round((Date.now() - this.startTime) / 1e3),
+      activeRequests: this.activeRequests,
+      memoryUsageMb: Math.round(process.memoryUsage().heapUsed / 1024 / 1024),
+      requestMetrics: {
+        totalRequests: this.totalRequests,
+        avgDurationMs: this.totalRequests > 0 ? Math.round(this.totalDurationMs / this.totalRequests) : 0,
+        errorCount: this.errorCount,
+        byMethod: Object.fromEntries(this.byMethod),
+        byStatusCode: Object.fromEntries(this.byStatusCode)
+      },
+      collectionMetrics,
+      recentSpans: [...this.recentSpans].reverse()
+    };
+  }
+};
+
+// libs/plugins/otel/src/lib/metrics/request-metrics.ts
+var import_express = require("express");
+
+// libs/plugins/otel/src/lib/metrics/otel-helpers.ts
+function createRequestInstruments(meter) {
+  return {
+    requestDuration: meter.createHistogram("http.server.request.duration", {
+      description: "HTTP request duration in seconds",
+      unit: "s"
+    }),
+    requestTotal: meter.createCounter("http.server.request.total", {
+      description: "Total HTTP requests"
+    }),
+    activeRequests: meter.createUpDownCounter("http.server.active_requests", {
+      description: "Number of active HTTP requests"
+    })
+  };
+}
+function createCollectionInstruments(meter) {
+  return {
+    operationTotal: meter.createCounter("momentum.collection.operation.total", {
+      description: "Total collection operations"
+    }),
+    operationDuration: meter.createHistogram("momentum.collection.operation.duration", {
+      description: "Collection operation duration in seconds",
+      unit: "s"
+    })
+  };
+}
+function tryLoadOtelSdk(serviceName) {
+  try {
+    const sdkMetrics = require("@opentelemetry/sdk-metrics");
+    const promExporter = require("@opentelemetry/exporter-prometheus");
+    const exporter = new promExporter.PrometheusExporter({
+      preventServerStart: true
+    });
+    const provider = new sdkMetrics.MeterProvider({
+      readers: [exporter]
+    });
+    return {
+      meter: provider.getMeter(serviceName),
+      provider,
+      exporter
+    };
+  } catch {
+    return null;
+  }
+}
+function getSpanContext(doc) {
+  const span = doc["__otelSpan"];
+  if (span == null || typeof span !== "object")
+    return null;
+  if (!("spanContext" in span))
+    return null;
+  const spanContextFn = span["spanContext"];
+  if (typeof spanContextFn !== "function")
+    return null;
+  const ctx = spanContextFn.call(span);
+  if (ctx == null || typeof ctx !== "object")
+    return null;
+  if (!("traceId" in ctx) || !("spanId" in ctx))
+    return null;
+  const traceId = typeof ctx["traceId"] === "string" ? ctx["traceId"] : "";
+  const spanId = typeof ctx["spanId"] === "string" ? ctx["spanId"] : "";
+  return { traceId, spanId };
+}
+
+// libs/plugins/otel/src/lib/metrics/request-metrics.ts
+function createRequestMetricsMiddleware(options) {
+  const { store } = options;
+  let instruments = null;
+  if (options.meter) {
+    instruments = createRequestInstruments(options.meter);
+  }
+  const router = (0, import_express.Router)();
+  router.use((req, res, next) => {
+    const start = process.hrtime.bigint();
+    store.incrementActiveRequests();
+    instruments?.activeRequests.add(1);
+    res.on("finish", () => {
+      const durationNs = Number(process.hrtime.bigint() - start);
+      const durationMs = durationNs / 1e6;
+      const durationSec = durationNs / 1e9;
+      const method = req.method;
+      const statusCode = res.statusCode;
+      const route = req.route?.path ?? req.path;
+      const attrs = {
+        method,
+        route,
+        status_code: String(statusCode)
+      };
+      instruments?.requestDuration.record(durationSec, attrs);
+      instruments?.requestTotal.add(1, attrs);
+      instruments?.activeRequests.add(-1);
+      store.decrementActiveRequests();
+      store.recordHttpRequest(method, statusCode, durationMs);
+    });
+    next();
+  });
+  return router;
+}
+
+// libs/plugins/otel/src/lib/metrics/collection-metrics.ts
+var EXCLUDED_COLLECTIONS = /* @__PURE__ */ new Set(["otel-snapshots"]);
+var TRACKED_OPERATIONS = /* @__PURE__ */ new Set(["create", "update", "delete"]);
+function isTrackedOperation(op) {
+  return TRACKED_OPERATIONS.has(op);
+}
+function calcDurationMs(startTime) {
+  if (typeof startTime === "bigint") {
+    return Number(process.hrtime.bigint() - startTime) / 1e6;
+  }
+  return 0;
+}
+function buildSpanRecord(doc, slug2, operation, durationMs) {
+  const spanCtx = getSpanContext(doc);
+  return {
+    traceId: spanCtx?.traceId ?? "",
+    spanId: spanCtx?.spanId ?? "",
+    name: `${slug2}.${operation}`,
+    collection: slug2,
+    operation,
+    durationMs: Math.round(durationMs),
+    status: "ok",
+    timestamp: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+function injectCollectionMetricsHooks(collections, options) {
+  const { store } = options;
+  let instruments = null;
+  if (options.meter) {
+    instruments = createCollectionInstruments(options.meter);
+  }
+  for (const collection of collections) {
+    if (EXCLUDED_COLLECTIONS.has(collection.slug))
+      continue;
+    collection.hooks = collection.hooks ?? {};
+    const beforeChangeHook = (args) => {
+      const operation = args.operation ?? "create";
+      if (options.operations && !options.operations.includes(operation)) {
+        return args.data;
+      }
+      if (args.data) {
+        args.data["__metricsStart"] = process.hrtime.bigint();
+      }
+      return args.data;
+    };
+    const afterChangeHook = (args) => {
+      const doc = args.doc ?? args.data ?? {};
+      const operation = args.operation ?? "create";
+      if (options.operations && !options.operations.includes(operation)) {
+        return;
+      }
+      const durationMs = calcDurationMs(doc["__metricsStart"]);
+      const attrs = { collection: collection.slug, operation };
+      instruments?.operationTotal.add(1, attrs);
+      instruments?.operationDuration.record(durationMs / 1e3, attrs);
+      if (isTrackedOperation(operation)) {
+        store.recordCollectionOperation(collection.slug, operation, durationMs);
+      }
+      store.recordSpan(buildSpanRecord(doc, collection.slug, operation, durationMs));
+      if (args.doc) {
+        delete args.doc["__metricsStart"];
+      }
+      if (args.data) {
+        delete args.data["__metricsStart"];
+      }
+    };
+    const beforeDeleteHook = (args) => {
+      if (options.operations && !options.operations.includes("delete")) {
+        return;
+      }
+      if (args.doc) {
+        args.doc["__metricsStart"] = process.hrtime.bigint();
+      }
+    };
+    const afterDeleteHook = (args) => {
+      if (options.operations && !options.operations.includes("delete")) {
+        return;
+      }
+      const doc = args.doc ?? {};
+      const durationMs = calcDurationMs(doc["__metricsStart"]);
+      const attrs = { collection: collection.slug, operation: "delete" };
+      instruments?.operationTotal.add(1, attrs);
+      instruments?.operationDuration.record(durationMs / 1e3, attrs);
+      store.recordCollectionOperation(collection.slug, "delete", durationMs);
+      store.recordSpan(buildSpanRecord(doc, collection.slug, "delete", durationMs));
+    };
+    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];
+  }
+}
+
+// libs/plugins/otel/src/lib/api/otel-query-handler.ts
+var import_express2 = require("express");
+
+// libs/plugins/otel/src/lib/api/otel-api-guards.ts
+function isFindable(val) {
+  return val != null && typeof val === "object" && "find" in val;
+}
+function isCreatable(val) {
+  return val != null && typeof val === "object" && "create" in val;
+}
+function isDeletable(val) {
+  return val != null && typeof val === "object" && "delete" in val;
+}
+function isRecord(val) {
+  return val != null && typeof val === "object" && !Array.isArray(val);
+}
+
+// libs/plugins/otel/src/lib/api/otel-query-handler.ts
+var logger = createLogger("OTel-API");
+function getUser(req) {
+  if (!("user" in req))
+    return null;
+  const user = req["user"];
+  if (user == null || typeof user !== "object")
+    return null;
+  if (!("id" in user))
+    return null;
+  return user;
+}
+function isAuthenticated(req) {
+  return getUser(req) != null;
+}
+function isAdmin(req) {
+  const user = getUser(req);
+  if (!user)
+    return false;
+  return "role" in user && user["role"] === "admin";
+}
+function requireAdmin(req, res) {
+  if (!isAuthenticated(req)) {
+    res.status(401).json({ error: "Authentication required" });
+    return false;
+  }
+  if (!isAdmin(req)) {
+    res.status(403).json({ error: "Admin role required" });
+    return false;
+  }
+  return true;
+}
+function buildTimeRangeWhere(req) {
+  const where = {};
+  const from = req.query["from"];
+  const to = req.query["to"];
+  if (typeof from === "string" || typeof to === "string") {
+    const createdAt = {};
+    if (typeof from === "string")
+      createdAt["gte"] = from;
+    if (typeof to === "string")
+      createdAt["lte"] = to;
+    where["createdAt"] = createdAt;
+  }
+  return where;
+}
+function createOtelQueryRouter(store, getApi, snapshotService) {
+  const router = (0, import_express2.Router)();
+  router.get("/summary", (req, res) => {
+    if (!requireAdmin(req, res))
+      return;
+    res.json(store.getSummary());
+  });
+  router.get("/history", async (req, res) => {
+    if (!requireAdmin(req, res))
+      return;
+    try {
+      const api = getApi?.();
+      if (!api) {
+        res.json({ snapshots: [], total: 0 });
+        return;
+      }
+      const ops = api.setContext({ overrideAccess: true }).collection("otel-snapshots");
+      if (!isFindable(ops)) {
+        res.json({ snapshots: [], total: 0 });
+        return;
+      }
+      const limit = Math.min(Number(req.query["limit"]) || 100, 500);
+      const page = Math.max(Number(req.query["page"]) || 1, 1);
+      const where = buildTimeRangeWhere(req);
+      const result = await ops.find({ where, limit, page, sort: "-createdAt" });
+      const docs = Array.isArray(result.docs) ? result.docs : [];
+      res.json({
+        snapshots: docs,
+        total: typeof result.totalDocs === "number" ? result.totalDocs : docs.length
+      });
+    } catch (err) {
+      logger.error("Failed to fetch history", { error: String(err) });
+      res.status(500).json({ error: "Failed to fetch metrics history" });
+    }
+  });
+  router.delete("/history", async (req, res) => {
+    if (!requireAdmin(req, res))
+      return;
+    try {
+      const deleted = await snapshotService?.purgeAll() ?? 0;
+      res.json({ deleted });
+    } catch (err) {
+      logger.error("Failed to purge history", { error: String(err) });
+      res.status(500).json({ error: "Failed to purge metrics history" });
+    }
+  });
+  router.get("/export", async (req, res) => {
+    if (!requireAdmin(req, res))
+      return;
+    try {
+      const api = getApi?.();
+      if (!api) {
+        res.status(503).json({ error: "API not available" });
+        return;
+      }
+      const ops = api.setContext({ overrideAccess: true }).collection("otel-snapshots");
+      if (!isFindable(ops)) {
+        res.status(503).json({ error: "Snapshots collection not available" });
+        return;
+      }
+      const where = buildTimeRangeWhere(req);
+      const date2 = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+      res.setHeader("Content-Type", "text/csv");
+      res.setHeader("Content-Disposition", `attachment; filename="otel-metrics-${date2}.csv"`);
+      res.write(
+        "timestamp,totalRequests,errorCount,avgDurationMs,memoryUsageMb,byMethod,byStatusCode,collectionMetrics\n"
+      );
+      let currentPage = 1;
+      let hasMore = true;
+      const batchSize = 50;
+      while (hasMore) {
+        const result = await ops.find({
+          where,
+          limit: batchSize,
+          page: currentPage,
+          sort: "-createdAt"
+        });
+        const docs = Array.isArray(result.docs) ? result.docs : [];
+        if (docs.length === 0) {
+          hasMore = false;
+          break;
+        }
+        for (const doc of docs) {
+          if (!isRecord(doc))
+            continue;
+          const timestamp = typeof doc["createdAt"] === "string" ? doc["createdAt"] : "";
+          const totalReqs = typeof doc["totalRequests"] === "number" ? doc["totalRequests"] : 0;
+          const errors = typeof doc["errorCount"] === "number" ? doc["errorCount"] : 0;
+          const avgMs = typeof doc["avgDurationMs"] === "number" ? doc["avgDurationMs"] : 0;
+          const memMb = typeof doc["memoryUsageMb"] === "number" ? doc["memoryUsageMb"] : 0;
+          const byMethod = csvEscape(JSON.stringify(doc["byMethod"] ?? {}));
+          const byStatus = csvEscape(JSON.stringify(doc["byStatusCode"] ?? {}));
+          const colMetrics = csvEscape(JSON.stringify(doc["collectionMetrics"] ?? []));
+          res.write(
+            `${timestamp},${totalReqs},${errors},${avgMs},${memMb},${byMethod},${byStatus},${colMetrics}
+`
+          );
+        }
+        const totalPages = typeof result.totalPages === "number" ? result.totalPages : 1;
+        hasMore = currentPage < totalPages;
+        currentPage++;
+      }
+      res.end();
+    } catch (err) {
+      logger.error("Failed to export metrics", { error: String(err) });
+      if (!res.headersSent) {
+        res.status(500).json({ error: "Failed to export metrics" });
+      } else {
+        res.end();
+      }
+    }
+  });
+  return router;
+}
+function csvEscape(value) {
+  if (value.includes(",") || value.includes('"') || value.includes("\n")) {
+    return `"${value.replace(/"/g, '""')}"`;
+  }
+  return value;
+}
+
+// libs/plugins/otel/src/lib/exporters/prometheus-handler.ts
+var import_express3 = require("express");
+function hasMetricsHandler(exporter) {
+  if (exporter == null || typeof exporter !== "object")
+    return false;
+  if (!("getMetricsRequestHandler" in exporter))
+    return false;
+  return typeof exporter["getMetricsRequestHandler"] === "function";
+}
+function createPrometheusHandler(options) {
+  const router = (0, import_express3.Router)();
+  const exporter = options.exporter;
+  const canServe = hasMetricsHandler(exporter);
+  router.get("/", (req, res) => {
+    if (canServe) {
+      exporter.getMetricsRequestHandler(req, res);
+    } else {
+      res.status(503).send("Prometheus exporter not available");
+    }
+  });
+  return router;
+}
+
+// libs/core/src/lib/collections/define-collection.ts
+function defineCollection(config) {
+  const collection = {
+    timestamps: true,
+    // Enable timestamps by default
+    ...config
+  };
+  if (!collection.slug) {
+    throw new Error("Collection must have a slug");
+  }
+  if (!collection.fields || collection.fields.length === 0) {
+    throw new Error(`Collection "${collection.slug}" must have at least one field`);
+  }
+  if (!/^[a-z][a-z0-9-]*$/.test(collection.slug)) {
+    throw new Error(
+      `Collection slug "${collection.slug}" must be kebab-case (lowercase letters, numbers, and hyphens, starting with a letter)`
+    );
+  }
+  return collection;
+}
+
+// libs/core/src/lib/fields/field-builders.ts
+function text(name, options = {}) {
+  return {
+    name,
+    type: "text",
+    ...options
+  };
+}
+function number(name, options = {}) {
+  return {
+    name,
+    type: "number",
+    ...options
+  };
+}
+function json(name, options = {}) {
+  return {
+    name,
+    type: "json",
+    ...options
+  };
+}
+
+// libs/core/src/lib/collections/media.collection.ts
+var validateFocalPoint = (value) => {
+  if (value === null || value === void 0)
+    return true;
+  if (typeof value !== "object" || Array.isArray(value)) {
+    return "Focal point must be an object with x and y coordinates";
+  }
+  const fp = Object.fromEntries(Object.entries(value));
+  if (!("x" in fp) || !("y" in fp)) {
+    return "Focal point must have both x and y properties";
+  }
+  const { x, y } = fp;
+  if (typeof x !== "number" || !Number.isFinite(x)) {
+    return "Focal point x must be a finite number";
+  }
+  if (typeof y !== "number" || !Number.isFinite(y)) {
+    return "Focal point y must be a finite number";
+  }
+  if (x < 0 || x > 1) {
+    return `Focal point x must be between 0 and 1 (received ${x})`;
+  }
+  if (y < 0 || y > 1) {
+    return `Focal point y must be between 0 and 1 (received ${y})`;
+  }
+  return true;
+};
+var MediaCollection = defineCollection({
+  slug: "media",
+  labels: {
+    singular: "Media",
+    plural: "Media"
+  },
+  upload: {
+    mimeTypes: ["image/*", "application/pdf", "video/*", "audio/*"]
+  },
+  admin: {
+    useAsTitle: "filename",
+    defaultColumns: ["filename", "mimeType", "filesize", "createdAt"]
+  },
+  fields: [
+    text("filename", {
+      required: true,
+      label: "Filename",
+      description: "Original filename of the uploaded file"
+    }),
+    text("mimeType", {
+      required: true,
+      label: "MIME Type",
+      description: "File MIME type (e.g., image/jpeg, application/pdf)"
+    }),
+    number("filesize", {
+      label: "File Size",
+      description: "File size in bytes"
+    }),
+    text("path", {
+      label: "Storage Path",
+      description: "Path/key where the file is stored",
+      admin: {
+        hidden: true
+      }
+    }),
+    text("url", {
+      label: "URL",
+      description: "Public URL to access the file"
+    }),
+    text("alt", {
+      label: "Alt Text",
+      description: "Alternative text for accessibility"
+    }),
+    number("width", {
+      label: "Width",
+      description: "Image width in pixels (for images only)"
+    }),
+    number("height", {
+      label: "Height",
+      description: "Image height in pixels (for images only)"
+    }),
+    json("focalPoint", {
+      label: "Focal Point",
+      description: "Focal point coordinates for image cropping",
+      validate: validateFocalPoint,
+      admin: {
+        hidden: true
+      }
+    }),
+    json("sizes", {
+      label: "Image Sizes",
+      description: "Generated image size variants",
+      admin: {
+        hidden: true
+      }
+    })
+  ],
+  access: {
+    // Media is readable by anyone by default
+    read: () => true,
+    // Only authenticated users can create/update/delete
+    create: ({ req }) => !!req?.user,
+    update: ({ req }) => !!req?.user,
+    delete: ({ req }) => !!req?.user
+  }
+});
+
+// libs/core/src/lib/access/access-helpers.ts
+function hasRole(role) {
+  return ({ req }) => req.user?.role === role;
+}
+
+// libs/plugins/otel/src/lib/metrics/otel-snapshot-collection.ts
+var OtelSnapshotsCollection = defineCollection({
+  slug: "otel-snapshots",
+  labels: {
+    singular: "OTel Snapshot",
+    plural: "OTel Snapshots"
+  },
+  admin: {
+    hidden: true
+  },
+  timestamps: true,
+  fields: [
+    number("totalRequests", { required: true }),
+    number("errorCount", { required: true }),
+    number("avgDurationMs", { required: true }),
+    number("memoryUsageMb", { required: true }),
+    json("byMethod", {}),
+    json("byStatusCode", {}),
+    json("collectionMetrics", {}),
+    json("topSpans", {})
+  ],
+  access: {
+    read: hasRole("admin"),
+    create: hasRole("admin"),
+    update: hasRole("admin"),
+    delete: hasRole("admin"),
+    admin: () => false
+  }
+});
+
+// libs/plugins/otel/src/lib/metrics/metrics-snapshot-service.ts
+var MetricsSnapshotService = class {
+  constructor(options) {
+    this.timer = null;
+    this.flushing = false;
+    this.store = options.store;
+    this.getApi = options.getApi;
+    this.snapshotInterval = options.snapshotInterval ?? 6e4;
+    this.retentionDays = options.retentionDays ?? 7;
+    this.logger = createLogger("OTel-Snapshots");
+  }
+  start() {
+    if (this.timer)
+      return;
+    this.timer = setInterval(() => {
+      void this.flush();
+    }, this.snapshotInterval);
+  }
+  async flush() {
+    if (this.flushing)
+      return;
+    this.flushing = true;
+    try {
+      const api = this.getApi();
+      if (!api)
+        return;
+      const ops = api.setContext({ overrideAccess: true }).collection("otel-snapshots");
+      if (!isCreatable(ops))
+        return;
+      const snapshot = this.store.getSnapshotData();
+      const data = {
+        totalRequests: snapshot.totalRequests,
+        errorCount: snapshot.errorCount,
+        avgDurationMs: snapshot.avgDurationMs,
+        memoryUsageMb: snapshot.memoryUsageMb,
+        byMethod: snapshot.byMethod,
+        byStatusCode: snapshot.byStatusCode,
+        collectionMetrics: snapshot.collectionMetrics,
+        topSpans: snapshot.topSpans
+      };
+      await ops.create(data);
+      await this.prune();
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      this.logger.error(`Failed to flush snapshot: ${message}`);
+    } finally {
+      this.flushing = false;
+    }
+  }
+  async restore() {
+    try {
+      const api = this.getApi();
+      if (!api)
+        return;
+      const ops = api.setContext({ overrideAccess: true }).collection("otel-snapshots");
+      if (!isFindable(ops))
+        return;
+      const result = await ops.find({ limit: 1, sort: "-createdAt" });
+      const docs = Array.isArray(result.docs) ? result.docs : [];
+      if (docs.length === 0)
+        return;
+      const doc = docs[0];
+      if (!isRecord(doc))
+        return;
+      const byMethod = {};
+      const rawMethod = doc["byMethod"];
+      if (isRecord(rawMethod)) {
+        for (const [k, v] of Object.entries(rawMethod)) {
+          if (typeof v === "number")
+            byMethod[k] = v;
+        }
+      }
+      const byStatusCode = {};
+      const rawStatus = doc["byStatusCode"];
+      if (isRecord(rawStatus)) {
+        for (const [k, v] of Object.entries(rawStatus)) {
+          if (typeof v === "number")
+            byStatusCode[k] = v;
+        }
+      }
+      const snapshot = {
+        totalRequests: typeof doc["totalRequests"] === "number" ? doc["totalRequests"] : 0,
+        errorCount: typeof doc["errorCount"] === "number" ? doc["errorCount"] : 0,
+        avgDurationMs: typeof doc["avgDurationMs"] === "number" ? doc["avgDurationMs"] : 0,
+        memoryUsageMb: typeof doc["memoryUsageMb"] === "number" ? doc["memoryUsageMb"] : 0,
+        byMethod,
+        byStatusCode,
+        collectionMetrics: Array.isArray(doc["collectionMetrics"]) ? extractCollectionMetrics(doc["collectionMetrics"]) : [],
+        topSpans: Array.isArray(doc["topSpans"]) ? extractSpanRecords(doc["topSpans"]) : []
+      };
+      this.store.restore(snapshot);
+      this.logger.info("Metrics restored from last snapshot");
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      this.logger.warn(`Failed to restore snapshot: ${message}`);
+    }
+  }
+  async shutdown() {
+    if (this.timer) {
+      clearInterval(this.timer);
+      this.timer = null;
+    }
+    await this.flush();
+  }
+  async purgeAll() {
+    const api = this.getApi();
+    if (!api)
+      return 0;
+    const ops = api.setContext({ overrideAccess: true }).collection("otel-snapshots");
+    if (!isFindable(ops) || !isDeletable(ops))
+      return 0;
+    let deleted = 0;
+    const MAX_BATCHES = 100;
+    for (let batch = 0; batch < MAX_BATCHES; batch++) {
+      const result = await ops.find({ limit: 50 });
+      const docs = Array.isArray(result.docs) ? result.docs : [];
+      if (docs.length === 0)
+        break;
+      let batchDeleted = 0;
+      for (const doc of docs) {
+        if (isRecord(doc) && typeof doc["id"] === "string") {
+          await ops.delete(doc["id"]);
+          deleted++;
+          batchDeleted++;
+        }
+      }
+      if (batchDeleted === 0)
+        break;
+    }
+    this.logger.info(`Purged ${deleted} snapshots`);
+    return deleted;
+  }
+  async prune() {
+    const api = this.getApi();
+    if (!api)
+      return;
+    const ops = api.setContext({ overrideAccess: true }).collection("otel-snapshots");
+    if (!isFindable(ops) || !isDeletable(ops))
+      return;
+    const cutoff = new Date(Date.now() - this.retentionDays * 24 * 60 * 60 * 1e3).toISOString();
+    try {
+      const result = await ops.find({
+        where: { createdAt: { lt: cutoff } },
+        limit: 100
+      });
+      const docs = Array.isArray(result.docs) ? result.docs : [];
+      for (const doc of docs) {
+        if (isRecord(doc) && typeof doc["id"] === "string") {
+          await ops.delete(doc["id"]);
+        }
+      }
+      if (docs.length > 0) {
+        this.logger.info(`Pruned ${docs.length} expired snapshots`);
+      }
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      this.logger.warn(`Failed to prune snapshots: ${message}`);
+    }
+  }
+};
+function extractCollectionMetrics(raw) {
+  const result = [];
+  for (const item of raw) {
+    if (!isRecord(item))
+      continue;
+    result.push({
+      collection: typeof item["collection"] === "string" ? item["collection"] : "",
+      creates: typeof item["creates"] === "number" ? item["creates"] : 0,
+      updates: typeof item["updates"] === "number" ? item["updates"] : 0,
+      deletes: typeof item["deletes"] === "number" ? item["deletes"] : 0,
+      avgDurationMs: typeof item["avgDurationMs"] === "number" ? item["avgDurationMs"] : 0
+    });
+  }
+  return result;
+}
+function extractSpanRecords(raw) {
+  const result = [];
+  for (const item of raw) {
+    if (!isRecord(item))
+      continue;
+    result.push({
+      traceId: typeof item["traceId"] === "string" ? item["traceId"] : "",
+      spanId: typeof item["spanId"] === "string" ? item["spanId"] : "",
+      name: typeof item["name"] === "string" ? item["name"] : "",
+      collection: typeof item["collection"] === "string" ? item["collection"] : "",
+      operation: typeof item["operation"] === "string" ? item["operation"] : "",
+      durationMs: typeof item["durationMs"] === "number" ? item["durationMs"] : 0,
+      status: item["status"] === "error" ? "error" : "ok",
+      timestamp: typeof item["timestamp"] === "string" ? item["timestamp"] : ""
+    });
+  }
+  return result;
+}
+
 // libs/plugins/otel/src/lib/otel-plugin.ts
+function isSpanLike(value) {
+  if (value == null || typeof value !== "object")
+    return false;
+  if (!("end" in value) || !("setStatus" in value))
+    return false;
+  return typeof value["end"] === "function" && typeof value["setStatus"] === "function";
+}
 var OtelLogEnricher = class {
   enrich() {
     const span = import_api.trace.getActiveSpan();
@@ -255,31 +1177,156 @@ var OtelLogEnricher = class {
     };
   }
 };
+function resolveAdminRoutes(dashboardConfig) {
+  if (dashboardConfig === false)
+    return [];
+  const dashboardModule = "./dashboard/otel-dashboard.page";
+  return [
+    {
+      path: "observability",
+      label: "Observability",
+      icon: "heroSignal",
+      loadComponent: () => import(dashboardModule).then(
+        (m) => m["OtelDashboardPage"]
+      ),
+      group: "Plugins"
+    }
+  ];
+}
+function getMeterFromProvider(provider, serviceName) {
+  if (provider == null || typeof provider !== "object")
+    return null;
+  if (!("getMeter" in provider))
+    return null;
+  const getMeterFn = provider["getMeter"];
+  if (typeof getMeterFn !== "function")
+    return null;
+  return getMeterFn.call(provider, serviceName);
+}
 function otelPlugin(config = {}) {
-  const { serviceName = "momentum-cms", enrichLogs = true, attributes = {}, operations } = config;
+  const {
+    serviceName = "momentum-cms",
+    enrichLogs = true,
+    attributes = {},
+    operations,
+    metrics: metricsConfig
+  } = config;
+  const metricsEnabled = metricsConfig?.enabled ?? false;
+  const prometheusEnabled = metricsConfig?.prometheus ?? metricsEnabled;
+  const dashboardEnabled = metricsConfig?.adminDashboard ?? metricsEnabled;
   let tracer;
   let enricher = null;
+  let metricsStore = null;
+  let meterProviderRef = null;
+  let snapshotService = null;
+  let momentumApi = null;
+  const adminRoutes = metricsEnabled ? resolveAdminRoutes(dashboardEnabled) : [];
   return {
     name: "otel",
-    onInit({ collections, logger }) {
+    adminRoutes,
+    browserImports: metricsEnabled ? {
+      adminRoutes: {
+        path: "@momentumcms/plugins-otel/admin-routes",
+        exportName: "otelAdminRoutes"
+      }
+    } : void 0,
+    onInit({ collections, logger: logger2, registerMiddleware }) {
       tracer = import_api.trace.getTracer(serviceName);
-      logger.info(`OpenTelemetry tracing enabled (service: ${serviceName})`);
+      logger2.info(`OpenTelemetry tracing enabled (service: ${serviceName})`);
       if (enrichLogs) {
         enricher = new OtelLogEnricher();
         MomentumLogger.registerEnricher(enricher);
-        logger.info("Log enricher registered for trace/span IDs");
+        logger2.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`);
+      logger2.info(`Tracing hooks injected into ${collections.length} collections`);
+      if (metricsEnabled) {
+        metricsStore = new MetricsStore();
+        collections.push(OtelSnapshotsCollection);
+        snapshotService = new MetricsSnapshotService({
+          store: metricsStore,
+          getApi: () => momentumApi,
+          snapshotInterval: metricsConfig?.snapshotInterval,
+          retentionDays: metricsConfig?.retentionDays
+        });
+        let meter = null;
+        if (metricsConfig?.meterProvider) {
+          meter = getMeterFromProvider(metricsConfig.meterProvider, serviceName);
+          logger2.info("Using user-supplied MeterProvider");
+        } else if (prometheusEnabled) {
+          const sdk = tryLoadOtelSdk(serviceName);
+          if (sdk) {
+            meter = sdk.meter;
+            meterProviderRef = sdk.provider;
+            const prometheusPath = typeof metricsConfig?.prometheus === "object" ? metricsConfig.prometheus.path ?? "/metrics" : "/metrics";
+            registerMiddleware({
+              path: prometheusPath,
+              handler: createPrometheusHandler({ exporter: sdk.exporter }),
+              position: "root"
+            });
+            logger2.info(`Prometheus endpoint registered at ${prometheusPath}`);
+          } else {
+            logger2.warn(
+              "@opentelemetry/sdk-metrics or @opentelemetry/exporter-prometheus not found. Install them to enable Prometheus metrics. Metrics store will still work for the dashboard."
+            );
+          }
+        }
+        const requestMetrics = createRequestMetricsMiddleware({
+          store: metricsStore,
+          meter
+        });
+        registerMiddleware({
+          path: "/",
+          handler: requestMetrics,
+          position: "before-api"
+        });
+        injectCollectionMetricsHooks(collections, {
+          store: metricsStore,
+          meter,
+          operations: operations ?? void 0
+        });
+        if (dashboardEnabled) {
+          const queryRouter = createOtelQueryRouter(
+            metricsStore,
+            () => momentumApi,
+            snapshotService
+          );
+          registerMiddleware({
+            path: "/otel",
+            handler: queryRouter,
+            position: "before-api"
+          });
+          logger2.info("Observability dashboard API registered");
+        }
+        logger2.info("Metrics collection enabled");
+      }
     },
-    onShutdown({ logger }) {
+    async onReady({ logger: logger2, api }) {
+      momentumApi = api;
+      if (snapshotService) {
+        await snapshotService.restore();
+        snapshotService.start();
+        logger2.info("Metrics snapshot service started");
+      }
+    },
+    async onShutdown({ logger: logger2 }) {
+      if (snapshotService) {
+        await snapshotService.shutdown();
+        snapshotService = null;
+      }
       if (enricher) {
         MomentumLogger.removeEnricher(enricher);
         enricher = null;
       }
-      logger.info("OpenTelemetry plugin shut down");
+      if (meterProviderRef) {
+        await meterProviderRef.shutdown();
+        meterProviderRef = null;
+      }
+      metricsStore = null;
+      momentumApi = null;
+      logger2.info("OpenTelemetry plugin shut down");
     }
   };
 }
@@ -305,14 +1352,16 @@ function injectTracingHooks(collection, tracer, attributes, operationFilter) {
   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: import_api.SpanStatusCode.OK });
-      typedSpan.end();
+    if (isSpanLike(span)) {
+      span.setStatus({ code: import_api.SpanStatusCode.OK });
+      span.end();
     }
     if (args.doc) {
       delete args.doc["__otelSpan"];
     }
+    if (args.data) {
+      delete args.data["__otelSpan"];
+    }
   };
   const beforeDeleteHook = (args) => {
     if (operationFilter && !operationFilter.includes("delete")) {
@@ -333,10 +1382,9 @@ function injectTracingHooks(collection, tracer, attributes, operationFilter) {
   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: import_api.SpanStatusCode.OK });
-      typedSpan.end();
+    if (isSpanLike(span)) {
+      span.setStatus({ code: import_api.SpanStatusCode.OK });
+      span.end();
     }
   };
   const existingBeforeChange = collection.hooks.beforeChange ?? [];