.*?)/ | stats avg(latency2) by @method2,
@user2
```
**Extrait les champs `loggingTime`, `loggingType` et `loggingMessage`, filtre vers le bas pour journaliser les événements qui contiennent les chaînes `ERROR` ou `INFO`, puis affiche uniquement les champs `loggingMessage` et `loggingType` pour les événements qui contiennent une chaîne `ERROR`.**
```
FIELDS @message
| PARSE @message "* [*] *" as loggingTime, loggingType, loggingMessage
| FILTER loggingType IN ["ERROR", "INFO"]
| DISPLAY loggingMessage, loggingType = "ERROR" as isError
```
# sort
Utilisez la commande `sort` pour afficher les événements du journal dans l'ordre croissant (`asc`) ou décroissant (`desc`) en fonction d'un champ spécifié. Vous pouvez l'utiliser avec la commande `limit` pour créer des requêtes de type « N premiers » ou « N derniers ».
L'algorithme de tri est une version actualisée du tri naturel. Si vous triez par ordre croissant, la logique suivante est utilisée.
+ Toutes les valeurs non numériques précèdent toutes les valeurs numériques. Les *valeurs numériques* sont des valeurs qui incluent uniquement des chiffres, et non un mélange de chiffres et d'autres caractères.
+ Pour les valeurs non numériques, l'algorithme regroupe les caractères numériques consécutifs et les caractères alphabétiques consécutifs dans des segments distincts à des fins de comparaison. Il classe les parties non numériques en fonction de leurs valeurs Unicode, et les parties numériques en fonction de leur longueur, puis en fonction de leur valeur numérique.
Pour plus d'informations sur l'ordre Unicode, voir [Liste des caractères Unicode](https://en.wikipedia.org/wiki/List_of_Unicode_characters).
Par exemple, ce qui suit est le résultat d'un tri par ordre croissant.
```
!: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> sorted by unicode order
#
*%04
0# >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Alphanumeric starting with numbers
5A
111A >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Starts with more digits than 5A, so it sorted to be later than 5A
2345_
@ >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 2345 is compared with @ in the unicode order,
@_
A >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Values starting with letters
A9876fghj
a12345hfh
0 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Number values
01
1
2
3
```
Si vous triez par ordre décroissant, les résultats du tri sont inverses.
Par exemple, la requête suivante pour les journaux de flux Amazon VPC permet de trouver les 15 premiers transferts de paquets entre les hôtes.
```
stats sum(packets) as packetsTransferred by srcAddr, dstAddr
| sort packetsTransferred desc
| limit 15
```
# stats
Utilisez `stats` pour créer des visualisations les données de vos journaux, telles que des diagrammes à barres, des graphiques linéaires et des diagrammes à aires empilées. Cela vous permet d'identifier plus efficacement les modèles dans vos données de journal. CloudWatch Logs Insights génère des visualisations pour les requêtes qui utilisent la `stats` fonction et une ou plusieurs fonctions d'agrégation.
Par exemple, la requête suivante dans un groupe de journaux Route 53 renvoie des visualisations présentant la distribution des enregistrements Route 53 par heure, par type de requête.
```
stats count(*) by queryType, bin(1h)
```
Toutes ces requêtes peuvent produire des graphiques à barres. En outre, si votre requête utilise la fonction `bin()` pour regrouper les données en fonction d'un seul champ au fil du temps, vous pouvez également voir des graphiques linéaires et des graphiques en aires empilées.
les unités de temps et les abréviations suivantes sont prises en charge par la fonction `bin`. Pour toutes les unités et abréviations qui incluent plus d'un caractère, l'ajout de s au pluriel est pris en charge. Donc, les deux `hr` et `hrs` travaillent pour spécifier les heures.
+ `millisecond` `ms` `msec`
+ `second` `s` `sec`
+ `minute` `m` `min`
+ `hour` `h` `hr`
+ `day` `d`
+ `week` `w`
+ `month` `mo` `mon`
+ `quarter` `q` `qtr`
+ `year` `y` `yr`
**Topics**
+ [Visualisation des données de séries temporelles](#CWL_Insights-Visualizing-TimeSeries)
+ [Visualisation des données de journal regroupées par champs](#CWL_Insights-Visualizing-ByFields)
+ [Utiliser plusieurs commandes stats dans une seule requête](#CWL_QuerySyntax-stats-multi)
+ [Fonctions à utiliser avec stats](#CWL_QuerySyntax-stats-functions)
## Visualisation des données de séries temporelles
Les visualisations chronologiques fonctionnent pour les requêtes présentant les caractéristiques suivantes :
+ La requête contient une ou plusieurs fonctions d'agrégation. Pour plus d'informations, consultez [Aggregation Functions in the Stats Command](#CWL_Insights_Aggregation_Functions).
+ La requête utilise la fonction `bin()` pour regrouper les données en un champ.
Ces requêtes peuvent produire des graphiques linéaires, des graphiques en aires empilées et des graphiques à barres et des graphiques circulaires.
**Exemples**
Pour un didacticiel complet, consultez [Didacticiel : Exécuter une requête qui produit des séries temporelles](CWL_AnalyzeLogData_VisualizationQuery.md).
Voici d'autres exemples de requêtes qui fonctionnent pour la visualisation chronologiques.
La requête suivante génère une visualisation des valeurs moyennes du champ `myfield1`, avec un point de données créé toutes les cinq minutes. Chaque point de données correspond à l'agrégation des moyennes des valeurs `myfield1` des journaux des cinq minutes précédentes.
```
stats avg(myfield1) by bin(5m)
```
La requête suivante génère une visualisation des trois valeurs basées sur différents champs, avec un point de données créé toutes les cinq minutes. La visualisation est générée, car la requête contient des fonctions d'agrégation et utilise `bin()` comme champ de regroupement.
```
stats avg(myfield1), min(myfield2), max(myfield3) by bin(5m)
```
**Restrictions pour les graphiques linéaires et les graphiques en aires empilées**
Les requêtes qui regroupent les informations d'entrée de journal sans utiliser la fonction `bin()` peuvent générer des graphiques à barres. Toutefois, les requêtes ne peuvent pas générer de graphique linéaire ou de graphique en aires empilées. Pour plus d'informations sur ces types de requête, consultez [Visualisation des données de journal regroupées par champs](#CWL_Insights-Visualizing-ByFields).
## Visualisation des données de journal regroupées par champs
Vous pouvez produire des graphiques à barres pour les requêtes qui utilisent la fonction `stats` et une ou plusieurs fonctions d'agrégation. Pour plus d'informations, consultez [Aggregation Functions in the Stats Command](#CWL_Insights_Aggregation_Functions).
Pour afficher la visualisation, exécutez votre requête. Choisissez ensuite l'onglet **Visualization (Visualisation)**, sélectionnez la flèche en regard de **Line (Ligne)**, puis choisissez **Bar (Barre)**. Les visualisations sont limitées à 100 barres dans le graphique à barres.
**Exemples**
Pour un didacticiel complet, consultez [Didacticiel : Exécuter une requête qui génère une visualisation groupée par champs de journal](CWL_AnalyzeLogData_VisualizationFieldQuery.md). Les paragraphes suivants incluent d'autres exemples de requête pour la visualisation par champs.
La requête de journal de flux VPC suivante recherche le nombre moyen d'octets transférés par session pour chaque adresse de destination.
```
stats avg(bytes) by dstAddr
```
Vous pouvez également produire un graphique qui comprend plus d'une barre pour chaque valeur résultante. Par exemple, la requête de journal de flux VPC suivante recherche le nombre moyen et le nombre maximal d'octets transférés par session pour chaque adresse de destination.
```
stats avg(bytes), max(bytes) by dstAddr
```
La requête suivante recherche le nombre de journaux de requêtes Amazon Route 53 pour chaque type de requête.
```
stats count(*) by queryType
```
## Utiliser plusieurs commandes stats dans une seule requête
Vous pouvez utiliser jusqu'à deux commandes `stats` dans une seule requête. Cela vous permet d'effectuer une agrégation supplémentaire sur la sortie de la première agrégation.
**Exemple : requête avec deux commandes `stats`**
Par exemple, la requête suivante trouve d'abord le volume de trafic total par tranches de 5 minutes, puis calcule le volume de trafic le plus élevé, le plus bas et le volume de trafic moyen parmi ces tranches de 5 minutes.
```
FIELDS strlen(@message) AS message_length
| STATS sum(message_length)/1024/1024 as logs_mb BY bin(5m)
| STATS max(logs_mb) AS peak_ingest_mb,
min(logs_mb) AS min_ingest_mb,
avg(logs_mb) AS avg_ingest_mb
```
**Exemple : combiner plusieurs commandes stats avec d'autres fonctions telles que `filter`, `fields`, `bin`**
Vous pouvez combiner deux commandes `stats` avec d'autres commandes, telles que `filter` et `fields` dans une seule requête. Par exemple, la requête suivante trouve le nombre d'adresses IP distinctes dans les sessions et le nombre de sessions par plateforme client, filtre ces adresses IP et enfin trouve la moyenne des demandes de session par plateforme client.
```
STATS count_distinct(client_ip) AS session_ips,
count(*) AS requests BY session_id, client_platform
| FILTER session_ips > 1
| STATS count(*) AS multiple_ip_sessions,
sum(requests) / count(*) AS avg_session_requests BY client_platform
```
Vous pouvez utiliser les fonctions `bin` et `dateceil` dans des requêtes comportant plusieurs commandes `stats`. Par exemple, la requête suivante combine d'abord les messages en blocs de 5 minutes, puis agrège ces blocs de 5 minutes en blocs de 10 minutes et calcule les volumes de trafic les plus élevés, les plus bas et la moyenne dans chaque bloc de 10 minutes.
```
FIELDS strlen(@message) AS message_length
| STATS sum(message_length) / 1024 / 1024 AS logs_mb BY BIN(5m) as @t
| STATS max(logs_mb) AS peak_ingest_mb,
min(logs_mb) AS min_ingest_mb,
avg(logs_mb) AS avg_ingest_mb BY dateceil(@t, 10m)
```
**Remarques et limitations**
Une requête peut avoir un maximum de deux commandes `stats`. Ce quota ne peut pas être modifié.
Si vous utilisez une commande `sort` ou `limit`, elle doit apparaître après la deuxième commande `stats`. Si elle est antérieure à la deuxième commande `stats`, la requête n'est pas valide.
Lorsqu'une requête comporte deux commandes `stats`, les résultats partiels de la requête ne commencent pas à s'afficher tant que la première agrégation `stats` n'est pas terminée.
Dans la deuxième commande `stats` d'une seule requête, vous ne pouvez faire référence qu'aux champs définis dans la première commande `stats`. Par exemple, la requête suivante n'est pas valide, car le champ `@message` ne sera plus disponible après la première agrégation `stats`.
```
FIELDS @message
| STATS SUM(Fault) by Operation
# You can only reference `SUM(Fault)` or Operation at this point
| STATS MAX(strlen(@message)) AS MaxMessageSize # Invalid reference to @message
```
Tous les champs auxquels vous faites référence après la première commande `stats` doivent être définis dans cette première commande `stats`.
```
STATS sum(x) as sum_x by y, z
| STATS max(sum_x) as max_x by z
# You can only reference `max(sum_x)`, max_x or z at this point
```
**Important**
La fonction `bin` utilise toujours implicitement le champ `@timestamp`. Cela signifie que vous ne pouvez pas utiliser `bin` dans la deuxième commande `stats` sans utiliser la première commande `stats` pour propager le champ `timestamp`. Par exemple, la requête suivante n'est pas valide.
```
FIELDS strlen(@message) AS message_length
| STATS sum(message_length) AS ingested_bytes BY @logStream
| STATS avg(ingested_bytes) BY bin(5m) # Invalid reference to @timestamp field
```
Définissez plutôt le champ `@timestamp` dans la première commande `stats`, puis utilisez-le avec `dateceil` dans la deuxième commande `stats`, comme dans l'exemple suivant.
```
FIELDS strlen(@message) AS message_length
| STATS sum(message_length) AS ingested_bytes, max(@timestamp) as @t BY @logStream
| STATS avg(ingested_bytes) BY dateceil(@t, 5m)
```
## Fonctions à utiliser avec stats
CloudWatch Logs Insights prend en charge à la fois les fonctions d'agrégation des statistiques et les fonctions de non-agrégation des statistiques.
Utilisez des fonctions statistiques d'agrégation dans la commande `stats` et en tant qu'arguments pour d'autres fonctions.
| Fonction | Type de résultat | Description |
| --- | --- | --- |
| `avg(fieldName: NumericLogField)` | nombre | Moyenne des valeurs dans le champ spécifié. |
| `count()` `count(fieldName: LogField)` | number | Compte les événements du journal. `count()`(ou `count(*)`) compte tous les événements renvoyés par la requête, tandis que `count(fieldName)` compte tous les enregistrements qui incluent le nom du champ spécifié. |
| `count_distinct(fieldName: LogField)` | number | Renvoie le nombre de valeurs uniques pour le champ. Si le champ a une cardinalité très élevée (contient de nombreuses valeurs uniques), la valeur renvoyée par `count_distinct` n'est qu'une approximation. |
| `max(fieldName: LogField)` | LogFieldValue | Valeur maximale des valeurs pour ce journal dans le champ interrogé. |
| `min(fieldName: LogField)` | LogFieldValue | Valeur minimale des valeurs pour ce journal dans le champ interrogé. |
| `pct(fieldName: LogFieldValue, percent: number)` | LogFieldValue | Un centile indique la position relative d'une valeur dans un ensemble de données. Par exemple, `pct(@duration, 95)` renvoie la valeur `@duration` à laquelle 95 % des valeurs de `@duration` sont inférieures à cette valeur et 5 % des valeurs lui sont supérieures. |
| `stddev(fieldName: NumericLogField)` | number | Déviation standard des valeurs dans le champ spécifié. |
| `sum(fieldName: NumericLogField)` | number | Somme des valeurs dans le champ spécifié. |
**Fonctions statiques de non-agrégation**
Utilisez des fonctions de non-agrégation dans la commande `stats` et en tant qu'arguments d'autres fonctions.
| Fonction | Type de résultat | Description |
| --- | --- | --- |
| `earliest(fieldName: LogField)` | LogField | Renvoie la valeur de `fieldName` à partir de l'événement de journal qui a l'horodatage le plus récent dans les journaux interrogés. |
| `latest(fieldName: LogField)` | LogField | Renvoie la valeur de `fieldName` à partir de l'événement de journal qui a l'horodatage le plus ancien dans les journaux interrogés. |
| `sortsFirst(fieldName: LogField)` | LogField | Renvoie la valeur de `fieldName` triée la première dans les journaux interrogés. |
| `sortsLast(fieldName: LogField)` | LogField | Renvoie la valeur de `fieldName` triée la dernière dans les journaux interrogés. |
# limite
Utilisez la commande `limit` pour spécifier le nombre d'événements du journal que vous voulez que votre requête retourne. Si vous omettez`limit`, la requête renverra jusqu'à 10 000 événements de journal dans les résultats.
Par exemple, l'exemple suivant renvoie uniquement les 25 derniers événements du journal
```
fields @timestamp, @message | sort @timestamp desc | limit 25
```
# dedup
Utilisez `dedup` pour supprimer les résultats dupliqués en fonction de valeurs spécifiques dans les champs que vous indiquez. Vous pouvez l'utiliser `dedup` avec un ou plusieurs champs. Si vous spécifiez un champ avec `dedup`, un seul événement du journal est renvoyé pour chaque valeur unique de ce champ. Si vous spécifiez plusieurs champs, un événement du journal est renvoyé pour chaque combinaison unique de valeurs pour ces champs.
Les doublons sont supprimés en fonction de l'ordre de tri, seul le premier résultat selon l'ordre de tri étant conservé. Nous vous recommandons de trier vos résultats avant de les soumettre à la commande `dedup`. Si les résultats ne sont pas triés avant d'être soumis à `dedup`, l'ordre de tri décroissant par défaut utilisant `@timestamp` est appliqué.
Les valeurs nulles ne sont pas considérées comme des doublons pour l'évaluation. Les événements du journal dont les valeurs sont nulles pour l'un des champs spécifiés sont conservés. Pour éliminer les champs contenant des valeurs nulles, utilisez **`filter`** en appliquant la fonction `isPresent(field)`.
La seule commande de requête que vous pouvez utiliser dans une requête après la commande `dedup` est `limit`.
Lorsque vous l'utilisez `dedup` dans une requête, la console affiche un message tel que **Afficher X des Y enregistrements**, où X représente le nombre de résultats dédupliqués et Y le nombre total d'enregistrements mis en correspondance avant la déduplication. Cela indique que les doublons ont été supprimés et ne signifie pas que des données sont manquantes.
**Exemple : n'afficher que l'événement du journal le plus récent pour chaque valeur unique du champ nommé `server`**
L'exemple suivant affiche les champs `timestamp`, `server`, `severity`, et `message` correspondant uniquement à l'événement le plus récent pour chaque valeur unique de `server`.
```
fields @timestamp, server, severity, message
| sort @timestamp desc
| dedup server
```
Pour d'autres exemples de requêtes CloudWatch Logs Insights, consultez[Requêtes générales](CWL_QuerySyntax-examples.md#CWL_QuerySyntax-examples-general).
# unmask
Utilisez la commande `unmask` pour afficher tout le contenu d'un événement du journal dont certains contenus ont été masqués en raison d'une politique de protection des données. Pour exécuter cette commande, vous devez disposer de l'autorisation `logs:Unmask`.
Pour plus d'informations sur la protection des données dans les groupes de journaux, consultez [Aider à protéger les données sensibles des journaux grâce au masquage](mask-sensitive-log-data.md) (français non garanti).
# unnest
`unnest`À utiliser pour aplatir une liste prise en entrée afin de produire plusieurs enregistrements avec un seul enregistrement pour chaque élément de la liste. En fonction du nombre d'éléments contenus dans un champ, cette commande supprime l'enregistrement actuel et génère de nouveaux enregistrements. Chaque enregistrement inclut le`unnested_field`, qui représente un élément. Tous les autres champs proviennent de l'enregistrement d'origine.
L'entrée pour `unnest` `LIST` is provient de la `jsonParse` fonction. Pour plus d'informations, consultez [la section Types de structures](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/CWL_QuerySyntax-operations-functions.html#CWL_QuerySyntax-structure-types). Tous les autres types, tels que `MAP``numbers`, `String` et, sont traités comme une liste contenant un élément`unnest`.
**Structure de commande**
L'exemple suivant décrit le format de cette commande.
```
unnest field into unnested_field
```
**Exemple de requête**
L'exemple suivant analyse une chaîne d'objet JSON et développe une liste d'événements de champ.
```
fields jsonParse(@message) as json_message
| unnest json_message.events into event
| display event.name
```
L'événement de journal pour cet exemple de requête peut être une chaîne JSON comme suit :
```
{
"events": [
{
"name": "exception"
},
{
"name": "user action"
}
]
}
```
Dans ce cas, l'exemple de requête produit deux enregistrements dans le résultat de la requête, l'un avec « `event.name` as » `exception` et l'autre avec « `event.name` as **user action** »
**Exemple de requête**
L'exemple suivant aplatit une liste, puis filtre les éléments.
```
fields jsonParse(@message) as js
| unnest js.accounts into account
| filter account.type = "internal"
```
**Exemple de requête**
L'exemple suivant aplatit une liste à des fins d'agrégation.
```
fields jsonParse(trimmedData) as accounts
| unnest accounts into account
| stats sum(account.droppedSpans) as n by account.accountId
| sort n desc
| limit 10
```
# chercher
`lookup`À utiliser pour enrichir les résultats de votre requête avec des données de référence issues d'une table de recherche. Une table de recherche contient des données CSV que vous chargez sur Amazon CloudWatch Logs. Lorsqu'une requête est exécutée, la `lookup` commande fait correspondre un champ de votre journal des événements à un champ de la table de recherche et ajoute les champs de sortie spécifiés aux résultats.
Utilisez les tables de recherche pour les scénarios d'enrichissement des données, tels que le mappage des informations utilisateur IDs à utilisateur, les codes de produit aux informations sur le produit ou les codes d'erreur aux descriptions d'erreurs.
## Création et gestion de tables de recherche
Avant de pouvoir utiliser la `lookup` commande dans une requête, vous devez créer une table de recherche. Vous pouvez créer et gérer des tables de recherche depuis la CloudWatch console ou à l'aide de l'API Amazon CloudWatch Logs.
**Pour créer une table de recherche (console)**
1. Ouvrez la CloudWatch console à l'adresse [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/).
1. Dans le volet de navigation, choisissez **Paramètres**, puis l'onglet **Journaux**.
1. Accédez aux **tables de recherche**, puis sélectionnez **Gérer**.
1. Choisissez **Créer une table de recherche**.
1. Entrez un nom pour la table de recherche. Le nom ne peut contenir que des caractères alphanumériques, des traits d'union et des traits de soulignement.
1. (Facultatif) Entrez une description.
1. Téléchargez un fichier CSV. Le fichier doit inclure une ligne d'en-tête avec les noms de colonnes, utiliser le codage UTF-8 et ne pas dépasser 10 Mo.
1. (Facultatif) Spécifiez une AWS KMS clé pour chiffrer les données de la table.
1. Choisissez **Créer**.
Après avoir créé une table de recherche, vous pouvez l'afficher dans l'éditeur de requêtes CloudWatch Logs Insights. Cliquez sur l'onglet **Tables de recherche** pour parcourir les tables disponibles et leurs champs.
Pour mettre à jour une table de recherche, sélectionnez-la et choisissez **Actions**, **Mettre à jour**. Téléchargez un nouveau fichier CSV pour remplacer tout le contenu existant. Pour supprimer une table de recherche, choisissez **Actions**, **Supprimer**.
**Note**
Vous pouvez créer jusqu'à 100 tables de recherche par compte et par compte Région AWS. Les fichiers CSV peuvent peser jusqu'à 10 Mo. Vous pouvez également gérer les tables de recherche à l'aide de l'API Amazon CloudWatch Logs. Pour plus d'informations, consultez [CreateLookupTable](https://docs.aws.amazon.com/AmazonCloudWatchLogs/latest/APIReference/API_CreateLookupTable.html)le manuel *Amazon CloudWatch Logs API Reference*.
**Note**
Si la table de recherche est chiffrée à l'aide d'une clé KMS, l'appelant doit avoir l'`kms:Decrypt`autorisation sur la clé (la clé KMS utilisée pour chiffrer la table de recherche) d'utiliser l'`StartQuery`API avec une requête faisant référence à cette table de recherche. Pour de plus amples informations, veuillez consulter [Chiffrez les tables de recherche dans les CloudWatch journaux à l'aide de AWS Key Management Service](encrypt-lookup-tables-kms.md).
## Syntaxe de requête pour la recherche
**Structure de commande**
Le format de cette commande est illustré ci-dessous.
```
lookup table lookup-field as log-field [,...] output-mode output-field[,...]
```
La commande utilise les arguments suivants :
+ `table`— Nom de la table de recherche à utiliser.
+ `lookup-field`— Le champ de la table de recherche à comparer.
+ `log-field`— Le champ correspondant dans votre journal des événements. La correspondance est exacte et distingue les majuscules et minuscules.
+ `output-mode`— Spécifiez `OUTPUT` d'ajouter les champs de sortie aux résultats. Si un champ portant le même nom existe déjà dans le journal des événements, il est remplacé.
+ `output-field`— Un ou plusieurs champs de la table de recherche à ajouter aux résultats.
**Exemple : enrichir les événements du journal avec les détails de l'utilisateur**
Supposons que vous disposiez d'un groupe de journaux contenant des événements contenant un `id` champ et d'une table de recherche nommée `user_data` par des colonnes `id``name`,`email`, et`department`. La requête suivante enrichit chaque événement du journal avec le nom, l'adresse e-mail et le service de l'utilisateur à partir de la table de recherche.
```
fields action, status, name, email, department
| lookup user_data id OUTPUT name, email, department
```
**Exemple : utilisation de la recherche avec agrégation**
Vous pouvez utiliser des champs de sortie de recherche avec des fonctions d'agrégation. La requête suivante enrichit les événements du journal avec les détails de l'utilisateur, puis compte les événements regroupés par adresse e-mail.
```
fields user_id, action, username, email, department
| lookup user_data user_id OUTPUT username, email, department
| stats count(*) by email
```
**Exemple : utiliser la recherche avec filtre**
Vous pouvez filtrer les résultats en fonction des champs renvoyés par la recherche. La requête suivante enrichit les événements du journal, puis filtre pour n'afficher que les événements d'un département spécifique.
```
fields user_id, action
| lookup user_data user_id OUTPUT username, email, department
| filter department = "Engineering"
```
# Fonctions booléennes, de comparaison, numériques, de date/heure et autres
CloudWatch Logs Insights prend en charge de nombreuses autres opérations et fonctions dans les requêtes, comme expliqué dans les sections suivantes.
**Topics**
+ [Opérateurs arithmétiques](#CWL_QuerySyntax-operations-arithmetic)
+ [Opérateurs booléens](#CWL_QuerySyntax-operations-Boolean)
+ [Opérateurs de comparaison](#CWL_QuerySyntax-operations-comparison)
+ [Opérateurs numériques](#CWL_QuerySyntax-operations-numeric)
+ [Types de structures](#CWL_QuerySyntax-structure-types)
+ [Fonctions Datetime](#CWL_QuerySyntax-datetime)
+ [Fonctions générales](#CWL_QuerySyntax-general-functions)
+ [Fonctions JSON](#CWL_QuerySyntax-json-functions)
+ [Fonctions de chaîne d'adresse IP](#CWL_QuerySyntax-IPaddress-functions)
+ [Fonctions de chaîne](#CWL_QuerySyntax-string-functions)
## Opérateurs arithmétiques
Les opérateurs arithmétiques acceptent les types de données numériques en tant qu'arguments et renvoient des résultats numériques. Utilisez des opérateurs arithmétiques dans les commandes `filter` et `fields` et en tant qu'arguments pour d'autres fonctions.
| Opération | Description |
| --- | --- |
| `a + b` | Addition |
| `a - b` | Soustraction |
| `a * b` | Multiplication |
| `a / b` | Division |
| `a ^ b` | Élévation à la puissance (`2 ^ 3` renvoie `8`) |
| `a % b` | Valeurs restantes ou module (`10 % 3` renvoie `1`) |
## Opérateurs booléens
Utilisez les opérateurs booléens `and`, `or` et `not`.
**Note**
Utilisez les opérateurs booléens uniquement dans les fonctions qui renvoient une valeur de **TRUE** (VRAI) ou **FALSE** (FAUX).
## Opérateurs de comparaison
Les opérateurs de comparaison acceptent tous les types de données en tant qu'arguments et renvoient un résultat booléen. Utilisez des opérations de comparaison dans la commande `filter` et en tant qu'arguments pour d'autres fonctions.
| Opérateur | Description |
| --- | --- |
| `=` | Égal à |
| `!=` | Non égal à |
| `<` | Inférieur à |
| `>` | Supérieur à |
| `<=` | Inférieur ou égal à |
| `>=` | Supérieur ou égal à |
## Opérateurs numériques
Les opérations numériques acceptent les types de données numériques en tant qu'arguments numériques et renvoient des résultats numériques. Utilisez des opérations numériques dans les commandes `filter` et `fields` et en tant qu'arguments pour d'autres fonctions.
| Opération | Type de résultat | Description |
| --- | --- | --- |
| `abs(a: number)` | nombre | Valeur absolue |
| `ceil(a: number)` | number | Arrondir jusqu'au nombre entier supérieur suivant (le plus petit nombre entier supérieur à la valeur de `a`) |
| `floor(a: number)` | number | Arrondir jusqu'au nombre entier inférieur suivant (le plus grand nombre entier inférieur à la valeur de `a`) |
| `greatest(a: number, ...numbers: number[])` | number | Renvoie la valeur la plus grande |
| `least(a: number, ...numbers: number[])` | number | Renvoie la valeur la plus petite |
| `log(a: number)` | number | Journal naturel |
| `sqrt(a: number)` | number | Racine carrée |
## Types de structures
Une carte ou une liste est un type de structure dans CloudWatch Logs Insights qui vous permet d'accéder aux attributs et de les utiliser pour les requêtes.
**Exemple : pour obtenir une carte ou une liste**
`jsonParse`À utiliser pour analyser un champ qui est une chaîne JSON dans une carte ou une liste.
```
fields jsonParse(@message) as json_message
```
**Exemple : pour accéder aux attributs**
Utilisez l'opérateur d'accès par points (map.attribute) pour accéder aux éléments d'une carte. Si un attribut d'une carte contient des caractères spéciaux, utilisez des backticks pour placer le nom de l'attribut (map.attributes). `special.char`).
```
fields jsonParse(@message) as json_message
| stats count() by json_message.status_code
```
Utilisez l'opérateur d'accès entre crochets (list [index]) pour récupérer un élément à une position spécifique dans la liste.
```
fields jsonParse(@message) as json_message
| filter json_message.users[1].action = "PutData"
```
Enveloppez les caractères spéciaux en backticks (``) lorsque des caractères spéciaux sont présents dans le nom de la clé.
```
fields jsonParse(@message) as json_message
| filter json_message.`user.id` = "123"
```
**Exemple : résultats vides**
Les cartes et les listes sont traitées comme nulles pour les fonctions de chaîne, de nombre et de date.
```
fields jsonParse(@message) as json_message
| display toupper(json_message)
```
La comparaison de la carte et de la liste avec tout autre champ donne`false`.
**Note**
L'utilisation de la carte et de la liste dans `dedup``pattern`,`sort`, et `stats` n'est pas prise en charge.
## Fonctions Datetime
**Fonctions Datetime**
Utilisez les fonctions de date et heure dans les commandes `fields` et `filter` et en tant qu'arguments pour d'autres fonctions. Utilisez ces fonctions pour créer des compartiments de temps pour les requêtes avec des fonctions de regroupement. Utilisez des périodes composées d'un nombre et de l'un des éléments suivants :
+ `ms`pendant des millisecondes
+ `s`pendant quelques secondes
+ `m`pendant quelques minutes
+ `h`pendant des heures
Par exemple, `10m` correspond à 10 minutes et `1h` correspond à une heure.
**Note**
Utilisez l'unité de temps la plus appropriée pour votre fonction datetime. CloudWatch Logs plafonne votre demande en fonction de l'unité de temps que vous avez choisie. Par exemple, il plafonne à 60 la valeur maximale pour toute demande utilisant`s`. Ainsi, si vous le spécifiez`bin(300s)`, CloudWatch Logs l'implémente en fait sous la forme de 60 secondes, car 60 est le nombre de secondes dans une minute. CloudWatch Logs n'utilisera donc pas un nombre supérieur à 60 avec`s`. Pour créer un bucket de 5 minutes, utilisez `bin(5m)` plutôt.
Le plafond pour `ms` est de 1000, les capuchons pour `s` et `m` sont de 60, et le plafond pour `h` est de 24.
Le tableau suivant contient une liste des différentes fonctions de date et heure que vous pouvez utiliser dans des commandes de requête. Le tableau répertorie le type de résultat de chaque fonction et contient une description de chaque fonction.
**Astuce**
Lorsque vous créez une commande de requête, vous pouvez utiliser le sélecteur d'intervalle pour sélectionner une période de temps à interroger. Par exemple, vous pouvez définir une période de temps entre des intervalles de 5 à 30 minutes, des intervalles de 1, 3 et 12 heures ou une période personnalisée. Vous pouvez également définir des périodes entre des dates spécifiques.
| Fonction | Type de résultat | Description |
| --- | --- | --- |
| `bin(period: Period)` | Horodatage | Arrondit la valeur de `@timestamp` à la période donnée, puis la tronque. Par exemple, `bin(5m)` arrondit la valeur de `@timestamp` aux 5 minutes les plus proches. Vous pouvez l'utiliser pour regrouper plusieurs entrées de journal dans une requête. L'exemple suivant indique le nombre d'exceptions par heure : filter @message like /Exception/
| stats count(*) as exceptionCount by bin(1h)
| sort exceptionCount desc
les unités de temps et les abréviations suivantes sont prises en charge par la fonction `bin`. Pour toutes les unités et abréviations qui incluent plus d'un caractère, l'ajout de s au pluriel est pris en charge. Donc, les deux `hr` et `hrs` travaillent pour spécifier les heures. [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/AmazonCloudWatch/latest/logs/CWL_QuerySyntax-operations-functions.html) |
| `datefloor(timestamp: Timestamp, period: Period)` | Horodatage | Tronque l'horodatage pour la période donnée. Par exemple, `datefloor(@timestamp, 1h)` tronque toutes les valeurs de `@timestamp` vers la valeur la plus basse de l'heure. |
| `dateceil(timestamp: Timestamp, period: Period)` | Horodatage | Arrondit l'horodatage pour la période donnée, puis la tronque. Par exemple, `dateceil(@timestamp, 1h)` tronque toutes les valeurs de `@timestamp` vers la valeur la plus élevée de l'heure. |
| `fromMillis(fieldName: number)` | Horodatage | Interprète le champ en entrée comme le nombre de millisecondes depuis l'époque Unix et le convertit en horodatage. |
| `toMillis(fieldName: Timestamp)` | number | Convertit l'horodatage trouvé dans le champ nommé en un nombre représentant les millisecondes depuis l'époque Unix. Par exemple, `toMillis(@timestamp)` convertit l'horodatage `2022-01-14T13:18:031.000-08:00` à `1642195111000`. |
| `now()` | number | Renvoie l'heure à laquelle le traitement de la requête a été lancé, en secondes d'époque. Cette fonction ne prend aucun argument. Vous pouvez l'utiliser pour filtrer les résultats de votre requête en fonction de l'heure actuelle. Par exemple, la requête suivante renvoie toutes les erreurs 4xx des deux dernières heures : parse @message "Status Code: *;" as statusCode\n
| filter statusCode >= 400 and statusCode <= 499 \n
| filter toMillis(@timestamp) >= (now() * 1000 - 7200000)
L'exemple suivant renvoie toutes les entrées du journal des cinq dernières heures contenant le mot `error` ou `failure` fields @timestamp, @message
| filter @message like /(?i)(error|failure)/
| filter toMillis(@timestamp) >= (now() * 1000 - 18000000)
|
**Note**
À l'heure actuelle, CloudWatch Logs Insights ne prend pas en charge le filtrage des journaux avec des horodatages lisibles par l'homme.
## Fonctions générales
**Fonctions générales**
Utilisez des fonctions générales dans les commandes `fields` et `filter` et en tant qu'arguments pour d'autres fonctions.
| Fonction | Type de résultat | Description |
| --- | --- | --- |
| `ispresent(fieldName: LogField)` | Booléen | Renvoie `true` si le champ existe |
| `coalesce(fieldName: LogField, ...fieldNames: LogField[])` | LogField | Renvoie la première valeur non nulle de la liste |
## Fonctions JSON
**Fonctions JSON**
Utilisez les fonctions JSON dans les `filter` commandes `fields` et comme arguments pour d'autres fonctions.
| Fonction | Type de résultat | Description |
| --- | --- | --- |
| `jsonParse(fieldName: string)` | Carte \$1 Liste \$1 Vide | Renvoie une carte ou une liste lorsque l'entrée est une représentation sous forme de chaîne d'un objet JSON ou d'un tableau JSON. Renvoie une valeur vide si l'entrée ne fait pas partie de la représentation. |
| `jsonStringify(fieldName: Map \| List)` | String | Renvoie une chaîne JSON à partir des données d'une carte ou d'une liste. |
## Fonctions de chaîne d'adresse IP
**Fonctions de chaîne d'adresse IP**
Utilisez les fonctions de chaîne d'adresse IP dans les commandes `filter` et `fields` et en tant qu'arguments pour d'autres fonctions.
| Fonction | Type de résultat | Description |
| --- | --- | --- |
| `isValidIp(fieldName: string)` | booléen | Renvoie `true` si le champ est une IPv6 adresse IPv4 ou une adresse valide. |
| `isValidIpV4(fieldName: string)` | boolean | Renvoie `true` si le champ est une IPv4 adresse valide. |
| `isValidIpV6(fieldName: string)` | boolean | Renvoie `true` si le champ est une IPv6 adresse valide. |
| `isIpInSubnet(fieldName: string, subnet: string)` | boolean | Renvoie `true` si le champ est une IPv6 adresse valide IPv4 dans le sous-réseau v4 ou v6 spécifié. Lorsque vous spécifiez le sous-réseau, utilisez la notation CIDR telle que `192.0.2.0/24` ou `2001:db8::/32`, où `192.0.2.0` ou `2001:db8::` est le début du bloc d'adresse CIDR. |
| `isIpv4InSubnet(fieldName: string, subnet: string)` | boolean | Renvoie `true` si le champ est une IPv4 adresse valide dans le sous-réseau v4 spécifié. Lorsque vous spécifiez le sous-réseau, utilisez la notation CIDR telle que `192.0.2.0/24` où `192.0.2.0` est le début du bloc d'adresse CIDR. |
| `isIpv6InSubnet(fieldName: string, subnet: string)` | boolean | Renvoie `true` si le champ est une IPv6 adresse valide dans le sous-réseau v6 spécifié. Lorsque vous spécifiez le sous-réseau, utilisez la notation CIDR telle que `2001:db8::/32` où `2001:db8::` est le début du bloc d'adresse CIDR. |
## Fonctions de chaîne
**Fonctions de chaîne**
Utilisez des fonctions de chaîne dans les commandes `fields` et `filter` et en tant qu'arguments pour d'autres fonctions.
| Fonction | Type de résultat | Description |
| --- | --- | --- |
| `isempty(fieldName: string)` | Number | Renvoie `1` si le champ est manquant ou est une chaîne vide. |
| `isblank(fieldName: string)` | Number | Renvoie `1` si le champ est manquant, est une chaîne vide ou contient uniquement un espace. |
| `concat(str: string, ...strings: string[])` | chaîne | Concatène les chaînes. |
| `ltrim(str: string)` `ltrim(str: string, trimChars: string)` | chaîne | Si la fonction ne possède pas de deuxième argument, elle supprime les espaces blancs à gauche de la chaîne. Si la fonction possède un deuxième argument de chaîne, elle ne supprime pas l'espace blanc. Au lieu de cela, elle supprime les caractères de `trimChars` à gauche de `str`. Par exemple, `ltrim("xyZxyfooxyZ","xyZ")` renvoie `"fooxyZ"`. |
| `rtrim(str: string)` `rtrim(str: string, trimChars: string)` | chaîne | Si la fonction ne possède pas de deuxième argument, elle supprime les espaces blancs à droite de la chaîne. Si la fonction possède un deuxième argument de chaîne, elle ne supprime pas l'espace blanc. Au lieu de cela, elle supprime les caractères de `trimChars` à droite de `str`. Par exemple, `rtrim("xyZfooxyxyZ","xyZ")` renvoie `"xyZfoo"`. |
| `trim(str: string)` `trim(str: string, trimChars: string)` | chaîne | Si la fonction ne possède pas de deuxième argument, elle supprime les espaces blancs aux deux extrémités de la chaîne. Si la fonction possède un deuxième argument de chaîne, elle ne supprime pas l'espace blanc. Au lieu de cela, il supprime les caractères de `trimChars` des deux côtés de `str`. Par exemple, `trim("xyZxyfooxyxyZ","xyZ")` renvoie `"foo"`. |
| `strlen(str: string)` | number | Renvoie la longueur de la chaîne en points de code Unicode. |
| `toupper(str: string)` | chaîne | Convertit la chaîne en majuscules. |
| `tolower(str: string)` | chaîne | Convertit la chaîne en minuscules. |
| `substr(str: string, startIndex: number)` `substr(str: string, startIndex: number, length: number)` | chaîne | Renvoie une sous-chaîne à partir de l'index spécifié par l'argument de nombre à la fin de la chaîne. Si la fonction comporte un second argument de nombre, elle comporte la longueur de la sous-chaîne à récupérer. Par exemple, `substr("xyZfooxyZ",3, 3)` renvoie `"foo"`. |
| `replace(fieldName: string, searchValue: string, replaceValue: string)` | chaîne | Remplace toutes les instances de `searchValue` dans `fieldName: string` par `replaceValue`. Par exemple, la fonction `replace(logGroup,"smoke_test","Smoke")` recherche les événements du journal où le champ `logGroup` contient la valeur de chaîne `smoke_test` et remplace la valeur par la chaîne `Smoke`. |
| `strcontains(str: string, searchValue: string)` | number | Renvoie 1 si `str` contient `searchValue` et 0 dans le cas contraire. |
# Champs contenant des caractères spéciaux
Si un champ contient des caractères non alphanumériques autres que le `@` symbole ou le point (`.`), vous devez l'entourer de caractères anticochés (). ``` Par exemple, le champ de journal `foo-bar` doit être placé entre accents graves (``foo-bar``), car il contient un caractère non alphanumérique, le trait d'union (`-`).
# Utilisation d'alias et de commentaires dans les requêtes
Créez des requêtes contenant des alias. Utilisez des alias pour renommer des champs de journal ou lors de l'extraction de valeurs dans des champs. Utilisez le mot-clé `as` pour attribuer un champ de journal ou obtenir un alias. Vous pouvez utiliser plusieurs alias dans une requête. Vous pouvez utiliser des alias dans les commandes suivantes :
+ `fields`
+ `parse`
+ `sort`
+ ` stats `
Les exemples suivants montrent comment créer des requêtes contenant des alias.
**Exemple**
La requête contient un alias dans la commande `fields`.
```
fields @timestamp, @message, accountId as ID
| sort @timestamp desc
| limit 20
```
La requête renvoie les valeurs des champs `@timestamp`, `@message` et `accountId`. Les résultats sont triés dans l'ordre décroissant et limités à 20. Les valeurs pour `accountId` sont répertoriés sous l'alias `ID`.
**Exemple**
La requête contient des alias dans les commandes `sort` et `stats`.
```
stats count(*) by duration as time
| sort time desc
```
La requête compte le nombre de fois que le champ `duration` apparaît dans le groupe de journaux et trie les résultats dans l'ordre décroissant. Les valeurs pour `duration` sont répertoriés sous l'alias `time`.
## Utilisation de commentaires
CloudWatch Logs Insights prend en charge les commentaires dans les requêtes. Utilisez le caractère dièse (**\$1**) pour afficher les commentaires. Vous pouvez utiliser des commentaires pour ignorer les lignes des requêtes ou des requêtes de documents.
**Exemple : requête**
Lorsque la requête suivante est exécutée, la deuxième ligne est ignorée.
```
fields @timestamp, @message, accountId
# | filter accountId not like "7983124201998"
| sort @timestamp desc
| limit 20
```
# Commencez avec Logs Insights QL : didacticiels sur les requêtes
Les sections suivantes incluent des exemples de didacticiels sur les requêtes pour vous aider à démarrer avec Logs Insights QL.
**Topics**
+ [Didacticiel : Exécution et modification d'un exemple de requête](CWL_AnalyzeLogData_RunSampleQuery.md)
+ [Didacticiel : Exécuter une requête avec une fonction d'agrégation](CWL_AnalyzeLogData_AggregationQuery.md)
+ [Didacticiel : Exécuter une requête qui génère une visualisation groupée par champs de journal](CWL_AnalyzeLogData_VisualizationFieldQuery.md)
+ [Didacticiel : Exécuter une requête qui produit des séries temporelles](CWL_AnalyzeLogData_VisualizationQuery.md)
# Didacticiel : Exécution et modification d'un exemple de requête
Le didacticiel suivant vous aide à démarrer avec CloudWatch Logs Insights. Vous exécutez un exemple de requête dans Logs Insights QL, puis vous découvrez comment le modifier et le réexécuter.
Pour exécuter une requête, les journaux doivent déjà être stockés dans CloudWatch Logs. Si vous utilisez déjà les CloudWatch journaux et que vous avez configuré des groupes de journaux et des flux de journaux, vous êtes prêt à commencer. Il se peut également que vous disposiez déjà de journaux si vous utilisez des services tels qu' AWS CloudTrail Amazon Route 53 ou Amazon VPC et que vous avez configuré les journaux de ces services pour qu'ils soient accessibles dans Logs. CloudWatch Pour plus d'informations sur l'envoi de CloudWatch journaux à Logs, consultez[Commencer à utiliser CloudWatch Logs](CWL_GettingStarted.md).
Les requêtes dans CloudWatch Logs Insights renvoient soit un ensemble de champs provenant des événements du journal, soit le résultat d'une agrégation mathématique ou d'une autre opération effectuée sur les événements du journal. Ce didacticiel illustre une requête qui renvoie une liste d'événements du journal.
## Exécution d'un exemple de requête
**Pour exécuter un exemple de requête CloudWatch Logs Insights**
1. Ouvrez la CloudWatch console à l'adresse [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/).
1. Dans le panneau de navigation, choisissez **Logs** (Journaux), puis **Logs Insights**.
Sur la page **Logs Insights**, l'éditeur de requêtes contient une requête par défaut dans Logs Insights QL qui renvoie les 20 événements de journal les plus récents.
1. Dans la liste déroulante **Sélectionner les groupes de journaux**, choisissez un ou plusieurs groupes de journaux à interroger.
S'il s'agit d'un compte de surveillance dans le CloudWatch domaine de l'observabilité entre comptes, vous pouvez sélectionner des groupes de journaux dans les comptes sources ainsi que dans le compte de surveillance. Une seule requête peut interroger les journaux de différents comptes à la fois.
Vous pouvez filtrer les groupes de journaux par nom de groupe de journaux, ID de compte ou étiquette de compte.
Lorsque vous sélectionnez un groupe de journaux dans la classe de CloudWatch journaux standard, Logs Insights détecte automatiquement les champs de données du groupe. Pour consulter les champs découverts, sélectionnez le menu **Champs** en haut à droite de la page.
**Note**
Les champs découverts ne sont pris en charge que pour les groupes de journaux de la classe de journaux standard. Pour plus d'informations sur les classes de log, consultez[Classes de log](CloudWatch_Logs_Log_Classes.md).
1. (Facultatif) Utilisez le sélecteur d'intervalle de temps pour sélectionner une période à interroger.
Vous pouvez choisir entre des intervalles de 5 à 30 minutes, des intervalles de 1, 3 et 12 heures ou une période personnalisée.
1. Choisissez **Run** (Exécuter) pour afficher les résultats.
Pour ce didacticiel, les résultats incluent les 20 événements du journal les plus récents.
CloudWatch Logs affiche un graphique à barres des événements du groupe de journaux au fil du temps. Ce graphique à barres montre non seulement les événements dans le tableau, mais également la distribution des événements dans le groupe de journaux qui correspondent à la requête et à la période.
1. Pour consulter tous les champs d'un événement du journal renvoyé, choisissez l'icône de liste déroulante triangulaire à gauche de l'événement numéroté.
## Modification de l'exemple de requête
Dans ce didacticiel, vous modifiez l'exemple de requête pour afficher les 50 événements du journal les plus récents.
Si vous n'avez pas encore exécuté le didacticiel précédent, faites-le maintenant. Ce didacticiel commence au moment où le didacticiel précédent se termine.
**Note**
Certains exemples de requêtes fournis avec CloudWatch Logs Insights utilisent des `tail` commandes `head` ou à la place de`limit`. Ces commandes sont considérées comme obsolètes et ont été remplacées par `limit`. Utilisez `limit` au lieu de `head` ou `tail` dans toutes les requêtes que vous écrivez.
**Pour modifier l'exemple de requête CloudWatch Logs Insights**
1. Dans l'éditeur de requêtes, remplacez **20** par **50**, puis choisissez **Exécuter**.
Les résultats de la nouvelle requête s'affichent. Si le groupe de journaux dispose de suffisamment de données dans la plage de temps par défaut, 50 journaux d'évènements sont désormais répertoriés.
1. (Facultatif) Vous pouvez enregistrer les requêtes que vous avez créées. Pour enregistrer cette requête, choisissez **Enregistrer**. Pour plus d'informations, consultez [Enregistrez et réexécutez les requêtes CloudWatch Logs Insights](CWL_Insights-Saving-Queries.md).
## Ajout d'une commande de filtre à l'exemple de requête
Ce didacticiel explique comment apporter une modification plus puissante à la requête dans l'éditeur de requête. Dans ce didacticiel, vous filtrez les résultats de la requête précédente basée sur un champ dans les événements du journal récupérés.
Si vous n'avez pas encore exécuté les didacticiels précédents, faites-le maintenant. Ce didacticiel commence au moment où le didacticiel précédent se termine.
**Pour ajouter une commande de filtre à la requête précédente**
1. Choisissez un champ à filtrer. Pour voir les champs les plus courants détectés par CloudWatch Logs dans les événements du journal contenus dans les groupes de journaux sélectionnés au cours des 15 dernières minutes, ainsi que le pourcentage de ces événements de journal dans lesquels chaque champ apparaît, sélectionnez **Champs** sur le côté droit de la page.
Pour afficher les champs contenus dans un événement de journal spécifique, choisissez l'icône située à gauche de cette ligne.
Le champ **awsRegion** peut s'afficher dans votre évènement de journal en fonction de la nature des événements qui se trouvent dans vos journaux. Pour le reste de ce didacticiel, nous utiliserons **awsRegion** en tant que champ de filtre, mais vous pouvez utiliser un autre champ si celui-ci n'est pas disponible.
1. Dans la zone de l'éditeur de requête, placez votre curseur après **50** et appuyez sur Entrée.
1. Sur la nouvelle ligne, commencez par entrer une barre verticale (« \$1 ») et un espace. Les commandes d'une requête CloudWatch Logs Insights doivent être séparées par le caractère pipe.
1. Saisissez **filter awsRegion="us-east-1"**.
1. Cliquez sur **Exécuter**.
La requête s'exécute à nouveau, et affiche désormais les 50 résultats les plus récents qui correspondent au nouveau filtre.
Si vous avez filtré sur un autre champ et obtenu un résultat d'erreur, il se peut que vous ayez besoin d'utiliser le nom du champ. Si le nom du champ inclut des caractères non alphanumériques, vous devez placer des guillemet inversés (`) avant et après le nom du champ (par exemple, **`error-code`="102"**).
Vous devez utiliser des guillemets inversés pour les noms de champs qui contiennent des caractères non alphanumériques, mais pas pour les valeurs. Les valeurs sont toujours entre guillemets (").
Logs Insights QL inclut de puissantes fonctionnalités de requête, notamment plusieurs commandes et la prise en charge des expressions régulières, des opérations mathématiques et statistiques. Pour de plus amples informations, veuillez consulter [CloudWatch Syntaxe des requêtes en langage Logs Insights](CWL_QuerySyntax.md).
# Didacticiel : Exécuter une requête avec une fonction d'agrégation
Vous pouvez utiliser des fonctions d'agrégation avec la commande `stats` et en tant qu'arguments pour d'autres fonctions. Dans ce didacticiel, vous exécutez une commande de requête qui compte le nombre d'événements du journal contenant un champ spécifié. La commande de requête renvoie un décompte total regroupé en fonction de la(des) valeur(s) du champ spécifié. Pour plus d'informations sur les fonctions d'agrégation, consultez la section [Opérations et fonctions prises en charge](https://docs.aws.amazon.com/en_us/AmazonCloudWatch/latest/logs/CWL_QuerySyntax.html#CWL_QuerySyntax-operations-functions) dans le *guide de l'utilisateur Amazon CloudWatch Logs*.
**Exécution d'une requête avec une fonction d'agrégation**
1. Ouvrez la CloudWatch console à l'adresse [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/).
1. Dans le panneau de navigation, choisissez **Logs** (Journaux), puis **Logs Insights**.
1. Vérifiez que l'onglet **Logs Insights QL** est sélectionné.
1. Dans la liste déroulante **Sélectionner les groupes de journaux**, choisissez un ou plusieurs groupes de journaux à interroger.
S'il s'agit d'un compte de surveillance dans le CloudWatch domaine de l'observabilité entre comptes, vous pouvez sélectionner des groupes de journaux dans les comptes sources ainsi que dans le compte de surveillance. Une seule requête peut interroger les journaux de différents comptes à la fois.
Vous pouvez filtrer les groupes de journaux par nom de groupe de journaux, ID de compte ou étiquette de compte.
Lorsque vous sélectionnez un groupe de CloudWatch journaux, Logs Insights détecte automatiquement les champs de données du groupe de journaux s'il s'agit d'un groupe de journaux de classe Standard. Pour consulter les champs découverts, sélectionnez le menu **Champs** en haut à droite de la page.
1. Supprimez la requête par défaut dans l'éditeur de requête et saisissez la commande suivante :
```
stats count(*) by fieldName
```
1. *fieldName*Remplacez-le par un champ découvert dans le menu **Champs**.
Le menu **Champs** se trouve en haut à droite de la page et affiche tous les champs découverts détectés par CloudWatch Logs Insights dans votre groupe de journaux.
1. Choisissez **Run** (Exécuter) pour consulter les résultats de requête.
Les résultats de requête indiquent le nombre de registres dans votre groupe de journaux qui correspondent à la commande de requête et le décompte total regroupé en fonction de la(des) valeur(s) du champ spécifié.
# Didacticiel : Exécuter une requête qui génère une visualisation groupée par champs de journal
Lorsque vous exécutez une requête qui utilise la fonction `stats` pour grouper les résultats renvoyés par les valeurs d'un ou de plusieurs champs dans les entrées du journal, vous pouvez afficher les résultats sous la forme d'un graphique à barres, d'un graphique circulaire, d'un graphique linéaire ou d'un graphique en aires empilées. Cela vous permet de visualiser plus efficacement les tendances dans vos journaux.
**Pour exécuter une requête pour générer une visualisation**
1. Ouvrez la CloudWatch console à l'adresse [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/).
1. Dans le panneau de navigation, choisissez **Logs** (Journaux), puis **Logs Insights**.
1. Dans la liste déroulante **Select log group(s)** (Sélectionner groupe(s) de journaux), choisissez un ou plusieurs groupes de journaux à interroger.
S'il s'agit d'un compte de surveillance dans le CloudWatch domaine de l'observabilité entre comptes, vous pouvez sélectionner des groupes de journaux dans les comptes sources ainsi que dans le compte de surveillance. Une seule requête peut interroger les journaux de différents comptes à la fois.
Vous pouvez filtrer les groupes de journaux par nom de groupe de journaux, ID de compte ou étiquette de compte.
1. Dans l'éditeur de requête, supprimez le contenu actuel, saisissez la fonction `stats` suivante, puis choisissez **Exécuter la requête**.
```
stats count(*) by @logStream
| limit 100
```
Les résultats indiquent le nombre d'événements de journal dans le groupe de journaux pour chaque flux de journaux. Les résultats sont limités à seulement 100 lignes.
1. Choisissez l'onglet **Visualisation**.
1. Sélectionnez la flèche en regard de **Ligne**, puis choisissez **Barre**.
Le graphique à barres apparaît, affichant une barre pour chaque flux de journaux du groupe de journaux.
# Didacticiel : Exécuter une requête qui produit des séries temporelles
Lorsque vous exécutez une requête qui utilise la fonction `bin()` pour regrouper les résultats renvoyés selon une période de temps, vous pouvez afficher les résultats sous forme de graphique linéaire, de graphique en aires empilées, de graphique circulaire ou de diagramme à barres. Cela vous aide à visualiser plus efficacement les tendances des événements du journal au fil du temps.
**Pour exécuter une requête pour générer une visualisation**
1. Ouvrez la CloudWatch console à l'adresse [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/).
1. Dans le panneau de navigation, choisissez **Logs** (Journaux), puis **Logs Insights**.
1. Vérifiez que l'onglet **Logs Insights QL** est sélectionné.
1. Dans la liste déroulante **Sélectionner les groupes de journaux**, choisissez un ou plusieurs groupes de journaux à interroger.
S'il s'agit d'un compte de surveillance dans le CloudWatch domaine de l'observabilité entre comptes, vous pouvez sélectionner des groupes de journaux dans les comptes sources ainsi que dans le compte de surveillance. Une seule requête peut interroger les journaux de différents comptes à la fois.
Vous pouvez filtrer les groupes de journaux par nom de groupe de journaux, ID de compte ou étiquette de compte.
1. Dans l'éditeur de requête, supprimez le contenu actuel, saisissez la fonction `stats` suivante, puis choisissez **Exécuter la requête**.
```
stats count(*) by bin(30s)
```
Les résultats indiquent le nombre d'événements du groupe de journaux reçus par CloudWatch Logs pour chaque période de 30 secondes.
1. Choisissez l’onglet **Visualisation**.
Les résultats sont affichés sous forme de graphique linéaire. Pour basculer vers un graphique à barres, un graphique circulaire ou un graphique en aires empilées, choisissez la flèche en regard de **Ligne** en haut à gauche du graphique.
# Exemples de requêtes
Cette section contient une liste de commandes de requête générales et utiles que vous pouvez exécuter dans la [CloudWatchconsole](https://console.aws.amazon.com/cloudwatch/). Pour plus d'informations sur l'exécution d'une commande de requête, consultez [Tutoriel : Exécuter et modifier un exemple de requête](https://docs.aws.amazon.com/en_us/AmazonCloudWatch/latest/logs/CWL_AnalyzeLogData_RunSampleQuery.html) dans le *guide de l'utilisateur Amazon CloudWatch Logs*.
Pour plus d'informations sur la syntaxe des requêtes, consultez[CloudWatch Syntaxe des requêtes en langage Logs Insights](CWL_QuerySyntax.md).
**Topics**
+ [Requêtes générales](#CWL_QuerySyntax-examples-general)
+ [Requêtes pour les journaux Lambda](#CWL_QuerySyntax-examples-Lambda)
+ [Requêtes pour les journaux de flux Amazon VPC](#CWL_QuerySyntax-examples-VPC)
+ [Requêtes pour les journaux Route 53](#CWL_QuerySyntax-examples-Route53)
+ [Requêtes pour les CloudTrail journaux](#CWL_QuerySyntax-examples-CloudTrail)
+ [Requêtes pour Amazon API Gateway](#CWL_QuerySyntax-examples-APIGateway)
+ [Requêtes pour passerelle NAT](#CWL_QuerySyntax-examples-NATGateway)
+ [Requêtes pour les journaux du serveur Apache](#CWL_QuerySyntax-examples-Apache)
+ [Requêtes pour Amazon EventBridge](#CWL_QuerySyntax-examples-EventBridge)
+ [Exemples de la commande d'analyse.](#CWL_QuerySyntax-examples-parse)
## Requêtes générales
**Rechercher les 25 derniers événements ajoutés au journal.**
```
fields @timestamp, @message | sort @timestamp desc | limit 25
```
**Obtenir une liste du nombre d'exceptions par heure.**
```
filter @message like /Exception/
| stats count(*) as exceptionCount by bin(1h)
| sort exceptionCount desc
```
**Obtenir une liste des événements de journal qui ne sont pas des exceptions.**
```
fields @message | filter @message not like /Exception/
```
**Obtenir l'événement du journal le plus récent pour chaque valeur unique du champ `server`.**
```
fields @timestamp, server, severity, message
| sort @timestamp asc
| dedup server
```
**Obtenir l'événement du journal le plus récent pour chaque valeur unique du champ `server` pour chaque type de `severity`.**
```
fields @timestamp, server, severity, message
| sort @timestamp desc
| dedup server, severity
```
## Requêtes pour les journaux Lambda
**Déterminer la quantité de mémoire surallouée.**
```
filter @type = "REPORT"
| stats max(@memorySize / 1000 / 1000) as provisonedMemoryMB,
min(@maxMemoryUsed / 1000 / 1000) as smallestMemoryRequestMB,
avg(@maxMemoryUsed / 1000 / 1000) as avgMemoryUsedMB,
max(@maxMemoryUsed / 1000 / 1000) as maxMemoryUsedMB,
provisonedMemoryMB - maxMemoryUsedMB as overProvisionedMB
```
**Créer un rapport de latence.**
```
filter @type = "REPORT" |
stats avg(@duration), max(@duration), min(@duration) by bin(5m)
```
**Rechercher les invocations de fonctions lentes et éliminer les requêtes dupliquées qui peuvent résulter de nouvelles tentatives ou d'un code côté client. Dans cette requête, la valeur `@duration` est exprimée en millisecondes.**
```
fields @timestamp, @requestId, @message, @logStream
| filter @type = "REPORT" and @duration > 1000
| sort @timestamp desc
| dedup @requestId
| limit 20
```
## Requêtes pour les journaux de flux Amazon VPC
**Rechercher les 15 premiers transferts de paquets entre les hôtes :**
```
stats sum(packets) as packetsTransferred by srcAddr, dstAddr
| sort packetsTransferred desc
| limit 15
```
**Trouver les 15 premiers transferts d'octets pour des hôtes sur un sous-réseau donné.**
```
filter isIpv4InSubnet(srcAddr, "192.0.2.0/24")
| stats sum(bytes) as bytesTransferred by dstAddr
| sort bytesTransferred desc
| limit 15
```
**Rechercher les adresses IP qui utilisent UDP comme protocole de transfert de données.**
```
filter protocol=17 | stats count(*) by srcAddr
```
**Rechercher les adresses IP pour lesquelles des enregistrements de flux ont été ignorés durant la fenêtre de capture.**
```
filter logStatus="SKIPDATA"
| stats count(*) by bin(1h) as t
| sort t
```
**Trouver un enregistrement unique pour chaque connexion, afin de résoudre les problèmes de connectivité réseau.**
```
fields @timestamp, srcAddr, dstAddr, srcPort, dstPort, protocol, bytes
| filter logStream = 'vpc-flow-logs' and interfaceId = 'eni-0123456789abcdef0'
| sort @timestamp desc
| dedup srcAddr, dstAddr, srcPort, dstPort, protocol
| limit 20
```
## Requêtes pour les journaux Route 53
**Rechercher la distribution d'enregistrements par heure par type de requête.**
```
stats count(*) by queryType, bin(1h)
```
**Rechercher les 10 premiers résolveurs DNS avec le plus grand nombre de requêtes.**
```
stats count(*) as numRequests by resolverIp
| sort numRequests desc
| limit 10
```
**Rechercher le nombre d'enregistrements par domaine et sous-domaine où le serveur n'a pas pu résoudre la requête DNS.**
```
filter responseCode="SERVFAIL" | stats count(*) by queryName
```
## Requêtes pour les CloudTrail journaux
**Trouvez le nombre d'entrées de journal pour chaque service, type d'événement et AWS région.**
```
stats count(*) by eventSource, eventName, awsRegion
```
**Trouvez les hôtes Amazon EC2 qui ont été démarrés ou arrêtés dans une région donnée AWS .**
```
filter (eventName="StartInstances" or eventName="StopInstances") and awsRegion="us-east-2"
```
**Trouvez les AWS régions, les noms d'utilisateur et les ARNs utilisateurs IAM nouvellement créés.**
```
filter eventName="CreateUser"
| fields awsRegion, requestParameters.userName, responseElements.user.arn
```
**Rechercher le nombre d'enregistrements où une exception s'est produite lors de l'appel de l'API `UpdateTrail`.**
```
filter eventName="UpdateTrail" and ispresent(errorCode)
| stats count(*) by errorCode, errorMessage
```
**Rechercher les entrées de journal dans lesquelles TLS 1.0 ou 1.1 a été utilisé**
```
filter tlsDetails.tlsVersion in [ "TLSv1", "TLSv1.1" ]
| stats count(*) as numOutdatedTlsCalls by userIdentity.accountId, recipientAccountId, eventSource, eventName, awsRegion, tlsDetails.tlsVersion, tlsDetails.cipherSuite, userAgent
| sort eventSource, eventName, awsRegion, tlsDetails.tlsVersion
```
**Rechercher le nombre d'appels par service qui ont utilisé les versions TLS 1.0 ou 1.1**
```
filter tlsDetails.tlsVersion in [ "TLSv1", "TLSv1.1" ]
| stats count(*) as numOutdatedTlsCalls by eventSource
| sort numOutdatedTlsCalls desc
```
## Requêtes pour Amazon API Gateway
Trouver les 10 dernières erreurs 4XX
```
fields @timestamp, status, ip, path, httpMethod
| filter status>=400 and status<=499
| sort @timestamp desc
| limit 10
```
Identifiez les 10 Amazon API Gateway demandes les plus anciennes de votre groupe de journaux Amazon API Gateway d'accès
```
fields @timestamp, status, ip, path, httpMethod, responseLatency
| sort responseLatency desc
| limit 10
```
Renvoyer la liste des chemins d'API les plus populaires de votre groupe de journaux d'accès Amazon API Gateway
```
stats count(*) as requestCount by path
| sort requestCount desc
| limit 10
```
Créer un rapport de latence d'intégration pour votre groupe de journaux d'accès Amazon API Gateway
```
filter status=200
| stats avg(integrationLatency), max(integrationLatency),
min(integrationLatency) by bin(1m)
```
## Requêtes pour passerelle NAT
Si vous constatez des coûts plus élevés que d'habitude sur votre AWS facture, vous pouvez utiliser CloudWatch Logs Insights pour trouver les meilleurs contributeurs. Pour plus d'informations sur les commandes de requête suivantes, consultez [Comment puis-je trouver les principaux contributeurs au trafic via la passerelle NAT de mon VPC](https://aws.amazon.com/premiumsupport/knowledge-center/vpc-find-traffic-sources-nat-gateway/) ? sur la page d'assistance AWS premium.
**Note**
Dans les commandes de requête suivantes, remplacez « x.x.x.x » par l'adresse IP privée de votre passerelle NAT et remplacez « y.y » par les deux premiers octets de votre plage CIDR VPC.
**Rechercher les instances qui envoient le plus de trafic via votre passerelle NAT.**
```
filter (dstAddr like 'x.x.x.x' and srcAddr like 'y.y.')
| stats sum(bytes) as bytesTransferred by srcAddr, dstAddr
| sort bytesTransferred desc
| limit 10
```
**Déterminer le trafic qui va vers et en provenance des instances de vos passerelles NAT.**
```
filter (dstAddr like 'x.x.x.x' and srcAddr like 'y.y.') or (srcAddr like 'xxx.xx.xx.xx' and dstAddr like 'y.y.')
| stats sum(bytes) as bytesTransferred by srcAddr, dstAddr
| sort bytesTransferred desc
| limit 10
```
**Déterminer les destinations Internet avec lesquelles les instances de votre VPC communiquent le plus souvent pour les chargements et les téléchargements.**
*****For uploads***** (Pour chargements)
```
filter (srcAddr like 'x.x.x.x' and dstAddr not like 'y.y.')
| stats sum(bytes) as bytesTransferred by srcAddr, dstAddr
| sort bytesTransferred desc
| limit 10
```
*****Pour les téléchargements*****
```
filter (dstAddr like 'x.x.x.x' and srcAddr not like 'y.y.')
| stats sum(bytes) as bytesTransferred by srcAddr, dstAddr
| sort bytesTransferred desc
| limit 10
```
## Requêtes pour les journaux du serveur Apache
Vous pouvez utiliser CloudWatch Logs Insights pour interroger les journaux du serveur Apache. Pour plus d'informations sur les requêtes suivantes, consultez [Simplifier les journaux du serveur Apache avec CloudWatch Logs Insights sur](https://aws.amazon.com/blogs/mt/simplifying-apache-server-logs-with-amazon-cloudwatch-logs-insights/) le blog AWS Cloud Operations & Migrations.
**Trouver les champs les plus pertinents, afin de pouvoir consulter vos journaux d'accès et vérifier le trafic dans le chemin */admin* de votre application.**
```
fields @timestamp, remoteIP, request, status, filename| sort @timestamp desc
| filter filename="/var/www/html/admin"
| limit 20
```
**Trouver le nombre de requêtes GET uniques qui ont accédé à votre page principale avec le code d'état « 200 » (succès).**
```
fields @timestamp, remoteIP, method, status
| filter status="200" and referrer= http://34.250.27.141/ and method= "GET"
| stats count_distinct(remoteIP) as UniqueVisits
| limit 10
```
**Rechercher le nombre de fois où votre service Apache a redémarré.**
```
fields @timestamp, function, process, message
| filter message like "resuming normal operations"
| sort @timestamp desc
| limit 20
```
## Requêtes pour Amazon EventBridge
Obtenez le nombre d' EventBridge événements regroupés par type de détail d'événement
```
fields @timestamp, @message
| stats count(*) as numberOfEvents by `detail-type`
| sort numberOfEvents desc
```
## Exemples de la commande d'analyse.
**Utilisez une expression glob pour extraire les champs `@user`, `@method` et `@latency` à partir du champ de journal `@message` et renvoyer la latence moyenne pour chaque combinaison unique de `@method` et `@user`.**
```
parse @message "user=*, method:*, latency := *" as @user,
@method, @latency | stats avg(@latency) by @method,
@user
```
**Utilisez une expression régulière pour extraire les champs `@user2`, `@method2` et `@latency2` à partir du champ du journal `@message` et renvoyer la latence moyenne pour chaque combinaison unique de `@method2` et `@user2`.**
```
parse @message /user=(?.*?), method:(?.*?),
latency := (?.*?)/ | stats avg(latency2) by @method2,
@user2
```
**Extrait les champs `loggingTime`, `loggingType` et `loggingMessage`, filtre vers le bas pour journaliser les événements qui contiennent les chaînes `ERROR` ou `INFO`, puis affiche uniquement les champs `loggingMessage` et `loggingType` pour les événements qui contiennent une chaîne `ERROR`.**
```
FIELDS @message
| PARSE @message "* [*] *" as loggingTime, loggingType, loggingMessage
| FILTER loggingType IN ["ERROR", "INFO"]
| DISPLAY loggingMessage, loggingType = "ERROR" as isError
```
# Comparer (diff) avec les plages temporelles précédentes
Vous pouvez utiliser CloudWatch Logs Insights avec Logs Insights QL pour comparer l'évolution des événements de vos journaux au fil du temps. Vous pouvez comparer les événements du journal ingérés au cours d'une période récente avec les journaux de la période immédiatement précédente. Vous pouvez également effectuer une comparaison avec des périodes antérieures similaires. Cela peut vous aider à déterminer si une erreur dans vos journaux a été introduite récemment ou s'est déjà produite, et peut vous aider à identifier d'autres tendances.
Les requêtes de comparaison renvoient uniquement des modèles dans les résultats, et non des événements de journal bruts. Les modèles renvoyés vous aideront à voir rapidement les tendances et l'évolution des événements du journal au fil du temps. Après avoir exécuté une requête de comparaison et obtenu les résultats des modèles, vous pouvez consulter des exemples d'événements de log bruts correspondant aux modèles qui vous intéressent. Pour plus d'informations sur les modèles de journalisation, consultez[Analyse de modèles](CWL_AnalyzeLogData_Patterns.md).
Lorsque vous exécutez une requête de comparaison, celle-ci est analysée par rapport à deux périodes différentes : la période de requête initiale que vous avez sélectionnée et la période de comparaison. La période de comparaison est toujours d'une durée égale à celle de votre période de requête initiale. Les intervalles de temps par défaut pour les comparaisons sont les suivants.
+ **Période précédente** : compare avec la période immédiatement antérieure à la période de votre requête.
+ **Jour précédent** : compare avec la période du jour précédant la période de votre requête.
+ **Semaine précédente** : comparaison avec la période d'une semaine précédant la période de votre requête.
+ **Mois précédent** : comparaison avec la période d'un mois précédant la période de votre requête.
**Note**
Les requêtes utilisant des comparaisons entraînent des frais similaires à ceux de l'exécution d'une seule requête CloudWatch Logs Insights sur une période combinée. Pour en savoir plus, consultez [Tarification Amazon CloudWatch](https://aws.amazon.com/cloudwatch/pricing/).
**Pour exécuter une requête de comparaison**
1. Ouvrez la CloudWatch console à l'adresse [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/).
1. Dans le volet de navigation, choisissez **Journaux**, **Informations sur les journaux**.
Une requête par défaut apparaît dans la zone de requête.
1. Vérifiez que l'onglet **Logs Insights QL** est sélectionné.
1. Conservez la requête par défaut ou entrez une autre requête.
1. Dans le menu déroulant **Sélectionner un ou plusieurs groupes de journaux**, choisissez un ou plusieurs groupes de journaux à interroger.
1. (Facultatif) Utilisez le sélecteur d'intervalle de temps pour sélectionner une période à interroger. La requête par défaut porte sur les données du journal de l'heure précédente.
1. Dans le sélecteur de plage horaire, choisissez **Comparer**. Choisissez ensuite la période précédente à laquelle vous souhaitez comparer les journaux d'origine, puis choisissez **Appliquer**.
1. Choisissez **Exécuter la requête**.
Pour que la requête récupère les données de la période de comparaison, la `diff` commande est ajoutée à votre requête.
1. Cliquez sur l'onglet **Motifs** pour voir les résultats.
Le tableau affiche les informations suivantes :
+ Chaque **modèle**, avec des parties variables du modèle remplacées par le symbole de jeton dynamique``. *string*Il s'agit d'une description du type de données que le jeton représente. *number*Indique où ce jeton apparaît dans le modèle, par rapport aux autres jetons dynamiques. Pour de plus amples informations, veuillez consulter [Analyse de modèles](CWL_AnalyzeLogData_Patterns.md).
+ Le **nombre d'événements** est le nombre d'événements du journal présentant ce modèle au cours de la période initiale plus récente.
+ Le **nombre d'événements** différentiels est la différence entre le nombre d'événements de journal correspondants au cours de la période en cours et celui de la période de comparaison. Une différence positive signifie qu'il y a davantage d'événements de ce type au cours de la période actuelle.
+ **La description de la différence** résume brièvement l'évolution de ce schéma entre la période en cours et la période de comparaison.
+ Le **type de gravité** est la gravité probable des événements du journal présentant ce modèle, sur la base de mots trouvés dans les événements du journal`FATAL`, tels que`ERROR`, et`WARN`.
1. Pour examiner plus en détail l'un des modèles de la liste, choisissez l'icône de l'un des modèles dans la colonne **Inspecter**.
Le volet **Pattern inspect** apparaît et affiche les informations suivantes :
+ Le **motif**. Sélectionnez un jeton dans le modèle pour analyser les valeurs de ce jeton.
+ Un histogramme indiquant le nombre d'occurrences du modèle sur la plage de temps demandée. Cela peut vous aider à identifier des tendances intéressantes, telles qu'une augmentation soudaine de l'occurrence d'un modèle.
+ L'onglet **Échantillons de journal** affiche quelques-uns des événements du journal correspondant au modèle sélectionné.
+ L'onglet **Valeurs du jeton** affiche les valeurs du jeton dynamique sélectionné, si vous en avez sélectionné un.
**Note**
Un maximum de 10 valeurs de jeton est capturée pour chaque jeton. Le nombre de jetons peut ne pas être précis. CloudWatch Logs utilise un compteur probabiliste pour générer le nombre de jetons, et non la valeur absolue.
+ L'onglet **Modèles associés** affiche d'autres modèles qui se sont produits fréquemment à peu près au même moment que le modèle que vous inspectez. Par exemple, si le modèle d'un `ERROR` message était généralement accompagné d'un autre événement de journal marqué comme `INFO` contenant des détails supplémentaires, ce modèle est affiché ici.
# Visualisation des données du journal dans des graphiques
Vous pouvez utiliser des visualisations telles que des diagrammes à barres, des graphiques linéaires et des graphiques à aires empilées pour identifier plus efficacement les modèles dans vos données de journal. CloudWatch Logs Insights génère des visualisations pour les requêtes qui utilisent la `stats` fonction et une ou plusieurs fonctions d'agrégation. Pour plus d'informations, veuillez consulter [stats](CWL_QuerySyntax-Stats.md).