Ce document explique comment activer la collecte et le stockage de l'activité Gemini Code Assist, y compris les éléments suivants :
- Journaux des prompts et des réponses de Gemini Code Assist, comme les entrées utilisateur, les informations contextuelles et les réponses.
- Journaux de métadonnées Gemini Code Assist, comme les métadonnées de télémétrie et les lignes de code acceptées par l'utilisateur.
Si vous devez générer des métriques Gemini Code Assist, 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 utilisateur 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 multiprojets.
Avant de commencer
-
Pour obtenir les autorisations dont vous avez besoin pour afficher les journaux Gemini Code Assist , demandez à votre administrateur de vous accorder le rôle Lecteur de journaux (
roles/logging.viewer) IAM 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 via 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 Gemini Code Assist, procédez de l'une des façons suivantes :
Console
-
Dans la Google Cloud console, accédez à la Explorateur 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
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 options suivantes, selon ce qui a déclenché logEntry : CompleteTask : par exemple, une demande de chat provenant de Gemini Code Assist.GenerateCode : par exemple, une demande de génération de code, comme une demande de transformation de code dans Gemini Code Assist.CompleteCode : par exemple, une demande de saisie semi-automatique de code lorsque vous travaillez dans l'IDE, comme les suggestions intégrées dans Gemini Code Assist. |
LogEntry.labels.product |
Nom du service auquel le journal s'applique. Les journaux pertinents pour l'utilisation de 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'interaction 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 seule action utilisateur. Voici quelques exemples de ces interactions :
- Un agent effectuant une tâche impliquant 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 un 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 une entrée de journal de réponse provenant d'une interaction avec un agent qui inclut 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 provenant 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 avec un 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 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 options suivantes, selon ce qui a déclenché logEntry : CompleteTask : par exemple, une demande de chat provenant de Gemini Code Assist.GenerateCode : par exemple, une demande de génération de code, comme une demande de transformation de code dans Gemini Code Assist.CompleteCode : par exemple, une demande de saisie semi-automatique de code lorsque vous travaillez dans l'IDE, comme les suggestions intégrées dans Gemini Code Assist. |
LogEntry.labels.product |
Nom du service auquel le journal s'applique. Les journaux pertinents pour l'utilisation de 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. 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 |
Pour les journaux de métadonnées, la valeur de cette étiquette est Export.Metrics. |
LogEntry.labels.product |
Nom du service auquel le journal s'applique. Les journaux pertinents pour l'utilisation de 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 |
Indique un événement codeExposure ou code.Acceptance. Un événement codeExposure indique qu'une suggestion de code a été présentée à un utilisateur. Un événement code.Acceptance 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). |
LogEntry.jsonPayload.clientName |
Nom de l'IDE, par exemple CloudCodeVscode. |
LogEntry.jsonPayload.clientVersion |
Numéro de version de l'IDE. |
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 dans la réponse du 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 du chat et le taux d'acceptation combiné total à 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 dans les événements avec codeAcceptance.originalRequestId et divisez-le par le nombre total d'identifiants uniques dans les é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 du chat
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 dans les événements avec chatAcceptance.originalRequestId et divisez-le par le nombre total d'identifiants uniques dans les é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 dans les événements avec
codeAcceptance.originalRequestIdplus le nombre total d'identifiants uniques dans les événements avecchatAcceptance.originalRequestId. - Nombre total d'événements d'exposition : nombre total d'identifiants uniques dans les événements avec
codeExposure.originalRequestIdplus le nombre total d'identifiants uniques dans les événements avecchatExposure.originalRequestId.
Cette formule fournit un taux d'acceptation qui reflète la probabilité globale qu'une suggestion soit acceptée dans 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.
Additionnez ensuite 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
chatAcceptance.linesCount champ pour chaque
chatAcceptance.originalRequestId unique. Additionnez ensuite 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, additionnez les lignes de code acceptées et lignes de code acceptées à partir du chat.
Étape suivante
- Découvrez comment afficher, analyser et surveiller vos journaux dans Google Cloud.
- Découvrez comment surveiller l'utilisation de Gemini Code Assist.