Added CPU profile functionality

Added CPU profile functionality

Author: paulrutter

.gitignore

@@ -57,4 +57,5 @@ typings/
 # dotenv environment variables file
 .env
 
-*.heapsnapshot
+*.heapsnapshot
+*.cpuprofile

README.md

@@ -1,6 +1,6 @@
 # node-oom-heapdump
 Node module which will create a V8 heap snapshot right before an "Out of Memory" error occurs.
-It can also create heapdumps on request like 'v8-profiler', but does this off-process so it doesn't interfere with execution of the main process.
+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 8.x, but should also work fine using Node.js 6.3 upwards (According to: https://chromedevtools.github.io/devtools-protocol/v8/).
 
@@ -54,8 +54,8 @@ These might impact performance though.
 * port - optionally, the alternative DevTools protocol port. Defaults to 9229. Should map on the port given to the --inspect arg.
 
 # API
-Besides creating heapdumps when an out of memory error occurs, there also is an API for creating heapdumps 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.
 
 ```javascript
 let nodeOomHeapdump = require("node-oom-heapdump")({
@@ -67,7 +67,7 @@ let nodeOomHeapdump = require("node-oom-heapdump")({
 * @param {String} snapshotPath - path of the snapshot
 * @return {Promise} Promise containing the heap snapshot path on success or error on rejection
 */
-nodeOomHeapdump.createHeapSnapshot("mypath").then((snapshotPath) => {
+nodeOomHeapdump.createHeapSnapshot("myheapsnapshotpath").then((snapshotPath) => {
   // do something with heap snapshot
 
   // and delete again from disk
@@ -87,4 +87,31 @@ nodeOomHeapdump.deleteAllHeapSnapshots();
 * @return {Promise}
 */
 nodeOomHeapdump.deleteHeapSnapshot(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 (default: 30000ms)
+  * @return {Promise} the CPU profile path on success or error on rejection
+  */
+nodeOomHeapdump.createCpuProfile("mycpuprofilepath", 10000).then((cpuProfilePath) => {
+  // do something with CPU profile
+  
+  // and delete again from disk
+  nodeOomHeapdump.deleteCpuProfile(cpuProfilePath);
+}).catch((err) => {
+  // handle error
+});
+
+/**
+  * Deletes all previously created CPU profiles from disk
+  */
+nodeOomHeapdump.deleteAllCpuProfiles();
+
+/**
+  * Deletes a particular CPU profile from disk
+  * @param {String} cpuProfilePath - path to the CPU profile to delete from disk
+  * @return {Promise}
+  */
+nodeOomHeapdump.deleteCpuProfile(cpuProfilePath);
 ```

index.js

@@ -43,8 +43,38 @@ class NodeOomHeapdumpAPI {
   deleteHeapSnapshot(snapshotPath) {
     return this._impl.deleteHeapSnapshot(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 (duration === undefined) {
+      duration = 30000;
+    } else {
+      duration = parseInt(duration);
+    }
+    return this._impl.createCpuProfile(cpuProfilePath, duration);
+  }
+
+  /**
+   * Deletes all previously created CPU profiles from disk
+   */
+  deleteAllCpuProfiles() {
+    this._impl.deleteAllCpuProfiles();
+  }
+
+  /**
+   * Deletes a particular CPU profile from disk
+   * @param {String} cpuProfilePath - path to the CPU profile to delete from disk
+   * @return {Promise}
+   */
+  deleteCpuProfile(cpuProfilePath) {
+    return this._impl.deleteCpuProfile(cpuProfilePath);
+  }
+}
 
 // utility functions
 function parseOptions(options) {

lib/cpuProfileWorker.js

@@ -0,0 +1,48 @@
+let fs = require('fs');
+
+// set global variables based on args passed on to this oomWorker
+let devToolsPort = process.argv[2];
+let path = process.argv[3];
+let duration = process.argv[4];
+
+console.error('Started CPU profile (duration: %sms) %s worker on DevTools port \'%s\'.', duration, path, devToolsPort);
+
+let CDP = require('chrome-remote-interface');
+let writeStream = fs.createWriteStream(path);
+let handleError = function () {
+    console.error(arguments);
+    writeStream.end();
+    process.exit(-1);
+};
+writeStream.on('error', (err) => {
+    handleError("CPU profile path not valid or writable", err);
+});
+
+CDP({
+    host: 'localhost',
+    port: devToolsPort,
+}, (debugInstance) => {
+    let cpuProfiler = debugInstance.Profiler;
+    cpuProfiler.enable();
+    cpuProfiler.start();
+
+    setTimeout(() => {
+        let Profile = cpuProfiler.stop();
+        Profile.then((p) => {
+            writeStream.write(JSON.stringify(p.profile));
+            writeStream.end();
+
+            cpuProfiler.disable();
+
+            console.error('CPU profile created in \'%s\'. Exiting worker now.', path);
+
+            // were done, exit normally
+            process.exit(0);
+        }).catch((err) => {
+            handleError(err);
+        });
+    }, duration);
+}).on('error', (err) => {
+    // cannot connect to the remote endpoint
+    handleError(err);
+});

lib/heapdumpWorker.js

@@ -8,7 +8,15 @@ let logPrefix = (process.argv[4]) ? process.argv[4] + " " : "";
 console.error('Started heapdump %sworker for \'%s\' on DevTools port \'%s\'.', logPrefix, path, devToolsPort);
 
 let CDP = require('chrome-remote-interface');
-
+let writeStream = fs.createWriteStream(path);
+let handleError = function () {
+    console.error(arguments);
+    writeStream.end();
+    process.exit(-1);
+};
+writeStream.on('error', (err) => {
+    handleError("Heapdump path not valid or writable", err);
+});
 CDP({
     host: 'localhost',
     port: devToolsPort,
@@ -19,12 +27,6 @@ CDP({
     let heapProfiler = debugInstance.HeapProfiler;
     heapProfiler.enable();
 
-    let writeStream = fs.createWriteStream(path);
-    writeStream.on('error', (err) => {
-        console.error("Heapdump path not valid or writable", err);
-        process.exit(-1);
-    });
-
     debugInstance.on('HeapProfiler.addHeapSnapshotChunk', function (evt) {
         writeStream.write(evt.chunk);
     });
@@ -42,8 +44,5 @@ CDP({
         process.exit(0);
     });
 }).on('error', (err) => {
-    // cannot connect to the remote endpoint
-    console.error(err);
-
-    process.exit(-1);
-});
+    handleError(err);
+});

lib/index.js

@@ -5,7 +5,7 @@ let path = require("path");
 class NodeOomHeapDumpImpl {
   constructor(options) {
     this._opts = options;
-    this._heapSnapshots = [];
+    this._files = [];
     this._busy = false;
     this._count = 0;
     this._limitReached = false;
@@ -48,31 +48,22 @@ class NodeOomHeapDumpImpl {
   }
 
   /**
-   * 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 heapdumo is created
-   * @return {Promise} the heap snapshot path on success or error on rejection
+   * 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
    */
-  createHeapSnapshot(snapshotPath, logPrefix) {
-    if (!snapshotPath) {
-      snapshotPath = path.resolve(__dirname, "./heapsnapshot");
-    }
-    if (logPrefix === "OoM" && this._opts.addTimestamp){
-      if (snapshotPath.endsWith(".heapsnapshot")) {
-        snapshotPath = snapshotPath.replace(".heapsnapshot", "");
-      }
-      // in case of OoM error, add if timestamp if needed
-      snapshotPath += "-" + Date.now();
-    }
-    if (!snapshotPath.endsWith(".heapsnapshot")) {
-      snapshotPath += ".heapsnapshot";
+  _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."));
+      });
     }
 
-    // resolve to absolute file path
-    snapshotPath = path.resolve(snapshotPath);
+    var args = [path.resolve(__dirname, workerPath)].concat(workerArgs);
 
-    // start OoMworker to create heapdump
-    let child = cp.spawn('node', [path.resolve(__dirname, './heapdumpWorker.js'), this._opts.port, snapshotPath, logPrefix || ""], {
+    // start worker
+    let child = cp.spawn('node', args, {
       cmd: path.dirname(require.main.filename),
       stdio: 'inherit'
     });
@@ -87,23 +78,77 @@ class NodeOomHeapDumpImpl {
       });
       child.on('exit', () => {
         if (!error) {
-          this._count++;
-          if (!this._heapSnapshots.includes(snapshotPath)) {
-            this._heapSnapshots.push(snapshotPath);
-          }
-          resolve(snapshotPath);
+          resolve();
         }
         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) {
+    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";
+    }
+
+    // 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._heapSnapshots.forEach((snapshotPath) => {
-      this.deleteHeapSnapshot(snapshotPath);
+    this._files.forEach((snapshotPath) => {
+      if (snapshotPath.endsWith(".heapsnapshot")) {
+        this.deleteHeapSnapshot(snapshotPath);
+      }
     });
   }
 
@@ -113,17 +158,46 @@ class NodeOomHeapDumpImpl {
    * @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._heapSnapshots.includes(snapshotPath)) {
-        fs.unlink(snapshotPath, (err) => {
+      if (this._files.includes(path)) {
+        fs.unlink(path, (err) => {
           if (err) {
             reject(err);
           } else {
-            resolve(snapshotPath);
+            resolve(path);
           }
         });
       } else {
-        reject(new Error("File not found:" + snapshotPath));
+        reject(new Error("File not found:" + path));
       }
     });
   }