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

package/lib/instrumentation/modules/@hapi/hapi.js

@@ -0,0 +1,221 @@
+/*
+ * 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 onPreAuthSym = Symbol('ElasticAPMOnPreAuth');
+
+// Collect simple data a Hapi `event.data` object, typically from a Hapi
+// 'log' or 'request' server event (https://hapi.dev/api/#server.events). This
+// limits to including simple property values (bool, string, number, Date) to
+// limit the possibility of accidentally capturing huge data in `captureError`
+// below.
+//
+// This implementation is based on lib/errors.js#attributesFromErr.
+function simpleDataFromEventData(agent, eventData) {
+  try {
+    let simpleRepr = simpleReprFromVal(eventData);
+    if (simpleRepr !== undefined) {
+      return simpleRepr;
+    }
+
+    let n = 0;
+    const attrs = {};
+    const keys = Object.keys(eventData);
+    for (let i = 0; i < keys.length; i++) {
+      const key = keys[i];
+      let val = eventData[key];
+      simpleRepr = simpleReprFromVal(val);
+      if (simpleRepr) {
+        attrs[key] = simpleRepr;
+        n++;
+      }
+    }
+    return n ? attrs : undefined;
+  } catch (err) {
+    agent.logger.trace(
+      'hapi: could not gather simple attrs from event data: ' + err.message,
+    );
+  }
+}
+
+// If `val` is a "simple" type (bool, string, number, Date), then return a
+// reasonable value to represent it in a JSON serialization. Otherwise, return
+// undefined.
+function simpleReprFromVal(val) {
+  switch (typeof val) {
+    case 'boolean':
+    case 'string':
+    case 'number':
+      break;
+    case 'object':
+      // Ignore all objects except Dates.
+      if (
+        val === null ||
+        typeof val.toISOString !== 'function' ||
+        typeof val.getTime !== 'function'
+      ) {
+        return;
+      } else if (Number.isNaN(val.getTime())) {
+        val = 'Invalid Date'; // calling toISOString() on invalid dates throws
+      } else {
+        val = val.toISOString();
+      }
+      break;
+    default:
+      return;
+  }
+  return val;
+}
+
+module.exports = function (hapi, agent, { version, enabled }) {
+  if (!enabled) {
+    return hapi;
+  }
+  if (!semver.satisfies(version, '>=17.9.0 <22.0.0')) {
+    agent.logger.debug('@hapi/hapi@%s not supported, skipping', version);
+    return hapi;
+  }
+
+  agent.setFramework({ name: 'hapi', version, overwrite: false });
+
+  agent.logger.debug('shimming hapi.Server, hapi.server');
+  shimmer.massWrap(hapi, ['Server', 'server'], function (orig) {
+    return function (options) {
+      var res = orig.apply(this, arguments);
+      patchServer(res);
+      return res;
+    };
+  });
+
+  function patchServer(server) {
+    // Hooks that are always allowed
+    if (typeof server.on === 'function') {
+      attachEvents(server);
+    } else if (typeof server.events.on === 'function') {
+      attachEvents(server.events);
+    } else {
+      agent.logger.debug('unable to enable hapi error tracking');
+    }
+
+    server.ext('onPreAuth', onPreAuth);
+    server.ext('onPreResponse', onPreResponse);
+    if (agent._conf.captureBody !== 'off') {
+      server.ext('onPostAuth', onPostAuth);
+    }
+  }
+
+  function attachEvents(emitter) {
+    emitter.on('log', function (event, tags) {
+      captureError('log', null, event, tags);
+    });
+
+    emitter.on('request', function (req, event, tags) {
+      captureError('request', req, event, tags);
+    });
+  }
+
+  function captureError(type, req, event, tags) {
+    if (!event || !tags.error || event.channel === 'internal') {
+      return;
+    }
+
+    // Hapi 'log' and 'request' events (https://hapi.dev/api/#server.events)
+    // have `event.error`, `event.data`, or neither.
+    // `agent.captureError` requires an Error instance or string for its first
+    // arg: bias to getting that, then any other data add to `opts.custom.data`.
+    const info = event.error || event.data;
+    let errOrStr, data;
+    if (info instanceof Error || typeof info === 'string') {
+      errOrStr = info;
+    } else if (info) {
+      data = simpleDataFromEventData(agent, info);
+    }
+    if (!errOrStr) {
+      errOrStr = 'hapi server emitted a "' + type + '" event tagged "error"';
+    }
+
+    agent.captureError(errOrStr, {
+      custom: {
+        tags: event.tags,
+        data,
+      },
+      request: req && req.raw && req.raw.req,
+    });
+  }
+
+  function onPreAuth(request, reply) {
+    agent.logger.debug('received hapi onPreAuth event');
+
+    // Record the fact that the preAuth extension have been called. This
+    // info is useful later to know if this is a CORS preflight request
+    // that is automatically handled by hapi (as those will not trigger
+    // the onPreAuth extention)
+    request[onPreAuthSym] = true;
+
+    if (request.route) {
+      // fingerprint was introduced in hapi 11 and is a little more
+      // stable in case the param names change
+      // - path example: /foo/{bar*2}
+      // - fingerprint example: /foo/?/?
+      var fingerprint = request.route.fingerprint || request.route.path;
+
+      if (fingerprint) {
+        var name =
+          (request.raw && request.raw.req && request.raw.req.method) ||
+          (request.route.method && request.route.method.toUpperCase());
+
+        if (typeof name === 'string') {
+          name = name + ' ' + fingerprint;
+        } else {
+          name = fingerprint;
+        }
+
+        agent._instrumentation.setDefaultTransactionName(name);
+      }
+    }
+
+    return reply.continue;
+  }
+
+  function onPostAuth(request, reply) {
+    if (request.payload && request.raw && request.raw.req) {
+      // Save the parsed req body to be picked up by getContextFromRequest().
+      request.raw.req.payload = request.payload;
+    }
+    return reply.continue;
+  }
+
+  function onPreResponse(request, reply) {
+    agent.logger.debug('received hapi onPreResponse event');
+
+    // Detection of CORS preflight requests:
+    // There is no easy way in hapi to get the matched route for a
+    // CORS preflight request that matches any of the autogenerated
+    // routes created by hapi when `cors: true`. The best solution is to
+    // detect the request "fingerprint" using the magic if-sentence below
+    // and group all those requests into on type of transaction
+    if (
+      !request[onPreAuthSym] &&
+      request.route &&
+      request.route.path === '/{p*}' &&
+      request.raw &&
+      request.raw.req &&
+      request.raw.req.method === 'OPTIONS' &&
+      request.raw.req.headers['access-control-request-method']
+    ) {
+      agent._instrumentation.setDefaultTransactionName('CORS preflight');
+    }
+
+    return reply.continue;
+  }
+
+  return hapi;
+};

package/lib/instrumentation/modules/@opentelemetry/api.js

@@ -0,0 +1,86 @@
+/*
+ * 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';
+
+// Instrument `.metrics.getMeterProvider()` from `@opentelemetry/api` to
+// provide an Elastic APM provider if user code hasn't registered one itself.
+//
+// This covers use case 2 in the OTel metrics spec:
+// https://github.com/elastic/apm/blob/main/specs/agents/metrics-otel.md#exporter-installation
+
+const semver = require('semver');
+
+const {
+  isOTelMetricsFeatSupported,
+} = require('../../../opentelemetry-metrics');
+const shimmer = require('../../shimmer');
+
+/**
+ * `otel.metrics.getMeterProvider()` returns a singleton instance of the
+ * internal `NoopMeterProvider` class if no global meter provider has been
+ * set. There isn't an explicitly API to determine if a provider is a noop
+ * one. This function attempts to sniff that out.
+ *
+ * We cannot rely on comparing to the `NOOP_METER_PROVIDER` exported by
+ * "src/metrics/NoopMeterProvider.ts" because there might be multiple
+ * "@opentelemetry/api" packages in play.
+ *
+ * @param {import('@opentelemetry/api').MeterProvider}
+ * @returns {boolean}
+ */
+function isNoopMeterProvider(provider) {
+  return !!(
+    provider &&
+    provider.constructor &&
+    provider.constructor.name === 'NoopMeterProvider'
+  );
+}
+
+module.exports = function (mod, agent, { version, enabled }) {
+  const log = agent.logger;
+
+  if (!enabled) {
+    return mod;
+  }
+  if (!agent._isMetricsEnabled()) {
+    log.trace(
+      'metrics are not enabled, skipping @opentelemetry/api instrumentation',
+      version,
+    );
+    return mod;
+  }
+  if (!semver.satisfies(version, '>=1.3.0 <2', { includePrerelease: true })) {
+    log.debug(
+      '@opentelemetry/api version %s not supported, skipping @opentelemetry/api instrumentation',
+      version,
+    );
+    return mod;
+  }
+  if (!isOTelMetricsFeatSupported) {
+    log.debug(
+      'elastic-apm-node OTel Metrics support does not support node %s, skipping @opentelemetry/api instrumentation',
+      process.version,
+    );
+    return mod;
+  }
+
+  log.debug('shimming @opentelemetry/api .metrics.getMeterProvider()');
+  shimmer.wrap(mod.metrics, 'getMeterProvider', wrapGetMeterProvider);
+
+  return mod;
+
+  function wrapGetMeterProvider(orig) {
+    return function wrappedGetMeterProvider() {
+      const provider = orig.apply(this, arguments);
+      if (!isNoopMeterProvider(provider)) {
+        return provider;
+      }
+      const elMeterProvider = agent._getOrCreateOTelMeterProvider();
+      return elMeterProvider || provider;
+    };
+  }
+};

package/lib/instrumentation/modules/@opentelemetry/sdk-metrics.js

@@ -0,0 +1,79 @@
+/*
+ * 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 instruments '@opentelemetry/sdk-metrics' to automatically add a metric
+// reader to any `MeterProvider` created by user code. The added metric
+// reader will export metrics to the configured APM server.
+//
+// This covers use case 1 in the OTel metrics spec:
+// https://github.com/elastic/apm/blob/main/specs/agents/metrics-otel.md#exporter-installation
+//
+// Dev Note: This avoids instrumenting the `MeterProvider` used *internally*
+// by the APM agent itself (see "lib/opentelemetry-metrics/index.js") because
+// that file imports `MeterProvider` before the APM agent is started.
+
+const semver = require('semver');
+
+const {
+  isOTelMetricsFeatSupported,
+  createOTelMetricReader,
+} = require('../../../opentelemetry-metrics');
+
+module.exports = function (mod, agent, { version, enabled }) {
+  const log = agent.logger;
+
+  if (!enabled) {
+    return mod;
+  }
+  if (!agent._isMetricsEnabled()) {
+    log.trace(
+      'metrics are not enabled, skipping @opentelemetry/sdk-metrics instrumentation',
+      version,
+    );
+    return mod;
+  }
+  // Minimum supported version is 1.11.0 because that version included the fix
+  // for side-effects from having two MetricReaders.
+  // https://github.com/open-telemetry/opentelemetry-js/issues/3664
+  if (!semver.satisfies(version, '>=1.11.0 <2', { includePrerelease: true })) {
+    log.debug(
+      '@opentelemetry/sdk-metrics@%s is not supported, skipping @opentelemetry/sdk-metrics instrumentation',
+      version,
+    );
+    return mod;
+  }
+  if (!isOTelMetricsFeatSupported) {
+    log.debug(
+      'elastic-apm-node OTel Metrics feature does not support node %s, skipping @opentelemetry/sdk-metrics instrumentation',
+      process.version,
+    );
+    return mod;
+  }
+
+  class ApmMeterProvider extends mod.MeterProvider {
+    constructor(...args) {
+      super(...args);
+      // We create a new metric reader for each new MeterProvider instance,
+      // because they shutdown independently -- they cannot be shared between
+      // multiple MeterProviders.
+      log.trace(
+        '@opentelemetry/sdk-metrics ins: create Elastic APM MetricReader',
+      );
+      this.addMetricReader(createOTelMetricReader(agent));
+    }
+  }
+  Object.defineProperty(mod, 'MeterProvider', {
+    configurable: true,
+    enumerable: true,
+    get: function () {
+      return ApmMeterProvider;
+    },
+  });
+
+  return mod;
+};

package/lib/instrumentation/modules/@redis/client/dist/lib/client/commands-queue.js

@@ -0,0 +1,178 @@
+/*
+ * 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.
+ */
+
+const semver = require('semver');
+const { getDBDestination } = require('../../../../../../context');
+const { redisClientOptions } = require('../../../../../../../../lib/symbols');
+const destinationContext = Symbol('destinationContext');
+
+const TYPE = 'db';
+const SUBTYPE = 'redis';
+const ACTION = 'query';
+
+// From https://redis.io/commands/ this is the set of redis commands that have
+// *two* tokens for the full command name.
+const IS_COMMAND_PREFIX = new Set([
+  'ACL',
+  'CLIENT',
+  'CLUSTER',
+  'COMMAND',
+  'CONFIG',
+  'FUNCTION', // e.g. FUNCTION LOAD
+  'LATENCY',
+  'MEMORY',
+  'MODULE',
+  'OBJECT',
+  'PUBSUB',
+  'SCRIPT',
+  'SLOWLOG',
+  'XGROUP',
+  'XINFO',
+]);
+
+/**
+ * Return the redis command name from the given `RedisCommandArguments`.
+ *
+ *    export type RedisCommandArgument = string | Buffer;
+ *    export type RedisCommandArguments = Array<RedisCommandArgument> & { preserve?: unknown };
+ *
+ * Examples:
+ *    > commandNameFromArgs(['PING'])
+ *    'PING'
+ *    > commandNameFromArgs(['SET', 'foo', 'bar'])
+ *    'SET'
+ *    > commandNameFromArgs(['ACL', 'SETUSER', 'karin', 'on', '+@all', '-@dangerous'])
+ *    'ACL SETUSER'
+ */
+function commandNameFromArgs(args) {
+  if (IS_COMMAND_PREFIX.has(args[0]) && args.length >= 2) {
+    return args.slice(0, 2).join(' ');
+  } else {
+    return args[0];
+  }
+}
+
+module.exports = function (mod, agent, { version, enabled }) {
+  if (!enabled) {
+    return mod;
+  }
+  if (!semver.satisfies(version, '>=1 <2')) {
+    agent.logger.debug(
+      '@redis/client/dist/lib/client version %s not supported - aborting...',
+      version,
+    );
+    return mod;
+  }
+
+  const RedisCommandsQueue = mod.default;
+  if (
+    !(
+      RedisCommandsQueue &&
+      RedisCommandsQueue.name === 'RedisCommandsQueue' &&
+      RedisCommandsQueue.prototype &&
+      typeof RedisCommandsQueue.prototype.addCommand === 'function'
+    )
+  ) {
+    agent.logger.debug('cannot instrument @redis/client');
+    return mod;
+  }
+
+  const ins = agent._instrumentation;
+
+  agent.logger.debug(
+    'shimming @redis/client RedisCommandsQueue.prototype.addCommand',
+  );
+
+  class RedisCommandsQueueTraced extends RedisCommandsQueue {
+    constructor() {
+      super(arguments);
+
+      // Determine destination context to use for Redis spans, using the
+      // RedisClient `options` passed down from RedisClient.create instrumentation.
+      if (ins[redisClientOptions]) {
+        // https://github.com/redis/node-redis/blob/master/docs/client-configuration.md
+        // Reproducing determination of 'address' and 'port' per
+        // `RedisClient.#initializeOptions()`
+        let address = 'localhost';
+        let port = 6379;
+        if (ins[redisClientOptions].url) {
+          const parsed = new URL(ins[redisClientOptions].url);
+          address = parsed.hostname;
+          if (parsed.port) {
+            port = parsed.port;
+          }
+        }
+        if (ins[redisClientOptions].socket) {
+          if (ins[redisClientOptions].socket.host) {
+            address = ins[redisClientOptions].socket.host;
+          }
+          if (
+            ins[redisClientOptions].socket.port &&
+            !isNaN(Number(ins[redisClientOptions].socket.port))
+          ) {
+            port = Number(ins[redisClientOptions].socket.port);
+          }
+        }
+
+        this[destinationContext] = getDBDestination(address, port);
+      }
+    }
+
+    addCommand(args) {
+      const commandName = commandNameFromArgs(args);
+      agent.logger.debug(
+        { commandName },
+        'intercepted call to @redis/client RedisCommandsQueue.prototype.addCommand',
+      );
+      const span = ins.createSpan(
+        commandName.toUpperCase(),
+        TYPE,
+        SUBTYPE,
+        ACTION,
+        { exitSpan: true },
+      );
+      if (!span) {
+        return super.addCommand.apply(this, arguments);
+      }
+
+      span.setDbContext({ type: 'redis' });
+
+      if (this[destinationContext]) {
+        span._setDestinationContext(this[destinationContext]);
+      }
+
+      const parentRunContext = ins.currRunContext();
+      const spanRunContext = parentRunContext.enterSpan(span);
+      const finish = ins.bindFunctionToRunContext(spanRunContext, (err) => {
+        if (err) {
+          agent.captureError(err);
+        }
+        span.end();
+      });
+
+      const promise = super.addCommand.apply(this, arguments);
+      if (promise.then) {
+        promise.then(
+          function onResolve(_result) {
+            finish(null);
+          },
+          function onReject(err) {
+            finish(err);
+          },
+        );
+      } else {
+        // didn't get back the expected promose -- just end the
+        // span now and accept that those spans will be bogus
+        // (sync, zero-ish elapsed time).
+        span.end();
+      }
+      return promise;
+    }
+  }
+  mod.default = RedisCommandsQueueTraced;
+
+  return mod;
+};

package/lib/instrumentation/modules/@redis/client/dist/lib/client/index.js

@@ -0,0 +1,49 @@
+/*
+ * 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.
+ */
+
+// Shim @redis/client's `RedisClient.create` to pass client options down to
+// the `RedisCommandsQueue` instrumentation in ./client/commands-queue.js.
+const semver = require('semver');
+const shimmer = require('../../../../../../shimmer');
+const { redisClientOptions } = require('../../../../../../../../lib/symbols');
+
+module.exports = function (mod, agent, { version, enabled }) {
+  if (!enabled) {
+    return mod;
+  }
+  if (!semver.satisfies(version, '>=1 <2')) {
+    agent.logger.debug(
+      '@redis/client/dist/lib/client version %s not supported - aborting...',
+      version,
+    );
+    return mod;
+  }
+
+  const RedisClient = mod.default;
+  if (!(RedisClient && typeof RedisClient.create === 'function')) {
+    agent.logger.debug('cannot instrument @redis/client RedisClient');
+    return mod;
+  }
+
+  const ins = agent._instrumentation;
+
+  agent.logger.debug('shimming @redis/client RedisClient.create');
+  shimmer.wrap(RedisClient, 'create', function wrap(origCreate) {
+    return function wrappedCreate(options) {
+      // Capture the RedisClient options for just the synchronous run of the
+      // create function. We are relying on the RedisClient constructor
+      // synchronously creating its RedisCommandsQueue, which we've wrapped
+      // to pick up these options. This allows the queue instance to determine
+      // the appropriate destination context for spans it creates.
+      ins[redisClientOptions] = options;
+      const rv = origCreate.apply(this, arguments);
+      delete ins[redisClientOptions];
+      return rv;
+    };
+  });
+
+  return mod;
+};