@alwaysai/device-agent 1.5.0 → 2.0.1

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

@@ -1,288 +1,161 @@
-import {
-  AppLogsPayload,
-  keyMirrors,
-  LiveStateUpdatesTogglePayload,
-  ToClientMessage,
-  buildAppLogsMessage,
-  buildAppStateMessage,
-  buildDeviceStatsMessage,
-  StatusResponsePayload,
-  buildToClientStatusResponseMessage,
-  ToClientMessageTypeValue
-} from '@alwaysai/device-agent-schemas';
-import { getAppLogs } from '../application-control';
+import { ToClientMessageTypeValue } from '@alwaysai/device-agent-schemas';
 import { logger } from '../util/logger';
 import sleep from '../util/sleep';
-import { Publisher } from './publisher';
-import { getAppStatePayload, getDeviceStatsPayload } from './messages';
 import { ALWAYSAI_LIVE_UPDATES_TIMEOUT_MS } from '../environment';
+import { stringifyError } from 'alwaysai/lib/util';
 
-const LIVE_UPDATES_TIMEOUT = ALWAYSAI_LIVE_UPDATES_TIMEOUT_MS
+const KILL_ALL_TIMEOUT_MS = ALWAYSAI_LIVE_UPDATES_TIMEOUT_MS
   ? parseInt(ALWAYSAI_LIVE_UPDATES_TIMEOUT_MS)
   : 80000;
 
+export const DEFAULT_INTERVALS_MS = 5000;
+
+interface IntervalOptions {
+  ms?: number;
+}
+
 export class LiveUpdatesHandler {
-  private publisher: Publisher;
-  private clientId: string;
+  private killAllTimeout: ReturnType<typeof setTimeout>;
+  private livingIntervals: Record<string, ReturnType<typeof setInterval>> = {};
+  private livingStreams = new Set<string>();
 
-  private liveUpdatesTimeout: ReturnType<typeof setTimeout>;
-  private liveUpdatesAlive = {
-    [keyMirrors.toClientMessageType.device_stats]: false,
-    [keyMirrors.toClientMessageType.app_state]: false,
-    [keyMirrors.toClientMessageType.app_logs]: false,
-    [keyMirrors.toClientMessageType.status_response]: false
-  };
-  private liveUpdatesSleepIntervals = {
-    [keyMirrors.toClientMessageType.device_stats]: 5000,
-    [keyMirrors.toClientMessageType.app_state]: 5000,
-    [keyMirrors.toClientMessageType.app_logs]: 5000,
-    [keyMirrors.toClientMessageType.status_response]: 5000
-  };
+  constructor() {
+    logger.debug(
+      `Toggle live updates timeout set to ${KILL_ALL_TIMEOUT_MS} ms`
+    );
+  }
 
-  private appLogStreams = new Set<string>();
-  private transactionStatuses = new Set<string>();
+  public async enable(
+    intervalType: ToClientMessageTypeValue,
+    publishingFn: () => Promise<void>,
+    transactionId?: string,
+    options?: IntervalOptions
+  ) {
+    this.restartKillAllTimeout();
 
-  private async getAppLogsWithRetry(
-    projectId: string
-  ): Promise<NodeJS.ReadableStream | null> {
-    // Retry starting logs until it starts successfully or is terminated
-    while (this.appLogStreams.has(projectId)) {
-      try {
-        return await getAppLogs({
-          projectId,
-          args: ['--tail', '100', '--no-log-prefix']
-        });
-      } catch (e) {
-        logger.info(
-          `Failed to start app logs, retrying in 1 second. Error: ${e}`
-        );
-        await sleep(1000);
-      }
-    }
-    // Case where logs were disabled prior to connecting
-    return null;
+    const key = this.generateIntervalKey(intervalType, transactionId);
+
+    this.safeSetInterval(key, publishingFn, options);
+
+    await publishingFn();
   }
 
-  private async startAppLogStream(projectId: string, txId: string) {
+  public disable(
+    intervalType: ToClientMessageTypeValue,
+    transactionId?: string
+  ) {
+    const key = this.generateIntervalKey(intervalType, transactionId);
+    clearInterval(this.livingIntervals[key]);
+    delete this.livingIntervals[key];
+  }
+
+  public async startStream(
+    projectId: string,
+    streamGetter: () => Promise<NodeJS.ReadableStream | null>,
+    publishingFn: (logChunk: string) => void
+  ) {
     logger.info(`Starting log stream for ${projectId}`);
 
-    this.appLogStreams.add(projectId);
+    this.livingStreams.add(projectId);
 
-    const readable = await this.getAppLogsWithRetry(projectId);
+    const readable = await this.getStreamWithRetry(projectId, streamGetter);
 
     if (readable === null) {
       logger.info(
-        `App log stream terminated for project ${projectId} prior to starting`
+        `Stream terminated prior to starting. Readable stream is null. ProjectId: ${projectId}`
       );
       return;
     }
 
     readable.on('data', async (chunk: Buffer) => {
-      if (!this.appLogStreams.has(projectId)) {
+      if (!this.livingStreams.has(projectId)) {
         // why doesn't typescript know about this function?
         // @ts-ignore
         readable.destroy();
-        logger.info(`App log stream terminated for project ${projectId}`);
+        logger.info(`Stream terminated. ProjectId: ${projectId}`);
         return;
       }
-      const logStr = chunk.toString();
-      const payload: AppLogsPayload = {
-        projectId,
-        logChunk: logStr
-      };
-      const message = buildAppLogsMessage(this.clientId, payload, txId);
-      this.publisher.publishToClient(message, logger.silly);
+
+      publishingFn(chunk.toString());
     });
 
     readable.on('error', (error) => {
-      logger.error(
-        `App log stream terminated for project ${projectId}: ${error}`
-      );
+      logger.error(`Stream terminated. ProjectId: ${projectId} - ${error}`);
     });
 
     readable.on('finished', () => {
-      logger.info(`App logs finished piping for project ${projectId}`);
+      logger.info(`Strean complete. ProjectId: ${projectId}`);
     });
   }
 
-  private continuePublishing(
-    flag: ToClientMessageTypeValue,
-    txId?: string
-  ): boolean {
-    switch (flag) {
-      case keyMirrors.toClientMessageType.device_stats:
-      case keyMirrors.toClientMessageType.app_state:
-        return this.liveUpdatesAlive[flag];
-      case keyMirrors.toClientMessageType.status_response: {
-        if (!txId) {
-          throw new Error(`Transaction ID not provided to continuePublishing!`);
-        }
-        return this.transactionStatuses.has(txId);
-      }
-      default:
-        logger.error(`Unrecognized publishable flag ${flag}`);
-        return false;
-    }
-  }
-
-  private getLiveUpdatesInterval(flag: ToClientMessageTypeValue): number {
-    const exists = this.liveUpdatesSleepIntervals[flag];
-    if (exists) {
-      return exists;
-    }
-    logger.error(`Unrecognized live updates flag ${flag}`);
-    return -1;
+  public stopStream(streamId: string) {
+    this.livingStreams.delete(streamId);
   }
 
-  private restartLiveUpdatesTimeout() {
-    clearTimeout(this.liveUpdatesTimeout);
-    this.liveUpdatesTimeout = setTimeout(() => {
-      this.disableAppStateLiveUpdates();
-      this.disableDeviceStatsLiveUpdates();
-      this.appLogStreams.clear();
-    }, LIVE_UPDATES_TIMEOUT);
-  }
+  /*=================================================================
+                            Private interface
+  =================================================================*/
 
-  private async startPublishingLiveUpdates(
-    messageType: ToClientMessageTypeValue,
-    getMessage: () => Promise<ToClientMessage>,
-    txId: string
-  ) {
-    logger.info(`Turned on live updates for ${messageType}`);
-    while (this.continuePublishing(messageType, txId)) {
+  private async getStreamWithRetry(
+    streamId: string,
+    streamGetter: () => Promise<NodeJS.ReadableStream | null>
+  ): Promise<NodeJS.ReadableStream | null> {
+    // Retry starting logs until it starts successfully or is terminated
+    while (this.livingStreams.has(streamId)) {
       try {
-        const message = await getMessage();
-        this.publisher.publishToClient(message, logger.silly);
-
-        await sleep(this.getLiveUpdatesInterval(messageType));
+        return await streamGetter();
       } catch (e) {
-        logger.error(
-          `Error publishing live updates for ${messageType}: ${e.message}`
+        logger.info(
+          `Failed to start app logs, retrying in 1 second.\n${stringifyError(
+            e
+          )}`
         );
+        await sleep(1000);
       }
     }
-    logger.info(`Turned off live updates for ${messageType}`);
+    // Case where logs were disabled prior to connecting
+    return null;
   }
 
-  /*=================================================================
-                            Public interface
-  =================================================================*/
-
-  constructor(publisher: Publisher, clientId: string) {
-    this.publisher = publisher;
-    this.clientId = clientId;
-    logger.debug(
-      `Toggle live updates timeout set to ${LIVE_UPDATES_TIMEOUT} ms`
+  // do not await any functions in the setSafeInterval other than inside setInterval()  as per EI-1694.
+  private safeSetInterval(
+    key: string,
+    publishingFn: () => Promise<void>,
+    options?: IntervalOptions
+  ) {
+    clearInterval(this.livingIntervals[key]);
+
+    this.livingIntervals[key] = setInterval(
+      async () => {
+        try {
+          await publishingFn();
+        } catch (e) {
+          logger.error(
+            `Error getting live updates: ${JSON.stringify(
+              e
+            )}: intervalKey: ${key}. Continuing...`
+          );
+        }
+      },
+      options?.ms ? options.ms : DEFAULT_INTERVALS_MS
     );
   }
 
-  public getDeviceStatsLiveUpdates(): boolean {
-    return this.liveUpdatesAlive.device_stats;
-  }
-
-  public disableDeviceStatsLiveUpdates() {
-    logger.info('Disabled live updates for device_stats');
-    this.liveUpdatesAlive.device_stats = false;
-  }
-
-  public getAppStateLiveUpdates(): boolean {
-    return this.liveUpdatesAlive.app_state;
-  }
-
-  public disableAppStateLiveUpdates() {
-    logger.info('Disabled live updates for app_state');
-    this.liveUpdatesAlive.app_state = false;
-  }
-
-  public getAppLogsLiveUpdates() {
-    return this.liveUpdatesAlive.app_logs;
-  }
-
-  public async enableTransactionStatus(props: { txId: string }) {
-    const { txId } = props;
-    this.liveUpdatesAlive.status_response = true;
-    if (!this.transactionStatuses.has(txId)) {
-      this.transactionStatuses.add(txId);
-      // Don't wait for this call to finish since it loops until disabled
-      void this.startPublishingLiveUpdates(
-        keyMirrors.toClientMessageType.status_response,
-        async () => {
-          const payload: StatusResponsePayload = {
-            status: keyMirrors.statusResponse.in_progress
-          };
-          return buildToClientStatusResponseMessage(
-            this.clientId,
-            payload,
-            txId
-          );
-        },
-        txId
+  private restartKillAllTimeout() {
+    clearTimeout(this.killAllTimeout);
+    this.killAllTimeout = setTimeout(() => {
+      Object.values(this.livingIntervals).forEach((interval) =>
+        clearInterval(interval)
       );
-    }
-  }
-
-  public async disableTransactionStatus(props: { txId: string }) {
-    const { txId } = props;
-    this.transactionStatuses.delete(txId);
-
-    if (this.transactionStatuses.size === 0) {
-      this.liveUpdatesAlive.status_response = false;
-    }
+      this.livingIntervals = {};
+      this.livingStreams.clear();
+    }, KILL_ALL_TIMEOUT_MS);
   }
 
-  public async handleToggles(
-    toggles: LiveStateUpdatesTogglePayload,
-    txId: string
-  ) {
-    const { deviceStats, appState, appLogs } = toggles;
-    this.restartLiveUpdatesTimeout();
-
-    const promises: Promise<void>[] = [];
-
-    if (deviceStats !== undefined) {
-      const currentDeviceStats = this.getDeviceStatsLiveUpdates();
-      this.liveUpdatesAlive.device_stats = deviceStats;
-      if (deviceStats && currentDeviceStats !== true) {
-        // Don't wait for this call to finish since it loops until disabled
-        const deviceStatsPromise = this.startPublishingLiveUpdates(
-          keyMirrors.toClientMessageType.device_stats,
-          async () => {
-            const payload = await getDeviceStatsPayload();
-            return buildDeviceStatsMessage(this.clientId, payload, txId);
-          },
-          txId
-        );
-        promises.push(deviceStatsPromise);
-      }
-    }
-
-    if (appState !== undefined) {
-      const currentAppState = this.getAppStateLiveUpdates();
-      this.liveUpdatesAlive.app_state = appState;
-      if (appState && currentAppState !== true) {
-        // Don't wait for this call to finish since it loops until disabled
-        const appStatePromise = this.startPublishingLiveUpdates(
-          keyMirrors.toClientMessageType.app_state,
-          async () => {
-            const payload = await getAppStatePayload();
-            return buildAppStateMessage(this.clientId, payload, txId);
-          },
-          txId
-        );
-        promises.push(appStatePromise);
-      }
-    }
-
-    if (appLogs !== undefined) {
-      const currentAppLogs = this.getAppLogsLiveUpdates();
-      if (appLogs.toggle && currentAppLogs !== true) {
-        // Don't wait for this call to finish since it loops until disabled
-        const appLogPromise = this.startAppLogStream(appLogs.projectId, txId);
-        promises.push(appLogPromise);
-      } else {
-        this.appLogStreams.delete(appLogs.projectId);
-      }
-    }
-    return promises;
+  private generateIntervalKey(
+    intervalType: ToClientMessageTypeValue,
+    transactionId?: string
+  ): string {
+    return intervalType + `${transactionId ? ':' + transactionId : ''}`;
   }
 }

package/src/cloud-connection/message-dispatcher.ts

@@ -0,0 +1,33 @@
+import { logger } from '../util/logger';
+
+export interface MessageHandler<T = any> {
+  handle(payload: T, topic?: string): void;
+}
+
+export class MessageDispatcher<T = any> {
+  private handlers: Map<string, MessageHandler<T>> = new Map();
+
+  public registerHandler(topic: string, handler: MessageHandler): void {
+    this.handlers.set(topic, handler);
+  }
+
+  public dispatch(topic: string, payload: T): void {
+    const handler = this.handlers.get(topic);
+    if (handler) {
+      handler.handle(payload, topic);
+    } else {
+      this.handleUnknownMessage(topic, payload);
+    }
+  }
+
+  // Handle unknown or unregistered message topic
+  private handleUnknownMessage(topic: string, payload: T): void {
+    logger.error(
+      `No handler found for topic/type: ${topic} for message ${JSON.stringify(
+        payload,
+        null,
+        2
+      )}`
+    );
+  }
+}

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

@@ -1,16 +1,23 @@
+import {
+  DeviceAgentStatusShadowUpdate,
+  PassthroughStatusValue
+} from '@alwaysai/device-agent-schemas/lib/shadow-schema';
+import { stringifyError } from 'alwaysai/lib/util';
 import * as amqp from 'amqplib';
+import { ALWAYSAI_ANALYTICS_PASSTHROUGH } from '../environment';
 import {
   LOCAL_CONNECTION_HOST,
   LOCAL_CONNECTION_PORT,
   LOCAL_CONNECTION_ROUTING_KEY
 } from '../local-connection/constants';
 import {
-  stopRabbitMQContainer,
-  setupRabbitMQContainer
+  setupRabbitMQContainer,
+  stopRabbitMQContainer
 } from '../local-connection/rabbitmq-connection';
 import { logger } from '../util/logger';
 import sleep from '../util/sleep';
 import { Publisher } from './publisher';
+import { ShadowHandler } from './shadow-handler';
 
 const messageQueue: any[] = [];
 const ackQueue: any[] = [];
@@ -18,12 +25,14 @@ const MAX_LOCAL_CONNECTION_ATTEMPTS = 10;
 
 export class PassthroughHandler {
   public publisher: Publisher;
+  public shadowHandler: ShadowHandler;
   public connection: amqp.Connection | undefined;
   public channel: amqp.Channel;
   public packetQueue;
 
-  constructor(publisher: Publisher) {
+  constructor(publisher: Publisher, shadowHandler: ShadowHandler) {
     this.publisher = publisher;
+    this.shadowHandler = shadowHandler;
   }
 
   runChannel = async () => {
@@ -79,9 +88,13 @@ export class PassthroughHandler {
                 );
               }
             } catch (e) {
-              logger.error(`There was a problem parsing RabbitMQ packet ${e}`);
+              logger.error(
+                `There was a problem parsing RabbitMQ packet!\n${stringifyError(
+                  e
+                )}`
+              );
               this.channel.ack(msg);
-              logger.debug(`Problematic packet was acknowledged`);
+              logger.debug('Problematic packet was acknowledged');
             }
           }
         }
@@ -138,21 +151,45 @@ export class PassthroughHandler {
     }
   }
 
-  public async setup() {
-    logger.debug(
-      `Setting up alwaysAI Local Connection on host: ${LOCAL_CONNECTION_HOST} and channel key: ${LOCAL_CONNECTION_ROUTING_KEY}`
+  private async publishPassthroughStatusUpdate(
+    status: PassthroughStatusValue,
+    message?: string
+  ) {
+    const deviceAgentPassthroughStatus: DeviceAgentStatusShadowUpdate = {
+      passthrough: {
+        status: status,
+        message: message ?? ''
+      }
+    };
+    await this.shadowHandler.updateDeviceAgentStatusShadow(
+      deviceAgentPassthroughStatus
     );
-    await setupRabbitMQContainer();
-    try {
-      await this.establishLocalConnection();
-      await this.runChannel();
-    } catch (error) {
-      logger.error(
-        `There was a problem maintaining RabbitMQ connection: ${error}`
-      );
-      throw new Error(
-        `There was a problem maintaining RabbitMQ connection: ${error}`
+  }
+
+  async setup() {
+    if (ALWAYSAI_ANALYTICS_PASSTHROUGH === true) {
+      logger.debug(
+        `Setting up alwaysAI Local Connection on host: ${LOCAL_CONNECTION_HOST} and channel key: ${LOCAL_CONNECTION_ROUTING_KEY}`
       );
+      await this.publishPassthroughStatusUpdate('starting');
+      await setupRabbitMQContainer();
+      try {
+        await this.establishLocalConnection();
+        await this.runChannel();
+        await this.publishPassthroughStatusUpdate(
+          'running',
+          `Passthrough running on host: ${LOCAL_CONNECTION_HOST} and channel key: ${LOCAL_CONNECTION_ROUTING_KEY}`
+        );
+      } catch (e) {
+        logger.error(
+          `There was a problem maintaining RabbitMQ connection!\n${stringifyError(
+            e
+          )}`
+        );
+        await this.publishPassthroughStatusUpdate('error', stringifyError(e));
+      }
+    } else {
+      await this.publishPassthroughStatusUpdate('disabled');
     }
   }
 }