Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.
# Monitoraggio e tracciamento dell’uso di Amazon Q Developer
Il monitoraggio è una parte importante per mantenere l'affidabilità, la disponibilità e le prestazioni di Amazon Q Developer e delle altre AWS soluzioni. AWS fornisce i seguenti strumenti e funzionalità di monitoraggio per monitorare e registrare l'attività di Amazon Q Developer:
+ *AWS CloudTrail*acquisisce le chiamate API e gli eventi correlati effettuati da o per conto tuo Account AWS e invia i file di log a un bucket Amazon Simple Storage Service (Amazon S3) da te specificato. Puoi identificare quali utenti e account hanno effettuato la chiamata AWS, l'indirizzo IP di origine da cui sono state effettuate le chiamate e quando sono avvenute le chiamate. Per ulteriori informazioni, consulta [Registrazione delle chiamate API Amazon Q Developer tramite AWS CloudTrail](logging-using-cloudtrail.md).
+ *Amazon CloudWatch* monitora AWS le tue risorse e le applicazioni su cui esegui AWS in tempo reale. È possibile raccogliere e tenere traccia dei parametri, creare pannelli di controllo personalizzati e impostare allarmi per inviare una notifica o intraprendere azioni quando un parametro specificato raggiunge una determinata soglia. Ad esempio, puoi tenere CloudWatch traccia del numero di volte in cui Amazon Q è stato richiamato sul tuo account o del numero di utenti attivi ogni giorno. Per ulteriori informazioni, consulta [Monitoraggio di Amazon Q Developer con Amazon CloudWatch](monitoring-cloudwatch.md).
Amazon Q Developer include anche le seguenti funzionalità per aiutarti a tracciare e registrare l’attività degli utenti in Amazon Q:
+ *Una dashboard* mostra le metriche aggregate delle attività degli abbonati ad Amazon Q Developer Pro. Per ulteriori informazioni, consulta [Visualizzazione delle attività degli utenti di Amazon Q Developer sulla dashboard](dashboard.md).
+ *I report sulle attività degli utenti* mostrano cosa fanno i singoli utenti in Amazon Q. Per ulteriori informazioni, consulta [Visualizzazione dell’attività di utenti specifici in Amazon Q Developer](q-admin-user-telemetry.md).
+ *I log dei prompt* forniscono un registro di tutti i prompt che gli utenti inseriscono nella chat di Amazon Q nel loro ambiente di sviluppo integrato (IDE). Per ulteriori informazioni, consulta [Logging dei prompt degli utenti in Amazon Q Developer](q-admin-prompt-logging.md).
# Registrazione delle chiamate API Amazon Q Developer tramite AWS CloudTrail
Amazon Q Developer Pro è integrato con AWS CloudTrail, un servizio che fornisce una registrazione delle azioni intraprese da un utente, da un ruolo o da un utente Servizio AWS in Amazon Q. CloudTrail Cattura tutte le chiamate API per Amazon Q come eventi. Le chiamate acquisite includono le chiamate dalla console Amazon Q e le chiamate di codice alle operazioni API di Amazon Q. **Se crei un trail, puoi abilitare la distribuzione continua di CloudTrail eventi a un bucket Amazon S3, inclusi gli eventi per Amazon Q. Se non configuri un trail, puoi comunque visualizzare gli eventi più recenti nella CloudTrail console in Cronologia eventi.** Utilizzando le informazioni raccolte da CloudTrail, puoi determinare la richiesta che è stata effettuata ad Amazon Q, l'indirizzo IP da cui è stata effettuata la richiesta, chi ha effettuato la richiesta, quando è stata effettuata e dettagli aggiuntivi.
Per ulteriori informazioni in merito CloudTrail, consulta la [Guida AWS CloudTrail per l'utente](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/).
## Informazioni per gli sviluppatori di Amazon Q in CloudTrail
CloudTrail è abilitato sul tuo account al Account AWS momento della creazione dell'account. Quando si verifica un'attività in Amazon Q Developer, tale attività viene registrata in un CloudTrail evento insieme ad altri Servizio AWS eventi nella **cronologia** degli eventi. Puoi visualizzare, cercare e scaricare eventi recenti nel tuo Account AWS. Per ulteriori informazioni, consulta [Visualizzazione degli eventi con cronologia degli CloudTrail eventi](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/view-cloudtrail-events.html) nella *Guida AWS CloudTrail per l'utente*.
Per una registrazione continua degli eventi del tuo sito Account AWS, compresi gli eventi per Amazon Q, crea un percorso. Un *trail* consente di CloudTrail inviare file di log a un bucket Amazon S3. Per impostazione predefinita, quando si crea un percorso nella console, questo sarà valido in tutte le Regioni AWS. Il trail registra gli eventi di tutte le regioni della AWS partizione e consegna i file di log al bucket Amazon S3 specificato. Inoltre, puoi configurarne altri Servizi AWS per analizzare ulteriormente e agire in base ai dati sugli eventi raccolti nei log. CloudTrail Per ulteriori informazioni, consulta gli argomenti seguenti nella *Guida per l'utente di AWS CloudTrail *:
+ [Panoramica della creazione di un percorso](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-create-and-update-a-trail.html)
+ [CloudTrail servizi e integrazioni supportati](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-aws-service-specific-topics.html#cloudtrail-aws-service-specific-topics-integrations)
+ [Configurazione delle notifiche Amazon SNS per CloudTrail](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/getting_notifications_top_level.html)
+ [Ricezione di file di CloudTrail registro da più regioni](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/receive-cloudtrail-log-files-from-multiple-regions.html)
+ [Ricezione di file di CloudTrail registro da più account](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-receive-logs-from-multiple-accounts.html)
Tutte le azioni di Amazon Q Developer vengono registrate CloudTrail e generano voci nei file di CloudTrail registro.
Ogni evento o voce di log contiene informazioni sull’utente che ha generato la richiesta. Le informazioni di identità consentono di determinare quanto segue:
+ Se la richiesta è stata effettuata con credenziali utente root o AWS Identity and Access Management (IAM)
+ Se la richiesta è stata effettuata con le credenziali di sicurezza temporanee per un ruolo o un utente federato.
+ Se la richiesta è stata effettuata da un altro Servizio AWS
Per ulteriori informazioni, vedete l'[elemento CloudTrail UserIdentity nella Guida](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-event-reference-user-identity.html) per l'*AWS CloudTrail utente*.
## Informazioni sulle voci dei file di log di Amazon Q Developer
Un trail è una configurazione che consente la distribuzione di eventi come file di log in un bucket Amazon S3 specificato dall'utente. CloudTrail i file di registro contengono una o più voci di registro. Un evento rappresenta una singola richiesta proveniente da qualsiasi fonte e include informazioni sull'azione richiesta, la data e l'ora dell'azione, i parametri della richiesta e così via. CloudTrail i file di registro non sono una traccia ordinata dello stack delle chiamate API pubbliche, quindi non vengono visualizzati in un ordine specifico.
Amazon Q Developer effettua anche chiamate API con un parametro `dryRun` per verificare che tu disponga delle autorizzazioni necessarie per l’azione, senza effettuare effettivamente la richiesta. Le chiamate ad Amazon Q Developer APIs con il `dryRun` parametro vengono acquisite come eventi e registrate in un CloudTrail registro con `"dryRun" : true` nel `requestParameters` campo.
L'esempio seguente mostra una voce di CloudTrail registro che illustra l'`SendMessage`azione.
```
{
"eventVersion": "1.08",
"userIdentity": {
"type": "AssumedRole",
"principalId": "AROAXD12ABCDEF3G4HI5J:aws-user",
"arn": "arn:aws:sts::123456789012:assumed-role/PowerUser/aws-user",
"accountId": "123456789012",
"accessKeyId": "ASIAAB12CDEFG34HIJK",
"sessionContext": {
"sessionIssuer": {
"type": "Role",
"principalId": "AROAXD12ABCDEF3G4HI5J",
"arn": "arn:aws:iam::123456789012:role/PowerUser",
"accountId": "123456789012",
"userName": "PowerUser"
},
"webIdFederationData": {},
"attributes": {
"creationDate": "2023-11-28T10:00:00Z",
"mfaAuthenticated": "false"
}
}
},
"eventTime": "2023-11-28T10:00:00Z",
"eventSource": "q.amazonaws.com",
"eventName": "SendMessage",
"awsRegion": "us-east-1",
"sourceIPAddress": "123.456.789.012",
"userAgent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:109.0) Gecko/20100101 Firefox/115.0",
"requestParameters": {
"Origin": "https://conversational-experience-worker.widget.console.aws.amazon.com",
"conversationId": "a298ec0d-0a49-4d2e-92bd-7d6e629b4619",
"source": "CONSOLE",
"conversationToken": "***",
"utterance": "***"
},
"responseElements": {
"result": {
"content": {
"text": {
"body": "***",
"references": []
}
},
"format": "PLAINTEXT",
"intents": {},
"type": "TEXT"
},
"Access-Control-Expose-Headers": "x-amzn-RequestId,x-amzn-ErrorType,x-amzn-ErrorMessage,Date",
"metadata": {
"conversationExpirationTime": "2024-02-25T19:31:38Z",
"conversationId": "a298ec0d-0a49-4d2e-92bd-7d6e629b4619",
"conversationToken": "***",
"utteranceId": "3b87b46f-04a9-41ef-b8fe-8abf52d2c053"
},
"resultCode": "LLM"
},
"additionalEventData": {
"quickAction": "dev"
},
"requestID": "19b3c30e-906e-4b7f-b5c3-509f67248655",
"eventID": "a552c487-7d97-403a-8ec4-d49539c7a03d",
"readOnly": false,
"eventType": "AwsApiCall",
"managementEvent": true,
"recipientAccountId": "123456789012",
"eventCategory": "Management"
}
```
L'esempio seguente mostra una voce di CloudTrail registro che illustra l'`PassRequest`azione.
```
{
"eventVersion": "1.09",
"userIdentity": {
"type": "AssumedRole",
"principalId": "AIDA6ON6E4XEGIEXAMPLE",
"arn": "arn:aws:iam::555555555555:user/Mary",
"accountId": "555555555555",
"accessKeyId": "AKIAIOSFODNN7EXAMPLE",
"sessionContext": {
"sessionIssuer": {
"type": "Role",
"principalId": "AIDA6ON6E4XEGIEXAMPLE",
"arn": "arn:aws:iam::555555555555:user/Mary",
"accountId": "555555555555",
"userName": "Mary"
},
"attributes": {
"creationDate": "2024-04-10T20:03:01Z",
"mfaAuthenticated": "false"
},
"invokedBy": "q.amazonaws.com"
},
"eventTime": "2024-04-10T20:04:42Z",
"eventSource": "q.amazonaws.com",
"eventName": "PassRequest",
"awsRegion": "us-east-1",
"sourceIPAddress": "q.amazonaws.com",
"userAgent": "q.amazonaws.com",
"requestParameters": null,
"responseElements": null,
"requestID": "2d528c76-329e-410b-9516-EXAMPLE565dc",
"eventID": "ba0801a1-87ec-4d26-be87-EXAMPLE75bbb",
"readOnly": false,
"eventType": "AwsApiCall",
"managementEvent": true,
"recipientAccountId": "555555555555",
"eventCategory": "Management"
}
```
L'esempio seguente mostra una voce di CloudTrail registro che dimostra che Amazon Q esegue l'`s3:ListBuckets`azione per tuo conto.
```
{
"eventVersion": "1.09",
"userIdentity": {
"type": "AssumedRole",
"principalId": "AIDA6ON6E4XEGIEXAMPLE",
"arn": "arn:aws:iam::555555555555:user/Paulo",
"accountId": "555555555555",
"accessKeyId": "AKIAIOSFODNN7EXAMPLE",
"sessionContext": {
"sessionIssuer": {
"type": "Role",
"principalId": "AIDA6ON6E4XEGIEXAMPLE",
"arn": "arn:aws:iam::555555555555:user/Paulo",
"accountId": "555555555555",
"userName": "Paulo"
},
"attributes": {
"creationDate": "2024-04-10T14:06:08Z",
"mfaAuthenticated": "false"
}
},
"invokedBy": "q.amazonaws.com"
},
"eventTime": "2024-04-10T14:07:55Z",
"eventSource": "s3.amazonaws.com",
"eventName": "ListBuckets",
"awsRegion": "us-east-1",
"sourceIPAddress": "q.amazonaws.com",
"userAgent": "q.amazonaws.com",
"requestParameters": {
"Host": "s3.amazonaws.com"
},
"responseElements": null,
"additionalEventData": {
"SignatureVersion": "SigV4",
"CipherSuite": "ECDHE-RSA-AES128-GCM-SHA256",
"bytesTransferredIn": 0,
"AuthenticationMethod": "AuthHeader",
"x-amz-id-2": "ExampleRequestId123456789",
"bytesTransferredOut": 4054
},
"requestID": "ecd94349-b36f-44bf-b6f5-EXAMPLE9c463",
"eventID": "2939ba50-1d26-4a5a-83bd-EXAMPLE85850",
"readOnly": true,
"eventType": "AwsApiCall",
"managementEvent": true,
"recipientAccountId": "555555555555",
"vpcEndpointId": "vpce-EXAMPLE1234",
"eventCategory": "Management"
}
```
# Monitoraggio di Amazon Q Developer con Amazon CloudWatch
**Nota**
Le metriche qui discusse riguardano solo l’utilizzo di [Amazon Q nel tuo IDE](q-in-IDE.md).
Puoi monitorare Amazon Q Developer utilizzando CloudWatch, che raccoglie dati grezzi e li elabora in metriche leggibili quasi in tempo reale. Queste statistiche vengono conservate per un periodo di 15 mesi, per permettere l’accesso alle informazioni storiche e offrire una prospettiva migliore sulle prestazioni di Amazon Q. È anche possibile impostare allarmi che controllano determinate soglie e inviare notifiche o intraprendere azioni quando queste soglie vengono raggiunte. Per ulteriori informazioni, consulta la [Amazon CloudWatch User Guide](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/).
Il servizio Amazon Q Developer riporta le metriche seguenti nel namespace `AWS/Q`.
| Dimensioni | Metrica | Caso d’uso o spiegazione |
| --- | --- | --- |
| Conteggio | Invocazioni | Vuoi determinare quante invocazioni sono state contate nel tempo. |
| UserCount | DailyActiveUserTrend | Vuoi determinare il numero di utenti attivi al giorno. |
| SubscriptionUserCount | SubscriptionCount | Vuoi determinare il numero di utenti con abbonamenti a pagamento. |
| UniqueUserCount | MonthlyActiveUniqueUsers | Vuoi determinare il numero di utenti attivi in un determinato mese. |
| ProgrammingLanguage, SuggestionState, CompletionType | GeneratedLineCount | Vuoi determinare il numero di righe generate da Amazon Q Developer. |
| ProgrammingLanguage, SuggestionState, CompletionType | SuggestionReferenceCount | Desideri determinare il numero di trigger di suggerimento con riferimenti che hanno avuto luogo. |
| ProgrammingLanguage | CodeScanCount | Desideri determinare il numero di scansioni di codice che sono state eseguite. |
| ProgrammingLanguage | TotalCharacterCount | Il numero di caratteri nel file, inclusi tutti i suggerimenti di Amazon Q Developer. |
| ProgrammingLanguage | CodeWhispererCharacterCount | Il numero di caratteri generati da Amazon Q Developer. |
Per aggregare Invocazioni, utilizza la statistica Somma.
Per aggregare DailyActiveUserTrend, usa la statistica Sum e usa «1 giorno» come periodo.
Per aggregare SubscriptionCount, usa la statistica Sum.
Per aggregare, MonthlyActiveUniqueUsers utilizza la statistica Sum e utilizza «30 giorni» come periodo.
# Identificazione delle azioni di utenti specifici con Amazon CloudWatch Logs
È possibile ottenere le metriche a livello di utente sull’utilizzo di Amazon Q Developer. Per capire quale utente ha intrapreso una particolare azione, cerca gli eventi chiamati SendTelemetryEvent ed esamina il tipo di oggetto JSON in essi contenuto. SendTelemetryEventRequest All’interno di quell’oggetto, lo schema viene visualizzato come segue.
**Suggerimento**
Puoi anche inviare l’attività dei singoli utenti in Amazon Q Developer in un report in formato CSV. Per ulteriori informazioni, consulta [Visualizzazione dell’attività di utenti specifici in Amazon Q Developer](q-admin-user-telemetry.md).
```
http://json-schema.org/draft-07/schema#",
"definitions": {
"ProgrammingLanguage": {
"type": "object",
"properties": {
"languageName": {
"type": "string",
"enum": [
"python",
"javascript",
"java",
"csharp",
"typescript",
"c",
"cpp",
"go",
"kotlin",
"php",
"ruby",
"rust",
"scala",
"shell",
"sql",
"json",
"yaml",
"vue",
"tf",
"tsx",
"jsx",
"plaintext"
],
"description": "Programming Languages supported by Q"
}
}
},
"Dimension": {
"type": "object",
"properties": {
"name": {
"type": "string",
"description": "must match ^[-a-zA-Z0-9._]*$ and be between 1 and 255 characters"
},
"value": {
"type": "string",
"description": "must match ^[-a-zA-Z0-9._]*$ and be between 1 and 1024 characters"
}
}
}
},
"telemetryEvents": {
"UserTriggerDecisionEvent": {
"type": "object",
"properties": {
"sessionId": {
"type": "string",
"description": "UUID for the session"
},
"requestId": {
"type": "string",
"description": "UUID for the request"
},
"customizationArn": {
"type": "string",
"description": "ARN of the customization matching pattern: ^arn:[-.a-z0-9]{1,63}:codewhisperer:([-.a-z0-9]{0,63}:){2}([a-zA-Z0-9-_:/]){1,1023}$"
},
"programmingLanguage": {
"$ref": "#/definitions/ProgrammingLanguage"
},
"completionType": {
"type": "string",
"enum": [
"BLOCK",
"LINE"
]
},
"suggestionState": {
"type": "string",
"enum": [
"ACCEPT",
"REJECT",
"DISCARD",
"EMPTY"
]
},
"recommendationLatencyMilliseconds": {
"type": "number"
},
"timestamp": {
"type": "string",
"description": "datetime, example: Jul 23, 2024, 12:11:02 AM"
},
"triggerToResponseLatencyMilliseconds": {
"type": "number"
},
"suggestionReferenceCount": {
"type": "integer"
},
"generatedLine": {
"type": "integer"
},
"numberOfRecommendations": {
"type": "integer"
}
},
"required": [
"sessionId",
"requestId",
"programmingLanguage",
"completionType",
"suggestionState",
"recommendationLatencyMilliseconds",
"timestamp"
]
},
"CodeCoverageEvent": {
"type": "object",
"properties": {
"customizationArn": {
"type": "string",
"description": "ARN of the customization matching pattern: ^arn:[-.a-z0-9]{1,63}:codewhisperer:([-.a-z0-9]{0,63}:){2}([a-zA-Z0-9-_:/]){1,1023}$"
},
"programmingLanguage": {
"$ref": "#/definitions/ProgrammingLanguage"
},
"acceptedCharacterCount": {
"type": "integer"
},
"totalCharacterCount": {
"type": "integer"
},
"timestamp": {
"type": "string",
"description": "datetime, example: Jul 23, 2024, 12:11:02 AM"
},
"unmodifiedAcceptedCharacterCount": {
"type": "integer"
}
},
"required": [
"programmingLanguage",
"acceptedCharacterCount",
"totalCharacterCount",
"timestamp"
]
},
"UserModificationEvent": {
"type": "object",
"properties": {
"sessionId": {
"type": "string",
"description": "UUID for the session"
},
"requestId": {
"type": "string",
"description": "UUID for the request"
},
"programmingLanguage": {
"$ref": "#/definitions/ProgrammingLanguage"
},
"modificationPercentage": {
"type": "number",
"description": "This is the percentage of AI generated code which has been modified by the user"
},
"customizationArn": {
"type": "string",
"description": "ARN of the customization matching pattern: ^arn:[-.a-z0-9]{1,63}:codewhisperer:([-.a-z0-9]{0,63}:){2}([a-zA-Z0-9-_:/]){1,1023}$"
},
"timestamp": {
"type": "string",
"description": "datetime, example: Jul 23, 2024, 12:11:02 AM"
}
},
"required": [
"sessionId",
"requestId",
"programmingLanguage",
"modificationPercentage",
"timestamp"
]
},
"CodeScanEvent": {
"type": "object",
"properties": {
"programmingLanguage": {
"$ref": "#/definitions/ProgrammingLanguage"
},
"codeScanJobId": {
"type": "string"
},
"timestamp": {
"type": "string",
"description": "datetime, example: Jul 23, 2024, 12:11:02 AM"
},
"codeAnalysisScope": {
"type": "string",
"enum": [
"FILE",
"PROJECT"
]
}
},
"required": [
"programmingLanguage",
"codeScanJobId",
"timestamp"
]
},
"CodeScanRemediationsEvent": {
"type": "object",
"properties": {
"programmingLanguage": {
"$ref": "#/definitions/ProgrammingLanguage"
},
"CodeScanRemediationsEventType": {
"type": "string",
"enum": [
"CODESCAN_ISSUE_HOVER",
"CODESCAN_ISSUE_APPLY_FIX",
"CODESCAN_ISSUE_VIEW_DETAILS"
]
},
"timestamp": {
"type": "string",
"description": "datetime, example: Jul 23, 2024, 12:11:02 AM"
},
"detectorId": {
"type": "string"
},
"findingId": {
"type": "string"
},
"ruleId": {
"type": "string"
},
"component": {
"type": "string"
},
"reason": {
"type": "string"
},
"result": {
"type": "string"
},
"includesFix": {
"type": "boolean"
}
}
},
"MetricData": {
"type": "object",
"properties": {
"metricName": {
"type": "string",
"description": "must match pattern ^[-a-zA-Z0-9._]*$ and be between 1 and 1024 characters"
},
"metricValue": {
"type": "number"
},
"timestamp": {
"type": "string",
"description": "datetime, example: Jul 23, 2024, 12:11:02 AM"
},
"product": {
"type": "string",
"description": "must match pattern ^[-a-zA-Z0-9._]*$ and be between 1 and 128 characters"
},
"dimensions": {
"type": "array",
"items": {
"$ref": "#/definitions/Dimension"
},
"description": "maximum size of 30"
}
},
"required": [
"metricName",
"metricValue",
"timestamp",
"product"
]
},
"ChatAddMessageEvent": {
"type": "object",
"properties": {
"conversationId": {
"type": "string",
"description": "ID which represents a multi-turn conversation, length between 1 and 128"
},
"messageId": {
"type": "string",
"description": "Unique identifier for the chat message"
},
"customizationArn": {
"type": "string",
"description": "ARN of the customization matching pattern: ^arn:[-.a-z0-9]{1,63}:codewhisperer:([-.a-z0-9]{0,63}:){2}([a-zA-Z0-9-_:/]){1,1023}$"
},
"userIntent": {
"type": "string",
"enum": [
"SUGGEST_ALTERNATE_IMPLEMENTATION",
"APPLY_COMMON_BEST_PRACTICES",
"IMPROVE_CODE",
"SHOW_EXAMPLES",
"CITE_SOURCES",
"EXPLAIN_LINE_BY_LINE",
"EXPLAIN_CODE_SELECTION",
"GENERATE_CLOUDFORMATION_TEMPLATE"
]
},
"hasCodeSnippet": {
"type": "boolean"
},
"programmingLanguage": {
"$ref": "#/definitions/ProgrammingLanguage"
},
"activeEditorTotalCharacters": {
"type": "integer"
},
"timeToFirstChunkMilliseconds": {
"type": "number"
},
"timeBetweenChunks": {
"type": "array",
"items": {
"type": "number"
},
"description": "maximum size of 100"
},
"fullResponselatency": {
"type": "number"
},
"requestLength": {
"type": "integer"
},
"responseLength": {
"type": "integer"
},
"numberOfCodeBlocks": {
"type": "integer"
},
"hasProjectLevelContext": {
"type": "boolean"
}
},
"required": [
"conversationId",
"messageId"
]
},
"ChatInteractWithMessageEvent": {
"type": "object",
"properties": {
"conversationId": {
"type": "string",
"description": "ID which represents a multi-turn conversation, length between 1 and 128"
},
"messageId": {
"type": "string",
"description": "Unique identifier for the chat message"
},
"customizationArn": {
"type": "string",
"description": "ARN of the customization matching pattern: ^arn:[-.a-z0-9]{1,63}:codewhisperer:([-.a-z0-9]{0,63}:){2}([a-zA-Z0-9-_:/]){1,1023}$"
},
"interactionType": {
"type": "string",
"enum": [
"INSERT_AT_CURSOR",
"COPY_SNIPPET",
"COPY",
"CLICK_LINK",
"CLICK_BODY_LINK",
"CLICK_FOLLOW_UP",
"HOVER_REFERENCE",
"UPVOTE",
"DOWNVOTE"
],
"description": "Chat Message Interaction Type"
},
"interactionTarget": {
"type": "string",
"description": "Target of message interaction"
},
"acceptedCharacterCount": {
"type": "integer"
},
"acceptedLineCount": {
"type": "integer"
},
"acceptedSnippetHasReference": {
"type": "boolean"
},
"hasProjectLevelContext": {
"type": "boolean"
}
},
"required": [
"conversationId",
"messageId"
]
},
"ChatUserModificationEvent": {
"type": "object",
"properties": {
"conversationId": {
"type": "string",
"description": "ID which represents a multi-turn conversation, length between 1 and 128"
},
"customizationArn": {
"type": "string",
"description": "ARN of the customization matching pattern: ^arn:[-.a-z0-9]{1,63}:codewhisperer:([-.a-z0-9]{0,63}:){2}([a-zA-Z0-9-_:/]){1,1023}$"
},
"messageId": {
"type": "string",
"description": "Unique identifier for the chat message"
},
"programmingLanguage": {
"$ref": "#/definitions/ProgrammingLanguage"
},
"modificationPercentage": {
"type": "number",
"description": "This is the percentage of AI generated code which has been modified by the user"
},
"hasProjectLevelContext": {
"type": "boolean"
}
},
"required": [
"conversationId",
"messageId",
"modificationPercentage"
]
},
"SuggestionState": {
"type": "string",
"enum": [
"ACCEPT",
"REJECT",
"DISCARD",
"EMPTY"
]
},
"TerminalUserInteractionEvent": {
"type": "object",
"properties": {
"terminalUserInteractionEventType": {
"type": "string",
"enum": [
"CODEWHISPERER_TERMINAL_TRANSLATION_ACTION",
"CODEWHISPERER_TERMINAL_COMPLETION_INSERTED"
],
"description": "Terminal User Interaction Event Type"
},
"terminal": {
"type": "string"
},
"terminalVersion": {
"type": "string"
},
"shell": {
"type": "string"
},
"shellVersion": {
"type": "string"
},
"duration": {
"type": "integer"
},
"timeToSuggestion": {
"type": "integer"
},
"isCompletionAccepted": {
"type": "boolean"
},
"cliToolCommand": {
"type": "string"
}
}
},
"FeatureDevEvent": {
"type": "object",
"properties": {
"conversationId": {
"type": "string",
"description": "ID which represents a multi-turn conversation, length between 1 and 128"
}
},
"required": [
"conversationId"
]
}
},
"SendTelemetryEventRequest": {
"type": "object",
"properties": {
"clientToken": {
"type": "string",
"description": "The client's authentication token"
},
"telemetryEvent": {
"properties": {
"oneOf": [
{
"_comment": "This event is emitted when a user accepts or rejects an inline code suggestion",
"$ref": "#/definitions/userTriggerDecisionEvent"
},
{
"_comment": "This event is emitted every five minutes. It details how much code is written by inline code suggestion and in total during that period",
"$ref": "#/definitions/codeCoverageEvent"
},
{
"_comment": "This event is emitted when a code snippet from inline code suggestion has been edited by a user. It details the percentage of that code snippet modified by the user",
"$ref": "#/definitions/userModificationEvent"
},
{
"_comment": "This field is emitted when a security scan is requested by a user",
"$ref": "#/definitions/codeScanEvent"
},
{
"_comment": "This field is emitted when a security scan recommended remediation is accepted by a user",
"$ref": "#/definitions/codeScanRemediationsEvent"
},
{
"_comment": "This event is deprecated but may still occur in telemetry. Do not use this.",
"$ref": "#/definitions/metricData"
},
{
"_comment": "This event is emitted when Q adds an AI generated message to the chat window",
"$ref": "#/definitions/chatAddMessageEvent"
},
{
"_comment": "This event is emitted when a user interacts with a chat message",
"$ref": "#/definitions/chatInteractWithMessageEvent"
},
{
"_comment": "This event is emitted when a user modifies a code snippet sourced from chat. It gives a percentage of the code snippet which has been modified",
"$ref": "#/definitions/chatUserModificationEvent"
},
{
"_comment": "This event is emitted when a user interacts with a terminal suggestion",
"$ref": "#/definitions/terminalUserInteractionEvent"
},
{
"_comment": "This event is emitted when a user first prompts the /dev feature.",
"$ref": "#/definitions/featureDevEvent"
}
]
}
},
"optOutPreference": {
"type": "string",
"enum": [
"OPTIN",
"OPTOUT"
],
"description": "OPTOUT and telemetry is only provided to the account of purchasing enterprise, OPTIN and telemetry may also be used for product improvement"
},
"userContext": {
"type": "object",
"properties": {
"ideCategory": {
"type": "string",
"enum": [
"JETBRAINS",
"VSCODE",
"CLI",
"JUPYTER_MD",
"JUPYTER_SM"
]
},
"operatingSystem": {
"type": "string",
"description": "The operating system being used"
},
"product": {
"type": "string",
"description": "The name of the product being used"
},
"clientId": {
"type": "string",
"description": "A UUID representing the individual client being used"
},
"ideVersion": {
"type": "string",
"description": "The version of the Q plugin"
}
},
"required": [
"ideCategory",
"operatingSystem",
"product",
"clientId",
"ideVersion"
]
},
"profileArn": {
"type": "string",
"description": "The arn of the Q Profile used to configure individual user accounts."
```
Tieni presente che a SendTelemetryEvent può contenere uno dei numerosi eventi di telemetria. Ciascuno di questi descrive un’interazione specifica tra l’ambiente di sviluppo.
Di seguito è riportata una descrizione più dettagliata di ciascun evento.
## UserTriggerDecisionEvent
Questo evento viene attivato quando un utente interagisce con un suggerimento fornito da Amazon Q. Rileva se il suggerimento è stato accettato, rifiutato o modificato, insieme ai metadati pertinenti.
+ `completionType`: se il completamento era un blocco o una riga.
+ `suggestionState`: indica se l’utente ha accettato, rifiutato o scartato il suggerimento.
## CodeScanEvent
Questo evento viene registrato quando viene eseguita una scansione del codice. Aiuta a tenere traccia dell’ambito e dei risultati della scansione, fornendo informazioni sulla sicurezza e sui controlli di qualità del codice.
+ `codeScanJobId`: identificatore univoco per il processo di scansione del codice.
+ `codeAnalysisScope`: se la scansione è stata eseguita a livello di file o a livello di progetto.
+ `programmingLanguage`: il linguaggio da scansionare.
## CodeScanRemediationsEvent
Questo evento registra le interazioni dell’utente con i suggerimenti di risoluzione di Amazon Q, come l’applicazione di correzioni o la visualizzazione dei dettagli dei problemi.
+ `CodeScanRemediationsEventType`: il tipo di azione correttiva intrapresa (ad esempio, visualizzazione dei dettagli o applicazione di una correzione).
+ `includesFix`: un booleano che indica se il problema del codice include una correzione suggerita.
## ChatAddMessageEvent
Questo evento viene attivato quando viene aggiunto un nuovo messaggio a una conversazione di chat in corso. Cattura l’intento dell’utente e tutti i frammenti di codice coinvolti.
+ `conversationId`: l’identificatore univoco per la conversazione.
+ `messageId`: l’identificatore univoco per il messaggio di chat.
+ `userIntent`: l’intento dell’utente, ad esempio migliorare o spiegare il codice.
+ `programmingLanguage`: la lingua relativa al messaggio di chat.
## ChatInteractWithMessageEvent
Questo evento rileva quando gli utenti interagiscono con i messaggi di chat, ad esempio quando copiano frammenti di codice, fanno clic su link o passano il mouse sui riferimenti.
+ `interactionType`: il tipo di interazione (ad esempio, copia, passa il mouse, fai clic).
+ `interactionTarget`: l’obiettivo dell’interazione (ad esempio, un frammento di codice o un link).
+ `acceptedCharacterCount`: il numero di caratteri del messaggio che sono stati accettati.
+ `acceptedSnippetHasReference`: un valore booleano che indica se il frammento di codice accettato include un riferimento.
## TerminalUserInteractionEvent
Questo evento registra le interazioni dell’utente con i comandi o i completamenti del terminale nell’ambiente del terminale.
+ `terminalUserInteractionEventType`: il tipo di interazione (ad esempio, traduzione del terminale o completamento del codice).
+ `isCompletionAccepted`: un valore booleano che indica se il completamento è stato accettato dall’utente.
+ `duration`: il tempo impiegato per l’interazione.
# Accesso ai messaggi relativi alla personalizzazione in Amazon Logs CloudWatch
Puoi memorizzare informazioni sulla creazione delle tue personalizzazioni in [Amazon CloudWatch Logs](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/WhatIsCloudWatchLogs.html).
È possibile autorizzare il tuo amministratore di Amazon Q Developer a visualizzare tali log con il seguente set di autorizzazioni.
*Per ulteriori informazioni sulle autorizzazioni necessarie per la distribuzione dei log a più risorse, consulta la sezione [Registrazione che richiede autorizzazioni aggiuntive [V2] nella](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/AWS-logs-and-resource-policy.html#AWS-vended-logs-permissions-V2) Amazon Logs User Guide. CloudWatch *
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "AllowLogDeliveryActions",
"Effect": "Allow",
"Action": [
"logs:PutDeliverySource",
"logs:GetDeliverySource",
"logs:DeleteDeliverySource",
"logs:DescribeDeliverySources",
"logs:PutDeliveryDestination",
"logs:GetDeliveryDestination",
"logs:DeleteDeliveryDestination",
"logs:DescribeDeliveryDestinations",
"logs:CreateDelivery",
"logs:GetDelivery",
"logs:DeleteDelivery",
"logs:DescribeDeliveries",
"firehose:ListDeliveryStreams",
"firehose:DescribeDeliveryStream",
"s3:ListAllMyBuckets",
"s3:ListBucket",
"s3:GetBucketLocation"
],
"Resource": [
"arn:aws:logs:us-east-1:111122223333:log-group:*",
"arn:aws:firehose:us-east-1:111122223333:deliverystream/*",
"arn:aws:s3:::*"
]
}
]
}
```
------
# Visualizzazione delle attività degli utenti di Amazon Q Developer sulla dashboard
Disponibile solo per gli amministratori di Amazon Q Developer, la dashboard di Amazon Q Developer riassume i dati utili su come gli abbonati al piano Pro utilizzano il servizio.
![\[La dashboard di Amazon Q che mostra gli abbonamenti totali, gli abbonamenti attivi, gli abbonamenti in sospeso, un widget con righe di codice suggerite, un widget per utenti attivi e filtri.\]](http://docs.aws.amazon.com/it_it/amazonq/latest/qdeveloper-ug/images/q-dev-dashboard.png)
Amazon Q genera e visualizza nuove metriche per la maggior parte su base oraria. L’unica sezione che non viene aggiornata ogni ora è il widget **Utenti attivi**, che viene aggiornato quotidianamente in base all’orario standard globale UTC (Coordinated Universal Time).
La dashboard mostra le metriche raccolte dagli utenti abbonati a:
+ l' AWS account a cui hai attualmente effettuato l'accesso
* e *
+ gli account membri, se hai effettuato l’accesso a un account di gestione per il quale è stata abilitata la [visibilità degli abbonamenti a livello di organizzazione](subscribe-visibility.md).
**Nota**
Il widget **Utenti attivi** mostra solo le informazioni dell’account a cui hai attualmente effettuato l’accesso.
**Per visualizzare e filtrare la dashboard**
1. Accedi alla Console di gestione AWS.
1. Passa alla console Amazon Q Developer.
1. Scegli **Dashboard** nel riquadro di navigazione.
1. (Facoltativo) Filtra le informazioni per intervallo di date, linguaggio di programmazione, personalizzazione o fornitore dell’ambiente di sviluppo integrato (IDE).
**Note:**
+ Se il link **Dashboard** non è disponibile nel riquadro di navigazione, consulta [Risoluzione dei problemi della dashboard](dashboard-troubleshooting.md).
+ Se desideri inviare le metriche degli utenti a un rapporto giornaliero con un’analisi per utente dell’utilizzo di Amazon Q Developer, consulta [Visualizzazione dell’attività di utenti specifici in Amazon Q Developer](q-admin-user-telemetry.md).
+ Per informazioni su metriche specifiche, consulta [Descrizioni delle metriche di utilizzo della dashboard di Amazon Q Developer](dashboard-metrics-descriptions.md) o scegli il link di aiuto (![\[The help link.\]](http://docs.aws.amazon.com/it_it/amazonq/latest/qdeveloper-ug/images/help-icon.png)) in alto a destra nella pagina della dashboard.
# Descrizioni delle metriche di utilizzo della dashboard di Amazon Q Developer
La tabella seguente descrive le metriche visualizzate nella dashboard di Amazon Q Developer.
Per ulteriori informazioni sulle pagine del pannello di controllo, consulta [Visualizzazione delle attività degli utenti di Amazon Q Developer sulla dashboard](dashboard.md).
| Nome parametro | Description |
| --- | --- |
| **Abbonamenti totali** | Mostra gli abbonamenti totali nell' AWS account corrente, nonché gli abbonamenti negli account dei membri, se hai effettuato l'accesso a un account di gestione per il quale è stata abilitata la [visibilità degli abbonamenti a livello di organizzazione](https://docs.aws.amazon.com/amazonq/latest/qdeveloper-ug/subscribe-visibility.html). |
| **Abbonamenti attivi** | [Mostra il totale degli abbonamenti attivi nell' AWS account corrente, nonché gli abbonamenti negli account dei membri, se hai effettuato l'accesso a un account di gestione per il quale è stata abilitata la visibilità degli abbonamenti a livello di organizzazione.](https://docs.aws.amazon.com/amazonq/latest/qdeveloper-ug/subscribe-visibility.html) *Gli abbonamenti attivi* sono quelli appartenenti agli utenti che hanno iniziato a utilizzare Amazon Q nel loro ambiente di sviluppo integrato (IDE). Questi abbonamenti ti vengono addebitati. Per ulteriori informazioni sulle sottoscrizioni attive, consulta [Stati dell’abbonamento ad Amazon Q Developer](q-admin-setup-subscribe-status.md). |
| **Abbonamenti in sospeso** | [Mostra il totale degli abbonamenti in sospeso nell' AWS account corrente, nonché gli abbonamenti negli account dei membri, se hai effettuato l'accesso a un account di gestione per il quale è stata abilitata la visibilità degli abbonamenti a livello di organizzazione.](https://docs.aws.amazon.com/amazonq/latest/qdeveloper-ug/subscribe-visibility.html) *Gli abbonamenti in sospeso* sono quelli appartenenti a utenti che non hanno ancora iniziato a utilizzare Amazon Q nel proprio IDE. Non ti viene addebitato alcun costo per questi abbonamenti. Per ulteriori informazioni, sugli abbonamenti in sospeso, consulta [Stati dell’abbonamento ad Amazon Q Developer](q-admin-setup-subscribe-status.md). |
| **Righe di codice accettate** | Mostra un grafico a torta che indica le righe di codice accettate dagli utenti, suddivise per funzionalità di Amazon Q (sviluppo di funzionalità, generazione di documentazione, generazione di unit test e così via). |
| **Utenti attivi** | Mostra un grafico a linee che indica il numero di abbonati che utilizzavano attivamente Amazon Q nell’IDE durante un intervallo di date specificato. |
| **Suggerimenti in linea** | Mostra il numero totale di suggerimenti e suggerimenti accettati per la funzionalità di [suggerimenti in linea](inline-suggestions.md). La percentuale di suggerimenti accettati viene calcolata prendendo il numero di suggerimenti accettati dagli utenti e dividendolo per il totale dei suggerimenti generati da Amazon Q. Il conteggio totale dei suggerimenti include i suggerimenti accettati e rifiutati attivamente; non include i suggerimenti respinti perché l’utente ha continuato a digitare o ha iniziato a eseguire altre operazioni nel proprio IDE. |
| **Chat in linea** | Mostra il numero totale di suggerimenti e il numero di suggerimenti accettati per la funzionalità di [chat in linea](q-in-IDE-inline-chat.md). La percentuale di suggerimenti accettati viene calcolata prendendo il numero di suggerimenti accettati dagli utenti e dividendolo per il totale dei suggerimenti generati da Amazon Q. |
| **Chat nell’IDE**: **totale dei messaggi inviati** | Mostra il numero totale di risposte da Amazon Q nella finestra di [chat di Amazon Q](q-in-IDE-chat.md) dell’IDE dell’utente. |
| **Sviluppo di funzionalità**: **tasso di accettazione** | Mostra il tasso di accettazione della [funzionalità di sviluppo](q-in-IDE-chat.md#develop-code) della funzionalità. Il tasso di accettazione viene calcolato prendendo il numero di righe di codice accettate dagli utenti e dividendolo per il totale delle righe di codice suggerite da Amazon Q. |
| **Generazione di documenti** | Mostra il numero totale di file di documentazione (ad READMEs esempio i file di supporto) creati e aggiornati dalla funzionalità di [generazione di documenti](q-in-IDE-chat.md#doc-generation). I tassi di accettazione sono pari al numero di aggiornamenti o creazioni di file accettati dagli utenti, diviso per il numero totale di aggiornamenti o creazioni di file suggeriti da Amazon Q. |
| **Generazione di test di unità** | Mostra il numero totale di unit test generati dalla funzionalità di [generazione di unit test](q-in-IDE-chat.md#unit-tests) e il numero di unit test accettati dagli utenti. Il tasso di accettazione viene calcolato prendendo il numero di test di unità accettati dagli utenti e dividendolo per il numero totale di test di unità generati da Amazon Q. |
| **Revisioni del codice** | Mostra il numero totale di revisioni del codice e report sui risultati generati dalla funzionalità di [revisione del codice](code-reviews.md). Le **revisioni totali del codice (solo manuale)** e il **report degli esiti** (solo manuale) si riferiscono alle revisioni del codice e ai report sugli esiti che *non* vengono [generati automaticamente](start-review.md#auto-scan). |
| **Correzioni al codice** | Mostra il numero totale di [correzioni al codice](address-code-issues.md) generate da Amazon Q. Il tasso di accettazione viene calcolato prendendo il numero di correzioni di codice accettate dagli utenti e dividendolo per il numero totale di correzioni di codice suggerite da Amazon Q. |
| **Trasformazione del codice** | Mostra il totale delle trasformazioni del codice numerico eseguite dalla funzionalità di [trasformazione](address-code-issues.md) e il numero di righe di codice elaborate. |
# Disabilitazione della dashboard di Amazon Q Developer
È possibile disabilitare la dashboard di Amazon Q Developer in caso di dubbi sulla privacy dei dati, sui tempi di caricamento delle pagine o su altri potenziali problemi. Quando disabiliti la dashboard, la relativa pagina (e i relativi link) non saranno più disponibili nella console Amazon Q Developer.
Per ulteriori informazioni sulle pagine del pannello di controllo, consulta [Visualizzazione delle metriche di utilizzo (dashboard)](dashboard.md).
**Per disabilitare la dashboard**
1. Apri la console Amazon Q Developer:
+ Se configuri Amazon Q Developer con un'istanza aziendale di AWS IAM Identity Center, accedi utilizzando un account di gestione o un account membro.
+ Se hai configurato Amazon Q Developer con un’istanza account del Centro identità IAM, accedi utilizzando l’account associato a quell’istanza.
1. Scegli **Impostazioni** e, nella sezione **Attività utente di Amazon Q Developer**, scegli **Modifica**.
1. Disattiva la **dashboard per l’utilizzo di Amazon Q Developer**.
# Risoluzione dei problemi della dashboard di Amazon Q Developer
Se la pagina della dashboard di Amazon Q Developer non è disponibile, procedi come segue:
+ **Verifica le autorizzazioni**. Per visualizzare la dashboard, sono necessarie le seguenti autorizzazioni:
+ `q:ListDashboardMetrics`
+ `codewhisperer:ListProfiles`
+ `sso:ListInstances`
+ `user-subscriptions:ListUserSubscriptions`
+ Per visualizzare le metriche generate prima del 22 novembre 2024, devi anche: `cloudwatch:GetMetricData` e `cloudwatch:ListMetrics`
Per ulteriori informazioni sulle autorizzazioni, consultare [Consenti agli amministratori di utilizzare la console Amazon Q Developer](id-based-policy-examples-admins.md#q-admin-setup-admin-users).
+ **Verifica le tue impostazioni**. Nella console Amazon Q Developer, scegli **Impostazioni** e assicurati che l’interruttore della **dashboard di utilizzo di Amazon Q Developer** sia abilitato.
Per ulteriori informazioni sulle pagine del pannello di controllo, consulta [Visualizzazione delle metriche di utilizzo (dashboard)](dashboard.md).
# Visualizzazione dell’attività di utenti specifici in Amazon Q Developer
È possibile configurare Amazon Q per raccogliere i dati di telemetria delle attività degli utenti dei singoli abbonati ad Amazon Q Developer della tua organizzazione e presentare tali informazioni in un report. Il report fornisce informazioni dettagliate su come utenti specifici utilizzano Amazon Q.
Amazon Q genera il report ogni giorno a mezzanotte (00:00) Coordinated Universal Time (UTC) e lo salva in un file CSV nel seguente percorso:
`s3://bucketName/prefix/AWSLogs/accountId/QDeveloperLogs/by_user_analytic/region/year/month/day/00/accountId_by_user_analytic_timestamp.csv`
Il file CSV è il seguente.
+ Ogni riga mostra un utente che ha interagito con Amazon Q quel giorno.
+ Ogni colonna mostra una metrica, come descritto in [Metriche del report sull’attività degli utenti](user-activity-metrics.md). Le metriche vengono calcolate in base alla telemetria dell’utente raccolta nel corso della giornata.
Se più di 1.000 utenti interagiscono con Amazon Q durante il giorno, Amazon Q suddivide i dati in diversi file CSV contenenti 1.000 utenti ciascuno e con i suffissi di `part_1`, `part_2` e così via.
**Nota**
Quando abiliti i report sulle attività degli utenti, Amazon Q raccoglie i dati di telemetria indipendentemente da come uno sviluppatore ha configurato l’impostazione **Consenti ad Amazon Q di inviare i dati di utilizzo ad AWS** nel proprio IDE. Questa impostazione controlla se la telemetria può essere utilizzata dalla societàAWS e non dalla tua organizzazione. Per ulteriori informazioni su questa impostazione, consulta [Disattivazione della condivisione della telemetria lato client](opt-out-IDE.md#opt-out-IDE-telemetry).
Utilizza le seguenti istruzioni per abilitare i report sulle attività degli utenti.
**Prerequisito**
Crea un bucket Amazon S3 per contenere il file CSV del report sull’attività degli utenti. Il bucket deve:
+ Sii nella AWS regione in cui è stato installato il profilo Amazon Q Developer. Questo profilo è stato installato quando hai sottoscritto per la prima volta gli utenti della forza lavoro del Centro identità IAM ad Amazon Q Developer Pro. Per ulteriori informazioni su questo profilo e sulle Regioni in cui è supportato, consulta [Cos’è il profilo di Amazon Q Developer?](subscribe-understanding-profile.md) e [Regioni supportate per la console Q Developer e il profilo Q Developer](q-admin-setup-subscribe-regions.md#qdev-console-and-profile-regions).
+ Accedi all' AWS account a cui gli utenti sono abbonati. Se gli utenti sono abbonati a più account AWS , devi creare dei bucket in ciascuno di questi account. I bucket tra più account non sono supportati.
+ (Facoltativo ma consigliato) Diversificati dal bucket che potresti utilizzare per la [registrazione di log dei prompt](q-admin-prompt-logging.md).
+ Includi un prefisso, noto anche come sottocartella, in cui Amazon Q salverà il file CSV. Il file CSV non può essere salvato nella root del bucket.
+ Adotta una policy di bucket come quella che segue. Sostituisci *bucketName**region*,*accountId*, e *prefix* con le tue informazioni.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "QDeveloperLogsWrite",
"Effect": "Allow",
"Principal": {
"Service": "q.amazonaws.com"
},
"Action": [
"s3:PutObject"
],
"Resource": [
"arn:aws:s3:::bucketName/prefix/*"
],
"Condition": {
"StringEquals": {
"aws:SourceAccount": "111122223333"
},
"ArnLike": {
"aws:SourceArn": "arn:aws:codewhisperer:us-east-1:111122223333:*"
}
}
}
]
}
```
------
Se configuri SSE-KMS sul bucket, aggiungi la seguente policy alla chiave KMS:
```
{
"Effect": "Allow",
"Principal": {
"Service": "q.amazonaws.com"
},
"Action": "kms:GenerateDataKey",
"Resource": "*",
"Condition": {
"StringEquals": {
"aws:SourceAccount": "accountId"
},
"ArnLike": {
"aws:SourceArn": "arn:aws:codewhisperer:region:accountId:*"
}
}
}
```
Per maggiori informazioni sulla protezione dei dati nel tuo bucket Amazon S3, consulta [Protezione dei dati con la crittografia](https://docs.aws.amazon.com/AmazonS3/latest/userguide/UsingEncryption.html) nella *Guida per l’utente di Amazon Simple Storage Service*.
**Per abilitare i report sulle attività degli utenti**
1. Apri la console Amazon Q Developer.
Per utilizzare la console Amazon Q Developer, è necessario disporre delle autorizzazioni definite in [Consenti agli amministratori di utilizzare la console Amazon Q Developer](id-based-policy-examples-admins.md#q-admin-setup-admin-users).
1. Seleziona **Impostazioni**.
1. In **Report sulle attività degli utenti di Q Developer**, scegli **Modifica**.
1. Attiva **Raccogli metriche granulari per utente**.
1. In **posizione S3**, inserisci l’URI di Amazon S3 che utilizzerai per archiviare i report CSV. Ad esempio: `s3://amzn-s3-demo-bucket/user-activity-reports/`
# Metriche del report sull’attività degli utenti
La tabella seguente descrive le metriche incluse nei report sulle attività degli utenti generate da Amazon Q Developer.
Per ulteriori informazioni su questi report, consulta [Visualizzazione dell’attività di utenti specifici in Amazon Q Developer](q-admin-user-telemetry.md).
| Nome parametro | Description |
| --- | --- |
| Chat\$1 AICode Lines | Righe di codice suggerite da Amazon Q e accettate dall’utente. Questa metrica include il codice generato tramite la [chat di Amazon Q](q-in-IDE-chat.md) (non la [chat in linea](q-in-IDE-inline-chat.md)) e inserito nell’IDE. |
| Chatta\$1 MessagesInteracted | Numero di messaggi di chat in cui l’utente ha interagito positivamente con Amazon Q. Esempi di interazioni positive: clic su un link, inserimento di un suggerimento e votazione positiva di una risposta di Amazon Q. Questa metrica include i messaggi generati dalla [chat di Amazon Q](q-in-IDE-chat.md) (non dalla [chat in linea](q-in-IDE-inline-chat.md)). |
| Chatta\$1 MessagesSent | Numero di messaggi inviati da e verso Amazon Q. Questa metrica include i prompt degli utenti e le risposte di Amazon Q nella [chat di Amazon Q](q-in-IDE-chat.md) (non nella [chat in linea](q-in-IDE-inline-chat.md)). |
| CodeFix\$1AcceptanceEventCount | Numero di correzioni di codice suggerite da Amazon Q e accettate dall’utente. Questa metrica si applica alle correzioni di codice generate tramite la funzionalità di revisione del [codice.](code-reviews.md) |
| CodeFix\$1AcceptedLines | Righe di codice suggerite da Amazon Q e accettate dall’utente. Questa metrica si applica alle righe di codice generate tramite la funzionalità di revisione del [codice.](code-reviews.md) |
| CodeFix\$1GeneratedLines | Righe di codice suggerite da Amazon Q. Questa metrica si applica alle righe di codice generate tramite la funzionalità di [revisione del codice](code-reviews.md). |
| CodeFix\$1GenerationEventCount | [Numero di correzioni di codice suggerite da Amazon Q. Questa metrica si applica alle correzioni del codice generate tramite la funzionalità di revisione del codice.](code-reviews.md) |
| CodeReview\$1FailedEventCount | Numero di problemi relativi al codice rilevati ma per i quali Amazon Q non è stato in grado di suggerire una correzione del codice. [Questa metrica si applica ai problemi di codice generati utilizzando la funzionalità di revisione del codice.](code-reviews.md) |
| CodeReview\$1FindingsCount | Numero di problemi di codice rilevati da Amazon Q. Questa metrica si applica ai problemi di codice rilevati utilizzando la funzionalità di [revisione del codice](code-reviews.md). |
| CodeReview\$1SucceededEventCount | Numero di problemi di codice rilevati e per i quali Amazon Q è stato in grado di generare una correzione del codice suggerita. Questa metrica si applica ai problemi di codice rilevati utilizzando la funzionalità di revisione del [codice.](code-reviews.md) |
| Dev\$1 AcceptanceEventCount | Numero di funzionalità del codice suggerite da Amazon Q e accettate dall’utente. Questa metrica si applica alle funzionalità di codice generate tramite il [comando /dev](q-in-IDE-chat.md#develop-code). |
| Dev\$1 AcceptedLines | Righe di codice suggerite da Amazon Q e accettate dall’utente. Questa metrica si applica alle righe di codice generate tramite il [comando /dev](q-in-IDE-chat.md#develop-code). |
| Dev\$1 GeneratedLines | Righe di codice suggerite da Amazon Q. Questa metrica si applica alle righe di codice generate tramite il [comando /dev](q-in-IDE-chat.md#develop-code). |
| Dev\$1 GenerationEventCount | Numero di funzionalità di codice suggerite da Amazon Q. Questa metrica si applica alle funzionalità del codice generate tramite il [comando /dev](q-in-IDE-chat.md#develop-code). |
| DocGeneration\$1AcceptedFileUpdates | Numero di aggiornamenti di file suggeriti da Amazon Q e accettati dall’utente. Questa metrica si applica agli aggiornamenti dei file generati tramite il [comando /doc](q-in-IDE-chat.md#doc-generation). |
| DocGeneration\$1AcceptedFilesCreations | Numero di creazioni di file suggerite da Amazon Q e accettate dall’utente. Questa metrica si applica alle creazioni di file generate tramite il [comando /doc](q-in-IDE-chat.md#doc-generation). |
| DocGeneration\$1AcceptedLineAdditions | Righe di integrazioni alla documentazione suggerite da Amazon Q e accettate dall’utente. Questa metrica si applica alla documentazione generata tramite il [comando /doc](q-in-IDE-chat.md#doc-generation). |
| DocGeneration\$1AcceptedLineUpdates | Linee di aggiornamento della documentazione suggerite da Amazon Q e accettate dall’utente. Questa metrica si applica alla documentazione generata utilizzando il [comando /doc](q-in-IDE-chat.md#doc-generation). |
| DocGeneration\$1EventCount | Numero di volte in cui l’utente ha interagito con Amazon Q utilizzando il [comando /doc](q-in-IDE-chat.md#doc-generation). |
| DocGeneration\$1RejectedFileCreations | Numero di creazioni di file suggerite da Amazon Q e rifiutate dall’utente. Questa metrica si applica alle creazioni di file generate tramite il [comando /doc](q-in-IDE-chat.md#doc-generation). |
| DocGeneration\$1RejectedFileUpdates | Numero di aggiornamenti di file suggeriti da Amazon Q e rifiutati dall’utente. Questa metrica si applica agli aggiornamenti dei file generati tramite il [comando /doc](q-in-IDE-chat.md#doc-generation). |
| DocGeneration\$1RejectedLineAdditions | Righe di integrazioni alla documentazione suggerite da Amazon Q e rifiutate dall’utente. Questa metrica si applica alla documentazione generata tramite il [comando /doc](q-in-IDE-chat.md#doc-generation). |
| DocGeneration\$1RejectedLineUpdates | Righe di aggiornamento della documentazione suggerite da Amazon Q e rifiutate dall’utente. Questa metrica si applica alla documentazione generata utilizzando il [comando /doc](q-in-IDE-chat.md#doc-generation). |
| InlineChat\$1AcceptedLineAdditions | Righe di codice da aggiungere suggerite da Amazon Q e accettate dall’utente. Questa metrica include le integrazioni di codice generate tramite la [chat in linea](q-in-IDE-inline-chat.md) (non la [chat di Amazon Q](q-in-IDE-chat.md)). |
| InlineChat\$1AcceptedLineDeletions | Righe di codice da eliminare suggerite da Amazon Q e accettate dall’utente. Questa metrica include le eliminazioni di codice suggerite tramite la [chat in linea](q-in-IDE-inline-chat.md) (non la [chat di Amazon Q](q-in-IDE-chat.md)). |
| InlineChat\$1AcceptanceEventCount | Numero di suggerimenti della [chat in linea](q-in-IDE-inline-chat.md) (non della [chat di Amazon Q](q-in-IDE-chat.md)) accettati dall’utente. |
| InlineChat\$1DismissalEventCount | Numero di suggerimenti delle [chat in linea](q-in-IDE-inline-chat.md) (non della [chat di Amazon Q](q-in-IDE-chat.md)) abbandonati dall’utente. Con “abbandonato”, intendiamo che il suggerimento di codice è stato visualizzato ma l’utente continuava a digitare o eseguire altre operazioni nel proprio IDE e non ha accettato o rifiutato esplicitamente il suggerimento di codice. |
| InlineChat\$1DismissedLineAdditions | Righe di codice da aggiungere suggerite da Amazon Q e abbandonate dall’utente. Con “abbandonato”, intendiamo che il suggerimento di codice è stato visualizzato ma l’utente continuava a digitare o eseguire altre operazioni nel proprio IDE e non ha accettato o rifiutato esplicitamente il suggerimento di codice. Questa metrica include le integrazioni di codice generate tramite la [chat in linea](q-in-IDE-inline-chat.md) (non la [chat di Amazon Q](q-in-IDE-chat.md)). |
| InlineChat\$1DismissedLineDeletions | Righe di codice da eliminare suggerite da Amazon Q e abbandonate dall’utente. Con “abbandonato”, intendiamo che il suggerimento di codice è stato visualizzato ma l’utente continuava a digitare o eseguire altre operazioni nel proprio IDE e non ha accettato o rifiutato esplicitamente il suggerimento di codice. Questa metrica include le eliminazioni di codice suggerite tramite la [chat in linea](q-in-IDE-inline-chat.md) (non la [chat di Amazon Q](q-in-IDE-chat.md)). |
| InlineChat\$1EventCount | Numero di sessioni di [chat in linea](q-in-IDE-inline-chat.md) (non della [chat di Amazon Q](q-in-IDE-chat.md)) a cui l’utente ha partecipato. |
| InlineChat\$1RejectedLineAdditions | Righe di codice da aggiungere suggerite da Amazon Q e rifiutate dall’utente. Questa metrica include le integrazioni di codice generate tramite la [chat in linea](q-in-IDE-inline-chat.md) (non la [chat di Amazon Q](q-in-IDE-chat.md)). |
| InlineChat\$1RejectedLineDeletions | Righe di codice da eliminare suggerite da Amazon Q e rifiutate dall’utente. Questa metrica include le eliminazioni di codice suggerite tramite la [chat in linea](q-in-IDE-inline-chat.md) (non la [chat di Amazon Q](q-in-IDE-chat.md)). |
| InlineChat\$1RejectionEventCount | Numero di suggerimenti delle [chat in linea](q-in-IDE-inline-chat.md) (non della [chat di Amazon Q](q-in-IDE-chat.md)) rifiutati dall’utente. |
| Linee Inline\$1 AICode | Righe di codice suggerite da Amazon Q e accettate dall’utente. Questa metrica include il codice accettato come [suggerimenti in linea](inline-suggestions.md). |
| In linea\$1 AcceptanceCount | Numero di [suggerimenti in linea](inline-suggestions.md) accettati dall’utente. |
| In linea\$1 SuggestionsCount | Numero di [suggerimenti in linea](inline-suggestions.md) visualizzati all’utente. |
| TestGeneration\$1AcceptedLines | Righe di codice suggerite da Amazon Q e accettate dall’utente. Questa metrica si applica alle righe di codice generate tramite il [ comando /test](q-in-IDE-chat.md#unit-tests). |
| TestGeneration\$1AcceptedTests | Numero di test di unità suggeriti da Amazon Q e accettati dall’utente. Questa metrica si applica ai test di unità generati tramite il [comando /test](q-in-IDE-chat.md#unit-tests). |
| TestGeneration\$1EventCount | Numero di volte in cui l’utente ha interagito con Amazon Q tramite il [comando /test.](q-in-IDE-chat.md#unit-tests) |
| TestGeneration\$1GeneratedLines | Righe di codice suggerite da Amazon Q. Questa metrica si applica alle righe di codice generate tramite il [comando /test](q-in-IDE-chat.md#unit-tests). |
| TestGeneration\$1GeneratedTests | Numero di test di unità suggeriti da Amazon Q. Questa metrica si applica ai test di unità generati tramite il [comando /test](q-in-IDE-chat.md#unit-tests). |
| Trasformazione\$1 EventCount | Numero di volte in cui l’utente ha interagito con Amazon Q tramite il [comando /transform](transform-in-IDE.md), escluse le volte in cui l’utente [ha trasformato il codice nella riga di comando](transform-CLI.md). |
| Trasformazione\$1 LinesGenerated | Righe di codice suggerite da Amazon Q. Questa metrica si applica al codice generato tramite il [comando /transform](transform-in-IDE.md), escluso il codice [trasformato nella riga di comando](transform-CLI.md). |
| Trasformazione\$1 LinesIngested | Righe di codice fornite ad Amazon Q per la trasformazione. Questa metrica si applica al codice fornito tramite il [comando /transform](transform-in-IDE.md), escluso il codice fornito per [la trasformazione nella riga di comando](transform-CLI.md) o per una conversione [SQL](transform-sql.md). |
# Logging dei prompt degli utenti in Amazon Q Developer
Gli amministratori possono abilitare registrazione dei log di tutti i [suggerimenti in linea](inline-suggestions.md) e delle [conversazioni in chat](q-in-IDE-chat.md) che gli utenti hanno tenuto con Amazon Q nel loro ambiente di sviluppo integrato (IDE). Questi log possono esse utili per il controllo, il debug, l’analisi e la garanzia della conformità.
Quando gli sviluppatori utilizzano suggerimenti in linea, Amazon Q registrerà i suggerimenti accettati e attivamente rifiutati. Quando gli sviluppatori chattano con Amazon Q, Amazon Q registra sia i prompt degli sviluppatori che le risposte di Amazon Q. Quando gli sviluppatori [chattano con Amazon Q Agent per lo sviluppo software](q-in-IDE-chat.md#develop-code) utilizzando il comando **/dev**, verranno registrati solo i prompt.
Amazon Q archivia i log in un bucket Amazon S3 creato da te, nel seguente percorso:
`bucketName/prefix/AWSLogs/accountId/QDeveloperLogs/log-type/region/year/month/day/utc-hour/zipFile.gz/logFile.json`
Nel percorso precedente, `log-type` è uno dei seguenti:
+ `GenerateAssistantResponse`: contiene i log delle chat
+ `GenerateCompletions`: contiene i log di completamento in linea
+ `StartTaskAssistCodeGeneration`: contiene i log **/dev**
Per esempi e spiegazioni del contenuto dei file di log, consulta [Esempi di log dei prompt in Amazon Q Developer](q-admin-prompt-log-examples.md).
Non sono previsti costi per la funzionalità di registrazione dei log dei prompt oltre al costo di storage del bucket Amazon S3 utilizzato per contenere i log e una piccola tariffa per la chiave KMS opzionale utilizzata per crittografare il bucket.
Utilizza le seguenti istruzioni per abilitare registrazione dei log dei prompt.
**Prerequisiti**
+ Assicurati che gli utenti si siano abbonati a un account autonomo o, se utilizzi [AWS Organizations](https://docs.aws.amazon.com/organizations/latest/userguide/orgs_introduction.html), a un account di gestione. Attualmente, Q Developer non supporta la registrazione dei log dei prompt degli utenti iscritti negli account membri in AWS Organizations.
+ Crea un bucket Amazon S3 per contenere i log dei prompt. Il bucket deve:
+ Sii nella AWS regione in cui è stato installato il profilo Amazon Q Developer. Questo profilo è stato installato quando hai abbonato gli utenti ad Amazon Q Developer Pro per la prima volta. Per ulteriori informazioni su questo profilo e sulle Regioni in cui è supportato, consulta [Cos’è il profilo di Amazon Q Developer?](subscribe-understanding-profile.md) e [Regioni supportate per la console Q Developer e il profilo Q Developer](q-admin-setup-subscribe-regions.md#qdev-console-and-profile-regions).
+ Accedi all' AWS account a cui gli utenti sono abbonati.
+ Adotta una policy di bucket come quella che segue. Sostituisci *bucketName**region*,*accountId*, e *prefix* con le tue informazioni.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "QDeveloperLogsWrite",
"Effect": "Allow",
"Principal": {
"Service": "q.amazonaws.com"
},
"Action": [
"s3:PutObject"
],
"Resource": [
"arn:aws:s3:::bucketName/prefix/*"
],
"Condition": {
"StringEquals": {
"aws:SourceAccount": "111122223333"
},
"ArnLike": {
"aws:SourceArn": "arn:aws:codewhisperer:us-east-1:111122223333:*"
}
}
}
]
}
```
------
Se configuri SSE-KMS sul bucket, aggiungi la seguente policy alla chiave KMS:
```
{
"Effect": "Allow",
"Principal": {
"Service": "q.amazonaws.com"
},
"Action": "kms:GenerateDataKey",
"Resource": "*",
"Condition": {
"StringEquals": {
"aws:SourceAccount": "accountId"
},
"ArnLike": {
"aws:SourceArn": "arn:aws:codewhisperer:region:accountId:*"
}
}
}
```
Per maggiori informazioni sulla protezione dei dati nel tuo bucket Amazon S3, consulta [Protezione dei dati con la crittografia](https://docs.aws.amazon.com/AmazonS3/latest/userguide/UsingEncryption.html) nella *Guida per l’utente di Amazon Simple Storage Service*.
**Per abilitare la registrazione dei log dei prompt**
1. Apri la console Amazon Q Developer.
Per utilizzare la console Amazon Q Developer, è necessario disporre delle autorizzazioni definite in [Consenti agli amministratori di utilizzare la console Amazon Q Developer](id-based-policy-examples-admins.md#q-admin-setup-admin-users).
**Nota**
Devi accedere come amministratore di account autonomo o amministratore dell’account di gestione. Gli amministratori dell’account membro non possono abilitare la registrazione dei log dei prompt perché non è supportata per gli utenti abbonati negli account membri.
1. Seleziona **Impostazioni**.
1. In **Preferenze**, scegli **Modifica**.
1. Nella finestra Modifica preferenze, attiva la **registrazione dei log dei prompt di Q Developer**.
1. In posizione Amazon S3, inserisci l’URI di Amazon S3 che utilizzerai per ricevere i log. Ad esempio: `s3://amzn-s3-demo-bucket/qdev-prompt-logs/`
# Esempi di log dei prompt in Amazon Q Developer
In questa sezione vengono forniti alcuni esempi di log dei prompt generati da Amazon Q Developer.
A ogni esempio segue una tabella che descrive i campi del file di log.
Per ulteriori informazioni sui log dei prompt, consulta [Logging dei prompt degli utenti in Amazon Q Developer](q-admin-prompt-logging.md).
**Topics**
+ [
## Esempio di log dei suggerimenti in linea
](#prompt-log-examples-inline)
+ [
## Esempi di log di chat
](#prompt-log-examples-chat)
+ [
## Esempi di log /dev
](#prompt-log-examples-dev)
## Esempio di log dei suggerimenti in linea
L’esempio seguente mostra un file di log che viene generato quando un utente accetta un suggerimento in linea.
```
{
"records": [
{
"generateCompletionsEventRequest": {
"leftContext": "import * cdk from 'aws-cdk-lib';\r\nimport * s3 from 'aws-cdk-lib/aws-s3';\r\nimport { Stack, StackProps } from 'constructs';\r\nexport class MyStack extends Stack {\r\n constructor(scope: cdk.App, id: string, props?: StackProps) {\r\n super(scope, id, props);\r\n\r\n new s3.Bucket(this, 'XXXXXXXX', {\r\n versioned: true\r\n });\r\n }\r\n ",
"rightContext": "",
"fileName": "cdk-modified.ts",
"customizationArn": null,
"userId": "d-92675051d5.b8f1f340-9081-70ad-5fc5-0f37151937a6",
"timeStamp": "2025-01-06T15:09:16.412719Z"
},
"generateCompletionsEventResponse": {
"completions": ["synth() {\n return cdk.App.prototype.synth.apply(this, arguments);\n }"],
"requestId": "797c70ee-abc9-4cc7-a148-b9df17f6ce48"
}
}
]
}
```
La tabella seguente descrive i campi nel file di log per suggerimenti in linea.
| Nome campo | Description |
| --- | --- |
| `records` | Campo di primo livello che contiene una serie di suggerimenti in linea, noti anche come completamenti in linea. |
| `generateCompletionsEventRequest` | Descrive la richiesta di un suggerimento di codice in linea. La richiesta viene effettuata da Amazon Q, per conto dell’utente. |
| `leftContext` | Indica il codice prima del cursore che Amazon Q utilizza come contesto per generare un suggerimento in linea. |
| `rightContext` | Indica il codice dopo il cursore che Amazon Q utilizza come contesto per generare un suggerimento in linea. |
| `fileName` | Indica il nome del file in cui è stato richiesto un suggerimento in linea. |
| `customizationArn` | Indica il nome della risorsa Amazon (ARN) della personalizzazione applicata ai suggerimenti in linea. In questo esempio, non è prevista alcuna personalizzazione. |
| `userId` | Indica l’ID utente dell’utente che ha richiesto un suggerimento in linea. |
| `timeStamp` | Indica la data e l’ora in cui è stato richiesto il suggerimento in linea. L’ora specificata è espressa in Coordinated Universal Time (UTC). |
| `generateCompletionsEventResponse` | Descrive il suggerimento in linea generato da Amazon Q. |
| `completions` | Indica il suggerimento in linea fornito da Amazon Q e accettato dall’utente. |
| `requestId` | L’ID della richiesta in linea che identifica l’evento in modo univoco. |
## Esempi di log di chat
L’esempio seguente mostra un file di log che viene generato quando un utente chatta utilizzando Amazon Q nel proprio IDE.
```
{
"records": [
{
"generateAssistantResponseEventRequest": {
"prompt": "Can you explain how to set up object-level access control in an S3 bucket using AWS CDK?",
"chatTriggerType": "MANUAL",
"customizationArn": null,
"userId": "d-92675051d5.b8f1f340-9081-70ad-5fc5-0f37151937a6",
"timeStamp": "2025-01-06T15:05:56.313070Z"
},
"generateAssistantResponseEventResponse": {
"assistantResponse": "I'll explain how to set up object-level access control for an S3 bucket using AWS CDK. Here's how you can implement different access control configurations: [[1]](https://docs.aws.amazon.com/AmazonS3/latest/API/s3_example_s3_Scenario_ManageACLs_section.html)\n\n1. Using Bucket Owner Enforced (Recommended Modern Approach):\n```typescript\nimport * as cdk from 'aws-cdk-lib';\nimport * as s3 from 'aws-cdk-lib/aws-s3';\n\nnew s3.Bucket(this, 'XXXXXXXX', {\n objectOwnership: s3.ObjectOwnership.BUCKET_OWNER_ENFORCED,\n blockPublicAccess: s3.BlockPublicAccess.BLOCK_ALL\n});\n```\n\n2. Using Public Access Block Configuration:\n```typescript\nimport * as cdk from 'aws-cdk-lib';\nimport * as s3 from 'aws-cdk-lib/aws-s3';\n\nnew s3.Bucket(this, 'XXXXXXXX', {\n blockPublicAccess: new s3.BlockPublicAccess({\n blockPublicAcls: true,\n blockPublicPolicy: true,\n ignorePublicAcls: true,\n restrictPublicBuckets: true\n })\n});\n```\n\n3. Setting Access Control for Specific Use Cases:\n```typescript\nimport * as cdk from 'aws-cdk-lib';\nimport * as s3 from 'aws-cdk-lib/aws-s3';\nimport * as iam from 'aws-cdk-lib/aws-iam';\n\nconst bucket = new s3.Bucket(this, 'XXXXXXXX', {\n // Enable versioning for object-level recovery\n versioned: true,\n \n // Enforce encryption\n encryption: s3.BucketEncryption.S3_MANAGED,\n \n // Block all public access\n blockPublicAccess: s3.BlockPublicAccess.BLOCK_ALL,\n \n // Enforce object ownership\n objectOwnership: s3.ObjectOwnership.BUCKET_OWNER_ENFORCED,\n \n // Enable server access logs\n serverAccessLogsPrefix: 'logs/'\n});\n\n// Grant read access to specific IAM role\nconst role = new iam.Role(this, 'MyRole', {\n assumedBy: new iam.ServicePrincipal('lambda.amazonaws.com'),\n});\nbucket.grantRead(role);\n\n// Grant write access to specific objects with prefix\nbucket.addToResourcePolicy(new iam.PolicyStatement({\n actions: ['s3:PutObject'],\n resources: [bucket.arnForObjects('uploads/*')],\n principals: [new iam.AccountRootPrincipal()]\n}));\n```\n\n4. Setting up Lifecycle Rules for Objects:\n```typescript\nimport * as cdk from 'aws-cdk-lib';\nimport * as s3 from 'aws-cdk-lib/aws-s3';\n\nnew s3.Bucket(this, 'XXXXXXXX', {\n lifecycle: [\n {\n transitions: [\n {\n storageClass: s3.StorageClass.INFREQUENT_ACCESS,\n transitionAfter: cdk.Duration.days(30)\n },\n {\n storageClass: s3.StorageClass.GLACIER,\n transitionAfter: cdk.Duration.days(90)\n }\n ],\n expiration: cdk.Duration.days(365)\n }\n ]\n});\n```\n\nKey points to remember:\n- Always use the principle of least privilege\n- Block public access by default unless explicitly required\n- Use BUCKET_OWNER_ENFORCED for object ownership when possible\n- Consider implementing lifecycle rules for cost optimization\n- Use versioning for sensitive data\n- Implement server-side encryption\n- Use resource policies and IAM roles for access control instead of ACLs\n- Monitor access patterns using server access logging\n\nThese configurations help create a secure and well-managed S3 bucket with appropriate access controls at both bucket and object levels.",
"followupPrompts": "How can you implement multi-factor authentication for S3 bucket access using AWS CDK?What are the best practices for setting up object-level versioning in AWS S3 using CDK?How can you use AWS CDK to create a custom error message for unauthorized access attempts on an S3 bucket?",
"messageMetadata": {
"conversationId": "491bd3cd-d70d-40c0-a452-5ef3f0878422",
"utteranceId": null
},
"codeReferenceEvents": [],
"supplementaryWebLinksEvent": [
{
"uri": "https://docs.aws.amazon.com/AmazonS3/latest/API/s3_example_s3_Scenario_ManageACLs_section.html",
"title": "[1] Manage access control lists (ACLs) for Amazon S3 buckets using an AWS SDK - Amazon Simple Storage Service",
"snippet": "The following code example shows how to manage access control lists (ACLs) for Amazon S3 buckets.\n\n.NET\n\n**AWS SDK for .NET**\n\n```\n using System;\n using System.Collections.Generic;\n using System.Threading.Tasks;\n using Amazon.S3;\n using Amazon.S3.Model;\n\n /// \n /// This example shows how to manage Amazon Simple Storage Service\n /// (Amazon S3) access control lists (ACLs) to control Amazon S3 bucket\n /// access.\n /// \n public class ManageACLs\n {\n public static async Task Main()\n {\n string bucketName = \"amzn-s3-demo-bucket1\";\n string newBucketName = \"amzn-s3-demo-bucket2\";\n string keyName = \"sample-object.txt\";\n string emailAddress = \"someone@example.com\";\n\n // If the AWS Region where your bucket is located is different from\n // the Region defined for the default user, pass the Amazon S3 bucket's\n // name to the client constructor. It should look like this:\n // RegionEndpoint bucketRegion = RegionEndpoint.USEast1;\n IAmazonS3 client = new AmazonS3Client();\n\n await TestBucketObjectACLsAsync(client, bucketName, newBucketName, keyName, emailAddress);\n }\n\n /// \n /// Creates a new Amazon S3 bucket with a canned ACL, then retrieves the ACL\n /// information and then adds a new ACL to one of the objects in the\n /// Amazon S3 bucket.\n /// \n /// The initialized Amazon S3 client object used to call\n /// methods to create a bucket, get an ACL, and add a different ACL to\n /// one of the objects.\n /// A string representing the original Amazon S3\n /// bucket name.\n /// A string representing the name of the\n /// new bucket that will be created.\n /// A string representing the key name of an Amazon S3\n /// object for which we will change the ACL.\n /// A string representing the email address\n /// belonging to the person to whom access to the Amazon S3 bucket will be\n /// granted.\n public static async Task TestBucketObjectACLsAsync(\n IAmazonS3 client,\n string bucketName,\n string newBucketName,\n string keyName,\n string emailAddress)\n {\n try\n {\n // Create a new Amazon S3 bucket and specify canned ACL.\n var success = await CreateBucketWithCannedACLAsync(client, newBucketName);\n\n // Get the ACL on a bucket.\n await GetBucketACLAsync(client, bucketName);\n\n // Add (replace) the ACL on an object in a bucket.\n await AddACLToExistingObjectAsync(client, bucketName, keyName, emailAddress);\n }\n catch (AmazonS3Exception amazonS3Exception)\n {\n Console.WriteLine($\"Exception: {amazonS3Exception.Message}\");\n }\n }\n\n /// \n /// Creates a new Amazon S3 bucket with a canned ACL attached.\n /// \n /// The initialized client object used to call\n /// PutBucketAsync.\n /// A string representing the name of the\n /// new Amazon S3 bucket.\n /// Returns a boolean value indicating success or failure.\n public static async Task CreateBucketWithCannedACLAsync(IAmazonS3 client, string newBucketName)\n {\n var request = new PutBucketRequest()\n {\n BucketName = newBucketName,\n BucketRegion = S3Region.EUWest1,\n\n // Add a canned ACL.\n CannedACL = S3CannedACL.LogDeliveryWrite,\n };\n\n var response = await client.PutBucketAsync(request);\n return response.HttpStatusCode == System.Net.HttpStatusCode.OK;\n }\n\n\n /// \n /// Retrieves the ACL associated with the Amazon S3 bucket name in the\n /// bucketName parameter.\n /// \n /// The initialized client object used to call\n /// PutBucketAsync.\n /// The Amazon S3 bucket for which we want to get the\n /// ACL list.\n /// Returns an S3AccessControlList returned from the call to\n /// GetACLAsync.\n public static async Task GetBucketACLAsync(IAmazonS3 client, string bucketName)\n {\n GetACLResponse response = await client.GetACLAsync(new GetACLRequest\n {\n BucketName = bucketName,\n });\n\n return response.AccessControlList;\n }\n\n\n\n /// \n /// Adds a new ACL to an existing object in the Amazon S3 bucket.\n /// \n /// The initialized client object used to call\n /// PutBucketAsync.\n /// A string representing the name of the Amazon S3\n /// bucket containing the object to which we want to apply a new ACL.\n /// A string representing the name of the object\n /// to which we want to apply the new ACL.\n /// The email address of the person to whom\n /// we will be applying to whom access will be granted.\n public static async Task AddACLToExistingObjectAsync(IAmazonS3 client, string bucketName, string keyName, string emailAddress)\n {\n // Retrieve the ACL for an object.\n GetACLResponse aclResponse = await client.GetACLAsync(new GetACLRequest\n {\n BucketName = bucketName,\n Key = keyName,\n });\n\n S3AccessControlList acl = aclResponse.AccessControlList;\n\n // Retrieve the owner.\n Owner owner = acl.Owner;\n\n // Clear existing grants.\n acl.Grants.Clear();\n\n // Add a grant to reset the owner's full permission\n // (the previous clear statement removed all permissions).\n var fullControlGrant = new S3Grant\n {\n Grantee = new S3Grantee { CanonicalUser = acl.Owner.Id },\n };\n acl.AddGrant(fullControlGrant.Grantee, S3Permission.FULL_CONTROL);\n\n // Specify email to identify grantee for granting permissions.\n var grantUsingEmail = new S3Grant\n {\n Grantee = new S3Grantee { EmailAddress = emailAddress },\n Permission = S3Permission.WRITE_ACP,\n };\n\n // Specify log delivery group as grantee.\n var grantLogDeliveryGroup = new S3Grant\n {\n Grantee = new S3Grantee { URI = \"http://acs.amazonaws.com/groups/s3/LogDelivery\" },\n Permission = S3Permission.WRITE,\n };\n\n // Create a new ACL.\n var newAcl = new S3AccessControlList\n {\n Grants = new List { grantUsingEmail, grantLogDeliveryGroup },\n Owner = owner,\n };\n\n // Set the new ACL. We're throwing away the response here.\n _ = await client.PutACLAsync(new PutACLRequest\n {\n BucketName = bucketName,\n Key = keyName,\n AccessControlList = newAcl,\n });\n }\n\n }\n\n\n```\n\n* For API details, see the following topics in _AWS SDK for .NET API Reference_.\n \n * GetBucketAcl\n\n* GetObjectAcl\n\n* PutBucketAcl\n\n* PutObjectAcl\n\nFor a complete list of AWS SDK developer guides and code examples, see Developing with Amazon S3 using the AWS SDKs. This topic also includes information about getting started and details about previous SDK versions.\n"
}
],
"requestId": "dad38fc0-815c-45f7-970a-db916cb7f131"
}
}
]
}
```
| Nome campo | Description |
| --- | --- |
| `records` | Campo di primo livello che contiene una serie di prompt e risposte. |
| `generateAssistantResponseEventRequest` | Descrive il prompt inserito dall’utente nella finestra di chat del proprio IDE. |
| `prompt` | Indica il prompt inserito dall’utente nella finestra di chat. |
| `chatTriggerType` | `MANUAL` indica che l’utente ha inserito un prompt nella finestra di chat o ha fatto clic su una delle domande suggerite nella finestra di chat. `INLINE_CHAT` indica che l’utente ha inserito un prompt nella piccola schermata di input nella finestra di codifica principale. Per ulteriori informazioni sulla chat in linea, consulta [Chattare in linea con Amazon Q Developer](q-in-IDE-inline-chat.md). |
| `customizationArn` | Indica il nome della risorsa Amazon (ARN) della personalizzazione applicata alla chat. In questo esempio, non è prevista alcuna personalizzazione. In |
| `userId` | Indica l’ID utente dell’utente che ha inserito il prompt. |
| `timeStamp` | Indica la data e l’ora in cui l’utente ha inserito il prompt. Il timestamp è espresso nell’ora UTC. |
| `generateAssistantResponseEventResponse` | Descrive la risposta generata da Amazon Q. |
| `assistantResponse` | Indica la risposta che Amazon Q ha fornito al prompt dell’utente. |
| `followupPrompts` | Indica i prompt di esempio successivi che sono stati visualizzati all’utente al termine della risposta. |
| `messageMetadata` | Descrive i metadati associati alla risposta. |
| `conversationId` | Indica l’ID della conversazione della risposta. L’ID di conversazione raggruppa i messaggi in una sessione di chat. |
| `utteranceId` | Indica l’ID dell’enunciazione della risposta. Un ID di enunciazione è un’etichetta che distingue un prompt da un altro all’interno di un dialogo o di un set di dati. |
| `codeReferenceEvents` | Descrive i link ai riferimenti di codice inclusi nella risposta. |
| `supplementaryWebLinksEvent` | Indica i link visualizzati all’utente al termine della risposta. |
| `requestId` | L’ID della risposta che identifica in modo univoco l’evento. |
## Esempi di log /dev
L’esempio seguente mostra un file di log generato con un utente che immette un comando **/dev** nella chat di Amazon Q nel proprio IDE.
```
{
"records": [
{
"startTaskAssistCodeGenerationEventRequest": {
"prompt": "write a python application that prints 'hello world!' text to the screen and format it in red bold text",
"chatTriggerType": "MANUAL",
"conversationId": "da1c95b6-84e1-46a2-9ef9-fe92f5ee169e",
"customizationArn": null,
"userId": "d-92675051d5.b8f1f340-9081-70ad-5fc5-0f37151937a6",
"timeStamp": "2025-01-13T15:40:27.808027101Z"
},
"startTaskAssistCodeGenerationEventResponse": {
"requestId": "e504f126-7197-4e3c-a046-1a10d5a3f3e0"
}
}
]
}
```
| Nome campo | Description |
| --- | --- |
| `records` | Campo di primo livello che contiene una serie di prompt e risposte. |
| `startTaskAssistCodeGenerationEventRequest` | Descrive il prompt **/dev** inserito dall’utente nella finestra di chat del proprio IDE. |
| `prompt` | Indica il prompt **/dev** inserito dall’utente nella finestra di chat. |
| `chatTriggerType` | `MANUAL` indica che l’utente ha inserito un prompt nella finestra di chat o ha fatto clic su una delle domande suggerite nella finestra di chat. `INLINE_CHAT` indica che l’utente ha inserito un prompt nella piccola schermata di input nella finestra di codifica principale. Per ulteriori informazioni sulla chat in linea, consulta [Chattare in linea con Amazon Q Developer](q-in-IDE-inline-chat.md). |
| `conversationId` | Indica l’ID della conversazione della risposta. L’ID di conversazione raggruppa i messaggi in una sessione di chat. |
| `customizationArn` | Indica il nome della risorsa Amazon (ARN) della personalizzazione applicata alla chat. In questo esempio, non è prevista alcuna personalizzazione. In |
| `userId` | Indica l’ID utente dell’utente che ha inserito il prompt. |
| `timeStamp` | Indica la data e l’ora in cui l’utente ha inserito il prompt. Il timestamp è espresso nell’ora UTC. |
| `startTaskAssistCodeGenerationEventResponse` | Descrive la risposta generata da Amazon Q. Attualmente, la registrazione delle risposte ai comandi **/dev** non è supportata, quindi il campo non includerà una risposta. |
| `assistantResponse` | Indica la risposta che Amazon Q ha fornito al prompt dell’utente. |
| `requestId` | L’ID della risposta che identifica in modo univoco l’evento. |