or run

npx @tessl/cli init
Log in

Version

Tile

Overview

Evals

Files

docs

index.md
tile.json

tessl/npm-response-time

Response time middleware for Node.js servers that measures and reports HTTP request duration

Workspace
tessl
Visibility
Public
Created
Last updated
Describes
npmpkg:npm/response-time@2.3.x

To install, run

npx @tessl/cli install tessl/npm-response-time@2.3.0

index.mddocs/

Response Time

Response Time is a Node.js middleware library that measures and reports HTTP request response times. It creates middleware that records the elapsed time from when a request enters the middleware to when the response headers are written out to the client.

Package Information

  • Package Name: response-time
  • Package Type: npm
  • Language: JavaScript
  • Installation: npm install response-time

Core Imports

const responseTime = require('response-time');

Basic Usage

const express = require('express');
const responseTime = require('response-time');

const app = express();

// Add X-Response-Time header automatically
app.use(responseTime());

app.get('/', (req, res) => {
  res.send('hello, world!');
});

app.listen(3000);

Capabilities

Automatic Header Mode

Creates middleware that automatically adds an X-Response-Time header to responses.

/**
 * Create middleware that adds X-Response-Time header displaying response duration
 * @param {ResponseTimeOptions} [options] - Configuration options
 * @returns {Function} Express/Connect middleware function
 */
function responseTime(options?: ResponseTimeOptions): MiddlewareFunction;

Usage Examples:

const express = require('express');
const responseTime = require('response-time');

const app = express();

// Default options (3 digits, X-Response-Time header, ms suffix)
app.use(responseTime());

// Custom precision
app.use(responseTime({ digits: 5 }));

// Custom header name  
app.use(responseTime({ header: 'X-Time-Taken' }));

// No suffix
app.use(responseTime({ suffix: false }));

// Combined options
app.use(responseTime({
  digits: 2,
  header: 'X-Processing-Time',
  suffix: true
}));

Custom Callback Mode

Creates middleware that measures response time and calls a custom function with the timing data.

/**
 * Create middleware that records response time and calls custom callback
 * @param {ResponseTimeCallback} fn - Callback function receiving timing data
 * @returns {Function} Express/Connect middleware function
 */
function responseTime(fn: ResponseTimeCallback): MiddlewareFunction;

Usage Examples:

const express = require('express');
const responseTime = require('response-time');
const StatsD = require('node-statsd');

const app = express();
const stats = new StatsD();

// Custom metrics collection
app.use(responseTime((req, res, time) => {
  const stat = (req.method + req.url).toLowerCase()
    .replace(/[:.]/g, '')
    .replace(/\//g, '_');
  stats.timing(stat, time);
}));

// Logging response times
app.use(responseTime((req, res, time) => {
  console.log(`${req.method} ${req.url} - ${time}ms`);
}));

// Conditional processing
app.use(responseTime((req, res, time) => {
  if (time > 1000) {
    console.warn(`Slow request: ${req.method} ${req.url} took ${time}ms`);
  }
}));

Vanilla HTTP Server Usage

Response-time can be used with vanilla Node.js HTTP servers without Express.

Usage Example:

const http = require('http');
const finalhandler = require('finalhandler');
const responseTime = require('response-time');

// Create middleware instance
const _responseTime = responseTime();

http.createServer((req, res) => {
  const done = finalhandler(req, res);
  
  _responseTime(req, res, (err) => {
    if (err) return done(err);
    
    // Respond to request
    res.setHeader('content-type', 'text/plain');
    res.end('hello, world!');
  });
}).listen(3000);

Types

/**
 * Configuration options for automatic header mode
 */
interface ResponseTimeOptions {
  /** Number of decimal digits in output (default: 3) */
  digits?: number;
  /** Name of response header to set (default: 'X-Response-Time') */  
  header?: string;
  /** Whether to add 'ms' suffix to output (default: true) */
  suffix?: boolean;
}

/**
 * Callback function for custom response time handling
 * @param req - HTTP request object
 * @param res - HTTP response object  
 * @param time - Response time in milliseconds
 */
type ResponseTimeCallback = (req: any, res: any, time: number) => void;

/**
 * Express/Connect middleware function signature
 * @param req - HTTP request object
 * @param res - HTTP response object
 * @param next - Next middleware function
 */
type MiddlewareFunction = (req: any, res: any, next: Function) => void;

Backward Compatibility

The library supports a deprecated single number argument for backwards compatibility:

// Deprecated - triggers deprecation warning
app.use(responseTime(3));

// Equivalent modern usage
app.use(responseTime({ digits: 3 }));

Error Handling

Response-time follows standard Express middleware error handling patterns. If an error occurs, it will be passed to the next middleware via the next(err) function.

Integration Patterns

Express Application

const express = require('express');
const responseTime = require('response-time');

const app = express();

// Apply to all routes
app.use(responseTime());

app.get('/api/users', (req, res) => {
  // Your route logic
  res.json({ users: [] });
});

Connect Application

const connect = require('connect');
const responseTime = require('response-time');

const app = connect();

app.use(responseTime());
app.use((req, res) => {
  res.end('Hello World');
});