Merge pull request #12 from oslabs-beta/Lucie/Add_comments

Lucie/add comments

Author: beezoo10

chronos_npm_package/chronos.js

@@ -149,11 +149,7 @@ class Chronos {
 
   ServerWrapper(server, proto, methods) {
     /**
-     * Wraps the gRPC server object to automatically write logs to user configed DB
-     *
-     * If the provided database is MongoDB, connection will be made to the Mongodb Atlas
-     *
-     * If the provided database is PostgreSQL, connection will be made to PostgreSQL client
+     * Wraps the gRPC server object to automatically write logs to provided DB
      * @param {*} server
      * @param {*} proto
      * @param {*} methods
@@ -171,11 +167,7 @@ class Chronos {
 
   ClientWrapper(client, service) {
     /**
-     * Wraps the gRPC client to automatically write logs to user configed DB
-     *
-     * If the provided database is MongoDB, connection will be made to the Mongodb Atlas
-     *
-     * If the provided database is PostgreSQL, connection will be made to PostgreSQL client
+     * Wraps the gRPC client to automatically write logs to provided DB
      *
      * @param {*} client
      * @param {*} service

chronos_npm_package/controllers/awsHelpers.js

@@ -1,10 +1,13 @@
 const si = require('systeminformation');
 
+/**
+ * Finds the data pt with containerName that matches microservice and extracts container ID, name, platform, and start time.
+ * @param {*} microservice 
+ * @returns array of active containers (ea. container = an obj).
+ */
 async function getDockerContainer(microservice) {
   try {
-      // dockerContainers() return an arr of active containers (ea. container = an obj).
-      // Find the data pt with containerName that matches microservice.
-      // Extract container ID, name, platform, and start time.
+      
       const containers = await si.dockerContainers();
       const out = {};;
       let found = false;
@@ -34,7 +37,6 @@ async function getDockerContainer(microservice) {
 
 
 async function readDockerContainer(input) {
-    // We are going to take the input object and add more data to it;
     const out = {...input};
     try {
       const data = await si.dockerContainerStats(input.containerid);

chronos_npm_package/controllers/dockerHelper.js

@@ -2,7 +2,10 @@ const si = require('systeminformation');
 
 const healthHelpers = {};
 
-/* This object contains all systeminformation methods, metric names, and corresponding points */
+/**
+ * This object contains all systeminformation methods,
+ * metric names, and corresponding data points
+ */
 
 const collectedMetrics = {
   cpu: {
@@ -50,10 +53,18 @@ const collectedMetrics = {
   inetLatency: 'all data collected',
 };
 
+/**
+ * collectHealthData scrapes metrics for microservices
+ * @returns Promise array with each metric in an object
+ */
+
 healthHelpers.collectHealthData = () => {
   const healthDataCollection = [];
   const time = Date.now();
 
+  /** obtains core CPU metrics and creates and pushes object with
+   *  metric name and value to the healthDataCollection array
+   */
   si.cpu()
     .then(data => {
       const siMethodName = 'cpu';
@@ -72,6 +83,9 @@ healthHelpers.collectHealthData = () => {
       }
     });
 
+  /** obtains CPU speed metrics and creates and pushes object with
+   *  metric name and value to the healthDataCollection array
+   */
   si.cpuCurrentSpeed()
     .then(data => {
       const siMethodName = 'cpuCurrentSpeed';
@@ -90,6 +104,10 @@ healthHelpers.collectHealthData = () => {
       }
     });
 
+  /** obtains CPU temperature metrics and creates and pushes object with
+   *  metric name and value to the healthDataCollection array
+   */
+
   si.cpuTemperature()
     .then(data => {
       const siMethodName = 'cpuTemperature';
@@ -108,6 +126,10 @@ healthHelpers.collectHealthData = () => {
       }
     });
 
+  /**
+   * obtains metrics relating to current load and creates and pushes object with
+   * metric name and value to the healthDataCollection array
+   */
   si.currentLoad()
     .then(data => {
       const siMethodName = 'currentLoad';
@@ -126,6 +148,10 @@ healthHelpers.collectHealthData = () => {
       }
     });
 
+  /**
+   * obtains metrics relating to memory and creates and pushes object with
+   * metric name and value to the healthDataCollection array
+   */
   si.mem()
     .then(data => {
       const siMethodName = 'mem';
@@ -144,6 +170,9 @@ healthHelpers.collectHealthData = () => {
       }
     });
 
+  /** obtains metrics relating to current processes and creates and pushes object with
+   *  metric name and value to the healthDataCollection array
+   */
   si.processes()
     .then(data => {
       const siMethodName = 'processes';
@@ -162,6 +191,9 @@ healthHelpers.collectHealthData = () => {
       }
     });
 
+  /** obtains latency and creates and pushes object with
+   *  metric name and value to the healthDataCollection array
+   */
   si.inetLatency()
     .then(data => {
       const siMethodName = 'inetLatency';
@@ -178,22 +210,14 @@ healthHelpers.collectHealthData = () => {
       }
     });
 
-  // Return a promise that resolves to an array of all of the data points unnested
-  return (
-    Promise.all(healthDataCollection)
-      // Remove any empty strings, NaN, or "NaN" from values prevent database errors
-      .then(array =>
-        array.filter(metric => {
-          if (
-            isNaN(metric.value) ||
-            metric.value === 'NaN' ||
-            metric.value === '' ||
-            metric.value === null
-          )
-            return false;
-          else return true;
-        })
-      )
+  /** Return a promise that resolves to an array of all of the data points
+   * and removes any empty strings, NaN, or "NaN" from values prevent database errors
+   */
+  return Promise.all(healthDataCollection).then(array =>
+    array.filter(metric => {
+      if (isNaN(metric.value) || metric.value === 'NaN' || metric.value === '') return false;
+      else return true;
+    })
   );
 };
 

chronos_npm_package/controllers/healthHelpers.js

@@ -39,12 +39,10 @@ mongo.connect = async ({ database }) => {
  * @param {string} microservice Microservice name
  * @param {number} interval Interval to collect data
  */
+
 mongo.services = ({ microservice, interval }) => {
   console.log(`Saving "${microservice}" to services...`);
-  // Create newService object to store microservice information
   const newService = { microservice, interval };
-
-  // Create MongoDB document from newService
   const service = new ServicesModel(newService);
 
   service
@@ -84,11 +82,10 @@ mongo.communications = ({ microservice, slack, email }) => {
         if (email) alert.sendEmail(res.statusCode, res.statusMessage, email);
       }
 
-      // Add status code and message to newComms
+      /** Add status code and message to newComms */
       newComms.responsestatus = res.statusCode;
       newComms.responsemessage = res.statusMessage;
 
-      // Create MongoDB document from newComms
       const communication = new CommunicationModel(newComms);
       communication
         .save()
@@ -116,7 +113,7 @@ mongo.health = async ({ microservice, interval, mode }) => {
 
   setInterval(() => {
     collectHealthData()
-      .then(async (healthMetrics) => {
+      .then(async healthMetrics => {
         if (l !== healthMetrics.length) {
           l = await mongo.addMetrics(healthMetrics, mode, currentMetricNames);
         }
@@ -135,40 +132,43 @@ mongo.health = async ({ microservice, interval, mode }) => {
  * Collects information on the docker container
  */
 mongo.docker = ({ microservice, interval, mode }) => {
-
   // Create collection using name of microservice
   const containerInfo = ContainerInfoFunc(`${microservice}-containerinfo`);
-  dockerHelper.getDockerContainer(microservice)
-    .then((containerData) => {
+  dockerHelper
+    .getDockerContainer(microservice)
+    .then(containerData => {
       setInterval(() => {
-        dockerHelper.readDockerContainer(containerData)
-          .then((data) => {
+        dockerHelper
+          .readDockerContainer(containerData)
+          .then(data => {
             return containerInfo.create(data);
           })
-          .then((_) => console.log(`Docker data recorded in MongoDB collection ${microservice}-containerinfo`))
-          .catch((err) => {
-            throw new Error(err)
+          .then(_ =>
+            console.log(`Docker data recorded in MongoDB collection ${microservice}-containerinfo`)
+          )
+          .catch(err => {
+            throw new Error(err);
           });
-      }, interval) 
-  })
-  
-  .catch((error) => {
-    if (error.constructor.name === 'Error') throw error
-    else throw new Error(error);
-  })
+      }, interval);
+    })
+
+    .catch(error => {
+      if (error.constructor.name === 'Error') throw error;
+      else throw new Error(error);
+    });
 };
 
 /*
  This function takes as a parameter the promise returned from the kafkaFetch().
  It then takes the returned array of metrics, turns them into documents based on
  KafkaModel.js, and inserts them into the db at the provided uri with insertMany()
 */
-mongo.serverQuery = (config) => {
+mongo.serverQuery = config => {
   mongo.saveService(config);
   mongo.setQueryOnInterval(config);
-}
+};
 
-mongo.saveService = (config) => {
+mongo.saveService = config => {
   let microservice;
   if (config.mode === 'kafka') {
     microservice = 'kafkametrics';
@@ -183,16 +183,19 @@ mongo.saveService = (config) => {
     interval: config.interval,
   });
 
-  service.save()
+  service
+    .save()
     .then(() => console.log(`Adding "${microservice}" to the services table`))
-    .catch(err => console.log(`Error saving "${microservice}" to the services table: `, err.message));
-}
+    .catch(err =>
+      console.log(`Error saving "${microservice}" to the services table: `, err.message)
+    );
+};
 
-mongo.setQueryOnInterval = async (config) => {
+mongo.setQueryOnInterval = async config => {
   let model;
   let metricsQuery;
 
-  let l = 0;
+  let length = 0;
   const currentMetricNames = {};
 
   if (config.mode === 'kafka') {
@@ -204,62 +207,64 @@ mongo.setQueryOnInterval = async (config) => {
   } else {
     throw new Error('Unrecognized mode');
   }
-  // When querying for currentMetrics, we narrow down the result to only include metrics for the current service being used.
-  // This way, when we go to compare parsedArray to currentMetricNames, the length of the arrays should match up unless there are new metrics available to view
 
-  l = await mongo.getSavedMetricsLength(config.mode, currentMetricNames);
+  length = await mongo.getSavedMetricsLength(config.mode, currentMetricNames);
 
-  console.log('currentMetricNames is: ', Object.keys(currentMetricNames).length)
+  console.log('currentMetricNames is: ', Object.keys(currentMetricNames).length);
   // Use setInterval to send queries to metrics server and then pipe responses to database
   setInterval(() => {
     metricsQuery(config)
       // This updates the Metrics Model with all chosen metrics. If there are no chosen metrics it sets all available metrics as chosen metrics within the metrics model.
-      .then(async (parsedArray) => {
+      .then(async parsedArray => {
         // This conditional would be used if new metrics are available to be tracked.
-        if (l !== parsedArray.length) {
-          l = await mongo.addMetrics(parsedArray, config.mode, currentMetricNames);
+        if (length !== parsedArray.length) {
+          length = await mongo.addMetrics(parsedArray, config.mode, currentMetricNames);
         }
         const documents = [];
         for (const metric of parsedArray) {
-          // This will check if the current metric in the parsed array evaluates to true within the currentMetricNames object.
-          // The currentMetricNames object is updated by the user when they select/deselect metrics on the electron app, so only the
-          // requested metrics will actually be populated in the database, which helps to avoid overloading the db with unnecessary data.
+          /**
+           * This will check if the current metric in the parsed array
+           * evaluates to true within the currentMetricNames object
+           * which is updated by the user when they select/deselect metrics on the electron app
+           * helping to avoid overloading the db with unnecessary data.
+           */
+
           if (currentMetricNames[metric.metric]) documents.push(model(metric));
         }
-        return model.insertMany(documents, (err) => {
+        return model.insertMany(documents, err => {
           if (err) console.error(err);
-        })
+        });
       })
       .then(() => console.log(`${config.mode} metrics recorded in MongoDB`))
       .catch(err => console.log(`Error inserting ${config.mode} documents in MongoDB: `, err));
   }, config.interval);
-}
+};
 
 mongo.getSavedMetricsLength = async (mode, currentMetricNames) => {
-  let currentMetrics = await MetricsModel.find({mode: mode});
+  let currentMetrics = await MetricsModel.find({ mode: mode });
   if (currentMetrics.length > 0) {
     currentMetrics.forEach(el => {
-    const { metric, selected } = el;
-    currentMetricNames[metric] = selected;
-    })
+      const { metric, selected } = el;
+      currentMetricNames[metric] = selected;
+    });
   }
   return currentMetrics.length ? currentMetrics.length : 0;
-}
+};
 
 mongo.addMetrics = async (arr, mode, obj) => {
-    const newMets = [];
-    arr.forEach(el => {
-      if (!(el.metric in obj)) {
-        const { metric } = el;
-        newMets.push({metric: metric, mode: mode})
-        obj[el.metric] = true;
-      }
-    })
-    await MetricsModel.insertMany(newMets, (err) => {
-      if (err) console.error(err)
-    })
-    return arr.length;
-}
+  const newMets = [];
+  arr.forEach(el => {
+    if (!(el.metric in obj)) {
+      const { metric } = el;
+      newMets.push({ metric: metric, mode: mode });
+      obj[el.metric] = true;
+    }
+  });
+  await MetricsModel.insertMany(newMets, err => {
+    if (err) console.error(err);
+  });
+  return arr.length;
+};
 
 // This middleware could be used if the user would like to update their chronos data in real time (immediately after updating saved metrics on the Chronos desktop app), but they would have to expose a URL/port to be queried for the Electron front end.
 //