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

package/lib/instrumentation/modules/pg.js

@@ -0,0 +1,148 @@
+/*
+ * 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';
+
+const EventEmitter = require('events');
+
+var semver = require('semver');
+var sqlSummary = require('sql-summary');
+
+var shimmer = require('../shimmer');
+var symbols = require('../../symbols');
+var { getDBDestination } = require('../context');
+
+module.exports = function (pg, agent, { version, enabled }) {
+  if (!enabled) {
+    return pg;
+  }
+  if (!semver.satisfies(version, '>=4.0.0 <9.0.0')) {
+    agent.logger.debug('pg version %s not supported - aborting...', version);
+    return pg;
+  }
+
+  patchClient(pg.Client, 'pg.Client', agent);
+
+  // Trying to access the pg.native getter will trigger and log the warning
+  // "Cannot find module 'pg-native'" to STDERR if the module isn't installed.
+  // Overwriting the getter we can lazily patch the native client only if the
+  // user is acually requesting it.
+  var getter = pg.__lookupGetter__('native');
+  if (getter) {
+    delete pg.native;
+    // To be as true to the original pg module as possible, we use
+    // __defineGetter__ instead of Object.defineProperty.
+    pg.__defineGetter__('native', function () {
+      var native = getter();
+      if (native && native.Client) {
+        patchClient(native.Client, 'pg.native.Client', agent);
+      }
+      return native;
+    });
+  }
+
+  return pg;
+};
+
+function patchClient(Client, klass, agent) {
+  agent.logger.debug('shimming %s.prototype.query', klass);
+  shimmer.wrap(Client.prototype, 'query', wrapQuery);
+
+  function wrapQuery(orig, name) {
+    return function wrappedFunction(sql) {
+      agent.logger.debug('intercepted call to %s.prototype.%s', klass, name);
+      const ins = agent._instrumentation;
+      const span = ins.createSpan('SQL', 'db', 'postgresql', 'query', {
+        exitSpan: true,
+      });
+      if (!span) {
+        return orig.apply(this, arguments);
+      }
+
+      // Get connection parameters from Client.
+      let host, port, database, user;
+      if (typeof this.connectionParameters === 'object') {
+        ({ host, port, database, user } = this.connectionParameters);
+      }
+      span._setDestinationContext(getDBDestination(host, port));
+
+      const dbContext = { type: 'sql' };
+      let sqlText = sql;
+      if (sql && typeof sql.text === 'string') {
+        sqlText = sql.text;
+      }
+      if (typeof sqlText === 'string') {
+        span.name = sqlSummary(sqlText);
+        dbContext.statement = sqlText;
+      } else {
+        agent.logger.debug(
+          'unable to parse sql form pg module (type: %s)',
+          typeof sqlText,
+        );
+      }
+      if (database) {
+        dbContext.instance = database;
+      }
+      if (user) {
+        dbContext.user = user;
+      }
+      span.setDbContext(dbContext);
+
+      if (this[symbols.knexStackObj]) {
+        span.customStackTrace(this[symbols.knexStackObj]);
+        this[symbols.knexStackObj] = null;
+      }
+
+      let index = arguments.length - 1;
+      let cb = arguments[index];
+      if (Array.isArray(cb)) {
+        index = cb.length - 1;
+        cb = cb[index];
+      }
+
+      const spanRunContext = ins.currRunContext().enterSpan(span);
+      const onQueryEnd = ins.bindFunctionToRunContext(
+        spanRunContext,
+        (_err) => {
+          agent.logger.debug('intercepted end of %s.prototype.%s', klass, name);
+          span.end();
+        },
+      );
+
+      if (typeof cb === 'function') {
+        arguments[index] = ins.bindFunction((err, res) => {
+          onQueryEnd(err);
+          return cb(err, res);
+        });
+        return orig.apply(this, arguments);
+      } else {
+        var queryOrPromise = orig.apply(this, arguments);
+
+        // It is important to prefer `.on` to `.then` for pg <7 >=6.3.0, because
+        // `query.then` is broken in those versions. See
+        // https://github.com/brianc/node-postgres/commit/b5b49eb895727e01290e90d08292c0d61ab86322#r23267714
+        if (typeof queryOrPromise.on === 'function') {
+          queryOrPromise.on('end', onQueryEnd);
+          queryOrPromise.on('error', onQueryEnd);
+          if (queryOrPromise instanceof EventEmitter) {
+            ins.bindEmitter(queryOrPromise);
+          }
+        } else if (typeof queryOrPromise.then === 'function') {
+          queryOrPromise.then(() => {
+            onQueryEnd();
+          }, onQueryEnd);
+        } else {
+          agent.logger.debug(
+            'ERROR: unknown pg query type: %s',
+            typeof queryOrPromise,
+          );
+        }
+
+        return queryOrPromise;
+      }
+    };
+  }
+}

package/lib/instrumentation/modules/pug.js

@@ -0,0 +1,18 @@
+/*
+ * 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 shimmer = require('../shimmer');
+var templateShared = require('../template-shared');
+
+module.exports = function (pug, agent, { enabled }) {
+  if (!enabled) return pug;
+  agent.logger.debug('shimming pug.compile');
+  shimmer.wrap(pug, 'compile', templateShared.wrapCompile(agent, 'pug'));
+
+  return pug;
+};

package/lib/instrumentation/modules/redis.js

@@ -0,0 +1,176 @@
+/*
+ * 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');
+
+const constants = require('../../constants');
+var shimmer = require('../shimmer');
+var { getDBDestination } = require('../context');
+
+const isWrappedRedisCbSym = Symbol('ElasticAPMIsWrappedRedisCb');
+
+const TYPE = 'db';
+const SUBTYPE = 'redis';
+const ACTION = 'query';
+
+module.exports = function (redis, agent, { version, enabled }) {
+  if (!enabled) {
+    return redis;
+  }
+  if (!semver.satisfies(version, '>=2.0.0 <4.0.0')) {
+    // Explicitly do not log.debug here, because the message is misleading for
+    // redis@4 and later that is being handled by @redis/client instrumentation.
+    return redis;
+  }
+
+  const ins = agent._instrumentation;
+
+  // The undocumented field on a RedisClient instance on which connection
+  // options are stored has changed a few times.
+  //
+  // - >=2.4.0: `client.connection_options.{host,port}`, commit eae5596a
+  // - >=2.3.0, <2.4.0: `client.connection_option.{host,port}`, commit d454e402
+  // - >=0.12.0, <2.3.0: `client.connectionOption.{host,port}`, commit 064260d1
+  // - <0.12.0: *maybe* `client.{host,port}`
+  const connOptsFromRedisClient = (rc) =>
+    rc.connection_options || rc.connection_option || rc.connectionOption || {};
+
+  var proto = redis.RedisClient && redis.RedisClient.prototype;
+  if (semver.satisfies(version, '>2.5.3')) {
+    agent.logger.debug(
+      'shimming redis.RedisClient.prototype.internal_send_command',
+    );
+    shimmer.wrap(proto, 'internal_send_command', wrapInternalSendCommand);
+  } else {
+    agent.logger.debug('shimming redis.RedisClient.prototype.send_command');
+    shimmer.wrap(proto, 'send_command', wrapSendCommand);
+  }
+
+  return redis;
+
+  function makeWrappedCallback(spanRunContext, span, origCb) {
+    const wrappedCallback = ins.bindFunctionToRunContext(
+      spanRunContext,
+      function (err, _reply) {
+        if (err) {
+          span._setOutcomeFromErrorCapture(constants.OUTCOME_FAILURE);
+          agent.captureError(err, { skipOutcome: true });
+        }
+        span.end();
+        if (origCb) {
+          return origCb.apply(this, arguments);
+        }
+      },
+    );
+    wrappedCallback[isWrappedRedisCbSym] = true;
+    return wrappedCallback;
+  }
+
+  function wrapInternalSendCommand(original) {
+    return function wrappedInternalSendCommand(commandObj) {
+      if (!commandObj || typeof commandObj.command !== 'string') {
+        // Unexpected usage. Skip instrumenting this call.
+        return original.apply(this, arguments);
+      }
+
+      if (commandObj.callback && commandObj.callback[isWrappedRedisCbSym]) {
+        // Avoid re-wrapping internal_send_command called *again* for commands
+        // queued before the client was "ready".
+        return original.apply(this, arguments);
+      }
+
+      const command = commandObj.command;
+      agent.logger.debug(
+        { command },
+        'intercepted call to RedisClient.prototype.internal_send_command',
+      );
+      const span = ins.createSpan(
+        command.toUpperCase(),
+        TYPE,
+        SUBTYPE,
+        ACTION,
+        { exitSpan: true },
+      );
+      if (!span) {
+        return original.apply(this, arguments);
+      }
+
+      const connOpts = connOptsFromRedisClient(this);
+      span._setDestinationContext(
+        getDBDestination(connOpts.host, connOpts.port),
+      );
+      span.setDbContext({ type: 'redis' });
+
+      const spanRunContext = ins.currRunContext().enterSpan(span);
+      commandObj.callback = makeWrappedCallback(
+        spanRunContext,
+        span,
+        commandObj.callback,
+      );
+      return ins.withRunContext(spanRunContext, original, this, ...arguments);
+    };
+  }
+
+  function wrapSendCommand(original) {
+    return function wrappedSendCommand(command, args, cb) {
+      if (typeof command !== 'string') {
+        // Unexpected usage. Skip instrumenting this call.
+        return original.apply(this, arguments);
+      }
+
+      let origCb = cb;
+      if (
+        !origCb &&
+        Array.isArray(args) &&
+        typeof args[args.length - 1] === 'function'
+      ) {
+        origCb = args[args.length - 1];
+      }
+      if (origCb && origCb[isWrappedRedisCbSym]) {
+        // Avoid re-wrapping send_command called *again* for commands queued
+        // before the client was "ready".
+        return original.apply(this, arguments);
+      }
+
+      agent.logger.debug(
+        { command },
+        'intercepted call to RedisClient.prototype.send_command',
+      );
+      var span = ins.createSpan(command.toUpperCase(), TYPE, SUBTYPE, ACTION, {
+        exitSpan: true,
+      });
+      if (!span) {
+        return original.apply(this, arguments);
+      }
+
+      const connOpts = connOptsFromRedisClient(this);
+      span._setDestinationContext(
+        getDBDestination(connOpts.host, connOpts.port),
+      );
+      span.setDbContext({ type: 'redis' });
+
+      const spanRunContext = ins.currRunContext().enterSpan(span);
+      const wrappedCb = makeWrappedCallback(spanRunContext, span, origCb);
+      if (cb) {
+        cb = wrappedCb;
+      } else if (origCb) {
+        args[args.length - 1] = wrappedCb;
+      } else {
+        cb = wrappedCb;
+      }
+      return ins.withRunContext(
+        spanRunContext,
+        original,
+        this,
+        command,
+        args,
+        cb,
+      );
+    };
+  }
+};

package/lib/instrumentation/modules/restify.js

@@ -0,0 +1,52 @@
+/*
+ * 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';
+
+const semver = require('semver');
+
+const shimmer = require('../shimmer');
+
+module.exports = function (restify, agent, { version, enabled }) {
+  if (!enabled) {
+    return restify;
+  }
+  if (!semver.satisfies(version, '>=5.2.0 <12.0.0')) {
+    agent.logger.debug('restify version %s not supported, skipping', version);
+    return restify;
+  }
+
+  agent.setFramework({ name: 'restify', version, overwrite: false });
+
+  function patchServer(server) {
+    if (semver.gte(version, '7.0.0')) {
+      shimmer.wrap(server, '_onHandlerError', function (orig) {
+        return function _wrappedOnHandlerError(err, req, res, isUncaught) {
+          if (err)
+            agent.captureError(err, { request: req, handled: !isUncaught });
+          return orig.apply(this, arguments);
+        };
+      });
+    } else {
+      shimmer.wrap(server, '_emitErrorEvents', function (orig) {
+        return function _wrappedOnHandlerError(req, res, route, err, cb) {
+          if (err) agent.captureError(err, { request: req });
+          return orig.apply(this, arguments);
+        };
+      });
+    }
+  }
+
+  shimmer.wrap(restify, 'createServer', function (fn) {
+    return function wrappedCreateServer() {
+      const server = fn.apply(this, arguments);
+      patchServer(server);
+      return server;
+    };
+  });
+
+  return restify;
+};

package/lib/instrumentation/modules/tedious.js

@@ -0,0 +1,159 @@
+/*
+ * 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 clone = require('shallow-clone-shim');
+var sqlSummary = require('sql-summary');
+
+var { getDBDestination } = require('../context');
+
+module.exports = function (tedious, agent, { version, enabled }) {
+  if (!enabled) return tedious;
+  if (
+    semver.satisfies(version, '>=19') &&
+    !semver.satisfies(process.version, '>=18.17')
+  ) {
+    agent.logger.debug(
+      'tedious version %s not supported for node %s - aborting...',
+      version,
+      process.version,
+    );
+    return tedious;
+  }
+  if (version === '4.0.0' || !semver.satisfies(version, '>=1.9.0 <20')) {
+    agent.logger.debug(
+      'tedious version %s not supported - aborting...',
+      version,
+    );
+    return tedious;
+  }
+
+  const ins = agent._instrumentation;
+
+  return clone({}, tedious, {
+    Connection(descriptor) {
+      const getter = descriptor.get;
+      if (getter) {
+        // tedious v6.5.0+
+        descriptor.get = function get() {
+          return wrapConnection(getter());
+        };
+      } else if (typeof descriptor.value === 'function') {
+        descriptor.value = wrapConnection(descriptor.value);
+      } else {
+        agent.logger.debug(
+          'could not patch `tedious.Connection` property for tedious version %s - aborting...',
+          version,
+        );
+      }
+      return descriptor;
+    },
+    Request(descriptor) {
+      const getter = descriptor.get;
+      if (getter) {
+        // tedious v6.5.0+
+        descriptor.get = function get() {
+          return wrapRequest(getter());
+        };
+      } else if (typeof descriptor.value === 'function') {
+        descriptor.value = wrapRequest(descriptor.value);
+      } else {
+        agent.logger.debug(
+          'could not patch `tedious.Request` property for tedious version %s - aborting...',
+          version,
+        );
+      }
+      return descriptor;
+    },
+  });
+
+  function wrapRequest(OriginalRequest) {
+    class Request extends OriginalRequest {
+      constructor() {
+        super(...arguments);
+        ins.bindEmitter(this);
+      }
+    }
+
+    return Request;
+  }
+
+  function wrapConnection(OriginalConnection) {
+    class Connection extends OriginalConnection {
+      constructor() {
+        super(...arguments);
+        ins.bindEmitter(this);
+      }
+
+      makeRequest(request, _packetType, payload) {
+        // if not a Request object (i.e. a BulkLoad), then bail
+        if (!request.parametersByName) {
+          return super.makeRequest(...arguments);
+        }
+        const span = ins.createSpan(null, 'db', 'mssql', 'query', {
+          exitSpan: true,
+        });
+        if (!span) {
+          return super.makeRequest(...arguments);
+        }
+
+        let host, port, instanceName;
+        if (typeof this.config === 'object') {
+          // http://tediousjs.github.io/tedious/api-connection.html#function_newConnection
+          host = this.config.server;
+          if (this.config.options) {
+            port = this.config.options.port;
+            instanceName = this.config.options.instanceName;
+          }
+        }
+        span._setDestinationContext(getDBDestination(host, port));
+
+        let sql;
+        let preparing;
+        if (payload.parameters !== undefined) {
+          // This looks for tedious instance with `RpcRequestPayload` started
+          // since version >=v11.0.10, when RPC parameter handling was refactored
+          // (https://github.com/tediousjs/tedious/pull/1275).
+          preparing =
+            typeof payload.procedure === 'number'
+              ? // tedious@16.2.0 starts using stored procedure *IDs*
+                // (https://github.com/tediousjs/tedious/pull/1327)
+                payload.procedure === 11
+              : payload.procedure === 'sp_prepare';
+          const stmtParam =
+            payload.parameters.find(({ name }) => name === 'statement') ||
+            payload.parameters.find(({ name }) => name === 'stmt');
+          sql = stmtParam ? stmtParam.value : request.sqlTextOrProcedure;
+        } else {
+          preparing = request.sqlTextOrProcedure === 'sp_prepare';
+          const params = request.parametersByName;
+          sql = (params.statement || params.stmt || {}).value;
+        }
+        span.name = sqlSummary(sql) + (preparing ? ' (prepare)' : '');
+        const dbContext = { type: 'sql', statement: sql };
+        if (instanceName) {
+          dbContext.instance = instanceName;
+        }
+        span.setDbContext(dbContext);
+
+        const origCallback = request.userCallback;
+        request.userCallback = ins.bindFunction(function tracedCallback() {
+          // TODO: captureError and setOutcome on err first arg here
+          span.end();
+          if (origCallback) {
+            return origCallback.apply(this, arguments);
+          }
+        });
+
+        return super.makeRequest(...arguments);
+      }
+    }
+
+    return Connection;
+  }
+};