appdynamics 22.2.0 → 22.7.0

package/appdynamics_version.json

@@ -1,7 +1,7 @@
 {
-    "version": "22.2.0.0",
+    "version": "22.7.0.0",
     "sha": "",
     "nodeVersion": "",
-    "buildName": "8373",
+    "buildName": "8783",
     "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;
 
@@ -282,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();
 
@@ -342,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/appdynamics_span_exporter.js

@@ -0,0 +1,43 @@
+"use strict";
+const core_1 = require("@opentelemetry/core");
+
+class AppdynamicsSpanExporter {
+  constructor(logger) {
+    this.logger = logger;
+  }
+
+  export(spans, resultCallback) {
+    return this._sendSpans(spans, resultCallback);
+  }
+
+  shutdown() {
+    this._sendSpans([]);
+    return Promise.resolve();
+  }
+
+  _exportInfo(span) {
+    return {
+      traceId: span.spanContext().traceId,
+      parentId: span.parentSpanId,
+      name: span.name,
+      id: span.spanContext().spanId,
+      kind: span.kind,
+      timestamp: core_1.hrTimeToMicroseconds(span.startTime),
+      duration: core_1.hrTimeToMicroseconds(span.duration),
+      attributes: span.attributes,
+      status: span.status,
+      events: span.events,
+    };
+  }
+
+  _sendSpans(spans, done) {
+    for (const span of spans) {
+      this.logger.trace("Exporting span : " + JSON.stringify(this._exportInfo(span)));
+    }
+    if (done) {
+      return done({ code: core_1.ExportResultCode.SUCCESS });
+    }
+  }
+}
+
+module.exports.AppdynamicsSpanExporter = AppdynamicsSpanExporter;

package/lib/core/opentelemetry-tracer.js

@@ -2,60 +2,91 @@
 
 const opentelemetry_api = require('@opentelemetry/api');
 const { ROOT_CONTEXT } = require('@opentelemetry/api');
-const { BatchSpanProcessor, ConsoleSpanExporter, BasicTracerProvider } = require('@opentelemetry/tracing');
-const { CollectorTraceExporter } = require("@opentelemetry/exporter-collector");
+const { BatchSpanProcessor, 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 } = require("@opentelemetry/core");
+const { ParentBasedSampler, AlwaysOnSampler, TraceIdRatioBasedSampler } = require("@opentelemetry/core");
 const { Resource } = require('@opentelemetry/resources');
 const { SemanticResourceAttributes } = require('@opentelemetry/semantic-conventions');
+const AppdynamicsSpanExporter = require('./appdynamics_span_exporter').AppdynamicsSpanExporter;
 const url = require('url');
 
 module.exports = TracerProvider;
 
 function TracerProvider(logger) {
   this.host = 'localhost';
-  this.port = '55681';
+  this.port = '4318';
+  this.url = `http://${this.host}:${this.port}/v1/traces`;
   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: new AlwaysOnSampler()
+      root: getSamplerFromConfig(config.openTelemetry)
     }),
     resource: new Resource({
       [SemanticResourceAttributes.SERVICE_NAME]: config.tierName,
-      "service.name": config.tierName,
-      "service.namespance": config.applicationName
+      [SemanticResourceAttributes.SERVICE_NAMESPACE]: config.applicationName
     }),
   });
 
   // default collector configuration, can be overridden from agent config
-  const defaultOptions = {
+  const collectorOptions = {
+    url: this.url,
     attributes: {'service.name': config.tierName,
                  'service.namespace': config.applicationName}
   };
 
-  if (config.openTelemetry && config.openTelemetry.collector) {
-    Object.assign(defaultOptions, config.openTelemetry.collector);
-    this.url = defaultOptions.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;
+  // batch export config, empty by default
+  const batchProcessorConfig = {};
+
+  if (config.openTelemetry) {
+    if (config.openTelemetry.collector) {
+      Object.assign(collectorOptions, config.openTelemetry.collector);
+      this.url = collectorOptions.url;
+      this.logger.debug('Exporter using config ' + JSON.stringify(collectorOptions));
+      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) {
+        batchProcessorConfig.maxExportBatchSize = config.openTelemetry.exporter.maxExportBatchSize;
+      }
+      if(config.openTelemetry.exporter.maxQueueSize) {
+        batchProcessorConfig.maxQueueSize = config.openTelemetry.exporter.maxQueueSize;
+      }
+      if(config.openTelemetry.exporter.exportTimeoutMillis) {
+        batchProcessorConfig.exportTimeoutMillis = config.openTelemetry.exporter.exportTimeoutMillis;
+      }
+      if(config.openTelemetry.exporter.maxExportBatchSize) {
+        batchProcessorConfig.maxExportBatchSize = config.openTelemetry.exporter.maxExportBatchSize;
+      }
+    }
+    this.logger.debug('Batch Processor config ' + JSON.stringify(batchProcessorConfig));
   }
 
-  const exporter = new CollectorTraceExporter(defaultOptions);
-  provider.addSpanProcessor(new BatchSpanProcessor(exporter));
-  if (config.openTelemetry && config.openTelemetry.debug) {
-    provider.addSpanProcessor(new BatchSpanProcessor(new ConsoleSpanExporter()));
-  }
+  const exporter = new OTLPTraceExporter(collectorOptions);
+  provider.addSpanProcessor(new BatchSpanProcessor(exporter, batchProcessorConfig));
+  const appdExporter = new AppdynamicsSpanExporter(this.logger, batchProcessorConfig);
+  provider.addSpanProcessor(new BatchSpanProcessor(appdExporter, batchProcessorConfig));
 
   const majorVersion = parseInt(process.versions.node.split('.')[0]);
   const minorVersion = parseInt(process.versions.node.split('.')[1]);
@@ -67,4 +98,4 @@ TracerProvider.prototype.register = function(config) {
 
 TracerProvider.prototype.getTracer = function(name) {
   return opentelemetry_api.trace.getTracer(name);
-};
+};

package/lib/libagent/libagent-connector.js

@@ -163,6 +163,10 @@ LibagentConnector.prototype.startBusinessTransaction = function (entryPointType,
 LibagentConnector.prototype.stopBusinessTransaction = function (transaction) {
   var self = this;
 
+  if(!self.agent.profiler.isValidThreadId(transaction.threadId)) {
+    return;
+  }
+
   if (transaction.error) {
     var name = self.protobufModel.extractErrorName(transaction.error);
     if (!name) {
@@ -203,6 +207,9 @@ LibagentConnector.prototype.stopBusinessTransaction = function (transaction) {
 
 LibagentConnector.prototype.startExitCall = function (transaction, exitCall) {
   var self = this;
+  if(!self.agent.profiler.isValidThreadId(exitCall.threadId)) {
+    return null;
+  }
 
   var propertiesArray = [];
   for (var propName in exitCall.properties) {
@@ -248,7 +255,10 @@ LibagentConnector.prototype.startExitCall = function (transaction, exitCall) {
 
 LibagentConnector.prototype.disableResolutionForExitCall = function (exitCall) {
   var self = this;
-
+  
+  if(!self.agent.profiler.isValidThreadId(exitCall.threadId)) {
+    return;
+  }
   if (exitCall.exitCallGuid !== undefined) {
     self.libagent.disableResolutionForExitCall(exitCall.exitCallGuid);
   }
@@ -256,6 +266,9 @@ LibagentConnector.prototype.disableResolutionForExitCall = function (exitCall) {
 
 LibagentConnector.prototype.getCorrelationHeader = function (exitCall) {
   var self = this;
+  if(!self.agent.profiler.isValidThreadId(exitCall.threadId)) {
+    return;
+  }
 
   if (exitCall.exitCallGuid !== undefined) {
     return self.libagent.getCorrelationHeader(exitCall.exitCallGuid);
@@ -264,6 +277,9 @@ LibagentConnector.prototype.getCorrelationHeader = function (exitCall) {
 
 LibagentConnector.prototype.stopExitCall = function (exitCall, error) {
   var self = this;
+  if(!self.agent.profiler.isValidThreadId(exitCall.threadId)) {
+    return;
+  }
 
   if (exitCall.exitCallGuid == undefined) {
     return;
@@ -310,12 +326,20 @@ LibagentConnector.prototype.sendInstanceTrackerInfo = function (instanceCounts)
 
 LibagentConnector.prototype.isSnapshotRequired = function (transaction) {
   var self = this;
+  if(!self.agent.profiler.isValidThreadId(transaction.threadId)) {
+    return false;
+  }
+
   return self.libagent.isSnapshotRequired(transaction.btGuid);
 };
 
 LibagentConnector.prototype.sendTransactionSnapshot = function (transaction, transactionSnapshot) {
   var self = this;
 
+  if(!self.agent.profiler.isValidThreadId(transaction.threadId)) {
+    return;
+  }
+
   // fixup exit calls: set all required fields so that the protobuf message remains valid
   if (transactionSnapshot.snapshot.exitCalls) {
     transactionSnapshot.snapshot.exitCalls.forEach(function (item) {
@@ -418,6 +442,9 @@ LibagentConnector.prototype.getBusinessTransactionId = function (txnGuid) {
 LibagentConnector.prototype.setHttpParamsInTransactionSnapshot = function (transaction) {
   var self = this;
   // url, methis and statusCode should be present for all http requests
+  if(!self.agent.profiler.isValidThreadId(transaction.threadId)) {
+    return false;
+  }
   if (transaction.url && transaction.method && transaction.statusCode) {
     return self.libagent.setHttpParamsInTransactionSnapshot(
       transaction.btGuid, transaction.url, transaction.method, transaction.statusCode);
@@ -426,11 +453,17 @@ LibagentConnector.prototype.setHttpParamsInTransactionSnapshot = function (trans
 
 LibagentConnector.prototype.addHttpDataToTransactionSnapshot = function (transaction, request) {
   var self = this;
+  if(!self.agent.profiler.isValidThreadId(transaction.threadId)) {
+    return false;
+  }
   return self.libagent.addHttpDataToTransactionSnapshot(transaction.btGuid, request);
 };
 
 LibagentConnector.prototype.setSnapshotRequired = function (transaction) {
   var self = this;
+  if(!self.agent.profiler.isValidThreadId(transaction)) {
+    return;
+  }
   self.libagent.setSnapshotRequired(transaction.btGuid);
 };
 
@@ -535,7 +568,7 @@ LibagentConnector.prototype.initializeTimers = function () {
 
 LibagentConnector.prototype.getEumCookieFields = function (transaction, shortForm) {
   var self = this;
-  if (!transaction.ignore)
+  if (self.agent.profiler.isValidThreadId(transaction.threadId) && !transaction.ignore)
     return self.libagent.getEumCookieFields(transaction.btGuid, shortForm);
   else
     return {};
@@ -545,6 +578,11 @@ LibagentConnector.prototype.setupEum = function (agent) {
   var libAgentConnector = this;
   agent.eum.eumCookie.prototype.setFieldValues = function () {
     var self = this;
+    
+    if(!agent.profiler.isValidThreadId(self.transaction.threadId)) {
+      return false;
+    }
+
     var shortForm = self.keyForm == 'short';
     var fields = libAgentConnector.getEumCookieFields(self.transaction, shortForm);
     if (fields) {

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

@@ -70,6 +70,7 @@ HttpExitProbe.prototype.attach = function (obj, moduleName) {
     var isRepeatForHttps = false;
 
     var [input, options] = args;
+    
     if (typeof(input) != 'string' && !(input instanceof url.URL)) {
       options = input;
       input = null;
@@ -78,6 +79,13 @@ HttpExitProbe.prototype.attach = function (obj, moduleName) {
       args[1] = options;
     }
 
+    if(typeof(options) == 'function') {
+      args[2] = options;
+      options = {};
+      args[1] = options;
+    }
+
+
     if (moduleName === 'https') {
       options.__appdIsHttps = true;
     }
@@ -204,11 +212,12 @@ HttpExitProbe.prototype.attach = function (obj, moduleName) {
   },
     function (obj, args, ret, locals) {
       var [input, options] = args;
+      
       if (typeof(input) != 'string' && !(input instanceof url.URL)) {
         options = input;
         input = null;
       }
-  
+
       options = options || {};
       if (!options.appdIgnore && (moduleName != 'http' || (moduleName === 'http' && !options.__appdIsHttps))) {
         if (locals.parentSpan) {
@@ -261,7 +270,6 @@ HttpExitProbe.prototype.attach = function (obj, moduleName) {
           httpParser = socket.parser;
           var kOnHeadersComplete = HTTPParser.kOnHeadersComplete | 0;
           httpParserMethod = kOnHeadersComplete ? kOnHeadersComplete : 'onHeadersComplete';
-
           var socketCloseHandler = function () {
             socket.removeListener('close', socketCloseHandler);
             if (socket.__appdynamicsCleanup) {

package/lib/probes/http-ot-utils.js

@@ -50,26 +50,28 @@ function getAbsoluteUrl(requestUrl, headers) {
 
 function getIncomingRequestAttributes(request) {
   const attributes = {};
-  const headers = request.headers;
-  const userAgent = headers ? headers['user-agent'] : null;
-  const method = request.method || 'GET';
-  const httpVersion = request.httpVersion;
-  const requestUrl = request.url ? url.parse(request.url) : null;
-  const host = requestUrl && requestUrl.host ? requestUrl.host : headers && headers.host ? headers.host : 'localhost';
-  attributes[SemanticAttributes.HTTP_URL] = getAbsoluteUrl(requestUrl, headers);
-  attributes[SemanticAttributes.HTTP_HOST] = host;
-  attributes[SemanticAttributes.HTTP_METHOD] = method;
-
-  if(requestUrl) {
-    attributes[SemanticAttributes.HTTP_TARGET] = requestUrl.pathname || '/';
-  }
-
-  if(userAgent) {
-    attributes[SemanticAttributes.HTTP_USER_AGENT] = userAgent;
-  }
-
-  if(httpVersion) {
-    attributes[SemanticAttributes.HTTP_FLAVOR] = httpVersion;
+  if (request) {
+    const headers = request.headers;
+    const userAgent = headers && headers['user-agent'];
+    const method = request.method || 'GET';
+    const httpVersion = request.httpVersion;
+    const requestUrl = request.url && url.parse(request.url);
+    const host = requestUrl && requestUrl.host ? requestUrl.host : headers && headers.host ? headers.host : 'localhost';
+    attributes[SemanticAttributes.HTTP_URL] = getAbsoluteUrl(requestUrl, headers);
+    attributes[SemanticAttributes.HTTP_HOST] = host;
+    attributes[SemanticAttributes.HTTP_METHOD] = method;
+
+    if(requestUrl) {
+      attributes[SemanticAttributes.HTTP_TARGET] = requestUrl.pathname || '/';
+    }
+
+    if(userAgent) {
+      attributes[SemanticAttributes.HTTP_USER_AGENT] = userAgent;
+    }
+
+    if(httpVersion) {
+      attributes[SemanticAttributes.HTTP_FLAVOR] = httpVersion;
+    }
   }
   return attributes;
 }
@@ -83,31 +85,33 @@ function getIncomingRequestAttributesOnResponse(response) {
 }
 
 function getOutgoingRequestAttributes(parsedRequest, headers) {
-  const method = parsedRequest.method || 'GET';
-  const userAgent = headers ? headers['user-agent'] : null;
-
   const attributes = {};
-  attributes[SemanticAttributes.HTTP_URL] = getAbsoluteUrl(parsedRequest, headers);
-  attributes[SemanticAttributes.HTTP_METHOD] = method; 
-  attributes[SemanticAttributes.HTTP_TARGET] = parsedRequest.path || '/';
-
+  const userAgent = headers && headers['user-agent'] || undefined;
   if(userAgent) {
     attributes[SemanticAttributes.HTTP_USER_AGENT] = userAgent;
   }
+
+  attributes[SemanticAttributes.HTTP_METHOD] = parsedRequest && parsedRequest.method || 'GET'; 
+  attributes[SemanticAttributes.HTTP_TARGET] = parsedRequest && parsedRequest.path || '/';
+
+  attributes[SemanticAttributes.HTTP_URL] = getAbsoluteUrl(parsedRequest, headers);
+
   return attributes;
 }
 
 function getOutgoingRequestAttributesOnResponse(response, hostname) {
   const attributes = {};
-  const statusCode = response.statusCode;
-  const httpVersion = response.httpVersion;
-  const socket = response.socket;
-  const remotePort = socket ? socket.remotePort : 0;
-  attributes[SemanticAttributes.HTTP_HOST] = `${hostname}:${remotePort}`;
-  attributes[SemanticAttributes.HTTP_STATUS_CODE] = statusCode;
-
-  if(httpVersion) {
-    attributes[SemanticAttributes.HTTP_FLAVOR] = httpVersion;    
+  if (response) {
+    const statusCode = response.statusCode;
+    const httpVersion = response.httpVersion;
+    const socket = response.socket;
+    const remotePort = socket && socket.remotePort || 0;
+    attributes[SemanticAttributes.HTTP_HOST] = `${hostname}:${remotePort}`;
+    attributes[SemanticAttributes.HTTP_STATUS_CODE] = statusCode;
+
+    if(httpVersion) {
+      attributes[SemanticAttributes.HTTP_FLAVOR] = httpVersion;    
+    }
   }
   return attributes;
 }

package/lib/probes/mongodb-probe.js

@@ -99,6 +99,8 @@ MongodbProbe.prototype.attach = function (obj) {
         var cid = event.connectionId;
         if (typeof (cid) === 'string')
           serverPool = [cid];
+        else if (typeof (cid) === 'number')
+          serverPool = [event.address];
         else
           serverPool = [cid.host + ':' + cid.port];
       }
@@ -146,6 +148,7 @@ MongodbProbe.prototype.attach = function (obj) {
     });
 
     supportedCommands.forEach(function (command) {
+      proxy.before(obj.Collection.prototype, command, withAPMBeforeHandler); 
       proxy.before(obj.Server.prototype, command, withAPMBeforeHandler);
       proxy.before(obj.ReplSet.prototype, command, withAPMBeforeHandler);
     });

package/lib/profiler/profiler.js

@@ -179,6 +179,11 @@ Profiler.prototype.endTransaction = function (time, transaction) {
   self._endTransaction(time, transaction);
 };
 
+Profiler.prototype.isValidThreadId = function(threadId) {
+  var self = this;
+  return (threadId && self.transactions[threadId]);
+};
+
 Profiler.prototype._endTransaction = function (time, transaction) {
   var self = this;
 
@@ -228,7 +233,8 @@ Profiler.prototype.__getNextSequenceInfo = function (transaction) {
 };
 
 Profiler.prototype.createExitCall = function (time, exitCallInfo) {
-  return this.agent.backendConnector.createExitCall(time, exitCallInfo);
+  var self = this;
+  return self.agent.backendConnector.createExitCall(time, exitCallInfo);
 };
 
 Profiler.prototype.addExitCall = function (time, exitCall, error) {

package/lib/secure_app/library_metadata.js

@@ -0,0 +1,56 @@
+var path = require('path');
+
+const MAX_ITEMS_PER_GROUP = 1024;
+
+exports.LibraryMetadata = LibraryMetadata;
+function LibraryMetadata(agent) {
+  var self = this;
+  self.agent = agent;
+}
+
+LibraryMetadata.prototype.init = function() {
+};
+
+LibraryMetadata.prototype.getMetadata = function() {
+  var self = this;
+  if(!self.metadataCache) {
+    self.metadataCache = self._getMetadata();
+  }
+  return self.metadataCache;
+};  
+
+LibraryMetadata.prototype._getJson = function()
+{
+  var rootPath = require('path').resolve('./');
+  return require(path.join(rootPath, './package-lock.json'));
+};
+
+LibraryMetadata.prototype._getMetadata = function() {
+  var self = this;
+  try {
+    var pkjson = self._getJson();
+    var metadataCache = [];
+    var cacheGroup = [];
+    var itemCount = 0;
+    for (var pkg in pkjson.dependencies) {
+      if(itemCount == MAX_ITEMS_PER_GROUP) {
+        metadataCache.push(cacheGroup);
+        cacheGroup = [];
+        itemCount = 0;
+      }
+      cacheGroup.push({
+        name: pkg,
+        version: pkjson.dependencies[pkg].version
+      });
+      itemCount = itemCount + 1;
+    }
+  } catch(error) {
+    self.agent.logger.warn('Error reading package metadata ' + error);
+  }
+
+  if(cacheGroup.length) {
+    metadataCache.push(cacheGroup);
+  }
+  return metadataCache;
+};
+

package/lib/secure_app/secure_app.js

@@ -0,0 +1,311 @@
+const http = require('http');
+const https = require('https');
+const url = require('url');
+const HttpsProxyAgent = require('https-proxy-agent');
+
+const LibraryMetadata = require('./library_metadata').LibraryMetadata;
+const MessageSender = require('../libagent/message-sender').MessageSender;
+
+const AUTH_PATH = "/auth/v1/oauth/token";
+const EVENT_PATH = "/argento-agent/v1/report";
+const REGISTER_PATH = "/argento-agent/v1/management";
+
+const MIN_TIMER = 60 * 1000;
+const DAY_TIMER = 24 * 60 * 60 * 1000;
+const RETRY_THRESHOLD = 2;
+const TIMEOUT = 1000;
+
+exports.SecureApp = SecureApp;
+function SecureApp() {
+}
+
+SecureApp.prototype.init = function(agent) {
+  var self = this;
+  self.agent = agent;
+  self.libraryMetadata = new LibraryMetadata(agent);
+  if(!process.env.SKIP_AUTH_FOR_TESTS) {
+    self.authTimerId = new MessageSender(self.agent, 10 * 1000, MIN_TIMER * 9, function () {
+      self.authToken();
+    });
+  } else {
+    self.agent.logger.debug('Secure App skipping auth as SKIP_AUTH_FOR_TESTS is ' + process.env.SKIP_AUTH_FOR_TESTS);
+    self.regTimerId = new MessageSender(self.agent, 10 * 1000, MIN_TIMER, function () {
+      self.register();
+    });
+  }
+  self.httpModule = (self.agent.opts.controllerSslEnabled) ? https : http;
+  self.libraryMetadata.init();
+  self.agent.logger.debug('Secure App module initialized');
+};
+
+SecureApp.prototype._sendRequestWithRetry = function(options, data, cb)
+{
+  var self = this;
+  options.currentRetryAttempt = 0;
+  self._sendRequest(options, data, cb);
+};
+
+SecureApp.prototype._retryRequest = function(options, data, cb)
+{
+  var self = this;
+  if (options.currentRetryAttempt === RETRY_THRESHOLD) {
+    return cb(null, new Error('Retry Threshold Reached'));
+  }
+  options.currentRetryAttempt++;
+  self.agent.logger.trace('SecureApp._retryRequest: Retry attempt ' + options.currentRetryAttempt + ' ' +  options.path);
+  setTimeout(() => {
+    self._sendRequest(options, data, cb);
+  }, TIMEOUT);
+};
+
+SecureApp.prototype._sendRequest = function(options, data, cb) {
+  var self = this;
+  self.agent.logger.trace('SecureApp._sendRequest: ' + options.path + " Data: " + ((options.headers['Content-Type'] != 'application/json') ?
+  data.length.toString() : JSON.stringify(data).length.toString()));
+
+  var request = self.httpModule.request(options, function(response) {
+    const chunks = [];
+    response.on('data', data_chunk => chunks.push(data_chunk));
+    response.on('end', () => {
+      var statusCode = response.statusCode | 0;
+      // don't retry on http 413 (payload too large)
+      if(statusCode == 413) {
+        self.agent.logger.warn('Secure App Http Request failed ' + ' statusCode ' + statusCode);
+        return cb(null, new Error('Http Payload too large'));
+      }
+
+      if (statusCode != 200 || response.is_error) {
+        self.agent.logger.info('Secure App Http Request failed ' + ' statusCode ' + statusCode + ' is_error ' + response.is_error);
+        return self._retryRequest(options, data, cb);
+      }
+      let body = Buffer.concat(chunks);
+      cb(body, null);
+    });
+  });
+
+  request.on('error', function(error) {
+    self.agent.logger.info('Secure app http request error : ' + error);
+    return self._retryRequest(options, data, cb);
+  });
+
+  request.end(data);
+};
+
+SecureApp.prototype._requestHeaders = function(requestOptions) {
+  var self = this;
+  requestOptions.headers['Authorization'] = `Bearer ${self.accessToken}`;
+  requestOptions.headers['User-Agent'] = "NodeJs";
+  requestOptions.headers['appdynamics-agent-applicationName'] = self.agent.opts.applicationName;
+  requestOptions.headers['appdynamics-agent-tierName'] = self.agent.opts.tierName;
+  requestOptions.headers['appdynamics-agent-nodeName'] = self.agent.opts.nodeName;
+  requestOptions.headers['appdynamics-agent-accountName'] = 'singularity-agent@' + self.agent.opts.accountName;
+  if (self.uuid) {
+    requestOptions.headers['appdynamics-agent-nodeUUID'] = self.uuid;
+  }
+};
+
+SecureApp.prototype._requestOptions = function(path, length, type) {
+  var self = this;
+  var requestOptions = {
+    'method': 'POST',
+  };
+
+  requestOptions.headers = {
+    'Content-Length': length,
+    'Content-Type': type
+  };
+
+  if (self.agent.opts.certificateFile) {
+    requestOptions['ca'] = self.agent.opts.certificateFile;
+  }
+
+  if(process.env.CONTROLLER_HOST_TEST) {
+    self.agent.logger.debug('Secure App using controller hostname  CONTROLLER_HOST_TEST: ' + process.env.CONTROLLER_HOST_TEST);
+    requestOptions['hostname'] = process.env.CONTROLLER_HOST_TEST;
+  } else {
+    requestOptions['hostname'] = self.agent.opts.controllerHostName;
+  }
+  if(process.env.CONTROLLER_PORT_TEST) {
+    self.agent.logger.debug('Secure App using controller port  CONTROLLER_PORT_TEST: ' + process.env.CONTROLLER_PORT_TEST);
+    requestOptions['port'] = process.env.CONTROLLER_PORT_TEST;
+  } else {
+    requestOptions['port'] = self.agent.opts.controllerPort;
+  }
+  requestOptions['path'] = path;
+
+  var proxy = {
+    hostName: self.agent.opts.proxyHost,
+    port: self.agent.opts.proxyPort,
+    userName: self.agent.opts.proxyUser,
+    password: ""
+  };
+
+  if (self.agent.opts.proxyPasswordFile) {
+    var fs = require('fs');
+    proxy.password = (fs.readFileSync(self.agent.opts.proxyPasswordFile, 'utf-8')).trim();
+  }
+
+  if (proxy.hostName) {
+    self.agent.logger.debug('Secure App using proxy');
+    var ro = requestOptions;
+    var proxyAuth = proxy.userName && proxy.password && Buffer.from(`${proxy.userName}:${proxy.password}`).toString('base64');
+
+    if (self.agent.opts.controllerSslEnabled) {
+      var proxyUrl = `http://${proxy.hostName}:${proxy.port}`;
+      var proxyOpts = url.parse(proxyUrl);
+      if (proxyAuth) {
+        proxyOpts.headers = {
+          'Proxy-Authentication': `Basic ${proxyAuth}`
+        };
+      }
+      var agent = new HttpsProxyAgent(proxyOpts);
+      ro['agent'] = agent;
+    } else {
+      ro['path'] = `http://${ro.hostname}:${ro.port}${ro.path}`;
+      ro['headers']['Host'] = `${ro.hostname}:${ro.port}`;
+      ro['hostname'] = proxy.hostName;
+      ro['port'] = proxy.port;
+      if (proxyAuth) {
+        ro['headers']['Proxy-Authorization'] = `Basic ${proxyAuth}`;
+      }
+    }
+  }
+  return requestOptions;
+};
+
+SecureApp.prototype._initializeTimers = function() {
+  var self = this;
+  if (self.timersInitialized) {
+    return;
+  }
+  self.timersInitialized = true;
+
+  self.reportEventTimerId = new MessageSender(self.agent, 10 * 1000, DAY_TIMER, function () {
+    self.reportEvents();
+  });
+};
+
+SecureApp.prototype.authenticate = function(grantType) {
+  var self = this;
+  var postData = "password=" + self.agent.opts.accountAccessKey +
+                 "&username=" + 'singularity-agent@' + self.agent.opts.accountName +
+                 "&grant_type=" + grantType;
+
+  if(grantType == 'refresh_token') {
+    postData += '&refresh_token=' + self.refreshToken;
+  }
+
+  var requestOptions = self._requestOptions(AUTH_PATH, postData.length.toString(),
+                               "application/x-www-form-urlencoded; charset=utf-8");
+
+  self._sendRequestWithRetry(requestOptions, postData, function(body, error) {
+    if (error != null) {
+      self.agent.logger.info('Secure App authentication failed');
+      self.accessToken = null;
+      self.refreshToken = null;
+      return;
+    }
+
+    try {
+      body = JSON.parse(body);
+      if (!self.accessToken) {
+        self.regTimerId = new MessageSender(self.agent, 10 * 1000, MIN_TIMER, function () {
+          self.register();
+        });
+      }
+
+      self.accessToken = body.access_token;
+      self.refreshToken = body.refresh_token;
+
+      self.agent.logger.debug('Secure App module authenticated');
+    } catch(err) {
+      self.accessToken = null;
+      self.refreshToken = null;
+      self.agent.logger.warn('Failed to parse Secure app authentication response ' + err);
+    }
+  });
+};
+
+SecureApp.prototype.authToken = function() {
+  var self = this;
+  if(!self.accessToken) {
+    self.authenticate("password");
+  } else {
+    self.authenticate("refresh_token");
+  }
+};
+
+SecureApp.prototype.register = function() {
+  var self = this;
+  var postData = JSON.stringify({
+    "message_type": 0,
+    "app": self.agent.opts.applicationName,
+    "tier": self.agent.opts.tierName,
+    "node": self.agent.opts.nodeName,
+    "access_key": self.agent.opts.accountAccessKey,
+    "account_name": self.agent.opts.accountName,
+    "file_name": "",
+    "epoch_msec": 0,
+    "force": false,
+    "version": 1,
+    "is_started": true,
+    "is_enabled": true,
+    "agent_type": "NodeJs",
+    "agent_build_version": ""
+  });
+
+  var requestOptions = self._requestOptions(REGISTER_PATH, postData.length.toString(), "application/json");
+  self._requestHeaders(requestOptions);
+
+  self._sendRequestWithRetry(requestOptions, postData, function(body, error) {
+    if (error != null) {
+      self.agent.logger.info('Secure App module registeration failed');
+      return;
+    }
+
+    try {
+      body = JSON.parse(body);
+      self.uuid = body.node_uuid;
+      self._initializeTimers();
+      self.agent.logger.debug('Secure App module registered');
+    } catch(err) {
+      self.agent.logger.warn('Failed to parse Secure app registration response ' + err);
+    }
+  });
+};
+
+SecureApp.prototype.sendVulnerabilityEvent = function() {
+  var self = this;
+  if(!self.vulnerabilityEvent) {
+    return;
+  }
+
+  self.vulnerabilityEvent.forEach((data, index) => {
+    var isDone = index == self.vulnerabilityEvent.length - 1 ? true : false;
+    var postData = JSON.stringify({
+      "id": 0,
+      "is_done": isDone,
+      "fragment_index": index,
+      "max_fragments": self.vulnerabilityEvent.length,
+      "nodejs_report_component_vulnerability_list": data
+    });
+    var requestOptions = self._requestOptions(EVENT_PATH, postData.length.toString(), "application/json");
+    self._requestHeaders(requestOptions);
+
+    self._sendRequestWithRetry(requestOptions, postData, function(body, error) {
+      if (error != null) {
+        self.agent.logger.info('Secure App module vulnerability event failed');
+        return;
+      }
+      self.agent.logger.info('Secure App module vulnerability event sent fragment');
+    });
+  });
+};
+
+SecureApp.prototype.reportEvents = function() {
+  var self = this;
+  if(!self.vulnerabilityEvent) {
+    self.vulnerabilityEvent = self.libraryMetadata.getMetadata();
+  }
+  self.sendVulnerabilityEvent();
+};

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "appdynamics",
-    "version": "22.2.0",
+    "version": "22.7.0",
     "description": "Performance Profiler and Monitor",
     "author": "AppDynamics, Inc.",
     "homepage": "https://www.appdynamics.com",
@@ -34,18 +34,20 @@
         "n": "^6.7.0"
     },
     "dependencies": {
-        "@opentelemetry/api": "^1.0.3",
-        "@opentelemetry/exporter-collector": "^0.25.0",
-        "@opentelemetry/node": "^0.24.0",
-        "@opentelemetry/semantic-conventions": "^1.0.1",
-        "@opentelemetry/tracing": "^0.24.0",
+        "@opentelemetry/api": "~1.0.3",
+        "@opentelemetry/context-async-hooks": "~1.0.1",
+        "@opentelemetry/core": "~1.0.1",
+        "@opentelemetry/exporter-trace-otlp-proto": "~0.27.0",
+        "@opentelemetry/resources": "~1.0.1",
+        "@opentelemetry/sdk-trace-base": "~1.0.1",
+        "@opentelemetry/semantic-conventions": "~1.0.1",
         "cls-hooked": "4.2.2",
-        "n": "^6.7.0",
-        "shelljs": "^0.8.5",
+        "https-proxy-agent": "^5.0.0",
         "uuid": "^8.3.2",
-        "appdynamics-libagent-napi": "https://cdn.appdynamics.com/packages/nodejs/22.2.0.0/appdynamics-libagent-napi-node.tgz",
-        "appdynamics-native": "https://cdn.appdynamics.com/packages/nodejs/22.2.0.0/appdynamics-native-node.tgz",
-        "appdynamics-protobuf": "https://cdn.appdynamics.com/packages/nodejs/22.2.0.0/appdynamics-protobuf-node.tgz"
+        "y18n": "^5.0.8",
+        "appdynamics-libagent-napi": "https://cdn.appdynamics.com/packages/nodejs/22.7.0.0/appdynamics-libagent-napi-node.tgz",
+        "appdynamics-native": "https://cdn.appdynamics.com/packages/nodejs/22.7.0.0/appdynamics-native-node.tgz",
+        "appdynamics-protobuf": "https://cdn.appdynamics.com/packages/nodejs/22.7.0.0/appdynamics-protobuf-node.tgz"
     },
     "engines": {
         "node": ">=12 <=v16.*"

package/packageBck.json

@@ -1,6 +1,6 @@
 {
     "name": "appdynamics",
-    "version": "22.2.0",
+    "version": "22.7.0",
     "description": "Performance Profiler and Monitor",
     "author": "AppDynamics, Inc.",
     "homepage": "https://www.appdynamics.com",
@@ -34,18 +34,20 @@
         "n": "^6.7.0"
     },
     "dependencies": {
-        "@opentelemetry/api": "^1.0.3",
-        "@opentelemetry/exporter-collector": "^0.25.0",
-        "@opentelemetry/node": "^0.24.0",
-        "@opentelemetry/semantic-conventions": "^1.0.1",
-        "@opentelemetry/tracing": "^0.24.0",
+        "@opentelemetry/api": "~1.0.3",
+        "@opentelemetry/context-async-hooks": "~1.0.1",
+        "@opentelemetry/core": "~1.0.1",
+        "@opentelemetry/exporter-trace-otlp-proto": "~0.27.0",
+        "@opentelemetry/resources": "~1.0.1",
+        "@opentelemetry/sdk-trace-base": "~1.0.1",
+        "@opentelemetry/semantic-conventions": "~1.0.1",
         "cls-hooked": "4.2.2",
-        "n": "^6.7.0",
-        "shelljs": "^0.8.5",
+        "https-proxy-agent": "^5.0.0",
         "uuid": "^8.3.2",
-        "appdynamics-libagent-napi": "https://cdn.appdynamics.com/packages/nodejs/22.2.0.0/appdynamics-libagent-napi-node.tgz",
-        "appdynamics-native": "https://cdn.appdynamics.com/packages/nodejs/22.2.0.0/appdynamics-native-node.tgz",
-        "appdynamics-protobuf": "https://cdn.appdynamics.com/packages/nodejs/22.2.0.0/appdynamics-protobuf-node.tgz"
+        "y18n": "^5.0.8",
+        "appdynamics-libagent-napi": "https://cdn.appdynamics.com/packages/nodejs/22.7.0.0/appdynamics-libagent-napi-node.tgz",
+        "appdynamics-native": "https://cdn.appdynamics.com/packages/nodejs/22.7.0.0/appdynamics-native-node.tgz",
+        "appdynamics-protobuf": "https://cdn.appdynamics.com/packages/nodejs/22.7.0.0/appdynamics-protobuf-node.tgz"
     },
     "engines": {
         "node": ">=12 <=v16.*"