comments added to dockerHelper, mongo.js, communicationModel and ContainerInfo. Deleted awsHelpers.js

Author: Lucienne Seidler

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

@@ -126,8 +126,9 @@ healthHelpers.collectHealthData = () => {
       }
     });
 
-  /** obtains metrics relating to current load and creates and pushes object with
-   *  metric name and value to the healthDataCollection array
+  /**
+   * obtains metrics relating to current load and creates and pushes object with
+   * metric name and value to the healthDataCollection array
    */
   si.currentLoad()
     .then(data => {
@@ -147,8 +148,9 @@ healthHelpers.collectHealthData = () => {
       }
     });
 
-  /** obtains metrics relating to memory and creates and pushes object with
-   *  metric name and value to the healthDataCollection array
+  /**
+   * obtains metrics relating to memory and creates and pushes object with
+   * metric name and value to the healthDataCollection array
    */
   si.mem()
     .then(data => {

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.
 //

chronos_npm_package/controllers/mongo.js

@@ -2,6 +2,10 @@ const mongoose = require('mongoose');
 
 const { Schema } = mongoose;
 
+/**
+ * This model is used for storing alerts and communications to developers
+ */
+
 const CommunicationsSchema = new Schema({
   microservice: {
     type: String,

chronos_npm_package/models/CommunicationModel.js

@@ -45,7 +45,7 @@ const ContainerSchema = new Schema({
   time: {
     type: Date,
     default: Date.now(),
-  }
+  },
 });
 
 module.exports = ContainerName => mongoose.model(ContainerName, ContainerSchema);