Add hatchet fixtures

spec/fixtures/repos/node-10-metrics/Procfile

+web: node src/index.js

spec/fixtures/repos/node-10-metrics/package.json

+{
+  "name": "node-metrics-test-app",
+  "version": "1.0.0",
+  "engines": {
+    "node": "10.x"
+  },
+  "main": "index.js",
+  "license": "MIT",
+  "devDependencies": {},
+  "dependencies": {}
+}

spec/fixtures/repos/node-10-metrics/src/index.js

+#!/usr/bin/env node
+
+const http = require('http');
+const EventEmitter = require('events');
+
+const PORT = process.env.PORT || 5000;
+const Events = new EventEmitter();
+
+// This will block the event loop for ~lengths of time
+function blockCpuFor(ms) {
+  return new Promise((resolve, reject) => {
+    setTimeout(() => {
+      console.log(`blocking the event loop for ${ms}ms`);
+      let now = new Date().getTime();
+      let result = 0
+      while(true) {
+        result += Math.random() * Math.random();
+        if (new Date().getTime() > now + ms)
+          break;
+      }
+      resolve();
+    }, 100);
+  });
+}
+
+function getNextMetricsEvent() {
+  return new Promise((resolve, reject) => Events.once('metrics', resolve));
+}
+
+const server = http.createServer((req, res) => {
+  // wait for the next metrics event
+  getNextMetricsEvent()
+    .then(blockCpuFor(2000))
+    .then(blockCpuFor(100))
+    .then(blockCpuFor(100))
+    .then(blockCpuFor(100))
+    .then(blockCpuFor(100))
+    .then(blockCpuFor(100))
+    .then(blockCpuFor(100))
+    .then(blockCpuFor(100))
+    .then(blockCpuFor(100))
+    .then(blockCpuFor(100))
+    .then(blockCpuFor(100))
+    // gather the next metrics data which should include these pauses
+    .then(getNextMetricsEvent())
+    .then(data => {
+      res.setHeader('Content-Type', 'application/json');
+      res.end(data); 
+    })
+    .catch(() => {
+      res.statusCode = 500;
+      res.end("Something went wrong"); 
+    });
+});
+
+server.listen(PORT, () => console.log(`Listening on ${PORT}`));
+
+// Create a second server that intercepts the HTTP requests
+// sent by the metrics plugin
+const metricsListener = http.createServer((req, res) => {
+  if (req.method == 'POST') {
+    let body = '';
+    req.on('data', (data) => body += data);
+    req.on('end', () => Events.emit('metrics', body));
+    res.statusCode = 200;
+    res.end();
+  }
+});
+
+metricsListener.listen(3000, () => console.log('Listening for metrics on 3000'));
+

spec/fixtures/repos/node-10/Procfile

+web: node src/index.js

spec/fixtures/repos/node-10/app.json

+{
+  "name": "hello-world"
+}

spec/fixtures/repos/node-10/package.json

+{
+  "name": "hello-world",
+  "version": "1.0.0",
+  "engines": {
+    "node": "10.x"
+  },
+  "scripts": {
+    "prettify": "prettier --single-quote --trailing-comma all --write 'bin/*' 'src/**/*.js'",
+    "test": "jest --silent",
+    "dev": "nodemon --watch . --watch src/* src/index.js",
+    "heroku-postbuild": "echo NODE_OPTIONS: $NODE_OPTIONS"
+  },
+  "main": "index.js",
+  "license": "MIT",
+  "devDependencies": {
+    "jest": "^19.0.2",
+    "nodemon": "^1.11.0",
+    "prettier": "^0.22.0"
+  },
+  "dependencies": {}
+}

spec/fixtures/repos/node-10/src/index.js

+#!/usr/bin/env node
+
+const http = require('http');
+const crypto = require('crypto');
+
+const PORT = process.env.PORT || 5000;
+
+// This will block the event loop for ~lengths of time
+function blockCpuFor(ms) {
+	var now = new Date().getTime();
+	var result = 0
+	while(true) {
+		result += Math.random() * Math.random();
+		if (new Date().getTime() > now +ms)
+			return;
+	}
+}
+
+// block the event loop for 100ms every second
+setInterval(() => {
+  blockCpuFor(100);
+}, 1000)
+
+// block the event loop for 1sec every 30 seconds
+setInterval(() => {
+  blockCpuFor(1000);
+}, 30000)
+
+// Allocate and erase memory on an interval
+let store = [];
+
+setInterval(() => {
+  store.push(crypto.randomBytes(1000000).toString('hex'));
+}, 500);
+
+setInterval(() => {
+  store = [];
+}, 60000);
+
+const server = http.createServer((req, res) => {
+  res.statusCode = 200;
+  res.setHeader('Content-Type', 'text/plain');
+  res.end("Hello, world!");
+})
+
+server.listen(PORT, () => console.log(`Listening on ${PORT}`));

spec/fixtures/repos/node-6/Procfile

+web: node src/index.js

spec/fixtures/repos/node-6/app.json

+{
+  "name": "hello-world"
+}

spec/fixtures/repos/node-6/package.json

+{
+  "name": "hello-world",
+  "version": "1.0.0",
+  "engines": {
+    "node": "6.x"
+  },
+  "scripts": {
+    "prettify": "prettier --single-quote --trailing-comma all --write 'bin/*' 'src/**/*.js'",
+    "test": "jest --silent",
+    "dev": "nodemon --watch . --watch src/* src/index.js",
+    "heroku-postbuild": "echo NODE_OPTIONS: $NODE_OPTIONS"
+  },
+  "main": "index.js",
+  "license": "MIT",
+  "devDependencies": {
+    "jest": "^19.0.2",
+    "nodemon": "^1.11.0",
+    "prettier": "^0.22.0"
+  },
+  "dependencies": {}
+}

spec/fixtures/repos/node-6/src/index.js

+#!/usr/bin/env node
+
+const http = require('http');
+const crypto = require('crypto');
+
+const PORT = process.env.PORT || 5000;
+
+// This will block the event loop for ~lengths of time
+function blockCpuFor(ms) {
+	var now = new Date().getTime();
+	var result = 0
+	while(true) {
+		result += Math.random() * Math.random();
+		if (new Date().getTime() > now +ms)
+			return;
+	}
+}
+
+// block the event loop for 100ms every second
+setInterval(() => {
+  blockCpuFor(100);
+}, 1000)
+
+// block the event loop for 1sec every 30 seconds
+setInterval(() => {
+  blockCpuFor(1000);
+}, 30000)
+
+// Allocate and erase memory on an interval
+let store = [];
+
+setInterval(() => {
+  store.push(crypto.randomBytes(1000000).toString('hex'));
+}, 500);
+
+setInterval(() => {
+  store = [];
+}, 60000);
+
+const server = http.createServer((req, res) => {
+  res.statusCode = 200;
+  res.setHeader('Content-Type', 'text/plain');
+  res.end("Hello, world!");
+})
+
+server.listen(PORT, () => console.log(`Listening on ${PORT}`));

spec/fixtures/repos/node-8-metrics/Procfile

+web: node src/index.js

spec/fixtures/repos/node-8-metrics/package.json

+{
+  "name": "node-metrics-test-app",
+  "version": "1.0.0",
+  "engines": {
+    "node": "8.x"
+  },
+  "main": "index.js",
+  "license": "MIT",
+  "devDependencies": {},
+  "dependencies": {}
+}

spec/fixtures/repos/node-8-metrics/src/index.js

+#!/usr/bin/env node
+
+const http = require('http');
+const EventEmitter = require('events');
+
+const PORT = process.env.PORT || 5000;
+const Events = new EventEmitter();
+
+// This will block the event loop for ~lengths of time
+function blockCpuFor(ms) {
+  return new Promise((resolve, reject) => {
+    setTimeout(() => {
+      console.log(`blocking the event loop for ${ms}ms`);
+      let now = new Date().getTime();
+      let result = 0
+      while(true) {
+        result += Math.random() * Math.random();
+        if (new Date().getTime() > now + ms)
+          break;
+      }
+      resolve();
+    }, 100);
+  });
+}
+
+function getNextMetricsEvent() {
+  return new Promise((resolve, reject) => Events.once('metrics', resolve));
+}
+
+const server = http.createServer((req, res) => {
+  // wait for the next metrics event
+  getNextMetricsEvent()
+    .then(blockCpuFor(2000))
+    .then(blockCpuFor(100))
+    .then(blockCpuFor(100))
+    .then(blockCpuFor(100))
+    .then(blockCpuFor(100))
+    .then(blockCpuFor(100))
+    .then(blockCpuFor(100))
+    .then(blockCpuFor(100))
+    .then(blockCpuFor(100))
+    .then(blockCpuFor(100))
+    .then(blockCpuFor(100))
+    // gather the next metrics data which should include these pauses
+    .then(getNextMetricsEvent())
+    .then(data => {
+      res.setHeader('Content-Type', 'application/json');
+      res.end(data); 
+    })
+    .catch(() => {
+      res.statusCode = 500;
+      res.end("Something went wrong"); 
+    });
+});
+
+server.listen(PORT, () => console.log(`Listening on ${PORT}`));
+
+// Create a second server that intercepts the HTTP requests
+// sent by the metrics plugin
+const metricsListener = http.createServer((req, res) => {
+  if (req.method == 'POST') {
+    let body = '';
+    req.on('data', (data) => body += data);
+    req.on('end', () => Events.emit('metrics', body));
+    res.statusCode = 200;
+    res.end();
+  }
+});
+
+metricsListener.listen(3000, () => console.log('Listening for metrics on 3000'));
+

spec/fixtures/repos/node-8/Procfile

+web: node src/index.js

spec/fixtures/repos/node-8/app.json

+{
+  "name": "hello-world"
+}

spec/fixtures/repos/node-8/package.json

+{
+  "name": "hello-world",
+  "version": "1.0.0",
+  "engines": {
+    "node": "8.x"
+  },
+  "scripts": {
+    "prettify": "prettier --single-quote --trailing-comma all --write 'bin/*' 'src/**/*.js'",
+    "test": "jest --silent",
+    "dev": "nodemon --watch . --watch src/* src/index.js",
+    "heroku-postbuild": "echo NODE_OPTIONS: $NODE_OPTIONS"
+  },
+  "main": "index.js",
+  "license": "MIT",
+  "devDependencies": {
+    "jest": "^19.0.2",
+    "nodemon": "^1.11.0",
+    "prettier": "^0.22.0"
+  },
+  "dependencies": {}
+}

spec/fixtures/repos/node-8/src/index.js

+#!/usr/bin/env node
+
+const http = require('http');
+const crypto = require('crypto');
+
+const PORT = process.env.PORT || 5000;
+
+// This will block the event loop for ~lengths of time
+function blockCpuFor(ms) {
+	var now = new Date().getTime();
+	var result = 0
+	while(true) {
+		result += Math.random() * Math.random();
+		if (new Date().getTime() > now +ms)
+			return;
+	}
+}
+
+// block the event loop for 100ms every second
+setInterval(() => {
+  blockCpuFor(100);
+}, 1000)
+
+// block the event loop for 1sec every 30 seconds
+setInterval(() => {
+  blockCpuFor(1000);
+}, 30000)
+
+// Allocate and erase memory on an interval
+let store = [];
+
+setInterval(() => {
+  store.push(crypto.randomBytes(1000000).toString('hex'));
+}, 500);
+
+setInterval(() => {
+  store = [];
+}, 60000);
+
+const server = http.createServer((req, res) => {
+  res.statusCode = 200;
+  res.setHeader('Content-Type', 'text/plain');
+  res.end("Hello, world!");
+})
+
+server.listen(PORT, () => console.log(`Listening on ${PORT}`));

spec/fixtures/repos/node-9-metrics/Procfile

+web: node src/index.js

spec/fixtures/repos/node-9-metrics/package.json

+{
+  "name": "node-metrics-test-app",
+  "version": "1.0.0",
+  "engines": {
+    "node": "9.x"
+  },
+  "main": "index.js",
+  "license": "MIT",
+  "devDependencies": {},
+  "dependencies": {}
+}

spec/fixtures/repos/node-9-metrics/src/index.js

+#!/usr/bin/env node
+
+const http = require('http');
+const EventEmitter = require('events');
+
+const PORT = process.env.PORT || 5000;
+const Events = new EventEmitter();
+
+// This will block the event loop for ~lengths of time
+function blockCpuFor(ms) {
+  return new Promise((resolve, reject) => {
+    setTimeout(() => {
+      console.log(`blocking the event loop for ${ms}ms`);
+      let now = new Date().getTime();
+      let result = 0
+      while(true) {
+        result += Math.random() * Math.random();
+        if (new Date().getTime() > now + ms)
+          break;
+      }
+      resolve();
+    }, 100);
+  });
+}
+
+function getNextMetricsEvent() {
+  return new Promise((resolve, reject) => Events.once('metrics', resolve));
+}
+
+const server = http.createServer((req, res) => {
+  // wait for the next metrics event
+  getNextMetricsEvent()
+    .then(blockCpuFor(2000))
+    .then(blockCpuFor(100))
+    .then(blockCpuFor(100))
+    .then(blockCpuFor(100))
+    .then(blockCpuFor(100))
+    .then(blockCpuFor(100))
+    .then(blockCpuFor(100))
+    .then(blockCpuFor(100))
+    .then(blockCpuFor(100))
+    .then(blockCpuFor(100))
+    .then(blockCpuFor(100))
+    // gather the next metrics data which should include these pauses
+    .then(getNextMetricsEvent())
+    .then(data => {
+      res.setHeader('Content-Type', 'application/json');
+      res.end(data); 
+    })
+    .catch(() => {
+      res.statusCode = 500;
+      res.end("Something went wrong"); 
+    });
+});
+
+server.listen(PORT, () => console.log(`Listening on ${PORT}`));
+
+// Create a second server that intercepts the HTTP requests
+// sent by the metrics plugin
+const metricsListener = http.createServer((req, res) => {
+  if (req.method == 'POST') {
+    let body = '';
+    req.on('data', (data) => body += data);
+    req.on('end', () => Events.emit('metrics', body));
+    res.statusCode = 200;
+    res.end();
+  }
+});
+
+metricsListener.listen(3000, () => console.log('Listening for metrics on 3000'));
+

spec/fixtures/repos/node-9/Procfile

+web: node src/index.js

spec/fixtures/repos/node-9/app.json

+{
+  "name": "hello-world"
+}

spec/fixtures/repos/node-9/package.json

+{
+  "name": "hello-world",
+  "version": "1.0.0",
+  "engines": {
+    "node": "9.x"
+  },
+  "scripts": {
+    "prettify": "prettier --single-quote --trailing-comma all --write 'bin/*' 'src/**/*.js'",
+    "test": "jest --silent",
+    "dev": "nodemon --watch . --watch src/* src/index.js",
+    "heroku-postbuild": "echo NODE_OPTIONS: $NODE_OPTIONS"
+  },
+  "main": "index.js",
+  "license": "MIT",
+  "devDependencies": {
+    "jest": "^19.0.2",
+    "nodemon": "^1.11.0",
+    "prettier": "^0.22.0"
+  },
+  "dependencies": {}
+}

spec/fixtures/repos/node-9/src/index.js

+#!/usr/bin/env node
+
+const http = require('http');
+const crypto = require('crypto');
+
+const PORT = process.env.PORT || 5000;
+
+// This will block the event loop for ~lengths of time
+function blockCpuFor(ms) {
+	var now = new Date().getTime();
+	var result = 0
+	while(true) {
+		result += Math.random() * Math.random();
+		if (new Date().getTime() > now +ms)
+			return;
+	}
+}
+
+// block the event loop for 100ms every second
+setInterval(() => {
+  blockCpuFor(100);
+}, 1000)
+
+// block the event loop for 1sec every 30 seconds
+setInterval(() => {
+  blockCpuFor(1000);
+}, 30000)
+
+// Allocate and erase memory on an interval
+let store = [];
+
+setInterval(() => {
+  store.push(crypto.randomBytes(1000000).toString('hex'));
+}, 500);
+
+setInterval(() => {
+  store = [];
+}, 60000);
+
+const server = http.createServer((req, res) => {
+  res.statusCode = 200;
+  res.setHeader('Content-Type', 'text/plain');
+  res.end("Hello, world!");
+})
+
+server.listen(PORT, () => console.log(`Listening on ${PORT}`));