appdynamics 21.9.0 → 22.5.0

package/lib/probes/http-probe.js

@@ -7,33 +7,36 @@ All Rights Reserved
 
 var HttpEntryProbe = require('./http-entry-probe').HttpEntryProbe;
 var HttpExitProbe = require('./http-exit-probe').HttpExitProbe;
+var ApolloEntryProbe = require('./apollo-entry-probe').ApolloEntryProbe;
 
 function HttpProbe(agent) {
   this.agent = agent;
-  this.packages = ['http', 'https', 'express-graphql'];
+  this.packages = ['http', 'https', 'express-graphql', 'apollo-server'];
 
   this.entryProbe = new HttpEntryProbe(agent);
   this.exitProbe = new HttpExitProbe(agent);
+  this.apolloEntryProbe = new ApolloEntryProbe(agent);
 
   this.init();
 }
 exports.HttpProbe = HttpProbe;
 
-HttpProbe.prototype.init = function() {
+HttpProbe.prototype.init = function () {
   this.entryProbe.init();
   this.exitProbe.init();
+  this.apolloEntryProbe.init();
 };
 
-HttpProbe.prototype.attach = function(obj, moduleName) {
+HttpProbe.prototype.attach = function (obj, moduleName) {
   var self = this;
   var proxy = this.agent.proxy;
 
-  if(obj.__appdynamicsProbeAttached__) return;
+  if (obj.__appdynamicsProbeAttached__) return;
   obj.__appdynamicsProbeAttached__ = true;
-  self.agent.on('destroy', function() {
-    if(obj.__appdynamicsProbeAttached__) {
+  self.agent.on('destroy', function () {
+    if (obj.__appdynamicsProbeAttached__) {
       delete obj.__appdynamicsProbeAttached__;
-      if (moduleName !== 'express-graphql') {
+      if (moduleName !== 'express-graphql' && moduleName !== 'apollo-server') {
         proxy.release(obj.Server.prototype.on);
         proxy.release(obj.Server.prototype.addListener);
         proxy.release(obj.request);
@@ -45,6 +48,10 @@ HttpProbe.prototype.attach = function(obj, moduleName) {
     if (self.agent.opts.enableGraphQL) {
       this.entryProbe.enableGraphQL(obj);
     }
+  } else if (moduleName === 'apollo-server') {
+    if(self.agent.opts.enableGraphQL) {
+      this.apolloEntryProbe.attach(obj, moduleName);
+    }
   } else {
     this.entryProbe.attach(obj, moduleName);
     this.exitProbe.attach(obj, moduleName);

package/lib/probes/mongodb-probe.js

@@ -43,18 +43,33 @@ MongodbProbe.prototype.attach = function (obj) {
     if (obj.__appdynamicsProbeAttached__) {
       delete obj.__appdynamicsProbeAttached__;
     }
-
     proxy.release(obj.Db.prototype.createCollection);
     proxy.release(obj.Db.prototype.dropCollection);
-    proxy.release(obj.Server.prototype.cursor);
-    proxy.release(obj.Server.prototype.insert);
-    proxy.release(obj.Server.prototype.update);
-    proxy.release(obj.Server.prototype.remove);
-    proxy.release(obj.ReplSet.prototype.cursor);
-    proxy.release(obj.ReplSet.prototype.insert);
-    proxy.release(obj.ReplSet.prototype.update);
-    proxy.release(obj.ReplSet.prototype.remove);
-    proxy.release(obj.Cursor.prototype._next);
+    if(obj.Server){
+      proxy.release(obj.Server.prototype.cursor);
+      proxy.release(obj.Server.prototype.insert);
+      proxy.release(obj.Server.prototype.update);
+      proxy.release(obj.Server.prototype.remove);
+    }
+    if(obj.ReplSet){
+      proxy.release(obj.ReplSet.prototype.cursor);
+      proxy.release(obj.ReplSet.prototype.insert);
+      proxy.release(obj.ReplSet.prototype.update);
+      proxy.release(obj.ReplSet.prototype.remove);
+    }
+    if(obj.Cursor){
+      proxy.release(obj.Cursor.prototype.next);
+    }
+    if(obj.Collection){
+      proxy.release(obj.Collection.prototype.find);
+      proxy.release(obj.Collection.prototype.insert);
+      proxy.release(obj.Collection.prototype.aggregate);
+      proxy.release(obj.Collection.prototype.remove);
+      proxy.release(obj.Collection.prototype.update);
+    }
+    if(obj.AbstractCursor){
+      proxy.release(obj.AbstractCursor.prototype.next);
+    }
   });
 
   if ('instrument' in obj) {
@@ -138,127 +153,200 @@ MongodbProbe.prototype.attach = function (obj) {
     collectionCommands.forEach(function (command) {
       proxy.before(obj.Db.prototype, command, withAPMBeforeHandler);
     });
-  } else if (!('version' in obj) && obj.Cursor) {
-    // driver 2.x w/out APM API
-    var commands = ['cursor', 'insert', 'update', 'remove'];
-
-    // queries via a cursor find command must be reported after they complete:
-    proxy.around(obj.Cursor.prototype, '_next', function (obj, args, locals) {
-      locals.methodHasCb = proxy.callback(args, -1, function (obj_, args) {
-        complete(args, obj);
-      });
-    }, after);
+  } else if (!('version' in obj)) {
+    if (obj.Cursor){
+      // driver 2.x w/out APM API
+      var commands = ['cursor', 'insert', 'update', 'remove'];
+
+      // queries via a cursor find command must be reported after they complete:
+      proxy.around(obj.Cursor.prototype, '_next', function (obj, args, locals) {
+        locals.methodHasCb = proxy.callback(args, -1, function (obj_, args) {
+          complete(args, obj);
+        });
+      }, after);
+
+      collectionCommands.forEach(function (command) {
+        function withoutAPMBeforeHandler(obj, args, locals) {
+          var commandDetails;
+          var category;
+          var commandName = command == 'cursor' ? 'find' : command;
+
+          if (command == 'cursor' && !args[1].find) return;
+          var serverPool = [];
+          if (obj.serverConfig instanceof mongoObj.ReplSet)
+            serverPool = self.getServerPool(obj.serverConfig.s, true);
+          else
+            serverPool = self.getServerPool(obj);
+          if (serverPool.length) {
+            commandDetails = {
+              command: commandName,
+              databaseName: obj.s.databaseName,
+              collectionName: args[0]
+            };
+
+            if (obj.auths && obj.auths.length > 0) {
+              commandDetails.auth = obj.auths[0];
+            }
 
-    collectionCommands.forEach(function (command) {
-      function withoutAPMBeforeHandler(obj, args, locals) {
-        var commandDetails;
-        var category;
-        var commandName = command == 'cursor' ? 'find' : command;
+            category = "write";
 
-        if (command == 'cursor' && !args[1].find) return;
-        var serverPool = [];
-        if (obj.serverConfig instanceof mongoObj.ReplSet)
-          serverPool = self.getServerPool(obj.serverConfig.s, true);
-        else
-          serverPool = self.getServerPool(obj);
-        if (serverPool.length) {
-          commandDetails = {
-            command: commandName,
-            databaseName: obj.s.databaseName,
-            collectionName: args[0]
-          };
+            locals.time = profiler.time();
 
-          if (obj.auths && obj.auths.length > 0) {
-            commandDetails.auth = obj.auths[0];
+            locals.exitCall = self.createExitCall(locals.time, serverPool,
+              commandDetails, category, profiler.stackTrace());
           }
 
-          category = "write";
-
-          locals.time = profiler.time();
-
-          locals.exitCall = self.createExitCall(locals.time, serverPool,
-            commandDetails, category, profiler.stackTrace());
+          locals.methodHasCb = proxy.callback(args, -1, function (obj, args) {
+            self.addExitCall(locals.time, locals.exitCall, args);
+          });
         }
 
-        locals.methodHasCb = proxy.callback(args, -1, function (obj, args) {
-          self.addExitCall(locals.time, locals.exitCall, args);
-        });
-      }
-
-      proxy.around(obj.Db.prototype, command, withoutAPMBeforeHandler, withoutAPMAfterHandler);
-    });
+        proxy.around(obj.Db.prototype, command, withoutAPMBeforeHandler, withoutAPMAfterHandler);
+      });
 
-    commands.forEach(function (command) {
-      var commandName = command == 'cursor' ? 'find' : command;
-      function withoutAPMBeforeHandler(obj, args, locals) {
-        var commandDetails;
-        var category;
-        var opts = {};
-        var query = '';
+      commands.forEach(function (command) {
+        var commandName = command == 'cursor' ? 'find' : command;
+        function withoutAPMBeforeHandler(obj, args, locals) {
+          var commandDetails;
+          var category;
+          var opts = {};
+          var query = '';
+
+          if (command == 'cursor' && !args[1].find) return;
+
+          var serverPool = [];
+          if (obj instanceof mongoObj.ReplSet)
+            serverPool = self.getServerPool(obj.s, true);
+          else
+            serverPool = self.getServerPool(obj.s);
+          if (serverPool.length) {
+            opts = {};
+            if (args[1] && args[1].query) {
+              query = args[1].query;
+              if (Object.prototype.toString.call(query) == "[object Object]") {
+                query = utility.filterSensitiveDataFromObject(Object.assign({}, args[1].query));
+              }
+              query = profiler.sanitize(JSON.stringify(query));
+              Object.keys(args[1]).forEach(function (key) {
+                if (key !== 'query') {
+                  opts[key] = args[1][key];
+                }
+              });
+            }
 
-        if (command == 'cursor' && !args[1].find) return;
+            commandDetails = {
+              command: commandName,
+              databaseName: args[0].split('.')[0],
+              collectionName: args[0].split('.')[1],
+              query: query,
+              numberToSkip: opts.skip,
+              numberToReturn: opts.limit
+            };
+
+            if (obj.s.auths && obj.s.auths.length > 0) {
+              commandDetails.auth = obj.s.auths[0];
+            }
 
-        var serverPool = [];
-        if (obj instanceof mongoObj.ReplSet)
-          serverPool = self.getServerPool(obj.s, true);
-        else
-          serverPool = self.getServerPool(obj.s);
-        if (serverPool.length) {
-          opts = {};
-          if (args[1] && args[1].query) {
-            query = args[1].query;
-            if (Object.prototype.toString.call(query) == "[object Object]") {
-              query = utility.filterSensitiveDataFromObject(Object.assign({}, args[1].query));
+            if (commandName == 'find') {
+              category = "read";
+            } else {
+              category = "write";
             }
-            query = profiler.sanitize(JSON.stringify(query));
-            Object.keys(args[1]).forEach(function (key) {
-              if (key !== 'query') {
-                opts[key] = args[1][key];
-              }
-            });
-          }
 
-          commandDetails = {
-            command: commandName,
-            databaseName: args[0].split('.')[0],
-            collectionName: args[0].split('.')[1],
-            query: query,
-            numberToSkip: opts.skip,
-            numberToReturn: opts.limit
-          };
+            locals.time = profiler.time();
 
-          if (obj.s.auths && obj.s.auths.length > 0) {
-            commandDetails.auth = obj.s.auths[0];
+            locals.exitCall = self.createExitCall(locals.time, serverPool,
+              commandDetails, category, profiler.stackTrace());
           }
 
           if (commandName == 'find') {
-            category = "read";
+            // stash exit call for later processing
+            args[1].__appd_exitcall_info = {
+              time: locals.time,
+              exitCall: locals.exitCall
+            };
+            locals.methodHasCb = true;
           } else {
-            category = "write";
+            locals.methodHasCb = proxy.callback(args, -1, function (obj, args) {
+              self.addExitCall(locals.time, locals.exitCall, args);
+            }, null, self.agent.thread.current());
           }
-
-          locals.time = profiler.time();
-
-          locals.exitCall = self.createExitCall(locals.time, serverPool,
-            commandDetails, category, profiler.stackTrace());
         }
+        proxy.around(obj.Server.prototype, command, withoutAPMBeforeHandler, withoutAPMAfterHandler);
+        proxy.around(obj.ReplSet.prototype, command, withoutAPMBeforeHandler, withoutAPMAfterHandler);
+      });
+    }
+    else{
+      proxy.before(obj.MongoClient.prototype, 'connect', function(obj){
+        obj.monitorCommands = true;
+        var newServerPool;
+        var newOpQueue = {};
+        var newApmCollectionEvents = ['create', 'drop'];
+        var newCollectionCommandMap = {
+          'create': 'createCollection',
+          'drop': 'dropCollection',
+          'find': 'find',
+          'cursor': 'cursor',
+          'insert': 'insert',
+          'update': 'update',
+          'remove': 'remove',
+          'aggregate': 'aggregate'
+        };
+        var newSupportedCommands = ['find', 'cursor', 'insert', 'update', 'remove', 'aggregate'].concat(newApmCollectionEvents);
+
+        // expose opQueue for integration testing
+        self.__opQueue = newOpQueue;
+        obj.on('commandStarted', (event) => {
+          var requestId = event.requestId, newRequest, newCommandQuery;
+          if (newSupportedCommands.indexOf(event.commandName) < 0) return;
+          if (event.address) {
+            newServerPool = [event.address];
+          }
+          if (newServerPool) {
+            if (!newOpQueue[requestId]) {
+              newOpQueue[requestId] = {
+                time: profiler.time(),
+                serverPool: newServerPool
+              };
+            }
+            newRequest = newOpQueue[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));
+            }
+            var commandDetails = {
+              command: newCollectionCommandMap[event.commandName],
+              databaseName: event.databaseName,
+              collectionName: event.command[event.commandName],
+              query: profiler.sanitize(JSON.stringify(newCommandQuery)),
+              numberToSkip: event.command.skip,
+              numberToReturn: event.command.limit
+            };
+
+
+            newRequest.exitCall = self.createExitCall(newRequest.time, newServerPool,
+              commandDetails, event.commandName == 'find' ? 'read' : 'write',
+              profiler.stackTrace());
+          }
+        });
 
-        if (commandName == 'find') {
-          // stash exit call for later processing
-          args[1].__appd_exitcall_info = {
-            time: locals.time,
-            exitCall: locals.exitCall
-          };
-          locals.methodHasCb = true;
-        } else {
-          locals.methodHasCb = proxy.callback(args, -1, function (obj, args) {
-            self.addExitCall(locals.time, locals.exitCall, args);
-          }, null, self.agent.thread.current());
-        }
-      }
-      proxy.around(obj.Server.prototype, command, withoutAPMBeforeHandler, withoutAPMAfterHandler);
-      proxy.around(obj.ReplSet.prototype, command, withoutAPMBeforeHandler, withoutAPMAfterHandler);
-    });
+        obj.on('commandSucceeded', function (event) {
+          var requestId = event.requestId, newRequest = newOpQueue[requestId];
+          if (newRequest) {
+            self.addExitCall(newRequest.time, newRequest.exitCall);
+            newOpQueue[requestId] = undefined;
+          }
+        });
+
+        obj.on('commandFailed', function (event) {
+          var requestId = event.requestId, newRequest = newOpQueue[requestId];
+          if (newRequest) {
+            self.addExitCall(event.time, event.exitCall, event.failure);
+            newOpQueue[requestId] = undefined;
+          }
+        });
+      });
+    }
   }
 
   function complete(err, obj, driver) {
@@ -356,11 +444,10 @@ MongodbProbe.prototype.createExitCall = function (time, serverPool, commandDetai
 MongodbProbe.prototype.addExitCall = function (time, exitCall, args) {
   var self = this;
   if (!time || !time.done()) return;
-
   var error = self.agent.proxy.getErrorObject(args);
   var profiler = self.agent.profiler;
 
   if (exitCall) {
     profiler.addExitCall(time, exitCall, error);
   }
-};
+};

package/lib/profiler/profiler.js

@@ -84,7 +84,7 @@ Profiler.prototype.formatStackTrace = function (err) {
 };
 
 
-Profiler.prototype.startTransaction = function (time, req, entryType) {
+Profiler.prototype.startTransaction = function(time, req, entryType, baggageCorrHeader) {
   var self = this;
 
   var transaction = new Transaction();
@@ -101,6 +101,10 @@ Profiler.prototype.startTransaction = function (time, req, entryType) {
     parsedParameterString: req.url ? url.parse(req.url).query : ''
   };
 
+  if(baggageCorrHeader) {
+    transaction.baggageCorrHeader = baggageCorrHeader;
+  }
+
   self.transactions[time.threadId] = transaction;
 
   var delayedCallbackAttached = false;

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;
+};
+