@memprofile/agent-node/dist/agent.js

Lightweight Node.js heap-snapshot agent for MemProfiler AI

#!/usr/bin/env node
"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 __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 __async = (__this, __arguments, generator) => {
  return new Promise((resolve, reject) => {
    var fulfilled = (value) => {
      try {
        step(generator.next(value));
      } catch (e) {
        reject(e);
      }
    };
    var rejected = (value) => {
      try {
        step(generator.throw(value));
      } catch (e) {
        reject(e);
      }
    };
    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
    step((generator = generator.apply(__this, __arguments)).next());
  });
};

// src/agent.ts
var import_promises2 = __toESM(require("fs/promises"));
var import_path = __toESM(require("path"));

// src/config.ts
var import_os = __toESM(require("os"));
var cfg = {
  apiKey: process.env.MEMPROF_API_KEY || "",
  endpoint: process.env.MEMPROF_ENDPOINT || "https://api.memprofiler.io/v1/snapshots",
  intervalSec: +(process.env.MEMPROF_INTERVAL || 3600),
  thresholdPct: +(process.env.MEMPROF_THRESHOLD || 10),
  host: process.env.MEMPROF_HOSTNAME || import_os.default.hostname(),
  snapshotDir: process.env.MEMPROF_TMP || ".snapshots"
};
if (!cfg.apiKey) throw new Error("MEMPROF_API_KEY missing");

// src/snapshot.ts
var import_inspector = __toESM(require("inspector"));
var import_promises = __toESM(require("fs/promises"));
function takeSnapshot(file) {
  return __async(this, null, function* () {
    const session = new import_inspector.default.Session();
    session.connect();
    const chunks = [];
    yield new Promise((res, rej) => {
      session.post("HeapProfiler.enable", () => {
        session.post("HeapProfiler.takeHeapSnapshot", {}, (err) => {
          if (err) rej(err);
        });
      });
      session.on("HeapProfiler.addHeapSnapshotChunk", (m) => chunks.push(m.params.chunk));
      session.on("HeapProfiler.reportHeapSnapshotProgress", (m) => {
        if (m.params.finished) {
          session.disconnect();
          res();
        }
      });
    });
    yield import_promises.default.writeFile(file, chunks.join(""));
  });
}

// src/compress.ts
var import_zlib = require("zlib");
var import_util = require("util");
var gz = (0, import_util.promisify)(import_zlib.gzip);
function gzFile(input) {
  return __async(this, null, function* () {
    return gz(input, { level: 9 });
  });
}

// src/upload.ts
var import_node_fetch = __toESM(require("node-fetch"));
var import_formdata_node = require("formdata-node");
function upload(buf) {
  return __async(this, null, function* () {
    const fd = new import_formdata_node.FormData();
    fd.set("host", cfg.host);
    fd.set("language", "node");
    fd.append("snapshot", buf, "snap.gz");
    const res = yield (0, import_node_fetch.default)(cfg.endpoint, {
      method: "POST",
      headers: { "x-api-key": cfg.apiKey },
      body: fd
    });
    if (!res.ok) {
      const text = yield res.text();
      throw new Error(`Upload failed (${res.status}): ${text.slice(0, 200)}`);
    }
  });
}

// src/agent.ts
(() => __async(null, null, function* () {
  yield import_promises2.default.mkdir(cfg.snapshotDir, { recursive: true });
  function cycle() {
    return __async(this, null, function* () {
      const stamp = Date.now();
      const raw = import_path.default.join(cfg.snapshotDir, `${stamp}.heapsnapshot`);
      yield takeSnapshot(raw);
      const buf = yield import_promises2.default.readFile(raw);
      const gzBuf = yield gzFile(buf);
      yield upload(gzBuf);
      const files = (yield import_promises2.default.readdir(cfg.snapshotDir)).filter((f) => f.endsWith(".heapsnapshot"));
      if (files.length > 3) for (const f of files.slice(0, files.length - 3))
        yield import_promises2.default.rm(import_path.default.join(cfg.snapshotDir, f));
      console.log(`[memprof] snapshot ${stamp} uploaded (${(buf.length / 1e6).toFixed(1)} MB)`);
    });
  }
  setInterval(cycle, cfg.intervalSec * 1e3);
  cycle();
}))();