cisco-perfmon 1.5.0 → 1.5.2

package/README.md

@@ -43,8 +43,9 @@ let service = new perfMonService(
 );
 
 var counterObj = {
-  host: "cucm01-pub",
+  host: cucmServerName,
   object: "Cisco CallManager",
+  instance: "",
   counter: "CallsActive",
 };
 
@@ -65,4 +66,27 @@ service
 npm run test
 ```
 
+## Output Examples
+
+```
+  Success Example
+  {
+    host: 'cucm01-pub',
+    object: 'Cisco CallManager',
+    instance: '',
+    counter: 'PRIChannelsActive',
+    value: '0',
+    cstatus: '1'
+  }
+
+  Error Example
+  {
+    status: 500,
+    code: 'Internal Server Error',
+    host: 'cucm01-pub',
+    counter: 'SAML SSO',
+    message: 'Exceeded allowed rate for Perfmon information. Current allowed rate for perfmon information is 80 requests per minute.PerfmonService'
+  }
+```
+
 Note: Test are using Cisco's DevNet sandbox information. Find more information here: [Cisco DevNet](https://devnetsandbox.cisco.com/)

package/main.js

@@ -104,13 +104,13 @@ class perfMonService {
         if (!retry) {
           return false;
         }
-        if (attempt > (process.env.PERFMON_RETRIES ? parseInt(process.env.PERFMON_RETRIES) : 3)) {
+        if (attempt > (process.env.PM_RETRY ? parseInt(process.env.PM_RETRY) : 3)) {
           return false;
         }
         // retry on any network error, or 4xx or 5xx status codes
         if (error !== null || response.status >= 400) {
           const delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
-          await delay(process.env.PERFMON_RETRY_DELAY ? parseInt(process.env.PERFMON_RETRY_DELAY) : 5000);
+          await delay(process.env.PM_RETRY_DELAY ? parseInt(process.env.PM_RETRY_DELAY) : 5000);
           return true;
         }
       },
@@ -168,13 +168,14 @@ class perfMonService {
 
       if (!response.ok) {
         // Local throw; if it weren't, I'd use Error or a subclass
-        throw { status: response.status, code: http.STATUS_CODES[response.status], message: output?.Body?.Fault?.faultstring ? output.Body.Fault.faultstring : "Unknown" };
+        throw { status: response.status, code: http.STATUS_CODES[response.status], host: host, object: object, message: output?.Body?.Fault?.faultstring ? output.Body.Fault.faultstring : "Unknown" };
       }
 
       // Let's check if the response contains the key we are looking for. This is the return data.
       if (output?.Body?.perfmonCollectCounterDataResponse?.perfmonCollectCounterDataReturn) {
         var returnResults = output.Body.perfmonCollectCounterDataResponse.perfmonCollectCounterDataReturn;
-        return cleanResponse(returnResults);
+        promiseResults.results = cleanResponse(returnResults);
+        return promiseResults;
       } else {
         // Return JSON with no results.
         return promiseResults;
@@ -219,7 +220,7 @@ class perfMonService {
 
     if (!response.ok) {
       // Local throw; if it weren't, I'd use Error or a subclass
-      throw { status: response.status, code: http.STATUS_CODES[response.status], message: output?.Body?.Fault?.faultstring ? output.Body.Fault.faultstring : "Unknown" };
+      throw { status: response.status, code: http.STATUS_CODES[response.status], sessionId: SessionHandle, message: output?.Body?.Fault?.faultstring ? output.Body.Fault.faultstring : "Unknown" };
     }
 
     if (output?.Body?.perfmonCollectSessionDataResponse?.perfmonCollectSessionDataReturn) {
@@ -267,7 +268,7 @@ class perfMonService {
 
     if (!response.ok) {
       // Local throw; if it weren't, I'd use Error or a subclass
-      throw { status: response.status, code: http.STATUS_CODES[response.status], message: output?.Body?.Fault?.faultstring ? output.Body.Fault.faultstring : "Unknown" };
+      throw { status: response.status, code: http.STATUS_CODES[response.status], host: host, message: output?.Body?.Fault?.faultstring ? output.Body.Fault.faultstring : "Unknown" };
     }
 
     if (output?.Body?.perfmonListCounterResponse?.perfmonListCounterReturn) {
@@ -321,7 +322,7 @@ class perfMonService {
 
     if (!response.ok) {
       // Local throw; if it weren't, I'd use Error or a subclass
-      throw { status: response.status, code: http.STATUS_CODES[response.status], message: output?.Body?.Fault?.faultstring ? output.Body.Fault.faultstring : "Unknown" };
+      throw { status: response.status, code: http.STATUS_CODES[response.status], host: host, object: object, message: output?.Body?.Fault?.faultstring ? output.Body.Fault.faultstring : "Unknown" };
     }
 
     if (output?.Body?.perfmonListInstanceResponse?.perfmonListInstanceReturn) {
@@ -383,6 +384,7 @@ class perfMonService {
     if (output?.Body?.perfmonOpenSessionResponse?.perfmonOpenSessionReturn) {
       var returnResults = output.Body.perfmonOpenSessionResponse.perfmonOpenSessionReturn;
       promiseResults.results = clean(returnResults);
+      return promiseResults;
     } else {
       // Return JSON with no results.
       return promiseResults;
@@ -424,7 +426,7 @@ class perfMonService {
 
     if (!response.ok) {
       // Local throw; if it weren't, I'd use Error or a subclass
-      throw { status: response.status, code: http.STATUS_CODES[response.status], message: output?.Body?.Fault?.faultstring ? output.Body.Fault.faultstring : "Unknown" };
+      throw { status: response.status, code: http.STATUS_CODES[response.status], sessionId: sessionHandle, message: output?.Body?.Fault?.faultstring ? output.Body.Fault.faultstring : "Unknown" };
     }
 
     if (output?.Body?.perfmonCloseSessionResponse) {
@@ -478,7 +480,7 @@ class perfMonService {
 
     if (!response.ok) {
       // Local throw; if it weren't, I'd use Error or a subclass
-      throw { status: response.status, code: http.STATUS_CODES[response.status], message: output?.Body?.Fault?.faultstring ? output.Body.Fault.faultstring : "Unknown" };
+      throw { status: response.status, code: http.STATUS_CODES[response.status], sessionId: sessionHandle, message: output?.Body?.Fault?.faultstring ? output.Body.Fault.faultstring : "Unknown" };
     }
 
     if (output?.Body?.perfmonAddCounterResponse) {
@@ -533,7 +535,7 @@ class perfMonService {
 
     if (!response.ok) {
       // Local throw; if it weren't, I'd use Error or a subclass
-      throw { status: response.status, code: http.STATUS_CODES[response.status], message: output?.Body?.Fault?.faultstring ? output.Body.Fault.faultstring : "Unknown" };
+      throw { status: response.status, code: http.STATUS_CODES[response.status], sessionId: sessionHandle, message: output?.Body?.Fault?.faultstring ? output.Body.Fault.faultstring : "Unknown" };
     }
 
     if (output?.Body?.perfmonRemoveCounterResponse) {
@@ -581,7 +583,7 @@ class perfMonService {
 
     if (!response.ok) {
       // Local throw; if it weren't, I'd use Error or a subclass
-      throw { status: response.status, code: http.STATUS_CODES[response.status], message: output?.Body?.Fault?.faultstring ? output.Body.Fault.faultstring : "Unknown" };
+      throw { status: response.status, code: http.STATUS_CODES[response.status], object: object, message: output?.Body?.Fault?.faultstring ? output.Body.Fault.faultstring : "Unknown" };
     }
 
     if (output?.Body?.perfmonQueryCounterDescriptionResponse?.perfmonQueryCounterDescriptionReturn) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cisco-perfmon",
-  "version": "1.5.0",
+  "version": "1.5.2",
   "description": "A library to pull Perfmon data from Cisco VOS applications via SOAP",
   "main": "main.js",
   "scripts": {

package/test/rateLimitTest.js

@@ -140,20 +140,57 @@ const retry = (fn, retriesLeft = 1, retryInteveral = 1000, promiseDelay = 0) =>
   try {
     // Let's run the perfmon loop for each counter
     console.log("Running rate limit test. This will take a while...");
-    var promises = [];
-    for (const counter of counterArr) {
-      promises.push(objectLimit(() => retry(() => perfmon_service.collectCounterData(cucmServerName, counter), 5, 5000, 1000)));
-    }
 
-    Promise.allSettled(promises).then((results) => {
-      results.forEach((result) => {
-        if (result.status === "fulfilled") {
-          console.log("Success:", result.value);
-        } else {
-          console.log("Failure:", JSON.stringify(result));
-        }
-      });
+    const promises = await counterArr.map((counter) => {
+      return objectLimit(() => retry(() => perfmon_service.collectCounterData(cucmServerName, counter), 0, 0, 0));
+    });
+
+    let output = await Promise.allSettled(promises);
+    output = output.map((el) => {
+      if (el.status === "fulfilled") {
+        return el.value;
+      } else {
+        return el.reason;
+      }
     });
+
+    output = output.flat(1);
+
+    let errors = {};
+    let success = {};
+
+    output.forEach((el) => {
+      if (el?.status > 400) {
+        errors[el.object] = (errors[el.object] || 0) + 1;
+      } else if (el?.results?.length > 0) {
+        el.results.forEach((result) => {
+          success[result.object] = (success[result.object] || 0) + 1;
+        });
+      }
+    });
+
+    const nonPercentageObjects = output.reduce((acc, obj) => {
+      if (obj?.results?.length > 0) {
+        const matchingItems = obj.results.filter((item) => !item?.counter.includes("%") && !item.counter?.includes("Percentage"));
+
+        if (matchingItems.length > 0) {
+          acc.push(matchingItems);
+        }
+        return acc.flat(1);
+      } else {
+        return acc;
+      }
+    }, []);
+
+    console.log(`Total number of objects: ${output.length}, matching non percentage objects: ${nonPercentageObjects.length}`);
+
+    var results = {
+      success: success,
+      errors: errors,
+    };
+
+    console.log(results);
+    console.log("Rate limit test completed.");
   } catch (err) {
     console.error("Error:", err);
   }

package/test/tests.js

@@ -28,8 +28,8 @@ var cucmServerName = env.CUCM_SERVER_NAME;
 
 // Variables to hold our SessionID and our Session Counter
 var SessionID;
-var counterObject = "Cisco CallManager";
-var sessionObj = {
+var perfmonObject = "Cisco CallManager";
+var perfmonSessionObj = {
   host: cucmServerName,
   object: "Cisco CallManager",
   instance: "",
@@ -37,9 +37,9 @@ var sessionObj = {
 };
 
 (async () => {
-  console.log("Let's get a description of our counter. We will also retrieve a cookie to use for the rest of the session.");
+  console.log("Let's get a description of our object. We will also retrieve a cookie to use for the rest of the session.");
   await service
-    .queryCounterDescription(sessionObj)
+    .queryCounterDescription(perfmonSessionObj)
     .then((response) => {
       console.log("queryCounterDescription: ", response.results);
       if (response.cookie) {
@@ -50,86 +50,79 @@ var sessionObj = {
       console.log("Error",JSON.stringify(error));
     });
 
-  
-    try {
-      var result =   await service.queryCounterDescription(sessionObj)
-    } catch (error) {
-      console.log(JSON.stringify(error));
-    }
-
-  // console.log("Let's collect some non session counter data.");
-  // await service
-  //   .collectCounterData(cucmServerName, counterObject)
-  //   .then((response) => {
-  //     console.log("collectCounterData", response);
-  //   })
-  //   .catch((error) => {
-  //     console.log(error.message);
-  //   });
+  console.log("Let's collect some non session object data.");
+  await service
+    .collectCounterData(cucmServerName, perfmonObject)
+    .then((response) => {
+      console.log("collectCounterData", response.results);
+    })
+    .catch((error) => {
+      console.log(error.message);
+    });
 
-  // 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 service
-  //   .openSession()
-  //   .then(async (response) => {
-  //     console.log("SessionID", response.results);
-  //     SessionID = response.results;
-  //     await service
-  //       .addCounter(SessionID, sessionObj)
-  //       .then(async (response) => {
-  //         console.log("addCounter", response.results);
-  //         const delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
-  //         console.log("Wait 15 seconds");
-  //         await delay(15000); // waiting 15 second.
-  //         await service
-  //           .collectSessionData(SessionID)
-  //           .then(async (response) => {
-  //             console.log("collectSessionData", response.results);
-  //             await service
-  //               .removeCounter(SessionID, response.results)
-  //               .then(async (response) => {
-  //                 console.log("removeCounter", response.results);
-  //                 await service
-  //                   .closeSession(SessionID)
-  //                   .then((response) => {
-  //                     console.log("closeSession", response.results);
-  //                   })
-  //                   .catch((error) => {
-  //                     console.log(error.message);
-  //                   });
-  //               })
-  //               .catch((error) => {
-  //                 console.log(error.message);
-  //               });
-  //           })
-  //           .catch((error) => {
-  //             console.log(error.message);
-  //           });
-  //       })
-  //       .catch((error) => {
-  //         console.log(error.message);
-  //       });
-  //   })
-  //   .catch((error) => {
-  //     console.log(error.message);
-  //   });
+  console.log("Let's open a session, add some object counters, wait 30 seconds, collect the session data, remove the object and finally close the session");
+  await service
+    .openSession()
+    .then(async (response) => {
+      console.log("SessionID", response.results);
+      SessionID = response.results;
+      await service
+        .addCounter(SessionID, perfmonSessionObj)
+        .then(async (response) => {
+          console.log("addCounter", response.results);
+          const delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+          console.log("Wait 15 seconds");
+          await delay(15000); // waiting 15 second.
+          await service
+            .collectSessionData(SessionID)
+            .then(async (response) => {
+              console.log("collectSessionData", response.results);
+              await service
+                .removeCounter(SessionID, response.results)
+                .then(async (response) => {
+                  console.log("removeCounter", response.results);
+                  await service
+                    .closeSession(SessionID)
+                    .then((response) => {
+                      console.log("closeSession", response.results);
+                    })
+                    .catch((error) => {
+                      console.log(error.message);
+                    });
+                })
+                .catch((error) => {
+                  console.log(error.message);
+                });
+            })
+            .catch((error) => {
+              console.log(error.message);
+            });
+        })
+        .catch((error) => {
+          console.log(error.message);
+        });
+    })
+    .catch((error) => {
+      console.log(error.message);
+    });
 
-  // console.log("Let's returns the list of available PerfMon objects and counters on a particular host");
-  // await service
-  //   .listCounter(cucmServerName)
-  //   .then((response) => {
-  //     console.log("listCounter", response.results);
-  //   })
-  //   .catch((error) => {
-  //     console.log(error.message);
-  //   });
+  console.log("Let's returns the list of available PerfMon objects and counters on a particular host");
+  await service
+    .listCounter(cucmServerName)
+    .then((response) => {
+      console.log("listCounter", response.results);
+    })
+    .catch((error) => {
+      console.log(error.message);
+    });
 
-  // console.log("Let's return a list of instances of a PerfMon object on a particular host. Instances of an object can dynamically change. This operation returns the most recent list.");
-  // await service
-  //   .listInstance(cucmServerName, "Processor")
-  //   .then((results) => {
-  //     console.log("listInstance", results.results);
-  //   })
-  //   .catch((error) => {
-  //     console.log(error.message);
-  //   });
+  console.log("Let's return a list of instances of a PerfMon object on a particular host. Instances of an object can dynamically change. This operation returns the most recent list.");
+  await service
+    .listInstance(cucmServerName, "Processor")
+    .then((results) => {
+      console.log("listInstance", results.results);
+    })
+    .catch((error) => {
+      console.log(error.message);
+    });
 })();