node-oom-heapdump 3.0.0-beta → 3.0.0

package/.github/workflows/publish-native-assets-to-github-releases.yml

@@ -0,0 +1,37 @@
+# This workflow will prebuild native binaries for supported NodeJS versions, and add them to the Github release that triggered the workflow
+
+name: Add native binaries to release
+
+on:
+  release:
+    types: [created]
+
+jobs:
+  augment-release:
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        node-version: [10.x, 11.x, 12.x, 14.x, 15.x, 16.x]
+        os: [ubuntu-latest, macos-latest, windows-latest]
+    steps:
+      - uses: actions/checkout@v2
+      - name: Use Node.js ${{ matrix.node-version }}
+        uses: actions/setup-node@v1
+        with:
+          node-version: ${{ matrix.node-version }}
+      - name: patch node gyp on windows to support Visual Studio 2019
+        if: matrix.os == 'windows-latest'
+        shell: powershell
+        run: |
+          npm install --global node-gyp@5.1.1
+          npm prefix -g | % {npm config set node_gyp "$_\node_modules\node-gyp\bin\node-gyp.js"}
+      - name: build using node-pre-gyp
+        run: |
+          npm install --build-from-source
+          ./node_modules/.bin/node-pre-gyp package
+      - name: Upload native binaries for Node ${{ matrix.node-version }} for ${{ matrix.os }}
+        uses: csexton/release-asset-action@v2
+        with:
+          pattern: "build/stage/*.tar.gz"
+          github-token: ${{ secrets.GITHUB_TOKEN }}
+          release-url: ${{ github.event.release.upload_url }}

package/CHANGELOG.md

@@ -1,13 +1,9 @@
-09-02-2022 Paul Rütter
+10-02-2022 Paul Rütter
 - 3.0.0
-- Updated dependencies to resolve https://github.com/blueconic/node-oom-heapdump/issues/19
-- Removed `gc-stats` as it was not used a lot anymore (breaking change) and contained security issues.
-- Removed creating heapdumps on out of memory, as this is superseeded by native node functionality.
-- Remove unused dependencies and native code.
-
-21-12-2020 Paul Rütter
-- 2.2.0
-- Updated ini
+- Added Node 16 support (by merging https://github.com/blueconic/node-oom-heapdump/pull/20, Thanks Simon Abbott!).
+  This fixes a recursion issue.
+- Removed "GC_MONITORING" at it relied on `gc-stats`, which is no longer maintained (and contained security issues)
+- Updated `node-pre-gyp` to `@mapbox/node-pre-gyp` so security issues are mitigated
 
 12-10-2020 Paul Rütter
 - 2.1.0

package/README.md

@@ -1,30 +1,40 @@
 [![TravisCI Build Status](https://travis-ci.org/blueconic/node-oom-heapdump.svg?branch=master)](https://travis-ci.org/blueconic/node-oom-heapdump)
 
 # node-oom-heapdump
-Node module that can create heapdumps and CPU profiles on request like 'v8-profiler', but does this off-process so it doesn't interfere with execution of the main process.
+Node module which will create a V8 heap snapshot right before an "Out of Memory" error occurs.
 
-Tested on Node.js 7.x, 8.x, 9.x, 10.x, 11.x, 12.x, 13.x, 14.x and 16.x.
-No support for Node.js < 7.0 at the moment (although this can be fixed if needed).  
+It can also create heapdumps and CPU profiles on request like 'v8-profiler', but does this off-process so it doesn't interfere with execution of the main process.
+
+Tested on Node.js 10.x, 11.x, 12.x, 13.x, 14.x, 15.x and 16.x.
+No support for Node.js < 10.x at the moment in version 3.0.0, use version 2.2.0 for if needed.  
 
 Also comes with prebuilt binaries (hosted on Github releases), thanks to Stuart Miller (https://github.com/spmiller).
 
-## Node.js 14.18.x and higher
+## Node.js 14.18.x
 https://github.com/nodejs/node/pull/33010 landed in Node.js 14.18.0, which makes this module no longer needed for heapdumps on out of memory.
-One can use the `--heapsnapshot-near-heap-limit` Node.js CLI option as an native alternative.
+One can use the `--heapsnapshot-near-heap-limit` Node.js CLI option as an alternative.
 See https://nodejs.org/dist/latest-v14.x/docs/api/cli.html#cli_heapsnapshot_near_heap_limit_max_count.
 
-For Node versions older than 14, use the `2.2.0` release, where this functionality is still present (not maintained anymore).
-For Node versions 14 and up, use `--heapsnapshot-near-heap-limit` for out-of-memory heapdumps. This functionality has been removed from `3.0.0`.
-
-One can still use the API of this module to create CPU profiles and heapdumps on request
-
 # Why?
-There are several modules around which can create heapdumps (v8-profiler, node-heapdump), although this module creates the heap snapshot from a separate process which performs better and doesn't affect the main event loop.
+When running nodejs processes in a low memory environment, every out of memory that occurs is interesting.
+To figure out why a process went out of memory, a heap snapshot (e.g. heapdump) can help a lot.
+This module creates a heap snapshot right before an out of memory error occurs (by leveraging 'SetOOMErrorHandler' of the V8 engine).
+It shows what the heap was filled with right before the out of memory error occured and can be opened with Chrome DevTools (Memory tab).
+
+There are several modules around which can create heapdumps (v8-profiler, node-heapdump), but these run in the same process as the one going out of memory. Often, creating heapdump won't work when the node process is already struggling.
+This module creates the heap snapshot from a separate process, which solves this issue.
+Also, these modules are not able to create a heapdump when an out of memory occurs.
 
 # What?
-When creating a heapdump of CPU profile on request, the DevTools protocol is used to create these files (no native add-on needed).
+Based on the work of 'trevnorris' (https://github.com/trevnorris/node-ofe/), this module uses 'isolate.SetOOMErrorHandler' (https://v8docs.nodesource.com/node-8.9/d5/dda/classv8_1_1_isolate.html#a08fd4087f39c33b4ac1c20ad953ce4e3) of the V8 engine, and then creates a heapdump when an actual Out of Memory occurs. To make this happen, a native C++ add-on is used. 
+Node-gyp is needed to compile this add-on.
+
+When creating a heapdump of CPU profile on request, the DevTools protocol is used to create these files (no native add-on).
 The --inspect node.js flag is needed to make this work (which is validated on startup).
 
+# Example
+Just run "npm test" to see it in action. It creates a heapdump named "my_heapdump.heapsnapshot" in the 'tests' directory of this module.
+
 # Usage
 
 ```javascript
@@ -52,10 +62,15 @@ These might impact performance though.
 On Node.js 12.x the latter two flags seem to cause some stability issues (see https://github.com/nodejs/node/issues/27552#issuecomment-542695931). So, if you encounter issues on Node.js 12.x in combination with those flags, please refrain from using these.
 
 # Options
+* heapdumpOnOOM - boolean whether to create a heapdump when an out of memory occurs. Default true.
+* OOMImplementation - Only "NATIVE_HOOK" is supported starting from 3.0.0
+"NATIVE_HOOK" relies on the native v8 hook and makes sure that the heapdump is actually created when the OoM occurs. It's more impacted by the OoMKiller of Unix systems though, when being run in memory restricted environments like Docker. 
+* path - the path where the heapdump ends up when an out of memory error occurs. '.heapsnapshot' is automatically appended. Defaults to this modules' directory.
+* addTimestamp - add a timestamp to the out of memory heapdump filename, to make it unique. Default is false.
 * port - optionally, the alternative DevTools protocol port. Defaults to 9229. Should map on the port given to the --inspect arg.
 
 # API
-The  API for creating heapdumps and CPU profiles on request. See below for the currently available API.
+Besides creating heapdumps when an out of memory error occurs, there also is an API for creating heapdumps and CPU profiles on request. See below for the currently available API.
 
 Notice that you cannot create a heapdump while a CPU profile is being generated and vice versa; an Error will be thrown if this is the case.
 

package/binding.gyp

@@ -0,0 +1,10 @@
+{
+	"targets" : [{
+		"target_name" : "node_oom_heapdump_native",
+		"sources" : [ "lib/node_oom_heapdump_native.cc" ],
+		"include_dirs": [
+			'<!(node -e "require(\'nan\')")'
+		],
+		"win_delay_load_hook" : "false"
+	}]
+}

package/build/binding.sln

@@ -4,14 +4,14 @@ Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "node_oom_heapdump_native",
 EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
-		Debug|x64 = Debug|x64
 		Release|x64 = Release|x64
+		Debug|x64 = Debug|x64
 	EndGlobalSection
 	GlobalSection(ProjectConfigurationPlatforms) = postSolution
-		{B44BD8E7-8AB3-68F6-9D96-154D16CEC9C0}.Debug|x64.ActiveCfg = Debug|x64
-		{B44BD8E7-8AB3-68F6-9D96-154D16CEC9C0}.Debug|x64.Build.0 = Debug|x64
 		{B44BD8E7-8AB3-68F6-9D96-154D16CEC9C0}.Release|x64.ActiveCfg = Release|x64
 		{B44BD8E7-8AB3-68F6-9D96-154D16CEC9C0}.Release|x64.Build.0 = Release|x64
+		{B44BD8E7-8AB3-68F6-9D96-154D16CEC9C0}.Debug|x64.ActiveCfg = Debug|x64
+		{B44BD8E7-8AB3-68F6-9D96-154D16CEC9C0}.Debug|x64.Build.0 = Debug|x64
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE

package/index.js

@@ -84,8 +84,8 @@ function parseOptions(options) {
   if (options.heapdumpOnOOM === undefined) {
     options.heapdumpOnOOM = true;
   }
-  if (options.OOMImplementation === undefined){
-    // default is the implementation, the old one was discarded because it wasn't used
+  if (options.OOMImplementation === undefined) {
+    // default is the "new" implementation
     options.OOMImplementation = "NATIVE_HOOK";
   }
   if (options.port === undefined) {
@@ -96,16 +96,6 @@ function parseOptions(options) {
   if (options.path === undefined) {
     options.path = "OoM-pid-" + process.pid;
   }
-  if (options.limit === undefined) {
-    options.limit = 3;
-  } else {
-    options.limit = parseInt(options.limit);
-  }
-  if (options.threshold === undefined) {
-    options.threshold = 70;
-  } else {
-    options.threshold = parseInt(options.threshold);
-  }
   if (options.addTimestamp === undefined) {
     options.addTimestamp = false;
   } else {

package/lib/index.js

@@ -7,6 +7,13 @@ class NodeOomHeapDumpImpl {
     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);
+      }
+    }
   }
 
 

package/lib/node_oom_heapdump_native.cc

@@ -0,0 +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;
+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)

package/package.json

@@ -1,18 +1,25 @@
 {
   "name": "node-oom-heapdump",
-  "version": "3.0.0-beta",
-  "description": "Create a heap snapshot or CPU profile on request, off-process through the DevTools protocol",
+  "version": "3.0.0",
+  "description": "Create a V8 heap snapshot when an \"Out of Memory\" error occurs, or create a heap snapshot or CPU profile on request.",
   "main": "index.js",
   "scripts": {
-    "dummy": "node -e \"process.exit(0)\"",
-    "api-publish-beta": "npm publish --tag beta"
+    "rebuild": "node-pre-gyp install --build-from-source",
+    "install": "node-pre-gyp install --fallback-to-build",
+    "test": "node --max_old_space_size=80 --inspect ./tests/oom_app.js",
+    "dummy": "node -e \"process.exit(0)\""
   },
   "repository": {
     "type": "git",
     "url": "git+https://github.com/blueconic/node-oom-heapdump.git"
   },
+  "binary": {
+    "module_name": "node_oom_heapdump_native",
+    "module_path": "./build/Release",
+    "host": "https://github.com/blueconic/node-oom-heapdump/releases/download/{version}"
+  },
   "engines": {
-    "node": ">=14.0.0"
+    "node": ">=7.0.0"
   },
   "keywords": [
     "nodejs",
@@ -33,8 +40,11 @@
     "eslint-config-google": "^0.14.0"
   },
   "dependencies": {
-    "chrome-remote-interface": "^0.31.2",
+    "@mapbox/node-pre-gyp": "^1.0.8",
+    "bindings": "^1.5.0",
+    "chrome-remote-interface": "^0.28.2",
+    "nan": "^2.14.2",
     "require-main-filename": "^2.0.0",
-    "ws": "^8.5.0"
+    "ws": "^7.4.6"
   }
 }

package/tests/index.js

@@ -0,0 +1,27 @@
+let cp = require("child_process");
+let fs = require("fs");
+let path = require("path");
+
+describe('Heapdumps', function () {
+  it('should be created in x seconds', function (done) {
+    this.timeout(250000);
+
+    let child = cp.fork(path.resolve(__dirname, './oom_app.js'), null, {
+      cmd: path.dirname(require.main.filename),
+      stdio: 'inherit',
+      execArgv: ["--max_old_space_size=40", "--optimize_for_size", "--always_compact", "--inspect=9229"]
+    });
+
+    setTimeout(function () {
+      child.kill();
+      fs.lstat(path.resolve(__dirname, "../abc.heapsnapshot"), (err, stats) => {
+        if (!err && stats.isFile()) {
+          done();
+        } else {
+          done(err);
+        }
+        clearTimeout(handle);
+      })
+    }, 20000);
+  });
+});

package/tests/long_running_process.js

@@ -0,0 +1,27 @@
+let oomLib = require("../index.js")({
+    heapdumpOnOOM: false
+});
+
+var i = 0;
+var path = "";
+
+var handle = setInterval(function () {
+    i++;
+
+    oomLib.createHeapSnapshot(require("path").resolve("../", "myName")).then((p) => {
+        path = p;
+    }).catch((err) => {
+        console.error(err);
+    });
+
+    if (i === 3) {
+        oomLib.deleteHeapSnapshot(path).then(() => {
+            //
+        }).catch((err) => {
+            console.error("err", err);
+        });
+        setTimeout(function () {
+            process.exit(0);
+        }, 100);
+    }
+}, 2000);

package/tests/long_running_process_cpu.js

@@ -0,0 +1,35 @@
+let oomLib = require("../index.js")({
+    heapdumpOnOOM: false
+});
+
+var i = 0;
+var path = "";
+
+oomLib.createCpuProfile(require("path").resolve("myCPU.cpuprofile"), 3000).then((p) => {
+    console.error("CPU profile", p);
+
+    //oomLib.deleteAllCpuProfiles();
+}).catch((err) => {
+    console.error(err);
+});
+
+var handle = setInterval(function () {
+    i++;
+
+    oomLib.createHeapSnapshot(require("path").resolve("../", "myName")).then((p) => {
+        path = p;
+    }).catch((err) => {
+        console.error(err);
+    });
+
+    if (i === 5) {
+        /* oomLib.deleteHeapSnapshot(path).then(() => {
+             //
+         }).catch((err) => {
+             console.error("err", err);
+         });*/
+        setTimeout(function () {
+            process.exit(0);
+        }, 100);
+    }
+}, 1000);

package/tests/oom_app.js

@@ -0,0 +1,22 @@
+let path = require('path');
+
+let oom = require("../index.js")({
+    path: path.resolve(__dirname, 'my_heapdump'),
+    heapdumpOnOOM: true,
+    //OOMImplementation: "GC_MONITORING", // use the old implementation
+    addTimestamp: false
+});
+
+// It is important to use named constructors (like the one below), otherwise
+// the heap snapshots will not produce useful outputs for you.
+function LeakingClass1() {
+}
+
+var leaks = [];
+var handle = setInterval(function () {
+    for (var i = 0; i < 100000; i++) {
+        leaks.push(new LeakingClass1);
+    }
+
+    console.error('Leaks: %d', leaks.length);
+}, 100);