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

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/_lambda-handler.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 propwrap = require('../../propwrap');
+
+/**
+ * Return a patch handler, `function (module, agent, options)`, that will patch
+ * the Lambda handler function at the given property path.
+ *
+ * For example, a Lambda _HANDLER=index.handler indicates that a file "index.js"
+ * has a `handler` export that is the Lambda handler function. In this case
+ * `module` will be the imported "index.js" module and `propPath` will be
+ * "handler".
+ */
+function createLambdaPatcher(propPath) {
+  return function lambdaHandlerPatcher(module, agent, { enabled }) {
+    if (!enabled) {
+      return module;
+    }
+
+    try {
+      const newMod = propwrap.wrap(module, propPath, (orig) => {
+        return agent.lambda(orig);
+      });
+      return newMod;
+    } catch (wrapErr) {
+      agent.logger.warn('could not wrap lambda handler: %s', wrapErr);
+      return module;
+    }
+  };
+}
+
+module.exports = {
+  createLambdaPatcher,
+};

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;
+    },
+  });
+};

package/lib/instrumentation/modules/aws-sdk/dynamodb.js

@@ -0,0 +1,155 @@
+/*
+ * 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 TYPE = 'db';
+const SUBTYPE = 'dynamodb';
+const ACTION = 'query';
+
+function getRegionFromRequest(request) {
+  return (
+    request &&
+    request.service &&
+    request.service.config &&
+    request.service.config.region
+  );
+}
+
+function getPortFromRequest(request) {
+  return (
+    request &&
+    request.service &&
+    request.service.endpoint &&
+    request.service.endpoint.port
+  );
+}
+
+function getMethodFromRequest(request) {
+  const method = request && request.operation;
+  if (method) {
+    return method[0].toUpperCase() + method.slice(1);
+  }
+}
+
+function getStatementFromRequest(request) {
+  const method = getMethodFromRequest(request);
+  if (
+    method === 'Query' &&
+    request &&
+    request.params &&
+    request.params.KeyConditionExpression
+  ) {
+    return request.params.KeyConditionExpression;
+  }
+  return undefined;
+}
+
+function getAddressFromRequest(request) {
+  return (
+    request &&
+    request.service &&
+    request.service.endpoint &&
+    request.service.endpoint.hostname
+  );
+}
+
+function getTableFromRequest(request) {
+  const table = request && request.params && request.params.TableName;
+  if (!table) {
+    return '';
+  }
+  return ` ${table}`;
+}
+
+// Creates the span name from request information
+function getSpanNameFromRequest(request) {
+  const method = getMethodFromRequest(request);
+  const table = getTableFromRequest(request);
+  const name = `DynamoDB ${method}${table}`;
+  return name;
+}
+
+function shouldIgnoreRequest(request, agent) {
+  return false;
+}
+
+// Main entrypoint for SQS instrumentation
+//
+// Must call (or one of its function calls must call) the
+// `orig` function/method
+function instrumentationDynamoDb(
+  orig,
+  origArguments,
+  request,
+  AWS,
+  agent,
+  { version, enabled },
+) {
+  if (shouldIgnoreRequest(request, agent)) {
+    return orig.apply(request, origArguments);
+  }
+
+  const ins = agent._instrumentation;
+  const name = getSpanNameFromRequest(request);
+  const span = ins.createSpan(name, TYPE, SUBTYPE, ACTION, { exitSpan: true });
+  if (!span) {
+    return orig.apply(request, origArguments);
+  }
+
+  const region = getRegionFromRequest(request);
+  const dbContext = {
+    type: SUBTYPE,
+    instance: region,
+  };
+  const dbStatement = getStatementFromRequest(request);
+  if (dbStatement) {
+    dbContext.statement = dbStatement;
+  }
+  span.setDbContext(dbContext);
+  span._setDestinationContext({
+    address: getAddressFromRequest(request),
+    port: getPortFromRequest(request),
+    cloud: {
+      region,
+    },
+  });
+
+  const onComplete = function (response) {
+    if (response && response.error) {
+      agent.captureError(response.error);
+    }
+    span.end();
+  };
+  // Bind onComplete to the span's run context so that `captureError` picks
+  // up the correct currentSpan.
+  const parentRunContext = ins.currRunContext();
+  const spanRunContext = parentRunContext.enterSpan(span);
+  request.on(
+    'complete',
+    ins.bindFunctionToRunContext(spanRunContext, onComplete),
+  );
+
+  const cb = origArguments[origArguments.length - 1];
+  if (typeof cb === 'function') {
+    origArguments[origArguments.length - 1] = ins.bindFunctionToRunContext(
+      parentRunContext,
+      cb,
+    );
+  }
+  return ins.withRunContext(spanRunContext, orig, request, ...origArguments);
+}
+
+module.exports = {
+  instrumentationDynamoDb,
+
+  // exported for testing
+  getRegionFromRequest,
+  getPortFromRequest,
+  getStatementFromRequest,
+  getAddressFromRequest,
+  getMethodFromRequest,
+};

package/lib/instrumentation/modules/aws-sdk/s3.js

@@ -0,0 +1,184 @@
+/*
+ * 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 AWS S3 operations via the 'aws-sdk' package.
+
+const constants = require('../../../constants');
+
+const TYPE = 'storage';
+const SUBTYPE = 's3';
+
+// Return the PascalCase operation name from `request.operation` by undoing to
+// `lowerFirst()` from
+// https://github.com/aws/aws-sdk-js/blob/c0c44b8a4e607aae521686898f39a3e359f727e4/lib/model/api.js#L63-L65
+//
+// For example: 'headBucket' -> 'HeadBucket'
+function opNameFromOperation(operation) {
+  return operation[0].toUpperCase() + operation.slice(1);
+}
+
+// Return an APM "resource" string for the bucket, Access Point ARN, or Outpost
+// ARN. ARNs are normalized to a shorter resource name.
+//
+// Known ARN patterns:
+// - arn:aws:s3:<region>:<account-id>:accesspoint/<accesspoint-name>
+// - arn:aws:s3-outposts:<region>:<account>:outpost/<outpost-id>/bucket/<bucket-name>
+// - arn:aws:s3-outposts:<region>:<account>:outpost/<outpost-id>/accesspoint/<accesspoint-name>
+//
+// In general that is:
+//    arn:$partition:$service:$region:$accountId:$resource
+//
+// This parses using the same "split on colon" used by the JavaScript AWS SDK v3.
+// https://github.com/aws/aws-sdk-js-v3/blob/v3.18.0/packages/util-arn-parser/src/index.ts#L14-L37
+function resourceFromBucket(bucket) {
+  let resource = null;
+  if (bucket) {
+    resource = bucket;
+    if (resource.startsWith('arn:')) {
+      resource = bucket.split(':').slice(5).join(':');
+    }
+  }
+  return resource;
+}
+
+// Instrument an awk-sdk@2.x operation (i.e. a AWS.Request.send or
+// AWS.Request.promise).
+//
+// @param {AWS.Request} request https://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/Request.html
+function instrumentationS3(
+  orig,
+  origArguments,
+  request,
+  AWS,
+  agent,
+  { version, enabled },
+) {
+  const opName = opNameFromOperation(request.operation);
+  const params = request.params;
+  const bucket = params && params.Bucket;
+  const resource = resourceFromBucket(bucket);
+  let name = 'S3 ' + opName;
+  if (resource) {
+    name += ' ' + resource;
+  }
+
+  const ins = agent._instrumentation;
+
+  const span = ins.createSpan(name, TYPE, SUBTYPE, opName, { exitSpan: true });
+  if (!span) {
+    return orig.apply(request, origArguments);
+  }
+
+  // As for now OTel spec defines attributes for operations that require a Bucket
+  // if that changes we should review this guard
+  // https://github.com/open-telemetry/opentelemetry-specification/blob/v1.20.0/semantic_conventions/trace/instrumentation/aws-sdk.yml#L435
+  if (bucket) {
+    const otelAttrs = span._getOTelAttributes();
+
+    otelAttrs['aws.s3.bucket'] = bucket;
+
+    if (params.Key) {
+      otelAttrs['aws.s3.key'] = params.Key;
+    }
+  }
+
+  const onComplete = function (response) {
+    // `response` is an AWS.Response
+    // https://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/Response.html
+
+    // Determining the bucket's region.
+    // `request.httpRequest.region` isn't documented, but the aws-sdk@2
+    // lib/services/s3.js will set it to the bucket's determined region.
+    // This can be asynchronously determined -- e.g. if it differs from the
+    // configured service endpoint region -- so this won't be set until
+    // 'complete'.
+    const httpRequest = request.httpRequest;
+    const region = httpRequest && httpRequest.region;
+
+    span.setServiceTarget('s3', resource);
+    const destContext = {};
+    // '.httpRequest.endpoint' might differ from '.service.endpoint' if
+    // the bucket is in a different region.
+    const endpoint = httpRequest && httpRequest.endpoint;
+    if (endpoint) {
+      destContext.address = endpoint.hostname;
+      destContext.port = endpoint.port;
+    }
+    if (region) {
+      destContext.cloud = { region };
+    }
+    span._setDestinationContext(destContext);
+
+    if (response) {
+      // https://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/HttpResponse.html
+      const httpResponse = response.httpResponse;
+      let statusCode;
+      if (httpResponse) {
+        statusCode = httpResponse.statusCode;
+
+        // Set HTTP context. Some context not being set, though it is available:
+        // - method: Not that helpful.
+        // - url: Mostly redundant with context.destination.address.
+        // - response.headers: A lot of added size for uncertain utility. The
+        //   inclusion of Amazon's request ID headers might be worth it.
+        const httpContext = {
+          status_code: statusCode,
+        };
+        const encodedBodySize =
+          Buffer.isBuffer(httpResponse.body) && httpResponse.body.byteLength;
+        if (encodedBodySize) {
+          // I'm not actually sure if this might be decoded_body_size.
+          httpContext.response = { encoded_body_size: encodedBodySize };
+        }
+        span.setHttpContext(httpContext);
+      }
+
+      // Follow the spec for HTTP client span outcome.
+      // https://github.com/elastic/apm/blob/main/specs/agents/tracing-instrumentation-http.md#outcome
+      //
+      // For example, a S3 GetObject conditional request (e.g. using the
+      // IfNoneMatch param) will respond with response.error=NotModifed and
+      // statusCode=304. This is a *successful* outcome.
+      if (statusCode) {
+        span._setOutcomeFromHttpStatusCode(statusCode);
+      } else {
+        // `statusCode` will be undefined for errors before sending a request, e.g.:
+        //  InvalidConfiguration: Custom endpoint is not compatible with access point ARN
+        span._setOutcomeFromErrorCapture(constants.OUTCOME_FAILURE);
+      }
+
+      if (response.error && (!statusCode || statusCode >= 400)) {
+        agent.captureError(response.error, { skipOutcome: true });
+      }
+    }
+
+    span.end();
+  };
+
+  // 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);
+  const cb = origArguments[origArguments.length - 1];
+  if (typeof cb === 'function') {
+    origArguments[origArguments.length - 1] = ins.bindFunctionToRunContext(
+      parentRunContext,
+      cb,
+    );
+  }
+  request.on(
+    'complete',
+    ins.bindFunctionToRunContext(spanRunContext, onComplete),
+  );
+  return ins.withRunContext(spanRunContext, orig, request, ...origArguments);
+}
+
+module.exports = {
+  instrumentationS3,
+};