fix: two telemetry events are emitted for mcp except init case

Author: laileni-aws

server/aws-lsp-codewhisperer/src/language-server/agenticChat/agenticChatController.ts

@@ -199,7 +199,7 @@ export class AgenticChatController implements ChatHandlers {
             this.#features.workspace,
             this.#features.lsp
         )
-        this.#mcpEventHandler = new McpEventHandler(features)
+        this.#mcpEventHandler = new McpEventHandler(features, telemetryService)
     }
 
     async onButtonClick(params: ButtonClickParams): Promise<ButtonClickResult> {

server/aws-lsp-codewhisperer/src/language-server/agenticChat/tools/mcp/mcpEventHandler.test.ts

@@ -8,10 +8,12 @@ import * as sinon from 'sinon'
 import { McpEventHandler } from './mcpEventHandler'
 import { McpManager } from './mcpManager'
 import * as mcpUtils from './mcpUtils'
+import { TelemetryService } from '../../../../shared/telemetry/telemetryService'
 
 describe('McpEventHandler error handling', () => {
     let eventHandler: McpEventHandler
     let features: any
+    let telemetryService: TelemetryService
     let loadStub: sinon.SinonStub
 
     beforeEach(() => {
@@ -44,8 +46,16 @@ describe('McpEventHandler error handling', () => {
             lsp: {},
         }
 
+        // Create mock telemetry service
+        telemetryService = {
+            emitUserTriggerDecision: sinon.stub(),
+            emitChatInteractWithMessage: sinon.stub(),
+            emitUserModificationEvent: sinon.stub(),
+            emitCodeCoverageEvent: sinon.stub(),
+        } as unknown as TelemetryService
+
         // Create the event handler
-        eventHandler = new McpEventHandler(features)
+        eventHandler = new McpEventHandler(features, telemetryService)
 
         // Stub loadPersonaPermissions
         sinon

server/aws-lsp-codewhisperer/src/language-server/agenticChat/tools/mcp/mcpEventHandler.ts

@@ -1,5 +1,6 @@
 import { Features } from '../../../types'
 import { MCP_SERVER_STATUS_CHANGED, McpManager } from './mcpManager'
+import { ChatTelemetryController } from '../../../chat/telemetry/chatTelemetryController'
 import {
     DetailedListGroup,
     DetailedListItem,
@@ -22,6 +23,7 @@ import {
     McpServerRuntimeState,
     McpServerStatus,
 } from './mcpTypes'
+import { TelemetryService } from '../../../../shared/telemetry/telemetryService'
 
 interface PermissionOption {
     label: string
@@ -33,12 +35,14 @@ export class McpEventHandler {
     #eventListenerRegistered: boolean
     #currentEditingServerName: string | undefined
     #shouldDisplayListMCPServers: boolean
+    #telemetryController: ChatTelemetryController
 
-    constructor(features: Features) {
+    constructor(features: Features, telemetryService: TelemetryService) {
         this.#features = features
         this.#eventListenerRegistered = false
         this.#currentEditingServerName = undefined
         this.#shouldDisplayListMCPServers = true
+        this.#telemetryController = new ChatTelemetryController(features, telemetryService)
     }
 
     /**
@@ -636,12 +640,41 @@ export class McpEventHandler {
             if (serverName !== originalServerName) {
                 await McpManager.instance.removeServer(originalServerName)
                 await McpManager.instance.addServer(serverName, config, configPath, personaPath)
+                // Emit server initialize event after adding server
+                this.#telemetryController?.emitMCPServerInitializeEvent({
+                    source: 'addServer',
+                    command: config.command,
+                    enabled: true,
+                    numTools: McpManager.instance.getAllToolsWithPermissions(serverName).length,
+                    scope: params.optionsValues['scope'] === 'global' ? 'global' : 'workspace',
+                    transportType: 'stdio',
+                    languageServerVersion: this.#features.runtime.serverInfo.version,
+                })
             } else {
                 await McpManager.instance.updateServer(serverName, config, configPath)
+                // Emit server initialize event after updating server
+                this.#telemetryController?.emitMCPServerInitializeEvent({
+                    source: 'updateServer',
+                    command: config.command,
+                    enabled: true,
+                    numTools: McpManager.instance.getAllToolsWithPermissions(serverName).length,
+                    scope: params.optionsValues['scope'] === 'global' ? 'global' : 'workspace',
+                    transportType: 'stdio',
+                    languageServerVersion: this.#features.runtime.serverInfo.version,
+                })
             }
         } else {
             // Create new server
             await McpManager.instance.addServer(serverName, config, configPath, personaPath)
+            this.#telemetryController?.emitMCPServerInitializeEvent({
+                source: 'addServer',
+                command: config.command,
+                enabled: true,
+                numTools: McpManager.instance.getAllToolsWithPermissions(serverName).length,
+                scope: params.optionsValues['scope'] === 'global' ? 'global' : 'workspace',
+                transportType: 'stdio',
+                languageServerVersion: this.#features.runtime.serverInfo.version,
+            })
         }
 
         this.#currentEditingServerName = undefined
@@ -980,20 +1013,99 @@ export class McpEventHandler {
             const mcpServerPermission = await this.#processPermissionUpdates(updatedPermissionConfig)
 
             await McpManager.instance.updateServerPermission(serverName, mcpServerPermission)
+
+            // Get server config to emit telemetry
+            const serverConfig = McpManager.instance.getAllServerConfigs().get(serverName)
+            if (serverConfig) {
+                // Emit server initialize event after permission change
+                this.#telemetryController?.emitMCPServerInitializeEvent({
+                    source: 'updatePermission',
+                    command: serverConfig.command,
+                    enabled: true,
+                    numTools: McpManager.instance.getAllToolsWithPermissions(serverName).length,
+                    scope:
+                        serverConfig?.__configPath__ ===
+                        getGlobalMcpConfigPath(this.#features.workspace.fs.getUserHomeDir())
+                            ? 'global'
+                            : 'workspace',
+                    transportType: 'stdio',
+                    languageServerVersion: this.#features.runtime.serverInfo.version,
+                })
+            }
             return { id: params.id }
         } catch (error) {
             this.#features.logging.error(`Failed to update MCP permissions: ${error}`)
             return { id: params.id }
         }
     }
 
+    #emitMCPConfigEvent() {
+        // Emit MCP config event after reinitialization
+        const mcpManager = McpManager.instance
+        const serverConfigs = mcpManager.getAllServerConfigs()
+        const activeServers = Array.from(serverConfigs.entries()).filter(
+            ([name, _]) => !mcpManager.isServerDisabled(name)
+        )
+
+        // Count global vs project servers
+        const globalServers = Array.from(serverConfigs.entries()).filter(
+            ([_, config]) =>
+                config?.__configPath__ === getGlobalMcpConfigPath(this.#features.workspace.fs.getUserHomeDir())
+        ).length
+        const projectServers = serverConfigs.size - globalServers
+
+        // Count tools by permission
+        let toolsAlwaysAllowed = 0
+        let toolsDenied = 0
+
+        for (const [serverName, _] of activeServers) {
+            const toolsWithPermissions = mcpManager.getAllToolsWithPermissions(serverName)
+            toolsWithPermissions.forEach(item => {
+                if (item.permission === McpPermissionType.alwaysAllow) {
+                    toolsAlwaysAllowed++
+                } else if (item.permission === McpPermissionType.deny) {
+                    toolsDenied++
+                }
+            })
+        }
+
+        this.#telemetryController?.emitMCPConfigEvent({
+            numActiveServers: activeServers.length,
+            numGlobalServers: globalServers,
+            numProjectServers: projectServers,
+            numToolsAlwaysAllowed: toolsAlwaysAllowed,
+            numToolsDenied: toolsDenied,
+            languageServerVersion: this.#features.runtime.serverInfo.version,
+        })
+
+        // Emit server initialize events for all active servers
+        for (const [serverName, config] of serverConfigs.entries()) {
+            const enabled = !mcpManager.isServerDisabled(serverName)
+            if (enabled) {
+                this.#telemetryController?.emitMCPServerInitializeEvent({
+                    source: 'reload',
+                    command: config.command,
+                    enabled,
+                    numTools: mcpManager.getAllToolsWithPermissions(serverName).length,
+                    scope:
+                        config?.__configPath__ === getGlobalMcpConfigPath(this.#features.workspace.fs.getUserHomeDir())
+                            ? 'global'
+                            : 'workspace',
+                    transportType: 'stdio',
+                    languageServerVersion: this.#features.runtime.serverInfo.version,
+                })
+            }
+        }
+    }
+
     /**
      * Handled refresh MCP list events
      */
     async #handleRefreshMCPList(params: McpServerClickParams) {
         this.#shouldDisplayListMCPServers = true
         try {
             await McpManager.instance.reinitializeMcpServers()
+            this.#emitMCPConfigEvent()
             return {
                 id: params.id,
             }

server/aws-lsp-codewhisperer/src/language-server/chat/telemetry/chatTelemetryController.ts

@@ -23,7 +23,6 @@ import { AcceptedSuggestionEntry, CodeDiffTracker } from '../../inline-completio
 import { TelemetryService } from '../../../shared/telemetry/telemetryService'
 import { getEndPositionForAcceptedSuggestion, getTelemetryReasonDesc } from '../../../shared/utils'
 import { CodewhispererLanguage } from '../../../shared/languageDetection'
-import { AgenticChatEventStatus } from '../../../client/token/codewhispererbearertokenclient'
 
 export const CONVERSATION_ID_METRIC_KEY = 'cwsprChatConversationId'
 
@@ -292,6 +291,54 @@ export class ChatTelemetryController {
         )
     }
 
+    public emitMCPConfigEvent(data?: {
+        numActiveServers?: number
+        numGlobalServers?: number
+        numProjectServers?: number
+        numToolsAlwaysAllowed?: number
+        numToolsDenied?: number
+        languageServerVersion?: string
+    }) {
+        this.#telemetry.emitMetric({
+            name: ChatTelemetryEventName.MCPConfig,
+            data: {
+                credentialStartUrl: this.#credentialsProvider.getConnectionMetadata()?.sso?.startUrl,
+                languageServerVersion: data?.languageServerVersion,
+                numActiveServers: data?.numActiveServers,
+                numGlobalServers: data?.numGlobalServers,
+                numProjectServers: data?.numProjectServers,
+                numToolsAlwaysAllowed: data?.numToolsAlwaysAllowed,
+                numToolsDenied: data?.numToolsDenied,
+            },
+        })
+    }
+
+    public emitMCPServerInitializeEvent(data?: {
+        command?: string
+        enabled?: boolean
+        initializeTime?: number
+        numTools?: number
+        scope?: string
+        source?: string
+        transportType?: string
+        languageServerVersion?: string
+    }) {
+        this.#telemetry.emitMetric({
+            name: ChatTelemetryEventName.MCPServerInit,
+            data: {
+                credentialStartUrl: this.#credentialsProvider.getConnectionMetadata()?.sso?.startUrl,
+                command: data?.command,
+                enabled: data?.enabled,
+                initializeTime: data?.initializeTime,
+                languageServerVersion: data?.languageServerVersion,
+                numTools: data?.numTools,
+                scope: data?.scope,
+                source: data?.source,
+                transportType: data?.transportType,
+            },
+        })
+    }
+
     public emitStartConversationMetric(tabId: string, metric: Partial<CombinedConversationEvent>) {
         this.emitConversationMetric(
             {

server/aws-lsp-codewhisperer/src/shared/telemetry/types.ts

@@ -202,6 +202,8 @@ export enum ChatTelemetryEventName {
     ToolUseSuggested = 'amazonq_toolUseSuggested',
     AgencticLoop_InvokeLLM = 'amazonq_invokeLLM',
     InteractWithAgenticChat = 'amazonq_interactWithAgenticChat',
+    MCPConfig = 'amazonq_mcpConfig',
+    MCPServerInit = 'amazonq_mcpServerInit',
     LoadHistory = 'amazonq_loadHistory',
     ChatHistoryAction = 'amazonq_performChatHistoryAction',
     ExportTab = 'amazonq_exportTab',
@@ -222,6 +224,8 @@ export interface ChatTelemetryEventMap {
     [ChatTelemetryEventName.ToolUseSuggested]: ToolUseSuggestedEvent
     [ChatTelemetryEventName.AgencticLoop_InvokeLLM]: AgencticLoop_InvokeLLMEvent
     [ChatTelemetryEventName.InteractWithAgenticChat]: InteractWithAgenticChatEvent
+    [ChatTelemetryEventName.MCPConfig]: MCPConfigEvent
+    [ChatTelemetryEventName.MCPServerInit]: MCPServerInitializeEvent
     [ChatTelemetryEventName.LoadHistory]: LoadHistoryEvent
     [ChatTelemetryEventName.ChatHistoryAction]: ChatHistoryActionEvent
     [ChatTelemetryEventName.ExportTab]: ExportTabEvent
@@ -306,6 +310,29 @@ export type AddMessageEvent = {
     cwsprChatCodeContextLength?: number
 }
 
+// Agentic MCP Telemetry
+export type MCPConfigEvent = {
+    credentialStartUrl?: string
+    languageServerVersion?: string
+    numActiveServers?: number
+    numGlobalServers?: number
+    numProjectServers?: number
+    numToolsAlwaysAllowed?: number
+    numToolsDenied?: number
+}
+
+export type MCPServerInitializeEvent = {
+    command?: string
+    credentialStartUrl?: string
+    enabled?: boolean
+    initializeTime?: number
+    languageServerVersion?: string
+    numTools?: number
+    scope?: string
+    source?: string
+    transportType?: string
+}
+
 export type EnterFocusChatEvent = {
     credentialStartUrl?: string
 }