'use strict';
|
|
var assert = require('assert-plus');
|
var hrTimeDurationInMs = require('./utils/hrTimeDurationInMs');
|
|
/**
|
* Timing internals
|
*
|
* Timings are also saved when there is no handler in the given category.
|
* Some handler categories are optional, for example there is no
|
* `use` and `route` for 404.
|
*
|
* @private
|
*
|
* req._timeStart - request lifecycle started in restify
|
* req._timePreStart - pre handlers started
|
* req._timePreEnd - all pre handlers finished
|
* req._timeUseStart - use handlers started
|
* req._timeUseEnd - all use handlers finished
|
* req._timeRouteStart - route handlers started
|
* req._timeRouteEnd - all route handlers finished
|
* req._timeFlushed - request flushed, may happens before handlers finished
|
* req._timeFinished - both all handlers finished and request flushed
|
*/
|
|
///--- API
|
|
/**
|
* The module includes the following plugins to be used with restify's `after`
|
* event, e.g., `server.on('after', restify.plugins.metrics());`:
|
*
|
* A plugin that listens to the server's after event and emits information
|
* about that request.
|
*
|
* @public
|
* @function metrics
|
* @param {Object} opts - an options obj
|
* @param {Server} opts.server - restify server
|
* @param {createMetrics~callback} callback - a callback fn
|
* @returns {Function} returns a function suitable to be used
|
* with restify server's `after` event
|
* @example
|
* server.on('after', restify.plugins.metrics({ server: server },
|
* function (err, metrics, req, res, route) {
|
* // metrics is an object containing information about the request
|
* }));
|
*/
|
function createMetrics(opts, callback) {
|
assert.object(opts, 'opts');
|
assert.object(opts.server, 'opts.server');
|
assert.func(callback, 'callback');
|
|
return function metrics(req, res, route, err) {
|
var data = {
|
// response status code. in most cases this should be a proper
|
// http status code, but in the case of an uncaughtException it can
|
// be undefined. otherwise, in most normal scenarios, even calling
|
// res.send() or res.end() should result in a 200 by default.
|
statusCode: res.statusCode,
|
// REST verb
|
method: req.method,
|
// overall request latency
|
totalLatency: hrTimeDurationInMs(req._timeStart, req._timeFinished),
|
latency: hrTimeDurationInMs(req._timeStart, req._timeFlushed),
|
preLatency: hrTimeDurationInMs(req._timePreStart, req._timePreEnd),
|
useLatency: hrTimeDurationInMs(req._timeUseStart, req._timeUseEnd),
|
routeLatency: hrTimeDurationInMs(
|
req._timeRouteStart,
|
req._timeRouteEnd
|
),
|
// the cleaned up url path
|
// e.g., /foo?a=1 => /foo
|
path: req.path(),
|
// connection state can currently only have the following values:
|
// 'close' | undefined.
|
//
|
// if the connection state is 'close'
|
// the status code will be set to 444
|
// it is possible to get a 200 statusCode with a connectionState
|
// value of 'close'. i.e., the client timed out,
|
// but restify thinks it "sent" a response. connectionState should
|
// always be the primary source of truth here, and check it first
|
// before consuming statusCode. otherwise, it may result in skewed
|
// metrics.
|
connectionState: req.connectionState && req.connectionState(),
|
unfinishedRequests:
|
opts.server.inflightRequests && opts.server.inflightRequests(),
|
inflightRequests:
|
opts.server.inflightRequests && opts.server.inflightRequests()
|
};
|
|
return callback(err, data, req, res, route);
|
};
|
}
|
|
/**
|
* Callback used by metrics plugin
|
* @callback metrics~callback
|
* @param {Error} err
|
* @param {Object} metrics - metrics about the request
|
* @param {Number} metrics.statusCode status code of the response. can be
|
* undefined in the case of an uncaughtException
|
* @param {String} metrics.method http request verb
|
* @param {Number} metrics.totalLatency latency includes both request is flushed
|
* and all handlers finished
|
* @param {Number} metrics.latency latency when request is flushed
|
* @param {Number|null} metrics.preLatency pre handlers latency
|
* @param {Number|null} metrics.useLatency use handlers latency
|
* @param {Number|null} metrics.routeLatency route handlers latency
|
* @param {String} metrics.path `req.path()` value
|
* @param {Number} metrics.inflightRequests Number of inflight requests pending
|
* in restify.
|
* @param {Number} metrics.unifinishedRequests Same as `inflightRequests`
|
* @param {String} metrics.connectionState can be either `'close'` or
|
* `undefined`. If this value is set, err will be a
|
* corresponding `RequestCloseError`.
|
* If connectionState is either
|
* `'close'`, then the `statusCode` is not applicable since the
|
* connection was severed before a response was written.
|
* @param {Request} req the request obj
|
* @param {Response} res the response obj
|
* @param {Route} route the route obj that serviced the request
|
*/
|
|
///-- Exports
|
|
module.exports = createMetrics;
|
