@office-ai/aioncli-core 0.1.21 → 0.2.2

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

@@ -3,28 +3,32 @@
  * Copyright 2025 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
-import { Buffer } from 'buffer';
-import * as https from 'https';
 import { HttpsProxyAgent } from 'https-proxy-agent';
-import { EndSessionEvent, } from '../types.js';
 import { EventMetadataKey } from './event-metadata-key.js';
 import { safeJsonStringify } from '../../utils/safeJsonStringify.js';
 import { getCachedGoogleAccount, getLifetimeGoogleAccounts, } from '../../utils/user_account.js';
 import { getInstallationId } from '../../utils/user_id.js';
 import { FixedDeque } from 'mnemonist';
-const start_session_event_name = 'start_session';
-const new_prompt_event_name = 'new_prompt';
-const tool_call_event_name = 'tool_call';
-const api_request_event_name = 'api_request';
-const api_response_event_name = 'api_response';
-const api_error_event_name = 'api_error';
-const end_session_event_name = 'end_session';
-const flash_fallback_event_name = 'flash_fallback';
-const loop_detected_event_name = 'loop_detected';
-const next_speaker_check_event_name = 'next_speaker_check';
-const slash_command_event_name = 'slash_command';
-const malformed_json_response_event_name = 'malformed_json_response';
-const ide_connection_event_name = 'ide_connection';
+import { GIT_COMMIT_INFO, CLI_VERSION } from '../../generated/git-commit.js';
+import { DetectedIde, detectIde } from '../../ide/detect-ide.js';
+export var EventNames;
+(function (EventNames) {
+    EventNames["START_SESSION"] = "start_session";
+    EventNames["NEW_PROMPT"] = "new_prompt";
+    EventNames["TOOL_CALL"] = "tool_call";
+    EventNames["API_REQUEST"] = "api_request";
+    EventNames["API_RESPONSE"] = "api_response";
+    EventNames["API_ERROR"] = "api_error";
+    EventNames["END_SESSION"] = "end_session";
+    EventNames["FLASH_FALLBACK"] = "flash_fallback";
+    EventNames["LOOP_DETECTED"] = "loop_detected";
+    EventNames["NEXT_SPEAKER_CHECK"] = "next_speaker_check";
+    EventNames["SLASH_COMMAND"] = "slash_command";
+    EventNames["MALFORMED_JSON_RESPONSE"] = "malformed_json_response";
+    EventNames["IDE_CONNECTION"] = "ide_connection";
+    EventNames["KITTY_SEQUENCE_OVERFLOW"] = "kitty_sequence_overflow";
+    EventNames["CHAT_COMPRESSION"] = "chat_compression";
+})(EventNames || (EventNames = {}));
 /**
  * Determine the surface that the user is currently using.  Surface is effectively the
  * distribution channel in which the user is using Gemini CLI.  Gemini CLI comes bundled
@@ -35,31 +39,66 @@ const ide_connection_event_name = 'ide_connection';
  * methods might have in their runtimes.
  */
 function determineSurface() {
-    if (process.env.CLOUD_SHELL === 'true') {
-        return 'CLOUD_SHELL';
+    if (process.env['SURFACE']) {
+        return process.env['SURFACE'];
     }
-    else if (process.env.MONOSPACE_ENV === 'true') {
-        return 'FIREBASE_STUDIO';
+    else if (process.env['GITHUB_SHA']) {
+        return 'GitHub';
+    }
+    else if (process.env['TERM_PROGRAM'] === 'vscode') {
+        return detectIde() || DetectedIde.VSCode;
     }
     else {
-        return process.env.SURFACE || 'SURFACE_NOT_SET';
+        return 'SURFACE_NOT_SET';
     }
 }
+/**
+ * Clearcut URL to send logging events to.
+ */
+const CLEARCUT_URL = 'https://play.googleapis.com/log?format=json&hasfast=true';
+/**
+ * Interval in which buffered events are sent to clearcut.
+ */
+const FLUSH_INTERVAL_MS = 1000 * 60;
+/**
+ * Maximum amount of events to keep in memory. Events added after this amount
+ * are dropped until the next flush to clearcut, which happens periodically as
+ * defined by {@link FLUSH_INTERVAL_MS}.
+ */
+const MAX_EVENTS = 1000;
+/**
+ * Maximum events to retry after a failed clearcut flush
+ */
+const MAX_RETRY_EVENTS = 100;
 // Singleton class for batch posting log events to Clearcut. When a new event comes in, the elapsed time
 // is checked and events are flushed to Clearcut if at least a minute has passed since the last flush.
 export class ClearcutLogger {
     static instance;
     config;
+    sessionData = [];
+    promptId = '';
+    /**
+     * Queue of pending events that need to be flushed to the server.  New events
+     * are added to this queue and then flushed on demand (via `flushToClearcut`)
+     */
     events;
-    last_flush_time = Date.now();
-    flush_interval_ms = 1000 * 60; // Wait at least a minute before flushing events.
-    max_events = 1000; // Maximum events to keep in memory
-    max_retry_events = 100; // Maximum failed events to retry
-    flushing = false; // Prevent concurrent flush operations
-    pendingFlush = false; // Track if a flush was requested during an ongoing flush
+    /**
+     * The last time that the events were successfully flushed to the server.
+     */
+    lastFlushTime = Date.now();
+    /**
+     * the value is true when there is a pending flush happening. This prevents
+     * concurrent flush operations.
+     */
+    flushing = false;
+    /**
+     * This value is true when a flush was requested during an ongoing flush.
+     */
+    pendingFlush = false;
     constructor(config) {
         this.config = config;
-        this.events = new FixedDeque(Array, this.max_events);
+        this.events = new FixedDeque(Array, MAX_EVENTS);
+        this.promptId = config?.getSessionId() ?? '';
     }
     static getInstance(config) {
         if (config === undefined || !config?.getUsageStatisticsEnabled())
@@ -77,7 +116,7 @@ export class ClearcutLogger {
     enqueueLogEvent(event) {
         try {
             // Manually handle overflow for FixedDeque, which throws when full.
-            const wasAtCapacity = this.events.size >= this.max_events;
+            const wasAtCapacity = this.events.size >= MAX_EVENTS;
             if (wasAtCapacity) {
                 this.events.shift(); // Evict oldest element to make space.
             }
@@ -97,17 +136,16 @@ export class ClearcutLogger {
             }
         }
     }
-    createLogEvent(name, data) {
+    createLogEvent(eventName, data = []) {
         const email = getCachedGoogleAccount();
-        const totalAccounts = getLifetimeGoogleAccounts();
-        data.push({
-            gemini_cli_key: EventMetadataKey.GEMINI_CLI_GOOGLE_ACCOUNTS_COUNT,
-            value: totalAccounts.toString(),
-        });
+        if (eventName !== EventNames.START_SESSION) {
+            data.push(...this.sessionData);
+        }
+        data = this.addDefaultFields(data);
         const logEvent = {
             console_type: 'GEMINI_CLI',
-            application: 102,
-            event_name: name,
+            application: 102, // GEMINI_CLI
+            event_name: eventName,
             event_metadata: [data],
         };
         // Should log either email or install ID, not both. See go/cloudmill-1p-oss-instrumentation#define-sessionable-id
@@ -120,7 +158,7 @@ export class ClearcutLogger {
         return logEvent;
     }
     flushIfNeeded() {
-        if (Date.now() - this.last_flush_time < this.flush_interval_ms) {
+        if (Date.now() - this.lastFlushTime < FLUSH_INTERVAL_MS) {
             return;
         }
         this.flushToClearcut().catch((error) => {
@@ -141,137 +179,65 @@ export class ClearcutLogger {
         }
         const eventsToSend = this.events.toArray();
         this.events.clear();
-        return new Promise((resolve, reject) => {
-            const request = [
-                {
-                    log_source_name: 'CONCORD',
-                    request_time_ms: Date.now(),
-                    log_event: eventsToSend,
-                },
-            ];
-            const body = safeJsonStringify(request);
-            const options = {
-                hostname: 'play.googleapis.com',
-                path: '/log',
+        const request = [
+            {
+                log_source_name: 'CONCORD',
+                request_time_ms: Date.now(),
+                log_event: eventsToSend,
+            },
+        ];
+        let result = {};
+        try {
+            const response = await fetch(CLEARCUT_URL, {
                 method: 'POST',
-                headers: { 'Content-Length': Buffer.byteLength(body) },
-                timeout: 30000, // 30-second timeout
-            };
-            const bufs = [];
-            const req = https.request({
-                ...options,
-                agent: this.getProxyAgent(),
-            }, (res) => {
-                res.on('error', reject); // Handle stream errors
-                res.on('data', (buf) => bufs.push(buf));
-                res.on('end', () => {
-                    try {
-                        const buffer = Buffer.concat(bufs);
-                        // Check if we got a successful response
-                        if (res.statusCode &&
-                            res.statusCode >= 200 &&
-                            res.statusCode < 300) {
-                            resolve({ buffer, statusCode: res.statusCode });
-                        }
-                        else {
-                            // HTTP error - reject with status code for retry handling
-                            reject(new Error(`HTTP ${res.statusCode}: ${res.statusMessage}`));
-                        }
-                    }
-                    catch (e) {
-                        reject(e);
-                    }
-                });
-            });
-            req.on('error', (e) => {
-                // Network-level error
-                reject(e);
-            });
-            req.on('timeout', () => {
-                if (!req.destroyed) {
-                    req.destroy(new Error('Request timeout after 30 seconds'));
-                }
+                body: safeJsonStringify(request),
+                headers: {
+                    'Content-Type': 'application/json',
+                },
             });
-            req.end(body);
-        })
-            .then(({ buffer }) => {
-            try {
-                this.last_flush_time = Date.now();
-                return this.decodeLogResponse(buffer) || {};
+            const responseBody = await response.text();
+            if (response.status >= 200 && response.status < 300) {
+                this.lastFlushTime = Date.now();
+                const nextRequestWaitMs = Number(JSON.parse(responseBody)[0]);
+                result = {
+                    ...result,
+                    nextRequestWaitMs,
+                };
             }
-            catch (error) {
-                console.error('Error decoding log response:', error);
-                return {};
+            else {
+                if (this.config?.getDebugMode()) {
+                    console.error(`Error flushing log events: HTTP ${response.status}: ${response.statusText}`);
+                }
+                // Re-queue failed events for retry
+                this.requeueFailedEvents(eventsToSend);
             }
-        })
-            .catch((error) => {
-            // Handle both network-level and HTTP-level errors
+        }
+        catch (e) {
             if (this.config?.getDebugMode()) {
-                console.error('Error flushing log events:', error);
+                console.error('Error flushing log events:', e);
             }
             // Re-queue failed events for retry
             this.requeueFailedEvents(eventsToSend);
-            // Return empty response to maintain the Promise<LogResponse> contract
-            return {};
-        })
-            .finally(() => {
-            this.flushing = false;
-            // If a flush was requested while we were flushing, flush again
-            if (this.pendingFlush) {
-                this.pendingFlush = false;
-                // Fire and forget the pending flush
-                this.flushToClearcut().catch((error) => {
-                    if (this.config?.getDebugMode()) {
-                        console.debug('Error in pending flush to Clearcut:', error);
-                    }
-                });
-            }
-        });
-    }
-    // Visible for testing. Decodes protobuf-encoded response from Clearcut server.
-    decodeLogResponse(buf) {
-        // TODO(obrienowen): return specific errors to facilitate debugging.
-        if (buf.length < 1) {
-            return undefined;
-        }
-        // The first byte of the buffer is `field<<3 | type`. We're looking for field
-        // 1, with type varint, represented by type=0. If the first byte isn't 8, that
-        // means field 1 is missing or the message is corrupted. Either way, we return
-        // undefined.
-        if (buf.readUInt8(0) !== 8) {
-            return undefined;
         }
-        let ms = BigInt(0);
-        let cont = true;
-        // In each byte, the most significant bit is the continuation bit. If it's
-        // set, we keep going. The lowest 7 bits, are data bits. They are concatenated
-        // in reverse order to form the final number.
-        for (let i = 1; cont && i < buf.length; i++) {
-            const byte = buf.readUInt8(i);
-            ms |= BigInt(byte & 0x7f) << BigInt(7 * (i - 1));
-            cont = (byte & 0x80) !== 0;
-        }
-        if (cont) {
-            // We have fallen off the buffer without seeing a terminating byte. The
-            // message is corrupted.
-            return undefined;
+        this.flushing = false;
+        // If a flush was requested while we were flushing, flush again
+        if (this.pendingFlush) {
+            this.pendingFlush = false;
+            // Fire and forget the pending flush
+            this.flushToClearcut().catch((error) => {
+                if (this.config?.getDebugMode()) {
+                    console.debug('Error in pending flush to Clearcut:', error);
+                }
+            });
         }
-        const returnVal = {
-            nextRequestWaitMs: Number(ms),
-        };
-        return returnVal;
+        return result;
     }
     logStartSessionEvent(event) {
-        const surface = determineSurface();
         const data = [
             {
                 gemini_cli_key: EventMetadataKey.GEMINI_CLI_START_SESSION_MODEL,
                 value: event.model,
             },
-            {
-                gemini_cli_key: EventMetadataKey.GEMINI_CLI_SESSION_ID,
-                value: this.config?.getSessionId() ?? '',
-            },
             {
                 gemini_cli_key: EventMetadataKey.GEMINI_CLI_START_SESSION_EMBEDDING_MODEL,
                 value: event.embedding_model,
@@ -320,37 +286,23 @@ export class ClearcutLogger {
                 gemini_cli_key: EventMetadataKey.GEMINI_CLI_START_SESSION_TELEMETRY_LOG_USER_PROMPTS_ENABLED,
                 value: event.telemetry_log_user_prompts_enabled.toString(),
             },
-            {
-                gemini_cli_key: EventMetadataKey.GEMINI_CLI_SURFACE,
-                value: surface,
-            },
         ];
+        this.sessionData = data;
         // Flush start event immediately
-        this.enqueueLogEvent(this.createLogEvent(start_session_event_name, data));
+        this.enqueueLogEvent(this.createLogEvent(EventNames.START_SESSION, data));
         this.flushToClearcut().catch((error) => {
             console.debug('Error flushing to Clearcut:', error);
         });
     }
     logNewPromptEvent(event) {
+        this.promptId = event.prompt_id;
         const data = [
             {
                 gemini_cli_key: EventMetadataKey.GEMINI_CLI_USER_PROMPT_LENGTH,
                 value: JSON.stringify(event.prompt_length),
             },
-            {
-                gemini_cli_key: EventMetadataKey.GEMINI_CLI_SESSION_ID,
-                value: this.config?.getSessionId() ?? '',
-            },
-            {
-                gemini_cli_key: EventMetadataKey.GEMINI_CLI_PROMPT_ID,
-                value: JSON.stringify(event.prompt_id),
-            },
-            {
-                gemini_cli_key: EventMetadataKey.GEMINI_CLI_AUTH_TYPE,
-                value: JSON.stringify(event.auth_type),
-            },
         ];
-        this.enqueueLogEvent(this.createLogEvent(new_prompt_event_name, data));
+        this.enqueueLogEvent(this.createLogEvent(EventNames.NEW_PROMPT, data));
         this.flushIfNeeded();
     }
     logToolCallEvent(event) {
@@ -359,10 +311,6 @@ export class ClearcutLogger {
                 gemini_cli_key: EventMetadataKey.GEMINI_CLI_TOOL_CALL_NAME,
                 value: JSON.stringify(event.function_name),
             },
-            {
-                gemini_cli_key: EventMetadataKey.GEMINI_CLI_PROMPT_ID,
-                value: JSON.stringify(event.prompt_id),
-            },
             {
                 gemini_cli_key: EventMetadataKey.GEMINI_CLI_TOOL_CALL_DECISION,
                 value: JSON.stringify(event.decision),
@@ -383,6 +331,10 @@ export class ClearcutLogger {
                 gemini_cli_key: EventMetadataKey.GEMINI_CLI_TOOL_CALL_ERROR_TYPE,
                 value: JSON.stringify(event.error_type),
             },
+            {
+                gemini_cli_key: EventMetadataKey.GEMINI_CLI_TOOL_TYPE,
+                value: JSON.stringify(event.tool_type),
+            },
         ];
         if (event.metadata) {
             const metadataMapping = {
@@ -400,7 +352,7 @@ export class ClearcutLogger {
                 }
             }
         }
-        const logEvent = this.createLogEvent(tool_call_event_name, data);
+        const logEvent = this.createLogEvent(EventNames.TOOL_CALL, data);
         this.enqueueLogEvent(logEvent);
         this.flushIfNeeded();
     }
@@ -410,12 +362,8 @@ export class ClearcutLogger {
                 gemini_cli_key: EventMetadataKey.GEMINI_CLI_API_REQUEST_MODEL,
                 value: JSON.stringify(event.model),
             },
-            {
-                gemini_cli_key: EventMetadataKey.GEMINI_CLI_PROMPT_ID,
-                value: JSON.stringify(event.prompt_id),
-            },
         ];
-        this.enqueueLogEvent(this.createLogEvent(api_request_event_name, data));
+        this.enqueueLogEvent(this.createLogEvent(EventNames.API_REQUEST, data));
         this.flushIfNeeded();
     }
     logApiResponseEvent(event) {
@@ -424,10 +372,6 @@ export class ClearcutLogger {
                 gemini_cli_key: EventMetadataKey.GEMINI_CLI_API_RESPONSE_MODEL,
                 value: JSON.stringify(event.model),
             },
-            {
-                gemini_cli_key: EventMetadataKey.GEMINI_CLI_PROMPT_ID,
-                value: JSON.stringify(event.prompt_id),
-            },
             {
                 gemini_cli_key: EventMetadataKey.GEMINI_CLI_API_RESPONSE_STATUS_CODE,
                 value: JSON.stringify(event.status_code),
@@ -460,12 +404,8 @@ export class ClearcutLogger {
                 gemini_cli_key: EventMetadataKey.GEMINI_CLI_API_RESPONSE_TOOL_TOKEN_COUNT,
                 value: JSON.stringify(event.tool_token_count),
             },
-            {
-                gemini_cli_key: EventMetadataKey.GEMINI_CLI_AUTH_TYPE,
-                value: JSON.stringify(event.auth_type),
-            },
         ];
-        this.enqueueLogEvent(this.createLogEvent(api_response_event_name, data));
+        this.enqueueLogEvent(this.createLogEvent(EventNames.API_RESPONSE, data));
         this.flushIfNeeded();
     }
     logApiErrorEvent(event) {
@@ -474,10 +414,6 @@ export class ClearcutLogger {
                 gemini_cli_key: EventMetadataKey.GEMINI_CLI_API_ERROR_MODEL,
                 value: JSON.stringify(event.model),
             },
-            {
-                gemini_cli_key: EventMetadataKey.GEMINI_CLI_PROMPT_ID,
-                value: JSON.stringify(event.prompt_id),
-            },
             {
                 gemini_cli_key: EventMetadataKey.GEMINI_CLI_API_ERROR_TYPE,
                 value: JSON.stringify(event.error_type),
@@ -490,50 +426,41 @@ export class ClearcutLogger {
                 gemini_cli_key: EventMetadataKey.GEMINI_CLI_API_ERROR_DURATION_MS,
                 value: JSON.stringify(event.duration_ms),
             },
-            {
-                gemini_cli_key: EventMetadataKey.GEMINI_CLI_AUTH_TYPE,
-                value: JSON.stringify(event.auth_type),
-            },
         ];
-        this.enqueueLogEvent(this.createLogEvent(api_error_event_name, data));
+        this.enqueueLogEvent(this.createLogEvent(EventNames.API_ERROR, data));
         this.flushIfNeeded();
     }
-    logFlashFallbackEvent(event) {
+    logChatCompressionEvent(event) {
         const data = [
             {
-                gemini_cli_key: EventMetadataKey.GEMINI_CLI_AUTH_TYPE,
-                value: JSON.stringify(event.auth_type),
+                gemini_cli_key: EventMetadataKey.GEMINI_CLI_COMPRESSION_TOKENS_BEFORE,
+                value: `${event.tokens_before}`,
             },
             {
-                gemini_cli_key: EventMetadataKey.GEMINI_CLI_SESSION_ID,
-                value: this.config?.getSessionId() ?? '',
+                gemini_cli_key: EventMetadataKey.GEMINI_CLI_COMPRESSION_TOKENS_AFTER,
+                value: `${event.tokens_after}`,
             },
         ];
-        this.enqueueLogEvent(this.createLogEvent(flash_fallback_event_name, data));
+        this.enqueueLogEvent(this.createLogEvent(EventNames.CHAT_COMPRESSION, data));
+    }
+    logFlashFallbackEvent() {
+        this.enqueueLogEvent(this.createLogEvent(EventNames.FLASH_FALLBACK, []));
         this.flushToClearcut().catch((error) => {
             console.debug('Error flushing to Clearcut:', error);
         });
     }
     logLoopDetectedEvent(event) {
         const data = [
-            {
-                gemini_cli_key: EventMetadataKey.GEMINI_CLI_PROMPT_ID,
-                value: JSON.stringify(event.prompt_id),
-            },
             {
                 gemini_cli_key: EventMetadataKey.GEMINI_CLI_LOOP_DETECTED_TYPE,
                 value: JSON.stringify(event.loop_type),
             },
         ];
-        this.enqueueLogEvent(this.createLogEvent(loop_detected_event_name, data));
+        this.enqueueLogEvent(this.createLogEvent(EventNames.LOOP_DETECTED, data));
         this.flushIfNeeded();
     }
     logNextSpeakerCheck(event) {
         const data = [
-            {
-                gemini_cli_key: EventMetadataKey.GEMINI_CLI_PROMPT_ID,
-                value: JSON.stringify(event.prompt_id),
-            },
             {
                 gemini_cli_key: EventMetadataKey.GEMINI_CLI_RESPONSE_FINISH_REASON,
                 value: JSON.stringify(event.finish_reason),
@@ -542,12 +469,8 @@ export class ClearcutLogger {
                 gemini_cli_key: EventMetadataKey.GEMINI_CLI_NEXT_SPEAKER_CHECK_RESULT,
                 value: JSON.stringify(event.result),
             },
-            {
-                gemini_cli_key: EventMetadataKey.GEMINI_CLI_SESSION_ID,
-                value: this.config?.getSessionId() ?? '',
-            },
         ];
-        this.enqueueLogEvent(this.createLogEvent(next_speaker_check_event_name, data));
+        this.enqueueLogEvent(this.createLogEvent(EventNames.NEXT_SPEAKER_CHECK, data));
         this.flushIfNeeded();
     }
     logSlashCommandEvent(event) {
@@ -563,7 +486,13 @@ export class ClearcutLogger {
                 value: JSON.stringify(event.subcommand),
             });
         }
-        this.enqueueLogEvent(this.createLogEvent(slash_command_event_name, data));
+        if (event.status) {
+            data.push({
+                gemini_cli_key: EventMetadataKey.GEMINI_CLI_SLASH_COMMAND_STATUS,
+                value: JSON.stringify(event.status),
+            });
+        }
+        this.enqueueLogEvent(this.createLogEvent(EventNames.SLASH_COMMAND, data));
         this.flushIfNeeded();
     }
     logMalformedJsonResponseEvent(event) {
@@ -573,7 +502,7 @@ export class ClearcutLogger {
                 value: JSON.stringify(event.model),
             },
         ];
-        this.enqueueLogEvent(this.createLogEvent(malformed_json_response_event_name, data));
+        this.enqueueLogEvent(this.createLogEvent(EventNames.MALFORMED_JSON_RESPONSE, data));
         this.flushIfNeeded();
     }
     logIdeConnectionEvent(event) {
@@ -583,22 +512,69 @@ export class ClearcutLogger {
                 value: JSON.stringify(event.connection_type),
             },
         ];
-        this.enqueueLogEvent(this.createLogEvent(ide_connection_event_name, data));
+        this.enqueueLogEvent(this.createLogEvent(EventNames.IDE_CONNECTION, data));
         this.flushIfNeeded();
     }
-    logEndSessionEvent(event) {
+    logKittySequenceOverflowEvent(event) {
         const data = [
             {
-                gemini_cli_key: EventMetadataKey.GEMINI_CLI_SESSION_ID,
-                value: event?.session_id?.toString() ?? '',
+                gemini_cli_key: EventMetadataKey.GEMINI_CLI_KITTY_SEQUENCE_LENGTH,
+                value: event.sequence_length.toString(),
+            },
+            {
+                gemini_cli_key: EventMetadataKey.GEMINI_CLI_KITTY_TRUNCATED_SEQUENCE,
+                value: event.truncated_sequence,
             },
         ];
+        this.enqueueLogEvent(this.createLogEvent(EventNames.KITTY_SEQUENCE_OVERFLOW, data));
+        this.flushIfNeeded();
+    }
+    logEndSessionEvent() {
         // Flush immediately on session end.
-        this.enqueueLogEvent(this.createLogEvent(end_session_event_name, data));
+        this.enqueueLogEvent(this.createLogEvent(EventNames.END_SESSION, []));
         this.flushToClearcut().catch((error) => {
             console.debug('Error flushing to Clearcut:', error);
         });
     }
+    /**
+     * Adds default fields to data, and returns a new data array.  This fields
+     * should exist on all log events.
+     */
+    addDefaultFields(data) {
+        const totalAccounts = getLifetimeGoogleAccounts();
+        const surface = determineSurface();
+        const defaultLogMetadata = [
+            {
+                gemini_cli_key: EventMetadataKey.GEMINI_CLI_SESSION_ID,
+                value: this.config?.getSessionId() ?? '',
+            },
+            {
+                gemini_cli_key: EventMetadataKey.GEMINI_CLI_AUTH_TYPE,
+                value: JSON.stringify(this.config?.getContentGeneratorConfig()?.authType),
+            },
+            {
+                gemini_cli_key: EventMetadataKey.GEMINI_CLI_GOOGLE_ACCOUNTS_COUNT,
+                value: `${totalAccounts}`,
+            },
+            {
+                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_INFO,
+            },
+            {
+                gemini_cli_key: EventMetadataKey.GEMINI_CLI_PROMPT_ID,
+                value: this.promptId,
+            },
+        ];
+        return [...data, ...defaultLogMetadata];
+    }
     getProxyAgent() {
         const proxyUrl = this.config?.getProxy();
         if (!proxyUrl)
@@ -613,19 +589,17 @@ export class ClearcutLogger {
         }
     }
     shutdown() {
-        const event = new EndSessionEvent(this.config);
-        this.logEndSessionEvent(event);
+        this.logEndSessionEvent();
     }
     requeueFailedEvents(eventsToSend) {
         // Add the events back to the front of the queue to be retried, but limit retry queue size
-        const eventsToRetry = eventsToSend.slice(-this.max_retry_events); // Keep only the most recent events
+        const eventsToRetry = eventsToSend.slice(-MAX_RETRY_EVENTS); // Keep only the most recent events
         // Log a warning if we're dropping events
-        if (eventsToSend.length > this.max_retry_events &&
-            this.config?.getDebugMode()) {
-            console.warn(`ClearcutLogger: Dropping ${eventsToSend.length - this.max_retry_events} events due to retry queue limit. Total events: ${eventsToSend.length}, keeping: ${this.max_retry_events}`);
+        if (eventsToSend.length > MAX_RETRY_EVENTS && this.config?.getDebugMode()) {
+            console.warn(`ClearcutLogger: Dropping ${eventsToSend.length - MAX_RETRY_EVENTS} events due to retry queue limit. Total events: ${eventsToSend.length}, keeping: ${MAX_RETRY_EVENTS}`);
         }
         // Determine how many events can be re-queued
-        const availableSpace = this.max_events - this.events.size;
+        const availableSpace = MAX_EVENTS - this.events.size;
         const numEventsToRequeue = Math.min(eventsToRetry.length, availableSpace);
         if (numEventsToRequeue === 0) {
             if (this.config?.getDebugMode()) {
@@ -641,7 +615,7 @@ export class ClearcutLogger {
             this.events.unshift(eventsToRequeue[i]);
         }
         // Clear any potential overflow
-        while (this.events.size > this.max_events) {
+        while (this.events.size > MAX_EVENTS) {
             this.events.pop();
         }
         if (this.config?.getDebugMode()) {
@@ -649,4 +623,8 @@ export class ClearcutLogger {
         }
     }
 }
+export const TEST_ONLY = {
+    MAX_RETRY_EVENTS,
+    MAX_EVENTS,
+};
 //# sourceMappingURL=clearcut-logger.js.map