merge graph timestamps into single array, use seconds

lib/app.js

@@ -41,18 +41,19 @@ class App {
     if (config.logToDatabase) {
       client.on('message', (message) => {
         if (message === 'requestHistoryGraph') {
-          // Send historical graphData built from all serverRegistrations
-          const graphData = {}
+          // FIXME: update schema, remove timestamp
+          // Since all history graph updates share timestamps, pull the timestamps from a single ServerRegistration
+          const timestamps = this.serverRegistrations[0].graphData.map(point => Math.floor(point[0] / 1000))
 
-          this.serverRegistrations.forEach((serverRegistration) => {
-            graphData[serverRegistration.serverId] = serverRegistration.graphData
-          })
+          // Send historical graphData built from all serverRegistrations
+          const graphData = this.serverRegistrations.map(serverRegistration => serverRegistration.graphData.map(point => point[1]))
 
           // Send graphData in object wrapper to avoid needing to explicity filter
           // any header data being appended by #MessageOf since the graph data is fed
           // directly into the graphing system
           client.send(MessageOf('historyGraph', {
-            graphData: graphData
+            timestamps,
+            graphData
           }))
         }
       })
@@ -77,7 +78,7 @@ class App {
         }
       })(),
       mojangServices: this.mojangUpdater.getLastUpdate(),
-      timestampPoints: this.timeTracker.getPoints(),
+      timestampPoints: this.timeTracker.getPointsSeconds(),
       servers: this.serverRegistrations.map(serverRegistration => serverRegistration.getPingHistory())
     }
 

lib/database.js

@@ -63,8 +63,8 @@ class Database {
       // When complete increment completeTasks to know when complete
       this.getRecord(serverRegistration.data.ip, (playerCount, timestamp) => {
         serverRegistration.recordData = {
-          playerCount: playerCount,
-          timestamp: timestamp
+          playerCount,
+          timestamp: Math.floor(timestamp / 1000)
         }
 
         // Check if completedTasks hit the finish value

lib/ping.js

@@ -85,6 +85,14 @@ class PingController {
   pingAll = () => {
     const timestamp = this._app.timeTracker.newTimestamp()
 
+    // Flag each group as history graph additions each minute
+    // This is sent to the frontend for graph updates
+    const updateHistoryGraph = config.logToDatabase && (!this._lastHistoryGraphUpdate || timestamp - this._lastHistoryGraphUpdate >= 60 * 1000)
+
+    if (updateHistoryGraph) {
+      this._lastHistoryGraphUpdate = timestamp
+    }
+
     this.startPingTasks(results => {
       const updates = []
 
@@ -102,7 +110,7 @@ class PingController {
         // Generate a combined update payload
         // This includes any modified fields and flags used by the frontend
         // This will not be cached and can contain live metadata
-        const update = serverRegistration.handlePing(timestamp, result.resp, result.err, result.version)
+        const update = serverRegistration.handlePing(timestamp, result.resp, result.err, result.version, updateHistoryGraph)
 
         updates[serverRegistration.serverId] = update
       }
@@ -110,7 +118,8 @@ class PingController {
       // Send object since updates uses serverIds as keys
       // Send a single timestamp entry since it is shared
       this._app.server.broadcast(MessageOf('updateServers', {
-        timestamp,
+        timestamp: Math.floor(timestamp / 1000),
+        updateHistoryGraph,
         updates
       }))
     })

lib/servers.js

@@ -20,7 +20,7 @@ class ServerRegistration {
     this._pingHistory = []
   }
 
-  handlePing (timestamp, resp, err, version) {
+  handlePing (timestamp, resp, err, version, updateHistoryGraph) {
     // Use null to represent a failed ping
     const playerCount = resp ? resp.players.online : null
 
@@ -35,19 +35,21 @@ class ServerRegistration {
     // Only notify the frontend to append to the historical graph
     // if both the graphing behavior is enabled and the backend agrees
     // that the ping is eligible for addition
-    let updateHistoryGraph = false
+    if (updateHistoryGraph) {
+      // FIXME: update schema, remove timestamp
+      this.graphData.push([timestamp, playerCount])
 
-    if (config.logToDatabase) {
-      if (this.addGraphPoint(playerCount, timestamp)) {
-        updateHistoryGraph = true
+      // Trim old graphPoints according to #getMaxGraphDataLength
+      if (this.graphData.length > TimeTracker.getMaxGraphDataLength()) {
+        this.graphData.shift()
       }
     }
 
     // Delegate out update payload generation
-    return this.getUpdate(timestamp, resp, err, version, updateHistoryGraph)
+    return this.getUpdate(timestamp, resp, err, version)
   }
 
-  getUpdate (timestamp, resp, err, version, updateHistoryGraph) {
+  getUpdate (timestamp, resp, err, version) {
     const update = {}
 
     if (resp) {
@@ -59,7 +61,7 @@ class ServerRegistration {
       if (config.logToDatabase && (!this.recordData || resp.players.online > this.recordData.playerCount)) {
         this.recordData = {
           playerCount: resp.players.online,
-          timestamp: timestamp
+          timestamp: Math.floor(timestamp / 1000)
         }
 
         // Append an updated recordData
@@ -80,12 +82,6 @@ class ServerRegistration {
         if (this.findNewGraphPeak()) {
           update.graphPeakData = this.getGraphPeak()
         }
-
-        // Handled inside logToDatabase to validate logic from #getUpdate call
-        // Only append when true since an undefined value == false
-        if (updateHistoryGraph) {
-          update.updateHistoryGraph = true
-        }
       }
     } else if (err) {
       // Append a filtered copy of err
@@ -155,18 +151,6 @@ class ServerRegistration {
     }
   }
 
-  addGraphPoint (playerCount, timestamp) {
-    // FIXME: update schema, remove timestamp
-    this.graphData.push([timestamp, playerCount])
-
-    // Trim old graphPoints according to #getMaxGraphDataLength
-    if (this.graphData.length > TimeTracker.getMaxGraphDataLength()) {
-      this.graphData.shift()
-    }
-
-    return true
-  }
-
   findNewGraphPeak () {
     let index = -1
     for (let i = 0; i < this.graphData.length; i++) {
@@ -192,7 +176,7 @@ class ServerRegistration {
     const graphPeak = this.graphData[this._graphPeakIndex]
     return {
       playerCount: graphPeak[1],
-      timestamp: graphPeak[0]
+      timestamp: Math.floor(graphPeak[0] / 1000)
     }
   }
 

lib/time.js

@@ -18,8 +18,8 @@ class TimeTracker {
     return timestamp
   }
 
-  getPoints () {
-    return this._points
+  getPointsSeconds () {
+    return this._points.map(value => Math.floor(value / 1000))
   }
 
   static getMaxServerGraphDataLength () {