@kabyeon/nexusjs 0.6.5

package/dist/metrics/index.js

@@ -0,0 +1,1033 @@
+// @bun
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toCommonJS = (from) => {
+  var entry = (__moduleCache ??= new WeakMap).get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (var key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(entry, key))
+        __defProp(entry, key, {
+          get: __accessProp.bind(from, key),
+          enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+        });
+  }
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __moduleCache;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+var __legacyDecorateClassTS = function(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;
+};
+var __legacyDecorateParamTS = (index, decorator) => (target, key) => decorator(target, key, index);
+var __legacyMetadataTS = (k, v) => {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function")
+    return Reflect.metadata(k, v);
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __require = import.meta.require;
+
+// src/core/constants.ts
+var METADATA_KEY, PARAM_TYPES, HTTP_METHODS;
+var init_constants = __esm(() => {
+  METADATA_KEY = {
+    CONTROLLER: "nexus:controller",
+    INJECTABLE: "nexus:injectable",
+    REPOSITORY: "nexus:repository",
+    MODULE: "nexus:module",
+    ROUTES: "nexus:routes",
+    PARAMS: "nexus:params",
+    VALIDATE: "nexus:validate",
+    PARAMTYPES: "design:paramtypes",
+    TYPE: "design:type",
+    RETURNTYPE: "design:returntype",
+    INJECT: "nexus:inject"
+  };
+  PARAM_TYPES = {
+    REQUEST: 0,
+    RESPONSE: 1,
+    NEXT: 2,
+    BODY: 3,
+    QUERY: 4,
+    PARAM: 5,
+    HEADERS: 6,
+    CTX: 7,
+    USER: 8
+  };
+  HTTP_METHODS = [
+    "GET",
+    "POST",
+    "PUT",
+    "DELETE",
+    "PATCH",
+    "OPTIONS",
+    "HEAD"
+  ];
+});
+
+// src/metrics/counter.ts
+function renderLabels(declared, values) {
+  if (declared.length === 0)
+    return "";
+  return declared.map((n) => `${n}="${escapeLabelValue(values[n] ?? "")}"`).join(",");
+}
+
+class CounterImpl {
+  name;
+  help;
+  labelNames;
+  values = new Map;
+  constructor(opts) {
+    this.name = opts.name;
+    this.help = opts.help;
+    this.labelNames = opts.labelNames ?? [];
+  }
+  inc(labels) {
+    this.incBy(1, labels);
+  }
+  incBy(n, labels) {
+    if (n < 0) {
+      throw new Error(`Counter ${this.name} can only increase (got ${n})`);
+    }
+    this.assertLabels(labels);
+    const key = this.key(labels);
+    this.values.set(key, (this.values.get(key) ?? 0) + n);
+  }
+  reset() {
+    this.values.clear();
+  }
+  getSamples() {
+    const out = [];
+    for (const [k, v] of this.values) {
+      out.push({ labels: this.parseKey(k), value: v });
+    }
+    return out;
+  }
+  renderPrometheus() {
+    const lines = [];
+    if (this.help)
+      lines.push(`# HELP ${this.name} ${this.help}`);
+    lines.push(`# TYPE ${this.name} counter`);
+    for (const [k, v] of this.values) {
+      const labels = this.parseKey(k);
+      const lbl = renderLabels(this.labelNames, labels);
+      lines.push(lbl ? `${this.name}{${lbl}} ${v}` : `${this.name} ${v}`);
+    }
+    return lines.join(`
+`);
+  }
+  assertLabels(labels) {
+    if (!labels && this.labelNames.length === 0)
+      return;
+    if (this.labelNames.length === 0) {
+      throw new Error(`Counter ${this.name} has no labels declared`);
+    }
+    if (!labels) {
+      throw new Error(`Counter ${this.name} requires labels: ${this.labelNames.join(", ")}`);
+    }
+    for (const required of this.labelNames) {
+      if (!(required in labels)) {
+        throw new Error(`Counter ${this.name} missing label "${required}"`);
+      }
+    }
+  }
+  key(labels) {
+    if (!labels)
+      return "";
+    return this.labelNames.map((n) => `${n}=${escapeLabelValue(labels[n] ?? "")}`).join(",");
+  }
+  parseKey(key) {
+    if (!key)
+      return {};
+    const out = {};
+    for (const part of key.split(",")) {
+      const [k, ...rest] = part.split("=");
+      out[k] = rest.join("=");
+    }
+    return out;
+  }
+}
+function escapeLabelValue(v) {
+  return v.replace(/\\/g, "\\\\").replace(/\n/g, "\\n").replace(/"/g, "\\\"");
+}
+// src/metrics/gauge.ts
+class GaugeImpl {
+  name;
+  help;
+  labelNames;
+  values = new Map;
+  constructor(opts) {
+    this.name = opts.name;
+    this.help = opts.help;
+    this.labelNames = opts.labelNames ?? [];
+  }
+  set(value, labels) {
+    this.assertLabels(labels);
+    this.values.set(this.key(labels), value);
+  }
+  inc(n = 1, labels) {
+    this.assertLabels(labels);
+    const k = this.key(labels);
+    this.values.set(k, (this.values.get(k) ?? 0) + n);
+  }
+  dec(n = 1, labels) {
+    this.assertLabels(labels);
+    const k = this.key(labels);
+    this.values.set(k, (this.values.get(k) ?? 0) - n);
+  }
+  setToCurrentTime(labels) {
+    this.set(Date.now() / 1000, labels);
+  }
+  reset() {
+    this.values.clear();
+  }
+  getSamples() {
+    const out = [];
+    for (const [k, v] of this.values) {
+      out.push({ labels: this.parseKey(k), value: v });
+    }
+    return out;
+  }
+  renderPrometheus() {
+    const lines = [];
+    if (this.help)
+      lines.push(`# HELP ${this.name} ${this.help}`);
+    lines.push(`# TYPE ${this.name} gauge`);
+    for (const [k, v] of this.values) {
+      const labels = this.parseKey(k);
+      const lbl = renderLabels(this.labelNames, labels);
+      lines.push(lbl ? `${this.name}{${lbl}} ${v}` : `${this.name} ${v}`);
+    }
+    return lines.join(`
+`);
+  }
+  assertLabels(labels) {
+    if (!labels && this.labelNames.length === 0)
+      return;
+    if (this.labelNames.length === 0) {
+      throw new Error(`Gauge ${this.name} has no labels declared`);
+    }
+    if (!labels) {
+      throw new Error(`Gauge ${this.name} requires labels: ${this.labelNames.join(", ")}`);
+    }
+    for (const required of this.labelNames) {
+      if (!(required in labels)) {
+        throw new Error(`Gauge ${this.name} missing label "${required}"`);
+      }
+    }
+  }
+  key(labels) {
+    if (!labels)
+      return "";
+    return this.labelNames.map((n) => `${n}=${escapeLabelValue(labels[n] ?? "")}`).join(",");
+  }
+  parseKey(key) {
+    if (!key)
+      return {};
+    const out = {};
+    for (const part of key.split(",")) {
+      const [k, ...rest] = part.split("=");
+      out[k] = rest.join("=");
+    }
+    return out;
+  }
+}
+// src/metrics/histogram.ts
+var DEFAULT_BUCKETS = [0.005, 0.01, 0.025, 0.05, 0.1, 0.25, 0.5, 1, 2.5, 5, 10];
+
+class HistogramImpl {
+  name;
+  help;
+  labelNames;
+  upperBounds;
+  states = new Map;
+  constructor(opts) {
+    this.name = opts.name;
+    this.help = opts.help;
+    this.labelNames = opts.labelNames ?? [];
+    const buckets = opts.buckets ?? DEFAULT_BUCKETS;
+    this.upperBounds = [...buckets].sort((a, b) => a - b);
+    if (this.upperBounds.length === 0) {
+      throw new Error(`Histogram ${this.name} requires at least one bucket`);
+    }
+  }
+  observe(value, labels) {
+    this.assertLabels(labels);
+    const k = this.key(labels);
+    let s = this.states.get(k);
+    if (!s) {
+      s = { buckets: new Array(this.upperBounds.length).fill(0), sum: 0, count: 0 };
+      this.states.set(k, s);
+    }
+    s.sum += value;
+    s.count++;
+    for (let i = 0;i < this.upperBounds.length; i++) {
+      if (value <= this.upperBounds[i])
+        s.buckets[i]++;
+    }
+  }
+  async time(fn, labels) {
+    const start = performance.now();
+    try {
+      return await fn(start);
+    } finally {
+      const elapsedMs = performance.now() - start;
+      this.observe(elapsedMs / 1000, labels);
+    }
+  }
+  reset() {
+    this.states.clear();
+  }
+  getSamples() {
+    const out = [];
+    for (const [k, s] of this.states) {
+      const labels = this.parseKey(k);
+      for (let i = 0;i < this.upperBounds.length; i++) {
+        out.push({
+          labels: { ...labels, le: String(this.upperBounds[i]) },
+          value: s.buckets[i]
+        });
+      }
+      out.push({ labels: { ...labels, le: "+Inf" }, value: s.count });
+      out.push({ labels: { ...labels }, value: s.sum });
+    }
+    return out;
+  }
+  renderPrometheus() {
+    const lines = [];
+    if (this.help)
+      lines.push(`# HELP ${this.name} ${this.help}`);
+    lines.push(`# TYPE ${this.name} histogram`);
+    for (const { labels, state } of this.enumerateStates()) {
+      lines.push(this.renderState(labels, state));
+    }
+    return lines.join(`
+`);
+  }
+  renderState(labels, state) {
+    const baseLabels = renderLabels(this.labelNames, labels);
+    const lines = [];
+    let cumulative = 0;
+    for (let i = 0;i < this.upperBounds.length; i++) {
+      cumulative = state.buckets[i];
+      const le = this.upperBounds[i];
+      const leStr = String(le);
+      const lbl = baseLabels ? `${baseLabels},le="${leStr}"` : `le="${leStr}"`;
+      lines.push(`${this.name}_bucket{${lbl}} ${cumulative}`);
+    }
+    {
+      const lbl = baseLabels ? `${baseLabels},le="+Inf"` : `le="+Inf"`;
+      lines.push(`${this.name}_bucket{${lbl}} ${state.count}`);
+    }
+    {
+      const lbl = baseLabels ? `{${baseLabels}}` : "";
+      lines.push(`${this.name}_sum${lbl} ${state.sum}`);
+    }
+    {
+      const lbl = baseLabels ? `{${baseLabels}}` : "";
+      lines.push(`${this.name}_count${lbl} ${state.count}`);
+    }
+    return lines.join(`
+`);
+  }
+  enumerateStates() {
+    const out = [];
+    for (const [k, s] of this.states) {
+      out.push({ labels: this.parseKey(k), state: s });
+    }
+    return out;
+  }
+  assertLabels(labels) {
+    if (!labels && this.labelNames.length === 0)
+      return;
+    if (this.labelNames.length === 0) {
+      throw new Error(`Histogram ${this.name} has no labels declared`);
+    }
+    if (!labels) {
+      throw new Error(`Histogram ${this.name} requires labels: ${this.labelNames.join(", ")}`);
+    }
+    for (const required of this.labelNames) {
+      if (!(required in labels)) {
+        throw new Error(`Histogram ${this.name} missing label "${required}"`);
+      }
+    }
+  }
+  key(labels) {
+    if (!labels)
+      return "";
+    return this.labelNames.map((n) => `${n}=${escapeLabelValue(labels[n] ?? "")}`).join(",");
+  }
+  parseKey(key) {
+    if (!key)
+      return {};
+    const out = {};
+    for (const part of key.split(",")) {
+      const [k, ...rest] = part.split("=");
+      out[k] = rest.join("=");
+    }
+    return out;
+  }
+}
+// src/metrics/summary.ts
+var DEFAULT_PERCENTILES = [0.5, 0.9, 0.99];
+var DEFAULT_MAX_AGE_SECONDS = 600;
+var DEFAULT_AGE_BUCKETS = 5;
+
+class SummaryImpl {
+  name;
+  help;
+  labelNames;
+  percentiles;
+  maxAgeSeconds;
+  ageBuckets;
+  bucketSize;
+  states = new Map;
+  constructor(opts) {
+    this.name = opts.name;
+    this.help = opts.help;
+    this.labelNames = opts.labelNames ?? [];
+    this.percentiles = opts.percentiles ?? DEFAULT_PERCENTILES;
+    this.maxAgeSeconds = opts.maxAgeSeconds ?? DEFAULT_MAX_AGE_SECONDS;
+    this.ageBuckets = opts.ageBuckets ?? DEFAULT_AGE_BUCKETS;
+    this.bucketSize = Math.ceil(this.maxAgeSeconds / this.ageBuckets);
+  }
+  observe(value, labels) {
+    this.assertLabels(labels);
+    const k = this.key(labels);
+    let s = this.states.get(k);
+    if (!s) {
+      s = this.newState();
+      this.states.set(k, s);
+    }
+    this.maybeRotate(s);
+    const b = s.buckets[s.currentBucket];
+    b.values.push(value);
+    b.sum += value;
+    b.count++;
+  }
+  async time(fn, labels) {
+    const start = performance.now();
+    try {
+      return await fn();
+    } finally {
+      const elapsedMs = performance.now() - start;
+      this.observe(elapsedMs / 1000, labels);
+    }
+  }
+  reset() {
+    this.states.clear();
+  }
+  getSamples() {
+    const out = [];
+    for (const [k] of this.states) {
+      out.push({ labels: this.parseKey(k), value: 0 });
+    }
+    return out;
+  }
+  renderPrometheus() {
+    const lines = [];
+    if (this.help)
+      lines.push(`# HELP ${this.name} ${this.help}`);
+    lines.push(`# TYPE ${this.name} summary`);
+    for (const [k, s] of this.states) {
+      const labels = this.parseKey(k);
+      this.maybeRotate(s);
+      const totals = this.totals(s);
+      for (const q of this.percentiles) {
+        const qval = this.quantile(s, q);
+        const qstr = clampQuantileLabel(q);
+        const fullLabels = { ...labels, quantile: qstr };
+        const baseStr = renderLabels(this.labelNames, fullLabels);
+        const lbl = baseStr ? `${baseStr},quantile="${qstr}"` : `quantile="${qstr}"`;
+        lines.push(`${this.name}{${lbl}} ${qval}`);
+      }
+      {
+        const lbl = renderLabels(this.labelNames, labels);
+        lines.push(`${this.name}_sum${lbl ? `{${lbl}}` : ""} ${totals.sum}`);
+        lines.push(`${this.name}_count${lbl ? `{${lbl}}` : ""} ${totals.count}`);
+      }
+    }
+    return lines.join(`
+`);
+  }
+  newState() {
+    const buckets = [];
+    for (let i = 0;i < this.ageBuckets; i++) {
+      buckets.push({ values: [], sum: 0, count: 0 });
+    }
+    return { buckets, currentBucket: 0, lastRotation: Date.now() };
+  }
+  maybeRotate(s) {
+    const now = Date.now();
+    const elapsed = (now - s.lastRotation) / 1000;
+    if (elapsed >= this.bucketSize) {
+      const rotations = Math.floor(elapsed / this.bucketSize);
+      for (let i = 0;i < rotations; i++) {
+        s.currentBucket = (s.currentBucket + 1) % this.ageBuckets;
+        s.buckets[s.currentBucket] = { values: [], sum: 0, count: 0 };
+      }
+      s.lastRotation = now;
+    }
+  }
+  totals(s) {
+    let sum = 0;
+    let count = 0;
+    for (const b of s.buckets) {
+      sum += b.sum;
+      count += b.count;
+    }
+    return { sum, count };
+  }
+  quantile(s, q) {
+    const all = [];
+    for (const b of s.buckets) {
+      for (const v of b.values)
+        all.push(v);
+    }
+    if (all.length === 0)
+      return 0;
+    all.sort((a, b) => a - b);
+    const idx = Math.min(all.length - 1, Math.max(0, Math.floor(q * all.length)));
+    return all[idx];
+  }
+  assertLabels(labels) {
+    if (!labels && this.labelNames.length === 0)
+      return;
+    if (this.labelNames.length === 0) {
+      throw new Error(`Summary ${this.name} has no labels declared`);
+    }
+    if (!labels) {
+      throw new Error(`Summary ${this.name} requires labels: ${this.labelNames.join(", ")}`);
+    }
+    for (const required of this.labelNames) {
+      if (!(required in labels)) {
+        throw new Error(`Summary ${this.name} missing label "${required}"`);
+      }
+    }
+  }
+  key(labels) {
+    if (!labels)
+      return "";
+    return this.labelNames.map((n) => `${n}=${escapeLabelValue(labels[n] ?? "")}`).join(",");
+  }
+  parseKey(key) {
+    if (!key)
+      return {};
+    const out = {};
+    for (const part of key.split(",")) {
+      const [k, ...rest] = part.split("=");
+      out[k] = rest.join("=");
+    }
+    return out;
+  }
+}
+function clampQuantileLabel(q) {
+  const s = String(q);
+  if (s.includes(".") && s.length > 8) {
+    return q.toFixed(6).replace(/0+$/, "").replace(/\.$/, "");
+  }
+  return s;
+}
+// src/metrics/registry.ts
+class MetricsRegistry {
+  metrics = new Map;
+  globalLabels = {};
+  setGlobalLabels(labels) {
+    this.globalLabels = { ...labels };
+  }
+  getGlobalLabels() {
+    return { ...this.globalLabels };
+  }
+  registerCounter(opts) {
+    if (this.metrics.has(opts.name)) {
+      throw new Error(`Metric ${opts.name} is already registered`);
+    }
+    const c = new CounterImpl(opts);
+    this.metrics.set(opts.name, { name: opts.name, type: "counter", impl: c });
+    return c;
+  }
+  registerGauge(opts) {
+    if (this.metrics.has(opts.name)) {
+      throw new Error(`Metric ${opts.name} is already registered`);
+    }
+    const g = new GaugeImpl(opts);
+    this.metrics.set(opts.name, { name: opts.name, type: "gauge", impl: g });
+    return g;
+  }
+  registerHistogram(opts) {
+    if (this.metrics.has(opts.name)) {
+      throw new Error(`Metric ${opts.name} is already registered`);
+    }
+    const h = new HistogramImpl(opts);
+    this.metrics.set(opts.name, { name: opts.name, type: "histogram", impl: h });
+    return h;
+  }
+  registerSummary(opts) {
+    if (this.metrics.has(opts.name)) {
+      throw new Error(`Metric ${opts.name} is already registered`);
+    }
+    const s = new SummaryImpl(opts);
+    this.metrics.set(opts.name, { name: opts.name, type: "summary", impl: s });
+    return s;
+  }
+  get(name) {
+    return this.metrics.get(name);
+  }
+  getCounter(name) {
+    const m = this.metrics.get(name);
+    if (!m)
+      throw new Error(`Counter ${name} is not registered`);
+    if (m.type !== "counter")
+      throw new Error(`Metric ${name} is a ${m.type}, not a counter`);
+    return m.impl;
+  }
+  getGauge(name) {
+    const m = this.metrics.get(name);
+    if (!m)
+      throw new Error(`Gauge ${name} is not registered`);
+    if (m.type !== "gauge")
+      throw new Error(`Metric ${name} is a ${m.type}, not a gauge`);
+    return m.impl;
+  }
+  getHistogram(name) {
+    const m = this.metrics.get(name);
+    if (!m)
+      throw new Error(`Histogram ${name} is not registered`);
+    if (m.type !== "histogram")
+      throw new Error(`Metric ${name} is a ${m.type}, not a histogram`);
+    return m.impl;
+  }
+  getSummary(name) {
+    const m = this.metrics.get(name);
+    if (!m)
+      throw new Error(`Summary ${name} is not registered`);
+    if (m.type !== "summary")
+      throw new Error(`Metric ${name} is a ${m.type}, not a summary`);
+    return m.impl;
+  }
+  get size() {
+    return this.metrics.size;
+  }
+  names() {
+    return [...this.metrics.keys()].sort();
+  }
+  resetAll() {
+    for (const m of this.metrics.values()) {
+      m.impl.reset();
+    }
+  }
+  expose(format = "prometheus") {
+    const sections = [];
+    const globalLabelsStr = renderGlobalLabels(this.globalLabels);
+    for (const m of this.metrics.values()) {
+      const out = m.impl.renderPrometheus();
+      if (globalLabelsStr) {
+        sections.push(applyGlobalLabels(out, this.globalLabels));
+      } else {
+        sections.push(out);
+      }
+    }
+    const body = sections.filter((s) => s.length > 0).join(`
+
+`);
+    const contentType = format === "openmetrics" ? "application/openmetrics-text; version=1.0.0; charset=utf-8" : "text/plain; version=0.0.4; charset=utf-8";
+    return { body: body + (body.endsWith(`
+`) ? "" : `
+`), contentType };
+  }
+}
+function renderGlobalLabels(labels) {
+  const keys = Object.keys(labels);
+  if (keys.length === 0)
+    return "";
+  return keys.map((k) => `${k}="${labels[k]}"`).join(",");
+}
+function applyGlobalLabels(block, labels) {
+  const keys = Object.keys(labels);
+  if (keys.length === 0)
+    return block;
+  const prefix = keys.map((k) => `${k}="${labels[k]}"`).join(",");
+  return block.split(`
+`).map((line) => {
+    if (line.startsWith("#"))
+      return line;
+    const openBrace = line.indexOf("{");
+    if (openBrace === -1) {
+      const space = line.indexOf(" ");
+      if (space === -1)
+        return line;
+      const metric = line.slice(0, space);
+      const rest = line.slice(space);
+      return `${metric}{${prefix}}${rest}`;
+    }
+    const closeBrace = line.indexOf("}", openBrace);
+    if (closeBrace === -1)
+      return line;
+    const existing = line.slice(openBrace + 1, closeBrace);
+    return `${line.slice(0, openBrace + 1)}${prefix},${existing}${line.slice(closeBrace)}`;
+  }).join(`
+`);
+}
+// src/metrics/service.ts
+var METRICS_SERVICE_TOKEN = Symbol.for("nexus:MetricsService");
+var _current;
+function setMetricsService(service) {
+  _current = service;
+}
+function getMetricsService() {
+  return _current;
+}
+
+class MetricsService {
+  registry = new MetricsRegistry;
+  counter(opts) {
+    return this.registry.registerCounter(opts);
+  }
+  gauge(opts) {
+    return this.registry.registerGauge(opts);
+  }
+  histogram(opts) {
+    return this.registry.registerHistogram(opts);
+  }
+  summary(opts) {
+    return this.registry.registerSummary(opts);
+  }
+  getCounter(name) {
+    return this.registry.getCounter(name);
+  }
+  getOrCreateCounter(name, help, labelNames) {
+    try {
+      return this.registry.getCounter(name);
+    } catch {
+      return this.registry.registerCounter({ name, help, labelNames });
+    }
+  }
+  getOrCreateHistogram(name, help, labelNames, buckets) {
+    try {
+      return this.registry.getHistogram(name);
+    } catch {
+      return this.registry.registerHistogram({ name, help, labelNames, buckets });
+    }
+  }
+  getGauge(name) {
+    return this.registry.getGauge(name);
+  }
+  getHistogram(name) {
+    return this.registry.getHistogram(name);
+  }
+  getSummary(name) {
+    return this.registry.getSummary(name);
+  }
+  expose(format = "prometheus") {
+    return this.registry.expose(format);
+  }
+  get size() {
+    return this.registry.size;
+  }
+}
+// src/core/decorators/module.ts
+init_constants();
+import"reflect-metadata";
+function Module(options = {}) {
+  return (target) => {
+    Reflect.defineMetadata(METADATA_KEY.MODULE, options, target);
+  };
+}
+function getModuleOptions(target) {
+  return Reflect.getMetadata(METADATA_KEY.MODULE, target) ?? {};
+}
+
+// src/metrics/controller.ts
+class MetricsController {
+  static PATH = "/metrics";
+  static handler(service) {
+    return (c) => {
+      const accept = c.req.header("accept") ?? "";
+      const format = accept.includes("application/openmetrics-text") ? "openmetrics" : "prometheus";
+      const { contentType, body } = service.expose(format);
+      return c.body(body, 200, {
+        "content-type": contentType,
+        "cache-control": "no-store"
+      });
+    };
+  }
+  static mount(app, service, path = MetricsController.PATH) {
+    app.get(path, MetricsController.handler(service));
+  }
+}
+
+// src/metrics/module.ts
+class MetricsModule {
+  static forRoot(config = {}) {
+    const fullConfig = {
+      defaultBuckets: config.defaultBuckets ?? [],
+      defaultPercentiles: config.defaultPercentiles ?? [],
+      path: config.path ?? "/metrics",
+      enableDefaultMetrics: config.enableDefaultMetrics ?? true,
+      mountController: config.mountController ?? true,
+      globalLabels: config.globalLabels ?? {}
+    };
+
+    class ConfiguredMetricsModule {
+      svc;
+      constructor(svc = new MetricsService) {
+        this.svc = svc;
+        if (Object.keys(fullConfig.globalLabels).length > 0) {
+          svc.registry.setGlobalLabels(fullConfig.globalLabels);
+        }
+        if (fullConfig.enableDefaultMetrics) {
+          registerDefaultMetrics(svc);
+        }
+      }
+      static get path() {
+        return fullConfig.path;
+      }
+      static get service() {
+        return new MetricsService;
+      }
+      static get controllerPath() {
+        return fullConfig.path;
+      }
+    }
+    ConfiguredMetricsModule = __legacyDecorateClassTS([
+      Module({
+        providers: [
+          MetricsService,
+          { provide: METRICS_SERVICE_TOKEN, useExisting: MetricsService },
+          { provide: "METRICS_CONFIG", useValue: fullConfig }
+        ],
+        exports: [MetricsService, METRICS_SERVICE_TOKEN, "METRICS_CONFIG"]
+      }),
+      __legacyMetadataTS("design:paramtypes", [
+        typeof MetricsService === "undefined" ? Object : MetricsService
+      ])
+    ], ConfiguredMetricsModule);
+    Object.defineProperty(ConfiguredMetricsModule, "name", {
+      value: "ConfiguredMetricsModule"
+    });
+    ConfiguredMetricsModule.mount = (app, service) => {
+      MetricsController.mount(app, service, fullConfig.path);
+    };
+    return ConfiguredMetricsModule;
+  }
+}
+MetricsModule = __legacyDecorateClassTS([
+  Module({
+    providers: [
+      MetricsService,
+      { provide: METRICS_SERVICE_TOKEN, useExisting: MetricsService }
+    ],
+    exports: [MetricsService, METRICS_SERVICE_TOKEN]
+  })
+], MetricsModule);
+function registerDefaultMetrics(service) {
+  const processStartTime = service.gauge({
+    name: "process_start_time_seconds",
+    help: "Start time of the process since unix epoch in seconds.",
+    labelNames: [],
+    collect: () => {
+      processStartTime.set(Math.floor(Date.now() / 1000));
+    }
+  });
+  const processResidentMemory = service.gauge({
+    name: "process_resident_memory_bytes",
+    help: "Resident memory size in bytes.",
+    labelNames: [],
+    collect: () => {
+      const mem = process.memoryUsage();
+      processResidentMemory.set(mem.rss);
+    }
+  });
+  const processHeapUsed = service.gauge({
+    name: "nodejs_heap_size_used_bytes",
+    help: "Node.js heap size used in bytes.",
+    labelNames: [],
+    collect: () => {
+      const mem = process.memoryUsage();
+      processHeapUsed.set(mem.heapUsed);
+    }
+  });
+  const processHeapTotal = service.gauge({
+    name: "nodejs_heap_size_total_bytes",
+    help: "Node.js heap size total in bytes.",
+    labelNames: [],
+    collect: () => {
+      const mem = process.memoryUsage();
+      processHeapTotal.set(mem.heapTotal);
+    }
+  });
+  const processExternalMemory = service.gauge({
+    name: "nodejs_external_memory_bytes",
+    help: "Node.js external memory size in bytes.",
+    labelNames: [],
+    collect: () => {
+      const mem = process.memoryUsage();
+      processExternalMemory.set(mem.external);
+    }
+  });
+  const processCpuUser = service.gauge({
+    name: "process_cpu_user_seconds_total",
+    help: "Total user CPU time spent in seconds.",
+    labelNames: [],
+    collect: () => {
+      const cpu = process.cpuUsage();
+      processCpuUser.set(cpu.user / 1e6);
+    }
+  });
+  const processCpuSystem = service.gauge({
+    name: "process_cpu_system_seconds_total",
+    help: "Total system CPU time spent in seconds.",
+    labelNames: [],
+    collect: () => {
+      const cpu = process.cpuUsage();
+      processCpuSystem.set(cpu.system / 1e6);
+    }
+  });
+  const eventLoopLag = service.gauge({
+    name: "nodejs_eventloop_lag_seconds",
+    help: "Lag of the event loop in seconds.",
+    labelNames: [],
+    collect: () => {
+      const start = process.hrtime.bigint();
+      setImmediate(() => {
+        const lagNs = Number(process.hrtime.bigint() - start);
+        eventLoopLag.set(lagNs / 1e9);
+      });
+    }
+  });
+  const processActiveHandles = service.gauge({
+    name: "nodejs_active_handles_total",
+    help: "Number of active handles.",
+    labelNames: [],
+    collect: () => {
+      const handles = process._getActiveHandles?.() ?? [];
+      processActiveHandles.set(handles.length);
+    }
+  });
+  const processActiveRequests = service.gauge({
+    name: "nodejs_active_requests_total",
+    help: "Number of active requests.",
+    labelNames: [],
+    collect: () => {
+      const reqs = process._getActiveRequests?.() ?? [];
+      processActiveRequests.set(reqs.length);
+    }
+  });
+}
+// src/metrics/decorators/counted.ts
+function Counted(metricName, options = {}) {
+  return function(_target, _propertyKey, descriptor) {
+    const original = descriptor.value;
+    if (typeof original !== "function") {
+      throw new Error(`@Counted() can only be applied to methods, got ${typeof original}`);
+    }
+    const isAsync = original.constructor?.name === "AsyncFunction";
+    if (isAsync) {
+      descriptor.value = async function wrapped(...args) {
+        const svc = getMetricsService();
+        if (svc) {
+          const labels = options.labels?.();
+          svc.getOrCreateCounter(metricName, undefined, labels ? Object.keys(labels) : undefined).inc(labels);
+        }
+        return original.apply(this, args);
+      };
+    } else {
+      descriptor.value = function wrapped(...args) {
+        const svc = getMetricsService();
+        if (svc) {
+          const labels = options.labels?.();
+          svc.getOrCreateCounter(metricName, undefined, labels ? Object.keys(labels) : undefined).inc(labels);
+        }
+        return original.apply(this, args);
+      };
+    }
+    return descriptor;
+  };
+}
+// src/metrics/decorators/timed.ts
+function Timed(metricName, options = {}) {
+  return function(_target, _propertyKey, descriptor) {
+    const original = descriptor.value;
+    if (typeof original !== "function") {
+      throw new Error(`@Timed() can only be applied to methods, got ${typeof original}`);
+    }
+    const isAsync = original.constructor?.name === "AsyncFunction";
+    if (isAsync) {
+      descriptor.value = async function wrapped(...args) {
+        const svc = getMetricsService();
+        const start = performance.now();
+        try {
+          return await original.apply(this, args);
+        } finally {
+          if (svc) {
+            const elapsedMs = performance.now() - start;
+            const labels = options.labels?.();
+            svc.getOrCreateHistogram(metricName, undefined, labels ? Object.keys(labels) : undefined, options.buckets).observe(elapsedMs / 1000, labels);
+          }
+        }
+      };
+    } else {
+      descriptor.value = function wrapped(...args) {
+        const svc = getMetricsService();
+        const start = performance.now();
+        try {
+          return original.apply(this, args);
+        } finally {
+          if (svc) {
+            const elapsedMs = performance.now() - start;
+            const labels = options.labels?.();
+            svc.getOrCreateHistogram(metricName, undefined, labels ? Object.keys(labels) : undefined, options.buckets).observe(elapsedMs / 1000, labels);
+          }
+        }
+      };
+    }
+    return descriptor;
+  };
+}
+export {
+  setMetricsService,
+  getMetricsService,
+  Timed,
+  SummaryImpl,
+  MetricsService,
+  MetricsRegistry,
+  MetricsModule,
+  MetricsController,
+  METRICS_SERVICE_TOKEN,
+  HistogramImpl,
+  GaugeImpl,
+  DEFAULT_PERCENTILES,
+  DEFAULT_BUCKETS,
+  CounterImpl,
+  Counted
+};
+
+//# debugId=96828E90AF3AE4CC64756E2164756E21
+//# sourceMappingURL=index.js.map