appdynamics 21.9.0 → 22.5.0

package/appdynamics_version.json

@@ -1,7 +1,7 @@
 {
-    "version": "21.9.0.0",
+    "version": "22.5.0.0",
     "sha": "",
     "nodeVersion": "",
-    "buildName": "8012",
+    "buildName": "8617",
     "compatibilityVersion": "4.4.1.0"
 }

package/lib/core/agent.js

@@ -34,6 +34,7 @@ var CpuProfiler = require('../v8/cpu-profiler').CpuProfiler;
 var HeapProfiler = require('../v8/heap-profiler').HeapProfiler;
 var agentVersion = require('../../appdynamics_version.json');
 var appDNativeLoader = require('appdynamics-native');
+var SecureApp = require('../secure_app/secure_app').SecureApp;
 
 var LibAgent = require('../libagent/libagent').LibAgent;
 var LibagentConnector = require('../libagent/libagent-connector').LibagentConnector;
@@ -88,6 +89,7 @@ function Agent() {
   this.gcStats = new GCStats(this);
   this.cpuProfiler = new CpuProfiler(this);
   this.heapProfiler = new HeapProfiler(this);
+  this.secureApp = new SecureApp(this);
 
   this.libagent = null;
 
@@ -177,6 +179,16 @@ Agent.prototype.init = function (opts) {
 
     self.backendConnector = new LibAgent(this);
 
+    if (opts.openTelemetry && opts.openTelemetry.enabled) {
+      var TracerProvider = require('./opentelemetry-tracer');
+      self.TracerProvider = new TracerProvider(self.logger);
+      if (!self.TracerProvider.register(opts)) {
+        self.logger.error('AppDynamics agent cannot be started: Tracer Provider registration has failed');
+        return;
+      }
+      self.tracer = self.TracerProvider.getTracer('appdynamics-tracer');
+    }
+
     self.precompiled = opts.precompiled === undefined || opts.precompiled;
 
     if (self.opts.excludeAgentFromCallGraph === undefined) {
@@ -272,6 +284,10 @@ Agent.prototype.init = function (opts) {
     self.cpuProfiler.init();
     self.heapProfiler.init();
 
+    if(self.opts.secureAppEnabled) {
+      self.secureApp.init(this);
+    }
+
     // Initialize libagent
     self.backendConnector.intializeAgentHelpers();
 
@@ -332,6 +348,12 @@ Agent.prototype.initializeOpts = function (opts) {
   if (self.opts.nodeName === undefined) {
     self.opts.nodeName = process.env.APPDYNAMICS_AGENT_NODE_NAME;
   }
+  if (self.opts.reuseNode === undefined) {
+    self.opts.reuseNode = process.env.APPDYNAMICS_AGENT_REUSE_NODE_NAME;
+  }
+  if (self.opts.reuseNodePrefix === undefined) {
+    self.opts.reuseNodePrefix = process.env.APPDYNAMICS_AGENT_REUSE_NODE_NAME_PREFIX;
+  }
   if (self.opts.analyticsMaxSegmentSizeInBytes === undefined && process.env.APPDYNAMICS_ANALYTICS_MAX_SEGMENT_SIZE) {
     self.opts.analyticsMaxSegmentSizeInBytes = parseInt(process.env.APPDYNAMICS_ANALYTICS_MAX_SEGMENT_SIZE, 10);
   }

package/lib/core/appDProxy.js

@@ -217,7 +217,7 @@ AppDProxy.prototype.before = function(obj, meths, hook, isCallbackHook, copyAllP
     var beforeExecLogic = function() {
       var currentCtxt = self.agent.thread.current();
       try {
-        var args = arguments;
+        var args = [...arguments];
         var methsInvocationCtxtLocal = methsInvocationCtxt;
         if (methsInvocationCtxtLocal)
           self.agent.thread.resume(methsInvocationCtxtLocal);
@@ -225,19 +225,19 @@ AppDProxy.prototype.before = function(obj, meths, hook, isCallbackHook, copyAllP
           var selfProxy = this;
 
           // the hook code should contain try/catch
-          args = hook(this, arguments, function() {
-            return orig.apply(selfProxy, args || arguments);
-          });
+          args = hook(this, args, function() {
+            return orig.apply(selfProxy, args);
+          }) || args;
         }
         else {
           try {
-            args = hook(this, arguments);
+            args = hook(this, args) || args;
           }
           catch (e) {
             self.logError(e);
           }
 
-          var retValue = orig.apply(this, args || arguments);
+          var retValue = orig.apply(this, args);
           return retValue;
         }
       } finally {
@@ -277,7 +277,7 @@ AppDProxy.prototype.after = function(obj, meths, hook, copyAllProps, methsInvoca
 
         var hookRet;
         try {
-          hookRet = hook(this, arguments, ret);
+          hookRet = hook(this, [...arguments], ret);
         }
         catch (e) {
           self.logError(e);
@@ -350,14 +350,14 @@ AppDProxy.prototype.around = function(obj, meths, hookBefore, hookAfter, copyAll
     defineProperty(obj, meth, function() {
       var currentCtxt = self.agent.thread.current();
       try {
-        var args = arguments;
+        var args = [...arguments];
         var methsInvocationCtxtLocal = methsInvocationCtxt;
         if (methsInvocationCtxtLocal)
           self.agent.thread.resume(methsInvocationCtxtLocal);
         var locals = new Locals();
 
         try {
-          args = hookBefore(this, arguments, locals);
+          args = hookBefore(this, args, locals) || args;
         }
         catch (e) {
           self.logError(e);
@@ -372,8 +372,8 @@ AppDProxy.prototype.around = function(obj, meths, hookBefore, hookAfter, copyAll
           }
         }
 
-        var ret = orig.apply(this, args || arguments);
-        var promiseRet = self.promise(ret, hookAfter, this, arguments, locals, methsInvocationCtxtLocal);
+        var ret = orig.apply(this, args);
+        var promiseRet = self.promise(ret, hookAfter, this, args, locals, methsInvocationCtxtLocal);
         if (promiseRet) {
           self.agent.thread.resume(currentCtxt);
           return promiseRet;
@@ -381,7 +381,7 @@ AppDProxy.prototype.around = function(obj, meths, hookBefore, hookAfter, copyAll
 
         var hookRet;
         try {
-          hookRet = hookAfter(this, arguments, ret, locals);
+          hookRet = hookAfter(this, args, ret, locals);
         }
         catch (e) {
           self.logError(e);

package/lib/core/logger.js

@@ -5,9 +5,6 @@ All Rights Reserved
  */
 'use strict';
 
-var cluster = require('cluster');
-var log4js = require('log4js');
-var path = require('path');
 
 
 function isDebugEnabled(agent) {
@@ -50,94 +47,45 @@ function Logger(agent) {
   };
 }
 exports.Logger = Logger;
-Logger.sharedLogger = undefined; // (for unit tests)
-
 
 /* istanbul ignore next -- log4j mocked in unit tests */
-Logger.prototype.init = function (config, initializeBackend) {
+Logger.prototype.init = function (config) {
   if (!config) {
     config = {};
   }
 
-  if (initializeBackend && Logger.sharedLogger) {
-    // work-around for unit tests to prevent too many loggers
-    // being created, which kills output to stdout :-/
-    this.logger = Logger.sharedLogger;
-  } else {
-    var dateString = new Date().toJSON();
-    dateString = dateString.replace(/[-:]/g, "_").replace("T", "__").replace(/\..*$/, "");
-    var logFileName = 'appd_node_agent_' + dateString + ".log";
-    var rootPath = config.root_directory || this.agent.tmpDir;
-    var baseName = config.filename || logFileName;
-    // Libagent logFile is already created in the libagent. Since, there is no
-    // way to tap on to the file name created by boost::log used by libagent
-    // show the log filePath till agent tmpDir.
-    var fileName = initializeBackend ? path.join(rootPath, baseName) : this.agent.tmpDir;
-
-
-    var consoleOnly = (this.agent.opts.logging && this.agent.opts.logging.logfiles &&
-      this.agent.opts.logging.logfiles.every(function (lf) {
-        return lf.outputType == 'console';
-      }));
-
-    // If console logging env variable is set and no custom logging config is provided
-    // then don't create temp path for logs
-    if (process.env.APPDYNAMICS_LOGGER_OUTPUT_TYPE === "console" && (!config.logfiles || config.logfiles.length == 0)) {
-      consoleOnly = true;
-    }
+  var rootPath = config.root_directory || this.agent.tmpDir;
+  // Libagent logFile is already created in the libagent. Since, there is no
+  // way to tap on to the file name created by boost::log used by libagent
+  // show the log filePath till agent tmpDir.
+  var fileName = this.agent.tmpDir;
 
-    if (!consoleOnly) {
-      this.agent.recursiveMkDir(rootPath);
-    }
 
-    if (this.agent.opts.debug) {
-      // force logging level to DEBUG and output location of logs
-      config.level = 'DEBUG';
-      if (!consoleOnly) {
-        console.log('[DEBUG] Appdynamics agent logs: ' + fileName);
-      }
-    }
+  var consoleOnly = (this.agent.opts.logging && this.agent.opts.logging.logfiles &&
+    this.agent.opts.logging.logfiles.every(function (lf) {
+      return lf.outputType == 'console';
+    }));
 
-    // libagent uses its own logging, and does not need the log4js backend to be initialized
-    if (!initializeBackend) {
-      this.libAgentConnector.initLogger();
-      return;
-    }
+  // If console logging env variable is set and no custom logging config is provided
+  // then don't create temp path for logs
+  if (process.env.APPDYNAMICS_LOGGER_OUTPUT_TYPE === "console" && (!config.logfiles || config.logfiles.length == 0)) {
+    consoleOnly = true;
+  }
 
-    if (process.env.APPDYNAMICS_LOGGER_OUTPUT_TYPE === "console") {
-      // Update the outputType in logging config to console for JavaProxy
-      config.outputType = config.outputType || "console";
-    }
+  if (!consoleOnly) {
+    this.agent.recursiveMkDir(rootPath);
+  }
 
-    if (cluster.isMaster) {
-      log4js.configure({
-        appenders: [{
-          type: 'clustered',
-          appenders: [{
-            type: 'logLevelFilter',
-            level: config.level || process.env.APPDYNAMICS_LOGGER_LEVEL || 'INFO',
-            appender: {
-              type: config.outputType || 'file',
-              filename: fileName,
-              maxLogSize: config.max_size || 5242880,
-              backups: config.max_files || 10,
-              category: 'default',
-              mode: config.mode || 'append'
-            }
-          }]
-        }]
-      });
-    }
-    else {
-      log4js.configure({
-        appenders: [{
-          type: 'clustered'
-        }]
-      });
+  if (this.agent.opts.debug) {
+    // force logging level to DEBUG and output location of logs
+    config.level = 'DEBUG';
+    if (!consoleOnly) {
+      console.log('[DEBUG] Appdynamics agent logs: ' + fileName);
     }
-
-    Logger.sharedLogger = this.logger = log4js.getLogger('default');
   }
+
+  // libagent uses its own logging, and does not need the log4js backend to be initialized
+  this.libAgentConnector.initLogger();
 };
 
 Logger.prototype.trace = function (msg) {
@@ -222,4 +170,4 @@ Logger.prototype.isErrorEnabled = function () {
 
 Logger.prototype.isFatalEnabled = function () {
   return this.logger.isFatalEnabled();
-};
+};

package/lib/core/opentelemetry-tracer.js

@@ -0,0 +1,97 @@
+'use strict';
+
+const opentelemetry_api = require('@opentelemetry/api');
+const { ROOT_CONTEXT } = require('@opentelemetry/api');
+const { BatchSpanProcessor, ConsoleSpanExporter, BasicTracerProvider } = require('@opentelemetry/sdk-trace-base');
+const { OTLPTraceExporter } = require("@opentelemetry/exporter-trace-otlp-proto");
+const { AsyncHooksContextManager, AsyncLocalStorageContextManager } = require("@opentelemetry/context-async-hooks");
+const { ParentBasedSampler, AlwaysOnSampler, TraceIdRatioBasedSampler } = require("@opentelemetry/core");
+const { Resource } = require('@opentelemetry/resources');
+const { SemanticResourceAttributes } = require('@opentelemetry/semantic-conventions');
+const url = require('url');
+
+module.exports = TracerProvider;
+
+function TracerProvider(logger) {
+  this.host = 'localhost';
+  this.port = '55681';
+  this.ot_api = opentelemetry_api;
+  this.ROOT_CONTEXT = ROOT_CONTEXT;
+  this.logger = logger;
+}
+
+function getSamplerFromConfig(config) {
+  if(config.sampler && config.sampler.TraceIdRatioBasedSampler) {
+    const ratio = config.sampler.TraceIdRatioBasedSampler.Ratio || 1;
+    return new TraceIdRatioBasedSampler(ratio);
+  } else {
+    return new AlwaysOnSampler();
+  }
+}
+
+TracerProvider.prototype.register = function(config) {
+  const provider = new BasicTracerProvider({
+    sampler: new ParentBasedSampler({
+      root: getSamplerFromConfig(config.openTelemetry)
+    }),
+    resource: new Resource({
+      [SemanticResourceAttributes.SERVICE_NAME]: config.tierName,
+      [SemanticResourceAttributes.SERVICE_NAMESPACE]: config.applicationName
+    }),
+  });
+
+  // default collector configuration, can be overridden from agent config
+  const collectorOptions = {
+    attributes: {'service.name': config.tierName,
+                 'service.namespace': config.applicationName}
+  };
+
+  // batch export config, empty by default
+  const batchExporterConfig = {};
+
+  if (config.openTelemetry) {
+    if (config.openTelemetry.collector) {
+      Object.assign(collectorOptions, config.openTelemetry.collector);
+      this.url = collectorOptions.url;
+      try {
+        var urlObj = url.parse(this.url);
+        this.host = urlObj.hostname;
+        this.port = urlObj.port;
+      } catch (e) {
+        this.logger.error('Collector url must be in <host>:<port> format');
+        return false;
+      }
+    }
+    if(config.openTelemetry.exporter) {
+      if(config.openTelemetry.exporter.maxExportBatchSize) {
+        batchExporterConfig.maxExportBatchSize = config.openTelemetry.exporter.maxExportBatchSize;
+      }
+      if(config.openTelemetry.exporter.maxQueueSize) {
+        batchExporterConfig.maxQueueSize = config.openTelemetry.exporter.maxQueueSize;
+      }
+      if(config.openTelemetry.exporter.exportTimeoutMillis) {
+        batchExporterConfig.exportTimeoutMillis = config.openTelemetry.exporter.exportTimeoutMillis;
+      }
+      if(config.openTelemetry.exporter.maxExportBatchSize) {
+        batchExporterConfig.maxExportBatchSize = config.openTelemetry.exporter.maxExportBatchSize;
+      }
+    }
+  }
+
+  const exporter = new OTLPTraceExporter(collectorOptions);
+  provider.addSpanProcessor(new BatchSpanProcessor(exporter, batchExporterConfig));
+  if (config.openTelemetry && config.openTelemetry.debug) {
+    provider.addSpanProcessor(new BatchSpanProcessor(new ConsoleSpanExporter(), batchExporterConfig));
+  }
+
+  const majorVersion = parseInt(process.versions.node.split('.')[0]);
+  const minorVersion = parseInt(process.versions.node.split('.')[1]);
+  const contextManager = majorVersion > 14 || majorVersion == 14 && minorVersion >= 8 ?
+    AsyncLocalStorageContextManager : AsyncHooksContextManager;
+  provider.register({contextManager: new contextManager()});
+  return true;
+};
+
+TracerProvider.prototype.getTracer = function(name) {
+  return opentelemetry_api.trace.getTracer(name);
+};

package/lib/libagent/libagent-connector.js

@@ -144,6 +144,7 @@ LibagentConnector.prototype.init = function () {
     self.updateConfigTimerId = new MessageSender(self.agent, 30, 60 * 1000, function () {
       self.libagent.updateConfig();
     });
+    self.setupEum(self.agent);
     self.emit("connected");
 
     self.agent.transactionSender.isEnabled = true;
@@ -345,6 +346,11 @@ LibagentConnector.prototype.startProcessSnapshot = function () {
   self.libagent.startProcessSnapshot();
 };
 
+LibagentConnector.prototype.getBusinessTransactionQueryType = function (entryPointType, callback) {
+  var self = this;
+  return self.libagent.getBusinessTransactionQueryType(entryPointType, callback);
+};
+
 LibagentConnector.prototype.sendProcessSnapshot = function (processSnapshot) {
   var self = this;
   self.libagent.addProcessSnapshot(processSnapshot);
@@ -534,3 +540,21 @@ LibagentConnector.prototype.getEumCookieFields = function (transaction, shortFor
   else
     return {};
 };
+
+LibagentConnector.prototype.setupEum = function (agent) {
+  var libAgentConnector = this;
+  agent.eum.eumCookie.prototype.setFieldValues = function () {
+    var self = this;
+    var shortForm = self.keyForm == 'short';
+    var fields = libAgentConnector.getEumCookieFields(self.transaction, shortForm);
+    if (fields) {
+      for (var key in fields) {
+        self.addSubCookie(key, fields[key]);
+      }
+      self.transaction.eumGuid = fields.g || fields.clientRequestGuid;
+      self.guid = self.transaction.eumGuid;
+      self.setCookie();
+    }
+    return true;
+  };
+};

package/lib/libagent/libagent.js

@@ -143,7 +143,7 @@ LibAgent.prototype.readNodeIndex = function(callback) {
 LibAgent.prototype.initializeLogger = function() {
   var self = this;
   self.agent.logger.setLibAgentConnector(self.agent.libagentConnector);
-  self.agent.logger.init(self.agent.opts.logging, false);
+  self.agent.logger.init(self.agent.opts.logging);
 };
 
 LibAgent.prototype.createCLRDirectories = function() {
@@ -182,6 +182,7 @@ LibAgent.prototype.createExitCall = function(time, exitCallInfo) {
     command: exitCallInfo.command || '',
     properties: exitCallInfo.supportedProperties,
     useBackendConfig: exitCallInfo.useBackendConfig,
+    protocol: exitCallInfo.protocol,
     addAnalyticsData: function(key, value) {
       this.userData = this.userData || [];
       if (value instanceof Date) {

package/lib/libagent/transaction-sender.js

@@ -3,7 +3,7 @@
 * 2016
 * All Rights Reserved
 */
-var url = require('url');
+var utility = require('../utility');
 
 function TransactionSender(agent) {
   this.agent = agent;
@@ -46,6 +46,18 @@ TransactionSender.prototype.init = function() {
         isHttpRequest = true;
         if('singularityheader' in req.headers) {
           corrHeader = req.headers.singularityheader || "";
+        } else if(self.agent.tracer && transaction.baggageCorrHeader) {
+          /* 
+           * 1: We append the doNotResolveSubHeader when the upstream is a pure OT service to 
+           *    prevent resolution to the preceding APPD service
+             2: The noTxDetectHeader is treated specially by libagent, so do not append the doNotResolveSubHeader
+                in this case
+           */
+          const noTxDetectHeader = self.agent.correlation.DISABLE_TRANSACTION_DETECTION + '=true';
+          const doNotResolveSubHeader = self.agent.correlation.DONOTRESOLVE + '=true';
+          corrHeader = transaction.baggageCorrHeader != noTxDetectHeader ? transaction.baggageCorrHeader + '*' + 
+                                                        doNotResolveSubHeader : transaction.baggageCorrHeader;
+          self.agent.logger.debug(`Using Singularity Header from Opentelemetry Baggage ${corrHeader}`);
         }
       }
       if (req.businessTransactionName) {
@@ -53,7 +65,7 @@ TransactionSender.prototype.init = function() {
       }
     }
 
-    var txData = libagentConnector.startBusinessTransaction('NODEJS_WEB', name, corrHeader, self.createBtNamingWrapper(req), isHttpRequest);
+    var txData = libagentConnector.startBusinessTransaction('NODEJS_WEB', name, corrHeader, utility.createBtNamingWrapper(req), isHttpRequest);
 
     if (txData === undefined || txData.isExcluded) {
       transaction.skip = true;
@@ -108,14 +120,3 @@ TransactionSender.prototype.init = function() {
     libagentConnector.stopExitCall(exitCall, error);
   });
 };
-
-
-TransactionSender.prototype.createBtNamingWrapper = function(req) {
-  // TODO: replace these with boost::regex in libagent bindings
-  if (req.url) {
-    var parsedUrl = url.parse(req.url);
-    req.parsedPathName = parsedUrl.pathname;
-    req.parsedParameterString = parsedUrl.query;
-  }
-  return req;
-};

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/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'
     );
   });