La collecte de l'activité Gemini Code Assist dans Cloud Logging vous permet d'auditer les prompts des développeurs, les réponses du modèle et les journaux de métadonnées, tels que les données de télémétrie et les lignes de code acceptées. Vous pouvez interroger ces entrées de journal pour évaluer les interactions avec l'assistant dans votre organisation. Pour suivre les tendances agrégées plutôt que les journaux bruts, consultez Surveiller l'utilisation de Gemini Code Assist.
Gemini Code Assist ne collecte ni n'envoie à Cloud Logging aucune autre interaction utilisateur avec Gemini Code Assist, pas même les commentaires écrits. Les données collectées sont envoyées à Cloud Logging pour stockage. Vous pouvez parcourir ces données en recherchant les entrées de journal avec le type de ressource cloudaicompanion.googleapis.com/Instance.
Cette fonctionnalité ne consigne pas les prompts ni les réponses dans Gemini dans Vertex AI. Pour activer les journaux pour Gemini dans Vertex AI, consultez Activer les journaux d'audit des accès aux données.
Les rôles IAM (Identity and Access Management) contrôlent la capacité d'un compte principal à accéder aux journaux. Vous pouvez attribuer des rôles prédéfinis aux comptes principaux ou créer des rôles personnalisés. Pour en savoir plus sur les autorisations requises, consultez Contrôle des accès.
Par défaut, Cloud Logging chiffre le contenu client stocké au repos. Les données stockées dans des buckets de journaux par Logging sont chiffrées à l'aide de clés de chiffrement de clé, un processus appelé chiffrement encapsulé. L'accès à vos données de journalisation nécessite l'accès à ces clés de chiffrement de clé, qui sont gérées par Google sans qu'aucune action de votre part ne soit requise.
Votre organisation peut avoir des exigences de chiffrement réglementaires, de conformité ou avancées que notre chiffrement au repos par défaut ne fournit pas. Afin de respecter les exigences de votre organisation, au lieu de laisser Google gérer les clés de chiffrement qui protègent vos données, vous pouvez configurer vos propres clés.
Pour en savoir plus sur l'utilisation des clés de chiffrement gérées par le client (CMEK), y compris leurs avantages et leurs limites, consultez Clés de chiffrement gérées par le client.
Limites
L'enregistrement des données de journaux Gemini Code Assist est limité aux interactions des utilisateurs avec Gemini Code Assist dans un IDE.
Par défaut, les journaux Gemini Code Assist sont collectés par projet. Pour savoir comment configurer un projet centralisé afin de collecter les journaux de plusieurs projets, consultez Configurer la journalisation multiprojet.
Les journaux Gemini Code Assist enregistrent un nombre de jetons combiné (
totalTokenCount) pour chaque requête de chat et d'agent (CompleteTask), que vous pouvez attribuer à un utilisateur avec l'étiquettelabels.user_id. Ce nombre apparaît dans les champsRequestLog.metadata.totalTokenCount,ResponseLog.metadata.totalTokenCountetMetadataLog.apiRequest.totalTokenCount. Les journaux des requêtes de complétion et de génération de code (CompleteCodeetGenerateCode) et les journaux de métadonnées qui enregistrent les événements de télémétrie, tels que les événementscodeExposure,codeAcceptance,chatExposureetchatAcceptance, n'incluent pas le nombre de jetons. Les journaux et les métriques Cloud Monitoring n'enregistrent pas séparément le nombre de jetons de requête et de réponse. Pour afficher l'utilisation agrégée des jetons pour votre projet, consultez Métriques de jetons et de quotas.
Avant de commencer
-
Pour obtenir les autorisations nécessaires pour afficher les journaux Gemini Code Assist, demandez à votre administrateur de vous accorder le rôle IAM Lecteur de journaux (
roles/logging.viewer) sur votre projet. Pour en savoir plus sur l'attribution de rôles, consultez Gérer l'accès aux projets, aux dossiers et aux organisations.Vous pouvez également obtenir les autorisations requises avec des rôles personnalisés ou d'autres rôles prédéfinis.
Consultez les tarifs de Cloud Logging et les tarifs de Gemini Code Assist.
Afficher les journaux utilisateur et de métadonnées Gemini Code Assist
Pour afficher les journaux utilisateur et de métadonnées de Gemini Code Assist, procédez de l'une des façons suivantes :
Console
-
Dans la console Google Cloud , accédez à la pageExplorateur de journaux :
Accéder à l'explorateur de journaux
Si vous utilisez la barre de recherche pour trouver cette page, sélectionnez le résultat dont le sous-titre est Logging.
- Dans la barre d'outils, sélectionnez un projet de la console Google Cloud .
- Dans la barre d'outils, développez le menu Toutes les ressources et sélectionnez la ressource Instance Cloud AI Companion.
gcloud
Exécutez la commande suivante :
gcloud logging read "resource.type=cloudaicompanion.googleapis.com/Instance" --project PROJECT_ID --limit 3
Remplacez PROJECT_ID par l'ID du projet dont vous souhaitez afficher les journaux Gemini Code Assist.
API
Créez un fichier JSON contenant les informations suivantes :
{ "resourceNames": [ "projects/PROJECT_ID" ], "pageSize": 5, "filter": "resource.type: cloudaicompanion.googleapis.com/Instance" }Remplacez
PROJECT_IDpar l'ID du projet dont vous souhaitez afficher les journaux Gemini Code Assist.Obtenez un jeton d'authentification :
TOKEN=$(gcloud auth print-access-token)Utilisez
cURLpour appeler la méthodeentries.list:curl -X POST --data-binary @JSON_FILE_NAME \ -H "Authorization: Bearer $TOKEN" \ -H "Content-Type: application/json" \ "https://logging.googleapis.com/v2/entries:list"
Remplacez
JSON_FILE_NAMEpar le chemin d'accès au fichier JSON que vous avez créé à l'étape précédente.Pour en savoir plus sur l'authentification, consultez S'authentifier pour utiliser REST.
La réponse renvoyée est un ensemble d'entrées de journal.
Journaux Gemini Code Assist
Un LogEntry est l'unité de base des données dans Cloud Logging. Les sections suivantes fournissent des listes de champs trouvés dans le LogEntry pour un événement de plate-forme Gemini Code Assist, tel que les requêtes utilisateur et les réponses Gemini Code Assist.
Requêtes utilisateur
Le tableau suivant présente la liste des champs figurant dans une entrée de journal de requête utilisateur :
| Champ | Valeurs et notes |
|---|---|
LogEntry.resource.type |
Type de ressource Gemini Code Assist : cloudaicompanion.googleapis.com/Instance. |
LogEntry.resource.labels.resource_container |
Identifiant unique du conteneur de ressources dans lequel Gemini Code Assist a été utilisé. |
LogEntry.resource.labels.location |
Emplacement où Gemini Code Assist a été utilisé. |
LogEntry.resource.labels.instance_id |
Identifiant unique de la ressource dans laquelle Gemini Code Assist a été utilisé. |
LogEntry.labels.method |
Il peut s'agir de l'une des valeurs suivantes, selon ce qui a appelé logEntry :CompleteTask : par exemple, une requête de chat de Gemini Code Assist.GenerateCode : par exemple, une requête de génération de code, comme une requête de transformation de code dans Gemini Code Assist.CompleteCode : par exemple, une requête de complétion de code lorsque vous travaillez dans l'IDE, comme avec les suggestions intégrées dans Gemini Code Assist. |
LogEntry.labels.product |
Nom du service auquel le journal s'applique. Les journaux pertinents pour Gemini Code Assist utilisent la valeur de produit code_assist. Si le journal est pertinent pour Gemini Cloud Assist, cette valeur est cloud_assist. Sinon, cette valeur est unknown. |
LogEntry.labels.request_id |
Identifiant unique permettant de mettre en corrélation une requête avec une entrée de journal de réponse. |
LogEntry.labels.user_id |
Identifiant de l'utilisateur qui a lancé cette requête. |
LogEntry.jsonPayload |
Charge utile de l'entrée de journal. |
LogEntry.logName |
Identifie le journal. |
L'exemple suivant montre une entrée de journal pour un événement de prompt de chat :
{
"insertId": "654581e30003b19e340bbd96",
"resource": {
"type": "cloudaicompanion.googleapis.com/Instance",
"labels": {
instance_id: "default"
location: "global"
resource_container: "my-project-id"
}
},
"timestamp": "2023-11-03T23:27:31.242078Z",
"labels": {
"product": "code_assist",
"request_id": "4ea1e265-ea5d-4d11-b3c8-39bad9c96326"
"user_id": "user@company.com"
},
"jsonPayload" : {
@type: "type.googleapis.com/google.cloud.cloudaicompanion.logging.v1.RequestLog"
"taskCompletionRequest":
input: {
messages: [{
author: "USER"
content: "What are some best practices to save cost on my Google Cloud bill?"
}]
preamble: ""
}
}
"logName": "projects/my-project-id/logs/cloudaicompanion.googleapis.com%2Frequest",
"receiveTimestamp": "2023-11-03T23:27:31.255648319Z"
"severity": "INFO"
}
L'exemple suivant montre une entrée RequestLog pour les prompts de suggestion de code intégré automatiques et pour un prompt Gemini Code Assist dans un fichier de code.
Les données de prompt pour les suggestions de code intégré utilisent l'objet codeCompletionRequest (comme indiqué dans l'exemple suivant), tandis que la génération déclenchée manuellement utilise codeGenerationRequest.
{
"insertId": "654581e30003b19e340bbd96",
"resource": {
"type": "cloudaicompanion.googleapis.com/Instance",
"labels": {
instance_id: "default"
location: "global"
resource_container: "my-project-id"
}
},
"timestamp": "2023-11-03T23:27:31.242078Z",
"labels": {
"product": "code_assist",
"request_id": "4ea1e265-ea5d-4d11-b3c8-39bad9c96326"
"user_id": "user@company.com"
},
"jsonPayload" : {
@type: "type.googleapis.com/google.cloud.cloudaicompanion.logging.v1.RequestLog"
"codeCompletionRequest": {
"input_data_context": {
"additional_context": {
"files": [
{
"language": "go",
"path": "{/path/to/../current-file.go",
"segments": [
{
"content": "...Prefix Text..."
},
{
"content": "...Suffix Text..."
}
],
"state": ["EDITED"]
},
{
"language": "go",
"path": "/path/to/../recent-file.go",
"segments": [
{
"content": "...File Text..."
}
],
"state": ["RECENTLY_OPENED"]
}
]
}
}
}
}
"logName": "projects/my-project-id/logs/cloudaicompanion.googleapis.com%2Frequest",
"receiveTimestamp": "2023-11-03T23:27:31.255648319Z"
"severity": "INFO"
}
Journaux d'interactions de l'agent
Certaines interactions avec Gemini peuvent générer plusieurs entrées de journal (requête, réponse et métadonnées) pour une même action utilisateur. Voici quelques exemples de telles interactions :
- Un agent effectuant une tâche qui implique l'utilisation d'un outil (par exemple, le modèle appelant des fonctions internes telles que
read_fileoureplace, comme illustré dans les exemples de journaux). - Un agent interagissant avec d'autres agents.
Entrée de journal de requête
L'exemple suivant montre une entrée de journal pour une requête qui lance une interaction avec l'agent :
{
"insertId": "qe9xxub2r",
"jsonPayload": {
"taskCompletionRequest": {
"input": {
"messages": [
{
"author": "USER",
"content": "hi can you add one test here\nCurrent File Path:\n```cpp\n/usr/local/google/home/pdec/test.cpp\n```\n\n"
}
],
"preamble": ""
}
},
"@type": "type.googleapis.com/google.cloud.cloudaicompanion.logging.v1.RequestLog"
},
"resource": {
"type": "cloudaicompanion.googleapis.com/Instance",
"labels": {
"resource_container": "my-project-id",
"instance_id": "default",
"location": "global"
}
},
"timestamp": "2025-10-08T10:09:52.225165428Z",
"severity": "INFO",
"labels": {
"request_id": "e60facb1485b17b7",
"client_version": "unknown",
"product": "code_assist",
"method": "CompleteTask",
"user_id": "user@company.com",
"client_name": "cloudcode_cli"
},
"logName": "projects/my-project-id/logs/cloudaicompanion.googleapis.com%2Frequest",
"receiveTimestamp": "2025-10-08T10:09:52.581787548Z"
}
Entrée de journal de réponse
L'exemple suivant montre un exemple d'entrée de journal de réponse d'une interaction d'agent incluant plusieurs messages :
{
"insertId": "qe9xxub2t",
"jsonPayload": {
"@type": "type.googleapis.com/google.cloud.cloudaicompanion.logging.v1.ResponseLog",
"taskCompletionResponse": {
"output": {
"messages": [
{
"content": "**Reading File Contents**\n\nI'm currently focused on reading the contents of `/usr/local/google/home/pdec/test.cpp`. This will inform what kind of test needs to be written and how it should be structured.\n\n\n",
"author": "MODEL"
},
{
"author": "MODEL",
"content": "**File Inspection Begins**\n\nI've initiated the process of reading the test file. My immediate goal is to grasp its existing structure and identify the testing framework, if one exists. This will directly influence the design of the new test case I'll be adding.\n\n\n"
},
{
"author": "MODEL",
"content": "Of course. What is the test about? I'll read the file to understand the context."
},
{
"content": "read_file({\"absolute_path\":\"/usr/local/google/home/pdec/test.cpp\"})",
"author": "MODEL"
}
]
}
}
},
"resource": {
"type": "cloudaicompanion.googleapis.com/Instance",
"labels": {
"resource_container": "my-project-id",
"instance_id": "default",
"location": "global"
}
},
"timestamp": "2025-10-08T10:09:52.227354297Z",
"severity": "INFO",
"labels": {
"product": "code_assist",
"request_id": "e60facb1485b17b7",
"user_id": "user@company.com",
"client_version": "unknown",
"method": "CompleteTask",
"client_name": "cloudcode_cli"
},
"logName": "projects/my-project-id/logs/cloudaicompanion.googleapis.com%2Fresponse",
"receiveTimestamp": "2025-10-08T10:09:52.581787548Z"
}
Entrée de journal de métadonnées
L'exemple suivant montre une entrée de journal de métadonnées d'une interaction avec un agent :
{
"insertId": "qe9xxub2s",
"jsonPayload": {
"apiRequest": {},
"clientName": "cloudcode_cli",
"requestId": "e60facb1485b17b7",
"@type": "type.googleapis.com/google.cloud.cloudaicompanion.logging.v1.MetadataLog",
"clientVersion": "unknown"
},
"resource": {
"type": "cloudaicompanion.googleapis.com/Instance",
"labels": {
"location": "global",
"instance_id": "default",
"resource_container": "my-project-id"
}
},
"timestamp": "2025-10-08T10:09:52.226420727Z",
"severity": "INFO",
"labels": {
"method": "CompleteTask",
"product": "code_assist",
"user_id": "user@company.com"
},
"logName": "projects/my-project-id/logs/cloudaicompanion.googleapis.com%2Fmetadata",
"receiveTimestamp": "2025-10-08T10:09:52.581787548Z"
}
Les exemples suivants montrent un autre exemple d'entrées de journal pour une interaction d'agent, avec l'ID de requête 4b66a582bad9cf2c :
Entrée de journal de requête
{
"insertId": "4qvt8nb2k",
"jsonPayload": {
"taskCompletionRequest": {
"input": {
"messages": [
{
"author": "USER",
"content": "FunctionResponse{name: read_file, response: {\"output\":\"#include <iostream>\\n\\n// Function to calculate the greatest common divisor (GCD) of two numbers.\\nint gcd(int a, int b) {\\n if (b == 0) {\\n return a;\\n }\\n return gcd(b, a % b);\\n}\\n\\n// Function to calculate the least common multiple (LCM) of two numbers.\\nint lcm(int a, int b) {\\n return (a * b) / gcd(a, b);\\n}\\n\\n// Function to check if a number is prime.\\nint is_prime(int a) {\\n if (a < 2) {\\n return 0;\\n }\\n for (int i = 2; i * i <= a; ++i) {\\n if (a % i == 0) {\\n return 0;\\n }\\n }\\n return 1;\\n}\\n\\n// Function for extended Euclidean algorithm.\\nint extended_gcd(int a, int b, int &x, int &y) {\\n if (b == 0) {\\n x = 1;\\n y = 0;\\n return a;\\n }\\n int x1, y1;\\n int d = extended_gcd(b, a % b, x1, y1);\\n x = y1;\\n y = x1 - (a / b) * y1;\\n return d;\\n}\\n\\n// Test function\\nvoid run_tests() {\\n // Test gcd\\n if (gcd(10, 15) == 5) {\\n std::cout << \\\"gcd(10, 15) passed\\\" << std::endl;\\n } else {\\n std::cout << \\\"gcd(10, 15) failed\\\" << std::endl;\\n }\\n\\n // Test lcm\\n if (lcm(10, 15) == 30) {\\n std::cout << \\\"lcm(10, 15) passed\\\" << std::endl;\\n } else {\\n std::cout << \\\"lcm(10, 15) failed\\\" << std::endl;\\n }\\n\\n // Test is_prime\\n if (is_prime(7) == 1) {\\n std::cout << \\\"is_prime(7) passed\\\" << std::endl;\\n } else {\\n std::cout << \\\"is_prime(7) failed\\\" << std::endl;\\n }\\n if (is_prime(10) == 0) {\\n std::cout << \\\"is_prime(10) passed\\\" << std::endl;\\n } else {\\n std::cout << \\\"is_prime(10) failed\\\" << std::endl;\\n }\\n\\n // Test extended_gcd\\n int x, y;\\n int g = extended_gcd(35, 15, x, y);\\n if (g == 5 && 35 * x + 15 * y == g) {\\n std::cout << \\\"extended_gcd(35, 15) passed\\\" << std::endl;\\n } else {\\n std::cout << \\\"extended_gcd(35, 15) failed\\\" << std::endl;\\n }\\n\\n // Test is_prime with 1\\n if (is_prime(1) == 0) {\\n std::cout << \\\"is_prime(1) passed\\\" << std::endl;\\n } else {\\n std::cout << \\\"is_prime(1) failed\\\" << std::endl;\\n }\\n\\n // Test is_prime with 9\\n if (is_prime(9) == 0) {\\n std::cout << \\\"is_prime(9) passed\\\" << std::endl;\\n } else {\\n std::cout << \\\"is_prime(9) failed\\\" << std::endl;\\n }\\n\\n // Test is_prime with 13\\n if (is_prime(13) == 1) {\\n std::cout << \\\"is_prime(13) passed\\\" << std::endl;\\n } else {\\n std::cout << \\\"is_prime(13) failed\\\" << std::endl;\\n }\\n\\n // Test lcm with 7 and 9\\n if (lcm(7, 9) == 63) {\\n std::cout << \\\"lcm(7, 9) passed\\\" << std::endl;\\n } else {\\n std::cout << \\\"lcm(7, 9) failed\\\" << std::endl;\\n }\\n\\n // Test gcd with 12 and 18\\n if (gcd(12, 18) == 6) {\\n std::cout << \\\"gcd(12, 18) passed\\\" << std::endl;\\n } else {\\n std::cout << \\\"gcd(12, 18) failed\\\" << std::endl;\\n }\\n\\n // Test gcd with two primes\\n if (gcd(7, 13) == 1) {\\n std::cout << \\\"gcd(7, 13) passed\\\" << std::endl;\\n } else {\\n std::cout << \\\"gcd(7, 13) failed\\\" << std::endl;\\n }\\n\\n // Test is_prime with 97\\n if (is_prime(97) == 1) {\\n std::cout << \\\"is_prime(97) passed\\\" << std::endl;\\n } else {\\n std::cout << \\\"is_prime(97) failed\\\" << std::endl;\\n }\\n\\n // Test extended_gcd with 48 and 18\\n int x2, y2;\\n int g2 = extended_gcd(48, 18, x2, y2);\\n if (g2 == 6 && 48 * x2 + 18 * y2 == g2) {\\n std::cout << \\\"extended_gcd(48, 18) passed\\\" << std::endl;\\n } else {\\n std::cout << \\\"extended_gcd(48, 18) failed\\\" << std::endl;\\n }\\n\\n // Test gcd with 27 and 18\\n if (gcd(27, 18) == 9) {\\n std::cout << \\\"gcd(27, 18) passed\\\" << std::endl;\\n } else {\\n std::cout << \\\"gcd(27, 18) failed\\\" << std::endl;\\n }\\n // test 999 and 123\\n if (gcd(999, 123) == 3) {\\n std::cout << \\\"gcd(999, 123) passed\\\" << std::endl;\\n } else {\\n std::cout << \\\"gcd(999, 123) failed\\\" << std::endl;\\n }\\n \\n \\n}\\n\\nint main() {\\n run_tests();\\n return 0;\\n}\"}}"
}
],
"preamble": ""
}
},
"@type": "type.googleapis.com/google.cloud.cloudaicompanion.logging.v1.RequestLog"
},
"resource": {
"type": "cloudaicompanion.googleapis.com/Instance",
"labels": {
"resource_container": "my-project-id",
"instance_id": "default",
"location": "global"
}
},
"timestamp": "2025-10-08T10:10:03.457717366Z",
"severity": "INFO",
"labels": {
"request_id": "4b66a582bad9cf2c",
"method": "CompleteTask",
"client_version": "unknown",
"product": "code_assist",
"client_name": "cloudcode_cli",
"user_id": "user@company.com"
},
"logName": "projects/my-project-id/logs/cloudaicompanion.googleapis.com%2Frequest",
"receiveTimestamp": "2025-10-08T10:10:03.606059154Z"
}
Entrée de journal de réponse
{
"insertId": "4qvt8nb2m",
"jsonPayload": {
"taskCompletionResponse": {
"output": {
"messages": [
{
"author": "MODEL",
"content": "**Testing the functions**\\n\\nI'm focusing on adding a new test case to `test.cpp`. The existing `run_tests` function is a great starting point. I'm considering which function to test further – maybe `extended_gcd`? I'll review the current tests for that function and then devise a new test scenario to add.\\n\\n\\n"
},
{
"author": "MODEL",
"content": "**Evaluating LCM Test**\\n\\nI've finalized the new test case for the `lcm` function within the `test.cpp` file. I'm adding a test for `lcm(12, 18)` to confirm the result is 36. I plan to use the `replace` command to inject this new test directly before the closing brace of the `run_tests` function. I've identified a unique line in `test.cpp` as the anchor for replacement.\\n\\n\\n"
},
{
"author": "MODEL",
"content": "**Inserting the new test**\\n\\nI've created a test case for `lcm(12, 18)`, confirming the expected result of 36. To implement this, I'm targeting the `run_tests` function. I'll use the `replace` command and will search the end of the `run_tests` function to inject the new test, right before the closing brace. I'm ready to implement this and confirm that it passes.\\n\\n\\n"
},
{
"author": "MODEL",
"content": "I've reviewed the file. I'll add a test case for the `lcm` function with inputs 12 and 18."
},
{
"content": "replace({\"file_path\":\"/usr/local/google/home/pdec/test.cpp\",\"instruction\":\"add a test for the lcm function with 12 and 18\",\"new_string\":\" // test 999 and 123\\n if (gcd(999, 123) == 3) {\\n std::cout << \\\"gcd(999, 123) passed\\\" << std::endl;\\n } else {\\n std::cout << \\\"gcd(999, 123) failed\\\" << std::endl;\\n }\\n \\n // Test lcm with 12 and 18\\n if (lcm(12, 18) == 36) {\\n std::cout << \\\"lcm(12, 18) passed\\\" << std::endl;\\n } else {\\n std::cout << \\\"lcm(12, 18) failed\\\" << std::endl;\\n }\\n \\n}\",\"old_string\":\" // test 999 and 123\\n if (gcd(999, 123) == 3) {\\n std::cout << \\\"gcd(999, 123) passed\\\" << std::endl;\\n } else {\\n std::cout << \\\"gcd(999, 123) failed\\\" << std::endl;\\n }\\n \\n \\n}\"})",
"author": "MODEL"
}
]
}
},
"@type": "type.googleapis.com/google.cloud.cloudaicompanion.logging.v1.ResponseLog"
},
"resource": {
"type": "cloudaicompanion.googleapis.com/Instance",
"labels": {
"location": "global",
"resource_container": "my-project-id",
"instance_id": "default"
}
},
"timestamp": "2025-10-08T10:10:03.461137399Z",
"severity": "INFO",
"labels": {
"client_name": "cloudcode_cli",
"client_version": "unknown",
"method": "CompleteTask",
"request_id": "4b66a582bad9cf2c",
"product": "code_assist",
"user_id": "user@company.com"
},
"logName": "projects/my-project-id/logs/cloudaicompanion.googleapis.com%2Fresponse",
"receiveTimestamp": "2025-10-08T10:10:03.606059154Z"
}
Entrée de journal de métadonnées
{
"insertId": "4qvt8nb2l",
"jsonPayload": {
"clientVersion": "unknown",
"apiRequest": {},
"clientName": "cloudcode_cli",
"requestId": "4b66a582bad9cf2c",
"@type": "type.googleapis.com/google.cloud.cloudaicompanion.logging.v1.MetadataLog"
},
"resource": {
"type": "cloudaicompanion.googleapis.com/Instance",
"labels": {
"resource_container": "my-project-id",
"location": "global",
"instance_id": "default"
}
},
"timestamp": "2025-10-08T10:10:03.459902984Z",
"severity": "INFO",
"labels": {
"product": "code_assist",
"user_id": "user@company.com",
"method": "CompleteTask"
},
"logName": "projects/my-project-id/logs/cloudaicompanion.googleapis.com%2Fmetadata",
"receiveTimestamp": "2025-10-08T10:10:03.606059154Z"
}
Réponses de Gemini Code Assist
Le tableau suivant présente les champs de réponse de Gemini Code Assist et leurs descriptions :
| Champ | Valeurs et notes |
|---|---|
LogEntry.resource.type |
Type de ressource Gemini Code Assist : cloudaicompanion.googleapis.com/Instance. |
LogEntry.resource.labels.resource_container |
Identifiant unique du conteneur de ressources dans lequel Gemini Code Assist a été utilisé. |
LogEntry.resource.labels.location |
Emplacement où Gemini Code Assist a été utilisé. |
LogEntry.resource.labels.instance_id |
Identifiant unique de la ressource dans laquelle Gemini Code Assist a été utilisé. |
LogEntry.labels.method |
Il peut s'agir de l'une des valeurs suivantes, selon ce qui a appelé logEntry :CompleteTask : par exemple, une requête de chat de Gemini Code Assist.GenerateCode : par exemple, une requête de génération de code, comme une requête de transformation de code dans Gemini Code Assist.CompleteCode : par exemple, une requête de complétion de code lorsque vous travaillez dans l'IDE, comme avec les suggestions intégrées dans Gemini Code Assist. |
LogEntry.labels.product |
Nom du service auquel le journal s'applique. Les journaux pertinents pour Gemini Code Assist utilisent la valeur de produit code_assist. Si le journal est pertinent pour Gemini Cloud Assist, cette valeur est cloud_assist. Sinon, cette valeur est unknown. |
LogEntry.labels.request_id |
Identifiant unique permettant de mettre en corrélation une requête avec une entrée de journal de réponse. |
LogEntry.labels.user_id |
Identifiant de l'utilisateur qui a lancé cette requête. |
LogEntry.jsonPayload |
Charge utile de l'entrée de journal. Toutes les citations de sources utilisées pour générer la réponse sont incluses dans cet objet en tant qu'éléments attribution_context. |
LogEntry.logName |
Identifie le journal. |
Journaux de métadonnées Gemini Code Assist
Pour que les journaux de métadonnées soient générés, le paramètre de données de télémétrie de l'extension Gemini Code Assist doit être activé pour les extensions VS Code et IntelliJ.
Les journaux de métadonnées Gemini Code Assist suivent la même structure que les journaux Gemini Code Assist, mais spécifient des champs différents. Les journaux de métadonnées incluent les types d'entrées suivants :
- Métadonnées de requête : Gemini Code Assist écrit une entrée de journal de métadonnées pour chaque requête de chat et d'agent, de génération de code et de complétion de code. Ces entrées ont une valeur
labels.methoddeCompleteTask,GenerateCodeouCompleteCode. Pour les requêtes de chat et d'agent (CompleteTask), l'entrée inclut un nombre de jetons combiné dansapiRequest.totalTokenCount. Pour les requêtes de génération et de complétion de code,apiRequestest vide. - Événements de télémétrie : l'IDE envoie des événements de télémétrie, tels que les événements
codeExposure,codeAcceptance,chatExposureetchatAcceptance, ainsi que le nombre de lignes acceptées. Ces entrées ont une valeurlabels.methoddeExport.Metricset n'incluent pas le nombre de jetons.
Le tableau suivant présente la liste des champs figurant dans une entrée de journal de requête utilisateur :
| Champ | Valeurs et notes |
|---|---|
LogEntry.@type |
Type de ressource de métadonnées Gemini Code Assist : type.googleapis.com/google.cloud.cloudaicompanion.logging.v1.MetadataLog. |
LogEntry.labels.method |
Il peut s'agir de l'une des valeurs suivantes, selon le type d'entrée de journal de métadonnées :Export.Metrics : événements de télémétrie envoyés par l'IDE, tels que codeExposure, codeAcceptance, chatExposure et chatAcceptance.CompleteTask, GenerateCode ou CompleteCode : métadonnées de requête pour les requêtes de chat et d'agent, de génération de code et de complétion de code, respectivement. |
LogEntry.labels.product |
Nom du service auquel le journal s'applique. Les journaux pertinents pour Gemini Code Assist utilisent la valeur de produit code_assist. Si le journal est pertinent pour Gemini Cloud Assist, cette valeur est cloud_assist. Sinon, cette valeur est unknown. |
LogEntry.labels.user_id |
Identifiant de l'utilisateur qui a lancé cette requête. |
LogEntry.jsonPayload |
Charge utile de l'entrée de journal de métadonnées. Pour les entrées de métadonnées de requête, la charge utile inclut un objet apiRequest. Pour les entrées de télémétrie, la charge utile inclut l'un des événements de télémétrie suivants : codeExposure, codeAcceptance, chatExposure ou chatAcceptance. Chaque événement de télémétrie est décrit dans les lignes suivantes. |
LogEntry.jsonPayload.clientName |
Nom de l'IDE, par exemple CloudCodeVscode. |
LogEntry.jsonPayload.clientVersion |
Numéro de version de l'IDE. |
LogEntry.jsonPayload.apiRequest |
Présent dans les entrées de métadonnées de requête (CompleteTask, GenerateCode et CompleteCode). Pour les requêtes de chat et d'agent (CompleteTask), inclut totalTokenCount : le nombre total de jetons pour la requête. Pour les requêtes de génération et de complétion de code (GenerateCode et CompleteCode), cet objet est vide ({}). |
LogEntry.jsonPayload.codeAcceptance |
Pour les IDE VS Code et IntelliJ uniquement, indique qu'un événement d'acceptation de la part de l'utilisateur a eu lieu (par exemple, une saisie, une tabulation ou une acceptation complète). Les champs suivants sont également inclus :
|
LogEntry.jsonPayload.codeExposure |
Pour les IDE VS Code et IntelliJ uniquement, indique qu'une suggestion de code a été présentée à un utilisateur. Les champs suivants sont également inclus :
|
LogEntry.jsonPayload.chatExposure |
Indique qu'une réponse de chat a été présentée à un utilisateur. Les champs suivants sont également inclus :
|
LogEntry.jsonPayload.chatAcceptance |
Indique qu'un événement d'acceptation de la part de l'utilisateur a eu lieu sur les blocs de code de la réponse de chat. Les champs suivants sont également inclus :
|
L'exemple suivant montre une entrée de journal codeExposure :
{
insertId: "whfrqgc1gj"
jsonPayload: {
@type: "type.googleapis.com/google.cloud.cloudaicompanion.logging.v1.MetadataLog"
clientName: "CloudCodeVscode"
clientVersion: "1.93.1"
codeExposure: {
originalRequestId: "cac019824a0b25ba"
programmingLanguage: "python"
}
requestId: "0c5178fe-446f-4ab6-b996-520dec100cf8"
}
labels: {
method: "Export.Metrics"
product: "code_assist"
user_id: "user@company.com"
}
logName: "projects/my-project-id/logs/cloudaicompanion.googleapis.com%2Fmetadata"
receiveTimestamp: "2025-02-03T23:34:35.662837985Z"
resource: {
labels: {
instance_id: "default"
location: "global"
resource_container: "my-project-id"
}
type: "cloudaicompanion.googleapis.com/Instance"
}
severity: "INFO"
timestamp: "2025-02-03T23:34:35.021564463Z"
}
L'exemple suivant montre une entrée de journal codeAcceptance :
{
insertId: "whfrqgc1gk"
jsonPayload: {
@type: "type.googleapis.com/google.cloud.cloudaicompanion.logging.v1.MetadataLog"
clientName: "CloudCodeVscode"
clientVersion: "1.93.1"
codeAcceptance: {
linesCount: 2
originalRequestId: "cac019824a0b25ba"
programmingLanguage: "python"
}
requestId: "ddf11040-c315-452e-b7cd-928c3f97984e"
}
labels: {
method: "Export.Metrics"
product: "code_assist"
user_id: "user@company.com"
}
logName: "projects/my-project-id/logs/cloudaicompanion.googleapis.com%2Fmetadata"
receiveTimestamp: "2025-02-03T23:34:37.632662272Z"
resource: {
labels: {
instance_id: "default"
location: "global"
resource_container: "my-project-id"
}
type: "cloudaicompanion.googleapis.com/Instance"
}
severity: "INFO"
timestamp: "2025-02-03T23:34:36.778692483Z"
}
L'exemple suivant montre une entrée de journal chatAcceptance :
{
"insertId": "1oru1grbow",
"jsonPayload": {
"clientVersion": "1.103.2",
"requestId": "32a0b0b8c967d8e8",
"clientName": "CloudCodeVscode",
"chatAcceptance": {
"interactionType": "ACCEPT_CODE_BLOCK",
"programmingLanguage": "go",
"linesCount": "15",
"originalRequestId": "75f7c41e63162567"
},
"@type": "type.googleapis.com/google.cloud.cloudaicompanion.logging.v1.MetadataLog"
},
"resource": {
"type": "cloudaicompanion.googleapis.com/Instance",
"labels": {
"resource_container": "my-project-id",
"instance_id": "default",
"location": "global"
}
},
"timestamp": "2025-08-25T09:34:01.240377123Z",
"severity": "INFO",
"labels": {
"product": "code_assist",
"method": "Export.Metrics",
"user_id": "user@company.com"
},
"logName": "projects/my-project-id/logs/cloudaicompanion.googleapis.com%2Fmetadata",
"receiveTimestamp": "2025-08-25T09:34:01.704925625Z"
}
L'exemple suivant montre une entrée de journal chatExposure :
{
insertId: "3diaj2c208"
jsonPayload: {
@type: "type.googleapis.com/google.cloud.cloudaicompanion.logging.v1.MetadataLog"
clientName: "CloudCodeVscode"
clientVersion: "1.93.1"
chatExposure: {
originalRequestId: "cac019824a0b25ba"
}
requestId: "0c5178fe-446f-4ab6-b996-520dec100cf8"
}
labels: {
method: "Export.Metrics"
product: "code_assist"
user_id: "user@company.com"
}
logName: "projects/my-project-id/logs/cloudaicompanion.googleapis.com%2Fmetadata"
receiveTimestamp: "2025-02-03T23:34:35.662837985Z"
resource: {
labels: {
instance_id: "default"
location: "global"
resource_container: "my-project-id"
}
type: "cloudaicompanion.googleapis.com/Instance"
}
severity: "INFO"
timestamp: "2025-02-03T23:34:35.021564463Z"
}
Calculer le taux d'acceptation
Les sections suivantes décrivent comment calculer le taux d'acceptation des suggestions de code, le taux d'acceptation des réponses dans le chat et le taux d'acceptation total combiné à l'aide des journaux de métadonnées Gemini Code Assist.
Calculer le taux d'acceptation du code
Pour calculer le taux d'acceptation du code à l'aide des journaux de métadonnées Gemini Code Assist, recherchez le nombre total d'identifiants uniques provenant des événements avec codeAcceptance.originalRequestId et divisez-le par le nombre total d'identifiants uniques provenant des événements avec codeExposure.originalRequestId.
Vous pouvez affiner ce calcul par langage de programmation et par utilisateur à l'aide des champs d'événement de journal de métadonnées correspondants.
Calculer le taux d'acceptation des chats
Pour calculer le taux d'acceptation du chat à l'aide des journaux de métadonnées Gemini Code Assist, recherchez le nombre total d'identifiants uniques provenant des événements avec chatAcceptance.originalRequestId et divisez-le par le nombre total d'identifiants uniques provenant des événements avec chatExposure.originalRequestId.
Vous pouvez affiner ce calcul par langage de programmation et par utilisateur à l'aide des champs d'événement de journal de métadonnées correspondants.
Calculer le taux d'acceptation total
Pour calculer le taux d'acceptation total à l'aide des journaux de métadonnées Gemini Code Assist, recherchez le nombre total d'événements acceptés et divisez-le par le nombre total d'événements d'exposition :
Taux d'acceptation total = nombre total d'événements acceptés ÷ nombre total d'événements d'exposition
- Nombre total d'événements acceptés : nombre total d'identifiants uniques provenant des événements avec
codeAcceptance.originalRequestIdplus le nombre total d'identifiants uniques provenant des événements avecchatAcceptance.originalRequestId. - Nombre total d'événements d'exposition : nombre total d'identifiants uniques provenant des événements avec
codeExposure.originalRequestIdplus le nombre total d'identifiants uniques provenant des événements avecchatExposure.originalRequestId.
Cette formule fournit un taux d'acceptation qui reflète la probabilité globale qu'une suggestion soit acceptée pour toutes les fonctionnalités de Gemini Code Assist.
Calculer les lignes de code acceptées
Les sections suivantes décrivent comment calculer le nombre de lignes de code acceptées à partir des suggestions de code, le nombre de lignes de code acceptées à partir du chat et le nombre total de lignes de code acceptées à l'aide des journaux de métadonnées Gemini Code Assist.
Calculer les lignes de code acceptées
Pour calculer les lignes de code acceptées, recherchez la valeur maximale de codeAcceptance.linesCount pour chaque codeAcceptance.originalRequestId unique.
Ensuite, additionnez ces valeurs maximales pour calculer le nombre total de lignes de code acceptées.
Vous pouvez affiner ce calcul par langage de programmation et par utilisateur à l'aide des champs d'événement de journal de métadonnées correspondants.
Calculer les lignes de code acceptées à partir du chat
Pour calculer les lignes de code acceptées à partir du chat, recherchez la valeur du champ chatAcceptance.linesCount pour chaque chatAcceptance.originalRequestId unique. Ensuite, additionnez ces valeurs maximales pour calculer le nombre total de lignes de chat acceptées.
Calculer le nombre total de lignes de code acceptées
Pour calculer le nombre total de lignes acceptées à l'aide des journaux de métadonnées Gemini Code Assist, ajoutez les lignes de code acceptées et les lignes de code acceptées depuis le chat.
Étapes suivantes
- Découvrez comment afficher, analyser et surveiller vos journaux dans Google Cloud.
- Découvrez comment surveiller l'utilisation de Gemini Code Assist.