public version

Author: dmelikyan

.gitignore

@@ -0,0 +1,6 @@
+.DS_Store
+._
+._.*
+build
+node_modules
+npm-debug.log

.npmignore

@@ -0,0 +1,5 @@
+*.log
+node_modules
+test
+.gitignore
+.npmignore

Gruntfile.js

@@ -0,0 +1,23 @@
+'use strict';
+
+module.exports = function(grunt) {
+  grunt.initConfig({
+    pkg: grunt.file.readJSON('package.json'),
+    jshint: {
+      files: ['Gruntfile.js', 'lib/**/*.js'],
+      options: {
+        node: true,
+        esversion: 6,
+        globalstrict: true,
+        '-W069': true
+      }
+    }
+  });
+
+  grunt.loadNpmTasks('grunt-contrib-jshint');
+
+  grunt.registerTask('default', [
+      'jshint'
+    ]);
+};
+

LICENSE

@@ -0,0 +1,25 @@
+Copyright (c) 2017, StackImpact GmbH. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the name of the StackImpact GmbH nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+

README.md

@@ -0,0 +1,99 @@
+# StackImpact Node.js Agent
+
+## Overview
+
+StackImpact is a performance profiler for production applications. It gives developers continuous and historical view of application performance with line-of-code precision, which includes CPU, memory allocation and blocking call hot spots as well as execution bottlenecks, errors and runtime metrics. Learn more at [stackimpact.com](https://stackimpact.com/).
+
+![dashboard](https://stackimpact.com/wp-content/uploads/2017/09/hotspots-cpu-1.4-nodejs.png)
+
+
+#### Features
+
+* Continuous hot spot profiling for CPU, memory allocations, blocking calls
+* Continuous bottleneck tracing for HTTP handlers and other libraries
+* Exception monitoring
+* Health monitoring including CPU, memory, garbage collection and other runtime metrics
+* Anomaly alerts on most important metrics
+* Multiple account users for team collaboration
+
+Learn more on the [features](https://stackimpact.com/features/) page (with screenshots).
+
+
+#### Documentation
+
+See full [documentation](https://stackimpact.com/docs/) for reference.
+
+
+
+## Supported environment
+
+* Linux, OS X or Windows. Node.js v4.0.0 or higher.
+* **CPU profiler is disabled by default for Node.js v7.0.0 and higher due to memory leak in underlying V8’s CPU profiler. To enable, add `cpuProfilerDisabled: false` to startup options.**
+* Allocation profiler supports Node.js v6.0.0 and higher. **The allocation profiler is disabled by default, since V8’s heap sampling is still experimental and is seen to result in segmentation faults. To enable, add `allocationProfilerDisabled: false` to startup options.**
+* Async profiler supports Node.js v8.1.0 and higher.
+
+
+## Getting started
+
+
+#### Create StackImpact account
+
+[Sign up](https://dashboard.stackimpact.com/#/signup) for a free account (also with GitHub login).
+
+
+#### Installing the agent
+
+Install the Node.js agent by running
+
+```
+npm install stackimpact
+```
+
+And import the package in your application
+
+```javascript
+const stackimpact = require('stackimpact');
+```
+
+
+#### Configuring the agent
+
+Start the agent in the main thread by specifying the agent key and application name. The agent key can be found in your account's Configuration section.
+
+```javascript
+let agent = stackimpact.start({
+  agentKey: 'agent key here',
+  appName = 'MyNodejsApp'
+});
+```
+
+All initialization options:
+
+* `agentKey` (Required) The API key for communication with the StackImpact servers.
+* `appName` (Required) A name to identify and group application data. Typically, a single codebase, deployable unit or executable module corresponds to one application.
+* `appVersion` (Optional) Sets application version, which can be used to associate profiling information with the source code release.
+* `appEnvironment` (Optional) Used to differentiate applications in different environments.
+* `hostName` (Optional) By default, host name will be the OS hostname.
+* `debug` (Optional) Enables debug logging.
+* `cpuProfilerDisabled`, `allocationProfilerDisabled`, `asyncProfilerDisabled`, `errorProfilerDisabled` (Optional) Disables respective profiler when `true`.
+* `includeAgentFrames` (Optional) Set to `true` to not exclude agent stack frames from profiles.
+
+
+#### Shutting down the agent
+
+Use `agent.destroy()` to stop the agent if necessary, e.g. to allow application to exit.
+
+
+#### Analyzing performance data in the Dashboard
+
+Once your application is restarted, you can start observing continuous CPU, memory, I/O, and other hot spot profiles, execution bottlenecks as well as process metrics in the [Dashboard](https://dashboard.stackimpact.com/).
+
+
+#### Troubleshooting
+
+To enable debug logging, add `debug: true` to startup options. If the debug log doesn't give you any hints on how to fix a problem, please report it to our support team in your account's Support section.
+
+
+## Overhead
+
+The agent overhead is measured to be less than 1% for applications under high load.

binding.gyp

@@ -0,0 +1,16 @@
+{
+  "targets": [
+    {
+      "target_name": "stackimpact-addon",
+      "sources": [
+        "src/stackimpact_addon.cc",
+        "src/heap_stats.cc",
+        "src/gc_stats.cc",
+        "src/event_loop_stats.cc",
+        "src/cpu_profiler.cc",
+        "src/allocation_sampler.cc"
+      ],
+      "include_dirs": ["<!(node -e \"require('nan')\")"]
+    }
+  ]
+}

examples/app.js

@@ -0,0 +1,142 @@
+const fs = require('fs');
+const http = require('http');
+const stackimpact = require('..');
+
+
+// StackImpact agent initialization
+let agent = stackimpact.start({
+  dashboardAddress: process.env.DASHBOARD_ADDRESS,
+  agentKey: process.env.AGENT_KEY,
+  appName: 'ExampleNodejsApp',
+  appVersion: '1.0.0',
+  cpuProfilerDisabled: false,
+  allocationProfilerDisabled: false,
+  debug: true
+});
+
+
+
+process.on('uncaughtException', (err) => {
+  // overwrites default exit behaviour
+  //console.log(err);
+});
+
+process.on('unhandledRejection', (err) => {
+  // overwrites default exit behaviour
+  //console.log(err);
+});
+
+
+function cpuWork(usage, duration) {
+  let usageTimer = setInterval(() => {
+    for(let i = 0; i < usage * 300000; i++) {
+      Math.random();
+    }
+  }, 1000);
+
+  if(duration) {
+    setTimeout(() => {
+      clearInterval(usageTimer);
+    }, duration * 1000);
+  }
+}
+
+
+function simulateCpu() {
+  cpuWork(15);
+
+  setInterval(() => {
+    cpuWork(50, 240);
+  }, 1200 * 1000);
+}
+
+
+function simulateMemLeak() {
+  let mem1 = [];
+  var n = 0;
+
+  // 30 min
+  setInterval(() => {
+    if(n++ > 1800) {
+      mem1 = [];
+      n = 0;
+    }
+
+    for(let i = 0; i < 10000; i++) {
+      obj1 = {'v': Math.random()};
+      mem1.push(obj1);
+    }
+  }, 1000);
+
+  // 5 sec
+  setInterval(() => {
+    let mem2 = [];
+    for(let i = 0; i < 1000; i++) {
+      obj2 = {'v': Math.random()};
+      mem2.push(obj2);
+    }
+  }, 5000);
+}
+
+
+function simulateHttp() {
+  setInterval(() => {
+
+    var options = {
+      host: '127.0.0.1',
+      port: 5005
+    };
+
+    var req = http.get(options, (res) => {
+    });
+
+    req.on('error', function(err) {
+      console.log(err.message);
+    });
+  }, 1000);
+}
+
+
+function simulateExceptions() {
+  setInterval(() => {
+    if(Math.random() > 0.2) {
+      setTimeout(() => {
+        throw new Error('some error ' + Math.round(Math.random() * 10));
+      }, 1);
+    }
+  }, 5 * 1000);
+}
+
+
+function simulateRejections() {
+  setInterval(() => {
+    if(Math.random() > 0.2) {
+      setTimeout(() => {
+        Promise.reject(new Error('some rejection'));
+      }, 1);
+    }
+  }, 5 * 1000);
+}
+
+
+const server = http.createServer((req, res) => {
+  fs.readFile('/tmp', () => {
+    setTimeout(() => {
+      cpuWork(10, 2);
+
+      res.statusCode = 200;
+      res.setHeader('Content-Type', 'text/plain');
+      res.end('Hello World\n');
+    }, 500);
+  });
+});
+
+server.listen(5005, '127.0.0.1', () => {
+  console.log('App running');
+
+  simulateCpu();
+  simulateMemLeak();
+  simulateHttp();
+  simulateExceptions();
+  simulateRejections();
+});

index.js

@@ -0,0 +1,13 @@
+let Agent = require('./lib/agent').Agent;
+
+
+let agent = null;
+
+exports.start = function(opts) {
+  if(!agent) {
+    agent = new Agent();
+  }
+
+  agent.start(opts);
+  return agent;
+};