@buenojs/bueno 0.8.3 → 0.8.5

package/dist/metrics/index.js

@@ -0,0 +1,289 @@
+// @bun
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+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 __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/metrics/index.ts
+function formatBytes(bytes) {
+  if (bytes === 0)
+    return "0 B";
+  const units = ["B", "KB", "MB", "GB", "TB"];
+  const i = Math.floor(Math.log(bytes) / Math.log(1024));
+  const value = bytes / Math.pow(1024, i);
+  if (i === 0)
+    return `${value} ${units[i]}`;
+  if (value >= 100)
+    return `${value.toFixed(1)} ${units[i]}`;
+  return `${value.toFixed(2)} ${units[i]}`;
+}
+function formatMicroseconds(microseconds) {
+  if (microseconds < 1000) {
+    return `${microseconds.toFixed(0)} \xB5s`;
+  }
+  const ms = microseconds / 1000;
+  if (ms < 1000) {
+    return `${ms.toFixed(2)} ms`;
+  }
+  const seconds = ms / 1000;
+  return `${seconds.toFixed(2)} s`;
+}
+function formatUptime(seconds) {
+  const days = Math.floor(seconds / 86400);
+  const hours = Math.floor(seconds % 86400 / 3600);
+  const minutes = Math.floor(seconds % 3600 / 60);
+  const secs = Math.floor(seconds % 60);
+  const parts = [];
+  if (days > 0)
+    parts.push(`${days}d`);
+  if (hours > 0)
+    parts.push(`${hours}h`);
+  if (minutes > 0)
+    parts.push(`${minutes}m`);
+  if (secs > 0 || parts.length === 0)
+    parts.push(`${secs}s`);
+  return parts.join(" ");
+}
+function getMetricsSummary(metrics) {
+  return {
+    memoryHeapUsed: formatBytes(metrics.memoryHeapUsed),
+    memoryHeapTotal: formatBytes(metrics.memoryHeapTotal),
+    memoryExternal: formatBytes(metrics.memoryExternal),
+    memoryRss: formatBytes(metrics.memoryRss),
+    cpuUser: formatMicroseconds(metrics.cpuUser),
+    cpuSystem: formatMicroseconds(metrics.cpuSystem),
+    uptime: formatUptime(metrics.uptime),
+    eventLoopLag: `${metrics.eventLoopLag.toFixed(2)} ms`,
+    timestamp: metrics.timestamp
+  };
+}
+async function measureEventLoopLag() {
+  const start = Bun.nanoseconds();
+  await new Promise((resolve) => setTimeout(resolve, 0));
+  const end = Bun.nanoseconds();
+  return (end - start) / 1e6;
+}
+async function measureEventLoopLagAverage(samples = 5) {
+  const measurements = [];
+  for (let i = 0;i < samples; i++) {
+    measurements.push(await measureEventLoopLag());
+  }
+  return measurements.reduce((a, b) => a + b, 0) / measurements.length;
+}
+
+class MetricsCollector {
+  history = [];
+  maxHistorySize;
+  measureEventLoopLagEnabled;
+  periodicTimer = null;
+  lastCpuUsage = undefined;
+  constructor(options = {}) {
+    this.maxHistorySize = options.maxHistorySize ?? 100;
+    this.measureEventLoopLagEnabled = options.measureEventLoopLag ?? true;
+  }
+  async collect() {
+    const memUsage = process.memoryUsage();
+    const cpuUsage = process.cpuUsage(this.lastCpuUsage);
+    this.lastCpuUsage = process.cpuUsage();
+    const uptime = process.uptime();
+    let eventLoopLag = 0;
+    if (this.measureEventLoopLagEnabled) {
+      eventLoopLag = await measureEventLoopLag();
+    }
+    const metrics = {
+      memoryHeapUsed: memUsage.heapUsed,
+      memoryHeapTotal: memUsage.heapTotal,
+      memoryExternal: memUsage.external,
+      memoryRss: memUsage.rss,
+      cpuUser: cpuUsage.user,
+      cpuSystem: cpuUsage.system,
+      uptime,
+      eventLoopLag,
+      timestamp: new Date().toISOString()
+    };
+    this.history.push(metrics);
+    if (this.history.length > this.maxHistorySize) {
+      this.history.shift();
+    }
+    return metrics;
+  }
+  startPeriodicCollection(intervalMs = 5000) {
+    if (this.periodicTimer !== null) {
+      throw new Error("Periodic collection is already running");
+    }
+    this.collect().catch(() => {});
+    this.periodicTimer = setInterval(() => {
+      this.collect().catch(() => {});
+    }, intervalMs);
+  }
+  stopPeriodicCollection() {
+    if (this.periodicTimer !== null) {
+      clearInterval(this.periodicTimer);
+      this.periodicTimer = null;
+    }
+  }
+  isCollecting() {
+    return this.periodicTimer !== null;
+  }
+  getHistory() {
+    return [...this.history];
+  }
+  getLatest() {
+    return this.history.length > 0 ? { ...this.history[this.history.length - 1] } : null;
+  }
+  getAverage() {
+    if (this.history.length === 0) {
+      return null;
+    }
+    const count = this.history.length;
+    let sumHeapUsed = 0;
+    let sumHeapTotal = 0;
+    let sumExternal = 0;
+    let sumRss = 0;
+    let sumCpuUser = 0;
+    let sumCpuSystem = 0;
+    let sumEventLoopLag = 0;
+    let minHeapUsed = Number.POSITIVE_INFINITY;
+    let maxHeapUsed = 0;
+    for (const m of this.history) {
+      sumHeapUsed += m.memoryHeapUsed;
+      sumHeapTotal += m.memoryHeapTotal;
+      sumExternal += m.memoryExternal;
+      sumRss += m.memoryRss;
+      sumCpuUser += m.cpuUser;
+      sumCpuSystem += m.cpuSystem;
+      sumEventLoopLag += m.eventLoopLag;
+      minHeapUsed = Math.min(minHeapUsed, m.memoryHeapUsed);
+      maxHeapUsed = Math.max(maxHeapUsed, m.memoryHeapUsed);
+    }
+    return {
+      avgMemoryHeapUsed: Math.round(sumHeapUsed / count),
+      avgMemoryHeapTotal: Math.round(sumHeapTotal / count),
+      avgMemoryExternal: Math.round(sumExternal / count),
+      avgMemoryRss: Math.round(sumRss / count),
+      avgCpuUser: Math.round(sumCpuUser / count),
+      avgCpuSystem: Math.round(sumCpuSystem / count),
+      avgEventLoopLag: Math.round(sumEventLoopLag / count * 100) / 100,
+      minMemoryHeapUsed: minHeapUsed === Number.POSITIVE_INFINITY ? 0 : minHeapUsed,
+      maxMemoryHeapUsed: maxHeapUsed,
+      sampleCount: count,
+      timeRange: {
+        start: this.history[0].timestamp,
+        end: this.history[count - 1].timestamp
+      }
+    };
+  }
+  reset() {
+    this.history = [];
+    this.lastCpuUsage = undefined;
+  }
+  getHistorySize() {
+    return this.history.length;
+  }
+}
+function toPrometheusFormat(metrics) {
+  const timestamp = Date.now();
+  const lines = [];
+  lines.push("# HELP process_memory_heap_used_bytes Heap memory used in bytes");
+  lines.push("# TYPE process_memory_heap_used_bytes gauge");
+  lines.push(`process_memory_heap_used_bytes ${metrics.memoryHeapUsed} ${timestamp}`);
+  lines.push("# HELP process_memory_heap_total_bytes Total heap memory in bytes");
+  lines.push("# TYPE process_memory_heap_total_bytes gauge");
+  lines.push(`process_memory_heap_total_bytes ${metrics.memoryHeapTotal} ${timestamp}`);
+  lines.push("# HELP process_memory_external_bytes External memory in bytes");
+  lines.push("# TYPE process_memory_external_bytes gauge");
+  lines.push(`process_memory_external_bytes ${metrics.memoryExternal} ${timestamp}`);
+  lines.push("# HELP process_memory_rss_bytes Resident Set Size in bytes");
+  lines.push("# TYPE process_memory_rss_bytes gauge");
+  lines.push(`process_memory_rss_bytes ${metrics.memoryRss} ${timestamp}`);
+  lines.push("# HELP process_cpu_user_seconds_total Total user CPU time");
+  lines.push("# TYPE process_cpu_user_seconds_total counter");
+  lines.push(`process_cpu_user_seconds_total ${(metrics.cpuUser / 1e6).toFixed(6)} ${timestamp}`);
+  lines.push("# HELP process_cpu_system_seconds_total Total system CPU time");
+  lines.push("# TYPE process_cpu_system_seconds_total counter");
+  lines.push(`process_cpu_system_seconds_total ${(metrics.cpuSystem / 1e6).toFixed(6)} ${timestamp}`);
+  lines.push("# HELP process_uptime_seconds Process uptime in seconds");
+  lines.push("# TYPE process_uptime_seconds gauge");
+  lines.push(`process_uptime_seconds ${metrics.uptime.toFixed(2)} ${timestamp}`);
+  lines.push("# HELP nodejs_eventloop_lag_ms Event loop lag in milliseconds");
+  lines.push("# TYPE nodejs_eventloop_lag_ms gauge");
+  lines.push(`nodejs_eventloop_lag_ms ${metrics.eventLoopLag.toFixed(2)} ${timestamp}`);
+  return lines.join(`
+`);
+}
+function averagedMetricsToPrometheus(averaged) {
+  const timestamp = Date.now();
+  const lines = [];
+  lines.push("# HELP process_memory_heap_used_avg_bytes Average heap memory used");
+  lines.push("# TYPE process_memory_heap_used_avg_bytes gauge");
+  lines.push(`process_memory_heap_used_avg_bytes ${averaged.avgMemoryHeapUsed} ${timestamp}`);
+  lines.push("# HELP process_memory_heap_used_min_bytes Minimum heap memory used");
+  lines.push("# TYPE process_memory_heap_used_min_bytes gauge");
+  lines.push(`process_memory_heap_used_min_bytes ${averaged.minMemoryHeapUsed} ${timestamp}`);
+  lines.push("# HELP process_memory_heap_used_max_bytes Maximum heap memory used");
+  lines.push("# TYPE process_memory_heap_used_max_bytes gauge");
+  lines.push(`process_memory_heap_used_max_bytes ${averaged.maxMemoryHeapUsed} ${timestamp}`);
+  lines.push("# HELP process_eventloop_lag_avg_ms Average event loop lag");
+  lines.push("# TYPE process_eventloop_lag_avg_ms gauge");
+  lines.push(`process_eventloop_lag_avg_ms ${averaged.avgEventLoopLag.toFixed(2)} ${timestamp}`);
+  lines.push("# HELP process_metrics_sample_count Number of samples collected");
+  lines.push("# TYPE process_metrics_sample_count gauge");
+  lines.push(`process_metrics_sample_count ${averaged.sampleCount} ${timestamp}`);
+  return lines.join(`
+`);
+}
+function createMetricsCollector(options) {
+  return new MetricsCollector(options);
+}
+async function collectMetrics() {
+  const memUsage = process.memoryUsage();
+  const cpuUsage = process.cpuUsage();
+  const uptime = process.uptime();
+  const eventLoopLag = await measureEventLoopLag();
+  return {
+    memoryHeapUsed: memUsage.heapUsed,
+    memoryHeapTotal: memUsage.heapTotal,
+    memoryExternal: memUsage.external,
+    memoryRss: memUsage.rss,
+    cpuUser: cpuUsage.user,
+    cpuSystem: cpuUsage.system,
+    uptime,
+    eventLoopLag,
+    timestamp: new Date().toISOString()
+  };
+}
+export {
+  toPrometheusFormat,
+  measureEventLoopLagAverage,
+  measureEventLoopLag,
+  getMetricsSummary,
+  formatUptime,
+  formatMicroseconds,
+  formatBytes,
+  createMetricsCollector,
+  collectMetrics,
+  averagedMetricsToPrometheus,
+  MetricsCollector
+};

package/dist/middleware/index.js

@@ -0,0 +1,77 @@
+// @bun
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+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 __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/middleware/index.ts
+var exports_middleware = {};
+__export(exports_middleware, {
+  createPipeline: () => createPipeline,
+  compose: () => compose,
+  Pipeline: () => Pipeline
+});
+function compose(middleware) {
+  return async (context, handler) => {
+    let index = -1;
+    const dispatch = async (i) => {
+      if (i <= index) {
+        throw new Error("next() called multiple times");
+      }
+      index = i;
+      if (i >= middleware.length) {
+        return handler(context);
+      }
+      const fn = middleware[i];
+      return fn(context, async () => {
+        return dispatch(i + 1);
+      });
+    };
+    return dispatch(0);
+  };
+}
+
+class Pipeline {
+  middleware = [];
+  use(middleware) {
+    this.middleware.push(middleware);
+    return this;
+  }
+  async execute(context, handler) {
+    const fn = compose(this.middleware);
+    return fn(context, handler);
+  }
+  get length() {
+    return this.middleware.length;
+  }
+}
+function createPipeline() {
+  return new Pipeline;
+}
+export {
+  createPipeline,
+  compose,
+  Pipeline
+};