1 files changed, 170 insertions, 28 deletions
diff --git a/src/server/DashStats.ts b/src/server/DashStats.ts
index a10b28608..8d341db63 100644
--- a/src/server/DashStats.ts
+++ b/src/server/DashStats.ts
@@ -1,35 +1,72 @@
 import { cyan, magenta } from 'colors';
-import { Request, Response } from 'express';
-import { Server } from 'http';
+import { Response } from 'express';
 import SocketIO from 'socket.io';
 import { timeMap } from './ApiManagers/UserManager';
 import { WebSocket } from './websocket';
 const fs = require('fs');
-const csv = require('csv-parser');
 
+/**
+ * DashStats focuses on tracking user data for each session.
+ * 
+ * This includes time connected, number of operations, and
+ * the rate of their operations
+ */
 export namespace DashStats {
+    export const SAMPLING_INTERVAL = 1000; // in milliseconds (ms) - Time interval to update the frontend. 
+    export const RATE_INTERVAL = 10; // in seconds (s) - Used to calculate rate
+
     const statsCSVFilename = './src/server/stats/userLoginStats.csv';
     const columns = ['USERNAME', 'ACTION', 'TIME'];
 
-    interface SocketPair {
+    /**
+     * UserStats holds the stats associated with a particular user. 
+     */
+    interface UserStats {
         socketId: string;
         username: string;
         time: string;
         operations: number;
+        rate: number;
+    }
+
+    /**
+     * UserLastOperations is the queue object for each user 
+     * storing their past operations. 
+     */
+    interface UserLastOperations {
+        sampleOperations: number; // stores how many operations total are in this rate section (10 sec, for example)
+        lastSampleOperations: number; // stores how many total operations were recorded at the last sample
+        previousOperationsQueue: number[]; // stores the operations to calculate rate. 
     }
 
+    /**
+     * StatsDataBundle represents an object that will be sent to the frontend view
+     * on each websocket update. 
+     */
+    interface StatsDataBundle {
+        connectedUsers: UserStats[];
+    }
+
+    /**
+     * CSVStore represents how objects will be stored in the CSV
+     */
     interface CSVStore {
         USERNAME: string;
         ACTION: string;
         TIME: string;
     }
 
+    /**
+     * ServerTraffic describes the current traffic going to the backend. 
+     */
     enum ServerTraffic {
         NOT_BUSY,
         BUSY,
         VERY_BUSY
     }
 
+    // These values can be changed after further testing how many
+    // users correspond to each traffic level in Dash. 
     const BUSY_SERVER_BOUND = 2;
     const VERY_BUSY_SERVER_BOUND = 3;
 
@@ -39,31 +76,47 @@ export namespace DashStats {
         "Very Busy"
     ]
 
+    // lastUserOperations maps each username to a UserLastOperations
+    // structure 
+    export const lastUserOperations = new Map<string, UserLastOperations>();
+
+    /**
+     * handleStats is called when the /stats route is called, providing a JSON
+     * object with relevant stats. In this case, we return the number of
+     * current connections and 
+     * @param res Response object from Express
+     */
     export function handleStats(res: Response) {
-        let current = getCurrentConnections();
+        let current = getCurrentStats();
         const results: CSVStore[] = [];
         res.json({
-                message: 'welcome to stats',
                 currentConnections: current.length,
                 socketMap: current,
             });
+    }
+
+    /**
+     * getUpdatedStatesBundle() sends an updated copy of the current stats to the 
+     * frontend /statsview route via websockets. 
+     * 
+     * @returns a StatsDataBundle that is sent to the frontend view on each websocket update
+     */
+    export function getUpdatedStatsBundle(): StatsDataBundle {
+        let current = getCurrentStats();
 
-        // fs.createReadStream(statsCSVFilename)
-        //     .pipe(csv())
-        //     .on('data', (data: any) => results.push(data))
-        //     .on('end', () => {
-        //         console.log(results);
-        //         res.json({
-        //             message: 'welcome to stats',
-        //             currentConnections: current.length,
-        //             socketMap: current,
-        //             results: results,
-        //         });
-        //     });
+        return {
+            connectedUsers: current,
+        }
     }
 
+    /**
+     * handleStatsView() is called when the /statsview route is called. This 
+     * will use pug to render a frontend view of the current stats
+     * 
+     * @param res 
+     */
     export function handleStatsView(res: Response) {
-        let current = getCurrentConnections();
+        let current = getCurrentStats();
 
         let connectedUsers = current.map((socketPair) => {
             return socketPair.time + " - " + socketPair.username + " Operations: " + socketPair.operations;
@@ -80,17 +133,23 @@ export namespace DashStats {
         
         res.render("stats.pug", {
             title: "Dash Stats",
-            numConnections: current.length,
+            numConnections: connectedUsers.length,
             serverTraffic: serverTraffic,
             serverTrafficMessage : serverTrafficMessages[serverTraffic],
             connectedUsers: connectedUsers
         });
     }
 
+    /**
+     * logUserLogin() writes a login event to the CSV file. 
+     * 
+     * @param username the username in the format of "username@domain.com logged in"
+     * @param socket the websocket associated with the current connection
+     */
     export function logUserLogin(username: string | undefined, socket: SocketIO.Socket) {
         if (!(username === undefined)) {
             let currentDate = new Date();
-            // console.log(magenta(`User ${username.split(' ')[0]} logged in at: ${currentDate.toISOString()}`));
+            console.log(magenta(`User ${username.split(' ')[0]} logged in at: ${currentDate.toISOString()}`));
 
             let toWrite: CSVStore = {
                 USERNAME : username,
@@ -105,10 +164,15 @@ export namespace DashStats {
         }
     }
 
+    /**
+     * logUserLogout() writes a logout event to the CSV file. 
+     * 
+     * @param username the username in the format of "username@domain.com logged in"
+     * @param socket the websocket associated with the current connection. 
+     */
     export function logUserLogout(username: string | undefined, socket: SocketIO.Socket) {
         if (!(username === undefined)) {
             let currentDate = new Date();
-            // console.log(magenta(`User ${username.split(' ')[0]} logged out at: ${currentDate.toISOString()}`));
 
             let statsFile = fs.createWriteStream(statsCSVFilename, { flags: "a"});
             let toWrite: CSVStore = {
@@ -121,10 +185,79 @@ export namespace DashStats {
         }
     }
 
-    function getCurrentConnections(): SocketPair[] {
-        console.log("timeMap: " + timeMap);
-        console.log("clients:" + WebSocket.clients);
-        let socketPairs: SocketPair[] = [];
+    /**
+     * getLastOperationsOrDefault() is a helper method that will attempt
+     * to query the lastUserOperations map for a specified username. If the
+     * username is not in the map, an empty UserLastOperations object is returned. 
+     * @param username 
+     * @returns the user's UserLastOperations structure or an empty
+     * UserLastOperations object (All values set to 0) if the username is not found.
+     */
+    function getLastOperationsOrDefault(username: string): UserLastOperations {
+        if(lastUserOperations.get(username) === undefined) {
+            let initializeOperationsQueue = [];
+            for(let i = 0; i < RATE_INTERVAL; i++) {
+                initializeOperationsQueue.push(0);
+            }
+            return {
+                sampleOperations: 0,
+                lastSampleOperations: 0,
+                previousOperationsQueue: initializeOperationsQueue
+            }
+        }
+        return lastUserOperations.get(username)!;
+    }
+
+    /**
+     * updateLastOperations updates a specific user's UserLastOperations information
+     * for the current sampling cycle. The method removes old/outdated counts for
+     * operations from the queue and adds new data for the current sampling 
+     * cycle to the queue, updating the total count as it goes. 
+     * @param lastOperationData the old UserLastOperations data that must be updated
+     * @param currentOperations the total number of operations measured for this sampling cycle.
+     * @returns the udpated UserLastOperations structure. 
+     */
+    function updateLastOperations(lastOperationData: UserLastOperations, currentOperations: number): UserLastOperations {
+        // create a copy of the UserLastOperations to modify
+        let newLastOperationData: UserLastOperations = {
+            sampleOperations: lastOperationData.sampleOperations,
+            lastSampleOperations: lastOperationData.lastSampleOperations,
+            previousOperationsQueue: lastOperationData.previousOperationsQueue.slice()
+        }
+
+        let newSampleOperations = newLastOperationData.sampleOperations;
+        newSampleOperations -= newLastOperationData.previousOperationsQueue.shift()!; // removes and returns the first element of the queue
+        let operationsThisCycle = currentOperations - lastOperationData.lastSampleOperations;
+        newSampleOperations += operationsThisCycle; // add the operations this cycle to find out what our count for the interval should be (e.g operations in the last 10 seconds)
+
+        // update values for the copy object
+        newLastOperationData.sampleOperations = newSampleOperations;
+
+        newLastOperationData.previousOperationsQueue.push(operationsThisCycle);
+        newLastOperationData.lastSampleOperations = currentOperations;
+
+        return newLastOperationData;
+    }
+
+    /**
+     * getUserOperationsOrDefault() is a helper method to get the user's total
+     * operations for the CURRENT sampling interval. The method will return 0 
+     * if the username is not in the userOperations map.
+     * @param username the username to search the map for
+     * @returns the total number of operations recorded up to this sampling cycle. 
+     */
+    function getUserOperationsOrDefault(username: string): number {
+        return WebSocket.userOperations.get(username) === undefined ? 0 : WebSocket.userOperations.get(username)!
+    }
+
+    /**
+     * getCurrentStats() calculates the total stats for this cycle. In this case,
+     * getCurrentStats() returns an Array of UserStats[] objects describing 
+     * the stats for each user
+     * @returns an array of UserStats storing data for each user at the current moment. 
+     */
+    function getCurrentStats(): UserStats[] {
+        let socketPairs: UserStats[] = [];
         for (let [key, value] of WebSocket.socketMap) {
             let username = value.split(' ')[0];
             let connectionTime = new Date(timeMap[username]);
@@ -132,19 +265,28 @@ export namespace DashStats {
             let connectionTimeString = connectionTime.toLocaleDateString() + " " + connectionTime.toLocaleTimeString();
 
             if (!key.disconnected) {
+                let lastRecordedOperations = getLastOperationsOrDefault(username);
+                let currentUserOperationCount = getUserOperationsOrDefault(username);
+
                 socketPairs.push({ 
                     socketId: key.id,
                     username: username,
                     time: connectionTimeString.includes("Invalid Date") ? "" : connectionTimeString,
                     operations : WebSocket.userOperations.get(username) ? WebSocket.userOperations.get(username)! : 0,
+                    rate: lastRecordedOperations.sampleOperations
                 });
+                lastUserOperations.set(username, updateLastOperations(lastRecordedOperations,currentUserOperationCount));
             }
         }
-        console.log(socketPairs);
-        // console.log([...WebSocket.clients.entries()]);
         return socketPairs;
     }
 
+    /**
+     * convertToCSV() is a helper method that stringifies a CSVStore object
+     * that can be written to the CSV file later. 
+     * @param dataObject the object to stringify
+     * @returns the object as a string. 
+     */
     function convertToCSV(dataObject: CSVStore): string {
         return `${dataObject.USERNAME},${dataObject.ACTION},${dataObject.TIME}\n`;
     }