@redthreadlabs/tracelog 1.4.0

package/lib/instrumentation/modules/graphql.js

@@ -0,0 +1,256 @@
+/*
+ * 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 clone = require('shallow-clone-shim');
+
+var getPathFromRequest = require('../express-utils').getPathFromRequest;
+
+module.exports = function (graphql, agent, { version, enabled }) {
+  if (!enabled) return graphql;
+  if (
+    !semver.satisfies(version, '>=0.7.0 <17') ||
+    !graphql.Kind ||
+    typeof graphql.Source !== 'function' ||
+    typeof graphql.parse !== 'function' ||
+    typeof graphql.validate !== 'function' ||
+    typeof graphql.execute !== 'function'
+  ) {
+    agent.logger.debug(
+      'graphql version %s not supported - aborting...',
+      version,
+    );
+    return graphql;
+  }
+
+  // Over the many versions the `graphql()` and `execute()` functions have
+  // changed in what arguments they accept:
+  // - Initially they only supported positional arguments:
+  //      function graphql(schema, requestString, rootValue, contextValue, variableValues, operationName)
+  // - Starting in v0.10.0 (in #356), they started accepting a second form where
+  //   all fields were passed in an object as the first argument:
+  //      function graphql(argsOrSchema, source, rootValue, contextValue, variableValues, operationName, fieldResolver)
+  //   and `arguments.length === 1` was used as the test to determine which.
+  // - Starting in v16 (in #2904), they dropped positional arguments:
+  //      function graphql(args)
+  const onlySupportsPositionalArgs = semver.lt(version, '0.10.0');
+  const onlySupportsSingleArg = semver.gte(version, '16.0.0');
+
+  const ins = agent._instrumentation;
+
+  return clone({}, graphql, {
+    graphql(descriptor) {
+      const getter = descriptor.get;
+      if (getter) {
+        descriptor.get = function get() {
+          return wrapGraphql(getter());
+        };
+      }
+      return descriptor;
+    },
+    execute(descriptor) {
+      const getter = descriptor.get;
+      if (getter) {
+        descriptor.get = function get() {
+          return wrapExecute(getter());
+        };
+      }
+      return descriptor;
+    },
+  });
+
+  function wrapGraphql(orig) {
+    return function wrappedGraphql(args) {
+      agent.logger.debug('intercepted call to graphql.graphql');
+      const span = ins.createSpan(
+        'GraphQL: Unknown Query',
+        'db',
+        'graphql',
+        'execute',
+      );
+      if (!span) {
+        return orig.apply(this, arguments);
+      }
+
+      let schema;
+      let source;
+      let operationName;
+      const singleArgForm =
+        onlySupportsSingleArg ||
+        (!onlySupportsPositionalArgs && arguments.length === 1);
+      if (singleArgForm) {
+        schema = args.schema;
+        source = args.source;
+        operationName = args.operationName;
+      } else {
+        schema = arguments[0];
+        source = arguments[1];
+        operationName = arguments[5];
+      }
+
+      const sourceObj =
+        typeof source === 'string'
+          ? new graphql.Source(source || '', 'GraphQL request')
+          : source;
+      if (sourceObj) {
+        var documentAST;
+
+        try {
+          documentAST = graphql.parse(sourceObj);
+        } catch (syntaxError) {
+          agent.logger.debug(
+            'graphql.parse(source) failed - skipping graphql query extraction',
+          );
+        }
+
+        if (documentAST) {
+          var validationErrors = graphql.validate(schema, documentAST);
+          if (validationErrors && validationErrors.length === 0) {
+            var queries = extractDetails(documentAST, operationName).queries;
+            if (queries.length > 0)
+              span.name = 'GraphQL: ' + queries.join(', ');
+          }
+        }
+      } else {
+        agent.logger.debug(
+          'graphql.Source(query) failed - skipping graphql query extraction',
+        );
+      }
+
+      const spanRunContext = ins.currRunContext().enterSpan(span);
+      const p = ins.withRunContext(spanRunContext, orig, this, ...arguments);
+      p.then(function () {
+        span.end();
+      });
+      return p;
+    };
+  }
+
+  function wrapExecute(orig) {
+    return function wrappedExecute(args) {
+      agent.logger.debug('intercepted call to graphql.execute');
+      const span = ins.createSpan(
+        'GraphQL: Unknown Query',
+        'db',
+        'graphql',
+        'execute',
+      );
+      if (!span) {
+        agent.logger.debug(
+          'no active transaction found - skipping graphql tracing',
+        );
+        return orig.apply(this, arguments);
+      }
+
+      let document;
+      let operationName;
+      const singleArgForm =
+        onlySupportsSingleArg ||
+        (!onlySupportsPositionalArgs && arguments.length === 1);
+      if (singleArgForm) {
+        document = args.document;
+        operationName = args.operationName;
+      } else {
+        document = arguments[1];
+        operationName = arguments[5];
+      }
+
+      var details = extractDetails(document, operationName);
+      var queries = details.queries;
+      operationName =
+        operationName ||
+        (details.operation &&
+          details.operation.name &&
+          details.operation.name.value);
+      if (queries.length > 0) {
+        span.name =
+          'GraphQL: ' +
+          (operationName ? operationName + ' ' : '') +
+          queries.join(', ');
+      }
+
+      // `_graphqlRoute` is a boolean, set in instrumentations of other modules
+      // that specify 'graphql' in peerDependencies (e.g. '@apollo/server') to
+      // indicate that this transaction is for a GraphQL request.
+      const trans = span.transaction;
+      if (trans._graphqlRoute) {
+        var name =
+          queries.length > 0 ? queries.join(', ') : 'Unknown GraphQL query';
+        if (trans.req) var path = getPathFromRequest(trans.req, true);
+        var defaultName = name;
+        defaultName = path ? defaultName + ' (' + path + ')' : defaultName;
+        defaultName = operationName
+          ? operationName + ' ' + defaultName
+          : defaultName;
+        trans.setDefaultName(defaultName);
+        trans.type = 'graphql';
+      }
+
+      const spanRunContext = ins.currRunContext().enterSpan(span);
+      const p = ins.withRunContext(spanRunContext, orig, this, ...arguments);
+      if (typeof p.then === 'function') {
+        p.then(function () {
+          span.end();
+        });
+      } else {
+        span.end();
+      }
+      return p;
+    };
+  }
+
+  function extractDetails(document, operationName) {
+    var queries = [];
+    var operation;
+
+    if (document && Array.isArray(document.definitions)) {
+      document.definitions.some(function (definition) {
+        if (
+          !definition ||
+          definition.kind !== graphql.Kind.OPERATION_DEFINITION
+        )
+          return false;
+        if (!operationName && operation) return false;
+        if (
+          !operationName ||
+          (definition.name && definition.name.value === operationName)
+        ) {
+          operation = definition;
+          return true;
+        }
+        return false;
+      });
+
+      var selections =
+        operation &&
+        operation.selectionSet &&
+        operation.selectionSet.selections;
+      if (selections && Array.isArray(selections)) {
+        for (const selection of selections) {
+          const kind = selection.name && selection.name.kind;
+          if (kind === graphql.Kind.NAME) {
+            const queryName = selection.name.value;
+            if (queryName) queries.push(queryName);
+          }
+        }
+
+        queries = queries.sort(function (a, b) {
+          if (a > b) return 1;
+          else if (a < b) return -1;
+          return 0;
+        });
+      }
+    } else {
+      agent.logger.debug(
+        'unexpected document format - skipping graphql query extraction',
+      );
+    }
+
+    return { queries, operation };
+  }
+};

package/lib/instrumentation/modules/handlebars.js

@@ -0,0 +1,33 @@
+/*
+ * 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 templateShared = require('../template-shared');
+
+module.exports = function (handlebars, agent, { version, enabled }) {
+  if (!enabled) return handlebars;
+
+  if (!semver.satisfies(version, '>=1 <5')) {
+    agent.logger.debug(
+      'cannot instrument handlebars version %s, skipping handlebars instrumentation',
+      version,
+    );
+    return handlebars;
+  }
+
+  agent.logger.debug('shimming handlebars.compile');
+  shimmer.wrap(
+    handlebars,
+    'compile',
+    templateShared.wrapCompile(agent, 'handlebars'),
+  );
+
+  return handlebars;
+};

package/lib/instrumentation/modules/http.js

@@ -0,0 +1,112 @@
+/*
+ * 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 httpShared = require('../http-shared');
+var shimmer = require('../shimmer');
+
+function getSafeHeaders(res) {
+  return res.getHeaders ? res.getHeaders() : res._headers;
+}
+
+module.exports = function (modExports, agent, { enabled, isImportMod }) {
+  if (agent._conf.instrumentIncomingHTTPRequests) {
+    agent.logger.debug('shimming http.Server.prototype.emit function');
+    shimmer.wrap(
+      modExports && modExports.Server && modExports.Server.prototype,
+      'emit',
+      httpShared.instrumentRequest(agent, 'http'),
+    );
+
+    agent.logger.debug(
+      'shimming http.ServerResponse.prototype.writeHead function',
+    );
+    shimmer.wrap(
+      modExports &&
+        modExports.ServerResponse &&
+        modExports.ServerResponse.prototype,
+      'writeHead',
+      wrapWriteHead,
+    );
+  }
+
+  if (!enabled) {
+    return modExports;
+  }
+
+  agent.logger.debug('shimming http.request function');
+  let wrapped = shimmer.wrap(
+    modExports,
+    'request',
+    httpShared.traceOutgoingRequest(agent, 'http', 'request'),
+  );
+  if (isImportMod && wrapped) {
+    // With IITM and `import` the above shimmer.wrap handles this usage:
+    //    import { request } from 'http'
+    // To handle this usage:
+    //    import http from 'http'
+    // we need to wrap `modExports.default.request` as well.
+    //
+    // Note that IITM gives us a Proxy *without* a getter, so
+    // `modExports.request !== wrapped`, even though we just set it.
+    modExports.default.request = wrapped;
+  }
+
+  agent.logger.debug('shimming http.get function');
+  wrapped = shimmer.wrap(
+    modExports,
+    'get',
+    httpShared.traceOutgoingRequest(agent, 'http', 'get'),
+  );
+  if (isImportMod && wrapped) {
+    modExports.default.get = wrapped;
+  }
+
+  return modExports;
+
+  function wrapWriteHead(original) {
+    return function wrappedWriteHead() {
+      var headers =
+        arguments.length === 1
+          ? getSafeHeaders(this) // might be because of implicit headers.
+          : arguments[arguments.length - 1];
+
+      var result = original.apply(this, arguments);
+
+      var trans = httpShared.transactionForResponse.get(this);
+      if (trans) {
+        httpShared.transactionForResponse.delete(this);
+
+        // It shouldn't be possible for the statusCode to be falsy, but just in
+        // case we're in a bad state we should avoid throwing
+        trans.result = 'HTTP ' + (this.statusCode || '').toString()[0] + 'xx';
+        trans._setOutcomeFromHttpStatusCode(this.statusCode);
+
+        // End transacton early in case of SSE
+        if (headers && typeof headers === 'object' && !Array.isArray(headers)) {
+          Object.keys(headers).some(function (key) {
+            if (key.toLowerCase() !== 'content-type') return false;
+            if (
+              String(headers[key])
+                .toLowerCase()
+                .indexOf('text/event-stream') !== 0
+            )
+              return false;
+            agent.logger.debug(
+              'detected SSE response - ending transaction %o',
+              { id: trans.id },
+            );
+            agent.endTransaction();
+            return true;
+          });
+        }
+      }
+
+      return result;
+    };
+  }
+};