@office-ai/aioncli-core 0.2.3 → 0.18.4

package/dist/src/telemetry/clearcut-logger/clearcut-logger.test.js

@@ -5,14 +5,17 @@
  */
 import 'vitest';
 import { vi, describe, it, expect, afterEach, beforeAll, afterAll, } from 'vitest';
-import { ClearcutLogger, EventNames, TEST_ONLY, } from './clearcut-logger.js';
-import * as userAccount from '../../utils/user_account.js';
-import * as userId from '../../utils/user_id.js';
+import { ClearcutLogger, EventNames, TEST_ONLY } from './clearcut-logger.js';
+import { AuthType } from '../../core/contentGenerator.js';
 import { EventMetadataKey } from './event-metadata-key.js';
 import { makeFakeConfig } from '../../test-utils/config.js';
 import { http, HttpResponse } from 'msw';
 import { server } from '../../mocks/msw.js';
-import { makeChatCompressionEvent } from '../types.js';
+import { UserPromptEvent, makeChatCompressionEvent, ModelRoutingEvent, ToolCallEvent, AgentStartEvent, AgentFinishEvent, WebFetchFallbackAttemptEvent, } from '../types.js';
+import { AgentTerminateMode } from '../../agents/types.js';
+import { GIT_COMMIT_INFO, CLI_VERSION } from '../../generated/git-commit.js';
+import { UserAccountManager } from '../../utils/userAccountManager.js';
+import { InstallationManager } from '../../utils/installationManager.js';
 expect.extend({
     toHaveEventName(received, name) {
         const { isNot } = this;
@@ -34,11 +37,31 @@ expect.extend({
             message: () => `event ${received} does${isNot ? ' not' : ''} have ${value}}`,
         };
     },
+    toHaveMetadataKey(received, key) {
+        const { isNot } = this;
+        const event = JSON.parse(received[0].source_extension_json);
+        const metadata = event['event_metadata'][0];
+        const pass = metadata.some((m) => m.gemini_cli_key === key);
+        return {
+            pass,
+            message: () => `event ${received} ${isNot ? 'has' : 'does not have'} the metadata key ${key}`,
+        };
+    },
+    toHaveGwsExperiments(received, expected_exps) {
+        const { isNot } = this;
+        const exps = received[0].gws_experiment;
+        const pass = exps.length === expected_exps.length &&
+            exps.every((value, index) => value === expected_exps[index]);
+        return {
+            pass,
+            message: () => `event ${received} ${isNot ? 'has' : 'does not have'} expected exp ids: ${expected_exps.join(',')}`,
+        };
+    },
 });
-vi.mock('../../utils/user_account');
-vi.mock('../../utils/user_id');
-const mockUserAccount = vi.mocked(userAccount);
-const mockUserId = vi.mocked(userId);
+vi.mock('../../utils/userAccountManager.js');
+vi.mock('../../utils/installationManager.js');
+const mockUserAccount = vi.mocked(UserAccountManager.prototype);
+const mockInstallMgr = vi.mocked(InstallationManager.prototype);
 // TODO(richieforeman): Consider moving this to test setup globally.
 beforeAll(() => {
     server.listen({});
@@ -61,7 +84,11 @@ describe('ClearcutLogger', () => {
     afterEach(() => {
         vi.unstubAllEnvs();
     });
-    function setup({ config = {}, lifetimeGoogleAccounts = 1, cachedGoogleAccount = 'test@google.com', installationId = 'test-installation-id', } = {}) {
+    function setup({ config = {
+        experiments: {
+            experimentIds: [123, 456, 789],
+        },
+    }, lifetimeGoogleAccounts = 1, cachedGoogleAccount = 'test@google.com', } = {}) {
         server.resetHandlers(http.post(CLEARCUT_URL, () => HttpResponse.text(EXAMPLE_RESPONSE)));
         vi.useFakeTimers();
         vi.setSystemTime(MOCK_DATE);
@@ -71,7 +98,9 @@ describe('ClearcutLogger', () => {
         ClearcutLogger.clearInstance();
         mockUserAccount.getCachedGoogleAccount.mockReturnValue(cachedGoogleAccount);
         mockUserAccount.getLifetimeGoogleAccounts.mockReturnValue(lifetimeGoogleAccounts);
-        mockUserId.getInstallationId.mockReturnValue(installationId);
+        mockInstallMgr.getInstallationId = vi
+            .fn()
+            .mockReturnValue('test-installation-id');
         const logger = ClearcutLogger.getInstance(loggerConfig);
         return { logger, loggerConfig };
     }
@@ -115,73 +144,187 @@ describe('ClearcutLogger', () => {
                 value: '9001',
             });
         });
-        it('logs the current surface from a github action', () => {
+        it('logs default metadata', () => {
+            // Define expected values
+            const session_id = 'my-session-id';
+            const auth_type = AuthType.USE_GEMINI;
+            const google_accounts = 123;
+            const surface = 'ide-1234';
+            const cli_version = CLI_VERSION;
+            const git_commit_hash = GIT_COMMIT_INFO;
+            const prompt_id = 'my-prompt-123';
+            // Setup logger with expected values
+            const { logger, loggerConfig } = setup({
+                lifetimeGoogleAccounts: google_accounts,
+                config: { sessionId: session_id },
+            });
+            vi.spyOn(loggerConfig, 'getContentGeneratorConfig').mockReturnValue({
+                authType: auth_type,
+            });
+            logger?.logNewPromptEvent(new UserPromptEvent(1, prompt_id)); // prompt_id == session_id before this
+            vi.stubEnv('SURFACE', surface);
+            // Create log event
+            const event = logger?.createLogEvent(EventNames.API_ERROR, []);
+            // Ensure expected values exist
+            expect(event?.event_metadata[0]).toEqual(expect.arrayContaining([
+                {
+                    gemini_cli_key: EventMetadataKey.GEMINI_CLI_SESSION_ID,
+                    value: session_id,
+                },
+                {
+                    gemini_cli_key: EventMetadataKey.GEMINI_CLI_AUTH_TYPE,
+                    value: JSON.stringify(auth_type),
+                },
+                {
+                    gemini_cli_key: EventMetadataKey.GEMINI_CLI_GOOGLE_ACCOUNTS_COUNT,
+                    value: `${google_accounts}`,
+                },
+                {
+                    gemini_cli_key: EventMetadataKey.GEMINI_CLI_SURFACE,
+                    value: surface,
+                },
+                {
+                    gemini_cli_key: EventMetadataKey.GEMINI_CLI_VERSION,
+                    value: cli_version,
+                },
+                {
+                    gemini_cli_key: EventMetadataKey.GEMINI_CLI_GIT_COMMIT_HASH,
+                    value: git_commit_hash,
+                },
+                {
+                    gemini_cli_key: EventMetadataKey.GEMINI_CLI_PROMPT_ID,
+                    value: prompt_id,
+                },
+                {
+                    gemini_cli_key: EventMetadataKey.GEMINI_CLI_OS,
+                    value: process.platform,
+                },
+                {
+                    gemini_cli_key: EventMetadataKey.GEMINI_CLI_USER_SETTINGS,
+                    value: logger?.getConfigJson(),
+                },
+            ]));
+        });
+        it('logs the current nodejs version', () => {
             const { logger } = setup({});
-            vi.stubEnv('GITHUB_SHA', '8675309');
-            const event = logger?.createLogEvent(EventNames.CHAT_COMPRESSION, []);
+            const event = logger?.createLogEvent(EventNames.API_ERROR, []);
             expect(event?.event_metadata[0]).toContainEqual({
-                gemini_cli_key: EventMetadataKey.GEMINI_CLI_SURFACE,
-                value: 'GitHub',
+                gemini_cli_key: EventMetadataKey.GEMINI_CLI_NODE_VERSION,
+                value: process.versions.node,
             });
         });
-        it('logs the current surface', () => {
-            const { logger } = setup({});
+        it('logs all user settings', () => {
+            const { logger } = setup({
+                config: { useSmartEdit: true, useModelRouter: true },
+            });
             vi.stubEnv('TERM_PROGRAM', 'vscode');
             vi.stubEnv('SURFACE', 'ide-1234');
-            const event = logger?.createLogEvent(EventNames.API_ERROR, []);
+            const event = logger?.createLogEvent(EventNames.TOOL_CALL, []);
             expect(event?.event_metadata[0]).toContainEqual({
-                gemini_cli_key: EventMetadataKey.GEMINI_CLI_SURFACE,
-                value: 'ide-1234',
+                gemini_cli_key: EventMetadataKey.GEMINI_CLI_USER_SETTINGS,
+                value: logger?.getConfigJson(),
             });
         });
         it.each([
             {
+                name: 'github action',
+                env: { GITHUB_SHA: '8675309' },
+                expected: 'GitHub',
+            },
+            {
+                name: 'Cloud Shell via EDITOR_IN_CLOUD_SHELL',
+                env: { EDITOR_IN_CLOUD_SHELL: 'true' },
+                expected: 'cloudshell',
+            },
+            {
+                name: 'Cloud Shell via CLOUD_SHELL',
+                env: { CLOUD_SHELL: 'true' },
+                expected: 'cloudshell',
+            },
+            {
+                name: 'VSCode via TERM_PROGRAM',
                 env: {
-                    CURSOR_TRACE_ID: 'abc123',
+                    TERM_PROGRAM: 'vscode',
                     GITHUB_SHA: undefined,
+                    MONOSPACE_ENV: '',
                 },
-                expectedValue: 'cursor',
+                expected: 'vscode',
+            },
+            {
+                name: 'SURFACE env var',
+                env: { SURFACE: 'ide-1234' },
+                expected: 'ide-1234',
             },
             {
+                name: 'SURFACE env var takes precedence',
+                env: { TERM_PROGRAM: 'vscode', SURFACE: 'ide-1234' },
+                expected: 'ide-1234',
+            },
+            {
+                name: 'Cursor',
                 env: {
+                    CURSOR_TRACE_ID: 'abc123',
                     TERM_PROGRAM: 'vscode',
                     GITHUB_SHA: undefined,
                 },
-                expectedValue: 'vscode',
+                expected: 'cursor',
             },
             {
+                name: 'Firebase Studio',
                 env: {
                     MONOSPACE_ENV: 'true',
+                    TERM_PROGRAM: 'vscode',
                     GITHUB_SHA: undefined,
                 },
-                expectedValue: 'firebasestudio',
+                expected: 'firebasestudio',
             },
             {
+                name: 'Devin',
                 env: {
                     __COG_BASHRC_SOURCED: 'true',
+                    TERM_PROGRAM: 'vscode',
                     GITHUB_SHA: undefined,
                 },
-                expectedValue: 'devin',
+                expected: 'devin',
             },
             {
+                name: 'unidentified',
                 env: {
-                    CLOUD_SHELL: 'true',
                     GITHUB_SHA: undefined,
+                    TERM_PROGRAM: undefined,
+                    SURFACE: undefined,
                 },
-                expectedValue: 'cloudshell',
+                expected: 'SURFACE_NOT_SET',
             },
-        ])('logs the current surface as $expectedValue, preempting vscode detection', ({ env, expectedValue }) => {
+        ])('logs the current surface as $expected from $name', ({ env, expected }) => {
             const { logger } = setup({});
             for (const [key, value] of Object.entries(env)) {
                 vi.stubEnv(key, value);
             }
-            vi.stubEnv('TERM_PROGRAM', 'vscode');
             const event = logger?.createLogEvent(EventNames.API_ERROR, []);
-            expect(event?.event_metadata[0][3]).toEqual({
+            expect(event?.event_metadata[0]).toContainEqual({
                 gemini_cli_key: EventMetadataKey.GEMINI_CLI_SURFACE,
-                value: expectedValue,
+                value: expected,
+            });
+        });
+    });
+    describe('GH_WORKFLOW_NAME metadata', () => {
+        it('includes workflow name when GH_WORKFLOW_NAME is set', () => {
+            const { logger } = setup({});
+            vi.stubEnv('GH_WORKFLOW_NAME', 'test-workflow');
+            const event = logger?.createLogEvent(EventNames.API_ERROR, []);
+            expect(event?.event_metadata[0]).toContainEqual({
+                gemini_cli_key: EventMetadataKey.GEMINI_CLI_GH_WORKFLOW_NAME,
+                value: 'test-workflow',
             });
         });
+        it('does not include workflow name when GH_WORKFLOW_NAME is not set', () => {
+            const { logger } = setup({});
+            vi.stubEnv('GH_WORKFLOW_NAME', undefined);
+            const event = logger?.createLogEvent(EventNames.API_ERROR, []);
+            const hasWorkflowName = event?.event_metadata[0].some((item) => item.gemini_cli_key === EventMetadataKey.GEMINI_CLI_GH_WORKFLOW_NAME);
+            expect(hasWorkflowName).toBe(false);
+        });
     });
     describe('logChatCompressionEvent', () => {
         it('logs an event with proper fields', () => {
@@ -203,6 +346,21 @@ describe('ClearcutLogger', () => {
             ]);
         });
     });
+    describe('logRipgrepFallbackEvent', () => {
+        it('logs an event with the proper name', () => {
+            const { logger } = setup();
+            // Spy on flushToClearcut to prevent it from clearing the queue
+            const flushSpy = vi
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                .spyOn(logger, 'flushToClearcut')
+                .mockResolvedValue({ nextRequestWaitMs: 0 });
+            logger?.logRipgrepFallbackEvent();
+            const events = getEvents(logger);
+            expect(events.length).toBe(1);
+            expect(events[0]).toHaveEventName(EventNames.RIPGREP_FALLBACK);
+            expect(flushSpy).toHaveBeenCalledOnce();
+        });
+    });
     describe('enqueueLogEvent', () => {
         it('should add events to the queue', () => {
             const { logger } = setup();
@@ -298,6 +456,7 @@ describe('ClearcutLogger', () => {
                     {
                         event_time_ms: Date.now(),
                         source_extension_json: JSON.stringify({ event_id: i }),
+                        gws_experiment: [],
                     },
                 ]);
             }
@@ -323,6 +482,7 @@ describe('ClearcutLogger', () => {
                     {
                         event_time_ms: Date.now(),
                         source_extension_json: JSON.stringify({ event_id: `failed_${i}` }),
+                        gws_experiment: [],
                     },
                 ]);
             }
@@ -338,5 +498,281 @@ describe('ClearcutLogger', () => {
             expect(firstRequeuedEvent.event_id).toBe('failed_5');
         });
     });
+    describe('logModelRoutingEvent', () => {
+        it('logs a successful routing event', () => {
+            const { logger } = setup();
+            const event = new ModelRoutingEvent('gemini-pro', 'default-strategy', 123, 'some reasoning', false, undefined);
+            logger?.logModelRoutingEvent(event);
+            const events = getEvents(logger);
+            expect(events.length).toBe(1);
+            expect(events[0]).toHaveEventName(EventNames.MODEL_ROUTING);
+            expect(events[0]).toHaveMetadataValue([
+                EventMetadataKey.GEMINI_CLI_ROUTING_DECISION,
+                'gemini-pro',
+            ]);
+            expect(events[0]).toHaveMetadataValue([
+                EventMetadataKey.GEMINI_CLI_ROUTING_DECISION_SOURCE,
+                'default-strategy',
+            ]);
+            expect(events[0]).toHaveMetadataValue([
+                EventMetadataKey.GEMINI_CLI_ROUTING_LATENCY_MS,
+                '123',
+            ]);
+            expect(events[0]).toHaveMetadataValue([
+                EventMetadataKey.GEMINI_CLI_ROUTING_FAILURE,
+                'false',
+            ]);
+        });
+        it('logs a failed routing event with a reason', () => {
+            const { logger } = setup();
+            const event = new ModelRoutingEvent('gemini-pro', 'router-exception', 234, 'some reasoning', true, 'Something went wrong');
+            logger?.logModelRoutingEvent(event);
+            const events = getEvents(logger);
+            expect(events.length).toBe(1);
+            expect(events[0]).toHaveEventName(EventNames.MODEL_ROUTING);
+            expect(events[0]).toHaveMetadataValue([
+                EventMetadataKey.GEMINI_CLI_ROUTING_DECISION,
+                'gemini-pro',
+            ]);
+            expect(events[0]).toHaveMetadataValue([
+                EventMetadataKey.GEMINI_CLI_ROUTING_DECISION_SOURCE,
+                'router-exception',
+            ]);
+            expect(events[0]).toHaveMetadataValue([
+                EventMetadataKey.GEMINI_CLI_ROUTING_LATENCY_MS,
+                '234',
+            ]);
+            expect(events[0]).toHaveMetadataValue([
+                EventMetadataKey.GEMINI_CLI_ROUTING_FAILURE,
+                'true',
+            ]);
+            expect(events[0]).toHaveMetadataValue([
+                EventMetadataKey.GEMINI_CLI_ROUTING_FAILURE_REASON,
+                'Something went wrong',
+            ]);
+        });
+    });
+    describe('logAgentStartEvent', () => {
+        it('logs an event with proper fields', () => {
+            const { logger } = setup();
+            const event = new AgentStartEvent('agent-123', 'TestAgent');
+            logger?.logAgentStartEvent(event);
+            const events = getEvents(logger);
+            expect(events.length).toBe(1);
+            expect(events[0]).toHaveEventName(EventNames.AGENT_START);
+            expect(events[0]).toHaveMetadataValue([
+                EventMetadataKey.GEMINI_CLI_AGENT_ID,
+                'agent-123',
+            ]);
+            expect(events[0]).toHaveMetadataValue([
+                EventMetadataKey.GEMINI_CLI_AGENT_NAME,
+                'TestAgent',
+            ]);
+        });
+    });
+    describe('logExperiments', () => {
+        it('logs an event with gws_experiment field containing exp ids', () => {
+            const { logger } = setup();
+            const event = new AgentStartEvent('agent-123', 'TestAgent');
+            logger?.logAgentStartEvent(event);
+            const events = getEvents(logger);
+            expect(events.length).toBe(1);
+            expect(events[0]).toHaveEventName(EventNames.AGENT_START);
+            expect(events[0]).toHaveGwsExperiments([123, 456, 789]);
+        });
+    });
+    describe('logAgentFinishEvent', () => {
+        it('logs an event with proper fields (success)', () => {
+            const { logger } = setup();
+            const event = new AgentFinishEvent('agent-123', 'TestAgent', 1000, 5, AgentTerminateMode.GOAL);
+            logger?.logAgentFinishEvent(event);
+            const events = getEvents(logger);
+            expect(events.length).toBe(1);
+            expect(events[0]).toHaveEventName(EventNames.AGENT_FINISH);
+            expect(events[0]).toHaveMetadataValue([
+                EventMetadataKey.GEMINI_CLI_AGENT_ID,
+                'agent-123',
+            ]);
+            expect(events[0]).toHaveMetadataValue([
+                EventMetadataKey.GEMINI_CLI_AGENT_NAME,
+                'TestAgent',
+            ]);
+            expect(events[0]).toHaveMetadataValue([
+                EventMetadataKey.GEMINI_CLI_AGENT_DURATION_MS,
+                '1000',
+            ]);
+            expect(events[0]).toHaveMetadataValue([
+                EventMetadataKey.GEMINI_CLI_AGENT_TURN_COUNT,
+                '5',
+            ]);
+            expect(events[0]).toHaveMetadataValue([
+                EventMetadataKey.GEMINI_CLI_AGENT_TERMINATE_REASON,
+                'GOAL',
+            ]);
+        });
+        it('logs an event with proper fields (error)', () => {
+            const { logger } = setup();
+            const event = new AgentFinishEvent('agent-123', 'TestAgent', 500, 2, AgentTerminateMode.ERROR);
+            logger?.logAgentFinishEvent(event);
+            const events = getEvents(logger);
+            expect(events.length).toBe(1);
+            expect(events[0]).toHaveEventName(EventNames.AGENT_FINISH);
+            expect(events[0]).toHaveMetadataValue([
+                EventMetadataKey.GEMINI_CLI_AGENT_TERMINATE_REASON,
+                'ERROR',
+            ]);
+        });
+    });
+    describe('logToolCallEvent', () => {
+        it('logs an event with all diff metadata', () => {
+            const { logger } = setup();
+            const completedToolCall = {
+                request: { name: 'test', args: {}, prompt_id: 'prompt-123' },
+                response: {
+                    resultDisplay: {
+                        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,
+                        },
+                    },
+                },
+                status: 'success',
+            };
+            logger?.logToolCallEvent(new ToolCallEvent(completedToolCall));
+            const events = getEvents(logger);
+            expect(events.length).toBe(1);
+            expect(events[0]).toHaveEventName(EventNames.TOOL_CALL);
+            expect(events[0]).toHaveMetadataValue([
+                EventMetadataKey.GEMINI_CLI_AI_ADDED_LINES,
+                '1',
+            ]);
+            expect(events[0]).toHaveMetadataValue([
+                EventMetadataKey.GEMINI_CLI_AI_REMOVED_LINES,
+                '2',
+            ]);
+            expect(events[0]).toHaveMetadataValue([
+                EventMetadataKey.GEMINI_CLI_AI_ADDED_CHARS,
+                '3',
+            ]);
+            expect(events[0]).toHaveMetadataValue([
+                EventMetadataKey.GEMINI_CLI_AI_REMOVED_CHARS,
+                '4',
+            ]);
+            expect(events[0]).toHaveMetadataValue([
+                EventMetadataKey.GEMINI_CLI_USER_ADDED_LINES,
+                '5',
+            ]);
+            expect(events[0]).toHaveMetadataValue([
+                EventMetadataKey.GEMINI_CLI_USER_REMOVED_LINES,
+                '6',
+            ]);
+            expect(events[0]).toHaveMetadataValue([
+                EventMetadataKey.GEMINI_CLI_USER_ADDED_CHARS,
+                '7',
+            ]);
+            expect(events[0]).toHaveMetadataValue([
+                EventMetadataKey.GEMINI_CLI_USER_REMOVED_CHARS,
+                '8',
+            ]);
+        });
+        it('logs an event with partial diff metadata', () => {
+            const { logger } = setup();
+            const completedToolCall = {
+                request: { name: 'test', args: {}, prompt_id: 'prompt-123' },
+                response: {
+                    resultDisplay: {
+                        diffStat: {
+                            model_added_lines: 1,
+                            model_removed_lines: 2,
+                            model_added_chars: 3,
+                            model_removed_chars: 4,
+                        },
+                    },
+                },
+                status: 'success',
+            };
+            logger?.logToolCallEvent(new ToolCallEvent(completedToolCall));
+            const events = getEvents(logger);
+            expect(events.length).toBe(1);
+            expect(events[0]).toHaveEventName(EventNames.TOOL_CALL);
+            expect(events[0]).toHaveMetadataValue([
+                EventMetadataKey.GEMINI_CLI_AI_ADDED_LINES,
+                '1',
+            ]);
+            expect(events[0]).toHaveMetadataValue([
+                EventMetadataKey.GEMINI_CLI_AI_REMOVED_LINES,
+                '2',
+            ]);
+            expect(events[0]).toHaveMetadataValue([
+                EventMetadataKey.GEMINI_CLI_AI_ADDED_CHARS,
+                '3',
+            ]);
+            expect(events[0]).toHaveMetadataValue([
+                EventMetadataKey.GEMINI_CLI_AI_REMOVED_CHARS,
+                '4',
+            ]);
+            expect(events[0]).not.toHaveMetadataKey(EventMetadataKey.GEMINI_CLI_USER_ADDED_LINES);
+            expect(events[0]).not.toHaveMetadataKey(EventMetadataKey.GEMINI_CLI_USER_REMOVED_LINES);
+            expect(events[0]).not.toHaveMetadataKey(EventMetadataKey.GEMINI_CLI_USER_ADDED_CHARS);
+            expect(events[0]).not.toHaveMetadataKey(EventMetadataKey.GEMINI_CLI_USER_REMOVED_CHARS);
+        });
+        it('does not log diff metadata if diffStat is not present', () => {
+            const { logger } = setup();
+            const completedToolCall = {
+                request: { name: 'test', args: {}, prompt_id: 'prompt-123' },
+                response: {
+                    resultDisplay: {},
+                },
+                status: 'success',
+            };
+            logger?.logToolCallEvent(new ToolCallEvent(completedToolCall));
+            const events = getEvents(logger);
+            expect(events.length).toBe(1);
+            expect(events[0]).toHaveEventName(EventNames.TOOL_CALL);
+            expect(events[0]).not.toHaveMetadataKey(EventMetadataKey.GEMINI_CLI_AI_ADDED_LINES);
+        });
+    });
+    describe('flushIfNeeded', () => {
+        it('should not flush if the interval has not passed', () => {
+            const { logger } = setup();
+            const flushSpy = vi
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                .spyOn(logger, 'flushToClearcut')
+                .mockResolvedValue({ nextRequestWaitMs: 0 });
+            logger.flushIfNeeded();
+            expect(flushSpy).not.toHaveBeenCalled();
+        });
+        it('should flush if the interval has passed', async () => {
+            const { logger } = setup();
+            const flushSpy = vi
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                .spyOn(logger, 'flushToClearcut')
+                .mockResolvedValue({ nextRequestWaitMs: 0 });
+            // Advance time by more than the flush interval
+            await vi.advanceTimersByTimeAsync(1000 * 60 * 2);
+            logger.flushIfNeeded();
+            expect(flushSpy).toHaveBeenCalled();
+        });
+    });
+    describe('logWebFetchFallbackAttemptEvent', () => {
+        it('logs an event with the proper name and reason', () => {
+            const { logger } = setup();
+            const event = new WebFetchFallbackAttemptEvent('private_ip');
+            logger?.logWebFetchFallbackAttemptEvent(event);
+            const events = getEvents(logger);
+            expect(events.length).toBe(1);
+            expect(events[0]).toHaveEventName(EventNames.WEB_FETCH_FALLBACK_ATTEMPT);
+            expect(events[0]).toHaveMetadataValue([
+                EventMetadataKey.GEMINI_CLI_WEB_FETCH_FALLBACK_REASON,
+                'private_ip',
+            ]);
+        });
+    });
 });
 //# sourceMappingURL=clearcut-logger.test.js.map