@redthreadlabs/tracelog 1.4.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/@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;
+};

package/lib/instrumentation/modules/@smithy/smithy-client.js

@@ -0,0 +1,198 @@
+/*
+ * 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 shimmer = require('../../shimmer');
+const elasticAPMMiddlewares = Symbol('elasticAPMMiddlewares');
+const {
+  DYNAMODB_NAME,
+  DYNAMODB_TYPE,
+  DYNAMODB_SUBTYPE,
+  dynamoDBMiddlewareFactory,
+  dynamoDBShouldIgnoreCommand,
+} = require('../@aws-sdk/client-dynamodb');
+const {
+  S3_NAME,
+  S3_TYPE,
+  S3_SUBTYPE,
+  s3MiddlewareFactory,
+  s3ShouldIgnoreCommand,
+} = require('../@aws-sdk/client-s3');
+const {
+  SNS_NAME,
+  SNS_TYPE,
+  SNS_SUBTYPE,
+  snsMiddlewareFactory,
+  snsShouldIgnoreCommand,
+} = require('../@aws-sdk/client-sns');
+
+const {
+  SQS_NAME,
+  SQS_TYPE,
+  SQS_SUBTYPE,
+  sqsMiddlewareFactory,
+  sqsShouldIgnoreCommand,
+} = require('../@aws-sdk/client-sqs');
+
+/**
+ * We do alias them to a local type
+ * @typedef {import('@aws-sdk/types').InitializeMiddleware} InitializeMiddleware
+ * @typedef {import('@aws-sdk/types').FinalizeRequestMiddleware } FinalizeRequestMiddleware
+ * @typedef {import('@aws-sdk/types').InitializeHandlerOptions} InitializeHandlerOptions
+ * @typedef {import('@aws-sdk/types').FinalizeRequestHandlerOptions } FinalizeRequestHandlerOptions
+ *
+ * Then create our types
+ * @typedef {InitializeMiddleware | FinalizeRequestMiddleware} AWSMiddleware
+ * @typedef {InitializeHandlerOptions | FinalizeRequestHandlerOptions} AWSMiddlewareOptions
+
+ * @typedef {object} AWSMiddlewareEntry
+ * @property {AWSMiddleware} middleware
+ * @property {AWSMiddlewareOptions} options
+ */
+
+const COMMAND_NAME_RE = /^(\w+)Command$/;
+/**
+ * TODO: this method may be shared with other instrumentations
+ * For a HeadObject API call, `context.commandName === 'HeadObjectCommand'`.
+ *
+ * @param {String} commandName
+ * @returns {String}
+ */
+function opNameFromCommandName(commandName) {
+  const match = COMMAND_NAME_RE.exec(commandName);
+  if (match) {
+    return match[1];
+  } else {
+    return '<unknown command>';
+  }
+}
+
+const clientsConfig = {
+  DynamoDBClient: {
+    NAME: DYNAMODB_NAME,
+    TYPE: DYNAMODB_TYPE,
+    SUBTYPE: DYNAMODB_SUBTYPE,
+    factory: dynamoDBMiddlewareFactory,
+    shouldIgnoreCommand: dynamoDBShouldIgnoreCommand,
+  },
+  S3Client: {
+    NAME: S3_NAME,
+    TYPE: S3_TYPE,
+    SUBTYPE: S3_SUBTYPE,
+    factory: s3MiddlewareFactory,
+    shouldIgnoreCommand: s3ShouldIgnoreCommand,
+  },
+  SNSClient: {
+    NAME: SNS_NAME,
+    TYPE: SNS_TYPE,
+    SUBTYPE: SNS_SUBTYPE,
+    factory: snsMiddlewareFactory,
+    shouldIgnoreCommand: snsShouldIgnoreCommand,
+  },
+  SQSClient: {
+    NAME: SQS_NAME,
+    TYPE: SQS_TYPE,
+    SUBTYPE: SQS_SUBTYPE,
+    factory: sqsMiddlewareFactory,
+    shouldIgnoreCommand: sqsShouldIgnoreCommand,
+  },
+};
+
+module.exports = function (mod, agent, { name, version, enabled }) {
+  if (!enabled) return mod;
+
+  // As of `@aws-sdk/*@3.363.0` the underlying smithy-client is under the
+  // `@smithy/` npm org.
+  if (
+    name === '@smithy/smithy-client' &&
+    !semver.satisfies(version, '>=1 <5')
+  ) {
+    agent.logger.debug(
+      'cannot instrument @aws-sdk/client-*: @smithy/smithy-client version %s not supported',
+      version,
+    );
+    return mod;
+  } else if (
+    name === '@aws-sdk/smithy-client' &&
+    !semver.satisfies(version, '>=3 <4')
+  ) {
+    agent.logger.debug(
+      'cannot instrument @aws-sdk/client-*: @aws-sdk/smithy-client version %s not supported',
+      version,
+    );
+    return mod;
+  }
+
+  shimmer.wrap(mod.Client.prototype, 'send', function (orig) {
+    return function _wrappedSmithyClientSend() {
+      const clientName = this.constructor && this.constructor.name;
+      const clientConfig = clientsConfig[clientName];
+
+      if (!clientConfig) {
+        return orig.apply(this, arguments);
+      }
+
+      if (!this[elasticAPMMiddlewares]) {
+        const factory = clientConfig && clientConfig.factory;
+        const middlewares =
+          typeof factory === 'function' ? factory(this, agent) : [];
+
+        // We do the instrumentation by leveraging the middleware mechanism provided by the
+        // middlewareStack property of the Client instance. We add the instrumentation middlewares
+        // once at the client level so they persist for the whole life of the client instance
+        // https://github.com/aws/aws-sdk-js-v3/tree/main/packages/middleware-stack
+        this[elasticAPMMiddlewares] = middlewares;
+        for (const item of this[elasticAPMMiddlewares]) {
+          this.middlewareStack.add(item.middleware, item.options);
+        }
+      }
+
+      const command = arguments[0];
+
+      if (clientConfig.shouldIgnoreCommand(command, agent._conf)) {
+        return orig.apply(this, arguments);
+      }
+
+      const opName = opNameFromCommandName(command.constructor.name);
+      const name = clientConfig.NAME + ' ' + opName;
+
+      const ins = agent._instrumentation;
+      const span = ins.createSpan(
+        name,
+        clientConfig.TYPE,
+        clientConfig.SUBTYPE,
+        opName,
+        { exitSpan: true },
+      );
+
+      if (!span) {
+        return orig.apply(this, arguments);
+      }
+
+      // Run context notes: The `orig` should run in the context of the S3 span,
+      // because that is the point. The user's callback `cb` should run outside of
+      // the S3 span.
+      const parentRunContext = ins.currRunContext();
+      const spanRunContext = parentRunContext.enterSpan(span);
+
+      // Although the client consumer may use the Promise API `S3Client.send(command).then(...)`
+      // the clients may make use of the callback parameter on the super class method (SmithyClient)
+      // therefore we need to have this check
+      const cb = arguments[arguments.length - 1];
+      if (typeof cb === 'function') {
+        arguments[arguments.length - 1] = ins.bindFunctionToRunContext(
+          parentRunContext,
+          cb,
+        );
+      }
+
+      return ins.withRunContext(spanRunContext, orig, this, ...arguments);
+    };
+  });
+  return mod;
+};

package/lib/instrumentation/modules/apollo-server-core.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.
+ */
+
+'use strict';
+
+const semver = require('semver');
+const shimmer = require('../shimmer');
+const clone = require('shallow-clone-shim');
+
+module.exports = function (apolloServerCore, agent, { version, enabled }) {
+  if (!enabled) return apolloServerCore;
+
+  if (!semver.satisfies(version, '^2.0.2 || ^3.0.0')) {
+    agent.logger.debug(
+      'apollo-server-core version %s not supported - aborting...',
+      version,
+    );
+    return apolloServerCore;
+  }
+
+  function wrapRunHttpQuery(orig) {
+    return function wrappedRunHttpQuery() {
+      var trans = agent._instrumentation.currTransaction();
+      if (trans) trans._graphqlRoute = true;
+      return orig.apply(this, arguments);
+    };
+  }
+
+  if (semver.satisfies(version, '<2.14')) {
+    shimmer.wrap(apolloServerCore, 'runHttpQuery', wrapRunHttpQuery);
+    return apolloServerCore;
+  }
+
+  // apollo-server-core >= 2.14 does not allow overriding the exports object
+  return clone({}, apolloServerCore, {
+    runHttpQuery(descriptor) {
+      const getter = descriptor.get;
+      if (getter) {
+        descriptor.get = function get() {
+          return wrapRunHttpQuery(getter());
+        };
+      }
+      return descriptor;
+    },
+  });
+};