@zucker-framework/monitoring 1.0.0

package/dist/index.js

@@ -0,0 +1,1748 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  AlertController: () => AlertController,
+  AlertManagerService: () => AlertManagerService,
+  Counter: () => Counter,
+  ERROR_REPORTER: () => ERROR_REPORTER,
+  ErrorTracker: () => ErrorTracker,
+  Gauge: () => Gauge,
+  HEALTH_OPTIONS: () => HEALTH_OPTIONS,
+  HealthCheckService: () => HealthCheckService,
+  HealthController: () => HealthController,
+  HealthStatus: () => HealthStatus,
+  Histogram: () => Histogram,
+  InMemoryMetricsCollector: () => InMemoryMetricsCollector,
+  METRICS_COLLECTOR: () => METRICS_COLLECTOR,
+  Metrics: () => Metrics,
+  MetricsRegistry: () => MetricsRegistry,
+  NoopErrorReporter: () => NoopErrorReporter,
+  PrometheusExporter: () => PrometheusExporter,
+  Summary: () => Summary,
+  SystemMetricsCollector: () => SystemMetricsCollector,
+  Timer: () => Timer,
+  UsageTracker: () => UsageTracker,
+  ZuckerMonitoringModule: () => ZuckerMonitoringModule,
+  getProcessUptime: () => getProcessUptime,
+  renderPrometheusMetrics: () => renderPrometheusMetrics
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/error-tracker.ts
+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;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") {
+    r = Reflect.decorate(decorators, target, key, desc);
+  } else {
+    for (var i = decorators.length - 1; i >= 0; i--) {
+      if (d = decorators[i]) {
+        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+      }
+    }
+  }
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate, "_ts_decorate");
+var ErrorTracker = class _ErrorTracker {
+  static {
+    __name(this, "ErrorTracker");
+  }
+  logger = new import_common.Logger(_ErrorTracker.name);
+  errors = /* @__PURE__ */ new Map();
+  counter = 0;
+  track(error, category = "unknown", metadata) {
+    const key = `${category}:${error.message}`;
+    const existing = this.errors.get(key);
+    if (existing) {
+      existing.count++;
+      existing.lastOccurrence = /* @__PURE__ */ new Date();
+      if (metadata) {
+        existing.metadata = {
+          ...existing.metadata,
+          ...metadata
+        };
+      }
+    } else {
+      this.errors.set(key, {
+        id: `err_${++this.counter}`,
+        message: error.message,
+        stack: error.stack,
+        category,
+        count: 1,
+        firstOccurrence: /* @__PURE__ */ new Date(),
+        lastOccurrence: /* @__PURE__ */ new Date(),
+        metadata
+      });
+    }
+    this.logger.warn(`[${category}] ${error.message} (count: ${this.errors.get(key).count})`);
+  }
+  getErrors() {
+    return Array.from(this.errors.values());
+  }
+  getErrorsByCategory(category) {
+    return this.getErrors().filter((e) => e.category === category);
+  }
+  getTopErrors(limit = 10) {
+    return this.getErrors().sort((a, b) => b.count - a.count).slice(0, limit);
+  }
+  clear() {
+    this.errors.clear();
+  }
+  clearCategory(category) {
+    for (const [key, error] of this.errors) {
+      if (error.category === category) {
+        this.errors.delete(key);
+      }
+    }
+  }
+};
+ErrorTracker = _ts_decorate([
+  (0, import_common.Injectable)()
+], ErrorTracker);
+
+// src/error-reporter.ts
+var ERROR_REPORTER = /* @__PURE__ */ Symbol.for("@zucker-framework/monitoring/error-reporter");
+var NoopErrorReporter = class {
+  static {
+    __name(this, "NoopErrorReporter");
+  }
+  captureException() {
+  }
+  captureMessage() {
+  }
+  setUser() {
+  }
+};
+
+// src/health-check.service.ts
+var import_common2 = require("@nestjs/common");
+function _ts_decorate2(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") {
+    r = Reflect.decorate(decorators, target, key, desc);
+  } else {
+    for (var i = decorators.length - 1; i >= 0; i--) {
+      if (d = decorators[i]) {
+        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+      }
+    }
+  }
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate2, "_ts_decorate");
+var HealthStatus = /* @__PURE__ */ (function(HealthStatus2) {
+  HealthStatus2["UP"] = "UP";
+  HealthStatus2["DOWN"] = "DOWN";
+  HealthStatus2["DEGRADED"] = "DEGRADED";
+  return HealthStatus2;
+})({});
+var HealthCheckService = class _HealthCheckService {
+  static {
+    __name(this, "HealthCheckService");
+  }
+  logger = new import_common2.Logger(_HealthCheckService.name);
+  indicators = [];
+  registerIndicator(indicator) {
+    this.indicators.push(indicator);
+    this.logger.log(`Health indicator registered: ${indicator.name}`);
+  }
+  unregisterIndicator(name) {
+    this.indicators = this.indicators.filter((i) => i.name !== name);
+  }
+  async checkAll() {
+    const checks = [];
+    let overallStatus = "UP";
+    for (const indicator of this.indicators) {
+      try {
+        const result = await indicator.check();
+        checks.push(result);
+        if (result.status === "DOWN") {
+          overallStatus = "DOWN";
+        } else if (result.status === "DEGRADED" && overallStatus !== "DOWN") {
+          overallStatus = "DEGRADED";
+        }
+      } catch (error) {
+        const errorType = error instanceof Error ? error.name : "UnknownError";
+        this.logger.warn(`Health indicator failed: ${indicator.name} (${errorType})`);
+        checks.push({
+          name: indicator.name,
+          status: "DOWN",
+          details: {
+            error: "Health check failed"
+          },
+          timestamp: /* @__PURE__ */ new Date()
+        });
+        overallStatus = "DOWN";
+      }
+    }
+    return {
+      status: overallStatus,
+      checks,
+      timestamp: /* @__PURE__ */ new Date()
+    };
+  }
+  async check(name) {
+    const indicator = this.indicators.find((i) => i.name === name);
+    if (!indicator) return void 0;
+    return indicator.check();
+  }
+};
+HealthCheckService = _ts_decorate2([
+  (0, import_common2.Injectable)()
+], HealthCheckService);
+
+// src/metrics-legacy.ts
+var InMemoryMetricsCollector = class _InMemoryMetricsCollector {
+  static {
+    __name(this, "InMemoryMetricsCollector");
+  }
+  metrics = [];
+  static sortedTagsKey(tags) {
+    const sortedKeys = Object.keys(tags).sort();
+    const sorted = {};
+    for (const k of sortedKeys) {
+      sorted[k] = tags[k];
+    }
+    return JSON.stringify(sorted);
+  }
+  increment(name, tags = {}) {
+    const tagsKey = _InMemoryMetricsCollector.sortedTagsKey(tags);
+    const existing = this.metrics.find((m) => m.name === name && _InMemoryMetricsCollector.sortedTagsKey(m.tags) === tagsKey);
+    if (existing) {
+      existing.value++;
+      existing.timestamp = /* @__PURE__ */ new Date();
+    } else {
+      this.metrics.push({
+        name,
+        value: 1,
+        tags,
+        timestamp: /* @__PURE__ */ new Date()
+      });
+    }
+  }
+  gauge(name, value, tags = {}) {
+    const tagsKey = _InMemoryMetricsCollector.sortedTagsKey(tags);
+    const existing = this.metrics.find((m) => m.name === name && _InMemoryMetricsCollector.sortedTagsKey(m.tags) === tagsKey);
+    if (existing) {
+      existing.value = value;
+      existing.timestamp = /* @__PURE__ */ new Date();
+    } else {
+      this.metrics.push({
+        name,
+        value,
+        tags,
+        timestamp: /* @__PURE__ */ new Date()
+      });
+    }
+  }
+  histogram(name, value, tags = {}) {
+    this.metrics.push({
+      name,
+      value,
+      tags,
+      timestamp: /* @__PURE__ */ new Date()
+    });
+  }
+  getMetrics() {
+    return [
+      ...this.metrics
+    ];
+  }
+  clear() {
+    this.metrics = [];
+  }
+};
+
+// src/metrics/metrics-registry.ts
+var import_common3 = require("@nestjs/common");
+function _ts_decorate3(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") {
+    r = Reflect.decorate(decorators, target, key, desc);
+  } else {
+    for (var i = decorators.length - 1; i >= 0; i--) {
+      if (d = decorators[i]) {
+        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+      }
+    }
+  }
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate3, "_ts_decorate");
+function normalizeLabels(labels) {
+  return Object.fromEntries(Object.entries(labels).sort(([a], [b]) => a.localeCompare(b)));
+}
+__name(normalizeLabels, "normalizeLabels");
+function serializeLabels(labels) {
+  return JSON.stringify(normalizeLabels(labels));
+}
+__name(serializeLabels, "serializeLabels");
+function deserializeLabels(key) {
+  if (!key) return {};
+  return JSON.parse(key);
+}
+__name(deserializeLabels, "deserializeLabels");
+var Counter = class {
+  static {
+    __name(this, "Counter");
+  }
+  name;
+  description;
+  values = /* @__PURE__ */ new Map();
+  constructor(name, description) {
+    this.name = name;
+    this.description = description;
+  }
+  increment(labels = {}, amount = 1) {
+    const key = this.labelsKey(labels);
+    this.values.set(key, (this.values.get(key) ?? 0) + amount);
+  }
+  get(labels = {}) {
+    return this.values.get(this.labelsKey(labels)) ?? 0;
+  }
+  getAll() {
+    return Array.from(this.values.entries()).map(([key, value]) => ({
+      labels: this.parseKey(key),
+      value
+    }));
+  }
+  labelsKey(labels) {
+    return serializeLabels(labels);
+  }
+  parseKey(key) {
+    return deserializeLabels(key);
+  }
+};
+var Gauge = class {
+  static {
+    __name(this, "Gauge");
+  }
+  name;
+  description;
+  values = /* @__PURE__ */ new Map();
+  constructor(name, description) {
+    this.name = name;
+    this.description = description;
+  }
+  set(value, labels = {}) {
+    this.values.set(this.labelsKey(labels), value);
+  }
+  get(labels = {}) {
+    return this.values.get(this.labelsKey(labels)) ?? 0;
+  }
+  increment(labels = {}, amount = 1) {
+    const key = this.labelsKey(labels);
+    this.values.set(key, (this.values.get(key) ?? 0) + amount);
+  }
+  decrement(labels = {}, amount = 1) {
+    const key = this.labelsKey(labels);
+    this.values.set(key, (this.values.get(key) ?? 0) - amount);
+  }
+  getAll() {
+    return Array.from(this.values.entries()).map(([key, value]) => ({
+      labels: this.parseKey(key),
+      value
+    }));
+  }
+  labelsKey(labels) {
+    return serializeLabels(labels);
+  }
+  parseKey(key) {
+    return deserializeLabels(key);
+  }
+};
+var Histogram = class {
+  static {
+    __name(this, "Histogram");
+  }
+  name;
+  description;
+  buckets;
+  maxSamples;
+  observations = /* @__PURE__ */ new Map();
+  constructor(name, description, buckets = [
+    5e-3,
+    0.01,
+    0.025,
+    0.05,
+    0.1,
+    0.25,
+    0.5,
+    1,
+    2.5,
+    5,
+    10
+  ], maxSamples = 1e4) {
+    this.name = name;
+    this.description = description;
+    this.buckets = buckets;
+    this.maxSamples = maxSamples;
+    if (!Number.isInteger(maxSamples) || maxSamples <= 0) {
+      throw new Error("Histogram maxSamples must be a positive integer");
+    }
+  }
+  observe(value, labels = {}) {
+    const key = this.labelsKey(labels);
+    const observation = this.observations.get(key) ?? {
+      count: 0,
+      sum: 0,
+      bucketCounts: this.buckets.map(() => 0),
+      samples: []
+    };
+    observation.count += 1;
+    observation.sum += value;
+    for (let index = 0; index < this.buckets.length; index += 1) {
+      if (value <= this.buckets[index]) observation.bucketCounts[index] += 1;
+    }
+    observation.samples.push(value);
+    if (observation.samples.length > this.maxSamples) {
+      observation.samples.splice(0, observation.samples.length - this.maxSamples);
+    }
+    this.observations.set(key, observation);
+  }
+  getPercentile(percentile, labels = {}) {
+    const values = this.observations.get(this.labelsKey(labels))?.samples ?? [];
+    if (values.length === 0) return 0;
+    const sorted = [
+      ...values
+    ].sort((a, b) => a - b);
+    const idx = Math.ceil(percentile / 100 * sorted.length) - 1;
+    return sorted[Math.max(0, idx)];
+  }
+  getCount(labels = {}) {
+    return this.observations.get(this.labelsKey(labels))?.count ?? 0;
+  }
+  getSum(labels = {}) {
+    return this.observations.get(this.labelsKey(labels))?.sum ?? 0;
+  }
+  getAll() {
+    return Array.from(this.observations.entries()).map(([key, observation]) => {
+      const bucketCounts = {};
+      for (let index = 0; index < this.buckets.length; index += 1) {
+        bucketCounts[String(this.buckets[index])] = observation.bucketCounts[index];
+      }
+      bucketCounts["+Inf"] = observation.count;
+      return {
+        labels: this.parseKey(key),
+        count: observation.count,
+        sum: observation.sum,
+        bucketCounts
+      };
+    });
+  }
+  labelsKey(labels) {
+    return serializeLabels(labels);
+  }
+  parseKey(key) {
+    return deserializeLabels(key);
+  }
+};
+var Timer = class {
+  static {
+    __name(this, "Timer");
+  }
+  name;
+  description;
+  histogram;
+  constructor(name, description) {
+    this.name = name;
+    this.description = description;
+    this.histogram = new Histogram(name, description);
+  }
+  /**
+  * 记录一次耗时（秒）
+  */
+  record(durationSeconds, labels = {}) {
+    this.histogram.observe(durationSeconds, labels);
+  }
+  /**
+  * 开始计时，返回结束函数
+  */
+  startTimer(labels = {}) {
+    const start = process.hrtime.bigint();
+    return () => {
+      const duration = Number(process.hrtime.bigint() - start) / 1e9;
+      this.record(duration, labels);
+      return duration;
+    };
+  }
+  getHistogram() {
+    return this.histogram;
+  }
+};
+var Summary = class {
+  static {
+    __name(this, "Summary");
+  }
+  name;
+  description;
+  quantiles;
+  maxAgeMs;
+  maxSamples;
+  observations = /* @__PURE__ */ new Map();
+  constructor(name, description, quantiles = [
+    0.5,
+    0.9,
+    0.95,
+    0.99
+  ], maxAgeMs = 6e5, maxSamples = 1e4) {
+    this.name = name;
+    this.description = description;
+    this.quantiles = quantiles;
+    this.maxAgeMs = maxAgeMs;
+    this.maxSamples = maxSamples;
+    if (!Number.isFinite(maxAgeMs) || maxAgeMs <= 0) {
+      throw new Error("Summary maxAgeMs must be greater than zero");
+    }
+    if (!Number.isInteger(maxSamples) || maxSamples <= 0) {
+      throw new Error("Summary maxSamples must be a positive integer");
+    }
+  }
+  observe(value, labels = {}) {
+    const key = this.labelsKey(labels);
+    const now = Date.now();
+    const observation = this.observations.get(key) ?? {
+      count: 0,
+      sum: 0,
+      samples: []
+    };
+    observation.count += 1;
+    observation.sum += value;
+    observation.samples.push({
+      value,
+      observedAt: now
+    });
+    this.prune(observation.samples, now);
+    this.observations.set(key, observation);
+  }
+  getQuantile(quantile, labels = {}) {
+    const observation = this.observations.get(this.labelsKey(labels));
+    if (!observation) return 0;
+    this.prune(observation.samples, Date.now());
+    const values = observation.samples.map(({ value }) => value);
+    if (values.length === 0) return 0;
+    const sorted = [
+      ...values
+    ].sort((a, b) => a - b);
+    const idx = Math.ceil(quantile * sorted.length) - 1;
+    return sorted[Math.max(0, idx)];
+  }
+  getCount(labels = {}) {
+    return this.observations.get(this.labelsKey(labels))?.count ?? 0;
+  }
+  getSum(labels = {}) {
+    return this.observations.get(this.labelsKey(labels))?.sum ?? 0;
+  }
+  getAll() {
+    const now = Date.now();
+    return Array.from(this.observations.entries()).map(([key, observation]) => {
+      this.prune(observation.samples, now);
+      const sorted = observation.samples.map(({ value }) => value).sort((a, b) => a - b);
+      const quantileValues = {};
+      for (const q of this.quantiles) {
+        if (sorted.length === 0) {
+          quantileValues[String(q)] = 0;
+        } else {
+          const idx = Math.ceil(q * sorted.length) - 1;
+          quantileValues[String(q)] = sorted[Math.max(0, idx)];
+        }
+      }
+      return {
+        labels: this.parseKey(key),
+        count: observation.count,
+        sum: observation.sum,
+        quantileValues
+      };
+    });
+  }
+  prune(samples, now) {
+    const cutoff = now - this.maxAgeMs;
+    let expired = 0;
+    while (expired < samples.length && samples[expired].observedAt < cutoff) {
+      expired += 1;
+    }
+    const excess = samples.length - expired - this.maxSamples;
+    const removeCount = expired + Math.max(0, excess);
+    if (removeCount > 0) samples.splice(0, removeCount);
+  }
+  labelsKey(labels) {
+    return serializeLabels(labels);
+  }
+  parseKey(key) {
+    return deserializeLabels(key);
+  }
+};
+var MetricsRegistry = class {
+  static {
+    __name(this, "MetricsRegistry");
+  }
+  counters = /* @__PURE__ */ new Map();
+  gauges = /* @__PURE__ */ new Map();
+  histograms = /* @__PURE__ */ new Map();
+  timers = /* @__PURE__ */ new Map();
+  summaries = /* @__PURE__ */ new Map();
+  counter(name, description = "") {
+    let c = this.counters.get(name);
+    if (!c) {
+      c = new Counter(name, description);
+      this.counters.set(name, c);
+    }
+    return c;
+  }
+  gauge(name, description = "") {
+    let g = this.gauges.get(name);
+    if (!g) {
+      g = new Gauge(name, description);
+      this.gauges.set(name, g);
+    }
+    return g;
+  }
+  histogram(name, description = "", buckets) {
+    let h = this.histograms.get(name);
+    if (!h) {
+      h = new Histogram(name, description, buckets);
+      this.histograms.set(name, h);
+    }
+    return h;
+  }
+  timer(name, description = "") {
+    let t = this.timers.get(name);
+    if (!t) {
+      t = new Timer(name, description);
+      this.timers.set(name, t);
+    }
+    return t;
+  }
+  summary(name, description = "", quantiles) {
+    let s = this.summaries.get(name);
+    if (!s) {
+      s = new Summary(name, description, quantiles);
+      this.summaries.set(name, s);
+    }
+    return s;
+  }
+  getCounters() {
+    return Array.from(this.counters.values());
+  }
+  getGauges() {
+    return Array.from(this.gauges.values());
+  }
+  getHistograms() {
+    return Array.from(this.histograms.values());
+  }
+  getTimers() {
+    return Array.from(this.timers.values());
+  }
+  getSummaries() {
+    return Array.from(this.summaries.values());
+  }
+  /**
+  * 重置所有指标
+  */
+  clear() {
+    this.counters.clear();
+    this.gauges.clear();
+    this.histograms.clear();
+    this.timers.clear();
+    this.summaries.clear();
+  }
+};
+MetricsRegistry = _ts_decorate3([
+  (0, import_common3.Injectable)()
+], MetricsRegistry);
+
+// src/metrics/metrics.decorator.ts
+function Metrics(name, options) {
+  return (_target, propertyKey, descriptor) => {
+    const originalMethod = descriptor.value;
+    descriptor.value = function(...args) {
+      const registry = options?.registry ?? this?.metricsRegistry;
+      if (!registry) {
+        return originalMethod.apply(this, args);
+      }
+      const baseLabels = {
+        method: String(propertyKey),
+        class: this?.constructor?.name ?? "Unknown",
+        ...options?.labels
+      };
+      const counter = registry.counter(`${name}_total`, `Total calls to ${String(propertyKey)}`);
+      const timer = registry.timer(`${name}_duration_seconds`, `Duration of ${String(propertyKey)}`);
+      const trackErrors = options?.trackErrors !== false;
+      const trackActive = options?.trackActiveRequests === true;
+      counter.increment(baseLabels);
+      const stopTimer = timer.startTimer(baseLabels);
+      let activeGauge;
+      if (trackActive) {
+        activeGauge = registry.gauge(`${name}_active_requests`, `Active requests for ${String(propertyKey)}`);
+        activeGauge.increment(baseLabels);
+      }
+      const onFinish = /* @__PURE__ */ __name((isError) => {
+        stopTimer();
+        if (trackActive && activeGauge) {
+          activeGauge.decrement(baseLabels);
+        }
+        if (isError && trackErrors) {
+          const errorCounter = registry.counter(`${name}_errors_total`, `Error calls to ${String(propertyKey)}`);
+          errorCounter.increment(baseLabels);
+        }
+      }, "onFinish");
+      try {
+        const result = originalMethod.apply(this, args);
+        if (result && typeof result === "object" && typeof result.then === "function") {
+          return result.then((val) => {
+            onFinish(false);
+            return val;
+          }, (err) => {
+            onFinish(true);
+            throw err;
+          });
+        }
+        onFinish(false);
+        return result;
+      } catch (err) {
+        onFinish(true);
+        throw err;
+      }
+    };
+    return descriptor;
+  };
+}
+__name(Metrics, "Metrics");
+
+// src/metrics/system-metrics.ts
+var import_common4 = require("@nestjs/common");
+var os = __toESM(require("os"));
+function _ts_decorate4(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") {
+    r = Reflect.decorate(decorators, target, key, desc);
+  } else {
+    for (var i = decorators.length - 1; i >= 0; i--) {
+      if (d = decorators[i]) {
+        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+      }
+    }
+  }
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate4, "_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");
+var SystemMetricsCollector = class {
+  static {
+    __name(this, "SystemMetricsCollector");
+  }
+  registry;
+  intervalHandle = null;
+  options;
+  lastCpuUsage = null;
+  lastCpuUsageTime = null;
+  constructor(registry) {
+    this.registry = registry;
+    this.options = {
+      intervalMs: 15e3,
+      enabled: true,
+      prefix: ""
+    };
+  }
+  configure(options) {
+    this.options = {
+      ...this.options,
+      ...options
+    };
+  }
+  onModuleInit() {
+    if (!this.options.enabled) return;
+    this.collect();
+    this.intervalHandle = setInterval(() => this.collect(), this.options.intervalMs);
+  }
+  onModuleDestroy() {
+    if (this.intervalHandle) {
+      clearInterval(this.intervalHandle);
+      this.intervalHandle = null;
+    }
+  }
+  metricName(name) {
+    return this.options.prefix ? `${this.options.prefix}_${name}` : name;
+  }
+  collect() {
+    this.collectCpuMetrics();
+    this.collectMemoryMetrics();
+    this.collectProcessMetrics();
+    this.collectUptimeMetrics();
+    this.measureEventLoopDelay();
+    this.collectHandleMetrics();
+  }
+  collectCpuMetrics() {
+    const cpus2 = os.cpus();
+    let totalIdle = 0;
+    let totalTick = 0;
+    for (const cpu of cpus2) {
+      const times = cpu.times;
+      totalIdle += times.idle;
+      totalTick += times.user + times.nice + times.sys + times.irq + times.idle;
+    }
+    const cpuUsage = totalTick > 0 ? 1 - totalIdle / totalTick : 0;
+    this.registry.gauge(this.metricName("system_cpu_usage"), "System CPU usage ratio").set(cpuUsage);
+    this.registry.gauge(this.metricName("system_cpu_count"), "Number of CPUs").set(cpus2.length);
+    const currentCpuUsage = process.cpuUsage();
+    const now = process.hrtime.bigint();
+    if (this.lastCpuUsage && this.lastCpuUsageTime) {
+      const elapsedMicros = Number(now - this.lastCpuUsageTime) / 1e3;
+      if (elapsedMicros > 0) {
+        const userDiff = currentCpuUsage.user - this.lastCpuUsage.user;
+        const systemDiff = currentCpuUsage.system - this.lastCpuUsage.system;
+        const processCpuUsage = (userDiff + systemDiff) / elapsedMicros;
+        this.registry.gauge(this.metricName("process_cpu_usage"), "Process CPU usage ratio").set(Math.min(1, processCpuUsage));
+        this.registry.gauge(this.metricName("process_cpu_user_seconds_total"), "Process CPU user time total").set(currentCpuUsage.user / 1e6);
+        this.registry.gauge(this.metricName("process_cpu_system_seconds_total"), "Process CPU system time total").set(currentCpuUsage.system / 1e6);
+      }
+    }
+    this.lastCpuUsage = currentCpuUsage;
+    this.lastCpuUsageTime = now;
+  }
+  collectMemoryMetrics() {
+    const totalMem = os.totalmem();
+    const freeMem = os.freemem();
+    this.registry.gauge(this.metricName("system_memory_total_bytes"), "Total system memory").set(totalMem);
+    this.registry.gauge(this.metricName("system_memory_free_bytes"), "Free system memory").set(freeMem);
+    this.registry.gauge(this.metricName("system_memory_used_bytes"), "Used system memory").set(totalMem - freeMem);
+  }
+  collectProcessMetrics() {
+    const memUsage = process.memoryUsage();
+    this.registry.gauge(this.metricName("process_memory_rss_bytes"), "Process RSS").set(memUsage.rss);
+    this.registry.gauge(this.metricName("process_memory_heap_total_bytes"), "Process heap total").set(memUsage.heapTotal);
+    this.registry.gauge(this.metricName("process_memory_heap_used_bytes"), "Process heap used").set(memUsage.heapUsed);
+    this.registry.gauge(this.metricName("process_memory_external_bytes"), "Process external memory").set(memUsage.external);
+    if (memUsage.arrayBuffers !== void 0) {
+      this.registry.gauge(this.metricName("process_memory_array_buffers_bytes"), "Process ArrayBuffers memory").set(memUsage.arrayBuffers);
+    }
+  }
+  collectUptimeMetrics() {
+    const processUptime = process.uptime();
+    this.registry.gauge(this.metricName("process_uptime_seconds"), "Process uptime").set(processUptime);
+    let systemUptime = 0;
+    try {
+      systemUptime = os.uptime();
+    } catch {
+      systemUptime = 0;
+    }
+    this.registry.gauge(this.metricName("system_uptime_seconds"), "System uptime").set(systemUptime);
+    this.registry.gauge(this.metricName("process_start_time_seconds"), "Process start time (Unix epoch)").set(Math.floor(Date.now() / 1e3 - processUptime));
+  }
+  measureEventLoopDelay() {
+    const start = process.hrtime.bigint();
+    setImmediate(() => {
+      const delay = Number(process.hrtime.bigint() - start) / 1e6;
+      this.registry.gauge(this.metricName("process_event_loop_delay_ms"), "Event loop delay").set(delay);
+    });
+  }
+  collectHandleMetrics() {
+    const activeHandles = process._getActiveHandles?.()?.length;
+    const activeRequests = process._getActiveRequests?.()?.length;
+    if (typeof activeHandles === "number") {
+      this.registry.gauge(this.metricName("process_active_handles"), "Number of active handles").set(activeHandles);
+    }
+    if (typeof activeRequests === "number") {
+      this.registry.gauge(this.metricName("process_active_requests"), "Number of active requests").set(activeRequests);
+    }
+  }
+};
+SystemMetricsCollector = _ts_decorate4([
+  (0, import_common4.Injectable)(),
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", [
+    typeof MetricsRegistry === "undefined" ? Object : MetricsRegistry
+  ])
+], SystemMetricsCollector);
+
+// src/metrics/prometheus-exporter.ts
+var import_common5 = require("@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") {
+    r = Reflect.decorate(decorators, target, key, desc);
+  } else {
+    for (var i = decorators.length - 1; i >= 0; i--) {
+      if (d = decorators[i]) {
+        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+      }
+    }
+  }
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate5, "_ts_decorate");
+function _ts_metadata2(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) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__name(_ts_param, "_ts_param");
+function formatLabels(labels) {
+  const entries = Object.entries(labels);
+  if (entries.length === 0) return "";
+  const pairs = entries.map(([key, value]) => `${key}="${escapeLabelValue(value)}"`);
+  return `{${pairs.join(",")}}`;
+}
+__name(formatLabels, "formatLabels");
+function escapeHelp(text) {
+  return text.replace(/\\/g, "\\\\").replace(/\n/g, "\\n");
+}
+__name(escapeHelp, "escapeHelp");
+function escapeLabelValue(value) {
+  return value.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\n/g, "\\n");
+}
+__name(escapeLabelValue, "escapeLabelValue");
+function renderPrometheusMetrics(registry) {
+  const lines = [];
+  for (const counter of registry.getCounters()) {
+    lines.push(`# HELP ${counter.name} ${escapeHelp(counter.description)}`);
+    lines.push(`# TYPE ${counter.name} counter`);
+    for (const { labels, value } of counter.getAll()) {
+      lines.push(`${counter.name}${formatLabels(labels)} ${value}`);
+    }
+  }
+  for (const gauge of registry.getGauges()) {
+    lines.push(`# HELP ${gauge.name} ${escapeHelp(gauge.description)}`);
+    lines.push(`# TYPE ${gauge.name} gauge`);
+    for (const { labels, value } of gauge.getAll()) {
+      lines.push(`${gauge.name}${formatLabels(labels)} ${value}`);
+    }
+  }
+  for (const histogram of registry.getHistograms()) {
+    lines.push(`# HELP ${histogram.name} ${escapeHelp(histogram.description)}`);
+    lines.push(`# TYPE ${histogram.name} histogram`);
+    for (const { labels, count, sum, bucketCounts } of histogram.getAll()) {
+      for (const [le, value] of Object.entries(bucketCounts)) {
+        lines.push(`${histogram.name}_bucket${formatLabels({
+          ...labels,
+          le
+        })} ${value}`);
+      }
+      lines.push(`${histogram.name}_count${formatLabels(labels)} ${count}`);
+      lines.push(`${histogram.name}_sum${formatLabels(labels)} ${sum}`);
+    }
+  }
+  for (const timer of registry.getTimers()) {
+    const histogram = timer.getHistogram();
+    lines.push(`# HELP ${timer.name} ${escapeHelp(timer.description)}`);
+    lines.push(`# TYPE ${timer.name} histogram`);
+    for (const { labels, count, sum, bucketCounts } of histogram.getAll()) {
+      for (const [le, value] of Object.entries(bucketCounts)) {
+        lines.push(`${timer.name}_bucket${formatLabels({
+          ...labels,
+          le
+        })} ${value}`);
+      }
+      lines.push(`${timer.name}_count${formatLabels(labels)} ${count}`);
+      lines.push(`${timer.name}_sum${formatLabels(labels)} ${sum}`);
+    }
+  }
+  for (const summary of registry.getSummaries()) {
+    lines.push(`# HELP ${summary.name} ${escapeHelp(summary.description)}`);
+    lines.push(`# TYPE ${summary.name} summary`);
+    for (const { labels, count, sum, quantileValues } of summary.getAll()) {
+      for (const [quantile, value] of Object.entries(quantileValues)) {
+        lines.push(`${summary.name}${formatLabels({
+          ...labels,
+          quantile
+        })} ${value}`);
+      }
+      lines.push(`${summary.name}_count${formatLabels(labels)} ${count}`);
+      lines.push(`${summary.name}_sum${formatLabels(labels)} ${sum}`);
+    }
+  }
+  return `${lines.join("\n")}
+`;
+}
+__name(renderPrometheusMetrics, "renderPrometheusMetrics");
+var PrometheusExporter = class {
+  static {
+    __name(this, "PrometheusExporter");
+  }
+  registry;
+  constructor(registry) {
+    this.registry = registry;
+  }
+  getMetrics() {
+    return renderPrometheusMetrics(this.registry);
+  }
+};
+_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)
+], 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", [
+    typeof MetricsRegistry === "undefined" ? Object : MetricsRegistry
+  ])
+], PrometheusExporter);
+
+// src/monitoring.module.ts
+var import_common9 = require("@nestjs/common");
+
+// src/health.controller.ts
+var import_common6 = require("@nestjs/common");
+
+// src/process-uptime.ts
+function getProcessUptime(startedAtMs, nowMs = Date.now()) {
+  const uptimeMs = Math.max(0, nowMs - startedAtMs);
+  return {
+    uptimeMs,
+    uptimeSeconds: Math.floor(uptimeMs / 1e3)
+  };
+}
+__name(getProcessUptime, "getProcessUptime");
+
+// src/health.controller.ts
+function _ts_decorate6(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") {
+    r = Reflect.decorate(decorators, target, key, desc);
+  } else {
+    for (var i = decorators.length - 1; i >= 0; i--) {
+      if (d = decorators[i]) {
+        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+      }
+    }
+  }
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate6, "_ts_decorate");
+function _ts_metadata3(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) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__name(_ts_param2, "_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 {
+  static {
+    __name(this, "HealthController");
+  }
+  healthCheckService;
+  startedAtMs = Date.now();
+  constructor(healthCheckService) {
+    this.healthCheckService = healthCheckService;
+  }
+  async check(res) {
+    const result = await this.healthCheckService.checkAll();
+    const statusCode = result.status === HealthStatus.DOWN ? 503 : 200;
+    res.status(statusCode).json({
+      status: result.status === HealthStatus.UP ? "up" : result.status === HealthStatus.DEGRADED ? "degraded" : "down",
+      checks: this.formatChecks(result.checks),
+      ...getProcessUptime(this.startedAtMs),
+      timestamp: result.timestamp.toISOString()
+    });
+  }
+  /**
+  * K8s liveness 探针 — 仅检查进程是否存活
+  */
+  live(res) {
+    res.status(200).json({
+      status: "up",
+      ...getProcessUptime(this.startedAtMs),
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    });
+  }
+  /**
+  * K8s readiness 探针 — 检查所有依赖是否就绪
+  */
+  async ready(res) {
+    const result = await this.healthCheckService.checkAll();
+    const isReady = result.status !== HealthStatus.DOWN;
+    const statusCode = isReady ? 200 : 503;
+    res.status(statusCode).json({
+      status: isReady ? "up" : "down",
+      checks: this.formatChecks(result.checks),
+      ...getProcessUptime(this.startedAtMs),
+      timestamp: result.timestamp.toISOString()
+    });
+  }
+  formatChecks(checks) {
+    const formatted = {};
+    for (const check of checks) {
+      formatted[check.name] = {
+        status: check.status === HealthStatus.UP ? "up" : check.status === HealthStatus.DEGRADED ? "degraded" : "down",
+        details: check.details
+      };
+    }
+    return formatted;
+  }
+};
+_ts_decorate6([
+  (0, import_common6.Get)(),
+  _ts_param2(0, (0, import_common6.Res)()),
+  _ts_metadata3("design:type", Function),
+  _ts_metadata3("design:paramtypes", [
+    Object
+  ]),
+  _ts_metadata3("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", [
+    Object
+  ]),
+  _ts_metadata3("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", [
+    Object
+  ]),
+  _ts_metadata3("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", [
+    typeof HealthCheckService === "undefined" ? Object : HealthCheckService
+  ])
+], HealthController);
+
+// src/alert/alert-manager.service.ts
+var import_common7 = require("@nestjs/common");
+var import_crypto = require("crypto");
+var import_event_emitter = require("@nestjs/event-emitter");
+function _ts_decorate7(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") {
+    r = Reflect.decorate(decorators, target, key, desc);
+  } else {
+    for (var i = decorators.length - 1; i >= 0; i--) {
+      if (d = decorators[i]) {
+        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+      }
+    }
+  }
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate7, "_ts_decorate");
+function _ts_metadata4(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) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__name(_ts_param3, "_ts_param");
+function nextAlertId() {
+  return `alert-${Date.now()}-${(0, import_crypto.randomUUID)().slice(0, 8)}`;
+}
+__name(nextAlertId, "nextAlertId");
+var AlertManagerService = class _AlertManagerService {
+  static {
+    __name(this, "AlertManagerService");
+  }
+  eventEmitter;
+  db;
+  logger = new import_common7.Logger(_AlertManagerService.name);
+  /** 已注册的告警规则 */
+  rules = /* @__PURE__ */ new Map();
+  /** 所有告警记录（含历史） */
+  alerts = /* @__PURE__ */ new Map();
+  /** 每条规则的持续违规状态 */
+  violations = /* @__PURE__ */ new Map();
+  /** 活跃告警的 ruleId 索引（非 RESOLVED 状态的告警） */
+  activeRuleIds = /* @__PURE__ */ new Set();
+  constructor(eventEmitter, db) {
+    this.eventEmitter = eventEmitter;
+    this.db = db;
+  }
+  async onModuleInit() {
+    if (!this.db) return;
+    try {
+      const rules = await this.db.model("alertRules").findMany({});
+      for (const rule of rules) {
+        this.rules.set(rule.id, rule);
+      }
+      if (rules.length > 0) {
+        this.logger.log(`Loaded ${rules.length} alert rules from database`);
+      }
+    } catch {
+    }
+  }
+  // ─── 规则管理 ───────────────────────────────────────
+  registerRule(rule) {
+    this.rules.set(rule.id, {
+      ...rule
+    });
+    if (this.db) {
+      this.db.model("alertRules").update({
+        where: {
+          id: rule.id
+        },
+        data: {
+          ...rule
+        }
+      }).catch(() => {
+        this.db.model("alertRules").create({
+          data: {
+            ...rule
+          }
+        }).catch((dbErr) => {
+          this.logger.warn(`Failed to persist alert rule ${rule.id} to database: ${dbErr instanceof Error ? dbErr.message : String(dbErr)}`);
+        });
+      });
+    }
+    this.logger.log(`Alert rule registered: ${rule.name} (${rule.id})`);
+  }
+  removeRule(ruleId) {
+    const deleted = this.rules.delete(ruleId);
+    if (deleted) {
+      this.violations.delete(ruleId);
+      this.logger.log(`Alert rule removed: ${ruleId}`);
+    }
+    return deleted;
+  }
+  getRules() {
+    return Array.from(this.rules.values());
+  }
+  getRule(ruleId) {
+    return this.rules.get(ruleId);
+  }
+  // ─── 告警评估 ───────────────────────────────────────
+  /**
+  * 对一组指标快照评估所有已启用规则。
+  * 应由调度器（如 Cron / Interval）定期调用。
+  */
+  evaluate(metrics) {
+    const triggered = [];
+    const now = Date.now();
+    for (const rule of this.rules.values()) {
+      if (!rule.enabled) continue;
+      const value = metrics[rule.metric];
+      if (value === void 0) continue;
+      const violated = this.checkCondition(value, rule.condition, rule.threshold);
+      if (violated) {
+        const state = this.violations.get(rule.id);
+        if (state) {
+          state.count++;
+          state.lastValue = value;
+        } else {
+          this.violations.set(rule.id, {
+            startedAt: now,
+            count: 1,
+            lastValue: value
+          });
+        }
+        const current = this.violations.get(rule.id);
+        const elapsedSec = (now - current.startedAt) / 1e3;
+        if (elapsedSec >= rule.duration && !this.hasActiveAlertForRule(rule.id)) {
+          const record = this.createAlert(rule, value);
+          triggered.push(record);
+        }
+      } else {
+        this.violations.delete(rule.id);
+        this.autoResolveForRule(rule.id);
+      }
+    }
+    return triggered;
+  }
+  // ─── 告警查询 ───────────────────────────────────────
+  getAlerts() {
+    return Array.from(this.alerts.values());
+  }
+  getActiveAlerts() {
+    return Array.from(this.alerts.values()).filter((a) => a.status === "ACTIVE");
+  }
+  getAlert(alertId) {
+    return this.alerts.get(alertId);
+  }
+  // ─── 告警操作 ───────────────────────────────────────
+  acknowledgeAlert(alertId, userId) {
+    const alert = this.alerts.get(alertId);
+    if (!alert || alert.status !== "ACTIVE") return void 0;
+    alert.status = "ACKNOWLEDGED";
+    alert.acknowledgedAt = Date.now();
+    alert.acknowledgedBy = userId;
+    this.eventEmitter?.emit("alert.acknowledged", {
+      ...alert
+    });
+    this.logger.log(`Alert acknowledged: ${alertId} by ${userId}`);
+    return {
+      ...alert
+    };
+  }
+  resolveAlert(alertId, userId) {
+    const alert = this.alerts.get(alertId);
+    if (!alert || alert.status === "RESOLVED") return void 0;
+    alert.status = "RESOLVED";
+    alert.resolvedAt = Date.now();
+    alert.resolvedBy = userId;
+    this.violations.delete(alert.ruleId);
+    if (!Array.from(this.alerts.values()).some((a) => a.ruleId === alert.ruleId && a.id !== alertId && a.status !== "RESOLVED")) {
+      this.activeRuleIds.delete(alert.ruleId);
+    }
+    this.eventEmitter?.emit("alert.resolved", {
+      ...alert
+    });
+    this.logger.log(`Alert resolved: ${alertId} by ${userId}`);
+    return {
+      ...alert
+    };
+  }
+  // ─── 内部方法 ───────────────────────────────────────
+  checkCondition(value, condition, threshold) {
+    switch (condition) {
+      case ">":
+        return value > threshold;
+      case ">=":
+        return value >= threshold;
+      case "<":
+        return value < threshold;
+      case "<=":
+        return value <= threshold;
+      case "==":
+        return value === threshold;
+      case "!=":
+        return value !== threshold;
+      default:
+        return false;
+    }
+  }
+  hasActiveAlertForRule(ruleId) {
+    return this.activeRuleIds.has(ruleId);
+  }
+  createAlert(rule, value) {
+    const record = {
+      id: nextAlertId(),
+      ruleId: rule.id,
+      ruleName: rule.name,
+      metric: rule.metric,
+      value,
+      threshold: rule.threshold,
+      severity: rule.severity,
+      status: "ACTIVE",
+      message: `${rule.metric} ${rule.condition} ${rule.threshold} (current: ${value})`,
+      triggeredAt: Date.now()
+    };
+    this.alerts.set(record.id, record);
+    this.activeRuleIds.add(rule.id);
+    this.eventEmitter?.emit("alert.triggered", {
+      ...record
+    });
+    this.logger.warn(`Alert triggered: [${record.severity}] ${record.message}`);
+    return {
+      ...record
+    };
+  }
+  autoResolveForRule(ruleId) {
+    for (const alert of this.alerts.values()) {
+      if (alert.ruleId === ruleId && alert.status !== "RESOLVED") {
+        alert.status = "RESOLVED";
+        alert.resolvedAt = Date.now();
+        alert.resolvedBy = "system";
+        this.eventEmitter?.emit("alert.resolved", {
+          ...alert
+        });
+        this.logger.log(`Alert auto-resolved: ${alert.id} (metric recovered)`);
+      }
+    }
+    if (!Array.from(this.alerts.values()).some((a) => a.ruleId === ruleId && a.status !== "RESOLVED")) {
+      this.activeRuleIds.delete(ruleId);
+    }
+  }
+};
+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", [
+    typeof import_event_emitter.EventEmitter2 === "undefined" ? Object : import_event_emitter.EventEmitter2,
+    Object
+  ])
+], AlertManagerService);
+
+// src/alert/alert.controller.ts
+var import_common8 = require("@nestjs/common");
+function _ts_decorate8(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") {
+    r = Reflect.decorate(decorators, target, key, desc);
+  } else {
+    for (var i = decorators.length - 1; i >= 0; i--) {
+      if (d = decorators[i]) {
+        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+      }
+    }
+  }
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate8, "_ts_decorate");
+function _ts_metadata5(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) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__name(_ts_param4, "_ts_param");
+var Permissions = /* @__PURE__ */ __name(() => (0, import_common8.SetMetadata)("zucker:auth:permissions", []), "Permissions");
+var AlertController = class {
+  static {
+    __name(this, "AlertController");
+  }
+  alertManager;
+  constructor(alertManager) {
+    this.alertManager = alertManager;
+  }
+  // ─── 告警列表 ───────────────────────────────────────
+  getAlerts() {
+    return this.alertManager.getAlerts();
+  }
+  // ─── 规则管理 ───────────────────────────────────────
+  getRules() {
+    return this.alertManager.getRules();
+  }
+  createRule(body) {
+    if (!body.id || !body.name || !body.metric || body.threshold === void 0) {
+      throw new import_common8.BadRequestException("Missing required fields: id, name, metric, threshold");
+    }
+    const rule = {
+      id: body.id,
+      name: body.name,
+      metric: body.metric,
+      condition: body.condition ?? ">",
+      threshold: body.threshold,
+      duration: body.duration ?? 0,
+      severity: body.severity ?? "MEDIUM",
+      enabled: body.enabled !== false,
+      notifyChannels: body.notifyChannels
+    };
+    this.alertManager.registerRule(rule);
+    return rule;
+  }
+  deleteRule(id) {
+    const removed = this.alertManager.removeRule(id);
+    if (!removed) {
+      throw new import_common8.NotFoundException(`Rule ${id} not found`);
+    }
+  }
+  // ─── 告警操作 ───────────────────────────────────────
+  acknowledgeAlert(id, userId) {
+    if (!userId) {
+      throw new import_common8.BadRequestException("userId is required");
+    }
+    const result = this.alertManager.acknowledgeAlert(id, userId);
+    if (!result) {
+      throw new import_common8.NotFoundException(`Alert ${id} not found or not in ACTIVE status`);
+    }
+    return result;
+  }
+  resolveAlert(id, userId) {
+    if (!userId) {
+      throw new import_common8.BadRequestException("userId is required");
+    }
+    const result = this.alertManager.resolveAlert(id, userId);
+    if (!result) {
+      throw new import_common8.NotFoundException(`Alert ${id} not found or already resolved`);
+    }
+    return result;
+  }
+};
+_ts_decorate8([
+  (0, import_common8.Get)(),
+  _ts_metadata5("design:type", Function),
+  _ts_metadata5("design:paramtypes", []),
+  _ts_metadata5("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)
+], 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", [
+    typeof AlertRule === "undefined" ? Object : AlertRule
+  ]),
+  _ts_metadata5("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", [
+    String
+  ]),
+  _ts_metadata5("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", [
+    String,
+    String
+  ]),
+  _ts_metadata5("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", [
+    String,
+    String
+  ]),
+  _ts_metadata5("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", [
+    typeof AlertManagerService === "undefined" ? Object : AlertManagerService
+  ])
+], AlertController);
+
+// src/monitoring.module.ts
+function _ts_decorate9(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") {
+    r = Reflect.decorate(decorators, target, key, desc);
+  } else {
+    for (var i = decorators.length - 1; i >= 0; i--) {
+      if (d = decorators[i]) {
+        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+      }
+    }
+  }
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate9, "_ts_decorate");
+var METRICS_COLLECTOR = /* @__PURE__ */ Symbol("METRICS_COLLECTOR");
+var ZuckerMonitoringModule = class {
+  static {
+    __name(this, "ZuckerMonitoringModule");
+  }
+};
+ZuckerMonitoringModule = _ts_decorate9([
+  (0, import_common9.Global)(),
+  (0, import_common9.Module)({
+    controllers: [
+      HealthController,
+      PrometheusExporter,
+      AlertController
+    ],
+    providers: [
+      ErrorTracker,
+      HealthCheckService,
+      MetricsRegistry,
+      SystemMetricsCollector,
+      AlertManagerService,
+      {
+        provide: METRICS_COLLECTOR,
+        useClass: InMemoryMetricsCollector
+      }
+    ],
+    exports: [
+      ErrorTracker,
+      HealthCheckService,
+      MetricsRegistry,
+      SystemMetricsCollector,
+      AlertManagerService,
+      METRICS_COLLECTOR
+    ]
+  })
+], ZuckerMonitoringModule);
+
+// src/usage-tracker.ts
+var import_common10 = require("@nestjs/common");
+var import_node_async_hooks = require("async_hooks");
+function _ts_decorate10(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") {
+    r = Reflect.decorate(decorators, target, key, desc);
+  } else {
+    for (var i = decorators.length - 1; i >= 0; i--) {
+      if (d = decorators[i]) {
+        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+      }
+    }
+  }
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate10, "_ts_decorate");
+var UsageContext = class UsageContext2 {
+  static {
+    __name(this, "UsageContext");
+  }
+  startTime = Date.now();
+  counters = /* @__PURE__ */ new Map();
+  increment(type, amount = 1) {
+    const current = this.counters.get(type) ?? 0;
+    this.counters.set(type, current + amount);
+  }
+  get(type) {
+    return this.counters.get(type) ?? 0;
+  }
+  toSummary() {
+    const metrics = {};
+    for (const [key, value] of this.counters) {
+      metrics[key] = value;
+    }
+    return {
+      metrics,
+      startTime: this.startTime,
+      elapsed: Date.now() - this.startTime
+    };
+  }
+};
+var storage = new import_node_async_hooks.AsyncLocalStorage();
+var UsageTracker = class _UsageTracker {
+  static {
+    __name(this, "UsageTracker");
+  }
+  static logger = new import_common10.Logger(_UsageTracker.name);
+  /**
+  * 在新的追踪上下文中执行函数
+  */
+  static runWithContext(fn) {
+    return storage.run(new UsageContext(), fn);
+  }
+  /**
+  * 记录一次资源使用
+  * @param type 资源类型（如 'db_query', 'cache_hit', 'cache_miss', 'storage_read', 'api_call'）
+  * @param amount 使用量（默认 1）
+  */
+  static track(type, amount = 1) {
+    const ctx = storage.getStore();
+    if (ctx) {
+      ctx.increment(type, amount);
+    }
+  }
+  /**
+  * 获取指定类型的当前计数
+  */
+  static getCount(type) {
+    return storage.getStore()?.get(type) ?? 0;
+  }
+  /**
+  * 获取当前请求的使用汇总
+  */
+  static getSummary() {
+    return storage.getStore()?.toSummary();
+  }
+  /**
+  * 检查是否在追踪上下文中
+  */
+  static isTracking() {
+    return storage.getStore() !== void 0;
+  }
+  // ─── 实例方法（通过 NestJS DI 注入） ──────────────────────────────
+  track(type, amount = 1) {
+    _UsageTracker.track(type, amount);
+  }
+  getSummary() {
+    return _UsageTracker.getSummary();
+  }
+};
+UsageTracker = _ts_decorate10([
+  (0, import_common10.Injectable)()
+], UsageTracker);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AlertController,
+  AlertManagerService,
+  Counter,
+  ERROR_REPORTER,
+  ErrorTracker,
+  Gauge,
+  HEALTH_OPTIONS,
+  HealthCheckService,
+  HealthController,
+  HealthStatus,
+  Histogram,
+  InMemoryMetricsCollector,
+  METRICS_COLLECTOR,
+  Metrics,
+  MetricsRegistry,
+  NoopErrorReporter,
+  PrometheusExporter,
+  Summary,
+  SystemMetricsCollector,
+  Timer,
+  UsageTracker,
+  ZuckerMonitoringModule,
+  getProcessUptime,
+  renderPrometheusMetrics
+});