unified and simplified vCore telemetry

src/AzureDBExperiences.ts

@@ -15,6 +15,7 @@ export enum API {
     Core = 'Core', // Now called NoSQL
     PostgresSingle = 'PostgresSingle',
     PostgresFlexible = 'PostgresFlexible',
+    Common = 'Common', // In case we're reporting a common event and still need to provide the value of the API
 }
 
 export enum DBAccountKind {

src/commands/importDocuments.ts

@@ -4,14 +4,16 @@
  *--------------------------------------------------------------------------------------------*/
 
 import { type ItemDefinition } from '@azure/cosmos';
-import { parseError, type IActionContext } from '@microsoft/vscode-azext-utils';
+import { callWithTelemetryAndErrorHandling, parseError, type IActionContext } from '@microsoft/vscode-azext-utils';
 import { EJSON } from 'bson';
 import * as fse from 'fs-extra';
+import { type InsertManyResult } from 'mongodb';
 import * as vscode from 'vscode';
 import { cosmosMongoFilter, sqlFilter } from '../constants';
 import { DocDBCollectionTreeItem } from '../docdb/tree/DocDBCollectionTreeItem';
 import { ext } from '../extensionVariables';
 import { MongoCollectionTreeItem } from '../mongo/tree/MongoCollectionTreeItem';
+import { type InsertDocumentsResult } from '../mongoClusters/MongoClustersClient';
 import { CollectionItem } from '../mongoClusters/tree/CollectionItem';
 import { nonNullProp, nonNullValue } from '../utils/nonNull';
 import { getRootPath } from '../utils/workspacUtils';
@@ -191,9 +193,16 @@ async function insertDocumentsIntoDocdb(
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 async function insertDocumentsIntoMongo(node: MongoCollectionTreeItem, documents: any[]): Promise<string> {
     let output = '';
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
-    const parsed = await node.collection.insertMany(documents);
-    if (parsed.acknowledged) {
+
+    let parsed: InsertManyResult<Document> | undefined;
+    await callWithTelemetryAndErrorHandling('cosmosDB.mongo.importDocumets', async (actionContext) => {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+        parsed = await node.collection.insertMany(documents);
+
+        actionContext.telemetry.measurements.documentCount = parsed?.insertedCount;
+    });
+
+    if (parsed?.acknowledged) {
         output = `Import into mongo successful. Inserted ${parsed.insertedCount} document(s). See output for more details.`;
         for (const inserted of Object.values(parsed.insertedIds)) {
             ext.outputChannel.appendLog(`Inserted document: ${inserted}`);
@@ -207,10 +216,15 @@ async function insertDocumentsIntoMongoCluster(
     node: CollectionItem,
     documents: unknown[],
 ): Promise<string> {
-    const result = await node.insertDocuments(context, documents as Document[]);
+    let result: InsertDocumentsResult | undefined;
+    await callWithTelemetryAndErrorHandling('cosmosDB.mongoClusters.importDocumets', async (actionContext) => {
+        result = await node.insertDocuments(context, documents as Document[]);
+
+        actionContext.telemetry.measurements.documentCount = result?.insertedCount;
+    });
 
     let message: string;
-    if (result.acknowledged) {
+    if (result?.acknowledged) {
         message = `Import successful. Inserted ${result.insertedCount} document(s).`;
     } else {
         message = `Import failed. The operation was not acknowledged by the database.`;

src/docdb/tree/DocDBAccountTreeItemBase.ts

@@ -104,7 +104,7 @@ export abstract class DocDBAccountTreeItemBase extends DocDBTreeItemBase<Databas
         const result = await callWithTelemetryAndErrorHandling(
             'getChildren',
             async (context: IActionContext): Promise<AzExtTreeItem[]> => {
-                context.telemetry.properties.parentContext = this.contextValue;
+                context.telemetry.properties.parentNodeContext = this.contextValue;
 
                 // move this to a shared file, currently it's defined in DocDBAccountTreeItem so I can't reference it here
                 if (this.contextValue.includes('cosmosDBDocumentServer')) {

src/mongo/connectToMongoClient.ts

@@ -10,7 +10,7 @@ export async function connectToMongoClient(connectionString: string, appName: st
     // appname appears to be the correct equivalent to user-agent for mongo
     const options: MongoClientOptions = <MongoClientOptions>{
         // appName should be wrapped in '@'s when trying to connect to a Mongo account, this doesn't effect the appendUserAgent string
-        appName: `@${appName}@`,
+        appName: `${appName}[RU]`,
         // https://github.com/lmammino/mongo-uri-builder/issues/2
         useNewUrlParser: true,
         useUnifiedTopology: true,

src/mongo/tree/MongoAccountTreeItem.ts

@@ -70,7 +70,7 @@ export class MongoAccountTreeItem extends AzExtParentTreeItem {
             'getChildren',
             async (context: IActionContext): Promise<AzExtTreeItem[]> => {
                 context.telemetry.properties.experience = API.MongoDB;
-                context.telemetry.properties.parentContext = this.contextValue;
+                context.telemetry.properties.parentNodeContext = this.contextValue;
 
                 let mongoClient: MongoClient | undefined;
                 try {

src/mongoClusters/MongoClustersClient.ts

@@ -9,6 +9,7 @@
  * singletone on a client with a getter from a connection pool..
  */
 
+import { appendExtensionUserAgent, callWithTelemetryAndErrorHandling } from '@microsoft/vscode-azext-utils';
 import { EJSON } from 'bson';
 import {
     MongoClient,
@@ -22,6 +23,8 @@ import {
     type WithoutId,
 } from 'mongodb';
 import { CredentialCache } from './CredentialCache';
+import { areMongoDBAzure, getHostsFromConnectionString } from './utils/connectionStringHelpers';
+import { getMongoClusterMetadata, type MongoClusterMetadata } from './utils/getMongoClusterMetadata';
 import { toFilterQueryObj } from './utils/toFilterQuery';
 
 export interface DatabaseItemModel {
@@ -73,9 +76,31 @@ export class MongoClustersClient {
         }
 
         this._credentialId = credentialId;
+
+        // check if it's an azure connection, and do some special handling
+        let userAgentString: string | undefined = undefined;
+        {
+            const cString = CredentialCache.getCredentials(credentialId)?.connectionString as string;
+            const hosts = getHostsFromConnectionString(cString);
+            if (areMongoDBAzure(hosts)) {
+                userAgentString = appendExtensionUserAgent();
+            }
+        }
+
         const cStringPassword = CredentialCache.getConnectionStringWithPassword(credentialId);
 
-        this._mongoClient = await MongoClient.connect(cStringPassword as string);
+        this._mongoClient = await MongoClient.connect(cStringPassword as string, {
+            appName: userAgentString,
+        });
+
+        void callWithTelemetryAndErrorHandling('cosmosDB.mongoClusters.connect.getmetadata', async (context) => {
+            const metadata: MongoClusterMetadata = await getMongoClusterMetadata(this._mongoClient);
+
+            context.telemetry.properties = {
+                ...context.telemetry.properties,
+                ...metadata,
+            };
+        });
     }
 
     public static async getClient(credentialId: string): Promise<MongoClustersClient> {

src/mongoClusters/MongoClustersExtension.ts

@@ -86,9 +86,6 @@ export class MongoClustersExtension implements vscode.Disposable {
                 registerCommand('command.internal.mongoClusters.containerView.open', openCollectionView);
                 registerCommand('command.internal.mongoClusters.documentView.open', openDocumentView);
 
-                registerCommand('command.internal.mongoClusters.importDocuments', mongoClustersImportDocuments);
-                registerCommand('command.internal.mongoClusters.exportDocuments', mongoClustersExportQueryResults);
-
                 registerCommandWithTreeNodeUnwrapping('command.mongoClusters.launchShell', launchShell);
 
                 registerCommandWithTreeNodeUnwrapping('command.mongoClusters.dropCollection', dropCollection);
@@ -101,6 +98,18 @@ export class MongoClustersExtension implements vscode.Disposable {
                     'command.mongoClusters.importDocuments',
                     mongoClustersImportDocuments,
                 );
+
+                /**
+                 * Here, exporting documents is done in two ways: one is accessible from the tree view
+                 * via a context menu, and the other is accessible programmatically. Both of them
+                 * use the same underlying function to export documents.
+                 *
+                 * mongoClustersExportEntireCollection calls mongoClustersExportQueryResults with no queryText.
+                 *
+                 * It was possible to merge the two commands into one, but it would result in code that is
+                 * harder to understand and maintain.
+                 */
+                registerCommand('command.internal.mongoClusters.exportDocuments', mongoClustersExportQueryResults);
                 registerCommandWithTreeNodeUnwrapping(
                     'command.mongoClusters.exportDocuments',
                     mongoClustersExportEntireCollection,

src/mongoClusters/commands/addWorkspaceConnection.ts

@@ -12,6 +12,7 @@ import { WorkspaceResourceType } from '../../tree/workspace/sharedWorkspaceResou
 import { SharedWorkspaceStorage } from '../../tree/workspace/sharedWorkspaceStorage';
 import { showConfirmationAsInSettings } from '../../utils/dialogs/showConfirmation';
 import { localize } from '../../utils/localize';
+import { areMongoDBRU } from '../utils/connectionStringHelpers';
 import { type AddWorkspaceConnectionContext } from '../wizards/addWorkspaceConnection/AddWorkspaceConnectionContext';
 import { ConnectionStringStep } from '../wizards/addWorkspaceConnection/ConnectionStringStep';
 import { PasswordStep } from '../wizards/addWorkspaceConnection/PasswordStep';
@@ -55,12 +56,8 @@ export async function addWorkspaceConnection(context: IActionContext): Promise<v
     wizardContext.valuesToMask.push(connectionStringWithCredentials);
 
     // discover whether it's a MongoDB RU connection string and abort here.
-    let isRU: boolean = false;
-    connectionString.hosts.forEach((host) => {
-        if (isMongoDBRU(host)) {
-            isRU = true;
-        }
-    });
+    const isRU = areMongoDBRU(connectionString.hosts);
+
     if (isRU) {
         try {
             await vscode.window.showInformationMessage(
@@ -104,15 +101,3 @@ export async function addWorkspaceConnection(context: IActionContext): Promise<v
         localize('showConfirmation.addedWorkspaceConnecdtion', 'New connection has been added to your workspace.'),
     );
 }
-
-function isMongoDBRU(host: string): boolean {
-    const knownSuffixes = ['mongo.cosmos.azure.com'];
-    const hostWithoutPort = host.split(':')[0];
-
-    for (const suffix of knownSuffixes) {
-        if (hostWithoutPort.toLowerCase().endsWith(suffix)) {
-            return true;
-        }
-    }
-    return false;
-}

src/mongoClusters/commands/exportDocuments.ts

@@ -3,7 +3,7 @@
  *  Licensed under the MIT License. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 
-import { type IActionContext } from '@microsoft/vscode-azext-utils';
+import { callWithTelemetryAndErrorHandling, type IActionContext } from '@microsoft/vscode-azext-utils';
 import { EJSON } from 'bson';
 import * as vscode from 'vscode';
 import { ext } from '../../extensionVariables';
@@ -12,21 +12,23 @@ import { getRootPath } from '../../utils/workspacUtils';
 import { MongoClustersClient } from '../MongoClustersClient';
 import { type CollectionItem } from '../tree/CollectionItem';
 
-export async function mongoClustersExportEntireCollection(_context: IActionContext, node?: CollectionItem) {
-    return mongoClustersExportQueryResults(_context, node);
+export async function mongoClustersExportEntireCollection(context: IActionContext, node?: CollectionItem) {
+    return mongoClustersExportQueryResults(context, node);
 }
 
 export async function mongoClustersExportQueryResults(
-    _context: IActionContext,
+    context: IActionContext,
     node?: CollectionItem,
-    queryText?: string,
+    props?: { queryText?: string; source?: string },
 ): Promise<void> {
     // node ??= ... pick a node if not provided
     if (!node) {
         throw new Error('No collection selected.');
     }
 
-    const targetUri = await askForTargetFile(_context);
+    context.telemetry.properties.calledFrom = props?.source ?? 'contextMenu';
+
+    const targetUri = await askForTargetFile(context);
 
     if (!targetUri) {
         return;
@@ -39,7 +41,7 @@ export async function mongoClustersExportQueryResults(
         node.databaseInfo.name,
         node.collectionInfo.name,
         docStreamAbortController.signal,
-        queryText,
+        props?.queryText,
     );
 
     const filePath = targetUri.fsPath; // Convert `vscode.Uri` to a regular file path
@@ -48,14 +50,20 @@ export async function mongoClustersExportQueryResults(
     let documentCount = 0;
 
     // Wrap the export process inside a progress reporting function
-    await runExportWithProgressAndDescription(node.id, async (progress, cancellationToken) => {
-        documentCount = await exportDocumentsToFile(
-            docStream,
-            filePath,
-            progress,
-            cancellationToken,
-            docStreamAbortController,
-        );
+    await callWithTelemetryAndErrorHandling('cosmosDB.mongoClusters.exportDocuments', async (actionContext) => {
+        await runExportWithProgressAndDescription(node.id, async (progress, cancellationToken) => {
+            documentCount = await exportDocumentsToFile(
+                docStream,
+                filePath,
+                progress,
+                cancellationToken,
+                docStreamAbortController,
+            );
+        });
+
+        actionContext.telemetry.properties.source = props?.source;
+        actionContext.telemetry.measurements.queryLength = props?.queryText?.length;
+        actionContext.telemetry.measurements.documentCount = documentCount;
     });
 
     ext.outputChannel.appendLog(`MongoDB Clusters: Exported document count: ${documentCount}`);

src/mongoClusters/commands/importDocuments.ts

@@ -10,6 +10,11 @@ import { type CollectionItem } from '../tree/CollectionItem';
 export async function mongoClustersImportDocuments(
     context: IActionContext,
     collectionNode?: CollectionItem,
+    _collectionNodes?: CollectionItem[], // required by the TreeNodeCommandCallback, but not used
+    ...args: unknown[]
 ): Promise<void> {
+    const source = (args[0] as { source?: string })?.source ?? 'contextMenu';
+    context.telemetry.properties.calledFrom = source;
+
     return importDocuments(context, undefined, collectionNode);
 }

src/mongoClusters/tree/MongoClusterResourceItem.ts

@@ -42,7 +42,7 @@ export class MongoClusterResourceItem extends MongoClusterItemBase {
      */
     protected async authenticateAndConnect(): Promise<MongoClustersClient | null> {
         const result = await callWithTelemetryAndErrorHandling(
-            'cosmosDB.mongoClusters.authenticate',
+            'cosmosDB.mongoClusters.connect',
             async (context: IActionContext) => {
                 ext.outputChannel.appendLine(
                     `MongoDB Clusters: Attempting to authenticate with "${this.mongoCluster.name}"...`,

src/mongoClusters/tree/MongoClustersBranchDataProvider.ts

@@ -52,7 +52,7 @@ export class MongoClustersBranchDataProvider
          */
         return await callWithTelemetryAndErrorHandling('getChildren', async (context: IActionContext) => {
             context.telemetry.properties.experience = API.MongoClusters;
-            context.telemetry.properties.parentContext = (await element.getTreeItem()).contextValue ?? 'unknown';
+            context.telemetry.properties.parentNodeContext = (await element.getTreeItem()).contextValue ?? 'unknown';
 
             return (await element.getChildren?.())?.map((child) => {
                 if (child.id) {

src/mongoClusters/tree/workspace/MongoClusterWorkspaceItem.ts

@@ -37,7 +37,7 @@ export class MongoClusterWorkspaceItem extends MongoClusterItemBase {
      */
     protected async authenticateAndConnect(): Promise<MongoClustersClient | null> {
         const result = await callWithTelemetryAndErrorHandling(
-            'cosmosDB.mongoClusters.authenticate',
+            'cosmosDB.mongoClusters.connect',
             async (context: IActionContext) => {
                 context.telemetry.properties.view = 'workspace';
 
@@ -127,7 +127,7 @@ export class MongoClusterWorkspaceItem extends MongoClusterItemBase {
 
         // Prompt the user for credentials
         await callWithTelemetryAndErrorHandling(
-            'cosmosDB.mongoClusters.authenticate.promptForCredentials',
+            'cosmosDB.mongoClusters.connect.promptForCredentials',
             async (context: IActionContext) => {
                 context.telemetry.properties.view = 'workspace';
 

src/mongoClusters/tree/workspace/MongoClustersWorkbenchBranchDataProvider.ts

@@ -35,7 +35,7 @@ export class MongoClustersWorkspaceBranchDataProvider
         return await callWithTelemetryAndErrorHandling('getChildren', async (context: IActionContext) => {
             context.telemetry.properties.experience = API.MongoClusters;
             context.telemetry.properties.view = 'workspace';
-            context.telemetry.properties.parentContext = (await element.getTreeItem()).contextValue ?? 'unknown';
+            context.telemetry.properties.parentNodeContext = (await element.getTreeItem()).contextValue ?? 'unknown';
 
             return (await element.getChildren?.())?.map((child) => {
                 if (child.id) {

src/mongoClusters/utils/connectionStringHelpers.ts

@@ -30,8 +30,41 @@ export const getPasswordFromConnectionString = (connectionString: string): strin
     return new ConnectionString(connectionString).password;
 };
 
+export const getHostsFromConnectionString = (connectionString: string): string[] => {
+    return new ConnectionString(connectionString).hosts;
+};
+
 export const addDatabasePathToConnectionString = (connectionString: string, databaseName: string): string => {
     const connectionStringOb = new ConnectionString(connectionString);
     connectionStringOb.pathname = databaseName;
     return connectionStringOb.toString();
 };
+
+/**
+ * Checks if any of the given hosts end with any of the provided suffixes.
+ *
+ * @param hosts - An array of host strings to check.
+ * @param suffixes - An array of suffixes to check against the hosts.
+ * @returns True if any host ends with any of the suffixes, false otherwise.
+ */
+function hostsEndWithAny(hosts: string[], suffixes: string[]): boolean {
+    return hosts.some((host) => {
+        const hostWithoutPort = host.split(':')[0].toLowerCase();
+        return suffixes.some((suffix) => hostWithoutPort.endsWith(suffix));
+    });
+}
+
+export function areMongoDBRU(hosts: string[]): boolean {
+    const knownSuffixes = ['mongo.cosmos.azure.com'];
+    return hostsEndWithAny(hosts, knownSuffixes);
+}
+
+export function areMongoDBvCore(hosts: string[]): boolean {
+    const knownSuffixes = ['mongocluster.cosmos.azure.com'];
+    return hostsEndWithAny(hosts, knownSuffixes);
+}
+
+export function areMongoDBAzure(hosts: string[]): boolean {
+    const knownSuffixes = ['azure.com'];
+    return hostsEndWithAny(hosts, knownSuffixes);
+}