Merge #2650 telemetry: AWS filetypes

Author: justinmk3

package-lock.json

@@ -2938,7 +2938,7 @@
         "report": "nyc report --reporter=html --reporter=json"
     },
     "devDependencies": {
-        "@aws-toolkits/telemetry": "1.0.42",
+        "@aws-toolkits/telemetry": "1.0.49",
         "@sinonjs/fake-timers": "^8.1.0",
         "@types/adm-zip": "^0.4.34",
         "@types/async-lock": "^1.1.3",

package.json

@@ -197,11 +197,15 @@ export class AwsResourceManager {
             }
         }
 
-        globals.schemaService.registerMapping({
-            path: file.fsPath,
-            type: 'json',
-            schema: location,
-        })
+        globals.schemaService.registerMapping(
+            {
+                path: file.fsPath,
+                type: 'json',
+                schema: location,
+            },
+            // Flush immediately so the onDidOpenTextDocument handler can work.
+            true
+        )
     }
 }
 

src/dynamicResources/awsResourceManager.ts

@@ -41,6 +41,7 @@ import { activate as activateEcr } from './ecr/activation'
 import { activate as activateSam } from './shared/sam/activation'
 import { activate as activateTelemetry } from './shared/telemetry/activation'
 import { activate as activateS3 } from './s3/activation'
+import * as awsFiletypes from './shared/awsFiletypes'
 import * as telemetry from './shared/telemetry/telemetry'
 import { ExtContext } from './shared/extensions'
 import { activate as activateApiGateway } from './apigateway/activation'
@@ -118,6 +119,7 @@ export async function activate(context: vscode.ExtensionContext) {
         await activateTelemetry(context, awsContext, settings)
         await globals.telemetry.start()
         await globals.schemaService.start()
+        awsFiletypes.activate()
 
         const extContext: ExtContext = {
             extensionContext: context,

src/extension.ts

@@ -0,0 +1,114 @@
+/*!
+ * Copyright 2020 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import * as vscode from 'vscode'
+import * as path from 'path'
+import * as constants from '../shared/constants'
+import * as aslFormats from '../stepFunctions/constants/aslFormats'
+import * as telemetry from './telemetry/telemetry'
+import * as pathutil from '../shared/utilities/pathUtils'
+import * as fsutil from '../shared/filesystemUtilities'
+import * as sysutil from '../shared/systemUtilities'
+import * as collectionUtil from '../shared/utilities/collectionUtils'
+import globals from './extensionGlobals'
+
+/** AWS filetypes: vscode language ids */
+export const awsFiletypeLangIds = {
+    /** vscode language ids registered by AWS Toolkit or other AWS extensions for handling. */
+    awsOwned: [aslFormats.JSON_ASL, aslFormats.YAML_ASL, constants.ssmJson, constants.ssmYaml],
+    /** generic vscode language ids that possibly are AWS filetypes  */
+    ambiguous: ['ini', 'plaintext', aslFormats.JSON_TYPE, aslFormats.YAML_TYPE],
+}
+
+/**
+ * Maps vscode language ids to AWS filetypes for telemetry.
+ */
+export function langidToAwsFiletype(langId: string): telemetry.AwsFiletype {
+    switch (langId) {
+        case constants.ssmJson:
+        case constants.ssmYaml:
+            return 'ssmDocument'
+        case aslFormats.JSON_ASL:
+        case aslFormats.YAML_ASL:
+            return 'stepfunctionsAsl'
+        default:
+            return 'other'
+    }
+}
+
+/** Returns true if file `f` is somewhere in `~/.aws`. */
+export function isAwsConfig(f: string): boolean {
+    const awsDir = path.join(sysutil.SystemUtilities.getHomeDirectory(), '.aws')
+    if (fsutil.isInDirectory(awsDir, f)) {
+        return true
+    }
+    return false
+}
+
+export function isAwsFiletype(doc: vscode.TextDocument): boolean | undefined {
+    if (awsFiletypeLangIds.awsOwned.includes(doc.languageId)) {
+        return true
+    }
+    if (isAwsConfig(doc.fileName)) {
+        return true
+    }
+    if (awsFiletypeLangIds.ambiguous.includes(doc.languageId)) {
+        return undefined // Maybe
+    }
+    return false
+}
+
+export function activate(): void {
+    globals.context.subscriptions.push(
+        // TODO: onDidChangeTextDocument ?
+        vscode.workspace.onDidOpenTextDocument(async (doc: vscode.TextDocument) => {
+            const isAwsFileExt = isAwsFiletype(doc)
+            const isSchemaHandled = globals.schemaService.isMapped(doc.uri)
+            const isCfnTemplate = !!globals.templateRegistry.registeredItems.find(
+                t => pathutil.normalize(t.path) === pathutil.normalize(doc.fileName)
+            )
+            if (!isAwsFileExt && !isSchemaHandled && !isCfnTemplate) {
+                return
+            }
+
+            let fileExt: string | undefined = path.extname(doc.fileName)
+            fileExt = fileExt ? fileExt : undefined // Telemetry client will fail on empty string.
+
+            // TODO: ask templateRegistry if this is SAM or CFN.
+            // TODO: ask schemaService for the precise filetype.
+            let telemKind = isAwsConfig(doc.fileName) ? 'awsCredentials' : langidToAwsFiletype(doc.languageId)
+            if (telemKind === 'other') {
+                telemKind = isCfnTemplate ? 'cloudformationSam' : isSchemaHandled ? 'cloudformation' : 'other'
+            }
+
+            // HACK: for "~/.aws/foo" vscode sometimes _only_ emits "~/.aws/foo.git".
+            if (telemKind === 'awsCredentials' && fileExt === '.git') {
+                fileExt = undefined
+            }
+
+            if (await isSameMetricPending(telemKind, fileExt)) {
+                return // Avoid redundant/duplicate metrics.
+            }
+
+            telemetry.recordFileEditAwsFile({
+                awsFiletype: telemKind,
+                passive: true,
+                result: 'Succeeded',
+                filenameExt: fileExt,
+            })
+        }, undefined)
+    )
+}
+
+async function isSameMetricPending(filetype: string, fileExt: string | undefined): Promise<boolean> {
+    const pendingMetrics = await collectionUtil.first(
+        globals.telemetry.findIter(m => {
+            const m1 = m.Metadata?.find(o => o.Key === 'awsFiletype')
+            const m2 = m.Metadata?.find(o => o.Key === 'filenameExt')
+            return m.MetricName === 'file_editAwsFile' && m1?.Value === filetype && m2?.Value === fileExt
+        })
+    )
+    return !!pendingMetrics
+}

src/shared/awsFiletypes.ts

@@ -34,6 +34,7 @@ function evaluate(schema: vscode.Uri | (() => vscode.Uri)): vscode.Uri {
 export interface YamlExtension {
     assignSchema(path: vscode.Uri, schema: vscode.Uri | (() => vscode.Uri)): void
     removeSchema(path: vscode.Uri): void
+    getSchema(path: vscode.Uri): vscode.Uri | undefined
 }
 
 export async function activateYamlExtension(): Promise<YamlExtension | undefined> {
@@ -61,5 +62,6 @@ export async function activateYamlExtension(): Promise<YamlExtension | undefined
     return {
         assignSchema: (path, schema) => schemaMap.set(path.toString(), applyScheme(AWS_SCHEME, evaluate(schema))),
         removeSchema: path => schemaMap.delete(path.toString()),
+        getSchema: path => schemaMap.get(path.toString()),
     }
 }

src/shared/extensions/yaml.ts

@@ -9,6 +9,7 @@ import * as vscode from 'vscode'
 import globals from './extensionGlobals'
 import { activateYamlExtension, YamlExtension } from './extensions/yaml'
 import * as filesystemUtilities from './filesystemUtilities'
+import * as pathutil from '../shared/utilities/pathUtils'
 import { getLogger } from './logger'
 import { FileResourceFetcher } from './resourcefetcher/fileResourceFetcher'
 import { getPropertyFromJsonUrl, HttpResourceFetcher } from './resourcefetcher/httpResourceFetcher'
@@ -29,7 +30,10 @@ export interface SchemaMapping {
 }
 
 export interface SchemaHandler {
+    /** Adds or removes a schema mapping to the given `schemas` collection. */
     handleUpdate(mapping: SchemaMapping, schemas: Schemas): Promise<void>
+    /** Returns true if the given file path is handled by this `SchemaHandler`. */
+    isMapped(f: vscode.Uri | string): boolean
 }
 
 /**
@@ -64,13 +68,31 @@ export class SchemaService {
             ])
     }
 
+    public isMapped(uri: vscode.Uri): boolean {
+        for (const h of this.handlers.values()) {
+            if (h.isMapped(uri)) {
+                return true
+            }
+        }
+        return false
+    }
+
     public async start(): Promise<void> {
         getDefaultSchemas(this.extensionContext).then(schemas => (this.schemas = schemas))
         await this.startTimer()
     }
 
-    public registerMapping(mapping: SchemaMapping): void {
+    /**
+     * Registers a schema mapping in the schema service.
+     *
+     * @param mapping
+     * @param flush Flush immediately instead of waiting for timer.
+     */
+    public registerMapping(mapping: SchemaMapping, flush?: boolean): void {
         this.updateQueue.push(mapping)
+        if (flush === true) {
+            this.processUpdates()
+        }
     }
 
     public async processUpdates(): Promise<void> {
@@ -259,6 +281,15 @@ async function addCustomTags(config = Settings.instance): Promise<void> {
 export class YamlSchemaHandler implements SchemaHandler {
     public constructor(private yamlExtension?: YamlExtension) {}
 
+    isMapped(file: string | vscode.Uri): boolean {
+        if (!this.yamlExtension) {
+            return false
+        }
+        const uri = typeof file === 'string' ? vscode.Uri.file(file) : file
+        const exists = !!this.yamlExtension?.getSchema(uri)
+        return exists
+    }
+
     async handleUpdate(mapping: SchemaMapping, schemas: Schemas): Promise<void> {
         if (!this.yamlExtension) {
             const ext = await activateYamlExtension()
@@ -286,14 +317,39 @@ export class JsonSchemaHandler implements SchemaHandler {
 
     public constructor(private readonly config = Settings.instance) {}
 
+    public isMapped(file: string | vscode.Uri): boolean {
+        const setting = this.getSettingBy({ file: file })
+        return !!setting
+    }
+
+    /**
+     * Gets a json schema setting by filtering on schema path and/or file path.
+     * @param args.schemaPath Path to the schema file
+     * @param args.file Path to the file being edited by the user
+     */
+    private getSettingBy(args: {
+        schemaPath?: string | vscode.Uri
+        file?: string | vscode.Uri
+    }): JSONSchemaSettings | undefined {
+        const path = typeof args.file === 'string' ? args.file : args.file?.fsPath
+        const schm = typeof args.schemaPath === 'string' ? args.schemaPath : args.schemaPath?.fsPath
+        const settings = this.getJsonSettings()
+        const setting = settings.find(schema => {
+            const schmMatch = schm && schema.url && pathutil.normalize(schema.url) === pathutil.normalize(schm)
+            const fileMatch = path && schema.fileMatch && schema.fileMatch.includes(path)
+            return (!path || fileMatch) && (!schm || schmMatch)
+        })
+        return setting
+    }
+
     async handleUpdate(mapping: SchemaMapping, schemas: Schemas): Promise<void> {
         await this.clean()
 
         let settings = this.getJsonSettings()
 
         if (mapping.schema) {
             const uri = resolveSchema(mapping.schema, schemas).toString()
-            const existing = settings.find(schema => schema.url === uri)
+            const existing = this.getSettingBy({ schemaPath: uri })
 
             if (existing) {
                 if (!existing.fileMatch) {

src/shared/schemas.ts

@@ -166,18 +166,26 @@ function createSettingsClass<T extends TypeDescriptor>(section: string, descript
     type Inner = FromDescriptor<T>
 
     // Class names are not always stable, especially when bundling
-    function makeLogger(name = 'Settings') {
+    function makeLogger(name = 'Settings', loglevel: 'debug' | 'error') {
         const prefix = `${isNameMangled() ? 'Settings' : name} (${section})`
-        return (message: string) => getLogger().debug(`${prefix}: ${message}`)
+        return (message: string) =>
+            loglevel === 'debug'
+                ? getLogger().debug(`${prefix}: ${message}`)
+                : getLogger().error(`${prefix}: ${message}`)
     }
 
     return class AnonymousSettings implements TypedSettings<Inner> {
         private readonly config = this.settings.getSection(section)
         private readonly disposables: vscode.Disposable[] = []
         // TODO(sijaden): add metadata prop to `Logger` so we don't need to make one-off log functions
-        protected readonly log = makeLogger(Object.getPrototypeOf(this)?.constructor?.name)
+        protected readonly log = makeLogger(Object.getPrototypeOf(this)?.constructor?.name, 'debug')
+        protected readonly logErr = makeLogger(Object.getPrototypeOf(this)?.constructor?.name, 'error')
 
-        public constructor(private readonly settings: ClassToInterfaceType<Settings> = Settings.instance) {}
+        public constructor(
+            private readonly settings: ClassToInterfaceType<Settings> = Settings.instance,
+            /** Throw an exception if the user config is invalid or the caller type doesn't match the stored type. */
+            private readonly throwInvalid: boolean = isAutomation()
+        ) {}
 
         public get onDidChange() {
             return this.getChangedEmitter().event
@@ -186,14 +194,11 @@ function createSettingsClass<T extends TypeDescriptor>(section: string, descript
         public get<K extends keyof Inner>(key: K & string, defaultValue?: Inner[K]) {
             try {
                 return this.getOrThrow(key, defaultValue)
-            } catch (error) {
-                this.log(`failed to read key "${key}": ${error}`)
-
-                if (isAutomation() || defaultValue === undefined) {
-                    throw new Error(`Failed to read key "${key}": ${error}`)
+            } catch (e) {
+                if (this.throwInvalid || defaultValue === undefined) {
+                    throw new Error(`Failed to read key "${key}": ${e}`)
                 }
-
-                this.log(`using default value for "${key}"`)
+                this.logErr(`using default for key "${key}", read failed: ${(e as Error).message ?? '?'}`)
 
                 return defaultValue
             }
@@ -255,8 +260,13 @@ function createSettingsClass<T extends TypeDescriptor>(section: string, descript
 
                 for (const key of props.filter(isDifferent)) {
                     this.log(`key "${key}" changed`)
-                    store[key] = this.get(key)
-                    emitter.fire({ key })
+                    try {
+                        store[key] = this.get(key)
+                        emitter.fire({ key })
+                    } catch {
+                        // getChangedEmitter() can't provide a default value so
+                        // we must silence errors here. Logging is done by this.get().
+                    }
                 }
             })