@office-ai/aioncli-core 0.2.3 → 0.18.4

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

@@ -5,29 +5,52 @@
  */
 import { HttpsProxyAgent } from 'https-proxy-agent';
 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 { InstallationManager } from '../../utils/installationManager.js';
+import { UserAccountManager } from '../../utils/userAccountManager.js';
+import { safeJsonStringify, safeJsonStringifyBooleanValuesOnly, } from '../../utils/safeJsonStringify.js';
 import { FixedDeque } from 'mnemonist';
 import { GIT_COMMIT_INFO, CLI_VERSION } from '../../generated/git-commit.js';
-import { DetectedIde, detectIde } from '../../ide/detect-ide.js';
+import { IDE_DEFINITIONS, detectIdeFromEnv, isCloudShell, } from '../../ide/detect-ide.js';
+import { debugLogger } from '../../utils/debugLogger.js';
 export var EventNames;
 (function (EventNames) {
     EventNames["START_SESSION"] = "start_session";
     EventNames["NEW_PROMPT"] = "new_prompt";
     EventNames["TOOL_CALL"] = "tool_call";
+    EventNames["FILE_OPERATION"] = "file_operation";
     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["RIPGREP_FALLBACK"] = "ripgrep_fallback";
     EventNames["LOOP_DETECTED"] = "loop_detected";
+    EventNames["LOOP_DETECTION_DISABLED"] = "loop_detection_disabled";
     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["CONVERSATION_FINISHED"] = "conversation_finished";
+    EventNames["INVALID_CHUNK"] = "invalid_chunk";
+    EventNames["CONTENT_RETRY"] = "content_retry";
+    EventNames["CONTENT_RETRY_FAILURE"] = "content_retry_failure";
+    EventNames["EXTENSION_ENABLE"] = "extension_enable";
+    EventNames["EXTENSION_DISABLE"] = "extension_disable";
+    EventNames["EXTENSION_INSTALL"] = "extension_install";
+    EventNames["EXTENSION_UNINSTALL"] = "extension_uninstall";
+    EventNames["EXTENSION_UPDATE"] = "extension_update";
+    EventNames["TOOL_OUTPUT_TRUNCATED"] = "tool_output_truncated";
+    EventNames["MODEL_ROUTING"] = "model_routing";
+    EventNames["MODEL_SLASH_COMMAND"] = "model_slash_command";
+    EventNames["SMART_EDIT_STRATEGY"] = "smart_edit_strategy";
+    EventNames["SMART_EDIT_CORRECTION"] = "smart_edit_correction";
+    EventNames["AGENT_START"] = "agent_start";
+    EventNames["AGENT_FINISH"] = "agent_finish";
+    EventNames["RECOVERY_ATTEMPT"] = "recovery_attempt";
+    EventNames["WEB_FETCH_FALLBACK_ATTEMPT"] = "web_fetch_fallback_attempt";
+    EventNames["LLM_LOOP_CHECK"] = "llm_loop_check";
 })(EventNames || (EventNames = {}));
 /**
  * Determine the surface that the user is currently using.  Surface is effectively the
@@ -42,16 +65,25 @@ function determineSurface() {
     if (process.env['SURFACE']) {
         return process.env['SURFACE'];
     }
+    else if (isCloudShell()) {
+        return IDE_DEFINITIONS.cloudshell.name;
+    }
     else if (process.env['GITHUB_SHA']) {
         return 'GitHub';
     }
     else if (process.env['TERM_PROGRAM'] === 'vscode') {
-        return detectIde() || DetectedIde.VSCode;
+        return detectIdeFromEnv().name || IDE_DEFINITIONS.vscode.name;
     }
     else {
         return 'SURFACE_NOT_SET';
     }
 }
+/**
+ * Determines the GitHub Actions workflow name if the CLI is running in a GitHub Actions environment.
+ */
+function determineGHWorkflowName() {
+    return process.env['GH_WORKFLOW_NAME'];
+}
 /**
  * Clearcut URL to send logging events to.
  */
@@ -77,6 +109,8 @@ export class ClearcutLogger {
     config;
     sessionData = [];
     promptId = '';
+    installationManager;
+    userAccountManager;
     /**
      * 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`)
@@ -99,6 +133,8 @@ export class ClearcutLogger {
         this.config = config;
         this.events = new FixedDeque(Array, MAX_EVENTS);
         this.promptId = config?.getSessionId() ?? '';
+        this.installationManager = new InstallationManager();
+        this.userAccountManager = new UserAccountManager();
     }
     static getInstance(config) {
         if (config === undefined || !config?.getUsageStatisticsEnabled())
@@ -124,10 +160,11 @@ export class ClearcutLogger {
                 {
                     event_time_ms: Date.now(),
                     source_extension_json: safeJsonStringify(event),
+                    gws_experiment: this.config?.getExperiments()?.experimentIds ?? [],
                 },
             ]);
             if (wasAtCapacity && this.config?.getDebugMode()) {
-                console.debug(`ClearcutLogger: Dropped old event to prevent memory leak (queue size: ${this.events.size})`);
+                debugLogger.debug(`ClearcutLogger: Dropped old event to prevent memory leak (queue size: ${this.events.size})`);
             }
         }
         catch (error) {
@@ -136,24 +173,55 @@ export class ClearcutLogger {
             }
         }
     }
-    createLogEvent(eventName, data = []) {
-        const email = getCachedGoogleAccount();
-        if (eventName !== EventNames.START_SESSION) {
-            data.push(...this.sessionData);
+    createBasicLogEvent(eventName, data = []) {
+        const surface = determineSurface();
+        const ghWorkflowName = determineGHWorkflowName();
+        const baseMetadata = [
+            ...data,
+            {
+                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_OS,
+                value: process.platform,
+            },
+        ];
+        if (ghWorkflowName) {
+            baseMetadata.push({
+                gemini_cli_key: EventMetadataKey.GEMINI_CLI_GH_WORKFLOW_NAME,
+                value: ghWorkflowName,
+            });
         }
-        data = this.addDefaultFields(data);
-        const logEvent = {
+        return {
             console_type: 'GEMINI_CLI',
             application: 102, // GEMINI_CLI
             event_name: eventName,
-            event_metadata: [data],
+            event_metadata: [baseMetadata],
         };
+    }
+    createLogEvent(eventName, data = []) {
+        const email = this.userAccountManager.getCachedGoogleAccount();
+        if (eventName !== EventNames.START_SESSION) {
+            data.push(...this.sessionData);
+        }
+        const totalAccounts = this.userAccountManager.getLifetimeGoogleAccounts();
+        data = this.addDefaultFields(data, totalAccounts);
+        const logEvent = this.createBasicLogEvent(eventName, data);
         // Should log either email or install ID, not both. See go/cloudmill-1p-oss-instrumentation#define-sessionable-id
         if (email) {
             logEvent.client_email = email;
         }
         else {
-            logEvent.client_install_id = getInstallationId();
+            logEvent.client_install_id = this.installationManager.getInstallationId();
         }
         return logEvent;
     }
@@ -162,20 +230,20 @@ export class ClearcutLogger {
             return;
         }
         this.flushToClearcut().catch((error) => {
-            console.debug('Error flushing to Clearcut:', error);
+            debugLogger.debug('Error flushing to Clearcut:', error);
         });
     }
     async flushToClearcut() {
         if (this.flushing) {
             if (this.config?.getDebugMode()) {
-                console.debug('ClearcutLogger: Flush already in progress, marking pending flush.');
+                debugLogger.debug('ClearcutLogger: Flush already in progress, marking pending flush.');
             }
             this.pendingFlush = true;
             return Promise.resolve({});
         }
         this.flushing = true;
         if (this.config?.getDebugMode()) {
-            console.log('Flushing log events to Clearcut.');
+            debugLogger.log('Flushing log events to Clearcut.');
         }
         const eventsToSend = this.events.toArray();
         this.events.clear();
@@ -226,7 +294,7 @@ export class ClearcutLogger {
             // Fire and forget the pending flush
             this.flushToClearcut().catch((error) => {
                 if (this.config?.getDebugMode()) {
-                    console.debug('Error in pending flush to Clearcut:', error);
+                    debugLogger.debug('Error in pending flush to Clearcut:', error);
                 }
             });
         }
@@ -286,12 +354,35 @@ 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_START_SESSION_MCP_SERVERS_COUNT,
+                value: event.mcp_servers_count
+                    ? event.mcp_servers_count.toString()
+                    : '',
+            },
+            {
+                gemini_cli_key: EventMetadataKey.GEMINI_CLI_START_SESSION_MCP_TOOLS_COUNT,
+                value: event.mcp_tools_count?.toString() ?? '',
+            },
+            {
+                gemini_cli_key: EventMetadataKey.GEMINI_CLI_START_SESSION_MCP_TOOLS,
+                value: event.mcp_tools ? event.mcp_tools : '',
+            },
+            {
+                gemini_cli_key: EventMetadataKey.GEMINI_CLI_START_SESSION_EXTENSIONS_COUNT,
+                value: event.extensions_count.toString(),
+            },
+            // We deliberately do not log the names of extensions here, to be safe.
+            {
+                gemini_cli_key: EventMetadataKey.GEMINI_CLI_START_SESSION_EXTENSION_IDS,
+                value: event.extension_ids.toString(),
+            },
         ];
         this.sessionData = data;
         // Flush start event immediately
         this.enqueueLogEvent(this.createLogEvent(EventNames.START_SESSION, data));
         this.flushToClearcut().catch((error) => {
-            console.debug('Error flushing to Clearcut:', error);
+            debugLogger.debug('Error flushing to Clearcut:', error);
         });
     }
     logNewPromptEvent(event) {
@@ -323,10 +414,6 @@ export class ClearcutLogger {
                 gemini_cli_key: EventMetadataKey.GEMINI_CLI_TOOL_CALL_DURATION_MS,
                 value: JSON.stringify(event.duration_ms),
             },
-            {
-                gemini_cli_key: EventMetadataKey.GEMINI_CLI_TOOL_ERROR_MESSAGE,
-                value: JSON.stringify(event.error),
-            },
             {
                 gemini_cli_key: EventMetadataKey.GEMINI_CLI_TOOL_CALL_ERROR_TYPE,
                 value: JSON.stringify(event.error_type),
@@ -335,13 +422,25 @@ export class ClearcutLogger {
                 gemini_cli_key: EventMetadataKey.GEMINI_CLI_TOOL_TYPE,
                 value: JSON.stringify(event.tool_type),
             },
+            {
+                gemini_cli_key: EventMetadataKey.GEMINI_CLI_TOOL_CALL_CONTENT_LENGTH,
+                value: JSON.stringify(event.content_length),
+            },
+            {
+                gemini_cli_key: EventMetadataKey.GEMINI_CLI_TOOL_CALL_MCP_SERVER_NAME,
+                value: JSON.stringify(event.mcp_server_name),
+            },
         ];
         if (event.metadata) {
             const metadataMapping = {
-                ai_added_lines: EventMetadataKey.GEMINI_CLI_AI_ADDED_LINES,
-                ai_removed_lines: EventMetadataKey.GEMINI_CLI_AI_REMOVED_LINES,
+                model_added_lines: EventMetadataKey.GEMINI_CLI_AI_ADDED_LINES,
+                model_removed_lines: EventMetadataKey.GEMINI_CLI_AI_REMOVED_LINES,
+                model_added_chars: EventMetadataKey.GEMINI_CLI_AI_ADDED_CHARS,
+                model_removed_chars: EventMetadataKey.GEMINI_CLI_AI_REMOVED_CHARS,
                 user_added_lines: EventMetadataKey.GEMINI_CLI_USER_ADDED_LINES,
                 user_removed_lines: EventMetadataKey.GEMINI_CLI_USER_REMOVED_LINES,
+                user_added_chars: EventMetadataKey.GEMINI_CLI_USER_ADDED_CHARS,
+                user_removed_chars: EventMetadataKey.GEMINI_CLI_USER_REMOVED_CHARS,
             };
             for (const [key, gemini_cli_key] of Object.entries(metadataMapping)) {
                 if (event.metadata[key] !== undefined) {
@@ -352,10 +451,49 @@ export class ClearcutLogger {
                 }
             }
         }
+        if (event.extension_id) {
+            data.push({
+                gemini_cli_key: EventMetadataKey.GEMINI_CLI_EXTENSION_ID,
+                value: event.extension_id,
+            });
+        }
         const logEvent = this.createLogEvent(EventNames.TOOL_CALL, data);
         this.enqueueLogEvent(logEvent);
         this.flushIfNeeded();
     }
+    logFileOperationEvent(event) {
+        const data = [
+            {
+                gemini_cli_key: EventMetadataKey.GEMINI_CLI_TOOL_CALL_NAME,
+                value: JSON.stringify(event.tool_name),
+            },
+            {
+                gemini_cli_key: EventMetadataKey.GEMINI_CLI_FILE_OPERATION_TYPE,
+                value: JSON.stringify(event.operation),
+            },
+            {
+                gemini_cli_key: EventMetadataKey.GEMINI_CLI_FILE_OPERATION_LINES,
+                value: JSON.stringify(event.lines),
+            },
+            {
+                gemini_cli_key: EventMetadataKey.GEMINI_CLI_FILE_OPERATION_MIMETYPE,
+                value: JSON.stringify(event.mimetype),
+            },
+            {
+                gemini_cli_key: EventMetadataKey.GEMINI_CLI_FILE_OPERATION_EXTENSION,
+                value: JSON.stringify(event.extension),
+            },
+        ];
+        if (event.programming_language) {
+            data.push({
+                gemini_cli_key: EventMetadataKey.GEMINI_CLI_PROGRAMMING_LANGUAGE,
+                value: event.programming_language,
+            });
+        }
+        const logEvent = this.createLogEvent(EventNames.FILE_OPERATION, data);
+        this.enqueueLogEvent(logEvent);
+        this.flushIfNeeded();
+    }
     logApiRequestEvent(event) {
         const data = [
             {
@@ -380,29 +518,25 @@ export class ClearcutLogger {
                 gemini_cli_key: EventMetadataKey.GEMINI_CLI_API_RESPONSE_DURATION_MS,
                 value: JSON.stringify(event.duration_ms),
             },
-            {
-                gemini_cli_key: EventMetadataKey.GEMINI_CLI_API_ERROR_MESSAGE,
-                value: JSON.stringify(event.error),
-            },
             {
                 gemini_cli_key: EventMetadataKey.GEMINI_CLI_API_RESPONSE_INPUT_TOKEN_COUNT,
-                value: JSON.stringify(event.input_token_count),
+                value: JSON.stringify(event.usage.input_token_count),
             },
             {
                 gemini_cli_key: EventMetadataKey.GEMINI_CLI_API_RESPONSE_OUTPUT_TOKEN_COUNT,
-                value: JSON.stringify(event.output_token_count),
+                value: JSON.stringify(event.usage.output_token_count),
             },
             {
                 gemini_cli_key: EventMetadataKey.GEMINI_CLI_API_RESPONSE_CACHED_TOKEN_COUNT,
-                value: JSON.stringify(event.cached_content_token_count),
+                value: JSON.stringify(event.usage.cached_content_token_count),
             },
             {
                 gemini_cli_key: EventMetadataKey.GEMINI_CLI_API_RESPONSE_THINKING_TOKEN_COUNT,
-                value: JSON.stringify(event.thoughts_token_count),
+                value: JSON.stringify(event.usage.thoughts_token_count),
             },
             {
                 gemini_cli_key: EventMetadataKey.GEMINI_CLI_API_RESPONSE_TOOL_TOKEN_COUNT,
-                value: JSON.stringify(event.tool_token_count),
+                value: JSON.stringify(event.usage.tool_token_count),
             },
         ];
         this.enqueueLogEvent(this.createLogEvent(EventNames.API_RESPONSE, data));
@@ -446,7 +580,13 @@ export class ClearcutLogger {
     logFlashFallbackEvent() {
         this.enqueueLogEvent(this.createLogEvent(EventNames.FLASH_FALLBACK, []));
         this.flushToClearcut().catch((error) => {
-            console.debug('Error flushing to Clearcut:', error);
+            debugLogger.debug('Error flushing to Clearcut:', error);
+        });
+    }
+    logRipgrepFallbackEvent() {
+        this.enqueueLogEvent(this.createLogEvent(EventNames.RIPGREP_FALLBACK, []));
+        this.flushToClearcut().catch((error) => {
+            debugLogger.debug('Error flushing to Clearcut:', error);
         });
     }
     logLoopDetectedEvent(event) {
@@ -456,9 +596,20 @@ export class ClearcutLogger {
                 value: JSON.stringify(event.loop_type),
             },
         ];
+        if (event.confirmed_by_model) {
+            data.push({
+                gemini_cli_key: EventMetadataKey.GEMINI_CLI_LOOP_DETECTED_CONFIRMED_BY_MODEL,
+                value: event.confirmed_by_model,
+            });
+        }
         this.enqueueLogEvent(this.createLogEvent(EventNames.LOOP_DETECTED, data));
         this.flushIfNeeded();
     }
+    logLoopDetectionDisabledEvent() {
+        const data = [];
+        this.enqueueLogEvent(this.createLogEvent(EventNames.LOOP_DETECTION_DISABLED, data));
+        this.flushIfNeeded();
+    }
     logNextSpeakerCheck(event) {
         const data = [
             {
@@ -492,6 +643,12 @@ export class ClearcutLogger {
                 value: JSON.stringify(event.status),
             });
         }
+        if (event.extension_id) {
+            data.push({
+                gemini_cli_key: EventMetadataKey.GEMINI_CLI_EXTENSION_ID,
+                value: event.extension_id,
+            });
+        }
         this.enqueueLogEvent(this.createLogEvent(EventNames.SLASH_COMMAND, data));
         this.flushIfNeeded();
     }
@@ -515,34 +672,399 @@ export class ClearcutLogger {
         this.enqueueLogEvent(this.createLogEvent(EventNames.IDE_CONNECTION, data));
         this.flushIfNeeded();
     }
-    logKittySequenceOverflowEvent(event) {
+    logConversationFinishedEvent(event) {
         const data = [
             {
-                gemini_cli_key: EventMetadataKey.GEMINI_CLI_KITTY_SEQUENCE_LENGTH,
-                value: event.sequence_length.toString(),
+                gemini_cli_key: EventMetadataKey.GEMINI_CLI_SESSION_ID,
+                value: this.config?.getSessionId() ?? '',
+            },
+            {
+                gemini_cli_key: EventMetadataKey.GEMINI_CLI_CONVERSATION_TURN_COUNT,
+                value: JSON.stringify(event.turnCount),
             },
             {
-                gemini_cli_key: EventMetadataKey.GEMINI_CLI_KITTY_TRUNCATED_SEQUENCE,
-                value: event.truncated_sequence,
+                gemini_cli_key: EventMetadataKey.GEMINI_CLI_APPROVAL_MODE,
+                value: event.approvalMode,
             },
         ];
-        this.enqueueLogEvent(this.createLogEvent(EventNames.KITTY_SEQUENCE_OVERFLOW, data));
+        this.enqueueLogEvent(this.createLogEvent(EventNames.CONVERSATION_FINISHED, data));
         this.flushIfNeeded();
     }
     logEndSessionEvent() {
         // Flush immediately on session end.
         this.enqueueLogEvent(this.createLogEvent(EventNames.END_SESSION, []));
         this.flushToClearcut().catch((error) => {
-            console.debug('Error flushing to Clearcut:', error);
+            debugLogger.debug('Error flushing to Clearcut:', error);
+        });
+    }
+    logInvalidChunkEvent(event) {
+        const data = [];
+        if (event.error_message) {
+            data.push({
+                gemini_cli_key: EventMetadataKey.GEMINI_CLI_INVALID_CHUNK_ERROR_MESSAGE,
+                value: event.error_message,
+            });
+        }
+        this.enqueueLogEvent(this.createLogEvent(EventNames.INVALID_CHUNK, data));
+        this.flushIfNeeded();
+    }
+    logContentRetryEvent(event) {
+        const data = [
+            {
+                gemini_cli_key: EventMetadataKey.GEMINI_CLI_CONTENT_RETRY_ATTEMPT_NUMBER,
+                value: String(event.attempt_number),
+            },
+            {
+                gemini_cli_key: EventMetadataKey.GEMINI_CLI_CONTENT_RETRY_ERROR_TYPE,
+                value: event.error_type,
+            },
+            {
+                gemini_cli_key: EventMetadataKey.GEMINI_CLI_CONTENT_RETRY_DELAY_MS,
+                value: String(event.retry_delay_ms),
+            },
+            {
+                gemini_cli_key: EventMetadataKey.GEMINI_CLI_API_REQUEST_MODEL,
+                value: event.model,
+            },
+        ];
+        this.enqueueLogEvent(this.createLogEvent(EventNames.CONTENT_RETRY, data));
+        this.flushIfNeeded();
+    }
+    logContentRetryFailureEvent(event) {
+        const data = [
+            {
+                gemini_cli_key: EventMetadataKey.GEMINI_CLI_CONTENT_RETRY_FAILURE_TOTAL_ATTEMPTS,
+                value: String(event.total_attempts),
+            },
+            {
+                gemini_cli_key: EventMetadataKey.GEMINI_CLI_CONTENT_RETRY_FAILURE_FINAL_ERROR_TYPE,
+                value: event.final_error_type,
+            },
+            {
+                gemini_cli_key: EventMetadataKey.GEMINI_CLI_API_REQUEST_MODEL,
+                value: event.model,
+            },
+        ];
+        if (event.total_duration_ms) {
+            data.push({
+                gemini_cli_key: EventMetadataKey.GEMINI_CLI_CONTENT_RETRY_FAILURE_TOTAL_DURATION_MS,
+                value: String(event.total_duration_ms),
+            });
+        }
+        this.enqueueLogEvent(this.createLogEvent(EventNames.CONTENT_RETRY_FAILURE, data));
+        this.flushIfNeeded();
+    }
+    async logExtensionInstallEvent(event) {
+        const data = [
+            {
+                gemini_cli_key: EventMetadataKey.GEMINI_CLI_EXTENSION_NAME,
+                value: event.extension_name,
+            },
+            {
+                gemini_cli_key: EventMetadataKey.GEMINI_CLI_EXTENSION_ID,
+                value: event.extension_id,
+            },
+            {
+                gemini_cli_key: EventMetadataKey.GEMINI_CLI_EXTENSION_VERSION,
+                value: event.extension_version,
+            },
+            {
+                gemini_cli_key: EventMetadataKey.GEMINI_CLI_EXTENSION_SOURCE,
+                value: event.extension_source,
+            },
+            {
+                gemini_cli_key: EventMetadataKey.GEMINI_CLI_EXTENSION_INSTALL_STATUS,
+                value: event.status,
+            },
+        ];
+        this.enqueueLogEvent(this.createBasicLogEvent(EventNames.EXTENSION_INSTALL, data));
+        await this.flushToClearcut().catch((error) => {
+            debugLogger.debug('Error flushing to Clearcut:', error);
+        });
+    }
+    async logExtensionUninstallEvent(event) {
+        const data = [
+            {
+                gemini_cli_key: EventMetadataKey.GEMINI_CLI_EXTENSION_NAME,
+                value: event.extension_name,
+            },
+            {
+                gemini_cli_key: EventMetadataKey.GEMINI_CLI_EXTENSION_ID,
+                value: event.extension_id,
+            },
+            {
+                gemini_cli_key: EventMetadataKey.GEMINI_CLI_EXTENSION_UNINSTALL_STATUS,
+                value: event.status,
+            },
+        ];
+        this.enqueueLogEvent(this.createBasicLogEvent(EventNames.EXTENSION_UNINSTALL, data));
+        await this.flushToClearcut().catch((error) => {
+            debugLogger.debug('Error flushing to Clearcut:', error);
         });
     }
+    async logExtensionUpdateEvent(event) {
+        const data = [
+            {
+                gemini_cli_key: EventMetadataKey.GEMINI_CLI_EXTENSION_NAME,
+                value: event.extension_name,
+            },
+            {
+                gemini_cli_key: EventMetadataKey.GEMINI_CLI_EXTENSION_ID,
+                value: event.extension_id,
+            },
+            {
+                gemini_cli_key: EventMetadataKey.GEMINI_CLI_EXTENSION_VERSION,
+                value: event.extension_version,
+            },
+            {
+                gemini_cli_key: EventMetadataKey.GEMINI_CLI_EXTENSION_PREVIOUS_VERSION,
+                value: event.extension_previous_version,
+            },
+            {
+                gemini_cli_key: EventMetadataKey.GEMINI_CLI_EXTENSION_SOURCE,
+                value: event.extension_source,
+            },
+            {
+                gemini_cli_key: EventMetadataKey.GEMINI_CLI_EXTENSION_UPDATE_STATUS,
+                value: event.status,
+            },
+        ];
+        this.enqueueLogEvent(this.createBasicLogEvent(EventNames.EXTENSION_UPDATE, data));
+        await this.flushToClearcut().catch((error) => {
+            debugLogger.debug('Error flushing to Clearcut:', error);
+        });
+    }
+    logToolOutputTruncatedEvent(event) {
+        const data = [
+            {
+                gemini_cli_key: EventMetadataKey.GEMINI_CLI_TOOL_CALL_NAME,
+                value: JSON.stringify(event.tool_name),
+            },
+            {
+                gemini_cli_key: EventMetadataKey.GEMINI_CLI_TOOL_OUTPUT_TRUNCATED_ORIGINAL_LENGTH,
+                value: JSON.stringify(event.original_content_length),
+            },
+            {
+                gemini_cli_key: EventMetadataKey.GEMINI_CLI_TOOL_OUTPUT_TRUNCATED_TRUNCATED_LENGTH,
+                value: JSON.stringify(event.truncated_content_length),
+            },
+            {
+                gemini_cli_key: EventMetadataKey.GEMINI_CLI_TOOL_OUTPUT_TRUNCATED_THRESHOLD,
+                value: JSON.stringify(event.threshold),
+            },
+            {
+                gemini_cli_key: EventMetadataKey.GEMINI_CLI_TOOL_OUTPUT_TRUNCATED_LINES,
+                value: JSON.stringify(event.lines),
+            },
+        ];
+        this.enqueueLogEvent(this.createLogEvent(EventNames.TOOL_OUTPUT_TRUNCATED, data));
+        this.flushIfNeeded();
+    }
+    logModelRoutingEvent(event) {
+        const data = [
+            {
+                gemini_cli_key: EventMetadataKey.GEMINI_CLI_ROUTING_DECISION,
+                value: event.decision_model,
+            },
+            {
+                gemini_cli_key: EventMetadataKey.GEMINI_CLI_ROUTING_DECISION_SOURCE,
+                value: event.decision_source,
+            },
+            {
+                gemini_cli_key: EventMetadataKey.GEMINI_CLI_ROUTING_LATENCY_MS,
+                value: event.routing_latency_ms.toString(),
+            },
+            {
+                gemini_cli_key: EventMetadataKey.GEMINI_CLI_ROUTING_FAILURE,
+                value: event.failed.toString(),
+            },
+        ];
+        if (event.error_message) {
+            data.push({
+                gemini_cli_key: EventMetadataKey.GEMINI_CLI_ROUTING_FAILURE_REASON,
+                value: event.error_message,
+            });
+        }
+        this.enqueueLogEvent(this.createLogEvent(EventNames.MODEL_ROUTING, data));
+        this.flushIfNeeded();
+    }
+    async logExtensionEnableEvent(event) {
+        const data = [
+            {
+                gemini_cli_key: EventMetadataKey.GEMINI_CLI_EXTENSION_NAME,
+                value: event.extension_name,
+            },
+            {
+                gemini_cli_key: EventMetadataKey.GEMINI_CLI_EXTENSION_ID,
+                value: event.extension_id,
+            },
+            {
+                gemini_cli_key: EventMetadataKey.GEMINI_CLI_EXTENSION_ENABLE_SETTING_SCOPE,
+                value: event.setting_scope,
+            },
+        ];
+        this.enqueueLogEvent(this.createBasicLogEvent(EventNames.EXTENSION_ENABLE, data));
+        await this.flushToClearcut().catch((error) => {
+            debugLogger.debug('Error flushing to Clearcut:', error);
+        });
+    }
+    logModelSlashCommandEvent(event) {
+        const data = [
+            {
+                gemini_cli_key: EventMetadataKey.GEMINI_CLI_MODEL_SLASH_COMMAND,
+                value: event.model_name,
+            },
+        ];
+        this.enqueueLogEvent(this.createLogEvent(EventNames.MODEL_SLASH_COMMAND, data));
+        this.flushIfNeeded();
+    }
+    async logExtensionDisableEvent(event) {
+        const data = [
+            {
+                gemini_cli_key: EventMetadataKey.GEMINI_CLI_EXTENSION_NAME,
+                value: event.extension_name,
+            },
+            {
+                gemini_cli_key: EventMetadataKey.GEMINI_CLI_EXTENSION_ID,
+                value: event.extension_id,
+            },
+            {
+                gemini_cli_key: EventMetadataKey.GEMINI_CLI_EXTENSION_DISABLE_SETTING_SCOPE,
+                value: event.setting_scope,
+            },
+        ];
+        this.enqueueLogEvent(this.createBasicLogEvent(EventNames.EXTENSION_DISABLE, data));
+        await this.flushToClearcut().catch((error) => {
+            debugLogger.debug('Error flushing to Clearcut:', error);
+        });
+    }
+    logSmartEditStrategyEvent(event) {
+        const data = [
+            {
+                gemini_cli_key: EventMetadataKey.GEMINI_CLI_SMART_EDIT_STRATEGY,
+                value: event.strategy,
+            },
+        ];
+        this.enqueueLogEvent(this.createLogEvent(EventNames.SMART_EDIT_STRATEGY, data));
+        this.flushIfNeeded();
+    }
+    logSmartEditCorrectionEvent(event) {
+        const data = [
+            {
+                gemini_cli_key: EventMetadataKey.GEMINI_CLI_SMART_EDIT_CORRECTION,
+                value: event.correction,
+            },
+        ];
+        this.enqueueLogEvent(this.createLogEvent(EventNames.SMART_EDIT_CORRECTION, data));
+        this.flushIfNeeded();
+    }
+    logAgentStartEvent(event) {
+        const data = [
+            {
+                gemini_cli_key: EventMetadataKey.GEMINI_CLI_AGENT_ID,
+                value: event.agent_id,
+            },
+            {
+                gemini_cli_key: EventMetadataKey.GEMINI_CLI_AGENT_NAME,
+                value: event.agent_name,
+            },
+        ];
+        this.enqueueLogEvent(this.createLogEvent(EventNames.AGENT_START, data));
+        this.flushIfNeeded();
+    }
+    logAgentFinishEvent(event) {
+        const data = [
+            {
+                gemini_cli_key: EventMetadataKey.GEMINI_CLI_AGENT_ID,
+                value: event.agent_id,
+            },
+            {
+                gemini_cli_key: EventMetadataKey.GEMINI_CLI_AGENT_NAME,
+                value: event.agent_name,
+            },
+            {
+                gemini_cli_key: EventMetadataKey.GEMINI_CLI_AGENT_DURATION_MS,
+                value: event.duration_ms.toString(),
+            },
+            {
+                gemini_cli_key: EventMetadataKey.GEMINI_CLI_AGENT_TURN_COUNT,
+                value: event.turn_count.toString(),
+            },
+            {
+                gemini_cli_key: EventMetadataKey.GEMINI_CLI_AGENT_TERMINATE_REASON,
+                value: event.terminate_reason,
+            },
+        ];
+        this.enqueueLogEvent(this.createLogEvent(EventNames.AGENT_FINISH, data));
+        this.flushIfNeeded();
+    }
+    logRecoveryAttemptEvent(event) {
+        const data = [
+            {
+                gemini_cli_key: EventMetadataKey.GEMINI_CLI_AGENT_ID,
+                value: event.agent_id,
+            },
+            {
+                gemini_cli_key: EventMetadataKey.GEMINI_CLI_AGENT_NAME,
+                value: event.agent_name,
+            },
+            {
+                gemini_cli_key: EventMetadataKey.GEMINI_CLI_AGENT_RECOVERY_REASON,
+                value: event.reason,
+            },
+            {
+                gemini_cli_key: EventMetadataKey.GEMINI_CLI_AGENT_RECOVERY_DURATION_MS,
+                value: event.duration_ms.toString(),
+            },
+            {
+                gemini_cli_key: EventMetadataKey.GEMINI_CLI_AGENT_RECOVERY_SUCCESS,
+                value: event.success.toString(),
+            },
+            {
+                gemini_cli_key: EventMetadataKey.GEMINI_CLI_AGENT_TURN_COUNT,
+                value: event.turn_count.toString(),
+            },
+        ];
+        this.enqueueLogEvent(this.createLogEvent(EventNames.RECOVERY_ATTEMPT, data));
+        this.flushIfNeeded();
+    }
+    logWebFetchFallbackAttemptEvent(event) {
+        const data = [
+            {
+                gemini_cli_key: EventMetadataKey.GEMINI_CLI_WEB_FETCH_FALLBACK_REASON,
+                value: event.reason,
+            },
+        ];
+        this.enqueueLogEvent(this.createLogEvent(EventNames.WEB_FETCH_FALLBACK_ATTEMPT, data));
+        this.flushIfNeeded();
+    }
+    logLlmLoopCheckEvent(event) {
+        const data = [
+            {
+                gemini_cli_key: EventMetadataKey.GEMINI_CLI_PROMPT_ID,
+                value: event.prompt_id,
+            },
+            {
+                gemini_cli_key: EventMetadataKey.GEMINI_CLI_LLM_LOOP_CHECK_FLASH_CONFIDENCE,
+                value: event.flash_confidence.toString(),
+            },
+            {
+                gemini_cli_key: EventMetadataKey.GEMINI_CLI_LLM_LOOP_CHECK_MAIN_MODEL,
+                value: event.main_model,
+            },
+            {
+                gemini_cli_key: EventMetadataKey.GEMINI_CLI_LLM_LOOP_CHECK_MAIN_MODEL_CONFIDENCE,
+                value: event.main_model_confidence.toString(),
+            },
+        ];
+        this.enqueueLogEvent(this.createLogEvent(EventNames.LLM_LOOP_CHECK, data));
+        this.flushIfNeeded();
+    }
     /**
      * 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();
+    addDefaultFields(data, totalAccounts) {
         const defaultLogMetadata = [
             {
                 gemini_cli_key: EventMetadataKey.GEMINI_CLI_SESSION_ID,
@@ -557,20 +1079,20 @@ export class ClearcutLogger {
                 value: `${totalAccounts}`,
             },
             {
-                gemini_cli_key: EventMetadataKey.GEMINI_CLI_SURFACE,
-                value: surface,
+                gemini_cli_key: EventMetadataKey.GEMINI_CLI_PROMPT_ID,
+                value: this.promptId,
             },
             {
-                gemini_cli_key: EventMetadataKey.GEMINI_CLI_VERSION,
-                value: CLI_VERSION,
+                gemini_cli_key: EventMetadataKey.GEMINI_CLI_NODE_VERSION,
+                value: process.versions.node,
             },
             {
-                gemini_cli_key: EventMetadataKey.GEMINI_CLI_GIT_COMMIT_HASH,
-                value: GIT_COMMIT_INFO,
+                gemini_cli_key: EventMetadataKey.GEMINI_CLI_USER_SETTINGS,
+                value: this.getConfigJson(),
             },
             {
-                gemini_cli_key: EventMetadataKey.GEMINI_CLI_PROMPT_ID,
-                value: this.promptId,
+                gemini_cli_key: EventMetadataKey.GEMINI_CLI_INTERACTIVE,
+                value: this.config?.isInteractive().toString() ?? 'false',
             },
         ];
         return [...data, ...defaultLogMetadata];
@@ -588,6 +1110,9 @@ export class ClearcutLogger {
             throw new Error('Unsupported proxy type');
         }
     }
+    getConfigJson() {
+        return safeJsonStringifyBooleanValuesOnly(this.config);
+    }
     shutdown() {
         this.logEndSessionEvent();
     }
@@ -596,14 +1121,14 @@ export class ClearcutLogger {
         const eventsToRetry = eventsToSend.slice(-MAX_RETRY_EVENTS); // Keep only the most recent events
         // Log a warning if we're dropping 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}`);
+            debugLogger.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 = MAX_EVENTS - this.events.size;
         const numEventsToRequeue = Math.min(eventsToRetry.length, availableSpace);
         if (numEventsToRequeue === 0) {
             if (this.config?.getDebugMode()) {
-                console.debug(`ClearcutLogger: No events re-queued (queue size: ${this.events.size})`);
+                debugLogger.debug(`ClearcutLogger: No events re-queued (queue size: ${this.events.size})`);
             }
             return;
         }
@@ -619,7 +1144,7 @@ export class ClearcutLogger {
             this.events.pop();
         }
         if (this.config?.getDebugMode()) {
-            console.debug(`ClearcutLogger: Re-queued ${numEventsToRequeue} events for retry (queue size: ${this.events.size})`);
+            debugLogger.debug(`ClearcutLogger: Re-queued ${numEventsToRequeue} events for retry (queue size: ${this.events.size})`);
         }
     }
 }