@alwaysai/device-agent 0.1.0 → 0.1.2

package/src/cloud-connection/live-updates-handler.ts

@@ -14,6 +14,11 @@ import {
   getDeviceStatsMessage
 } from './messages';
 import { AgentMessageTypeValue } from '@alwaysai/device-agent-schemas/lib/constants';
+import { ALWAYSAI_LIVE_UPDATES_TIMEOUT_MS } from '../environment';
+
+const LIVE_UPDATES_TIMEOUT = ALWAYSAI_LIVE_UPDATES_TIMEOUT_MS
+  ? parseInt(ALWAYSAI_LIVE_UPDATES_TIMEOUT_MS)
+  : 60000;
 
 export class LiveUpdatesHandler {
   private publisher: Publisher;
@@ -101,10 +106,10 @@ export class LiveUpdatesHandler {
   }
 
   private setLiveUpdates(toggles: LiveUpdatesToggles) {
-    if (toggles.deviceStats) {
+    if (toggles.deviceStats !== undefined) {
       this.liveUpdatesAlive.device_stats = toggles.deviceStats;
     }
-    if (toggles.appState) {
+    if (toggles.appState !== undefined) {
       this.liveUpdatesAlive.app_state = toggles.appState;
     }
   }
@@ -117,8 +122,7 @@ export class LiveUpdatesHandler {
         appState: false
       });
       this.appLogStreams.clear();
-      // TODO: Make constant, not hard coded
-    }, 600000); // 10 min
+    }, LIVE_UPDATES_TIMEOUT);
   }
 
   private async startPublishingLiveUpdates<T extends any[]>(
@@ -152,6 +156,21 @@ export class LiveUpdatesHandler {
 
   constructor(publisher: Publisher) {
     this.publisher = publisher;
+    logger.debug(
+      `Toggle live updates timeout set to ${LIVE_UPDATES_TIMEOUT} ms`
+    );
+  }
+
+  public getDeviceStatsLiveUpdates() {
+    return this.liveUpdatesAlive.device_stats;
+  }
+
+  public getAppStateLiveUpdates() {
+    return this.liveUpdatesAlive.app_state;
+  }
+
+  public getAppLogsLiveUpdates() {
+    return this.liveUpdatesAlive.app_logs;
   }
 
   public async enableAppInstallStatus(props: {
@@ -184,9 +203,11 @@ export class LiveUpdatesHandler {
   public async handleToggles(toggles: LiveUpdatesToggles) {
     const { deviceStats, appState, appLogs } = toggles;
     this.restartLiveUpdatesTimeout();
+
+    const currentDeviceStats = this.getDeviceStatsLiveUpdates();
     if (deviceStats !== undefined) {
       this.liveUpdatesAlive.device_stats = deviceStats;
-      if (deviceStats) {
+      if (deviceStats && currentDeviceStats !== true) {
         // Don't wait for this call to finish since it loops until disabled
         void this.startPublishingLiveUpdates(
           keyMirrors.agentMessageType.device_stats,
@@ -196,9 +217,10 @@ export class LiveUpdatesHandler {
       }
     }
 
+    const currentAppState = this.getAppStateLiveUpdates();
     if (appState !== undefined) {
       this.liveUpdatesAlive.app_state = appState;
-      if (appState) {
+      if (appState && currentAppState !== true) {
         // Don't wait for this call to finish since it loops until disabled
         void this.startPublishingLiveUpdates(
           keyMirrors.agentMessageType.app_state,
@@ -208,8 +230,9 @@ export class LiveUpdatesHandler {
       }
     }
 
+    const currentAppLogs = this.getAppLogsLiveUpdates();
     if (appLogs !== undefined) {
-      if (appLogs.toggle) {
+      if (appLogs.toggle && currentAppLogs !== true) {
         // Don't wait for this call to finish since it loops until disabled
         void this.startAppLogStream(appLogs.projectId);
       } else {

package/src/cloud-connection/passthrough-handler.ts

@@ -7,6 +7,7 @@ import { Publisher } from './publisher';
 
 const messageQueue: any[] = [];
 const ackQueue: any[] = [];
+const MAX_LOCAL_CONNECTION_ATTEMPTS = 10;
 
 export class PassthroughHandler {
   public publisher: Publisher;
@@ -22,16 +23,22 @@ export class PassthroughHandler {
     await setupRabbitMQContainer();
     let connectAttempts = 0;
     let connected = false;
-    while (connectAttempts <= 10 && this.connection === undefined) {
+    while (
+      connectAttempts <= MAX_LOCAL_CONNECTION_ATTEMPTS &&
+      this.connection === undefined
+    ) {
       try {
         this.connection = await amqp.connect('amqp://localhost');
         this.channel = await this.connection.createChannel();
         connected = true;
       } catch (e) {
+        const timeTillNextAttemptMs = 1000 + 1000 * connectAttempts;
         logger.debug(
-          `Attempting to connect to alwaysAI Local Connection ${connectAttempts}`
+          `Attempted to connect to alwaysAI Local Connection: attempt ${connectAttempts} of ${MAX_LOCAL_CONNECTION_ATTEMPTS}. ${
+            timeTillNextAttemptMs / 1000
+          } seconds until next attempt`
         );
-        await sleep(1000 + 1000 * connectAttempts);
+        await sleep(timeTillNextAttemptMs);
         connectAttempts += 1;
       }
     }