Migrate over telemetry to the shared package (#908)

Migrate all telemetry calls to the shared package

Author: hunterwerlla

package-lock.json

@@ -479,7 +479,7 @@
         "createRelease": "ts-node ./build-scripts/createRelease.ts"
     },
     "devDependencies": {
-        "@aws-toolkits/telemetry": "0.0.6",
+        "@aws-toolkits/telemetry": "0.0.8",
         "@types/adm-zip": "^0.4.32",
         "@types/async-lock": "^1.1.0",
         "@types/cross-spawn": "^6.0.0",

package.json

@@ -16,8 +16,12 @@ import { ext } from '../shared/extensionGlobals'
 import { safeGet } from '../shared/extensionUtilities'
 import { getLogger } from '../shared/logger'
 import { RegionProvider } from '../shared/regions/regionProvider'
-import { recordVscodeActiveregions } from '../shared/telemetry/telemetry'
-import { registerCommand } from '../shared/telemetry/telemetryUtils'
+import {
+    recordAwsHideRegion,
+    recordAwsRefreshExplorer,
+    recordAwsShowRegion,
+    recordVscodeActiveRegions
+} from '../shared/telemetry/telemetry'
 import { AWSTreeNodeBase } from '../shared/treeview/nodes/awsTreeNodeBase'
 import { ErrorNode } from '../shared/treeview/nodes/errorNode'
 import { showErrorDetails } from '../shared/treeview/webviews/showErrorDetails'
@@ -43,7 +47,7 @@ export async function activate(activateArguments: {
 
     await registerAwsExplorerCommands(awsExplorer)
 
-    recordVscodeActiveregions({ value: awsExplorer.getRegionNodesSize() })
+    recordVscodeActiveRegions({ value: awsExplorer.getRegionNodesSize() })
 
     activateArguments.awsContextTrees.addTree(awsExplorer)
 
@@ -58,28 +62,27 @@ async function registerAwsExplorerCommands(
     awsExplorer: AwsExplorer,
     lambdaOutputChannel: vscode.OutputChannel = vscode.window.createOutputChannel('AWS Lambda')
 ): Promise<void> {
-    registerCommand({
-        command: 'aws.showRegion',
-        callback: async () => {
+    vscode.commands.registerCommand('aws.showRegion', async () => {
+        try {
             await ext.awsContextCommands.onCommandShowRegion()
-            recordVscodeActiveregions({ value: awsExplorer.getRegionNodesSize() })
-        },
-        telemetryName: 'Command_aws.showRegion'
+        } finally {
+            recordAwsShowRegion()
+            recordVscodeActiveRegions({ value: awsExplorer.getRegionNodesSize() })
+        }
     })
 
-    registerCommand({
-        command: 'aws.hideRegion',
-        callback: async (node?: RegionNode) => {
+    vscode.commands.registerCommand('aws.hideRegion', async (node?: RegionNode) => {
+        try {
             await ext.awsContextCommands.onCommandHideRegion(safeGet(node, x => x.regionCode))
-            recordVscodeActiveregions({ value: awsExplorer.getRegionNodesSize() })
-        },
-        telemetryName: 'Command_aws.hideRegion'
+        } finally {
+            recordAwsHideRegion()
+            recordVscodeActiveRegions({ value: awsExplorer.getRegionNodesSize() })
+        }
     })
 
-    registerCommand({
-        command: 'aws.refreshAwsExplorer',
-        callback: async () => awsExplorer.refresh(),
-        telemetryName: 'Command_aws.refreshAwsExplorer'
+    vscode.commands.registerCommand('aws.refreshAwsExplorer', async () => {
+        recordAwsRefreshExplorer()
+        awsExplorer.refresh()
     })
 
     vscode.commands.registerCommand(
@@ -93,36 +96,33 @@ async function registerAwsExplorerCommands(
             })
     )
 
-    registerCommand({
-        command: 'aws.deleteCloudFormation',
-        callback: async (node: CloudFormationStackNode) =>
-            await deleteCloudFormation(() => awsExplorer.refresh(node.parent), node),
-        telemetryName: 'cloudformation_delete'
-    })
+    vscode.commands.registerCommand(
+        'aws.deleteCloudFormation',
+        async (node: CloudFormationStackNode) =>
+            await deleteCloudFormation(() => awsExplorer.refresh(node.parent), node)
+    )
 
-    registerCommand({
-        command: 'aws.showErrorDetails',
-        callback: async (node: ErrorNode) => await showErrorDetails(node),
-        telemetryName: 'Command_aws.showErrorDetails'
-    })
+    vscode.commands.registerCommand('aws.showErrorDetails', async (node: ErrorNode) => await showErrorDetails(node))
 
-    registerCommand({
-        command: 'aws.invokeLambda',
-        callback: async (node: LambdaFunctionNode) =>
+    vscode.commands.registerCommand(
+        'aws.invokeLambda',
+        async (node: LambdaFunctionNode) =>
             await invokeLambda({
                 functionNode: node,
                 outputChannel: lambdaOutputChannel
-            }),
-        telemetryName: 'lambda_invokeremote'
-    })
+            })
+    )
 
-    registerCommand({
-        command: 'aws.refreshAwsExplorerNode',
-        callback: async (awsexplorer: AwsExplorer, element: AWSTreeNodeBase) => {
-            awsexplorer.refresh(element)
-        },
-        telemetryName: 'Command_aws.refreshAwsExplorerNode'
-    })
+    vscode.commands.registerCommand(
+        'aws.refreshAwsExplorerNode',
+        async (awsexplorer: AwsExplorer, element: AWSTreeNodeBase) => {
+            try {
+                awsexplorer.refresh(element)
+            } finally {
+                recordAwsRefreshExplorer()
+            }
+        }
+    )
 }
 
 function updateAwsExplorerWhenAwsContextCredentialsChange(

src/awsexplorer/activation.ts

@@ -5,24 +5,20 @@
 
 import * as vscode from 'vscode'
 import { cdkDocumentationUrl, cdkProvideFeedbackUrl } from '../shared/constants'
-import { ext } from '../shared/extensionGlobals'
-import { TelemetryEvent } from '../shared/telemetry/telemetryEvent'
-import { defaultMetricDatum, registerCommand } from '../shared/telemetry/telemetryUtils'
+import {
+    recordCdkAppExpanded,
+    recordCdkExplorerDisabled,
+    recordCdkExplorerEnabled,
+    recordCdkHelp,
+    recordCdkProvideFeedback,
+    recordCdkRefreshExplorer
+} from '../shared/telemetry/telemetry'
 import { AwsCdkExplorer } from './explorer/awsCdkExplorer'
 import { AppNode } from './explorer/nodes/appNode'
 import { cdk } from './globals'
 
 const EXPLORER_ENABLED_CONFIG_KEY = 'aws.cdk.explorer.enabled'
 
-/**
- * Telemetry event names for recorded metrics
- */
-enum TelemetryEventTypes {
-    APP_EXPANDED = 'cdk_appExpanded',
-    EXPLORER_RE_ENABLED = 'cdk_explorerEnabled',
-    EXPLORER_DISABLED = 'cdk_explorerDisabled'
-}
-
 /**
  * Activate AWS CDK related functionality for the extension.
  */
@@ -42,7 +38,7 @@ export async function activate(activateArguments: { extensionContext: vscode.Ext
     const appNodeExpanded = view.onDidExpandElement(e => {
         if (e.element instanceof AppNode && !e.element.expandMetricRecorded) {
             e.element.expandMetricRecorded = true
-            ext.telemetry.record(getTelemetryEvent(TelemetryEventTypes.APP_EXPANDED))
+            recordCdkAppExpanded()
         }
     })
     activateArguments.extensionContext.subscriptions.push(appNodeExpanded)
@@ -51,22 +47,15 @@ export async function activate(activateArguments: { extensionContext: vscode.Ext
     const explorerEnabledToggled = vscode.workspace.onDidChangeConfiguration(e => {
         if (e.affectsConfiguration(EXPLORER_ENABLED_CONFIG_KEY)) {
             if (vscode.workspace.getConfiguration().get(EXPLORER_ENABLED_CONFIG_KEY)) {
-                ext.telemetry.record(getTelemetryEvent(TelemetryEventTypes.EXPLORER_RE_ENABLED))
+                recordCdkExplorerEnabled()
             } else {
-                ext.telemetry.record(getTelemetryEvent(TelemetryEventTypes.EXPLORER_DISABLED))
+                recordCdkExplorerDisabled()
             }
         }
     })
     activateArguments.extensionContext.subscriptions.push(explorerEnabledToggled)
 }
 
-function getTelemetryEvent(eventName: TelemetryEventTypes): TelemetryEvent {
-    return {
-        createTime: new Date(),
-        data: [defaultMetricDatum(eventName)]
-    }
-}
-
 function initializeIconPaths(context: vscode.ExtensionContext) {
     cdk.iconPaths.dark.cdk = context.asAbsolutePath('resources/dark/cdk/cdk.svg')
     cdk.iconPaths.light.cdk = context.asAbsolutePath('resources/light/cdk/cdk.svg')
@@ -76,23 +65,19 @@ function initializeIconPaths(context: vscode.ExtensionContext) {
 }
 
 async function registerCdkCommands(explorer: AwsCdkExplorer): Promise<void> {
-    registerCommand({
-        command: 'aws.cdk.provideFeedback',
-        callback: async () => {
-            vscode.env.openExternal(vscode.Uri.parse(cdkProvideFeedbackUrl))
-        },
-        telemetryName: 'Command_aws.cdk.provideFeedback'
+    vscode.commands.registerCommand('aws.cdk.provideFeedback', async () => {
+        vscode.env.openExternal(vscode.Uri.parse(cdkProvideFeedbackUrl))
+        recordCdkProvideFeedback()
     })
-    registerCommand({
-        command: 'aws.cdk.help',
-        callback: async () => {
-            vscode.env.openExternal(vscode.Uri.parse(cdkDocumentationUrl))
-        },
-        telemetryName: 'Command_aws.cdk.help'
+    vscode.commands.registerCommand('aws.cdk.help', async () => {
+        vscode.env.openExternal(vscode.Uri.parse(cdkDocumentationUrl))
+        recordCdkHelp()
     })
-    registerCommand({
-        command: 'aws.refreshCdkExplorer',
-        callback: async () => explorer.refresh(),
-        telemetryName: 'Command_aws.refreshCdkExplorer'
+    vscode.commands.registerCommand('aws.refreshCdkExplorer', async () => {
+        try {
+            explorer.refresh()
+        } finally {
+            recordCdkRefreshExplorer()
+        }
     })
 }

src/cdk/activation.ts

@@ -11,6 +11,7 @@ import { AwsContext } from '../shared/awsContext'
 import { credentialHelpUrl } from '../shared/constants'
 import { getAccountId } from '../shared/credentials/accountId'
 import { getLogger } from '../shared/logger'
+import { recordAwsSetCredentials, Result } from '../shared/telemetry/telemetry'
 import { CredentialsStore } from './credentialsStore'
 import { CredentialsProvider } from './providers/credentialsProvider'
 import { asString, CredentialsProviderId } from './providers/credentialsProviderId'
@@ -26,6 +27,7 @@ export class LoginManager {
      * If an error occurs while trying to set up and verify these credentials, the Toolkit is "logged out".
      */
     public async login(credentialsProviderId: CredentialsProviderId): Promise<void> {
+        let loginResult: Result = 'Succeeded'
         try {
             const provider = await CredentialsProviderManager.getInstance().getCredentialsProvider(
                 credentialsProviderId
@@ -54,6 +56,7 @@ export class LoginManager {
                 defaultRegion: provider.getDefaultRegion()
             })
         } catch (err) {
+            loginResult = 'Failed'
             getLogger().error(
                 `Error trying to connect to AWS with Credentials Provider ${asString(
                     credentialsProviderId
@@ -65,6 +68,8 @@ export class LoginManager {
             await this.logout()
 
             this.notifyUserInvalidCredentials(credentialsProviderId)
+        } finally {
+            recordAwsSetCredentials({ result: loginResult })
         }
     }
 

src/credentials/loginManager.ts

@@ -3,13 +3,13 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
+import * as vscode from 'vscode'
 import { downloadSchemaItemCode } from '../eventSchemas/commands/downloadSchemaItemCode'
 import { createSearchSchemasWebView } from '../eventSchemas/commands/searchSchemas'
 import { viewSchemaItem } from '../eventSchemas/commands/viewSchemaItem'
 import { RegistryItemNode } from '../eventSchemas/explorer/registryItemNode'
 import { SchemaItemNode } from '../eventSchemas/explorer/schemaItemNode'
 import { SchemasNode } from '../eventSchemas/explorer/schemasNode'
-import { registerCommand } from '../shared/telemetry/telemetryUtils'
 
 /**
  * Activate Schemas functionality for the extension.
@@ -19,33 +19,17 @@ export async function activate(): Promise<void> {
 }
 
 async function registerSchemasCommands(): Promise<void> {
-    registerCommand({
-        command: 'aws.viewSchemaItem',
-        callback: async (node: SchemaItemNode) => await viewSchemaItem(node),
-        telemetryName: 'schemas_view'
-    })
-
-    registerCommand({
-        command: 'aws.downloadSchemaItemCode',
-        callback: async (node: SchemaItemNode) => await downloadSchemaItemCode(node),
-        telemetryName: 'schemas_download'
-    })
-
-    registerCommand({
-        command: 'aws.searchSchema',
-        callback: async (node: SchemasNode) =>
-            await createSearchSchemasWebView({
-                node: node
-            }),
-        telemetryName: 'schemas_search'
-    })
-
-    registerCommand({
-        command: 'aws.searchSchemaPerRegistry',
-        callback: async (node: RegistryItemNode) =>
-            await createSearchSchemasWebView({
-                node: node
-            }),
-        telemetryName: 'schemas_search'
-    })
+    vscode.commands.registerCommand('aws.viewSchemaItem', async (node: SchemaItemNode) => await viewSchemaItem(node))
+    vscode.commands.registerCommand(
+        'aws.downloadSchemaItemCode',
+        async (node: SchemaItemNode) => await downloadSchemaItemCode(node)
+    )
+    vscode.commands.registerCommand(
+        'aws.searchSchema',
+        async (node: SchemasNode) => await createSearchSchemasWebView({ node: node })
+    )
+    vscode.commands.registerCommand(
+        'aws.searchSchemaPerRegistry',
+        async (node: RegistryItemNode) => await createSearchSchemasWebView({ node: node })
+    )
 }

src/eventSchemas/activation.ts

@@ -12,6 +12,7 @@ import * as vscode from 'vscode'
 import { SchemaClient } from '../../shared/clients/schemaClient'
 import { makeTemporaryToolkitFolder } from '../../shared/filesystemUtilities'
 import { getLogger, Logger } from '../../shared/logger'
+import { recordSchemasDownload, Result } from '../../shared/telemetry/telemetry'
 import { ExtensionDisposableFiles } from '../../shared/utilities/disposableFiles'
 import { SchemaItemNode } from '../explorer/schemaItemNode'
 import { getLanguageDetails } from '../models/schemaCodeLangs'
@@ -34,6 +35,7 @@ const MAX_RETRIES = 150 // p100 of Java code generation is 250 seconds. So retry
 
 export async function downloadSchemaItemCode(node: SchemaItemNode) {
     const logger: Logger = getLogger()
+    let downloadResult: Result = 'Succeeded'
 
     try {
         const wizardContext = new DefaultSchemaCodeDownloadWizardContext(node)
@@ -75,6 +77,7 @@ export async function downloadSchemaItemCode(node: SchemaItemNode) {
             await vscode.window.showTextDocument(vscode.Uri.file(coreCodeFilePath))
         }
     } catch (err) {
+        downloadResult = 'Failed'
         const error = err as Error
         let errorMessage = localize(
             'AWS.message.error.schemas.downloadCodeBindings.failed_to_download',
@@ -86,6 +89,8 @@ export async function downloadSchemaItemCode(node: SchemaItemNode) {
         }
         vscode.window.showErrorMessage(errorMessage)
         logger.error('Error downloading schema', error)
+    } finally {
+        recordSchemasDownload({ result: downloadResult })
     }
 }