@depup/elastic-apm-node 4.15.0-depup.0

package/lib/instrumentation/modules/express.js

@@ -0,0 +1,162 @@
+/*
+ * Copyright Elasticsearch B.V. and other contributors where applicable.
+ * Licensed under the BSD 2-Clause License; you may not use this file except in
+ * compliance with the BSD 2-Clause License.
+ */
+
+'use strict';
+
+var isError = require('core-util-is').isError;
+var semver = require('semver');
+
+var shimmer = require('../shimmer');
+var symbols = require('../../symbols');
+
+module.exports = function (express, agent, { version, enabled }) {
+  if (!enabled) return express;
+
+  agent.setFramework({ name: 'express', version, overwrite: false });
+
+  if (!semver.satisfies(version, '>=4.0.0 <6')) {
+    agent.logger.debug('cannot instrument express version %s', version);
+    return express;
+  }
+
+  if (
+    semver.satisfies(version, '>5') &&
+    semver.satisfies(process.version, '<18')
+  ) {
+    agent.logger.debug(
+      'express version %s not supported for node version %s, skipping express instrumentation',
+      version,
+      process.version,
+    );
+    return express;
+  }
+
+  // express 5 moves the router methods onto a prototype
+  var routerProto = semver.satisfies(version, '^5')
+    ? express.Router && express.Router.prototype
+    : express.Router;
+
+  var layerPatchedSymbol = Symbol('layer-patched');
+
+  function shouldReport(err) {
+    if (!agent._conf.captureExceptions) return false;
+    if (typeof err === 'string') return true;
+    if (isError(err) && !err[symbols.errorReportedSymbol]) {
+      err[symbols.errorReportedSymbol] = true;
+      return true;
+    }
+    return false;
+  }
+
+  function safePush(obj, prop, value) {
+    if (!obj[prop]) obj[prop] = [];
+    obj[prop].push(value);
+  }
+
+  function patchLayer(layer, layerPath) {
+    if (!layer[layerPatchedSymbol]) {
+      layer[layerPatchedSymbol] = true;
+      agent.logger.debug(
+        'shimming express.Router.Layer.handle function: %s',
+        layer.name,
+      );
+      shimmer.wrap(layer, 'handle', function (orig) {
+        let handle;
+
+        if (orig.length !== 4) {
+          handle = function (req, res, next) {
+            if (!layer.route && layerPath && typeof next === 'function') {
+              safePush(req, symbols.expressMountStack, layerPath);
+              arguments[2] = function (nextArg) {
+                // https://github.com/expressjs/express/blob/4.18.1/lib/router/route.js#L116-L149
+                // The argument to an Express handler's `next()` can be:
+                // falsey (call the next handler), 'route' (skip handlers for
+                // this route), 'router' (skip handlers for this Router), or
+                // any other value is considered an error (it doesn't have to
+                // be an instance of Error). For all but the last one, Express
+                // will consider other routes, so we want to pop the mount
+                // stack.
+                if (!nextArg || nextArg === 'route' || nextArg === 'router') {
+                  req[symbols.expressMountStack].pop();
+                }
+                return next.apply(this, arguments);
+              };
+            }
+
+            return orig.apply(this, arguments);
+          };
+        } else {
+          handle = function (err, req, res, next) {
+            if (shouldReport(err)) {
+              agent.captureError(err, { request: req });
+            }
+            return orig.apply(this, arguments);
+          };
+        }
+
+        for (const prop in orig) {
+          if (Object.prototype.hasOwnProperty.call(orig, prop)) {
+            handle[prop] = orig[prop];
+          }
+        }
+
+        return handle;
+      });
+    }
+  }
+
+  agent.logger.debug('shimming express.Router.use function');
+
+  shimmer.wrap(routerProto, 'route', (orig) => {
+    return function route(path) {
+      var route = orig.apply(this, arguments);
+      var layer = this.stack[this.stack.length - 1];
+      patchLayer(layer, path);
+      return route;
+    };
+  });
+
+  shimmer.wrap(routerProto, 'use', (orig) => {
+    return function use(path) {
+      var route = orig.apply(this, arguments);
+      var layer = this.stack[this.stack.length - 1];
+      patchLayer(layer, typeof path === 'string' && path);
+      return route;
+    };
+  });
+
+  agent.logger.debug('shimming express.static function');
+
+  shimmer.wrap(express, 'static', function wrapStatic(orig) {
+    // By the time of this writing, Express adds a `mime` property to the
+    // `static` function that needs to be copied to the wrapped function.
+    // Instead of only copying the `mime` function, let's loop over all
+    // properties in case new properties are added in later versions of
+    // Express.
+    for (const prop of Object.keys(orig)) {
+      agent.logger.debug('copying property %s from express.static', prop);
+      wrappedStatic[prop] = orig[prop];
+    }
+
+    return wrappedStatic;
+
+    function wrappedStatic() {
+      var origServeStatic = orig.apply(this, arguments);
+      return function serveStatic(req, res, next) {
+        req[symbols.staticFile] = true;
+
+        return origServeStatic(req, res, nextHook);
+
+        function nextHook(err) {
+          if (!err) req[symbols.staticFile] = false;
+          return next.apply(this, arguments);
+        }
+      };
+    }
+  });
+
+  return express;
+};

package/lib/instrumentation/modules/fastify.js

@@ -0,0 +1,172 @@
+/*
+ * Copyright Elasticsearch B.V. and other contributors where applicable.
+ * Licensed under the BSD 2-Clause License; you may not use this file except in
+ * compliance with the BSD 2-Clause License.
+ */
+
+'use strict';
+
+// Instrumentation of fastify.
+// https://www.fastify.io/docs/latest/LTS/
+
+const semver = require('semver');
+
+// Return the fastify route or request method, without hitting a Fastify
+// deprecation warning.
+// https://fastify.dev/docs/latest/Reference/Warnings/#FSTDEP018
+function fastifyRouteMethod(req) {
+  if (req.routeOptions) {
+    // `.routeOptions` was added in fastify@4.10.0.
+    return req.routeOptions.method;
+  } else {
+    return req.routerMethod || req.raw.method; // Fallback for fastify >3 <3.3.0
+  }
+}
+
+// Return the fastify route or request URL, without hitting a Fastify
+// deprecation warning.
+// https://fastify.dev/docs/latest/Reference/Warnings/#FSTDEP017
+function fastifyRouteUrl(req, reply) {
+  if (req.routeOptions) {
+    // `.routeOptions` was added in fastify@4.10.0.
+    // Note that `.routeOptions.url` might be undefined for a 404 route.
+    return req.routeOptions.url;
+  } else {
+    return req.routerPath || reply.context.config.url; // Fallback for fastify >3 <3.3.0
+  }
+}
+
+module.exports = function (
+  modExports,
+  agent,
+  { version, enabled, isImportMod },
+) {
+  if (!enabled) {
+    return modExports;
+  }
+  if (isImportMod && !semver.satisfies(version, '>=3.5.0')) {
+    // https://github.com/fastify/fastify/pull/2590
+    agent.logger.debug(
+      'ESM instrumentation of fastify requires fastify >=3.5.0, skipping instrumentation',
+    );
+    return modExports;
+  }
+
+  agent.setFramework({ name: 'fastify', version, overwrite: false });
+
+  agent.logger.debug('wrapping fastify build function');
+  const origFastify = isImportMod ? modExports.default : modExports;
+
+  var wrapper;
+  if (semver.gte(version, '3.0.0')) {
+    wrapper = wrappedFastify;
+  } else if (semver.gte(version, '2.0.0-rc')) {
+    wrapper = wrappedFastify2;
+  } else {
+    wrapper = wrappedFastify1;
+  }
+
+  // Assign all enumerable properties to the wrapper.
+  // - 'fastify' and 'default' are intentionally circular references to
+  //   support various import/require styles. See:
+  //   https://github.com/fastify/fastify/blob/v4.17.0/fastify.js#L814-L827
+  for (var prop in origFastify) {
+    switch (prop) {
+      case 'fastify':
+      case 'default':
+        wrapper[prop] = wrapper;
+        break;
+      default:
+        wrapper[prop] = origFastify[prop];
+        break;
+    }
+  }
+
+  if (isImportMod) {
+    modExports.fastify = wrapper;
+    modExports.default = wrapper;
+    return modExports;
+  } else {
+    return wrapper;
+  }
+
+  function wrappedFastify() {
+    const _fastify = origFastify.apply(null, arguments);
+
+    agent.logger.debug('adding onRequest hook to fastify');
+    _fastify.addHook('onRequest', (req, reply, next) => {
+      const method = fastifyRouteMethod(req);
+      const url = fastifyRouteUrl(req, reply);
+      const name = method + ' ' + url;
+      agent._instrumentation.setDefaultTransactionName(name);
+      next();
+    });
+
+    agent.logger.debug('adding preHandler hook to fastify');
+    _fastify.addHook('preHandler', (req, reply, next) => {
+      // Save the parsed req body to be picked up by getContextFromRequest().
+      req.raw.body = req.body;
+      next();
+    });
+
+    agent.logger.debug('adding onError hook to fastify');
+    _fastify.addHook('onError', (req, reply, err, next) => {
+      agent.captureError(err, { request: req.raw });
+      next();
+    });
+
+    return _fastify;
+  }
+
+  function wrappedFastify2() {
+    const _fastify = origFastify.apply(null, arguments);
+
+    agent.logger.debug('adding onRequest hook to fastify');
+    _fastify.addHook('onRequest', (req, reply, next) => {
+      const context = reply.context;
+      const name = req.raw.method + ' ' + context.config.url;
+      agent._instrumentation.setDefaultTransactionName(name);
+      next();
+    });
+
+    agent.logger.debug('adding preHandler hook to fastify');
+    _fastify.addHook('preHandler', (req, reply, next) => {
+      // Save the parsed req body to be picked up by getContextFromRequest().
+      req.raw.body = req.body;
+      next();
+    });
+
+    agent.logger.debug('adding onError hook to fastify');
+    _fastify.addHook('onError', (req, reply, err, next) => {
+      agent.captureError(err, { request: req.raw });
+      next();
+    });
+
+    return _fastify;
+  }
+
+  function wrappedFastify1() {
+    const _fastify = origFastify.apply(null, arguments);
+
+    agent.logger.debug('adding onRequest hook to fastify');
+    _fastify.addHook('onRequest', (req, reply, next) => {
+      const context = reply._context;
+      const name = req.method + ' ' + context.config.url;
+      agent._instrumentation.setDefaultTransactionName(name);
+      next();
+    });
+
+    agent.logger.debug('adding preHandler hook to fastify');
+    _fastify.addHook('preHandler', (req, reply, next) => {
+      // Save the parsed req body to be picked up by getContextFromRequest().
+      req.raw.body = req.body;
+      next();
+    });
+
+    agent.logger.warn(
+      'Elastic APM cannot automaticaly capture errors on this verison of Fastify. Upgrade to version 2.0.0 or later.',
+    );
+
+    return _fastify;
+  }
+};

package/lib/instrumentation/modules/finalhandler.js

@@ -0,0 +1,41 @@
+/*
+ * Copyright Elasticsearch B.V. and other contributors where applicable.
+ * Licensed under the BSD 2-Clause License; you may not use this file except in
+ * compliance with the BSD 2-Clause License.
+ */
+
+'use strict';
+
+// Instrumentation of https://www.npmjs.com/package/finalhandler
+// This will `apm.captureError` any error passed to the finalhandler.
+//
+// Both 'express' and 'connect' use finalhandler, so this effectively handles
+// capturing errors from incoming request handlers for Express and Connect apps.
+// The `errorReportedSymbol` symbol is used to coordinate with 'express'
+// instrumentation to avoid double-reporting errors.
+
+var isError = require('core-util-is').isError;
+
+var symbols = require('../../symbols');
+
+function shouldReport(err) {
+  if (typeof err === 'string') return true;
+  if (isError(err) && !err[symbols.errorReportedSymbol]) {
+    err[symbols.errorReportedSymbol] = true;
+    return true;
+  }
+  return false;
+}
+
+module.exports = function (finalhandler, agent) {
+  return function wrappedFinalhandler(req, res, options) {
+    var final = finalhandler.apply(this, arguments);
+
+    return function (err) {
+      if (shouldReport(err)) {
+        agent.captureError(err, { request: req });
+      }
+      return final.apply(this, arguments);
+    };
+  };
+};

package/lib/instrumentation/modules/generic-pool.js

@@ -0,0 +1,85 @@
+/*
+ * Copyright Elasticsearch B.V. and other contributors where applicable.
+ * Licensed under the BSD 2-Clause License; you may not use this file except in
+ * compliance with the BSD 2-Clause License.
+ */
+
+'use strict';
+
+var semver = require('semver');
+
+var shimmer = require('../shimmer');
+
+module.exports = function (generic, agent, { version }) {
+  if (semver.satisfies(version, '^2.0.0')) {
+    agent.logger.debug('shimming generic-pool.Pool');
+    shimmer.wrap(generic, 'Pool', function (orig) {
+      return function wrappedPool() {
+        var trans = agent._instrumentation.currTransaction();
+        var id = trans && trans.id;
+        agent.logger.debug('intercepted call to generic-pool.Pool %o', { id });
+
+        var pool;
+        if (this instanceof generic.Pool) {
+          var args = [].slice.call(arguments);
+          args.unshift(null);
+          pool = new (Function.prototype.bind.apply(orig, args))();
+        } else {
+          pool = orig.apply(this, arguments);
+        }
+
+        shimmer.wrap(pool, 'acquire', function (orig) {
+          return function wrappedAcquire() {
+            var trans = agent._instrumentation.currTransaction();
+            var id = trans && trans.id;
+            agent.logger.debug('intercepted call to pool.acquire %o', { id });
+
+            var cb = arguments[0];
+            if (typeof cb === 'function') {
+              arguments[0] = agent._instrumentation.bindFunction(cb);
+            }
+
+            return orig.apply(this, arguments);
+          };
+        });
+
+        return pool;
+      };
+    });
+  } else if (semver.satisfies(version, '^3.1.0') && generic.PriorityQueue) {
+    // A work-around as an alternative patching the returned promise from the
+    // acquire function, we instead patch its resolve and reject functions.
+    //
+    // We can do that because they are exposed to the PriorityQueue when
+    // enqueuing a ResourceRequest:
+    //
+    // https://github.com/coopernurse/node-pool/blob/58c275c5146977192165f679e86950396be1b9f1/lib/Pool.js#L404
+    agent.logger.debug('shimming generic-pool.PriorityQueue.prototype.enqueue');
+    shimmer.wrap(generic.PriorityQueue.prototype, 'enqueue', function (orig) {
+      return function wrappedEnqueue() {
+        var trans = agent._instrumentation.currTransaction();
+        var id = trans && trans.id;
+        agent.logger.debug(
+          'intercepted call to generic-pool.PriorityQueue.prototype.enqueue %o',
+          { id },
+        );
+
+        var obj = arguments[0];
+        // Expect obj to of type Deferred
+        if (obj._resolve && obj._reject) {
+          obj._resolve = agent._instrumentation.bindFunction(obj._resolve);
+          obj._reject = agent._instrumentation.bindFunction(obj._reject);
+        }
+
+        return orig.apply(this, arguments);
+      };
+    });
+  } else {
+    agent.logger.debug(
+      'generic-pool version %s not supported - aborting...',
+      version,
+    );
+  }
+
+  return generic;
+};