@didim365/agent-cli-core 0.1.1 → 0.1.2

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

@@ -1,1176 +0,0 @@
-/**
- * @license
- * Copyright 2025 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { FileOperation, MemoryMetricType, ToolExecutionPhase, ApiRequestPhase, } from './metrics.js';
-import { makeFakeConfig } from '../test-utils/config.js';
-import { ModelRoutingEvent, AgentFinishEvent } from './types.js';
-import { AgentTerminateMode } from '../agents/types.js';
-const mockCounterAddFn = vi.fn();
-const mockHistogramRecordFn = vi.fn();
-const mockCreateCounterFn = vi.fn();
-const mockCreateHistogramFn = vi.fn();
-const mockCounterInstance = {
-    add: mockCounterAddFn,
-};
-const mockHistogramInstance = {
-    record: mockHistogramRecordFn,
-};
-const mockMeterInstance = {
-    createCounter: mockCreateCounterFn.mockReturnValue(mockCounterInstance),
-    createHistogram: mockCreateHistogramFn.mockReturnValue(mockHistogramInstance),
-};
-function originalOtelMockFactory() {
-    return {
-        metrics: {
-            getMeter: vi.fn(),
-        },
-        ValueType: {
-            INT: 1,
-            DOUBLE: 2,
-        },
-        diag: {
-            setLogger: vi.fn(),
-            warn: vi.fn(),
-        },
-        DiagConsoleLogger: vi.fn(),
-        DiagLogLevel: {
-            NONE: 0,
-            INFO: 1,
-        },
-    };
-}
-vi.mock('@opentelemetry/api');
-vi.mock('./telemetryAttributes.js');
-describe('Telemetry Metrics', () => {
-    let initializeMetricsModule;
-    let recordTokenUsageMetricsModule;
-    let recordFileOperationMetricModule;
-    let recordChatCompressionMetricsModule;
-    let recordModelRoutingMetricsModule;
-    let recordStartupPerformanceModule;
-    let recordMemoryUsageModule;
-    let recordCpuUsageModule;
-    let recordToolQueueDepthModule;
-    let recordToolExecutionBreakdownModule;
-    let recordTokenEfficiencyModule;
-    let recordApiRequestBreakdownModule;
-    let recordPerformanceScoreModule;
-    let recordPerformanceRegressionModule;
-    let recordBaselineComparisonModule;
-    let recordGenAiClientTokenUsageModule;
-    let recordGenAiClientOperationDurationModule;
-    let recordFlickerFrameModule;
-    let recordExitFailModule;
-    let recordAgentRunMetricsModule;
-    let recordLinesChangedModule;
-    let recordSlowRenderModule;
-    beforeEach(async () => {
-        vi.resetModules();
-        vi.doMock('@opentelemetry/api', () => {
-            const actualApi = originalOtelMockFactory();
-            actualApi.metrics.getMeter.mockReturnValue(mockMeterInstance);
-            return actualApi;
-        });
-        const { getCommonAttributes } = await import('./telemetryAttributes.js');
-        getCommonAttributes.mockReturnValue({
-            'session.id': 'test-session-id',
-            'installation.id': 'test-installation-id',
-            'user.email': 'test@example.com',
-        });
-        const metricsJsModule = await import('./metrics.js');
-        initializeMetricsModule = metricsJsModule.initializeMetrics;
-        recordTokenUsageMetricsModule = metricsJsModule.recordTokenUsageMetrics;
-        recordFileOperationMetricModule = metricsJsModule.recordFileOperationMetric;
-        recordChatCompressionMetricsModule =
-            metricsJsModule.recordChatCompressionMetrics;
-        recordModelRoutingMetricsModule = metricsJsModule.recordModelRoutingMetrics;
-        recordStartupPerformanceModule = metricsJsModule.recordStartupPerformance;
-        recordMemoryUsageModule = metricsJsModule.recordMemoryUsage;
-        recordCpuUsageModule = metricsJsModule.recordCpuUsage;
-        recordToolQueueDepthModule = metricsJsModule.recordToolQueueDepth;
-        recordToolExecutionBreakdownModule =
-            metricsJsModule.recordToolExecutionBreakdown;
-        recordTokenEfficiencyModule = metricsJsModule.recordTokenEfficiency;
-        recordApiRequestBreakdownModule = metricsJsModule.recordApiRequestBreakdown;
-        recordPerformanceScoreModule = metricsJsModule.recordPerformanceScore;
-        recordPerformanceRegressionModule =
-            metricsJsModule.recordPerformanceRegression;
-        recordBaselineComparisonModule = metricsJsModule.recordBaselineComparison;
-        recordGenAiClientTokenUsageModule =
-            metricsJsModule.recordGenAiClientTokenUsage;
-        recordGenAiClientOperationDurationModule =
-            metricsJsModule.recordGenAiClientOperationDuration;
-        recordFlickerFrameModule = metricsJsModule.recordFlickerFrame;
-        recordExitFailModule = metricsJsModule.recordExitFail;
-        recordAgentRunMetricsModule = metricsJsModule.recordAgentRunMetrics;
-        recordLinesChangedModule = metricsJsModule.recordLinesChanged;
-        recordSlowRenderModule = metricsJsModule.recordSlowRender;
-        const otelApiModule = await import('@opentelemetry/api');
-        mockCounterAddFn.mockClear();
-        mockCreateCounterFn.mockClear();
-        mockCreateHistogramFn.mockClear();
-        mockHistogramRecordFn.mockClear();
-        otelApiModule.metrics.getMeter.mockClear();
-        otelApiModule.metrics.getMeter.mockReturnValue(mockMeterInstance);
-        mockCreateCounterFn.mockReturnValue(mockCounterInstance);
-        mockCreateHistogramFn.mockReturnValue(mockHistogramInstance);
-    });
-    describe('recordFlickerFrame', () => {
-        it('does not record metrics if not initialized', () => {
-            const config = makeFakeConfig({});
-            recordFlickerFrameModule(config);
-            expect(mockCounterAddFn).not.toHaveBeenCalled();
-        });
-        it('records a flicker frame event when initialized', () => {
-            const config = makeFakeConfig({});
-            initializeMetricsModule(config);
-            recordFlickerFrameModule(config);
-            // Called for session, then for flicker
-            expect(mockCounterAddFn).toHaveBeenCalledTimes(2);
-            expect(mockCounterAddFn).toHaveBeenNthCalledWith(2, 1, {
-                'session.id': 'test-session-id',
-                'installation.id': 'test-installation-id',
-                'user.email': 'test@example.com',
-            });
-        });
-    });
-    describe('recordExitFail', () => {
-        it('does not record metrics if not initialized', () => {
-            const config = makeFakeConfig({});
-            recordExitFailModule(config);
-            expect(mockCounterAddFn).not.toHaveBeenCalled();
-        });
-        it('records a exit fail event when initialized', () => {
-            const config = makeFakeConfig({});
-            initializeMetricsModule(config);
-            recordExitFailModule(config);
-            // Called for session, then for exit fail
-            expect(mockCounterAddFn).toHaveBeenCalledTimes(2);
-            expect(mockCounterAddFn).toHaveBeenNthCalledWith(2, 1, {
-                'session.id': 'test-session-id',
-                'installation.id': 'test-installation-id',
-                'user.email': 'test@example.com',
-            });
-        });
-    });
-    describe('recordSlowRender', () => {
-        it('does not record metrics if not initialized', () => {
-            const config = makeFakeConfig({});
-            recordSlowRenderModule(config, 123);
-            expect(mockHistogramRecordFn).not.toHaveBeenCalled();
-        });
-        it('records a slow render event when initialized', () => {
-            const config = makeFakeConfig({});
-            initializeMetricsModule(config);
-            recordSlowRenderModule(config, 123);
-            expect(mockHistogramRecordFn).toHaveBeenCalledWith(123, {
-                'session.id': 'test-session-id',
-                'installation.id': 'test-installation-id',
-                'user.email': 'test@example.com',
-            });
-        });
-    });
-    describe('initializeMetrics', () => {
-        const mockConfig = {
-            getSessionId: () => 'test-session-id',
-            getTelemetryEnabled: () => true,
-        };
-        it('should apply common attributes including email', () => {
-            initializeMetricsModule(mockConfig);
-            expect(mockCounterAddFn).toHaveBeenCalledWith(1, {
-                'session.id': 'test-session-id',
-                'installation.id': 'test-installation-id',
-                'user.email': 'test@example.com',
-            });
-        });
-    });
-    describe('recordChatCompressionMetrics', () => {
-        it('does not record metrics if not initialized', () => {
-            const lol = makeFakeConfig({});
-            recordChatCompressionMetricsModule(lol, {
-                tokens_after: 100,
-                tokens_before: 200,
-            });
-            expect(mockCounterAddFn).not.toHaveBeenCalled();
-        });
-        it('records token compression with the correct attributes', () => {
-            const config = makeFakeConfig({});
-            initializeMetricsModule(config);
-            recordChatCompressionMetricsModule(config, {
-                tokens_after: 100,
-                tokens_before: 200,
-            });
-            expect(mockCounterAddFn).toHaveBeenCalledWith(1, {
-                'session.id': 'test-session-id',
-                'installation.id': 'test-installation-id',
-                'user.email': 'test@example.com',
-                tokens_after: 100,
-                tokens_before: 200,
-            });
-        });
-    });
-    describe('recordTokenUsageMetrics', () => {
-        const mockConfig = {
-            getSessionId: () => 'test-session-id',
-            getTelemetryEnabled: () => true,
-        };
-        it('should not record metrics if not initialized', () => {
-            recordTokenUsageMetricsModule(mockConfig, 100, {
-                model: 'gemini-pro',
-                type: 'input',
-            });
-            expect(mockCounterAddFn).not.toHaveBeenCalled();
-        });
-        it.each([
-            { type: 'input', tokens: 100, model: 'gemini-pro' },
-            { type: 'output', tokens: 50, model: 'gemini-pro' },
-            { type: 'thought', tokens: 25, model: 'gemini-pro' },
-            { type: 'cache', tokens: 75, model: 'gemini-pro' },
-            { type: 'tool', tokens: 125, model: 'gemini-pro' },
-            { type: 'input', tokens: 200, model: 'gemini-different-model' },
-        ])('should record token usage for $type type with $tokens tokens for model $model', ({ type, tokens, model }) => {
-            initializeMetricsModule(mockConfig);
-            mockCounterAddFn.mockClear();
-            recordTokenUsageMetricsModule(mockConfig, tokens, {
-                model,
-                type: type,
-            });
-            expect(mockCounterAddFn).toHaveBeenCalledWith(tokens, {
-                'session.id': 'test-session-id',
-                'installation.id': 'test-installation-id',
-                'user.email': 'test@example.com',
-                model,
-                type,
-            });
-        });
-    });
-    describe('recordLinesChanged metric', () => {
-        const mockConfig = {
-            getSessionId: () => 'test-session-id',
-            getTelemetryEnabled: () => true,
-        };
-        it('should not record lines added/removed if not initialized', () => {
-            recordLinesChangedModule(mockConfig, 10, 'added', {
-                function_name: 'fn',
-            });
-            recordLinesChangedModule(mockConfig, 5, 'removed', {
-                function_name: 'fn',
-            });
-            expect(mockCounterAddFn).not.toHaveBeenCalled();
-        });
-        it('should record lines added with function_name after initialization', () => {
-            initializeMetricsModule(mockConfig);
-            mockCounterAddFn.mockClear();
-            recordLinesChangedModule(mockConfig, 10, 'added', {
-                function_name: 'my-fn',
-            });
-            expect(mockCounterAddFn).toHaveBeenCalledWith(10, {
-                'session.id': 'test-session-id',
-                'installation.id': 'test-installation-id',
-                'user.email': 'test@example.com',
-                type: 'added',
-                function_name: 'my-fn',
-            });
-        });
-        it('should record lines removed with function_name after initialization', () => {
-            initializeMetricsModule(mockConfig);
-            mockCounterAddFn.mockClear();
-            recordLinesChangedModule(mockConfig, 7, 'removed', {
-                function_name: 'my-fn',
-            });
-            expect(mockCounterAddFn).toHaveBeenCalledWith(7, {
-                'session.id': 'test-session-id',
-                'installation.id': 'test-installation-id',
-                'user.email': 'test@example.com',
-                type: 'removed',
-                function_name: 'my-fn',
-            });
-        });
-    });
-    describe('recordFileOperationMetric', () => {
-        const mockConfig = {
-            getSessionId: () => 'test-session-id',
-            getTelemetryEnabled: () => true,
-        };
-        it.each([
-            {
-                name: 'should not record metrics if not initialized',
-                initialized: false,
-                attributes: {
-                    operation: FileOperation.CREATE,
-                    lines: 10,
-                    mimetype: 'text/plain',
-                    extension: 'txt',
-                },
-                shouldCall: false,
-            },
-            {
-                name: 'should record file creation with all attributes',
-                initialized: true,
-                attributes: {
-                    operation: FileOperation.CREATE,
-                    lines: 10,
-                    mimetype: 'text/plain',
-                    extension: 'txt',
-                },
-                shouldCall: true,
-            },
-            {
-                name: 'should record file read with minimal attributes',
-                initialized: true,
-                attributes: { operation: FileOperation.READ },
-                shouldCall: true,
-            },
-            {
-                name: 'should record file update with some attributes',
-                initialized: true,
-                attributes: {
-                    operation: FileOperation.UPDATE,
-                    mimetype: 'application/javascript',
-                },
-                shouldCall: true,
-            },
-            {
-                name: 'should record file update with no optional attributes',
-                initialized: true,
-                attributes: { operation: FileOperation.UPDATE },
-                shouldCall: true,
-            },
-        ])('$name', ({ initialized, attributes, shouldCall }) => {
-            if (initialized) {
-                initializeMetricsModule(mockConfig);
-                // The session start event also calls the counter.
-                mockCounterAddFn.mockClear();
-            }
-            recordFileOperationMetricModule(mockConfig, attributes);
-            if (shouldCall) {
-                expect(mockCounterAddFn).toHaveBeenCalledWith(1, {
-                    'session.id': 'test-session-id',
-                    'installation.id': 'test-installation-id',
-                    'user.email': 'test@example.com',
-                    ...attributes,
-                });
-            }
-            else {
-                expect(mockCounterAddFn).not.toHaveBeenCalled();
-            }
-        });
-    });
-    describe('recordModelRoutingMetrics', () => {
-        const mockConfig = {
-            getSessionId: () => 'test-session-id',
-            getTelemetryEnabled: () => true,
-        };
-        it('should not record metrics if not initialized', () => {
-            const event = new ModelRoutingEvent('gemini-pro', 'default', 100, 'test-reason', false, undefined);
-            recordModelRoutingMetricsModule(mockConfig, event);
-            expect(mockHistogramRecordFn).not.toHaveBeenCalled();
-            expect(mockCounterAddFn).not.toHaveBeenCalled();
-        });
-        it('should record latency for a successful routing decision', () => {
-            initializeMetricsModule(mockConfig);
-            const event = new ModelRoutingEvent('gemini-pro', 'default', 150, 'test-reason', false, undefined);
-            recordModelRoutingMetricsModule(mockConfig, event);
-            expect(mockHistogramRecordFn).toHaveBeenCalledWith(150, {
-                'session.id': 'test-session-id',
-                'installation.id': 'test-installation-id',
-                'user.email': 'test@example.com',
-                'routing.decision_model': 'gemini-pro',
-                'routing.decision_source': 'default',
-                'routing.failed': false,
-                'routing.reasoning': 'test-reason',
-            });
-            // The session counter is called once on init
-            expect(mockCounterAddFn).toHaveBeenCalledTimes(1);
-        });
-        it('should record latency and failure for a failed routing decision', () => {
-            initializeMetricsModule(mockConfig);
-            const event = new ModelRoutingEvent('gemini-pro', 'classifier', 200, 'test-reason', true, 'test-error');
-            recordModelRoutingMetricsModule(mockConfig, event);
-            expect(mockHistogramRecordFn).toHaveBeenCalledWith(200, {
-                'session.id': 'test-session-id',
-                'installation.id': 'test-installation-id',
-                'user.email': 'test@example.com',
-                'routing.decision_model': 'gemini-pro',
-                'routing.decision_source': 'classifier',
-                'routing.failed': true,
-                'routing.reasoning': 'test-reason',
-            });
-            expect(mockCounterAddFn).toHaveBeenCalledTimes(2);
-            expect(mockCounterAddFn).toHaveBeenNthCalledWith(2, 1, {
-                'session.id': 'test-session-id',
-                'installation.id': 'test-installation-id',
-                'user.email': 'test@example.com',
-                'routing.decision_model': 'gemini-pro',
-                'routing.decision_source': 'classifier',
-                'routing.failed': true,
-                'routing.reasoning': 'test-reason',
-                'routing.error_message': 'test-error',
-            });
-        });
-    });
-    describe('recordAgentRunMetrics', () => {
-        const mockConfig = {
-            getSessionId: () => 'test-session-id',
-            getTelemetryEnabled: () => true,
-        };
-        it('should not record metrics if not initialized', () => {
-            const event = new AgentFinishEvent('agent-123', 'TestAgent', 1000, 5, AgentTerminateMode.GOAL);
-            recordAgentRunMetricsModule(mockConfig, event);
-            expect(mockCounterAddFn).not.toHaveBeenCalled();
-            expect(mockHistogramRecordFn).not.toHaveBeenCalled();
-        });
-        it('should record agent run metrics', () => {
-            initializeMetricsModule(mockConfig);
-            mockCounterAddFn.mockClear();
-            mockHistogramRecordFn.mockClear();
-            const event = new AgentFinishEvent('agent-123', 'TestAgent', 1000, 5, AgentTerminateMode.GOAL);
-            recordAgentRunMetricsModule(mockConfig, event);
-            // Verify agent run counter
-            expect(mockCounterAddFn).toHaveBeenCalledWith(1, {
-                'session.id': 'test-session-id',
-                'installation.id': 'test-installation-id',
-                'user.email': 'test@example.com',
-                agent_name: 'TestAgent',
-                terminate_reason: 'GOAL',
-            });
-            // Verify agent duration histogram
-            expect(mockHistogramRecordFn).toHaveBeenCalledWith(1000, {
-                'session.id': 'test-session-id',
-                'installation.id': 'test-installation-id',
-                'user.email': 'test@example.com',
-                agent_name: 'TestAgent',
-            });
-            // Verify agent turns histogram
-            expect(mockHistogramRecordFn).toHaveBeenCalledWith(5, {
-                'session.id': 'test-session-id',
-                'installation.id': 'test-installation-id',
-                'user.email': 'test@example.com',
-                agent_name: 'TestAgent',
-            });
-        });
-    });
-    describe('OpenTelemetry GenAI Semantic Convention Metrics', () => {
-        const mockConfig = {
-            getSessionId: () => 'test-session-id',
-            getTelemetryEnabled: () => true,
-        };
-        describe('recordGenAiClientTokenUsage', () => {
-            it('should not record metrics when not initialized', () => {
-                recordGenAiClientTokenUsageModule(mockConfig, 100, {
-                    'gen_ai.operation.name': 'generate_content',
-                    'gen_ai.provider.name': 'gcp.gen_ai',
-                    'gen_ai.token.type': 'input',
-                });
-                expect(mockHistogramRecordFn).not.toHaveBeenCalled();
-            });
-            it('should record input token usage with correct attributes', () => {
-                initializeMetricsModule(mockConfig);
-                mockHistogramRecordFn.mockClear();
-                recordGenAiClientTokenUsageModule(mockConfig, 150, {
-                    'gen_ai.operation.name': 'generate_content',
-                    'gen_ai.provider.name': 'gcp.gen_ai',
-                    'gen_ai.token.type': 'input',
-                    'gen_ai.request.model': 'gemini-2.0-flash',
-                    'gen_ai.response.model': 'gemini-2.0-flash',
-                });
-                expect(mockHistogramRecordFn).toHaveBeenCalledWith(150, {
-                    'session.id': 'test-session-id',
-                    'installation.id': 'test-installation-id',
-                    'user.email': 'test@example.com',
-                    'gen_ai.operation.name': 'generate_content',
-                    'gen_ai.provider.name': 'gcp.gen_ai',
-                    'gen_ai.token.type': 'input',
-                    'gen_ai.request.model': 'gemini-2.0-flash',
-                    'gen_ai.response.model': 'gemini-2.0-flash',
-                });
-            });
-            it('should record output token usage with correct attributes', () => {
-                initializeMetricsModule(mockConfig);
-                mockHistogramRecordFn.mockClear();
-                recordGenAiClientTokenUsageModule(mockConfig, 75, {
-                    'gen_ai.operation.name': 'generate_content',
-                    'gen_ai.provider.name': 'gcp.vertex_ai',
-                    'gen_ai.token.type': 'output',
-                    'gen_ai.request.model': 'gemini-pro',
-                });
-                expect(mockHistogramRecordFn).toHaveBeenCalledWith(75, {
-                    'session.id': 'test-session-id',
-                    'installation.id': 'test-installation-id',
-                    'user.email': 'test@example.com',
-                    'gen_ai.operation.name': 'generate_content',
-                    'gen_ai.provider.name': 'gcp.vertex_ai',
-                    'gen_ai.token.type': 'output',
-                    'gen_ai.request.model': 'gemini-pro',
-                });
-            });
-            it('should record token usage with optional attributes', () => {
-                initializeMetricsModule(mockConfig);
-                mockHistogramRecordFn.mockClear();
-                recordGenAiClientTokenUsageModule(mockConfig, 200, {
-                    'gen_ai.operation.name': 'generate_content',
-                    'gen_ai.provider.name': 'gcp.vertex_ai',
-                    'gen_ai.token.type': 'input',
-                    'gen_ai.request.model': 'text-embedding-004',
-                    'server.address': 'aiplatform.googleapis.com',
-                    'server.port': 443,
-                });
-                expect(mockHistogramRecordFn).toHaveBeenCalledWith(200, {
-                    'session.id': 'test-session-id',
-                    'installation.id': 'test-installation-id',
-                    'user.email': 'test@example.com',
-                    'gen_ai.operation.name': 'generate_content',
-                    'gen_ai.provider.name': 'gcp.vertex_ai',
-                    'gen_ai.token.type': 'input',
-                    'gen_ai.request.model': 'text-embedding-004',
-                    'server.address': 'aiplatform.googleapis.com',
-                    'server.port': 443,
-                });
-            });
-        });
-        describe('recordGenAiClientOperationDuration', () => {
-            it('should not record metrics when not initialized', () => {
-                recordGenAiClientOperationDurationModule(mockConfig, 2.5, {
-                    'gen_ai.operation.name': 'generate_content',
-                    'gen_ai.provider.name': 'gcp.gen_ai',
-                });
-                expect(mockHistogramRecordFn).not.toHaveBeenCalled();
-            });
-            it('should record successful operation duration with correct attributes', () => {
-                initializeMetricsModule(mockConfig);
-                mockHistogramRecordFn.mockClear();
-                recordGenAiClientOperationDurationModule(mockConfig, 1.25, {
-                    'gen_ai.operation.name': 'generate_content',
-                    'gen_ai.provider.name': 'gcp.gen_ai',
-                    'gen_ai.request.model': 'gemini-2.0-flash',
-                    'gen_ai.response.model': 'gemini-2.0-flash',
-                });
-                expect(mockHistogramRecordFn).toHaveBeenCalledWith(1.25, {
-                    'session.id': 'test-session-id',
-                    'installation.id': 'test-installation-id',
-                    'user.email': 'test@example.com',
-                    'gen_ai.operation.name': 'generate_content',
-                    'gen_ai.provider.name': 'gcp.gen_ai',
-                    'gen_ai.request.model': 'gemini-2.0-flash',
-                    'gen_ai.response.model': 'gemini-2.0-flash',
-                });
-            });
-            it('should record failed operation duration with error type', () => {
-                initializeMetricsModule(mockConfig);
-                mockHistogramRecordFn.mockClear();
-                recordGenAiClientOperationDurationModule(mockConfig, 3.75, {
-                    'gen_ai.operation.name': 'generate_content',
-                    'gen_ai.provider.name': 'gcp.vertex_ai',
-                    'gen_ai.request.model': 'gemini-pro',
-                    'error.type': 'quota_exceeded',
-                });
-                expect(mockHistogramRecordFn).toHaveBeenCalledWith(3.75, {
-                    'session.id': 'test-session-id',
-                    'installation.id': 'test-installation-id',
-                    'user.email': 'test@example.com',
-                    'gen_ai.operation.name': 'generate_content',
-                    'gen_ai.provider.name': 'gcp.vertex_ai',
-                    'gen_ai.request.model': 'gemini-pro',
-                    'error.type': 'quota_exceeded',
-                });
-            });
-            it('should record operation duration with server details', () => {
-                initializeMetricsModule(mockConfig);
-                mockHistogramRecordFn.mockClear();
-                recordGenAiClientOperationDurationModule(mockConfig, 0.95, {
-                    'gen_ai.operation.name': 'generate_content',
-                    'gen_ai.provider.name': 'gcp.vertex_ai',
-                    'gen_ai.request.model': 'gemini-1.5-pro',
-                    'gen_ai.response.model': 'gemini-1.5-pro-001',
-                    'server.address': 'us-central1-aiplatform.googleapis.com',
-                    'server.port': 443,
-                });
-                expect(mockHistogramRecordFn).toHaveBeenCalledWith(0.95, {
-                    'session.id': 'test-session-id',
-                    'installation.id': 'test-installation-id',
-                    'user.email': 'test@example.com',
-                    'gen_ai.operation.name': 'generate_content',
-                    'gen_ai.provider.name': 'gcp.vertex_ai',
-                    'gen_ai.request.model': 'gemini-1.5-pro',
-                    'gen_ai.response.model': 'gemini-1.5-pro-001',
-                    'server.address': 'us-central1-aiplatform.googleapis.com',
-                    'server.port': 443,
-                });
-            });
-            it('should handle minimal required attributes', () => {
-                initializeMetricsModule(mockConfig);
-                mockHistogramRecordFn.mockClear();
-                recordGenAiClientOperationDurationModule(mockConfig, 2.1, {
-                    'gen_ai.operation.name': 'generate_content',
-                    'gen_ai.provider.name': 'gcp.gen_ai',
-                });
-                expect(mockHistogramRecordFn).toHaveBeenCalledWith(2.1, {
-                    'session.id': 'test-session-id',
-                    'installation.id': 'test-installation-id',
-                    'user.email': 'test@example.com',
-                    'gen_ai.operation.name': 'generate_content',
-                    'gen_ai.provider.name': 'gcp.gen_ai',
-                });
-            });
-        });
-    });
-    describe('Performance Monitoring Metrics', () => {
-        const mockConfig = {
-            getSessionId: () => 'test-session-id',
-            getTelemetryEnabled: () => true,
-        };
-        describe('recordStartupPerformance', () => {
-            it('should not record metrics when performance monitoring is disabled', async () => {
-                // Re-import with performance monitoring disabled by mocking the config
-                const mockConfigDisabled = {
-                    getSessionId: () => 'test-session-id',
-                    getTelemetryEnabled: () => false, // Disable telemetry to disable performance monitoring
-                };
-                initializeMetricsModule(mockConfigDisabled);
-                mockHistogramRecordFn.mockClear();
-                recordStartupPerformanceModule(mockConfigDisabled, 100, {
-                    phase: 'settings_loading',
-                    details: {
-                        auth_type: 'gemini',
-                    },
-                });
-                expect(mockHistogramRecordFn).not.toHaveBeenCalled();
-            });
-            it('should record startup performance with phase and details', () => {
-                initializeMetricsModule(mockConfig);
-                mockHistogramRecordFn.mockClear();
-                recordStartupPerformanceModule(mockConfig, 150, {
-                    phase: 'settings_loading',
-                    details: {
-                        auth_type: 'gemini',
-                        telemetry_enabled: true,
-                        settings_sources: 2,
-                    },
-                });
-                expect(mockHistogramRecordFn).toHaveBeenCalledWith(150, {
-                    'session.id': 'test-session-id',
-                    'installation.id': 'test-installation-id',
-                    'user.email': 'test@example.com',
-                    phase: 'settings_loading',
-                    auth_type: 'gemini',
-                    telemetry_enabled: true,
-                    settings_sources: 2,
-                });
-            });
-            it('should record startup performance without details', () => {
-                initializeMetricsModule(mockConfig);
-                mockHistogramRecordFn.mockClear();
-                recordStartupPerformanceModule(mockConfig, 50, { phase: 'cleanup' });
-                expect(mockHistogramRecordFn).toHaveBeenCalledWith(50, {
-                    'session.id': 'test-session-id',
-                    'installation.id': 'test-installation-id',
-                    'user.email': 'test@example.com',
-                    phase: 'cleanup',
-                });
-            });
-            it('should handle floating-point duration values from performance.now()', () => {
-                initializeMetricsModule(mockConfig);
-                mockHistogramRecordFn.mockClear();
-                // Test with realistic floating-point values that performance.now() would return
-                const floatingPointDuration = 123.45678;
-                recordStartupPerformanceModule(mockConfig, floatingPointDuration, {
-                    phase: 'total_startup',
-                    details: {
-                        is_tty: true,
-                        has_question: false,
-                    },
-                });
-                expect(mockHistogramRecordFn).toHaveBeenCalledWith(floatingPointDuration, {
-                    'session.id': 'test-session-id',
-                    'installation.id': 'test-installation-id',
-                    'user.email': 'test@example.com',
-                    phase: 'total_startup',
-                    is_tty: true,
-                    has_question: false,
-                });
-            });
-        });
-        describe('recordMemoryUsage', () => {
-            it.each([
-                {
-                    memory_type: MemoryMetricType.HEAP_USED,
-                    component: 'startup',
-                    value: 15728640,
-                },
-                {
-                    memory_type: MemoryMetricType.HEAP_TOTAL,
-                    component: 'api_call',
-                    value: 31457280,
-                },
-                {
-                    memory_type: MemoryMetricType.EXTERNAL,
-                    component: 'tool_execution',
-                    value: 2097152,
-                },
-                {
-                    memory_type: MemoryMetricType.RSS,
-                    component: 'memory_monitor',
-                    value: 41943040,
-                },
-                {
-                    memory_type: MemoryMetricType.HEAP_USED,
-                    component: undefined,
-                    value: 15728640,
-                },
-            ])('should record memory usage for $memory_type', ({ memory_type, component, value }) => {
-                initializeMetricsModule(mockConfig);
-                mockHistogramRecordFn.mockClear();
-                recordMemoryUsageModule(mockConfig, value, {
-                    memory_type,
-                    component,
-                });
-                const expectedAttributes = {
-                    'session.id': 'test-session-id',
-                    'installation.id': 'test-installation-id',
-                    'user.email': 'test@example.com',
-                    memory_type,
-                };
-                if (component) {
-                    expectedAttributes['component'] = component;
-                }
-                expect(mockHistogramRecordFn).toHaveBeenCalledWith(value, expectedAttributes);
-            });
-        });
-        describe('recordCpuUsage', () => {
-            it('should record CPU usage percentage', () => {
-                initializeMetricsModule(mockConfig);
-                mockHistogramRecordFn.mockClear();
-                recordCpuUsageModule(mockConfig, 85.5, {
-                    component: 'tool_execution',
-                });
-                expect(mockHistogramRecordFn).toHaveBeenCalledWith(85.5, {
-                    'session.id': 'test-session-id',
-                    'installation.id': 'test-installation-id',
-                    'user.email': 'test@example.com',
-                    component: 'tool_execution',
-                });
-            });
-            it('should record CPU usage without component', () => {
-                initializeMetricsModule(mockConfig);
-                mockHistogramRecordFn.mockClear();
-                recordCpuUsageModule(mockConfig, 42.3, {});
-                expect(mockHistogramRecordFn).toHaveBeenCalledWith(42.3, {
-                    'session.id': 'test-session-id',
-                    'installation.id': 'test-installation-id',
-                    'user.email': 'test@example.com',
-                });
-            });
-        });
-        describe('recordToolQueueDepth', () => {
-            it('should record tool queue depth', () => {
-                initializeMetricsModule(mockConfig);
-                mockHistogramRecordFn.mockClear();
-                recordToolQueueDepthModule(mockConfig, 3);
-                expect(mockHistogramRecordFn).toHaveBeenCalledWith(3, {
-                    'session.id': 'test-session-id',
-                    'installation.id': 'test-installation-id',
-                    'user.email': 'test@example.com',
-                });
-            });
-            it('should record zero queue depth', () => {
-                initializeMetricsModule(mockConfig);
-                mockHistogramRecordFn.mockClear();
-                recordToolQueueDepthModule(mockConfig, 0);
-                expect(mockHistogramRecordFn).toHaveBeenCalledWith(0, {
-                    'session.id': 'test-session-id',
-                    'installation.id': 'test-installation-id',
-                    'user.email': 'test@example.com',
-                });
-            });
-        });
-        describe('recordToolExecutionBreakdown', () => {
-            it('should record tool execution breakdown for all phases', () => {
-                initializeMetricsModule(mockConfig);
-                mockHistogramRecordFn.mockClear();
-                recordToolExecutionBreakdownModule(mockConfig, 25, {
-                    function_name: 'Read',
-                    phase: ToolExecutionPhase.VALIDATION,
-                });
-                expect(mockHistogramRecordFn).toHaveBeenCalledWith(25, {
-                    'session.id': 'test-session-id',
-                    'installation.id': 'test-installation-id',
-                    'user.email': 'test@example.com',
-                    function_name: 'Read',
-                    phase: 'validation',
-                });
-            });
-            it('should record execution breakdown for different phases', () => {
-                initializeMetricsModule(mockConfig);
-                mockHistogramRecordFn.mockClear();
-                recordToolExecutionBreakdownModule(mockConfig, 50, {
-                    function_name: 'Bash',
-                    phase: ToolExecutionPhase.PREPARATION,
-                });
-                recordToolExecutionBreakdownModule(mockConfig, 1500, {
-                    function_name: 'Bash',
-                    phase: ToolExecutionPhase.EXECUTION,
-                });
-                recordToolExecutionBreakdownModule(mockConfig, 75, {
-                    function_name: 'Bash',
-                    phase: ToolExecutionPhase.RESULT_PROCESSING,
-                });
-                expect(mockHistogramRecordFn).toHaveBeenCalledTimes(3); // One for each call
-                expect(mockHistogramRecordFn).toHaveBeenNthCalledWith(1, 50, {
-                    'session.id': 'test-session-id',
-                    'installation.id': 'test-installation-id',
-                    'user.email': 'test@example.com',
-                    function_name: 'Bash',
-                    phase: 'preparation',
-                });
-                expect(mockHistogramRecordFn).toHaveBeenNthCalledWith(2, 1500, {
-                    'session.id': 'test-session-id',
-                    'installation.id': 'test-installation-id',
-                    'user.email': 'test@example.com',
-                    function_name: 'Bash',
-                    phase: 'execution',
-                });
-                expect(mockHistogramRecordFn).toHaveBeenNthCalledWith(3, 75, {
-                    'session.id': 'test-session-id',
-                    'installation.id': 'test-installation-id',
-                    'user.email': 'test@example.com',
-                    function_name: 'Bash',
-                    phase: 'result_processing',
-                });
-            });
-        });
-        describe('recordTokenEfficiency', () => {
-            it('should record token efficiency metrics', () => {
-                initializeMetricsModule(mockConfig);
-                mockHistogramRecordFn.mockClear();
-                recordTokenEfficiencyModule(mockConfig, 0.85, {
-                    model: 'gemini-pro',
-                    metric: 'cache_hit_rate',
-                    context: 'api_request',
-                });
-                expect(mockHistogramRecordFn).toHaveBeenCalledWith(0.85, {
-                    'session.id': 'test-session-id',
-                    'installation.id': 'test-installation-id',
-                    'user.email': 'test@example.com',
-                    model: 'gemini-pro',
-                    metric: 'cache_hit_rate',
-                    context: 'api_request',
-                });
-            });
-            it('should record token efficiency without context', () => {
-                initializeMetricsModule(mockConfig);
-                mockHistogramRecordFn.mockClear();
-                recordTokenEfficiencyModule(mockConfig, 125.5, {
-                    model: 'gemini-pro',
-                    metric: 'tokens_per_operation',
-                });
-                expect(mockHistogramRecordFn).toHaveBeenCalledWith(125.5, {
-                    'session.id': 'test-session-id',
-                    'installation.id': 'test-installation-id',
-                    'user.email': 'test@example.com',
-                    model: 'gemini-pro',
-                    metric: 'tokens_per_operation',
-                });
-            });
-        });
-        describe('recordApiRequestBreakdown', () => {
-            it('should record API request breakdown for all phases', () => {
-                initializeMetricsModule(mockConfig);
-                mockHistogramRecordFn.mockClear();
-                recordApiRequestBreakdownModule(mockConfig, 15, {
-                    model: 'gemini-pro',
-                    phase: ApiRequestPhase.REQUEST_PREPARATION,
-                });
-                expect(mockHistogramRecordFn).toHaveBeenCalledWith(15, {
-                    'session.id': 'test-session-id',
-                    'installation.id': 'test-installation-id',
-                    'user.email': 'test@example.com',
-                    model: 'gemini-pro',
-                    phase: 'request_preparation',
-                });
-            });
-            it('should record API request breakdown for different phases', () => {
-                initializeMetricsModule(mockConfig);
-                mockHistogramRecordFn.mockClear();
-                recordApiRequestBreakdownModule(mockConfig, 250, {
-                    model: 'gemini-pro',
-                    phase: ApiRequestPhase.NETWORK_LATENCY,
-                });
-                recordApiRequestBreakdownModule(mockConfig, 100, {
-                    model: 'gemini-pro',
-                    phase: ApiRequestPhase.RESPONSE_PROCESSING,
-                });
-                recordApiRequestBreakdownModule(mockConfig, 50, {
-                    model: 'gemini-pro',
-                    phase: ApiRequestPhase.TOKEN_PROCESSING,
-                });
-                expect(mockHistogramRecordFn).toHaveBeenCalledTimes(3); // One for each call
-                expect(mockHistogramRecordFn).toHaveBeenNthCalledWith(1, 250, {
-                    'session.id': 'test-session-id',
-                    'installation.id': 'test-installation-id',
-                    'user.email': 'test@example.com',
-                    model: 'gemini-pro',
-                    phase: 'network_latency',
-                });
-                expect(mockHistogramRecordFn).toHaveBeenNthCalledWith(2, 100, {
-                    'session.id': 'test-session-id',
-                    'installation.id': 'test-installation-id',
-                    'user.email': 'test@example.com',
-                    model: 'gemini-pro',
-                    phase: 'response_processing',
-                });
-                expect(mockHistogramRecordFn).toHaveBeenNthCalledWith(3, 50, {
-                    'session.id': 'test-session-id',
-                    'installation.id': 'test-installation-id',
-                    'user.email': 'test@example.com',
-                    model: 'gemini-pro',
-                    phase: 'token_processing',
-                });
-            });
-        });
-        describe('recordPerformanceScore', () => {
-            it('should record performance score with category and baseline', () => {
-                initializeMetricsModule(mockConfig);
-                mockHistogramRecordFn.mockClear();
-                recordPerformanceScoreModule(mockConfig, 85.5, {
-                    category: 'memory_efficiency',
-                    baseline: 80.0,
-                });
-                expect(mockHistogramRecordFn).toHaveBeenCalledWith(85.5, {
-                    'session.id': 'test-session-id',
-                    'installation.id': 'test-installation-id',
-                    'user.email': 'test@example.com',
-                    category: 'memory_efficiency',
-                    baseline: 80.0,
-                });
-            });
-            it('should record performance score without baseline', () => {
-                initializeMetricsModule(mockConfig);
-                mockHistogramRecordFn.mockClear();
-                recordPerformanceScoreModule(mockConfig, 92.3, {
-                    category: 'overall_performance',
-                });
-                expect(mockHistogramRecordFn).toHaveBeenCalledWith(92.3, {
-                    'session.id': 'test-session-id',
-                    'installation.id': 'test-installation-id',
-                    'user.email': 'test@example.com',
-                    category: 'overall_performance',
-                });
-            });
-        });
-        describe('recordPerformanceRegression', () => {
-            it('should record performance regression with baseline comparison', () => {
-                initializeMetricsModule(mockConfig);
-                mockCounterAddFn.mockClear();
-                mockHistogramRecordFn.mockClear();
-                recordPerformanceRegressionModule(mockConfig, {
-                    metric: 'startup_time',
-                    current_value: 1200,
-                    baseline_value: 1000,
-                    severity: 'medium',
-                });
-                // Verify regression counter
-                expect(mockCounterAddFn).toHaveBeenCalledWith(1, {
-                    'session.id': 'test-session-id',
-                    'installation.id': 'test-installation-id',
-                    'user.email': 'test@example.com',
-                    metric: 'startup_time',
-                    severity: 'medium',
-                    current_value: 1200,
-                    baseline_value: 1000,
-                });
-                // Verify baseline comparison histogram (20% increase)
-                expect(mockHistogramRecordFn).toHaveBeenCalledWith(20, {
-                    'session.id': 'test-session-id',
-                    'installation.id': 'test-installation-id',
-                    'user.email': 'test@example.com',
-                    metric: 'startup_time',
-                    severity: 'medium',
-                    current_value: 1200,
-                    baseline_value: 1000,
-                });
-            });
-            it('should handle zero baseline value gracefully', () => {
-                initializeMetricsModule(mockConfig);
-                mockCounterAddFn.mockClear();
-                mockHistogramRecordFn.mockClear();
-                recordPerformanceRegressionModule(mockConfig, {
-                    metric: 'memory_usage',
-                    current_value: 100,
-                    baseline_value: 0,
-                    severity: 'high',
-                });
-                // Verify regression counter still recorded
-                expect(mockCounterAddFn).toHaveBeenCalledWith(1, {
-                    'session.id': 'test-session-id',
-                    'installation.id': 'test-installation-id',
-                    'user.email': 'test@example.com',
-                    metric: 'memory_usage',
-                    severity: 'high',
-                    current_value: 100,
-                    baseline_value: 0,
-                });
-                // Verify no baseline comparison due to zero baseline
-                expect(mockHistogramRecordFn).not.toHaveBeenCalled();
-            });
-            it('should record different severity levels', () => {
-                initializeMetricsModule(mockConfig);
-                mockCounterAddFn.mockClear();
-                recordPerformanceRegressionModule(mockConfig, {
-                    metric: 'api_latency',
-                    current_value: 500,
-                    baseline_value: 400,
-                    severity: 'low',
-                });
-                recordPerformanceRegressionModule(mockConfig, {
-                    metric: 'cpu_usage',
-                    current_value: 90,
-                    baseline_value: 70,
-                    severity: 'high',
-                });
-                expect(mockCounterAddFn).toHaveBeenNthCalledWith(1, 1, {
-                    'session.id': 'test-session-id',
-                    'installation.id': 'test-installation-id',
-                    'user.email': 'test@example.com',
-                    metric: 'api_latency',
-                    severity: 'low',
-                    current_value: 500,
-                    baseline_value: 400,
-                });
-                expect(mockCounterAddFn).toHaveBeenNthCalledWith(2, 1, {
-                    'session.id': 'test-session-id',
-                    'installation.id': 'test-installation-id',
-                    'user.email': 'test@example.com',
-                    metric: 'cpu_usage',
-                    severity: 'high',
-                    current_value: 90,
-                    baseline_value: 70,
-                });
-            });
-        });
-        describe('recordBaselineComparison', () => {
-            it('should record baseline comparison with percentage change', () => {
-                initializeMetricsModule(mockConfig);
-                mockHistogramRecordFn.mockClear();
-                recordBaselineComparisonModule(mockConfig, {
-                    metric: 'memory_usage',
-                    current_value: 120,
-                    baseline_value: 100,
-                    category: 'performance_tracking',
-                });
-                // 20% increase: (120 - 100) / 100 * 100 = 20%
-                expect(mockHistogramRecordFn).toHaveBeenCalledWith(20, {
-                    'session.id': 'test-session-id',
-                    'installation.id': 'test-installation-id',
-                    'user.email': 'test@example.com',
-                    metric: 'memory_usage',
-                    category: 'performance_tracking',
-                    current_value: 120,
-                    baseline_value: 100,
-                });
-            });
-            it('should handle negative percentage change (improvement)', () => {
-                initializeMetricsModule(mockConfig);
-                mockHistogramRecordFn.mockClear();
-                recordBaselineComparisonModule(mockConfig, {
-                    metric: 'startup_time',
-                    current_value: 800,
-                    baseline_value: 1000,
-                    category: 'optimization',
-                });
-                // 20% decrease: (800 - 1000) / 1000 * 100 = -20%
-                expect(mockHistogramRecordFn).toHaveBeenCalledWith(-20, {
-                    'session.id': 'test-session-id',
-                    'installation.id': 'test-installation-id',
-                    'user.email': 'test@example.com',
-                    metric: 'startup_time',
-                    category: 'optimization',
-                    current_value: 800,
-                    baseline_value: 1000,
-                });
-            });
-            it('should skip recording when baseline is zero', async () => {
-                // Access the actual mocked module
-                const mockedModule = (await vi.importMock('@opentelemetry/api'));
-                const diagSpy = vi.spyOn(mockedModule.diag, 'warn');
-                initializeMetricsModule(mockConfig);
-                mockHistogramRecordFn.mockClear();
-                recordBaselineComparisonModule(mockConfig, {
-                    metric: 'new_metric',
-                    current_value: 50,
-                    baseline_value: 0,
-                    category: 'testing',
-                });
-                expect(diagSpy).toHaveBeenCalledWith('Baseline value is zero, skipping comparison.');
-                expect(mockHistogramRecordFn).not.toHaveBeenCalled();
-            });
-        });
-        describe('recordHookCallMetrics', () => {
-            let recordHookCallMetricsModule;
-            beforeEach(async () => {
-                recordHookCallMetricsModule = (await import('./metrics.js'))
-                    .recordHookCallMetrics;
-            });
-            it('should record hook call metrics with counter and histogram', () => {
-                initializeMetricsModule(mockConfig);
-                mockCounterAddFn.mockClear();
-                mockHistogramRecordFn.mockClear();
-                recordHookCallMetricsModule(mockConfig, 'BeforeTool', 'test-hook', 150, true);
-                // Verify counter recorded
-                expect(mockCounterAddFn).toHaveBeenCalledWith(1, {
-                    'session.id': 'test-session-id',
-                    'installation.id': 'test-installation-id',
-                    'user.email': 'test@example.com',
-                    hook_event_name: 'BeforeTool',
-                    hook_name: 'test-hook',
-                    success: true,
-                });
-                // Verify histogram recorded
-                expect(mockHistogramRecordFn).toHaveBeenCalledWith(150, {
-                    'session.id': 'test-session-id',
-                    'installation.id': 'test-installation-id',
-                    'user.email': 'test@example.com',
-                    hook_event_name: 'BeforeTool',
-                    hook_name: 'test-hook',
-                    success: true,
-                });
-            });
-            it('should always sanitize hook names regardless of content', () => {
-                initializeMetricsModule(mockConfig);
-                mockCounterAddFn.mockClear();
-                // Test with a command that has sensitive information
-                recordHookCallMetricsModule(mockConfig, 'BeforeTool', '/path/to/.gemini/hooks/check-secrets.sh --api-key=abc123', 150, true);
-                // Verify hook name is sanitized (detailed sanitization tested in hook-call-event.test.ts)
-                expect(mockCounterAddFn).toHaveBeenCalledWith(1, {
-                    'session.id': 'test-session-id',
-                    'installation.id': 'test-installation-id',
-                    'user.email': 'test@example.com',
-                    hook_event_name: 'BeforeTool',
-                    hook_name: 'check-secrets.sh', // Sanitized
-                    success: true,
-                });
-            });
-            it('should track both success and failure', () => {
-                initializeMetricsModule(mockConfig);
-                mockCounterAddFn.mockClear();
-                // Success case
-                recordHookCallMetricsModule(mockConfig, 'BeforeTool', 'test-hook', 100, true);
-                expect(mockCounterAddFn).toHaveBeenNthCalledWith(1, 1, expect.objectContaining({
-                    hook_event_name: 'BeforeTool',
-                    hook_name: 'test-hook',
-                    success: true,
-                }));
-                // Failure case
-                recordHookCallMetricsModule(mockConfig, 'AfterTool', 'test-hook', 150, false);
-                expect(mockCounterAddFn).toHaveBeenNthCalledWith(2, 1, expect.objectContaining({
-                    hook_event_name: 'AfterTool',
-                    hook_name: 'test-hook',
-                    success: false,
-                }));
-            });
-        });
-    });
-});
-//# sourceMappingURL=metrics.test.js.map