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

package/lib/instrumentation/modules/knex.js

@@ -0,0 +1,91 @@
+/*
+ * 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.
+ */
+
+// Knex instrumentation exists to capture a more useful span stacktrace at
+// the start of a Knex query, and use that stacktrace on the 'pg' or 'mysql'
+// span.
+
+'use strict';
+
+var semver = require('semver');
+
+var shimmer = require('../shimmer');
+var symbols = require('../../symbols');
+
+module.exports = function (Knex, agent, { version, enabled }) {
+  if (!enabled) {
+    return Knex;
+  }
+  if (!semver.satisfies(version, '>=0.10.0 <4.0.0')) {
+    agent.logger.debug(
+      `knex@${version} is not supported, skipping knex instrumentation`,
+    );
+    return Knex;
+  }
+
+  if (agent._conf.spanStackTraceMinDuration < 0) {
+    agent.logger.trace(
+      'not instrumenting knex because not capturing span stack traces (spanStackTraceMinDuration=%s)',
+      agent._conf.spanStackTraceMinDuration,
+    );
+    return Knex;
+  }
+
+  function wrapQueryStartPoint(original) {
+    return function wrappedQueryStartPoint() {
+      var builder = original.apply(this, arguments);
+
+      agent.logger.debug('capturing custom stack trace for knex');
+      var obj = {};
+      Error.captureStackTrace(obj);
+      builder[symbols.knexStackObj] = obj;
+
+      return builder;
+    };
+  }
+
+  function wrapRunner(original) {
+    return function wrappedRunner() {
+      var runner = original.apply(this, arguments);
+
+      agent.logger.debug('shimming knex runner.query');
+      shimmer.wrap(runner, 'query', wrapQuery);
+
+      return runner;
+    };
+  }
+
+  function wrapQuery(original) {
+    return function wrappedQuery() {
+      agent.logger.debug('intercepted call to knex runner.query');
+      if (this.connection) {
+        this.connection[symbols.knexStackObj] = this.builder
+          ? this.builder[symbols.knexStackObj]
+          : null;
+      }
+      return original.apply(this, arguments);
+    };
+  }
+
+  return function wrappedKnex() {
+    const knexInstance = Knex.apply(null, arguments);
+
+    if (knexInstance && knexInstance.client) {
+      const QUERY_FNS = ['queryBuilder', 'raw'];
+      agent.logger.debug('shimming knexInstance.client.runner');
+      shimmer.wrap(knexInstance.client, 'runner', wrapRunner);
+      agent.logger.debug(
+        'shimming Knex.Client.prototype functions: %j',
+        QUERY_FNS,
+      );
+      shimmer.massWrap(knexInstance.client, QUERY_FNS, wrapQueryStartPoint);
+    } else {
+      agent.logger.debug('could not shim Knex');
+    }
+
+    return knexInstance;
+  };
+};

package/lib/instrumentation/modules/koa-router.js

@@ -0,0 +1,74 @@
+/*
+ * 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 (Router, agent, { version, enabled }) {
+  if (!enabled) return Router;
+  if (!semver.satisfies(version, '>=5.2.0 <14')) {
+    agent.logger.debug(
+      'koa-router version %s not supported - aborting...',
+      version,
+    );
+    return Router;
+  }
+  if (
+    semver.satisfies(version, '>=13') &&
+    semver.satisfies(process.version, '<18')
+  ) {
+    agent.logger.debug(
+      'koa-router version %s not supported for node %s - aborting...',
+      version,
+      process.version,
+    );
+    return Router;
+  }
+
+  agent.logger.debug('shimming koa-router prototype.match function');
+  shimmer.wrap(Router.prototype, 'match', function (orig) {
+    return function (_, method) {
+      var matched = orig.apply(this, arguments);
+
+      if (typeof method !== 'string') {
+        agent.logger.debug(
+          'unexpected method type in koa-router prototype.match: %s',
+          typeof method,
+        );
+        return matched;
+      }
+
+      if (Array.isArray(matched && matched.pathAndMethod)) {
+        const layer = matched.pathAndMethod.find(function (layer) {
+          return layer && layer.opts && layer.opts.end === true;
+        });
+
+        var path = layer && layer.path;
+        if (typeof path === 'string') {
+          var name = method + ' ' + path;
+          agent._instrumentation.setDefaultTransactionName(name);
+        } else {
+          agent.logger.debug(
+            'unexpected path type in koa-router prototype.match: %s',
+            typeof path,
+          );
+        }
+      } else {
+        agent.logger.debug(
+          'unexpected match result in koa-router prototype.match: %s',
+          typeof matched,
+        );
+      }
+
+      return matched;
+    };
+  });
+
+  return Router;
+};

package/lib/instrumentation/modules/koa.js

@@ -0,0 +1,15 @@
+/*
+ * 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';
+
+module.exports = function (koa, agent, { version, enabled }) {
+  if (!enabled) return koa;
+
+  agent.setFramework({ name: 'koa', version, overwrite: false });
+
+  return koa;
+};

package/lib/instrumentation/modules/memcached.js

@@ -0,0 +1,99 @@
+/*
+ * 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')) {
+    agent.logger.debug(
+      'Memcached version %s not supported - aborting...',
+      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);
+      }
+    };
+  }
+};