Supporting express executions

Author: Diler Zaza

packages/core/src/shared/clients/lambdaClient.ts

@@ -120,6 +120,18 @@ export class DefaultLambdaClient {
         }
     }
 
+    public async getFunctionConfiguration(name: string): Promise<Lambda.FunctionConfiguration> {
+        const client = await this.createSdkClient()
+        try {
+            const request = client.getFunctionConfiguration({ FunctionName: name })
+            const response = await request.promise()
+            return response
+        } catch (e) {
+            getLogger().error('Failed to get function configuration: %s', e)
+            throw e
+        }
+    }
+
     private async createSdkClient(): Promise<Lambda> {
         return await globals.sdkClientBuilder.createAwsService(
             Lambda,

packages/core/src/stepFunctions/activation.ts

@@ -105,10 +105,11 @@ async function registerStepFunctionCommands(
                 prompt: 'Enter Execution ARN',
                 placeHolder:
                     'arn:aws:states:us-east-1:123456789012:execution:MyStateMachine:12345678-1234-1234-1234-123456789012',
+                ignoreFocusOut: true,
             })
 
             if (validate(arn)) {
-                await ExecutionDetailProvider.openExecutionDetails(arn!)
+                await handleExecutionDetails(arn!)
             } else {
                 void vscode.window.showErrorMessage(
                     'Invalid ARN format. Please provide a valid Step Functions execution ARN (e.g., arn:aws:states:us-east-1:123456789012:execution:MyStateMachine:12345678-1234-1234-1234-123456789012)'
@@ -118,6 +119,44 @@ async function registerStepFunctionCommands(
     )
 }
 
+/**
+ * Determines if a Step Functions execution ARN is for an express execution
+ * @param arn The execution ARN to check
+ * @returns true if it's an express execution, false if it's a standard execution
+ */
+function isExpressExecution(arn: string): boolean {
+    const arnSegments = arn.split(':')
+    return arnSegments.length === 9 && arnSegments[5] === 'express'
+}
+
+/**
+ * Handles opening execution details based on execution type (standard vs express)
+ * @param arn The execution ARN
+ */
+async function handleExecutionDetails(arn: string): Promise<void> {
+    if (isExpressExecution(arn)) {
+        // For express executions, prompt for additional information
+        const startTime = await vscode.window.showInputBox({
+            prompt: 'Enter Start Time',
+            placeHolder: 'Start time of the express execution.',
+            ignoreFocusOut: true,
+        })
+
+        if (startTime) {
+            await ExecutionDetailProvider.openExecutionDetails(arn, startTime)
+        } else {
+            void vscode.window.showErrorMessage(
+                'Invalid Start Time. Value must be a Unix timestamp or in date time string format: YYYY-MM-DDTHH:mm:ss.sssZ.'
+            )
+        }
+    }
+
+    // For standard executions, directly open execution details
+    else {
+        await ExecutionDetailProvider.openExecutionDetails(arn)
+    }
+}
+
 async function startLspServer(extensionContext: vscode.ExtensionContext) {
     const perflog = new PerfLog('stepFunctions: start LSP client/server')
     await ASLLanguageClient.create(extensionContext)

packages/core/src/stepFunctions/executionDetails/executionDetailProvider.ts

@@ -28,6 +28,7 @@ export class ExecutionDetailProvider {
      */
     public static async openExecutionDetails(
         executionArn: string,
+        startTime?: string,
         params?: vscode.WebviewPanelOptions & vscode.WebviewOptions
     ): Promise<void> {
         // Create and show the webview panel
@@ -43,7 +44,7 @@ export class ExecutionDetailProvider {
         )
         // Create the provider and initialize the panel
         const provider = new ExecutionDetailProvider()
-        await provider.initializePanel(panel, executionArn)
+        await provider.initializePanel(panel, executionArn, startTime)
     }
 
     protected webviewHtml: string
@@ -67,7 +68,7 @@ export class ExecutionDetailProvider {
      * Gets the webview content for Execution Details.
      * @private
      */
-    private getWebviewContent = async (executionArn: string): Promise<string> => {
+    private getWebviewContent = async (executionArn: string, startTime?: string): Promise<string> => {
         const htmlFileSplit = this.webviewHtml.split('<head>')
 
         // Set asset source to CDN
@@ -85,22 +86,25 @@ export class ExecutionDetailProvider {
         const componentTypeTag = `<meta name="component-type" content="${ComponentType.ExecutionDetails}" />`
         const executionArnTag = `<meta name="execution-arn" content="${executionArn}" />`
 
-        return `${htmlFileSplit[0]} <head> ${baseTag} ${localeTag} ${darkModeTag} ${componentTypeTag} ${executionArnTag} ${htmlFileSplit[1]}`
+        // Only include start time tag for express executions (when startTime is provided)
+        const startTimeTag = startTime ? `<meta name="start-time" content="${startTime}" />` : ''
+
+        return `${htmlFileSplit[0]} <head> ${baseTag} ${localeTag} ${darkModeTag} ${componentTypeTag} ${executionArnTag} ${startTimeTag} ${htmlFileSplit[1]}`
     }
 
     /**
      * Initializes a WebView panel with execution details.
      * @param panel The WebView panel to initialize
      * @param executionArn The ARN of the execution to display
      */
-    public async initializePanel(panel: vscode.WebviewPanel, executionArn: string): Promise<void> {
+    public async initializePanel(panel: vscode.WebviewPanel, executionArn: string, startTime?: string): Promise<void> {
         try {
             if (!this.webviewHtml) {
                 await this.fetchWebviewHtml()
             }
 
             // Set up the content
-            panel.webview.html = await this.getWebviewContent(executionArn)
+            panel.webview.html = await this.getWebviewContent(executionArn, startTime)
             const context: ExecutionDetailsContext = {
                 panel,
                 loaderNotification: undefined,

packages/core/src/stepFunctions/messageHandlers/stepFunctionApiHandler.ts

@@ -6,6 +6,8 @@
 import * as StepFunctions from '@aws-sdk/client-sfn'
 import { IamClient, IamRole } from '../../shared/clients/iam'
 import { StepFunctionsClient } from '../../shared/clients/stepFunctions'
+import { CloudWatchLogsClient } from '../../shared/clients/cloudWatchLogs'
+import { DefaultLambdaClient } from '../../shared/clients/lambdaClient'
 import { ApiAction, ApiCallRequestMessage, Command, MessageType, BaseContext } from './types'
 import { telemetry } from '../../shared/telemetry/telemetry'
 import { ListRolesRequest } from '@aws-sdk/client-iam'
@@ -17,6 +19,8 @@ export class StepFunctionApiHandler {
         private readonly clients = {
             sfn: new StepFunctionsClient(region),
             iam: new IamClient(region),
+            cwl: new CloudWatchLogsClient(region),
+            lambda: new DefaultLambdaClient(region),
         }
     ) {}
 
@@ -57,6 +61,12 @@ export class StepFunctionApiHandler {
                 case ApiAction.SFNStopExecution:
                     response = await this.clients.sfn.stopExecution(params)
                     break
+                case ApiAction.CWlFilterLogEvents:
+                    response = await this.clients.cwl.filterLogEvents(params)
+                    break
+                case ApiAction.LambdaGetFunctionConfiguration:
+                    response = await this.clients.lambda.getFunctionConfiguration(params.FunctionName!)
+                    break
                 default:
                     throw new Error(`Unknown API: ${apiName}`)
             }

packages/core/src/stepFunctions/messageHandlers/types.ts

@@ -4,6 +4,8 @@
  */
 import { IAM } from 'aws-sdk'
 import * as StepFunctions from '@aws-sdk/client-sfn'
+import * as CloudWatchLogs from '@aws-sdk/client-cloudwatch-logs'
+import * as Lambda from '@aws-sdk/client-lambda'
 import * as vscode from 'vscode'
 
 export enum ComponentType {
@@ -111,6 +113,8 @@ export enum ApiAction {
     SFNRedriveExecution = 'sfn:redriveExecution',
     SFNStartExecution = 'sfn:startExecution',
     SFNStopExecution = 'sfn:stopExecution',
+    CWlFilterLogEvents = 'cwl:filterLogEvents',
+    LambdaGetFunctionConfiguration = 'lambda:getFunctionConfiguration',
 }
 
 type ApiCallRequestMapping = {
@@ -124,6 +128,8 @@ type ApiCallRequestMapping = {
     [ApiAction.SFNRedriveExecution]: StepFunctions.RedriveExecutionInput
     [ApiAction.SFNStartExecution]: StepFunctions.StartExecutionInput
     [ApiAction.SFNStopExecution]: StepFunctions.StopExecutionInput
+    [ApiAction.CWlFilterLogEvents]: CloudWatchLogs.FilterLogEventsCommandInput
+    [ApiAction.LambdaGetFunctionConfiguration]: Lambda.GetFunctionConfigurationCommandInput
 }
 
 interface ApiCallRequestMessageBase<ApiName extends ApiAction> extends Message {
@@ -146,3 +152,5 @@ export type ApiCallRequestMessage =
     | ApiCallRequestMessageBase<ApiAction.SFNRedriveExecution>
     | ApiCallRequestMessageBase<ApiAction.SFNStartExecution>
     | ApiCallRequestMessageBase<ApiAction.SFNStopExecution>
+    | ApiCallRequestMessageBase<ApiAction.CWlFilterLogEvents>
+    | ApiCallRequestMessageBase<ApiAction.LambdaGetFunctionConfiguration>

packages/core/src/test/stepFunctions/apiHandler/stepFunctionApiHandler.test.ts

@@ -17,6 +17,8 @@ import {
 import * as vscode from 'vscode'
 import { assertTelemetry } from '../../testUtil'
 import { StepFunctionsClient } from '../../../shared/clients/stepFunctions'
+import { CloudWatchLogsClient } from '../../../shared/clients/cloudWatchLogs'
+import { DefaultLambdaClient } from '../../../shared/clients/lambdaClient'
 import { IamClient } from '../../../shared/clients/iam'
 
 describe('stepFunctionApiHandler', function () {
@@ -68,6 +70,8 @@ describe('stepFunctionApiHandler', function () {
         apiHandler = new StepFunctionApiHandler('us-east-1', context, {
             sfn: sfnClient,
             iam: new IamClient('us-east-1'),
+            cwl: new CloudWatchLogsClient('us-east-1'),
+            lambda: new DefaultLambdaClient('us-east-1'),
         })
 
         testState = sinon.stub(sfnClient, 'testState')