@zucker-framework/monitoring 1.0.0 → 1.0.2

package/dist/index.mjs

@@ -2,7 +2,8 @@ var __defProp = Object.defineProperty;
 var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 
 // src/error-tracker.ts
-import { Injectable, Logger } from "@nestjs/common";
+import { createHash } from "crypto";
+import { Injectable, Logger, Inject, Optional } from "@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;
   if (typeof Reflect === "object" && typeof Reflect.decorate === "function") {
@@ -17,40 +18,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 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 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) {
@@ -71,7 +112,13 @@ var ErrorTracker = class _ErrorTracker {
   }
 };
 ErrorTracker = _ts_decorate([
-  Injectable()
+  Injectable(),
+  _ts_param(0, Optional()),
+  _ts_param(0, Inject(ERROR_TRACKER_OPTIONS)),
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", [
+    typeof ErrorTrackerOptions === "undefined" ? Object : ErrorTrackerOptions
+  ])
 ], ErrorTracker);
 
 // src/error-reporter.ts
@@ -123,10 +170,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);
@@ -700,12 +759,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");
@@ -828,14 +887,14 @@ var SystemMetricsCollector = class {
 };
 SystemMetricsCollector = _ts_decorate4([
   Injectable4(),
-  _ts_metadata("design:type", Function),
-  _ts_metadata("design:paramtypes", [
+  _ts_metadata2("design:type", Function),
+  _ts_metadata2("design:paramtypes", [
     typeof MetricsRegistry === "undefined" ? Object : MetricsRegistry
   ])
 ], SystemMetricsCollector);
 
 // src/metrics/prometheus-exporter.ts
-import { Controller, Get, Header, Inject } from "@nestjs/common";
+import { Controller, Get, Header, Inject as Inject2 } from "@nestjs/common";
 function _ts_decorate5(decorators, target, key, desc) {
   var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
   if (typeof Reflect === "object" && typeof Reflect.decorate === "function") {
@@ -850,18 +909,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 "";
@@ -955,15 +1014,15 @@ var PrometheusExporter = class {
 _ts_decorate5([
   Get(),
   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([
   Controller("metrics"),
-  _ts_param(0, Inject(MetricsRegistry)),
-  _ts_metadata2("design:type", Function),
-  _ts_metadata2("design:paramtypes", [
+  _ts_param2(0, Inject2(MetricsRegistry)),
+  _ts_metadata3("design:type", Function),
+  _ts_metadata3("design:paramtypes", [
     typeof MetricsRegistry === "undefined" ? Object : MetricsRegistry
   ])
 ], PrometheusExporter);
@@ -999,18 +1058,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(() => SetMetadata("zucker:auth:isPublic", true), "Public");
 var HEALTH_OPTIONS = /* @__PURE__ */ Symbol("HEALTH_OPTIONS");
 var HealthController = class {
@@ -1069,42 +1128,42 @@ var HealthController = class {
 };
 _ts_decorate6([
   Get2(),
-  _ts_param2(0, Res()),
-  _ts_metadata3("design:type", Function),
-  _ts_metadata3("design:paramtypes", [
+  _ts_param3(0, 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([
   Get2("live"),
-  _ts_param2(0, Res()),
-  _ts_metadata3("design:type", Function),
-  _ts_metadata3("design:paramtypes", [
+  _ts_param3(0, 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([
   Get2("ready"),
-  _ts_param2(0, Res()),
-  _ts_metadata3("design:type", Function),
-  _ts_metadata3("design:paramtypes", [
+  _ts_param3(0, 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([
   Controller2("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);
 
 // src/alert/alert-manager.service.ts
-import { Injectable as Injectable5, Logger as Logger3, Optional, Inject as Inject2 } from "@nestjs/common";
+import { Injectable as Injectable5, Logger as Logger3, Optional as Optional2, Inject as Inject3 } from "@nestjs/common";
 import { randomUUID } from "crypto";
 import { EventEmitter2 } from "@nestjs/event-emitter";
 function _ts_decorate7(decorators, target, key, desc) {
@@ -1121,18 +1180,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()}-${randomUUID().slice(0, 8)}`;
 }
@@ -1353,11 +1412,11 @@ var AlertManagerService = class _AlertManagerService {
 };
 AlertManagerService = _ts_decorate7([
   Injectable5(),
-  _ts_param3(0, Optional()),
-  _ts_param3(1, Optional()),
-  _ts_param3(1, Inject2("DATABASE_ADAPTER")),
-  _ts_metadata4("design:type", Function),
-  _ts_metadata4("design:paramtypes", [
+  _ts_param4(0, Optional2()),
+  _ts_param4(1, Optional2()),
+  _ts_param4(1, Inject3("DATABASE_ADAPTER")),
+  _ts_metadata5("design:type", Function),
+  _ts_metadata5("design:paramtypes", [
     typeof EventEmitter2 === "undefined" ? Object : EventEmitter2,
     Object
   ])
@@ -1379,18 +1438,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(() => SetMetadata2("zucker:auth:permissions", []), "Permissions");
 var AlertController = class {
   static {
@@ -1456,63 +1515,63 @@ var AlertController = class {
 };
 _ts_decorate8([
   Get3(),
-  _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([
   Get3("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([
   Post("rules"),
   HttpCode(HttpStatus.CREATED),
-  _ts_param4(0, Body()),
-  _ts_metadata5("design:type", Function),
-  _ts_metadata5("design:paramtypes", [
+  _ts_param5(0, 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([
   Delete("rules/:id"),
   HttpCode(HttpStatus.NO_CONTENT),
-  _ts_param4(0, Param("id")),
-  _ts_metadata5("design:type", Function),
-  _ts_metadata5("design:paramtypes", [
+  _ts_param5(0, 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([
   Put(":id/acknowledge"),
-  _ts_param4(0, Param("id")),
-  _ts_param4(1, Body("userId")),
-  _ts_metadata5("design:type", Function),
-  _ts_metadata5("design:paramtypes", [
+  _ts_param5(0, Param("id")),
+  _ts_param5(1, 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([
   Put(":id/resolve"),
-  _ts_param4(0, Param("id")),
-  _ts_param4(1, Body("userId")),
-  _ts_metadata5("design:type", Function),
-  _ts_metadata5("design:paramtypes", [
+  _ts_param5(0, Param("id")),
+  _ts_param5(1, 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([
   Controller3("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);
@@ -1662,11 +1721,93 @@ var UsageTracker = class _UsageTracker {
 UsageTracker = _ts_decorate10([
   Injectable6()
 ], UsageTracker);
+
+// src/sentry-error-reporter.ts
+import { redactFields } from "@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((module) => module));
+    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] = 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);
+  }
+};
 export {
   AlertController,
   AlertManagerService,
   Counter,
   ERROR_REPORTER,
+  ERROR_TRACKER_OPTIONS,
   ErrorTracker,
   Gauge,
   HEALTH_OPTIONS,
@@ -1680,11 +1821,13 @@ export {
   MetricsRegistry,
   NoopErrorReporter,
   PrometheusExporter,
+  SentryErrorReporter,
   Summary,
   SystemMetricsCollector,
   Timer,
   UsageTracker,
   ZuckerMonitoringModule,
+  errorFingerprint,
   getProcessUptime,
   renderPrometheusMetrics
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zucker-framework/monitoring",
-  "version": "1.0.0",
+  "version": "1.0.2",
   "main": "dist/index.js",
   "module": "dist/index.mjs",
   "types": "dist/index.d.ts",
@@ -12,12 +12,14 @@
   ],
   "devDependencies": {
     "@nestjs/event-emitter": "^12.0.0",
-    "@types/node": "^20.19.43"
+    "@types/node": "^20.19.43",
+    "@sentry/node": "^10.73.0"
   },
   "peerDependencies": {
     "@nestjs/common": "^12.0.0",
     "@nestjs/core": "^12.0.0",
-    "@nestjs/event-emitter": "^12.0.0"
+    "@nestjs/event-emitter": "^12.0.0",
+    "@sentry/node": "^10.73.0"
   },
   "license": "Apache-2.0",
   "author": "Lind",
@@ -30,8 +32,16 @@
     "access": "public",
     "registry": "https://registry.npmjs.org/"
   },
+  "dependencies": {
+    "@zucker-framework/core": "1.0.2"
+  },
+  "peerDependenciesMeta": {
+    "@sentry/node": {
+      "optional": true
+    }
+  },
   "scripts": {
-    "build": "tsup src/index.ts --format cjs,esm --dts",
+    "build": "tsup src/index.ts --format cjs,esm --dts --external @sentry/node --external @zucker-framework/core",
     "clean": "rm -rf dist",
     "lint": "eslint src/"
   }