telemetry: AWS filetypes

Problem:
No telemetry for AWS filetypes.

Solution:
- Set an `onDidOpenTextDocument` handler
    - Checks if the opened file is an "AWS filetype" by asking these services:
        - `schemaService`
        - `templateRegistry`
        - `awsFiletypes`
    - TODO: only if edited? (`onDidChangeTextDocument`)
    - TODO:is it worth adding "Resources" filetypes?
- Emit the `file_editAwsFile` metric.
  - Currently "passive". May change later.
- Add TelemetryLogger.clear() so that tests can clear the global logger
  state before querying.
    - TODO: can we eliminate TelemetryLogger (just use the
      TelemetryService directly)?

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

@@ -45,6 +45,10 @@ export class TelemetryLogger {
         return this._metrics.length
     }
 
+    public clear(): void {
+        this._metrics.length = 0
+    }
+
     public log(metric: MetricDatum): void {
         const msg = `telemetry: emitted metric "${metric.MetricName}"`
         if (!isReleaseVersion()) {

src/shared/telemetry/telemetryLogger.ts

@@ -9,7 +9,7 @@ import * as path from 'path'
 import { v4 as uuidv4 } from 'uuid'
 import { ExtensionContext } from 'vscode'
 import { AwsContext } from '../awsContext'
-import { isReleaseVersion } from '../vscode/env'
+import { isReleaseVersion, isAutomation } from '../vscode/env'
 import { getLogger } from '../logger'
 import { MetricDatum } from './clienttelemetry'
 import { DefaultTelemetryClient } from './telemetryClient'
@@ -88,11 +88,15 @@ export class DefaultTelemetryService {
             globals.clock.clearTimeout(this._timer)
             this._timer = undefined
         }
-        const currTime = new globals.clock.Date()
-        recordSessionEnd({ value: currTime.getTime() - this.startTime.getTime() })
 
-        // only write events to disk if telemetry is enabled at shutdown time
-        if (this.telemetryEnabled) {
+        // Only write events to disk at shutdown time if:
+        //   1. telemetry is enabled
+        //   2. we are not in CI or a test suite run
+        if (this.telemetryEnabled && !isAutomation()) {
+            const currTime = new globals.clock.Date()
+            // This is noisy when running tests in vscode.
+            recordSessionEnd({ value: currTime.getTime() - this.startTime.getTime() })
+
             try {
                 await writeFile(this.persistFilePath, JSON.stringify(this._eventQueue))
             } catch {}
@@ -302,6 +306,19 @@ export class DefaultTelemetryService {
             }
         }
     }
+
+    /**
+     * Queries the current pending (not flushed) metrics.
+     *
+     * @note The underlying metrics queue may be updated or flushed at any time while this iterates.
+     */
+    public async *findIter(predicate: (m: MetricDatum) => boolean): AsyncIterable<MetricDatum> {
+        for (const m of this._eventQueue) {
+            if (predicate(m)) {
+                yield m
+            }
+        }
+    }
 }
 
 export function filterTelemetryCacheEvents(input: any): MetricDatum[] {

src/shared/telemetry/telemetryService.ts

@@ -185,7 +185,7 @@ describe('ResourceManager', function () {
 
     it('registers schema mappings when opening in edit', async function () {
         const editor = await resourceManager.open(resourceNode, false)
-        verify(schemaService.registerMapping(anything())).once()
+        verify(schemaService.registerMapping(anything(), anything())).once()
 
         // eslint-disable-next-line @typescript-eslint/unbound-method
         const [mapping] = capture(schemaService.registerMapping).last()
@@ -212,7 +212,8 @@ describe('ResourceManager', function () {
     it('deletes resource mapping on file close', async function () {
         const editor = await resourceManager.open(resourceNode, false)
         await resourceManager.close(editor.document.uri)
-        verify(schemaService.registerMapping(anything())).twice()
+        verify(schemaService.registerMapping(anything())).once()
+        verify(schemaService.registerMapping(anything(), anything())).once()
 
         // eslint-disable-next-line @typescript-eslint/unbound-method
         const [mapping] = capture(schemaService.registerMapping).last()