node-oom-heapdump 2.1.0-progress.1 → 3.0.0

package/lib/index.js

@@ -1,228 +1,194 @@
-let cp = require("child_process");
-let fs = require("fs");
-let path = require("path");
-
-class NodeOomHeapDumpImpl {
-  constructor(options) {
-    this._opts = options;
-    this._files = [];
-    this._busy = false;
-    this._count = 0;
-    this._limitReached = false;
-
-    if (this._opts.heapdumpOnOOM) {
-      if (options.OOMImplementation === "NATIVE_HOOK") {
-        require('bindings')('node_oom_heapdump_native.node').call(this._getHeapSnapshotPath(this._opts.path), this._opts.addTimestamp);
-      } else if (options.OOMImplementation === "GC_MONITORING") {
-        this._monitorHeap();
-      }
-    }
-  }
-
-  _monitorHeap() {
-    // see https://www.npmjs.com/package/gc-stats	
-    let gcStats = new require('gc-stats')();
-    gcStats.on('stats', (stats) => {
-      // gctype 2 is a Full GC (Mark/Sweep/Compact)	
-      if (stats.gctype === 2 && !this._busy) {
-        let memoryUsagePercentage = Math.round((stats.after.usedHeapSize / stats.after.heapSizeLimit) * 100);
-        if (memoryUsagePercentage > this._opts.threshold) {
-          if (this._count < this._opts.limit) {
-            // this is a full GC and the used heap size is using more than x% of the assigned heap space limit	
-            console.warn('OoM is imminent: Full GC (Mark/Sweep/Compact) complete and still more than %s% (%s%) of the heap is used. Creating heapdump now. GC stats: ', this._opts.threshold, Math.round(memoryUsagePercentage), JSON.stringify(stats));
-
-            this.createHeapSnapshot(this._opts.path, "OoM");
-
-            // block execution of other code for a while (5 second) to enable snapshot to be created	
-            const time = Date.now();
-            let diff = 0;
-            do {
-              diff = Date.now() - time;
-            }
-            while (diff < 5000);
-          } else if (!this._limitReached) {
-            this._limitReached = true;
-            console.warn("OoM heapdump limit reached (%s); no more heapdumps will be created.", this._opts.limit);
-            return;
-          }
-        }
-      }
-    });
-  }
-
-
-  /**
-   * Calls the designated worker and returns a promise
-   * @param {String} workerPath - path of the worker
-   * @param {String[]} workerArgs - arguments to worker
-   * @return {Promise} resolve on success, reject on error
-   */
-  _callWorker(workerPath, workerArgs) {
-    if (this._busy) {
-      return new Promise((resolve, reject) => {
-        reject(new Error("A CPU profile or heapdump is already being created, please retry later."));
-      });
-    }
-
-    var args = [path.resolve(__dirname, workerPath)].concat(workerArgs);
-
-    // use 'require-main-filename' module instead of require.main.filename, see https://github.com/blueconic/node-oom-heapdump/issues/3
-    let mainFilename = require('require-main-filename')();
-
-    // start worker
-    let child = cp.spawn('node', args, {
-      cmd: path.dirname(mainFilename),
-      stdio: 'inherit'
-    });
-
-    return new Promise((resolve, reject) => {
-      this._busy = true;
-      var error = null;
-
-      child.on('error', (err) => {
-        error = err;
-        reject(err);
-      });
-      child.on('exit', (code) => {
-        if (!error) {
-          if (code === 0) {
-            resolve();
-          } else {
-            reject(new Error("Worker exited with statusCode: " + code));
-          }
-        }
-        this._busy = false;
-      });
-    });
-  }
-
-  /**
-   * Returns the path to the created heap snapshot in a promise, or rejects on error
-   * @param {String} snapshotPath - path of the snapshot
-   * @param {String} logPrefix - optional log prefix message when heapdump is created
-   * @return {Promise} the heap snapshot path on success or error on rejection
-   */
-  createHeapSnapshot(snapshotPath, logPrefix) {
-    snapshotPath = this._getHeapSnapshotPath(snapshotPath, logPrefix);
-
-    // start OoMworker to create heapdump
-    return this._callWorker('./heapdumpWorker.js', [this._opts.port, snapshotPath, logPrefix || ""]).then(() => {
-      if (logPrefix === "OoM") {
-        this._count++;
-      }
-      if (!this._files.includes(snapshotPath)) {
-        this._files.push(snapshotPath);
-      }
-      return snapshotPath;
-    });
-  }
-
-  /**
-   * Returns the path to the created CPU profile in a promise, or rejects on error
-   * @param {String} cpuProfilePath - path of the CPU profile
-   * @param {number} duration - the duration of the cpu profile (in ms)
-   * @return {Promise} the CPU profile path on success or error on rejection
-   */
-  createCpuProfile(cpuProfilePath, duration) {
-    if (!cpuProfilePath) {
-      cpuProfilePath = path.resolve(__dirname, "../cpuprofile-" + Date.now());
-    }
-    if (!cpuProfilePath.endsWith(".cpuprofile")) {
-      cpuProfilePath += ".cpuprofile";
-    }
-
-    // start OoMworker to create heapdump
-    return this._callWorker('./cpuProfileWorker.js', [this._opts.port, cpuProfilePath, duration]).then(() => {
-      if (!this._files.includes(cpuProfilePath)) {
-        this._files.push(cpuProfilePath);
-      }
-      return cpuProfilePath;
-    });
-  }
-
-  /**
-   * Delete all created heap snapshots
-   */
-  deleteAllHeapSnapshots() {
-    this._files.forEach((snapshotPath) => {
-      if (snapshotPath.endsWith(".heapsnapshot")) {
-        this.deleteHeapSnapshot(snapshotPath);
-      }
-    });
-  }
-
-  /**
-   * Deletes a particular snapshot from disk
-   * @param {String} snapshotPath - path of the heap snapshot to delete
-   * @return {Promise}
-   */
-  deleteHeapSnapshot(snapshotPath) {
-    return this._deleteFile(snapshotPath);
-  }
-
-  /**
-   * Delete all created CPU profiles
-   */
-  deleteAllCpuProfiles() {
-    this._files.forEach((path) => {
-      if (path.endsWith(".cpuprofile")) {
-        this.deleteCpuProfile(path);
-      }
-    });
-  }
-
-  /**
-   * Deletes a particular CPU profile from disk
-   * @param {String} cpuProfilePath - path of the CPU profile to delete
-   * @return {Promise}
-   */
-  deleteCpuProfile(cpuProfilePath) {
-    return this._deleteFile(cpuProfilePath);
-  }
-
-  /**
-   * Deletes a given CPU profile or heapsnapshot  from disk
-   * @param {String} path - path to the file to delete
-   * @return {Promise}
-   */
-  _deleteFile(path) {
-    return new Promise((resolve, reject) => {
-      if (this._files.includes(path)) {
-        fs.unlink(path, (err) => {
-          if (err) {
-            reject(err);
-          } else {
-            resolve(path);
-          }
-        });
-      } else {
-        reject(new Error("File not found:" + path));
-      }
-    });
-  }
-
-  /**
-   * Returns a proper snapshot path, based on the given parameter
-   * @param {String} snapshotPath 
-   * @param {String} logPrefix
-   * @return {String} path
-   */
-  _getHeapSnapshotPath(snapshotPath, logPrefix) {
-    if (!snapshotPath) {
-      snapshotPath = path.resolve(__dirname, "../heapsnapshot-" + Date.now());
-    }
-    if (logPrefix === "OoM" && this._opts.addTimestamp) {
-      if (snapshotPath.endsWith(".heapsnapshot")) {
-        snapshotPath = snapshotPath.replace(".heapsnapshot", "");
-      }
-      // in case of OoM error, add timestamp if needed	
-      snapshotPath += "-" + Date.now();
-    }
-    if (!snapshotPath.endsWith(".heapsnapshot")) {
-      snapshotPath += ".heapsnapshot";
-    }
-    return snapshotPath;
-  }
-}
-
+let cp = require("child_process");
+let fs = require("fs");
+let path = require("path");
+
+class NodeOomHeapDumpImpl {
+  constructor(options) {
+    this._opts = options;
+    this._files = [];
+    this._busy = false;
+    this._count = 0;
+
+    if (this._opts.heapdumpOnOOM) {
+      if (options.OOMImplementation === "NATIVE_HOOK") {
+        require('bindings')('node_oom_heapdump_native.node').call(this._getHeapSnapshotPath(this._opts.path), this._opts.addTimestamp);
+      }
+    }
+  }
+
+
+  /**
+   * Calls the designated worker and returns a promise
+   * @param {String} workerPath - path of the worker
+   * @param {String[]} workerArgs - arguments to worker
+   * @return {Promise} resolve on success, reject on error
+   */
+  _callWorker(workerPath, workerArgs) {
+    if (this._busy) {
+      return new Promise((resolve, reject) => {
+        reject(new Error("A CPU profile or heapdump is already being created, please retry later."));
+      });
+    }
+
+    var args = [path.resolve(__dirname, workerPath)].concat(workerArgs);
+
+    // use 'require-main-filename' module instead of require.main.filename, see https://github.com/blueconic/node-oom-heapdump/issues/3
+    let mainFilename = require('require-main-filename')();
+
+    // start worker
+    let child = cp.spawn('node', args, {
+      cmd: path.dirname(mainFilename),
+      stdio: 'inherit'
+    });
+
+    return new Promise((resolve, reject) => {
+      this._busy = true;
+      var error = null;
+
+      child.on('error', (err) => {
+        error = err;
+        reject(err);
+      });
+      child.on('exit', (code) => {
+        if (!error) {
+          if (code === 0) {
+            resolve();
+          } else {
+            reject(new Error("Worker exited with statusCode: " + code));
+          }
+        }
+        this._busy = false;
+      });
+    });
+  }
+
+  /**
+   * Returns the path to the created heap snapshot in a promise, or rejects on error
+   * @param {String} snapshotPath - path of the snapshot
+   * @param {String} logPrefix - optional log prefix message when heapdump is created
+   * @return {Promise} the heap snapshot path on success or error on rejection
+   */
+  createHeapSnapshot(snapshotPath, logPrefix) {
+    snapshotPath = this._getHeapSnapshotPath(snapshotPath, logPrefix);
+
+    // start OoMworker to create heapdump
+    return this._callWorker('./heapdumpWorker.js', [this._opts.port, snapshotPath, logPrefix || ""]).then(() => {
+      if (logPrefix === "OoM") {
+        this._count++;
+      }
+      if (!this._files.includes(snapshotPath)) {
+        this._files.push(snapshotPath);
+      }
+      return snapshotPath;
+    });
+  }
+
+  /**
+   * Returns the path to the created CPU profile in a promise, or rejects on error
+   * @param {String} cpuProfilePath - path of the CPU profile
+   * @param {number} duration - the duration of the cpu profile (in ms)
+   * @return {Promise} the CPU profile path on success or error on rejection
+   */
+  createCpuProfile(cpuProfilePath, duration) {
+    if (!cpuProfilePath) {
+      cpuProfilePath = path.resolve(__dirname, "../cpuprofile-" + Date.now());
+    }
+    if (!cpuProfilePath.endsWith(".cpuprofile")) {
+      cpuProfilePath += ".cpuprofile";
+    }
+
+    // start OoMworker to create heapdump
+    return this._callWorker('./cpuProfileWorker.js', [this._opts.port, cpuProfilePath, duration]).then(() => {
+      if (!this._files.includes(cpuProfilePath)) {
+        this._files.push(cpuProfilePath);
+      }
+      return cpuProfilePath;
+    });
+  }
+
+  /**
+   * Delete all created heap snapshots
+   */
+  deleteAllHeapSnapshots() {
+    this._files.forEach((snapshotPath) => {
+      if (snapshotPath.endsWith(".heapsnapshot")) {
+        this.deleteHeapSnapshot(snapshotPath);
+      }
+    });
+  }
+
+  /**
+   * Deletes a particular snapshot from disk
+   * @param {String} snapshotPath - path of the heap snapshot to delete
+   * @return {Promise}
+   */
+  deleteHeapSnapshot(snapshotPath) {
+    return this._deleteFile(snapshotPath);
+  }
+
+  /**
+   * Delete all created CPU profiles
+   */
+  deleteAllCpuProfiles() {
+    this._files.forEach((path) => {
+      if (path.endsWith(".cpuprofile")) {
+        this.deleteCpuProfile(path);
+      }
+    });
+  }
+
+  /**
+   * Deletes a particular CPU profile from disk
+   * @param {String} cpuProfilePath - path of the CPU profile to delete
+   * @return {Promise}
+   */
+  deleteCpuProfile(cpuProfilePath) {
+    return this._deleteFile(cpuProfilePath);
+  }
+
+  /**
+   * Deletes a given CPU profile or heapsnapshot  from disk
+   * @param {String} path - path to the file to delete
+   * @return {Promise}
+   */
+  _deleteFile(path) {
+    return new Promise((resolve, reject) => {
+      if (this._files.includes(path)) {
+        fs.unlink(path, (err) => {
+          if (err) {
+            reject(err);
+          } else {
+            resolve(path);
+          }
+        });
+      } else {
+        reject(new Error("File not found:" + path));
+      }
+    });
+  }
+
+  /**
+   * Returns a proper snapshot path, based on the given parameter
+   * @param {String} snapshotPath 
+   * @param {String} logPrefix
+   * @return {String} path
+   */
+  _getHeapSnapshotPath(snapshotPath, logPrefix) {
+    if (!snapshotPath) {
+      snapshotPath = path.resolve(__dirname, "../heapsnapshot-" + Date.now());
+    }
+    if (logPrefix === "OoM" && this._opts.addTimestamp) {
+      if (snapshotPath.endsWith(".heapsnapshot")) {
+        snapshotPath = snapshotPath.replace(".heapsnapshot", "");
+      }
+      // in case of OoM error, add timestamp if needed	
+      snapshotPath += "-" + Date.now();
+    }
+    if (!snapshotPath.endsWith(".heapsnapshot")) {
+      snapshotPath += ".heapsnapshot";
+    }
+    return snapshotPath;
+  }
+}
+
 module.exports = NodeOomHeapDumpImpl;

package/lib/node_oom_heapdump_native.cc

@@ -1,110 +1,119 @@
-#include <nan.h>
-#include <v8-profiler.h>
-#include <stdlib.h>
-#if defined(_WIN32)
-  #include <time.h>
-  #define snprintf _snprintf
-#else
-  #include <sys/time.h>
-#endif
-
-using namespace v8;
-
-char filename[256];
-bool addTimestamp;
-
-class FileOutputStream: public OutputStream {
-  public:
-    FileOutputStream(FILE* stream): stream_(stream) { }
-    virtual int GetChunkSize() {
-      return 65536;
-    }
-    virtual void EndOfStream() { }
-    virtual WriteResult WriteAsciiChunk(char* data, int size) {
-      const size_t len = static_cast<size_t>(size);
-      size_t off = 0;
-      while (off < len && !feof(stream_) && !ferror(stream_))
-        off += fwrite(data + off, 1, len - off, stream_);
-      return off == len ? kContinue : kAbort;
-    }
-
-  private:
-    FILE* stream_;
-};
-
-class ActivityControlAdapter : public ActivityControl {
-    public:
-      ActivityControlAdapter()
-      {}
-
-      ControlOption ReportProgressValue(int done, int total) {
-          printf("\nProgress of heapdump: %d, %d", done, total);
-          return kContinue;
-      }
-  };
-
-void OnOOMError(const char *location, bool is_heap_oom) {
-  if (addTimestamp) {
-    // Add timestamp to filename
-    time_t rawtime;
-    struct tm* timeinfo;
-    time(&rawtime);
-    timeinfo = localtime(&rawtime);
-
-    char * pch;
-    pch = strstr (filename,".heapsnapshot");
-    strncpy (pch,"",1);
-    strcat (filename, "-%Y%m%dT%H%M%S.heapsnapshot");
-    
-    char newFilename[256];
-    strftime(newFilename, sizeof(filename), filename, timeinfo);
-    strcpy(filename, newFilename);
-  }
-
-  fprintf(stderr, "Generating Heapdump to '%s' now...\n", filename);
-  FILE* fp = fopen(filename, "w");
-  if (fp == NULL) abort();
-
-  // Create heapdump, depending on which Node.js version this can differ
-  // for now, just support Node.js 7 and higher
-  
-    ActivityControlAdapter* control = new ActivityControlAdapter();
-    const HeapSnapshot* snap = v8::Isolate::GetCurrent()->GetHeapProfiler()->TakeHeapSnapshot(control);
-  
-    FileOutputStream stream(fp);
-    snap->Serialize(&stream, HeapSnapshot::kJSON);
-    fclose(fp);
-
-    fprintf(stderr, "Done! Exiting process now.\n");
-    exit(1);
-  
-}
-
-void ParseArgumentsAndSetErrorHandler(const FunctionCallbackInfo<Value>& args) {
-  Isolate* isolate = args.GetIsolate();
-  isolate->SetOOMErrorHandler(OnOOMError);
-  
-  // parse JS arguments
-  // 1: filename
-  // 2: addTimestamp boolean
-  #if NODE_VERSION_AT_LEAST(12, 0, 0)
-  String::Utf8Value fArg(isolate, args[0]->ToString(isolate));
-  #elif NODE_VERSION_AT_LEAST(9, 0, 0)
-  String::Utf8Value fArg(isolate, args[0]->ToString());
-  #else
-  String::Utf8Value fArg(args[0]->ToString());
-  #endif
-  strncpy(filename, (const char*)(*fArg), sizeof(filename) - 1);
-
-  #if NODE_VERSION_AT_LEAST(12, 0, 0)
-  addTimestamp = args[1]->BooleanValue(isolate);
-  #else
-  addTimestamp = args[1]->BooleanValue();
-  #endif
-}
-
-void init(Local<Object> exports) {
-  NODE_SET_METHOD(exports, "call", ParseArgumentsAndSetErrorHandler);
-}
-
-NODE_MODULE(NODE_OOM_HEAPDUMP_NATIVE, init)
+#include <nan.h>
+#include <v8-profiler.h>
+#include <stdlib.h>
+#if defined(_WIN32)
+  #include <time.h>
+  #define snprintf _snprintf
+#else
+  #include <sys/time.h>
+#endif
+
+using namespace v8;
+
+char filename[256];
+bool addTimestamp;
+bool processingOOM = false;
+
+class FileOutputStream: public OutputStream {
+  public:
+    FileOutputStream(FILE* stream): stream_(stream) { }
+    virtual int GetChunkSize() {
+      return 65536;
+    }
+    virtual void EndOfStream() { }
+    virtual WriteResult WriteAsciiChunk(char* data, int size) {
+      const size_t len = static_cast<size_t>(size);
+      size_t off = 0;
+      while (off < len && !feof(stream_) && !ferror(stream_))
+        off += fwrite(data + off, 1, len - off, stream_);
+      return off == len ? kContinue : kAbort;
+    }
+
+  private:
+    FILE* stream_;
+};
+
+size_t RaiseLimit(void* data, size_t current_heap_limit, size_t initial_heap_limit) {
+  return current_heap_limit + 10u * 1024 * 1024; // 10MiB
+}
+
+void OnOOMError(const char *location, bool is_heap_oom) {
+  if (processingOOM) {
+    fprintf(stderr, "FATAL: OnOOMError called more than once.\n");
+    exit(2);
+  }
+  processingOOM = true;
+
+  if (addTimestamp) {
+    // Add timestamp to filename
+    time_t rawtime;
+    struct tm* timeinfo;
+    time(&rawtime);
+    timeinfo = localtime(&rawtime);
+
+    char * pch;
+    pch = strstr (filename,".heapsnapshot");
+    strncpy (pch,"",1);
+    strcat (filename, "-%Y%m%dT%H%M%S.heapsnapshot");
+
+    char newFilename[256];
+    strftime(newFilename, sizeof(filename), filename, timeinfo);
+    strcpy(filename, newFilename);
+  }
+
+  fprintf(stderr, "Generating Heapdump to '%s' now...\n", filename);
+  FILE* fp = fopen(filename, "w");
+  if (fp == NULL) abort();
+
+  auto* isolate = v8::Isolate::GetCurrent();
+
+  // Capturing a heap snapshot forces a garbage collection which can, in turn,
+  // trigger the OOM flow which causes recursion. To prevent this, this callback
+  // will raise the heap limit if the GC tries to go down that path again.
+  // Normally we would want to add a call to RemoveNearHeapLimitCallback() after
+  // we are done, but that is not necessary since we exit() before it matters.
+  isolate->AddNearHeapLimitCallback(RaiseLimit, nullptr);
+
+  // Create heapdump, depending on which Node.js version this can differ
+  // for now, just support Node.js 7 and higher
+  const HeapSnapshot* snap = isolate->GetHeapProfiler()->TakeHeapSnapshot();
+
+  FileOutputStream stream(fp);
+  snap->Serialize(&stream, HeapSnapshot::kJSON);
+  fclose(fp);
+
+  fprintf(stderr, "Done! Exiting process now.\n");
+  exit(1);
+}
+
+void ParseArgumentsAndSetErrorHandler(const FunctionCallbackInfo<Value>& args) {
+  Isolate* isolate = args.GetIsolate();
+  isolate->SetOOMErrorHandler(OnOOMError);
+
+  // parse JS arguments
+  // 1: filename
+  // 2: addTimestamp boolean
+  #if NODE_VERSION_AT_LEAST(13, 0, 0)
+  Local<Context> context = isolate->GetCurrentContext();
+  String::Utf8Value fArg(isolate, args[0]->ToString(context).ToLocalChecked());
+  #elif NODE_VERSION_AT_LEAST(12, 0, 0)
+  String::Utf8Value fArg(isolate, args[0]->ToString(isolate));
+  #elif NODE_VERSION_AT_LEAST(9, 0, 0)
+  String::Utf8Value fArg(isolate, args[0]->ToString());
+  #else
+  String::Utf8Value fArg(args[0]->ToString());
+  #endif
+  strncpy(filename, (const char*)(*fArg), sizeof(filename) - 1);
+
+  #if NODE_VERSION_AT_LEAST(12, 0, 0)
+  addTimestamp = args[1]->BooleanValue(isolate);
+  #else
+  addTimestamp = args[1]->BooleanValue();
+  #endif
+}
+
+void init(Local<Object> exports) {
+  NODE_SET_METHOD(exports, "call", ParseArgumentsAndSetErrorHandler);
+}
+
+NODE_MODULE(NODE_OOM_HEAPDUMP_NATIVE, init)