merge in upstream changes

Author: Hweinstock

docs/telemetry.md

@@ -293,3 +293,38 @@ traceId: 'aaaaa-aaaaa-aaaaa-aaaaa-aaaaa'
 allowing us to look up `traceId=aaaaa-aaaaa-aaaaa-aaaaa-aaaaa` in our telemetry instance and find all the related events.
 
 For more information visit the OpenTelemetry documentation on traces: https://opentelemetry.io/docs/concepts/signals/traces/
+
+### Manual Trace ID Instrumentation
+
+In certain scenarios you may need to manually instrument disjoint flows to track how a `traceId` propagates through them. e.g.
+
+1. Measuring the time it takes for a message to travel from Amazon Q chat, through VS Code, and back to the customer.
+2. Determining the duration for Amazon Q inline to display a message to the user.
+
+In these cases, where there isn't a direct hierarchy of function calls, manual instrumentation of the `traceId` is necessary.
+
+#### Implementation Options
+
+#### 1. When not currently running in a span
+
+If you're not within an active span and you know the `traceId` you want to use:
+
+```javascript
+telemetry.withTraceId(() => {
+    // Code to be executed within this trace
+}, 'myTraceId')
+```
+
+This method wraps the provided function with the specified traceId
+
+#### 2. When currently running in a span
+
+If you're already executing within a span (e.g., vscode_executeCommand) and you know the traceId you want to use:
+
+```javascript
+telemetry.record({
+    traceId: 'myTraceId',
+})
+```
+
+This approach records the traceId for the current span and all future spans within the same execution context.

packages/amazonq/.changes/next-release/Bug Fix-385bc912-dc06-4b16-91ae-47fa1c586367.json

@@ -0,0 +1,4 @@
+{
+	"type": "Bug Fix",
+	"description": "Security Scan: Fixes an issue that incorrectly removes hardcoded credentials detections from auto scans."
+}

packages/amazonq/.changes/next-release/Feature-cd5797a0-6460-4fc6-b3f7-47f55f9bf163.json

@@ -0,0 +1,4 @@
+{
+	"type": "Feature",
+	"description": "Amazon Q Code Transformation: allow users to skip running tests"
+}

packages/amazonq/test/unit/codewhisperer/service/securityScanHandler.test.ts

@@ -180,5 +180,24 @@ describe('securityScanHandler', function () {
             assert.equal(codeScanIssueMap.size, 1)
             assert.equal(codeScanIssueMap.get('file1.ts')?.length, 2)
         })
+
+        it('should handle issue filtering with redacted code', () => {
+            const json = JSON.stringify([
+                {
+                    filePath: 'file1.ts',
+                    startLine: 1,
+                    endLine: 2,
+                    codeSnippet: [
+                        { number: 1, content: '**** *' },
+                        { number: 2, content: '**** *' },
+                    ],
+                },
+                { filePath: 'file1.ts', startLine: 3, endLine: 3, codeSnippet: [{ number: 3, content: '**** **' }] },
+            ])
+
+            mapToAggregatedList(codeScanIssueMap, json, editor, CodeAnalysisScope.FILE)
+            assert.strictEqual(codeScanIssueMap.size, 1)
+            assert.strictEqual(codeScanIssueMap.get('file1.ts')?.length, 1)
+        })
     })
 })

packages/amazonq/test/unit/codewhisperer/util/codeParsingUtil.test.ts

@@ -3,8 +3,17 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-import { extractClasses, extractFunctions, isTestFile, utgLanguageConfigs } from 'aws-core-vscode/codewhisperer'
+import * as vscode from 'vscode'
+import {
+    PlatformLanguageId,
+    extractClasses,
+    extractFunctions,
+    isTestFile,
+    utgLanguageConfigs,
+} from 'aws-core-vscode/codewhisperer'
+import * as path from 'path'
 import assert from 'assert'
+import { createTestWorkspaceFolder, toFile } from 'aws-core-vscode/test'
 
 describe('RegexValidationForPython', () => {
     it('should extract all function names from a python file content', () => {
@@ -57,6 +66,99 @@ describe('RegexValidationForJava', () => {
 })
 
 describe('isTestFile', () => {
+    let testWsFolder: string
+    beforeEach(async function () {
+        testWsFolder = (await createTestWorkspaceFolder()).uri.fsPath
+    })
+
+    it('validate by file path', async function () {
+        const langs = new Map<string, string>([
+            ['java', '.java'],
+            ['python', '.py'],
+            ['typescript', '.ts'],
+            ['javascript', '.js'],
+            ['typescriptreact', '.tsx'],
+            ['javascriptreact', '.jsx'],
+        ])
+        const testFilePathsWithoutExt = [
+            '/test/MyClass',
+            '/test/my_class',
+            '/tst/MyClass',
+            '/tst/my_class',
+            '/tests/MyClass',
+            '/tests/my_class',
+        ]
+
+        const srcFilePathsWithoutExt = [
+            '/src/MyClass',
+            'MyClass',
+            'foo/bar/MyClass',
+            'foo/my_class',
+            'my_class',
+            'anyFolderOtherThanTest/foo/myClass',
+        ]
+
+        for (const [languageId, ext] of langs) {
+            const testFilePaths = testFilePathsWithoutExt.map((it) => it + ext)
+            for (const testFilePath of testFilePaths) {
+                const actual = await isTestFile(testFilePath, { languageId: languageId })
+                assert.strictEqual(actual, true)
+            }
+
+            const srcFilePaths = srcFilePathsWithoutExt.map((it) => it + ext)
+            for (const srcFilePath of srcFilePaths) {
+                const actual = await isTestFile(srcFilePath, { languageId: languageId })
+                assert.strictEqual(actual, false)
+            }
+        }
+    })
+
+    async function assertIsTestFile(
+        fileNames: string[],
+        config: { languageId: PlatformLanguageId },
+        expected: boolean
+    ) {
+        for (const fileName of fileNames) {
+            const p = path.join(testWsFolder, fileName)
+            await toFile('', p)
+            const document = await vscode.workspace.openTextDocument(p)
+            const actual = await isTestFile(document.uri.fsPath, { languageId: config.languageId })
+            assert.strictEqual(actual, expected)
+        }
+    }
+
+    it('validate by file name', async function () {
+        const camelCaseSrc = ['Foo.java', 'Bar.java', 'Baz.java']
+        await assertIsTestFile(camelCaseSrc, { languageId: 'java' }, false)
+
+        const camelCaseTst = ['FooTest.java', 'BarTests.java']
+        await assertIsTestFile(camelCaseTst, { languageId: 'java' }, true)
+
+        const snakeCaseSrc = ['foo.py', 'bar.py']
+        await assertIsTestFile(snakeCaseSrc, { languageId: 'python' }, false)
+
+        const snakeCaseTst = ['test_foo.py', 'bar_test.py']
+        await assertIsTestFile(snakeCaseTst, { languageId: 'python' }, true)
+
+        const javascriptSrc = ['Foo.js', 'bar.js']
+        await assertIsTestFile(javascriptSrc, { languageId: 'javascript' }, false)
+
+        const javascriptTst = ['Foo.test.js', 'Bar.spec.js']
+        await assertIsTestFile(javascriptTst, { languageId: 'javascript' }, true)
+
+        const typescriptSrc = ['Foo.ts', 'bar.ts']
+        await assertIsTestFile(typescriptSrc, { languageId: 'typescript' }, false)
+
+        const typescriptTst = ['Foo.test.ts', 'Bar.spec.ts']
+        await assertIsTestFile(typescriptTst, { languageId: 'typescript' }, true)
+
+        const jsxSrc = ['Foo.jsx', 'Bar.jsx']
+        await assertIsTestFile(jsxSrc, { languageId: 'javascriptreact' }, false)
+
+        const jsxTst = ['Foo.test.jsx', 'Bar.spec.jsx']
+        await assertIsTestFile(jsxTst, { languageId: 'javascriptreact' }, true)
+    })
+
     it('should return true if the file name matches the test filename pattern - Java', async () => {
         const filePaths = ['/path/to/MyClassTest.java', '/path/to/TestMyClass.java', '/path/to/MyClassTests.java']
         const language = 'java'

packages/amazonq/test/unit/codewhisperer/util/utgUtils.test.ts

@@ -44,3 +44,31 @@ describe('shouldFetchUtgContext', () => {
         assert.strictEqual(utgUtils.shouldFetchUtgContext('c', UserGroup.CrossFile), undefined)
     })
 })
+
+describe('guessSrcFileName', function () {
+    it('should return undefined if no matching regex', function () {
+        assert.strictEqual(utgUtils.guessSrcFileName('Foo.java', 'java'), undefined)
+        assert.strictEqual(utgUtils.guessSrcFileName('folder1/foo.py', 'python'), undefined)
+        assert.strictEqual(utgUtils.guessSrcFileName('Bar.js', 'javascript'), undefined)
+    })
+
+    it('java', function () {
+        assert.strictEqual(utgUtils.guessSrcFileName('FooTest.java', 'java'), 'Foo.java')
+        assert.strictEqual(utgUtils.guessSrcFileName('FooTests.java', 'java'), 'Foo.java')
+    })
+
+    it('python', function () {
+        assert.strictEqual(utgUtils.guessSrcFileName('test_foo.py', 'python'), 'foo.py')
+        assert.strictEqual(utgUtils.guessSrcFileName('foo_test.py', 'python'), 'foo.py')
+    })
+
+    it('typescript', function () {
+        assert.strictEqual(utgUtils.guessSrcFileName('Foo.test.ts', 'typescript'), 'Foo.ts')
+        assert.strictEqual(utgUtils.guessSrcFileName('Foo.spec.ts', 'typescript'), 'Foo.ts')
+    })
+
+    it('javascript', function () {
+        assert.strictEqual(utgUtils.guessSrcFileName('Foo.test.js', 'javascript'), 'Foo.js')
+        assert.strictEqual(utgUtils.guessSrcFileName('Foo.spec.js', 'javascript'), 'Foo.js')
+    })
+})

packages/core/src/amazonqGumby/activation.ts

@@ -7,7 +7,11 @@ import * as vscode from 'vscode'
 import { Commands } from '../shared/vscode/commands2'
 import { TransformationHubViewProvider } from '../codewhisperer/service/transformByQ/transformationHubViewProvider'
 import { ExtContext } from '../shared/extensions'
-import { stopTransformByQ } from '../codewhisperer/commands/startTransformByQ'
+import {
+    cleanupTransformationJob,
+    postTransformationJob,
+    stopTransformByQ,
+} from '../codewhisperer/commands/startTransformByQ'
 import { transformByQState } from '../codewhisperer/models/model'
 import { ProposedTransformationExplorer } from '../codewhisperer/service/transformByQ/transformationResultsViewProvider'
 import { CodeTransformTelemetryState } from './telemetry/codeTransformTelemetryState'
@@ -48,7 +52,9 @@ export async function activate(context: ExtContext) {
 
         Commands.register('aws.amazonq.stopTransformationInHub', async (cancelSrc: CancelActionPositions) => {
             if (transformByQState.isRunning()) {
-                void stopTransformByQ(transformByQState.getJobId(), cancelSrc)
+                await stopTransformByQ(transformByQState.getJobId(), cancelSrc)
+                await postTransformationJob()
+                await cleanupTransformationJob()
             }
         }),
 

packages/core/src/amazonqGumby/chat/controller/controller.ts

@@ -303,6 +303,12 @@ export class GumbyController {
                 })
                 this.messenger.sendJobFinishedMessage(message.tabID, CodeWhispererConstants.jobCancelledChatMessage)
                 break
+            case ButtonActions.CONFIRM_SKIP_TESTS_FORM:
+                await this.handleSkipTestsSelection(message)
+                break
+            case ButtonActions.CANCEL_SKIP_TESTS_FORM:
+                this.messenger.sendJobFinishedMessage(message.tabID, CodeWhispererConstants.jobCancelledChatMessage)
+                break
             case ButtonActions.VIEW_TRANSFORMATION_HUB:
                 await vscode.commands.executeCommand(GumbyCommands.FOCUS_TRANSFORMATION_HUB, CancelActionPositions.Chat)
                 this.messenger.sendJobSubmittedMessage(message.tabID)
@@ -334,6 +340,23 @@ export class GumbyController {
         }
     }
 
+    private async handleSkipTestsSelection(message: any) {
+        const skipTestsSelection = message.formSelectedValues['GumbyTransformSkipTestsForm']
+        if (skipTestsSelection === CodeWhispererConstants.skipUnitTestsMessage) {
+            transformByQState.setCustomBuildCommand(CodeWhispererConstants.skipUnitTestsBuildCommand)
+        } else {
+            transformByQState.setCustomBuildCommand(CodeWhispererConstants.doNotSkipUnitTestsBuildCommand)
+        }
+        telemetry.codeTransform_submitSelection.emit({
+            codeTransformSessionId: CodeTransformTelemetryState.instance.getSessionId(),
+            userChoice: skipTestsSelection,
+            result: MetadataResult.Pass,
+        })
+        this.messenger.sendSkipTestsSelectionMessage(skipTestsSelection, message.tabID)
+        // perform local build
+        await this.validateBuildWithPromptOnError(message)
+    }
+
     // prompt user to pick project and specify source JDK version
     private async handleUserProjectSelection(message: any) {
         await telemetry.codeTransform_submitSelection.run(async () => {
@@ -365,7 +388,8 @@ export class GumbyController {
             }
 
             await processTransformFormInput(pathToProject, fromJDKVersion, toJDKVersion)
-            await this.validateBuildWithPromptOnError(message)
+
+            await this.messenger.sendSkipTestsPrompt(message.tabID)
         })
     }
 

packages/core/src/amazonqGumby/chat/controller/messenger/messenger.ts

@@ -109,6 +109,45 @@ export class Messenger {
         this.dispatcher.sendAuthenticationUpdate(new AuthenticationUpdateMessage(gumbyEnabled, authenticatingTabIDs))
     }
 
+    public async sendSkipTestsPrompt(tabID: string) {
+        const formItems: ChatItemFormItem[] = []
+        formItems.push({
+            id: 'GumbyTransformSkipTestsForm',
+            type: 'select',
+            title: CodeWhispererConstants.skipUnitTestsFormTitle,
+            mandatory: true,
+            options: [
+                {
+                    value: CodeWhispererConstants.runUnitTestsMessage,
+                    label: CodeWhispererConstants.runUnitTestsMessage,
+                },
+                {
+                    value: CodeWhispererConstants.skipUnitTestsMessage,
+                    label: CodeWhispererConstants.skipUnitTestsMessage,
+                },
+            ],
+        })
+
+        this.dispatcher.sendAsyncEventProgress(
+            new AsyncEventProgressMessage(tabID, {
+                inProgress: true,
+                message: CodeWhispererConstants.skipUnitTestsFormMessage,
+            })
+        )
+
+        this.dispatcher.sendChatPrompt(
+            new ChatPrompt(
+                {
+                    message: 'Q Code Transformation',
+                    formItems: formItems,
+                },
+                'TransformSkipTestsForm',
+                tabID,
+                false
+            )
+        )
+    }
+
     public async sendProjectPrompt(projects: TransformationCandidateProject[], tabID: string) {
         const projectFormOptions: { value: any; label: string }[] = []
         const detectedJavaVersions = new Array<JDKVersion | undefined>()
@@ -125,7 +164,7 @@ export class Messenger {
         formItems.push({
             id: 'GumbyTransformProjectForm',
             type: 'select',
-            title: 'Choose a project to transform',
+            title: CodeWhispererConstants.chooseProjectFormTitle,
             mandatory: true,
 
             options: projectFormOptions,
@@ -134,7 +173,7 @@ export class Messenger {
         formItems.push({
             id: 'GumbyTransformJdkFromForm',
             type: 'select',
-            title: 'Choose the source code version',
+            title: CodeWhispererConstants.chooseSourceVersionFormTitle,
             mandatory: true,
             options: [
                 {
@@ -155,7 +194,7 @@ export class Messenger {
         formItems.push({
             id: 'GumbyTransformJdkToForm',
             type: 'select',
-            title: 'Choose the target code version',
+            title: CodeWhispererConstants.chooseTargetVersionFormTitle,
             mandatory: true,
             options: [
                 {
@@ -407,7 +446,7 @@ export class Messenger {
         projectName: string,
         fromJDKVersion: JDKVersion,
         toJDKVersion: JDKVersion,
-        tabID: any
+        tabID: string
     ) {
         const message = `### Transformation details
 -------------
@@ -421,6 +460,11 @@ export class Messenger {
         this.dispatcher.sendChatMessage(new ChatMessage({ message, messageType: 'prompt' }, tabID))
     }
 
+    public sendSkipTestsSelectionMessage(skipTestsSelection: string, tabID: string) {
+        const message = `Okay, I will ${skipTestsSelection.toLowerCase()} when building your project.`
+        this.dispatcher.sendChatMessage(new ChatMessage({ message, messageType: 'ai-prompt' }, tabID))
+    }
+
     public sendHumanInTheLoopInitialMessage(tabID: string, codeSnippet: string) {
         let message = `I was not able to upgrade all dependencies. To resolve it, I will try to find an updated depedency in your local Maven repository. I will need additional information from you to continue.`
 

packages/core/src/amazonqGumby/chat/controller/messenger/messengerUtils.ts

@@ -14,7 +14,9 @@ export enum ButtonActions {
     STOP_TRANSFORMATION_JOB = 'gumbyStopTransformationJob',
     VIEW_TRANSFORMATION_HUB = 'gumbyViewTransformationHub',
     CONFIRM_TRANSFORMATION_FORM = 'gumbyTransformFormConfirm',
+    CONFIRM_SKIP_TESTS_FORM = 'gumbyTransformSkipTestsFormConfirm',
     CANCEL_TRANSFORMATION_FORM = 'gumbyTransformFormCancel',
+    CANCEL_SKIP_TESTS_FORM = 'gumbyTransformSkipTestsFormCancel',
     CONFIRM_DEPENDENCY_FORM = 'gumbyTransformDependencyFormConfirm',
     CANCEL_DEPENDENCY_FORM = 'gumbyTransformDependencyFormCancel',
     CONFIRM_JAVA_HOME_FORM = 'gumbyJavaHomeFormConfirm',