appdynamics 21.6.0 → 22.2.0

package/lib/metrics/metrics-manager.js

@@ -6,6 +6,7 @@ All Rights Reserved
 'use strict';
 
 var EventLoopMetrics = require('./eventloop').EventLoopMetrics;
+var Metric = require('./metric').Metric;
 
 /*
  * MetricsManager manages metric lifecycle, i.e. keeps list
@@ -476,16 +477,16 @@ MetricsManager.prototype.createMetric = function (definition, isCustom) {
 
   if (this.metrics.length == 5000) {
     self.agent.logger.warn('too many metrics, ignoring metric');
-    return new self.agent.Metric(self.agent, definition, isCustom);
+    return new Metric(self.agent, definition, isCustom);
   }
 
   var path = definition.path;
   if (!self.validatePath(path)) {
     self.agent.logger.warn('metric parameter(s) missing or invalid, ignoring metric');
-    return new self.agent.Metric(self.agent, definition, isCustom); // dummy metric
+    return new Metric(self.agent, definition, isCustom); // dummy metric
   }
 
-  metric = new self.agent.Metric(self.agent, definition, isCustom);
+  metric = new Metric(self.agent, definition, isCustom);
   self.metrics.push(metric);
   self.metricMap[definition.path] = metric;
 

package/lib/probes/apollo-entry-probe.js

@@ -0,0 +1,69 @@
+/*
+This is for apollo-server entry probe 
+*/
+
+let HttpCommon = require("./http-common");
+
+exports.ApolloEntryProbe = ApolloEntryProbe;
+
+function ApolloEntryProbe(agent) {
+  this.agent = agent;
+}
+
+ApolloEntryProbe.prototype.init = function () {};
+
+ApolloEntryProbe.prototype.attach = function (obj) {
+  let self = this;
+  self.agent.proxy.before(
+    obj.ApolloServer.prototype,
+    "createServerInfo",
+    (args) => this.addLifeCycleHooks(args)
+  );
+};
+
+ApolloEntryProbe.prototype.addLifeCycleHooks = function (obj) {
+  let self = this;
+  let userDefinedContext = obj.context;
+  obj.context = function ({ req, res }) {
+    let userCtx;
+    if (userDefinedContext instanceof Function) {
+      userCtx = userDefinedContext.call(this, ...arguments);
+    } else if (userDefinedContext instanceof Object) {
+      userDefinedContext.gqlReq = req;
+      userDefinedContext.gqlRes = res;
+      return userDefinedContext;
+    }
+    return Object.assign({ gqlReq: req, gqlRes: res }, userCtx);
+  };
+
+  obj.plugins = [
+    {
+      requestDidStart() {
+        return {
+          didResolveOperation(response) {
+            response.context.gqlReq.graphqlop = response.operationName;
+            response.context.gqlReq.transactionStarted = true;
+            HttpCommon.startTransactionHandler(
+              response.context.gqlReq,
+              response.context.gqlRes,
+              self.agent
+            );
+          },
+
+          didEncounterErrors(response) {
+            response.context.gqlRes.error = response.errors[0];
+            if(response.context.gqlReq.transactionStarted) {
+              return;
+            }
+            HttpCommon.startTransactionHandler(
+              response.context.gqlReq,
+              response.context.gqlRes,
+              self.agent
+            );
+          },
+        };
+      },
+    },
+    ...obj.plugins,
+  ];
+};

package/lib/probes/cluster-probe.js

@@ -77,7 +77,7 @@ ClusterProbe.prototype.attach = function(obj) {
     }
 
     function writeIndexPid() {
-      fs.writeFile(indexDir + '/' + freeIndex + '.pid', ret.process.pid, function(err) {
+      fs.writeFile(indexDir + '/' + freeIndex + '.pid', String(ret.process.pid), function(err) {
         if(err) return self.agent.logger.error(err);
       });
     }

package/lib/probes/couchbase-probe.js

@@ -64,6 +64,25 @@ CouchBaseProbe.prototype.attach = function(obj) {
         after
       );
     }
+
+    // driver 3.x Cluster prototype
+    proxy.around(obj.Cluster.prototype, 'query',
+      function(obj, args, locals) {
+        locals.time = self.agent.profiler.time();
+        locals.methodHasCb = proxy.callback(args, -1, function() {}, null, self.agent.thread.current());
+
+        var addresses;
+        var bucketName = Object.keys(obj._conns);
+        addresses = obj._connStr || '';
+        addresses = (addresses.match(/(?:.*:\/\/)?([^/?]+)/)[1] || '').split(',');
+
+        var command = 'query';
+        var commandArgs = args;
+
+        self.createExitCall(bucketName, addresses, command, commandArgs, locals);
+      },
+      after
+    );
   } else {
     // driver 2.x
     proxy.around(obj.Cluster.prototype, 'openBucket', function(obj, args, locals) {

package/lib/probes/grpc-exit-probe.js

@@ -121,7 +121,7 @@ GrpcExitProbe.prototype.injectCorrelationHeader = function(args, type, corrHeade
   var metadataIndex = args.findIndex((arg) => {
     return (arg &&
             typeof arg === 'object' &&
-            arg._internal_repr &&
+            arg.internalRepr &&
             typeof arg.getMap === 'function'
     );
   });

package/lib/probes/http-common.js

@@ -4,10 +4,14 @@ Copyright (c) AppDynamics, Inc., and its affiliates
 All Rights Reserved
  */
 'use strict';
+var HttpOTUtils = require('./http-ot-utils.js');
 
 module.exports.getHttpStatusCodeConfig = getHttpStatusCodeConfig;
 module.exports.generateError = generateError;
 module.exports.getHttpExitCallError = getHttpExitCallError;
+module.exports.finalizeTransaction = finalizeTransaction;
+module.exports.startTransactionHandler = startTransactionHandler;
+
 
 function getHttpStatusCodeConfig(statusCode, statusCodesConfig) {
   if (!statusCodesConfig) {
@@ -61,3 +65,96 @@ function getHttpExitCallError(statusCode, stack, locals) {
     stack: stack};
   return error;
 }
+
+
+function finalizeTransaction (err, profiler, time, transaction, req, res, span) {
+  if (!time.done()) return;
+
+  transaction.error = transaction.error || res.error || err;
+  transaction.statusCode = transaction.statusCode ||
+    (transaction.error && transaction.error.statusCode) ||
+    (res && res.statusCode) ||
+    500;
+  transaction.stackTrace = transaction.stackTrace || profiler.formatStackTrace(transaction.error);
+
+  var error = generateError(transaction.error, transaction.statusCode);
+  if (error) {
+    transaction.error = error;
+  }
+
+  if (transaction.api && transaction.api.onResponseComplete) {
+    transaction.api.onResponseComplete.apply(transaction.api, [req, res]);
+  }
+
+  if (span) {
+    span.setAttributes(HttpOTUtils.getIncomingRequestAttributesOnResponse(res));
+    span.setStatus(HttpOTUtils.parseResponseStatus(res));
+    span.end();
+  }
+
+  profiler.endTransaction(time, transaction);
+}
+
+function startTransactionHandler(req, res, agent, isHTTPs, tracer, ot_api) {
+  var profiler = agent.profiler;
+  var proxy = agent.proxy;
+  var time = profiler.time(true);
+
+  agent.metricsManager.addMetric(
+    agent.metricsManager.HTTP_INCOMING_COUNT,
+    1
+  );
+
+  var span = undefined;
+  var baggageCorrHeader = undefined;
+  var otContext = undefined;
+  
+  if (tracer) {
+    otContext = ot_api.propagation.extract(agent.TracerProvider.ot_api.ROOT_CONTEXT, req.headers);
+    var baggage = ot_api.propagation.getBaggage(otContext);
+    if (baggage && baggage.getEntry(agent.correlation.HEADER_NAME)) {
+      baggageCorrHeader = baggage.getEntry(agent.correlation.HEADER_NAME).value;
+    }
+  }
+
+  var transaction = profiler.startTransaction(time, req, "NODEJS_WEB", baggageCorrHeader);
+
+  if (tracer) {
+    ot_api.context.with(otContext, () => {
+      span = tracer.startSpan(transaction.name, {
+        kind: ot_api.SpanKind.SERVER,
+        attributes: HttpOTUtils.getIncomingRequestAttributes(req)
+      });
+    });
+  }
+
+  agent.context.set("threadId", transaction.threadId);
+  req.__appdThreadId = transaction.threadId;
+
+  transaction.url = req.url;
+  transaction.method = req.method;
+  transaction.requestHeaders = req.headers;
+
+  var eumEnabled = transaction.eumEnabled && !transaction.skip;
+
+  if (!transaction.corrHeader && eumEnabled) {
+    proxy.before(res, "writeHead", function (obj) {
+      if (!transaction.isFinished) {
+        var eumCookie = agent.eum.newEumCookie(
+          transaction,
+          req,
+          obj,
+          isHTTPs
+        );
+        eumCookie.build();
+      }
+    });
+  }
+
+  proxy.after(res, "end", function () {
+    finalizeTransaction(null, profiler, time, transaction, req, res, span);
+    transaction = null;
+  });
+
+  return { transaction, span, otContext };
+}

package/lib/probes/http-entry-probe.js

@@ -3,27 +3,19 @@ Copyright (c) AppDynamics, Inc., and its affiliates
 2015
 All Rights Reserved
  */
-'use strict';
+"use strict";
 
-var HttpCommon = require('./http-common');
+var utility = require("../utility");
+var HttpCommon = require("./http-common");
 var getGraphQLParams;
 
 function HttpEntryProbe(agent) {
   this.agent = agent;
-
-  this.statusCodesConfig = undefined;
-  this.delayedCallbackQueue = [];
 }
 
 exports.HttpEntryProbe = HttpEntryProbe;
 
-HttpEntryProbe.prototype.init = function () {
-  var self = this;
-
-  self.agent.on('configUpdated', function () {
-    self.statusCodesConfig = self.agent.configManager.getConfigValue('errorConfig.httpStatusCodes');
-  });
-};
+HttpEntryProbe.prototype.init = function () {};
 
 HttpEntryProbe.prototype.enableGraphQL = function (egql) {
   getGraphQLParams = egql.getGraphQLParams;
@@ -32,18 +24,12 @@ HttpEntryProbe.prototype.enableGraphQL = function (egql) {
 HttpEntryProbe.prototype.attach = function (obj, moduleName) {
   var self = this;
 
-  self.agent.timers.startTimer(100, true, function () {
-    var now = Date.now();
+  self.agent.timers.startTimer(100, true, function () {});
 
-    while (self.delayedCallbackQueue.length > 0) {
-      if (self.delayedCallbackQueue[0].ts < now - 10) {
-        var delayedCallbackInfo = self.delayedCallbackQueue.shift();
-        delayedCallbackInfo.func.call(this);
-      } else {
-        break;
-      }
-    }
-  });
+  if (self.agent.tracer) {
+    self.ot_api = self.agent.TracerProvider.ot_api;
+    self.tracer = self.agent.tracer;
+  }
 
   self.isHTTPs = obj.Agent && (obj.Agent.prototype.defaultPort == 443);
 
@@ -60,59 +46,16 @@ HttpEntryProbe.prototype.attach = function (obj, moduleName) {
   });
 };
 
-HttpEntryProbe.prototype.finalizeTransaction = function (err, profiler, time, transaction, req, res) {
-  if (!time.done()) return;
-
-  transaction.error = transaction.error || res.error || err;
-  transaction.statusCode = transaction.statusCode ||
-    (transaction.error && transaction.error.statusCode) ||
-    (res && res.statusCode) ||
-    500;
-  transaction.stackTrace = transaction.stackTrace || profiler.formatStackTrace(transaction.error);
-
-  var error = HttpCommon.generateError(transaction.error, transaction.statusCode, this.statusCodesConfig);
-  if (error) {
-    transaction.error = error;
-  }
-
-  if (transaction.api && transaction.api.onResponseComplete) {
-    transaction.api.onResponseComplete.apply(transaction.api, [req, res]);
-  }
-  profiler.endTransaction(time, transaction);
-};
-
-function createBTCallback(agent, profiler, time, transaction, req, res, thread, callback, self, origSelf, origArgs) {
-  var didRun = false;
-  var threadId = thread.current();
-
-  // Node 0.8: need to ensure request isn't consumed
-  // before delayed handler gets run
-  if (agent.processInfo.isv0_8) {
-    req.pause();
+function invokeOriginal(callback, self, args, ot_api, span, otCtx, req, res) {
+  if (ot_api) {
+    ot_api.context.with(ot_api.trace.setSpan(otCtx, span), () => {
+      ot_api.context.bind(ot_api.context.active(), req);
+      ot_api.context.bind(ot_api.context.active(), res);
+      return callback.apply(self, args);
+    });
+  } else {
+    return callback.apply(self, args);
   }
-
-  return self.agent.context.bind(function () {
-    if (didRun) return;
-    didRun = true;
-
-    // Node 0.8: safe to resume the request now
-    // we're ready to process it
-    if (agent.processInfo.isv0_8) {
-      req.resume();
-    }
-
-    var oldThreadId = thread.current();
-    thread.resume(threadId);
-    try {
-      callback = agent.proxy.wrapWithThreadProxyIfEnabled(callback);
-      callback.apply(origSelf, origArgs);
-    } catch (e) {
-      self.finalizeTransaction(e, profiler, time, transaction, req, res);
-      throw e;
-    } finally {
-      thread.resume(oldThreadId);
-    }
-  });
 }
 
 HttpEntryProbe.prototype.__createRequestHandler = function (callback, isHTTPs) {
@@ -129,66 +72,43 @@ HttpEntryProbe.prototype.__createRequestHandler = function (callback, isHTTPs) {
         self.agent.context.run(requestHandler, req, res);
       });
     } else {
-      self.agent.context.run(requestHandler, req, res);
+      if (
+        self.agent.opts.enableGraphQL
+        && self.agent.libagentConnector.getBusinessTransactionQueryType(
+          "NODEJS_WEB",
+          utility.createBtNamingWrapper(req)
+        ) == utility.constants.GRAPHQL_QUERY_TYPE
+      ) {
+        self.agent.context.run(callback, req, res);
+      } else {
+        self.agent.context.run(requestHandler, req, res);
+      }
     }
   };
 
   function requestHandler(req, res) {
-    var profiler = self.agent.profiler;
-    var proxy = self.agent.proxy;
-    var time = profiler.time(true);
+    let profiler = self.agent.profiler;
+    let time = profiler.time(true);
 
     self.agent.metricsManager.addMetric(self.agent.metricsManager.HTTP_INCOMING_COUNT, 1);
 
-    var transaction = profiler.startTransaction(time, req, 'NODEJS_WEB');
-    self.agent.context.set('threadId', transaction.threadId);
-    req.__appdThreadId = transaction.threadId;
-
-    transaction.url = req.url;
-    transaction.method = req.method;
-    transaction.requestHeaders = req.headers;
+    let { transaction, span, otContext } = HttpCommon.startTransactionHandler(req, res, self.agent, isHTTPs, self.tracer, self.ot_api);
 
-    var eumEnabled = (transaction.eumEnabled && !transaction.skip) || (self.agent.eum.enabled && self.agent.eum.enabledForTransaction(req));
+    var threadId = transaction.threadId;
+    self.agent.context.run(() => {
+      
+      var oldThreadId = self.agent.thread.current();
+      self.agent.thread.resume(threadId);
 
-    if (!transaction.corrHeader && eumEnabled) {
-      proxy.before(res, 'writeHead', function (obj) {
-        if (!transaction.isFinished) {
-          var eumCookie = self.agent.eum.newEumCookie(transaction, req, obj, isHTTPs);
-          eumCookie.build();
-        }
-      });
-    }
-
-    proxy.after(res, 'end', function () {
-      self.finalizeTransaction(null, profiler, time, transaction, req, res);
-      transaction = null;
-    });
-
-    if (self.agent.opts.btEntryPointDelayDisabled) {
       try {
-        let threadProxyWrappedCb = self.agent.proxy.wrapWithThreadProxyIfEnabled(callback);
-        return threadProxyWrappedCb.apply(this, arguments);
+        return invokeOriginal(callback, this, arguments, self.ot_api, span, otContext, req, res);
       } catch (e) {
-        self.finalizeTransaction(e, profiler, time, transaction, req, res);
+        HttpCommon.finalizeTransaction(e, profiler, time, transaction, req, res, span);
         transaction = null;
         throw e;
+      } finally {
+        self.agent.thread.resume(oldThreadId);
       }
-    }
-
-    var delayedCallback = createBTCallback(self.agent,
-      profiler,
-      time,
-      transaction,
-      req, res,
-      self.agent.thread,
-      callback,
-      self,
-      this,
-      arguments);
-
-    transaction.once('ignoreTransactionCbExecute', delayedCallback);
-    transaction.emit('delayedCallbackReady');
-    transaction.once('btInfoResponse', delayedCallback);
-    self.delayedCallbackQueue.push({ ts: Date.now(), func: delayedCallback });
+    });
   }
 };