Review change

Author: Vandita Patidar

packages/core/src/awsService/appBuilder/activation.ts

@@ -202,7 +202,7 @@ async function registerAppBuilderCommands(context: ExtContext): Promise<void> {
             }
         }),
         Commands.register({ id: 'aws.toolkit.lambda.createServerlessLandProject', autoconnect: false }, async () => {
-            await telemetry.serverlessland_createProject.run(async () => {
+            await telemetry.lambda_createServerlessLandProject.run(async () => {
                 await createNewServerlessLandProject(context)
             })
         })

packages/core/src/awsService/appBuilder/serverlessLand/main.ts

@@ -7,10 +7,9 @@ import * as nls from 'vscode-nls'
 const localize = nls.loadMessageBundle()
 import * as path from 'path'
 import * as vscode from 'vscode'
-import { getTelemetryReason, getTelemetryResult } from '../../../shared/errors'
 import { getLogger } from '../../../shared/logger/logger'
 import { checklogs } from '../../../shared/localizedText'
-import { Result, telemetry } from '../../../shared/telemetry/telemetry'
+import { telemetry } from '../../../shared/telemetry/telemetry'
 import { CreateServerlessLandWizardForm, CreateServerlessLandWizard } from './wizard'
 import { ExtContext } from '../../../shared/extensions'
 import { addFolderToWorkspace } from '../../../shared/utilities/workspaceUtils'
@@ -37,17 +36,13 @@ const serverlessLandRepo = 'serverless-patterns'
  * 6. Handles errors and emits telemetry
  */
 export async function createNewServerlessLandProject(extContext: ExtContext): Promise<void> {
-    let createResult: Result = 'Succeeded'
-    let reason: string | undefined
     let metadataManager: MetadataManager
 
     try {
         metadataManager = MetadataManager.getInstance()
         // Launch the project creation wizard
         const config = await launchProjectCreationWizard(extContext)
         if (!config) {
-            createResult = 'Cancelled'
-            reason = 'userCancelled'
             return
         }
         const assetName = metadataManager.getAssetName(config.pattern, config.runtime, config.iac)
@@ -61,9 +56,11 @@ export async function createNewServerlessLandProject(extContext: ExtContext): Pr
             },
             true
         )
+        telemetry.record({
+            runtimeString: config.runtime,
+            templateName: assetName,
+        })
     } catch (err) {
-        createResult = getTelemetryResult(err)
-        reason = getTelemetryReason(err)
         getLogger().error(
             localize(
                 'AWS.serverlessland.initWizard.general.error',
@@ -72,11 +69,6 @@ export async function createNewServerlessLandProject(extContext: ExtContext): Pr
             )
         )
         getLogger().error('Error creating new Serverless Land Application: %O', err as Error)
-    } finally {
-        telemetry.serverlessland_createProject.emit({
-            result: createResult,
-            reason: reason,
-        })
     }
 }
 
@@ -98,15 +90,7 @@ export async function downloadPatternCode(config: CreateServerlessLandWizardForm
     const location = vscode.Uri.joinPath(config.location, config.name)
     try {
         await getPattern(serverlessLandOwner, serverlessLandRepo, fullAssetName, location, true)
-        telemetry.record({
-            action: fullAssetName + config.iac + config.runtime,
-            result: 'Succeeded',
-        })
     } catch (error) {
-        telemetry.serverlessland_downloadPattern.emit({
-            result: 'Failed',
-            reason: getTelemetryReason(error),
-        })
         if (error instanceof ToolkitError) {
             throw error
         }
@@ -119,22 +103,11 @@ export async function openReadmeFile(config: CreateServerlessLandWizardForm): Pr
         const readmeUri = await getProjectUri(config, readmeFile)
         if (!readmeUri) {
             getLogger().warn('README.md file not found in the project directory')
-            telemetry.serverlessland_readme.emit({
-                result: 'Failed',
-                reason: 'FileNotFound',
-            })
             return
         }
         await vscode.commands.executeCommand('workbench.action.focusFirstEditorGroup')
         await vscode.commands.executeCommand('markdown.showPreview', readmeUri)
-        telemetry.serverlessland_readme.emit({
-            result: 'Succeeded',
-        })
     } catch (err) {
-        telemetry.serverlessland_readme.emit({
-            result: 'Failed',
-            reason: getTelemetryReason(err),
-        })
         getLogger().error(`Error in openReadmeFile: ${err}`)
         throw new ToolkitError('Error processing README file')
     }

packages/core/src/awsService/appBuilder/serverlessLand/metadataManager.ts

@@ -3,9 +3,9 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 import * as nodefs from 'fs' // eslint-disable-line no-restricted-imports
+import * as path from 'path'
 import { ToolkitError } from '../../../shared/errors'
 import globals from '../../../shared/extensionGlobals'
-import { telemetry } from '../../../shared/telemetry/telemetry'
 
 interface Implementation {
     iac: string
@@ -49,7 +49,7 @@ export class MetadataManager {
     }
 
     public getMetadataPath(): string {
-        return globals.context.asAbsolutePath('dist/src/serverlessLand/metadata.json')
+        return globals.context.asAbsolutePath(path.join('dist', 'src', 'serverlessLand', 'metadata.json'))
     }
 
     /**
@@ -63,18 +63,9 @@ export class MetadataManager {
                 const metadataContent = nodefs.readFileSync(metadataPath, { encoding: 'utf-8' })
                 const parseMetadata = JSON.parse(metadataContent) as ProjectMetadata
                 this.metadata = parseMetadata
-                telemetry.record({
-                    action: 'serverlessland_metadataLoaded',
-                    result: 'Succeeded',
-                })
             }
             return this.metadata
         } catch (err) {
-            telemetry.record({
-                action: 'serverlessland_metadataLoaded',
-                result: 'Failed',
-                reason: err instanceof Error ? err.message : String(err),
-            })
             throw new ToolkitError(`Failed to load metadata: ${err instanceof Error ? err.message : String(err)}`)
         }
     }

packages/core/src/awsService/appBuilder/serverlessLand/wizard.ts

@@ -22,7 +22,6 @@ export interface CreateServerlessLandWizardForm {
     pattern: string
     runtime: string
     iac: string
-    assetName: string
 }
 
 function promptPattern(metadataManager: MetadataManager) {

packages/core/src/shared/telemetry/vscodeTelemetry.json

@@ -645,21 +645,9 @@
             "description": "Records a call to remove a region from the explorer"
         },
         {
-            "name": "serverlessland_createProject",
+            "name": "lambda_createServerlessLandProject",
             "description": "Called when creating a new Serverless Project"
         },
-        {
-            "name": "serverlessland_downloadPattern",
-            "description": "Called when downloading a Serverless Pattern"
-        },
-        {
-            "name": "serverlessland_readme",
-            "description": "Called when opening the Serverless Pattern Readme"
-        },
-        {
-            "name": "serverlessland_wizard",
-            "description": "Called when opening the Serverless Pattern Wizard"
-        },
         {
             "name": "sam_detect",
             "description": "Called when detecting the location of the SAM CLI",

packages/core/src/test/awsService/appBuilder/serverlessLand/main.test.ts

@@ -11,146 +11,89 @@ import * as vscode from 'vscode'
 import assert from 'assert'
 import * as sinon from 'sinon'
 import * as path from 'path'
+import { MetadataManager } from '../../../../awsService/appBuilder/serverlessLand/metadataManager'
 import * as main from '../../../../awsService/appBuilder/serverlessLand/main'
 import {
     createNewServerlessLandProject,
-    launchProjectCreationWizard,
     openReadmeFile,
     getProjectUri,
     downloadPatternCode,
 } from '../../../../awsService/appBuilder/serverlessLand/main'
-import * as workspaceUtils from '../../../../shared/utilities/workspaceUtils'
 import { fs } from '../../../../shared/fs/fs'
 import * as downloadPatterns from '../../../../shared/utilities/downloadPatterns'
-import { assertTelemetryCurried } from '../../../testUtil'
-import { CreateServerlessLandWizard } from '../../../../awsService/appBuilder/serverlessLand/wizard'
-import { MetadataManager } from '../../../../awsService/appBuilder/serverlessLand/metadataManager'
 import { ExtContext } from '../../../../shared/extensions'
+import { workspaceUtils } from '../../../../shared'
+import * as downloadPattern from '../../../../shared/utilities/downloadPatterns'
+import * as wizardModule from '../../../../awsService/appBuilder/serverlessLand/wizard'
 
 describe('createNewServerlessLandProject', () => {
     let sandbox: sinon.SinonSandbox
-    const mockExtContext = {
-        awsContext: {
-            getCredentials: () => Promise.resolve({}),
-            getCredentialDefaultRegion: () => 'us-west-2',
-        },
-    } as unknown as ExtContext
-    const assertTelemetry = assertTelemetryCurried('serverlessland_createProject')
-    const mockWizardResponse = {
-        name: 'test-project',
-        location: vscode.Uri.file('/test'),
-        pattern: 'test-pattern',
-        runtime: 'nodejs',
-        iac: 'sam',
-        assetName: 'test-asset',
-    }
+    let mockExtContext: ExtContext
+    let mockMetadataManager: sinon.SinonStubbedInstance<MetadataManager>
+    let mockWizard: { run: sinon.SinonStub }
 
     beforeEach(() => {
         sandbox = sinon.createSandbox()
-    })
-
-    afterEach(() => {
-        sandbox.restore()
-    })
-
-    it('successfully creates a new serverless land project', async () => {
-        const wizardStub = sandbox.stub(main, 'launchProjectCreationWizard').resolves(mockWizardResponse)
-        const metadataStub = sandbox
-            .stub(MetadataManager.prototype, 'getAssetName')
-            .withArgs('test-pattern', 'node.js', 'sam')
-            .returns('test-asset')
-        const downloadStub = sandbox.stub(main, 'downloadPatternCode').resolves()
-        const readmeStub = sandbox.stub(main, 'openReadmeFile').resolves()
-        const addFolderStub = sandbox.stub(workspaceUtils, 'addFolderToWorkspace').resolves()
-
-        await main.createNewServerlessLandProject(mockExtContext)
-
-        sandbox.assert.calledOnce(wizardStub)
-        sandbox.assert.calledOnce(metadataStub)
-        sandbox.assert.calledWith(downloadStub, mockWizardResponse, 'test-asset')
-        sandbox.assert.calledOnce(readmeStub)
-        sandbox.assert.calledWith(readmeStub, mockWizardResponse)
-        sandbox.assert.calledOnce(addFolderStub)
-        assertTelemetry({
-            result: 'Succeeded',
-        })
-    })
+        mockExtContext = {
+            awsContext: {
+                getCredentials: sandbox.stub().resolves({}),
+                getCredentialDefaultRegion: () => 'us-west-2',
+            },
+        } as unknown as ExtContext
 
-    it('handles wizard cancellation', async () => {
-        sandbox.stub(main, 'launchProjectCreationWizard').resolves(undefined)
-        await createNewServerlessLandProject(mockExtContext)
-        assertTelemetry({
-            result: 'Failed',
-            reason: 'Error',
-        })
-    })
+        mockMetadataManager = sandbox.createStubInstance(MetadataManager)
+        mockMetadataManager.getAssetName.returns('test-asset-name')
+        sandbox.stub(MetadataManager, 'getInstance').returns(mockMetadataManager as unknown as MetadataManager)
 
-    it('handles errors during project creation', async () => {
-        sandbox.stub(main, 'launchProjectCreationWizard').resolves(mockWizardResponse)
-        sandbox.stub(main, 'downloadPatternCode').rejects(new Error('Download failed'))
-        await createNewServerlessLandProject(mockExtContext)
-        assertTelemetry({
-            result: 'Failed',
-            reason: 'Error',
-        })
-    })
-})
+        mockWizard = { run: sandbox.stub() }
+        sandbox.stub(wizardModule, 'CreateServerlessLandWizard').returns(mockWizard)
 
-describe('launchProjectCreationWizard', () => {
-    let sandbox: sinon.SinonSandbox
-    const mockWizardResponse = {
-        name: 'test-project',
-        location: 'test-location',
-        pattern: 'test-pattern',
-        runtime: 'nodejs',
-        iac: 'sam',
-    }
-    const mockExtContext = {
-        awsContext: {
-            getCredentials: () => Promise.resolve({}),
-            getCredentialDefaultRegion: () => 'us-west-2',
-        },
-    } as unknown as ExtContext
+        sandbox.stub(vscode.Uri, 'joinPath').returns(vscode.Uri.file('/test'))
+        sandbox.stub(vscode.commands, 'executeCommand').resolves()
 
-    beforeEach(() => {
-        sandbox = sinon.createSandbox()
+        sandbox.stub(workspaceUtils, 'addFolderToWorkspace').resolves()
+        sandbox.stub(downloadPattern, 'getPattern').resolves()
     })
     afterEach(() => {
         sandbox.restore()
     })
-    it('should launch wizard and return form data', async () => {
-        const wizardRunStub = sandbox.stub().resolves(mockWizardResponse)
-        sandbox.stub(CreateServerlessLandWizard.prototype, 'run').get(() => wizardRunStub)
-
-        const result = await launchProjectCreationWizard(mockExtContext)
-
-        sinon.assert.calledOnce(wizardRunStub)
-        assert.deepStrictEqual(result, mockWizardResponse)
+    it('should complete project creation successfully', async () => {
+        const mockConfig = {
+            pattern: 'testPattern',
+            runtime: 'nodejs',
+            iac: 'sam',
+            location: vscode.Uri.file('/test'),
+            name: 'testProject',
+        }
+        mockWizard.run.resolves(mockConfig)
+        await createNewServerlessLandProject(mockExtContext)
+        assert.strictEqual(mockWizard.run.calledOnce, true)
+        assert.strictEqual(mockMetadataManager.getAssetName.calledOnce, true)
+        assert.strictEqual((downloadPattern.getPattern as sinon.SinonStub).calledOnce, true)
     })
-    it('should return undefined when wizard is cancelled', async () => {
-        const wizardRunStub = sandbox.stub().resolves(undefined)
-        sandbox.stub(CreateServerlessLandWizard.prototype, 'run').get(() => wizardRunStub)
-
-        const result = await launchProjectCreationWizard(mockExtContext)
-
-        sinon.assert.calledOnce(wizardRunStub)
-        assert.strictEqual(result, undefined)
+    it('should handle wizard cancellation', async () => {
+        mockWizard.run.resolves(undefined)
+        await createNewServerlessLandProject(mockExtContext)
+        assert.strictEqual(mockWizard.run.calledOnce, true)
+        assert.strictEqual(mockMetadataManager.getAssetName.called, false)
+        assert.strictEqual((downloadPattern.getPattern as sinon.SinonStub).called, false)
     })
 })
 
 describe('downloadPatternCode', () => {
+    let sandbox: sinon.SinonSandbox
     let getPatternStub: sinon.SinonStub
-    const assertTelemetry = assertTelemetryCurried('serverlessland_downloadPattern')
 
     beforeEach(function () {
-        getPatternStub = sinon.stub(downloadPatterns, 'getPattern')
+        sandbox = sinon.createSandbox()
+        getPatternStub = sandbox.stub(downloadPatterns, 'getPattern')
     })
     afterEach(function () {
-        sinon.restore()
+        sandbox.restore()
     })
     const mockConfig = {
         name: 'test-project',
-        location: vscode.Uri.file('./test'),
+        location: vscode.Uri.file('/test'),
         pattern: 'test-project-sam-python',
         runtime: 'python',
         iac: 'sam',
@@ -178,10 +121,6 @@ describe('downloadPatternCode', () => {
             await downloadPatternCode(mockConfig, mockAssetName)
             assert.fail('Expected an error to be thrown')
         } catch (err: any) {
-            assertTelemetry({
-                result: 'Failed',
-                reason: 'Error',
-            })
             assert.strictEqual(err.message, 'Failed to download pattern: Error: Download failed')
         }
     })
@@ -273,7 +212,7 @@ describe('getProjectUri', () => {
         } as vscode.Uri)
 
         const result = await getProjectUri(mockConfig, testFile)
-        sinon.assert.calledWith(uriFileStub, expectedPath)
+        sandbox.assert.calledWith(uriFileStub, expectedPath)
         assert.strictEqual(result?.fsPath, expectedPath)
     })
     it('handles missing project directory', async () => {