@redthreadlabs/tracelog 1.4.0

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

@@ -0,0 +1,361 @@
+/*
+ * 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 { URL } = require('url');
+const {
+  MAX_MESSAGES_PROCESSED_FOR_TRACE_CONTEXT,
+} = require('../../../constants');
+
+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 TYPE = 'messaging';
+const SUBTYPE = 'sqs';
+const queueMetrics = new Map();
+
+const MAX_SQS_MESSAGE_ATTRIBUTES = 10;
+
+// Returns Message Queue action from AWS SDK method name
+function getActionFromRequest(request) {
+  request = request || {};
+  const operation = request.operation ? request.operation : 'unknown';
+  const action = OPERATIONS_TO_ACTIONS[operation];
+
+  return action;
+}
+
+// Returns preposition to use in span name
+//
+// POLL from ...
+// SEND to ...
+function getToFromFromOperation(operation) {
+  let result = 'from';
+  if (operation === 'sendMessage' || operation === 'sendMessageBatch') {
+    result = 'to';
+  }
+  return result;
+}
+
+// Parses queue/topic name from AWS queue URL
+function getQueueNameFromRequest(request) {
+  const unknown = 'unknown';
+  if (!request || !request.params || !request.params.QueueUrl) {
+    return unknown;
+  }
+  try {
+    const url = new URL(request.params.QueueUrl);
+    return url.pathname.split('/').pop();
+  } catch (e) {
+    return unknown;
+  }
+}
+
+// Parses region name from AWS service configuration
+function getRegionFromRequest(request) {
+  const region =
+    request &&
+    request.service &&
+    request.service.config &&
+    request.service.config.region;
+  return region || '';
+}
+
+function getAddressFromRequest(request) {
+  return (
+    request &&
+    request.service &&
+    request.service.endpoint &&
+    request.service.endpoint.hostname
+  );
+}
+
+function getPortFromRequest(request) {
+  return (
+    request &&
+    request.service &&
+    request.service.endpoint &&
+    request.service.endpoint.port
+  );
+}
+
+// Creates message destination context suitable for setDestinationContext
+function getMessageDestinationContextFromRequest(request) {
+  const destination = {
+    address: getAddressFromRequest(request),
+    port: getPortFromRequest(request),
+    cloud: {
+      region: getRegionFromRequest(request),
+    },
+  };
+  return destination;
+}
+
+// create message context suitable for setMessageContext
+function getMessageContextFromRequest(request) {
+  const message = {
+    queue: {
+      name: getQueueNameFromRequest(request),
+    },
+  };
+  return message;
+}
+
+// Record queue related metrics
+//
+// Creates metric collector objects on first run, and
+// updates their data with data from received messages
+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);
+  }
+}
+
+// Creates the span name from request information
+function getSpanNameFromRequest(request) {
+  const action = getActionFromRequest(request);
+  const toFrom = getToFromFromOperation(request.operation);
+  const queueName = getQueueNameFromRequest(request);
+
+  const name = `${SUBTYPE.toUpperCase()} ${action.toUpperCase()} ${toFrom} ${queueName}`;
+  return name;
+}
+
+// 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' } }
+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;
+}
+
+function shouldIgnoreRequest(request, agent) {
+  const operation = request && request.operation;
+  // are we interested in this operation/method call?
+  if (OPERATIONS.indexOf(operation) === -1) {
+    return true;
+  }
+
+  // is the named queue on our ignore list?
+  if (agent._conf && agent._conf.ignoreMessageQueuesRegExp) {
+    const queueName = getQueueNameFromRequest(request);
+    for (const rule of agent._conf.ignoreMessageQueuesRegExp) {
+      if (rule.test(queueName)) {
+        return true;
+      }
+    }
+  }
+
+  return false;
+}
+
+function propagateTraceContextInMessageAttributes(
+  parentSpan,
+  msgParams,
+  log,
+  queueUrl,
+) {
+  const msgAttrs = msgParams.MessageAttributes;
+  if (
+    msgAttrs &&
+    Object.keys(msgAttrs).length + 2 > MAX_SQS_MESSAGE_ATTRIBUTES
+  ) {
+    log.warn(
+      { QueueUrl: queueUrl },
+      'cannot propagate trace-context with SQS message, too many MessageAttributes',
+    );
+  } else {
+    parentSpan.propagateTraceContextHeaders(
+      msgAttrs,
+      function (msgAttrs, name, value) {
+        if (name.startsWith('elastic-')) {
+          return;
+        }
+        msgAttrs[name] = { DataType: 'String', StringValue: value };
+      },
+    );
+  }
+}
+
+// Main entrypoint for SQS instrumentation
+//
+// Must call (or one of its function calls must call) the
+// `orig` function/method
+function instrumentationSqs(
+  orig,
+  origArguments,
+  request,
+  AWS,
+  agent,
+  { version, enabled },
+) {
+  if (shouldIgnoreRequest(request, agent)) {
+    return orig.apply(request, origArguments);
+  }
+
+  const ins = agent._instrumentation;
+  const log = agent.logger;
+  const action = getActionFromRequest(request);
+  const name = getSpanNameFromRequest(request);
+  const parentRunContext = ins.currRunContext();
+  const span = ins.createSpan(name, TYPE, SUBTYPE, action, { exitSpan: true });
+
+  // W3C trace-context propagation.
+  const parent =
+    span || parentRunContext.currSpan() || parentRunContext.currTransaction();
+  if (parent) {
+    if (!request.params || typeof request.params !== 'object') {
+      // Pass. This is a sanity guard against bogus user input.
+    } else if (request.operation === 'sendMessage') {
+      const paramsCopy = Object.assign({}, request.params);
+      paramsCopy.MessageAttributes = Object.assign(
+        {},
+        paramsCopy.MessageAttributes,
+      );
+      request.params = paramsCopy;
+      propagateTraceContextInMessageAttributes(
+        parent,
+        request.params,
+        log,
+        request.params.QueueUrl,
+      );
+    } else if (
+      request.operation === 'sendMessageBatch' &&
+      Array.isArray(request.params.Entries)
+    ) {
+      const paramsCopy = Object.assign({}, request.params);
+      paramsCopy.Entries = paramsCopy.Entries.map((msgParams) => {
+        const msgParamsCopy = Object.assign({}, msgParams);
+        msgParamsCopy.MessageAttributes = Object.assign(
+          {},
+          msgParamsCopy.MessageAttributes,
+        );
+        propagateTraceContextInMessageAttributes(
+          parent,
+          msgParamsCopy,
+          log,
+          request.params.QueueUrl,
+        );
+        return msgParamsCopy;
+      });
+      request.params = paramsCopy;
+    }
+  }
+
+  if (!span) {
+    return orig.apply(request, origArguments);
+  }
+
+  span._setDestinationContext(getMessageDestinationContextFromRequest(request));
+  span.setMessageContext(getMessageContextFromRequest(request));
+
+  const onComplete = function (response) {
+    if (response && response.error) {
+      agent.captureError(response.error);
+    }
+
+    const receiveMsgData =
+      request.operation === 'receiveMessage' && response && response.data;
+    if (receiveMsgData) {
+      const links = getSpanLinksFromResponseData(receiveMsgData);
+      if (links) {
+        span.addLinks(links);
+      }
+    }
+
+    span.end();
+
+    if (receiveMsgData) {
+      recordMetrics(getQueueNameFromRequest(request), receiveMsgData, agent);
+    }
+  };
+  // Bind onComplete to the span's run context so that `captureError` picks
+  // up the correct currentSpan.
+  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 = {
+  instrumentationSqs,
+
+  // exported for tests
+  getToFromFromOperation,
+  getActionFromRequest,
+  getQueueNameFromRequest,
+  getRegionFromRequest,
+  getMessageDestinationContextFromRequest,
+  shouldIgnoreRequest,
+};

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

@@ -0,0 +1,76 @@
+/*
+ * 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 { instrumentationS3 } = require('./aws-sdk/s3');
+const { instrumentationSqs } = require('./aws-sdk/sqs');
+const { instrumentationDynamoDb } = require('./aws-sdk/dynamodb.js');
+const { instrumentationSns } = require('./aws-sdk/sns.js');
+
+const instrumentorFromSvcId = {
+  s3: instrumentationS3,
+  sqs: instrumentationSqs,
+  dynamodb: instrumentationDynamoDb,
+  sns: instrumentationSns,
+};
+
+// Called in place of AWS.Request.send and AWS.Request.promise
+//
+// Determines which amazon service an API request is for
+// and then passes call on to an appropriate instrumentation
+// function.
+function instrumentOperation(
+  orig,
+  origArguments,
+  request,
+  AWS,
+  agent,
+  { version, enabled },
+) {
+  const instrumentor = instrumentorFromSvcId[request.service.serviceIdentifier];
+  if (instrumentor) {
+    return instrumentor(orig, origArguments, request, AWS, agent, {
+      version,
+      enabled,
+    });
+  }
+
+  // if we're still here, then we still need to call the original method
+  return orig.apply(request, origArguments);
+}
+
+// main entry point for aws-sdk instrumentation
+module.exports = function (AWS, agent, { version, enabled }) {
+  if (!enabled) return AWS;
+  if (!semver.satisfies(version, '>1 <3')) {
+    agent.logger.debug(
+      'aws-sdk version %s not supported - aborting...',
+      version,
+    );
+    return AWS;
+  }
+
+  shimmer.wrap(AWS.Request.prototype, 'send', function (orig) {
+    return function _wrappedAWSRequestSend() {
+      return instrumentOperation(orig, arguments, this, AWS, agent, {
+        version,
+        enabled,
+      });
+    };
+  });
+
+  shimmer.wrap(AWS.Request.prototype, 'promise', function (orig) {
+    return function _wrappedAWSRequestPromise() {
+      return instrumentOperation(orig, arguments, this, AWS, agent, {
+        version,
+        enabled,
+      });
+    };
+  });
+  return AWS;
+};

package/lib/instrumentation/modules/bluebird.js

@@ -0,0 +1,93 @@
+/*
+ * 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 massWrap = shimmer.massWrap;
+var wrap = shimmer.wrap;
+
+var BLUEBIRD_FNS = ['_then', '_addCallbacks'];
+
+module.exports = function (bluebird, agent, { version }) {
+  var ins = agent._instrumentation;
+
+  if (!semver.satisfies(version, '>=2 <4')) {
+    agent.logger.debug(
+      'bluebird version %s not supported - aborting...',
+      version,
+    );
+    return bluebird;
+  }
+
+  agent.logger.debug('shimming bluebird.prototype functions: %j', BLUEBIRD_FNS);
+  massWrap(bluebird.prototype, BLUEBIRD_FNS, wrapThen);
+
+  // Calling bluebird.config might overwrite the
+  // bluebird.prototype._attachCancellationCallback function with a new
+  // function. We need to hook into this new function
+  agent.logger.debug('shimming bluebird.config');
+  wrap(bluebird, 'config', function wrapConfig(original) {
+    return function wrappedConfig() {
+      var result = original.apply(this, arguments);
+
+      agent.logger.debug(
+        'shimming bluebird.prototype._attachCancellationCallback',
+      );
+      wrap(
+        bluebird.prototype,
+        '_attachCancellationCallback',
+        function wrapAttachCancellationCallback(original) {
+          return function wrappedAttachCancellationCallback(onCancel) {
+            if (arguments.length !== 1) return original.apply(this, arguments);
+            return original.call(this, ins.bindFunction(onCancel));
+          };
+        },
+      );
+
+      return result;
+    };
+  });
+
+  // WARNING: even if you remove these two shims, the tests might still pass
+  // for bluebird@2. The tests are flaky and will only fail sometimes and in
+  // some cases only if run together with the other tests.
+  //
+  // To test, run in a while-loop:
+  //
+  //   while :; do node test/instrumentation/modules/bluebird/bluebird.js || exit $?; done
+  if (semver.satisfies(version, '<3')) {
+    agent.logger.debug('shimming bluebird.each');
+    wrap(bluebird, 'each', function wrapEach(original) {
+      return function wrappedEach(promises, fn) {
+        if (arguments.length !== 2) return original.apply(this, arguments);
+        return original.call(this, promises, ins.bindFunction(fn));
+      };
+    });
+
+    agent.logger.debug('shimming bluebird.prototype.each');
+    wrap(bluebird.prototype, 'each', function wrapEach(original) {
+      return function wrappedEach(fn) {
+        if (arguments.length !== 1) return original.apply(this, arguments);
+        return original.call(this, ins.bindFunction(fn));
+      };
+    });
+  }
+
+  return bluebird;
+
+  function wrapThen(original) {
+    return function wrappedThen() {
+      var args = Array.prototype.slice.call(arguments);
+      if (typeof args[0] === 'function') args[0] = ins.bindFunction(args[0]);
+      if (typeof args[1] === 'function') args[1] = ins.bindFunction(args[1]);
+      return original.apply(this, args);
+    };
+  }
+};