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

package/lib/instrumentation/modules/@apollo/server.js

@@ -0,0 +1,30 @@
+/*
+ * 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 shimmer = require('../../shimmer');
+
+module.exports = function (apolloServer, agent, { enabled }) {
+  if (!enabled) {
+    return apolloServer;
+  }
+
+  function wrapExecuteHTTPGraphQLRequest(orig) {
+    return function wrappedExecuteHTTPGraphQLRequest() {
+      var trans = agent._instrumentation.currTransaction();
+      if (trans) trans._graphqlRoute = true;
+      return orig.apply(this, arguments);
+    };
+  }
+
+  shimmer.wrap(
+    apolloServer.ApolloServer.prototype,
+    'executeHTTPGraphQLRequest',
+    wrapExecuteHTTPGraphQLRequest,
+  );
+  return apolloServer;
+};

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

@@ -0,0 +1,143 @@
+/*
+ * 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 constants = require('../../../constants');
+const NAME = 'DynamoDB';
+const TYPE = 'db';
+const SUBTYPE = 'dynamodb';
+const elasticAPMStash = Symbol('elasticAPMStash');
+
+/**
+ * Returns middlewares to instrument an S3Client instance
+ *
+ * @param {import('@aws-sdk/client-dynamodb').DynamoDBClient} client
+ * @param {any} agent
+ * @returns {import('../@smithy/smithy-client').AWSMiddlewareEntry[]}
+ */
+function dynamoDBMiddlewareFactory(client, agent) {
+  return [
+    {
+      middleware: (next, context) => async (args) => {
+        // Ensure there is a span from the wrapped `client.send()`.
+        const span = agent._instrumentation.currSpan();
+        if (!span || !(span.type === TYPE && span.subtype === SUBTYPE)) {
+          return await next(args);
+        }
+
+        const input = args.input;
+        const table = input && input.TableName;
+        // The given span comes with the operation name and we need to
+        // add the table if applies
+        if (table) {
+          span.name += ' ' + table;
+        }
+
+        let err;
+        let result;
+        let response;
+        let statusCode;
+        try {
+          result = await next(args);
+          response = result && result.response;
+          statusCode = response && response.statusCode;
+        } catch (ex) {
+          // Save the error for use in `finally` below, but re-throw it to
+          // not impact code flow.
+          err = ex;
+
+          // This code path happens with a GetObject conditional request
+          // that returns a 304 Not Modified.
+          statusCode = err && err.$metadata && err.$metadata.httpStatusCode;
+          throw ex;
+        } finally {
+          if (statusCode) {
+            span._setOutcomeFromHttpStatusCode(statusCode);
+          } else {
+            span._setOutcomeFromErrorCapture(constants.OUTCOME_FAILURE);
+          }
+          if (err && (!statusCode || statusCode >= 400)) {
+            agent.captureError(err, { skipOutcome: true });
+          }
+
+          const config = client.config;
+          const region = await config.region();
+
+          // Set the db context
+          const dbContext = { type: SUBTYPE }; // dynamodb
+          if (region) {
+            dbContext.instance = region;
+          }
+          if (input && input.KeyConditionExpression) {
+            dbContext.statement = input.KeyConditionExpression;
+          }
+          span.setDbContext(dbContext);
+
+          // Set destination context
+          const destContext = {};
+          if (context[elasticAPMStash]) {
+            destContext.address = context[elasticAPMStash].hostname;
+            destContext.port = context[elasticAPMStash].port;
+          }
+          if (region) {
+            destContext.service = { resource: `dynamodb/${region}` };
+            destContext.cloud = { region };
+          }
+          span._setDestinationContext(destContext);
+
+          // TODO: add OTel attributes when spec is merged
+          // https://github.com/elastic/apm/pull/817
+
+          span.end();
+        }
+
+        return result;
+      },
+      options: { step: 'initialize', priority: 'high', name: 'elasticAPMSpan' },
+    },
+    {
+      middleware: (next, context) => async (args) => {
+        const req = args.request;
+        let port = req.port;
+
+        // Resolve port for HTTP(S) protocols
+        if (port === undefined) {
+          if (req.protocol === 'https:') {
+            port = 443;
+          } else if (req.protocol === 'http:') {
+            port = 80;
+          }
+        }
+
+        context[elasticAPMStash] = {
+          hostname: req.hostname,
+          port,
+        };
+        return next(args);
+      },
+      options: { step: 'finalizeRequest', name: 'elasticAPMHTTPInfo' },
+    },
+  ];
+}
+
+/**
+ * Tells if the command needs to be ingored
+ * @param {import('@aws-sdk/types').Command} command the command sent by the SNS client
+ * @param {any} config the agent configuration
+ * @returns {boolean} false if the command should create a span
+ */
+function dynamoDBShouldIgnoreCommand(command, config) {
+  return false;
+}
+
+module.exports = {
+  DYNAMODB_NAME: NAME,
+  DYNAMODB_TYPE: TYPE,
+  DYNAMODB_SUBTYPE: SUBTYPE,
+  dynamoDBMiddlewareFactory,
+  dynamoDBShouldIgnoreCommand,
+};

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

@@ -0,0 +1,230 @@
+/*
+ * 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 constants = require('../../../constants');
+const NAME = 'S3';
+const TYPE = 'storage';
+const SUBTYPE = 's3';
+const elasticAPMStash = Symbol('elasticAPMStash');
+
+/**
+ * Gets the region from the ARN
+ *
+ * @param {String} s3Arn
+ * @returns {String}
+ */
+function regionFromS3Arn(s3Arn) {
+  return s3Arn.split(':')[3];
+}
+
+/**
+ * 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
+ *
+ * @param {String} bucket The bucket string
+ * @returns {String | null}
+ */
+function resourceFromBucket(bucket) {
+  let resource = null;
+  if (bucket) {
+    resource = bucket;
+    if (resource.startsWith('arn:')) {
+      resource = bucket.split(':').slice(5).join(':');
+    }
+  }
+  return resource;
+}
+
+/**
+ * Returns middlewares to instrument an S3Client instance
+ *
+ * @param {import('@aws-sdk/client-s3').S3Client} client
+ * @param {any} agent
+ * @returns {import('./smithy-client').AWSMiddlewareEntry[]}
+ */
+function s3MiddlewareFactory(client, agent) {
+  return [
+    {
+      middleware: (next, context) => async (args) => {
+        // Ensure there is a span from the wrapped `client.send()`.
+        const span = agent._instrumentation.currSpan();
+        if (!span || !(span.type === TYPE && span.subtype === SUBTYPE)) {
+          return await next(args);
+        }
+
+        const input = args.input;
+        const bucket = input && input.Bucket;
+        const resource = resourceFromBucket(bucket);
+        // The given span comes with the operation name and we need to
+        // add the resource if applies
+        if (resource) {
+          span.name += ' ' + resource;
+          span.setServiceTarget('s3', resource);
+        }
+
+        // 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 (input.Key) {
+            otelAttrs['aws.s3.key'] = input.Key;
+          }
+        }
+
+        let err;
+        let result;
+        let response;
+        let statusCode;
+        try {
+          result = await next(args);
+          response = result && result.response;
+          statusCode = response && response.statusCode;
+        } catch (ex) {
+          // Save the error for use in `finally` below, but re-throw it to
+          // not impact code flow.
+          err = ex;
+
+          // This code path happens with a GetObject conditional request
+          // that returns a 304 Not Modified.
+          statusCode = err && err.$metadata && err.$metadata.httpStatusCode;
+          throw ex;
+        } finally {
+          if (statusCode) {
+            span._setOutcomeFromHttpStatusCode(statusCode);
+          } else {
+            span._setOutcomeFromErrorCapture(constants.OUTCOME_FAILURE);
+          }
+          if (err && (!statusCode || statusCode >= 400)) {
+            agent.captureError(err, { skipOutcome: true });
+          }
+
+          // Set the httpContext
+          if (statusCode) {
+            const httpContext = {
+              status_code: statusCode,
+            };
+
+            if (
+              response &&
+              response.headers &&
+              response.headers['content-length']
+            ) {
+              const encodedBodySize = Number(
+                response.headers['content-length'],
+              );
+              if (!isNaN(encodedBodySize)) {
+                httpContext.response = { encoded_body_size: encodedBodySize };
+              }
+            }
+            span.setHttpContext(httpContext);
+          }
+
+          // Configuring `new S3Client({useArnRegion:true})` allows one to
+          // use an Access Point bucket ARN for a region *other* than the
+          // one for which the client is configured. Therefore, we attempt
+          // to get the bucket region from the ARN first.
+          const config = client.config;
+          let useArnRegion;
+          if (typeof config.useArnRegion === 'boolean') {
+            useArnRegion = config.useArnRegion;
+          } else {
+            useArnRegion = await config.useArnRegion();
+          }
+
+          let region;
+          if (useArnRegion && bucket && bucket.startsWith('arn:')) {
+            region = regionFromS3Arn(args.input.Bucket);
+          } else {
+            region =
+              typeof config.region === 'boolean'
+                ? region
+                : await config.region();
+          }
+
+          // Destination context.
+          const destContext = {
+            service: {
+              name: SUBTYPE,
+              type: TYPE,
+            },
+          };
+          if (context[elasticAPMStash]) {
+            destContext.address = context[elasticAPMStash].hostname;
+            destContext.port = context[elasticAPMStash].port;
+          }
+          if (resource) {
+            destContext.service.resource = resource;
+          }
+          if (region) {
+            destContext.cloud = { region };
+          }
+          span._setDestinationContext(destContext);
+
+          span.end();
+        }
+
+        return result;
+      },
+      options: { step: 'initialize', priority: 'high', name: 'elasticAPMSpan' },
+    },
+    {
+      middleware: (next, context) => async (args) => {
+        const req = args.request;
+        let port = req.port;
+
+        // Resolve port for HTTP(S) protocols
+        if (port === undefined) {
+          if (req.protocol === 'https:') {
+            port = 443;
+          } else if (req.protocol === 'http:') {
+            port = 80;
+          }
+        }
+
+        context[elasticAPMStash] = {
+          hostname: req.hostname,
+          port,
+        };
+        return next(args);
+      },
+      options: { step: 'finalizeRequest', name: 'elasticAPMHTTPInfo' },
+    },
+  ];
+}
+
+/**
+ * Tells if the command needs to be ingored
+ * @param {import('@aws-sdk/types').Command} command the command sent by the SNS client
+ * @param {any} config the agent configuration
+ * @returns {boolean} false if the command should create a span
+ */
+function s3ShouldIgnoreCommand(command, config) {
+  return false;
+}
+
+module.exports = {
+  S3_NAME: NAME,
+  S3_TYPE: TYPE,
+  S3_SUBTYPE: SUBTYPE,
+  s3MiddlewareFactory,
+  s3ShouldIgnoreCommand,
+};

package/lib/instrumentation/modules/@aws-sdk/client-sns.js

@@ -0,0 +1,197 @@
+/*
+ * 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 constants = require('../../../constants');
+const NAME = 'SNS';
+const TYPE = 'messaging';
+const SUBTYPE = 'sns';
+const MAX_SNS_MESSAGE_ATTRIBUTES = 10;
+const elasticAPMStash = Symbol('elasticAPMStash');
+
+/**
+ * Returns middlewares to instrument an S3Client instance
+ *
+ * @param {import('@aws-sdk/client-sns').SNSClient} client
+ * @param {any} agent
+ * @returns {import('./smithy-client').AWSMiddlewareEntry[]}
+ */
+function snsMiddlewareFactory(client, agent) {
+  return [
+    {
+      middleware: (next, context) => async (args) => {
+        const ins = agent._instrumentation;
+        const log = agent.logger;
+        const span = ins.currSpan();
+        const input = args.input;
+
+        // W3C trace-context propagation.
+        const runContext = ins.currRunContext();
+        const parentSpan =
+          span || runContext.currSpan() || runContext.currTransaction();
+        const targetId =
+          input && (input.TopicArn || input.TargetArn || input.PhoneNumber);
+
+        if (parentSpan) {
+          // Though our spec only mentions a 10-message-attribute limit for *SQS*, we'll
+          // do the same limit here, because
+          // https://docs.aws.amazon.com/sns/latest/dg/sns-message-attributes.html
+          // mentions the 10-message-attribute limit for SQS subscriptions.
+          input.MessageAttributes = input.MessageAttributes || {};
+          const attributesCount = Object.keys(input.MessageAttributes).length;
+
+          if (attributesCount + 2 > MAX_SNS_MESSAGE_ATTRIBUTES) {
+            log.warn(
+              'cannot propagate trace-context with SNS message to %s, too many MessageAttributes',
+              targetId,
+            );
+          } else {
+            parentSpan.propagateTraceContextHeaders(
+              input.MessageAttributes,
+              function (msgAttrs, name, value) {
+                if (name.startsWith('elastic-')) {
+                  return;
+                }
+                msgAttrs[name] = { DataType: 'String', StringValue: value };
+              },
+            );
+          }
+        }
+
+        // Ensure there is a span from the wrapped `client.send()`.
+        if (!span || !(span.type === TYPE && span.subtype === SUBTYPE)) {
+          return await next(args);
+        }
+
+        const destTargets = [
+          input.TopicArn && input.TopicArn.split(':').pop(),
+          input.TargetArn && input.TargetArn.split(':').pop().split('/').pop(),
+          input.PhoneNumber && '<PHONE_NUMBER>',
+        ];
+        const topicName = destTargets.filter((a) => a).join(', ');
+
+        if (topicName) {
+          span.name += ' to ' + topicName;
+        }
+
+        let err;
+        let result;
+        let response;
+        let statusCode;
+        try {
+          result = await next(args);
+          response = result && result.response;
+          statusCode = response && response.statusCode;
+        } catch (ex) {
+          // Save the error for use in `finally` below, but re-throw it to
+          // not impact code flow.
+          err = ex;
+
+          // This code path happens with a Publish command that returns a 404 Not Found.
+          statusCode = err && err.$metadata && err.$metadata.httpStatusCode;
+          throw ex;
+        } finally {
+          if (statusCode) {
+            span._setOutcomeFromHttpStatusCode(statusCode);
+          } else {
+            span._setOutcomeFromErrorCapture(constants.OUTCOME_FAILURE);
+          }
+          if (err && (!statusCode || statusCode >= 400)) {
+            agent.captureError(err, { skipOutcome: true });
+          }
+
+          // Destination context.
+          const region = await client.config.region();
+          const service = { name: SUBTYPE, type: TYPE };
+          const destCtx = { service };
+
+          if (context[elasticAPMStash]) {
+            destCtx.address = context[elasticAPMStash].hostname;
+            destCtx.port = context[elasticAPMStash].port;
+          }
+
+          if (region) {
+            destCtx.cloud = { region };
+          }
+          span._setDestinationContext(destCtx);
+
+          // Message context
+          if (topicName) {
+            span.setMessageContext({ queue: { name: topicName } });
+          }
+
+          span.end();
+        }
+
+        return result;
+      },
+      options: { step: 'initialize', priority: 'high', name: 'elasticAPMSpan' },
+    },
+    {
+      middleware: (next, context) => async (args) => {
+        const req = args.request;
+        let port = req.port;
+
+        // Resolve port for HTTP(S) protocols
+        if (port === undefined) {
+          if (req.protocol === 'https:') {
+            port = 443;
+          } else if (req.protocol === 'http:') {
+            port = 80;
+          }
+        }
+
+        context[elasticAPMStash] = {
+          hostname: req.hostname,
+          port,
+        };
+        return next(args);
+      },
+      options: { step: 'finalizeRequest', name: 'elasticAPMHTTPInfo' },
+    },
+  ];
+}
+
+/**
+ * Tells if the command needs to be ingored
+ * @param {import('@aws-sdk/types').Command} command the command sent by the SNS client
+ * @param {any} config the agent configuration
+ * @returns {boolean} false if the command should create a span
+ */
+function snsShouldIgnoreCommand(command, config) {
+  if (command.constructor.name !== 'PublishCommand') {
+    return true;
+  }
+
+  if (config.ignoreMessageQueuesRegExp) {
+    const input = command.input;
+    // It's unlikely but input can have multiple targets defined
+    // and having a priority list between them may result in
+    // not honoring `ignoreMessageQueues` config.
+    const topicNames = input
+      ? [input.TopicArn, input.TargetArn, input.PhoneNumber].filter((t) => t)
+      : [];
+
+    for (const topicName of topicNames) {
+      for (const rule of config.ignoreMessageQueuesRegExp) {
+        if (rule.test(topicName)) {
+          return true;
+        }
+      }
+    }
+  }
+
+  return false;
+}
+
+module.exports = {
+  SNS_NAME: NAME,
+  SNS_TYPE: TYPE,
+  SNS_SUBTYPE: SUBTYPE,
+  snsMiddlewareFactory,
+  snsShouldIgnoreCommand,
+};