cisco-perfmon 1.3.2 → 1.3.4

package/main.js

@@ -1,5 +1,5 @@
 // fetch-retry can also wrap Node.js's native fetch API implementation:
-const fetch = require('fetch-retry')(global.fetch);
+const fetch = require("fetch-retry")(global.fetch);
 const util = require("util");
 const parseString = require("xml2js").parseString;
 const stripPrefix = require("xml2js").processors.stripPrefix;
@@ -100,15 +100,15 @@ var XML_REMOVE_COUNTER_ENVELOPE = `<soapenv:Envelope xmlns:soapenv="http://schem
 class perfMonService {
   constructor(host, username, password, options) {
     this._OPTIONS = {
-      retries: 5,
-      retryDelay: 800,
+      retries: process.env.PERFMON_RETRIES ? parseInt(process.env.PERFMON_RETRIES) : 3,
+      retryDelay: process.env.PERFMON_RETRY_DELAY ? parseInt(process.env.PERFMON_RETRY_DELAY) : 1000,
       retryOn: [503],
       method: "POST",
       headers: {
         Authorization: "Basic " + Buffer.from(username + ":" + password).toString("base64"),
         "Content-Type": "text/xml;charset=UTF-8",
         Connection: "keep-alive",
-      }
+      },
     };
 
     // Adds additional headers if they are provided. Useful for adding cookies for SSO sessions
@@ -146,15 +146,15 @@ class perfMonService {
     return new Promise((resolve, reject) => {
       // Set up our promise results
       var promiseResults = {
-        Cookie: "",
-        Results: "",
+        cookie: "",
+        results: "",
       };
       // We fetch the API endpoint
       fetch(`https://${server}:8443/perfmonservice2/services/PerfmonService/`, options)
         .then(async (response) => {
           try {
             var data = []; // create an array to save chunked data from server
-            promiseResults.Cookie = response.headers.get("set-cookie") ? response.headers.get("set-cookie") : "";
+            promiseResults.cookie = response.headers.get("set-cookie") ? response.headers.get("set-cookie") : "";
             // response.body is a ReadableStream
             const reader = response.body.getReader();
             for await (const chunk of readChunks(reader)) {
@@ -166,72 +166,78 @@ class perfMonService {
             // Remove unnecessary keys
             removeKeys(output, "$");
 
-            if (keyExists(output, "perfmonCollectCounterDataReturn")) {
-              var returnResults = output.Body.perfmonCollectCounterDataResponse.perfmonCollectCounterDataReturn;
-              if (returnResults) {
-                var newOutput;
-                if (Array.isArray(returnResults)) {
-                  newOutput = returnResults.map((item) => {
-                    let arr = item.Name.split("\\").filter((element) => element);
+            // Let's check if the response contains the key we are looking for. This is the return data.
+            if (keyExists(output, "perfmonCollectCounterDataResponse")) {
+              if (keyExists(output, "perfmonCollectCounterDataReturn")) {
+                var returnResults = output.Body.perfmonCollectCounterDataResponse.perfmonCollectCounterDataReturn;
+                if (returnResults) {
+                  var newOutput;
+                  if (Array.isArray(returnResults)) {
+                    newOutput = returnResults.map((item) => {
+                      let arr = item.Name.split("\\").filter((element) => element);
+
+                      let instanceArr = arr[1].split(/[()]+/).filter(function (e) {
+                        return e;
+                      });
+
+                      return {
+                        host: arr[0],
+                        object: instanceArr[0],
+                        instance: instanceArr[1] ? instanceArr[1] : "",
+                        counter: arr[2],
+                        value: item.Value,
+                        cstatus: item.CStatus,
+                      };
+                    });
+                  } else {
+                    let arr = returnResults.Name.split("\\").filter((element) => element);
 
                     let instanceArr = arr[1].split(/[()]+/).filter(function (e) {
                       return e;
                     });
 
-                    return {
+                    newOutput = {
                       host: arr[0],
                       object: instanceArr[0],
                       instance: instanceArr[1] ? instanceArr[1] : "",
                       counter: arr[2],
-                      value: item.Value,
-                      cstatus: item.CStatus,
+                      value: returnResults.Value,
+                      cstatus: returnResults.CStatus,
                     };
-                  });
+                  }
+                  promiseResults.results = clean(newOutput);
+                  resolve(promiseResults);
                 } else {
-                  let arr = returnResults.Name.split("\\").filter((element) => element);
-
-                  let instanceArr = arr[1].split(/[()]+/).filter(function (e) {
-                    return e;
-                  });
-
-                  newOutput = {
-                    host: arr[0],
-                    object: instanceArr[0],
-                    instance: instanceArr[1] ? instanceArr[1] : "",
-                    counter: arr[2],
-                    value: returnResults.Value,
-                    cstatus: returnResults.CStatus,
-                  };
+                  promiseResults.results = { response: "empty" };
+                  resolve(promiseResults);
                 }
-                promiseResults.Results = clean(newOutput);
-                resolve(promiseResults);
               } else {
-                promiseResults.Results = output.Body.Fault;
-                reject(promiseResults);
+                promiseResults.results = { response: "empty" };
+                resolve(promiseResults);
               }
             } else {
               // Error checking. If the response contains a fault, we return the fault.
               if (keyExists(output, "Fault")) {
                 if (output.Body.Fault.faultcode.includes("RateControl")) {
-                  promiseResults.Results = { faultcode: "RateControl", faultstring: output.Body.Fault.faultstring };
+                  promiseResults.results = { faultcode: "RateControl", faultstring: output.Body.Fault.faultstring };
                 } else if (output.Body.Fault.faultcode.includes("generalException")) {
-                  promiseResults.Results = { faultcode: "generalException", faultstring: output.Body.Fault.faultstring };
+                  promiseResults.results = { faultcode: "generalException", faultstring: output.Body.Fault.faultstring };
                 } else {
-                  promiseResults.Results = { faultcode: output.Body.Fault.faultcode, faultstring: output.Body.Fault.faultstring };
+                  promiseResults.results = { faultcode: output.Body.Fault.faultcode, faultstring: output.Body.Fault.faultstring };
                 }
                 resolve(promiseResults);
               } else {
-                // Error unknown. Return the response status instead.
+                // Error unknown. Reject with the response status instead. Most likely a 500 error from the server.
                 reject(response.status);
               }
             }
           } catch (e) {
-            promiseResults.Results = e;
+            promiseResults.results = e;
             reject(promiseResults);
           }
         })
         .catch((error) => {
-          promiseResults.Results = error;
+          promiseResults.results = error;
           reject(promiseResults);
         }); // catches the error and logs it
     });
@@ -263,15 +269,15 @@ class perfMonService {
     return new Promise((resolve, reject) => {
       // Set up our promise results
       var promiseResults = {
-        Cookie: "",
-        Results: "",
+        cookie: "",
+        results: "",
       };
       // We fetch the API endpoint
       fetch(`https://${server}:8443/perfmonservice2/services/PerfmonService/`, options)
         .then(async (response) => {
           try {
             var data = []; // create an array to save chunked data from server
-            promiseResults.Cookie = response.headers.get("set-cookie") ? response.headers.get("set-cookie") : "";
+            promiseResults.cookie = response.headers.get("set-cookie") ? response.headers.get("set-cookie") : "";
             // response.body is a ReadableStream
             const reader = response.body.getReader();
             for await (const chunk of readChunks(reader)) {
@@ -283,61 +289,77 @@ class perfMonService {
             // Remove unnecessary keys
             removeKeys(output, "$");
 
-            if (keyExists(output, "perfmonCollectSessionDataReturn")) {
-              var returnResults = output.Body.perfmonCollectSessionDataResponse.perfmonCollectSessionDataReturn;
-
-              if (returnResults) {
-                var newOutput;
-                if (Array.isArray(returnResults)) {
-                  newOutput = returnResults.map((item) => {
-                    let arr = item.Name.split("\\").filter((element) => element);
+            if (keyExists(output, "perfmonCollectSessionDataResponse")) {
+              if (keyExists(output, "perfmonCollectSessionDataReturn")) {
+                var returnResults = output.Body.perfmonCollectSessionDataResponse.perfmonCollectSessionDataReturn;
+                if (returnResults) {
+                  var newOutput;
+                  if (Array.isArray(returnResults)) {
+                    newOutput = returnResults.map((item) => {
+                      let arr = item.Name.split("\\").filter((element) => element);
+
+                      let instanceArr = arr[1].split(/[()]+/).filter(function (e) {
+                        return e;
+                      });
+
+                      return {
+                        host: arr[0],
+                        object: instanceArr[0],
+                        instance: instanceArr[1] ? instanceArr[1] : "",
+                        counter: arr[2],
+                        value: item.Value,
+                        cstatus: item.CStatus,
+                      };
+                    });
+                  } else {
+                    let arr = returnResults.Name.split("\\").filter((element) => element);
 
                     let instanceArr = arr[1].split(/[()]+/).filter(function (e) {
                       return e;
                     });
 
-                    return {
+                    newOutput = {
                       host: arr[0],
                       object: instanceArr[0],
                       instance: instanceArr[1] ? instanceArr[1] : "",
                       counter: arr[2],
-                      value: item.Value,
-                      cstatus: item.CStatus,
+                      value: returnResults.Value,
+                      cstatus: returnResults.CStatus,
                     };
-                  });
+                  }
+                  promiseResults.results = clean(newOutput);
+                  resolve(promiseResults);
                 } else {
-                  let arr = returnResults.Name.split("\\").filter((element) => element);
-
-                  let instanceArr = arr[1].split(/[()]+/).filter(function (e) {
-                    return e;
-                  });
-
-                  newOutput = {
-                    host: arr[0],
-                    object: instanceArr[0],
-                    instance: instanceArr[1] ? instanceArr[1] : "",
-                    counter: arr[2],
-                    value: returnResults.Value,
-                    cstatus: returnResults.CStatus,
-                  };
+                  promiseResults.results = { response: "empty" };
+                  resolve(promiseResults);
                 }
-                promiseResults.Results = clean(newOutput);
-                resolve(promiseResults);
               } else {
-                promiseResults.Results = output.Body.Fault;
-                reject(promiseResults);
+                promiseResults.results = { response: "empty" };
+                resolve(promiseResults);
               }
             } else {
-              promiseResults.Results = { response: "empty" };
-              resolve(promiseResults);
+              // Error checking. If the response contains a fault, we return the fault.
+              if (keyExists(output, "Fault")) {
+                if (output.Body.Fault.faultcode.includes("RateControl")) {
+                  promiseResults.results = { faultcode: "RateControl", faultstring: output.Body.Fault.faultstring };
+                } else if (output.Body.Fault.faultcode.includes("generalException")) {
+                  promiseResults.results = { faultcode: "generalException", faultstring: output.Body.Fault.faultstring };
+                } else {
+                  promiseResults.results = { faultcode: output.Body.Fault.faultcode, faultstring: output.Body.Fault.faultstring };
+                }
+                resolve(promiseResults);
+              } else {
+                // Error unknown. Reject with the response status instead. Most likely a 500 error from the server.
+                reject(response.status);
+              }
             }
           } catch (e) {
-            promiseResults.Results = e;
+            promiseResults.results = e;
             reject(promiseResults);
           }
         })
         .catch((error) => {
-          promiseResults.Results = error;
+          promiseResults.results = error;
           reject(promiseResults);
         }); // catches the error and logs it
     });
@@ -369,15 +391,15 @@ class perfMonService {
     return new Promise((resolve, reject) => {
       // Set up our promise results
       var promiseResults = {
-        Cookie: "",
-        Results: "",
+        cookie: "",
+        results: "",
       };
       // We fetch the API endpoint
       fetch(`https://${server}:8443/perfmonservice2/services/PerfmonService/`, options)
         .then(async (response) => {
           try {
             var data = []; // create an array to save chunked data from server
-            promiseResults.Cookie = response.headers.get("set-cookie") ? response.headers.get("set-cookie") : "";
+            promiseResults.cookie = response.headers.get("set-cookie") ? response.headers.get("set-cookie") : "";
             // response.body is a ReadableStream
             const reader = response.body.getReader();
             for await (const chunk of readChunks(reader)) {
@@ -389,27 +411,43 @@ class perfMonService {
             // Remove unnecessary keys
             removeKeys(output, "$");
 
-            if (keyExists(output, "perfmonListCounterReturn")) {
-              var returnResults = output.Body.perfmonListCounterResponse.perfmonListCounterReturn;
-
-              if (returnResults) {
-                promiseResults.Results = clean(returnResults);
-                resolve(promiseResults);
+            if (keyExists(output, "perfmonListCounterResponse")) {
+              if (keyExists(output, "perfmonListCounterReturn")) {
+                var returnResults = output.Body.perfmonListCounterResponse.perfmonListCounterReturn;
+                if (returnResults) {
+                  promiseResults.results = clean(returnResults);
+                  resolve(promiseResults);
+                } else {
+                  promiseResults.results = { response: "empty" };
+                  resolve(promiseResults);
+                }
               } else {
-                promiseResults.Results = output.Body.Fault;
-                reject(promiseResults);
+                promiseResults.results = { response: "empty" };
+                resolve(promiseResults);
               }
             } else {
-              promiseResults.Results = { response: "empty" };
-              resolve(promiseResults);
+              // Error checking. If the response contains a fault, we return the fault.
+              if (keyExists(output, "Fault")) {
+                if (output.Body.Fault.faultcode.includes("RateControl")) {
+                  promiseResults.results = { faultcode: "RateControl", faultstring: output.Body.Fault.faultstring };
+                } else if (output.Body.Fault.faultcode.includes("generalException")) {
+                  promiseResults.results = { faultcode: "generalException", faultstring: output.Body.Fault.faultstring };
+                } else {
+                  promiseResults.results = { faultcode: output.Body.Fault.faultcode, faultstring: output.Body.Fault.faultstring };
+                }
+                resolve(promiseResults);
+              } else {
+                // Error unknown. Reject with the response status instead. Most likely a 500 error from the server.
+                reject(response.status);
+              }
             }
           } catch (e) {
-            promiseResults.Results = e;
+            promiseResults.results = e;
             reject(promiseResults);
           }
         })
         .catch((error) => {
-          promiseResults.Results = error;
+          promiseResults.results = error;
           reject(promiseResults);
         }); // catches the error and logs it
     });
@@ -442,15 +480,15 @@ class perfMonService {
     return new Promise((resolve, reject) => {
       // Set up our promise results
       var promiseResults = {
-        Cookie: "",
-        Results: "",
+        cookie: "",
+        results: "",
       };
       // We fetch the API endpoint
       fetch(`https://${server}:8443/perfmonservice2/services/PerfmonService/`, options)
         .then(async (response) => {
           try {
             var data = []; // create an array to save chunked data from server
-            promiseResults.Cookie = response.headers.get("set-cookie") ? response.headers.get("set-cookie") : "";
+            promiseResults.cookie = response.headers.get("set-cookie") ? response.headers.get("set-cookie") : "";
             // response.body is a ReadableStream
             const reader = response.body.getReader();
             for await (const chunk of readChunks(reader)) {
@@ -462,27 +500,43 @@ class perfMonService {
             // Remove unnecessary keys
             removeKeys(output, "$");
 
-            if (keyExists(output, "perfmonListInstanceReturn")) {
-              var returnResults = output.Body.perfmonListInstanceResponse.perfmonListInstanceReturn;
-
-              if (returnResults) {
-                promiseResults.Results = clean(returnResults);
-                resolve(promiseResults);
+            if (keyExists(output, "perfmonListInstanceResponse")) {
+              if (keyExists(output, "perfmonListInstanceReturn")) {
+                var returnResults = output.Body.perfmonListInstanceResponse.perfmonListInstanceReturn;
+                if (returnResults) {
+                  promiseResults.results = clean(returnResults);
+                  resolve(promiseResults);
+                } else {
+                  promiseResults.results = { response: "empty" };
+                  resolve(promiseResults);
+                }
               } else {
-                promiseResults.Results = output.Body.Fault;
-                reject(promiseResults);
+                promiseResults.results = { response: "empty" };
+                resolve(promiseResults);
               }
             } else {
-              promiseResults.Results = { response: "empty" };
-              resolve(promiseResults);
+              // Error checking. If the response contains a fault, we return the fault.
+              if (keyExists(output, "Fault")) {
+                if (output.Body.Fault.faultcode.includes("RateControl")) {
+                  promiseResults.results = { faultcode: "RateControl", faultstring: output.Body.Fault.faultstring };
+                } else if (output.Body.Fault.faultcode.includes("generalException")) {
+                  promiseResults.results = { faultcode: "generalException", faultstring: output.Body.Fault.faultstring };
+                } else {
+                  promiseResults.results = { faultcode: output.Body.Fault.faultcode, faultstring: output.Body.Fault.faultstring };
+                }
+                resolve(promiseResults);
+              } else {
+                // Error unknown. Reject with the response status instead. Most likely a 500 error from the server.
+                reject(response.status);
+              }
             }
           } catch (e) {
-            promiseResults.Results = e;
+            promiseResults.results = e;
             reject(promiseResults);
           }
         })
         .catch((error) => {
-          promiseResults.Results = error;
+          promiseResults.results = error;
           reject(promiseResults);
         }); // catches the error and logs it
     });
@@ -512,15 +566,15 @@ class perfMonService {
     return new Promise((resolve, reject) => {
       // Set up our promise results
       var promiseResults = {
-        Cookie: "",
-        Results: "",
+        cookie: "",
+        results: "",
       };
       // We fetch the API endpoint
       fetch(`https://${server}:8443/perfmonservice2/services/PerfmonService/`, options)
         .then(async (response) => {
           try {
             var data = []; // create an array to save chunked data from server
-            promiseResults.Cookie = response.headers.get("set-cookie") ? response.headers.get("set-cookie") : "";
+            promiseResults.cookie = response.headers.get("set-cookie") ? response.headers.get("set-cookie") : "";
             // response.body is a ReadableStream
             const reader = response.body.getReader();
             for await (const chunk of readChunks(reader)) {
@@ -532,27 +586,43 @@ class perfMonService {
             // Remove unnecessary keys
             removeKeys(output, "$");
 
-            if (keyExists(output, "perfmonOpenSessionReturn")) {
-              var returnResults = output.Body.perfmonOpenSessionResponse.perfmonOpenSessionReturn;
-
-              if (returnResults) {
-                promiseResults.Results = clean(returnResults);
-                resolve(promiseResults);
+            if (keyExists(output, "perfmonOpenSessionResponse")) {
+              if (keyExists(output, "perfmonOpenSessionReturn")) {
+                var returnResults = output.Body.perfmonOpenSessionResponse.perfmonOpenSessionReturn;
+                if (returnResults) {
+                  promiseResults.results = clean(returnResults);
+                  resolve(promiseResults);
+                } else {
+                  promiseResults.results = { response: "empty" };
+                  resolve(promiseResults);
+                }
               } else {
-                promiseResults.Results = output.Body.Fault;
-                reject(promiseResults);
+                promiseResults.results = { response: "empty" };
+                resolve(promiseResults);
               }
             } else {
-              promiseResults.Results = { response: "empty" };
-              resolve(promiseResults);
+              // Error checking. If the response contains a fault, we return the fault.
+              if (keyExists(output, "Fault")) {
+                if (output.Body.Fault.faultcode.includes("RateControl")) {
+                  promiseResults.results = { faultcode: "RateControl", faultstring: output.Body.Fault.faultstring };
+                } else if (output.Body.Fault.faultcode.includes("generalException")) {
+                  promiseResults.results = { faultcode: "generalException", faultstring: output.Body.Fault.faultstring };
+                } else {
+                  promiseResults.results = { faultcode: output.Body.Fault.faultcode, faultstring: output.Body.Fault.faultstring };
+                }
+                resolve(promiseResults);
+              } else {
+                // Error unknown. Reject with the response status instead. Most likely a 500 error from the server.
+                reject(response.status);
+              }
             }
           } catch (e) {
-            promiseResults.Results = e;
+            promiseResults.results = e;
             reject(promiseResults);
           }
         })
         .catch((error) => {
-          promiseResults.Results = error;
+          promiseResults.results = error;
           reject(promiseResults);
         }); // catches the error and logs it
     });
@@ -583,15 +653,15 @@ class perfMonService {
     return new Promise((resolve, reject) => {
       // Set up our promise results
       var promiseResults = {
-        Cookie: "",
-        Results: "",
+        cookie: "",
+        results: "",
       };
       // We fetch the API endpoint
       fetch(`https://${server}:8443/perfmonservice2/services/PerfmonService/`, options)
         .then(async (response) => {
           try {
             var data = []; // create an array to save chunked data from server
-            promiseResults.Cookie = response.headers.get("set-cookie") ? response.headers.get("set-cookie") : "";
+            promiseResults.cookie = response.headers.get("set-cookie") ? response.headers.get("set-cookie") : "";
             // response.body is a ReadableStream
             const reader = response.body.getReader();
             for await (const chunk of readChunks(reader)) {
@@ -606,23 +676,35 @@ class perfMonService {
             if (keyExists(output, "perfmonCloseSessionResponse")) {
               var returnResults = output.Body.perfmonCloseSessionResponse;
               if (returnResults) {
-                promiseResults.Results = { response: "success" };
+                promiseResults.results = { response: "success" };
                 resolve(promiseResults);
               } else {
-                promiseResults.Results = output.Body.Fault;
+                promiseResults.results = { response: "unknow" };
                 reject(promiseResults);
               }
             } else {
-              promiseResults.Results = { response: "empty" };
-              resolve(promiseResults);
+              // Error checking. If the response contains a fault, we return the fault.
+              if (keyExists(output, "Fault")) {
+                if (output.Body.Fault.faultcode.includes("RateControl")) {
+                  promiseResults.results = { faultcode: "RateControl", faultstring: output.Body.Fault.faultstring };
+                } else if (output.Body.Fault.faultcode.includes("generalException")) {
+                  promiseResults.results = { faultcode: "generalException", faultstring: output.Body.Fault.faultstring };
+                } else {
+                  promiseResults.results = { faultcode: output.Body.Fault.faultcode, faultstring: output.Body.Fault.faultstring };
+                }
+                resolve(promiseResults);
+              } else {
+                // Error unknown. Reject with the response status instead. Most likely a 500 error from the server.
+                reject(response.status);
+              }
             }
           } catch (e) {
-            promiseResults.Results = e;
+            promiseResults.results = e;
             reject(promiseResults);
           }
         })
         .catch((error) => {
-          promiseResults.Results = error;
+          promiseResults.results = error;
           reject(promiseResults);
         }); // catches the error and logs it
     });
@@ -682,25 +764,31 @@ class perfMonService {
             removeKeys(output, "$");
 
             if (keyExists(output, "perfmonAddCounterResponse")) {
-              var returnResults = output.Body.perfmonAddCounterResponse;
-              if (returnResults) {
-                promiseResults.Results = { response: "success" };
+              promiseResults.results = { response: "success" };
+              resolve(promiseResults);
+            } else {
+              // Error checking. If the response contains a fault, we return the fault.
+              if (keyExists(output, "Fault")) {
+                if (output.Body.Fault.faultcode.includes("RateControl")) {
+                  promiseResults.results = { faultcode: "RateControl", faultstring: output.Body.Fault.faultstring };
+                } else if (output.Body.Fault.faultcode.includes("generalException")) {
+                  promiseResults.results = { faultcode: "generalException", faultstring: output.Body.Fault.faultstring };
+                } else {
+                  promiseResults.results = { faultcode: output.Body.Fault.faultcode, faultstring: output.Body.Fault.faultstring };
+                }
                 resolve(promiseResults);
               } else {
-                promiseResults.Results = output.Body.Fault;
-                reject(promiseResults);
+                // Error unknown. Reject with the response status instead. Most likely a 500 error from the server.
+                reject(response.status);
               }
-            } else {
-              promiseResults.Results = { response: "empty" };
-              resolve(promiseResults);
             }
           } catch (e) {
-            promiseResults.Results = e;
+            promiseResults.results = e;
             reject(promiseResults);
           }
         })
         .catch((error) => {
-          promiseResults.Results = error;
+          promiseResults.results = error;
           reject(promiseResults);
         }); // catches the error and logs it
     });
@@ -762,23 +850,35 @@ class perfMonService {
             if (keyExists(output, "perfmonRemoveCounterResponse")) {
               var returnResults = output.Body.perfmonRemoveCounterResponse;
               if (returnResults) {
-                promiseResults.Results = { response: "success" };
+                promiseResults.results = { response: "success" };
                 resolve(promiseResults);
               } else {
-                promiseResults.Results = output.Body.Fault;
-                reject(promiseResults);
+                promiseResults.results = { response: "unknown" };
+                resolve(promiseResults);
               }
             } else {
-              promiseResults.Results = { response: "empty" };
-              resolve(promiseResults);
+              // Error checking. If the response contains a fault, we return the fault.
+              if (keyExists(output, "Fault")) {
+                if (output.Body.Fault.faultcode.includes("RateControl")) {
+                  promiseResults.results = { faultcode: "RateControl", faultstring: output.Body.Fault.faultstring };
+                } else if (output.Body.Fault.faultcode.includes("generalException")) {
+                  promiseResults.results = { faultcode: "generalException", faultstring: output.Body.Fault.faultstring };
+                } else {
+                  promiseResults.results = { faultcode: output.Body.Fault.faultcode, faultstring: output.Body.Fault.faultstring };
+                }
+                resolve(promiseResults);
+              } else {
+                // Error unknown. Reject with the response status instead. Most likely a 500 error from the server.
+                reject(response.status);
+              }
             }
           } catch (e) {
-            promiseResults.Results = e;
+            promiseResults.results = e;
             reject(promiseResults);
           }
         })
         .catch((error) => {
-          promiseResults.Results = error;
+          promiseResults.results = error;
           reject(promiseResults);
         }); // catches the error and logs it
     });
@@ -812,15 +912,15 @@ class perfMonService {
     return new Promise((resolve, reject) => {
       // Set up our promise results
       var promiseResults = {
-        Cookie: "",
-        Results: "",
+        cookie: "",
+        results: "",
       };
       // We fetch the API endpoint
       fetch(`https://${server}:8443/perfmonservice2/services/PerfmonService/`, options)
         .then(async (response) => {
           try {
             var data = []; // create an array to save chunked data from server
-            promiseResults.Cookie = response.headers.get("set-cookie") ? response.headers.get("set-cookie") : "";
+            promiseResults.cookie = response.headers.get("set-cookie") ? response.headers.get("set-cookie") : "";
             // response.body is a ReadableStream
             const reader = response.body.getReader();
             for await (const chunk of readChunks(reader)) {
@@ -833,26 +933,43 @@ class perfMonService {
             // Remove unnecessary keys
             removeKeys(output, "$");
 
-            if (keyExists(output, "perfmonQueryCounterDescriptionReturn")) {
-              var returnResults = output.Body.perfmonQueryCounterDescriptionResponse.perfmonQueryCounterDescriptionReturn;
-              if (returnResults) {
-                promiseResults.Results = clean(returnResults);
-                resolve(promiseResults);
+            if (keyExists(output, "perfmonQueryCounterDescriptionResponse")) {
+              if (keyExists(output, "perfmonQueryCounterDescriptionReturn")) {
+                var returnResults = output.Body.perfmonQueryCounterDescriptionResponse.perfmonQueryCounterDescriptionReturn;
+                if (returnResults) {
+                  promiseResults.results = clean(returnResults);
+                  resolve(promiseResults);
+                } else {
+                  promiseResults.results = { response: "empty" };
+                  resolve(promiseResults);
+                }
               } else {
-                promiseResults.Results = output.Body.Fault;
-                reject(promiseResults);
+                promiseResults.results = { response: "empty" };
+                resolve(promiseResults);
               }
             } else {
-              promiseResults.Results = { response: "empty" };
-              resolve(promiseResults);
+              // Error checking. If the response contains a fault, we return the fault.
+              if (keyExists(output, "Fault")) {
+                if (output.Body.Fault.faultcode.includes("RateControl")) {
+                  promiseResults.results = { faultcode: "RateControl", faultstring: output.Body.Fault.faultstring };
+                } else if (output.Body.Fault.faultcode.includes("generalException")) {
+                  promiseResults.results = { faultcode: "generalException", faultstring: output.Body.Fault.faultstring };
+                } else {
+                  promiseResults.results = { faultcode: output.Body.Fault.faultcode, faultstring: output.Body.Fault.faultstring };
+                }
+                resolve(promiseResults);
+              } else {
+                // Error unknown. Reject with the response status instead. Most likely a 500 error from the server.
+                reject(response.status);
+              }
             }
           } catch (e) {
-            promiseResults.Results = e;
+            promiseResults.results = e;
             reject(promiseResults);
           }
         })
         .catch((error) => {
-          promiseResults.Results = error;
+          promiseResults.results = error;
           reject(promiseResults);
         }); // catches the error and logs it
     });

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "cisco-perfmon",
-  "version": "1.3.2",
+  "version": "1.3.4",
   "description": "A library to pull Perfmon data from Cisco VOS applications via SOAP",
   "main": "main.js",
   "scripts": {
-    "test": "NODE_OPTIONS=--experimental-vm-modules NODE_NO_WARNINGS=1 NODE_TLS_REJECT_UNAUTHORIZED=0 NODE_ENV=test node ./test/tests.js",
+    "test": "NODE_OPTIONS=--experimental-vm-modules NODE_NO_WARNINGS=1 NODE_TLS_REJECT_UNAUTHORIZED=0 NODE_ENV=development node ./test/tests.js",
     "development": "NODE_OPTIONS=--experimental-vm-modules NODE_NO_WARNINGS=1 NODE_TLS_REJECT_UNAUTHORIZED=0 NODE_ENV=development node ./test/tests.js"
   },
   "repository": {

package/test/tests.js

@@ -30,14 +30,14 @@ var cucmServerName = env.CUCM_SERVER_NAME;
 var SessionID;
 var counterObj = {
   host: cucmServerName,
-  object: "Processor(_Total)",
-  counter: "% CPU Time",
+  object: "Memory",
+  counter: "% Mem Used",
 };
 
 var serviceSSO = "";
 
 (async () => {
-  console.log("Let's get a description of our counter.");
+  console.log("Let's get a description of our counter. We will also retrieve a cookie to use for the rest of the session.");
   await service
     .queryCounterDescription(counterObj)
     .then((results) => {
@@ -50,12 +50,22 @@ var serviceSSO = "";
       console.log(error);
     });
 
+  console.log("Let's collect some non session counter data.");
+  await serviceSSO
+    .collectCounterData(cucmServerName, "Cisco CallManager")
+    .then((results) => {
+      console.log("collectCounterData", results.Results);
+    })
+    .catch((error) => {
+      console.log(error);
+    });
+
   console.log("Let's open a session, add a counter, wait 30 seconds, collect the session data, remove the counter and finally close the session");
   await serviceSSO
     .openSession()
     .then(async (results) => {
       console.log("SessionID", results.Results);
-      SessionID = results;
+      SessionID = results.Results;
       await serviceSSO
         .addCounter(SessionID, counterObj)
         .then(async (results) => {
@@ -96,16 +106,6 @@ var serviceSSO = "";
       console.log(error);
     });
 
-  console.log("Let's collect some non session counter data.");
-  await serviceSSO
-    .collectCounterData(cucmServerName, "Cisco CallManager")
-    .then((results) => {
-      console.log("collectCounterData", results.Results);
-    })
-    .catch((error) => {
-      console.log(error);
-    });
-
   console.log("Let's returns the list of available PerfMon objects and counters on a particular host");
   await serviceSSO
     .listCounter(cucmServerName)