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

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

@@ -0,0 +1,336 @@
+/*
+ * 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 {
+  MAX_MESSAGES_PROCESSED_FOR_TRACE_CONTEXT,
+  OUTCOME_FAILURE,
+} = require('../../../constants');
+const NAME = 'SQS';
+const TYPE = 'messaging';
+const SUBTYPE = 'sqs';
+const elasticAPMStash = Symbol('elasticAPMStash');
+
+// TODO: simthy-client already resolves span.action from the command name but does not have these values
+// DeleteMessageCommand => span.action = 'DeleteMessage'
+// do we need to have same messages (keep this key/val pairs) or its okay to have the ones form smithy-client?
+const OPERATIONS_TO_ACTIONS = {
+  DeleteMessage: 'delete',
+  DeleteMessageBatch: 'delete_batch',
+  ReceiveMessage: 'poll',
+  SendMessageBatch: 'send_batch',
+  SendMessage: 'send',
+  unknown: 'unknown',
+};
+const OPERATIONS = Object.keys(OPERATIONS_TO_ACTIONS);
+const MAX_SQS_MESSAGE_ATTRIBUTES = 10;
+const queueMetrics = new Map();
+
+/**
+ * Returns middlewares to instrument an S3Client instance
+ *
+ * @param {import('@aws-sdk/client-sqs').SQSClient} client
+ * @param {any} agent
+ * @returns {import('../@smithy/smithy-client').AWSMiddlewareEntry[]}
+ */
+function sqsMiddlewareFactory(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 commandName = context.commandName.replace('Command', '');
+        const runContext = ins.currRunContext();
+        const parentSpan =
+          span || runContext.currSpan() || runContext.currTransaction();
+
+        if (parentSpan) {
+          const toPropagate = [];
+
+          if (commandName === 'SendMessage' && input.MessageAttributes) {
+            toPropagate.push(input.MessageAttributes);
+          } else if (
+            commandName === 'SendMessageBatch' &&
+            Array.isArray(input.Entries)
+          ) {
+            for (const e of input.Entries) {
+              if (e && e.MessageAttributes) {
+                toPropagate.push(e.MessageAttributes);
+              }
+            }
+          }
+
+          // 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.
+          toPropagate.forEach((msgAttrs) => {
+            const attrsCount = Object.keys(msgAttrs).length + 2;
+            if (attrsCount > MAX_SQS_MESSAGE_ATTRIBUTES) {
+              log.warn(
+                { QueueUrl: input.QueueUrl },
+                'cannot propagate trace-context with SQS message, too many MessageAttributes',
+              );
+              return;
+            }
+            parentSpan.propagateTraceContextHeaders(
+              msgAttrs,
+              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);
+        }
+
+        // Action is not equal to command/operation name, we have to map it
+        span.action = OPERATIONS_TO_ACTIONS[commandName] || 'unknown';
+
+        const queueName = getQueueNameFromCommand(args);
+        let toFrom = 'from';
+        if (span.action === 'send' || span.action === 'send_batch') {
+          toFrom = 'to';
+        }
+        span.name = `SQS ${span.action.toUpperCase()} ${toFrom} ${queueName}`;
+
+        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(OUTCOME_FAILURE);
+          }
+          if (err && (!statusCode || statusCode >= 400)) {
+            agent.captureError(err, { skipOutcome: true });
+          }
+
+          // Destination context.
+          const region = await client.config.region();
+          const service = { type: SUBTYPE };
+          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
+          span.setMessageContext({ queue: { name: queueName } });
+
+          const receiveMsgData =
+            span.action === 'poll' && result && result.output;
+          if (receiveMsgData) {
+            // Links
+            const links = getSpanLinksFromResponseData(result && result.output);
+            if (links) {
+              span.addLinks(links);
+            }
+
+            // Metrics
+            recordMetrics(queueName, receiveMsgData, agent);
+          }
+
+          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' },
+    },
+  ];
+}
+
+/**
+ * Get the queue name from a command
+ * @param {import('@aws-sdk/types').Command} command the command sent by the SQS client
+ * @returns {string} the queue name
+ */
+function getQueueNameFromCommand(command) {
+  const queueUrl = command && command.input && command.input.QueueUrl;
+
+  if (queueUrl) {
+    try {
+      const url = new URL(queueUrl);
+      return url.pathname.split('/').pop();
+    } catch {}
+  }
+
+  return 'unknown';
+}
+
+/**
+ * @typedef {import('@aws-sdk/client-sqs').Message} Message
+ */
+/**
+ * Extract span links from up to 1000 messages in this batch.
+ * https://github.com/elastic/apm/blob/main/specs/agents/tracing-instrumentation-messaging.md#receiving-trace-context
+ *
+ * A span link is created from a `traceparent` message attribute in a message.
+ * `msg.messageAttributes` is of the form:
+ *    { <attribute-name>: { DataType: <attr-type>, StringValue: <attr-value>, ... } }
+ * For example:
+ *    { traceparent: { DataType: 'String', StringValue: 'test-traceparent' } }
+ *
+ * @param { {Messages?: Message[]} } data
+ * @returns { Array<{ context: string }> }
+ */
+function getSpanLinksFromResponseData(data) {
+  if (!data || !data.Messages || data.Messages.length === 0) {
+    return null;
+  }
+  const links = [];
+  const limit = Math.min(
+    data.Messages.length,
+    MAX_MESSAGES_PROCESSED_FOR_TRACE_CONTEXT,
+  );
+  for (let i = 0; i < limit; i++) {
+    const attrs = data.Messages[i].MessageAttributes;
+    if (!attrs) {
+      continue;
+    }
+
+    let traceparent;
+    const attrNames = Object.keys(attrs);
+    for (let j = 0; j < attrNames.length; j++) {
+      const attrVal = attrs[attrNames[j]];
+      if (attrVal.DataType !== 'String') {
+        continue;
+      }
+      const attrNameLc = attrNames[j].toLowerCase();
+      if (attrNameLc === 'traceparent') {
+        traceparent = attrVal.StringValue;
+        break;
+      }
+    }
+    if (traceparent) {
+      links.push({ context: traceparent });
+    }
+  }
+  return links;
+}
+
+/**
+ * Record queue related metrics
+ *
+ * Creates metric collector objects on first run, and
+ * updates their data with data from received messages
+ * @param {string} queueName
+ * @param { {Messages?: Message[]} } data
+ * @param {any} agent
+ */
+function recordMetrics(queueName, data, agent) {
+  const messages = data && data.Messages;
+  if (!messages || messages.length < 1) {
+    return;
+  }
+  if (!queueMetrics.get(queueName)) {
+    const collector = agent._metrics.createQueueMetricsCollector(queueName);
+    if (!collector) {
+      return;
+    }
+    queueMetrics.set(queueName, collector);
+  }
+  const metrics = queueMetrics.get(queueName);
+
+  for (const message of messages) {
+    const sentTimestamp =
+      message.Attributes && message.Attributes.SentTimestamp;
+    const delay = new Date().getTime() - sentTimestamp;
+    metrics.updateStats(delay);
+  }
+}
+
+/**
+ * Tells if the command needs to be ignored or not
+ * @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 sqsShouldIgnoreCommand(command, config) {
+  const commandName = command.constructor.name;
+  const operation = commandName.replace(/Command$/, '');
+
+  if (OPERATIONS.indexOf(operation) === -1) {
+    return true;
+  }
+
+  if (config.ignoreMessageQueuesRegExp) {
+    const queueName = getQueueNameFromCommand(command);
+    if (queueName) {
+      for (const rule of config.ignoreMessageQueuesRegExp) {
+        if (rule.test(queueName)) {
+          return true;
+        }
+      }
+    }
+  }
+
+  return false;
+}
+
+module.exports = {
+  SQS_NAME: NAME,
+  SQS_TYPE: TYPE,
+  SQS_SUBTYPE: SUBTYPE,
+  sqsMiddlewareFactory,
+  sqsShouldIgnoreCommand,
+};

package/lib/instrumentation/modules/@elastic/elasticsearch.js

@@ -0,0 +1,343 @@
+/*
+ * 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 the @elastic/elasticsearch module.
+//
+// Limitations:
+// - In @elastic/elasticsearch >=7.14 <8, the diagnostic events sent for ES
+//   spans started before the product-check is finished will have an incorrect
+//   `currentSpan`.
+//
+//   An Elasticsearch (ES) request typically results in a single HTTP request to
+//   the server. For some of the later 7.x versions of @elastic/elasticsearch
+//   there is a product-check "GET /" that blocks the *first* request to the
+//   server. The handling of ES requests are effectively queued until that
+//   product-check is complete. When they *do* run, the async context is that
+//   of the initial ES span. This means that `apm.currentSpan` inside an ES
+//   client diagnostic event for these queued ES requests will be wrong.
+//   Currently the APM agent is not patching for this.
+
+const semver = require('semver');
+const { URL, URLSearchParams } = require('url');
+
+const { getDBDestination } = require('../../context');
+const { getElasticsearchDbStatement } = require('../../elasticsearch-shared');
+const shimmer = require('../../shimmer');
+
+/**
+ * Get the Elasticsearch cluster name, if possible.
+ *
+ * This is currently a partial implementation of:
+ * https://github.com/elastic/apm/blob/main/specs/agents/tracing-instrumentation-db.md#cluster-name
+ *
+ * @param {import("@elastic/elasticsearch").DiagnosticResult || null}
+ * @returns { string || null }
+ */
+function getESClusterName(diagResult) {
+  if (diagResult && diagResult.headers) {
+    const clusterNameFromHeader =
+      diagResult.headers['x-found-handling-cluster'];
+    if (clusterNameFromHeader) {
+      return clusterNameFromHeader;
+    }
+  }
+}
+
+module.exports = function (elasticsearch, agent, { version, enabled }) {
+  if (!enabled) {
+    return elasticsearch;
+  }
+  if (!elasticsearch.Client) {
+    agent.logger.debug(
+      '@elastic/elasticsearch@%s is not supported (no `elasticsearch.Client`) - aborting...',
+      version,
+    );
+    return elasticsearch;
+  }
+
+  // Before v7.7.0 the Transport#request() implementation's Promises support
+  // would re-call `this.request(...)` inside a Promise.
+  const doubleCallsRequestIfNoCb = semver.lt(version, '7.7.0');
+  const ins = agent._instrumentation;
+  const isGteV8 = semver.satisfies(version, '>=8', { includePrerelease: true });
+  const elasticsearchCaptureBodyUrlsRegExp =
+    agent._conf.elasticsearchCaptureBodyUrlsRegExp;
+
+  agent.logger.debug(
+    'shimming elasticsearch.Transport.prototype.{request,getConnection}',
+  );
+  shimmer.wrap(
+    elasticsearch.Transport && elasticsearch.Transport.prototype,
+    'request',
+    wrapRequest,
+  );
+  shimmer.wrap(
+    elasticsearch.Transport && elasticsearch.Transport.prototype,
+    'getConnection',
+    wrapGetConnection,
+  );
+  shimmer.wrap(elasticsearch, 'Client', wrapClient);
+
+  // Tracking the ES client Connection object and DiagnosticResult for each
+  // active span. Use WeakMap to avoid a leak from possible spans that don't
+  // end.
+  const connFromSpan = new WeakMap();
+  const diagResultFromSpan = new WeakMap();
+
+  return elasticsearch;
+
+  function wrapClient(OrigClient) {
+    class ClientTraced extends OrigClient {
+      constructor(...args) {
+        super(...args);
+        const diagnostic = isGteV8 ? this.diagnostic : this;
+        diagnostic.on('response', (_err, result) => {
+          if (result) {
+            const currSpan = ins.currSpan();
+            if (currSpan) {
+              diagResultFromSpan.set(currSpan, result);
+            }
+          }
+        });
+      }
+    }
+    return ClientTraced;
+  }
+
+  // Transport#request() calls Transport#getConnection() when it is ready to
+  // make the HTTP request. This returns the actual connection to be used for
+  // the request. This is limited, however:
+  // - `getConnection()` is not called if the request was aborted early.
+  // - If all connections are marked dead, then this returns null.
+  // - We are assuming this is called with the correct async context. See
+  //   "Limitations" above.
+  function wrapGetConnection(origGetConnection) {
+    return function wrappedGetConnection(opts) {
+      const conn = origGetConnection.apply(this, arguments);
+      const currSpan = ins.currSpan();
+      if (conn && currSpan) {
+        connFromSpan.set(currSpan, conn);
+      }
+      return conn;
+    };
+  }
+
+  function wrapRequest(origRequest) {
+    return function wrappedRequest(params, options, cb) {
+      options = options || {};
+      if (typeof options === 'function') {
+        cb = options;
+        options = {};
+      }
+
+      if (typeof cb !== 'function' && doubleCallsRequestIfNoCb) {
+        return origRequest.apply(this, arguments);
+      }
+
+      const method = (params && params.method) || '<UnknownMethod>';
+      const path = (params && params.path) || '<UnknownPath>';
+      agent.logger.debug(
+        { method, path },
+        'intercepted call to @elastic/elasticsearch.Transport.prototype.request',
+      );
+      const span = ins.createSpan(
+        `Elasticsearch: ${method} ${path}`,
+        'db',
+        'elasticsearch',
+        'request',
+        { exitSpan: true },
+      );
+      if (!span) {
+        return origRequest.apply(this, arguments);
+      }
+
+      const parentRunContext = ins.currRunContext();
+      const spanRunContext = parentRunContext.enterSpan(span);
+      const finish = ins.bindFunctionToRunContext(
+        spanRunContext,
+        (err, result) => {
+          // Set destination context.
+          // Use the connection from wrappedGetConnection() above, if that worked.
+          // Otherwise, fallback to using the first connection on
+          // `Transport#connectionPool`, if any.  (This is the best parsed
+          // representation of connection options passed to the Client ctor.)
+          let conn = connFromSpan.get(span);
+          if (conn) {
+            connFromSpan.delete(span);
+          } else if (this.connectionPool && this.connectionPool.connections) {
+            conn = this.connectionPool.connections[0];
+          }
+          const connUrl = conn && conn.url;
+          span._setDestinationContext(
+            getDBDestination(
+              connUrl && connUrl.hostname,
+              connUrl && connUrl.port,
+            ),
+          );
+
+          // Gather some HTTP context.
+          // We are *not* including the response headers b/c they are boring:
+          //
+          //    X-elastic-product: Elasticsearch
+          //    content-type: application/json
+          //    content-length: ...
+          //
+          // Getting the ES client request "DiagnosticResult" object has some edge cases:
+          // - In v7 using a callback, we always get it as `result`.
+          // - In v7 using a Promise, if the promise is rejected, then `result` is
+          //   not passed.
+          // - In v8, `result` only includes HTTP response info if `options.meta`
+          //   is true. We use the diagnostic 'response' event instead.
+          // - In v7, see the limitation note above for the rare start case where
+          //   the diagnostic 'response' event may have the wrong currentSpan.
+          // The result is that with Promise usage of v7, ES client requests that
+          // are queued behind the "product-check" and that reject, won't have a
+          // `diagResult`.
+          const httpContext = {};
+          let haveHttpContext = false;
+          let diagResult = isGteV8 ? null : result;
+          if (!diagResult) {
+            diagResult = diagResultFromSpan.get(span);
+            if (diagResult) {
+              diagResultFromSpan.delete(span);
+            }
+          }
+          if (diagResult) {
+            if (diagResult.statusCode) {
+              haveHttpContext = true;
+              httpContext.status_code = diagResult.statusCode;
+            }
+
+            if (diagResult.headers && 'content-length' in diagResult.headers) {
+              const contentLength = Number(
+                diagResult.headers['content-length'],
+              );
+              if (!isNaN(contentLength)) {
+                haveHttpContext = true;
+                httpContext.response = { encoded_body_size: contentLength };
+              }
+            }
+          }
+
+          // Reconstruct the full URL (including query params).
+          let origin;
+          if (connUrl) {
+            origin = connUrl.origin;
+          } else if (
+            diagResult &&
+            diagResult.meta &&
+            diagResult.meta.connection &&
+            diagResult.meta.connection.url
+          ) {
+            try {
+              origin = new URL(diagResult.meta.connection.url).origin;
+            } catch (_ignoredErr) {}
+          }
+          if (origin && params && params.path) {
+            const fullUrl = new URL(origin);
+            fullUrl.pathname = params.path;
+            fullUrl.search = new URLSearchParams(params.querystring).toString();
+            httpContext.url = fullUrl.toString();
+            haveHttpContext = true;
+          }
+
+          if (haveHttpContext) {
+            span.setHttpContext(httpContext);
+          }
+
+          // Set DB context.
+          const dbContext = {
+            type: 'elasticsearch',
+          };
+          if (params) {
+            const statement = getElasticsearchDbStatement(
+              params.path,
+              params.body || params.bulkBody,
+              elasticsearchCaptureBodyUrlsRegExp,
+            );
+            if (statement) {
+              dbContext.statement = statement;
+            }
+          }
+          const clusterName = getESClusterName(diagResult);
+          if (clusterName) {
+            dbContext.instance = clusterName;
+          }
+          span.setDbContext(dbContext);
+
+          if (err) {
+            // Error properties are specified here:
+            // https://github.com/elastic/elasticsearch-js/blob/master/lib/errors.d.ts
+            // - We capture some data from ResponseError, which is for
+            //   Elasticsearch API errors:
+            //   https://www.elastic.co/guide/en/elasticsearch/reference/current/common-options.html#common-options-error-options
+            // - Otherwise we explicitly turn off `captureAttributes` to avoid
+            //   grabbing potentially large and sensitive properties like
+            //   `err.data` on DeserializationError.
+            const errOpts = {
+              captureAttributes: false,
+            };
+            const errBody = err.body;
+            if (err.name === 'ResponseError' && errBody && errBody.error) {
+              // Include some data from the Elasticsearch API response body:
+              // https://www.elastic.co/guide/en/elasticsearch/reference/current/common-options.html#common-options-error-options
+              const errType = errBody.error.type;
+              if (errType) {
+                // Specialize `error.exception.type` for better error grouping.
+                errOpts.exceptionType = `ResponseError (${errType})`;
+              }
+              errOpts.custom = {
+                type: errType,
+                reason: errBody.error.reason,
+                status: errBody.status,
+              };
+              if (errBody.error.caused_by) {
+                errOpts.custom.caused_by = errBody.error.caused_by;
+              }
+            }
+            agent.captureError(err, errOpts);
+          }
+
+          span.end();
+        },
+      );
+
+      if (typeof cb === 'function') {
+        const wrappedCb = (err, result) => {
+          finish(err, result);
+          ins.withRunContext(parentRunContext, cb, this, err, result);
+        };
+        return ins.withRunContext(
+          spanRunContext,
+          origRequest,
+          this,
+          params,
+          options,
+          wrappedCb,
+        );
+      } else {
+        const origPromise = ins.withRunContext(
+          spanRunContext,
+          origRequest,
+          this,
+          ...arguments,
+        );
+        origPromise.then(
+          function onResolve(result) {
+            finish(null, result);
+          },
+          function onReject(err) {
+            finish(err, null);
+          },
+        );
+
+        return origPromise;
+      }
+    };
+  }
+};