node-observe 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 node-observe contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,143 @@
+# node-observe
+
+**Datadog-lite backend observability for Node.js.** No agent, no SaaS bill, minimal dependencies — drop it into an Express + Mongo + Redis app and get latency percentiles, query timings, memory-leak detection, and Slack alerts in a few lines.
+
+Built for small teams who don't (yet) have an APM but still need to know *what's slow* and *when something's leaking*.
+
+- 🌐 **API latency tracking** — per-route p50/p95/p99, error rates, status-class counters
+- 🍃 **MongoDB query timing** — every Mongoose query/aggregate/save, by `Model.op`
+- 🧱 **Redis timing** — every ioredis command, by command name
+- 📈 **Memory-leak detection** — least-squares trend on heap-used (MB/min), not noisy single readings
+- 🔔 **Slack alerts** — threshold breaches pushed to a webhook, with cooldown de-duplication
+- 📊 **`/insights` snapshot** — one JSON endpoint with everything
+
+```bash
+npm install node-observe
+```
+
+> Node ≥ 18 (uses global `fetch` for Slack). ESM + CJS, fully typed. `express`, `mongoose`, and `ioredis` are **optional** — node-observe duck-types whatever you pass it, so it depends on none of them.
+
+---
+
+## Quick start
+
+```ts
+import express from "express";
+import mongoose from "mongoose";
+import Redis from "ioredis";
+import { Insights } from "node-observe";
+
+const insights = new Insights({
+  serviceName: "api",
+  slackWebhook: process.env.SLACK_WEBHOOK_URL, // optional
+  thresholds: {
+    requestMs: 1000,   // alert on requests slower than 1s
+    mongoMs: 300,
+    redisMs: 100,
+    heapGrowthMbPerMin: 50,
+  },
+});
+
+const app = express();
+
+app.use(insights.express());          // 1. time every request
+insights.instrumentMongoose(mongoose); // 2. time every Mongo op (call before models compile)
+insights.instrumentRedis(new Redis()); // 3. time every Redis command
+insights.startMemoryMonitor();         // 4. watch the heap for leaks
+
+app.get("/insights", insights.handler()); // 5. expose the JSON snapshot
+```
+
+That's it. Hit `/insights` and you'll see something like:
+
+```jsonc
+{
+  "service": "api",
+  "uptimeSec": 3600,
+  "http": {
+    "GET /users/:id":  { "count": 1240, "errors": 3, "mean": 42.1, "p95": 88.0, "p99": 210.5, ... },
+    "POST /posts":     { "count": 95,  "errors": 0, "mean": 120.4, "p95": 305.0, ... }
+  },
+  "mongo": { "User.findOne": { "count": 2100, "p95": 12.0, ... }, "Post.aggregate": { "p95": 240.0, ... } },
+  "redis": { "get": { "count": 8800, "p95": 1.2 }, "hgetall": { "p95": 3.0 } },
+  "counters": { "http.status.2xx": 1300, "http.status.5xx": 3 },
+  "memory": { "heapUsedMb": 180.2, "rssMb": 320.5, "growthMbPerMin": 1.4 }
+}
+```
+
+---
+
+## Alerts
+
+When a metric crosses its threshold, node-observe raises an `Alert`. Each alert is de-duplicated per key for `alertCooldownMs` (default 60s) so you don't get spammed.
+
+```ts
+const insights = new Insights({
+  slackWebhook: process.env.SLACK_WEBHOOK_URL,
+  onAlert: (alert) => {
+    // also forward anywhere you like: logs, PagerDuty, etc.
+    logger.warn(`[${alert.type}] ${alert.message}`);
+  },
+});
+```
+
+Alert types: `slow-request`, `slow-mongo`, `slow-redis`, `memory-leak`, `memory-high`.
+
+A Slack alert looks like:
+
+> 🐢 **[api] slow-request**
+> `GET /users/:id` took 1820ms
+> • value: `1820` • threshold: `1000` • at: 2026-06-08T12:00:00.000Z
+
+### Memory-leak detection
+
+`startMemoryMonitor()` samples `heapUsed` every `memorySampleIntervalMs` (default 15s) and fits a least-squares line over the recent window. A **sustained** positive slope (MB/min) above `heapGrowthMbPerMin` triggers `memory-leak` — this ignores the sawtooth of normal GC, which single-threshold checks get wrong. Set `heapUsedMb` to also alert on an absolute heap ceiling.
+
+---
+
+## Configuration
+
+| Option | Default | Description |
+| --- | --- | --- |
+| `serviceName` | `"node-observe"` | Label in snapshots/alerts. |
+| `slackWebhook` | — | Slack incoming-webhook URL. |
+| `thresholds.requestMs` | `1000` | Slow-request alert threshold. |
+| `thresholds.mongoMs` | `300` | Slow-Mongo alert threshold. |
+| `thresholds.redisMs` | `100` | Slow-Redis alert threshold. |
+| `thresholds.heapGrowthMbPerMin` | `50` | Leak alert threshold. |
+| `thresholds.heapUsedMb` | `0` (off) | Absolute heap alert. |
+| `sampleSize` | `1024` | Ring-buffer size per metric (percentile window). |
+| `alertCooldownMs` | `60000` | Min gap between repeats of the same alert. |
+| `memorySampleIntervalMs` | `15000` | Memory sampling cadence. |
+| `normalizePaths` | `true` | Collapse `/users/123` → `/users/:id`. |
+| `onAlert` | — | Custom alert sink. |
+| `logger` | `console` | Internal error logger. |
+
+---
+
+## API
+
+| Export | Description |
+| --- | --- |
+| `new Insights(options)` | The central handle. |
+| `insights.express()` | Express/Connect middleware (request latency). |
+| `insights.instrumentMongoose(mongoose)` | Global plugin timing all queries. |
+| `insights.instrumentRedis(client)` | Wrap an ioredis client's commands. |
+| `insights.startMemoryMonitor()` | Start leak detection (returns a stop fn). |
+| `insights.snapshot()` | Current `InsightsSnapshot` object. |
+| `insights.handler()` | Express handler serving the snapshot as JSON. |
+| `insights.recordRequest/recordMongo/recordRedis(...)` | Manual recording. |
+| `Histogram`, `MetricsRegistry`, `MemoryMonitor` | Building blocks, exported for custom use. |
+| `normalizePath`, `formatSlackMessage`, `postToSlack` | Utilities. |
+
+## Notes
+
+- The Express middleware records on the response `finish`/`close` event and prefers the matched route pattern (`req.route.path`) to keep cardinality low.
+- `instrumentMongoose` must run **before** your models are compiled so the global plugin applies to every schema.
+- `instrumentRedis` is idempotent — calling it twice on the same client is a no-op.
+- Observability never throws into your app: Slack failures and `onAlert` errors are logged, not propagated.
+- All durations are milliseconds; memory values are MB.
+
+## License
+
+MIT

package/dist/index.cjs

@@ -0,0 +1,466 @@
+'use strict';
+
+// src/histogram.ts
+var Histogram = class {
+  buffer = [];
+  head = 0;
+  cap;
+  count = 0;
+  errors = 0;
+  sum = 0;
+  minV = Infinity;
+  maxV = -Infinity;
+  constructor(cap = 1024) {
+    this.cap = Math.max(1, cap);
+  }
+  /** Record one duration (ms). Mark `isError` to count it toward the error tally. */
+  record(value, isError = false) {
+    if (!Number.isFinite(value) || value < 0) return;
+    this.count++;
+    this.sum += value;
+    if (isError) this.errors++;
+    if (value < this.minV) this.minV = value;
+    if (value > this.maxV) this.maxV = value;
+    if (this.buffer.length < this.cap) {
+      this.buffer.push(value);
+    } else {
+      this.buffer[this.head] = value;
+      this.head = (this.head + 1) % this.cap;
+    }
+  }
+  /** Linear-interpolation percentile over the retained window. `p` in [0,100]. */
+  percentile(p) {
+    const n = this.buffer.length;
+    if (n === 0) return 0;
+    const sorted = [...this.buffer].sort((a, b) => a - b);
+    if (n === 1) return sorted[0];
+    const rank = p / 100 * (n - 1);
+    const lo = Math.floor(rank);
+    const hi = Math.ceil(rank);
+    const frac = rank - lo;
+    return sorted[lo] * (1 - frac) + sorted[hi] * frac;
+  }
+  snapshot() {
+    const round = (n) => Math.round(n * 100) / 100;
+    return {
+      count: this.count,
+      errors: this.errors,
+      mean: this.count ? round(this.sum / this.count) : 0,
+      min: this.count ? round(this.minV) : 0,
+      max: this.count ? round(this.maxV) : 0,
+      p50: round(this.percentile(50)),
+      p95: round(this.percentile(95)),
+      p99: round(this.percentile(99))
+    };
+  }
+};
+var MetricsRegistry = class {
+  constructor(cap = 1024) {
+    this.cap = cap;
+  }
+  cap;
+  histograms = /* @__PURE__ */ new Map();
+  counters = /* @__PURE__ */ new Map();
+  record(name, value, isError = false) {
+    let h = this.histograms.get(name);
+    if (!h) {
+      h = new Histogram(this.cap);
+      this.histograms.set(name, h);
+    }
+    h.record(value, isError);
+  }
+  increment(name, by = 1) {
+    this.counters.set(name, (this.counters.get(name) ?? 0) + by);
+  }
+  snapshot() {
+    const out = {};
+    for (const [name, h] of this.histograms) out[name] = h.snapshot();
+    return out;
+  }
+  counterSnapshot() {
+    return Object.fromEntries(this.counters);
+  }
+  reset() {
+    this.histograms.clear();
+    this.counters.clear();
+  }
+};
+
+// src/memory.ts
+var MemoryMonitor = class {
+  samples = [];
+  window;
+  constructor(window = 30) {
+    this.window = Math.max(2, window);
+  }
+  /** Add the current memory reading. `now`/`mem` are injectable for testing. */
+  sample(now, mem) {
+    this.samples.push({ t: now, heapUsed: mem.heapUsed });
+    if (this.samples.length > this.window) this.samples.shift();
+  }
+  /** Heap growth rate in MB per minute over the retained window. */
+  growthMbPerMin() {
+    if (this.samples.length < 2) return 0;
+    const n = this.samples.length;
+    const t0 = this.samples[0].t;
+    let sx = 0;
+    let sy = 0;
+    let sxx = 0;
+    let sxy = 0;
+    for (const s of this.samples) {
+      const x = (s.t - t0) / 6e4;
+      const y = s.heapUsed / (1024 * 1024);
+      sx += x;
+      sy += y;
+      sxx += x * x;
+      sxy += x * y;
+    }
+    const denom = n * sxx - sx * sx;
+    if (denom === 0) return 0;
+    const slope = (n * sxy - sx * sy) / denom;
+    return Math.round(slope * 100) / 100;
+  }
+  snapshot(mem) {
+    const mb = (b) => Math.round(b / (1024 * 1024) * 100) / 100;
+    return {
+      heapUsedMb: mb(mem.heapUsed),
+      heapTotalMb: mb(mem.heapTotal),
+      rssMb: mb(mem.rss),
+      externalMb: mb(mem.external),
+      growthMbPerMin: this.growthMbPerMin()
+    };
+  }
+  /** Number of samples currently retained. */
+  get size() {
+    return this.samples.length;
+  }
+};
+
+// src/slack.ts
+var EMOJI = {
+  "slow-request": "\u{1F422}",
+  "slow-mongo": "\u{1F343}",
+  "slow-redis": "\u{1F9F1}",
+  "memory-leak": "\u{1F4C8}",
+  "memory-high": "\u{1F6A8}"
+};
+function formatSlackMessage(alert, service) {
+  const emoji = EMOJI[alert.type] ?? "\u26A0\uFE0F";
+  return `${emoji} *[${service}] ${alert.type}*
+${alert.message}
+\u2022 value: \`${alert.value}\`  \u2022 threshold: \`${alert.threshold}\`  \u2022 at: ${alert.at}`;
+}
+async function postToSlack(webhook, alert, service, logger) {
+  if (typeof fetch !== "function") {
+    logger?.warn?.("node-observe: global fetch unavailable (need Node 18+); skipping Slack alert");
+    return;
+  }
+  try {
+    const res = await fetch(webhook, {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify({ text: formatSlackMessage(alert, service) })
+    });
+    if (!res.ok) {
+      logger?.error?.(`node-observe: Slack webhook returned ${res.status}`);
+    }
+  } catch (err) {
+    logger?.error?.(`node-observe: Slack alert failed: ${err.message}`);
+  }
+}
+
+// src/util.ts
+function normalizePath(path) {
+  const clean = path.split("?")[0] ?? path;
+  return clean.split("/").map((seg) => {
+    if (seg === "") return seg;
+    if (/^\d+$/.test(seg)) return ":id";
+    if (/^[0-9a-f]{24}$/i.test(seg)) return ":id";
+    if (/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(seg)) return ":id";
+    if (/^[0-9a-f]{32,}$/i.test(seg)) return ":id";
+    return seg;
+  }).join("/");
+}
+function elapsedMs(start) {
+  return Number(process.hrtime.bigint() - start) / 1e6;
+}
+
+// src/express.ts
+function instrumentExpress(insights) {
+  return function nodeObserveMiddleware(req, res, next) {
+    const start = process.hrtime.bigint();
+    let done = false;
+    const finish2 = () => {
+      if (done) return;
+      done = true;
+      const ms = elapsedMs(start);
+      const method = req.method ?? "GET";
+      const route = routeOf(req);
+      insights.recordRequest(method, route, res.statusCode ?? 0, ms);
+    };
+    res.on("finish", finish2);
+    res.on("close", finish2);
+    next();
+  };
+}
+function routeOf(req) {
+  if (req.route?.path) {
+    const base = req.baseUrl ?? "";
+    return base + req.route.path || req.route.path;
+  }
+  return req.path ?? (req.originalUrl ?? req.url ?? "unknown").split("?")[0] ?? "unknown";
+}
+
+// src/mongo.ts
+var START = /* @__PURE__ */ Symbol("nodeObserveStart");
+var QUERY_HOOK = /^(find|findOne|findOneAnd|count|countDocuments|estimatedDocumentCount|update|updateOne|updateMany|delete|deleteOne|deleteMany|replaceOne)/;
+function instrumentMongoose(mongoose, insights) {
+  const m = mongoose;
+  if (!m || typeof m.plugin !== "function") {
+    insights.logger.warn?.("node-observe: instrumentMongoose called with a non-mongoose value; skipping");
+    return;
+  }
+  m.plugin((schema) => {
+    schema.pre(QUERY_HOOK, function() {
+      this[START] = process.hrtime.bigint();
+    });
+    schema.post(QUERY_HOOK, function() {
+      finish(insights, modelName(this), this.op ?? "query", this[START]);
+    });
+    schema.pre("aggregate", function() {
+      this[START] = process.hrtime.bigint();
+    });
+    schema.post("aggregate", function() {
+      finish(insights, aggregateModelName(this), "aggregate", this[START]);
+    });
+    schema.pre("save", function() {
+      this[START] = process.hrtime.bigint();
+    });
+    schema.post("save", function() {
+      finish(insights, this?.constructor?.modelName ?? "Document", "save", this[START]);
+    });
+  });
+}
+function finish(insights, model, op, start) {
+  if (typeof start !== "bigint") return;
+  insights.recordMongo(`${model}.${op}`, elapsedMs(start));
+}
+function modelName(query) {
+  return query?.model?.modelName ?? query?.mongooseCollection?.name ?? "Model";
+}
+function aggregateModelName(agg) {
+  return agg?._model?.modelName ?? agg?.model?.()?.modelName ?? "Model";
+}
+
+// src/redis.ts
+var PATCHED = /* @__PURE__ */ Symbol.for("nodeObserve.redisPatched");
+function instrumentRedis(client, insights) {
+  const c = client;
+  if (!c || typeof c.sendCommand !== "function") {
+    insights.logger.warn?.("node-observe: instrumentRedis called with a non-ioredis value; skipping");
+    return;
+  }
+  if (c[PATCHED]) return;
+  c[PATCHED] = true;
+  const original = c.sendCommand.bind(c);
+  c.sendCommand = function patchedSendCommand(command, ...rest) {
+    const start = process.hrtime.bigint();
+    const name = (command?.name ?? "unknown").toLowerCase();
+    const result = original(command, ...rest);
+    const promise = command?.promise ?? result;
+    if (promise && typeof promise.then === "function") {
+      promise.then(
+        () => insights.recordRedis(name, elapsedMs(start), false),
+        () => insights.recordRedis(name, elapsedMs(start), true)
+      );
+    }
+    return result;
+  };
+}
+
+// src/insights.ts
+var consoleLogger = {
+  info: (m) => console.log(m),
+  error: (m) => console.error(m),
+  warn: (m) => console.warn(m),
+  debug: (m) => console.debug(m)
+};
+var DEFAULT_THRESHOLDS = {
+  requestMs: 1e3,
+  mongoMs: 300,
+  redisMs: 100,
+  heapGrowthMbPerMin: 50,
+  heapUsedMb: 0
+  // disabled by default
+};
+var Insights = class {
+  http;
+  mongo;
+  redis;
+  counters;
+  memory;
+  serviceName;
+  thresholds;
+  logger;
+  opts;
+  cooldownMs;
+  lastAlertAt = /* @__PURE__ */ new Map();
+  memoryTimer;
+  startedAt = Date.now();
+  constructor(options = {}) {
+    this.opts = options;
+    this.serviceName = options.serviceName ?? "node-observe";
+    this.thresholds = { ...DEFAULT_THRESHOLDS, ...options.thresholds ?? {} };
+    this.logger = options.logger ?? consoleLogger;
+    this.cooldownMs = options.alertCooldownMs ?? 6e4;
+    this.memory = new MemoryMonitor();
+    const cap = options.sampleSize ?? 1024;
+    this.http = new MetricsRegistry(cap);
+    this.mongo = new MetricsRegistry(cap);
+    this.redis = new MetricsRegistry(cap);
+    this.counters = new MetricsRegistry(cap);
+  }
+  // ---- recording (used by the instrumentations) -----------------------------
+  /** Record an HTTP request. `route` is normalized when `normalizePaths` is on. */
+  recordRequest(method, route, statusCode, ms) {
+    const path = this.opts.normalizePaths === false ? route : normalizePath(route);
+    const isError = statusCode >= 500;
+    const key = `${method.toUpperCase()} ${path}`;
+    this.http.record(key, ms, isError);
+    this.counters.increment(`http.status.${Math.floor(statusCode / 100)}xx`);
+    if (ms > this.thresholds.requestMs) {
+      this.raise("slow-request", key, `${key} took ${ms.toFixed(0)}ms`, ms, this.thresholds.requestMs);
+    }
+  }
+  /** Record a Mongo operation, e.g. `User.find`. */
+  recordMongo(operation, ms, isError = false) {
+    this.mongo.record(operation, ms, isError);
+    if (ms > this.thresholds.mongoMs) {
+      this.raise("slow-mongo", operation, `Mongo ${operation} took ${ms.toFixed(0)}ms`, ms, this.thresholds.mongoMs);
+    }
+  }
+  /** Record a Redis command, e.g. `get`. */
+  recordRedis(command, ms, isError = false) {
+    this.redis.record(command, ms, isError);
+    if (ms > this.thresholds.redisMs) {
+      this.raise("slow-redis", command, `Redis ${command} took ${ms.toFixed(0)}ms`, ms, this.thresholds.redisMs);
+    }
+  }
+  // ---- instrumentation attach points ----------------------------------------
+  /** Express/Connect middleware that times every request. */
+  express() {
+    return instrumentExpress(this);
+  }
+  /** Instrument a Mongoose instance so every query/aggregate/save is timed. */
+  instrumentMongoose(mongoose) {
+    instrumentMongoose(mongoose, this);
+  }
+  /** Instrument an ioredis client so every command is timed. */
+  instrumentRedis(client) {
+    instrumentRedis(client, this);
+  }
+  /** Begin periodic memory sampling + leak detection. Returns a stop function. */
+  startMemoryMonitor() {
+    if (this.memoryTimer) return () => this.stopMemoryMonitor();
+    const interval = this.opts.memorySampleIntervalMs ?? 15e3;
+    this.memoryTimer = setInterval(() => this.checkMemory(), interval);
+    this.memoryTimer.unref?.();
+    return () => this.stopMemoryMonitor();
+  }
+  stopMemoryMonitor() {
+    if (this.memoryTimer) {
+      clearInterval(this.memoryTimer);
+      this.memoryTimer = void 0;
+    }
+  }
+  /**
+   * Take one memory reading and evaluate the leak/high-heap thresholds.
+   * `now`/`mem` are injectable for testing; both default to live process values.
+   */
+  checkMemory(now = Date.now(), mem = process.memoryUsage()) {
+    this.memory.sample(now, mem);
+    const snap = this.memory.snapshot(mem);
+    if (this.memory.size >= 5 && snap.growthMbPerMin > this.thresholds.heapGrowthMbPerMin) {
+      this.raise(
+        "memory-leak",
+        "heap",
+        `Heap growing ${snap.growthMbPerMin}MB/min (now ${snap.heapUsedMb}MB)`,
+        snap.growthMbPerMin,
+        this.thresholds.heapGrowthMbPerMin
+      );
+    }
+    if (this.thresholds.heapUsedMb > 0 && snap.heapUsedMb > this.thresholds.heapUsedMb) {
+      this.raise(
+        "memory-high",
+        "heap",
+        `Heap usage ${snap.heapUsedMb}MB`,
+        snap.heapUsedMb,
+        this.thresholds.heapUsedMb
+      );
+    }
+  }
+  // ---- output ---------------------------------------------------------------
+  snapshot() {
+    const mem = process.memoryUsage();
+    return {
+      service: this.serviceName,
+      uptimeSec: Math.round((Date.now() - this.startedAt) / 1e3),
+      http: this.http.snapshot(),
+      mongo: this.mongo.snapshot(),
+      redis: this.redis.snapshot(),
+      counters: this.counters.counterSnapshot(),
+      memory: this.memory.snapshot(mem),
+      generatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
+  /** Express handler that responds with the JSON snapshot. */
+  handler() {
+    return (_req, res) => {
+      const body = this.snapshot();
+      if (typeof res.json === "function") {
+        res.json(body);
+      } else {
+        res.setHeader?.("Content-Type", "application/json");
+        res.end?.(JSON.stringify(body));
+      }
+    };
+  }
+  // ---- alerting -------------------------------------------------------------
+  raise(type, key, message, value, threshold) {
+    const dedupeKey = `${type}:${key}`;
+    const now = Date.now();
+    const last = this.lastAlertAt.get(dedupeKey) ?? 0;
+    if (now - last < this.cooldownMs) return;
+    this.lastAlertAt.set(dedupeKey, now);
+    const alert = {
+      type,
+      key,
+      message,
+      value: Math.round(value * 100) / 100,
+      threshold,
+      at: new Date(now).toISOString()
+    };
+    try {
+      this.opts.onAlert?.(alert);
+    } catch (err) {
+      this.logger.error(`node-observe: onAlert handler threw: ${err.message}`);
+    }
+    if (this.opts.slackWebhook) {
+      void postToSlack(this.opts.slackWebhook, alert, this.serviceName, this.logger);
+    }
+  }
+};
+
+exports.Histogram = Histogram;
+exports.Insights = Insights;
+exports.MemoryMonitor = MemoryMonitor;
+exports.MetricsRegistry = MetricsRegistry;
+exports.elapsedMs = elapsedMs;
+exports.formatSlackMessage = formatSlackMessage;
+exports.instrumentExpress = instrumentExpress;
+exports.instrumentMongoose = instrumentMongoose;
+exports.instrumentRedis = instrumentRedis;
+exports.normalizePath = normalizePath;
+exports.postToSlack = postToSlack;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map