appdynamics 23.7.0 → 24.1.0

package/appdynamics_version.json

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

package/lib/core/agent.js

@@ -163,6 +163,27 @@ Agent.computeTmpDir = function (rootTmpDir,
   return path.join(rootTmpDir, sha256.digest('hex').slice(0, 32));
 };
 
+Agent.prototype.setKubernetesConfig = function() {
+  var self = this;
+  try {
+    const NSPACE_PATH = "/var/run/secrets/kubernetes.io/serviceaccount/namespace";
+
+    let clusterService = (process.env.APPDYNAMICS_CONTAINERINFO_FETCH_SERVICE).split(":");
+    if(clusterService.length != 2) {
+      return;
+    }
+
+    self.opts.kbHost = clusterService[0];
+    self.opts.kbPort = parseInt(clusterService[1]);
+    self.opts.kbPodName = process.env.HOSTNAME;
+    self.opts.kbContainerName = process.env.APPDYNAMICS_CONTAINER_NAME;
+    self.opts.kbNspace = fs.readFileSync(NSPACE_PATH, 'utf-8').trim();
+    self.opts.kbConfigEnabled = true;
+  } catch(err) {
+    self.logger.warn('Kubernetes containerid disabled due to' + err + '\n' + err.stack);
+  }
+};
+
 /* istanbul ignore next -- requires too much stubbing and mocking to unit test */
 Agent.prototype.init = function (opts) {
   var self = this;
@@ -177,6 +198,10 @@ Agent.prototype.init = function (opts) {
 
     self.opts.clsDisabled = !!self.opts.clsDisabled;
 
+    if(process.env.APPDYNAMICS_CONTAINERINFO_FETCH_SERVICE) {
+      self.setKubernetesConfig();
+    }
+
     self.backendConnector = new LibAgent(this);
 
     if (opts.openTelemetry && opts.openTelemetry.enabled) {
@@ -225,7 +250,7 @@ Agent.prototype.init = function (opts) {
         self.logger.error('AppDynamics agent cannot be started: node name/node name prefix is either missing or empty');
         return;
       }
-      
+
       var nodeName;
       if(self.opts.nodeName && self.opts.nodeName.length) {
         nodeName = self.opts.nodeName;
@@ -319,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 || {};
@@ -363,8 +401,8 @@ Agent.prototype.initializeOpts = function (opts) {
   if (self.opts.analyticsMaxMessageSizeInBytes === undefined && process.env.APPDYNAMICS_ANALYTICS_MAX_MESSAGE_SIZE) {
     self.opts.analyticsMaxMessageSizeInBytes = parseInt(process.env.APPDYNAMICS_ANALYTICS_MAX_MESSAGE_SIZE, 10);
   }
-};
 
+};
 
 Agent.prototype.fetchMetadata = function (cb) {
   var self = this, key;
@@ -437,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);
@@ -99,13 +100,14 @@ LibagentConnector.prototype.initLogger = function () {
 
 LibagentConnector.prototype.init = function () {
   var self = this;
-
   // initialize protobuf
   self.protobufModel = new ProtobufModel(self.agent);
   self.protobufModel.init();
 
   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() });
 
@@ -143,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();
     });
@@ -257,7 +263,7 @@ LibagentConnector.prototype.startExitCall = function (transaction, exitCall) {
 
 LibagentConnector.prototype.disableResolutionForExitCall = function (exitCall) {
   var self = this;
-  
+
   if(!self.agent.profiler.isValidThreadId(exitCall.threadId)) {
     return;
   }
@@ -322,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);
 };
@@ -496,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;
 
@@ -565,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");
 };
 
@@ -580,7 +611,7 @@ 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;
     }
@@ -602,4 +633,4 @@ LibagentConnector.prototype.setupEum = function (agent) {
 LibagentConnector.prototype.getContainerId = function () {
   var self = this;
   return self.libagent.getContainerId();
-};
+};

package/lib/libagent/libagent.js

@@ -18,6 +18,7 @@ function LibAgent(agent) {
     self.agent.libagentConnector.init();
   });
   this.nodeIndexComputed = false;
+
   // For unit-testing
   this.libagent = true;
 }
@@ -50,11 +51,11 @@ LibAgent.prototype.addNodeIndexToNodeName = function() {
         if (process.argv.filter(arg => arg.includes("yarn")).length !== 0) {
           return;
         }
-        
+
         if (process.argv.filter(arg => arg.includes("npm")).length !== 0) {
           return;
         }
-      }      
+      }
       // create or update node name
       var computedNodeName = (self.agent.opts.nodeName || os.hostname());
       if (!self.agent.opts.noNodeNameSuffix) {

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

@@ -12,13 +12,25 @@ function ApolloEntryProbe(agent) {
 
 ApolloEntryProbe.prototype.init = function () {};
 
-ApolloEntryProbe.prototype.attach = function (obj) {
+ApolloEntryProbe.prototype.attach = function (obj, moduleName) {
+
   let self = this;
-  self.agent.proxy.before(
-    obj.ApolloServer.prototype,
-    "createServerInfo",
-    (args) => this.addLifeCycleHooks(args)
-  );
+
+  if(moduleName == 'apollo-server') {
+    self.agent.proxy.before(
+      obj.ApolloServer.prototype,
+      "createServerInfo",
+      (args) => this.addLifeCycleHooks(args)
+    );
+  } else {
+    const originalObject = obj;
+    const overriddenObject = {};
+  
+    overriddenObject.startStandaloneServer = proxyStartStandaloneServer(self, originalObject);
+    overriddenObject.__proto__ = originalObject;
+    return overriddenObject;
+  }
+
 };
 
 ApolloEntryProbe.prototype.addLifeCycleHooks = function (obj) {
@@ -67,3 +79,49 @@ ApolloEntryProbe.prototype.addLifeCycleHooks = function (obj) {
     ...obj.plugins,
   ];
 };
+
+function proxyStartStandaloneServer(self, originalObject) {
+
+  return async function startStandaloneServerProxy(server, options) {
+    const overriddenOptions = options || {};
+
+    const context = options ? options.context : undefined;
+    const overriddenContext = async function (contextParam) {
+      const contextValue =  context ? await context(contextParam) : {};
+      contextValue.gqlReq = contextParam.req;
+      contextValue.gqlRes = contextParam.res;
+      return contextValue;
+    };
+    overriddenOptions.context = overriddenContext;
+
+    const plugin = {
+      async requestDidStart() {
+        return {
+          didResolveOperation(requestContext) {
+            requestContext.contextValue.gqlReq.graphqlop = requestContext.operationName;
+            requestContext.contextValue.gqlReq.transactionStarted = true;
+            
+            HttpCommon.startTransactionHandler(
+              requestContext.contextValue.gqlReq,
+              requestContext.contextValue.gqlRes,
+              self.agent
+            );
+          },
+          didEncounterErrors(requestContext) {
+            requestContext.contextValue.gqlRes.error = requestContext.errors[0];
+            if(requestContext.contextValue.gqlReq.transactionStarted) {
+              return;
+            }
+            HttpCommon.startTransactionHandler(
+              requestContext.contextValue.gqlReq,
+              requestContext.contextValue.gqlRes,
+              self.agent
+            );
+          },
+        };
+      }
+    };
+    server.addPlugin(plugin);
+    return await originalObject.startStandaloneServer(server, overriddenOptions);
+  };
+}

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

@@ -8,6 +8,7 @@ All Rights Reserved
 var utility = require("../utility");
 var HttpCommon = require("./http-common");
 var getGraphQLParams;
+var parseRequestParams;
 
 function HttpEntryProbe(agent) {
   this.agent = agent;
@@ -21,6 +22,10 @@ HttpEntryProbe.prototype.enableGraphQL = function (egql) {
   getGraphQLParams = egql.getGraphQLParams;
 };
 
+HttpEntryProbe.prototype.enableGraphQLHttp = function (obj) {
+  parseRequestParams = obj.parseRequestParams;
+};
+
 HttpEntryProbe.prototype.attach = function (obj, moduleName) {
   var self = this;
 
@@ -71,6 +76,12 @@ HttpEntryProbe.prototype.__createRequestHandler = function (callback, isHTTPs) {
         }
         self.agent.context.run(requestHandler, req, res);
       });
+    } else if (parseRequestParams) {
+      parseRequestParams(req).then(function(params) {
+        const { operationName } = params;
+        req.graphqlop = operationName;
+      });
+      self.agent.context.run(requestHandler, req, res);
     } else {
       if (
         self.agent.opts.enableGraphQL

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/http-probe.js

@@ -9,9 +9,17 @@ var HttpEntryProbe = require('./http-entry-probe').HttpEntryProbe;
 var HttpExitProbe = require('./http-exit-probe').HttpExitProbe;
 var ApolloEntryProbe = require('./apollo-entry-probe').ApolloEntryProbe;
 
+const graphQLHttpImplementationPaths = [
+  'graphql-http/lib/use/http',
+  'graphql-http/lib/use/http2',
+  'graphql-http/lib/use/express'
+];
+
+const apolloPackages = ['apollo-server', '@apollo/server/standalone'];
+
 function HttpProbe(agent) {
   this.agent = agent;
-  this.packages = ['http', 'https', 'express-graphql', 'apollo-server'];
+  this.packages = ['http', 'https', 'express-graphql', ...apolloPackages, ...graphQLHttpImplementationPaths];
 
   this.entryProbe = new HttpEntryProbe(agent);
   this.exitProbe = new HttpExitProbe(agent);
@@ -33,17 +41,19 @@ HttpProbe.prototype.attach = function (obj, moduleName) {
 
   if (obj.__appdynamicsProbeAttached__) return;
   obj.__appdynamicsProbeAttached__ = true;
-  self.agent.on('destroy', function () {
-    if (obj.__appdynamicsProbeAttached__) {
-      delete obj.__appdynamicsProbeAttached__;
-      if (moduleName !== 'express-graphql' && moduleName !== 'apollo-server') {
+
+  if(moduleName == 'http' || moduleName == 'https') {
+    // Skipping destroy for graphql-http modules as we do not modify them
+    self.agent.on('destroy', function () {
+      if (obj.__appdynamicsProbeAttached__) {
+        delete obj.__appdynamicsProbeAttached__;
         proxy.release(obj.Server.prototype.on);
         proxy.release(obj.Server.prototype.addListener);
         proxy.release(obj.request);
       }
-    }
-  });
-
+    });
+  }
+  
   if (moduleName === 'express-graphql') {
     if (self.agent.opts.enableGraphQL) {
       this.entryProbe.enableGraphQL(obj);
@@ -52,6 +62,14 @@ HttpProbe.prototype.attach = function (obj, moduleName) {
     if(self.agent.opts.enableGraphQL) {
       this.apolloEntryProbe.attach(obj, moduleName);
     }
+  } else if (moduleName === '@apollo/server/standalone') {
+    if(self.agent.opts.enableGraphQL) {
+      return this.apolloEntryProbe.attach(obj, moduleName);
+    }
+  } else if (moduleName.includes('graphql-http')) {
+    if(self.agent.opts.enableGraphQL) {
+      this.entryProbe.enableGraphQLHttp(obj);
+    }
   } else {
     this.entryProbe.attach(obj, moduleName);
     this.exitProbe.attach(obj, moduleName);

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.7.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.7.0.0/appdynamics-libagent-napi-node.tgz",
-        "appdynamics-native": "https://cdn.appdynamics.com/packages/nodejs/23.7.0.0/appdynamics-native-node.tgz",
-        "appdynamics-protobuf": "https://cdn.appdynamics.com/packages/nodejs/23.7.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.7.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.7.0.0/appdynamics-libagent-napi-node.tgz",
-        "appdynamics-native": "https://cdn.appdynamics.com/packages/nodejs/23.7.0.0/appdynamics-native-node.tgz",
-        "appdynamics-protobuf": "https://cdn.appdynamics.com/packages/nodejs/23.7.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
 }