@redthreadlabs/tracelog 1.4.0

package/lib/instrumentation/modules/memcached.js

@@ -0,0 +1,100 @@
+/*
+ * 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 { getDBDestination } = require('../context');
+
+module.exports = function (memcached, agent, { version, enabled }) {
+  if (!enabled) {
+    return memcached;
+  }
+
+  if (!semver.satisfies(version, '>=2.2.0 <3')) {
+    agent.logger.debug(
+      'memcached version %s not supported, skipping memcached instrumentation',
+      version,
+    );
+    return memcached;
+  }
+
+  const ins = agent._instrumentation;
+
+  agent.logger.debug('shimming memcached.prototype.command');
+  shimmer.wrap(memcached.prototype, 'command', wrapCommand);
+  shimmer.wrap(memcached.prototype, 'connect', wrapConnect);
+  return memcached;
+
+  function wrapConnect(original) {
+    return function wrappedConnect() {
+      const currentSpan = ins.currSpan();
+      const server = arguments[0];
+      agent.logger.debug('intercepted call to memcached.prototype.connect %o', {
+        server,
+      });
+
+      if (currentSpan) {
+        const [host, port = 11211] = server.split(':');
+        currentSpan._setDestinationContext(getDBDestination(host, port));
+      }
+      return original.apply(this, arguments);
+    };
+  }
+
+  // Wrap the generic command that is used to build touch, get, gets etc
+  function wrapCommand(original) {
+    return function wrappedCommand(queryCompiler, _server) {
+      if (typeof queryCompiler !== 'function') {
+        return original.apply(this, arguments);
+      }
+
+      var query = queryCompiler();
+      // Replace the queryCompiler function so it isn't called a second time.
+      arguments[0] = function prerunQueryCompiler() {
+        return query;
+      };
+
+      // If the callback is not a function the user doesn't care about result.
+      if (!query && typeof query.callback !== 'function') {
+        return original.apply(this, arguments);
+      }
+
+      const span = ins.createSpan(
+        `memcached.${query.type}`,
+        'db',
+        'memcached',
+        query.type,
+        { exitSpan: true },
+      );
+      if (!span) {
+        return original.apply(this, arguments);
+      }
+
+      agent.logger.debug('intercepted call to memcached.prototype.command %o', {
+        id: span.id,
+        type: query.type,
+      });
+      span.setDbContext({
+        statement: `${query.type} ${query.key}`,
+        type: 'memcached',
+      });
+
+      const spanRunContext = ins.currRunContext().enterSpan(span);
+      const origCallback = query.callback;
+      query.callback = ins.bindFunctionToRunContext(
+        spanRunContext,
+        function tracedCallback() {
+          span.end();
+          return origCallback.apply(this, arguments);
+        },
+      );
+      return ins.withRunContext(spanRunContext, original, this, ...arguments);
+    };
+  }
+};

package/lib/instrumentation/modules/mimic-response.js

@@ -0,0 +1,45 @@
+/*
+ * 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';
+
+/*
+ * This instrumentation exists to work around an issue in mimic-response@1.0.0
+ * that was fixed in mimic-response@1.0.1.
+ * See https://github.com/elastic/apm-agent-nodejs/issues/423.
+ */
+
+var semver = require('semver');
+
+module.exports = function (mimicResponse, agent, { version, enabled }) {
+  if (!enabled) return mimicResponse;
+
+  if (semver.gte(version, '1.0.1')) {
+    agent.logger.debug(
+      "mimic-response version %s doesn't need to be patched - ignoring...",
+      version,
+    );
+    return mimicResponse;
+  }
+
+  var ins = agent._instrumentation;
+
+  return function wrappedMimicResponse(fromStream, toStream) {
+    // If we bound the `fromStream` emitter, but not the `toStream` emitter, we
+    // need to do so as else the `on`, `addListener`, and `prependListener`
+    // functions of the `fromStream` will be copied over to the `toStream` but
+    // run in the context of the `fromStream`.
+    if (
+      fromStream &&
+      toStream &&
+      ins.isEventEmitterBound(fromStream) &&
+      !ins.isEventEmitterBound(toStream)
+    ) {
+      ins.bindEmitter(toStream);
+    }
+    return mimicResponse.apply(null, arguments);
+  };
+};

package/lib/instrumentation/modules/mongodb/lib/cmap/connection_pool.js

@@ -0,0 +1,40 @@
+/*
+ * 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 { AsyncResource } = require('../../../../../async-hooks-polyfill');
+
+const semver = require('semver');
+
+module.exports = (mod, agent, { version, enabled }) => {
+  if (!enabled) return mod;
+  if (!semver.satisfies(version, '>=3.3 <6.4.0')) {
+    // - mongodb <3.3 is instrumented via mongodb-core
+    // - mongodb >=6.4.0 now longer requires ConnectionPool#checkOut to be
+    //   patched to fix async context tracking. See discussion at
+    //   https://github.com/elastic/apm-agent-nodejs/pull/3897
+    return mod;
+  }
+  agent.logger.debug('instrumenting mongodb ConnectionPool#checkOut');
+
+  if (mod.ConnectionPool) {
+    class ConnectionPoolTraced extends mod.ConnectionPool {
+      checkOut(callback) {
+        return super.checkOut(AsyncResource.bind(callback));
+      }
+    }
+
+    Object.defineProperty(mod, 'ConnectionPool', {
+      enumerable: true,
+      get: function () {
+        return ConnectionPoolTraced;
+      },
+    });
+
+    return mod;
+  }
+};

package/lib/instrumentation/modules/mongodb-core.js

@@ -0,0 +1,206 @@
+/*
+ * 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 { getDBDestination } = require('../context');
+var shimmer = require('../shimmer');
+
+var SERVER_FNS = ['insert', 'update', 'remove', 'auth'];
+var CURSOR_FNS_FIRST = ['next', '_getmore'];
+
+const firstSpan = Symbol('first-span');
+
+module.exports = function (mongodb, agent, { version, enabled }) {
+  if (!enabled) return mongodb;
+  if (!semver.satisfies(version, '>=1.2.19 <4')) {
+    agent.logger.debug(
+      'mongodb-core version %s not supported - aborting...',
+      version,
+    );
+    return mongodb;
+  }
+
+  const ins = agent._instrumentation;
+
+  if (mongodb.Server) {
+    agent.logger.debug('shimming mongodb-core.Server.prototype.command');
+    shimmer.wrap(mongodb.Server.prototype, 'command', wrapCommand);
+    agent.logger.debug(
+      'shimming mongodb-core.Server.prototype functions: %j',
+      SERVER_FNS,
+    );
+    shimmer.massWrap(mongodb.Server.prototype, SERVER_FNS, wrapQuery);
+  }
+
+  if (mongodb.Cursor) {
+    agent.logger.debug(
+      'shimming mongodb-core.Cursor.prototype functions: %j',
+      CURSOR_FNS_FIRST,
+    );
+    shimmer.massWrap(mongodb.Cursor.prototype, CURSOR_FNS_FIRST, wrapCursor);
+  }
+
+  return mongodb;
+
+  function wrapCommand(orig) {
+    return function wrappedFunction(ns, cmd) {
+      var trans = agent._instrumentation.currTransaction();
+      var id = trans && trans.id;
+      var span;
+
+      agent.logger.debug(
+        'intercepted call to mongodb-core.Server.prototype.command %o',
+        { id, ns },
+      );
+
+      if (trans && arguments.length > 0) {
+        var index = arguments.length - 1;
+        var cb = arguments[index];
+        if (typeof cb === 'function') {
+          var type;
+          if (cmd.findAndModify) type = 'findAndModify';
+          else if (cmd.createIndexes) type = 'createIndexes';
+          else if (cmd.ismaster) type = 'ismaster';
+          else if (cmd.count) type = 'count';
+          else type = 'command';
+
+          span = ins.createSpan(ns + '.' + type, 'db', 'mongodb', 'query', {
+            exitSpan: true,
+          });
+          if (span) {
+            span.setDbContext({ type: 'mongodb', instance: ns });
+            arguments[index] = ins.bindFunctionToRunContext(
+              ins.currRunContext(),
+              wrappedCallback,
+            );
+          }
+        }
+      }
+
+      return orig.apply(this, arguments);
+
+      function wrappedCallback(_err, commandResult) {
+        agent.logger.debug(
+          'intercepted mongodb-core.Server.prototype.command callback %o',
+          { id },
+        );
+        if (commandResult && commandResult.connection) {
+          span._setDestinationContext(
+            getDBDestination(
+              commandResult.connection.host,
+              commandResult.connection.port,
+            ),
+          );
+        }
+        span.end();
+        return cb.apply(this, arguments);
+      }
+    };
+  }
+
+  function wrapQuery(orig, name) {
+    return function wrappedFunction(ns) {
+      var trans = agent._instrumentation.currTransaction();
+      var id = trans && trans.id;
+      var span;
+
+      agent.logger.debug(
+        'intercepted call to mongodb-core.Server.prototype.%s %o',
+        name,
+        { id, ns },
+      );
+
+      if (trans && arguments.length > 0) {
+        var index = arguments.length - 1;
+        var cb = arguments[index];
+        if (typeof cb === 'function') {
+          span = ins.createSpan(ns + '.' + name, 'db', 'mongodb', 'query', {
+            exitSpan: true,
+          });
+          if (span) {
+            span.setDbContext({ type: 'mongodb', instance: ns });
+            arguments[index] = ins.bindFunctionToRunContext(
+              ins.currRunContext(),
+              wrappedCallback,
+            );
+          }
+        }
+      }
+
+      return orig.apply(this, arguments);
+
+      function wrappedCallback(_err, commandResult) {
+        agent.logger.debug(
+          'intercepted mongodb-core.Server.prototype.%s callback %o',
+          name,
+          { id },
+        );
+        if (commandResult && commandResult.connection) {
+          span._setDestinationContext(
+            getDBDestination(
+              commandResult.connection.host,
+              commandResult.connection.port,
+            ),
+          );
+        }
+        span.end();
+        return cb.apply(this, arguments);
+      }
+    };
+  }
+  function wrapCursor(orig, name) {
+    return function wrappedFunction() {
+      var trans = agent._instrumentation.currTransaction();
+      var id = trans && trans.id;
+      var span;
+
+      agent.logger.debug(
+        'intercepted call to mongodb-core.Cursor.prototype.%s %o',
+        name,
+        { id },
+      );
+
+      if (trans && arguments.length > 0) {
+        var cb = arguments[0];
+        if (typeof cb === 'function') {
+          if (name !== 'next' || !this[firstSpan]) {
+            var spanName = `${this.ns}.${this.cmd.find ? 'find' : name}`;
+            span = ins.createSpan(spanName, 'db', 'mongodb', 'query', {
+              exitSpan: true,
+            });
+          }
+          if (span) {
+            span.setDbContext({ type: 'mongodb', instance: this.ns });
+            // Limitation: Currently not getting destination address/port for
+            // cursor calls.
+            arguments[0] = ins.bindFunctionToRunContext(
+              ins.currRunContext(),
+              wrappedCallback,
+            );
+            if (name === 'next') {
+              this[firstSpan] = true;
+            }
+          }
+        }
+      }
+
+      return orig.apply(this, arguments);
+
+      function wrappedCallback() {
+        agent.logger.debug(
+          'intercepted mongodb-core.Cursor.prototype.%s callback %o',
+          name,
+          { id },
+        );
+        span.end();
+        return cb.apply(this, arguments);
+      }
+    };
+  }
+};

package/lib/instrumentation/modules/mongodb.js

@@ -0,0 +1,259 @@
+/*
+ * 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 { OUTCOME_SUCCESS, OUTCOME_FAILURE } = require('../../constants');
+const { getDBDestination } = require('../context');
+const shimmer = require('../shimmer');
+const kListenersAdded = Symbol('kListenersAdded');
+
+// Match expected `<hostname>:<port>`, e.g. "mongo:27017", "::1:27017",
+// "127.0.0.1:27017".
+const HOSTNAME_PORT_RE = /^(.+):(\d+)$/;
+
+module.exports = (mongodb, agent, { version, enabled }) => {
+  if (!enabled) return mongodb;
+  if (!semver.satisfies(version, '>=3.3 <7')) {
+    agent.logger.debug(
+      'mongodb version %s not instrumented (mongodb <3.3 is instrumented via mongodb-core)',
+      version,
+    );
+    return mongodb;
+  }
+
+  const ins = agent._instrumentation;
+
+  const activeSpans = new Map();
+  if (mongodb.instrument) {
+    const listener = mongodb.instrument();
+    listener.on('started', onStart);
+    listener.on('succeeded', onSuccess);
+    listener.on('failed', onFailure);
+  } else if (mongodb.MongoClient) {
+    // mongodb 4.0+ removed the instrument() method in favor of
+    // listeners on the instantiated client objects. There are two mechanisms
+    // to get a client:
+    // 1. const client = new mongodb.MongoClient(...)
+    // 2. const client = await MongoClient.connect(...)
+    class MongoClientTraced extends mongodb.MongoClient {
+      constructor() {
+        // The `command*` events are only emitted if `options.monitorCommands: true`.
+        const args = Array.prototype.slice.call(arguments);
+        if (!args[1]) {
+          args[1] = { monitorCommands: true };
+        } else if (args[1].monitorCommands !== true) {
+          args[1] = Object.assign({}, args[1], { monitorCommands: true });
+        }
+        super(...args);
+        this.on('commandStarted', onStart);
+        this.on('commandSucceeded', onSuccess);
+        this.on('commandFailed', onFailure);
+        this[kListenersAdded] = true;
+      }
+    }
+    Object.defineProperty(mongodb, 'MongoClient', {
+      enumerable: true,
+      get: function () {
+        return MongoClientTraced;
+      },
+    });
+
+    shimmer.wrap(mongodb.MongoClient, 'connect', wrapConnect);
+  } else {
+    agent.logger.warn('could not instrument mongodb@%s', version);
+  }
+  return mongodb;
+
+  // Wrap the MongoClient.connect(url, options?, callback?) static method.
+  // It calls back with `function (err, client)` or returns a Promise that
+  // resolves to the client.
+  // https://github.com/mongodb/node-mongodb-native/blob/v4.2.1/src/mongo_client.ts#L503-L511
+  //
+  // From versions >=4.11.0 the method uses `new this` to create the client instance. Hence
+  // our `MongoClientTraced`'s constructor is used and the command listeners are already
+  // registered. We should check if the client has already added the listeners to avoid handling
+  // the same events twice
+  // NOTE: prefering to use a Symbol over version check since internal implementation may
+  // change in future versions
+  // https://github.com/mongodb/node-mongodb-native/blob/v4.11.0/src/mongo_client.ts#L618
+  function wrapConnect(origConnect) {
+    return function wrappedConnect(url, options, callback) {
+      if (typeof options === 'function') {
+        callback = options;
+        options = {};
+      }
+      options = options || {};
+      if (!options.monitorCommands) {
+        options.monitorCommands = true;
+      }
+      if (typeof callback === 'function') {
+        return origConnect.call(
+          this,
+          url,
+          options,
+          function wrappedCallback(err, client) {
+            if (err) {
+              callback(err);
+            } else {
+              if (!client[kListenersAdded]) {
+                client.on('commandStarted', onStart);
+                client.on('commandSucceeded', onSuccess);
+                client.on('commandFailed', onFailure);
+                client[kListenersAdded] = true;
+              }
+              callback(err, client);
+            }
+          },
+        );
+      } else {
+        const p = origConnect.call(this, url, options, callback);
+        p.then((client) => {
+          if (!client[kListenersAdded]) {
+            client.on('commandStarted', onStart);
+            client.on('commandSucceeded', onSuccess);
+            client.on('commandFailed', onFailure);
+            client[kListenersAdded] = true;
+          }
+        });
+        return p;
+      }
+    };
+  }
+
+  function onStart(event) {
+    // `event` is a `CommandStartedEvent`
+    // https://github.com/mongodb/specifications/blob/master/source/command-logging-and-monitoring/command-logging-and-monitoring.rst#command-started-message
+    // E.g. with mongodb@6.2.0:
+    //   CommandStartedEvent {
+    //     connectionId: '127.0.0.1:27017',
+    //     requestId: 1,
+    //     databaseName: 'test',
+    //     commandName: 'insert',
+    //     command:
+    //     { ... } }
+    const name = [
+      event.databaseName,
+      collectionFor(event),
+      event.commandName,
+    ].join('.');
+
+    const span = ins.createSpan(name, 'db', 'mongodb', event.commandName, {
+      exitSpan: true,
+    });
+    if (span) {
+      activeSpans.set(event.requestId, span);
+
+      // Destination context.
+      // Per the following code it looks like "<hostname>:<port>" should be
+      // available via the `address` or `connectionId` field.
+      // https://github.com/mongodb/node-mongodb-native/blob/dd356f0ede/lib/core/connection/apm.js#L155-L169
+      const address = event.address || event.connectionId;
+      let match;
+      if (
+        address &&
+        typeof address === 'string' &&
+        (match = HOSTNAME_PORT_RE.exec(address))
+      ) {
+        span._setDestinationContext(getDBDestination(match[1], match[2]));
+      } else {
+        agent.logger.trace(
+          'could not set destination context on mongodb span from address=%j',
+          address,
+        );
+      }
+
+      const dbContext = { type: 'mongodb', instance: event.databaseName };
+      span.setDbContext(dbContext);
+    }
+  }
+
+  function onSuccess(event) {
+    // `event` is a `CommandSucceededEvent`
+    // https://github.com/mongodb/specifications/blob/master/source/command-logging-and-monitoring/command-logging-and-monitoring.rst#command-succeeded-message
+    // E.g. with mongodb@6.2.0:
+    //   CommandSucceededEvent {
+    //     connectionId: '127.0.0.1:27017',
+    //     requestId: 1,
+    //     duration: 1,
+    //     reply: { ... }
+    //   }
+    if (!activeSpans.has(event.requestId)) return;
+
+    const span = activeSpans.get(event.requestId);
+    activeSpans.delete(event.requestId);
+
+    // From mongodb@3.6.0 and up some commands like `deleteOne` may contain
+    // error data inside the `reply` property. It makes sense to capture it.
+    const writeErrors = event?.reply?.writeErrors;
+
+    if (writeErrors && writeErrors.length) {
+      agent.captureError(writeErrors[0].errmsg, {
+        skipOutcome: true,
+        parent: span,
+      });
+    }
+    span.setOutcome(OUTCOME_SUCCESS);
+    span.end(span._timer.start / 1000 + event.duration);
+  }
+
+  function onFailure(event) {
+    // `event` is a `CommandFailedEvent`
+    // https://github.com/mongodb/specifications/blob/master/source/command-logging-and-monitoring/command-logging-and-monitoring.rst#command-failed-message
+    // E.g. with mongodb@6.2.0:
+    // CommandFailedEvent {
+    //   connectionId: '127.0.0.1:27017',
+    //   requestId: 6,
+    //   commandName: "find",
+    //   duration: 1,
+    //   "failure": { ... }
+    // }
+    if (!activeSpans.has(event.requestId)) return;
+
+    const span = activeSpans.get(event.requestId);
+    activeSpans.delete(event.requestId);
+    span.setOutcome(OUTCOME_FAILURE);
+    span.end(span._timer.start / 1000 + event.duration);
+  }
+
+  function collectionFor(event) {
+    // `getMore` command is a special case where the collection name is
+    // placed in a property named `collection`. The types exported
+    // do not ensure the property is there so we are defensive on its
+    // retrieval.
+    //
+    // Example of `getMore` payload:
+    // {
+    //   event: CommandStartedEvent {
+    //     name: 'commandStarted',
+    //     address: '172.20.0.2:27017',
+    //     connectionId: 12,
+    //     requestId: 686,
+    //     databaseName: 'mydatabase',
+    //     commandName: 'getMore',
+    //     command: {
+    //       getMore: new Long('1769182660590360229'),
+    //       collection: 'Interaction',
+    //       ...
+    //     }
+    //   },
+    //   commandName: 'getMore',
+    //   collection: new Long('1769182660590360229')
+    // }
+    // ref: https://github.com/elastic/apm-agent-nodejs/issues/3834
+    if (
+      event.commandName === 'getMore' &&
+      typeof event.command.collection === 'string'
+    ) {
+      return event.command.collection;
+    }
+
+    const collection = event.command[event.commandName];
+    return typeof collection === 'string' ? collection : '$cmd';
+  }
+};