DEV Community

Cover image for Benchmarking Tests in Node.js API: A Comprehensive Guide
Wallace Freitas
Wallace Freitas

Posted on

Benchmarking Tests in Node.js API: A Comprehensive Guide

Understanding the performance characteristics of your Node.js API requires benchmarking. It aids in the identification of bottlenecks, code optimization, and assurance that your API can manage the necessary traffic. This post will discuss benchmarking tests in a Node.js API, including both simple and complex methods with real-world examples.

🤨 Why Benchmarking is Important
Before diving into the implementation, it's crucial to understand why benchmarking is so valuable:

↳ Performance Optimization: Benchmarking helps you identify slow endpoints or functions that need optimization.

↳ Scalability Testing: It lets you see how your API handles varying loads to make sure it scales properly.

↳ Baseline Establishment: It gives you a performance baseline to gauge how infrastructure improvements or code modifications affect things.

↳ Improved User Experience: You may provide your users with a faster and more responsive API by detecting and fixing performance issues.

🏎️ Setting Up a Basic Node.js API for Benchmarking

To get started, let's set up a simple Node.js API that we'll use for our benchmarking tests.

Step 1: Create a Simple Express API

First, create a new Node.js project and install Express:

mkdir nodejs-benchmarking
cd nodejs-benchmarking
npm init -y
npm install express
Enter fullscreen mode Exit fullscreen mode

Next, create an index.js file with a basic Express server:

const express = require('express');
const app = express();

app.get('/fast-endpoint', (req, res) => {
    res.send('This is a fast endpoint!');
});

app.get('/slow-endpoint', (req, res) => {
    setTimeout(() => {
        res.send('This is a slow endpoint!');
    }, 500);
});

const PORT = process.env.PORT || 3000;
app.listen(PORT, () => {
    console.log(`Server is running on port ${PORT}`);
});
Enter fullscreen mode Exit fullscreen mode

In this example, we have two endpoints: /fast-endpoint and /slow-endpoint. The /slow-endpoint simulates a slow response by introducing a 500ms delay.

🚀 Benchmarking with autocannon

One of the most popular tools for benchmarking Node.js APIs is autocannon. It's fast, easy to use, and can handle a large number of concurrent requests.

Step 2: Install autocannon

You can install autocannon globally or as a development dependency:

npm install -g autocannon
Enter fullscreen mode Exit fullscreen mode

Step 3: Running a Benchmark Test

To run a benchmark test against our API, use the following command:

autocannon -d 10 -c 50 http://localhost:3000/fast-endpoint

-d 10: Duration of the test in seconds.
-c 50: Number of concurrent connections.
Enter fullscreen mode Exit fullscreen mode

This command will send 50 concurrent requests to the /fast-endpoint for 10 seconds.

Step 4: Analyzing the Results

The results from autocannon will look something like this:

Running 10s test @ http://localhost:3000/fast-endpoint
50 connections

Stat         Avg    Stdev   Max
Latency (ms) 5.32   3.02    47
Req/Sec      9221   187.5   9499
Bytes/Sec    1.79 MB        38.5 kB

90194 requests in 10.02s, 17.9 MB read
Latency: The time taken for a request to be processed.
Req/Sec: The number of requests processed per second.
Bytes/Sec: The amount of data transferred per second.
Enter fullscreen mode Exit fullscreen mode

From these metrics, you can see how well your API performs under load and identify areas that need improvement.

📈 Advanced Benchmarking with wrk

For more advanced benchmarking, you might want to use wrk, a modern HTTP benchmarking tool that provides more flexibility and control over your tests.

Step 5: Install wrk

You can install wrk using Homebrew on macOS:

brew install work
Enter fullscreen mode Exit fullscreen mode

Step 6: Running a Benchmark with wrk

Here's how to run a simple benchmark with wrk:

wrk -t12 -c400 -d30s http://localhost:3000/slow-endpoint

-t12: Number of threads to use.
-c400: Number of open connections.
-d30s: Duration of the test.
Enter fullscreen mode Exit fullscreen mode

Step 7: Interpreting wrk Results

The output from wrk will provide you with detailed statistics about the request latency, throughput, and more:

Running 30s test @ http://localhost:3000/slow-endpoint
  12 threads and 400 connections
  Thread Stats   Avg      Stdev     Max   +/- Stdev
    Latency    44.32ms   13.22ms  88.95ms   55.12%
    Req/Sec   758.66     32.37    83.25    73.41%
  227547 requests in 30.02s, 22.47MB read
  Requests/sec:   7582.03
  Transfer/sec:    788.93KB
Enter fullscreen mode Exit fullscreen mode

This output gives you a more comprehensive view of your API's performance under heavier load conditions.

Optimizing Your Node.js API Based on Benchmarking Results

After running your benchmarks, you may identify certain performance bottlenecks. Here are some common strategies to optimize your Node.js API:

1. Use Caching
Implement caching for frequently requested data to reduce the load on your server.

Example: Caching with node-cache

const NodeCache = require('node-cache');
const myCache = new NodeCache();

app.get('/cached-endpoint', (req, res) => {
    const cachedData = myCache.get('key');

    if (cachedData) {
        return res.send(cachedData);
    }

    const data = "Expensive Operation Result";
    myCache.set('key', data, 60); // Cache for 60 seconds
    res.send(data);
});
Enter fullscreen mode Exit fullscreen mode

2. Optimize Database Queries

Database queries can be a significant source of latency. Optimize your queries by indexing, avoiding N+1 queries, and using connection pooling.

Example: Optimizing a Database Query

app.get('/optimized-query', async (req, res) => {
    const users = await db.query('SELECT * FROM users WHERE active = true LIMIT 100');
    res.send(users);
});
Enter fullscreen mode Exit fullscreen mode

3. Reduce Middleware Overhead

Review your middleware stack and ensure that only necessary middleware is applied to each route.

Example: Selective Middleware Application

const authenticate = require('./middleware/authenticate');

app.get('/protected-endpoint', authenticate, (req, res) => {
    res.send('This is a protected endpoint!');
});

app.get('/public-endpoint', (req, res) => {
    res.send('This is a public endpoint!');
});
Enter fullscreen mode Exit fullscreen mode

4. Use Asynchronous Programming

Take advantage of Node.js's non-blocking I/O model by using asynchronous programming techniques like async/await.

Example: Asynchronous Route Handling

app.get('/async-endpoint', async (req, res) => {
    try {
        const data = await someAsyncFunction();
        res.send(data);
    } catch (err) {
        res.status(500).send('Something went wrong!');
    }
});
Enter fullscreen mode Exit fullscreen mode

A crucial step in making sure your Node.js API functions at its best under different loads is benchmarking. You can find areas for improvement and obtain useful insights about the performance of your API by utilizing tools like as autocannon and wrk. Building quicker, more scalable apps can be achieved by implementing optimizations like caching, database query optimization, middleware overhead reduction, and asynchronous programming once your API has been benchmarked.

To make sure your Node.js API can handle user demands and scales well as your application grows, start benchmarking it right away.

Reference:

https://assets.toptal.io/images?url=https%3A%2F%2Fbs-uploads.toptal.io%2Fblackfish-uploads%2Fcomponents%2Fblog_post_page%2F4085508%2Fcover_image%2Fregular_1708x683%2Fcover-secure-rest-api-in-nodejs-360b1ec113164955f21196433cb1e125.png

Top comments (0)