@zucker-framework/monitoring 1.0.0 → 1.0.2

package/dist/index.js

@@ -35,6 +35,7 @@ __export(index_exports, {
   AlertManagerService: () => AlertManagerService,
   Counter: () => Counter,
   ERROR_REPORTER: () => ERROR_REPORTER,
+  ERROR_TRACKER_OPTIONS: () => ERROR_TRACKER_OPTIONS,
   ErrorTracker: () => ErrorTracker,
   Gauge: () => Gauge,
   HEALTH_OPTIONS: () => HEALTH_OPTIONS,
@@ -48,17 +49,20 @@ __export(index_exports, {
   MetricsRegistry: () => MetricsRegistry,
   NoopErrorReporter: () => NoopErrorReporter,
   PrometheusExporter: () => PrometheusExporter,
+  SentryErrorReporter: () => SentryErrorReporter,
   Summary: () => Summary,
   SystemMetricsCollector: () => SystemMetricsCollector,
   Timer: () => Timer,
   UsageTracker: () => UsageTracker,
   ZuckerMonitoringModule: () => ZuckerMonitoringModule,
+  errorFingerprint: () => errorFingerprint,
   getProcessUptime: () => getProcessUptime,
   renderPrometheusMetrics: () => renderPrometheusMetrics
 });
 module.exports = __toCommonJS(index_exports);
 
 // src/error-tracker.ts
+var import_node_crypto = require("crypto");
 var import_common = require("@nestjs/common");
 function _ts_decorate(decorators, target, key, desc) {
   var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
@@ -74,40 +78,80 @@ function _ts_decorate(decorators, target, key, desc) {
   return c > 3 && r && Object.defineProperty(target, key, r), r;
 }
 __name(_ts_decorate, "_ts_decorate");
+function _ts_metadata(metadataKey, metadataValue) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") {
+    return Reflect.metadata(metadataKey, metadataValue);
+  }
+}
+__name(_ts_metadata, "_ts_metadata");
+function _ts_param(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__name(_ts_param, "_ts_param");
+var ERROR_TRACKER_OPTIONS = /* @__PURE__ */ Symbol("ERROR_TRACKER_OPTIONS");
+function errorFingerprint(error, endpoint = "") {
+  return (0, import_node_crypto.createHash)("sha256").update([
+    error.name,
+    error.message,
+    error.stack?.split("\n")[1]?.trim() ?? "",
+    endpoint
+  ].join("::")).digest("hex");
+}
+__name(errorFingerprint, "errorFingerprint");
 var ErrorTracker = class _ErrorTracker {
   static {
     __name(this, "ErrorTracker");
   }
+  options;
   logger = new import_common.Logger(_ErrorTracker.name);
   errors = /* @__PURE__ */ new Map();
   counter = 0;
+  constructor(options = {}) {
+    this.options = options;
+    if (options.retentionMs !== void 0 && (!Number.isFinite(options.retentionMs) || options.retentionMs <= 0)) throw new Error("Invalid error retention window");
+  }
+  prune() {
+    if (this.options.retentionMs === void 0) return;
+    const cutoff = Date.now() - this.options.retentionMs;
+    for (const [key, record] of this.errors) if (record.firstOccurrence.getTime() <= cutoff) this.errors.delete(key);
+  }
   track(error, category = "unknown", metadata) {
-    const key = `${category}:${error.message}`;
+    this.prune();
+    const key = this.options.fingerprint?.(error, category, metadata) ?? `${category}:${error.message}`;
+    const safeMetadata = metadata ? this.options.sanitizeMetadata?.(metadata) ?? metadata : void 0;
     const existing = this.errors.get(key);
     if (existing) {
       existing.count++;
       existing.lastOccurrence = /* @__PURE__ */ new Date();
-      if (metadata) {
+      if (safeMetadata) {
         existing.metadata = {
           ...existing.metadata,
-          ...metadata
+          ...safeMetadata
         };
       }
     } else {
-      this.errors.set(key, {
+      const record = {
         id: `err_${++this.counter}`,
-        message: error.message,
-        stack: error.stack,
+        message: this.options.sanitizeText?.(error.message) ?? error.message,
+        stack: error.stack ? this.options.sanitizeText?.(error.stack) ?? error.stack : void 0,
         category,
         count: 1,
         firstOccurrence: /* @__PURE__ */ new Date(),
         lastOccurrence: /* @__PURE__ */ new Date(),
-        metadata
-      });
+        metadata: safeMetadata
+      };
+      this.errors.set(key, record);
+      this.options.onNewError?.(error, record);
+    }
+    if (this.options.logEntries !== false) {
+      const record = this.errors.get(key);
+      this.logger.warn(`[${category}] ${record.message} (count: ${record.count})`);
     }
-    this.logger.warn(`[${category}] ${error.message} (count: ${this.errors.get(key).count})`);
   }
   getErrors() {
+    this.prune();
     return Array.from(this.errors.values());
   }
   getErrorsByCategory(category) {
@@ -128,7 +172,13 @@ var ErrorTracker = class _ErrorTracker {
   }
 };
 ErrorTracker = _ts_decorate([
-  (0, import_common.Injectable)()
+  (0, import_common.Injectable)(),
+  _ts_param(0, (0, import_common.Optional)()),
+  _ts_param(0, (0, import_common.Inject)(ERROR_TRACKER_OPTIONS)),
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", [
+    typeof ErrorTrackerOptions === "undefined" ? Object : ErrorTrackerOptions
+  ])
 ], ErrorTracker);
 
 // src/error-reporter.ts
@@ -180,10 +230,22 @@ var HealthCheckService = class _HealthCheckService {
   unregisterIndicator(name) {
     this.indicators = this.indicators.filter((i) => i.name !== name);
   }
-  async checkAll() {
+  /** Select a declared subset for readiness vs. diagnostics; absent indicators fail closed. */
+  async checkAll(names) {
     const checks = [];
     let overallStatus = "UP";
-    for (const indicator of this.indicators) {
+    const indicators = names === void 0 ? this.indicators : names.map((name) => this.indicators.find((indicator) => indicator.name === name) ?? {
+      name,
+      check: /* @__PURE__ */ __name(async () => ({
+        name,
+        status: "DOWN",
+        details: {
+          error: "Health indicator not registered"
+        },
+        timestamp: /* @__PURE__ */ new Date()
+      }), "check")
+    });
+    for (const indicator of indicators) {
       try {
         const result = await indicator.check();
         checks.push(result);
@@ -757,12 +819,12 @@ function _ts_decorate4(decorators, target, key, desc) {
   return c > 3 && r && Object.defineProperty(target, key, r), r;
 }
 __name(_ts_decorate4, "_ts_decorate");
-function _ts_metadata(metadataKey, metadataValue) {
+function _ts_metadata2(metadataKey, metadataValue) {
   if (typeof Reflect === "object" && typeof Reflect.metadata === "function") {
     return Reflect.metadata(metadataKey, metadataValue);
   }
 }
-__name(_ts_metadata, "_ts_metadata");
+__name(_ts_metadata2, "_ts_metadata");
 var SystemMetricsCollector = class {
   static {
     __name(this, "SystemMetricsCollector");
@@ -885,8 +947,8 @@ var SystemMetricsCollector = class {
 };
 SystemMetricsCollector = _ts_decorate4([
   (0, import_common4.Injectable)(),
-  _ts_metadata("design:type", Function),
-  _ts_metadata("design:paramtypes", [
+  _ts_metadata2("design:type", Function),
+  _ts_metadata2("design:paramtypes", [
     typeof MetricsRegistry === "undefined" ? Object : MetricsRegistry
   ])
 ], SystemMetricsCollector);
@@ -907,18 +969,18 @@ function _ts_decorate5(decorators, target, key, desc) {
   return c > 3 && r && Object.defineProperty(target, key, r), r;
 }
 __name(_ts_decorate5, "_ts_decorate");
-function _ts_metadata2(metadataKey, metadataValue) {
+function _ts_metadata3(metadataKey, metadataValue) {
   if (typeof Reflect === "object" && typeof Reflect.metadata === "function") {
     return Reflect.metadata(metadataKey, metadataValue);
   }
 }
-__name(_ts_metadata2, "_ts_metadata");
-function _ts_param(paramIndex, decorator) {
+__name(_ts_metadata3, "_ts_metadata");
+function _ts_param2(paramIndex, decorator) {
   return function(target, key) {
     decorator(target, key, paramIndex);
   };
 }
-__name(_ts_param, "_ts_param");
+__name(_ts_param2, "_ts_param");
 function formatLabels(labels) {
   const entries = Object.entries(labels);
   if (entries.length === 0) return "";
@@ -1012,15 +1074,15 @@ var PrometheusExporter = class {
 _ts_decorate5([
   (0, import_common5.Get)(),
   (0, import_common5.Header)("Content-Type", "text/plain; version=0.0.4; charset=utf-8"),
-  _ts_metadata2("design:type", Function),
-  _ts_metadata2("design:paramtypes", []),
-  _ts_metadata2("design:returntype", String)
+  _ts_metadata3("design:type", Function),
+  _ts_metadata3("design:paramtypes", []),
+  _ts_metadata3("design:returntype", String)
 ], PrometheusExporter.prototype, "getMetrics", null);
 PrometheusExporter = _ts_decorate5([
   (0, import_common5.Controller)("metrics"),
-  _ts_param(0, (0, import_common5.Inject)(MetricsRegistry)),
-  _ts_metadata2("design:type", Function),
-  _ts_metadata2("design:paramtypes", [
+  _ts_param2(0, (0, import_common5.Inject)(MetricsRegistry)),
+  _ts_metadata3("design:type", Function),
+  _ts_metadata3("design:paramtypes", [
     typeof MetricsRegistry === "undefined" ? Object : MetricsRegistry
   ])
 ], PrometheusExporter);
@@ -1056,18 +1118,18 @@ function _ts_decorate6(decorators, target, key, desc) {
   return c > 3 && r && Object.defineProperty(target, key, r), r;
 }
 __name(_ts_decorate6, "_ts_decorate");
-function _ts_metadata3(metadataKey, metadataValue) {
+function _ts_metadata4(metadataKey, metadataValue) {
   if (typeof Reflect === "object" && typeof Reflect.metadata === "function") {
     return Reflect.metadata(metadataKey, metadataValue);
   }
 }
-__name(_ts_metadata3, "_ts_metadata");
-function _ts_param2(paramIndex, decorator) {
+__name(_ts_metadata4, "_ts_metadata");
+function _ts_param3(paramIndex, decorator) {
   return function(target, key) {
     decorator(target, key, paramIndex);
   };
 }
-__name(_ts_param2, "_ts_param");
+__name(_ts_param3, "_ts_param");
 var Public = /* @__PURE__ */ __name(() => (0, import_common6.SetMetadata)("zucker:auth:isPublic", true), "Public");
 var HEALTH_OPTIONS = /* @__PURE__ */ Symbol("HEALTH_OPTIONS");
 var HealthController = class {
@@ -1126,36 +1188,36 @@ var HealthController = class {
 };
 _ts_decorate6([
   (0, import_common6.Get)(),
-  _ts_param2(0, (0, import_common6.Res)()),
-  _ts_metadata3("design:type", Function),
-  _ts_metadata3("design:paramtypes", [
+  _ts_param3(0, (0, import_common6.Res)()),
+  _ts_metadata4("design:type", Function),
+  _ts_metadata4("design:paramtypes", [
     Object
   ]),
-  _ts_metadata3("design:returntype", Promise)
+  _ts_metadata4("design:returntype", Promise)
 ], HealthController.prototype, "check", null);
 _ts_decorate6([
   (0, import_common6.Get)("live"),
-  _ts_param2(0, (0, import_common6.Res)()),
-  _ts_metadata3("design:type", Function),
-  _ts_metadata3("design:paramtypes", [
+  _ts_param3(0, (0, import_common6.Res)()),
+  _ts_metadata4("design:type", Function),
+  _ts_metadata4("design:paramtypes", [
     Object
   ]),
-  _ts_metadata3("design:returntype", void 0)
+  _ts_metadata4("design:returntype", void 0)
 ], HealthController.prototype, "live", null);
 _ts_decorate6([
   (0, import_common6.Get)("ready"),
-  _ts_param2(0, (0, import_common6.Res)()),
-  _ts_metadata3("design:type", Function),
-  _ts_metadata3("design:paramtypes", [
+  _ts_param3(0, (0, import_common6.Res)()),
+  _ts_metadata4("design:type", Function),
+  _ts_metadata4("design:paramtypes", [
     Object
   ]),
-  _ts_metadata3("design:returntype", Promise)
+  _ts_metadata4("design:returntype", Promise)
 ], HealthController.prototype, "ready", null);
 HealthController = _ts_decorate6([
   (0, import_common6.Controller)("health"),
   Public(),
-  _ts_metadata3("design:type", Function),
-  _ts_metadata3("design:paramtypes", [
+  _ts_metadata4("design:type", Function),
+  _ts_metadata4("design:paramtypes", [
     typeof HealthCheckService === "undefined" ? Object : HealthCheckService
   ])
 ], HealthController);
@@ -1178,18 +1240,18 @@ function _ts_decorate7(decorators, target, key, desc) {
   return c > 3 && r && Object.defineProperty(target, key, r), r;
 }
 __name(_ts_decorate7, "_ts_decorate");
-function _ts_metadata4(metadataKey, metadataValue) {
+function _ts_metadata5(metadataKey, metadataValue) {
   if (typeof Reflect === "object" && typeof Reflect.metadata === "function") {
     return Reflect.metadata(metadataKey, metadataValue);
   }
 }
-__name(_ts_metadata4, "_ts_metadata");
-function _ts_param3(paramIndex, decorator) {
+__name(_ts_metadata5, "_ts_metadata");
+function _ts_param4(paramIndex, decorator) {
   return function(target, key) {
     decorator(target, key, paramIndex);
   };
 }
-__name(_ts_param3, "_ts_param");
+__name(_ts_param4, "_ts_param");
 function nextAlertId() {
   return `alert-${Date.now()}-${(0, import_crypto.randomUUID)().slice(0, 8)}`;
 }
@@ -1410,11 +1472,11 @@ var AlertManagerService = class _AlertManagerService {
 };
 AlertManagerService = _ts_decorate7([
   (0, import_common7.Injectable)(),
-  _ts_param3(0, (0, import_common7.Optional)()),
-  _ts_param3(1, (0, import_common7.Optional)()),
-  _ts_param3(1, (0, import_common7.Inject)("DATABASE_ADAPTER")),
-  _ts_metadata4("design:type", Function),
-  _ts_metadata4("design:paramtypes", [
+  _ts_param4(0, (0, import_common7.Optional)()),
+  _ts_param4(1, (0, import_common7.Optional)()),
+  _ts_param4(1, (0, import_common7.Inject)("DATABASE_ADAPTER")),
+  _ts_metadata5("design:type", Function),
+  _ts_metadata5("design:paramtypes", [
     typeof import_event_emitter.EventEmitter2 === "undefined" ? Object : import_event_emitter.EventEmitter2,
     Object
   ])
@@ -1436,18 +1498,18 @@ function _ts_decorate8(decorators, target, key, desc) {
   return c > 3 && r && Object.defineProperty(target, key, r), r;
 }
 __name(_ts_decorate8, "_ts_decorate");
-function _ts_metadata5(metadataKey, metadataValue) {
+function _ts_metadata6(metadataKey, metadataValue) {
   if (typeof Reflect === "object" && typeof Reflect.metadata === "function") {
     return Reflect.metadata(metadataKey, metadataValue);
   }
 }
-__name(_ts_metadata5, "_ts_metadata");
-function _ts_param4(paramIndex, decorator) {
+__name(_ts_metadata6, "_ts_metadata");
+function _ts_param5(paramIndex, decorator) {
   return function(target, key) {
     decorator(target, key, paramIndex);
   };
 }
-__name(_ts_param4, "_ts_param");
+__name(_ts_param5, "_ts_param");
 var Permissions = /* @__PURE__ */ __name(() => (0, import_common8.SetMetadata)("zucker:auth:permissions", []), "Permissions");
 var AlertController = class {
   static {
@@ -1513,63 +1575,63 @@ var AlertController = class {
 };
 _ts_decorate8([
   (0, import_common8.Get)(),
-  _ts_metadata5("design:type", Function),
-  _ts_metadata5("design:paramtypes", []),
-  _ts_metadata5("design:returntype", void 0)
+  _ts_metadata6("design:type", Function),
+  _ts_metadata6("design:paramtypes", []),
+  _ts_metadata6("design:returntype", void 0)
 ], AlertController.prototype, "getAlerts", null);
 _ts_decorate8([
   (0, import_common8.Get)("rules"),
-  _ts_metadata5("design:type", Function),
-  _ts_metadata5("design:paramtypes", []),
-  _ts_metadata5("design:returntype", void 0)
+  _ts_metadata6("design:type", Function),
+  _ts_metadata6("design:paramtypes", []),
+  _ts_metadata6("design:returntype", void 0)
 ], AlertController.prototype, "getRules", null);
 _ts_decorate8([
   (0, import_common8.Post)("rules"),
   (0, import_common8.HttpCode)(import_common8.HttpStatus.CREATED),
-  _ts_param4(0, (0, import_common8.Body)()),
-  _ts_metadata5("design:type", Function),
-  _ts_metadata5("design:paramtypes", [
+  _ts_param5(0, (0, import_common8.Body)()),
+  _ts_metadata6("design:type", Function),
+  _ts_metadata6("design:paramtypes", [
     typeof AlertRule === "undefined" ? Object : AlertRule
   ]),
-  _ts_metadata5("design:returntype", void 0)
+  _ts_metadata6("design:returntype", void 0)
 ], AlertController.prototype, "createRule", null);
 _ts_decorate8([
   (0, import_common8.Delete)("rules/:id"),
   (0, import_common8.HttpCode)(import_common8.HttpStatus.NO_CONTENT),
-  _ts_param4(0, (0, import_common8.Param)("id")),
-  _ts_metadata5("design:type", Function),
-  _ts_metadata5("design:paramtypes", [
+  _ts_param5(0, (0, import_common8.Param)("id")),
+  _ts_metadata6("design:type", Function),
+  _ts_metadata6("design:paramtypes", [
     String
   ]),
-  _ts_metadata5("design:returntype", void 0)
+  _ts_metadata6("design:returntype", void 0)
 ], AlertController.prototype, "deleteRule", null);
 _ts_decorate8([
   (0, import_common8.Put)(":id/acknowledge"),
-  _ts_param4(0, (0, import_common8.Param)("id")),
-  _ts_param4(1, (0, import_common8.Body)("userId")),
-  _ts_metadata5("design:type", Function),
-  _ts_metadata5("design:paramtypes", [
+  _ts_param5(0, (0, import_common8.Param)("id")),
+  _ts_param5(1, (0, import_common8.Body)("userId")),
+  _ts_metadata6("design:type", Function),
+  _ts_metadata6("design:paramtypes", [
     String,
     String
   ]),
-  _ts_metadata5("design:returntype", void 0)
+  _ts_metadata6("design:returntype", void 0)
 ], AlertController.prototype, "acknowledgeAlert", null);
 _ts_decorate8([
   (0, import_common8.Put)(":id/resolve"),
-  _ts_param4(0, (0, import_common8.Param)("id")),
-  _ts_param4(1, (0, import_common8.Body)("userId")),
-  _ts_metadata5("design:type", Function),
-  _ts_metadata5("design:paramtypes", [
+  _ts_param5(0, (0, import_common8.Param)("id")),
+  _ts_param5(1, (0, import_common8.Body)("userId")),
+  _ts_metadata6("design:type", Function),
+  _ts_metadata6("design:paramtypes", [
     String,
     String
   ]),
-  _ts_metadata5("design:returntype", void 0)
+  _ts_metadata6("design:returntype", void 0)
 ], AlertController.prototype, "resolveAlert", null);
 AlertController = _ts_decorate8([
   (0, import_common8.Controller)("monitoring/alerts"),
   Permissions(),
-  _ts_metadata5("design:type", Function),
-  _ts_metadata5("design:paramtypes", [
+  _ts_metadata6("design:type", Function),
+  _ts_metadata6("design:paramtypes", [
     typeof AlertManagerService === "undefined" ? Object : AlertManagerService
   ])
 ], AlertController);
@@ -1719,12 +1781,94 @@ var UsageTracker = class _UsageTracker {
 UsageTracker = _ts_decorate10([
   (0, import_common10.Injectable)()
 ], UsageTracker);
+
+// src/sentry-error-reporter.ts
+var import_privacy = require("@zucker-framework/core/privacy");
+var SentryErrorReporter = class {
+  static {
+    __name(this, "SentryErrorReporter");
+  }
+  options;
+  sdk;
+  initializing;
+  constructor(options) {
+    this.options = options;
+  }
+  onModuleInit() {
+    return this.initializing ??= this.initialize();
+  }
+  async initialize() {
+    if (!this.options.dsn) {
+      this.options.onUnavailable?.();
+      return;
+    }
+    const sdk = await (this.options.loadSdk?.() ?? import("@sentry/node").then((module2) => module2));
+    sdk.init({
+      dsn: this.options.dsn,
+      environment: this.options.environment,
+      release: this.options.release,
+      tracesSampleRate: this.options.tracesSampleRate,
+      beforeSend: /* @__PURE__ */ __name((event) => {
+        const redaction = this.options.redaction;
+        let safe = event;
+        if (redaction) {
+          safe = {
+            ...event
+          };
+          for (const section of redaction.sections) {
+            const value = event[section];
+            if (value !== null && typeof value === "object") {
+              safe[section] = (0, import_privacy.redactFields)(value, redaction.fields, redaction.replacement);
+            }
+          }
+        }
+        return this.options.beforeSend ? this.options.beforeSend(safe) : safe;
+      }, "beforeSend")
+    });
+    this.sdk = sdk;
+    this.options.onInitialized?.();
+  }
+  captureException(error, context) {
+    const sdk = this.sdk;
+    if (!sdk) return;
+    sdk.withScope((scope) => {
+      this.applyContext(scope, context, "exception");
+      sdk.captureException(error);
+    });
+  }
+  captureMessage(message, context) {
+    const sdk = this.sdk;
+    if (!sdk) return;
+    sdk.withScope((scope) => {
+      this.applyContext(scope, context, "message");
+      sdk.captureMessage(message);
+    });
+  }
+  setUser(user) {
+    this.sdk?.setUser(user);
+  }
+  applyContext(scope, context, kind) {
+    if (!context) return;
+    const mapped = this.options.mapContext?.(context, kind) ?? {
+      tags: context.requestId ? {
+        requestId: context.requestId
+      } : void 0,
+      user: context.userId ? {
+        id: context.userId
+      } : void 0
+    };
+    for (const [key, value] of Object.entries(mapped.tags ?? {})) scope.setTag(key, value);
+    if (mapped.user !== void 0) scope.setUser(mapped.user);
+    for (const [key, value] of Object.entries(mapped.extra ?? {})) scope.setExtra(key, value);
+  }
+};
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   AlertController,
   AlertManagerService,
   Counter,
   ERROR_REPORTER,
+  ERROR_TRACKER_OPTIONS,
   ErrorTracker,
   Gauge,
   HEALTH_OPTIONS,
@@ -1738,11 +1882,13 @@ UsageTracker = _ts_decorate10([
   MetricsRegistry,
   NoopErrorReporter,
   PrometheusExporter,
+  SentryErrorReporter,
   Summary,
   SystemMetricsCollector,
   Timer,
   UsageTracker,
   ZuckerMonitoringModule,
+  errorFingerprint,
   getProcessUptime,
   renderPrometheusMetrics
 });