@alwaysai/device-agent 1.4.0 → 2.0.0

package/src/cloud-connection/device-agent.ts

@@ -1,16 +1,20 @@
 // eslint-disable-next-line
 const awsIot = require('aws-iot-device-sdk');
+import { getTargetHardwareUuid } from 'alwaysai/lib/core/app';
 import {
+  DEVICE_CERTIFICATE_FILE_NAME,
+  DEVICE_CERTIFICATE_ID_FILE_NAME,
   DEVICE_PRIVATE_KEY_FILE_NAME,
+  LOCAL_CERT_AND_KEY_DIR
+} from 'alwaysai/lib/infrastructure';
+import { JsSpawner } from 'alwaysai/lib/util';
+import {
   CERTIFICATE_OWNERSHIP_TOKEN_FILE_NAME,
-  DEVICE_ID_FILE_NAME,
-  DEVICE_CERTIFICATE_FILE_NAME
-} from '../util/directories';
+  getBootstrapCertificateDirectoryPath
+} from '../infrastructure/device-certificate';
 import { getDeviceUuid } from '../util/get-device-id';
-import { JsSpawner } from 'alwaysai/lib/util';
 import { logger } from '../util/logger';
-import { getTargetHardwareUuid } from 'alwaysai/lib/core/app';
-import { LOCAL_CERT_AND_KEY_DIR } from 'alwaysai/lib/paths';
+
 // eslint-disable-next-line
 const process = require('process');
 
@@ -85,7 +89,10 @@ export class BootstrapAgent extends DeviceAgent {
 
         await certSpawner.writeFile(DEVICE_PRIVATE_KEY_FILE_NAME, privateKey);
 
-        await certSpawner.writeFile(DEVICE_ID_FILE_NAME, certificateId);
+        await certSpawner.writeFile(
+          DEVICE_CERTIFICATE_ID_FILE_NAME,
+          certificateId
+        );
 
         await certSpawner.writeFile(
           CERTIFICATE_OWNERSHIP_TOKEN_FILE_NAME,
@@ -111,6 +118,8 @@ export class BootstrapAgent extends DeviceAgent {
       }
       case '$aws/provisioning-templates/FleetProvisionTemplate/provision/json/accepted': {
         logger.info('Device agent provisioning: success');
+        const spawner = JsSpawner();
+        await spawner.rimraf(getBootstrapCertificateDirectoryPath());
         process.exit();
       }
     }

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

@@ -1,89 +1,162 @@
-import { LiveUpdatesHandler } from './live-updates-handler';
-import { Publisher } from './publisher';
-
-global.setTimeout = jest.fn() as unknown as typeof setTimeout;
+import {
+  DEFAULT_INTERVALS_MS,
+  LiveUpdatesHandler
+} from './live-updates-handler';
+import { keyMirrors } from '@alwaysai/device-agent-schemas';
+import { randomUUID } from 'crypto';
+import { PassThrough } from 'stream';
+
+jest.mock('../util/sleep');
+jest.mock('./messages');
+jest.useFakeTimers();
 
 // https://github.com/facebook/react-native/issues/35701
 Object.defineProperty(global, 'performance', {
   writable: true
 });
 
-const testTrueToggles = {
-  deviceStats: true,
-  appState: true
-};
-
-const testFalseToggles = {
-  deviceStats: false,
-  appState: false
-};
-
-const mockClient = jest.fn();
-const clientId = 'test-client';
-const emptyTxId = '';
-
-// NOTE: this was the way I found to mock private class functions
-const mockStartPublishingLiveUpdates = jest.spyOn(
-  LiveUpdatesHandler.prototype as any,
-  'startPublishingLiveUpdates'
-);
-mockStartPublishingLiveUpdates.mockResolvedValue(null);
+const mockTransactionId = '9b1deb4d-3b7d-4bad-9bdd-2b0d7b3dcb6d';
+const mockProjectId = '12345678-abcd-abcd-abcd-0123456789ab';
 
 describe('Test Live Updates Handler', () => {
   let liveUpdatesHandler: LiveUpdatesHandler;
-  let publisher: Publisher;
 
   beforeEach(() => {
-    publisher = new Publisher(mockClient, clientId);
-    liveUpdatesHandler = new LiveUpdatesHandler(publisher, clientId);
+    liveUpdatesHandler = new LiveUpdatesHandler();
     jest.clearAllMocks();
   });
 
-  test('ignore subsequent enables', async () => {
-    void liveUpdatesHandler.handleToggles(testTrueToggles, emptyTxId);
-    // called twice, once for device stats, once for app state
-    expect(mockStartPublishingLiveUpdates).toBeCalledTimes(2);
-    // restartLiveUpdatesTimeout is always called once when handleToggles is called
-    expect(jest.mocked(setTimeout)).toBeCalledTimes(1);
+  test('enable interval', async () => {
+    const mockPublishingFn = jest.fn();
+    const mockClearInterval = jest.spyOn(global, 'clearInterval');
+    const mockSetInterval = jest.spyOn(global, 'setInterval');
 
-    // Second call -> should not call startPublishingLiveUpdates should not be called
-    jest.clearAllMocks();
-    void liveUpdatesHandler.handleToggles(testTrueToggles, emptyTxId);
-    expect(mockStartPublishingLiveUpdates).toBeCalledTimes(0);
-    expect(jest.mocked(setTimeout)).toHaveBeenCalledTimes(1);
+    await liveUpdatesHandler.enable(
+      keyMirrors.toClientMessageType.device_stats,
+      mockPublishingFn
+    );
+
+    jest.advanceTimersByTime(DEFAULT_INTERVALS_MS);
+
+    expect(mockPublishingFn).toBeCalledTimes(2);
+    expect(mockClearInterval).toBeCalledWith(undefined);
+    expect(mockSetInterval).toBeCalledTimes(1);
+  });
+
+  test('subsequent enable resets interval with no duplicates', async () => {
+    const mockPublishingFn = jest.fn();
+    const mockSetInterval = jest.spyOn(global, 'setInterval');
+    const mockClearInterval = jest.spyOn(global, 'clearInterval');
+
+    await liveUpdatesHandler.enable(
+      keyMirrors.toClientMessageType.device_stats,
+      mockPublishingFn,
+      mockTransactionId
+    );
+    await liveUpdatesHandler.enable(
+      keyMirrors.toClientMessageType.device_stats,
+      mockPublishingFn,
+      mockTransactionId
+    );
+
+    jest.advanceTimersByTime(DEFAULT_INTERVALS_MS);
+
+    expect(mockClearInterval.mock.calls[0][0]).toEqual(undefined);
+    expect(mockClearInterval.mock.calls[1][0]).toEqual(
+      mockSetInterval.mock.results[0].value
+    );
+    expect(mockSetInterval).toBeCalledTimes(2);
+    expect(mockPublishingFn).toBeCalledTimes(3);
   });
 
   test('test disable live updates', async () => {
-    // Test calling handleToggles one time, enabling it
-    void liveUpdatesHandler.handleToggles(testTrueToggles, emptyTxId);
-    expect(mockStartPublishingLiveUpdates).toBeCalledTimes(2);
-    expect(jest.mocked(setTimeout)).toHaveBeenCalledTimes(1);
-    expect(liveUpdatesHandler.getDeviceStatsLiveUpdates()).toBe(true);
-    expect(liveUpdatesHandler.getAppStateLiveUpdates()).toBe(true);
-    expect(liveUpdatesHandler.getAppLogsLiveUpdates()).toBe(false);
-
-    // Check to see that attributes are properly set to false when disabled
-    jest.clearAllMocks();
-    void liveUpdatesHandler.handleToggles(testFalseToggles, emptyTxId);
-    expect(mockStartPublishingLiveUpdates).toBeCalledTimes(0);
-    expect(jest.mocked(setTimeout)).toHaveBeenCalledTimes(1);
-    expect(liveUpdatesHandler.getDeviceStatsLiveUpdates()).toBe(false);
-    expect(liveUpdatesHandler.getAppStateLiveUpdates()).toBe(false);
-    expect(liveUpdatesHandler.getAppLogsLiveUpdates()).toBe(false);
+    const mockSetInterval = jest.spyOn(global, 'setInterval');
+    const mockClearInterval = jest.spyOn(global, 'clearInterval');
+
+    await liveUpdatesHandler.enable(
+      keyMirrors.toClientMessageType.device_stats,
+      async () => undefined,
+      mockTransactionId
+    );
+    liveUpdatesHandler.disable(
+      keyMirrors.toClientMessageType.device_stats,
+      mockTransactionId
+    );
+
+    expect(mockClearInterval).toHaveBeenLastCalledWith(
+      mockSetInterval.mock.results[0].value
+    );
   });
 
-  test('timeout turns off live updates', async () => {
-    jest.useFakeTimers({ legacyFakeTimers: true });
+  test('kill all timeout turns off all live updates', async () => {
+    const mockPublishingFn = jest.fn();
+    const mockSetInterval = jest.spyOn(global, 'setInterval');
+    const mockClearInterval = jest.spyOn(global, 'clearInterval');
+    jest.spyOn(global, 'setTimeout');
+
+    const numLivingIntervals = 5;
+    for (let i = 0; i < numLivingIntervals; i++) {
+      await liveUpdatesHandler.enable(
+        keyMirrors.toClientMessageType.status_response,
+        mockPublishingFn,
+        randomUUID()
+      );
+    }
+
+    mockSetInterval.mock.results.forEach((result) =>
+      clearInterval(result.value)
+    );
+    jest.runAllTimers();
 
-    void liveUpdatesHandler.handleToggles(testTrueToggles, emptyTxId);
-    expect(liveUpdatesHandler.getDeviceStatsLiveUpdates()).toBe(true);
-    expect(liveUpdatesHandler.getAppStateLiveUpdates()).toBe(true);
-    expect(liveUpdatesHandler.getAppLogsLiveUpdates()).toBe(false);
+    expect(mockPublishingFn).toBeCalledTimes(numLivingIntervals);
+    expect(mockSetInterval).toBeCalledTimes(numLivingIntervals);
+    for (let i = 0; i < numLivingIntervals; i++) {
+      expect(mockClearInterval).toHaveBeenCalledWith(
+        mockSetInterval.mock.results[i].value
+      );
+    }
+  });
 
-    jest.runAllTimers();
+  test('startStream streams data to publish', async () => {
+    const mockStream = new PassThrough();
+    const mockPublishingFn = jest
+      .fn()
+      .mockImplementation((logChunk: string) => undefined);
+
+    await liveUpdatesHandler.startStream(
+      mockProjectId,
+      async () => mockStream,
+      mockPublishingFn
+    );
+
+    const data = 'Data for stream';
+    mockStream.emit('data', data);
+
+    expect(mockPublishingFn).toBeCalledWith(data);
+
+    mockStream.end();
+    mockStream.destroy();
+  });
 
-    expect(liveUpdatesHandler.getDeviceStatsLiveUpdates()).toBe(false);
-    expect(liveUpdatesHandler.getAppStateLiveUpdates()).toBe(false);
-    expect(liveUpdatesHandler.getAppLogsLiveUpdates()).toBe(false);
+  test('failure does not disable interval', async () => {
+    const mockPublishingFn = jest
+      .fn()
+      .mockImplementationOnce(() => undefined)
+      .mockImplementation(() => {
+        throw new Error('Manual throw for unit test');
+      });
+    jest.spyOn(global, 'setInterval');
+    const mockClearInterval = jest.spyOn(global, 'clearInterval');
+
+    await liveUpdatesHandler.enable(
+      keyMirrors.toClientMessageType.device_stats,
+      mockPublishingFn,
+      mockTransactionId
+    );
+
+    jest.advanceTimersByTime(DEFAULT_INTERVALS_MS);
+
+    expect(mockClearInterval).toBeCalledTimes(1);
+    expect(mockPublishingFn).toBeCalledTimes(2);
   });
 });

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

@@ -1,284 +1,153 @@
-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 { read } from 'fs';
+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)
-  : 60000;
+  : 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);
+
+    clearInterval(this.livingIntervals[key]);
+
+    // initial publish
+    await publishingFn();
+
+    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 disable(
+    intervalType: ToClientMessageTypeValue,
+    transactionId?: string
+  ) {
+    const key = this.generateIntervalKey(intervalType, transactionId);
+    clearInterval(this.livingIntervals[key]);
+    delete this.livingIntervals[key];
   }
 
-  private async startAppLogStream(projectId: string, txId: string) {
+  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;
-  }
-
-  private setLiveUpdates(toggles: LiveStateUpdatesTogglePayload) {
-    if (toggles.deviceStats !== undefined) {
-      this.liveUpdatesAlive.device_stats = toggles.deviceStats;
-    }
-    if (toggles.appState !== undefined) {
-      this.liveUpdatesAlive.app_state = toggles.appState;
-    }
-  }
-
-  private restartLiveUpdatesTimeout() {
-    clearTimeout(this.liveUpdatesTimeout);
-    this.liveUpdatesTimeout = setTimeout(() => {
-      this.setLiveUpdates({
-        deviceStats: false,
-        appState: false
-      });
-      this.appLogStreams.clear();
-    }, LIVE_UPDATES_TIMEOUT);
-  }
-
-  private async startPublishingLiveUpdates(
-    messageType: ToClientMessageTypeValue,
-    getMessage: () => Promise<ToClientMessage>,
-    txId: string
-  ) {
-    logger.info(`Turned on live updates for ${messageType}`);
-    try {
-      while (this.continuePublishing(messageType, txId)) {
-        const message = await getMessage();
-        this.publisher.publishToClient(message, logger.silly);
-
-        await sleep(this.getLiveUpdatesInterval(messageType));
-      }
-    } catch (e) {
-      logger.error(
-        `Error publishing live updates for ${messageType}: ${e.message}`
-      );
-    }
-    logger.info(`Turned off live updates for ${messageType}`);
+  public stopStream(streamId: string) {
+    this.livingStreams.delete(streamId);
   }
 
   /*=================================================================
-                            Public interface
+                            Private interface
   =================================================================*/
 
-  constructor(publisher: Publisher, clientId: string) {
-    this.publisher = publisher;
-    this.clientId = clientId;
-    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 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 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 {
+        return await streamGetter();
+      } catch (e) {
+        logger.info(
+          `Failed to start app logs, retrying in 1 second.\n${stringifyError(
+            e
+          )}`
+        );
+        await sleep(1000);
+      }
     }
+    // Case where logs were disabled prior to connecting
+    return null;
   }
 
-  public async disableTransactionStatus(props: { txId: string }) {
-    const { txId } = props;
-    this.transactionStatuses.delete(txId);
-
-    if (this.transactionStatuses.size === 0) {
-      this.liveUpdatesAlive.status_response = false;
-    }
+  private restartKillAllTimeout() {
+    clearTimeout(this.killAllTimeout);
+    this.killAllTimeout = setTimeout(() => {
+      Object.values(this.livingIntervals).forEach((interval) =>
+        clearInterval(interval)
+      );
+      this.livingIntervals = {};
+      this.livingStreams.clear();
+    }, KILL_ALL_TIMEOUT_MS);
   }
 
-  public async handleToggles(
-    toggles: LiveStateUpdatesTogglePayload,
-    txId: string
+  private generateIntervalKey(
+    intervalType: ToClientMessageTypeValue,
+    transactionId?: string
   ) {
-    const { deviceStats, appState, appLogs } = toggles;
-    this.restartLiveUpdatesTimeout();
-
-    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
-        void this.startPublishingLiveUpdates(
-          keyMirrors.toClientMessageType.device_stats,
-          async () => {
-            const payload = await getDeviceStatsPayload();
-            return buildDeviceStatsMessage(this.clientId, payload, txId);
-          },
-          txId
-        );
-      }
-    }
-
-    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
-        void this.startPublishingLiveUpdates(
-          keyMirrors.toClientMessageType.app_state,
-          async () => {
-            const payload = await getAppStatePayload();
-            return buildAppStateMessage(this.clientId, payload, txId);
-          },
-          txId
-        );
-      }
-    }
-
-    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
-        void this.startAppLogStream(appLogs.projectId, txId);
-      } else {
-        this.appLogStreams.delete(appLogs.projectId);
-      }
-    }
+    return intervalType + `${transactionId ? ':' + transactionId : ''}`;
   }
 }