@office-ai/aioncli-core 0.2.2 → 0.8.1

package/dist/src/telemetry/loggers.test.js

@@ -4,18 +4,22 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 import { AuthType, EditTool, GeminiClient, ToolConfirmationOutcome, ToolErrorType, ToolRegistry, } from '../index.js';
+import { OutputFormat } from '../output/types.js';
 import { logs } from '@opentelemetry/api-logs';
 import { SemanticAttributes } from '@opentelemetry/semantic-conventions';
-import { EVENT_API_REQUEST, EVENT_API_RESPONSE, EVENT_CLI_CONFIG, EVENT_TOOL_CALL, EVENT_USER_PROMPT, EVENT_FLASH_FALLBACK, } from './constants.js';
-import { logApiRequest, logApiResponse, logCliConfiguration, logUserPrompt, logToolCall, logFlashFallback, logChatCompression, } from './loggers.js';
+import { EVENT_API_REQUEST, EVENT_API_RESPONSE, EVENT_CLI_CONFIG, EVENT_TOOL_CALL, EVENT_USER_PROMPT, EVENT_FLASH_FALLBACK, EVENT_MALFORMED_JSON_RESPONSE, EVENT_FILE_OPERATION, EVENT_RIPGREP_FALLBACK, EVENT_MODEL_ROUTING, EVENT_EXTENSION_ENABLE, EVENT_EXTENSION_DISABLE, EVENT_EXTENSION_INSTALL, EVENT_EXTENSION_UNINSTALL, } from './constants.js';
+import { logApiRequest, logApiResponse, logCliConfiguration, logUserPrompt, logToolCall, logFlashFallback, logChatCompression, logMalformedJsonResponse, logFileOperation, logRipgrepFallback, logToolOutputTruncated, logModelRouting, logExtensionEnable, logExtensionDisable, logExtensionInstallEvent, logExtensionUninstall, } from './loggers.js';
 import { ToolCallDecision } from './tool-call-decision.js';
-import { ApiRequestEvent, ApiResponseEvent, StartSessionEvent, ToolCallEvent, UserPromptEvent, FlashFallbackEvent, makeChatCompressionEvent, } from './types.js';
+import { ApiRequestEvent, ApiResponseEvent, StartSessionEvent, ToolCallEvent, UserPromptEvent, FlashFallbackEvent, RipgrepFallbackEvent, MalformedJsonResponseEvent, makeChatCompressionEvent, FileOperationEvent, ToolOutputTruncatedEvent, ModelRoutingEvent, ExtensionEnableEvent, ExtensionDisableEvent, ExtensionInstallEvent, ExtensionUninstallEvent, } from './types.js';
 import * as metrics from './metrics.js';
+import { FileOperation } from './metrics.js';
 import * as sdk from './sdk.js';
-import { vi, describe, beforeEach, it, expect } from 'vitest';
+import { vi, describe, beforeEach, it, expect, afterEach } from 'vitest';
+import { DiscoveredMCPTool } from '../tools/mcp-tool.js';
 import * as uiTelemetry from './uiTelemetry.js';
 import { makeFakeConfig } from '../test-utils/config.js';
 import { ClearcutLogger } from './clearcut-logger/clearcut-logger.js';
+import { UserAccountManager } from '../utils/userAccountManager.js';
 describe('loggers', () => {
     const mockLogger = {
         emit: vi.fn(),
@@ -24,9 +28,11 @@ describe('loggers', () => {
         addEvent: vi.fn(),
     };
     beforeEach(() => {
+        vi.clearAllMocks();
         vi.spyOn(sdk, 'isTelemetrySdkInitialized').mockReturnValue(true);
         vi.spyOn(logs, 'getLogger').mockReturnValue(mockLogger);
         vi.spyOn(uiTelemetry.uiTelemetryService, 'addEvent').mockImplementation(mockUiEvent.addEvent);
+        vi.spyOn(UserAccountManager.prototype, 'getCachedGoogleAccount').mockReturnValue('test-user@example.com');
         vi.useFakeTimers();
         vi.setSystemTime(new Date('2025-01-01T00:00:00.000Z'));
     });
@@ -81,6 +87,7 @@ describe('loggers', () => {
                 getQuestion: () => 'test-question',
                 getTargetDir: () => 'target-dir',
                 getProxy: () => 'http://test.proxy.com:8080',
+                getOutputFormat: () => OutputFormat.JSON,
             };
             const startSessionEvent = new StartSessionEvent(mockConfig);
             logCliConfiguration(mockConfig, startSessionEvent);
@@ -88,6 +95,7 @@ describe('loggers', () => {
                 body: 'CLI configuration loaded.',
                 attributes: {
                     'session.id': 'test-session-id',
+                    'user.email': 'test-user@example.com',
                     'event.name': EVENT_CLI_CONFIG,
                     'event.timestamp': '2025-01-01T00:00:00.000Z',
                     model: 'test-model',
@@ -101,6 +109,10 @@ describe('loggers', () => {
                     file_filtering_respect_git_ignore: true,
                     debug_mode: true,
                     mcp_servers: 'test-server',
+                    mcp_servers_count: 1,
+                    mcp_tools: undefined,
+                    mcp_tools_count: undefined,
+                    output_format: 'json',
                 },
             });
         });
@@ -119,10 +131,13 @@ describe('loggers', () => {
                 body: 'User prompt. Length: 11.',
                 attributes: {
                     'session.id': 'test-session-id',
+                    'user.email': 'test-user@example.com',
                     'event.name': EVENT_USER_PROMPT,
                     'event.timestamp': '2025-01-01T00:00:00.000Z',
                     prompt_length: 11,
                     prompt: 'test-prompt',
+                    prompt_id: 'prompt-id-8',
+                    auth_type: 'vertex-ai',
                 },
             });
         });
@@ -134,15 +149,18 @@ describe('loggers', () => {
                 getTargetDir: () => 'target-dir',
                 getUsageStatisticsEnabled: () => true,
             };
-            const event = new UserPromptEvent(11, 'test-prompt', AuthType.CLOUD_SHELL);
+            const event = new UserPromptEvent(11, 'prompt-id-9', AuthType.CLOUD_SHELL, 'test-prompt');
             logUserPrompt(mockConfig, event);
             expect(mockLogger.emit).toHaveBeenCalledWith({
                 body: 'User prompt. Length: 11.',
                 attributes: {
                     'session.id': 'test-session-id',
+                    'user.email': 'test-user@example.com',
                     'event.name': EVENT_USER_PROMPT,
                     'event.timestamp': '2025-01-01T00:00:00.000Z',
                     prompt_length: 11,
+                    prompt_id: 'prompt-id-9',
+                    auth_type: 'cloud-shell',
                 },
             });
         });
@@ -177,6 +195,7 @@ describe('loggers', () => {
                 body: 'API response from test-model. Status: 200. Duration: 100ms.',
                 attributes: {
                     'session.id': 'test-session-id',
+                    'user.email': 'test-user@example.com',
                     'event.name': EVENT_API_RESPONSE,
                     'event.timestamp': '2025-01-01T00:00:00.000Z',
                     [SemanticAttributes.HTTP_STATUS_CODE]: 200,
@@ -194,34 +213,8 @@ describe('loggers', () => {
                     auth_type: 'oauth-personal',
                 },
             });
-            expect(mockMetrics.recordApiResponseMetrics).toHaveBeenCalledWith(mockConfig, 'test-model', 100, 200, undefined);
-            expect(mockMetrics.recordTokenUsageMetrics).toHaveBeenCalledWith(mockConfig, 'test-model', 50, 'output');
-            expect(mockUiEvent.addEvent).toHaveBeenCalledWith({
-                ...event,
-                'event.name': EVENT_API_RESPONSE,
-                'event.timestamp': '2025-01-01T00:00:00.000Z',
-            });
-        });
-        it('should log an API response with an error', () => {
-            const usageData = {
-                promptTokenCount: 17,
-                candidatesTokenCount: 50,
-                cachedContentTokenCount: 10,
-                thoughtsTokenCount: 5,
-                toolUsePromptTokenCount: 2,
-            };
-            const event = new ApiResponseEvent('test-model', 100, 'prompt-id-1', AuthType.USE_GEMINI, usageData, 'test-response', 'test-error');
-            logApiResponse(mockConfig, event);
-            expect(mockLogger.emit).toHaveBeenCalledWith({
-                body: 'API response from test-model. Status: 200. Duration: 100ms.',
-                attributes: {
-                    'session.id': 'test-session-id',
-                    ...event,
-                    'event.name': EVENT_API_RESPONSE,
-                    'event.timestamp': '2025-01-01T00:00:00.000Z',
-                    'error.message': 'test-error',
-                },
-            });
+            expect(mockMetrics.recordApiResponseMetrics).toHaveBeenCalledWith(mockConfig, 100, { model: 'test-model', status_code: 200 });
+            expect(mockMetrics.recordTokenUsageMetrics).toHaveBeenCalledWith(mockConfig, 50, { model: 'test-model', type: 'output' });
             expect(mockUiEvent.addEvent).toHaveBeenCalledWith({
                 ...event,
                 'event.name': EVENT_API_RESPONSE,
@@ -244,6 +237,7 @@ describe('loggers', () => {
                 body: 'API request to test-model.',
                 attributes: {
                     'session.id': 'test-session-id',
+                    'user.email': 'test-user@example.com',
                     'event.name': EVENT_API_REQUEST,
                     'event.timestamp': '2025-01-01T00:00:00.000Z',
                     model: 'test-model',
@@ -259,6 +253,7 @@ describe('loggers', () => {
                 body: 'API request to test-model.',
                 attributes: {
                     'session.id': 'test-session-id',
+                    'user.email': 'test-user@example.com',
                     'event.name': EVENT_API_REQUEST,
                     'event.timestamp': '2025-01-01T00:00:00.000Z',
                     model: 'test-model',
@@ -279,6 +274,7 @@ describe('loggers', () => {
                 body: 'Switching to flash as Fallback.',
                 attributes: {
                     'session.id': 'test-session-id',
+                    'user.email': 'test-user@example.com',
                     'event.name': EVENT_FLASH_FALLBACK,
                     'event.timestamp': '2025-01-01T00:00:00.000Z',
                     auth_type: 'vertex-ai',
@@ -286,6 +282,41 @@ describe('loggers', () => {
             });
         });
     });
+    describe('logRipgrepFallback', () => {
+        const mockConfig = {
+            getSessionId: () => 'test-session-id',
+            getUsageStatisticsEnabled: () => true,
+        };
+        beforeEach(() => {
+            vi.spyOn(ClearcutLogger.prototype, 'logRipgrepFallbackEvent');
+        });
+        it('should log ripgrep fallback event', () => {
+            const event = new RipgrepFallbackEvent();
+            logRipgrepFallback(mockConfig, event);
+            expect(ClearcutLogger.prototype.logRipgrepFallbackEvent).toHaveBeenCalled();
+            const emittedEvent = mockLogger.emit.mock.calls[0][0];
+            expect(emittedEvent.body).toBe('Switching to grep as fallback.');
+            expect(emittedEvent.attributes).toEqual(expect.objectContaining({
+                'session.id': 'test-session-id',
+                'user.email': 'test-user@example.com',
+                'event.name': EVENT_RIPGREP_FALLBACK,
+                error: undefined,
+            }));
+        });
+        it('should log ripgrep fallback event with an error', () => {
+            const event = new RipgrepFallbackEvent('rg not found');
+            logRipgrepFallback(mockConfig, event);
+            expect(ClearcutLogger.prototype.logRipgrepFallbackEvent).toHaveBeenCalled();
+            const emittedEvent = mockLogger.emit.mock.calls[0][0];
+            expect(emittedEvent.body).toBe('Switching to grep as fallback.');
+            expect(emittedEvent.attributes).toEqual(expect.objectContaining({
+                'session.id': 'test-session-id',
+                'user.email': 'test-user@example.com',
+                'event.name': EVENT_RIPGREP_FALLBACK,
+                error: 'rg not found',
+            }));
+        });
+    });
     describe('logToolCall', () => {
         const cfg1 = {
             getSessionId: () => 'test-session-id',
@@ -349,10 +380,26 @@ describe('loggers', () => {
                 },
                 response: {
                     callId: 'test-call-id',
-                    responseParts: 'test-response',
-                    resultDisplay: undefined,
+                    responseParts: [{ text: 'test-response' }],
+                    resultDisplay: {
+                        fileDiff: 'diff',
+                        fileName: 'file.txt',
+                        originalContent: 'old content',
+                        newContent: 'new content',
+                        diffStat: {
+                            model_added_lines: 1,
+                            model_removed_lines: 2,
+                            model_added_chars: 3,
+                            model_removed_chars: 4,
+                            user_added_lines: 5,
+                            user_removed_lines: 6,
+                            user_added_chars: 7,
+                            user_removed_chars: 8,
+                        },
+                    },
                     error: undefined,
                     errorType: undefined,
+                    contentLength: 13,
                 },
                 tool,
                 invocation: {},
@@ -365,6 +412,7 @@ describe('loggers', () => {
                 body: 'Tool call: test-function. Decision: accept. Success: true. Duration: 100ms.',
                 attributes: {
                     'session.id': 'test-session-id',
+                    'user.email': 'test-user@example.com',
                     'event.name': EVENT_TOOL_CALL,
                     'event.timestamp': '2025-01-01T00:00:00.000Z',
                     function_name: 'test-function',
@@ -377,9 +425,27 @@ describe('loggers', () => {
                     decision: ToolCallDecision.ACCEPT,
                     prompt_id: 'prompt-id-1',
                     tool_type: 'native',
+                    error: undefined,
+                    error_type: undefined,
+                    metadata: {
+                        model_added_lines: 1,
+                        model_removed_lines: 2,
+                        model_added_chars: 3,
+                        model_removed_chars: 4,
+                        user_added_lines: 5,
+                        user_removed_lines: 6,
+                        user_added_chars: 7,
+                        user_removed_chars: 8,
+                    },
+                    content_length: 13,
                 },
             });
-            expect(mockMetrics.recordToolCallMetrics).toHaveBeenCalledWith(mockConfig, 'test-function', 100, true, ToolCallDecision.ACCEPT, 'native');
+            expect(mockMetrics.recordToolCallMetrics).toHaveBeenCalledWith(mockConfig, 100, {
+                function_name: 'test-function',
+                success: true,
+                decision: ToolCallDecision.ACCEPT,
+                tool_type: 'native',
+            });
             expect(mockUiEvent.addEvent).toHaveBeenCalledWith({
                 ...event,
                 'event.name': EVENT_TOOL_CALL,
@@ -401,10 +467,11 @@ describe('loggers', () => {
                 },
                 response: {
                     callId: 'test-call-id',
-                    responseParts: 'test-response',
+                    responseParts: [{ text: 'test-response' }],
                     resultDisplay: undefined,
                     error: undefined,
                     errorType: undefined,
+                    contentLength: undefined,
                 },
                 durationMs: 100,
                 outcome: ToolConfirmationOutcome.Cancel,
@@ -415,6 +482,7 @@ describe('loggers', () => {
                 body: 'Tool call: test-function. Decision: reject. Success: false. Duration: 100ms.',
                 attributes: {
                     'session.id': 'test-session-id',
+                    'user.email': 'test-user@example.com',
                     'event.name': EVENT_TOOL_CALL,
                     'event.timestamp': '2025-01-01T00:00:00.000Z',
                     function_name: 'test-function',
@@ -427,9 +495,18 @@ describe('loggers', () => {
                     decision: ToolCallDecision.REJECT,
                     prompt_id: 'prompt-id-2',
                     tool_type: 'native',
+                    error: undefined,
+                    error_type: undefined,
+                    metadata: undefined,
+                    content_length: undefined,
                 },
             });
-            expect(mockMetrics.recordToolCallMetrics).toHaveBeenCalledWith(mockConfig, 'test-function', 100, false, ToolCallDecision.REJECT, 'native');
+            expect(mockMetrics.recordToolCallMetrics).toHaveBeenCalledWith(mockConfig, 100, {
+                function_name: 'test-function',
+                success: false,
+                decision: ToolCallDecision.REJECT,
+                tool_type: 'native',
+            });
             expect(mockUiEvent.addEvent).toHaveBeenCalledWith({
                 ...event,
                 'event.name': EVENT_TOOL_CALL,
@@ -451,10 +528,11 @@ describe('loggers', () => {
                 },
                 response: {
                     callId: 'test-call-id',
-                    responseParts: 'test-response',
+                    responseParts: [{ text: 'test-response' }],
                     resultDisplay: undefined,
                     error: undefined,
                     errorType: undefined,
+                    contentLength: 13,
                 },
                 outcome: ToolConfirmationOutcome.ModifyWithEditor,
                 tool: new EditTool(mockConfig),
@@ -467,6 +545,7 @@ describe('loggers', () => {
                 body: 'Tool call: test-function. Decision: modify. Success: true. Duration: 100ms.',
                 attributes: {
                     'session.id': 'test-session-id',
+                    'user.email': 'test-user@example.com',
                     'event.name': EVENT_TOOL_CALL,
                     'event.timestamp': '2025-01-01T00:00:00.000Z',
                     function_name: 'test-function',
@@ -479,9 +558,18 @@ describe('loggers', () => {
                     decision: ToolCallDecision.MODIFY,
                     prompt_id: 'prompt-id-3',
                     tool_type: 'native',
+                    error: undefined,
+                    error_type: undefined,
+                    metadata: undefined,
+                    content_length: 13,
                 },
             });
-            expect(mockMetrics.recordToolCallMetrics).toHaveBeenCalledWith(mockConfig, 'test-function', 100, true, ToolCallDecision.MODIFY, 'native');
+            expect(mockMetrics.recordToolCallMetrics).toHaveBeenCalledWith(mockConfig, 100, {
+                function_name: 'test-function',
+                success: true,
+                decision: ToolCallDecision.MODIFY,
+                tool_type: 'native',
+            });
             expect(mockUiEvent.addEvent).toHaveBeenCalledWith({
                 ...event,
                 'event.name': EVENT_TOOL_CALL,
@@ -503,10 +591,11 @@ describe('loggers', () => {
                 },
                 response: {
                     callId: 'test-call-id',
-                    responseParts: 'test-response',
+                    responseParts: [{ text: 'test-response' }],
                     resultDisplay: undefined,
                     error: undefined,
                     errorType: undefined,
+                    contentLength: 13,
                 },
                 tool: new EditTool(mockConfig),
                 invocation: {},
@@ -518,6 +607,7 @@ describe('loggers', () => {
                 body: 'Tool call: test-function. Success: true. Duration: 100ms.',
                 attributes: {
                     'session.id': 'test-session-id',
+                    'user.email': 'test-user@example.com',
                     'event.name': EVENT_TOOL_CALL,
                     'event.timestamp': '2025-01-01T00:00:00.000Z',
                     function_name: 'test-function',
@@ -529,9 +619,19 @@ describe('loggers', () => {
                     success: true,
                     prompt_id: 'prompt-id-4',
                     tool_type: 'native',
+                    decision: undefined,
+                    error: undefined,
+                    error_type: undefined,
+                    metadata: undefined,
+                    content_length: 13,
                 },
             });
-            expect(mockMetrics.recordToolCallMetrics).toHaveBeenCalledWith(mockConfig, 'test-function', 100, true, undefined, 'native');
+            expect(mockMetrics.recordToolCallMetrics).toHaveBeenCalledWith(mockConfig, 100, {
+                function_name: 'test-function',
+                success: true,
+                decision: undefined,
+                tool_type: 'native',
+            });
             expect(mockUiEvent.addEvent).toHaveBeenCalledWith({
                 ...event,
                 'event.name': EVENT_TOOL_CALL,
@@ -539,6 +639,7 @@ describe('loggers', () => {
             });
         });
         it('should log a failed tool call with an error', () => {
+            const errorMessage = 'test-error';
             const call = {
                 status: 'error',
                 request: {
@@ -553,13 +654,11 @@ describe('loggers', () => {
                 },
                 response: {
                     callId: 'test-call-id',
-                    responseParts: 'test-response',
+                    responseParts: [{ text: 'test-response' }],
                     resultDisplay: undefined,
-                    error: {
-                        name: 'test-error-type',
-                        message: 'test-error',
-                    },
+                    error: new Error(errorMessage),
                     errorType: ToolErrorType.UNKNOWN,
+                    contentLength: errorMessage.length,
                 },
                 durationMs: 100,
             };
@@ -569,6 +668,7 @@ describe('loggers', () => {
                 body: 'Tool call: test-function. Success: false. Duration: 100ms.',
                 attributes: {
                     'session.id': 'test-session-id',
+                    'user.email': 'test-user@example.com',
                     'event.name': EVENT_TOOL_CALL,
                     'event.timestamp': '2025-01-01T00:00:00.000Z',
                     function_name: 'test-function',
@@ -584,15 +684,319 @@ describe('loggers', () => {
                     'error.type': ToolErrorType.UNKNOWN,
                     prompt_id: 'prompt-id-5',
                     tool_type: 'native',
+                    decision: undefined,
+                    metadata: undefined,
+                    content_length: errorMessage.length,
                 },
             });
-            expect(mockMetrics.recordToolCallMetrics).toHaveBeenCalledWith(mockConfig, 'test-function', 100, false, undefined, 'native');
+            expect(mockMetrics.recordToolCallMetrics).toHaveBeenCalledWith(mockConfig, 100, {
+                function_name: 'test-function',
+                success: false,
+                decision: undefined,
+                tool_type: 'native',
+            });
             expect(mockUiEvent.addEvent).toHaveBeenCalledWith({
                 ...event,
                 'event.name': EVENT_TOOL_CALL,
                 'event.timestamp': '2025-01-01T00:00:00.000Z',
             });
         });
+        it('should log a tool call with mcp_server_name for MCP tools', () => {
+            const mockMcpTool = new DiscoveredMCPTool({}, 'mock_mcp_server', 'mock_mcp_tool', 'tool description', {
+                type: 'object',
+                properties: {
+                    arg1: { type: 'string' },
+                    arg2: { type: 'number' },
+                },
+                required: ['arg1', 'arg2'],
+            });
+            const call = {
+                status: 'success',
+                request: {
+                    name: 'mock_mcp_tool',
+                    args: { arg1: 'value1', arg2: 2 },
+                    callId: 'test-call-id',
+                    isClientInitiated: true,
+                    prompt_id: 'prompt-id',
+                },
+                response: {
+                    callId: 'test-call-id',
+                    responseParts: [{ text: 'test-response' }],
+                    resultDisplay: undefined,
+                    error: undefined,
+                    errorType: undefined,
+                },
+                tool: mockMcpTool,
+                invocation: {},
+                durationMs: 100,
+            };
+            const event = new ToolCallEvent(call);
+            logToolCall(mockConfig, event);
+            expect(mockLogger.emit).toHaveBeenCalledWith({
+                body: 'Tool call: mock_mcp_tool. Success: true. Duration: 100ms.',
+                attributes: {
+                    'session.id': 'test-session-id',
+                    'user.email': 'test-user@example.com',
+                    'event.name': EVENT_TOOL_CALL,
+                    'event.timestamp': '2025-01-01T00:00:00.000Z',
+                    function_name: 'mock_mcp_tool',
+                    function_args: JSON.stringify({
+                        arg1: 'value1',
+                        arg2: 2,
+                    }, null, 2),
+                    duration_ms: 100,
+                    success: true,
+                    prompt_id: 'prompt-id',
+                    tool_type: 'mcp',
+                    mcp_server_name: 'mock_mcp_server',
+                    decision: undefined,
+                    error: undefined,
+                    error_type: undefined,
+                    metadata: undefined,
+                },
+            });
+        });
+    });
+    describe('logMalformedJsonResponse', () => {
+        beforeEach(() => {
+            vi.spyOn(ClearcutLogger.prototype, 'logMalformedJsonResponseEvent');
+        });
+        it('logs the event to Clearcut and OTEL', () => {
+            const mockConfig = makeFakeConfig();
+            const event = new MalformedJsonResponseEvent('test-model');
+            logMalformedJsonResponse(mockConfig, event);
+            expect(ClearcutLogger.prototype.logMalformedJsonResponseEvent).toHaveBeenCalledWith(event);
+            expect(mockLogger.emit).toHaveBeenCalledWith({
+                body: 'Malformed JSON response from test-model.',
+                attributes: {
+                    'session.id': 'test-session-id',
+                    'user.email': 'test-user@example.com',
+                    'event.name': EVENT_MALFORMED_JSON_RESPONSE,
+                    'event.timestamp': '2025-01-01T00:00:00.000Z',
+                    model: 'test-model',
+                },
+            });
+        });
+    });
+    describe('logFileOperation', () => {
+        const mockConfig = {
+            getSessionId: () => 'test-session-id',
+            getTargetDir: () => 'target-dir',
+            getUsageStatisticsEnabled: () => true,
+            getTelemetryEnabled: () => true,
+            getTelemetryLogPromptsEnabled: () => true,
+        };
+        const mockMetrics = {
+            recordFileOperationMetric: vi.fn(),
+        };
+        beforeEach(() => {
+            vi.spyOn(metrics, 'recordFileOperationMetric').mockImplementation(mockMetrics.recordFileOperationMetric);
+        });
+        it('should log a file operation event', () => {
+            const event = new FileOperationEvent('test-tool', FileOperation.READ, 10, 'text/plain', '.txt', 'typescript');
+            logFileOperation(mockConfig, event);
+            expect(mockLogger.emit).toHaveBeenCalledWith({
+                body: 'File operation: read. Lines: 10.',
+                attributes: {
+                    'session.id': 'test-session-id',
+                    'user.email': 'test-user@example.com',
+                    'event.name': EVENT_FILE_OPERATION,
+                    'event.timestamp': '2025-01-01T00:00:00.000Z',
+                    tool_name: 'test-tool',
+                    operation: 'read',
+                    lines: 10,
+                    mimetype: 'text/plain',
+                    extension: '.txt',
+                    programming_language: 'typescript',
+                },
+            });
+            expect(mockMetrics.recordFileOperationMetric).toHaveBeenCalledWith(mockConfig, {
+                operation: 'read',
+                lines: 10,
+                mimetype: 'text/plain',
+                extension: '.txt',
+                programming_language: 'typescript',
+            });
+        });
+    });
+    describe('logToolOutputTruncated', () => {
+        const mockConfig = {
+            getSessionId: () => 'test-session-id',
+            getUsageStatisticsEnabled: () => true,
+        };
+        it('should log a tool output truncated event', () => {
+            const event = new ToolOutputTruncatedEvent('prompt-id-1', {
+                toolName: 'test-tool',
+                originalContentLength: 1000,
+                truncatedContentLength: 100,
+                threshold: 500,
+                lines: 10,
+            });
+            logToolOutputTruncated(mockConfig, event);
+            expect(mockLogger.emit).toHaveBeenCalledWith({
+                body: 'Tool output truncated for test-tool.',
+                attributes: {
+                    'session.id': 'test-session-id',
+                    'user.email': 'test-user@example.com',
+                    'event.name': 'tool_output_truncated',
+                    'event.timestamp': '2025-01-01T00:00:00.000Z',
+                    eventName: 'tool_output_truncated',
+                    prompt_id: 'prompt-id-1',
+                    tool_name: 'test-tool',
+                    original_content_length: 1000,
+                    truncated_content_length: 100,
+                    threshold: 500,
+                    lines: 10,
+                },
+            });
+        });
+    });
+    describe('logModelRouting', () => {
+        const mockConfig = {
+            getSessionId: () => 'test-session-id',
+            getUsageStatisticsEnabled: () => true,
+        };
+        beforeEach(() => {
+            vi.spyOn(ClearcutLogger.prototype, 'logModelRoutingEvent');
+            vi.spyOn(metrics, 'recordModelRoutingMetrics');
+        });
+        it('should log the event to Clearcut and OTEL, and record metrics', () => {
+            const event = new ModelRoutingEvent('gemini-pro', 'default', 100, 'test-reason', false, undefined);
+            logModelRouting(mockConfig, event);
+            expect(ClearcutLogger.prototype.logModelRoutingEvent).toHaveBeenCalledWith(event);
+            expect(mockLogger.emit).toHaveBeenCalledWith({
+                body: 'Model routing decision. Model: gemini-pro, Source: default',
+                attributes: {
+                    'session.id': 'test-session-id',
+                    'user.email': 'test-user@example.com',
+                    ...event,
+                    'event.name': EVENT_MODEL_ROUTING,
+                },
+            });
+            expect(metrics.recordModelRoutingMetrics).toHaveBeenCalledWith(mockConfig, event);
+        });
+        it('should only log to Clearcut if OTEL SDK is not initialized', () => {
+            vi.spyOn(sdk, 'isTelemetrySdkInitialized').mockReturnValue(false);
+            const event = new ModelRoutingEvent('gemini-pro', 'default', 100, 'test-reason', false, undefined);
+            logModelRouting(mockConfig, event);
+            expect(ClearcutLogger.prototype.logModelRoutingEvent).toHaveBeenCalledWith(event);
+            expect(mockLogger.emit).not.toHaveBeenCalled();
+            expect(metrics.recordModelRoutingMetrics).not.toHaveBeenCalled();
+        });
+    });
+    describe('logExtensionInstall', () => {
+        const mockConfig = {
+            getSessionId: () => 'test-session-id',
+            getUsageStatisticsEnabled: () => true,
+        };
+        beforeEach(() => {
+            vi.spyOn(ClearcutLogger.prototype, 'logExtensionInstallEvent');
+        });
+        afterEach(() => {
+            vi.resetAllMocks();
+        });
+        it('should log extension install event', () => {
+            const event = new ExtensionInstallEvent('vscode', '0.1.0', 'git', 'success');
+            logExtensionInstallEvent(mockConfig, event);
+            expect(ClearcutLogger.prototype.logExtensionInstallEvent).toHaveBeenCalledWith(event);
+            expect(mockLogger.emit).toHaveBeenCalledWith({
+                body: 'Installed extension vscode',
+                attributes: {
+                    'session.id': 'test-session-id',
+                    'user.email': 'test-user@example.com',
+                    'event.name': EVENT_EXTENSION_INSTALL,
+                    'event.timestamp': '2025-01-01T00:00:00.000Z',
+                    extension_name: 'vscode',
+                    extension_version: '0.1.0',
+                    extension_source: 'git',
+                    status: 'success',
+                },
+            });
+        });
+    });
+    describe('logExtensionUninstall', () => {
+        const mockConfig = {
+            getSessionId: () => 'test-session-id',
+            getUsageStatisticsEnabled: () => true,
+        };
+        beforeEach(() => {
+            vi.spyOn(ClearcutLogger.prototype, 'logExtensionUninstallEvent');
+        });
+        afterEach(() => {
+            vi.resetAllMocks();
+        });
+        it('should log extension uninstall event', () => {
+            const event = new ExtensionUninstallEvent('vscode', 'success');
+            logExtensionUninstall(mockConfig, event);
+            expect(ClearcutLogger.prototype.logExtensionUninstallEvent).toHaveBeenCalledWith(event);
+            expect(mockLogger.emit).toHaveBeenCalledWith({
+                body: 'Uninstalled extension vscode',
+                attributes: {
+                    'session.id': 'test-session-id',
+                    'user.email': 'test-user@example.com',
+                    'event.name': EVENT_EXTENSION_UNINSTALL,
+                    'event.timestamp': '2025-01-01T00:00:00.000Z',
+                    extension_name: 'vscode',
+                    status: 'success',
+                },
+            });
+        });
+    });
+    describe('logExtensionEnable', () => {
+        const mockConfig = {
+            getSessionId: () => 'test-session-id',
+            getUsageStatisticsEnabled: () => true,
+        };
+        beforeEach(() => {
+            vi.spyOn(ClearcutLogger.prototype, 'logExtensionEnableEvent');
+        });
+        afterEach(() => {
+            vi.resetAllMocks();
+        });
+        it('should log extension enable event', () => {
+            const event = new ExtensionEnableEvent('vscode', 'user');
+            logExtensionEnable(mockConfig, event);
+            expect(ClearcutLogger.prototype.logExtensionEnableEvent).toHaveBeenCalledWith(event);
+            expect(mockLogger.emit).toHaveBeenCalledWith({
+                body: 'Enabled extension vscode',
+                attributes: {
+                    'session.id': 'test-session-id',
+                    'user.email': 'test-user@example.com',
+                    'event.name': EVENT_EXTENSION_ENABLE,
+                    'event.timestamp': '2025-01-01T00:00:00.000Z',
+                    extension_name: 'vscode',
+                    setting_scope: 'user',
+                },
+            });
+        });
+    });
+    describe('logExtensionDisable', () => {
+        const mockConfig = {
+            getSessionId: () => 'test-session-id',
+            getUsageStatisticsEnabled: () => true,
+        };
+        beforeEach(() => {
+            vi.spyOn(ClearcutLogger.prototype, 'logExtensionDisableEvent');
+        });
+        afterEach(() => {
+            vi.resetAllMocks();
+        });
+        it('should log extension disable event', () => {
+            const event = new ExtensionDisableEvent('vscode', 'user');
+            logExtensionDisable(mockConfig, event);
+            expect(ClearcutLogger.prototype.logExtensionDisableEvent).toHaveBeenCalledWith(event);
+            expect(mockLogger.emit).toHaveBeenCalledWith({
+                body: 'Disabled extension vscode',
+                attributes: {
+                    'session.id': 'test-session-id',
+                    'user.email': 'test-user@example.com',
+                    'event.name': EVENT_EXTENSION_DISABLE,
+                    'event.timestamp': '2025-01-01T00:00:00.000Z',
+                    extension_name: 'vscode',
+                    setting_scope: 'user',
+                },
+            });
+        });
     });
 });
 //# sourceMappingURL=loggers.test.js.map