@google/gemini-cli-core 0.9.0-nightly.20250926.1487841d → 0.9.0-nightly.20251001.33269bdb

package/dist/src/telemetry/metrics.js

@@ -4,9 +4,226 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 import { diag, metrics, ValueType } from '@opentelemetry/api';
-import { SERVICE_NAME, METRIC_TOOL_CALL_COUNT, METRIC_TOOL_CALL_LATENCY, METRIC_API_REQUEST_COUNT, METRIC_API_REQUEST_LATENCY, METRIC_TOKEN_USAGE, METRIC_SESSION_COUNT, METRIC_FILE_OPERATION_COUNT, EVENT_CHAT_COMPRESSION, METRIC_INVALID_CHUNK_COUNT, METRIC_CONTENT_RETRY_COUNT, METRIC_CONTENT_RETRY_FAILURE_COUNT, METRIC_MODEL_ROUTING_LATENCY, METRIC_MODEL_ROUTING_FAILURE_COUNT, METRIC_MODEL_SLASH_COMMAND_CALL_COUNT, 
+import { SERVICE_NAME, EVENT_CHAT_COMPRESSION } from './constants.js';
+import { AuthType } from '../core/contentGenerator.js';
+const TOOL_CALL_COUNT = 'gemini_cli.tool.call.count';
+const TOOL_CALL_LATENCY = 'gemini_cli.tool.call.latency';
+const API_REQUEST_COUNT = 'gemini_cli.api.request.count';
+const API_REQUEST_LATENCY = 'gemini_cli.api.request.latency';
+const TOKEN_USAGE = 'gemini_cli.token.usage';
+const SESSION_COUNT = 'gemini_cli.session.count';
+const FILE_OPERATION_COUNT = 'gemini_cli.file.operation.count';
+const INVALID_CHUNK_COUNT = 'gemini_cli.chat.invalid_chunk.count';
+const CONTENT_RETRY_COUNT = 'gemini_cli.chat.content_retry.count';
+const CONTENT_RETRY_FAILURE_COUNT = 'gemini_cli.chat.content_retry_failure.count';
+const MODEL_ROUTING_LATENCY = 'gemini_cli.model_routing.latency';
+const MODEL_ROUTING_FAILURE_COUNT = 'gemini_cli.model_routing.failure.count';
+const MODEL_SLASH_COMMAND_CALL_COUNT = 'gemini_cli.slash_command.model.call_count';
+// OpenTelemetry GenAI Semantic Convention Metrics
+const GEN_AI_CLIENT_TOKEN_USAGE = 'gen_ai.client.token.usage';
+const GEN_AI_CLIENT_OPERATION_DURATION = 'gen_ai.client.operation.duration';
 // Performance Monitoring Metrics
-METRIC_STARTUP_TIME, METRIC_MEMORY_USAGE, METRIC_CPU_USAGE, METRIC_TOOL_QUEUE_DEPTH, METRIC_TOOL_EXECUTION_BREAKDOWN, METRIC_TOKEN_EFFICIENCY, METRIC_API_REQUEST_BREAKDOWN, METRIC_PERFORMANCE_SCORE, METRIC_REGRESSION_DETECTION, METRIC_REGRESSION_PERCENTAGE_CHANGE, METRIC_BASELINE_COMPARISON, } from './constants.js';
+const STARTUP_TIME = 'gemini_cli.startup.duration';
+const MEMORY_USAGE = 'gemini_cli.memory.usage';
+const CPU_USAGE = 'gemini_cli.cpu.usage';
+const TOOL_QUEUE_DEPTH = 'gemini_cli.tool.queue.depth';
+const TOOL_EXECUTION_BREAKDOWN = 'gemini_cli.tool.execution.breakdown';
+const TOKEN_EFFICIENCY = 'gemini_cli.token.efficiency';
+const API_REQUEST_BREAKDOWN = 'gemini_cli.api.request.breakdown';
+const PERFORMANCE_SCORE = 'gemini_cli.performance.score';
+const REGRESSION_DETECTION = 'gemini_cli.performance.regression';
+const REGRESSION_PERCENTAGE_CHANGE = 'gemini_cli.performance.regression.percentage_change';
+const BASELINE_COMPARISON = 'gemini_cli.performance.baseline.comparison';
+const baseMetricDefinition = {
+    getCommonAttributes: (config) => ({
+        'session.id': config.getSessionId(),
+    }),
+};
+const COUNTER_DEFINITIONS = {
+    [TOOL_CALL_COUNT]: {
+        description: 'Counts tool calls, tagged by function name and success.',
+        valueType: ValueType.INT,
+        assign: (c) => (toolCallCounter = c),
+        attributes: {},
+    },
+    [API_REQUEST_COUNT]: {
+        description: 'Counts API requests, tagged by model and status.',
+        valueType: ValueType.INT,
+        assign: (c) => (apiRequestCounter = c),
+        attributes: {},
+    },
+    [TOKEN_USAGE]: {
+        description: 'Counts the total number of tokens used.',
+        valueType: ValueType.INT,
+        assign: (c) => (tokenUsageCounter = c),
+        attributes: {},
+    },
+    [SESSION_COUNT]: {
+        description: 'Count of CLI sessions started.',
+        valueType: ValueType.INT,
+        assign: (c) => (sessionCounter = c),
+        attributes: {},
+    },
+    [FILE_OPERATION_COUNT]: {
+        description: 'Counts file operations (create, read, update).',
+        valueType: ValueType.INT,
+        assign: (c) => (fileOperationCounter = c),
+        attributes: {},
+    },
+    [INVALID_CHUNK_COUNT]: {
+        description: 'Counts invalid chunks received from a stream.',
+        valueType: ValueType.INT,
+        assign: (c) => (invalidChunkCounter = c),
+        attributes: {},
+    },
+    [CONTENT_RETRY_COUNT]: {
+        description: 'Counts retries due to content errors (e.g., empty stream).',
+        valueType: ValueType.INT,
+        assign: (c) => (contentRetryCounter = c),
+        attributes: {},
+    },
+    [CONTENT_RETRY_FAILURE_COUNT]: {
+        description: 'Counts occurrences of all content retries failing.',
+        valueType: ValueType.INT,
+        assign: (c) => (contentRetryFailureCounter = c),
+        attributes: {},
+    },
+    [MODEL_ROUTING_FAILURE_COUNT]: {
+        description: 'Counts model routing failures.',
+        valueType: ValueType.INT,
+        assign: (c) => (modelRoutingFailureCounter = c),
+        attributes: {},
+    },
+    [MODEL_SLASH_COMMAND_CALL_COUNT]: {
+        description: 'Counts model slash command calls.',
+        valueType: ValueType.INT,
+        assign: (c) => (modelSlashCommandCallCounter = c),
+        attributes: {},
+    },
+    [EVENT_CHAT_COMPRESSION]: {
+        description: 'Counts chat compression events.',
+        valueType: ValueType.INT,
+        assign: (c) => (chatCompressionCounter = c),
+        attributes: {},
+    },
+};
+const HISTOGRAM_DEFINITIONS = {
+    [TOOL_CALL_LATENCY]: {
+        description: 'Latency of tool calls in milliseconds.',
+        unit: 'ms',
+        valueType: ValueType.INT,
+        assign: (h) => (toolCallLatencyHistogram = h),
+        attributes: {},
+    },
+    [API_REQUEST_LATENCY]: {
+        description: 'Latency of API requests in milliseconds.',
+        unit: 'ms',
+        valueType: ValueType.INT,
+        assign: (h) => (apiRequestLatencyHistogram = h),
+        attributes: {},
+    },
+    [MODEL_ROUTING_LATENCY]: {
+        description: 'Latency of model routing decisions in milliseconds.',
+        unit: 'ms',
+        valueType: ValueType.INT,
+        assign: (h) => (modelRoutingLatencyHistogram = h),
+        attributes: {},
+    },
+    [GEN_AI_CLIENT_TOKEN_USAGE]: {
+        description: 'Number of input and output tokens used.',
+        unit: 'token',
+        valueType: ValueType.INT,
+        assign: (h) => (genAiClientTokenUsageHistogram = h),
+        attributes: {},
+    },
+    [GEN_AI_CLIENT_OPERATION_DURATION]: {
+        description: 'GenAI operation duration.',
+        unit: 's',
+        valueType: ValueType.DOUBLE,
+        assign: (h) => (genAiClientOperationDurationHistogram = h),
+        attributes: {},
+    },
+};
+const PERFORMANCE_COUNTER_DEFINITIONS = {
+    [REGRESSION_DETECTION]: {
+        description: 'Performance regression detection events.',
+        valueType: ValueType.INT,
+        assign: (c) => (regressionDetectionCounter = c),
+        attributes: {},
+    },
+};
+const PERFORMANCE_HISTOGRAM_DEFINITIONS = {
+    [STARTUP_TIME]: {
+        description: 'CLI startup time in milliseconds, broken down by initialization phase.',
+        unit: 'ms',
+        valueType: ValueType.DOUBLE,
+        assign: (h) => (startupTimeHistogram = h),
+        attributes: {},
+    },
+    [MEMORY_USAGE]: {
+        description: 'Memory usage in bytes.',
+        unit: 'bytes',
+        valueType: ValueType.INT,
+        assign: (h) => (memoryUsageGauge = h),
+        attributes: {},
+    },
+    [CPU_USAGE]: {
+        description: 'CPU usage percentage.',
+        unit: 'percent',
+        valueType: ValueType.DOUBLE,
+        assign: (h) => (cpuUsageGauge = h),
+        attributes: {},
+    },
+    [TOOL_QUEUE_DEPTH]: {
+        description: 'Number of tools in execution queue.',
+        unit: 'count',
+        valueType: ValueType.INT,
+        assign: (h) => (toolQueueDepthGauge = h),
+        attributes: {},
+    },
+    [TOOL_EXECUTION_BREAKDOWN]: {
+        description: 'Tool execution time breakdown by phase in milliseconds.',
+        unit: 'ms',
+        valueType: ValueType.INT,
+        assign: (h) => (toolExecutionBreakdownHistogram = h),
+        attributes: {},
+    },
+    [TOKEN_EFFICIENCY]: {
+        description: 'Token efficiency metrics (tokens per operation, cache hit rate, etc.).',
+        unit: 'ratio',
+        valueType: ValueType.DOUBLE,
+        assign: (h) => (tokenEfficiencyHistogram = h),
+        attributes: {},
+    },
+    [API_REQUEST_BREAKDOWN]: {
+        description: 'API request time breakdown by phase in milliseconds.',
+        unit: 'ms',
+        valueType: ValueType.INT,
+        assign: (h) => (apiRequestBreakdownHistogram = h),
+        attributes: {},
+    },
+    [PERFORMANCE_SCORE]: {
+        description: 'Composite performance score (0-100).',
+        unit: 'score',
+        valueType: ValueType.DOUBLE,
+        assign: (h) => (performanceScoreGauge = h),
+        attributes: {},
+    },
+    [REGRESSION_PERCENTAGE_CHANGE]: {
+        description: 'Percentage change compared to baseline for detected regressions.',
+        unit: 'percent',
+        valueType: ValueType.DOUBLE,
+        assign: (h) => (regressionPercentageChangeHistogram = h),
+        attributes: {},
+    },
+    [BASELINE_COMPARISON]: {
+        description: 'Performance comparison to established baseline (percentage change).',
+        unit: 'percent',
+        valueType: ValueType.DOUBLE,
+        assign: (h) => (baselineComparisonHistogram = h),
+        attributes: {},
+    },
+};
 export var FileOperation;
 (function (FileOperation) {
     FileOperation["CREATE"] = "create";
@@ -43,12 +260,27 @@ export var ApiRequestPhase;
     ApiRequestPhase["RESPONSE_PROCESSING"] = "response_processing";
     ApiRequestPhase["TOKEN_PROCESSING"] = "token_processing";
 })(ApiRequestPhase || (ApiRequestPhase = {}));
+export var GenAiOperationName;
+(function (GenAiOperationName) {
+    GenAiOperationName["GENERATE_CONTENT"] = "generate_content";
+})(GenAiOperationName || (GenAiOperationName = {}));
+export var GenAiProviderName;
+(function (GenAiProviderName) {
+    GenAiProviderName["GCP_GEN_AI"] = "gcp.gen_ai";
+    GenAiProviderName["GCP_VERTEX_AI"] = "gcp.vertex_ai";
+})(GenAiProviderName || (GenAiProviderName = {}));
+export var GenAiTokenType;
+(function (GenAiTokenType) {
+    GenAiTokenType["INPUT"] = "input";
+    GenAiTokenType["OUTPUT"] = "output";
+})(GenAiTokenType || (GenAiTokenType = {}));
 let cliMeter;
 let toolCallCounter;
 let toolCallLatencyHistogram;
 let apiRequestCounter;
 let apiRequestLatencyHistogram;
 let tokenUsageCounter;
+let sessionCounter;
 let fileOperationCounter;
 let chatCompressionCounter;
 let invalidChunkCounter;
@@ -57,6 +289,9 @@ let contentRetryFailureCounter;
 let modelRoutingLatencyHistogram;
 let modelRoutingFailureCounter;
 let modelSlashCommandCallCounter;
+// OpenTelemetry GenAI Semantic Convention Metrics
+let genAiClientTokenUsageHistogram;
+let genAiClientOperationDurationHistogram;
 // Performance Monitoring Metrics
 let startupTimeHistogram;
 let memoryUsageGauge; // Using Histogram until ObservableGauge is available
@@ -71,11 +306,6 @@ let regressionPercentageChangeHistogram;
 let baselineComparisonHistogram;
 let isMetricsInitialized = false;
 let isPerformanceMonitoringEnabled = false;
-function getCommonAttributes(config) {
-    return {
-        'session.id': config.getSessionId(),
-    };
-}
 export function getMeter() {
     if (!cliMeter) {
         cliMeter = metrics.getMeter(SERVICE_NAME);
@@ -89,154 +319,87 @@ export function initializeMetrics(config) {
     if (!meter)
         return;
     // Initialize core metrics
-    toolCallCounter = meter.createCounter(METRIC_TOOL_CALL_COUNT, {
-        description: 'Counts tool calls, tagged by function name and success.',
-        valueType: ValueType.INT,
-    });
-    toolCallLatencyHistogram = meter.createHistogram(METRIC_TOOL_CALL_LATENCY, {
-        description: 'Latency of tool calls in milliseconds.',
-        unit: 'ms',
-        valueType: ValueType.INT,
-    });
-    apiRequestCounter = meter.createCounter(METRIC_API_REQUEST_COUNT, {
-        description: 'Counts API requests, tagged by model and status.',
-        valueType: ValueType.INT,
-    });
-    apiRequestLatencyHistogram = meter.createHistogram(METRIC_API_REQUEST_LATENCY, {
-        description: 'Latency of API requests in milliseconds.',
-        unit: 'ms',
-        valueType: ValueType.INT,
-    });
-    tokenUsageCounter = meter.createCounter(METRIC_TOKEN_USAGE, {
-        description: 'Counts the total number of tokens used.',
-        valueType: ValueType.INT,
-    });
-    fileOperationCounter = meter.createCounter(METRIC_FILE_OPERATION_COUNT, {
-        description: 'Counts file operations (create, read, update).',
-        valueType: ValueType.INT,
-    });
-    chatCompressionCounter = meter.createCounter(EVENT_CHAT_COMPRESSION, {
-        description: 'Counts chat compression events.',
-        valueType: ValueType.INT,
-    });
-    // New counters for content errors
-    invalidChunkCounter = meter.createCounter(METRIC_INVALID_CHUNK_COUNT, {
-        description: 'Counts invalid chunks received from a stream.',
-        valueType: ValueType.INT,
-    });
-    contentRetryCounter = meter.createCounter(METRIC_CONTENT_RETRY_COUNT, {
-        description: 'Counts retries due to content errors (e.g., empty stream).',
-        valueType: ValueType.INT,
-    });
-    contentRetryFailureCounter = meter.createCounter(METRIC_CONTENT_RETRY_FAILURE_COUNT, {
-        description: 'Counts occurrences of all content retries failing.',
-        valueType: ValueType.INT,
+    Object.entries(COUNTER_DEFINITIONS).forEach(([name, { description, valueType, assign }]) => {
+        assign(meter.createCounter(name, { description, valueType }));
     });
-    modelRoutingLatencyHistogram = meter.createHistogram(METRIC_MODEL_ROUTING_LATENCY, {
-        description: 'Latency of model routing decisions in milliseconds.',
-        unit: 'ms',
-        valueType: ValueType.INT,
+    Object.entries(HISTOGRAM_DEFINITIONS).forEach(([name, { description, unit, valueType, assign }]) => {
+        assign(meter.createHistogram(name, { description, unit, valueType }));
     });
-    modelRoutingFailureCounter = meter.createCounter(METRIC_MODEL_ROUTING_FAILURE_COUNT, {
-        description: 'Counts model routing failures.',
-        valueType: ValueType.INT,
-    });
-    modelSlashCommandCallCounter = meter.createCounter(METRIC_MODEL_SLASH_COMMAND_CALL_COUNT, {
-        description: 'Counts model slash command calls.',
-        valueType: ValueType.INT,
-    });
-    const sessionCounter = meter.createCounter(METRIC_SESSION_COUNT, {
-        description: 'Count of CLI sessions started.',
-        valueType: ValueType.INT,
-    });
-    sessionCounter.add(1, getCommonAttributes(config));
+    // Increment session counter after all metrics are initialized
+    sessionCounter?.add(1, baseMetricDefinition.getCommonAttributes(config));
     // Initialize performance monitoring metrics if enabled
     initializePerformanceMonitoring(config);
     isMetricsInitialized = true;
 }
-export function recordChatCompressionMetrics(config, args) {
+export function recordChatCompressionMetrics(config, attributes) {
     if (!chatCompressionCounter || !isMetricsInitialized)
         return;
     chatCompressionCounter.add(1, {
-        ...getCommonAttributes(config),
-        ...args,
+        ...baseMetricDefinition.getCommonAttributes(config),
+        ...attributes,
     });
 }
-export function recordToolCallMetrics(config, functionName, durationMs, success, decision, tool_type) {
+export function recordToolCallMetrics(config, durationMs, attributes) {
     if (!toolCallCounter || !toolCallLatencyHistogram || !isMetricsInitialized)
         return;
     const metricAttributes = {
-        ...getCommonAttributes(config),
-        function_name: functionName,
-        success,
-        decision,
-        tool_type,
+        ...baseMetricDefinition.getCommonAttributes(config),
+        ...attributes,
     };
     toolCallCounter.add(1, metricAttributes);
     toolCallLatencyHistogram.record(durationMs, {
-        ...getCommonAttributes(config),
-        function_name: functionName,
+        ...baseMetricDefinition.getCommonAttributes(config),
+        function_name: attributes.function_name,
     });
 }
-export function recordTokenUsageMetrics(config, model, tokenCount, type) {
+export function recordCustomTokenUsageMetrics(config, tokenCount, attributes) {
     if (!tokenUsageCounter || !isMetricsInitialized)
         return;
     tokenUsageCounter.add(tokenCount, {
-        ...getCommonAttributes(config),
-        model,
-        type,
+        ...baseMetricDefinition.getCommonAttributes(config),
+        ...attributes,
     });
 }
-export function recordApiResponseMetrics(config, model, durationMs, statusCode) {
+export function recordCustomApiResponseMetrics(config, durationMs, attributes) {
     if (!apiRequestCounter ||
         !apiRequestLatencyHistogram ||
         !isMetricsInitialized)
         return;
     const metricAttributes = {
-        ...getCommonAttributes(config),
-        model,
-        status_code: statusCode ?? 'ok',
+        ...baseMetricDefinition.getCommonAttributes(config),
+        model: attributes.model,
+        status_code: attributes.status_code ?? 'ok',
     };
     apiRequestCounter.add(1, metricAttributes);
     apiRequestLatencyHistogram.record(durationMs, {
-        ...getCommonAttributes(config),
-        model,
+        ...baseMetricDefinition.getCommonAttributes(config),
+        model: attributes.model,
     });
 }
-export function recordApiErrorMetrics(config, model, durationMs, statusCode, errorType) {
+export function recordApiErrorMetrics(config, durationMs, attributes) {
     if (!apiRequestCounter ||
         !apiRequestLatencyHistogram ||
         !isMetricsInitialized)
         return;
     const metricAttributes = {
-        ...getCommonAttributes(config),
-        model,
-        status_code: statusCode ?? 'error',
-        error_type: errorType ?? 'unknown',
+        ...baseMetricDefinition.getCommonAttributes(config),
+        model: attributes.model,
+        status_code: attributes.status_code ?? 'error',
+        error_type: attributes.error_type ?? 'unknown',
     };
     apiRequestCounter.add(1, metricAttributes);
     apiRequestLatencyHistogram.record(durationMs, {
-        ...getCommonAttributes(config),
-        model,
+        ...baseMetricDefinition.getCommonAttributes(config),
+        model: attributes.model,
     });
 }
-export function recordFileOperationMetric(config, operation, lines, mimetype, extension, programming_language) {
+export function recordFileOperationMetric(config, attributes) {
     if (!fileOperationCounter || !isMetricsInitialized)
         return;
-    const attributes = {
-        ...getCommonAttributes(config),
-        operation,
-    };
-    if (lines !== undefined)
-        attributes['lines'] = lines;
-    if (mimetype !== undefined)
-        attributes['mimetype'] = mimetype;
-    if (extension !== undefined)
-        attributes['extension'] = extension;
-    if (programming_language !== undefined) {
-        attributes['programming_language'] = programming_language;
-    }
-    fileOperationCounter.add(1, attributes);
+    fileOperationCounter.add(1, {
+        ...baseMetricDefinition.getCommonAttributes(config),
+        ...attributes,
+    });
 }
 // --- New Metric Recording Functions ---
 /**
@@ -245,7 +408,7 @@ export function recordFileOperationMetric(config, operation, lines, mimetype, ex
 export function recordInvalidChunk(config) {
     if (!invalidChunkCounter || !isMetricsInitialized)
         return;
-    invalidChunkCounter.add(1, getCommonAttributes(config));
+    invalidChunkCounter.add(1, baseMetricDefinition.getCommonAttributes(config));
 }
 /**
  * Records a metric for when a retry is triggered due to a content error.
@@ -253,7 +416,7 @@ export function recordInvalidChunk(config) {
 export function recordContentRetry(config) {
     if (!contentRetryCounter || !isMetricsInitialized)
         return;
-    contentRetryCounter.add(1, getCommonAttributes(config));
+    contentRetryCounter.add(1, baseMetricDefinition.getCommonAttributes(config));
 }
 /**
  * Records a metric for when all content error retries have failed for a request.
@@ -261,13 +424,13 @@ export function recordContentRetry(config) {
 export function recordContentRetryFailure(config) {
     if (!contentRetryFailureCounter || !isMetricsInitialized)
         return;
-    contentRetryFailureCounter.add(1, getCommonAttributes(config));
+    contentRetryFailureCounter.add(1, baseMetricDefinition.getCommonAttributes(config));
 }
 export function recordModelSlashCommand(config, event) {
     if (!modelSlashCommandCallCounter || !isMetricsInitialized)
         return;
     modelSlashCommandCallCounter.add(1, {
-        ...getCommonAttributes(config),
+        ...baseMetricDefinition.getCommonAttributes(config),
         'slash_command.model.model_name': event.model_name,
     });
 }
@@ -277,18 +440,64 @@ export function recordModelRoutingMetrics(config, event) {
         !isMetricsInitialized)
         return;
     modelRoutingLatencyHistogram.record(event.routing_latency_ms, {
-        ...getCommonAttributes(config),
+        ...baseMetricDefinition.getCommonAttributes(config),
         'routing.decision_model': event.decision_model,
         'routing.decision_source': event.decision_source,
     });
     if (event.failed) {
         modelRoutingFailureCounter.add(1, {
-            ...getCommonAttributes(config),
+            ...baseMetricDefinition.getCommonAttributes(config),
             'routing.decision_source': event.decision_source,
             'routing.error_message': event.error_message,
         });
     }
 }
+// OpenTelemetry GenAI Semantic Convention Recording Functions
+export function recordGenAiClientTokenUsage(config, tokenCount, attributes) {
+    if (!genAiClientTokenUsageHistogram || !isMetricsInitialized)
+        return;
+    const metricAttributes = {
+        ...baseMetricDefinition.getCommonAttributes(config),
+        ...attributes,
+    };
+    genAiClientTokenUsageHistogram.record(tokenCount, metricAttributes);
+}
+export function recordGenAiClientOperationDuration(config, durationSeconds, attributes) {
+    if (!genAiClientOperationDurationHistogram || !isMetricsInitialized)
+        return;
+    const metricAttributes = {
+        ...baseMetricDefinition.getCommonAttributes(config),
+        ...attributes,
+    };
+    genAiClientOperationDurationHistogram.record(durationSeconds, metricAttributes);
+}
+export function getConventionAttributes(event) {
+    const operationName = getGenAiOperationName();
+    const provider = getGenAiProvider(event.auth_type);
+    return {
+        'gen_ai.operation.name': operationName,
+        'gen_ai.provider.name': provider,
+        'gen_ai.request.model': event.model,
+        'gen_ai.response.model': event.model,
+    };
+}
+/**
+ * Maps authentication type to GenAI provider name following OpenTelemetry conventions
+ */
+function getGenAiProvider(authType) {
+    switch (authType) {
+        case AuthType.USE_VERTEX_AI:
+        case AuthType.CLOUD_SHELL:
+        case AuthType.LOGIN_WITH_GOOGLE:
+            return GenAiProviderName.GCP_VERTEX_AI;
+        case AuthType.USE_GEMINI:
+        default:
+            return GenAiProviderName.GCP_GEN_AI;
+    }
+}
+function getGenAiOperationName() {
+    return GenAiOperationName.GENERATE_CONTENT;
+}
 // Performance Monitoring Functions
 export function initializePerformanceMonitoring(config) {
     const meter = getMeter();
@@ -300,178 +509,149 @@ export function initializePerformanceMonitoring(config) {
     isPerformanceMonitoringEnabled = config.getTelemetryEnabled();
     if (!isPerformanceMonitoringEnabled)
         return;
-    // Initialize startup time histogram
-    startupTimeHistogram = meter.createHistogram(METRIC_STARTUP_TIME, {
-        description: 'CLI startup time in milliseconds, broken down by initialization phase.',
-        unit: 'ms',
-        valueType: ValueType.DOUBLE,
+    Object.entries(PERFORMANCE_COUNTER_DEFINITIONS).forEach(([name, { description, valueType, assign }]) => {
+        assign(meter.createCounter(name, { description, valueType }));
     });
-    // Initialize memory usage histogram (using histogram until ObservableGauge is available)
-    memoryUsageGauge = meter.createHistogram(METRIC_MEMORY_USAGE, {
-        description: 'Memory usage in bytes.',
-        unit: 'bytes',
-        valueType: ValueType.INT,
-    });
-    // Initialize CPU usage histogram
-    cpuUsageGauge = meter.createHistogram(METRIC_CPU_USAGE, {
-        description: 'CPU usage percentage.',
-        unit: 'percent',
-        valueType: ValueType.DOUBLE,
-    });
-    // Initialize tool queue depth histogram
-    toolQueueDepthGauge = meter.createHistogram(METRIC_TOOL_QUEUE_DEPTH, {
-        description: 'Number of tools in execution queue.',
-        valueType: ValueType.INT,
-    });
-    // Initialize performance breakdowns
-    toolExecutionBreakdownHistogram = meter.createHistogram(METRIC_TOOL_EXECUTION_BREAKDOWN, {
-        description: 'Tool execution time breakdown by phase in milliseconds.',
-        unit: 'ms',
-        valueType: ValueType.INT,
-    });
-    tokenEfficiencyHistogram = meter.createHistogram(METRIC_TOKEN_EFFICIENCY, {
-        description: 'Token efficiency metrics (tokens per operation, cache hit rate, etc.).',
-        valueType: ValueType.DOUBLE,
-    });
-    apiRequestBreakdownHistogram = meter.createHistogram(METRIC_API_REQUEST_BREAKDOWN, {
-        description: 'API request time breakdown by phase in milliseconds.',
-        unit: 'ms',
-        valueType: ValueType.INT,
-    });
-    // Initialize performance score and regression detection
-    performanceScoreGauge = meter.createHistogram(METRIC_PERFORMANCE_SCORE, {
-        description: 'Composite performance score (0-100).',
-        unit: 'score',
-        valueType: ValueType.DOUBLE,
-    });
-    regressionDetectionCounter = meter.createCounter(METRIC_REGRESSION_DETECTION, {
-        description: 'Performance regression detection events.',
-        valueType: ValueType.INT,
-    });
-    regressionPercentageChangeHistogram = meter.createHistogram(METRIC_REGRESSION_PERCENTAGE_CHANGE, {
-        description: 'Percentage change compared to baseline for detected regressions.',
-        unit: 'percent',
-        valueType: ValueType.DOUBLE,
-    });
-    baselineComparisonHistogram = meter.createHistogram(METRIC_BASELINE_COMPARISON, {
-        description: 'Performance comparison to established baseline (percentage change).',
-        unit: 'percent',
-        valueType: ValueType.DOUBLE,
+    Object.entries(PERFORMANCE_HISTOGRAM_DEFINITIONS).forEach(([name, { description, unit, valueType, assign }]) => {
+        assign(meter.createHistogram(name, { description, unit, valueType }));
     });
 }
-export function recordStartupPerformance(config, phase, durationMs, details) {
+export function recordStartupPerformance(config, durationMs, attributes) {
     if (!startupTimeHistogram || !isPerformanceMonitoringEnabled)
         return;
-    const attributes = {
-        ...getCommonAttributes(config),
-        phase,
-        ...details,
+    const metricAttributes = {
+        ...baseMetricDefinition.getCommonAttributes(config),
+        phase: attributes.phase,
+        ...attributes.details,
     };
-    startupTimeHistogram.record(durationMs, attributes);
+    startupTimeHistogram.record(durationMs, metricAttributes);
 }
-export function recordMemoryUsage(config, memoryType, bytes, component) {
+export function recordMemoryUsage(config, bytes, attributes) {
     if (!memoryUsageGauge || !isPerformanceMonitoringEnabled)
         return;
-    const attributes = {
-        ...getCommonAttributes(config),
-        memory_type: memoryType,
-        component,
+    const metricAttributes = {
+        ...baseMetricDefinition.getCommonAttributes(config),
+        ...attributes,
     };
-    memoryUsageGauge.record(bytes, attributes);
+    memoryUsageGauge.record(bytes, metricAttributes);
 }
-export function recordCpuUsage(config, percentage, component) {
+export function recordCpuUsage(config, percentage, attributes) {
     if (!cpuUsageGauge || !isPerformanceMonitoringEnabled)
         return;
-    const attributes = {
-        ...getCommonAttributes(config),
-        component,
+    const metricAttributes = {
+        ...baseMetricDefinition.getCommonAttributes(config),
+        ...attributes,
     };
-    cpuUsageGauge.record(percentage, attributes);
+    cpuUsageGauge.record(percentage, metricAttributes);
 }
 export function recordToolQueueDepth(config, queueDepth) {
     if (!toolQueueDepthGauge || !isPerformanceMonitoringEnabled)
         return;
     const attributes = {
-        ...getCommonAttributes(config),
+        ...baseMetricDefinition.getCommonAttributes(config),
     };
     toolQueueDepthGauge.record(queueDepth, attributes);
 }
-export function recordToolExecutionBreakdown(config, functionName, phase, durationMs) {
+export function recordToolExecutionBreakdown(config, durationMs, attributes) {
     if (!toolExecutionBreakdownHistogram || !isPerformanceMonitoringEnabled)
         return;
-    const attributes = {
-        ...getCommonAttributes(config),
-        function_name: functionName,
-        phase,
+    const metricAttributes = {
+        ...baseMetricDefinition.getCommonAttributes(config),
+        ...attributes,
     };
-    toolExecutionBreakdownHistogram.record(durationMs, attributes);
+    toolExecutionBreakdownHistogram.record(durationMs, metricAttributes);
 }
-export function recordTokenEfficiency(config, model, metric, value, context) {
+export function recordTokenEfficiency(config, value, attributes) {
     if (!tokenEfficiencyHistogram || !isPerformanceMonitoringEnabled)
         return;
-    const attributes = {
-        ...getCommonAttributes(config),
-        model,
-        metric,
-        context,
+    const metricAttributes = {
+        ...baseMetricDefinition.getCommonAttributes(config),
+        ...attributes,
     };
-    tokenEfficiencyHistogram.record(value, attributes);
+    tokenEfficiencyHistogram.record(value, metricAttributes);
 }
-export function recordApiRequestBreakdown(config, model, phase, durationMs) {
+export function recordApiRequestBreakdown(config, durationMs, attributes) {
     if (!apiRequestBreakdownHistogram || !isPerformanceMonitoringEnabled)
         return;
-    const attributes = {
-        ...getCommonAttributes(config),
-        model,
-        phase,
+    const metricAttributes = {
+        ...baseMetricDefinition.getCommonAttributes(config),
+        ...attributes,
     };
-    apiRequestBreakdownHistogram.record(durationMs, attributes);
+    apiRequestBreakdownHistogram.record(durationMs, metricAttributes);
 }
-export function recordPerformanceScore(config, score, category, baseline) {
+export function recordPerformanceScore(config, score, attributes) {
     if (!performanceScoreGauge || !isPerformanceMonitoringEnabled)
         return;
-    const attributes = {
-        ...getCommonAttributes(config),
-        category,
-        baseline,
+    const metricAttributes = {
+        ...baseMetricDefinition.getCommonAttributes(config),
+        ...attributes,
     };
-    performanceScoreGauge.record(score, attributes);
+    performanceScoreGauge.record(score, metricAttributes);
 }
-export function recordPerformanceRegression(config, metric, currentValue, baselineValue, severity) {
+export function recordPerformanceRegression(config, attributes) {
     if (!regressionDetectionCounter || !isPerformanceMonitoringEnabled)
         return;
-    const attributes = {
-        ...getCommonAttributes(config),
-        metric,
-        severity,
-        current_value: currentValue,
-        baseline_value: baselineValue,
+    const metricAttributes = {
+        ...baseMetricDefinition.getCommonAttributes(config),
+        ...attributes,
     };
-    regressionDetectionCounter.add(1, attributes);
-    if (baselineValue !== 0 && regressionPercentageChangeHistogram) {
-        const percentageChange = ((currentValue - baselineValue) / baselineValue) * 100;
-        regressionPercentageChangeHistogram.record(percentageChange, attributes);
+    regressionDetectionCounter.add(1, metricAttributes);
+    if (attributes.baseline_value !== 0 && regressionPercentageChangeHistogram) {
+        const percentageChange = ((attributes.current_value - attributes.baseline_value) /
+            attributes.baseline_value) *
+            100;
+        regressionPercentageChangeHistogram.record(percentageChange, metricAttributes);
     }
 }
-export function recordBaselineComparison(config, metric, currentValue, baselineValue, category) {
+export function recordBaselineComparison(config, attributes) {
     if (!baselineComparisonHistogram || !isPerformanceMonitoringEnabled)
         return;
-    if (baselineValue === 0) {
+    if (attributes.baseline_value === 0) {
         diag.warn('Baseline value is zero, skipping comparison.');
         return;
     }
-    const percentageChange = ((currentValue - baselineValue) / baselineValue) * 100;
-    const attributes = {
-        ...getCommonAttributes(config),
-        metric,
-        category,
-        current_value: currentValue,
-        baseline_value: baselineValue,
+    const percentageChange = ((attributes.current_value - attributes.baseline_value) /
+        attributes.baseline_value) *
+        100;
+    const metricAttributes = {
+        ...baseMetricDefinition.getCommonAttributes(config),
+        ...attributes,
     };
-    baselineComparisonHistogram.record(percentageChange, attributes);
+    baselineComparisonHistogram.record(percentageChange, metricAttributes);
 }
 // Utility function to check if performance monitoring is enabled
 export function isPerformanceMonitoringActive() {
     return isPerformanceMonitoringEnabled && isMetricsInitialized;
 }
+/**
+ * Token usage recording that emits both custom and convention metrics.
+ */
+export function recordTokenUsageMetrics(config, tokenCount, attributes) {
+    recordCustomTokenUsageMetrics(config, tokenCount, {
+        model: attributes.model,
+        type: attributes.type,
+    });
+    if ((attributes.type === 'input' || attributes.type === 'output') &&
+        attributes.genAiAttributes) {
+        recordGenAiClientTokenUsage(config, tokenCount, {
+            ...attributes.genAiAttributes,
+            'gen_ai.token.type': attributes.type,
+        });
+    }
+}
+/**
+ * Operation latency recording that emits both custom and convention metrics.
+ */
+export function recordApiResponseMetrics(config, durationMs, attributes) {
+    recordCustomApiResponseMetrics(config, durationMs, {
+        model: attributes.model,
+        status_code: attributes.status_code,
+    });
+    if (attributes.genAiAttributes) {
+        const durationSeconds = durationMs / 1000;
+        recordGenAiClientOperationDuration(config, durationSeconds, {
+            ...attributes.genAiAttributes,
+        });
+    }
+}
 //# sourceMappingURL=metrics.js.map