Add LiveTail StatusBarItems

Author: Keegan Irby

packages/core/src/awsService/cloudWatchLogs/commands/tailLogGroup.ts

@@ -8,8 +8,12 @@ import { TailLogGroupWizard } from '../wizard/tailLogGroupWizard'
 import { CancellationError } from '../../../shared/utilities/timeoutUtils'
 import { LiveTailSession, LiveTailSessionConfiguration } from '../registry/liveTailSession'
 import { LiveTailSessionRegistry } from '../registry/liveTailSessionRegistry'
-import { LiveTailSessionLogEvent, StartLiveTailResponseStream } from '@aws-sdk/client-cloudwatch-logs'
-import { ToolkitError } from '../../../shared'
+import {
+    LiveTailSessionLogEvent,
+    LiveTailSessionUpdate,
+    StartLiveTailResponseStream,
+} from '@aws-sdk/client-cloudwatch-logs'
+import { convertToTimeString, globals, ToolkitError } from '../../../shared'
 
 export async function tailLogGroup(
     registry: LiveTailSessionRegistry,
@@ -35,13 +39,17 @@ export async function tailLogGroup(
     registry.set(session.uri, session)
 
     const document = await prepareDocument(session)
-    registerTabChangeCallback(session, registry, document)
+    const timer = startSessionTimer(session)
+    hideShowStatusBarItemsOnActiveEditor(session, document)
+    registerTabChangeCallback(session, registry, document, timer)
+
     const stream = await session.startLiveTailSession()
 
-    await handleSessionStream(stream, document, session)
+    await handleSessionStream(stream, document, session, timer)
 }
 
-export function closeSession(sessionUri: vscode.Uri, registry: LiveTailSessionRegistry) {
+export function closeSession(sessionUri: vscode.Uri, registry: LiveTailSessionRegistry, timer: NodeJS.Timer) {
+    globals.clock.clearInterval(timer)
     const session = registry.get(sessionUri)
     if (session === undefined) {
         throw new ToolkitError(`No LiveTail session found for URI: ${sessionUri.toString()}`)
@@ -63,27 +71,35 @@ async function prepareDocument(session: LiveTailSession): Promise<vscode.TextDoc
     await clearDocument(textDocument)
     await vscode.window.showTextDocument(textDocument, { preview: false })
     await vscode.languages.setTextDocumentLanguage(textDocument, 'log')
+    session.showStatusBarItems()
     return textDocument
 }
 
 async function handleSessionStream(
     stream: AsyncIterable<StartLiveTailResponseStream>,
     document: vscode.TextDocument,
-    session: LiveTailSession
+    session: LiveTailSession,
+    timer: NodeJS.Timer
 ) {
-    for await (const event of stream) {
-        if (event.sessionUpdate !== undefined && event.sessionUpdate.sessionResults !== undefined) {
-            const formattedLogEvents = event.sessionUpdate.sessionResults.map<string>((logEvent) =>
-                formatLogEvent(logEvent)
-            )
-            if (formattedLogEvents.length !== 0) {
-                //Determine should scroll before adding new lines to doc because adding large
-                //amount of new lines can push bottom of file out of view before scrolling.
-                const editorsToScroll = getTextEditorsToScroll(document)
-                await updateTextDocumentWithNewLogEvents(formattedLogEvents, document, session.maxLines)
-                editorsToScroll.forEach(scrollTextEditorToBottom)
+    try {
+        for await (const event of stream) {
+            if (event.sessionUpdate !== undefined && event.sessionUpdate.sessionResults !== undefined) {
+                const formattedLogEvents = event.sessionUpdate.sessionResults.map<string>((logEvent) =>
+                    formatLogEvent(logEvent)
+                )
+                if (formattedLogEvents.length !== 0) {
+                    //Determine should scroll before adding new lines to doc because adding large
+                    //amount of new lines can push bottom of file out of view before scrolling.
+                    const editorsToScroll = getTextEditorsToScroll(document)
+                    await updateTextDocumentWithNewLogEvents(formattedLogEvents, document, session.maxLines)
+                    editorsToScroll.forEach(scrollTextEditorToBottom)
+                }
+                updateStatusBarItemsOnStreamEvent(session, event.sessionUpdate)
             }
         }
+    } catch (err) {
+        globals.clock.clearInterval(timer)
+        throw err
     }
 }
 
@@ -147,6 +163,52 @@ function trimOldestLines(
     edit.delete(document.uri, range)
 }
 
+function updateStatusBarItemsOnStreamEvent(session: LiveTailSession, event: LiveTailSessionUpdate) {
+    updateIsSampledStatusBar(session.statusBarItems.isSampled, event)
+    updateEventRateStatusBar(session.statusBarItems.eventRate, event)
+}
+
+function updateIsSampledStatusBar(isSampledStatusBarItem: vscode.StatusBarItem, event: LiveTailSessionUpdate) {
+    let isSampled: boolean
+    //sessionMetadata is expected to always be present on a LiveTail stream update
+    if (event.sessionMetadata === undefined || event.sessionMetadata.sampled === undefined) {
+        isSampled = false
+    } else {
+        isSampled = event.sessionMetadata.sampled
+    }
+    isSampledStatusBarItem.text = `Sampled: ${isSampled ? 'Yes' : 'No'}`
+    return isSampledStatusBarItem
+}
+
+function updateEventRateStatusBar(eventRateStatusBarItem: vscode.StatusBarItem, event: LiveTailSessionUpdate) {
+    let numEvents
+    if (event.sessionResults === undefined) {
+        numEvents = 0
+    } else {
+        numEvents = event.sessionResults.length
+    }
+    eventRateStatusBarItem.text = `${numEvents} events/sec.`
+    return eventRateStatusBarItem
+}
+
+function hideShowStatusBarItemsOnActiveEditor(session: LiveTailSession, document: vscode.TextDocument) {
+    vscode.window.onDidChangeActiveTextEditor((editor) => {
+        if (editor?.document === document) {
+            session.showStatusBarItems()
+        } else {
+            session.hideStatusBarItems()
+        }
+    })
+}
+
+function startSessionTimer(session: LiveTailSession): NodeJS.Timer {
+    return globals.clock.setInterval(() => {
+        const elapsedTime = session.getLiveTailSessionDuration()
+        const timeString = convertToTimeString(elapsedTime)
+        session.statusBarItems.sessionTimer.text = `LiveTail Session Timer: ${timeString}`
+    }, 500)
+}
+
 /**
  * The LiveTail session should be automatically closed if the user does not have the session's
  * document in any Tab in their editor.
@@ -162,12 +224,13 @@ function trimOldestLines(
 function registerTabChangeCallback(
     session: LiveTailSession,
     registry: LiveTailSessionRegistry,
-    document: vscode.TextDocument
+    document: vscode.TextDocument,
+    timer: NodeJS.Timer
 ) {
     vscode.window.tabGroups.onDidChangeTabs((tabEvent) => {
         const isOpen = isLiveTailSessionOpenInAnyTab(session)
         if (!isOpen) {
-            closeSession(session.uri, registry)
+            closeSession(session.uri, registry, timer)
             void clearDocument(document)
         }
     })

packages/core/src/awsService/cloudWatchLogs/registry/liveTailSession.ts

@@ -14,6 +14,12 @@ import { Settings, ToolkitError } from '../../../shared'
 import { createLiveTailURIFromArgs } from './liveTailSessionRegistry'
 import { getUserAgent } from '../../../shared/telemetry/util'
 
+export type LiveTailSessionStatusBarItems = {
+    isSampled: vscode.StatusBarItem
+    eventRate: vscode.StatusBarItem
+    sessionTimer: vscode.StatusBarItem
+}
+
 export type LiveTailSessionConfiguration = {
     logGroupName: string
     logStreamFilter?: LogStreamFilterResponse
@@ -33,6 +39,9 @@ export class LiveTailSession {
     private logEventFilterPattern?: string
     private _maxLines: number
     private _uri: vscode.Uri
+    private _statusBarItems: LiveTailSessionStatusBarItems
+    private startTime: number | undefined
+    private endTime: number | undefined
 
     static settings = new CloudWatchLogsSettings(Settings.instance)
 
@@ -48,6 +57,7 @@ export class LiveTailSession {
         }
         this._maxLines = LiveTailSession.settings.get('limit', 10000)
         this._uri = createLiveTailURIFromArgs(configuration)
+        this._statusBarItems = this.createStatusBarItems()
     }
 
     public get maxLines() {
@@ -62,6 +72,10 @@ export class LiveTailSession {
         return this._logGroupName
     }
 
+    public get statusBarItems(): LiveTailSessionStatusBarItems {
+        return this._statusBarItems
+    }
+
     public async startLiveTailSession(): Promise<AsyncIterable<StartLiveTailResponseStream>> {
         const command = this.buildStartLiveTailCommand()
         try {
@@ -71,17 +85,33 @@ export class LiveTailSession {
             if (!commandOutput.responseStream) {
                 throw new ToolkitError('LiveTail session response stream is undefined.')
             }
+            this.startTime = Date.now()
+            this.endTime = undefined
             return commandOutput.responseStream
         } catch (e) {
             throw new ToolkitError('Encountered error while trying to start LiveTail session.')
         }
     }
 
     public stopLiveTailSession() {
+        this.endTime = Date.now()
+        this.disposeStatusBarItems()
         this.liveTailClient.abortController.abort()
         this.liveTailClient.cwlClient.destroy()
     }
 
+    public getLiveTailSessionDuration(): number {
+        //Never started
+        if (this.startTime === undefined) {
+            return 0
+        }
+        //Currently running
+        if (this.endTime === undefined) {
+            return Date.now() - this.startTime
+        }
+        return this.endTime - this.startTime
+    }
+
     private buildStartLiveTailCommand(): StartLiveTailCommand {
         let logStreamNamePrefix = undefined
         let logStreamName = undefined
@@ -102,4 +132,30 @@ export class LiveTailSession {
             logEventFilterPattern: this.logEventFilterPattern ? this.logEventFilterPattern : undefined,
         })
     }
+
+    private createStatusBarItems(): LiveTailSessionStatusBarItems {
+        return {
+            sessionTimer: vscode.window.createStatusBarItem(vscode.StatusBarAlignment.Right, 0),
+            eventRate: vscode.window.createStatusBarItem(vscode.StatusBarAlignment.Right, 1),
+            isSampled: vscode.window.createStatusBarItem(vscode.StatusBarAlignment.Right, 2),
+        }
+    }
+
+    public showStatusBarItems() {
+        this.statusBarItems.eventRate.show()
+        this.statusBarItems.isSampled.show()
+        this.statusBarItems.sessionTimer.show()
+    }
+
+    public hideStatusBarItems() {
+        this.statusBarItems.eventRate.hide()
+        this.statusBarItems.isSampled.hide()
+        this.statusBarItems.sessionTimer.hide()
+    }
+
+    private disposeStatusBarItems() {
+        this.statusBarItems.eventRate.dispose()
+        this.statusBarItems.isSampled.dispose()
+        this.statusBarItems.sessionTimer.dispose()
+    }
 }

packages/core/src/test/awsService/cloudWatchLogs/commands/tailLogGroup.test.ts

@@ -4,6 +4,7 @@
  */
 
 import * as sinon from 'sinon'
+import * as FakeTimers from '@sinonjs/fake-timers'
 import * as vscode from 'vscode'
 
 import assert from 'assert'
@@ -18,6 +19,7 @@ import {
 } from '../../../../awsService/cloudWatchLogs/wizard/tailLogGroupWizard'
 import { getTestWindow } from '../../../shared/vscode/window'
 import { CloudWatchLogsSettings } from '../../../../awsService/cloudWatchLogs/cloudWatchLogsUtils'
+import { installFakeClock } from '../../../testUtil'
 
 describe('TailLogGroup', function () {
     const testLogGroup = 'test-log-group'
@@ -31,11 +33,22 @@ describe('TailLogGroup', function () {
     let cloudwatchSettingsSpy: sinon.SinonSpy
     let wizardSpy: sinon.SinonSpy
 
+    let clock: FakeTimers.InstalledClock
+
+    before(function () {
+        clock = installFakeClock()
+    })
+
     beforeEach(function () {
+        clock.reset()
         sandbox = sinon.createSandbox()
         registry = new LiveTailSessionRegistry()
     })
 
+    after(function () {
+        clock.uninstall()
+    })
+
     afterEach(function () {
         sandbox.restore()
     })
@@ -112,15 +125,18 @@ describe('TailLogGroup', function () {
             .callsFake(async function () {
                 return
             })
+        // const fakeClock = installFakeClock()
+        const timer = setInterval(() => {}, 1000)
         const session = new LiveTailSession({
             logGroupName: testLogGroup,
             region: testRegion,
         })
         registry.set(session.uri, session)
 
-        closeSession(session.uri, registry)
+        closeSession(session.uri, registry, timer)
         assert.strictEqual(0, registry.size)
         assert.strictEqual(true, stopLiveTailSessionSpy.calledOnce)
+        assert.strictEqual(0, clock.countTimers())
     })
 
     it('clearDocument clears all text from document', async function () {
@@ -172,6 +188,9 @@ describe('TailLogGroup', function () {
         const updateFrames: StartLiveTailResponseStream[] = logEvents.map((event) => {
             return {
                 sessionUpdate: {
+                    sessionMetadata: {
+                        sampled: false,
+                    },
                     sessionResults: [event],
                 },
             }