@redthreadlabs/tracelog 1.4.0

package/lib/instrumentation/modules/mysql.js

@@ -0,0 +1,200 @@
+/*
+ * 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 (mysql, agent, { version, enabled }) {
+  if (!enabled) {
+    return mysql;
+  }
+  if (!semver.satisfies(version, '^2.0.0')) {
+    agent.logger.debug('mysql version %s not supported - aborting...', version);
+    return mysql;
+  }
+
+  agent.logger.debug('shimming mysql.createPool');
+  shimmer.wrap(mysql, 'createPool', wrapCreatePool);
+
+  agent.logger.debug('shimming mysql.createPoolCluster');
+  shimmer.wrap(mysql, 'createPoolCluster', wrapCreatePoolCluster);
+
+  agent.logger.debug('shimming mysql.createConnection');
+  shimmer.wrap(mysql, 'createConnection', wrapCreateConnection);
+
+  return mysql;
+
+  function wrapCreateConnection(original) {
+    return function wrappedCreateConnection() {
+      var connection = original.apply(this, arguments);
+
+      wrapQueryable(connection, 'connection', agent);
+
+      return connection;
+    };
+  }
+
+  function wrapCreatePool(original) {
+    return function wrappedCreatePool() {
+      var pool = original.apply(this, arguments);
+
+      agent.logger.debug('shimming mysql pool.getConnection');
+      shimmer.wrap(pool, 'getConnection', wrapGetConnection);
+
+      return pool;
+    };
+  }
+
+  function wrapCreatePoolCluster(original) {
+    return function wrappedCreatePoolCluster() {
+      var cluster = original.apply(this, arguments);
+
+      agent.logger.debug('shimming mysql cluster.of');
+      shimmer.wrap(cluster, 'of', function wrapOf(original) {
+        return function wrappedOf() {
+          var ofCluster = original.apply(this, arguments);
+
+          agent.logger.debug('shimming mysql cluster of.getConnection');
+          shimmer.wrap(ofCluster, 'getConnection', wrapGetConnection);
+
+          return ofCluster;
+        };
+      });
+
+      return cluster;
+    };
+  }
+
+  function wrapGetConnection(original) {
+    return function wrappedGetConnection() {
+      var cb = arguments[0];
+
+      if (typeof cb === 'function') {
+        arguments[0] = agent._instrumentation.bindFunction(
+          function wrapedCallback(_err, connection) {
+            if (connection)
+              wrapQueryable(connection, 'getConnection() > connection', agent);
+            return cb.apply(this, arguments);
+          },
+        );
+      }
+
+      return original.apply(this, arguments);
+    };
+  }
+};
+
+function wrapQueryable(connection, objType, agent) {
+  const ins = agent._instrumentation;
+
+  agent.logger.debug('shimming mysql %s.query', objType);
+  shimmer.wrap(connection, 'query', wrapQuery);
+
+  let host, port, user, database;
+  if (typeof connection.config === 'object') {
+    ({ host, port, user, database } = connection.config);
+  }
+
+  function wrapQuery(original) {
+    return function wrappedQuery(sql, values, cb) {
+      agent.logger.debug('intercepted call to mysql %s.query', objType);
+
+      var span = ins.createSpan(null, 'db', 'mysql', 'query', {
+        exitSpan: true,
+      });
+      if (!span) {
+        return original.apply(this, arguments);
+      }
+
+      var hasCallback = false;
+      var sqlStr;
+
+      if (this[symbols.knexStackObj]) {
+        span.customStackTrace(this[symbols.knexStackObj]);
+        this[symbols.knexStackObj] = null;
+      }
+
+      const wrapCallback = function (origCallback) {
+        hasCallback = true;
+        return ins.bindFunction(function wrappedCallback(_err) {
+          span.end();
+          return origCallback.apply(this, arguments);
+        });
+      };
+
+      switch (typeof sql) {
+        case 'string':
+          sqlStr = sql;
+          break;
+        case 'object':
+          if (typeof sql._callback === 'function') {
+            sql._callback = wrapCallback(sql._callback);
+          }
+          sqlStr = sql.sql;
+          break;
+        case 'function':
+          arguments[0] = wrapCallback(sql);
+          break;
+      }
+
+      if (sqlStr) {
+        agent.logger.debug({ sql: sqlStr }, 'extracted sql from mysql query');
+        span.setDbContext({
+          statement: sqlStr,
+          type: 'sql',
+          user,
+          instance: database,
+        });
+        span.name = sqlSummary(sqlStr);
+      }
+      span._setDestinationContext(getDBDestination(host, port));
+
+      if (typeof values === 'function') {
+        arguments[1] = wrapCallback(values);
+      } else if (typeof cb === 'function') {
+        arguments[2] = wrapCallback(cb);
+      }
+
+      const spanRunContext = ins.currRunContext().enterSpan(span);
+      const result = ins.withRunContext(
+        spanRunContext,
+        original,
+        this,
+        ...arguments,
+      );
+
+      if (!hasCallback && result instanceof EventEmitter) {
+        // Wrap `result.emit` instead of `result.once('error', ...)` to avoid
+        // changing app behaviour by possibly setting the only 'error' handler.
+        shimmer.wrap(result, 'emit', function (origEmit) {
+          return function wrappedEmit(event, data) {
+            // The 'mysql' module emits 'end' even after an 'error' event.
+            switch (event) {
+              case 'error':
+                break;
+              case 'end':
+                span.end();
+                break;
+            }
+            return origEmit.apply(this, arguments);
+          };
+        });
+        // Ensure event handlers execute in the caller run context.
+        ins.bindEmitter(result);
+      }
+
+      return result;
+    };
+  }
+}

package/lib/instrumentation/modules/mysql2.js

@@ -0,0 +1,140 @@
+/*
+ * 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 sqlSummary = require('sql-summary');
+
+var shimmer = require('../shimmer');
+var symbols = require('../../symbols');
+var { getDBDestination } = require('../context');
+
+module.exports = function (mysql2, agent, { version, enabled }) {
+  if (!enabled) {
+    return mysql2;
+  }
+  if (!semver.satisfies(version, '>=1 <4')) {
+    agent.logger.debug(
+      'mysql2 version %s not supported - aborting...',
+      version,
+    );
+    return mysql2;
+  }
+
+  var ins = agent._instrumentation;
+
+  // mysql2@3.11.5 added BaseConnection class which is extended by Connection
+  // but is not in the public API so we need to extract it via prototype chain
+  // ref: https://github.com/sidorares/node-mysql2/pull/3081
+  const baseClass = Object.getPrototypeOf(mysql2.Connection);
+  const baseProto = baseClass.prototype;
+  const hasQuery = typeof baseProto?.query === 'function';
+  const hasExec = typeof baseProto?.execute === 'function';
+  const shouldPatchBase = hasQuery && hasExec;
+
+  if (shouldPatchBase) {
+    shimmer.wrap(baseProto, 'query', wrapQuery);
+    shimmer.wrap(baseProto, 'execute', wrapQuery);
+  } else {
+    shimmer.wrap(mysql2.Connection.prototype, 'query', wrapQuery);
+    shimmer.wrap(mysql2.Connection.prototype, 'execute', wrapQuery);
+  }
+
+  return mysql2;
+
+  function wrapQuery(original) {
+    return function wrappedQuery(sql, values, cb) {
+      agent.logger.debug('intercepted call to mysql2.%s', original.name);
+
+      var span = ins.createSpan(null, 'db', 'mysql', 'query', {
+        exitSpan: true,
+      });
+      if (!span) {
+        return original.apply(this, arguments);
+      }
+
+      if (this[symbols.knexStackObj]) {
+        span.customStackTrace(this[symbols.knexStackObj]);
+        this[symbols.knexStackObj] = null;
+      }
+
+      let hasCallback = false;
+      const wrapCallback = function (origCallback) {
+        hasCallback = true;
+        return ins.bindFunction(function wrappedCallback(_err) {
+          span.end();
+          return origCallback.apply(this, arguments);
+        });
+      };
+
+      let host, port, user, database;
+      if (typeof this.config === 'object') {
+        ({ host, port, user, database } = this.config);
+      }
+      span._setDestinationContext(getDBDestination(host, port));
+
+      let sqlStr;
+      switch (typeof sql) {
+        case 'string':
+          sqlStr = sql;
+          break;
+        case 'object':
+          // `mysql2.{query,execute}` support the only arg being an instance
+          // of the internal mysql2 `Command` object.
+          if (typeof sql.onResult === 'function') {
+            sql.onResult = wrapCallback(sql.onResult);
+          }
+          sqlStr = sql.sql;
+          break;
+        case 'function':
+          arguments[0] = wrapCallback(sql);
+          break;
+      }
+      if (sqlStr) {
+        span.setDbContext({
+          type: 'sql',
+          instance: database,
+          user,
+          statement: sqlStr,
+        });
+        span.name = sqlSummary(sqlStr);
+      } else {
+        span.setDbContext({ type: 'sql', instance: database, user });
+      }
+
+      if (typeof values === 'function') {
+        arguments[1] = wrapCallback(values);
+      } else if (typeof cb === 'function') {
+        arguments[2] = wrapCallback(cb);
+      }
+      const spanRunContext = ins.currRunContext().enterSpan(span);
+      const result = ins.withRunContext(
+        spanRunContext,
+        original,
+        this,
+        ...arguments,
+      );
+
+      if (result && !hasCallback) {
+        ins.bindEmitter(result);
+        shimmer.wrap(result, 'emit', function (origEmit) {
+          return function (event) {
+            switch (event) {
+              case 'error':
+              case 'close':
+              case 'end':
+                span.end();
+            }
+            return origEmit.apply(this, arguments);
+          };
+        });
+      }
+
+      return result;
+    };
+  }
+};

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,29 @@
+/*
+ * 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');
+var templateShared = require('../template-shared');
+
+module.exports = function (pug, agent, { version, enabled }) {
+  if (!enabled) return pug;
+
+  if (!semver.satisfies(version, '>=0.1.0 <4')) {
+    agent.logger.debug(
+      'cannot instrument pug version %s, skipping pug instrumentation',
+      version,
+    );
+    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,
+      );
+    };
+  }
+};