autocannon

The Client object is passed to the setupClient option and the response event. Use it to dynamically mutate headers, bodies, or the entire request for each connection/request.

Methods:

• client.setHeaders(headers): Set request headers (Object or undefined to remove).
• client.setBody(body): Set request body (String, Buffer, or undefined to remove).
• client.setHeadersAndBody(headers, body): Set both simultaneously.
• client.setRequest(request): Mutate the entire request object (attributes: headers, body, method, path).
• client.setRequests(newRequests): Overwrite the entire requests array.

Client Events:

• headers: Emitted when request headers are received (passes Object).
• body: Emitted when response body is received (passes Buffer).
• response: Emitted when a complete response is received (passes statusCode, resBytes, responseTime).
• reset: Emitted when the requests pipeline was reset.

'use strict'

const autocannon = require('autocannon')

const instance = autocannon({
  url: 'http://localhost:3000',
  setupClient: setupClient
}, (err, result) => handleResults(result))

instance.on('done', handleResults)
instance.on('tick', () => console.log('ticking'))
instance.on('response', handleResponse)

function setupClient (client) {
  client.on('body', console.log) // log response body
}

function handleResponse (client, statusCode, resBytes, responseTime) {
  console.log(`Got response with code ${statusCode} in ${responseTime} milliseconds`)
  
  // update the body or headers for the next request
  client.setHeaders({new: 'header'})
  client.setBody('new body')
  client.setHeadersAndBody({new: 'header'}, 'new body')
}

function handleResults(result) {
  // ...
}

Start a benchmark against a target URL by calling autocannon(opts[, cb]).

Parameters:

• opts: Configuration object (Required).
• cb: Callback function called on completion. Receives (err, results).

If cb is omitted, the function returns an EventEmitter instance that can also be used as a Promise.

Key Configuration Options (opts):

• url (Required): The target HTTP or HTTPS URL. Multiple URLs are allowed.
• connections: Number of concurrent connections (default: 10).
• duration: Seconds to run (default: 10). Can be a timestring.
• amount: Total number of requests to make. Overrides duration.
• method: HTTP method (default: 'GET').
• headers: Object containing request headers.
• body: String or Buffer for the request body. Use [<id>] for random ID replacement if idReplacement: true is set.
• workers: Number of worker threads.
• pipelining: Number of pipelined requests per connection (default: 1).
• overallRate: Rate of requests per second from all connections.
• connectionRate: Rate of requests per second from each individual connection.
• idReplacement: Boolean to enable [<id>] tag replacement in the body (default: false).
• forever: Boolean to restart the instance indefinitely after the done event (default: false).

Use autocannon.track(instance, opts) to programmatically monitor the progress of an active benchmark instance. This is useful for rendering progress bars or tables to the terminal.

Options (opts):

• outputStream: Stream to output to (default: process.stderr).
• renderProgressBar: Enable/disable progress bar (default: true).
• renderResultsTable: Enable/disable results table on completion (default: true).
• renderLatencyTable: Enable/disable advanced latency table (default: false).
• progressBarString: Format for the progress display (must be valid progress module syntax).

'use strict'

const autocannon = require('autocannon')

const instance = autocannon({
  url: 'http://localhost:3000'
}, console.log)

// this is used to kill the instance on CTRL-C
process.once('SIGINT', () => {
  instance.stop()
})

// just render results
autocannon.track(instance, {renderProgressBar: false})