appdynamics 22.3.0 → 22.5.0

package/appdynamics_version.json

@@ -1,7 +1,7 @@
 {
-    "version": "22.3.0.0",
+    "version": "22.5.0.0",
     "sha": "",
     "nodeVersion": "",
-    "buildName": "8455",
+    "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;
 
@@ -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/opentelemetry-tracer.js

@@ -5,7 +5,7 @@ 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 } = require("@opentelemetry/core");
+const { ParentBasedSampler, AlwaysOnSampler, TraceIdRatioBasedSampler } = require("@opentelemetry/core");
 const { Resource } = require('@opentelemetry/resources');
 const { SemanticResourceAttributes } = require('@opentelemetry/semantic-conventions');
 const url = require('url');
@@ -20,15 +20,23 @@ function TracerProvider(logger) {
   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.namespace": config.applicationName
+      [SemanticResourceAttributes.SERVICE_NAMESPACE]: config.applicationName
     }),
   });
 

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,276 @@
+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;
+
+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._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) {
+    cb(request, response);
+  });
+
+  request.on('error', function(error) {
+    self.agent.logger.info('Secure app http request error : ' + error);
+  });
+  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._sendRequest(requestOptions, postData, function(request, response) {
+    var statusCode = response.statusCode | 0;
+    if (statusCode != 200 || response.is_error) {
+      self.agent.logger.info('Secure App authentication failed');
+      return;
+    }
+
+    const chunks = [];
+    response.on('data', data => chunks.push(data));
+    response.on('end', () => {
+      let body = Buffer.concat(chunks);
+      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');
+    });
+  });
+};
+
+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._sendRequest(requestOptions, postData, function(request, response) {
+    var statusCode = response.statusCode | 0;
+    if (statusCode != 200 || response.is_error) {
+      self.agent.logger.info('Secure App module registeration failed');
+      return;
+    }
+    const chunks = [];
+    response.on('data', data => chunks.push(data));
+    response.on('end', () => {
+      let body = Buffer.concat(chunks);
+      body = JSON.parse(body);
+      self.uuid = body.node_uuid;
+      self._initializeTimers();
+      self.agent.logger.debug('Secure App module registered');
+    });
+  });
+};
+
+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._sendRequest(requestOptions, postData, function(request, response) {
+      var statusCode = response.statusCode | 0;
+      if (statusCode != 200 || response.is_error) {
+        self.agent.logger.info('Secure App module vulnerability event failed');
+        return;
+      }
+
+      const chunks = [];
+      response.on('data', data => chunks.push(data));      
+      response.on('end', () => {
+        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.3.0",
+    "version": "22.5.0",
     "description": "Performance Profiler and Monitor",
     "author": "AppDynamics, Inc.",
     "homepage": "https://www.appdynamics.com",
@@ -42,11 +42,12 @@
         "@opentelemetry/sdk-trace-base": "~1.0.1",
         "@opentelemetry/semantic-conventions": "~1.0.1",
         "cls-hooked": "4.2.2",
+        "https-proxy-agent": "^5.0.0",
         "uuid": "^8.3.2",
         "y18n": "^5.0.8",
-        "appdynamics-libagent-napi": "https://cdn.appdynamics.com/packages/nodejs/22.3.0.0/appdynamics-libagent-napi-node.tgz",
-        "appdynamics-native": "https://cdn.appdynamics.com/packages/nodejs/22.3.0.0/appdynamics-native-node.tgz",
-        "appdynamics-protobuf": "https://cdn.appdynamics.com/packages/nodejs/22.3.0.0/appdynamics-protobuf-node.tgz"
+        "appdynamics-libagent-napi": "https://cdn.appdynamics.com/packages/nodejs/22.5.0.0/appdynamics-libagent-napi-node.tgz",
+        "appdynamics-native": "https://cdn.appdynamics.com/packages/nodejs/22.5.0.0/appdynamics-native-node.tgz",
+        "appdynamics-protobuf": "https://cdn.appdynamics.com/packages/nodejs/22.5.0.0/appdynamics-protobuf-node.tgz"
     },
     "engines": {
         "node": ">=12 <=v16.*"

package/packageBck.json

@@ -1,6 +1,6 @@
 {
     "name": "appdynamics",
-    "version": "22.3.0",
+    "version": "22.5.0",
     "description": "Performance Profiler and Monitor",
     "author": "AppDynamics, Inc.",
     "homepage": "https://www.appdynamics.com",
@@ -42,11 +42,12 @@
         "@opentelemetry/sdk-trace-base": "~1.0.1",
         "@opentelemetry/semantic-conventions": "~1.0.1",
         "cls-hooked": "4.2.2",
+        "https-proxy-agent": "^5.0.0",
         "uuid": "^8.3.2",
         "y18n": "^5.0.8",
-        "appdynamics-libagent-napi": "https://cdn.appdynamics.com/packages/nodejs/22.3.0.0/appdynamics-libagent-napi-node.tgz",
-        "appdynamics-native": "https://cdn.appdynamics.com/packages/nodejs/22.3.0.0/appdynamics-native-node.tgz",
-        "appdynamics-protobuf": "https://cdn.appdynamics.com/packages/nodejs/22.3.0.0/appdynamics-protobuf-node.tgz"
+        "appdynamics-libagent-napi": "https://cdn.appdynamics.com/packages/nodejs/22.5.0.0/appdynamics-libagent-napi-node.tgz",
+        "appdynamics-native": "https://cdn.appdynamics.com/packages/nodejs/22.5.0.0/appdynamics-native-node.tgz",
+        "appdynamics-protobuf": "https://cdn.appdynamics.com/packages/nodejs/22.5.0.0/appdynamics-protobuf-node.tgz"
     },
     "engines": {
         "node": ">=12 <=v16.*"