appdynamics 23.10.0 → 24.1.0

package/appdynamics_version.json

@@ -1,7 +1,7 @@
 {
-    "version": "23.10.0.0",
-    "sha": "",
+    "version": "24.1.0.0",
+    "sha": "e8cff3813a1c37f72ee6694209ae1b557d372eb0",
     "nodeVersion": "",
-    "buildName": "9494",
+    "buildName": "9734",
     "compatibilityVersion": "4.4.1.0"
 }

package/lib/core/agent.js

@@ -344,6 +344,19 @@ Agent.prototype.init = function (opts) {
   }
 };
 
+Agent.prototype.registerOtelProviders = function(containerId) {
+  var self = this;
+  if (self.opts.openTelemetryLogger && self.opts.openTelemetryLogger.enabled) {
+    var OtelLoggerProvider = require('./opentelemetry-logger');
+    self.OtelLoggerProvider = new OtelLoggerProvider(self.logger);
+    if (!self.OtelLoggerProvider.register(self.opts, containerId)) {
+      self.logger.error('OtelLoggerProvider registration has failed, feature disabled');
+      return;
+    }
+    self.OtelLogger = self.OtelLoggerProvider;
+  }
+};
+
 Agent.prototype.initializeOpts = function (opts) {
   var self = this;
   opts = opts || {};
@@ -462,6 +475,7 @@ Agent.prototype.loadProbes = function () {
   probeCons.push(require('../probes/cassandra-probe').CassandraProbe);
   probeCons.push(require('../probes/express-probe').ExpressProbe);
   probeCons.push(require('../probes/rabbitmq-probe').RabbitMQProbe);
+  probeCons.push(require('../probes/winston-probe').WinstonProbe);
 
   var packageProbes = {};
   probeCons.forEach(function (ProbeCon) {

package/lib/core/opentelemetry-logger.js

@@ -0,0 +1,88 @@
+'use strict';
+
+const opentelemetry_api = require('@opentelemetry/api');
+const { DiagConsoleLogger, DiagLogLevel, diag } = require('@opentelemetry/api');
+const { logs, SeverityNumber } = require('@opentelemetry/api-logs');
+const { LoggerProvider, ConsoleLogRecordExporter, SimpleLogRecordProcessor, BatchLogRecordProcessor} = require('@opentelemetry/sdk-logs');
+const { OTLPLogExporter } = require('@opentelemetry/exporter-logs-otlp-proto');
+const { SemanticResourceAttributes } = require('@opentelemetry/semantic-conventions');
+const { Resource } = require('@opentelemetry/resources');
+const url = require('url');
+
+module.exports = OtelLoggerProvider;
+
+function OtelLoggerProvider(logger) {
+  this.ot_api = opentelemetry_api;
+  this.logger = logger;
+}
+
+OtelLoggerProvider.prototype.register = function(config, containerId) {
+  const collectorOptions = {};
+
+  if (config.openTelemetryLogger) {
+    if (config.openTelemetryLogger.collector) {
+      Object.assign(collectorOptions, config.openTelemetryLogger.collector);
+      var urlconfig = collectorOptions.url;
+      this.logger.debug('Exporter using config ' + JSON.stringify(collectorOptions));
+      try {
+        url.parse(urlconfig);
+      } catch (e) {
+        this.logger.error('Collector url must be in <host>:<port> format');
+        return false;
+      }
+    }
+  }
+
+  // Optional and only needed to see the internal diagnostic logging (during development)
+  diag.setLogger(new DiagConsoleLogger(), DiagLogLevel.DEBUG);
+
+  const resource = Resource.default().merge(new Resource({
+    [SemanticResourceAttributes.SERVICE_NAME]: config.tierName,
+    [SemanticResourceAttributes.SERVICE_NAMESPACE]: config.applicationName,
+    [SemanticResourceAttributes.SERVICE_INSTANCE_ID]: config.nodeName,
+    [SemanticResourceAttributes.CONTAINER_ID]: containerId
+  }));
+
+  const loggerProvider = new LoggerProvider({
+    resource: resource,
+  });
+
+  if(config.openTelemetryLogger.debug) {
+    loggerProvider.addLogRecordProcessor(
+      new SimpleLogRecordProcessor(new ConsoleLogRecordExporter())
+    );
+  }
+
+  const loggerExporter = new OTLPLogExporter(collectorOptions);
+  loggerProvider.addLogRecordProcessor(
+    new BatchLogRecordProcessor(loggerExporter)
+  );
+
+  logs.setGlobalLoggerProvider(loggerProvider);
+
+  this.logger = logs.getLogger('Appdynamics', '1.0.0');
+
+  return true;
+};
+
+OtelLoggerProvider.prototype.emit = function(txn, btId, obj, filteredMsg, allowedLevel) {
+
+  const severityNumber = SeverityNumber[obj.level.toUpperCase()];
+  if(severityNumber < allowedLevel) {
+    return;
+  }
+
+  const attributes = {
+    'severity': obj.level.toUpperCase(),  // obj
+    'appd.bt.id': btId, // transaction
+    'appd.bt.name': txn.name, // transaction
+    'appd.request.guid': txn.guid // transaction
+  };
+
+  this.logger.emit({
+    severityNumber: severityNumber,
+    severityText: obj.level.toUpperCase(),
+    body: filteredMsg,
+    attributes: attributes,
+  });
+};

package/lib/libagent/libagent-connector.js

@@ -85,6 +85,7 @@ function LibagentConnector(agent) {
   this.manualProcessSnapshotInProgress = undefined;
   this.instanceTrackingTimerId = undefined;
   this.timersInitialized = false;
+  this.nodeProperties = new Map();
   EventEmitter.call(this);
 }
 util.inherits(LibagentConnector, EventEmitter);
@@ -105,8 +106,11 @@ LibagentConnector.prototype.init = function () {
 
   self.manualProcessSnapshotInProgress = false;
 
+  self.nodeProperties.set("opentelemetry-logs-push-enabled", 0);
+  self.nodeProperties.set("opentelemetry-allowed-log-level", 0);
   self.libagent.init(self.agent);
   self.agent.TracerProvider && self.agent.TracerProvider.updateResourceAttributes({ "container.id": self.getContainerId() });
+
   self.exceptionHandlers = new ExceptionHandlers();
   self.exceptionHandlers.init(
     self.agent,
@@ -141,6 +145,10 @@ LibagentConnector.prototype.init = function () {
 
   self.agent.on('agentStarted', function (meta, filters) {
     self.libagent.start(meta, filters);
+    self.registerNodeProperties();
+
+    self.agent.registerOtelProviders(self.getContainerId());
+
     self.updateConfigTimerId = new MessageSender(self.agent, 30, 60 * 1000, function () {
       self.libagent.updateConfig();
     });
@@ -320,6 +328,20 @@ LibagentConnector.prototype.updateInstanceTracking = function () {
   this.emit("instanceTrackerConfig", config);
 };
 
+LibagentConnector.prototype.updateNodeProperties = function () {
+  this.nodeProperties.forEach((value, key) => {
+    this.nodeProperties.set(key, this.libagent.getNodeProperty(key));
+  });
+};
+
+LibagentConnector.prototype.getNodeProperty = function (name) {
+  return this.nodeProperties.get(name);
+};
+
+LibagentConnector.prototype.filterLogMessage = function (msg) {
+  return this.libagent.filterLogMessage(msg);
+};
+
 LibagentConnector.prototype.sendInstanceTrackerInfo = function (instanceCounts) {
   this.libagent.addInstanceData(instanceCounts);
 };
@@ -494,6 +516,13 @@ LibagentConnector.prototype.handleProcessSnapshotRequest = function () {
   }
 };
 
+LibagentConnector.prototype.registerNodeProperties = function () {
+  var self = this;
+  this.nodeProperties.forEach((value, key) => {
+    self.libagent.registerNodeProperty(key, value);
+  });
+};
+
 LibagentConnector.prototype.initializeTimers = function () {
   var self = this;
 
@@ -563,6 +592,10 @@ LibagentConnector.prototype.initializeTimers = function () {
     self.updateInstanceTracking();
   });
 
+  self.updateNodePropertyTimerId = new MessageSender(self.agent, 10, 60 * 1000, function () {
+    self.updateNodeProperties();
+  });
+
   self.logDebug("Initialized libagent timers");
 };
 
@@ -600,4 +633,4 @@ LibagentConnector.prototype.setupEum = function (agent) {
 LibagentConnector.prototype.getContainerId = function () {
   var self = this;
   return self.libagent.getContainerId();
-};
+};

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

@@ -69,7 +69,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;
@@ -88,11 +88,11 @@ HttpExitProbe.prototype.attach = function (obj, moduleName) {
     if (moduleName === 'https') {
       options.__appdIsHttps = true;
     }
-      
+
     self.setHttpDefaults(locals, args[0], args[1], moduleName);
 
     if (locals.opts.method === 'CONNECT') {
-      // ignore proxy tunnel setup; requests sent via the 
+      // ignore proxy tunnel setup; requests sent via the
       // proxy tunnel will get instrumented as they are made
       options.appdIgnore = true;
       return;
@@ -117,7 +117,7 @@ HttpExitProbe.prototype.attach = function (obj, moduleName) {
       self.agent.logger.debug('Skipping HTTP exit call for the transaction.' +
         'AppdIgnore is: ' + options.appdIgnore + ' ' +
         'DynamoDB call is:' + isDynamoDBReq + ' ' +
-        'HTTPS call is:' + isRepeatForHttps + ' ' + 
+        'HTTPS call is:' + isRepeatForHttps + ' ' +
         'isOtPath is :' + isOtPath);
     } else {
       self.agent.logger.debug('Gatheing HTTP exit call information.');
@@ -210,7 +210,7 @@ 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;
@@ -223,7 +223,7 @@ HttpExitProbe.prototype.attach = function (obj, moduleName) {
         }
         var writeOnce = false, httpParser, httpParserMethod;
         var threadId = locals.time.threadId;
-  
+
         proxy.before(ret, ['on', 'addListener'], function (obj, args) {
           proxy.callback(args, -1, null, null, threadId);
         }, false, false, threadId);
@@ -259,7 +259,7 @@ HttpExitProbe.prototype.attach = function (obj, moduleName) {
             obj.setHeader(self.agent.correlation.HEADER_NAME, correlationHeaderValue);
           }
         }, false, false, threadId);
-        
+
         ret.on('socket', function (socket) {
           httpParser = socket.parser;
           httpParserMethod = httpParser.__proto__.constructor.kOnHeadersComplete;
@@ -305,6 +305,8 @@ HttpExitProbe.prototype.attach = function (obj, moduleName) {
 HttpExitProbe.prototype.setHttpDefaults = function (locals, spec, opts, protocol) {
   if (typeof (spec) === 'string') {
     locals.opts = url.parse(spec);
+  } else if (spec instanceof url.URL) {
+    locals.opts = url.parse(spec.toString());
   } else {
     locals.opts = Object.assign({}, spec);
   }
@@ -313,7 +315,7 @@ HttpExitProbe.prototype.setHttpDefaults = function (locals, spec, opts, protocol
   }
 
   locals.opts.hostname = locals.opts.hostname || locals.opts.host || 'localhost';
-  locals.opts.port = locals.opts.port 
+  locals.opts.port = locals.opts.port
     || locals.opts.defaultPort
     || locals.opts.agent && locals.opts.agent.defaultPort
     || ((protocol === 'https') ? 443 : 80);

package/lib/probes/winston-probe.js

@@ -0,0 +1,41 @@
+exports.WinstonProbe = WinstonProbe;
+
+function WinstonProbe(agent) {
+  this.agent = agent;
+  this.packages = ['winston'];
+}
+
+WinstonProbe.prototype.init = function () {};
+
+WinstonProbe.prototype.attach = function (obj) {
+  if(obj.__appdynamicsProbeAttached__) return;
+  obj.__appdynamicsProbeAttached__ = true;
+  let self = this;
+  self.agent.proxy.before(
+    obj.Logger.prototype,
+    "write",
+    (obj, args) => this.addLifeCycleHooks(obj, args)
+  );
+};
+
+WinstonProbe.prototype.addLifeCycleHooks = function (obj, args) {
+  let self = this;
+
+  if(!self.agent.libagentConnector.getNodeProperty("opentelemetry-logs-push-enabled")
+     || !self.agent.OtelLogger) {
+    return;
+  }
+
+  const threadId =  self.agent.profiler.time().threadId;
+  const txn = self.agent.profiler.getTransaction(threadId);
+  if(!args[0]) {
+    self.agent.logger.debug('Invalid Log message captured in winston probe');
+    return;
+  }
+  const logMessage = args[0];
+  this.agent.OtelLogger.emit(txn,
+                             self.agent.libagentConnector.getBusinessTransactionId(txn.btGuid),
+                             logMessage,
+                             self.agent.libagentConnector.filterLogMessage(logMessage.message),
+                             self.agent.libagentConnector.getNodeProperty("opentelemetry-allowed-log-level"));
+};

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "appdynamics",
-    "version": "23.10.0",
+    "version": "24.1.0",
     "description": "Performance Profiler and Monitor",
     "author": "AppDynamics, Inc.",
     "homepage": "https://www.appdynamics.com",
@@ -31,30 +31,34 @@
         "lib": "./lib"
     },
     "optionalDependencies": {
-        "n": "^6.7.0"
+        "n": "^6.8.0"
     },
     "dependencies": {
         "@opentelemetry/api": "~1.4.1",
+        "@opentelemetry/api-logs": "^0.45.1",
         "@opentelemetry/context-async-hooks": "~1.10.1",
         "@opentelemetry/core": "~1.10.1",
-        "@opentelemetry/exporter-trace-otlp-proto": "~0.36.1",
+        "@opentelemetry/exporter-logs-otlp-grpc": "^0.45.1",
+        "@opentelemetry/exporter-logs-otlp-proto": "^0.45.1",
+        "@opentelemetry/exporter-trace-otlp-proto": "^0.36.1",
         "@opentelemetry/resources": "~1.10.1",
+        "@opentelemetry/sdk-logs": "^0.45.1",
         "@opentelemetry/sdk-trace-base": "~1.10.1",
         "@opentelemetry/semantic-conventions": "~1.10.1",
         "@yarnpkg/lockfile": "^1.1.0",
         "cls-hooked": "4.2.2",
-        "https-proxy-agent": "^5.0.0",
+        "https-proxy-agent": "^5.0.1",
         "uuid": "^8.3.2",
         "y18n": "^5.0.8",
-        "appdynamics-libagent-napi": "https://cdn.appdynamics.com/packages/nodejs/23.10.0.0/appdynamics-libagent-napi-node.tgz",
-        "appdynamics-native": "https://cdn.appdynamics.com/packages/nodejs/23.10.0.0/appdynamics-native-node.tgz",
-        "appdynamics-protobuf": "https://cdn.appdynamics.com/packages/nodejs/23.10.0.0/appdynamics-protobuf-node.tgz"
+        "appdynamics-libagent-napi": "https://cdn.appdynamics.com/packages/nodejs/24.1.0.0/appdynamics-libagent-napi-node.tgz",
+        "appdynamics-native": "https://cdn.appdynamics.com/packages/nodejs/24.1.0.0/appdynamics-native-node.tgz",
+        "appdynamics-protobuf": "https://cdn.appdynamics.com/packages/nodejs/24.1.0.0/appdynamics-protobuf-node.tgz"
     },
     "overrides": {
         "semver": "7.5.4"
     },
     "engines": {
-        "node": ">=12 <=v20.*"
+        "node": ">=12 <=v21.*"
     },
     "engine-strict": true
 }

package/packageBck.json

@@ -1,6 +1,6 @@
 {
     "name": "appdynamics",
-    "version": "23.10.0",
+    "version": "24.1.0",
     "description": "Performance Profiler and Monitor",
     "author": "AppDynamics, Inc.",
     "homepage": "https://www.appdynamics.com",
@@ -31,30 +31,34 @@
         "lib": "./lib"
     },
     "optionalDependencies": {
-        "n": "^6.7.0"
+        "n": "^6.8.0"
     },
     "dependencies": {
         "@opentelemetry/api": "~1.4.1",
+        "@opentelemetry/api-logs": "^0.45.1",
         "@opentelemetry/context-async-hooks": "~1.10.1",
         "@opentelemetry/core": "~1.10.1",
-        "@opentelemetry/exporter-trace-otlp-proto": "~0.36.1",
+        "@opentelemetry/exporter-logs-otlp-grpc": "^0.45.1",
+        "@opentelemetry/exporter-logs-otlp-proto": "^0.45.1",
+        "@opentelemetry/exporter-trace-otlp-proto": "^0.36.1",
         "@opentelemetry/resources": "~1.10.1",
+        "@opentelemetry/sdk-logs": "^0.45.1",
         "@opentelemetry/sdk-trace-base": "~1.10.1",
         "@opentelemetry/semantic-conventions": "~1.10.1",
         "@yarnpkg/lockfile": "^1.1.0",
         "cls-hooked": "4.2.2",
-        "https-proxy-agent": "^5.0.0",
+        "https-proxy-agent": "^5.0.1",
         "uuid": "^8.3.2",
         "y18n": "^5.0.8",
-        "appdynamics-libagent-napi": "https://cdn.appdynamics.com/packages/nodejs/23.10.0.0/appdynamics-libagent-napi-node.tgz",
-        "appdynamics-native": "https://cdn.appdynamics.com/packages/nodejs/23.10.0.0/appdynamics-native-node.tgz",
-        "appdynamics-protobuf": "https://cdn.appdynamics.com/packages/nodejs/23.10.0.0/appdynamics-protobuf-node.tgz"
+        "appdynamics-libagent-napi": "https://cdn.appdynamics.com/packages/nodejs/24.1.0.0/appdynamics-libagent-napi-node.tgz",
+        "appdynamics-native": "https://cdn.appdynamics.com/packages/nodejs/24.1.0.0/appdynamics-native-node.tgz",
+        "appdynamics-protobuf": "https://cdn.appdynamics.com/packages/nodejs/24.1.0.0/appdynamics-protobuf-node.tgz"
     },
     "overrides": {
         "semver": "7.5.4"
     },
     "engines": {
-        "node": ">=12 <=v20.*"
+        "node": ">=12 <=v21.*"
     },
     "engine-strict": true
 }