appdynamics 24.9.0 → 24.12.0

package/appdynamics_version.json

@@ -1,7 +1,7 @@
 {
-    "version": "24.9.0.0",
-    "sha": "",
+    "version": "24.12.0.0",
+    "sha": "9ace834212bd2d285a9d19f2e69af5f771a8acc6",
     "nodeVersion": "",
-    "buildName": "10247",
+    "buildName": "10453",
     "compatibilityVersion": "4.4.1.0"
 }

package/lib/core/agent.js

@@ -189,7 +189,7 @@ Agent.prototype.isMainThread = function () {
   return isMainThread;
 };
 
-function setMetadataFile(instrumentedStatus) {
+function setMetadataFile(agent, instrumentedStatus) {
   const filePath = process.env.APPDYNAMICS_AGENT_DIR || '/tmp/appd';
   const fileName = path.join(filePath, 'app-metadata.json');
 
@@ -198,7 +198,7 @@ function setMetadataFile(instrumentedStatus) {
     const content = JSON.stringify({ instrumented: instrumentedStatus });
     fs.writeFileSync(fileName, content);
   } catch (err) {
-    this.agent.logger.error(
+    agent.logger.error(
       `Unable to write the file app-metadata.json to path ${filePath} \n`,
       err
     );
@@ -240,7 +240,7 @@ Agent.prototype.init = function (opts) {
     }
 
 
-    self.libagentConnector.subscribeToIsEnabled((isEnabled) => setMetadataFile(isEnabled));
+    self.libagentConnector.subscribeToIsEnabled((isEnabled) => setMetadataFile(self, isEnabled));
 
     self.precompiled = opts.precompiled === undefined || opts.precompiled;
 
@@ -731,3 +731,7 @@ var AppDynamics = function () {
 AppDynamics.Agent = Agent;
 
 exports = module.exports = new AppDynamics();
+
+// export for testing
+exports._setMetadataFile = setMetadataFile;
+

package/lib/core/opentelemetry-tracer.js

@@ -6,7 +6,7 @@ const { BatchSpanProcessor, BasicTracerProvider } = require('@opentelemetry/sdk-
 const { OTLPTraceExporter } = require("@opentelemetry/exporter-trace-otlp-proto");
 const { AsyncHooksContextManager, AsyncLocalStorageContextManager } = require("@opentelemetry/context-async-hooks");
 const { ParentBasedSampler, AlwaysOnSampler, TraceIdRatioBasedSampler } = require("@opentelemetry/core");
-const { Resource } = require('@opentelemetry/resources');
+const { Resource, envDetectorSync, processDetectorSync, hostDetectorSync } = require('@opentelemetry/resources');
 const { SemanticResourceAttributes } = require('@opentelemetry/semantic-conventions');
 const AppdynamicsSpanExporter = require('./appdynamics_span_exporter').AppdynamicsSpanExporter;
 const url = require('url');
@@ -33,15 +33,26 @@ function getSamplerFromConfig(config) {
 }
 
 TracerProvider.prototype.register = function(config) {
+  const envResource = envDetectorSync.detect();
+  const processResource = processDetectorSync.detect();
+  const hostResource = hostDetectorSync.detect();
+
+  const configResourceAttributes = {
+    [SemanticResourceAttributes.SERVICE_NAME]: config.tierName,
+    [SemanticResourceAttributes.SERVICE_NAMESPACE]: config.applicationName,
+    [SemanticResourceAttributes.CONTAINER_ID]: ""
+  };
+  
+  const mergedResource = new Resource(configResourceAttributes)
+  .merge(envResource)
+  .merge(processResource)
+  .merge(hostResource);
+
   const provider = new BasicTracerProvider({
     sampler: new ParentBasedSampler({
       root: getSamplerFromConfig(config.openTelemetry)
     }),
-    resource: new Resource({
-      [SemanticResourceAttributes.SERVICE_NAME]: config.tierName,
-      [SemanticResourceAttributes.SERVICE_NAMESPACE]: config.applicationName,
-      [SemanticResourceAttributes.CONTAINER_ID]: ""
-    }),
+    resource: mergedResource,
   });
 
   // default collector configuration, can be overridden from agent config

package/lib/libagent/libagent-connector.js

@@ -174,6 +174,12 @@ LibagentConnector.prototype.init = function () {
 
     self.agent.transactionSender.isEnabled = true;
   });
+
+  self.libagent.delegate.on('sepDropped', function (guid) {
+    var profiler = self.agent.profiler;
+    profiler.sepDropped(guid);
+  });
+
   self.libagent.delegate.on('transactionDropped', function (guid) {
     var profiler = self.agent.profiler;
     profiler.transactionDropped(guid);
@@ -229,6 +235,33 @@ LibagentConnector.prototype.stopBusinessTransaction = function (transaction) {
   self.libagent.stopBusinessTransaction(transaction.btGuid);
 };
 
+LibagentConnector.prototype.startServiceEndpoint = function (entryPointType, request) {
+  var self = this;
+  return self.libagent.startServiceEndpoint(entryPointType, request);
+};
+
+LibagentConnector.prototype.stopServiceEndpoint = function (sep) {
+  var self = this;
+
+  if(!self.agent.profiler.isValidSepThreadId(sep.threadId)) {
+    return;
+  }
+
+  if (sep.error) {
+    var name = self.protobufModel.extractErrorName(sep.error);
+    if (!name) {
+      name = "";
+    }
+    var message = self.protobufModel.extractErrorMessage(sep.error);
+    if (!message) {
+      message = "";
+    }
+
+    self.libagent.addErrorToEndpoint(sep.sepGuid, name, message);
+  }
+
+  self.libagent.stopServiceEndpoint(sep.sepGuid);
+};
 
 LibagentConnector.prototype.startExitCall = function (transaction, exitCall) {
   var self = this;

package/lib/libagent/transaction-sender.js

@@ -22,6 +22,29 @@ TransactionSender.prototype.init = function() {
     self.isEnabled = true;
   });
 
+  self.agent.on("serviceEndpointStart", function(sep, req) {
+    if (!self.isEnabled) {
+      self.agent.logger.warn('serviceEndpointStart sent without enabled sender');
+      return;
+    }
+    var sepData = libagentConnector.startServiceEndpoint('NODEJS_WEB', utility.createBtNamingWrapper(req));
+
+    if (sepData === undefined || sepData.isExcluded) {
+      sep.skip = true;
+      return;
+    }
+
+    sep.skip = false;
+    sep.name = sepData.name;
+    sep.sepGuid = sepData.sepGuid;
+  });
+
+  self.agent.on("serviceEndpointStop", function(sep) {
+    if (!self.isEnabled || sep.skip) {
+      return;
+    }
+    libagentConnector.stopServiceEndpoint(sep);
+  });
 
   self.agent.on("transactionStarted", function(transaction, req) {
     if (!self.isEnabled) {
@@ -47,15 +70,15 @@ TransactionSender.prototype.init = function() {
         if('singularityheader' in req.headers) {
           corrHeader = req.headers.singularityheader || "";
         } else if(self.agent.tracer && transaction.baggageCorrHeader) {
-          /* 
-           * 1: We append the doNotResolveSubHeader when the upstream is a pure OT service to 
+          /*
+           * 1: We append the doNotResolveSubHeader when the upstream is a pure OT service to
            *    prevent resolution to the preceding APPD service
              2: The noTxDetectHeader is treated specially by libagent, so do not append the doNotResolveSubHeader
                 in this case
            */
           const noTxDetectHeader = self.agent.correlation.DISABLE_TRANSACTION_DETECTION + '=true';
           const doNotResolveSubHeader = self.agent.correlation.DONOTRESOLVE + '=true';
-          corrHeader = transaction.baggageCorrHeader != noTxDetectHeader ? transaction.baggageCorrHeader + '*' + 
+          corrHeader = transaction.baggageCorrHeader != noTxDetectHeader ? transaction.baggageCorrHeader + '*' +
                                                         doNotResolveSubHeader : transaction.baggageCorrHeader;
           self.agent.logger.debug(`Using Singularity Header from Opentelemetry Baggage ${corrHeader}`);
         }

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

@@ -22,7 +22,22 @@ ApolloEntryProbe.prototype.attach = function (obj, moduleName) {
       "createServerInfo",
       (args) => this.addLifeCycleHooks(args)
     );
-  } else {
+  } else if (moduleName === '@apollo/server') {
+
+    const originalObject = obj;
+    const overriddenObject = {};
+
+    overriddenObject.ApolloServer = proxyApolloServer(self, originalObject);
+    return overriddenObject;
+    
+  } else if(moduleName === '@apollo/server/express4') {
+    const originalObject = obj;
+    const overriddenObject = {};
+
+    overriddenObject.expressMiddleware = proxyExpressMiddleware(self, originalObject);
+    overriddenObject.__proto__ = originalObject;
+    return overriddenObject;
+  } else if(moduleName === '@apollo/server/standalone'){
     const originalObject = obj;
     const overriddenObject = {};
   
@@ -80,48 +95,87 @@ ApolloEntryProbe.prototype.addLifeCycleHooks = function (obj) {
   ];
 };
 
-function proxyStartStandaloneServer(self, originalObject) {
+function appDynamicsApolloServerPlugin(self) {
+  const plugin = {
+    async requestDidStart() {
+      return {
+        didResolveOperation(requestContext) {
+          if(!requestContext.contextValue.gqlReq) {
+            requestContext.contextValue.gqlReq = {};
+            requestContext.contextValue.gqlRes = {};
+          }
+          requestContext.contextValue.gqlReq.graphqlop = requestContext.operationName;
+          requestContext.contextValue.gqlReq.transactionStarted = true;
+          
+          HttpCommon.startTransactionHandler(
+            requestContext.contextValue.gqlReq,
+            requestContext.contextValue.gqlRes,
+            self.agent
+          );
+        },
+        didEncounterErrors(requestContext) {
+          if(!requestContext.contextValue.gqlReq) {
+            requestContext.contextValue.gqlReq = {};
+            requestContext.contextValue.gqlRes = {};
+          }
+          requestContext.contextValue.gqlRes.error = requestContext.errors[0];
+          if(requestContext.contextValue.gqlReq.transactionStarted) {
+            return;
+          }
+          HttpCommon.startTransactionHandler(
+            requestContext.contextValue.gqlReq,
+            requestContext.contextValue.gqlRes,
+            self.agent
+          );
+        },
+      };
+    }
+  };
+  return plugin;
+}
+
+function appDymanicsApolloServerOverriddenOptions(options) {
+  const overriddenOptions = options || {};
+
+  const context = options ? options.context : undefined;
+  const overriddenContext = async function (contextParam) {
+    const contextValue =  context ? await context(contextParam) : {};
+    contextParam.req.url = contextParam.req.baseUrl; // For Apollo Server 4
+    contextValue.gqlReq = contextParam.req;
+    contextValue.gqlRes = contextParam.res;
+    return contextValue;
+  };
+  overriddenOptions.context = overriddenContext;
+  return overriddenOptions;
+}
+
+function proxyApolloServer(self, originalObject) {
+  const ApolloServer = originalObject.ApolloServer;
 
+  // Define ApolloServerProxy class
+  class ApolloServerProxy extends ApolloServer {
+    constructor(config) {
+      // Call the ApolloServer constructor
+      super(config);
+
+      // Add the plugin to the plugins array
+      this.addPlugin(appDynamicsApolloServerPlugin(self));
+    }
+  }
+
+  return ApolloServerProxy;
+}
+
+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);
+    const overriddenOptions = appDymanicsApolloServerOverriddenOptions(options);
     return await originalObject.startStandaloneServer(server, overriddenOptions);
   };
 }
+
+function proxyExpressMiddleware(self, originalObject) {
+  return function expressMiddlewareProxy(server, options) {
+    const overriddenOptions = appDymanicsApolloServerOverriddenOptions(options);
+    return originalObject.expressMiddleware(server, overriddenOptions);
+  };
+}

package/lib/probes/http-common.js

@@ -10,6 +10,7 @@ module.exports.getHttpStatusCodeConfig = getHttpStatusCodeConfig;
 module.exports.generateError = generateError;
 module.exports.getHttpExitCallError = getHttpExitCallError;
 module.exports.finalizeTransaction = finalizeTransaction;
+module.exports.finalizeRequest = finalizeRequest;
 module.exports.startTransactionHandler = startTransactionHandler;
 
 
@@ -66,10 +67,30 @@ function getHttpExitCallError(statusCode, stack, locals) {
   return error;
 }
 
-
-function finalizeTransaction (err, profiler, time, transaction, req, res, span) {
+function finalizeRequest(err, profiler, time, transaction, req, res, span, sep) {
   if (!time.done()) return;
+  finalizeTransaction(err, profiler, time, transaction, req, res, span);
+  finalizeServiceEndpoint(err, profiler, time, sep, res);
+}
+
+function finalizeServiceEndpoint (err, profiler, time, sep, res) {
+  if(!sep) return;
+  sep.error = sep.error || res.error || err;
+  sep.statusCode = sep.statusCode ||
+    (sep.error && sep.error.statusCode) ||
+    (res && res.statusCode) ||
+    500;
+  sep.stackTrace = sep.stackTrace || profiler.formatStackTrace(sep.error);
+
+  var error = generateError(sep.error, sep.statusCode);
+  if (error) {
+    sep.error = error;
+  }
+  profiler.endServiceEndpoint(time, sep);
+}
+
 
+function finalizeTransaction (err, profiler, time, transaction, req, res, span) {
   transaction.error = transaction.error || res.error || err;
   transaction.statusCode = transaction.statusCode ||
     (transaction.error && transaction.error.statusCode) ||
@@ -108,7 +129,7 @@ function startTransactionHandler(req, res, agent, isHTTPs, tracer, ot_api) {
   var span = undefined;
   var baggageCorrHeader = undefined;
   var otContext = undefined;
-  
+
   if (tracer) {
     otContext = ot_api.propagation.extract(agent.TracerProvider.ot_api.ROOT_CONTEXT, req.headers);
     var baggage = ot_api.propagation.getBaggage(otContext);
@@ -151,10 +172,13 @@ function startTransactionHandler(req, res, agent, isHTTPs, tracer, ot_api) {
     });
   }
 
+  var serviceEndpoint = profiler.startServiceEndpoint(time, req, 'NODEJS_WEB');
+
   proxy.after(res, "end", function () {
-    finalizeTransaction(null, profiler, time, transaction, req, res, span);
+    finalizeRequest(null, profiler, time, transaction, req, res, span, serviceEndpoint);
     transaction = null;
+    serviceEndpoint = null;
   });
 
-  return { transaction, span, otContext };
+  return { transaction, span, otContext, serviceEndpoint };
 }

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

@@ -115,7 +115,7 @@ HttpEntryProbe.prototype.__createRequestHandler = function (callback, isHTTPs) {
 
     self.agent.metricsManager.addMetric(self.agent.metricsManager.HTTP_INCOMING_COUNT, 1);
 
-    let { transaction, span, otContext } = HttpCommon.startTransactionHandler(req, res, self.agent, isHTTPs, self.tracer, self.ot_api);
+    let { transaction, span, otContext, serviceEndpoint } = HttpCommon.startTransactionHandler(req, res, self.agent, isHTTPs, self.tracer, self.ot_api);
 
     var threadId = transaction.threadId;
     self.agent.context.run(() => {
@@ -127,7 +127,8 @@ HttpEntryProbe.prototype.__createRequestHandler = function (callback, isHTTPs) {
         let threadProxyWrappedCb = self.agent.proxy.wrapWithThreadProxyIfEnabled(callback);
         return invokeOriginal(threadProxyWrappedCb, this, arguments, self.ot_api, span, otContext, req, res);
       } catch (e) {
-        HttpCommon.finalizeTransaction(e, profiler, time, transaction, req, res, span);
+        HttpCommon.finalizeRequest(e, profiler, time, transaction, req, res, span, serviceEndpoint);
+        serviceEndpoint = null;
         transaction = null;
         throw e;
       } finally {
@@ -140,6 +141,6 @@ HttpEntryProbe.prototype.__createRequestHandler = function (callback, isHTTPs) {
   // This is needed as Express attaches a bunch of extra properties and
   // functionality, which may need to be accessed by other modules down stream.
   handler.__proto__ = callback;
-  
+
   return handler;
 };

package/lib/probes/http-probe.js

@@ -9,7 +9,7 @@ var HttpEntryProbe = require('./http-entry-probe').HttpEntryProbe;
 var HttpExitProbe = require('./http-exit-probe').HttpExitProbe;
 var ApolloEntryProbe = require('./apollo-entry-probe').ApolloEntryProbe;
 
-const apolloPackages = ['apollo-server', '@apollo/server/standalone'];
+const apolloPackages = ['apollo-server', '@apollo/server/standalone', '@apollo/server/express4', '@apollo/server'];
 
 function HttpProbe(agent) {
   this.agent = agent;
@@ -58,9 +58,21 @@ HttpProbe.prototype.attach = function (obj, moduleName) {
     }
   } else if (moduleName === '@apollo/server/standalone') {
     if(self.agent.opts.enableGraphQL) {
+      obj.__appdynamicsProbeAttached__ = false;
       return this.apolloEntryProbe.attach(obj, moduleName);
     }
-  } else if (moduleName.includes('graphql-http')) {
+  } else if(moduleName === '@apollo/server/express4') {
+    if(self.agent.opts.enableGraphQL) {
+      obj.__appdynamicsProbeAttached__ = false;
+      return this.apolloEntryProbe.attach(obj, moduleName);
+    }
+  } else if(moduleName === '@apollo/server') {
+    if(self.agent.opts.enableGraphQL) {
+      obj.__appdynamicsProbeAttached__ = false;
+      return this.apolloEntryProbe.attach(obj, moduleName);
+    }
+  }
+  else if (moduleName.includes('graphql-http')) {
     if(self.agent.opts.enableGraphQL) {
       this.entryProbe.enableGraphQLHttp(obj);
     }

package/lib/probes/mongodb-probe.js

@@ -283,7 +283,7 @@ MongodbProbe.prototype.attach = function (obj) {
       proxy.before(obj.MongoClient.prototype, 'connect', function(obj){
         obj.monitorCommands = true;
         var newServerPool;
-        var newOpQueue = {};
+        var newOpQueue = new Map();
         var newApmCollectionEvents = ['create', 'drop'];
         var newCollectionCommandMap = {
           'create': 'createCollection',
@@ -306,13 +306,13 @@ MongodbProbe.prototype.attach = function (obj) {
             newServerPool = [event.address];
           }
           if (newServerPool) {
-            if (!newOpQueue[requestId]) {
-              newOpQueue[requestId] = {
+            if (!newOpQueue.has(requestId)) {
+              newOpQueue.set(requestId, {
                 time: profiler.time(),
                 serverPool: newServerPool
-              };
+              });
             }
-            newRequest = newOpQueue[requestId];
+            newRequest = newOpQueue.get(requestId);
             newCommandQuery = event.command.filter;
             if (event.command.filter && Object.prototype.toString.call(event.command.filter) == "[object Object]") {
               newCommandQuery = utility.filterSensitiveDataFromObject(utility.deepCopy(event.command.filter));
@@ -334,18 +334,18 @@ MongodbProbe.prototype.attach = function (obj) {
         });
 
         obj.on('commandSucceeded', function (event) {
-          var requestId = event.requestId, newRequest = newOpQueue[requestId];
+          var requestId = event.requestId, newRequest = newOpQueue.get(requestId);
           if (newRequest) {
             self.addExitCall(newRequest.time, newRequest.exitCall);
-            newOpQueue[requestId] = undefined;
+            newOpQueue.delete(requestId);
           }
         });
 
         obj.on('commandFailed', function (event) {
-          var requestId = event.requestId, newRequest = newOpQueue[requestId];
+          var requestId = event.requestId, newRequest = newOpQueue.get(requestId);
           if (newRequest) {
             self.addExitCall(event.time, event.exitCall, event.failure);
-            newOpQueue[requestId] = undefined;
+            newOpQueue.delete(requestId);
           }
         });
       });

package/lib/profiler/profiler.js

@@ -19,6 +19,7 @@ function Profiler(agent) {
   this.agent = agent;
 
   this.transactions = {};
+  this.serviceEndpoints = {};
   this.stackTraceFilter = /appdynamics/;
 }
 exports.Profiler = Profiler;
@@ -83,6 +84,43 @@ Profiler.prototype.formatStackTrace = function (err) {
   return undefined;
 };
 
+Profiler.prototype.startServiceEndpoint = function(time, req, entryType) {
+  var self = this;
+  var sep = {};
+  sep.time = time;
+  sep.id = time.id;
+  sep.threadId = time.threadId;
+  sep.entryType = entryType;
+
+  self.serviceEndpoints[time.threadId] = sep;
+
+  try {
+    self.agent.emit('serviceEndpointStart', sep, req);
+  } catch (err) {
+    self.agent.logger.warn(err);
+  }
+
+  return sep;
+};
+
+Profiler.prototype.endServiceEndpoint = function (time, sep) {
+  var self = this;
+
+  if (sep.isFinished) {
+    return;
+  }
+
+  sep.isFinished = true;
+  sep.ms = time.ms;
+
+  try {
+    self.agent.emit('serviceEndpointStop', sep);
+  } catch (err) {
+    self.agent.logger.warn(err);
+  }
+
+  delete self.serviceEndpoints[time.threadId];
+};
 
 Profiler.prototype.startTransaction = function(time, req, entryType, baggageCorrHeader) {
   var self = this;
@@ -184,6 +222,11 @@ Profiler.prototype.isValidThreadId = function(threadId) {
   return (threadId && self.transactions[threadId]);
 };
 
+Profiler.prototype.isValidSepThreadId = function(threadId) {
+  var self = this;
+  return (threadId && self.serviceEndpoints[threadId]);
+};
+
 Profiler.prototype._endTransaction = function (time, transaction) {
   var self = this;
 
@@ -217,6 +260,18 @@ Profiler.prototype.transactionDropped = function (guid) {
   }
 };
 
+Profiler.prototype.sepDropped = function (guid) {
+  var self = this;
+
+  for (var threadId in self.serviceEndpoints) {
+    if (self.serviceEndpoints[threadId].sepGuid === guid) {
+      self.agent.logger.info('SEP ' + self.serviceEndpoints[threadId].id + ' dropped');
+      delete self.serviceEndpoints[threadId];
+      break;
+    }
+  }
+};
+
 Profiler.prototype.__getNextSequenceInfo = function (transaction) {
   var self = this;
   transaction.exitCallCounter++;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "appdynamics",
-    "version": "24.9.0",
+    "version": "24.12.0",
     "description": "Performance Profiler and Monitor",
     "author": "AppDynamics, Inc.",
     "homepage": "https://www.appdynamics.com",
@@ -51,9 +51,9 @@
         "https-proxy-agent": "^5.0.1",
         "uuid": "^8.3.2",
         "y18n": "^5.0.8",
-        "appdynamics-libagent-napi": "https://cdn.appdynamics.com/packages/nodejs/24.9.0.0/appdynamics-libagent-napi-node.tgz",
-        "appdynamics-native": "https://cdn.appdynamics.com/packages/nodejs/24.9.0.0/appdynamics-native-node.tgz",
-        "appdynamics-protobuf": "https://cdn.appdynamics.com/packages/nodejs/24.9.0.0/appdynamics-protobuf-node.tgz"
+        "appdynamics-libagent-napi": "https://cdn.appdynamics.com/packages/nodejs/24.12.0.0/appdynamics-libagent-napi-node.tgz",
+        "appdynamics-native": "https://cdn.appdynamics.com/packages/nodejs/24.12.0.0/appdynamics-native-node.tgz",
+        "appdynamics-protobuf": "https://cdn.appdynamics.com/packages/nodejs/24.12.0.0/appdynamics-protobuf-node.tgz"
     },
     "overrides": {
         "semver": "7.5.4"

package/packageBck.json

@@ -1,6 +1,6 @@
 {
     "name": "appdynamics",
-    "version": "24.9.0",
+    "version": "24.12.0",
     "description": "Performance Profiler and Monitor",
     "author": "AppDynamics, Inc.",
     "homepage": "https://www.appdynamics.com",
@@ -51,9 +51,9 @@
         "https-proxy-agent": "^5.0.1",
         "uuid": "^8.3.2",
         "y18n": "^5.0.8",
-        "appdynamics-libagent-napi": "https://cdn.appdynamics.com/packages/nodejs/24.9.0.0/appdynamics-libagent-napi-node.tgz",
-        "appdynamics-native": "https://cdn.appdynamics.com/packages/nodejs/24.9.0.0/appdynamics-native-node.tgz",
-        "appdynamics-protobuf": "https://cdn.appdynamics.com/packages/nodejs/24.9.0.0/appdynamics-protobuf-node.tgz"
+        "appdynamics-libagent-napi": "https://cdn.appdynamics.com/packages/nodejs/24.12.0.0/appdynamics-libagent-napi-node.tgz",
+        "appdynamics-native": "https://cdn.appdynamics.com/packages/nodejs/24.12.0.0/appdynamics-native-node.tgz",
+        "appdynamics-protobuf": "https://cdn.appdynamics.com/packages/nodejs/24.12.0.0/appdynamics-protobuf-node.tgz"
     },
     "overrides": {
         "semver": "7.5.4"