telemetry: add domain acccount id telemetry (#8048)

## Problem
- Require account id to create a more complete product metric on SMUS
feature usage
## Solution
- Add domain account id metadata to smus_login metric

## Test
- on core `npm run generateTelemetry`
- `npm test`
- manually test telemetry
```
2025-09-16 01:21:25.358 [debug] telemetry: smus_login {
  Metadata: {
    metricId: '43dfab8d-d5a6-4791-9afb-b0b3454efb23',
    traceId: 'ba4dd30a-3ad6-4101-84a0-8ae558947fed',
    parentId: '4e6f9558-995e-444e-8461-d718bd6434a5',
    duration: '1763',
    result: 'Cancelled',
    reason: 'UserCancelled',
    reasonDesc: 'Failed to initiate login. | UserCancelled: User cancelled domain URL input',
    awsAccount: 'not-set',
    awsRegion: 'us-east-1'
  },
  Value: 1,
  Unit: 'None',
  Passive: false
}

2025-09-16 01:22:39.406 [debug] telemetry: smus_login {
  Metadata: {
    metricId: '4840c7e2-7a68-49a8-8bb6-710d629856ab',
    traceId: '65160024-7c03-47c8-80e3-9fdf8493047b',
    smusDomainId: 'dzd_bh80g0fbj1h7xl',
    awsRegion: 'us-east-2',
    smusDomainAccountId: '050752642559',
    duration: '34889',
    result: 'Succeeded',
    awsAccount: 'not-set'
  },
  Value: 1,
  Unit: 'None',
  Passive: false
}

2025-09-16 01:22:48.391 [debug] telemetry: smus_accessProject {
  Metadata: {
    metricId: 'fad0c4d1-49bd-4a87-aed5-72a6e4d04c3a',
    traceId: '65160024-7c03-47c8-80e3-9fdf8493047b',
    parentId: 'cda698a1-1c85-477c-9722-ca5b81ae6f63',
    smusDomainId: 'dzd_bh80g0fbj1h7xl',
    smusProjectId: 'c1wqm5rlzb150p',
    smusDomainRegion: 'us-east-2',
    smusDomainAccountId: '050752642559',
    duration: '10451',
    result: 'Succeeded',
    awsAccount: 'not-set',
    awsRegion: 'us-east-1'
  },
  Value: 1,
  Unit: 'None',
  Passive: false
}

2025-09-16 01:22:51.374 [debug] telemetry: smus_renderProjectChildrenNode {
  Metadata: {
    metricId: '0bc6e3e4-a54b-44a2-84d6-b033e656d91e',
    traceId: 'e280e0c3-54c5-4aae-8431-ef5724a20e42',
    smusToolkitEnv: 'local',
    smusDomainId: 'dzd_bh80g0fbj1h7xl',
    smusDomainAccountId: '050752642559',
    smusProjectId: 'c1wqm5rlzb150p',
    smusDomainRegion: 'us-east-2',
    duration: '2979',
    result: 'Succeeded',
    awsAccount: 'not-set',
    awsRegion: 'us-east-1'
  },
  Value: 1,
  Unit: 'None',
  Passive: true
}

2025-09-16 01:24:25.389 [debug] telemetry: smus_renderLakehouseNode {
  Metadata: {
    metricId: 'f50b2b04-ffe7-49f6-8d85-a1e5d59438cc',
    traceId: '83155b49-3d84-4896-bb04-5ed5182006e6',
    smusToolkitEnv: 'local',
    smusDomainId: 'dzd_bh80g0fbj1h7xl',
    smusDomainAccountId: '050752642559',
    smusProjectId: 'c1wqm5rlzb150p',
    smusConnectionId: 'c1pnab9bdg3qjt',
    smusConnectionType: 'LAKEHOUSE',
    smusProjectRegion: 'us-east-2',
    duration: '2321',
    result: 'Succeeded',
    awsAccount: 'not-set',
    awsRegion: 'us-east-1'
  },
  Value: 1,
  Unit: 'None',
  Passive: false
}


2025-09-16 01:24:54.443 [debug] telemetry: smus_renderS3Node {
  Metadata: {
    metricId: '74f286b6-1feb-43aa-b15e-4e0919ab272a',
    traceId: '9db37019-272f-4963-9e9e-1da9d9f9a26e',
    smusToolkitEnv: 'local',
    smusDomainId: 'dzd_bh80g0fbj1h7xl',
    smusDomainAccountId: '050752642559',
    smusProjectId: 'c1wqm5rlzb150p',
    smusConnectionId: 'c13ow7arqtblih',
    smusConnectionType: 'S3',
    smusProjectRegion: 'us-east-2',
    duration: '2',
    result: 'Succeeded',
    awsAccount: 'not-set',
    awsRegion: 'us-east-1'
  },
  Value: 1,
  Unit: 'None',
  Passive: false
}

2025-09-16 01:25:40.741 [debug] telemetry: smus_openRemoteConnection {
  Metadata: {
    metricId: '2f32a489-b013-4f47-951f-04d535bc2761',
    traceId: '1b90a3dc-f01f-40cc-b0bf-5920b7c6e9cc',
    smusSpaceKey: 'd-rxs4hhmzrnho__ce',
    smusDomainRegion: 'us-east-2',
    smusDomainId: 'dzd_bh80g0fbj1h7xl',
    smusDomainAccountId: '050752642559',
    smusProjectId: 'c1wqm5rlzb150p',
    duration: '18000',
    result: 'Succeeded',
    awsAccount: 'not-set',
    awsRegion: 'us-east-1'
  },
  Value: 1,
  Unit: 'None',
  Passive: false
}

2025-09-16 01:26:52.258 [debug] telemetry: smus_stopSpace {
  Metadata: {
    metricId: 'b0903fd5-ffb5-4a9a-b131-99baf11cb3a7',
    traceId: 'c5ec5f41-ae58-46b3-af8e-47c1d8fb737d',
    smusSpaceKey: 'd-rxs4hhmzrnho__ce',
    smusDomainRegion: 'us-east-2',
    smusDomainId: 'dzd_bh80g0fbj1h7xl',
    smusDomainAccountId: '050752642559',
    smusProjectId: 'c1wqm5rlzb150p',
    duration: '2308',
    result: 'Succeeded',
    awsAccount: 'not-set',
    awsRegion: 'us-east-1'
  },
  Value: 1,
  Unit: 'None',
  Passive: false
}

2025-09-16 01:27:22.027 [debug] telemetry: smus_signOut {
  Metadata: {
    metricId: 'e41138b8-9949-4088-b175-73c4d48110cc',
    traceId: 'b6a34176-e2a2-47f1-b170-d092488c0d00',
    parentId: '51f87fa9-fc1c-4351-914b-c0ce077b8f1b',
    smusDomainId: 'dzd_bh80g0fbj1h7xl',
    awsRegion: 'us-east-2',
    smusDomainAccountId: '050752642559',
    duration: '476',
    result: 'Succeeded',
    awsAccount: 'not-set'
  },
  Value: 1,
  Unit: 'None',
  Passive: false
}

```

---

- Treat all work as PUBLIC. Private `feature/x` branches will not be
squash-merged at release time.
- Your code changes must meet the guidelines in
[CONTRIBUTING.md](https://github.com/aws/aws-toolkit-vscode/blob/master/CONTRIBUTING.md#guidelines).
- License: I confirm that my contribution is made under the terms of the
Apache 2.0 license.

Author: kzr-at-amazon

packages/core/src/sagemakerunifiedstudio/auth/providers/connectionCredentialsProvider.ts

@@ -73,6 +73,14 @@ export class ConnectionCredentialsProvider implements CredentialsProvider {
         return this.smusAuthProvider.getDomainRegion()
     }
 
+    /**
+     * Gets the domain AWS account ID
+     * @returns Promise resolving to the domain account ID
+     */
+    public async getDomainAccountId(): Promise<string> {
+        return this.smusAuthProvider.getDomainAccountId()
+    }
+
     /**
      * Gets the hash code
      * @returns Hash code

packages/core/src/sagemakerunifiedstudio/auth/providers/smusAuthenticationProvider.ts

@@ -14,7 +14,7 @@ import * as localizedText from '../../../shared/localizedText'
 import { ToolkitPromptSettings } from '../../../shared/settings'
 import { setContext, getContext } from '../../../shared/vscode/setContext'
 import { getLogger } from '../../../shared/logger/logger'
-import { SmusUtils, SmusErrorCodes } from '../../shared/smusUtils'
+import { SmusUtils, SmusErrorCodes, extractAccountIdFromArn } from '../../shared/smusUtils'
 import { createSmusProfile, isValidSmusConnection, SmusConnection } from '../model'
 import { DomainExecRoleCredentialsProvider } from './domainExecRoleCredentialsProvider'
 import { ProjectRoleCredentialsProvider } from './projectRoleCredentialsProvider'
@@ -23,6 +23,7 @@ import { ConnectionClientStore } from '../../shared/client/connectionClientStore
 import { getResourceMetadata } from '../../shared/utils/resourceMetadataUtils'
 import { fromIni } from '@aws-sdk/credential-providers'
 import { randomUUID } from '../../../shared/crypto'
+import { DefaultStsClient } from '../../../shared/clients/stsClient'
 
 /**
  * Sets the context variable for SageMaker Unified Studio connection state
@@ -53,6 +54,7 @@ export class SmusAuthenticationProvider {
     private credentialsProviderCache = new Map<string, any>()
     private projectCredentialProvidersCache = new Map<string, ProjectRoleCredentialsProvider>()
     private connectionCredentialProvidersCache = new Map<string, ConnectionCredentialsProvider>()
+    private cachedDomainAccountId: string | undefined
 
     public constructor(
         public readonly auth = Auth.instance,
@@ -75,6 +77,8 @@ export class SmusAuthenticationProvider {
             this.projectCredentialProvidersCache.clear()
             // Clear connection provider cache when connection changes
             this.connectionCredentialProvidersCache.clear()
+            // Clear cached domain account ID when connection changes
+            this.cachedDomainAccountId = undefined
             // Clear all clients in client store when connection changes
             ConnectionClientStore.getInstance().clearAll()
             await setSmusConnectedContext(this.isConnected())
@@ -423,6 +427,99 @@ export class SmusAuthenticationProvider {
         return this.activeConnection.domainUrl
     }
 
+    /**
+     * Gets the AWS account ID for the active domain connection
+     * In SMUS space environment, extracts from ResourceArn in metadata
+     * Otherwise, makes an STS GetCallerIdentity call using DER credentials and caches the result
+     * @returns Promise resolving to the domain's AWS account ID
+     * @throws ToolkitError if unable to retrieve account ID
+     */
+    public async getDomainAccountId(): Promise<string> {
+        const logger = getLogger()
+
+        // Return cached value if available
+        if (this.cachedDomainAccountId) {
+            logger.debug('SMUS: Using cached domain account ID')
+            return this.cachedDomainAccountId
+        }
+
+        // If in SMUS space environment, extract account ID from resource-metadata file
+        if (getContext('aws.smus.inSmusSpaceEnvironment')) {
+            try {
+                logger.debug('SMUS: Extracting domain account ID from ResourceArn in resource-metadata file')
+
+                const resourceMetadata = getResourceMetadata()!
+                const resourceArn = resourceMetadata.ResourceArn
+
+                if (!resourceArn) {
+                    throw new ToolkitError('ResourceArn not found in metadata file', {
+                        code: SmusErrorCodes.AccountIdNotFound,
+                    })
+                }
+
+                // Extract account ID from ResourceArn using SmusUtils
+                const accountId = extractAccountIdFromArn(resourceArn)
+
+                // Cache the account ID
+                this.cachedDomainAccountId = accountId
+
+                logger.debug(
+                    `Successfully extracted and cached domain account ID from resource-metadata file: ${accountId}`
+                )
+
+                return accountId
+            } catch (err) {
+                logger.error(`Failed to extract domain account ID from ResourceArn: %s`, err)
+
+                throw new ToolkitError('Failed to extract AWS account ID from ResourceArn in SMUS space environment', {
+                    code: SmusErrorCodes.GetDomainAccountIdFailed,
+                    cause: err instanceof Error ? err : undefined,
+                })
+            }
+        }
+
+        if (!this.activeConnection) {
+            throw new ToolkitError('No active SMUS connection available', { code: SmusErrorCodes.NoActiveConnection })
+        }
+
+        // Use existing STS GetCallerIdentity implementation for non-SMUS space environments
+        try {
+            logger.debug('Fetching domain account ID via STS GetCallerIdentity')
+
+            // Get DER credentials provider
+            const derCredProvider = await this.getDerCredentialsProvider()
+
+            // Get the region for STS client
+            const region = this.getDomainRegion()
+
+            // Create STS client with DER credentials
+            const stsClient = new DefaultStsClient(region, await derCredProvider.getCredentials())
+
+            // Make GetCallerIdentity call
+            const callerIdentity = await stsClient.getCallerIdentity()
+
+            if (!callerIdentity.Account) {
+                throw new ToolkitError('Account ID not found in STS GetCallerIdentity response', {
+                    code: SmusErrorCodes.AccountIdNotFound,
+                })
+            }
+
+            // Cache the account ID
+            this.cachedDomainAccountId = callerIdentity.Account
+
+            logger.debug(`Successfully retrieved and cached domain account ID: ${callerIdentity.Account}`)
+
+            return callerIdentity.Account
+        } catch (err) {
+            logger.error(`Failed to retrieve domain account ID: %s`, err)
+
+            throw new ToolkitError('Failed to retrieve AWS account ID for active domain connection', {
+                code: SmusErrorCodes.GetDomainAccountIdFailed,
+                cause: err instanceof Error ? err : undefined,
+            })
+        }
+    }
+
     public getDomainRegion(): string {
         if (getContext('aws.smus.inSmusSpaceEnvironment')) {
             const resourceMetadata = getResourceMetadata()!
@@ -516,6 +613,10 @@ export class SmusAuthenticationProvider {
                 logger.warn(`SMUS: Failed to invalidate connection credentials for cache key ${cacheKey}: %s`, err)
             }
         }
+
+        // Clear cached domain account ID
+        this.cachedDomainAccountId = undefined
+        logger.debug('SMUS: Cleared cached domain account ID')
     }
 
     /**
@@ -560,6 +661,10 @@ export class SmusAuthenticationProvider {
             }
         }
         this.credentialsProviderCache.clear()
+
+        // Clear cached domain account ID
+        this.cachedDomainAccountId = undefined
+
         this.logger.debug('SMUS Auth: Successfully disposed authentication provider')
     }
 

packages/core/src/sagemakerunifiedstudio/explorer/activation.ts

@@ -20,8 +20,8 @@ import { getLogger } from '../../shared/logger/logger'
 import { setSmusConnectedContext, SmusAuthenticationProvider } from '../auth/providers/smusAuthenticationProvider'
 import { setupUserActivityMonitoring } from '../../awsService/sagemaker/sagemakerSpace'
 import { telemetry } from '../../shared/telemetry/telemetry'
-import { SageMakerUnifiedStudioSpacesParentNode } from './nodes/sageMakerUnifiedStudioSpacesParentNode'
 import { isSageMaker } from '../../shared/extensionUtilities'
+import { recordSpaceTelemetry } from '../shared/telemetry'
 
 export async function activate(extensionContext: vscode.ExtensionContext): Promise<void> {
     // Initialize the SMUS authentication provider
@@ -75,16 +75,7 @@ export async function activate(extensionContext: vscode.ExtensionContext): Promi
                 return
             }
             await telemetry.smus_stopSpace.run(async (span) => {
-                span.record({
-                    smusSpaceKey: node.resource.DomainSpaceKey,
-                    smusDomainRegion: node.resource.regionCode,
-                    smusDomainId: (
-                        node.resource.getParent() as SageMakerUnifiedStudioSpacesParentNode
-                    )?.getAuthProvider()?.activeConnection?.domainId,
-                    smusProjectId: (
-                        node.resource.getParent() as SageMakerUnifiedStudioSpacesParentNode
-                    )?.getProjectId(),
-                })
+                await recordSpaceTelemetry(span, node)
                 await stopSpace(node.resource, extensionContext, node.resource.sageMakerClient)
             })
         }),
@@ -95,17 +86,8 @@ export async function activate(extensionContext: vscode.ExtensionContext): Promi
                 if (!validateNode(node)) {
                     return
                 }
-                await telemetry.smus_startSpace.run(async (span) => {
-                    span.record({
-                        smusSpaceKey: node.resource.DomainSpaceKey,
-                        smusDomainRegion: node.resource.regionCode,
-                        smusDomainId: (
-                            node.resource.getParent() as SageMakerUnifiedStudioSpacesParentNode
-                        )?.getAuthProvider()?.activeConnection?.domainId,
-                        smusProjectId: (
-                            node.resource.getParent() as SageMakerUnifiedStudioSpacesParentNode
-                        )?.getProjectId(),
-                    })
+                await telemetry.smus_openRemoteConnection.run(async (span) => {
+                    await recordSpaceTelemetry(span, node)
                     await openRemoteConnect(node.resource, extensionContext, node.resource.sageMakerClient)
                 })
             }

packages/core/src/sagemakerunifiedstudio/explorer/nodes/lakehouseStrategy.ts

@@ -34,7 +34,7 @@ import { createPlaceholderItem } from '../../../shared/treeview/utils'
 import { Column, Database, Table } from '@aws-sdk/client-glue'
 import { ConnectionCredentialsProvider } from '../../auth/providers/connectionCredentialsProvider'
 import { telemetry } from '../../../shared/telemetry/telemetry'
-import { getContext } from '../../../shared/vscode/setContext'
+import { recordDataConnectionTelemetry } from '../../shared/telemetry'
 
 /**
  * Lakehouse data node for SageMaker Unified Studio
@@ -152,16 +152,7 @@ export function createLakehouseConnectionNode(
         },
         async (node) => {
             return telemetry.smus_renderLakehouseNode.run(async (span) => {
-                const isInSmusSpace = getContext('aws.smus.inSmusSpaceEnvironment')
-
-                span.record({
-                    smusToolkitEnv: isInSmusSpace ? 'smus_space' : 'local',
-                    smusDomainId: connection.domainId,
-                    smusProjectId: connection.projectId,
-                    smusConnectionId: connection.connectionId,
-                    smusConnectionType: connection.type,
-                    smusProjectRegion: connection.location?.awsRegion,
-                })
+                await recordDataConnectionTelemetry(span, connection, connectionCredentialsProvider)
                 try {
                     logger.info(`Loading Lakehouse catalogs for connection ${connection.name}`)
 

packages/core/src/sagemakerunifiedstudio/explorer/nodes/redshiftStrategy.ts

@@ -131,10 +131,11 @@ export function createRedshiftConnectionNode(
         async (node) => {
             return telemetry.smus_renderRedshiftNode.run(async (span) => {
                 const isInSmusSpace = getContext('aws.smus.inSmusSpaceEnvironment')
-
+                const accountId = await connectionCredentialsProvider.getDomainAccountId()
                 span.record({
                     smusToolkitEnv: isInSmusSpace ? 'smus_space' : 'local',
                     smusDomainId: connection.domainId,
+                    smusDomainAccountId: accountId,
                     smusProjectId: connection.projectId,
                     smusConnectionId: connection.connectionId,
                     smusConnectionType: connection.type,

packages/core/src/sagemakerunifiedstudio/explorer/nodes/s3Strategy.ts

@@ -20,7 +20,7 @@ import {
 import { S3, ListObjectsV2Command } from '@aws-sdk/client-s3'
 import { ConnectionCredentialsProvider } from '../../auth/providers/connectionCredentialsProvider'
 import { telemetry } from '../../../shared/telemetry/telemetry'
-import { getContext } from '../../../shared/vscode/setContext'
+import { recordDataConnectionTelemetry } from '../../shared/telemetry'
 
 // Regex to match default S3 connection names
 // eslint-disable-next-line @typescript-eslint/naming-convention
@@ -144,16 +144,7 @@ export function createS3ConnectionNode(
         },
         async (node) => {
             return telemetry.smus_renderS3Node.run(async (span) => {
-                const isInSmusSpace = getContext('aws.smus.inSmusSpaceEnvironment')
-
-                span.record({
-                    smusToolkitEnv: isInSmusSpace ? 'smus_space' : 'local',
-                    smusDomainId: connection.domainId,
-                    smusProjectId: connection.projectId,
-                    smusConnectionId: connection.connectionId,
-                    smusConnectionType: connection.type,
-                    smusProjectRegion: connection.location?.awsRegion,
-                })
+                await recordDataConnectionTelemetry(span, connection, connectionCredentialsProvider)
                 try {
                     if (isDefaultConnection && s3Info.prefix) {
                         // For default connections, show the full path as the first node

packages/core/src/sagemakerunifiedstudio/explorer/nodes/sageMakerUnifiedStudioProjectNode.ts

@@ -82,10 +82,11 @@ export class SageMakerUnifiedStudioProjectNode implements TreeNode {
         return telemetry.smus_renderProjectChildrenNode.run(async (span) => {
             try {
                 const isInSmusSpace = getContext('aws.smus.inSmusSpaceEnvironment')
-
+                const accountId = await this.authProvider.getDomainAccountId()
                 span.record({
                     smusToolkitEnv: isInSmusSpace ? 'smus_space' : 'local',
                     smusDomainId: this.project?.domainId,
+                    smusDomainAccountId: accountId,
                     smusProjectId: this.project?.id,
                     smusDomainRegion: this.authProvider.getDomainRegion(),
                 })

packages/core/src/sagemakerunifiedstudio/explorer/nodes/sageMakerUnifiedStudioRootNode.ts

@@ -13,10 +13,10 @@ import { telemetry } from '../../../shared/telemetry/telemetry'
 import { createQuickPick } from '../../../shared/ui/pickerPrompter'
 import { SageMakerUnifiedStudioProjectNode } from './sageMakerUnifiedStudioProjectNode'
 import { SageMakerUnifiedStudioAuthInfoNode } from './sageMakerUnifiedStudioAuthInfoNode'
-import { SmusUtils } from '../../shared/smusUtils'
+import { SmusErrorCodes, SmusUtils } from '../../shared/smusUtils'
 import { SmusAuthenticationProvider } from '../../auth/providers/smusAuthenticationProvider'
 import { ToolkitError } from '../../../../src/shared/errors'
-import { errorCode } from '../../shared/errors'
+import { recordAuthTelemetry } from '../../shared/telemetry'
 
 const contextValueSmusRoot = 'sageMakerUnifiedStudioRoot'
 const contextValueSmusLogin = 'sageMakerUnifiedStudioLogin'
@@ -237,7 +237,10 @@ export const smusLoginCommand = Commands.declare('aws.smus.login', () => async (
             if (!domainUrl) {
                 // User cancelled
                 logger.debug('User cancelled domain URL input')
-                return
+                throw new ToolkitError('User cancelled domain URL input', {
+                    cancelled: true,
+                    code: SmusErrorCodes.UserCancelled,
+                })
             }
 
             // Show a simple status bar message instead of progress dialog
@@ -252,19 +255,16 @@ export const smusLoginCommand = Commands.declare('aws.smus.login', () => async (
 
                 if (!connection) {
                     throw new ToolkitError('Failed to establish connection', {
-                        code: errorCode.failedAuthConnecton,
+                        code: SmusErrorCodes.FailedAuthConnecton,
                     })
                 }
 
-                // Extract domain ID and region for logging
+                // Extract domain account ID, domain ID, and region for logging
                 const domainId = connection.domainId
                 const region = connection.ssoRegion
 
                 logger.info(`Connected to SageMaker Unified Studio domain: ${domainId} in region ${region}`)
-                span.record({
-                    smusDomainId: domainId,
-                    awsRegion: region,
-                })
+                await recordAuthTelemetry(span, authProvider, domainId, region)
 
                 // Show success message
                 void vscode.window.showInformationMessage(
@@ -292,9 +292,12 @@ export const smusLoginCommand = Commands.declare('aws.smus.login', () => async (
                 })
             }
         } catch (err) {
-            void vscode.window.showErrorMessage(
-                `SageMaker Unified Studio: Failed to initiate login: ${(err as Error).message}`
-            )
+            const isUserCancelled = err instanceof ToolkitError && err.code === SmusErrorCodes.UserCancelled
+            if (!isUserCancelled) {
+                void vscode.window.showErrorMessage(
+                    `SageMaker Unified Studio: Failed to initiate login: ${(err as Error).message}`
+                )
+            }
             logger.error('Failed to initiate login: %s', (err as Error).message)
             throw new ToolkitError('Failed to initiate login.', {
                 cause: err as Error,
@@ -329,11 +332,7 @@ export const smusSignOutCommand = Commands.declare('aws.smus.signOut', () => asy
 
             // Show status message
             vscode.window.setStatusBarMessage('Signing out from SageMaker Unified Studio...', 5000)
-
-            span.record({
-                smusDomainId: domainId,
-                awsRegion: region,
-            })
+            await recordAuthTelemetry(span, authProvider, domainId, region)
 
             // Delete the connection (this will also invalidate tokens and clear cache)
             if (activeConnection) {
@@ -425,10 +424,12 @@ export async function selectSMUSProject(projectNode?: SageMakerUnifiedStudioProj
             }
 
             const selectedProject = await showQuickPick(items)
+            const accountId = await authProvider.getDomainAccountId()
             span.record({
                 smusDomainId: authProvider.getDomainId(),
                 smusProjectId: (selectedProject as DataZoneProject).id as string | undefined,
                 smusDomainRegion: authProvider.getDomainRegion(),
+                smusDomainAccountId: accountId,
             })
             if (
                 selectedProject &&