overtake 0.0.1-rc1

package/LICENSE

@@ -0,0 +1,13 @@
+Copyright (c) 2022-present Ivan Zakharchanka
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

package/README.md

@@ -0,0 +1,105 @@
+# Overtake
+
+NodeJS performance benchmark
+
+[![Build Status][github-image]][github-url]
+[![NPM version][npm-image]][npm-url]
+[![Downloads][downloads-image]][npm-url]
+[![Coverage Status][codecov-image]][codecov-url]
+[![Maintainability][codeclimate-image]][codeclimate-url]
+[![Snyk][snyk-image]][snyk-url]
+
+## Table of Contents
+
+- [Features](#features)
+- [Installing](#installing)
+- [Examples](#examples)
+- [License](#license)
+
+## Features
+
+- CLI
+- TypeScript support
+- Running in thread worker
+
+## Installing
+
+Using yarn:
+
+```bash
+$ yarn add -D overtake
+```
+
+Using npm:
+
+```bash
+$ npm install -D overtake
+```
+
+## Examples
+
+Create a benchmark in `__benchmarks__` folder
+
+```javascript
+benchmark('mongodb vs postgres', () => {
+  // initialize a context for benchmark
+  setup(async () => {
+    const { Client } = await import('pg');
+    const postgres = new Client();
+    await postgres.connect();
+
+    const { MongoClient } = await import('mongob');
+    const mongo = new MongoClient(uri);
+    await mongo.connect();
+
+    return { postgres, mongo };
+  });
+
+  measure('mongodb inserts', ({ mongo }/* context */, next) => {
+    // prepare a collection
+    const database = mongo.db('overtake');
+    const test = database.collection('test');
+
+    return (data) => test.insertOne(data).then(next);
+  });
+
+  measure('postgres inserts', ({ postgres }/* context */, next) => {
+    // prepare a query
+    const query = 'INSERT INTO overtake(value) VALUES($1) RETURNING *';
+
+    return (data) => postgres.query(query, [data.value]).then(next);
+  });
+
+  teardown(({ mongo, postgres }) => {
+    await postgres.end()
+    await mongo.end()
+  });
+
+  perform('simple test', 100000, [
+    { value: 'test' },
+  ]);
+});
+```
+
+```bash
+yarn overtake
+```
+
+Please take a look at [benchmarks](__benchmarks__) to see more examples
+
+## License
+
+License [Apache-2.0](http://www.apache.org/licenses/LICENSE-2.0)
+Copyright (c) 2021-present Ivan Zakharchanka
+
+[npm-url]: https://www.npmjs.com/package/overtake
+[downloads-image]: https://img.shields.io/npm/dw/overtake.svg?maxAge=43200
+[npm-image]: https://img.shields.io/npm/v/overtake.svg?maxAge=43200
+[github-url]: https://github.com/3axap4eHko/overtake/actions/workflows/cicd.yml
+[github-image]: https://github.com/3axap4eHko/overtake/actions/workflows/cicd.yml/badge.svg
+[codecov-url]: https://codecov.io/gh/3axap4eHko/overtake
+[codecov-image]: https://codecov.io/gh/3axap4eHko/overtake/branch/master/graph/badge.svg?token=JZ8QCGH6PI
+[codeclimate-url]: https://codeclimate.com/github/3axap4eHko/overtake/maintainability
+[codeclimate-image]: https://api.codeclimate.com/v1/badges/0ba20f27f6db2b0fec8c/maintainability
+[snyk-url]: https://snyk.io/test/npm/overtake/latest
+[snyk-image]: https://img.shields.io/snyk/vulnerabilities/github/3axap4eHko/overtake.svg?maxAge=43200

package/cli.js

@@ -0,0 +1,28 @@
+#!/usr/bin/env node
+import Path from 'path';
+import glob from 'glob';
+import { benchmark, setup, teardown, measure, perform, suites, runner } from './index.js';
+
+const pattern = process.argv[2] || '**/__benchmarks__/**/*.js';
+
+Object.assign(globalThis, {
+  benchmark,
+  setup,
+  teardown,
+  measure,
+  perform,
+});
+
+glob(pattern, async (err, files) => {
+  try {
+    for (const file of files) {
+      const filepath = Path.resolve(file);
+      await import(filepath);
+    }
+  } catch (e) {
+    console.error(e.stack);
+  }
+  for (const suite of suites) {
+    await runner(suite);
+  }
+});

package/index.d.ts

@@ -0,0 +1,15 @@
+declare global {
+  declare function benchmark(title: string, init: () => void): void;
+
+  declare function setup<C>(init: () => C): any;
+
+  declare function teardown<C>(teardown: (context: C) => void): void;
+
+  declare function measure(title: string, init: (next: () => void) => void): void;
+  declare function measure<C>(title: string, init: (context: C, next: () => void) => void): void;
+  declare function measure<C, A>(title: string, init: (context: C, args: A, next: () => void) => void): void;
+
+  declare function perform<A>(title: string, counter: number, args: A): void;
+}
+
+export { benchmark, setup, teardown, measure, perform };

package/index.js

@@ -0,0 +1,223 @@
+import WorkerThreads from 'worker_threads';
+
+export const suites = [];
+
+const NOOP = () => {};
+
+const SPINNER = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏', '⠿'];
+const SPINNER_INTERVAL = 80;
+
+const ACCURACY = 6;
+
+const renderSpinner = (index) => {
+  process.stdout.moveCursor(0, -1);
+  process.stdout.write(SPINNER[index]);
+  process.stdout.moveCursor(-3, 1);
+};
+
+export function benchmark(title, init) {
+  const suite = {
+    title,
+    current: true,
+    measures: [],
+    performs: [],
+    setup: NOOP,
+    teardown: NOOP,
+  };
+  suites.push(suite);
+  init();
+  suite.current = false;
+}
+
+export function getSuite() {
+  const suite = suites[suites.length - 1];
+  if (!suite.current) {
+    throw new Error('should be inside benchmark');
+  }
+  return suite;
+}
+
+export function setup(init) {
+  const suite = getSuite();
+  suite.setup = init;
+}
+
+export function teardown(init) {
+  const suite = getSuite();
+  suite.teardown = init;
+}
+
+export function measure(title, init) {
+  const suite = getSuite();
+  suite.measures.push({ title, init });
+}
+
+export function perform(title, count, args) {
+  const suite = getSuite();
+  suite.performs.push({ title, count, args });
+}
+
+export function formatFloat(value, digits = ACCURACY) {
+  return parseFloat(value.toFixed(digits));
+}
+
+export async function runWorker({ args, count, ...options }) {
+  const setupCode = options.setup.toString();
+  const teardownCode = options.teardown.toString();
+  const initCode = options.init.toString();
+  const params = JSON.stringify({
+    setupCode,
+    teardownCode,
+    initCode,
+    count,
+    args,
+  });
+  let i = 0;
+  const spinnerSize = SPINNER.length - 1;
+
+  const timerId = setInterval(() => renderSpinner(i++ % spinnerSize), SPINNER_INTERVAL);
+
+  const worker = new WorkerThreads.Worker(new URL('runner.js', import.meta.url), { argv: [params] });
+  return new Promise((resolve) => {
+    worker.on('message', resolve);
+    worker.on('error', (error) => resolve({ success: false, error: error.message }));
+  }).finally((result) => {
+    clearInterval(timerId);
+    renderSpinner(spinnerSize);
+
+    return result;
+  });
+}
+
+export async function runner(suite) {
+  console.group(`\nStart ${suite.title} benchmark`);
+
+  for (let measureIdx = 0; measureIdx < suite.measures.length; measureIdx++) {
+    const currentMeasure = suite.measures[measureIdx];
+    const reports = {};
+    console.group(`\n  Measuring performance of ${currentMeasure.title}`);
+    for (let performIdx = 0; performIdx < suite.performs.length; performIdx++) {
+      const currentPerform = suite.performs[performIdx];
+      const report = await runWorker({
+        setup: suite.setup,
+        teardown: suite.teardown,
+        init: currentMeasure.init,
+        count: currentPerform.count,
+        args: currentPerform.args,
+      });
+      reports[currentPerform.title] = { title: perform.title, report };
+      if (report.success) {
+        reports[currentPerform.title] = {
+          Count: currentPerform.count,
+          'Setup, ms': formatFloat(report.setup),
+          'Work, ms': formatFloat(report.work),
+          'Avg, ms': formatFloat(report.avg),
+          'Mode, ms': report.mode,
+        };
+      } else {
+        reports[`${currentPerform.title} ${currentMeasure.title}`] = {
+          Count: currentPerform.count,
+          'Setup, ms': '?',
+          'Work, ms': '?',
+          'Avg, ms': '?',
+          'Mode, ms': '?',
+          Error: report.error,
+        };
+      }
+    }
+    console.groupEnd();
+    console.table(reports);
+  }
+  console.groupEnd();
+}
+
+const FALSE_START = () => {
+  throw new Error('False start');
+};
+
+export async function start(input) {
+  const { setupCode, teardownCode, initCode, count, args = [[]] } = JSON.parse(input);
+  const setup = Function(`return ${setupCode};`)();
+  const teardown = Function(`return ${teardownCode};`)();
+  const init = Function(`return ${initCode};`)();
+
+  let i = count;
+  let done = FALSE_START;
+
+  const timings = [];
+  const argSize = args.length;
+  const context = await setup();
+  const initArgs = [() => done()];
+  if (init.length > 2) {
+    initArgs.unshift(args);
+  }
+  if (init.length > 1) {
+    initArgs.unshift(context);
+  }
+  const startMark = performance.now();
+  const action = await init(...initArgs);
+  const workMark = performance.now();
+
+  try {
+    const loop = (resolve, reject) => {
+      const argIdx = i % argSize;
+      const timerId = setTimeout(reject, 10000, new Error('Timeout'));
+
+      done = () => {
+        // eslint-disable-next-line
+        const elapsed = performance.now() - startTickTime;
+        clearTimeout(timerId);
+        done = FALSE_START;
+        timings.push(elapsed);
+
+        resolve();
+      };
+      const startTickTime = performance.now();
+      action(...args[argIdx], count - i);
+    };
+
+    while (i--) {
+      await new Promise(loop);
+    }
+    const completeMark = performance.now();
+
+    await teardown(context);
+
+    timings.sort();
+
+    const {
+      mode: { time: mode },
+    } = timings
+      .map((time) => parseFloat(time.toFixed(ACCURACY)))
+      .reduce((result, time) => {
+        const value = (result[time] || 0) + 1;
+        const mode = !result.mode || result.mode.value < value ? { time, value } : result.mode;
+        return { ...result, [time]: value, mode };
+      }, {});
+
+    const min = timings.reduce((a, b) => Math.min(a, b), Infinity);
+    const max = timings.reduce((a, b) => Math.max(a, b), 0);
+    const avg = timings.reduce((a, b) => a + b, 0) / count;
+    const p90idx = parseInt(timings.length * 0.9, 10);
+    const p95idx = parseInt(timings.length * 0.95, 10);
+    const p99idx = parseInt(timings.length * 0.99, 10);
+    const p90 = timings[p90idx];
+    const p95 = timings[p95idx];
+    const p99 = timings[p99idx];
+
+    WorkerThreads.parentPort.postMessage({
+      min,
+      max,
+      avg,
+      p90,
+      p95,
+      p99,
+      mode,
+      setup: workMark - startMark,
+      work: completeMark - workMark,
+      success: true,
+    });
+  } catch (error) {
+    WorkerThreads.parentPort.postMessage({ success: false, error: error.stack });
+  }
+}

package/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "overtake",
+  "version": "0.0.1-rc1",
+  "description": "NodeJS performance benchmark",
+  "main": "index.js",
+  "types": "index.d.ts",
+  "type": "module",
+  "bin": {
+    "overtake": "cli.js"
+  },
+  "scripts": {
+    "measure": "node ./__runner__/class-vs-function.js",
+    "test": "yarn node --experimental-vm-modules $(yarn bin jest)",
+    "lint": "eslint .",
+    "prepare": "husky install"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/3axap4eHko/overtake.git"
+  },
+  "keywords": [
+    "benchmark",
+    "performance",
+    "measure",
+    "worker"
+  ],
+  "author": "Ivan Zakharchanka",
+  "license": "Apache-2.0",
+  "bugs": {
+    "url": "https://github.com/3axap4eHko/overtake/issues"
+  },
+  "homepage": "https://github.com/3axap4eHko/overtake#readme",
+  "devDependencies": {
+    "@jest/globals": "^27.5.1",
+    "@types/jest": "^27.4.1",
+    "eslint": "^8.14.0",
+    "eslint-config-airbnb-base": "^15.0.0",
+    "eslint-config-prettier": "^8.5.0",
+    "eslint-plugin-import": "^2.26.0",
+    "husky": "^7.0.4",
+    "jest": "^27.5.1",
+    "prettier": "^2.6.2",
+    "pretty-quick": "^3.1.3"
+  },
+  "dependencies": {
+    "glob": "^8.0.1"
+  }
+}

package/runner.js

@@ -0,0 +1,3 @@
+import { start } from './index.js';
+
+start(process.argv[2]);