Save the maximum package name length which was seen

src/api/admin.ts

@@ -34,9 +34,12 @@ export const createAdminRouter = ({ database, websocket, eventHandler }: {
 
   router.get('/status', async (_, res, next) => {
     try {
+      const { counters, maxValues } = await eventHandler.getValues()
+
       res.json({
         websocketClients: websocket.countConnections(),
-        counters: await eventHandler.getCounters()
+        counters,
+        maxValues
       })
     } catch (ex) {
       next(ex)
@@ -45,7 +48,7 @@ export const createAdminRouter = ({ database, websocket, eventHandler }: {
 
   router.post('/reset-counters', async (_, res, next) => {
     try {
-      await eventHandler.resetCounters()
+      await eventHandler.reset()
 
       res.json({ ok: true })
     } catch (ex) {

src/function/sync/apply-actions/dispatch-helper/app-logic-action.ts

@@ -15,6 +15,8 @@
  * along with this program.  If not, see <https://www.gnu.org/licenses/>.
  */
 
+import { max } from 'lodash'
+import { AddInstalledAppsAction, AppLogicAction, UpdateAppActivitiesAction } from '../../../../action'
 import { parseAppLogicAction } from '../../../../action/serialization'
 import { ClientPushChangesRequestAction } from '../../../../api/schema'
 import { isSerializedAppLogicAction } from '../../../../api/validator'
@@ -23,6 +25,30 @@ import { Cache } from '../cache'
 import { dispatchAppLogicAction as dispatchAppLogicActionInternal } from '../dispatch-app-logic-action'
 import { dispatch } from './helper'
 
+function getAppRelatedMaxValues (action: AppLogicAction): {
+  packageNameLength: number | null
+  activityNameLength: number | null
+} {
+  if (action instanceof AddInstalledAppsAction) {
+    const packageNameLength = max(action.apps.map((item) => item.packageName.length)) || null
+
+    return { packageNameLength, activityNameLength: null }
+  } else if (action instanceof UpdateAppActivitiesAction) {
+    const packageNameLength = max(action.updatedOrAdded.map((item) => item.packageName.length)) || null
+    const activityNameLength = max(action.updatedOrAdded.map((item) => item.activityName.length)) || null
+
+    return { packageNameLength, activityNameLength }
+  } else return { packageNameLength: null, activityNameLength: null }
+}
+
+function roundCounterUp (input: number, factor: number) {
+  if (input % factor === 0) {
+    return input
+  } else {
+    return input - (input % factor) + factor
+  }
+}
+
 export async function dispatchAppLogicAction ({ action, eventHandler, deviceId, cache }: {
   action: ClientPushChangesRequestAction
   deviceId: string
@@ -36,6 +62,11 @@ export async function dispatchAppLogicAction ({ action, eventHandler, deviceId,
     validator: isSerializedAppLogicAction,
     parser: parseAppLogicAction,
     applier: async (action) => {
+      const maxValues = getAppRelatedMaxValues(action)
+
+      if (maxValues.packageNameLength) eventHandler.reportMax('packageNameLength', roundCounterUp(maxValues.packageNameLength, 10))
+      if (maxValues.activityNameLength) eventHandler.reportMax('activityNameLength', roundCounterUp(maxValues.activityNameLength, 10))
+
       await dispatchAppLogicActionInternal({ action, cache, eventHandler, deviceId })
     }
   })

src/monitoring/eventhandler.ts

@@ -17,6 +17,10 @@
 
 export interface EventHandler {
   countEvent (name: string): void
-  getCounters (): Promise<{[key: string]: number}>
-  resetCounters (): Promise<void>
+  reportMax (name: string, value: number): void
+  getValues (): Promise<{
+    counters: {[key: string]: number}
+    maxValues: {[key: string]: number}
+  }>
+  reset (): Promise<void>
 }

src/monitoring/inmemoryeventhandler.ts

@@ -19,6 +19,7 @@ import { EventHandler } from './eventhandler'
 
 export class InMemoryEventHandler implements EventHandler {
   private counters = new Map<string, number>()
+  private maxValues = new Map<string, number>()
 
   countEvent (name: string) {
     this.counters.set(
@@ -27,17 +28,39 @@ export class InMemoryEventHandler implements EventHandler {
     )
   }
 
-  async getCounters () {
-    const result: {[key: string]: number} = {}
+  reportMax (name: string, value: number) {
+    this.maxValues.set(
+      name,
+      Math.max((this.maxValues.get(name) || 0), value)
+    )
+  }
 
-    this.counters.forEach((value, key) => {
-      result[key] = value
+  async getValues () {
+    return {
+      counters: this.buildObject(this.counters),
+      maxValues: this.buildObject(this.maxValues)
+    }
+  }
+
+  async reset () {
+    this.counters.clear()
+    this.maxValues.clear()
+  }
+
+  private buildObject<T> (map: Map<string, T>): {[key: string]: T} {
+    const result: {[key: string]: T} = {}
+
+    const keys: Array<string> = []
+    map.forEach((_, key) => keys.push(key))
+
+    keys.sort().forEach((key) => {
+      const value = map.get(key)
+
+      if (value !== undefined) {
+        result[key] = value
+      }
     })
 
     return result
   }
-
-  async resetCounters () {
-    this.counters.clear()
-  }
 }