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

package/lib/instrumentation/modules/bluebird.js

@@ -0,0 +1,93 @@
+/*
+ * 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 massWrap = shimmer.massWrap;
+var wrap = shimmer.wrap;
+
+var BLUEBIRD_FNS = ['_then', '_addCallbacks'];
+
+module.exports = function (bluebird, agent, { version }) {
+  var ins = agent._instrumentation;
+
+  if (!semver.satisfies(version, '>=2 <4')) {
+    agent.logger.debug(
+      'bluebird version %s not supported - aborting...',
+      version,
+    );
+    return bluebird;
+  }
+
+  agent.logger.debug('shimming bluebird.prototype functions: %j', BLUEBIRD_FNS);
+  massWrap(bluebird.prototype, BLUEBIRD_FNS, wrapThen);
+
+  // Calling bluebird.config might overwrite the
+  // bluebird.prototype._attachCancellationCallback function with a new
+  // function. We need to hook into this new function
+  agent.logger.debug('shimming bluebird.config');
+  wrap(bluebird, 'config', function wrapConfig(original) {
+    return function wrappedConfig() {
+      var result = original.apply(this, arguments);
+
+      agent.logger.debug(
+        'shimming bluebird.prototype._attachCancellationCallback',
+      );
+      wrap(
+        bluebird.prototype,
+        '_attachCancellationCallback',
+        function wrapAttachCancellationCallback(original) {
+          return function wrappedAttachCancellationCallback(onCancel) {
+            if (arguments.length !== 1) return original.apply(this, arguments);
+            return original.call(this, ins.bindFunction(onCancel));
+          };
+        },
+      );
+
+      return result;
+    };
+  });
+
+  // WARNING: even if you remove these two shims, the tests might still pass
+  // for bluebird@2. The tests are flaky and will only fail sometimes and in
+  // some cases only if run together with the other tests.
+  //
+  // To test, run in a while-loop:
+  //
+  //   while :; do node test/instrumentation/modules/bluebird/bluebird.js || exit $?; done
+  if (semver.satisfies(version, '<3')) {
+    agent.logger.debug('shimming bluebird.each');
+    wrap(bluebird, 'each', function wrapEach(original) {
+      return function wrappedEach(promises, fn) {
+        if (arguments.length !== 2) return original.apply(this, arguments);
+        return original.call(this, promises, ins.bindFunction(fn));
+      };
+    });
+
+    agent.logger.debug('shimming bluebird.prototype.each');
+    wrap(bluebird.prototype, 'each', function wrapEach(original) {
+      return function wrappedEach(fn) {
+        if (arguments.length !== 1) return original.apply(this, arguments);
+        return original.call(this, ins.bindFunction(fn));
+      };
+    });
+  }
+
+  return bluebird;
+
+  function wrapThen(original) {
+    return function wrappedThen() {
+      var args = Array.prototype.slice.call(arguments);
+      if (typeof args[0] === 'function') args[0] = ins.bindFunction(args[0]);
+      if (typeof args[1] === 'function') args[1] = ins.bindFunction(args[1]);
+      return original.apply(this, args);
+    };
+  }
+};

package/lib/instrumentation/modules/cassandra-driver.js

@@ -0,0 +1,280 @@
+/*
+ * 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 sqlSummary = require('sql-summary');
+
+const shimmer = require('../shimmer');
+
+module.exports = function (cassandra, agent, { version, enabled }) {
+  if (!enabled) return cassandra;
+  if (!semver.satisfies(version, '>=3 <5')) {
+    agent.logger.debug(
+      'cassandra-driver version %s not supported - aborting...',
+      version,
+    );
+    return cassandra;
+  }
+
+  const ins = agent._instrumentation;
+
+  if (cassandra.Client) {
+    if (semver.gte(version, '4.4.0')) {
+      // Prior to v4.4.0, the regular `connect` function would be called by the
+      // other functions (e.g. `execute`). In newer versions an internal
+      // `_connect` function is called instead (this is also called by
+      // `connect`).
+      shimmer.wrap(cassandra.Client.prototype, '_connect', wrapAsyncConnect);
+    } else {
+      shimmer.wrap(cassandra.Client.prototype, 'connect', wrapConnect);
+    }
+    shimmer.wrap(cassandra.Client.prototype, 'execute', wrapExecute);
+    shimmer.wrap(cassandra.Client.prototype, 'eachRow', wrapEachRow);
+    shimmer.wrap(cassandra.Client.prototype, 'batch', wrapBatch);
+  }
+
+  return cassandra;
+
+  function wrapAsyncConnect(original) {
+    return async function wrappedAsyncConnect() {
+      const span = ins.createSpan(
+        'Cassandra: Connect',
+        'db',
+        'cassandra',
+        'connect',
+        { exitSpan: true },
+      );
+      if (!span) {
+        return original.apply(this, arguments);
+      }
+
+      const dbContext = { type: 'cassandra' };
+      if (this.keyspace) {
+        dbContext.instance = this.keyspace;
+      }
+      span.setDbContext(dbContext);
+
+      try {
+        return await original.apply(this, arguments);
+      } finally {
+        span.end();
+      }
+    };
+  }
+
+  function wrapConnect(original) {
+    return function wrappedConnect(callback) {
+      const span = ins.createSpan(
+        'Cassandra: Connect',
+        'db',
+        'cassandra',
+        'connect',
+        { exitSpan: true },
+      );
+      if (!span) {
+        return original.apply(this, arguments);
+      }
+
+      const dbContext = { type: 'cassandra' };
+      if (this.keyspace) {
+        dbContext.instance = this.keyspace;
+      }
+      span.setDbContext(dbContext);
+
+      function resolve() {
+        span.end();
+      }
+
+      // Wrap the callback
+      const ret = original.call(this, wrapCallback(callback));
+
+      if (typeof callback !== 'function') {
+        if (typeof ret.then === 'function') {
+          ret.then(resolve, resolve);
+        } else {
+          agent.logger.error(
+            'unable to identify span exit point for cassandra-driver',
+          );
+        }
+      }
+
+      return ret;
+
+      function wrapCallback(cb) {
+        if (typeof cb !== 'function') return cb;
+        return function wrappedCallback() {
+          resolve();
+          return cb.apply(this, arguments);
+        };
+      }
+    };
+  }
+
+  function toQueryString(query) {
+    return query.query;
+  }
+
+  function wrapBatch(original) {
+    return function wrappedBatch(queries, options, callback) {
+      const span = ins.createSpan(
+        'Cassandra: Batch query',
+        'db',
+        'cassandra',
+        'query',
+        { exitSpan: true },
+      );
+      if (!span) {
+        return original.apply(this, arguments);
+      }
+
+      const queryStrings = queries.map(toQueryString);
+      const query = queryStrings.join(';\n');
+      const dbContext = { type: 'cassandra', statement: query };
+      const keyspace =
+        (options && typeof options === 'object' && options.keyspace) ||
+        this.keyspace;
+      if (keyspace) {
+        dbContext.instance = keyspace;
+      }
+      span.setDbContext(dbContext);
+
+      function resolve() {
+        span.end();
+      }
+
+      // Wrap the callback
+      const index = arguments.length - 1;
+      const cb = arguments[index];
+      const isPromise = typeof cb !== 'function';
+      if (!isPromise) {
+        arguments[index] = function wrappedCallback() {
+          resolve();
+          return cb.apply(this, arguments);
+        };
+      }
+
+      const ret = original.apply(this, arguments);
+
+      if (isPromise) {
+        if (typeof ret.then === 'function') {
+          ret.then(resolve, resolve);
+        } else {
+          agent.logger.error(
+            'unable to identify span exit point for cassandra-driver',
+          );
+        }
+      }
+
+      return ret;
+    };
+  }
+
+  function wrapExecute(original) {
+    return function wrappedExecute(query, params, options, callback) {
+      const span = ins.createSpan(null, 'db', 'cassandra', 'query', {
+        exitSpan: true,
+      });
+      if (!span) {
+        return original.apply(this, arguments);
+      }
+
+      span.name = sqlSummary(query);
+      const dbContext = { type: 'cassandra', statement: query };
+      const keyspace =
+        (options && typeof options === 'object' && options.keyspace) ||
+        this.keyspace;
+      if (keyspace) {
+        dbContext.instance = keyspace;
+      }
+      span.setDbContext(dbContext);
+
+      function resolve() {
+        span.end();
+      }
+
+      // Wrap the callback
+      const index = arguments.length - 1;
+      const cb = arguments[index];
+      const isPromise = typeof cb !== 'function';
+      if (!isPromise) {
+        arguments[index] = function wrappedCallback() {
+          resolve();
+          return cb.apply(this, arguments);
+        };
+      }
+
+      const ret = original.apply(this, arguments);
+
+      if (isPromise) {
+        if (typeof ret.then === 'function') {
+          ret.then(resolve, resolve);
+        } else {
+          agent.logger.error(
+            'unable to identify span exit point for cassandra-driver',
+          );
+        }
+      }
+
+      return ret;
+    };
+  }
+
+  function wrapEachRow(original) {
+    return function wrappedEachRow(
+      query,
+      params,
+      options,
+      rowCallback,
+      callback,
+    ) {
+      const span = ins.createSpan(null, 'db', 'cassandra', 'query', {
+        exitSpan: true,
+      });
+      if (!span) {
+        return original.apply(this, arguments);
+      }
+
+      span.name = sqlSummary(query);
+      const dbContext = { type: 'cassandra', statement: query };
+      const keyspace =
+        (options && typeof options === 'object' && options.keyspace) ||
+        this.keyspace;
+      if (keyspace) {
+        dbContext.instance = keyspace;
+      }
+      span.setDbContext(dbContext);
+
+      // Wrap the callback
+      const index = arguments.length - 1;
+      const hasRowCallback = typeof arguments[index - 1] === 'function';
+
+      function resolve() {
+        span.end();
+      }
+
+      if (hasRowCallback) {
+        const cb = arguments[index];
+        if (typeof cb === 'function') {
+          arguments[index] = function wrappedCallback() {
+            resolve();
+            return cb.apply(this, arguments);
+          };
+        } else {
+          agent.logger.error(
+            'unable to identify span exit point for cassandra-driver',
+          );
+        }
+      } else {
+        arguments[index + 1] = resolve;
+        arguments.length++;
+      }
+
+      return original.apply(this, arguments);
+    };
+  }
+};

package/lib/instrumentation/modules/elasticsearch.js

@@ -0,0 +1,191 @@
+/*
+ * 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 { URL, URLSearchParams } = require('url');
+
+var shimmer = require('../shimmer');
+var { getDBDestination } = require('../context');
+const { getElasticsearchDbStatement } = require('../elasticsearch-shared');
+
+const startsWithProtocolRE = /^([a-z]+:)?\/\//i;
+const DEFAULT_PORT = 9200;
+const DEFAULT_PORT_FROM_PROTO = {
+  'http:': 80,
+  'https:': 443,
+};
+
+// This is an imperfect equivalent of the handling in the `Transport`
+// constructor and internal `Host` parsing function in the ES client.
+// This returns a `URL` object or null.
+function getTargetUrlFromTransportConfig(config) {
+  const transportHosts = config ? config.host || config.hosts : null;
+  if (!transportHosts) {
+    return null;
+  }
+
+  let firstTransportHost = Array.isArray(transportHosts)
+    ? transportHosts[0]
+    : transportHosts;
+  if (!firstTransportHost) {
+    return null;
+  }
+
+  if (typeof firstTransportHost === 'string') {
+    // "example.com:42" or "someprotocol://example.com:42" or
+    // "someprotocol://example.com".
+    if (!startsWithProtocolRE.test(firstTransportHost)) {
+      firstTransportHost = 'http://' + firstTransportHost;
+    }
+    try {
+      return new URL(firstTransportHost);
+    } catch (_err) {
+      return null;
+    }
+  } else if (typeof firstTransportHost === 'object') {
+    let proto = firstTransportHost.protocol || 'http:';
+    if (!proto.endsWith(':')) {
+      proto += ':';
+    }
+    const hostname = firstTransportHost.hostname || firstTransportHost.host;
+    const port = firstTransportHost.port || DEFAULT_PORT;
+    try {
+      return new URL(proto + '//' + hostname + ':' + port);
+    } catch (_ignoredErr) {
+      return null;
+    }
+  }
+
+  return null;
+}
+
+module.exports = function (elasticsearch, agent, { enabled }) {
+  if (!enabled) return elasticsearch;
+
+  const ins = agent._instrumentation;
+  const elasticsearchCaptureBodyUrlsRegExp =
+    agent._conf.elasticsearchCaptureBodyUrlsRegExp;
+
+  agent.logger.debug('shimming elasticsearch.Transport.prototype.request');
+  shimmer.wrap(
+    elasticsearch.Transport && elasticsearch.Transport.prototype,
+    'request',
+    wrapRequest,
+  );
+
+  return elasticsearch;
+
+  function wrapRequest(original) {
+    return function wrappedRequest(params, cb) {
+      var span = ins.createSpan(null, 'db', 'elasticsearch', 'request', {
+        exitSpan: true,
+      });
+      var id = span && span.transaction.id;
+      var method = params && params.method;
+      var path = params && params.path;
+
+      agent.logger.debug(
+        'intercepted call to elasticsearch.Transport.prototype.request %o',
+        { id, method, path },
+      );
+
+      if (span && method && path) {
+        span.name = `Elasticsearch: ${method} ${path}`;
+
+        // Set DB context.
+        const dbContext = {
+          type: 'elasticsearch',
+        };
+        const statement = getElasticsearchDbStatement(
+          path,
+          params && params.body,
+          elasticsearchCaptureBodyUrlsRegExp,
+        );
+        if (statement) {
+          dbContext.statement = statement;
+        }
+        span.setDbContext(dbContext);
+
+        // Get the remote host information from elasticsearch Transport options.
+        const targetUrl = getTargetUrlFromTransportConfig(this._config);
+        let port = targetUrl && targetUrl.port;
+        if (!port && targetUrl) {
+          port = DEFAULT_PORT_FROM_PROTO[targetUrl.protocol];
+        }
+        span._setDestinationContext(
+          getDBDestination(targetUrl && targetUrl.hostname, port),
+        );
+        if (targetUrl) {
+          targetUrl.pathname = path;
+          targetUrl.search = new URLSearchParams(params.query).toString();
+          span.setHttpContext({
+            url: targetUrl.toString(),
+          });
+        }
+
+        const parentRunContext = ins.currRunContext();
+        const spanRunContext = parentRunContext.enterSpan(span);
+        if (typeof cb === 'function') {
+          var args = Array.prototype.slice.call(arguments);
+          args[1] = function () {
+            span.end();
+            ins.withRunContext(parentRunContext, cb, this, ...arguments);
+          };
+          return ins.withRunContext(spanRunContext, original, this, ...args);
+        } else {
+          const originalPromise = ins.withRunContext(
+            spanRunContext,
+            original,
+            this,
+            ...arguments,
+          );
+
+          const descriptors = Object.getOwnPropertyDescriptors(originalPromise);
+          delete descriptors.domain;
+
+          const inspectedPromise = originalPromise.then(
+            function (value) {
+              span.end();
+              return value;
+            },
+            function (err) {
+              span.end();
+              throw err;
+            },
+          );
+
+          Object.defineProperties(inspectedPromise, descriptors);
+
+          // we have to properly end the span when user aborts the request
+          shimmer.wrap(
+            inspectedPromise,
+            'abort',
+            function wrapAbort(originalAbort) {
+              return function wrappedAbort() {
+                if (span.ended) return;
+                agent.logger.debug(
+                  'intercepted call to elasticsearch.Transport.request.abort %o',
+                  { id, method, path },
+                );
+                const originalReturn = originalAbort.apply(this, args);
+                span.end();
+                return originalReturn;
+              };
+            },
+          );
+
+          return inspectedPromise;
+        }
+      } else {
+        agent.logger.debug('could not instrument elasticsearch request %o', {
+          id,
+        });
+        return original.apply(this, arguments);
+      }
+    };
+  }
+};

package/lib/instrumentation/modules/express-graphql.js

@@ -0,0 +1,66 @@
+/*
+ * 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 shimmer = require('../shimmer');
+
+module.exports = function (expressGraphql, agent, { version, enabled }) {
+  if (!enabled) {
+    return expressGraphql;
+  }
+
+  if (semver.satisfies(version, '>=0.10.0 <0.13.0')) {
+    // https://github.com/graphql/express-graphql/pull/626 changed `graphqlHTTP`
+    // to no longer be the top-level export:
+    //   {
+    //     graphqlHTTP: [Function: graphqlHTTP],
+    //     getGraphQLParams: [AsyncFunction: getGraphQLParams]
+    //   }
+    shimmer.wrap(expressGraphql, 'graphqlHTTP', wrapGraphqlHTTP);
+    return expressGraphql;
+  } else if (
+    semver.satisfies(version, '>=0.6.1 <0.10.0') &&
+    typeof expressGraphql === 'function'
+  ) {
+    // Up to and including 0.9.x, `require('express-graphql')` is:
+    //   [Function: graphqlHTTP] {
+    //     getGraphQLParams: [AsyncFunction: getGraphQLParams]
+    //   }
+    const wrappedGraphqlHTTP = wrapGraphqlHTTP(expressGraphql);
+    for (const key of Object.keys(expressGraphql)) {
+      wrappedGraphqlHTTP[key] = expressGraphql[key];
+    }
+    return wrappedGraphqlHTTP;
+  } else {
+    agent.logger.debug(
+      'express-graphql@%s not supported: skipping instrumentation',
+      version,
+    );
+    return expressGraphql;
+  }
+
+  function wrapGraphqlHTTP(origGraphqlHTTP) {
+    return function wrappedGraphqlHTTP() {
+      var orig = origGraphqlHTTP.apply(this, arguments);
+
+      if (typeof orig !== 'function') {
+        return orig;
+      }
+
+      // Express is very particular with the number of arguments!
+      return function (req, res) {
+        var trans = agent._instrumentation.currTransaction();
+        if (trans) {
+          trans._graphqlRoute = true;
+        }
+        return orig.apply(this, arguments);
+      };
+    };
+  }
+};

package/lib/instrumentation/modules/express-queue.js

@@ -0,0 +1,28 @@
+/*
+ * 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');
+
+module.exports = function (expressQueue, agent, { enabled }) {
+  if (!enabled) return expressQueue;
+
+  var ins = agent._instrumentation;
+
+  return function wrappedExpressQueue(config) {
+    var result = expressQueue(config);
+    shimmer.wrap(result.queue, 'createJob', function (original) {
+      return function (job) {
+        if (job.next) {
+          job.next = ins.bindFunction(job.next);
+        }
+        return original.apply(this, arguments);
+      };
+    });
+    return result;
+  };
+};