| + Método + | + ++ Nivel + | +
|---|---|
| + `console.log` + | + ++ `'INFO'` + | +
| + `console.error` + | + ++ `'ERROR'` + | +
| + `console.warn` + | + ++ `'WARN'` + | +
| + `console.info` + | + ++ `'INFO'` + | +
| + `console.debug` + | + ++ `'DEBUG'` + | +
| + `console.trace` + | + ++ `'TRACE'` + | +
| + Entidad + | + ++ Tipo de datos + | + ++ Proveedor + | +
|---|---|---|
| + Grupo + | + ++ `Metric` + | + ++ `Confluent` + | +
| + Métrica + | + ++ Unidad + | + ++ Descripción + | +
|---|---|---|
| + `cluster_load_percent` + | + ++ Por ciento + | + ++ Una medida de la utilización del clúster. El valor está entre 0,0 y 1,0. Sólo el nivel clúster dedicado tiene estos datos métricos. + | +
| + `hot_partition_ingress` + | + ++ Por ciento + | + ++ Un indicador de la presencia de una partición caliente causada por el rendimiento de entrada. El valor es 1.0 cuando se detecta una partición activa y está vacío cuando no se detecta ninguna partición activa. + | +
| + `hot_partition_egress` + | + ++ Por ciento + | + ++ Un indicador de la presencia de una partición caliente causada por el rendimiento de salida. El valor es 1.0 cuando se detecta una partición activa y está vacío cuando no se detecta ninguna partición activa. + | +
| + `request_bytes` + | + ++ Bytes + | + ++ El recuento delta del total de bytes de solicitud de los tipos de solicitud especificados enviados a través de la red. Cada muestra es el número de bytes enviados desde el punto de datos anterior. El recuento se muestrea cada 60 segundos. + | +
| + `response_bytes` + | + ++ Bytes + | + ++ El recuento delta del total de bytes de respuesta de los tipos de respuesta especificados enviados a través de la red. Cada muestra es el número de bytes enviados desde el punto de datos anterior. El recuento se muestrea cada 60 segundos. + | +
| + `received_bytes` + | + ++ Bytes + | + ++ El recuento delta de bytes de los datos de los clientes recibidos de la red. Cada muestra es el número de bytes recibidos desde la muestra de datos anterior. El recuento se realiza cada 60 segundos. + | +
| + `sent_bytes` + | + ++ Bytes + | + ++ El recuento delta de bytes de los datos de los clientes enviados a través de la red. Cada muestra es el número de bytes enviados desde el punto de datos anterior. El recuento se realiza cada 60 segundos. + | +
| + `received_records` + | + ++ Contar + | + ++ El recuento delta de registros recibidos. Cada muestra es el número de registros recibidos desde la muestra de datos anterior. El recuento se realiza cada 60 segundos. + | +
| + `sent_records` + | + ++ Contar + | + ++ El recuento delta de registros enviados. Cada muestra es el número de registros enviados desde el punto de datos anterior. El recuento se realiza cada 60 segundos. + | +
| + `partition_count` + | + ++ Contar + | + ++ El número de particiones. + | +
| + `consumer_lag_offsets` + | + ++ Milisegundos + | + ++ El retraso entre el desplazamiento comprometido de un miembro del grupo y la marca de límite superior de la partición. + | +
| + `successful_authentication_count` + | + ++ Contar + | + ++ El recuento delta de autenticaciones exitosas. Cada muestra es el número de autenticaciones exitosas desde el punto de datos anterior. El recuento se realizó cada 60 segundos. + | +
| + `active_connection_count` + | + ++ Contar + | + ++ El recuento de conexiones autenticadas activas. + | +
| + Con el apoyo de la instrumentación + | + ++ Producto de AWS + | +
|---|---|
| + + | + [DinamoDB](/docs/infrastructure/amazon-integrations/aws-integrations-list/aws-dynamodb-monitoring-integration) + | +
| + ✅ + | + ++ [ElastiCache](/docs/infrastructure/amazon-integrations/aws-integrations-list/aws-elasticache-monitoring-integration) + | +
| + ✅ + | + ++ [Búsqueda elástica](/docs/infrastructure/host-integrations/host-integrations-list/elasticsearch/elasticsearch-integration) + | +
| + + | + [Manguera de datos de Kinesis](/docs/infrastructure/amazon-integrations/aws-integrations-list/aws-kinesis-data-firehose-monitoring-integration) + | +
| + + | + [Flujos de datos de Kinesis](/docs/infrastructure/amazon-integrations/aws-integrations-list/aws-kinesis-data-streams-monitoring-integration) + | +
| + + | + [Lambda](/docs/infrastructure/amazon-integrations/aws-integrations-list/aws-lambda-monitoring-integration) + | +
| + ✅ + | + ++ [MQ](/docs/infrastructure/amazon-integrations/aws-integrations-list/aws-mq-integration) + | +
| + ✅ + | + ++ [MSC](/docs/infrastructure/amazon-integrations/aws-integrations-list/aws-managed-kafka-msk-integration) + | +
| + + | + [SQS](/docs/infrastructure/amazon-integrations/aws-integrations-list/amazon-sqs-monitoring-integration) + | +
| + Paramètres + | + ++ Description + | +
|---|---|
|
+ ` |
+
+ + L'ID de votre application Amazon Q Business. + | +
|
+ ` |
+
+ + Le nom de votre plugin personnalisé. + | +
|
+ ` |
+
+ + La région AWS où se trouvent vos ressources. + | +
|
+ ` |
+
+ + Votre identifiant de compte AWS. + | +
|
+ ` |
+
+ + Le nom du secret dans AWS Secrets Manager. + | +
|
+ ` |
+
+ + Le nom du rôle IAM. + | +
|
+ ` |
+
+ + Une description pour votre plugin personnalisé. + | +
|
+ ` |
+
+ + Le nom du bucket S3 dans lequel votre schéma API est stocké. + | +
|
+ ` |
+
+ + Le nom de clé du fichier de schéma API dans le bucket S3. + | +
\ No newline at end of file
diff --git a/src/i18n/content/fr/docs/agentic-ai/agentic-integration/gemini-integration.mdx b/src/i18n/content/fr/docs/agentic-ai/agentic-integration/gemini-integration.mdx
new file mode 100644
index 00000000000..b5812bf1e38
--- /dev/null
+++ b/src/i18n/content/fr/docs/agentic-ai/agentic-integration/gemini-integration.mdx
@@ -0,0 +1,61 @@
+---
+title: Nouvel agent Relic pour Google Gemini Code Assist
+metaDescription: 'The New Relic agent for Google Gemini extension provides intelligent insights and guidance tailored to optimize application performance, monitor infrastructure, and manage deployments—all seamlessly integrated within Gemini.'
+tags:
+ - Gemini Code Assist Integration
+ - New Relic AI
+ - Agentic AI
+freshnessValidatedDate: never
+translationType: machine
+---
+
+
+
+## Activer New Relic AI [#enable]
+
+New Relic AI est toujours en version préliminaire. Pour utiliser New Relic AI en aperçu, cliquez sur **Demander à l'IA** dans le coin supérieur droit de n'importe quelle page, puis cliquez sur **Commencer**. Vous serez invité à consulter les [Conditions spécifiques génératives de l'IA](https://newrelic.com/termsandconditions/service-specific). Si votre organisation n'a pas encore accepté [la politique de pré-sortie de New Relic](/docs/licenses/license-information/referenced-policies/new-relic-pre-release-policy/), vous serez invité à la consulter ici. Vous pouvez soit annuler, soit cliquer sur **Accepter**. Si vous acceptez ces conditions, elles s'appliqueront à tous vos comptes.
+
+## Discuter avec l'IA [#ask-AI]
+
+Vous pouvez utiliser notre expérience de chat interactif pour travailler avec notre IA à tout moment. Il vous suffit de cliquer sur le bouton 
+
+
+
+Vous pouvez approfondir votre enquête en informant notre assistant IA de votre stack et en posant des questions de suivi. Par exemple, vous pouvez demander :
+
+```
+How often does this error occur? What's the error rate? Is it 1% or 50%?
+```
+
+```
+Which hosts are throwing these errors? Is it across all of my hosts, or is it just affecting one or two of them?
+```
+
+## Analyser les traces d'appels dans la boîte de réception des erreurs [#stack-traces]
+
+L'utilisation de notre assistant IA pour analyser les traces d'appels réduira les changements de contexte et contribuera à accélérer le tri et l'analyse. Pour enquêter sur les traces d'appels dans la boîte de réception des erreurs avec New Relic AI:
+
+1. Allez à 
+
+Vous pouvez approfondir le sujet en posant des questions complémentaires. Par exemple, vous pouvez dire :
+
+```
+I have an Azure environment and am having issues with Redis being periodically unavailable. Can you tell me more about this error? How can I diagnose this issue?
+```
+
+## Combler les lacunes en matière d’alerte [#coverage-gaps]
+
+À mesure que votre équipe et votre système évoluent, il est essentiel de garder une longueur d’avance sur les problèmes potentiels. Les alertes sont votre système d’alerte précoce, mais les maintenir à jour peut être difficile. New Relic AI peut vous aider à identifier les domaines dans lesquels vous pourriez manquer des notifications critiques.
+
+Discutez avec New Relic AI et demandez :
+
+```
+Show me all of my entities that are not covered by an alert.
+```
+
+```
+Show me my OpenTelemetry services that are not covered by an alert.
+```
+
+## Créer un moniteur synthétique [#synthetic]
+
+monitoring synthétique vous aide à détecter et à résoudre de manière proactive les problèmes avant qu'ils n'affectent vos clients. Vous pouvez désormais créer un moniteur Synthétique en discutant avec notre assistant IA. À l'aide de New Relic AI, créez un moniteur de vérification de ping à partir de l'emplacement sélectionné et vérifiez la disponibilité d'une URL à la cadence souhaitée.
+
+Par exemple:
+
+```
+Create a synthetic monitor to check the URL 'newrelic.com' every 10 minutes and name it: 'my awesome monitor'.
+```
+
+Pour créer un moniteur de contrôle de ping avec New Relic AI:
+
+1. Accédez à **[one.newrelic.com > All capabilities](https://one.newrelic.com/all-capabilities)** **All Entities**.
+2. Cliquez sur **Demander à l’IA** dans le coin supérieur droit.
+3. Demandez à l’IA de créer un moniteur de contrôle de ping en fonction de vos paramètres.
+4. Cliquez sur **Créer un moniteur**.
+5. Si vous souhaitez voir vos paramètres ou apporter des modifications, sélectionnez **Accéder au moniteur**.
+6. Sélectionnez **Configurer un autre moniteur** si vous souhaitez des paramètres plus avancés ou accéder à d'autres types de moniteur Synthétique.
+
+## Vérifiez le statut du ticket d'assistance [#support]
+
+Demandez à New Relic AI un résumé de votre ticket d'assistance pour réduire le temps de résolution. Revoir les solutions et les problèmes passés pour rationaliser la gestion. Vous pouvez également vérifier si le ticket reste ouvert ou peut être fermé comme résolu.
+
+Discutez avec l'IA et demandez :
+
+```
+Summarize my support ticket(s).
+```
+
+```
+What is the status of my support ticket(s)?
+```
+
+## Démystifiez votre dashboard [#dashboards]
+
+Dashboards sont un outil incroyablement utile, mais si vous étudiez la télémétrie sur un dashboard que vous ne possédez pas, vous risquez de ne pas comprendre toutes les nuances. New Relic AI peut être votre analyste de données personnel, résumant automatiquement les informations clés et découvrant des informations cachées détaillées directement dans l'UI de New Relic.
+
+1. Allez à | + Action + | + ++ Exemple prompt + | +
|---|---|
| + Pour générer un rapport d'alerte Intelligence + | + ++ `@newrelic I just got paged by an alert? What happened` + | +
| + Pour analyser une alerte spécifique + | + +
+ `@newrelic analyze alert |
+
| + Se concentrer sur un service ou une période spécifique + | + +
+ `@newrelic check for recent alerts related to |
+
| + Action + | + ++ Exemple prompt + | +
|---|---|
| + Pour générer un rapport Change Intelligence + | + +
+ `@newrelic how did my deployment for |
+
| + Pour analyser un déploiement spécifique + | + +
+ `@newrelic analyze deployment |
+
+
+ 
+
+
-
-
@@ -199,4 +179,4 @@ Pour afficher les numéros au format texte, dans le coin droit, cliquez sur 
+
+La page de problème alimentée par l'IA fournit un résumé concis qui comprend l'entité affectée, la gravité du problème, une explication de la condition d'alerte et des détails supplémentaires pour aider au débogage. De plus, la page des problèmes comprend un nouvel onglet « Aperçu » avec trois widgets qui répondent aux questions les plus critiques que se posent les premiers intervenants lorsqu'ils sont confrontés à un problème.
+
+
+
+**Qu'est-ce qui est impacté ?**Les premiers intervenants doivent évaluer le « rayon d’explosion » pour déterminer la gravité d’un problème et décider des prochaines étapes. Ce widget fournit un aperçu de l'entité affectée ainsi que de l'impact sur l'utilisateur final de l'application ou du service. + +**Que s'est-il passé auparavant ?**
De nombreux problèmes informatiques ont tendance à se reproduire. Savoir si un problème s’est déjà produit, pourquoi il s’est produit et comment il a été résolu peut faire gagner un temps précieux aux premiers intervenants lors d’un incident. Pour soutenir cela, les clients peuvent utiliser le widget pour lier leurs documents rétrospectifs ou post-mortem existants. En tirant parti de la génération augmentée de récupération (RAG), la plateforme New Relic AI indexera et stockera ces informations pour une référence contextuelle future. Une fois configuré, les premiers intervenants verront un résumé des problèmes passés similaires, ainsi que des liens vers les documents rétrospectifs pour une analyse détaillée. + +**Que vérifier ?**
Les premiers intervenants ont souvent besoin de conseils contextuels sur les actions immédiates à mener pour atténuer un problème. Ce widget fournit des étapes personnalisées pour les aider à restaurer rapidement les services à des niveaux opérationnels normaux. De plus, l’onglet Causes potentielles identifie les causes probables grâce à une analyse causale, couvrant une gamme d’anomalies et de problèmes de performances possibles. Pour plus d’informations, reportez-vous à l’analyse occasionnelle. + +## Analyse causale + +Le moteur d’analyse causale identifie les symptômes potentiels qui pourraient avoir déclenché un événement d’alerte et suggère des mesures d’atténuation immédiates pour y remédier. + +Considérez un scénario dans lequel une application PHP rencontre une fuite de mémoire, entraînant une défaillance du débit SLI et déclenchant une alerte. Notre moteur enquête en passant du niveau de service à l'application APM, puis au conteneur d'infrastructure pour détecter le symptôme. + +Comment fonctionne le moteur ? Le moteur d'analyse causale utilise des catégories d'analyse distinctes, telles que l'événement de déploiement, les limites des ressources infrastructure , etc. Chaque catégorie est conçue pour répondre à diverses sources potentielles d’anomalies et de problèmes de performances. Ces catégories se concentrent sur des types de données et des mesures spécifiques, permettant une analyse précise et une identification plus précise des relations de cause à effet. + +Pour le moment, New Relic ne prend en charge l'analyse causale que pour l'entité APM. + +
+
+### Actions d'atténuation et visualisations
+
+Pour chaque cause potentielle identifiée, le moteur propose des actions d'atténuation personnalisées qui guident l'utilisateur à travers les étapes nécessaires pour restaurer rapidement les services et l'entité à leurs états de fonctionnement normaux. Nous reconnaissons que bon nombre de nos clients s'appuient généralement sur NRQL pour analyser les requêtes importantes. C'est pourquoi nous fournissons des visuels pertinents à côté de la requête sous-jacente pour chaque requête.
+
+### Analyse générée par New Relic AI
+
+Dans certains scénarios, notre moteur causal peut ne pas identifier une cause générée par un algorithme. Cependant, nous disposons d’informations détaillées qui, combinées aux LLM, peuvent vous offrir des mesures concrètes. Pour accéder à cette fonctionnalité, vous devez avoir le droit New Relic AI activé.
\ No newline at end of file
diff --git a/src/i18n/content/fr/docs/apis/nerdgraph/examples/manage-live-chart-urls-via-api.mdx b/src/i18n/content/fr/docs/apis/nerdgraph/examples/manage-live-chart-urls-via-api.mdx
index ed9228f33f1..1da2a6ab256 100644
--- a/src/i18n/content/fr/docs/apis/nerdgraph/examples/manage-live-chart-urls-via-api.mdx
+++ b/src/i18n/content/fr/docs/apis/nerdgraph/examples/manage-live-chart-urls-via-api.mdx
@@ -1,5 +1,5 @@
---
-title: "Tutoriel NerdGraph\_: répertorier et révoquer les URL des graphiques en direct"
+title: 'NerdGraph tutorial: List and revoke public sharing chart URLs'
tags:
- APIs
- NerdGraph
@@ -11,21 +11,21 @@ translationType: machine
Vous pouvez répertorier et révoquer les URL de graphiques en direct accessibles au public à l'aide de requêtes et de mutations dans [NerdGraph](/docs/apis/nerdgraph/get-started/introduction-new-relic-nerdgraph).
-Pour ce faire :
+To do this:
-1. Accédez à l'[explorateur GraphiQL](https://api.newrelic.com/graphiql).
+1. Go to [GraphiQL Explorer](https://api.newrelic.com/graphiql).
2. [Répertoriez toutes les URL de graphiques en direct](#list) créées dans votre compte New Relic.
3. [Révoquez toute URL de graphique en direct que vous souhaitez](#revoke).
| + paramètres + | + ++ Type de données + | + ++ Est-ce obligatoire ? + | + ++ Description + | +
|---|---|---|---|
| + `eq` + | + ++ Chaîne + | + ++ Oui + | + ++ Définissez la valeur sur + + `organization` + + pour récupérer le rôle des dashboards. + | +
| + paramètres + | + ++ Type de données + | + ++ Est-ce obligatoire ? + | + ++ Description + | +
|---|---|---|---|
| + `id` + | + ++ Chaîne + | + ++ Oui + | + ++ L’ID de l’organisation copié à l’étape précédente. + | +
| + `type` + | + ++ Chaîne + | + ++ Oui + | + ++ Définissez le type sur + + `organization` + + . + | +
| + `name` + | + ++ Chaîne + | + ++ Oui + | + ++ Le nom du rôle. + | +
| + `PermissionId` + | + ++ Int + | + ++ Oui + | + ++ Répertoriez les ID de la fonctionnalité récupérée à l'aide de mutations + + `customerAdministration` + + pour les règles Scorecards et Scorecards. + | +
| + `scope` + | + ++ Chaîne + | + ++ Oui + | + ++ Définissez la portée sur + + `organization` + + . + | +
| + paramètres + | + ++ Type de données + | + ++ Description + | +
|---|---|---|
| + `id` + | + ++ Int + | + ++ L'ID de rôle personnalisé. Copiez et conservez cette pièce d'identité pour une utilisation ultérieure. + | +
| + paramètres + | + ++ Type de données + | + ++ Est-ce obligatoire ? + | + ++ Description + | +
|---|---|---|---|
| + `id` + | + ++ Chaîne + | + ++ Oui + | + ++ L’ID de l’organisation copié à l’étape précédente. + | +
| + paramètres + | + ++ Type de données + | + ++ Est-ce obligatoire ? + | + ++ Description + | +
|---|---|---|---|
| + `roleId` + | + ++ Chaîne + | + ++ Oui + | + ++ L'ID de rôle personnalisé créé dans la section + + [Rôle personnalisé]() + + . + | +
| + `groupId` + | + ++ Chaîne + | + ++ Non + | + ++ L’ID de groupe récupéré à l’étape précédente. + | +
\ No newline at end of file
diff --git a/src/i18n/content/fr/docs/apis/nerdgraph/examples/nerdgraph-scorecards-tutorial.mdx b/src/i18n/content/fr/docs/apis/nerdgraph/examples/nerdgraph-scorecards-tutorial.mdx
new file mode 100644
index 00000000000..2c36d1e4225
--- /dev/null
+++ b/src/i18n/content/fr/docs/apis/nerdgraph/examples/nerdgraph-scorecards-tutorial.mdx
@@ -0,0 +1,1014 @@
+---
+title: "Tutoriel NerdGraph\_: afficher et gérer les dashboards"
+tags:
+ - Scorecards
+ - APIs
+ - NerdGraph
+ - Examples
+metaDescription: How to use New Relic NerdGraph API to create and update Scorecards and rules.
+freshnessValidatedDate: never
+translationType: machine
+---
+
+| + paramètres + | + ++ Type de données + | + ++ Est-ce obligatoire ? + | + ++ Description + | +
|---|---|---|---|
| + `name` + | + ++ Chaîne + | + ++ Oui + | + ++ Le nom du dashboard. + | +
| + `description` + | + ++ Chaîne + | + ++ Non + | + ++ Une brève description du dashboard. + | +
| + `accountId` + | + ++ Chaîne + | + ++ Oui + | + ++ Le compte où l'entité sera stockée. + | +
| + paramètres + | + ++ Type de données + | + ++ Est-ce obligatoire ? + | + ++ Description + | +
|---|---|---|---|
| + `name` + | + ++ Chaîne + | + ++ Oui + | + ++ Le nom de la règle. + | +
| + `description` + | + ++ Chaîne + | + ++ Non + | + ++ Une brève description de la règle. + | +
| + `query` + | + ++ Chaîne + | + ++ Oui + | + ++ Une requête NRQL pour évaluer la conformité. + | +
| + `accounts` + | + ++ Int + | + ++ Oui + | + ++ Liste des ID de compte où la règle doit exécuter la requête. + | +
| + paramètres + | + ++ Type de données + | + ++ Est-ce obligatoire ? + | + ++ Description + | +
|---|---|---|---|
| + `name` + | + ++ Chaîne + | + ++ Oui + | + ++ Le nom de la règle. + | +
| + `description` + | + ++ Chaîne + | + ++ Non + | + ++ Une brève description de la règle. + | +
| + `query` + | + ++ Chaîne + | + ++ Oui + | + ++ Une requête NRQL pour évaluer la conformité. + | +
| + `accounts` + | + ++ Int + | + ++ Oui + | + ++ Liste des ID de compte où la règle doit exécuter la requête. + | +
| + paramètres + | + ++ Type de données + | + ++ Est-ce obligatoire ? + | + ++ Description + | +
|---|---|---|---|
| + `collectionId` + | + ++ Chaîne + | + ++ Oui + | + ++ L'ID de la carte de score pour ajouter les règles. + | +
| + `rules` + | + ++ Chaîne + | + ++ Oui + | + ++ Liste des identifiants de règles à ajouter à la fiche d’évaluation. + | +
| + paramètres + | + ++ Type de données + | + ++ Est-ce obligatoire ? + | + ++ Description + | +
|---|---|---|---|
| + `id` + | + ++ Chaîne + | + ++ Oui + | + ++ L'identifiant unique de la Scorecard. + | +
| + `description` + | + ++ Chaîne + | + ++ Non + | + ++ Description mise à jour du dashboard. + | +
| + `name` + | + ++ Chaîne + | + ++ Oui + | + ++ Nom mis à jour du dashboard. + | +
| + paramètres + | + ++ Type de données + | + ++ Est-ce obligatoire ? + | + ++ Description + | +
|---|---|---|---|
| + `ruleId` + | + ++ IDENTIFIANT + | + ++ Oui + | + ++ L'identifiant unique de la règle. + | +
| + `name` + | + ++ Chaîne + | + ++ Oui + | + ++ Le nom de la règle. + | +
| + `description` + | + ++ Chaîne + | + ++ Non + | + ++ Une brève description de la règle. + | +
| + `query` + | + ++ Chaîne + | + ++ Oui + | + ++ Une requête NRQL pour évaluer la conformité. + | +
| + `queryAccounts` + | + ++ Int + | + ++ Oui + | + ++ Liste des ID de compte où la règle doit exécuter la requête. + | +
| + `enabled` + | + ++ Booléen + | + ++ Non + | + ++ Activer ou désactiver la règle. + | +
| + paramètres + | + ++ Type de données + | + ++ Est-ce obligatoire ? + | + ++ Description + | +
|---|---|---|---|
| + `id` + | + ++ IDENTIFIANT + | + ++ Oui + | + ++ L'ID de la carte de score ou de la règle cible à supprimer. + | +
| + paramètres + | + ++ Type de données + | + ++ Est-ce obligatoire ? + | + ++ Description + | +
|---|---|---|---|
| + `scorecardId` + | + ++ Chaîne + | + ++ Oui + | + ++ L'ID du Scorecard pour récupérer les règles. + | +
| + paramètres + | + ++ Type de données + | + ++ Est-ce obligatoire ? + | + ++ Description + | +
|---|---|---|---|
| + `ruleId` + | + ++ Chaîne + | + ++ Oui + | + ++ L'identifiant unique de la règle. + | +
| + paramètres + | + ++ Type de données + | + ++ Est-ce obligatoire ? + | + ++ Description + | +
|---|---|---|---|
| + `collectionId` + | + ++ Chaîne + | + ++ Oui + | + ++ L'ID obtenu à partir de la réponse + + `FindRuleOwnerCollections` + + . + | +
| + Méthode + | + ++ Niveau + | +
|---|---|
| + console.log + | + ++ `INFO` + | +
| + console.error + | + ++ `ERROR` + | +
| + console.warn + | + ++ `WARN` + | +
| + console.info + | + ++ `INFO` + | +
| + console.debug + | + ++ `DEBUG` + | +
| + console.trace + | + ++ `TRACE` + | +
+
+## Désactiver le log du navigateur [#disable-browser-logs]
+
+Pour désactiver le log du navigateur pour une application de navigateur existante :
+
+| + fonctionnalité + | + ++ Description + | +
|---|---|
| + [**Collecte automatique des logs**](/docs/browser/browser-monitoring/browser-pro-features/browser-logs/get-started/#automatic-log) + | + ++ Capture automatiquement tous les messages du log de la console du navigateur, y compris les logs d'erreur, d'avertissement, d'informations et de débogage, offrant une vue complète de l'activité du front-end. + | +
| + [**Paramètres personnalisables**](/docs/browser/browser-monitoring/browser-pro-features/browser-logs/get-started) + | + ++ * **Activer/désactiver le logging automatique**: activer ou désactiver la collecte log . + * **Configurer le taux d'échantillonnage**: définissez le pourcentage de sessions utilisateur pour la collecte log . + * **Définir les niveaux de verbosité du log**: sélectionnez le niveau de log minimum à capturer, incluant automatiquement tous les niveaux précédents. + | +
| + [**connectez-vous Session Replay**](/docs/browser/browser-monitoring/browser-pro-features/browser-logs/view-browser-logs/logs-in-session-replay) + | + ++ Affichez les logs du navigateur en temps réel avec Session Replay, reliant les fonctionnalités de l'application et l'expérience utilisateur. [En savoir plus sur Session Replay](#session-replay-section). + | +
| + [**se connecter Errors Inbox**](/docs/browser/browser-monitoring/browser-pro-features/browser-logs/view-browser-logs/logs-in-error-inbox) + | + ++ Affichez le log du navigateur ainsi que les erreurs JavaScript pendant le dépannage, facilitant ainsi le débogage et une meilleure analyse des causes profondes. [En savoir plus sur Errors Inbox](#errors-inbox-section) + | +
\ No newline at end of file
diff --git a/src/i18n/content/fr/docs/browser/browser-monitoring/browser-pro-features/browser-logs/view-browser-logs/logs-in-session-replay.mdx b/src/i18n/content/fr/docs/browser/browser-monitoring/browser-pro-features/browser-logs/view-browser-logs/logs-in-session-replay.mdx
new file mode 100644
index 00000000000..f18a1b74c84
--- /dev/null
+++ b/src/i18n/content/fr/docs/browser/browser-monitoring/browser-pro-features/browser-logs/view-browser-logs/logs-in-session-replay.mdx
@@ -0,0 +1,11 @@
+---
+title: connectez-vous Session Replay
+tags: null
+metaDescription: Learn how to view browser logs in context with Session Replay to gain valuable insights into user interactions and application functionality.
+freshnessValidatedDate: never
+translationType: machine
+---
+
+Lorsque vous utilisez la fonctionnalité Session Replay, vous pouvez afficher les logs du navigateur en contexte avec Session Replay. Cette intégration fournit une vue complète des fonctionnalités de l'application et de l'expérience utilisateur, offrant des informations précieuses et détaillées sur l'interaction utilisateur.
+
+
\ No newline at end of file
diff --git a/src/i18n/content/fr/docs/browser/browser-monitoring/browser-pro-features/browser-logs/view-browser-logs/logs-of-a-browser-app.mdx b/src/i18n/content/fr/docs/browser/browser-monitoring/browser-pro-features/browser-logs/view-browser-logs/logs-of-a-browser-app.mdx
new file mode 100644
index 00000000000..319fc230cf5
--- /dev/null
+++ b/src/i18n/content/fr/docs/browser/browser-monitoring/browser-pro-features/browser-logs/view-browser-logs/logs-of-a-browser-app.mdx
@@ -0,0 +1,31 @@
+---
+title: Log pour l'application de navigateur
+tags: null
+metaDescription: Learn how to view and analyze logs for your browser app using New Relic.
+freshnessValidatedDate: never
+translationType: machine
+---
+
+Pour afficher le log des performances d’une application de navigateur :
+
+
+
+## Quelle est la prochaine étape ?
+
+* Vous pouvez également afficher les logs du navigateur en contexte avec Session Replay (si vous utilisez la fonctionnalité Session Replay ) ou à côté des erreurs JavaScript dans Errors Inbox. Reportez-vous [à la connexion Session Replay](#session-replay-section) et [à la connexion à la boîte de réception des erreurs](#js-errors-section) pour plus de détails.
+
+* Pour plus d'informations sur l'UI du log, voir [Utiliser UI du log](/docs/logs/ui-data/use-logs-ui) pour plus de détails.
\ No newline at end of file
diff --git a/src/i18n/content/fr/docs/browser/browser-monitoring/browser-pro-features/sequence-filtering.mdx b/src/i18n/content/fr/docs/browser/browser-monitoring/browser-pro-features/sequence-filtering.mdx
new file mode 100644
index 00000000000..9027af02fa0
--- /dev/null
+++ b/src/i18n/content/fr/docs/browser/browser-monitoring/browser-pro-features/sequence-filtering.mdx
@@ -0,0 +1,104 @@
+---
+title: Filtrage de séquence
+metaDescription: Play back user interactions to debug faster and improve page performance.
+freshnessValidatedDate: '2025-02-25'
+translationType: machine
+---
+
+La fonctionnalité **de filtrage de séquence** vous aide à filtrer la relecture de session en fonction d'une séquence spécifique d'événements enregistrés lors de l'interaction de l'utilisateur. Cette fonctionnalité est conçue pour vous aider à naviguer efficacement parmi de nombreux enregistrements de session sur la page **de liste des sessions**, rendant la recherche de rediffusions pertinentes transparente.
+
+## Fonctionnalité clé
+
+* **Filtrage de séquence d'événements**: Vous pouvez filtrer les rediffusions en spécifiant une séquence d'événements dans un ordre particulier, comme un utilisateur effectuant une recherche suivie de l'ajout d'un article à son panier.
+* **Filtres personnalisables**: vous pouvez sélectionner des attributs, des opérateurs et des valeurs pour définir leurs filtres de séquence.
+* **Prise en charge de plusieurs actions**: vous pouvez spécifier jusqu'à cinq actions dans une séquence.
+* **Filtrage flexible**: les filtres peuvent être appliqués dans n'importe quel ordre, vous permettant de combiner des filtres de séquence avec d'autres types de filtres tels que la durée.
+
+## Personnaliser la vue
+
+Par défaut, la **séquence** est définie sur **Tout**. Vous pouvez personnaliser la vue en sélectionnant le filtre **Séquence = Tout** et en cliquant sur la boîte de dialogue **Configurer une séquence de filtrage** pour définir leurs filtres de séquence.
+
+| + Action + | + ++ Description + | +
|---|---|
| + Attribut + | + ++ Sélectionnez un attribut : + + * **URL consultée**: Filtrez les données en fonction de l'URL de la page consultée par l'utilisateur. + + * **Action de la page**: filtrez les données en fonction de l'interaction de l'utilisateur avec la page. + + * **Saisie au clavier**: filtrez les données en fonction de la saisie au clavier de l'utilisateur. Vous pouvez élargir davantage la recherche en sélectionnant les options ci-dessous : + + * **cible**: Sélectionnez l'élément cible où la saisie au clavier a été effectuée. + * **cible ID**: Sélectionnez l'ID cible où la saisie au clavier a été effectuée. + * **Classe cible**: Sélectionnez la classe cible dans laquelle la saisie au clavier a été effectuée. + + * **clics du utilisateur**: Filtrez les données en fonction des clics du utilisateur. + | +
| + Opérateur + | + ++ Sélectionnez un opérateur parmi les options ci-dessous : + + * **=** : Où la valeur fournie est égale à la valeur de l'attribut incident. + * **Comme** : lorsque la valeur fournie est similaire à la valeur de l’attribut incident. + | +
| + Valeur + | + ++ Recherchez ou saisissez une valeur. + | +
\ No newline at end of file
diff --git a/src/i18n/content/fr/docs/browser/browser-monitoring/browser-pro-features/session-replay/iframes.mdx b/src/i18n/content/fr/docs/browser/browser-monitoring/browser-pro-features/session-replay/iframes.mdx
new file mode 100644
index 00000000000..da4bbc35fb3
--- /dev/null
+++ b/src/i18n/content/fr/docs/browser/browser-monitoring/browser-pro-features/session-replay/iframes.mdx
@@ -0,0 +1,25 @@
+---
+title: Relecture de session et iframes
+metaDescription: Understand and troubleshoot common issues with session replay and iframes behavior
+freshnessValidatedDate: '2025-02-19T00:00:00.000Z'
+translationType: machine
+---
+
+Lorsqu'elle est activée, la fonctionnalité de relecture de session peut ne pas afficher les données de relecture pour le contenu iframe. Cette limitation résulte du comportement de la relecture de session dans les scénarios iframe, qui varie en fonction de l'origine de l'iframe et du placement de l'agent du navigateur.
+
+Supposons qu’une page Web contienne une fenêtre de niveau supérieur et un enfant `iframe`. Les comportements de relecture de session, basés sur le placement de l'agent du navigateur, sont les suivants :
+
+* **Iframes de même origine**:
+
+ * Avec l'agent du navigateur dans la fenêtre de niveau supérieur, Session Replay enregistre à la fois la fenêtre et le contenu `iframe` .
+ * Avec l'agent du navigateur uniquement dans le `iframe`, Session Replay enregistre uniquement le contenu dans le `iframe`.
+ * Avec l'agent du navigateur dans la fenêtre de niveau supérieur et dans le `iframe`, Session Replay enregistre chaque contexte indépendamment, ce qui donne lieu à deux sessions distinctes.
+
+* **Iframes multi-origines**:
+
+ * Avec l'agent du navigateur dans la fenêtre de niveau supérieur, Session Replay capture uniquement le contenu de la fenêtre ; le contenu `iframe` ne sera pas visible dans la relecture.
+ * Avec l'agent de navigateur dans l'iframe, Session Replay capture uniquement le contenu `iframe` .
+
+**Limites:**
+
+* Session Replay ne prend pas en charge les éléments `` .
\ No newline at end of file
diff --git a/src/i18n/content/fr/docs/browser/browser-monitoring/browser-pro-features/upload-source-maps-un-minify-js-errors.mdx b/src/i18n/content/fr/docs/browser/browser-monitoring/browser-pro-features/upload-source-maps-un-minify-js-errors.mdx
index ca51dcdf13b..4d22fe97f60 100644
--- a/src/i18n/content/fr/docs/browser/browser-monitoring/browser-pro-features/upload-source-maps-un-minify-js-errors.mdx
+++ b/src/i18n/content/fr/docs/browser/browser-monitoring/browser-pro-features/upload-source-maps-un-minify-js-errors.mdx
@@ -161,7 +161,7 @@ Vous avez même des difficultés à générer des cartes sources ? Chaque syst
```bash
uglifyjs [source files] \
-o bundle.min.js \
- -c -m
+ -c -m \
--source-map "includeSources=true"
```
diff --git a/src/i18n/content/fr/docs/browser/browser-monitoring/installation/install-browser-monitoring-agent.mdx b/src/i18n/content/fr/docs/browser/browser-monitoring/installation/install-browser-monitoring-agent.mdx
index b4968ffbe6d..1fcce947035 100644
--- a/src/i18n/content/fr/docs/browser/browser-monitoring/installation/install-browser-monitoring-agent.mdx
+++ b/src/i18n/content/fr/docs/browser/browser-monitoring/installation/install-browser-monitoring-agent.mdx
@@ -26,7 +26,7 @@ Il existe quatre façons d’installer l’agent du navigateur. En fonction de v
|
+ |
+
+
+ |
+
|---|---|
| + Renommer et continuer à collecter des données + | + +
+ Cette option est utile lorsque vous souhaitez simplement donner à une application un nom d'affichage différent (alias).
+
+ Pour modifier l'alias qui apparaît dans l'UI de New Relic, utilisez la [page |
+
| + Arrêtez de signaler sous l'ancien nom + | + +
+ Pour arrêter de signaler des données sous l'ancien nom et commencer à collecter des données avec un nouveau nom (identifiant d'application), utilisez le [fichier de configuration](/docs/agents/manage-apm-agents/app-naming/rename-your-application#app-identifier) de l'agent APM. Cela modifie l'identifiant que [le collecteur de données](/docs/accounts-partnerships/education/getting-started-new-relic/glossary#collector) de New Relic utilise pour distinguer une application d'une autre. Sur la base du [calendrier de conservation des données](/docs/accounts-partnerships/accounts/account-billing-usage/data-retention), New Relic conservera les données historiques collectées sous l'ancien nom et collectera et agrégera les données sous le nouveau nom. Si [une ou plusieurs applications partagent le même nom](/docs/agents/manage-apm-agents/app-naming/use-multiple-names-app), leurs données seront agrégées dans l'UI.
+
+ |
+
+
+|
+ |
+
+
+ |
+
|---|---|
| + Modifier l'ordre de tri + | + ++ Sélectionnez n’importe quel en-tête de colonne pour trier la liste par ordre croissant ou décroissant. + | +
| + Afficher un résumé de monitoring d'une application par navigateur + | + +
+ Sélectionnez le nom de l'application pour accéder à la [page |
+
| + Rechercher des applications spécifiques + | + +
+ Pour affiner la recherche, saisissez un ou plusieurs caractères dans le filtre |
+
| + Afficher les détails des performances du navigateur pour une application + | + +
+ Sélectionnez l’un des liens correspondants. Par exemple, sélectionnez le lien |
+
| + Retour à l'index des applications du navigateur + | + +
+ Depuis n’importe quelle page du navigateur, sélectionnez 
+ |
+
|
+ |
+
+
+ |
+
|---|---|
| + Horaires de peinture + | + ++ Les attributs [`firstPaint`](/attribute-dictionary/?event=BrowserInteraction&attribute=firstPaint) et [`firstContentfulPaint`](/attribute-dictionary/?event=BrowserInteraction&attribute=firstContentfulPaint) dans l'événement `BrowserInteraction`, `PageView` et [`PageViewTiming`](/docs/browser/new-relic-browser/page-load-timing-resources/pageviewtiming-async-or-dynamic-page-details) ne sont [compatibles qu'avec](https://developer.mozilla.org/en-US/docs/Web/API/PerformancePaintTiming#Browser_compatibility): + + * Chrome 60 ou supérieur pour ordinateur de bureau et mobile (Android WebView et Chrome pour Android) + * Opera 47 ou supérieur pour ordinateur de bureau + * Opera 44 ou supérieur pour mobile Android + * Internet Samsung pour mobile + | +
| + AJAX + | + ++ [La fonctionnalité de synchronisation AJAX](/docs/browser/new-relic-browser/dashboard-details/ajax-dashboard) n'est pas disponible avec : + + * Chrome pour iPhone et iPad + * IE 7 et 8 + | +
| + `PageAction` événement + | + ++ [`PageAction` événement](/docs/insights/new-relic-insights/adding-querying-data/inserting-custom-events-attributes-insights-javascript-api) nécessite un navigateur prenant entièrement en charge les domaines `XMLHttpRequests` multi-domaines. Internet Explorer versions 9 et antérieures ne peut pas enregistrer l'événement `PageAction` . En savoir plus sur [l'interrogation de vos données](/docs/using-new-relic/data/understand-data/query-new-relic-data). + | +
| + trace de session + | + ++ [les traces de session](/docs/browser/new-relic-browser/dashboard-details/session-traces-exploring-webpages-life-cycle) ne sont signalées qu'à partir des navigateurs qui prennent en charge la [spécification Resource Timing](http://www.w3.org/TR/resource-timing/). + | +
| + SHA-256 + | + ++ New Relic ne peut monitorer que les navigateurs compatibles avec [SHA-256](https://support.globalsign.com/customer/portal/articles/1499561-sha-256-compatibility). + | +
| + Exceptions de compatibilité + | + ++ Commentaires + | +
|---|---|
| + Zone.js + | + +
+ Si vous utilisez AngularJS et que vous souhaitez utiliser notre [fonctionnalité monitoring SPA](/docs/browser/single-page-app-monitoring/get-started/welcome-single-page-app-monitoring), notez que les versions Zone.js 0.6.18 à 0.6.24 ne sont pas compatibles avec le navigateur. Dans tous les cas, l'agent de navigateur |
+
| + Cypress.io + | + ++ Browser n'est pas en mesure d' instrumentercorrectement les méthodes `open` et `send` des requests lorsque les tests sont exécutés dans Cypress. Cela entraînera l'apparition de l'erreur suivante : + + ``` + Cannot set property 'status' of undefined + ``` + + Cela n'affectera que les clients exécutant des tests avec l'agent de navigateur présent dans leur code. Les applications de production ne devraient pas être affectées. + | +
| + html2pdf.js + | + ++ Cette bibliothèque n'est pas compatible avec notre [agent Pro+SPA](/docs/browser/browser-monitoring/installation/install-browser-monitoring-agent#agent-types) en raison de la manière dont cette bibliothèque enveloppe ses promesses. Si vous utilisez cette bibliothèque, nous vous recommandons de sélectionner le [type d'agent Pro](/docs/browser/browser-monitoring/installation/install-browser-monitoring-agent#agent-types). + | +
| + MooTools + | + ++ L'agent de navigateur n'est pas compatible avec les versions de MooTools antérieures à `1.6.0` ou avec toute version incluant la couche de compatibilité mootools. Si la migration depuis MooTools n'est pas une option, nous vous recommandons d'utiliser la version `1.6.0-nocompat`. + | +
| + Exception CSP + | + ++ Commentaires + | +
|---|---|
| + `unsafe-inline` + | + ++ Ajoutez à la directive `script-src` ou à la directive de secours `default-src` . Ceci est nécessaire car l'agent est installé en incluant un script en ligne. + | +
| + `https://js-agent.newrelic.com` + | + ++ Ajoutez à la directive `script-src` ou à la directive de secours `default-src` . C'est ici que sont hébergés les fichiers de script supplémentaires dont l'agent a besoin. + | +
| + `*.nr-data.net` + | + ++ L'agent tente d'envoyer des frais aux sous-domaines de `nr-data.net`, qui peuvent varier selon le type de compte. Si `*.nr-data.net` est trop inclusif pour vos besoins, chaque sous-domaine individuel devra être ajouté : + + * Comptes basés aux États-Unis : + + * `https://bam.nr-data.net` + * `https://bam-cell.nr-data.net` + + * Comptes basés dans l'UE : + + * `https://bam.eu01.nr-data.net` + + * Comptes conformes au programme FedRAMP : + + * `https://gov-bam.nr-data.net` + + * Ajoutez à la directive `connect-src` ou à la directive de secours `default-src` . La directive `connect-src` affecte les URL que le script peut appeler (par exemple, en utilisant l'interface XMLHttpRequest). Si vous avez des restrictions CSP spécifiquement autour de cette directive, ajoutez cette URL comme exception. + | +
| + Agent APM + | + ++ Version minimale + | + ++ Note d'assistance + | +
|---|---|---|
| + Go + | + ++ [2.5.0](/docs/release-notes/agent-release-notes/go-release-notes/go-agent-25/) + | + ++ Prend en charge l'injection du snippet JavaScript via l'API `Transaction.BrowserTimingHeader`. Vous devrez écrire du code supplémentaire pour modifier l'élément de script afin d'ajouter l'attribut `nonce` . Voir [Ajouter monitoring des navigateurs pour les applications Go](/docs/apm/agents/go-agent/features/add-browser-monitoring-your-go-apps/). + | +
| + Java + | + ++ [7.6.0](/docs/release-notes/agent-release-notes/java-release-notes/java-agent-760/) + | + ++ Prend en charge l'ajout de `nonce` via les API `getBrowserTimingHeader` et `getBrowserTimingFooter` . Voir la [Java documentation monitoring des agents des navigateurs](/docs/apm/agents/java-agent/instrumentation/instrument-browser-monitoring-java-agent-api/). + | +
| + .NET + | + ++ [8.39.0.0](/docs/release-notes/agent-release-notes/net-release-notes/net-agent-83900/) + | + ++ Prend en charge l'ajout de `nonce` via l'API `GetBrowserTimingHeader` . Voir la [documentation monitoring des agents .NET des navigateurs](/docs/apm/agents/net-agent/other-features/browser-monitoring-net-agent/). + | +
| + Node.js + | + ++ [4.3.0](/docs/release-notes/agent-release-notes/nodejs-release-notes/node-agent-430/) + | + ++ Prend en charge l'ajout de `nonce` via l'API `getBrowserTimingHeader` . Consultez la [Node.js documentation monitoring de l'agent des navigateurs](/docs/apm/agents/nodejs-agent/extend-your-instrumentation/browser-monitoring-nodejs-agent/). + | +
| + Ruby + | + ++ [7.1.0](/docs/release-notes/agent-release-notes/ruby-release-notes/ruby-agent-710/) + | + ++ Prend en charge l'ajout de `nonce` via l'API `browser_timing_header` . Consultez la [Ruby documentation monitoring de l'agent des navigateurs](/docs/apm/agents/ruby-agent/features/new-relic-browser-ruby-agent/). + | +
+
+Dans cette procédure, vous utilisez New Relic Browser pour découvrir la cause de ces erreurs et déboguer votre application en temps opportun.
+
+
+ 
+ 
+
+ Ici, vous voyez des pics indiquant que votre application comporte des erreurs Javascript.
+ 
+
+ Cela vous amène à la page 
+ 
+
+ Ici, vous voyez 
+ 
+
+ 
+
+ Ici, vous voyez plus de détails liés à votre erreur particulière, notamment 
+
+ Ici, vous voyez la trace d'appels de votre erreur.
+ 
+
+ Ici, vous voyez une option pour télécharger la carte source.
+ 
+
+ Cela ouvre une fenêtre d'explorateur de fichiers pour vous permettre de télécharger la carte source à partir de votre stockage local. Recherchez et téléchargez votre carte source à partir du répertoire *build/static/js* de votre projet.
+
+ 
+
+ Ici, vous voyez le fichier particulier et la ligne de code qui génère cette erreur. Notez qu'à la ligne 119, le Relicstaurants
+ by New Relic
+
+
+## Résumé
+
+Pour récapituler, vous avez observé une erreur dans votre application et utilisé le navigateur New Relic pour :
+
+1. Vérifiez le pourcentage d'erreur
+2. Analysez les erreurs JS dans votre application
+3. Comprendre l'instance d'erreur
+4. Déboguer l'erreur JS en téléchargeant la carte source
+
+
+
+Oh oh! Vos clients n'ont pas l'air contents. Il est temps d'utiliser monitoring des navigateurs New Relic pour découvrir la source du retard.
+
+
+
+ Le Largest Contentful Paint (LCP) représente la vitesse à laquelle le contenu principal d'une page Web est chargé. Idéalement, le contenu ne devrait pas prendre plus d’une ou deux secondes à charger. Ici, vous voyez que votre site se charge en plus de 5 secondes. Pas étonnant que vos techniciens se plaignent !
+
+ Mais qu'est-ce qui cause ce retard ? arrière-plan?
+ 
+
+ Cliquez sur 
+
+ Le graphique indique que le back-end a pris au maximum 140 millisecondes pour traiter la demande dans le pire des cas. Cela signifie-t-il que votre frontend provoque des retards ?
+
+ Cliquez sur 
+
+ Voilà le problème ! Le graphique indique que le retard se produit sur le frontend.
+ 
+ 
+
+ Le graphique indique que 
+
+ Cela vous amène à 
+ 
+
+ Notez que la page initiale prend près de 90 % du temps à charger.
+
+ 
+
+ Cliquez dessus pour voir ses détails.
+
+ 
+
+ Cette page vous montre 
+
+ Vous savez maintenant que la page initiale prend beaucoup de temps à s'afficher, ce qui ralentit votre application. Ensuite, nous observons le 
+ 
+ 
+
+ 
+
+ Cela vous amène à la page de détails 
+ 
+ 
+ 
+ 
+
+ Notez que c'est une image. En particulier, c'est l'image d'arrière-plan de votre application qui prend 5 à 6 secondes à charger et qui provoque le retard.
+ 
+ 
+
+ L'UI vous guidera tout au long de l'installation de notre agent de navigateur.
+ 
+ 
+
+ Ceci vous donne un snippet de code JavaScript pour permettre monitoring des navigateurs. Copiez-le dans votre presse-papiers.
+
+ 
+ 
+
+ Saisissez votre adresse de livraison et recherchez des restaurants pour commencer.
+
+ 
+
+ Ici, vous voyez une liste de restaurants où vous pouvez commander de la nourriture.
+ 
+ 
+ 
+ 
+
+ Votre commande a été passée avec succès.
+
+ 
+
+ Ensuite, vous utilisez un simulateur pour générer plus de trafic vers votre application.
+ |
+ |
+
+
+ |
+
|---|---|
|
+ API de spécification de synchronisation de navigation |
+
+
+ Pour les navigateurs qui implémentent l'API [de spécification de synchronisation de navigation](http://www.w3.org/TR/navigation-timing/ "Le lien s'ouvre dans une nouvelle fenêtre"), les informations de synchronisation de chargement de page sont lues à partir du navigateur et signalées à New Relic par l'agent du navigateur. Les valeurs appropriées sont simplement lues à partir de l'objet de synchronisation des performances de la page Web pour capturer les informations de synchronisation.
+
+ * |
+
|
+ API de spécification de synchronisation de navigation |
+
+
+ Pour les navigateurs qui n'implémentent pas l'API de spécification de synchronisation de navigation, nous nous appuyons sur le [cookie NREUM](/docs/browser/new-relic-browser/miscellaneous/new-relic-cookies#nreum) et l'agent du navigateur pour collecter des informations de synchronisation. |
+
| + instrumentationsupplémentaire + | + ++ Browser utilise également : + + * instrumentation de l'objet `XMLHttpRequest` pour collecter [des données de synchronisation AJAX](/docs/browser/new-relic-browser/browser-pro-features/ajax-dashboard-identifying-time-consuming-calls). + * instrumentation de fonctions JavaScript pour collecter [les erreurs JavaScript](/docs/errors-inbox/browser-tab/) non détectées. + | +
| + API de synchronisation des ressources + | + ++ Pour les navigateurs qui implémentent l' [API Resource Timing](http://www.w3.org/TR/resource-timing/), l'agent du navigateur lit et signale les détails [de la trace de session](/docs/browser/new-relic-browser/browser-pro-features/session-traces-exploring-webpages-life-cycle) . + | +
| + monitoringdes applications monopages (SPA) + | + ++ Pour [le monitoring du SPA](/docs/browser/new-relic-browser/getting-started/compatibility-requirements-browser-monitoring#spa), nous avons besoin de l'API [de spécification de synchronisation de navigation](http://www.w3.org/TR/navigation-timing/) et de l'API `addEventListener` . + | +
|
+ |
+
+
+ |
+
|---|---|
| + Récupérer le script de l'agent + | + ++ Une fois la page suivante chargée via https + | +
| + Envoyer les données de temps de chargement de la page + | + ++ Une fois la page suivante chargée via https + | +
| + Envoyer les données de temps d'affichage de la page (`PageViewTiming`) + | + ++ Les données sont envoyées 10 secondes après le chargement initial de la page, puis toutes les 30 secondes par la suite. + | +
| + Envoyer des données d'erreur AJAX et JavaScript + | + ++ Une fois toutes les 10 secondes lorsqu'il y a une activité via https + | +
| + Envoyer les données de trace de session + | + ++ Toutes les dix secondes lorsqu'il y a une activité et qu'une trace de session se produit via https + | +
| + Envoyer des données SPA + | + ++ A la fin d'une interaction via https + | +
+
+
+
+| + Données complémentaires + | + ++ Commentaires + | +
|---|---|
| + `firstPaint` et `firstContentfulPaint` + | + ++ Les attributs [`firstPaint`](/attribute-dictionary/?event=PageViewTiming&attribute=firstPaint) et [`firstContentfulPaint`](/attribute-dictionary/?event=PageViewTiming&attribute=firstContentfulPaint) sont déjà disponibles avec les événements `BrowserInteraction` et `PageView` . Cependant, ils ne sont pas toujours capturés de manière fiable avant le déclenchement de l'événement de chargement de la fenêtre. + + L'utilisation de `PageViewTiming` vous donne un moyen de capturer ces métriques même si elles se produisent après le temps de chargement de la page d'origine. Cela vous donne une meilleure compréhension de la corrélation entre la réactivité de cet événement de chargement et le rendu visuel de votre contenu. + | +
| + `largestContentfulPaint` + | + ++ La métrique [`largestContentfulPaint`](/attribute-dictionary/?event=PageViewTiming&attribute=largestContentfulPaint) est disponible avec [la version d'agent 1163 ou supérieure](/docs/release-notes/new-relic-browser-release-notes/browser-agent-release-notes/browser-agent-v1163). Il indique le temps de rendu du plus grand élément de contenu visible dans la fenêtre d'affichage. + + Les recherches de Google ont révélé que regarder le moment où l'élément le plus volumineux était rendu était un moyen plus précis de mesurer le moment où le contenu principal d'une page est chargé et utile. Pour plus d'informations sur cette métrique, y compris les limitations et les considérations, consultez le [projet w3c](https://wicg.github.io/largest-contentful-paint/). + + Nous rapportons également l'attribut de score de décalage de disposition cumulé avec LCP. Cet attribut est signalé comme `cumulativeLayoutShift`. + + Le contenu le plus volumineux est l'une des trois métriques identifiées par Google comme les [éléments essentiels du Web](https://web.dev/vitals/). Les valeurs LCP jusqu'à 2,5 secondes sont considérées comme « bonnes », celles entre 2,5 et 4 secondes sont considérées comme « à améliorer » et celles supérieures à 4 secondes sont considérées comme « médiocres ». + | +
| + `firstInteraction` et `interactionToNextPaint` + | + ++ Avec l'ajout de [`firstInteraction`](/attribute-dictionary/?event=PageViewTiming&attribute=firstInteraction) et [`interactionToNextPaint`](/attribute-dictionary/?event=PageViewTiming&attribute=interactionToNextPaint), vous pouvez rapidement déterminer la manière dont votre utilisateur interagit avec ce contenu visuel. Ces métriques vous indiquent non seulement quand ils ont interagi, mais également quel type d' interaction (mousedown, pointerdown, etc.) et combien de temps il leur a fallu pour recevoir une réponse de votre site. + + La métrique `interactionToNextPaint` se situe entre les métriques `FirstContentfulPaint` et Time to Interactive (TTI). Il mesure le temps entre le moment où une première entrée peut être effectuée et le moment où le thread principal du navigateur est capable de répondre à toute interaction. + + Nous rapportons également l'attribut de score de décalage de mise en page cumulé (CLS) au moment de la première interaction de l'utilisateur. Cet attribut est signalé comme `cumulativeLayoutShift.` + + L'INP est l'une des trois mesures identifiées par Google comme les [principaux éléments essentiels du Web](https://web.dev/vitals/). Un score INP de 200 ms ou moins est considéré comme « bon », entre 200 et 500 ms est considéré comme « à améliorer » et au-dessus de 500 ms est considéré comme « médiocre ». + | +
| + `cumulativeLayoutShift` + | + ++ [Le décalage de disposition cumulatif (CLS)](https://web.dev/cls/) est disponible avec [l'agent v1177 ou supérieur](/docs/release-notes/new-relic-browser-release-notes/browser-agent-release-notes/browser-agent-v1177). Le CLS est une mesure importante et centrée sur l'utilisateur pour mesurer [la stabilité visuelle](https://web.dev/user-centric-performance-metrics/#types-of-metrics), car il permet de quantifier la fréquence à laquelle l'utilisateur subit des changements de mise en page inattendus. Un CLS faible contribue à garantir que la page est [agréable](https://web.dev/user-centric-performance-metrics/#questions). + + Le décalage cumulé de mise en page est l'une des trois mesures identifiées par Google comme les [éléments essentiels du Web](https://web.dev/vitals/). Les scores CLS jusqu'à 0,1 sont considérés comme « bons », ceux compris entre 0,1 et 0,25 sont considérés comme « à améliorer » et ceux supérieurs à 0,25 sont considérés comme « médiocres ». + | +
| + `interactionToNextPaint` + | + ++ [L'interaction avec la peinture suivante (INP)](https://web.dev/inp/) est disponible avec [l'agent v1227 ou supérieur](/docs/release-notes/new-relic-browser-release-notes/browser-agent-release-notes/browser-agent-v1227). INP est une nouvelle mesure permettant de mesurer [la réactivité d'exécution](https://web.dev/user-centric-performance-metrics/#types-of-metrics) et les performances perçues par l'utilisateur. Il mesure la plus grande latence entre l'interaction de l'utilisateur et la réponse de la page ou les repeintures. Il s'agit d'une mesure expérimentale mais identifiée comme significative ajoutée dans [Web Vitals](https://github.com/GoogleChrome/web-vitals) v3. + + Les scores INP jusqu'à 200 ms sont considérés comme « bons », entre 200 et 500 ms sont considérés comme « à améliorer » et au-dessus de 500 ms sont considérés comme « médiocres ». + | +
| + `timingName` + | + ++ Vous pouvez consulter différents types d'activités avec l'attribut `timingName`, tels que `firstPaint`, `firstContentfulPaint`, `firstInteraction`, `largestContentfulPaint`, `pageHide` et `windowUnload`. Par exemple, un événement `PageViewTiming` peut avoir une `timingName` de `firstPaint` et une valeur `firstPaint` de `.03`. L'événement inclura également tous les attributs par défaut inclus avec l'événement standard `BrowserInteraction` et `PageView` . + | +
| + `elementId` + | + ++ Il s'agit du `Id`, s'il est spécifié, de l'élément `largestContentfulPaint` . Cette valeur ne sera signalée qu'avec la métrique LCP. Cette valeur peut être `null`. + | +
| + `elementSize` + | + ++ Il s'agit de la taille signalée de l'élément `largestContentfulPaint` . Cette valeur ne sera signalée qu'avec la métrique LCP. + | +
| + `pageHide` + | + ++ L'événement `pageHide`, disponible avec [l'agent v1177 ou supérieur](/docs/release-notes/new-relic-browser-release-notes/browser-agent-release-notes/browser-agent-v1177), est envoyé lorsque le document devient masqué pour l'utilisateur. Dans la pratique moderne, cela signale de manière très fiable la *fin potentielle* d’une session utilisateur. Cet événement accompagne toujours `windowUnload` si cela se produit, mais il peut également se déclencher séparément lorsque l'utilisateur change d'onglet. Dans ce cas, le déchargement n'est pas déclenché. + + Nous signalons également l'attribut de score de décalage de disposition cumulé (CLS) avec `pageHide`. Cet attribut est signalé comme `cumulativeLayoutShift.` + | +
| + `windowLoad` + | + ++ L'événement `windowLoad` est disponible avec [l'agent v1177 ou supérieur](/docs/release-notes/new-relic-browser-release-notes/browser-agent-release-notes/browser-agent-v1177). Cette option est déclenchée lorsque la page entière est chargée, y compris toutes les ressources dépendantes telles que les feuilles de style et les images. Pour obtenir de la documentation complémentaire et la compatibilité du navigateur pour l'événement `windowLoad`, consultez le [site MDN Web Docs](https://developer.mozilla.org/en-US/docs/Web/API/Window/load_event). + + Nous signalons également l'attribut de score de décalage de disposition cumulé (CLS) avec `windowLoad`. Cet attribut est signalé comme `cumulativeLayoutShift.` + | +
| + `windowUnload` + | + ++ L'événement `windowUnload`, disponible avec [l'agent v1163 ou supérieur](/docs/release-notes/new-relic-browser-release-notes/browser-agent-release-notes/browser-agent-v1163), est envoyé lorsque le déchargement de la page est détecté. Dans la pratique moderne, cela est basé sur le déclenchement de l'événement de masquage de page de la fenêtre et signifie que l'utilisateur navigue ailleurs. + + Nous signalons également l'attribut de score de décalage de disposition cumulé (CLS) avec `windowUnload`. Cet attribut est signalé comme `cumulativeLayoutShift`. + | +
| + Métriques + | + ++ Versions de navigateur prises en charge + | +
|---|---|
| + `cumulativeLayoutShift` + | + ++ * Chrome 79 + * métrique est élevé à stable ; les changements dans la définition métrique seront signalés dans ce log. + * Chrome 77 + * métrique exposée via API : [décalage de mise en page cumulé](https://web.dev/cls/) disponible via [l'API d'instabilité de mise en page](https://github.com/WICG/layout-instability) + | +
| + `firstPaint` + + `firstContentfulPaint` + | + ++ * Chrome 60 ou supérieur pour ordinateur de bureau et mobile (Android WebView et Chrome pour Android) + * Opera 47 ou supérieur pour ordinateur de bureau + * Opera 44 ou supérieur pour mobile Android + * Internet Samsung pour mobile + | +
| + `largestContentfulPaint` + | + ++ * Chrome 77 ou supérieur pour ordinateur de bureau et mobile + | +
| + `interactionToNextPaint` + | + ++ * Chrome 96 ou supérieur + + * Edge 96 ou supérieur + + Selon l'API Web-Vitals, la prise en charge est déterminée par [PerformanceEventTiming.interactionId](https://developer.mozilla.org/en-US/docs/Web/API/PerformanceEventTiming/interactionId#browser_compatibility). + | +
| + `pageHide` + | + ++ Cet événement est actuellement pris en charge par la plupart des versions de navigateur modernes, à l'exception de Safari inférieur à 14.1 (bureau) ou 14.5 (iOS). [Matrice de compatibilité via la documentation MDN](https://developer.mozilla.org/en-US/docs/Web/API/Document/visibilitychange_event#browser_compatibility). + | +
| + `windowLoad` + | + ++ Cet événement est actuellement pris en charge par tous les navigateurs sur ordinateur et mobile. [Matrice de compatibilité via la documentation MDN](https://developer.mozilla.org/en-US/docs/Web/API/Window/load_event#Browser_compatibility). + | +
| + `windowUnload` + | + ++ Cet événement est actuellement pris en charge par tous les navigateurs sur ordinateur et mobile. [Matrice de compatibilité via la documentation MDN](https://developer.mozilla.org/en-US/docs/Web/API/Window/pagehide_event#Browser_compatibility). + | +
| + scénario + | + ++ Lite + | + ++ Pro + | + ++ Pro + SPA + | +
|---|---|---|---|
| + Taille du script en ligne + | + ++ 10,2 Ko + | + ++ 15,5 Ko + | + ++ 17,5 Ko + | +
| + Taille du script téléchargé + | + ++ 15,3 Ko + | + ++ 21 Ko + | + ++ 25,4 Ko + | +
| + Type de données + | + ++ Lite + | + ++ Pro + | + ++ Pro + SPA + | + ++ Fréquence de récolte + | +
|---|---|---|---|---|
| + [PageView](/attribute-dictionary/?event=PageView) événement + | + ++ Oui + | + ++ Oui + | + ++ Oui + | + +
+ `PageView` événement sont récoltés une fois immédiatement après l'événement du cycle de vie de la page `load` . Ces données sont responsables de la génération des métriques de pages vues dans le UI New Browser dashboard Relic. Il s'agit d'un appel JSONP à `bam.nr-data.net` ou `bam-cell.nr-data.net`. Tous les agents doivent |
+
| + Événement [PageViewTiming](/attribute-dictionary/?event=PageViewTiming) + | + ++ Oui + | + ++ Oui + | + ++ Oui + | + ++ `PageViewTiming` Les événements sont collectés par tous les agents et incluent des données de synchronisation telles que les mesures des principaux éléments vitaux du Web. La première récolte se produit 10 secondes après l'événement du cycle de vie de la page `load` . Des récoltes supplémentaires se produisent toutes les 30 secondes selon les besoins lorsqu'il y a des données à envoyer. Consultez la [documentation PageViewTiming](/docs/browser/new-relic-browser/page-load-timing-resources/pageviewtiming-async-or-dynamic-page-details/#interactivity-metrics) pour obtenir une liste des événements signalés. + | +
| + Métriques [d'erreur JavaScript](/attribute-dictionary/?event=JavaScriptError) + | + ++ Non + | + ++ Oui + | + ++ Oui + | + ++ `JavaScriptError` les métriques sont collectées toutes les 10 secondes après l'événement du cycle de vie de la page `load` . Cette récolte est envoyée sous forme de données d'intervalle de temps métrique et comprend également les métriques Ajax. + | +
| + Métriques Ajax + | + ++ Non + | + ++ Oui + | + ++ Oui + | + ++ Envoyé avec JavaScriptError métriques comme données d'intervalle de temps. + | +
| + Événement [AjaxRequest](/attribute-dictionary/?event=AjaxRequest) + | + ++ Non + | + ++ Oui + | + ++ Oui + | + ++ `AjaxRequest` Les événements sont récoltés toutes les 10 secondes après l'événement du cycle de vie de la page `load`, sauf si l'agent `SPA` est en cours d'utilisation. Si vous utilisez l'agent `SPA`, la première récolte aura lieu après l'événement du cycle de vie de la page `load` . Les récoltes suivantes auront lieu toutes les 10 secondes ou lorsque l'agent `SPA` remarquera un changement d'itinéraire. + | +
| + trace de session + | + ++ Non + | + ++ Oui + | + ++ Oui + | + ++ Les données de trace de session sont collectées après l’événement du cycle de vie de la page `load` . La récolte ultérieure a lieu toutes les 10 secondes si suffisamment de données ont été collectées. Les traces de session envoient le plus de données, mais elles sont fortement échantillonnées. Seules environ 75 pages vues par heure sont autorisées à envoyer des données de trace de session. + | +
| + Session Replay + | + ++ Non + | + ++ Oui + | + ++ Oui + | + ++ Les événements de relecture de session sont récoltés lorsque l'un des événements suivants se produit : + + * Lorsque les données compressées collectées pour la session atteignent une taille maximale de 64 Ko. + * Si l'utilisateur reste sur la même page pendant plus de 60 secondes. + * Lorsque la visibilité de la page change (changement d'onglet, focus, navigation, etc.) + + Le point de terminaison peut différer selon les paramètres régionaux, mais un exemple pour les États-Unis serait `https://bam.nr-data.net/browser/blobs`. + | +
| + [PageAction](/attribute-dictionary/?event=PageAction) événement + | + ++ Non + | + ++ Oui + | + ++ Oui + | + ++ `PageAction` Les événements sont récoltés après le cycle de vie de la page `load` . Les récoltes ultérieures se produisent toutes les 30 secondes. + | +
| + [NavigateurInteraction](/attribute-dictionary/?event=BrowserInteraction) événement + | + ++ Non + | + ++ Non + | + ++ Oui + | + ++ `BrowserInteraction` Les événements sont récoltés immédiatement après la fin de interaction . La première récolte se produit après l'événement du cycle de vie de la page `load` . Il y aura toujours au moins une interaction qui représente le chargement initial de la page. Les interactions supplémentaires ne sont collectées que si l'URL change (représentant un changement d'itinéraire). `AjaxRequest` événement sont également récoltés en même temps s'ils surviennent lors d'une interaction. + | +
|
+ |
+
+
+ |
+
|---|---|
| + Utilisez des segments d’URL constants. + | + ++ Ajoutez uniquement les segments d’URL qui restent constants sur plusieurs pages vues. N'ajoutez pas de segments uniques tels que des identifiants ou des catégories très spécifiques, car cela peut entraîner [des problèmes de regroupement métrique](/docs/features/metric-grouping-issues). + | +
| + Entrez des correspondances exactes. + | + ++ Saisissez tous les segments d'URL comme correspondances exactes, y compris la casse. + | +
| + Utiliser les règles existantes. + | + +
+ Si une règle apparaît déjà pour un domaine :
+
+ 1. Allez à |
+
| + Sous-domaine du groupe. + | + ++ Regroupez les sous-domaines similaires tels que `foo.domain.com` et `bar.domain.com` sous `*.domain.com`. Ce regroupement doit apparaître juste avant le nom de domaine de premier niveau. + | +
| + Configurer des applications d'une seule page. + | + +
+ Si votre site est une application à page unique et que vous ne voyez que `/` sous les pages vues, votre regroupement fonctionne correctement. New Relic enregistre requests ultérieures au fur et à mesure du chargement d'AJAX, et votre [page |
+
| + Supprimez les règles lorsque cela est approprié. + | + ++ Si vous devez supprimer une règle, obtenez de l'aide sur [support.newrelic.com](https://support.newrelic.com/). + | +
+
+
+
+
+
+| + Onglet Détails + | + ++ Commentaires + | +
|---|---|
| + données historiques + | + +
+ L'onglet |
+
| + Pannes + | + +
+ L'onglet |
+
| + Attribut + | + ++ Description + | +
|---|---|
| + `entityGuid` + | + ++ La valeur `entityGuid` est l'identifiant unique attribué par New Relic à vos composants système lors des processus d'instrumentation et de configuration. Pour plus d'informations sur l'entité New Relic et pour trouver le GUID de l'entité, consultez ce [guide](/docs/new-relic-solutions/new-relic-one/core-concepts/what-entity-new-relic/#find). + | +
| + `version` + | + +
+ La valeur de l'attribut de version peut être n'importe quoi, bien que nous vous recommandons d'utiliser le numéro de version défini pendant votre processus de génération. Pour voir un exemple de la manière dont cela peut être réalisé, consultez notre [documentation sur les plugins de déploiement Jenkins](#jenkins-markers) ci-dessous. Si vous signalez déjà les numéros de version à New Relic |
+
| + Attribut + | + ++ Description + | +
|---|---|
| + `changelog` + | + ++ Vous pouvez soumettre une URL ou n’importe quelle chaîne pour l’attribut changelog. Par exemple : `changelog: "Added: /v2/deployments.rb, Removed: None"` ou `changelog: "https://github.com/nodejs/node/blob/v4.2.3/CHANGELOG.md"`. + | +
| + `description` + | + ++ Vous pouvez soumettre n’importe quelle chaîne pour l’attribut description. Par exemple : `description: "Added a deployments resource to the v2 API"`. + + L'attribut description peut être l'endroit où vous choisissez d'insérer des informations codifiées provenant de vos processus de gestion de déploiement internes. Vous pouvez utiliser les identifiants ou les balises que vous attribuez à chaque validation ou déploiement qui décrivent l'aspect organisationnel ou commercial du travail, par exemple, `EU_MAINT_DMARK_v101`. + | +
| + `commit` + | + ++ Vous pouvez soumettre n'importe quelle chaîne pour l'attribut `commit`, et nous vous suggérons d'utiliser le SHA de validation associé au déploiement ou à la modification, par exemple, `commit: "r3ws4sa43f"`. + | +
| + `deepLink` + | + ++ Vous pouvez soumettre n’importe quelle URL pour l’attribut `deepLink` . Nous vous suggérons d'en utiliser un qui aidera quelqu'un à évaluer un changement sur New Relic pour accéder rapidement à un endroit où il peut prendre d'autres mesures, comme Jenkins, ArgoCD ou GitHub Actions. Voici un exemple : `deepLink: "http://localhost:8080/job/PipelineV2/configure"`. + | +
| + `deploymentType` + | + ++ Vous pouvez diviser les modifications liées aux déploiements en différents types. Ces types s'alignent sur les techniques de déploiement courantes, mais il existe également un type `OTHER` . Les types incluent : + + * `BASIC` + * `BLUE_GREEN` + * `CANARY` + * `ROLLING` + * `SHADOW` + * `OTHER` + + Attribuer un type à chaque déploiement vous aidera à filtrer les résultats sur le suivi des changements d'interface et les résultats des requêtes NerdGraph/NRQL . + | +
| + `groupId` + | + +
+ Vous souhaiterez peut-être regrouper le déploiement dans les cas où vous apportez une série de modifications à une ou plusieurs entités ou effectuez de nombreuses modifications sur plusieurs entités de votre système. En définissant la même valeur d'attribut `groupId` pour chaque déploiement associé, vous pouvez plus facilement voir ces modifications ensemble dans les interfaces New Relic ou utiliser `groupId` pour affiner les résultats de la requête.
+
+ Le `groupId` peut être n'importe quelle chaîne de votre choix, et vous pouvez continuer à ajouter un déploiement à un groupe après la première utilisation du `groupId` (au cas où vous voudriez relier ce déploiement à un déploiement qui s'est produit il y a des semaines ou même des mois).
+
+ |
+
| + utilisateur + | + ++ Peut être n’importe quelle chaîne, par exemple, `user: "datanerd@example.com"`. + | +
| + Attribut + | + ++ Description + | +
|---|---|
| + horodatage + | + +
+ L'heure à laquelle l'appel NerdGraph a été reçu. Vous pouvez fournir ici un remplacement sous la forme du nombre de millisecondes depuis l'époque Unix. Par exemple : `timestamp: 1032480000000`.
+
+ |
+
| + `deploymentId` + | + ++ Un identifiant unique généré lors de l’enregistrement du déploiement. Bien que vous ne puissiez pas définir `deploymentId`, vous pouvez l'utiliser dans votre requête NerdGraph et NRQL pour localiser un déploiement spécifique. Voici un exemple : `deploymentId: "8a3a594c-e726-4bc2-8078-26dffec9a3d8"`. + | +
+
+ 
+
+* 
+
+## Analysez l'impact de votre changement [#impact]
+
+Comment vos changements ont-ils affecté votre système ? Nous vous proposons plusieurs méthodes pour analyser les effets des changements que vous suivez.
+
+### Modifier la page des détails [#change-details]
+
+Lorsque vous cliquez sur une modification que vous suivez dans New Relic, comme sur un graphique ou sur la page 
+
+
+
+ 
+
+
+
+Lorsque vous comparez les changements :
+
+* Chaque graphique de série chronologique affichera une courbe pour CE changement et CE changement, ce qui vous aidera à comparer les performances relatives de chaque changement.
+
+ 
+
+* D'autres calculs sur cette page seront mis à jour pour vous aider à comprendre la différence entre CE changement et CE changement. Ils peuvent afficher des augmentations/diminutions en pourcentage pour les taux ou les nombres (par exemple, +11) lorsque cela est logique de le faire.
+
+* Vous pouvez ouvrir jusqu'à cinq vues empilées de modifications associées.
+
+### Voir les effets des changements sur les métriques et les événements [#trend-boards]
+
+Pour voir comment un changement, tel qu'une déploiement, affecte les mesures et les événements d'une entité, vous pouvez créer des tableaux de tendances personnalisés. Vous avez la possibilité de créer jusqu'à trois tableaux pour vous aider à prendre des décisions concernant votre changement récent.
+
+Que pouvez-vous voir avec ces tableaux de tendances personnalisés ? Vous pouvez sélectionner parmi toutes les métriques ou événements disponibles pour votre entité, puis lui appliquer une fonction d'agrégation. Par exemple, vous pouvez créer des tableaux de tendances personnalisés qui répondent à ces types de questions :
+
+* Comment le temps de réponse moyen d'une page vue a-t-il évolué avant et après ce changement ?
+* Comment le temps de réponse maximal d'une page vue a-t-il évolué avant et après ce changement ?
+
+Contrairement aux graphiques de dashboard classiques, ces tableaux de tendances personnalisés sont des graphiques entièrement intégrés à la fenêtre temporelle et aux paramètres 
+
+
+
+Pour contrôler ce que le tableau affiche :
+
+* Utilisez la liste déroulante 
+4. Sous | + Clé + | + ++ Valeur + | +
|---|---|
| + `created_at` + | + ++ L'horodatage du déploiement au format ISO 8601 + | +
| + `application_name` + | + ++ Le nom de l'entité d'application APM + | +
| + `account_name` + | + ++ Le nom du compte propriétaire de l'entité d'application APM + | +
| + `changelog` + | + ++ Une liste des modifications incluses dans le déploiement + | +
| + `description` + | + ++ Une description du déploiement + | +
| + `revision` + | + ++ La version du logiciel de déploiement + | +
| + `deployment_url` + | + ++ Un lien vers l'UI déployée pour l'entité applicative APM + | +
| + `deployed_by` + | + ++ L'utilisateur qui déploie l'application + | +
| + Clé + | + ++ Requis + | + ++ Défaut + | + ++ Description + | +
|---|---|---|---|
| + `guid` + | + ++ Oui + | + ++ n/a + | + ++ L'entité GUID à laquelle appliquer le marqueur de changement + | +
| + `apiKey` + | + ++ Oui + | + ++ n/a + | + ++ Votre [clé API personnelle](/docs/apis/get-started/intro-apis/types-new-relic-api-keys#personal-api-key)New Relic + | +
| + `changelog` + | + ++ Non + | + ++ n/a + | + +
+ Un résumé de ce qui a été apporté à ce changement, visible sur la page |
+
| + `commit` + | + ++ Non + | + ++ n/a + | + +
+ Le SHA de validation pour cette modification qui est visible dans la page |
+
| + `description` + | + ++ Non + | + ++ n/a + | + +
+ Une description de haut niveau de ce changement, visible sur la page |
+
| + `deeplink` + | + ++ Non + | + ++ n/a + | + ++ Un lien profond vers la source qui a déclenché le changement + | +
| + `deploymentType` + | + ++ Non + | + ++ `BASIC` + | + ++ Le type de déploiement. Outre la valeur par défaut de `BASIC`, choisissez entre `BLUE_GREEN`, `CANARY`, `OTHER`, `ROLLING` ou `SHADOW` + | +
| + `groupId` + | + ++ Non + | + ++ n/a + | + ++ Un identifiant de groupe pour la modification à lier à d'autres modifications + | +
| + `region` + | + ++ Non + | + ++ `US` + | + ++ La région de votre compte New Relic + | +
| + `version` + | + ++ Oui + | + ++ n/a + | + ++ métadonnées à appliquer au marqueur de changement, comme la dernière tagde sortie + | +
| + `user` + | + ++ Oui + | + ++ `github.actor` + | + +
+ Un nom d'utilisateur à associer au changement qui est visible dans les pages |
+
+
+2. Cliquez sur 
+
+3. Une nouvelle page apparaît avec la progression de votre installation. Aucun redémarrage n'est nécessaire pour le plugin.
+
+## Créer une action post-construction [#create-post--build-action]
+
+Pour ajouter le notificateur de déploiement New Relic en tant qu'action post-build dans la configuration de votre tâche de build Jenkins :
+
+1. Dans votre configuration de tâche Jenkins, accédez à 
+
+2. Créez un nom d'utilisateur/mot de passe pour la [clé API](/docs/apis/intro-apis/new-relic-api-keys/) utilisateur. Entrez la clé comme mot de passe.
+
+ 
+
+3. Sélectionnez une entité dans la liste déroulante.
+
+ 
+
+4. Ajoutez la valeur `Version` ou `Revision` requise et l’une des valeurs facultatives. Vous pouvez [utiliser des variables d’environnement](https://www.jenkins.io/doc/book/pipeline/jenkinsfile/#using-environment-variables) dans ces champs, comme `${BUILD_NUMBER}`.
+
+ 
+
+ | + Champ + | + ++ Description + | +
|---|---|
| + Description + | + ++ Insérez une description de ce que vous suivez. + | +
| + Révision + | + ++ Révision pour le déploiement. `${BUILD_NUMBER}` pourrait être une bonne valeur ici. + | +
| + Log des modifications + | + ++ Référence à la liste des changements intervenus lors du déploiement. + | +
| + Commettre + | + ++ Un hacher pour référencer l'ID de validation. + | +
| + Lien profond + | + ++ Un lien profond vers le travail Jenkins ou toute autre référence au déploiement. + | +
| + EntityGuid + | + ++ L'entité d'application en référence au déploiement (voir [Plus d'informations sur le GUID de l'application](#guid)). + | +
| + Type de déploiement + | + ++ Le type de déploiement en cours. + | +
| + ID de groupe + | + ++ Un identifiant pour référencer un cluster de modifications. + | +
| + horodatage + | + ++ Horodatage optionnel au format long Unix Epoch . S'il n'est pas fourni, nous le définirons sur l'heure à laquelle nous avons reçu la demande, qui sera le nombre de millisecondes depuis l' Epoch Unix. + | +
| + Version + | + ++ Version de ce qui est affiché. `${BUILD_NUMBER}` pourrait être une bonne valeur ici. + | +
| + Utilisateur + | + +
+ L'utilisateur effectuant le déploiement. 
+ |
+
\ No newline at end of file
diff --git a/src/i18n/content/fr/docs/codestream/codestream-settings/account-settings.mdx b/src/i18n/content/fr/docs/codestream/codestream-settings/account-settings.mdx
new file mode 100644
index 00000000000..7cab221ddf8
--- /dev/null
+++ b/src/i18n/content/fr/docs/codestream/codestream-settings/account-settings.mdx
@@ -0,0 +1,18 @@
+---
+title: Notification CodeStream
+metaDescription: An overview of CodeStream notifications.
+freshnessValidatedDate: '2024-11-08T00:00:00.000Z'
+translationType: machine
+---
+
+CodeStream vous avertit par e-mail lorsque de nouvelles [anomalies au niveau des transactions](/docs/codestream/observability/transactions) sont détectées dans les services créés à partir de votre code. Pour gérer ces notifications, accédez aux paramètres 
+
+Vous pouvez vous désabonner d'un référentiel en visitant la page 
\ No newline at end of file
diff --git a/src/i18n/content/fr/docs/codestream/observability/code-level-metrics.mdx b/src/i18n/content/fr/docs/codestream/observability/code-level-metrics.mdx
new file mode 100644
index 00000000000..7f86a132fd0
--- /dev/null
+++ b/src/i18n/content/fr/docs/codestream/observability/code-level-metrics.mdx
@@ -0,0 +1,46 @@
+---
+title: Métriques au niveau du code
+metaDescription: See performance data at the method level.
+freshnessValidatedDate: '2024-12-04T00:00:00.000Z'
+translationType: machine
+---
+
+Sans avoir à les rechercher, les données de performance sont affichées contextuellement dans l'éditeur afin de pouvoir éclairer le travail en cours. Imaginons que vous travaillez sur un débogage et que vous remarquez que la zone du code sur laquelle vous travaillez présente un taux d'erreur élevé. Peut-être que vous abordez ce problème dans le cadre de votre débogage afin qu'il ne dégénère pas en un problème plus grave.
+
+
+
+CodeStream affiche la durée moyenne et le taux d'erreur, pour les 30 dernières minutes, dans un CodeLens au-dessus de chaque méthode instrumentée par les agents New Relic APM . Pour Visual Studio, une icône New Relic s’affiche dans la gouttière de l’éditeur à la place d’un CodeLens. Les métriques sont calculées pour le service actuellement sélectionné dans le volet CodeStream . Développez un service différent et les métriques seront mises à jour en conséquence.
+
+Cliquez sur CodeLens pour voir des graphiques visualisant chacune des métriques. Si le référentiel est associé à plusieurs services New Relic-monitorer, vous pouvez facilement basculer entre eux. Cela modifie le service sur lequel sont basés les niveaux de code métriques affichés dans les graphiques et dans l'éditeur, et modifie également la sélection de service dans le volet CodeStream .
+
+
+
+En plus d'un graphique du taux d'erreur, vous verrez également une liste des erreurs réelles se produisant dans la même période, y compris le nombre d'occurrences pour chacune. Si le taux d'erreur augmente et que vous voyez qu'une erreur particulière est à l'origine du problème, vous pouvez cliquer dessus pour afficher la trace des appels et [commencer à collaborer](/docs/codestream/observability/error-investigation) à la résolution.
+
+## Couverture [#coverage]
+
+L'agent New Relic tente de collecter automatiquement des données pour les fonctions des classes liées aux requests HTTP. Dans de nombreux cas, et avec de nombreux frameworks qui utilisent un framework MVC, il s'agit souvent de méthodes sur une classe Controller.
+
+Étant donné que toutes requests de l'agent New Relic ne sont pas collectées en permanence, il est possible que les méthodes à faible trafic ne voient aucune donnée. Si des données manquent pour une méthode spécifique pour laquelle vous souhaitez voir des résultats, vous pouvez utiliser une instrumentation personnalisée pour combler les lacunes. Consultez les conseils pour [Java](/docs/apm/agents/java-agent/custom-instrumentation/java-custom-instrumentation), [.NET](/docs/apm/agents/net-agent/custom-instrumentation/introduction-net-custom-instrumentation), [PHP](/docs/apm/agents/php-agent/features/php-custom-instrumentation), [Python](/docs/apm/agents/python-agent/custom-instrumentation/python-custom-instrumentation), [Ruby](/docs/apm/agents/ruby-agent/api-guides/ruby-custom-instrumentation), [Go](/docs/apm/agents/go-agent/instrumentation/instrument-go-transactions) et [Node.js.](/docs/apm/agents/nodejs-agent/extend-your-instrumentation/nodejs-custom-instrumentation)
+
+Exécutez la requête NRQL suivante pour identifier où vous pourriez voir des CodeLenses avec des métriques au niveau du code pour l’un de vos services. Remplacez simplement la valeur d’exemple `entity.guid` par celle du service donné. Dans les résultats de la requête, regardez l'attribut `code.*` pour voir si l'un d'entre eux représente votre code et non le code framework .
+
+```sql
+SELECT * FROM Span
+WHERE entity.guid = 'YOUR_ENTITY_GUID' AND code.function IS NOT NULL
+SINCE 30 minutes ago LIMIT MAX
+```
+
+## Exigences [#requirements]
+
+Pour voir les données de performances dans l'éditeur, votre service doit répondre aux exigences répertoriées ci-dessous et le service doit avoir collecté des données au cours des 30 dernières minutes.
+
+* Le [tracing distribué](/docs/distributed-tracing/enable-configure/language-agents-enable-distributed-tracing) doit être activé. Le tracing distribué est activé par défaut dans les versions récentes de tous les agents, vous n'avez donc à vous en soucier que si vous avez désactivé le tracing distribué.
+* Si vous utilisez VS Code, vous devez avoir une extension de prise en charge linguistique installée pour [Java](https://marketplace.visualstudio.com/items?itemName=redhat.java), [C#](https://marketplace.visualstudio.com/items?itemName=ms-dotnettools.csharp), [PHP](https://marketplace.visualstudio.com/items?itemName=bmewburn.vscode-intelephense-client), [Python](https://marketplace.visualstudio.com/items?itemName=ms-python.python), [Go](https://marketplace.visualstudio.com/items?itemName=golang.go) ou [Ruby](https://marketplace.visualstudio.com/items?itemName=Shopify.ruby-lsp).
+* 
+
+Cliquez simplement sur une erreur pour en déterminer la cause première et collaborer avec vos coéquipiers sur l’enquête.
+
+
+
+Cliquez sur n'importe quelle image dans la trace d'appels pour accéder directement au fichier et au numéro de ligne correspondants. Si vous [associez des références git à vos erreurs](#buildsha), CodeStream ouvre un onglet d'éditeur en lecture seule du fichier qui a déclenché l'erreur dans l'environnement. Si vous n'associez pas de références git, une version locale du fichier s'ouvre à la place. Vous ne pourrez pas cliquer sur les cadres trace d'appels qui représentent du code ne faisant pas partie de votre référentiel (par exemple, une bibliothèque externe).
+
+Pour les erreurs de monitoring des services de navigateurs, vous devrez [télécharger des cartes sources](/docs/browser/browser-monitoring/browser-pro-features/upload-source-maps-un-minify-js-errors/) afin que la trace des appels puisse être déminifiée, vous permettant ainsi d'accéder au code de chaque image.
+
+En parcourant la trace d'appels, vous pouvez trouver du code qui semble être la source de votre problème et démarrer une discussion avec le bouton de commentaire. CodeStream mentionne automatiquement la personne la plus récente à avoir touché ce code, ce qui vous permet d'intégrer facilement les bonnes personnes à la discussion.
+
+
+
+Une fois le problème identifié, vous pouvez attribuer l'erreur ou mettre à jour le statut d'erreur de `unresolved` à `resolved` ou `ignored`.
+
+## À partir de la boîte de réception des erreurs [#errors-inbox]
+
+Vous pouvez accéder à cette même expérience d'erreur directement à partir d'une erreur dans la [boîte de réception des erreurs](/docs/errors-inbox/errors-inbox/) sur New Relic. Lorsque vous visualisez une erreur avec une trace d'appels, cliquez sur 
+
+Notez également que les discussions sont synchronisées entre CodeStream et la boîte de réception des erreurs, vous pouvez donc participer depuis l'un ou l'autre endroit.
+
+### Associer les SHA de build ou la balise de sortie aux erreurs [#buildsha]
+
+Lorsque vous visualisez une erreur dans CodeStream, vous pouvez voir une tag SHA ou sortie de build associée à l'erreur si elle n'a pas de référence git. CodeStream utilise la référence git pour faire correspondre l'erreur trace d'appels spécifique avec la version du code exécuté dans l'environnement qui a déclenché l'erreur. Bien que vous n’ayez pas besoin d’une référence git configurée pour enquêter sur l’erreur, gardez à l’esprit que vous ne regardez peut-être pas la version du code qui l’a provoquée.
+
+
+
+Vous pouvez utiliser une variable d'environnement pour permettre à l'agent New Relic 
+
+CodeStream vous indiquera également si l'erreur n'a pas de trace d'appels associée. Cela se produit avec des erreurs plus anciennes lorsque la trace d'appels a vieilli sur New Relic.
\ No newline at end of file
diff --git a/src/i18n/content/fr/docs/codestream/observability/log-search.mdx b/src/i18n/content/fr/docs/codestream/observability/log-search.mdx
new file mode 100644
index 00000000000..622057af0d1
--- /dev/null
+++ b/src/i18n/content/fr/docs/codestream/observability/log-search.mdx
@@ -0,0 +1,26 @@
+---
+title: Recherche de log
+metaDescription: Search logs from your IDE.
+freshnessValidatedDate: '2024-04-03T00:00:00.000Z'
+translationType: machine
+---
+
+Pas besoin de ralentir votre enquête en basculant entre votre IDE et votre navigateur pour rechercher le log. CodeStream intègre l'expérience de recherche de logs New Relic directement dans votre IDE ! Cliquez sur l'entrée 
+
+Développez les entrées log pour obtenir des informations détaillées en cliquant sur le signe d’insertion à côté d’elles. Passez la souris sur n’importe quelle valeur pour la copier.
+
+Si vous avez affiné vos résultats à l'aide d'une recherche par mot-clé (par exemple, pour un message d'erreur) et que vous souhaitez maintenant voir un résultat spécifique dans son contexte, passez la souris sur l'entrée et cliquez sur le bouton *Afficher le log environnant* qui apparaît à droite. Cela épinglera ce résultat spécifique et affichera ensuite les entrées log qui l'ont précédé et suivi dans le fichier de log.
+
+
+
+## Rechercher des lignes log spécifiques [#context-menu]
+
+Vous pouvez également accéder à une recherche log directement à partir de n’importe quelle ligne log dans votre code. Vous pouvez sélectionner une chaîne à rechercher et sélectionner 
\ No newline at end of file
diff --git a/src/i18n/content/fr/docs/codestream/observability/performance-monitoring.mdx b/src/i18n/content/fr/docs/codestream/observability/performance-monitoring.mdx
new file mode 100644
index 00000000000..330a0374912
--- /dev/null
+++ b/src/i18n/content/fr/docs/codestream/observability/performance-monitoring.mdx
@@ -0,0 +1,27 @@
+---
+title: observabilité dans l'IDE avec CodeStream
+metaDescription: Bring observability into the developer's IDE with New Relic CodeStream.
+freshnessValidatedDate: '2024-04-03T00:00:00.000Z'
+translationType: machine
+---
+
+New Relic CodeStream permet aux développeurs de voir comment le code dont ils sont responsables fonctionne en production en apportant l'observabilité dans l'IDE et en l'intégrant à leur routine quotidienne.
+
+Les données d'observabilité affichées dans CodeStream sont contextuelles au référentiel que vous avez ouvert dans votre IDE. Si ces référentiels ne sont pas associés à des services sur New Relic, vous serez invité à [effectuer ces associations](/docs/codestream/observability/repo-association). Sinon, vous obtiendrez une vue complète des performances des services créés à partir de votre code.
+
+
+
+Pour chaque service, les données de performance suivantes peuvent être affichées :
+
+* 
+
+En fonction des données que vous avez spécifiées, le générateur de requêtes sélectionne le type de graphique qui affiche vos résultats le plus efficacement. Cependant, vous pouvez utiliser la liste déroulante au-dessus des résultats pour choisir parmi d'autres types de graphiques disponibles afin de présenter vos données dans le format que vous souhaitez utiliser. Vous pouvez également exporter les données au format CSV ou JSON, ce qui ouvrira un nouvel onglet d'éditeur et affichera les données dans le format sélectionné.
+
+## Fichiers NRQL [#nrql-files]
+
+La liste déroulante au-dessus du générateur de requêtes, à droite, vous permet de sélectionner la requête que vous avez récemment exécutée. Une autre façon de sauvegarder la requête est d'ajouter un fichier avec une extension `.nrql` à votre référentiel. Vous pouvez enregistrer votre requête dans ce fichier et même partager ces requêtes avec vos coéquipiers en validant et en poussant ce fichier. Cliquez simplement sur le lien « Exécuter » dans CodeLens au-dessus de chaque requête pour exécuter la requête.
+
+
\ No newline at end of file
diff --git a/src/i18n/content/fr/docs/codestream/observability/repo-association.mdx b/src/i18n/content/fr/docs/codestream/observability/repo-association.mdx
new file mode 100644
index 00000000000..74a00f664cb
--- /dev/null
+++ b/src/i18n/content/fr/docs/codestream/observability/repo-association.mdx
@@ -0,0 +1,168 @@
+---
+title: Connecter le référentiel aux services
+metaDescription: Connect your repository to a service to see observability.
+freshnessValidatedDate: '2024-12-11T00:00:00.000Z'
+translationType: machine
+---
+
+Les données télémétriques disponibles dans CodeStream sont contextuelles, ce qui signifie qu'elles sont toutes liées au code que vous avez ouvert dans votre IDE. Pour ce faire, CodeStream a besoin de savoir quels services dans New Relic sont construits à partir du référentiel que vous avez ouvert dans votre IDE. CodeStream vous prompt de sélectionner un service à associer au référentiel que vous avez actuellement ouvert dans votre IDE.
+
+
+
+Dans certains cas, votre référentiel peut devoir être associé à plusieurs services. Par exemple, vous pouvez avoir différents services qui représentent différents environnements (comme la production ou la simulation) et ils peuvent tous être associés au même référentiel. Pour associer le référentiel actuel à un service supplémentaire, cliquez sur 
+
+Effectuer ces associations à la volée lorsque vous y êtes invité est un excellent moyen de commencer, mais nous recommandons l'une des méthodes suivantes, car elles nécessitent moins d'efforts manuels continus et éliminent la possibilité d'erreurs finales de l'utilisateur, telles que des URL distantes mal configurées.
+
+
+
+ Cliquez sur 
+
+CodeStream identifie les problèmes de performances en commençant par les transactions et en recherchant une anomalie dans le taux d'erreur ou la durée moyenne. Si vous utilisez [le suivi des changements](/docs/change-tracking/change-tracking-introduction/) de New Relic pour envoyer des informations de déploiement, les anomalies sont calculées en comparant les performances depuis votre dernière sortie avec les trois semaines précédentes. Dans le cas contraire, la comparaison est effectuée sur les sept derniers jours. Pour toutes les transactions identifiées comme présentant des problèmes de performances, CodeStream analyse ensuite en profondeur les segments (par exemple, requête de base de données, appels externes, méthodes individuelles, etc.) qui composent la transaction pour voir si l'un d'entre eux fonctionne mal. Cela vous permet de cibler la source du problème.
+
+Cliquez sur n'importe quelle transaction ou segment pour voir le problème de performance représenté sur un graphique au fil du temps. Pour un taux d'erreur anormal, les erreurs contribuant à l'augmentation du taux d'erreur sont répertoriées et vous pouvez cliquer sur CodeStream l'une d'entre elles pour accéder à [l'expérience d'investigation des erreurs de .](/docs/codestream/observability/error-investigation)
+
+
+
+Pour une durée moyenne anormale, CodeStream effectue une analyse du chemin critique pour répertorier les opérations les plus lentes. Et pour les opérations de base de données anormales, les requêtes réelles sont répertoriées.
\ No newline at end of file
diff --git a/src/i18n/content/fr/docs/codestream/start-here/install-codestream.mdx b/src/i18n/content/fr/docs/codestream/start-here/install-codestream.mdx
new file mode 100644
index 00000000000..c3313181cfa
--- /dev/null
+++ b/src/i18n/content/fr/docs/codestream/start-here/install-codestream.mdx
@@ -0,0 +1,30 @@
+---
+title: Installez CodeStream et inscrivez-vous
+metaDescription: How to install CodeStream and integrate it with your New Relic account.
+freshnessValidatedDate: '2024-12-04T00:00:00.000Z'
+translationType: machine
+---
+
+Vous pouvez installer l'extension CodeStream pour votre IDE spécifique.
+
+
\ No newline at end of file
diff --git a/src/i18n/content/fr/docs/codestream/start-here/what-is-codestream.mdx b/src/i18n/content/fr/docs/codestream/start-here/what-is-codestream.mdx
new file mode 100644
index 00000000000..5fa13f60133
--- /dev/null
+++ b/src/i18n/content/fr/docs/codestream/start-here/what-is-codestream.mdx
@@ -0,0 +1,38 @@
+---
+title: Présentation de New Relic CodeStream
+description: New Relic CodeStream rend la télémétrie de production accessible là où vivent les développeurs... l'IDE.
+freshnessValidatedDate: '2024-04-15T00:00:00.000Z'
+translationType: machine
+---
+
+New Relic CodeStream est un IDE d'extension qui vous permet de vous déplacer vers la gauche en intégrant les performances du code aux premières étapes du processus de développement.
+
+* Découvrez les performances des services créés à partir de votre code, avec des informations sur les métriques dorées, les erreurs, les anomalies de transaction, les SLO, etc.
+* Enquêtez sur les erreurs plus rapidement en parcourant la trace d'appels et en collaborant avec vos coéquipiers.
+* Recherchez dans le log de votre IDE pour étudier les problèmes sans changer de contexte.
+* Exécutez la requête NRQL, puis enregistrez et partagez la requête avec vos coéquipiers via les fichiers `.nrql`.
+* Consultez les données de performances des méthodes individuelles dans le code, directement dans l'éditeur.
+
+## Enquête sur les erreurs
+
+Découvrez les erreurs qui se produisent dans le code dont vous êtes responsable. Parcourez rapidement la trace des appels, CodeStream vous amenant automatiquement au bon fichier et au bon numéro de ligne, puis impliquez les coéquipiers concernés dans la discussion afin que vous puissiez résoudre le problème le plus rapidement possible.
+
+
+
+## Recherche de log
+
+Si vous devez enquêter sur un problème en recherchant dans le log, pourquoi changer de contexte en dehors de votre IDE pour effectuer ce travail sur le Web ? Recherchez dans le log directement depuis votre IDE. Vous pouvez même lancer une recherche à partir de lignes log individuelles dans votre code.
+
+
+
+## Métriques au niveau du code
+
+Consultez les données de performance, au niveau de la méthode, directement dans votre éditeur. La vue permanente garantit que les problèmes de performances sont pris en compte dans le travail en cours. Vous pouvez même voir les métriques de votre environnement de préproduction et anticiper les problèmes de performances avant qu'ils n'atteignent la production.
+
+
+
+## monitoringdes performances
+
+Obtenez une vue dans l'IDE des performances des services créés à partir de votre code, dans n'importe quel environnement. métriques dorées, objectifs de niveau de service et services associés vous donnent une vue d'ensemble en un coup d'œil.
+
+
\ No newline at end of file
diff --git a/src/i18n/content/fr/docs/codestream/troubleshooting/client-logs.mdx b/src/i18n/content/fr/docs/codestream/troubleshooting/client-logs.mdx
new file mode 100644
index 00000000000..1ade94d9cc6
--- /dev/null
+++ b/src/i18n/content/fr/docs/codestream/troubleshooting/client-logs.mdx
@@ -0,0 +1,24 @@
+---
+title: "Où puis-je trouver mon log côté client CodeStream\_?"
+metaDescription: Find your CodeStream log files.
+freshnessValidatedDate: never
+translationType: machine
+---
+
+Lorsque vous signalez des problèmes au support client New Relic, il est souvent utile d'inclure un fichier de log. Suivez ces instructions pour que votre IDE obtienne votre fichier de log.
+
+## JetBrains [#jetbrains]
+
+1. Reproduisez le problème.
+2. Dans votre IDE, accédez à 
+
+Si le trousseau natif est déjà sélectionné, il est également possible que la première fois que vous avez été invité à autoriser l'accès au trousseau IDE, vous l'ayez refusé. Si tel est le cas, vous pouvez accéder à l'application 
\ No newline at end of file
diff --git a/src/i18n/content/fr/docs/codestream/troubleshooting/proxy-support.mdx b/src/i18n/content/fr/docs/codestream/troubleshooting/proxy-support.mdx
new file mode 100644
index 00000000000..5706e22f460
--- /dev/null
+++ b/src/i18n/content/fr/docs/codestream/troubleshooting/proxy-support.mdx
@@ -0,0 +1,24 @@
+---
+title: Prise en charge du proxy CodeStream
+metaDescription: Troubleshoot a common CodeStream connectivity issue.
+freshnessValidatedDate: never
+translationType: machine
+---
+
+Si vous rencontrez des problèmes de connectivité avec l'extension New Relic CodeStream, cela peut être dû au fait que vous êtes derrière un proxy réseau et que CodeStream n'est pas configuré pour fonctionner avec lui. Pour trouver les paramètres de CodeStream dans votre IDE :
+
+* VS Code : accédez à 
+
+Si vous avez configuré la prise en charge du proxy dans votre IDE, CodeStream essaiera d'abord d'hériter de ces paramètres. Sinon, CodeStream héritera des paramètres proxy de votre système d’exploitation/environnement.
+
+Après avoir modifié vos paramètres, redémarrez votre IDE.
\ No newline at end of file
diff --git a/src/i18n/content/fr/docs/codestream/troubleshooting/using-wsl.mdx b/src/i18n/content/fr/docs/codestream/troubleshooting/using-wsl.mdx
new file mode 100644
index 00000000000..a78b630c2cc
--- /dev/null
+++ b/src/i18n/content/fr/docs/codestream/troubleshooting/using-wsl.mdx
@@ -0,0 +1,26 @@
+---
+title: Comment puis-je utiliser WSL et CodeStream ?
+metaDescription: You can run CodeStream in Windows using WSL
+freshnessValidatedDate: never
+translationType: machine
+---
+
+Pour utiliser CodeStream et WSL (sous-système Windows pour Linux), procédez comme suit :
+
+1. Assurez-vous que Git est installé sur la machine Windows, ainsi que dans votre distribution WSL. Bien que les versions installées entre les deux puissent différer, il est préférable de s'assurer que la version Windows correspond à celle installée dans votre distribution WSL.
+
+2. Clonez votre référentiel git (dépôt) dans votre distribution WSL (par exemple, `~/code/YOUR_PROJECT_FOLDER`).
+
+3. Sous Windows, autorisez Git à communiquer via ce chemin UNC en marquant le répertoire comme `safe`. Faites-le dans votre terminal Windows avec cette commande, en remplaçant `YOUR_DISTRO`, `YOUR_USERNAME` et `YOUR_PROJECT_FOLDER` pour correspondre à votre configuration :
+
+ ```shell
+ git config --global --add safe.directory '//wsl.localhost/YOUR_DISTRO/home/YOUR_USERNAME/code/YOUR_PROJECT_FOLDER'
+ ```
+
+4. Dans votre IDE, ouvrez le projet en utilisant le chemin UNC WSL. Par exemple, si vous aviez Ubuntu, votre nom d'utilisateur était `codestream` et votre dossier de projet était `Amazing_App`, votre chemin UNC serait `//wsl.localhost/Ubuntu/home/codestream/code/Amazing_App`.
+
+| + Pourquoi utiliser des métriques ? + | + ++ Commentaires + | +
|---|---|
| + Flexibilité + | + ++ * Les métriques sont [dimensionnelles](/docs/telemetry-data-platform/ingest-manage-data/understand-data/new-relic-data-types#dimensional-metrics). Vous pouvez choisir les métadonnées (comme le nom de l'hôte ou le nom de l'application) qui leur sont associées. + * Les mesures métriques courantes, comme la moyenne, la somme, le minimum et le maximum, sont déjà calculées. + | +
| + Agrégation et conservation des données + | + ++ * Les données ont déjà été pré-agrégées dans des tranches de temps plus longues. + * la rétention des données est de 13 mois. + | +
| + Capacités de requête + | + ++ * Vous pouvez [effectuer une requête en utilisant le type de données `Metric` ](/docs/telemetry-data-platform/get-data/apis/query-metric-data-type). + * Lorsque vous créez des métriques, cela ne supprime pas votre événement ou d'autres types de données. Cependant, les métriques sont plus adaptées aux requêtes et aux graphiques à plus longue portée. + | +
| + Élément + | + ++ Description + | +
|---|---|
| + `mutation` + | + ++ L’un des [types d’opérations API](/docs/apis/graphql-api/getting-started/introduction-new-relic-graphql-api#tutorials) de base. + | +
| + `eventsToMetricsDeleteRule` + | + ++ La méthode appelée pour supprimer une règle. + | +
| + `deletes` + | + ++ Cela prend deux paramètres : + + * `ruleId`: L'ID de la règle pour événement à métriques, log à métriques ou spans à métriques. + * `accountId`: L' [ID de compte New Relic](/docs/accounts/install-new-relic/account-setup/account-id). + | +
| + `successes` et `submitted` blocs + | + ++ Ici, vous définissez les données renvoyées par un succès ou un échec. Paramètres disponibles pour ces blocs : + + * `id` (ou `ruleId` pour `submitted`) + * `name` + * `description` + * `nrql` + * `enabled` + * `accountId` + | +
| + Élément + | + ++ Description + | +
|---|---|
| + `mutation` + | + ++ L’un des [types d’opérations API](/docs/apis/graphql-api/getting-started/introduction-new-relic-graphql-api#tutorials) de base. + | +
| + `eventsToMetricsUpdateRule` + | + ++ La méthode appelée pour mettre à jour une règle existante et l'activer ou la désactiver. + | +
| + `updates` + | + ++ Cela nécessite trois paramètres obligatoires : + + * `ruleId`: L'ID de la règle pour événement à métriques, log à métriques ou spans à métriques. + * `accountId`: L' [ID de compte New Relic](/docs/accounts/install-new-relic/account-setup/account-id). + * `enabled`: Pour activer une règle désactivée, définissez cette valeur sur `true`. Pour désactiver une règle, définissez cette valeur sur `false`. + | +
| + `successes` et `submitted` blocs + | + ++ Ici, vous définissez les données renvoyées par un succès ou un échec. Paramètres disponibles pour ces blocs : + + * `id` (ou `ruleId` pour `submitted`) + * `name` + * `description` + * `nrql` + * `enabled` + * `accountId` + | +
| + Élément + | + ++ Description + | +
|---|---|
| + `query` + | + ++ L’un des [types d’opérations API](/docs/apis/graphql-api/getting-started/introduction-new-relic-graphql-api#tutorials) de base. Utilisé pour effectuer des requêtes mais pas pour apporter des modifications. + | +
| + `actor` + | + ++ Ceci spécifie l'utilisateur New Relic actuel. + | +
| + `account(id: 123456)` + | + ++ Spécifiez l' [ID du compte New Relic](/docs/accounts/install-new-relic/account-setup/account-id) où récupérer les données. + | +
| + `eventsToMetrics` + | + ++ Portez les données uniquement pour les règles événement-à-métriques, log-to-métriques ou spans-to-métriques. + | +
| + `allRules` + | + ++ Renvoie toutes les règles pour ce compte. + | +
| + `rules` + | + ++ Dans le bloc `rules`, vous pouvez définir les données que vous souhaitez renvoyer. Les champs disponibles incluent : + + * `id` + * `name` + * `description` + * `nrql` + * `accountId` + * `enabled` + | +
| + Éléments de la demande + | + ++ Description + | +
|---|---|
| + `mutation` + | + ++ L’un des [types d’opérations API](/docs/apis/graphql-api/getting-started/introduction-new-relic-graphql-api#tutorials) de base. + | +
| + `eventsToMetricsCreateRule` + | + ++ La méthode appelée pour créer une règle. + | +
| + `rules` + | + ++ Prend quatre paramètres : + + * `name`:Le [nom de la règle](#naming). + * `description`: Facultatif. La description de la règle. Nous vous recommandons d'inclure des informations sur la personne qui a créé les données métriques et sur celle qui les utilisera. + * `accountId`: L' [ID de compte New Relic](/docs/accounts/install-new-relic/account-setup/account-id) où l'événement, le log ou les étendues vivent et les métriques seront créées. + * `nrql`: La requête NRQL qui crée la règle. Pour en savoir plus, voir [Créer une requête NRQL](#create-nrql). + | +
| + `successes` et `submitted` blocs + | + ++ Ici, vous définissez les données renvoyées par une réponse réussie ou échouée. Les paramètres disponibles pour ces blocs incluent : + + * `id` (`ruleId` pour `submitted`) + * `name` + * `description` + * `nrql` + * `enabled` (statut activé/désactivé) + * `accountId` + | +
| + `ruleId` et `accountId` + | + ++ Si un échec se produit, les `ruleId` et `accountId` soumis seront renvoyés avec la raison de l'erreur et la description de l'erreur. + | +
| + Fonction + | + ++ Commentaires + | +
|---|---|
| + `summary` + | + +
+ Crée un point de données récapitulatif métrique pour chaque fenêtre temporelle (actuellement 1 minute). Utilisez ceci si votre requête NRQL utilise [des fonctions d'agrégateur](/docs/insights/nrql-new-relic-query-language/nrql-reference/nrql-syntax-components-functions#functions) prises en charge par le type métrique récapitulatif, telles que `average`, `sum`, `min` ou `max`.
+
+ |
+
| + `uniqueCount` + | + ++ Crée un point de données métrique `uniqueCount` pour chaque fenêtre temporelle d'une minute. Utilisez ceci si votre requête NRQL utilise le [type d'agrégateur](/docs/insights/nrql-new-relic-query-language/nrql-reference/nrql-syntax-components-functions#functions) `uniqueCount` . + + Exemple de requête de création de règle : + + ```sql + FROM Transaction SELECT uniqueCount(request.headers.userAgent) + AS 'server.request.header.userAgent.uniqueCount' + WHERE appName = 'Browser Monitoring Router' FACET http.statusCode, name, appName, host + ``` + | +
| + `distribution` + | + +
+ Crée un point de données de métrique de distribution pour chaque fenêtre temporelle d'une minute. Utilisez ceci si votre requête NRQL utilise [des fonctions d'agrégation](/docs/insights/nrql-new-relic-query-language/nrql-reference/nrql-syntax-components-functions#functions) telles que `percentile`, `histogram`, `min`, `max`, `average`, `sum` ou `count`. Utilisez uniquement l’attribut qui vous intéresse comme argument et ignorez le reste des arguments de `percentile` ou `histogram`. La métrique générée prend en charge tout argument sur `percentile` ou `histogram`.
+
+ |
+
| + Comptage simple : `summary(1)` et `sum` + | + +
+ Si vous souhaitez une métrique qui est un simple décompte de l'événement, du log ou des étendues qui correspondent à une clause `WHERE` particulière, utilisez la métrique `summary(1)` . Ce type métrique compte le nombre d'événements, de logs ou de périodes spécifiés par minute. Lors de l'interrogation de la métrique créée, utilisez la méthode `sum` pour voir le résultat.
+
+ |
+
| + Limites + | + ++ Commentaires + | +
|---|---|
| + Limites du compte + | + ++ Un compte peut avoir un maximum de 1 000 règles de création de métriques. + | +
| + Limites de la règle métrique + | + ++ Une règle peut : + + * Créez un [maximum de 10 métriques](#multiple-metrics). + * Utilisez un seul type de données (événement, log ou étendues). + * Sélectionnez un maximum de 20 attributs (facettes) à inclure sur une métrique. + | +
| + Limites de la fenêtre de temps + | + ++ Limite de 50 000 pour les combinaisons uniques de nom de métrique/valeur d'attribut pour une seule métrique dans une fenêtre temporelle de 30 secondes. [Les limites de cardinalité normales sur les cumuls](/docs/data-apis/ingest-apis/metric-api/metric-api-limits-restricted-attributes/#requirements) s'appliqueront. + + Si la limite de 50 000 dans une fenêtre de 30 secondes est dépassée, la règle est désactivée et un [événement`NrIntegrationError` ](/docs/telemetry-data-platform/manage-data/nrintegrationerror)est créé dans ce compte qui inclut : + + * Les détails de la règle + * Un message sur le fait d'avoir trop de facettes + * Une valeur d'attribut `newRelicFeature` de `eventToMetric` + | +
| + noms métriques + | + ++ Exigences et recommandations + | +
|---|---|
| + Exigences + | + ++ Conditions requises pour nommer une métrique : + + * Inférieur ou égal à 255 unités de code 16 bits (UTF-16). Une façon de vous assurer que vous êtes en dessous de la limite est de garder chaque chaîne en dessous de 127 de ce qui est le plus facile à compter. + + * Pas d'espaces. + + * Commencez par une lettre. + + Exemples de noms métriques forts : + + * `rubyvm.memory.heap_used` + + * `redis.container.cpu.percent` + + * `memcached.process_virtual_memory.bytes` + | +
| + Longueur et structure + | + ++ Choisissez un nom et une structure qui permettent aux autres de trouver, de comprendre et d’utiliser facilement cette métrique. + + * Nous vous recommandons de conserver le nom de votre métrique à moins de 40 caractères pour une lisibilité idéale. Les noms plus longs peuvent être coupés ou chevaucher d’autres noms. + * Votre schéma de nommage métrique dépendra de votre logique métier. Vous souhaiterez peut-être utiliser l'espace de nommage pour préfixer votre nom métrique, ou vos noms devront peut-être être plus généraux. + | +
| + Composants dans le nom + | + +
+ Si vous souhaitez créer des composants au sein du nom de votre métrique (comme la source des métriques et l'élément que vous mesurez), nous vous recommandons d'aller du large au spécifique (de gauche à droite) :
+
+ 1. Utilisez un point pour séparer ces composants afin d'être cohérent avec nos noms métriques New Relic.
+
+ 2. Ensuite, utilisez un trait de soulignement pour séparer les mots à l’intérieur des points.
+
+ |
+
| + attribut + | + +
+ Évitez de mettre un attribut dans votre nom métrique. Les attributs sont des qualités de votre métrique que vous pouvez utiliser pour filtrer ou facetter vos données, comme cluster ou la zone de disponibilité.
+
+ |
+
| + Modification des noms métriques + | + ++ Si vous modifiez le nom d'une métrique, les données historiques ne seront **pas** mises à jour avec ce nouveau nom. Pour interroger ou tracer ces données historiques, vous devrez spécifier l'ancien nom de la métrique. + | +
| + Région + | + ++ Zone + | +
|---|---|
| + `us-east-1 (Virginia)` + | + ++ * `use1-az1` + * `use1-az2` + * `use1-az3` + * `use1-az4` + * `use1-az5` + * `use1-az6` + | +
| + `us-east-2 (Ohio)` + | + ++ * `use2-az1` + * `use2-az2` + * `use2-az3` + | +
| + `us-west-2 (Oregon)` + | + ++ * `usw2-az1` + * `usw2-az2` + * `usw2-az3` + * `usw2-az4` + | +
| + `eu-central-1` + | + ++ * `euc1-az1` + * `euc1-az2` + * `euc1-az3` + | +
| + Source des données + | + ++ nom d'hôte(s) + | + ++ Nom(s) du service de point de terminaison + | +
|---|---|---|
| + APM + | + ++ `collector.newrelic.com` + | + ++ `com.amazonaws.vpce.us-east-1.vpce-svc-084f1583d1a7afdaf` + | +
| + Evénement API + | + ++ `insights-collector.newrelic.com` + | + ++ `com.amazonaws.vpce.us-east-1.vpce-svc-0ec0af01ab096419c` + | +
| + API métrique (incluant Prometheus et autres intégrations) + | + ++ `metric-api.newrelic.com` + | + ++ `com.amazonaws.vpce.us-east-1.vpce-svc-085e8fb87d5493160` + | +
| + Enregistrement + | + ++ `log-api.newrelic.com` + | + ++ `com.amazonaws.vpce.us-east-1.vpce-svc-03408b499252a02a7` + | +
| + Tracing distribué + | + ++ `trace-api.newrelic.com` + | + ++ `com.amazonaws.vpce.us-east-1.vpce-svc-095f88345b701aaae` + | +
| + AWS Lambda des logs et CloudWatch monitoring + | + ++ `cloud-collector.newrelic.com` + | + ++ `com.amazonaws.vpce.us-east-1.vpce-svc-0ba6e1d02e7cbbccb` + | +
| + monitoring d'infrastructure et intégration sur hôte + | + ++ `infra-api.newrelic.com` + | + ++ `com.amazonaws.vpce.us-east-1.vpce-svc-007e743510dc46024` + | +
| + + | + `identity-api.newrelic.com` `infrastructure-command-api.newrelic.com` + | + ++ `com.amazonaws.vpce.us-east-1.vpce-svc-05adda8aa9c23eaa3` + | +
| + OpenTelemetry + | + ++ `otlp.nr-data.net` + | + ++ `com.amazonaws.vpce.us-east-1.vpce-svc-07d529b1d0f6d417d` + | +
| + API REST de New Relic + | + ++ `api.newrelic.com` + | + ++ `com.amazonaws.vpce.us-east-1.vpce-svc-05adda8aa9c23eaa3` + | +
| + Gestionnaire de travaux Synthetics + | + ++ `synthetics-horde.nr-data.net` + | + ++ `com.amazonaws.vpce.us-east-1.vpce-svc-05adda8aa9c23eaa3` + | +
| + Source des données + | + ++ nom d'hôte(s) + | + ++ Nom du service de point de terminaison + | +
|---|---|---|
| + APM + | + ++ `collector.newrelic.com` + | + ++ `com.amazonaws.vpce.us-east-2.vpce-svc-00e75af63239fbdc8` + | +
| + Evénement API + | + ++ `insights-collector.newrelic.com` + | + ++ `com.amazonaws.vpce.us-east-2.vpce-svc-030074dde03e5f7f1` + | +
| + API métrique (incluant Prometheus et autres intégrations) + | + ++ `metric-api.newrelic.com` + | + ++ `com.amazonaws.vpce.us-east-2.vpce-svc-0b48963952181a468` + | +
| + Enregistrement + | + ++ `log-api.newrelic.com` + | + ++ `com.amazonaws.vpce.us-east-2.vpce-svc-070f8190492d268ec` + | +
| + Tracing distribué + | + ++ `trace-api.newrelic.com` + | + ++ `com.amazonaws.vpce.us-east-2.vpce-svc-0cc5a5c85730683db` + | +
| + AWS Lambda des logs et CloudWatch monitoring + | + ++ `cloud-collector.newrelic.com` + | + ++ `com.amazonaws.vpce.us-east-2.vpce-svc-0c4032e13941b3e9d` + | +
| + monitoring d'infrastructure et intégration sur hôte + | + ++ `infra-api.newrelic.com` + | + ++ `com.amazonaws.vpce.us-east-2.vpce-svc-0df10112dc8c0f0b0` + | +
| + + | + `identity-api.newrelic.com` `infrastructure-command-api.newrelic.com` + | + ++ `com.amazonaws.vpce.us-east-2.vpce-svc-09230bb8d16a9171e` + | +
| + OpenTelemetry + | + ++ `otlp.nr-data.net` + | + ++ `com.amazonaws.vpce.us-east-2.vpce-svc-0bf91fb637cf37b4f` + | +
| + API REST de New Relic + | + ++ `api.newrelic.com` + | + ++ `com.amazonaws.vpce.us-east-2.vpce-svc-09230bb8d16a9171e` + | +
| + Gestionnaire de travaux Synthetics + | + ++ `synthetics-horde.nr-data.net` + | + ++ `com.amazonaws.vpce.us-east-2.vpce-svc-09230bb8d16a9171e` + | +
| + Source des données + | + ++ nom d'hôte(s) + | + ++ Nom du service de point de terminaison + | +
|---|---|---|
| + APM + | + ++ `collector.newrelic.com` + | + ++ `com.amazonaws.vpce.us-west-2.vpce-svc-05b3227a3674b5c8f` + | +
| + Evénement API + | + ++ `insights-collector.newrelic.com` + | + ++ `com.amazonaws.vpce.us-west-2.vpce-svc-0e22aa3aa8ca03a52` + | +
| + API métrique (incluant Prometheus et autres intégrations) + | + ++ `metric-api.newrelic.com` + | + ++ `com.amazonaws.vpce.us-west-2.vpce-svc-0c656c220a611437f` + | +
| + Enregistrement + | + ++ `log-api.newrelic.com` + | + ++ `com.amazonaws.vpce.us-west-2.vpce-svc-06acfe4c3ff826816` + | +
| + Tracing distribué + | + ++ `trace-api.newrelic.com` + | + ++ `com.amazonaws.vpce.us-west-2.vpce-svc-07ccec1d95aa1a7b6` + | +
| + AWS Lambda des logs et CloudWatch monitoring + | + ++ `cloud-collector.newrelic.com` + | + ++ `com.amazonaws.vpce.us-west-2.vpce-svc-00658fd192f80188a` + | +
| + monitoring d'infrastructure et intégration sur hôte + | + ++ `infra-api.newrelic.com` + | + ++ `com.amazonaws.vpce.us-west-2.vpce-svc-006678e8c6f037152` + | +
| + + | + `identity-api.newrelic.com` `infrastructure-command-api.newrelic.com` + | + ++ `com.amazonaws.vpce.us-west-2.vpce-svc-0e8e1c3c0fd16ff9c` + | +
| + OpenTelemetry + | + ++ `otlp.nr-data.net` + | + ++ `com.amazonaws.vpce.us-west-2.vpce-svc-06192ca8948a1e41c` + | +
| + API REST de New Relic + | + ++ `api.newrelic.com` + | + ++ `com.amazonaws.vpce.us-west-2.vpce-svc-0e8e1c3c0fd16ff9c` + | +
| + Gestionnaire de travaux Synthetics + | + ++ `synthetics-horde.nr-data.net` + | + ++ `com.amazonaws.vpce.us-west-2.vpce-svc-0e8e1c3c0fd16ff9c` + | +
| + Source des données + | + ++ nom d'hôte(s) + | + ++ Nom du service de point de terminaison + | +
|---|---|---|
| + APM + | + ++ `collector.eu.newrelic.com` et `collector.eu01.nr-data.net` + | + ++ `com.amazonaws.vpce.eu-central-1.vpce-svc-080da8c256534bc15` et `com.amazonaws.vpce.eu-central-1.vpce-svc-09677bc6c976d9d9e`, respectivement + | +
| + Evénement API + | + ++ `insights-collector.eu01.nr-data.net` + | + ++ `com.amazonaws.vpce.eu-central-1.vpce-svc-02a22c14c11af33eb` + | +
| + API métrique (incluant Prometheus et autres intégrations) + | + ++ `metric-api.eu.newrelic.com` + | + ++ `com.amazonaws.vpce.eu-central-1.vpce-svc-046613de75b465eb5` + | +
| + Enregistrement + | + ++ `log-api.eu.newrelic.com` + | + ++ `com.amazonaws.vpce.eu-central-1.vpce-svc-042ba37fec695fcde` + | +
| + Tracing distribué + | + ++ `trace-api.eu.newrelic.com` + | + ++ `com.amazonaws.vpce.eu-central-1.vpce-svc-07ae0a14716c59a2d` + | +
| + AWS Lambda des logs et CloudWatch monitoring + | + ++ `cloud-collector.eu01.nr-data.net` + | + ++ `com.amazonaws.vpce.eu-central-1.vpce-svc-0cf7eae9d784a86a8` + | +
| + monitoring d'infrastructure et intégration sur hôte + | + ++ `infra-api.eu01.nr-data.net` et `infra-api.eu.newrelic.com` + | + ++ `com.amazonaws.vpce.eu-central-1.vpce-svc-06d5b2d7e79ddd78e` et `com.amazonaws.vpce.eu-central-1.vpce-svc-02fc7dd8d7be95a32`, respectivement + | +
| + + | + `identity-api.eu.newrelic.com` `infrastructure-command-api.eu.newrelic.com` + | + ++ `com.amazonaws.vpce.eu-central-1.vpce-svc-0779388869aeac607` + | +
| + OpenTelemetry + | + ++ `otlp.eu01.nr-data.net` + | + ++ `com.amazonaws.vpce.eu-central-1.vpce-svc-04308d96cf1012913` + | +
| + API REST de New Relic + | + ++ `api.eu.newrelic.com` + | + ++ `com.amazonaws.vpce.eu-central-1.vpce-svc-0779388869aeac607` + | +
| + Gestionnaire de travaux Synthetics + | + ++ `synthetics-horde.eu01.nr-data.net` + | + ++ `com.amazonaws.vpce.eu-central-1.vpce-svc-0779388869aeac607` + | +
| + Champ + | + ++ Description + | +
|---|---|
|
+ |
+
+ + Facultatif. + | +
|
+ |
+
+
+ Sélectionnez |
+
|
+ |
+
+
+ Pour |
+
|
+ |
+
+ + Sélectionnez le VPC dans la liste déroulante. + | +
|
+ |
+
+
+ Sélectionnez les éléments suivants :
+
+ * |
+
|
+ |
+
+
+ Sélectionnez les zones. Pour |
+
|
+ |
+
+
+ Sélectionnez le |
+
|
+ |
+
+ + Insérez des paires valeur clé facultatives. + | +
+ | + Méthode + | + +
+ |
+
|---|---|
| + Spécifier l'attribut en XML + | + +
+ XML vous permet de spécifier des attributs personnalisés sans modifier aucune de vos sources de code. Vous pouvez avoir plusieurs fichiers XML pour les attributs personnalisés qui sont regroupés par une facette logique.
+
+ Pour définir des attributs personnalisés pour votre application Java via XML :
+
+ 1. Consultez la documentation de l'agent Java New Relic sur [le format de fichier XML, les méthodes et les classes, ainsi que les exemples](/docs/agents/java-agent/custom-instrumentation/java-custom-instrumentation-xml-examples).
+ 2. Depuis votre répertoire `Extensions` dans l'agent Java New Relic, créez un [fichier XML](/docs/agents/java-agent/custom-instrumentation/java-instrumentation-xml) unique.
+ 3. Définissez les méthodes que vous souhaitez que New Relic monitore en [modifiant directement votre fichier XML](/docs/agents/java-agent/custom-instrumentation/java-instrumentation-xml) .
+ 4. Définissez un fichier instrumentation XML à l'aide de l' [UI de New Relic](/docs/agents/java-agent/custom-instrumentation/custom-instrumentation-editor-quickly-customize-your-java-instrumentation). Cela peut nécessiter une configuration supplémentaire dans le bloc `common:` de votre |
+
| + Appeler l'API de l'agent + | + +
+ |
+
| + Collecter l'attribut utilisateur + | + ++ L'agent Java comprend également un mécanisme intégré pour [activer l'attribut utilisateur](/docs/agents/java-agent/attributes/enabling-disabling-attributes-java#user-attributes) et collecter les informations utilisateur de `HttpServletRequest.getUserPrincipal()` en tant qu'attribut personnalisé. + | +
| + Exigence + | + ++ Description + | +
|---|---|
| + charge + | + +
+ Taille ou longueur maximale totale : |
+
| + Types de données d'attribut + | + ++ Les valeurs [d'attribut](/docs/using-new-relic/welcome-new-relic/get-started/glossary#attribute) peuvent être soit une chaîne, soit un entier numérique ou un flottant. Pour plus d'informations sur le formatage des données de date et d'heure, voir [Date/heure personnalisées](/docs/query-your-data/explore-query-data/use-charts/use-your-charts/#custom-date-time). + | +
| + limites d'attribut + | + +
+ Longueur maximale du nom de l'attribut : 255 caractères.
+
+ Longueur maximale des valeurs de l'attribut personnalisé :
+
+ * Pour un événement envoyé via [l'API événement](/docs/insights/insights-data-sources/custom-data/send-custom-events-event-api): 4096 caractères
+
+ * Pour un événement envoyé via des agents : 255 caractères
+
+ Attribut total maximum par événement : 254. |
+
| + Syntaxe de dénomination pour l'événement et l'attribut + | + ++ Les noms d'événements peuvent être une combinaison de caractères alphanumériques, de deux points (`:`) et de traits de soulignement (`_`). Les noms d'attributs peuvent inclure ceux-ci ainsi que des points (`.`) et des barres obliques (`/`). + + Nous vous recommandons de commencer les noms par une lettre : s'ils commencent par autre chose, vous devrez mettre des guillemets inversés autour du nom lors de la requête. Pour en savoir plus sur le moment où les guillemets inversés sont requis dans une requête, consultez [la référence NRQL](/docs/query-your-data/nrql-new-relic-query-language/get-started/introduction-nrql-how-nrql-works/#syntax). + + N'utilisez pas [de mots réservés à l'usage de NRQL](#reserved-words). + + Longueur maximale du nom de l'événement : 255 caractères. + | +
| + Valeurs nulles + | + ++ La base de données ne stocke aucune donnée avec une valeur nulle. + | +
|
+ |
+
+
+ |
+
|---|---|
| + `accountId` + | + ++ Il s'agit d'un nom [d'attribut](/docs/using-new-relic/welcome-new-relic/get-started/glossary#attribute) réservé. S'il est inclus, il sera supprimé lors de l'ingestion. + | +
| + `appId` + | + ++ La valeur doit être un entier. S'il ne s'agit pas d'un entier, le nom et la valeur de l'attribut seront supprimés lors de l'ingestion. + | +
| + `eventType` + | + ++ Le type d'événement tel que stocké dans New Relic. Les agents et scripts New Relic signalent normalement cela comme `eventType`. Peut être une combinaison de caractères alphanumériques, de deux points (`:`) et de traits de soulignement (`_`). Assurez-vous de vérifier les [valeurs `eventType` interdites](#prohibited-eventType) et [les limites`eventType` ](#event-limits). + | +
| + Valeurs `eventType` interdites + | + ++ Pour votre valeur `eventType`, évitez d'utiliser : + + * `Metric`, `MetricRaw` et les chaînes préfixées par `Metric[0-9]` (telles que `Metric2` ou `Metric1Minute`). + + * `Entity`, `EntityUpdate` et les chaînes préfixées par `Entity[0-9]` (telles que `Entity2` ou `Entity1HOUR`). + + * `EntityRelationship`, `RelationshipUpdate` et les chaînes préfixées par `Relationship[0-9]` (telles que `Relationship2` ou `Relationship1HOUR`) + + * `Public_` et les chaînes préfixées par `Public_`. + + Ces types d'événements sont réservés à l'usage de New Relic. l'événement transmis avec ces valeurs `eventType` sera supprimé. + | +
| + `timestamp` + | + ++ Doit être un horodatage d'époque Unix. Vous pouvez définir l'horodatage soit en secondes, soit en millisecondes. Il doit être +/-1 jour (24 heures) de l'heure actuelle sur le serveur. + | +
| + conditions de transfert de logs + | + ++ Les clés suivantes sont réservées par la fonctionnalité de transfert de log de l'agent d'infrastructure : `entity.guid`, log, `hostname`, `plugin.type`, `fb.input`.S'ils sont utilisés, ils sont supprimés lors de l'ingestion et un avertissement est ajouté au log. + | +
| + Termes de syntaxe NRQL + | + ++ Si vous devez utiliser des termes de syntaxe [NRQL](/docs/query-data/nrql-new-relic-query-language/getting-started/introduction-nrql) comme noms d'attribut, y compris des attributs en pointillés, ils doivent être placés entre guillemets inversés ; par exemple, `` `LIMIT` `` ou `` `consumer.offset` ``. Sinon, évitez d’utiliser ces mots réservés : + + `ago`, `and`, `as`, `auto`, + + `begin`, `begintime`, + + `compare`, + + `day`, `days`, + + `end`, `endtime`, `explain`, + + `facet`, `from`, + + `hour`, `hours`, + + `in`, `is`, + + `like`, `limit`, + + `minute`, `minutes`, `month`, `months`, + + `not`, `null`, + + `offset`, `or`, + + `raw`, + + `second`, `seconds`, `select`, `since`, + + `timeseries`, + + `until`, + + `week`, `weeks`, `where`, `with` + | +
|
+ |
+
+
+ |
+
|---|---|
| + Version de l'agent + | + ++ La version de votre agent monitoring de navigateurs doit être [1.277.0 ou supérieure](/docs/browser/new-relic-browser/installation-configuration/upgrading-browser-agent#checking). + | +
| + Version du navigateur client + | + ++ Pour enregistrer `Custom` événement, le navigateur doit [prendre en charge les XHR inter-domaines](/docs/browser/new-relic-browser/getting-started/compatibility-requirements#browser-types). + | +
| + événement par cycle + | + ++ `Custom` Les événements sont mis en mémoire tampon avec d'autres événements Browser et sont envoyés toutes les 30 secondes. Si 1 000 événements au total sont observés, l'agent récoltera immédiatement l'événement mis en mémoire tampon, en contournant l'intervalle du cycle de collecte. + | +
| + nom de l'événement/attribut, type de données, taille + | + ++ Assurez-vous de suivre [les exigences générales](/docs/insights/insights-data-sources/custom-data/data-requirements#general) concernant la syntaxe de dénomination des événements/attributs, les types de données et la taille. + | +
|
+ |
+
+
+ |
+
|---|---|
| + Version de l'agent + | + ++ La version de votre agent monitoring de navigateurs doit être [593 ou supérieure](/docs/browser/new-relic-browser/installation-configuration/upgrading-browser-agent#checking). + | +
| + Version du navigateur client + | + ++ Pour enregistrer `PageAction` événement, le navigateur doit [prendre en charge les XHR inter-domaines](/docs/browser/new-relic-browser/getting-started/compatibility-requirements#browser-types). + | +
| + événement par cycle + | + ++ `PageAction` Les événements sont mis en mémoire tampon avec d'autres événements Browser et sont envoyés toutes les 30 secondes. Si 1 000 événements sont observés, l'agent récoltera immédiatement l'événement mis en mémoire tampon, en contournant l'intervalle du cycle de collecte. + | +
| + nom de l'événement/attribut, type de données, taille + | + ++ Assurez-vous de suivre [les exigences générales](/docs/insights/insights-data-sources/custom-data/data-requirements#general) concernant la syntaxe de dénomination des événements/attributs, les types de données et la taille. + | +
| + agent + | + ++ Activer le transfert d'attribut + | +
|---|---|
| + Go + | + ++ Pour activer l'attribut, ajoutez ceci à votre configuration (désactivé par défaut) : + + ```go + cfg.BrowserMonitoring.Attributes.Enabled = true + ``` + + Ajoutez ensuite l’attribut que vous souhaitez inclure : + + ```go + cfg.BrowserMonitoring.Attributes.Include = []string{"request.*"} + ``` + | +
| + Java + | + ++ Ajoutez l’option [`attributes.enabled`](/docs/agents/java-agent/configuration/java-agent-configuration-config-file#cfg-browser-attributes-enabled) dans la section `browser_monitoring` et définissez-la sur `true`. + | +
| + .NET + | + +
+ Ajoutez l'élément [` |
+
| + Node.js + | + ++ Ajoutez [`attributes: {enabled: true}`](/docs/agents/nodejs-agent/installation-configuration/nodejs-agent-configuration#browser-debug-enabled) à la section `browser_monitoring` du fichier de configuration `newrelic.js` de votre application. + | +
| + PHP + | + ++ Ajoutez l’option [`newrelic.browser_monitoring.attributes.enabled`](/docs/agents/php-agent/attributes/enabling-disabling-attributes#cfg-browser-attributes-enabled) et définissez-la sur `true`. + | +
| + Python + | + ++ Ajoutez l’option [`browser_monitoring.attributes.enabled`](/docs/agents/python-agent/installation-configuration/python-agent-configuration#cfg-browser-attributes-enabled) et définissez-la sur `true`. + | +
| + Ruby + | + ++ Ajoutez l’option [`browser_monitoring.attributes.enabled`](/docs/agents/ruby-agent/installation-configuration/ruby-agent-configuration#browser_monitoring-attributes-enabled) et définissez-la sur `true`. + | +
| + Attribut + | + ++ Description + | +
|---|---|
| + identifiant de l'application + | + ++ Identifiant d'application de l'entité New Relic. + | +
| + nom de l'application + | + ++ Le nom de l'application de l'entité New Relic. + | +
| + asn + | + ++ Numéro de système autonome. + | +
| + asnLatitude + | + ++ La latitude associée à l'ASN + | +
| + asnLongitude + | + ++ La longitude associée à l'ASN + | +
| + Organisation asn + | + ++ L'organisation associée à l'ASN + | +
| + ville + | + ++ La ville où l'événement s'est produit. + | +
| + Code du pays + | + ++ Le code du pays où l'événement s'est produit. + | +
| + URL actuelle + | + ++ L'URL où l'événement s'est produit, qui inclut les navigations souples + | +
| + Type d'appareil + | + ++ Le type d'appareil sur lequel l'événement s'est produit. + | +
| + entityGuid + | + ++ Le GUID de l'entité New Relic. + | +
| + nom + | + ++ Le nom de la transaction s'il est fourni par APM + | +
| + URL de la page + | + ++ L'URL où l'événement s'est produit. + | +
| + code de région + | + ++ Le code de la région où l'événement s'est produit. + | +
| + session + | + ++ L'identifiant de session lié à la session utilisateur où l'événement s'est produit. + | +
| + sessionTraceId + | + ++ L'ID de trace de session lié au chargement de la page où l'événement s'est produit. + | +
| + horodatage + | + ++ L'horodatage Unix de l'événement. + | +
| + nom d'agent utilisateur + | + ++ Le nom de l'agent utilisateur où l'événement s'est produit. + | +
| + Agent utilisateur OS + | + ++ Le système d’exploitation de l’agent utilisateur où l’événement s’est produit. + | +
| + Version de l'agent utilisateur + | + ++ La version de l'agent utilisateur dans laquelle l'événement s'est produit. + | +
|
+ |
+
+
+ |
+
|---|---|
| + attribut personnalisé manquant + | + ++ Si votre attribut personnalisé n'apparaît pas sur l'événement `PageView`, vérifiez que vous appelez `setCustomAttribute` avant le chargement de l'événement sur votre page. Si l'attribut personnalisé est appelé après le chargement de la page, il ne sera pas visible sur `PageView`. + | +
| + `PageAction` événement + | + ++ Si votre événement `PageAction` n'apparaît pas lorsque vous effectuez votre requête, consultez les [exigences](#requirements). + + Si les exigences sont remplies, vérifiez que vous n'utilisez pas [de noms d'attributs réservés ou de valeurs non valides](/docs/insights/new-relic-insights/adding-querying-data/inserting-custom-events-insights-api#limits). + | +
| + `Custom` événement + | + ++ Si votre événement `custom` n'apparaît pas lorsque vous effectuez votre requête, consultez les [exigences](#requirements). + + Si les exigences sont remplies, vérifiez que vous n'utilisez pas [de noms d'attributs réservés ou de valeurs non valides](/docs/insights/new-relic-insights/adding-querying-data/inserting-custom-events-insights-api#limits). + | +
| + Source + | + ++ Comment envoyer des données personnalisées + | +
|---|---|
| + [Agent APM](/docs/apm/new-relic-apm/getting-started/introduction-apm) + | + +
+ Utilisez l |
+
| + [Agent monitoring des navigateurs](/docs/browser/browser-monitoring/getting-started/introduction-browser-monitoring) + | + ++ Utilisez l'API du navigateur d'agent pour [envoyer un événement personnalisé](/docs/data-apis/custom-data/custom-events/report-browser-monitoring-custom-events-attributes) et [définir l'attribut personnalisé](/docs/browser/new-relic-browser/browser-agent-spa-api/setcustomattribute-browser-agent-api). + + Transférer [l'attribut personnalisé de l'agent APM](/docs/data-apis/custom-data/custom-events/report-browser-monitoring-custom-events-attributes/) à l'événement `PageView` . + | +
| + [Evénement API](/docs/data-apis/ingest-apis/introduction-event-api) + | + ++ Pour signaler un événement personnalisé non associé à d'autres fonctionnalités de New Relic, utilisez l' [API événement](/docs/data-apis/ingest-apis/introduction-event-api). + | +
| + [Agent monitoring d'infrastructure](/docs/infrastructure/new-relic-infrastructure/data-instrumentation/default-infrastructure-attributes-events) + | + ++ [Ajoutez l'attribut personnalisé](/docs/infrastructure/manage-your-data/data-instrumentation/default-infrastructure-monitoring-data) à l'événement infrastructure par défaut. + + Utilisez l' [outil d'intégrationFlex ](/docs/infrastructure/host-integrations/host-integrations-list/flex-integration-tool-build-your-own-integration/)pour rapporter vos propres données d'événement personnalisé. + | +
| + [agent monitoring des applications mobiles](/docs/mobile-monitoring/new-relic-mobile/get-started/introduction-mobile-monitoring) + | + ++ Utilisez l'API mobile d'agent pour [envoyer un événement personnalisé et un attribut](/docs/data-apis/custom-data/custom-events/report-mobile-monitoring-custom-events-attributes). + | +
| + [Monitoring synthétique](/docs/synthetics/synthetic-monitoring/getting-started/get-started-synthetic-monitoring) + | + ++ [Ajoutez l'attribut personnalisé](/docs/synthetics/synthetic-monitoring/scripting-monitors/add-custom-attributes-synthetic-monitoring-data) à l'événement `SyntheticCheck` via les outils `$util.insights` . + | +
+
+
+
+
+
+| + Champ + | + ++ Description + | +
|---|---|
| + `aggregationTag.*` + + *chaîne*, *nombre* ou *horodatage* + | + +
+ |
+
| + `state` + + *énumération : (`trigger`, `resolve`)* + | + +
+ |
+
| + `priority` + + *énumération : (`low`, `medium`, `high`, `critical`)* + | + ++ La priorité de l'incident. Par défaut : `high`. + + La priorité la plus élevée sera utilisée lorsque des priorités différentes sont envoyées. + | +
| + `title` + + *chaîne* + | + +
+ |
+
| + `source` + + *chaîne* + | + +
+ |
+
| + `description` + + *chaîne* + | + ++ La description de l'événement déclencheur. + | +
| + `deepLinkUrl` + + *chaîne* + | + ++ Un lien profond vers une page liée à l'incident. + | +
| + `runbookUrl` + + *chaîne* + | + ++ Une URL runbook . + | +
| + `externalId` + + *chaîne* + | + ++ Un identifiant externe que vous pouvez attacher à l'événement. + + Par exemple, il peut être utilisé pour interroger les erreurs liées à l'ingestion de cet événement. + | +
| + `entityName` + + *chaîne* + | + ++ Le nom de l'entité qui a généré l'incident. + | +
| + `entity.guid` + + *chaîne* + | + ++ L'ID de l'entité qui a généré l'incident. + | +
| + `version` + + *virgule flottante* + | + ++ La version actuelle du format. + | +
| + attribut + | + ++ Directives relatives au format JSON + | +
|---|---|
| + `eventType` + | + +
+ |
+
| + Valeurs flottantes et chaînes + | + ++ Format de valeur flottante : `"label":value` + + Format de valeur de chaîne : `"label":"value"` + | +
| + Types de données + | + ++ L'API accepte uniquement les paires valeur-clé, pas les valeurs map/object ou éventail. Les types de données pris en charge pour cette API sont les chaînes et les nombres (entiers ou flottants). Pour plus d'informations, voir [Exigences en matière de données](/docs/insights/insights-data-sources/custom-data/insights-custom-data-requirements-limits). + | +
| + Chiffres dans les chaînes + | + ++ Pour des raisons de performances, nous ne convertissons pas les valeurs soumises à l'API. Par exemple, nous traitons `123` comme un nombre et `"123"` comme une chaîne. + + La base de données ne stockera que des nombres jusqu'à 64 bits. Tous les nombres supérieurs à 64 bits seront tronqués. + | +
| + Dates + | + ++ Pour les attributs contenant des informations de date, utilisez un horaire Unix non formaté dans le [formateur de données](/docs/insights/use-insights-ui/manage-account-data/data-formatter-set-default-formats-numeric-values). Vous pouvez [définir l'attribut date](#timestamp) soit en secondes, soit en millisecondes, tous deux relatifs à l'époque Unix. + | +
| + Temps + | + ++ Sauf indication contraire, l'horodatage d'un événement soumis correspond à l'heure à laquelle il a été soumis à New Relic. Pour spécifier une heure différente pour l'événement, utilisez l' [attribut`timestamp` ](#timestamp). + | +
| + Message de réussite + | + ++ Commentaires + | +
|---|---|
| + 200 + | + ++ ```json + {"success":true,"uuid":"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx"} + ``` + | +
| + Erreurs de soumission + | + ++ Dépannage + | +
|---|---|
| + 400 + | + ++ Longueur de contenu manquante ou non valide : impossible de traiter une demande vide. + | +
| + 403 + | + +
+ Clé manquante ou invalide : Clé de licence invalide. Inscrivez un |
+
| + 408 + | + ++ La demande a expiré : le traitement de la demande a pris trop de temps. + | +
| + 413 + | + ++ Contenu trop volumineux : la demande est trop volumineuse pour être traitée. Reportez-vous aux limites et aux caractères restreints pour résoudre les problèmes. + | +
| + 415 + | + ++ Type de contenu non valide : doit être application/JSON. L'API événement accepte tout type de contenu à l'exception des parties multiples/liées et suppose qu'il peut être analysé en JSON. + | +
| + 429 + | + ++ Trop de requests en raison de la limitation du débit. + | +
| + 503 + | + ++ Service temporairement indisponible : Demande de réessai + | +
| + Erreurs d'analyse + | + ++ Dépannage + | +
|---|---|
| + X événement(s) rejeté(s) car l'attribut `appId` n'était pas un entier + | + ++ Un attribut `appId` a une valeur non entière, telle qu'une valeur décimale ou une chaîne. + | +
| + X événement(s) rejeté(s) car `eventType` ne peut pas contenir les caractères suivants : `[., \]` + | + ++ Un attribut `eventType` comprenait un caractère non valide, tel qu'un point ou une barre oblique inverse. + | +
| + X événement(s) rejeté(s) car l'attribut ne contient pas de nom d'attribut + | + ++ Un nom d’attribut a été défini sur null ou une chaîne vide. + | +
| + X événement(s) rejeté(s) car le nom de l'attribut dépassait la longueur maximale + | + ++ Un nom d’attribut comporte plus de 255 caractères. + | +
| + X événement(s) rejeté(s) car la valeur de l'attribut dépassait la longueur maximale + | + ++ Une valeur d’attribut était plus longue que 4096 caractères. + | +
| + X événement(s) rejeté(s) car l'événement a dépassé le nombre maximum d'attributs + | + ++ Un événement possède plus de 255 attributs. + | +
| + X événement(s) rejeté(s) car attribut obligatoire manquant `eventType` + | + ++ L'attribut `eventType` est requis pour l'événement personnalisé. + | +
| + Erreur lors de l'analyse de la charge utile JSON + | + ++ Une erreur s'est produite lors de l'analyse de la demande JSON en raison de problèmes de formatage ou de données corrompues. + | +
| + Attribut NrIntegrationError + | + ++ Dépannage + | +
|---|---|
| + `timestamp` + | + ++ L'horodatage de réception de la demande. L'attribut `timestamp` prend un horodatage Unix entier de 64 bits dans les dernières 24 heures. Vous pouvez définir l'horodatage soit en secondes, soit en millisecondes, tous deux relatifs à l'époque Unix. + + N'utilisez pas de décimale pour l'horodatage. Si une décimale est utilisée, l'attribut sera par défaut l'horodatage lors de la création de l'événement personnalisé. + | +
| + `newRelicFeature` + | + ++ Le nom de la fonctionnalité rencontrant des erreurs. Pour toutes les erreurs d'analyse d'événement personnalisé, ce sera `Event API`. + | +
| + `apiKeyPrefix` + | + +
+ Les six premiers caractères du |
+
| + `requestId` + | + ++ Le `uuid` renvoyé par l'API pour la requête qui a généré une erreur. + | +
| + `category` + | + ++ La catégorie de l'erreur. Pour un événement personnalisé, c'est `EventApiException`. + | +
| + `message` + | + ++ Contenu du message d'erreur. + | +
| + `name` + | + ++ Le nom de l'erreur. Pour un événement personnalisé, c'est toujours `EventValidationException`. + | +
| + `eventTypeSample` + | + ++ L'un des types d'événements ayant généré l'erreur, lorsqu'il était disponible. + | +
+
+Lorsqu'elle est soumise à l'API métrique, l'une de ces métriques pourrait ressembler à ceci :
+
+```json
+{
+ "metrics": [
+ {
+ "name": "memory.heap",
+ "type": "gauge",
+ "value": 5514,
+ "timestamp": 1234567890,
+ "attributes": {
+ "host": "W",
+ "container": "1"
+ }
+ }
+ ]
+}
+```
+
+Cette métrique aurait alors une cardinalité de 8, car c'est le nombre de modélisations uniques de `host` et `container` possibles. Si une nouvelle mesure pour cette métrique est prise avec un attribut identique à celui précédemment rapporté, aucune nouvelle cardinalité ne sera comptabilisée.
+
+## Influences de la cardinalité [#influences]
+
+Comme indiqué ci-dessus, toute modification apportée aux clés ou aux valeurs représentera une nouvelle cardinalité, mais prédire comment ces modifications affecteront votre cardinalité totale peut devenir un peu délicat. Il est tentant de supposer que la cardinalité d'une métrique est alors le produit du nombre de toutes les valeurs possibles pour chaque clé possible, mais c'est rarement le cas dans la pratique, car les valeurs d'une clé donnée dépendent souvent ou déterminent les valeurs d'autres clés.
+
+En utilisant l'exemple précédent, une fois que nous avions une valeur `container` de `1`, la valeur de `host` a été fixée à `W`, en supposant que ces identifiants de conteneur sont uniques au niveau mondial. Ainsi, bien qu'il y ait 8 conteneurs sur 4 hôtes, la cardinalité est toujours 8, et non 4 \* 8 = 32, puisque la plupart des combinaisons comptées par la méthode de multiplication simple ne sont pas possibles et ne contribuent donc pas à la cardinalité de cette métrique. Nous ne verrons jamais la combinaison de `host = 'X', container = 1`, par instance.
+
+Cela signifie également que l’ajout de clés supplémentaires à une carte d’attributs n’implique pas nécessairement une augmentation de la cardinalité totale. Si la valeur de la nouvelle clé est déterminée de manière unique par les valeurs des clés existantes, elle n’ajoutera pas de nouvelle cardinalité à long terme. Par instance si vous ajoutez quelque chose comme `region` à votre carte dans l'exemple, il est probable que la valeur `container` soit également fixée à une valeur de région particulière et maintienne donc votre cardinalité à 8.
+
+Un avertissement important ici est que même si l’ajout de `region` n’augmentera pas la cardinalité à l’avenir, il introduira une nouvelle cardinalité lors de son premier ajout. Cela est dû au fait que l’ajout de clés rendra ces cartes d’attributs distinctes de toutes celles qui les ont précédées, augmentant temporairement la cardinalité totale pour ce jour.
+
+## Exemples et exemples de workflow [#examples-samples]
+
+Si vous atteignez l'une de vos limites de cardinalité, vous pouvez utiliser plusieurs options pour remédier à la situation. Une réponse simple consiste à augmenter vos limites, mais si vous préférez ne pas le faire, une bonne alternative est d’explorer les dimensions qui contribuent le plus à votre cardinalité et de penser à les supprimer si elles n’apportent pas de valeur. Cela peut vous permettre d’économiser sur les coûts de stockage et de bande passante et potentiellement vous éviter d’avoir à augmenter vos limites.
+
+### Trouver les contributeurs de cardinalité : métriques [#metrics-contributors]
+
+Rappelons comment obtenir la cardinalité d’une métrique particulière :
+
+```sql
+FROM Metric SELECT cardinality(memory.heap) SINCE today RAW
+```
+
+Pour la cardinalité totale du compte, vous pouvez utiliser la même structure de requête de base et simplement omettre le nom de la métrique :
+
+```sql
+FROM Metric SELECT cardinality() SINCE today RAW
+```
+
+La cardinalité du compte est essentiellement la somme de la cardinalité de chaque métrique, donc l'ajout d'une simple requête `FACET` peut aider à trouver la cardinalité métrique forte :
+
+```sql
+FROM Metric SELECT cardinality() SINCE today RAW FACET metricName
+```
+
+Enfin, si vous pensez avoir atteint l'une de vos limites de cardinalité, vous pouvez le confirmer en recherchant un `NrIntegrationError` associé :
+
+```sql
+FROM NrIntegrationError SELECT count(*)
+WHERE name = 'CardinalityViolationException' AND newRelicFeature = 'Metrics'
+FACET cardinalityLimitType, metricName, message SINCE today
+```
+
+### Recherche des contributeurs de cardinalité : dimensions [#dimensions-contributors]
+
+Une fois que vous avez déterminé la métrique que vous souhaitez explorer, l’étape suivante consiste à déterminer quelles dimensions d’une métrique donnée contribuent le plus à sa cardinalité. Si vous n'êtes pas familier avec les valeurs de vos dimensions, vous pouvez les considérer comme ceci :
+
+```sql
+FROM Metric SELECT dimensions() WHERE metricName = 'memory.heap' SINCE today RAW
+```
+
+La vue des résultats JSON sera probablement recommandée ici. En les examinant, vous pourriez découvrir certaines dimensions contenant un identifiant unique ou une autre valeur très variable qui pourrait valoir la peine d'être supprimée.
+
+Si vous connaissez déjà les valeurs que votre attribut peut prendre, les résultats `keySet()` peuvent être plus faciles à analyser :
+
+```sql
+FROM Metric SELECT keySet() WHERE metricName = 'memory.heap' SINCE today RAW
+```
+
+Comprendre les dimensions qui ont le plus d’influence sur votre cardinalité totale revient à comprendre comment les valeurs de chaque clé sont corrélées les unes aux autres. Vous pouvez tester quelle serait votre cardinalité sans dimension simplement en l'ajoutant à la liste d'exclusion :
+
+```sql
+FROM Metric SELECT cardinality(memory.heap, exclude: {'container.id'}) SINCE today RAW
+```
+
+De même, il existe une liste d'inclusion si cela est plus pratique dans le contexte de la requête :
+
+```sql
+FROM Metric SELECT cardinality(memory.heap, include: {'host.name', 'region'}) SINCE today RAW
+```
+
+La gestion de la cardinalité peut être difficile à conceptualiser, mais les méthodes ci-dessus vous aideront à obtenir des réponses à des questions telles que « Quelle métrique contribue le plus à la cardinalité ? » et « Quel impact un ou plusieurs attributs donnés ont-ils sur cette cardinalité totale ? ».
+
+Il arrive souvent que la cardinalité suive la valeur la plus unique, car cette valeur peut déterminer les valeurs possibles que d'autres attributs peuvent prendre. Cependant, il existe de nombreux cas où l’explosion des combinaisons possibles d’une poignée d’attributs détermine la cardinalité totale. Les éléments qui ressemblent à des identifiants uniques sont généralement un bon point de départ, mais parfois, il ne s'agit pas d'une clé unique mais de la combinaison de deux ou plusieurs clés. Plus vous serez familier avec vos données et le système qui les génère, plus il sera facile de savoir quel attribut inclure ou exclure.
+
+### Ajuster les limites de cardinalité [#adjusting-cardinality-limits]
+
+Une fois qu'une métrique a été identifiée avec une forte cardinalité et déterminée comme étant une utilisation valide de cette cardinalité, certains ajustements sont possibles pour aider à atténuer toute violation de limite qui pourrait survenir. Pour augmenter la cardinalité d'un nom de métrique particulier, vous pouvez utiliser notre [API NerdGraph](/docs/apis/nerdgraph/get-started/introduction-new-relic-nerdgraph). Quelques exemples requests NerdGraph sont inclus ci-dessous.
+
+Avant d’utiliser l’API pour ajuster les limites de cardinalité, examinez [les facteurs qui influencent la cardinalité](#influences).
+
+
+
+
+
+Toutes les métriques ont une limite de cardinalité par défaut de 100 000. En fonction de vos besoins, vous pouvez [ajuster les limites par métrique](#per-metric-limit-adjustment).
+
+## Décomposition de la cardinalité métrique [#metric-cardinality-breakdown]
+
+Sélectionnez une métrique dans la table 
+
+### graphique à barres
+
+Dans la vue spécifique aux métriques, vous pouvez vérifier l'utilisation actuelle de la cardinalité avec deux graphiques à barres :
+
+* 
+
+4. Cliquez sur 
+
+3. Saisissez un nom ou une description de règle.
+
+4. Pour créer la règle d’élagage, cliquez sur | + Condition + | + ++ Limite + | +
|---|---|
| + Tranche d'âge pour les valeurs d'horodatage + | + ++ Les métriques rapportées avec un horodatage datant de plus de 48 heures ou de plus de 24 heures à compter du moment où elles sont rapportées sont supprimées. + | +
| + Nombre maximal de points de données par minute (DPM) + | + ++ 3 à 15 millions de DPM [(en savoir plus)](#additional-considerations) + | +
| + Nombre maximal de séries temporelles uniques (cardinalité) par compte et par jour + | + ++ 1 à 15 millions [(en savoir plus)](#additional-considerations) + + Une série chronologique est une combinaison unique d'un nom métrique et de n'importe quel attribut. + | +
| + Nombre maximal de séries temporelles uniques (cardinalité) par nom de métrique et par jour + | + ++ 100 000 + | +
| + Charge maximale par minute + | + ++ 100k [(en savoir plus)](#additional-considerations) + | +
| + Attribut max par métrique + | + ++ 100 + | +
| + Longueur maximale du nom de l'attribut métrique + | + ++ 255 caractères + | +
| + Nombre maximal de caractères pour une clé d'attribut + | + ++ 255 caractères + | +
| + Longueur maximale de la valeur d'attribut métrique + | + ++ 4096 caractères + | +
| + Protocoles HTTP autorisés + | + ++ HTTPS uniquement + | +
| + Valeurs longues numériques se situant en dehors des valeurs longues Java minimales ou maximales + | + ++ Les valeurs numériques longues qui ne correspondent pas à la valeur longue Java minimale ou maximale seront rejetées. + + * Si le numéro se trouve dans le bloc commun, le bloc entier sera supprimé. + * Si le nombre se trouve dans un point de données métrique, le point de données métrique dans lequel il réside sera supprimé. + | +
| + Valeurs doubles numériques se situant en dehors des valeurs doubles Java minimales ou maximales + | + ++ Les valeurs doubles numériques qui se situent en dehors d'une valeur double Java minimale ou maximale seront rejetées. + + * Si le numéro se trouve dans le bloc commun, le bloc entier sera supprimé. + * Si le nombre se trouve dans un point de données métrique, le point de données métrique dans lequel il réside sera supprimé. + | +
| + Valeurs doubles numériques qui nécessitent un arrondi pour être converties en un nombre à virgule flottante double précision. + | + ++ Les valeurs numériques doubles qui nécessitent un arrondi pour être converties en un nombre à virgule flottante double précision seront rejetées. + + Un exemple de ceci est `1.12345678901234567E18`. Un double peut contenir une valeur aussi grande mais il n'a pas assez de précision pour la représenter avec précision (il faudrait l'arrondir à `1.12345678901234573E18`). + + * Si le numéro se trouve dans le bloc commun, le bloc entier sera supprimé. + * Si le nombre se trouve dans un point de données métrique, le point de données métrique dans lequel il réside sera supprimé. + | +
| + Taille de la charge utile + | + +
+ Taille ou longueur maximale totale : |
+
| + Format de charge utile + | + +
+ La charge utile doit être codée comme |
+
| + syntaxe de dénomination des attributs + | + ++ Les noms d'attributs peuvent être une combinaison de caractères alphanumériques, de deux points (`:`), de points (`.`) et de traits de soulignement (`_`). + | +
| + Condition + | + ++ Limite + | +
|---|---|
| + Nombre maximal de séries chronologiques uniques de décompte et de résumé (cardinalité) par compte par intervalle de 5 minutes + | + ++ 1 à 15 millions [(en savoir plus)](#additional-considerations) + + Une série chronologique est une combinaison unique d'un nom métrique et de n'importe quel attribut. Les séries chronologiques reçues au-dessus de cette limite sont supprimées. Cette limite est appliquée avant et en plus des limites métriques standard. + | +
| + Attribut + | + ++ Description + | +
|---|---|
| + `newrelic.source` + | + ++ Cela réinitialise à la valeur `metricAPI`. + | +
| + `metricName` + | + ++ Cela réinitialise la valeur `name` transmise à chaque point de données. Cela permet `name` d’être une clé d’attribut. + | +
| + `endTimestamp` + | + ++ `timestamp` et `interval.ms` sera converti en `endTimestamp` pour le point de données. + | +
| + Attribut + | + ++ Description + | +
|---|---|
| + `entity.guid` + | + ++ Identifiant unique attribué à une entité par New Relic. + | +
| + `entity.name` + | + ++ Nom lisible par l'homme d'une entité, souvent utilisé pour identifier une entité dans l'UI. + | +
| + `entity.type` + | + ++ Utilisé pour différencier les différents types d'entités, comme les hôtes, les applications, etc. + | +
| + Restriction + | + ++ Commentaires + | +
|---|---|
| + métrique et noms d'attributs + | + +
+ Vous ne pouvez pas transmettre la même valeur pour le nom de la métrique et le nom de l'attribut.
+
+ Dans l'exemple suivant, la métrique n'est pas valide car elle est nommée `service.errors.all` et il existe un attribut `service.errors.all`.
+
+ |
+
| + Mots réservés + | + ++ Évitez d’utiliser [des mots réservés](/docs/data-apis/custom-data/custom-events/data-requirements-limits-custom-event-data/#reserved-words), tels que `accountId`, `appId` et `eventType`. Vous devez également éviter d'utiliser les termes de syntaxe NRQL, sauf si vous les mettez entre guillemets (` `` `). + | +
| + Clés dans la métrique JSON + | + +
+ Toutes les clés utilisées dans la métrique JSON ne peuvent pas être des clés d’attribut. Cela inclut `interval.ms`, `timestamp`, `value`, `common`, `min`, `max`, `count`, `sum` et `metrics`.
+
+ |
+
| + En-tête + | + ++ Envoyer comme paramètre de requête ? + | + ++ Détails + | +
|---|---|---|
| + `Content-Type` + | + ++ Non + | + +
+ |
+
| + `Content-Length` + | + ++ Non + | + +
+ |
+
| + `Api-Key` + | + ++ Oui + | + +
+ |
+
| + `Content-Encoding` + | + ++ Non + | + +
+ |
+
| + `x-request-id` + | + ++ Non + | + +
+ |
+
| + Clé + | + ++ Description + | +
|---|---|
| + `name` + + *chaîne* + | + +
+ |
+
| + `value` + + *numéro* ou *carte* + | + +
+ |
+
| + `timestamp` + + *long* + | + +
+ |
+
| + `interval.ms` + + *positif long* + | + +
+ |
+
| + `type` + | + ++ Recommandé. Cela doit être l’un des [types métriques pris en charge](/docs/telemetry-data-platform/ingest-manage-data/understand-data/metric-data-type). Si vous ne spécifiez pas de type, la valeur par défaut sera `gauge`. + | +
| + `attributes` + + *chaînes*, *nombres JSON* ou *booléens* + | + ++ Recommandé. Une carte des paires de valeurs clés associées à cette métrique spécifique. Les valeurs peuvent être des chaînes, des nombres JSON ou des booléens. Les clés sont sensibles à la casse et doivent comporter moins de 255 caractères. + | +
| + Attribut + | + ++ Description + | +
|---|---|
| + `timestamp` + + *long* + | + ++ L'heure de début de la métrique en [heure Unix](https://currentmillis.com/). La valeur par défaut est l'heure actuelle dans le fuseau horaire UTC. Ce champ prend également en charge les secondes, les microsecondes et les nanosecondes. Cependant, les données seront converties en millisecondes pour le stockage et l'interrogation ultérieure. + | +
| + `interval.ms` + + *positif long* + | + +
+ |
+
| + `attributes` + + *chaînes, nombres JSON ou booléens* + | + ++ Une carte des paires de valeurs clés associées à cette métrique spécifique. Les valeurs peuvent être des chaînes, des nombres JSON ou des booléens. + | +
| + Code d'état + | + ++ Définition + | +
|---|---|
| + `202` + | + ++ Données acceptées. + | +
| + `400` + | + ++ La structure de la demande n'est pas valide. + | +
| + `403` + | + ++ Échec d'authentification. + | +
| + `404` + | + ++ Le chemin de la demande est incorrect. + | +
| + `405` + | + ++ J'ai utilisé une méthode de requête autre que POST. + | +
| + `408` + | + ++ La demande a mis trop de temps à atteindre le point de terminaison. + | +
| + `411` + | + ++ L'en-tête `Content-Length` n'a pas été inclus. + | +
| + `413` + | + ++ La charge utile était trop lourde. la charge doit être inférieure à 1 Mo (10^6 octets). + | +
| + `414` + | + ++ L'URI de la demande était trop longue. + | +
| + `415` + | + ++ Le `Content-Type` ou `Content-Encoding` n'était pas valide. + | +
| + `429` + | + ++ Le quota du taux de requêtes a été dépassé. + | +
| + `431` + | + ++ Les en-têtes de requête sont trop longs. + | +
| + `5xx` + | + ++ Une erreur de serveur s'est produite (veuillez réessayer). + | +
| + Catégorie + | + ++ Type de limite de taux + | + ++ Description et solution + | +
|---|---|---|
| + `BadRequest` + | + ++ (non défini) + | + ++ Il y a un problème avec la charge utile JSON. Il s’agit notamment d’erreurs de syntaxe JSON, de noms d’attributs ou de valeurs trop longues. + + Vérifiez le champ `message` pour déterminer le problème exact. Vérifiez ensuite la charge utile JSON et mettez-la à jour pour vous assurer qu’elle répond aux directives sémantiques appropriées. + | +
| + `RateLimit` + | + ++ `DatapointsPerMinute` + | + ++ Vous envoyez trop de points de données par minute. Si vous obtenez cette erreur, vous pouvez soit envoyer des données moins fréquemment, soit demander des modifications de vos limites de débit métrique en contactant votre représentant de compte New Relic ou en visitant notre [portail d'assistance](https://support.newrelic.com/). + | +
| + `RateLimit` + | + ++ `UniqueTimeseriesPerDay` + | + ++ Vous avez un attribut avec un nombre élevé de valeur unique, comme `containerId` ou `URI`. Pour résoudre cette erreur, examinez tout attribut pouvant être à l’origine du problème et supprimez-le. Si vous le souhaitez, vous pouvez utiliser des [règles de suppression des données](/docs/accounts/accounts/data-management/drop-data-using-nerdgraph) pour supprimer l'attribut au moment de l'ingestion. + | +
| + `RateLimit` + | + ++ `UniquePrometheusTimeseries` + | + ++ Vous avez des serveurs Prometheus qui signalent trop de séries chronologiques uniques via [le point de terminaison remote\_write de New Relic](/docs/integrations/prometheus-integrations/get-started/monitor-prometheus-new-relic#remote-write). + + Réduisez le nombre de séries chronologiques uniques signalées en modifiant de [Prometheus votre configuration](https://prometheus.io/docs/prometheus/latest/configuration/configuration/) serveur pour réduire le nombre de cibles récupérées, ou en utilisant des [règles de réétiquetage](https://prometheus.io/docs/prometheus/latest/configuration/configuration/#relabel_config) dans la [section remote\_write de de votre serveur](https://prometheus.io/docs/prometheus/latest/configuration/configuration/#remote_write) configuration pour supprimer les séries chronologiques ou les étiquettes hautement uniques. + | +
| + `RateLimit` + | + ++ `RequestsPerMinute` + | + ++ Trop de requests sont envoyées par minute. Pour résoudre ce problème, placez plus de points de données dans chaque requête et envoyez-les moins fréquemment. + | +
| + `RateLimit` + | + ++ `ErrorGroupsPerDay` + | + ++ Vous avez dépassé votre limite de groupe d’erreurs quotidiennes. Les groupes d'erreurs entrants seront abandonnés pour le reste de la journée et continueront normalement après minuit UTC. + + Pour résoudre ce problème, réduisez la quantité de messages d'erreur uniques collectés par New Relic. + | +
| + paramètres + | + ++ Description + | +
|---|---|
| + `repository` + | + ++ Facultatif : l'URL du référentiel pour l'application avec votre intégration. + | +
| + Champ + | + ++ Description + | +
|---|---|
| + `source` + | + ++ Le nom convivial de l'outil de sécurité qui a généré cet événement tel que `Snyk` ou `Dependabot`. + | +
| + `title` + | + ++ Un bref résumé (50 à 100 caractères) du problème. Devrait convenir à une utilisation comme titre de page ou comme contenu de cellule de tableau. + | +
| + `message` + | + ++ Description détaillée du problème, y compris l’explication du résultat et la manière d’y remédier. Peut inclure une réduction. + | +
| + `issueType` + | + ++ Un type de problème pris en charge par New Relic. Actuellement, ce sont : + + * `Library Vulnerability` + * `Container Vulnerability` + * `Host Vulnerability` + | +
| + `issueId` + | + ++ Un identifiant standard pour le problème détecté. Par exemple, l'identifiant CVE ou CWE, ou la règle critères CIS. Si plusieurs outils détectent le même problème, le `issueId` doit être le même pour tous les outils. + | +
| + `severity` + | + ++ Le consensus communautaire défini sur la gravité du problème ou de l’outil d’analyse. Cela devrait être l'un des suivants : + + * `CRITICAL` + * `HIGH` + * `MEDIUM` + * `LOW` + * `INFO` + | +
| + `entityType` + | + ++ Utilisé pour corréler un problème signalé à une [entité](/docs/new-relic-solutions/new-relic-one/core-concepts/what-entity-new-relic/) connue de la plateforme New Relic. Doit être l'un des types reconnus par l'API de recherche d'entité, ou des cas particuliers pris en charge par l'API de sécurité (`Image` et `AWS`). + + Un exemple avec `entityLookupValue` serait : + + ```json + "entityType": "AWS", + "entityLookupValue": "arn:aws:rds:us-east-2:403720000000:db:my-database" + ``` + | +
| + `entityLookupValue` + | + ++ Utilisé pour trouver l'entité appropriée de ce type. + + Un exemple avec `entityType` serait : + + ```json + "entityType": "Repository", + "entityLookupValue": "https://github.com/newrelic/ruby_agent" + ``` + | +
| + `entityGuid` + | + ++ Un identifiant unique pour une entité spécifique au sein de la plateforme New Relic, essentiel pour le suivi et la gestion des applications, des services ou des composants d'infrastructure. + + Un exemple de `entityGuid` serait : + + ``` + "entityGuid": "MTI1NjM5fEFQfEFQUExJQ0FUSU9OfDEyMzQ1Njc4OQ" + ``` + | +
| + Champ + | + ++ Description + | +
|---|---|
| + `cvssScore` + | + ++ Le score CVSSv3 attribué au CVE, sous forme de nombre à virgule flottante au format JSON/ + | +
| + `cvssVector` + | + ++ Le vecteur CVSSv3 décrivant ce CVE. + | +
| + `issueInstanceKey` + | + ++ Un chemin ou un identifiant qui identifie de manière unique l'occurrence de cette instance des vulnérabilités à partir d'une autre instance dans le même référentiel (référentiel), service, entité ou compte. Par exemple : chemin complet vers un fichier plus le numéro de ligne pour une recherche de code source, ou chemin vers un binaire vulnérable sur un hôte ou dans une image de conteneur. La clé instance doit être identique pour les résultats répétés du même problème tout en différenciant plusieurs instances nécessitant chacune une correction. S'il n'est pas fourni, le `entityGuid` résolu ou `entityLookupValue` fourni par l'utilisateur est utilisé. + | +
| + `issueVendorID` + | + ++ Identifiant spécifique au fournisseur pour le problème, s'il est différent de `issueId`. + | +
| + `disclosureUrl` + | + ++ Une URL vers des informations supplémentaires sur le problème, provenant soit du site Web du fournisseur de l'outil source, soit de références de divulgation publique. Cela devrait être une source fiable. + | +
| + `remediationExists` + | + ++ Booléen indiquant si un correctif pour le problème existe. + | +
| + `remediationRecommendation` + | + ++ Texte court expliquant les mesures à prendre pour remédier au problème. Pour les dépendances de tiers, utilisez le formulaire `upgrade PACKAGE_NAME to X.Y.Z` + | +
| + `detectedAt` + | + ++ Horodatage du moment où le problème a été détecté, en millisecondes depuis l'époque. Si elles ne sont pas fournies, nous utilisons le moment où les données sont envoyées à New Relic. + | +
| + Langue + | + ++ Bibliothèque + | + ++ Types de données New Relic pris en charge + | +
|---|---|---|
| + Java + | + ++ [Bibliothèque Java sur GitHub](https://github.com/newrelic/newrelic-telemetry-sdk-java) + | + ++ Métriques + + Événements + + Logs + + Traces + | +
| + Node/TypeScript + | + ++ [Bibliothèque Node.js sur GitHub](https://github.com/newrelic/newrelic-telemetry-sdk-node) + | + ++ Métriques + + Traces + | +
| + Python + | + ++ [Bibliothèque Python sur GitHub](https://github.com/newrelic/newrelic-telemetry-sdk-python) + | + ++ Métriques + + Événements + + Logs + + Traces + | +
| + Go + | + ++ [Bibliothèque Go sur Github](https://github.com/newrelic/newrelic-telemetry-sdk-go) + | + ++ Métriques + + Traces + | +
| + C + | + ++ [Bibliothèque C sur Github](https://github.com/newrelic/newrelic-telemetry-sdk-c) + | + ++ Traces + | +
| + Rust + | + ++ [Bibliothèque Rust sur Github](https://github.com/newrelic/newrelic-telemetry-sdk-rust) + | + ++ Traces + | +
| + Ruby + | + ++ [Bibliothèque Ruby sur Github](https://github.com/newrelic/newrelic-telemetry-sdk-ruby) + + [Gem sur Rubygems](https://rubygems.org/gems/newrelic-telemetry_sdk) + | + ++ Traces + | +
| + Type de règle de suppression + | + ++ NRQL + | +
|---|---|
| + `DROP_DATA` + | + +
+ |
+
| + `DROP_ATTRIBUTES` + | + +
+ |
+
+
+
+
+
+
+| + Source des données + | + ++ espace de nommage + | + ++ Conservation pour [option de données originales](/docs/accounts/accounts-billing/new-relic-one-pricing-billing/data-ingest-billing#data-prices) (jours) + | + ++ Conservation [des données plus](/docs/accounts/accounts-billing/new-relic-one-pricing-billing/data-ingest-billing#data-prices) (jours) + | +
|---|---|---|---|
| + APM + | + ++ APM + | + ++ 8 + | + ++ 98 + | +
| + APM + | + ++ Erreurs APM + | + ++ 8 + | + ++ 98 + | +
| + APM + | + ++ Erreur de suivi des appels APM + | + ++ 8 + | + ++ 8 + | +
| + navigateur + | + ++ Tous ([en savoir plus](#browser-namespaces)) + | + ++ 8 + | + ++ 98 + | +
| + Événements personnalisés + | + ++ Événements personnalisés + | + ++ 30 + | + ++ 120 + | +
| + Enregistrement + | + ++ Enregistrement + | + ++ 30 + | + ++ 120 + | +
| + infrastructure + | + ++ Processus d'infrastructure ([en savoir plus](#infrastructure-data)) + | + ++ 8 + | + ++ 98 + | +
| + infrastructure + | + ++ intégration d'infrastructures ([en savoir plus](#infrastructure-data)) + | + ++ 395 (13 mois) + | + ++ 485 (16 mois) + | +
| + Marker ([suivi des changements](/docs/change-tracking/change-tracking-introduction)) + | + ++ Marqueur + | + ++ 395 (13 mois) + | + ++ 485 (16 mois) + | +
| + Applications mobiles + | + ++ Mobile crash suivi des événements (fil d'Ariane) + | + ++ 8 + | + ++ 98 + | +
| + Applications mobiles + | + ++ Exception mobile + | + ++ 8 + | + ++ 98 + | +
| + Applications mobiles + | + ++ Mobile général + | + ++ 8 + | + ++ 98 + | +
| + Applications mobiles + | + ++ Erreur mobile + | + ++ 8 + | + ++ 98 + | +
| + Applications mobiles + | + ++ Crash du mobile + | + ++ 90 + | + ++ 180 + | +
| + Applications mobiles + | + ++ Session mobile + | + ++ 90 + | + ++ 180 + | +
| + Réseau + | + ++ Flux (cloud et sur site) + | + ++ 30 + | + ++ 120 + | +
| + Réseau + | + ++ SNMP ([voir métriques](#dimensional-metrics)) + | + ++ 395 + | + ++ 485 + | +
| + Réseau + | + +
+ |
+
+ + 30 + | + ++ 120 + | +
| + Serverless + | + ++ Lambda + | + ++ 8 + | + ++ 98 + | +
| + Serverless + | + ++ Lambda personnalisé + | + ++ 8 + | + ++ 98 + | +
| + Serverless + | + ++ Étendues Lambda + | + ++ 8 + | + ++ 98 + | +
| + monitoring synthétique (non modifiable) + | + ++ Données synthétiques (non modifiables) + | + ++ 395 (13 mois) + | + ++ 395 (13 mois) + | +
| + Traces + | + ++ traces distribuées + | + ++ 8 + | + ++ 98 + | +
| + APM + | + +
+ * [Apdex](/docs/site/apdex-measuring-user-satisfaction), pour le serveur d'applications
+ * débit et pages vues
+ * temps de réponse, ainsi qu'une répartition par [niveau](/docs/accounts-partnerships/education/getting-started-new-relic/glossary#tier) ou catégories sur [le graphique principal |
+
| + navigateur + | + ++ * [Apdex](/docs/site/apdex-measuring-user-satisfaction), pour navigateur + * navigateur temps de chargement de page + * débit total. Après 90 jours, il n'y a pas de répartition par type de navigateur et seule la valeur moyenne combinée est disponible pour la plage horaire demandée. + | +
| + Applications mobiles + | + ++ * taux de plantation : pour [iOS](/docs/mobile-monitoring/new-relic-mobile/getting-started/ios-agent-crash-reporting) et pour [Android](/docs/mobile-monitoring/new-relic-mobile/getting-started/android-agent-crash-reporting) + * [Débit du réseau](/docs/mobile-monitoring/mobile-monitoring-ui/network-pages/http-requests-page) + * [Temps de réponse du réseau](/docs/mobile-monitoring/mobile-monitoring-ui/network-pages/http-requests-page) + * [Taux d'erreur du réseau](/docs/mobile-monitoring/mobile-monitoring-ui/network-pages/errors-mobile-apps) + * [trace d'interaction](/docs/mobile-monitoring/mobile-monitoring-ui/mobile-app-pages/interactions-page) + | +
|
+ |
+
+
+ |
+
+
+ |
+
|---|---|---|
| + Brut (5, 10 ou 15 secondes) + | + ++ 0 à 59 minutes + | + ++ 8 jours + | +
| + 1 minute + | + ++ 60 minutes à 6 heures + | + ++ 30 jours + | +
| + 10 minutes + | + ++ 6 heures à 3 jours + | + ++ 13 mois + | +
| + 1 heure + | + ++ 3 jours à 14 jours + | + ++ 13 mois + | +
| + 3 heures + | + ++ 14+ jours + | + ++ 13 mois + | +
+
+
+
+
+
+|
+ |
+
+
+ |
+
| + `category` + | + ++ `RateLimit` ou `ApiLimit`. La catégorie `RateLimit` est utilisée pour les limites basées sur une unité de temps telle que le nombre de requests ingérées par minute. Le `ApiLimit` est utilisé pour les limites constantes, telles que le nombre d'attributs sur un enregistrement. + | +
| + `limitName` + | + ++ Le nom de la limite. + | +
| + `message` + | + ++ Décrit la limite et l'impact. + | +
| + Valeur limite + | + ++ La limite atteinte. + | +
| + Condition limitée + | + ++ Limite + | +
|---|---|
| + Taux d'ingestion d'enregistrements NRDB\* + | + ++ 55 millions par compte et par minute + | +
| + Nombre maximal d'enregistrements NRDB\* ingérés par appel d'API + | + ++ 1 Mo (10^6 octets) + | +
| + Taille maximale de la valeur d'attribut + | + ++ 1 Ko (10^3 octets) + | +
| + Longueur maximale du nom d'attribut + | + ++ 255 caractères + | +
| + Longueur maximale de la valeur d'attribut + | + ++ API de métrique, de trace et d'événement : 4 096 caractères. log API : 4 094 caractères. + | +
| + Taille maximale de la charge utile + | + ++ 1 Mo (10^6 octets) + | +
| + Nombre total maximal d'attributs par type de données (y compris l'attribut par défaut) + | + ++ 254 (moins pour certains outils ; par exemple, 64 pour les agents) + | +
| + Nombre de [types de données](/docs/telemetry-data-platform/ingest-manage-data/understand-data/new-relic-data-types) personnalisées uniques par compte par [espace de nommage](/docs/data-apis/manage-data/manage-data-retention) par jour + | + ++ 250 (principalement une limite pour [événement personnalisé](/docs/insights/insights-data-sources/custom-data/report-custom-event-data)) + | +
| + Limites APM + | + ++ * Instance d'agent : 50 000 par compte + * Instance d'agent par application : 10 000 + | +
| + Browser: nombre de pages vues + | + ++ 1 M par minute par application + | +
|
+ Taux d' [intervalle de temps métrique](/docs/telemetry-data-platform/ingest-manage-data/understand-data/new-relic-data-types#timeslice-data) (utilisé par APM, navigateur, |
+
+ + * Ingestion : 2 millions par minute + * Taux de noms : 4 millions par minute par compte + * Nombre par application de monitoring : 300 000 + | +
| + Tracing distribué + | + ++ Voir [Limites de traces](/docs/distributed-tracing/concepts/how-new-relic-distributed-tracing-works/#trace-limits). + | +
| + agents d'infrastructure, intégration + | + ++ * Nombre brut de nouveaux conteneurs de monitoring : 5 000 par heure par compte + * Nombre brut de nouvelles entités de monitoring issues de l'intégration cloud (AWS, Azure, GCP) : 30 000 par heure et par compte + * flux de métriques AWS - Kinesis Data Firehose requests par minute : 50 + | +
| + monitoring des applications mobiles : nombre de crashs signalés + | + ++ 10 000 $ par heure + | +
| + Moniteur synthétique + | + ++ Voir [les limites des synthétiques](/docs/synthetics/synthetic-monitoring/using-monitors/monitor-limits). + | +
| + Limites de requête + | + ++ Voir [les limites des requêtes NRQL](/docs/query-your-data/nrql-new-relic-query-language/get-started/rate-limits-nrql-queries) + | +
| + Limites des requêtes d'alerte + | + ++ Voir [les règles et limites d'alerte](/docs/alerts-applied-intelligence/new-relic-alerts/learn-alerts/rules-limits-alerts#query-limit) + | +
| + Événement + | + ++ Description + | +
|---|---|
| + [`Transaction`](/attribute-dictionary/?event=Transaction) + | + ++ Une transaction est une unité de travail logique dans une application logicielle. L'événement `Transaction` inclut des informations sur l'application, les appels de base de données, la durée de la transaction et toutes les erreurs pouvant survenir. + | +
| + [`TransactionError`](/attribute-dictionary/?event=TransactionError) + | + ++ Les erreurs de transaction se produisent lorsqu'une demande génère une exception dans le chemin de code qui a été emprunté pour répondre à cette demande. Le nombre d'erreurs de transaction n'est pas égal au nombre de transactions, car vous pouvez spécifier si vous souhaitez [collecter, ignorer ou marquer les erreurs comme prévues](/docs/agents/manage-apm-agents/agent-data/manage-errors-apm-collect-ignore-or-mark-expected). + | +
| + [`Span`](/attribute-dictionary/?event=Span) + | + ++ Les événements Span sont créés lorsque des agents New Relic ou d'autres outils instrumentation de tracing, instrumentent des opérations qui font partie d'une trace distribuée. Voir la [définition de span](/docs/using-new-relic/welcome-new-relic/getting-started/glossary#span). + | +
| + Événement + | + ++ Description + | +
|---|---|
| + [`PageView`](/attribute-dictionary/?event=PageView) + | + ++ `PageView` suit les données géographiques et temporelles pour chaque chargement de page de navigateur. + | +
| + [`PageViewTiming`](/attribute-dictionary/?event=PageViewTiming) + | + ++ `PageViewTiming` envoie chaque point de données en tant qu'événement distinct dès qu'il est disponible. Ceci est utile pour les pages asynchrones et dynamiques. + + Pour utiliser cet événement, vous devez disposer de la version 1149 ou supérieure de l'agent de navigateur. Pour plus d'informations, consultez les [exemples de requête`PageViewTiming` ](/docs/browser/new-relic-browser/page-load-timing-resources/pageviewtiming-async-or-dynamic-page-details). + | +
| + [`PageAction`](/attribute-dictionary/?event=PageAction) + | + ++ `PageAction` L'événement suit les données sur chaque action effectuée sur une page. Son attribut fournit des données d'application et géographiques, ainsi que des données sur les dimensions du navigateur de l'utilisateur, les identifiants de session et les URL de référence et de page. + | +
| + [`BrowserInteraction` (SPA)](/attribute-dictionary/?event=BrowserInteraction) + | + ++ `BrowserInteraction` contient plusieurs attributs PageView ainsi que des attributs spécifiques aux applications monopage (SPA) + | +
| + [`AjaxRequest`](/attribute-dictionary/?attribute_name=&events_tids%5B%5D=8302&event=AjaxRequest) + | + ++ Un événement `AjaxRequest` est créé à chaque fois qu'un appel Ajax est effectué. Lorsqu'un appel Ajax se produit pendant un événement `BrowserInteraction`, il est agrémenté d'un attribut supplémentaire lié à l' interaction avec le navigateur. L'attribut événement suit les informations géographiques et celles du navigateur. + | +
| + [`BrowserTiming` (SPA)](/attribute-dictionary/?event=BrowserTiming) + | + ++ `BrowserTiming` est un événement personnalisé qui capture les données de synchronisation SPA pour l'interaction du navigateur démarrée à l'aide de la méthode API SPA [createTracer](/docs/browser/new-relic-browser/browser-agent-spa-api/createtracer-browser-spa-api) personnalisée. `BrowserTiming` contient de nombreux attributs identiques utilisés par d'autres événements, en particulier `AjaxRequest`. (obsolète) + | +
| + [`JavaScriptError`](/attribute-dictionary/?event=JavaScriptError) + | + ++ Lorsqu'une erreur JavaScript se produit, un événement `JavaScriptError` est créé. `JavaScriptError` capture les données d’erreur JavaScript ainsi que les données d’interaction du navigateur. Pour plus d'informations, consultez la [page des erreurs JS](/docs/browser/new-relic-browser/browser-pro-features/javascript-errors-page-examine-errors-over-time) dans l'UI du navigateur et l' [exemple de requête NRQL ](/docs/insights/nrql-new-relic-query-language/nrql-query-examples/insights-query-examples-new-relic-browser-single-page-app-data#javascriptError-example)pour le navigateur et l'événement SPA. + | +
| + [`Span`](/attribute-dictionary/?event=Span) + | + ++ `Span` les données sont signalées pour [le tracing distribué](/docs/browser/new-relic-browser/browser-pro-features/browser-data-distributed-tracing). + | +
| + Événement + | + ++ Description + | +
|---|---|
| + [`Mobile`](/attribute-dictionary/?event=Mobile) + | + ++ Un événement `Mobile` est créé lorsqu'un crash se produit, lorsqu'une interaction se termine ou s'est exécutée pendant 1 seconde, ou si une session se termine après la fermeture de l'application, sa mise en arrière-plan ou son exécution pendant 10 minutes. `Mobile` événement était autrefois le seul type d'événement et était généré pour chaque événement, mais il existe désormais plusieurs types d'événements spécialisés. + | +
| + [`MobileApplicationExit`](/attribute-dictionary/?event=mobileApplicationExit) + | + ++ Un événement `MobileApplicationExit` est généré lorsqu'une application se termine, soit en raison d'un crash, soit pour d'autres raisons telles qu'une mémoire insuffisante, des ANR, etc. Cet événement fournit des informations précieuses détaillées sur les circonstances entourant la résiliation de l'application et comprend des attributs tels que la raison, le code de sortie et la description de la résiliation d'une application. + + Actuellement, l'événement `MobileApplicationExit` est signalé uniquement pour les applications mobiles Android. Il exploite l'API `ApplicationExitInfo` d' Android pour monitorer et signaler les différentes raisons de la résiliation de votre application. + | +
| + `MobileBreadcrumb` + | + ++ Aucun attribut n'est répertorié pour cet événement ; l'attribut inclura l' [attribut de session](#session-list) et tout [attribut personnalisé ajouté](/docs/mobile-monitoring/new-relic-mobile/maintenance/add-custom-data-new-relic-mobile). + | +
| + [`MobileCrash`](/attribute-dictionary/?event=MobileCrash) + | + ++ L'événement `MobileCrash` est créé lorsqu'une application plante. `MobileCrash` inclut des attributs tels que le numéro de ligne de crash, la classe et le message de crash. + | +
| + [`MobileHandledException`](/attribute-dictionary/?event=MobileHandledException) + | + +
+ `MobileHandledException` est envoyé lorsqu'une exception est détectée et est utilisé pour les exceptions non fatales signalées à New Relic à l'aide de l' [appel d'API`recordHandledException` ](/docs/mobile-monitoring/new-relic-mobile/mobile-sdk/record-handled-exceptions/).
+
+ Les exceptions seront visibles dans la requête de cet événement et sur la [page d' UI |
+
| + [`MobileRequest`](/attribute-dictionary/?event=MobileRequest) + | + ++ Un événement `MobileRequest` est créé lorsqu'une requête HTTP se termine avec succès, générant un code de réponse inférieur à 400. + + Les données New Relic `MobileRequest` sont activées par défaut pour : + + * [Version Android 5.15.2](/docs/release-notes/mobile-release-notes/android-release-notes/android-5152) ou supérieure + + * [iOS version 6.0.0](/docs/release-notes/mobile-release-notes/ios-release-notes/ios-agent-600) ou supérieure + + Pour les versions antérieures, à partir de la version Android 5.14.0 ou iOS 5.14.0, vous devez activer la fonctionnalité. Effectuez une mise à niveau vers la dernière version [Android](/docs/mobile-monitoring/new-relic-mobile-android/install-configure/upgrade-android-agent) ou [iOS](/docs/mobile-monitoring/new-relic-mobile-ios/installation/upgrade-ios-agent), ou activez l'indicateur de fonctionnalité `NetworkRequests` à l'aide des paramètres de configuration [Android](/docs/mobile-monitoring/new-relic-mobile-android/install-configure/android-agent-configuration-feature-flags) ou [iOS](/docs/mobile-monitoring/new-relic-mobile-ios/install-configure/ios-agent-configuration-feature-flags#networkRequest) . + | +
| + [`MobileRequestError`](/attribute-dictionary/?event=MobileRequestError) + | + ++ Un `MobileRequestError` est utilisé pour les erreurs HTTP ou les échecs de réseau. Les erreurs HTTP sont requests HTTP dont le code d’état est supérieur à 400. Une panne de réseau est une requête HTTP qui n’entraîne aucune réponse. L'événement est envoyé lorsque la requête HTTP est terminée. + | +
| + [`MobileSession`](/attribute-dictionary/?event=MobileSession) + | + ++ Un événement `MobileSession` est envoyé lorsqu'une application est fermée, en arrière-plan ou lorsque 10 minutes d'utilisation active se sont écoulées. Il s'agit de la source des données de session générales utilisées par les autres applications monitoring des événements mobiles. `MobileSession` capture des attributs tels que le type d'appareil, le système d'exploitation de l'appareil et les informations géographiques. + | +
| + `MobileUserAction` + | + ++ Aucun attribut n'est répertorié pour cet événement ; l'attribut inclura l' [attribut de session](#session-list) et tout [attribut personnalisé ajouté](/docs/mobile-monitoring/new-relic-mobile/maintenance/add-custom-data-new-relic-mobile). + + Cet événement est enregistré lorsque l'on suppose qu'une action de l'utilisateur a provoqué le démarrage/le retour au premier plan ou l'arrêt/le retour à l'arrière-plan de l'agent lorsque la fonctionnalité de tracing distribué est activée. + | +
| + Événements personnalisés + | + ++ Il n'y a pas de liste d'attributs pour ce type d'événement car il s'agit d'un événement personnalisé ; l'attribut inclura l' [attribut de session](#session-list) et tout [attribut personnalisé](/docs/mobile-monitoring/new-relic-mobile/maintenance/add-custom-data-new-relic-mobile) que vous ajoutez. + | +
| + Événement + | + ++ Description + | +
|---|---|
| + [`SyntheticCheck`](/attribute-dictionary/?event=SyntheticCheck) + | + ++ `SyntheticCheck` renvoie les métriques d'une exécution d'un moniteur spécifique. Ces métriques incluent des informations sur la durée du moniteur, l'emplacement de la vérification du moniteur, la taille des en-têtes de demande et de réponse, le type de moniteur et un horodatage. + + Chaque fois qu'un moniteur Synthétique exécute une vérification, les détails de la vérification sont capturés dans le type d'événement`SyntheticCheck` . `SyntheticCheck` événement contient des détails spécifiques à la vérification pour fournir une visibilité telle que le statut, le type de moniteur et la taille des en-têtes de demande et de réponse. + | +
| + [`SyntheticRequest`](/attribute-dictionary/?event=SyntheticRequest) + | + ++ `SyntheticRequest` renvoie les résultats des requests HTTP individuelles effectuées lors d'une vérification. Les données collectées comprennent des informations sur le travail, l'emplacement, le type de contenu de la demande, les informations sur la durée, la taille de la demande et les informations sur le chargement de la page. + + À chaque vérification de monitoring simple ou scripté, nous capturons chaque requête HTTP individuelle effectuée pendant la vérification. Les détails HTTP sont capturés à un niveau plus granulaire que le type d'événement `SyntheticCheck` . + | +
| + [`SyntheticPrivateLocationStatus`](/attribute-dictionary/?event=SyntheticsPrivateLocationStatus) + | + ++ Chaque contrôle de monitoring exécuté sur un site privé déclenche des détails de capacité pour ce site privé. Ces détails sont capturés dans un événement `SyntheticPrivateLocationStatus` . Cela permet de visualiser la capacité d'un site privé et de savoir si des partenaires supplémentaires sont nécessaires pour prendre en charge la workload. + | +
| + [`SyntheticPrivateMinion`](/attribute-dictionary/?event=SyntheticsPrivateMinion) + | + ++ Si vous avez un emplacement privé, comme ceux à l'intérieur de votre pare-feu, vous pouvez consulter les informations concernant ces emplacements avec l'événement `SyntheticPrivateMinion` . + + Chaque subordonné privé en cours d'exécution envoie des détails de santé à `SyntheticPrivateMinion` toutes les 30 secondes. Cela vous permet de comprendre l'état de santé du réseau privé en fonctionnement à cet endroit. + | +
| + types métriques + | + ++ API prises en charge + | + ++ Description + | + ++ Fonctions de requête disponibles + | +
|---|---|---|---|
| + `count` + | + ++ ✅ [API métrique New Relic](/docs/data-apis/ingest-apis/metric-api/report-metrics-metric-api) + + ❌ [Nouvel événement Relic à Métriques](/docs/data-apis/convert-to-metrics/analyze-monitor-data-trends-metrics) + + ✅ [Écriture à distance Prometheus](/docs/infrastructure/prometheus-integrations/get-started/send-prometheus-metric-data-new-relic) + + ✅ [OpenTelemetry](/docs/more-integrations/open-source-telemetry-integrations/opentelemetry/best-practices/opentelemetry-best-practices-metrics) + | + ++ Mesure le nombre d'occurrences d'un événement. Le compte doit être réinitialisé à `0` chaque fois que la métrique est signalée. Les exemples incluent le taux d'accès au cache par intervalle de rapport et le nombre de threads créés par intervalle de rapport. + + Vous devez spécifier une valeur pour `interval.ms` lors de la déclaration du type métrique `count` à l'aide de l' [API métrique](/docs/telemetry-data-platform/get-data/apis/introduction-metric-api). + + La valeur doit être un double positif. + + En général, vous souhaitez prendre le `rate` du `sum`: + + ```sql + FROM Metric SELECT rate(sum(myMetric), 1 minute`) . . . + ``` + | + ++ * [`sum`](/docs/query-your-data/nrql-new-relic-query-language/get-started/nrql-syntax-clauses-functions#func-sum) + | +
| + `cumulativeCount` + | + ++ ❌ [API métrique New Relic](/docs/data-apis/ingest-apis/metric-api/report-metrics-metric-api) + + ❌ [Nouvel événement Relic à Métriques](/docs/data-apis/convert-to-metrics/analyze-monitor-data-trends-metrics) + + ✅ [Écriture à distance Prometheus](/docs/infrastructure/prometheus-integrations/get-started/send-prometheus-metric-data-new-relic) + + ✅ [OpenTelemetry](/docs/more-integrations/open-source-telemetry-integrations/opentelemetry/best-practices/opentelemetry-best-practices-metrics) + | + +
+ Equivalent au type `count` décrit ci-dessus, mais donne en plus accès aux champs métriques cumulatifs. Pour en savoir plus, voir [Métriques cumulatives](/docs/data-apis/understand-data/metric-data/cumulative-metrics).
+
+ |
+
+ + * [somme](/docs/query-your-data/nrql-new-relic-query-language/get-started/nrql-syntax-clauses-functions#func-sum) + | +
| + `distribution` + | + ++ ❌ [API métrique New Relic](/docs/data-apis/ingest-apis/metric-api/report-metrics-metric-api) + + ✅ [Nouvel événement Relic à Métriques](/docs/data-apis/convert-to-metrics/analyze-monitor-data-trends-metrics) (delta uniquement) + + ✅ [Écriture à distance Prometheus](/docs/infrastructure/prometheus-integrations/get-started/send-prometheus-metric-data-new-relic) + + ✅ [OpenTelemetry](/docs/more-integrations/open-source-telemetry-integrations/opentelemetry/best-practices/opentelemetry-best-practices-metrics) + | + ++ Suit la distribution statistique sur un attribut numérique. Cette métrique est ré-agrégable. Par exemple, des points de données d’une minute sur 60 minutes peuvent être agrégés en un point de données d’une heure, sans dégradation de la précision. + + Ce type : + + * Prend en charge les fonctions statistiques telles que percentile et l'histogramme, ainsi que toutes les fonctions prises en charge par le type de résumé. + * Utilise le même algorithme que la fonction percentile. + | + ++ * `percentile` + * `histogram` + * `min` + * `max` + * `sum` + * `count` + * `average` + | +
| + `gauge` + | + ++ ✅ [API métrique New Relic](/docs/data-apis/ingest-apis/metric-api/report-metrics-metric-api) + + ❌ [Nouvel événement Relic à Métriques](/docs/data-apis/convert-to-metrics/analyze-monitor-data-trends-metrics) + + ✅ [Écriture à distance Prometheus](/docs/infrastructure/prometheus-integrations/get-started/send-prometheus-metric-data-new-relic) + + ✅ [OpenTelemetry](/docs/more-integrations/open-source-telemetry-integrations/opentelemetry/best-practices/opentelemetry-best-practices-metrics) + | + ++ Représente une valeur qui peut augmenter ou diminuer avec le temps. Les exemples de jauges incluent la température, l'utilisation du processeur et la mémoire. + + Par exemple, il y a toujours une température, mais vous la prenez périodiquement et la signalez. + + La valeur doit correspondre à la plage d'un double Java. + | + ++ * `latest` + * `min` + * `max` + * `sum` + * `count` + * `average` + | +
| + `summary` + | + ++ ✅ [API métrique New Relic](/docs/data-apis/ingest-apis/metric-api/report-metrics-metric-api) + + ✅ [Nouvel événement Relic à Métriques](/docs/data-apis/convert-to-metrics/analyze-monitor-data-trends-metrics) + + ✅ [Écriture à distance Prometheus](/docs/infrastructure/prometheus-integrations/get-started/send-prometheus-metric-data-new-relic) + + ✅ [OpenTelemetry](/docs/more-integrations/open-source-telemetry-integrations/opentelemetry/best-practices/opentelemetry-best-practices-metrics) (legacy) + | + ++ Utilisé pour signaler des données pré-agrégées ou des informations sur des événements discrets agrégés. Un résumé comprend une valeur `count`, une valeur `sum`, une valeur `min` et une valeur `max` . La valeur `count` doit être positive. Les exemples incluent le nombre/la durée des transactions et le nombre/la durée des files d'attente. + + Vous devez spécifier une valeur pour `interval.ms` lors de la déclaration du type métrique `summary` à l'aide de l' [API métrique](/docs/telemetry-data-platform/get-data/apis/introduction-metric-api). + | + ++ * `min` + * `max` + * `sum` + * `count` + * `average` + | +
| + `uniqueCount` + | + ++ ❌ [API métrique New Relic](/docs/data-apis/ingest-apis/metric-api/report-metrics-metric-api) + + ✅ [Nouvel événement Relic à Métriques](/docs/data-apis/convert-to-metrics/analyze-monitor-data-trends-metrics) + + ❌ [Écriture à distance Prometheus](/docs/infrastructure/prometheus-integrations/get-started/send-prometheus-metric-data-new-relic) + + ❌ [OpenTelemetry](/docs/more-integrations/open-source-telemetry-integrations/opentelemetry/best-practices/opentelemetry-best-practices-metrics) (legacy) + | + ++ Suit le nombre de valeurs uniques sur une chaîne ou un attribut numérique. Cette métrique est ré-agrégable. Par exemple, des points de données d’une minute sur 60 minutes peuvent être agrégés en un point de données d’une heure, sans dégradation de la précision. + + Ce type est généré uniquement via le [service événement-to-métriques](/docs/accounts/accounts/data-management/introduction-events-metrics-service). + | + ++ * [`uniqueCount`](/docs/query-your-data/nrql-new-relic-query-language/get-started/nrql-syntax-clauses-functions#func-uniqueCount) + | +
| + Segment de requête + | + ++ Qu'est-ce que ça fait ? + | +
|---|---|
| + `FROM Metric` + | + ++ `Metric` est l'un de nos principaux [types de données](/docs/using-new-relic/data/understand-data/new-relic-data-types#dimensional-metrics) et les données d'intervalle de temps métrique sont stockées sous ce type de données. Pour obtenir des conseils généraux sur l'interrogation de données `Metric`, consultez [les exemples de requêtes métriques](/docs/data-ingest-apis/get-data-new-relic/metric-api/view-query-you-metric-data). + | +
| + `SELECT count(apm.service.error.count) / count(apm.service.transaction.duration)` + | + ++ Ce calcul génère un décompte d'erreurs à partir d'un décompte total de métriques de transaction. Cette requête utilise les [noms métriques convertis](#timeslice-conversion). + + Notez que vous pouvez utiliser d'autres [fonctions d'agrégateur](#aggregator-functions). + | +
| + `WHERE (entity.guid = 'AN_ENTITY_GUID')` + | + ++ Vous devez spécifier au moins une source de données. Vous pouvez sélectionner le GUID d'une seule entité, comme indiqué ici, ou vous pouvez [sélectionner plusieurs sources](#multiple-app-names). Cette requête utilise `entity.guid`, mais vous pouvez également utiliser `appId` ou `appName`. + | +
| + `AND (transactionType = 'Web')` + | + ++ Définit le type de transaction sur Web, ce qui signifie que l'arrière-plan/la transaction non Web ne sera pas comptabilisé. + | +
| + `SINCE 1 day ago` + | + ++ Sélection d'une plage horaire. + | +
| + `TIMESERIES` + | + ++ Cette clause facultative affiche les résultats dans un graphique temporel. + | +
| + intervalle de temps métrique structure + | + ++ Structure métrique dimensionnelle + | +
|---|---|
| + Les noms métriques APM sont représentés sous forme de chaînes uniques de segments séparés par des barres obliques. + + Par exemple, la métrique « `Datastore/statement/MySQL/users/select` » représente le temps passé dans une opération de sélection de base de données sur la table utilisateur. + | + ++ Une métrique unidimensionnelle nommée `apm.service.datastore.operation.duration` représente l'ensemble du groupe de métriques datastore . + + Cette métrique possède trois attributs représentant les valeurs de données codées dans le nom de la métrique, `datastoreType`, `table` et `operation`: + + `datastoreType = 'MySQL'` + + `table = 'users'` + + `operation = 'select'` + | +
| + Nom métrique + | + ++ Description + | + ++ attribut + | + ++ Unité métrique + | +
|---|---|---|---|
| + `apm.service.cpu.usertime.utilization` + | + ++ Temps passé dans le code en mode utilisateur + | + ++ `percentage` + | + ++ pourcentage + | +
| + `apm.service.datastore.operation.duration` + | + ++ temps de réponse pour les appels de base de données répartis par opérations de table + | + ++ `datastoreType`, `table`, `operation` + | + ++ secondes + | +
| + `apm.service.error.count` + | + ++ Résumé des mesures du nombre d'erreurs + | + ++ `transactionType` + | + ++ compter + | +
| + `apm.service.external.host.duration` + | + ++ temps de réponse pour les appels externes répartis par nom d'hôte externe + | + ++ `external.host` + | + ++ secondes + | +
| + `apm.service.instance.count` + | + ++ Nombre d'instances d'agent + | + ++ + | + compter + | +
| + `apm.service.memory.physical` + | + ++ Mémoire de processus en Mo + | + ++ + | + mégaoctets + | +
| + `apm.service.transaction.apdex` + | + ++ Scores Apdex par transaction + | + ++ `transactionName`, `transactionType` + | + ++ indice ap. + | +
| + `apm.service.transaction.duration` + | + ++ temps de réponse par transaction + | + ++ `keyTransactionName`, `transactionName`, `transactionType` + | + ++ secondes + | +
| + `apm.service.transaction.error.count` + | + ++ Nombre d'erreurs par transaction + | + ++ `keyTransactionName`, `transactionName`, `transactionType` + | + ++ compter + | +
| + `apm.service.transaction.external.duration` + | + ++ Temps de réponse d'appel externe par type de transaction + | + ++ `transactionType` + | + ++ secondes + | +
| + Nom + | + ++ Description + | +
|---|---|
| + `appName` + | + ++ Le nom de l'application. + | +
| + `appId` + | + ++ L'ID de l'application. + | +
| + `entity.guid` + | + ++ Le GUID de l'application. + | +
| + `host` + | + ++ L'hôte du processus de monitoring. + | +
| + `host.bootId` + | + ++ L'ID du démarrage de l'hôte, s'il est disponible. + | +
| + `host.displayName` + | + ++ Le `display_name` de l'hôte, s'il a été défini dans l'agent. + | +
| + `instanceName` + | + +
+ Pour les agents Java |
+
| + `metricName` + | + ++ Le nom de la métrique dimensionnelle. + | +
| + `metricTimesliceName` + | + ++ Le nom de la tranche de temps de la métrique legacy . + | +
| + `scope` + | + ++ (Facultatif) Le nom de la tranche de temps de la métrique legacy à laquelle cette métrique est « limitée ». Les métriques avec une portée lui appartiennent : leurs mesures s'appliquent au contexte de la métrique nommée dans l'attribut `scope` . Voir ci-dessous pour des exemples. + | +
| + Nom métrique + | + ++ Description + | + ++ attribut + | +
|---|---|---|
| + `apm.service.overview.web` + | + ++ Répartition du temps passé dans les différentes parties du service pour la transaction web + | + ++ `segmentName` + | +
| + `apm.service.overview.other` + | + ++ Répartition du temps passé dans les différentes parties du service pour les tâches d'arrière-plan/de transaction non Web + | + ++ `segmentName` + | +
| + `apm.service.transaction.overview` + | + ++ Répartition du temps passé sur une transaction spécifique + | + ++ `metricTimesliceName` + | +
| + `apm.key.transaction.overview` + | + ++ Répartition du temps passé sur une transaction clé spécifique + | + ++ `segmentName` + | +
| + expression régulière + | + ++ exemple de métrique + | + ++ nom de la légende + | +
|---|---|---|
| + `ActiveMerchant/.*` + | + ++ `ActiveMerchant/PayJunctionGateway` + | + ++ |
| + `ActiveMerchant/gateway/.*` + | + ++ `ActiveMerchant/gateway/PayJunctionGateway/purchase` + | + ++ `PayJunctionGateway` + | +
| + `ActiveMerchant/operation/.*` + | + ++ `ActiveMerchant/operation/purchase` + | + ++ `purchase` + | +
| + expression régulière + | + ++ exemple de métrique + | + ++ nom de la légende + | +
|---|---|---|
| + `ActiveRecord/.*/find` + | + ++ `ActiveRecord/User/find` + | + ++ `User#find` + | +
| + `ActiveRecord/.*/save` + | + ++ `ActiveRecord/Product/save` + | + ++ `Product#save` + | +
| + expression régulière + | + ++ exemple de métrique + | + ++ nom de la légende + | +
|---|---|---|
| + `Controller/.*` + | + ++ `Controller/Users/show` + | + ++ `/Users/show` + | +
| + `Controller/.*/(?!\(other\)).*` + | + ++ `Controller/Users/show` + | + ++ `/Users/show` + | +
| + `Controller$` + | + ++ `Controller` + | + ++ `All Controller Actions` + | +
| + `ControllerCPU/` + | + ++ `ControllerCPU/Users/Show` + | + ++ /utilisateur/show + | +
| + expression régulière + | + ++ exemple de métrique + | + ++ nom de la légende + | +
|---|---|---|
| + `Errors/all` + | + ++ `Errors/all` + | + ++ |
| + expression régulière + | + ++ exemple de métrique + | + ++ nom de la légende + | +
|---|---|---|
| + `External/[^/]+/all$` + | + ++ `External/service.example.com/all` + | + ++ Tous les appels à service.example.com + | +
| + `External/` + | + ++ `External/host.aws.com/Net::Http::POST` + | + ++ Net::Http::POST\[host.aws.com] + | +
| + `External/all$` + | + ++ `External/all` + | + ++ Services externes + | +
| + `External/[^/]+/(?!all)/` + | + ++ `External/service.example.com/all` + | + ++ Tous les appels à service.example.com + | +
| + expression régulière + | + ++ exemple de métrique + | + ++ nom de la légende + | +
|---|---|---|
| + `^HttpDispatcher$` + | + ++ `HttpDispatcher` + | + ++ Répartiteur Http + | +
| + expression régulière + | + ++ exemple de métrique + | + ++ nom de la légende + | +
|---|---|---|
| + `MemCache/.*` + | + ++ `MemCache/read` + | + ++ Opérations de lecture MemCache + | +
| + `MemCache/read` + | + ++ `MemCache/read` + | + ++ Opérations de lecture MemCache + | +
| + `MemCache/write` + | + ++ `MemCache/write` + | + ++ Opérations d'écriture MemCache + | +
| + expression régulière + | + ++ exemple de métrique + | + ++ nom de la légende + | +
|---|---|---|
| + `Mongrel/Queue Length` + | + ++ `Mongrel/Queue Length` + | + ++ Longueur de la file d'attente + | +
| + expression régulière + | + ++ exemple de métrique + | + ++ nom de la légende + | +
|---|---|---|
| + `View/.*` + | + ++ `View/Users/_child.html.erb/Partial` + | + ++ Users/\_child.html.erb + | +
| + `View/.*/Partial` + | + ++ `View/Users/_child.html.erb/Partial` + | + ++ Users/\_child.html.erb + | +
| + `View/.*/Rendering` + | + ++ `View/Users/show.html.erb/Rendering` + | + ++ Users/show\.html.erb + | +
+
+* Si vous utilisez 
+
+ 
+
+ 
+
+ L'observateur de trace maintient la trace ouverte pendant que les intervalles pour cette trace arrivent. Une fois que la première plage d’une trace arrive, une session est maintenue ouverte pendant 10 secondes. Chaque fois qu'une nouvelle plage pour cette trace arrive, le délai d'expiration est réinitialisé à 10 secondes. les traces qui n'ont pas vu de span arriver au cours des 10 dernières secondes expireront automatiquement.
+ | + Échantillonneur + | + ++ Critères de correspondance + | + ++ Pourcentage cible + | +
|---|---|---|
| + Durée + | + ++ tracer avec une durée valeur hors norme, à l'aide de deux algorithmes : + + * Gaussien (suppose une distribution normale et un seuil au 99e percentile) + * Excentricité (suppose l'absence de distribution et un seuil basé sur le cluster) + | + ++ 100% + | +
| + Erreur + | + ++ trace ayant au moins une étendue avec une erreur + | + ++ 100% + | +
| + Aléatoire + | + ++ Toutes les traces + | + ++ 1% (Ceci est configurable. Voir [Infinite Tracing : filtre de trace aléatoire](/docs/understand-dependencies/distributed-tracing/other-requirements/infinite-tracing-random-trace-filter)) + | +
+
+| + Article + | + ++ Description + | +
|---|---|
| + `accountId` + | + ++ Il s'agit de votre identifiant de compte New Relic. Cependant, seuls les membres de votre compte et les administrateurs de New Relic peuvent associer cet identifiant aux informations de votre compte de quelque manière que ce soit. + | +
| + `appId` + | + ++ Il s'agit de l'identifiant d'application de l'application générant l'en-tête de la trace. Tout comme `accountId`, cet identifiant ne fournira aucune information à moins que vous ne soyez un utilisateur du compte. + | +
| + `guid` + | + ++ Avec le tracing distribué, chaque segment de travail dans une trace est représenté par un `span` et chaque étendue a un attribut [`guid`](/attribute-dictionary/?event=Span&attribute=guid) . Le `guid` de la dernière étendue du processus est envoyé avec la requête sortante afin que le premier segment de travail dans le service de réception puisse ajouter ce `guid` comme attribut [`parentId`](/attribute-dictionary/?event=Span&attribute=parentId) qui connecte les données dans la trace. + | +
| + Type de parent + | + ++ La source de l'en-tête de la trace, comme dans mobile, navigateur, application Ruby, etc. Cela devient l’attribut [`parent.type`](/attribute-dictionary/?event=Transaction&attribute=parent.type) sur la transaction déclenchée par la demande à laquelle cet en-tête est attaché. + | +
| + Priorité + | + ++ Une valeur de classement de priorité générée aléatoirement qui permet de déterminer quelles données sont échantillonnées lorsque les limites d'échantillonnage sont atteintes. Il s'agit d'une valeur flottante définie par le premier agent New Relic qui fait partie de la demande, de sorte que toutes les données de la trace auront la même valeur de priorité. + | +
| + Échantillonné + | + ++ Une valeur booléenne qui indique à l'agent si des données de trace doivent être collectées pour la demande. Ceci est également ajouté en tant [qu'attribut à toutes les données de transaction et de portée collectées](/attribute-dictionary/?event=Span&attribute=sampled). + | +
| + horodatage + | + ++ Horodatage Unix en millisecondes lorsque la charge a été créée. + | +
| + `traceId` + | + ++ L' [ID unique](/attribute-dictionary/?event=Span&attribute=traceId) (une chaîne générée aléatoirement) utilisé pour identifier une demande unique lorsqu'elle franchit les limites inter et intra processus. Cet identifiant permet de lier des spans dans une tracedistribuée. Ceci est également ajouté en tant qu'attribut aux données de portée et de transaction. + | +
| + `transactionId` + | + ++ L' [identifiant unique](/attribute-dictionary/?event=Span&attribute=transactionId) de l'événement de transaction. + | +
| + Clé de compte de confiance + | + ++ Il s’agit d’une clé qui permet d’identifier tous les autres comptes associés à votre compte. Ainsi, si vous avez plusieurs sous-comptes que la trace traverse, nous pouvons confirmer que toutes les données incluses dans la trace proviennent d'une source fiable et nous indiquer quel utilisateur doit avoir accès aux données. + | +
| + Version et clé de données + | + ++ Cela identifie les versions majeures/mineures, donc si un agent reçoit un en-tête de trace d'une version avec des modifications radicales par rapport à celle sur laquelle il se trouve, il peut rejeter cet en-tête et signaler le rejet et la raison. + | +
+
+
+ 
+ 
+ 
+
+
+
+1. 
+
+2. 
+
+4. Sous 
+
+5. Dans la liste déroulante 
+
+### Afficher les métriques dans les paramètres Infinite Tracing [#view-in-edge]
+
+Lorsque vous activez le monitoring de l'observateur de trace, trace les métriques de l'observateur s'affichent dans les paramètres d'Infinite Tracing :
+
+* Deux colonnes sont ajoutées à la liste principale des observateurs de trace :
+
+ * 
+
+### Afficher dans le générateur de requêtes
+
+Si vous préférez une manière programmatique de visualiser les métriques, voici quelques exemples de requêtes NRQL . Ces exemples reproduisent les deux graphiques des paramètres Infinite Tracing :
+
+| + Valeur + | + ++ Description + | +
|---|---|
| + `YOUR_LICENSE_KEY` + | + +
+ Remplacez ceci par votre ingestion |
+
| + `YOUR_TRACE_OBSERVER_URL` + | + +
+ Remplacez ceci par la valeur de point de terminaison |
+
| + Valeur + | + ++ Description + | +
|---|---|
| + `YOUR_LICENSE_KEY` + | + +
+ Remplacez ceci par votre |
+
| + `YOUR_TRACE_OBSERVER_URL` + | + +
+ Remplacez ceci par la valeur de point de terminaison |
+
+
+3. Sélectionnez les sources de données que vous souhaitez inclure, en gardant à l’esprit les points suivants :
+
+ * Vous pouvez utiliser le filtre pour affiner vos options.
+ * Si votre application de navigateur est connectée à un agent | + champ + | + ++ type + | + ++ description + | + ++ requis + | + ++ défaut + | +
|---|---|---|---|---|
| + `id` + | + ++ *chaîne* + | + ++ Identifiant unique pour cette période. + | + ++ Oui + | + ++ N/A + | +
| + `trace.id` + | + ++ *chaîne* + | + ++ Identifiant unique partagé par tous les spans au sein d'une même trace. + | + ++ Oui + | + ++ N/A + | +
| + `timestamp` + | + ++ *long* + | + ++ Heure de début de l'intervalle en [millisecondes depuis l'époque Unix](https://currentmillis.com/). + | + ++ Non + | + ++ Heure actuelle dans le fuseau horaire UTC + | +
| + `attributes` + | + ++ *objet* + | + ++ Tout ensemble de paires valeur-clé qui ajoutent plus de détails sur une plage. `duration.ms` est obligatoire, et il est fortement recommandé d'ajouter les attributs `name` et `parent.id` . + | + ++ Oui + | + ++ N/A + | +
| + champ + | + ++ type + | + ++ description + | + ++ requis + | + ++ défaut + | +
|---|---|---|---|---|
| + `attributes` + | + ++ *objet* + | + ++ Tout ensemble de paires valeur-clé qui ajoutent des détails communs sur les portées de la charge. Si une étendue contient un attribut qui a été défini dans `common`, la clé de l'objet d'attribut étendue aura la priorité. Il est fortement recommandé d'ajouter `duration.ms`, `name` et `parent.id` . + | + ++ Non + | + ++ N/A + | +
| + attribut + | + ++ défaut + | + ++ description + | +
|---|---|---|
| + `duration.ms` + + *virgule flottante* + | + ++ aucun + | + ++ Durée de cette période en millisecondes. + | +
| + `name` + + *chaîne* + | + ++ aucun + | + ++ Le nom de cette travée. + | +
| + `parent.id` + + *chaîne* + | + ++ aucun + | + ++ L'identifiant de l'appelant de ce span. La valeur est `null` s'il s'agit de la [racine span](/docs/apm/distributed-tracing/ui-data/understand-use-distributed-tracing-data#trace-grouping). la trace sans étendue racine ne sera pas affichée. + | +
| + `service.name` + + *chaîne* + | + ++ aucun + | + ++ Le nom de l'entité qui a créé cette plage. Si aucune valeur ou une chaîne vide n'est fournie, l'étendue est attribuée à une entité « INCONNUE » et s'affichera comme telle dans l'UI. Cette valeur doit être fournie pour obtenir une expérience complète dans l'UI. + | +
| + attribut + | + ++ défaut + | + ++ description + | +
|---|---|---|
| + `entity.name` + + *chaîne* + | + ++ `service.name` + | + ++ Ceci est dérivé de l'attribut `service.name` . + | +
| + `entity.type` + + *chaîne* + | + ++ `service` + | + ++ Le type d’entité est supposé être un service. + | +
| + `entity.guid` + + *chaîne* + | + ++ Aucun + | + ++ `entity.guid` est une valeur dérivée qui identifie de manière unique l'entité dans le backend de New Relic. + | +
+
+Pour en savoir plus :
+
+* [Découvrez où les données de l'API de trace s'affichent dans l'UI](/docs/understand-dependencies/distributed-tracing/ui-data/additional-distributed-tracing-features-new-relic-one#find-data).
+* [Envoyer des données à partir d'une instrumentation Zipkin existante](#existing-zipkin).
+* [Apprenez à décorer les travées](/docs/apm/distributed-tracing/trace-api/trace-api-decorate-spans-attributes) en ajoutant une balise. Cela vous aide à personnaliser la manière dont les traces sont affichées dans notre UI pour une expérience plus riche et plus utile.
+* Découvrez [les informations générales sur le point de terminaison (limites des données, métadonnées requises et validation des réponses](/docs/apm/distributed-tracing/trace-api/trace-api-endpoint-requirements-limits)).
+* Découvrez comment [les données Zipkin sont transformées et stockées dans notre format](#zipkin-transform).
+* Si vous ne voyez pas vos données trace, consultez [dépannage](/docs/apm/distributed-tracing/trace-api/troubleshooting-missing-trace-api-data).
+
+## Envoyer des données à partir de l'instrumentation Zipkin existante [#existing-zipkin]
+
+Notes préliminaires :
+
+* Si vous souhaitez activer [l'Infinite Tracing](/docs/understand-dependencies/distributed-tracing/infinite-tracing/introduction-infinite-tracing), vous devez d'abord [configurer un observateur de trace](/docs/understand-dependencies/distributed-tracing/infinite-tracing/set-trace-observer#set-up).
+* Il peut être utile d’ [envoyer d’abord un exemple de charge utile](#quick-start) pour vérifier que tout fonctionne correctement.
+
+Pour signaler des données à partir d'une Zipkin instrumentation existante, vous pointerez le Zipkin traceur vers les [points de terminaison d'API](/docs/understand-dependencies/distributed-tracing/trace-api/trace-api-general-requirements-limits#requirements) appropriés avec certaines métadonnées de requête requises. Vous pouvez envoyer les métadonnées requises sous forme d'en-têtes ou de paramètres de requête (certaines versions du traceur Zipkin ne permettent pas de spécifier des en-têtes HTTP).
+
+Voici un exemple de ce à quoi pourrait ressembler la création d'un Zipkin `OkHttpSender` en Java configuré pour l'API de trace :
+
+```java
+OkHttpSender.create("https://trace-api.newrelic.com/trace/v1?Api-Key=NEW_RELIC_LICENSE_KEY&Data-Format=zipkin&Data-Format-Version=2");
+```
+
+Notez que si vous utilisiez Infinite Tracing ou si vous disposiez d'un compte New Relic dans la région UE, le [point de terminaison](/docs/understand-dependencies/distributed-tracing/trace-api/trace-api-general-requirements-limits#requirements) serait différent.
+
+Pour une explication de `Api-Key` et des autres métadonnées, voir [Demande de métadonnées](/docs/apm/distributed-tracing/trace-api/trace-api-endpoint-requirements-limits#headers-query-parameters).
+
+## Transformation des données Zipkin [#zipkin-transform]
+
+Pour créer une expérience de recherche/requête cohérente, certaines données Zipkin seront transformées pour correspondre à la dénomination [des attributs](/docs/using-new-relic/welcome-new-relic/get-started/glossary#attribute) New Relic. Pour en savoir plus sur la manière dont nous stockons et structurons les données trace, consultez [Fonctionnement du tracing distribué](/docs/understand-dependencies/distributed-tracing/get-started/how-new-relic-distributed-tracing-works).
+
+| + Zipkin tag + | + ++ Stocké dans New Relic sous le nom... + | + ++ Détails + | +
|---|---|---|
| + `traceId` + | + ++ `trace.id` + | + ++ Identifiant unique pour une trace. + | +
| + `id` + | + ++ `id` + | + ++ Identifiant unique pour une durée. + | +
| + `parentId` + | + ++ `parent.id` + | + ++ identifiant du span en amont qui a appelé le service. + | +
| + `kind` + | + ++ `kind` + | + ++ Soit `Client` ou `Server`. + | +
| + `name` + | + ++ `name` + | + ++ Nom de l'envergure. + | +
| + `duration` + | + ++ `duration.ms` + | + ++ Les étendues Zipkin v2 doivent avoir des durées spécifiées en microsecondes et seront converties en millisecondes. + | +
| + localEndpoint : `serviceName` + | + ++ `service.name` + | + ++ Nous utilisons le nom de service Zipkin v2 pour identifier l’entité qui a créé cette plage. Si aucune valeur ou une chaîne vide n'est fournie, l'étendue est attribuée à une entité « INCONNUE » et s'affichera comme telle dans l'UI. Cette valeur doit être fournie pour obtenir une expérience complète dans l'UI. + | +
| + localEndpoint : `port` + | + ++ `localEndpoint.port` + | + ++ Toutes les valeurs de l'objet `localEndpoint` seront aplaties dans un attribut span appelé `localEndpoint.key` + | +
| + `tags` + | + ++ signalé comme [attribut](/docs/using-new-relic/welcome-new-relic/get-started/glossary#attribute) + | + ++ les paires valeur clé dans l'objet `tags` dans Zipkin v2 seront écrites comme attribut span. + | +
| + annotations + | + ++ non pris en charge + | + ++ Nous ne prenons actuellement pas en charge les annotations dans l'API de trace. Les étendues ne seront pas rejetées si elles contiennent des annotations, mais les données d'annotations ne seront pas écrites. + | +
| + Propriété de portée souhaitée + | + ++ Indicateur UI + | + ++ Comment ajouter une propriété + | +
|---|---|---|
| + Erreurs + | + +
+ 
+ |
+
+ + Utilisez un attribut avec un préfixe `error.` . Par exemple : `error.message`. + | +
| + Externe + | + +
+ 
+ |
+
+ + Utilisez un attribut avec un préfixe `http.` . Par exemple : `http.method`. Un span apparaîtra également comme externe s'il a un enfant provenant d'une entité différente. Pour être indexé sur la [page Services externes](/docs/apm/apm-ui-pages/monitoring/external-services/external-services-intro), `http.url` ou `net.peer.name` doit être fourni. + | +
| + magasin de données + | + +
+ 
+ |
+
+ + Utilisez un attribut avec un préfixe `db.` . Par exemple : `db.statement`. + | +
| + Service + | + +
+ 
+ |
+
+ + Cela ne peut pas être fait avec un attribut. Une étendue est classée comme une étendue de service si elle est l'étendue racine ou si son parent provient d'une entité différente. Si une étendue possède plusieurs propriétés, la classification de l'étendue de service est prioritaire dans l'UI. + | +
| + En cours de réalisation + | + +
+ 
+ |
+
+ + Cela ne peut pas être fait avec un attribut. Une étendue est classée comme en cours de traitement si elle n'a pas été classée comme étendue de service, étendue datastore ou étendue externe. + | +
| + Attribut restreint + | + ++ Description + | +
|---|---|
| + `entityGuid` + + *chaîne* + | + ++ Identifiant unique de l'entité qui a créé cette travée. Généré à partir de `service.name`, si disponible. + | +
| + `guid` + + *chaîne* + | + +
+ Utilisé pour la compatibilité descendante avec les données des agents |
+
| + Attribut restreint + | + ++ description + | +
|---|---|
| + `entity.guid` + + *chaîne* + | + ++ Identifiant unique de l'entité associée à cette travée. + | +
| + `entity.name` + + *chaîne* + | + ++ Nom lisible par l'homme d'une entité, souvent utilisé pour identifier une entité dans l'UI. + | +
| + `entity.type` + + *chaîne* + | + ++ Utilisé pour différencier les différents types d'entités, comme les hôtes, les applications, etc. + | +
| + En-tête + | + ++ Paramètre de requête ? + | + ++ Détails + | +
|---|---|---|
| + `Content-Type` + | + ++ Non + | + +
+ |
+
| + `Content-Length` + | + ++ Non + | + +
+ |
+
| + `Api-Key` + | + ++ Oui (sensible à la casse) + | + +
+ |
+
| + `Content-Encoding` + | + ++ Non + | + +
+ |
+
| + `Data-Format` + | + ++ Oui + | + +
+ |
+
| + `Data-Format-Version` + | + ++ Oui + | + +
+ |
+
| + `x-request-id` + | + ++ Non + | + +
+ |
+
| + Code + | + ++ Signification + | +
|---|---|
| + 202 + | + ++ Données acceptées. Cela signifie que vous avez passé les vérifications préliminaires, mais cela ne garantit pas que les données ont été analysées et indexées avec succès dans le cadre d'une tracedistribuée. + | +
| + 400 + | + ++ La structure de la demande n'était pas valide. Erreurs avec les paramètres de requête, etc. + | +
| + 403 + | + +
+ Erreur d'authentification. Peut se produire avec un |
+
| + 404 + | + ++ Le chemin de la demande est incorrect. + | +
| + 405 + | + ++ Pour toute méthode de requête autre que POST. + | +
| + 408 + | + ++ La demande a mis trop de temps à atteindre le point de terminaison. + | +
| + 411 + | + ++ L'en-tête Content-Length n'était pas inclus. + | +
| + 413 + | + ++ La charge utile était trop lourde. + | +
| + 414 + | + ++ L'URI de la demande était trop longue. + | +
| + 415 + | + ++ Le type de contenu ou le codage de contenu n'était pas valide. + | +
| + 429 + | + ++ Le quota du taux de requêtes a été dépassé. + | +
| + 431 + | + ++ Les en-têtes de requête sont trop longs. + | +
| + 5xx + | + ++ Une erreur de serveur s'est produite (veuillez réessayer). + | +
| + Méthode de configuration .NET + | + ++ Exemple + | +
|---|---|
| + Fichier de configuration + | + +
+ ```xml
+ |
+
| + Variable d'environnement + | + ++ ```ini + NEW_RELIC_INFINITE_TRACING_SPAN_EVENTS_QUEUE_SIZE=100000 + ``` + | +
| + Méthode de configuration Python + | + ++ Exemple + | +
|---|---|
| + Fichier de configuration + | + ++ ```ini + infinite_tracing.span_queue_size = 100000 + ``` + | +
| + Variable d'environnement + | + ++ ```ini + NEW_RELIC_INFINITE_TRACING_SPAN_QUEUE_SIZE = 100000 + ``` + | +
+
+ Le diagramme suivant montre également une propagation d'en-tête réussie, mais il inclut un exportateur dans le service 2 qui envoie les détails de l'étendue à New Relic (voir [API Trace](/docs/understand-dependencies/distributed-tracing/trace-api/introduction-trace-api)) :
+
+ 
+ 
+
+ Une solution consiste à mettre à niveau votre agent New Relic vers une version prenant en charge le contexte de trace W3C. Dans le diagramme ci-dessous, l'agent New Relic conforme au W3C transmet l'en-tête précédent ainsi que deux en-têtes standardisés :
+
+ 
+ 
+
+Chaque élément de la liste affiche :
+
+* Direction du chemin d'appel : `Upstream` ou `Downstream` suivi du nombre moyen de sauts dans les chemins d'appel entre cette entité et votre service.
+
+ * `Upstream`:entité envoyant des appels à votre service, directement ou indirectement.
+ * `Downstream`:entité à laquelle votre service fait appel, directement ou indirectement.
+
+* La performance du signal avec un changement significatif d'impact sur votre service, dans l'ensemble et au fil du temps.
+
+* Le nom de l'entité.
+
+* La performance de l'entité :
+
+ * 
+
+## Vue pleine page [#full-page-view]
+
+La vue pleine page affiche la même liste de signaux significatifs mais avec plus d'espace pour faire défiler des listes plus longues. Il comprend également une option de filtre pour se concentrer sur les signaux d'un type particulier.
+
+
+
+## Vue dégagée [#all-clear-view]
+
+La vue claire signifie qu'aucun service en amont ou en aval n'a subi de changements significatifs dans son impact sur les performances.
+
+
+
+## Comprendre les messages de données de tracing manquantes [#no-trace-data]
+
+Pour vous assurer de travailler avec les informations de tracing détaillées les plus pertinentes, voici une ventilation des messages que vous pourriez rencontrer lorsque les données ne sont pas disponibles, ainsi que les actions recommandées :
+
+* `No data for this time range`:
+
+ * Ce message indique que vous avez sélectionné une fenêtre temporelle pour votre service qui se situe en dehors de la période de conservation actuelle des données de trace.
+ * Pour accéder aux informations détaillées, ajustez la plage horaire pour vous concentrer sur une période au cours de la dernière semaine.
+
+* `No data from your entity`:
+
+ * Ce message suggère que votre service ne signale actuellement pas le suivi des données distribuées.
+ * Pour débloquer ces précieuses informations détaillées, mettez en place le tracing distribué pour votre service en suivant la [procédure d'installation guidée](https://onenr.io/0OQM6lV3DwG). Si vous débutez avec le tracing distribué, commencez par lire le [guide de planification du tracing distribué](/docs/distributed-tracing/concepts/distributed-tracing-planning-guide/).
+
+* `No data from related entities`;
+
+ * Ce message indique que votre service signale des données mais que ses dépendances ne le font pas.
+ * En [activant le tracing distribué pour vos services](https://onenr.io/0OQM6lV3DwG), votre dépendance devrait également être automatiquement activée.
\ No newline at end of file
diff --git a/src/i18n/content/fr/docs/distributed-tracing/ui-data/trace-details.mdx b/src/i18n/content/fr/docs/distributed-tracing/ui-data/trace-details.mdx
new file mode 100644
index 00000000000..308cc8a2a63
--- /dev/null
+++ b/src/i18n/content/fr/docs/distributed-tracing/ui-data/trace-details.mdx
@@ -0,0 +1,313 @@
+---
+title: Comprendre la trace UI page des détails
+tags:
+ - Distributed tracing
+ - UI and data
+ - Trace details
+metaDescription: 'Dive deeper into New Relic''s distributed tracing feature: learn how to use and understand the trace details UI.'
+freshnessValidatedDate: '2023-07-19T00:00:00.000Z'
+translationType: machine
+---
+
+Une fois que vous avez sélectionné une trace dans la liste trace, vous serez dirigé vers la page des détails trace dans l'UI. Utilisez les détails trace pour comprendre le flux d'opérations qui composent une tracedistribuée et ajustez la vue pour trouver les informations les plus importantes pour vous.
+
+
+
+
+ 
+
+ * | + Propriété de portée + | + ++ Indicateur + | + ++ Description + | +
|---|---|---|
| + Service + | + +
+ 
+ |
+
+ + Cette icône représente une étendue qui est le point d'entrée d'un service. + | +
| + En cours de réalisation + | + +
+ 
+ |
+
+ + Cette icône représente une [étendue en cours de processus](#in-process), qui est une étendue qui se déroule au sein d'un processus (par opposition à une étendue inter-processus). Exemples : instrumentation middleware, étendues créées par l’utilisateur. + | +
| + magasin de données + | + +
+ 
+ |
+
+ + Cette icône représente un appel d'étendue vers une datastore. + | +
| + Externe + | + +
+ 
+ |
+
+ + Cette icône représente une catégorie représentant un appel à un service externe effectué via HTTP. + | +
| + Application de navigateur + | + +
+ 
+ |
+
+ + Cette icône représente une [application de navigateur étendue](/docs/browser/new-relic-browser/browser-pro-features/browser-data-distributed-tracing). + | +
| + Lambda + | + +
+ 
+ |
+
+ + Cette icône représente une étendue d'une [fonction Lambda](/docs/serverless-function-monitoring/aws-lambda-monitoring/get-started/introduction-new-relic-monitoring-aws-lambda). + | +
| + Propriété de portée + | + ++ Indicateur + | + ++ Description + | +
|---|---|---|
| + Type de connexion + | + +
+ 
+ |
+
+ + Les lignes pleines indiquent une relation parent-enfant directe ; en d’autres termes, un processus ou une fonction appelant directement un autre. Une ligne pointillée indique une relation non directe. Pour en savoir plus sur les relations entre les étendues, voir [Structure de trace](/docs/understand-dependencies/distributed-tracing/get-started/how-new-relic-distributed-tracing-works#trace-structure). + | +
| + Erreurs + | + +
+ 
+ |
+
+ + Un span avec une erreur. Voir [Comment comprendre les erreurs d'étendue](#error-tips). + | +
| + Anormal + | + +
+ 
+ |
+
+ + Cette icône représente la détection d'une [portée anormale](#anomalous-spans). + | +
| + Travées orphelines + | + +
+ 
+ |
+
+ + Certaines étendues peuvent être « orphelines » ou séparées de la trace. Ces étendues apparaîtront au bas de la trace. Pour plus de détails, voir [Trace fragmentée](#fragmented-traces). + | +
| + Plusieurs noms d'applications + | + +
+ 
+ |
+
+ + Lorsqu'il est à côté d'un nom d'étendue, cela représente une entité pour laquelle [plusieurs noms d'application ont été définis](/docs/agents/manage-apm-agents/app-naming/use-multiple-names-app). Sélectionnez cette option pour voir tous les noms d'applications auxquelles elle fait référence. Pour rechercher des données de trace par noms d’application alternatifs, utilisez l’attribut `appName` . + | +
| + Décalage horaire client/serveur + | + +
+ 
+ |
+
+ + Si l'indicateur de durée d'une période n'est pas complètement coloré (comme dans cet exemple), cela signifie qu'il existe un décalage horaire entre la durée côté serveur et la durée côté client pour cette activité. Pour plus de détails à ce sujet, voir [Différence de temps client/serveur](#client-server-time). + | +
+
+ 
+
+ 
+
+ * 
+
+ 
+
+ Contrôler ce qui est affiché dans le nuage de points :
+
+ 1. Sélectionnez le type de durée dans la liste déroulante | + Type d'erreur + | + ++ Description + | +
|---|---|
| + Travées se terminant par des erreurs + | + ++ Une erreur qui quitte la limite d'une étendue entraîne une erreur sur cette étendue et sur toutes les étendues ancêtres qui sortent également avec une erreur, jusqu'à ce que l'erreur soit détectée ou quitte la transaction. Vous pouvez voir si une erreur est détectée dans une étendue d'ancêtre. + | +
| + Remarquez les erreurs + | + ++ Les erreurs constatées par les appels à l'API de l'agent `noticeError` ou par l' instrumentation automatique de l'agent sont attachées à la plage en cours d'exécution. + | +
| + Erreurs de code de réponse + | + ++ Les erreurs de code de réponse sont attachées à l'étendue associée, telles que : + + * client span : transactions externes préfixées par `http` ou `db`. + + * Portée de la saisie : Dans le cas d'une transaction se terminant par une erreur de code de réponse. + + Le code de réponse pour ces plages est capturé en tant qu’attribut `http.statusCode` et attaché à cette plage. + | +
| + Erreurs OpenTelemetry + | + +
+ La zone |
+
+
+ A. Lorsqu'un client SPAN est plus long que le serveur SPAN, cela peut être dû à une latence dans un certain nombre de domaines, tels que : le temps réseau, le temps de file d'attente, le temps de résolution DNS ou un équilibreur de charge que nous ne pouvons pas voir. B. Lorsqu'un client SPAN démarre et se termine avant le début d'un SPAN de serveur, cela peut être dû à un décalage d'horloge ou au fait que le serveur effectue un travail asynchrone qui continue après l'envoi de la réponse. C. Lorsqu'un client SPAN démarre après un SPAN de serveur, il s'agit probablement d'un décalage d'horloge.
+ 
+
+ Types de propriétés span orphelines indiquées dans l'UI:
+
+ * 
+ 
+
+## Affichage de la liste des erreurs [#list-view]
+
+Commencez par les graphiques de taux d’erreur pour voir en un coup d’œil s’il y a des pics, des creux ou des modèles inattendus avec des erreurs en général.
+
+Mettez en corrélation les modèles généraux du graphique des 5 principales erreurs avec les alertes survenues au cours de la même période.
+
+* 
+
+Les profils d'erreur peuvent vous aider à répondre à des questions telles que : quels utilisateurs étaient les plus courants dans tous les événements d'erreur au cours de la fenêtre temporelle sélectionnée ? Ou quelle session était la plus courante dans tous les événements d’erreur au cours de la fenêtre temporelle sélectionnée ?
+
+Cliquez sur **les profils d'attributs** pour accéder aux profils individuels.
+
+
+
+## Affichage des détails des erreurs [#details-view]
+
+Sur cette page, vous pouvez approfondir un groupe d'erreurs spécifique : vous avez peut-être identifié un groupe spécifique d'hôtes qui provoque un pic d'erreurs. La vue détaillée fournit des détails contextuels.
+
+À partir de la vue détaillée, vous pouvez parcourir des erreurs spécifiques à l'aide du bouton bascule en haut à droite pour naviguer entre la première instance de l'erreur, la dernière ou n'importe quelle instance intermédiaire.
+
+En haut de la page de détails, vous pouvez inspecter les champs 
+
+#### Tracing distribué [#occurrences-dt]
+
+Si vous avez configuré [le tracing distribué](/docs/distributed-tracing/concepts/quick-start/) et s'il existe des échantillons de traces liées à des erreurs, vous verrez des options permettant d'afficher les détails trace . Il s'agit d'un moyen rapide d'afficher les informations trace sans accéder à la page principale de tracing distribué :
+
+* Dans le volet de gauche intitulé 
+
+* Dans le volet de droite intitulé 
+
+ * Cliquez sur 
+
+## Suppression de la trace d'erreur [#delete-stacktrace]
+
+Si vous devez supprimer des informations sensibles suite à une erreur, nous vous encourageons à [soumettre une demande de suppression de données personnelles](/docs/security/security-privacy/data-privacy/new-relic-personal-data-requests/#submit-requests).
+
+## Données d'erreur [#error-data]
+
+Types de données d'erreur : détails de l'événement et trace
+
+Par défaut, nos agents APM collectent deux types de données d'erreur : les détails de l'événement et de la trace.
+
+## Événements [#events]
+
+Le type de données error événement inclut l’attribut par défaut, ainsi que tout attribut personnalisé instrumenté dans votre service. Il ne contient aucune trace d'appels.
+
+Les événements sont sujets à échantillonnage (voir [Plafonds sur les rapports d'erreur](#caps-error-reporting) et [Graphiques des taux d'erreur et des comptages](#charting-error-rates)). Pour en savoir plus sur les données d'événement d'erreur, voir [événement signalé par APM](/docs/insights/insights-data-sources/default-data/apm-default-events-insights).
+
+## Détails de la trace [#trace-details]
+
+Le type de données d'erreur des détails trace inclut la trace des appels et l'attribut, et complète l'événement avec plus de données. Il est prévu que davantage d'événements seront signalés que de détails trace - voir [Limites sur les rapports d'erreurs](#caps-error-reporting).
+
+
+
+Pour examiner les erreurs JavaScript :
+
+1. Allez à 
+
+## Profils d'erreur [#JS-profiles]
+
+Les profils d’erreur révèlent les utilisateurs fréquemment impactés pendant une période donnée. Vous pouvez télécharger les attributs utilisateur au format CSV ou explorer les répartitions détaillées en sélectionnant des lignes individuelles. Profitez de ces informations détaillées pour prioriser le débogage et améliorer la stabilité des applications.
+
+
+
+
+
+## Onglet Occurrences [#error-group-occurrences]
+
+L'onglet 
+
+La section de triage relie l'occurrence d'erreur spécifique que vous visualisez à un [groupe d'erreurs créé par le système](/docs/errors-inbox/errors-inbox/#groups) qui possède une empreinte digitale unique. Pourquoi est-ce important ? Cette empreinte digitale unique vous permet de trier un groupe d’erreurs à l’aide d’une mise à jour [de statut](/docs/errors-inbox/errors-inbox/#status) ou [d’une affectation](/docs/errors-inbox/errors-inbox/#assign). Les groupes d’erreurs créés par le système sont ceux que vous trouvez dans l’onglet 
+
+Voici quelques raisons pour lesquelles l’événement dans le log des événements n’est pas présent :
+
+* 
+
+Nous stockons un lien vers le ticket ainsi que le groupe d'erreurs associé pendant 13 mois. Si l'erreur se reproduit dans ce délai, vous pouvez facilement accéder au ticket associé.
+
+
\ No newline at end of file
diff --git a/src/i18n/content/fr/docs/errors-inbox/error-limiting.mdx b/src/i18n/content/fr/docs/errors-inbox/error-limiting.mdx
new file mode 100644
index 00000000000..44c26fcdde0
--- /dev/null
+++ b/src/i18n/content/fr/docs/errors-inbox/error-limiting.mdx
@@ -0,0 +1,32 @@
+---
+title: Erreurs Limite de la boîte de réception atteinte
+metaDescription: Daily limit on number of unique error groups exceeded
+freshnessValidatedDate: never
+translationType: machine
+---
+
+Un nombre limité de comptes peuvent recevoir l'avertissement suivant lorsqu'ils tentent d'utiliser la boîte de réception des erreurs :
+
+### Problème [#problem]
+
+```
+You’ve reached the daily limit of unique error groups on account xxx. This limit will be reset at 00:00 UTC.
+```
+
+### Solution [#solution]
+
+Pour réduire le nombre de groupes d'erreurs, essayez de supprimer l'identifiant unique de la classe ou du message d'erreur, [plus de détails ici](/docs/errors-inbox/errors-inbox/#similar-events)
+
+***
+
+### Problème [#problem]
+
+```
+You’ve reached the daily maximum unique time series (cardinality) limit on account xxx. This limit will be reset at 00:00 UTC.
+```
+
+Lorsque cette limite est atteinte, la boîte de réception des erreurs ne sera plus mise à jour et les erreurs sembleront stagner ou diminuer.
+
+### Solution [#solution]
+
+Pour résoudre ce problème, [réduisez la portée de votre charge de travail](/docs/new-relic-one/use-new-relic-one/workloads/use-workloads/).
\ No newline at end of file
diff --git a/src/i18n/content/fr/docs/errors-inbox/error-users-impacted.mdx b/src/i18n/content/fr/docs/errors-inbox/error-users-impacted.mdx
new file mode 100644
index 00000000000..b68dae0393d
--- /dev/null
+++ b/src/i18n/content/fr/docs/errors-inbox/error-users-impacted.mdx
@@ -0,0 +1,178 @@
+---
+title: Suivi des utilisateurs impactés par les erreurs de la boîte de réception
+metaDescription: Triage more effectively by viewing how many users are impacted by an error group.
+freshnessValidatedDate: never
+translationType: machine
+---
+
+Les agents New Relic capturent automatiquement les données sur l’impact sur l’utilisateur. Lorsque vous organisez par groupe d'erreurs, vous pouvez voir combien d'utilisateurs sont affectés par des erreurs. Cela vous aide à prioriser où concentrer vos efforts de débogage en vous montrant les erreurs avec le plus grand nombre d'utilisateurs affectés.
+
+
+
+| + agent + | + ++ Méthode pour identifier un utilisateur final + | +
|---|---|
| + navigateur + | + ++ [`newrelic.setUserId(value: string|null)`](/docs/browser/new-relic-browser/browser-apis/setuserid/) + | +
| + Go + | + ++ [`txn.SetUserID("example user ID")`](/docs/apm/agents/go-agent/api-guides/guide-using-go-agent-api/#user-tracking) + | +
| + Java + | + ++ [`NewRelic.setUserId(String userId);`](/docs/apm/agents/java-agent/attributes/java-agent-attributes/#user-attributes) + | +
| + Applications mobiles + | + ++ [`setUserId`](/docs/data-apis/custom-data/custom-events/report-mobile-monitoring-custom-events-attributes/#track-user) + | +
| + .NET + | + ++ [`SetUserId`](/docs/apm/agents/net-agent/net-agent-api/itransaction/#setuserid) + | +
| + Node.js + | + ++ [`setUserID(id)`](https://newrelic.github.io/node-newrelic/API.html#setUserID) + | +
| + PHP + | + ++ [`newrelic_set_user_id(string $user_id)`](https://docs.newrelic.com/docs/apm/agents/php-agent/php-agent-api/newrelic_set_user_id/) + | +
| + Python + | + ++ [`newrelic.agent.set_user_id(user_id)`](https://docs.newrelic.com/docs/apm/agents/python-agent/python-agent-api/setuserid-python-agent-api) + | +
| + Ruby + | + ++ [`NewRelic::Agent.set_user_id`](/docs/apm/agents/ruby-agent/api-guides/sending-handled-errors-new-relic/#user-tracking) + | +
+
+Des notifications par e-mail sont actuellement envoyées aux membres de votre équipe. Si vous souhaitez inclure un nouveau membre, dans le menu de gauche, cliquez sur 
+
+Cliquez sur le lien 
+
+### erreur attendue tag [#expected-errors-tags]
+
+Un groupe d'erreurs est étiqueté avec une tag 
+
+### Actions groupées [#bulk-actions]
+
+
+
+
+
+Dans le panneau de gauche, vous pouvez trouver des détails sur une **agrégation de toutes les occurrences** de cette erreur :
+
+* Métriques : Nombre d'utilisateurs impactés, premier vu, dernier vu
+* Occurrences : nombre de fois que l'erreur s'est produite au cours des 30 dernières minutes
+* Occurrences par version : nombre de fois que l'erreur s'est produite par version de déploiement
+* Profils : Attribut impacté (cliquez sur un profil pour une analyse)
+
+Dans le panneau de droite, vous pouvez trouver les détails d'une seule occurrence de cette erreur :
+
+* Nombre et fréquence des erreurs
+
+* Comptes associés
+
+* trace d'appel
+
+* [Tracing distribué](/docs/distributed-tracing/concepts/quick-start/)
+
+* [Les logs en contexte](/docs/logs/logs-context/logs-in-context)
+
+* Une liste d'attributs d'erreur
+
+ À partir de la vue détaillée, vous pouvez parcourir des erreurs spécifiques à l'aide du bouton bascule en haut à droite pour naviguer entre la première instance de l'erreur, la dernière ou n'importe quelle instance intermédiaire.
+
+ Si vous avez configuré [le tracing distribué](/docs/distributed-tracing/concepts/quick-start/) et s'il existe des échantillons de traces liées à des erreurs, vous verrez des options permettant d'afficher les détails trace . Il s'agit d'un moyen rapide d'afficher les informations trace sans accéder à la page principale de tracing distribué :
+
+* Dans le volet de gauche intitulé
+
+* Dans
+
+ * Cliquez sur 
+
+
+
+
+
+ 
+
+ 
+
+
+
+## workflowrecommandé [#suggested-workflow]
+
+Nous recommandons l'approche suivante pour enquêter sur les erreurs de requête HTTP et les échecs de réseau, vous permettant d'acquérir une compréhension complète de l'erreur, d'identifier les facteurs contributifs et de mettre en œuvre des stratégies de débogage efficaces :
+
+1. **Accédez à une seule erreur**: pour afficher les détails d’une erreur de demande ou d’une défaillance du réseau, cliquez sur la ligne du tableau du groupe d’erreurs. Ici, vous pouvez afficher les informations de la demande, l'attribut de la demande et le corps de la réponse, ainsi qu'obtenir plus d'informations sur cette erreur.
+
+2. **Interroger et partager les données d'erreur**: Pour explorer les données derrière l'un des graphiques ou des listes sur la page d'erreurs HTTP :
+
+ * Sur n’importe quel graphique, cliquez sur le menu **…**, puis sur **
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 
+
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+ 
+
+Vous pouvez définir l'un des statuts suivants et filtrer votre boîte de réception par statut :
+
+* 
+
+Vous pouvez utiliser [le suivi des changements](/docs/change-tracking/change-tracking-view-analyze/) pour monitorer votre déploiement. Si vous avez fait cela, il est important de vous assurer que votre déploiement correspond au même format de version que vous avez instrumenté sur votre entité afin que vous puissiez faire correspondre les versions de vos erreurs à votre déploiement.
+
+## Rechercher des versions par groupe d'erreurs [#find-versions-by-error-group]
+
+Vous pouvez également cliquer sur un groupe d’erreurs pour voir chaque déploiement qui correspond aux dates de première et de dernière apparition de votre groupe d’erreurs. Vous ne verrez que les versions qui ont été mises en ligne dans les 30 minutes suivant votre première date de visionnage et dans les 30 minutes précédant votre dernière date de visionnage.
+
+
+
+Vous pouvez approfondir vos groupes d’erreurs en utilisant le graphique qui montre chacune de vos occurrences d’erreur regroupées par version.
+
+Si vous avez également mis en place une déploiement avec suivi des changements, vous verrez marqueur de déploiement sur ce tableau. Ces marqueurs indiquent quand chaque déploiement a eu lieu. Cliquez sur le marqueur pour accéder au déploiement.
\ No newline at end of file
diff --git a/src/i18n/content/fr/docs/iast/applications.mdx b/src/i18n/content/fr/docs/iast/applications.mdx
new file mode 100644
index 00000000000..8c215a681d8
--- /dev/null
+++ b/src/i18n/content/fr/docs/iast/applications.mdx
@@ -0,0 +1,58 @@
+---
+title: Tests et applications IAST
+tags:
+ - IAST
+ - New Relic IAST
+ - Applications
+metaDescription: Find out the total number of exploitable applications and safe applications you have.
+freshnessValidatedDate: never
+translationType: machine
+---
+
+La page des applications vous informe du nombre total de vulnérabilités trouvées dans vos applications testées et du nombre d'applications non testées dont vous disposez. Vous pouvez toujours ajouter des applications non testées à la fonctionnalité IAST de New Relic. Gardez à l’esprit que chaque test d’application est une version d’une application. Chaque fois que votre pré-environnement de production lance une nouvelle build et exécute un nouveau test, il apparaîtra avec ce nom d'application. Pour chaque exécution de test, nous affichons le nom de l'application, le compte, l'état, le nombre d'exploits, l'efficacité du test et la dernière fois que l'application a été testée. Vous pouvez trier par nom d'application pour voir toutes les exécutions de test d'une application ensemble afin de comparer rapidement leur statut.
+
+## Détails et correction d'une demande [#remediation-app]
+
+Découvrez tous les problèmes détectés avec les tests IAS sur vos applications. Pour voir les détails et les instructions de correction d'une demande :
+
+1. Accédez à 
+
+## Activer New Relic IAST [#enable-iast]
+
+Activez IAST sur vos applications non testées pour monitorer, tester et corriger les risques de sécurité tout au long du SDLC à grande échelle. Cela vous aidera également à expédier le code plus rapidement. Pour activer IAST :
+
+
+
+ 
+
+
+ 
+
+
+
+
+
+
+
+
+
+
+ 
+ 
+
+|
+ |
+
+
+ |
+
+
+ |
+
+
+ |
+
|---|---|---|---|
| + Version APM 3.30.0 ou supérieure + | + ++ Version APM 8.9.0 ou supérieure + | + ++ Version APM 11.10.4 ou supérieure + | + ++ Version APM 9.12.0 ou supérieure + | +
| + Gravité + | + ++ Plage de score de base + | +
|---|---|
| + Faible + | + ++ 0,1-3,9 + | +
| + Moyen + | + ++ 4,0-6,9 + | +
| + Haut + | + ++ 7,0-8,9 + | +
| + Critique + | + ++ 9,0-10,0 + | +
+
+| + métrique (min, max, moyenne, compte, somme) + | + ++ Unité + | + ++ Description + | +
|---|---|---|
| + `ActualCapacity` + | + ++ Compter + | + ++ Le nombre total d'instances disponibles pour le streaming ou en cours de streaming. + | +
| + `AvailableCapacity` + | + ++ Compter + | + ++ Le nombre d'instances inactives actuellement disponibles pour les sessions utilisateur. + | +
| + `CapacityUtilization` + | + ++ Pour cent + | + ++ Le pourcentage d'instances dans une flotte qui sont utilisées, en utilisant la formule suivante. + | +
| + `DesiredCapacity` + | + ++ Compter + | + ++ Le nombre total d'instances en cours d'exécution ou en attente. + | +
| + `InUseCapacity` + | + ++ Compter + | + ++ Le nombre d'instances actuellement utilisées pour les sessions de streaming. + | +
| + `PendingCapacity` + | + ++ Compter + | + ++ Le nombre d'instances provisionnées par AppStream 2.0. + | +
| + `RunningCapacity` + | + ++ Compter + | + ++ Le nombre total d'instances actuellement en cours d'exécution. + | +
| + `InsufficientCapacityError` + | + ++ Compter + | + ++ Le nombre de requests de session rejetées en raison d'un manque de capacité. + | +
| + métrique + | + ++ Description + | +
|---|---|
| + `NumberOfBackupJobsCreated` + | + ++ Le nombre de tâches de sauvegarde créées par AWS Backup. + | +
| + `NumberOfBackupJobsPending` + | + ++ Nombre de tâches de sauvegarde sur le point d'être exécutées dans AWS Backup. + | +
| + `NumberOfBackupJobsRunning` + | + ++ Nombre de tâches de sauvegarde actuellement en cours d'exécution dans AWS Backup. + | +
| + `NumberOfBackupJobsAborted` + | + ++ Le nombre de tâches de sauvegarde annulées par l'utilisateur. + | +
| + `NumberOfBackupJobsCompleted` + | + ++ Le nombre de tâches de sauvegarde terminées par AWS Backup. + | +
| + `NumberOfBackupJobsFailed` + | + ++ Le nombre de tâches de sauvegarde avec un statut Échec. Souvent causé par la planification d'une tâche de sauvegarde pendant ou 1 heure avant une ressource de base de données ou 4 heures avant ou pendant une fenêtre de maintenance Amazon FSx ou une fenêtre de sauvegarde automatisée et sans utiliser AWS Backup pour effectuer une sauvegarde continue pour les restaurations à un instant donné. Consultez Récupération à un moment donné pour obtenir une liste des services pris en charge et des instructions sur la façon d'utiliser AWS Backup pour effectuer des sauvegardes continues ou replanifier vos tâches de sauvegarde. + | +
| + `NumberOfBackupJobsExpired` + | + ++ Nombre de tâches de sauvegarde qu'AWS Backup a tenté de supprimer en fonction de votre cycle de vie de conservation de sauvegarde, mais n'a pas pu supprimer. Vous paierez pour le stockage consommé par les sauvegardes expirées et devrez les supprimer manuellement. + | +
| + `NumberOfCopyJobsCreated` + | + ++ Nombre de tâches de copie inter-comptes et inter-régions créées par AWS Backup. + | +
| + `NumberOfCopyJobsRunning` + | + ++ Nombre de tâches de copie inter-comptes et inter-régions actuellement en cours d'exécution dans AWS Backup. + | +
| + `NumberOfCopyJobsCompleted` + | + ++ Nombre de tâches de copie inter-comptes et inter-régions terminées par AWS Backup. + | +
| + `NumberOfCopyJobsFailed` + | + ++ Nombre de tâches de copie inter-comptes et inter-régions qu'AWS Backup a tentées mais n'a pas pu terminer. + | +
| + `NumberOfRestoreJobsPending` + | + ++ Nombre de tâches de restauration sur le point d'être exécutées dans AWS Backup. + | +
| + `NumberOfRestoreJobsRunning` + | + ++ Nombre de tâches de restauration actuellement en cours d'exécution dans AWS Backup. + | +
| + `NumberOfRestoreJobsCompleted` + | + ++ Le nombre de tâches de restauration terminées par AWS Backup. + | +
| + `NumberOfRestoreJobsFailed` + | + ++ Nombre de tâches de restauration qu'AWS Backup a tentées mais n'a pas pu terminer. + | +
| + métrique (min, max, moyenne, compte, somme) + | + ++ Unité + | + ++ Description + | +
|---|---|---|
| + `SuccessfulRequests` + | + ++ Compter + | + ++ Le nombre de requests de recherche traitées avec succès par une instance de recherche. + | +
| + `SearchableDocuments` + | + ++ Compter + | + ++ Le nombre de documents consultables dans l'index de recherche du domaine. + | +
| + `IndexUtilization` + | + ++ Pour cent + | + ++ Le pourcentage de la capacité d'index de l'instance de recherche qui a été utilisé. + | +
| + `Partitions` + | + ++ Compter + | + ++ Le nombre de partitions sur lesquelles l’index est distribué. + | +
| + métrique + | + ++ Unité + | + ++ Description + | +
|---|---|---|
| + `Latency` + | + ++ MS + | + ++ Le délai avant que le transfert de données ne commence après la demande. + | +
| + `Faults` + | + ++ Compter + | + ++ Un décompte des erreurs côté serveur HTTP 5XX et des erreurs d'état d'étendue OpenTelemetry. + | +
| + `Errors` + | + ++ Compter + | + ++ Nombre d'erreurs côté client HTTP 4XX. Il s’agit d’erreurs de demande qui ne sont pas causées par des problèmes de service. Par conséquent, la mesure de disponibilité affichée sur le dashboard des signaux d’application ne considère pas ces erreurs comme des défauts de service. + | +
| + métrique + | + ++ Unité + | + ++ Description + | +
|---|---|---|
| + `HealthIndicator` + | + ++ Binaire + | + ++ L'indicateur d'état du réseau prend en charge deux valeurs pour la version bêta-0 (le réseau AWS est en bon état) ou 1 (le réseau AWS est dégradé) + | +
| + `RTT` + | + ++ millisecondes + | + ++ Le temps (en millisecondes) nécessaire à une requête réseau pour passer d'un point de départ à une destination + | +
| + `PacketLoss` + | + ++ Pour cent + | + ++ La perte de paquets est mesurée en pourcentage de paquets échantillonnés reçus par la source avant qu'un délai d'attente statique ne soit atteint. + | +
| + métrique (min, max, moyenne, compte, somme) + | + ++ Unité + | + ++ Description + | +
|---|---|---|
| + `Builds` + | + ++ Compter + | + ++ Mesure le nombre de builds déclenchées. + | +
| + `FailedBuilds` + | + ++ Compter + | + ++ Mesure le nombre de builds qui ont échoué en raison d'une erreur client ou d'un délai d'attente. + | +
| + `SucceededBuilds` + | + ++ Compter + | + ++ Mesure le nombre de builds réussies. + | +
| + `Duration` + | + ++ Secondes + | + ++ Mesure la durée de toutes les builds au fil du temps. + | +
| + `BuildDuration` + | + ++ Secondes + | + ++ Mesure la durée de la phase BUILD de la build. + | +
| + `PreBuildDuration` + | + ++ Secondes + | + ++ Mesure la durée de la phase PRE\_BUILD de la build. + | +
| + `PostBuildDuration` + | + ++ Secondes + | + ++ Mesure la durée de la phase POST\_BUILD de la construction + | +
| + `FinalizingDuration` + | + ++ Secondes + | + ++ Mesure la durée de la phase de FINALISATION de la construction. + | +
| + `UploadArtifactsDuration` + | + ++ Secondes + | + ++ Mesure la durée de la phase UPLOAD\_ARTIFACTS de la build. + | +
| + `SubmittedDuration` + | + ++ Secondes + | + ++ Mesure la durée de la phase SOUMIS de la build. + | +
| + `ProvisioningDuration` + | + ++ Secondes + | + ++ Mesure la durée de la phase de PROVISIONING de la build. + | +
| + `QueuedDuration` + | + ++ Secondes + | + ++ Mesure la durée de la phase QUEUED de la build. + | +
| + `InstallDuration` + | + ++ Secondes + | + ++ Mesure la durée de la phase d'installation de la build. + | +
| + `DownloadSourceDuration` + | + ++ Secondes + | + ++ Mesure la durée de la phase DOWNLOAD\_SOURCE de la build. + | +
| + `CPUUtilized` + | + ++ Unités de processeur + | + ++ Le nombre d'unités CPU de traitement allouées utilisées par le conteneur de build. + | +
| + `MemoryUtilized` + | + ++ Mégaoctets + | + ++ Le nombre de mégaoctets de mémoire utilisés par le conteneur de build. + | +
| + `CPUUtilizedPercent` + | + ++ Pour cent + | + ++ Le pourcentage de traitement alloué utilisé par le conteneur de build. + | +
| + `MemoryUtilizedPercent` + | + ++ Pour cent + | + ++ Le pourcentage de mémoire allouée utilisé par le conteneur de build. + | +
| + `StorageReadBytes` + | + ++ Octets/seconde + | + ++ La vitesse de lecture de stockage utilisée par le conteneur de build. + | +
| + `StorageWriteBytes` + | + ++ Octets/seconde + | + ++ La vitesse d'écriture de stockage utilisée par le conteneur de build. + | +
| + métrique + | + ++ Unité + | + ++ Description + | +
|---|---|---|
| + `signUpSuccesses` + | + ++ Compter + | + ++ Nombre total de requests d'enregistrement d'utilisateur réussies adressées au pool d'utilisateurs Cognito. Pour trouver le pourcentage de requests d'enregistrement d'utilisateur réussies, utilisez l'attribut Moyenne sur cette métrique. Pour compter le nombre total de requests d'enregistrement d'utilisateurs, utilisez l'attribut SampleCount sur cette métrique. Pour compter le nombre total de requests d'enregistrement d'utilisateur réussies, utilisez l'attribut Sum sur cette métrique. Pour compter le nombre total de requests d'enregistrement d'utilisateur ayant échoué, soustrayez l'attribut Sum de l'attribut SampleCount. + | +
| + `signUpThrottles` + | + ++ Compter + | + ++ Le nombre total de requests d'enregistrement d'utilisateur limitées. Pour compter le nombre total de requests d'enregistrement d'utilisateur limitées, utilisez l'attribut Somme pour cette métrique. + | +
| + `signInSuccesses` + | + ++ Compter + | + ++ Nombre total de requests d'authentification d'utilisateur réussies auprès du pool d'utilisateurs. Pour trouver le pourcentage de requests d'authentification d'utilisateur réussies, utilisez l'attribut Moyenne sur cette métrique. Pour compter le nombre total de requests d'authentification d'utilisateur, utilisez l'attribut SampleCount sur cette métrique. Pour compter le nombre total de requests d'authentification d'utilisateur réussies, utilisez l'attribut Sum sur cette métrique. Pour compter le nombre total de requests d’authentification d’utilisateur ayant échoué, soustrayez l’attribut Sum de l’attribut SampleCount. + | +
| + `signInThrottles` + | + ++ Compter + | + ++ Nombre total de requests d'authentification d'utilisateur limitées adressées au pool d'utilisateurs Cognito. Pour compter le nombre total de requests d'authentification d'utilisateur limitées, utilisez l'attribut Sum pour cette métrique. + | +
| + `tokenRefreshSuccesses` + | + ++ Compter + | + ++ Le nombre total de requests réussies pour actualiser un jeton Cognito dans le pool d'utilisateurs. Pour trouver le pourcentage de requests réussies pour actualiser un jeton Cognito, utilisez l'attribut Moyenne sur cette métrique. Pour compter le nombre total de requests d'actualisation d'un jeton Cognito, utilisez l'attribut SampleCount sur cette métrique. Pour compter le nombre total de requests réussies pour actualiser un jeton Cognito, utilisez l'attribut Sum sur cette métrique. Pour compter le nombre total de requests ayant échoué pour actualiser un jeton Cognito, soustrayez l'attribut Sum de l'attribut SampleCount. + | +
| + `tokenRefreshThrottles` + | + ++ Compter + | + ++ Le nombre total de requests limitées pour actualiser un jeton Cognito dans le pool d'utilisateurs. Pour compter le nombre total de requests limitées pour actualiser un jeton Cognito, utilisez l'attribut Sum pour cette métrique. + | +
| + `federationSuccesses` + | + ++ Compter + | + ++ Nombre total de requests fédération d'identité réussies adressées au pool d'utilisateurs Cognito. Pour trouver le pourcentage de requests de fédération d'identité réussies, utilisez l'attribut Moyenne sur cette métrique. Pour compter le nombre total de requests de fédération d'identité, utilisez l'attribut SampleCount sur cette métrique. Pour compter le nombre total de requests de fédération d'identité réussies, utilisez l'attribut Sum sur cette métrique. Pour compter le nombre total de requests de fédération d’identité ayant échoué, soustrayez l’attribut Sum de l’attribut SampleCount. + | +
| + `federationThrottles` + | + ++ Compter + | + ++ Nombre total de requests fédération d'identité limitées adressées au pool d'utilisateurs Cognito. Pour compter le nombre total de requests de fédération d'identité limitées, utilisez l'attribut Somme pour cette métrique. + | +
| + métrique (min, max, moyenne, compte, somme) + | + ++ Unité + | + ++ Description + | +
|---|---|---|
| + `AvailableMemory` + | + ++ Octets + | + ++ Une estimation de la quantité de mémoire disponible pour démarrer de nouvelles applications, sans échange. + | +
| + `CPUAllocated` + | + ++ Pour cent + | + ++ Le pourcentage de CPU alloué au maximum à la tâche (0 signifie aucune limite). + | +
| + `CPUUtilization` + | + ++ Compter + | + ++ Le pourcentage de vCPU (CPU virtuel) alloué actuellement utilisé sur l'instance. + | +
| + `DiskQueueDepth` + | + ++ Compter + | + ++ Le nombre de requests de lecture/écriture (I/O) en attente d'accès au disque. + | +
| + `FreeStorageSpace` + | + ++ Octets + | + ++ La quantité d'espace de stockage disponible. + | +
| + `FreeMemory` + | + ++ Octets + | + ++ La quantité de mémoire physique disponible pour être utilisée par les applications, le cache de pages et pour les structures de données propres au noyau. + | +
| + `FreeableMemory` + | + ++ Octets + | + ++ La quantité de mémoire vive disponible. + | +
| + `MemoryAllocated` + | + ++ MioB + | + ++ L'allocation maximale de mémoire pour la tâche (0 signifie aucune limite). + | +
| + `WriteIOPS` + | + ++ Compte/seconde + | + ++ Le nombre moyen d'opérations I/O d'écriture sur disque par seconde. + | +
| + `ReadIOPS` + | + ++ Compte/seconde + | + ++ Nombre moyen d'opérations I/O de lecture de disque par seconde. + | +
| + `WriteThroughput` + | + ++ Octets/seconde + | + ++ Le nombre moyen d'octets écrits à partir du disque par seconde. + | +
| + `ReadThroughput` + | + ++ Octets/seconde + | + ++ Le nombre moyen d'octets lus sur le disque par seconde. + | +
| + `WriteLatency` + | + ++ Millisecondes + | + ++ La durée moyenne nécessaire à chaque opération d' I/O (sortie) du disque. + | +
| + `ReadLatency` + | + ++ Millisecondes + | + ++ La durée moyenne nécessaire à chaque opération d' I/O (entrée) sur disque. + | +
| + `SwapUsage` + | + ++ Octets + | + ++ La quantité d’espace de swap utilisée sur l’instance de réplication. + | +
| + `NetworkTransmitThroughput` + | + ++ Octets/seconde + | + ++ Le trafic réseau sortant (transmission) sur l' instance de réplication, y compris le trafic de base de données des clients et le trafic AWS DMS utilisé pour monitoring et la réplication. + | +
| + `NetworkReceiveThroughput` + | + ++ Octets/seconde + | + ++ Le trafic réseau entrant (réception) sur l' instance de réplication, y compris le trafic de base de données des clients et le trafic AWS DMS utilisé pour monitoring et la réplication. + | +
| + métrique (min, max, moyenne, compte, somme) + | + ++ Unité + | + ++ Description + | +
|---|---|---|
| + `FullLoadThroughputBandwidthTarget` + | + ++ Ko/seconde + | + ++ Données sortantes transmises à partir d'une charge complète pour la cible. + | +
| + `FullLoadThroughputRowsTarget` + | + ++ Rangées/seconde + | + ++ Modifications sortantes d'une charge complète pour la cible. + | +
| + `CDCIncomingChanges` + | + ++ Compter + | + ++ Le nombre total d'événements de changement à un moment donné qui attendent d'être appliqués à la cible. + | +
| + `CDCChangesMemorySource` + | + ++ Compter + | + ++ Nombre de lignes s'accumulant dans une mémoire et attendant d'être validées à partir de la source. + | +
| + `CDCChangesMemoryTarget` + | + ++ Compter + | + ++ Nombre de lignes s'accumulant dans une mémoire et attendant d'être validées dans la cible. + | +
| + `CDCChangesDiskSource` + | + ++ Compter + | + ++ Nombre de lignes accumulées sur le disque et en attente d'être validées à partir de la source. + | +
| + `CDCChangesDiskTarget` + | + ++ Compter + | + ++ Nombre de lignes accumulées sur le disque et en attente d'être validées sur la cible. + | +
| + `CDCThroughputBandwidthTarget` + | + ++ Ko/seconde + | + ++ Données sortantes transmises pour la cible. + | +
| + `CDCThroughputRowsSource` + | + ++ Rangées/seconde + | + ++ Les tâches entrantes changent depuis la source. + | +
| + `CDCThroughputRowsTarget` + | + ++ Rangées/seconde + | + ++ Modifications des tâches sortantes pour la cible. + | +
| + `CDCLatencySource` + | + ++ Secondes + | + ++ L'écart entre le dernier événement capturé à partir du point de terminaison source et l'horodatage système actuel de l'instance AWS DMS. + | +
| + `CDCLatencyTarget` + | + ++ Secondes + | + ++ L'écart entre l'horodatage du premier événement en attente de validation sur la cible et l'horodatage actuel de l'instance AWS DMS. + | +
| + `MemoryUsage` + | + ++ Mégaoctets + | + ++ Le groupe de contrôle (cgroup) memory.usage\_in\_bytesconsommé par une tâche. + | +
| + métrique (min, max, moyenne, compte, somme) + | + ++ Unité + | + ++ Description + | +
|---|---|---|
| + `BytesCompressed` + | + ++ Octets + | + ++ Le nombre physique d'octets transférés sur le réseau après l'application de la compression. + | +
| + `BytesPreparedDestination` + | + ++ Octets + | + ++ Le nombre total d'octets de données préparés à l'emplacement de destination. + | +
| + `BytesPreparedSource` + | + ++ Octets + | + ++ Le nombre total d’octets de données préparés à l’emplacement source. + | +
| + `BytesTransferred` + | + ++ Octets + | + ++ Le nombre total d'octets impliqués dans le transfert. + | +
| + `BytesVerifiedDestination` + | + ++ Octets + | + ++ Le nombre total d’octets de données vérifiés à l’emplacement de destination. + | +
| + `BytesVerifiedSource` + | + ++ Octets + | + ++ Le nombre total d’octets de données vérifiés à l’emplacement source. + | +
| + `BytesWritten` + | + ++ Octets + | + ++ La taille logique totale de tous les fichiers qui ont été transférés vers l'emplacement de destination. + | +
| + `FilesPreparedDestination` + | + ++ Octets + | + ++ Le nombre total de fichiers préparés à l’emplacement de destination. + | +
| + `FilesPreparedSource` + | + ++ Octets + | + ++ Le nombre total de fichiers préparés à l’emplacement source. + | +
| + `FilesTransferred` + | + ++ Octets + | + ++ Le nombre réel de fichiers ou de métadonnées qui ont été transférés sur le réseau. + | +
| + `FilesVerifiedDestination` + | + ++ Octets + | + ++ Le nombre total de fichiers vérifiés à l’emplacement de destination. + | +
| + `FilesVerifiedSource` + | + ++ Octets + | + ++ Le nombre total de fichiers vérifiés à l’emplacement source. + | +
| + métrique (min, max, moyenne, compte, somme) + | + ++ Unité + | + ++ Description + | +
|---|---|---|
| + `BilledAudioOutput` + | + ++ Secondes + | + ++ Le nombre de secondes facturables de sortie audio pour un pipeline. + | +
| + `BilledHDOutput` + | + ++ Secondes + | + ++ Le nombre de secondes facturables de sortie SD pour un pipeline. + | +
| + `BilledSDOutput` + | + ++ Secondes + | + ++ Le nombre de secondes facturables de sortie SD pour un pipeline. + | +
| + `Errors` + | + ++ Compter + | + ++ Le nombre d'erreurs causées par des paramètres d'opération non valides, comme une demande d'état de tâche qui n'inclut pas l'ID de tâche. + | +
| + `JobsCompleted` + | + ++ Compter + | + ++ Le nombre de tâches réalisées par ce pipeline. + | +
| + `JobsErrored` + | + ++ Compter + | + ++ Le nombre de tâches qui ont échoué en raison d'entrées non valides, comme une demande de transcodage d'un fichier qui ne se trouve pas dans le bucket d'entrée donné. + | +
| + `StandbyTime` + | + ++ Secondes + | + ++ Le nombre de secondes avant qu'Elastic Transcoder ne commence le transcodage d'une tâche. + | +
| + `Throttles` + | + ++ Compter + | + ++ Le nombre de fois où Elastic Transcoder a automatiquement limité une opération. + | +
| + métrique (min, max, moyenne, compte, somme) + | + ++ Unité + | + ++ Description + | +
|---|---|---|
| + `ActiveInstances` + | + ++ Compter + | + ++ instance avec le statut ACTIF, ce qui signifie qu'ils exécutent des processus serveur actifs. + | +
| + `DesiredInstances` + | + ++ Compter + | + ++ numéro cible de l'instance active qu'Amazon GameLift s'efforce de maintenir dans la flotte. + | +
| + `IdleInstances` + | + ++ Compter + | + ++ Instance active qui héberge actuellement zéro (0) session de jeu. + | +
| + `MaxInstances` + | + ++ Compter + | + ++ Nombre maximal d'instances autorisées pour la flotte. + | +
| + `MinInstances` + | + ++ Compter + | + ++ Nombre minimum d'instances autorisées pour la flotte. + | +
| + `PercentIdleInstances` + | + ++ Pour cent + | + ++ Pourcentage de toutes les instances actives qui sont inactives (calculé comme IdleInstances / ActiveInstances). + | +
| + `RecycledInstances` + | + ++ Compter + | + ++ Nombre d'instances ponctuelles qui ont été recyclées et remplacées. + | +
| + `InstanceInterruptions` + | + ++ Compter + | + ++ Nombre d'instances ponctuelles qui ont été interrompues. + | +
| + `CPUUtilization` + | + ++ Pour cent + | + ++ Amazon GameLift cette métrique représente les performances matérielles sur toutes les instances actives dans un emplacement de flotte. + | +
| + `NetworkIn` + | + ++ Compter + | + ++ identifie le volume de trafic réseau entrant vers une application sur une seule instance. + | +
| + `NetworkOut` + | + ++ Octets + | + ++ identifie le volume du trafic réseau sortant vers une application sur une seule instance. + | +
| + `DiskReadBytes` + | + ++ Octets + | + ++ Octets lus à partir de tous les volumes de stockage d'instance disponibles pour l'instance. + | +
| + `DiskWriteBytes` + | + ++ Octets + | + ++ Octets écrits sur tous les volumes de stockage d'instance disponibles pour l'instance. + | +
| + `DiskReadOps` + | + ++ Compter + | + ++ Opérations de lecture terminées à partir de tous les volumes de stockage d' instance disponibles pour l' instance au cours d'une période spécifiée. + | +
| + `DiskWriteOps` + | + ++ Compter + | + ++ Opérations d’écriture terminées sur tous les volumes de stockage instance disponibles pour l’ instance dans une période de temps spécifiée. + | +
| + `ActiveServerProcesses` + | + ++ Compter + | + ++ Processus serveur avec le statut ACTIF, ce qui signifie qu'ils sont en cours d'exécution et capables d'héberger des sessions de jeu. + | +
| + `HealthyServerProcesses` + | + ++ Compter + | + ++ Processus de serveur actifs qui signalent un état sain. Cette métrique est utile pour suivre l'état de santé général des serveurs de jeu de la flotte. + | +
| + `PercentHealthyServerProcesses` + | + ++ Pour cent + | + ++ Pourcentage de tous les processus de serveur actifs qui signalent qu'ils sont sains (calculé comme HealthyServerProcesses / ActiveServerProcesses). + | +
| + `ServerProcessAbnormalTerminations` + | + ++ Compter + | + ++ Processus serveur qui ont été arrêtés en raison de circonstances anormales depuis le dernier rapport. + | +
| + `ServerProcessActivations` + | + ++ Compter + | + ++ Processus serveur qui sont passés avec succès du statut ACTIVATION au statut ACTIF depuis le dernier rapport. + | +
| + `ServerProcessTerminations` + | + ++ Compter + | + ++ Processus serveur qui ont été arrêtés depuis le dernier rapport. + | +
| + `ActivatingGameSessions` + | + ++ Compter + | + ++ Sessions de jeu avec le statut ACTIVATION, ce qui signifie qu'elles sont en cours de démarrage. + | +
| + `ActiveGameSessions` + | + ++ Compter + | + ++ Sessions de jeu avec le statut ACTIF, ce qui signifie qu'elles peuvent héberger des joueurs et hébergent zéro ou plusieurs joueurs. + | +
| + `AvailableGameSessions` + | + ++ Compter + | + ++ Processus serveur actifs et sains qui ne sont pas actuellement utilisés pour héberger une session de jeu et peuvent démarrer une nouvelle session de jeu sans délai pour lancer de nouveaux processus ou instances de serveur. + | +
| + `ConcurrentActivatableGameSessions` + | + ++ Compter + | + ++ Processus serveur actifs et sains qui ne sont pas actuellement utilisés pour héberger une session de jeu et peuvent immédiatement démarrer une nouvelle session de jeu. + | +
| + `PercentAvailableGameSessions` + | + ++ Pour cent + | + ++ PercentAvailableGameSessions peut être utilisé avec une mise à l'échelle automatique. + | +
| + `GameSessionInterruptions` + | + ++ Compter + | + ++ Nombre de sessions de jeu sur l'instance spot qui ont été interrompues. + | +
| + `CurrentPlayerSessions` + | + ++ Compter + | + ++ Sessions de joueurs avec le statut ACTIF ou le statut RÉSERVÉ. + | +
| + `PlayerSessionActivations` + | + ++ Compter + | + ++ Sessions de joueurs qui sont passées du statut RÉSERVÉ à ACTIF depuis le dernier rapport. + | +
| + `AverageWaitTime` + | + ++ Secondes + | + ++ Durée moyenne pendant laquelle requests de placement de session de jeu dans la file d'attente avec le statut EN ATTENTE ont attendu d'être satisfaites. + | +
| + `FirstChoiceNotViable` + | + ++ Compter + | + ++ Sessions de jeu qui ont été placées avec succès mais PAS dans la flotte de premier choix, car cette flotte n'était pas considérée comme viable. + | +
| + `FirstChoiceOutOfCapacity` + | + ++ Compter + | + ++ Sessions de jeu qui ont été placées avec succès mais PAS dans la flotte de premier choix, car cette flotte n'avait pas de ressources disponibles. + | +
| + `LowestLatencyPlacement` + | + ++ Compter + | + ++ Sessions de jeu qui ont été placées avec succès dans une région offrant la latence la plus faible possible pour la file d'attente des joueurs. + | +
| + `LowestPricePlacement` + | + ++ Compter + | + ++ Sessions de jeu qui ont été placées avec succès dans une flotte avec le prix le plus bas possible de la file d'attente pour la région choisie. + | +
| + `PlacementsCanceled` + | + ++ Compter + | + ++ requests de placement de session de jeu qui ont été annulées avant l'expiration du délai depuis le dernier rapport. + | +
| + `PlacementsFailed` + | + ++ Compter + | + ++ requests de placement de session de jeu qui ont échoué pour une raison quelconque depuis le dernier rapport. + | +
| + `PlacementsStarted` + | + ++ Compter + | + ++ Nouvelles requests de placement de session de jeu qui ont été ajoutées à la file d'attente depuis le dernier rapport. + | +
| + `PlacementsSucceeded` + | + ++ Compter + | + ++ requests de placement de session de jeu qui ont abouti à une nouvelle session de jeu depuis le dernier rapport. + | +
| + `PlacementsTimedOut` + | + ++ Compter + | + ++ requests de placement de session de jeu qui ont atteint la limite de délai d'attente de la file d'attente sans avoir été satisfaites depuis le dernier rapport. + | +
| + métrique (min, max, moyenne, compte, somme) + | + ++ Unité + | + ++ Description + | +
|---|---|---|
| + `TotalMatchingAgents` + | + ++ Compter + | + ++ Nombre d'agents correspondant à cette cible + | +
| + `TotalHealthyAgents` + | + ++ Compter + | + ++ Nombre d'agents correspondant à cette cible qui sont en bonne santé + | +
| + `TotalAssessmentRuns` + | + ++ Compter + | + ++ Nombre d'exécutions d'évaluation pour cette cible + | +
| + `TotalAssessmentRunFindings` + | + ++ Compter + | + ++ Nombre de résultats pour cette cible + | +
| + métrique (min, max, moyenne, compte, somme) + | + ++ Unité + | + ++ Description + | +
|---|---|---|
| + `BillableTableSizeInBytes` + | + ++ Octets + | + ++ La taille facturable de la table en octets. + | +
| + `ConditionalCheckFailedRequests` + | + ++ Compter + | + ++ Le nombre de requests d'écriture de transactions légères (LWT) ayant échoué. + | +
| + `ConsumedReadCapacityUnits` + | + ++ Compter + | + ++ Le nombre d'unités de capacité de lecture consommées sur la période spécifiée. + | +
| + `ConsumedWriteCapacityUnits` + | + ++ Compter + | + ++ Le nombre d'unités de capacité d'écriture consommées sur la période spécifiée. + | +
| + `PerConnectionRequestRateExceeded` + | + ++ Compter + | + ++ Requêtes vers Amazon Keyspaces qui dépassent le quota du taux de requêtes par connexion. + | +
| + `ProvisionedReadCapacityUnits` + | + ++ Compter + | + ++ Le nombre d'unités de capacité de lecture provisionnées pour une table. + | +
| + `ProvisionedWriteCapacityUnits` + | + ++ Compter + | + ++ Le nombre d'unités de capacité d'écriture provisionnées pour une table. + | +
| + `ReadThrottleEvents` + | + ++ Compter + | + ++ Demandes adressées à Amazon Keyspaces qui dépassent la capacité de lecture provisionnée pour une table, ou les quotas au niveau du compte, les quotas de demande par connexion ou les quotas au niveau de la partition. + | +
| + `ReplicationLatency` + | + ++ Millisecond + | + ++ Cette métrique s'applique uniquement aux espaces clés multi-régions et mesure le temps nécessaire pour répliquer les mises à jour, les insertions ou les suppressions d'une table de réplication vers une autre table de réplication dans un espace clé multi-régions. + | +
| + `ReturnedItemCountBySelect` + | + ++ Compter + | + ++ Le nombre de lignes renvoyées par la requête SELECT multi-lignes pendant la période spécifiée. + | +
| + `StoragePartitionThroughputCapacityExceeded` + | + ++ Compter + | + ++ Demandes adressées à une partition de stockage Amazon Keyspaces qui dépassent la capacité de débit de la partition. + | +
| + `SuccessfulRequestCount` + | + ++ Compter + | + ++ Le nombre de requests traitées avec succès au cours de la période spécifiée. + | +
| + `SuccessfulRequestLatency` + | + ++ Millisecondes + | + ++ Les requests réussies adressées à Amazon Keyspaces pendant la période spécifiée. + | +
| + `SystemErrors` + | + ++ Compter + | + ++ Les requests adressées à Amazon Keyspaces qui génèrent une ServerError pendant la période spécifiée. + | +
| + `SystemReconciliationDeletes` + | + ++ Compter + | + ++ Les unités consommées pour supprimer les données tombstoned lorsque l'horodatage côté client est activé. + | +
| + `TTLDeletes` + | + ++ Compter + | + ++ Les unités consommées pour supprimer ou mettre à jour des données d'affilée en utilisant Time to Live (TTL). + | +
| + `UserErrors` + | + ++ Compter + | + ++ Requêtes adressées à Amazon Keyspaces qui génèrent une erreur InvalidRequest pendant la période spécifiée. + | +
| + `WriteThrottleEvents` + | + ++ Compter + | + ++ Demandes adressées à Amazon Keyspaces qui dépassent la capacité d'écriture provisionnée pour une table, ou les quotas au niveau du compte, les quotas de demande par connexion ou les quotas au niveau de la partition. + | +
| + métrique (min, max, moyenne, compte, somme) + | + ++ Unité + | + ++ Description + | +
|---|---|---|
| + `AccountMaxTableLevelReads` + | + ++ Compter + | + ++ Le nombre maximal d'unités de capacité de lecture qui peuvent être utilisées par une table d'un compte. + | +
| + `AccountMaxTableLevelWrites` + | + ++ Compter + | + ++ Le nombre maximal d'unités de capacité d'écriture qui peuvent être utilisées par une table d'un compte. + | +
| + `AccountProvisionedReadCapacityUtilization` + | + ++ Pour cent + | + ++ Pourcentage d'unités de capacité de lecture provisionnées utilisées par un compte. + | +
| + `AccountProvisionedWriteCapacityUtilization` + | + ++ Pour cent + | + ++ Pourcentage d'unités de capacité d'écriture provisionnées utilisées par un compte. + | +
| + `MaxProvisionedTableReadCapacityUtilization` + | + ++ Pour cent + | + ++ Pourcentage d'unités de capacité de lecture provisionnées utilisées par la table de lecture provisionnée la plus élevée d'un compte. + | +
| + `MaxProvisionedTableWriteCapacityUtilization` + | + ++ Pour cent + | + ++ Pourcentage de la capacité d'écriture provisionnée utilisée par la table d'écriture provisionnée la plus élevée d'un compte. + | +
| + métrique + | + ++ Unité + | + ++ Description + | +
|---|---|---|
| + `ActiveDefragHits` + | + ++ Nombre + | + ++ Le nombre de réallocations de valeur par minute effectuées par le processus de défragmentation actif. Ceci est dérivé de la statistique active\_defrag\_hits dans [INFO](http://valkey.io/commands/info). + | +
| + `AuthenticationFailures` + | + ++ Compter + | + ++ Le nombre total de tentatives infructueuses d’authentification à l’aide de la commande AUTH. Vous pouvez trouver plus d’informations sur les échecs d’authentification individuels à l’aide de la commande ACL log. Nous vous suggérons de définir une alarme pour détecter les tentatives d'accès non autorisées. + | +
| + `BytesUsedForMemoryDB` + | + ++ Octets + | + ++ Le nombre total d'octets alloués par MemoryDB à toutes fins, y compris l'ensemble de données, les tampons, etc. + | +
| + `BytesReadFromDisk` + | + ++ Octets + | + ++ Le nombre total d'octets lus sur le disque par minute. Pris en charge uniquement pour les clusters utilisant le niveau de données. + | +
| + `BytesWrittenToDisk` + | + ++ Octets + | + ++ Le nombre total d'octets écrits sur le disque par minute. Pris en charge uniquement pour les clusters utilisant le niveau de données. + | +
| + `CommandAuthorizationFailures` + | + ++ Compter + | + ++ Le nombre total de tentatives infructueuses de l'utilisateur pour exécuter des commandes qu'il n'a pas l'autorisation d'appeler. Vous pouvez trouver plus d’informations sur les échecs d’authentification individuels à l’aide de la commande ACL log. Nous vous suggérons de définir une alarme pour détecter les tentatives d'accès non autorisées. + | +
| + `CurrConnections` + | + ++ Compter + | + ++ Le nombre de connexions client, à l'exclusion des connexions provenant de répliques en lecture. MemoryDB utilise 2 à 4 connexions pour monitorer le cluster dans chaque cas. Ceci est dérivé de la statistique connected\_clients dans [INFO](http://valkey.io/commands/info). + | +
| + `CurrItems` + | + ++ Compter + | + ++ Le nombre d'éléments dans le cache. Ceci est dérivé de la statistique de l'espace clé, qui additionne toutes les clés de l'espace clé entier. + | +
| + `DatabaseMemoryUsagePercentage` + | + ++ Pour cent + | + ++ Pourcentage de la mémoire disponible pour le cluster qui est utilisée. Ceci est calculé en utilisant used\_memory/maxmemory de [INFO](http://valkey.io/commands/info). + | +
| + `DatabaseCapacityUsagePercentage` + | + ++ Pour cent + | + ++ Pourcentage de la capacité totale de données du cluster qui est utilisée. + + Sur l'instance de niveau Données, la métrique est calculée comme (used\_memory - mem\_not\_counted\_for\_evict + SSD utilisé) / (maxmemory + capacité totale du SSD), où used\_memory et maxmemory sont extraits de [INFO](http://valkey.io/commands/info). + + Dans tous les autres cas, la métrique est calculée à l’aide de used\_memory/maxmemory. + | +
| + `DB0AverageTTL` + | + ++ Millisecondes + | + ++ exposer avg\_ttl de DBO à partir de l'espace clé statistique de la commande INFO. + | +
| + `EngineCPUUtilization` + | + ++ Pour cent + | + ++ Fournit l'utilisation du processeur du thread du moteur Valkey ou Redis OSS. Étant donné que le moteur est monothread, vous pouvez utiliser cette métrique pour analyser la charge du processus lui-même. La métrique EngineCPUUtilization fournit une visibilité plus précise du processus. Vous pouvez l'utiliser en conjonction avec la métrique CPUUtilization. CPUUtilization expose l'utilisation du processeur pour l' instance du serveur dans son ensemble, y compris d'autres processus du système d'exploitation et de gestion. Pour les types de nœuds plus grands avec quatre vCPU ou plus, utilisez la métrique EngineCPUUtilization pour monitorer et définir le seuil de mise à l'échelle. + | +
| + `Evictions` + | + ++ Compter + | + ++ Le nombre de clés qui ont été expulsées en raison de la limite de mémoire maximale. Ceci est dérivé de la statistique evicted\_keys dans [INFO](http://valkey.io/commands/info). + | +
| + `IsPrimary` + | + ++ Compter + | + ++ Indique si le nœud est le nœud principal du fragment actuel. La métrique peut être soit 0 (non principale) soit 1 (principale). + | +
| + `KeyAuthorizationFailures` + | + ++ Compter + | + ++ Le nombre total de tentatives infructueuses de l'utilisateur pour accéder aux clés auxquelles il n'est pas autorisé à accéder. Vous pouvez trouver plus d’informations sur les échecs d’authentification individuels à l’aide de la commande ACL log. Nous vous suggérons de définir une alarme pour détecter les tentatives d'accès non autorisées. + | +
| + `KeyspaceHits` + | + ++ Compter + | + ++ Le nombre de recherches de clés en lecture seule réussies dans le dictionnaire principal. Ceci est dérivé de la statistique keyspace\_hits dans [INFO](http://valkey.io/commands/info). + | +
| + `KeyspaceMisses` + | + ++ Compter + | + ++ Le nombre de recherches de clés en lecture seule infructueuses dans le dictionnaire principal. Ceci est dérivé de la statistique keyspace\_misses dans [INFO](http://valkey.io/commands/info). + | +
| + `KeysTracked` + | + ++ Compter + | + ++ Nombre de clés suivies par le suivi des clés en pourcentage du nombre maximal de clés de la table de suivi. Le suivi des clés est utilisé pour faciliter la mise en cache côté client et avertit les clients lorsque les clés sont modifiées. + | +
| + `MaxReplicationThroughput` + | + ++ Octets par seconde + | + ++ Le débit de réplication maximal observé au cours du dernier cycle de mesure. + | +
| + `MemoryFragmentationRatio` + | + ++ Nombre + | + ++ Indique l'efficacité dans l'allocation de mémoire du moteur Valkey ou Redis OSS. Certains seuils signifient des comportements différents. La valeur recommandée est d'avoir une fragmentation supérieure à 1,0. Ceci est calculé à partir de la statistique mem\_fragmentation\_ratio de [INFO](http://valkey.io/commands/info). + | +
| + `NewConnections` + | + ++ Compter + | + ++ Le nombre total de connexions qui ont été acceptées par le serveur pendant cette période. Ceci est dérivé de la statistique total\_connections\_received dans [INFO](http://valkey.io/commands/info). + | +
| + `NumItemsReadFromDisk` + | + ++ Compter + | + ++ Le nombre total d'éléments récupérés sur le disque par minute. Pris en charge uniquement pour les clusters utilisant le niveau de données. + | +
| + `NumItemsWrittenToDisk` + | + ++ Compter + | + ++ Le nombre total d'éléments écrits sur le disque par minute. Pris en charge uniquement pour les clusters utilisant le niveau de données. + | +
| + `PrimaryLinkHealthStatus` + | + ++ Booléen + | + ++ Ce statut a deux valeurs : 0 ou 1. La valeur 0 indique que les données du nœud principal MemoryDB ne sont pas synchronisées avec le moteur Valkey ou Redis OSS sur EC2. La valeur 1 indique que les données sont synchronisées. + | +
| + `Reclaimed` + | + ++ Compter + | + ++ Le nombre total d'événements d'expiration de clé. Ceci est dérivé de la statistique expired\_keys dans [INFO](http://valkey.io/commands/info). + | +
| + `ReplicationBytes` + | + ++ Octets + | + ++ Pour les nœuds dans une configuration répliquée, ReplicationBytes indique le nombre d'octets que le nœud principal envoie à tous ses réplicas. Cette métrique est représentative de la charge d’écriture sur le cluster. Ceci est dérivé de la statistique master\_repl\_offset dans [INFO](http://valkey.io/commands/info). + | +
| + `ReplicationDelayedWriteCommands` + | + ++ Compter + | + ++ Nombre de commandes d'écriture retardées en raison d'une réplication synchrone. La réplication peut être retardée en raison de divers facteurs, par exemple la congestion du réseau ou le dépassement du débit de réplication maximal. + | +
| + `ReplicationLag` + | + ++ Secondes + | + ++ Cette métrique s’applique uniquement à un nœud exécuté en tant que réplica en lecture. Il représente le retard, en secondes, de la réplique dans l'application des modifications à partir du nœud principal. + | +
| + métrique (min, max, moyenne, compte, somme) + | + ++ Unité + | + ++ Description + | +
|---|---|---|
| + `Invocations` + | + ++ Compter + | + ++ Le nombre de requests InvokeEndpoint envoyées à un point de terminaison de modèle. + | +
| + `InvocationsPerInstance` + | + ++ Compter + | + ++ Le nombre d'appels envoyés à un modèle, normalisé par InstanceCount dans chaque ProductionVariant. + | +
| + `OverheadLatency` + | + ++ Microsecondes + | + ++ L'intervalle de temps ajouté au temps nécessaire pour répondre à une demande client par les frais généraux de SageMaker. + | +
| + `ModelLatency` + | + ++ Microsecondes + | + ++ L'intervalle de temps pris par un modèle pour répondre à une demande d'API SageMaker. + | +
| + `Invocation4XXErrors` + | + ++ Compter + | + ++ Nombre de requests InvokeEndpoint pour lesquelles le modèle a renvoyé un code de réponse HTTP 4xx. + | +
| + `Invocation5XXErrors` + | + ++ Compter + | + ++ Nombre de requests InvokeEndpoint pour lesquelles le modèle a renvoyé un code de réponse HTTP 5xx. + | +
| + `InvocationModelErrors` + | + ++ Compter + | + ++ Le nombre de requests d'invocation de modèles qui n'ont pas abouti à une réponse HTTP 2XX. + | +
| + métrique (min, max, moyenne, compte, somme) + | + ++ Unité + | + ++ Description + | +
|---|---|---|
| + `MemoryUtilization` + | + ++ Pour cent + | + ++ Le pourcentage de mémoire utilisé par le conteneur sur une instance. Pour les variantes de point de terminaison, la valeur est la somme de l'utilisation de la mémoire du conteneur principal et supplémentaire sur l' instance. + | +
| + `DiskUtilization` + | + ++ Pour cent + | + ++ Le pourcentage d'espace disque utilisé par le conteneur sur une instance . Pour les variantes de point de terminaison, la valeur est la somme de l'utilisation de l'espace disque du conteneur principal et supplémentaire sur l' instance. + | +
| + `CPUUtilization` + | + ++ Pour cent + | + ++ La somme de l'utilisation de chaque cœur de processeur individuel. Pour les variantes de point de terminaison, la valeur est la somme de l'utilisation du processeur du conteneur principal et supplémentaire sur l' instance. + | +
| + `GPUMemoryUtilization` + | + ++ Pour cent + | + ++ Le pourcentage de mémoire GPU utilisé par le conteneur sur une instance. Pour les variantes de point de terminaison, la valeur est la somme de l'utilisation de la mémoire GPU du conteneur principal et supplémentaire sur l' instance. + | +
| + `GPUUtilization` + | + ++ Pour cent + | + ++ Le pourcentage d'unités GPU utilisées par le conteneur sur une instance. Pour les variantes de point de terminaison, la valeur est la somme de l'utilisation du GPU du conteneur principal et supplémentaire sur l' instance. + | +
| + métrique (min, max, moyenne, compte, somme) + | + ++ Unité + | + ++ Description + | +
|---|---|---|
| + `MemoryUtilization` + | + ++ Pour cent + | + ++ Le pourcentage de mémoire utilisé par le conteneur sur une instance. Pour le travail d'apprentissage, la valeur est l'utilisation de la mémoire de l'algorithme conteneur sur l' instance. + | +
| + `DiskUtilization` + | + ++ Pour cent + | + ++ Le pourcentage d'espace disque utilisé par le conteneur sur une instance . Pour le travail d'apprentissage, la valeur est l'utilisation de l'espace disque du conteneur d'algorithmes sur l' instance. + | +
| + `CPUUtilization` + | + ++ Pour cent + | + ++ La somme de l'utilisation de chaque cœur de processeur individuel. Pour le travail d'apprentissage, la valeur est l'utilisation du processeur du conteneur d'algorithmes sur l' instance. + | +
| + `TrainErrors` + | + ++ Compter + | + ++ Mesure le nombre d'erreurs du train de travail d'apprentissage. + | +
| + métrique (min, max, moyenne, compte, somme) + | + ++ Unité + | + ++ Description + | +
|---|---|---|
| + `DecisionTaskScheduleToStartTime` + | + ++ Temps + | + ++ L'intervalle de temps, en millisecondes, entre le moment où la tâche de décision a été planifiée et celui où elle a été reprise par un travailleur et démarrée. + | +
| + `DecisionTaskStartToCloseTime` + | + ++ Temps + | + ++ L'intervalle de temps, en millisecondes, entre le moment où la tâche de décision a été démarrée et celui où elle a été fermée. + | +
| + `DecisionTasksCompleted` + | + ++ Compter + | + ++ Le nombre de tâches de décision qui ont été accomplies. + | +
| + `PendingTasks` + | + ++ Compter + | + ++ Le nombre de tâches en attente dans un intervalle d'une minute pour une liste de tâches spécifique. + | +
| + `StartedDecisionTasksTimedOutOnClose` + | + ++ Compter + | + ++ Le nombre de tâches de décision qui ont démarré mais qui ont expiré à la fermeture. + | +
| + `WorkflowStartToCloseTime` + | + ++ Temps + | + ++ Le temps, en millisecondes, entre le moment où le workflow a démarré et celui où il s'est terminé. + | +
| + `WorkflowsCanceled` + | + ++ Compter + | + ++ Le nombre de workflows qui ont été annulés. + | +
| + `WorkflowsCompleted` + | + ++ Compter + | + ++ Le nombre de workflows terminés. + | +
| + `WorkflowsContinuedAsNew` + | + ++ Compter + | + ++ Le nombre de workflows qui ont continué comme nouveaux. + | +
| + `WorkflowsFailed` + | + ++ Compter + | + ++ Le nombre de workflows qui ont échoué. + | +
| + `WorkflowsTerminated` + | + ++ Compter + | + ++ Le nombre de workflows qui ont été terminés. + | +
| + `WorkflowsTimedOut` + | + ++ Compter + | + ++ Le nombre de workflows qui ont expiré, pour une raison quelconque. + | +
| + Nom + | + ++ Description + | +
|---|---|
| + `approximateAgeOfOldestMessage` + | + ++ L'âge approximatif du message non supprimé le plus ancien dans la file d'attente, en secondes. Pour les files d'attente de lettres mortes, cette valeur correspond à la durée la plus longue pendant laquelle un message est resté dans la file d'attente. + | +
| + `approximateNumberOfMessagesDelayed` + | + ++ Le nombre approximatif de messages dans la file d'attente qui sont retardés et non disponibles pour lecture immédiate. Cela peut se produire lorsque la file d'attente est configurée comme file d'attente de retard ou lorsqu'un message a été envoyé avec un paramètre de retard. + | +
| + `approximateNumberOfMessagesNotVisible` + | + ++ Le nombre approximatif de messages « en vol ». Les messages sont considérés comme en vol s'ils ont été envoyés à un client mais n'ont pas encore été supprimés ou n'ont pas encore atteint la fin de leur fenêtre de visibilité. + | +
| + `ApproximateNumberOfMessagesVisible` + | + ++ Le nombre approximatif de messages disponibles pour récupération dans la file d'attente. + | +
| + `numberOfEmptyReceives` + | + ++ Le nombre de `ReceiveMessage` appels d'API qui n'ont pas renvoyé de message. + | +
| + `numberOfMessagesDeleted` + | + ++ Le nombre de messages supprimés de la file d'attente. + | +
| + `numberOfMessagesReceived` + | + ++ Le nombre de messages renvoyés par les appels à l'action API `ReceiveMessage` . + | +
| + `numberOfMessagesSent` + | + ++ Le nombre de messages ajoutés à une file d'attente. + | +
| + `sentMessagesSize` + | + ++ La taille en octets des messages ajoutés à une file d'attente. + | +
| + entité + | + ++ Fournisseur + | +
|---|---|
| + base de données + | + ++ `cloudwatch-metric-streams` + | +
| + Tableau + | + ++ `cloudwatch-metric-streams` + | +
| + métrique (min, max, moyenne, compte, somme) + | + ++ Unité + | + ++ Description + | +
|---|---|---|
| + `SystemErrors` + | + ++ Compter + | + ++ Les requests adressées à Timestream qui génèrent une erreur système pendant la période spécifiée. + | +
| + `UserErrors` + | + ++ Compter + | + ++ Requêtes adressées à Timestream qui génèrent une erreur InvalidRequest pendant la période spécifiée. + | +
| + `SuccessfulRequestLatency` + | + ++ Millisecondes + | + ++ Les requests réussies adressées à Timestream pendant la période spécifiée. + | +
| + `CumulativeBytesMetered` + | + ++ Octets + | + ++ La quantité de données analysées par la requête envoyée à Timestream, en octets. + | +
| + `MagneticStoreRejectedRecordCount` + | + ++ Compter + | + ++ Le nombre d'enregistrements écrits dans le magasin magnétique qui ont été rejetés de manière asynchrone. + | +
| + `MagneticStoreRejectedUploadUserFailures` + | + ++ Compter + | + ++ Nombre de rapports d'enregistrements rejetés par le magasin magnétique qui n'ont pas été téléchargés en raison d'erreurs de l'utilisateur. + | +
| + `MagneticStoreRejectedUploadSystemFailures` + | + ++ Compter + | + ++ Nombre de rapports d'enregistrements rejetés par le magasin magnétique qui n'ont pas été téléchargés en raison d'erreurs système. + | +
| + `ActiveMagneticStorePartitions` + | + ++ Compter + | + ++ Le nombre de partitions de stockage magnétique ingérant activement des données à un moment donné. + | +
| + `MagneticStorePendingRecordsLatency` + | + ++ Millisecondes + | + ++ L'écriture la plus ancienne dans une mémoire magnétique qui n'est pas disponible pour la requête. + | +
| + `MemoryCumulativeBytesMetered` + | + ++ Octets + | + ++ La quantité de données stockées dans la mémoire, en octets. + | +
| + `MagneticCumulativeBytesMetered` + | + ++ Octets + | + ++ La quantité de données stockées dans la mémoire magnétique, en octets. + | +
| + `CumulativeBytesMetered` + | + ++ Octets + | + ++ La quantité de données analysées par la requête envoyée à Timestream, en octets. + | +
| + métrique (min, max, moyenne, compte, somme) + | + ++ Unité + | + ++ Description + | +
|---|---|---|
| + `SystemErrors` + | + ++ Compter + | + ++ Les requests adressées à Timestream qui génèrent une erreur système pendant la période spécifiée. + | +
| + `UserErrors` + | + ++ Compter + | + ++ Requêtes adressées à Timestream qui génèrent une erreur InvalidRequest pendant la période spécifiée. + | +
| + `SuccessfulRequestLatency` + | + ++ Millisecondes + | + ++ Les requests réussies adressées à Timestream pendant la période spécifiée. + | +
| + `MagneticStoreRejectedRecordCount` + | + ++ Compter + | + ++ Le nombre d'enregistrements écrits dans le magasin magnétique qui ont été rejetés de manière asynchrone. + | +
| + `MagneticStoreRejectedUploadUserFailures` + | + ++ Compter + | + ++ Nombre de rapports d'enregistrements rejetés par le magasin magnétique qui n'ont pas été téléchargés en raison d'erreurs de l'utilisateur. + | +
| + `MagneticStoreRejectedUploadSystemFailures` + | + ++ Compter + | + ++ Nombre de rapports d'enregistrements rejetés par le magasin magnétique qui n'ont pas été téléchargés en raison d'erreurs système. + | +
| + `MagneticStorePendingRecordsLatency` + | + ++ Millisecondes + | + ++ L'écriture la plus ancienne dans une mémoire magnétique qui n'est pas disponible pour la requête. + | +
| + métrique (min, max, moyenne, compte, somme) + | + ++ Unité + | + ++ Description + | +
|---|---|---|
| + `BytesIn` + | + ++ Compter + | + ++ Le nombre total d'octets transférés vers le serveur. + | +
| + `BytesOut` + | + ++ Compter + | + ++ Le nombre total d'octets transférés hors du serveur. + | +
| + `FilesIn` + | + ++ Compter + | + ++ Le nombre total de fichiers transférés sur le serveur. + | +
| + `FilesOut` + | + ++ Compter + | + ++ Le nombre total de fichiers transférés hors du serveur. + | +
| + `InboundMessage` + | + ++ Compter + | + ++ Le nombre total de messages AS2 reçus avec succès d'un partenaire commercial. + | +
| + `InboundFailedMessage` + | + ++ Compter + | + ++ Le nombre total de messages AS2 qui ont été reçus sans succès d'un partenaire commercial. + | +
| + `OnPartialUploadExecutionsStarted` + | + ++ Compter + | + ++ Nombre total d'exécutions de workflow de téléchargement partiel démarrées sur le serveur. + | +
| + `OnPartialUploadExecutionsSuccess` + | + ++ Compter + | + ++ Nombre total d'exécutions de workflow réussies avec téléchargement partiel sur le serveur. + | +
| + `OnPartialUploadExecutionsFailed` + | + ++ Compter + | + ++ Le nombre total d'exécutions de workflow infructueuses et à téléchargement partiel sur le serveur. + | +
| + `OnUploadExecutionsStarted` + | + ++ Compter + | + ++ Le nombre total d'exécutions de workflow démarrées sur le serveur. + | +
| + `OnUploadExecutionsSuccess` + | + ++ Compter + | + ++ Le nombre total d'exécutions de workflow réussies sur le serveur. + | +
| + `OnUploadExecutionsFailed` + | + ++ Compter + | + ++ Le nombre total d'exécutions de workflow infructueuses sur le serveur. + | +
| + entité + | + ++ Type d'événement + | + ++ Fournisseur + | +
|---|---|---|
| + Passerelle de transit + | + ++ `AwsTransitGatewayTransitGatewaySample` + | + ++ `AwsTransitGatewayTransitGateway` + | +
| + métrique + | + ++ Unité + | + ++ Description + | +
|---|---|---|
| + `bytesIn` + | + ++ Compter + | + ++ Le nombre d'octets reçus par la passerelle de transit. + | +
| + `bytesOut` + | + ++ Compter + | + ++ Le nombre d'octets envoyés depuis la passerelle de transit. + | +
| + `packetsIn` + | + ++ Compter + | + ++ Le nombre de paquets reçus par la passerelle de transit. + | +
| + `packetsOut` + | + ++ Compter + | + ++ Le nombre de paquets envoyés par la passerelle de transit. + | +
| + `packetDropCountBlackhole` + | + ++ Compter + | + ++ Le nombre de paquets abandonnés parce qu'ils correspondaient à une route de trou noir. + | +
| + `packetDropCountNoRoute` + | + ++ Compter + | + ++ Le nombre de paquets abandonnés car ils ne correspondaient pas à un itinéraire. + | +
| + `bytesDropCountBlackhole` + | + ++ Compter + | + ++ Le nombre d'octets supprimés parce qu'ils correspondaient à une route de trou noir. + | +
| + `bytesDropCountNoRoute` + | + ++ Compter + | + ++ Le nombre d'octets supprimés car ils ne correspondaient pas à un itinéraire. + | +
| + métrique (min, max, moyenne, compte, somme) + | + ++ Unité + | + ++ Description + | +
|---|---|---|
| + `OrganizationEmailReceived` + | + ++ Compter + | + ++ Le nombre d'e-mails reçus par votre organisation Amazon WorkMail. + | +
| + `MailboxEmailDelivered` + | + ++ Compter + | + ++ Le nombre d’e-mails livrés aux boîtes aux lettres individuelles de votre organisation Amazon WorkMail. + | +
| + `IncomingEmailBounced` + | + ++ Compter + | + ++ Le nombre d'e-mails entrants qui ont rebondi en raison de boîtes aux lettres pleines. + | +
| + `OutgoingEmailBounced` + | + ++ Compter + | + ++ Le nombre d'e-mails sortants qui n'ont pas pu être livrés, compté pour chaque destinataire prévu. + | +
| + `OutgoingEmailSent` + | + ++ Compter + | + ++ Le nombre d'e-mails envoyés avec succès depuis votre organisation Amazon WorkMail. + | +
| + métrique (min, max, moyenne, compte, somme) + | + ++ Unité + | + ++ Description + | +
|---|---|---|
| + `Available` + | + ++ Compter + | + ++ Le nombre d'espaces de travail qui ont renvoyé un état sain. + | +
| + `Unhealthy` + | + ++ Compter + | + ++ Le nombre d'espaces de travail qui ont renvoyé un état non sain. + | +
| + `ConnectionAttempt` + | + ++ Compter + | + ++ Le nombre de tentatives de connexion. + | +
| + `ConnectionSuccess` + | + ++ Compter + | + ++ Le nombre de connexions réussies. + | +
| + `ConnectionFailure` + | + ++ Compter + | + ++ Le nombre de connexions échouées. + | +
| + `SessionLaunchTime` + | + ++ Compter + | + ++ Le temps nécessaire pour lancer une session WorkSpaces. + | +
| + `InSessionLatency` + | + ++ Compter + | + ++ Le temps d’aller-retour entre le client WorkSpaces et le WorkSpace. + | +
| + `SessionDisconnect` + | + ++ Compter + | + ++ Le nombre de connexions qui ont été fermées, y compris les connexions initiées par l'utilisateur et celles qui ont échoué. + | +
| + `UserConnected` + | + ++ Compter + | + ++ Le nombre d'espaces de travail auxquels un utilisateur est connecté. + | +
| + `Stopped` + | + ++ Compter + | + ++ Le nombre d’espaces de travail arrêtés. + | +
| + `Maintenance` + | + ++ Compter + | + ++ Le nombre d'espaces de travail en cours de maintenance. + | +
| + `TrustedDeviceValidationAttempt` + | + ++ Compter + | + ++ Le nombre de tentatives de validation de la signature d'authentification de l'appareil. + | +
| + `TrustedDeviceValidationSuccess` + | + ++ Compter + | + ++ Le nombre de validations réussies de la signature d'authentification de l'appareil. + | +
| + `TrustedDeviceValidationFailure` + | + ++ Compter + | + ++ Nombre de validations de signature d'authentification de périphérique ayant échoué. + | +
| + `TrustedDeviceCertificateDaysBeforeExpiration` + | + ++ Compter + | + ++ Jours restants avant l'expiration du certificat racine associé au répertoire. + | +
| + métrique (min, max, moyenne, compte, somme) + | + ++ Unité + | + ++ Description + | +
|---|---|---|
| + `SessionAttempt` + | + ++ Compter + | + ++ Nombre de tentatives de session Web Amazon WorkSpaces. + | +
| + `SessionSuccess` + | + ++ Compter + | + ++ Nombre de sessions Web Amazon WorkSpaces démarrées avec succès. + | +
| + `SessionFailure` + | + ++ Compter + | + ++ Nombre de démarrages de sessions Web Amazon WorkSpaces ayant échoué. + | +
| + métrique + | + ++ Description + | +
|---|---|
| + `activeConnectionCount` + | + ++ Le nombre total de connexions TCP simultanées actives des clients vers l'équilibreur de charge et de l'équilibreur de charge vers la cible. + | +
| + `newConnectionCount` + | + ++ Le nombre total de nouvelles connexions TCP établies entre les clients et l'équilibreur de charge et entre l'équilibreur de charge et la cible. + | +
| + `rejectedConnectionCount` + | + ++ Le nombre de connexions qui ont été rejetées parce que l'équilibreur de charge avait atteint son nombre maximal de connexions. + | +
| + `processedBytes` + | + ++ Le nombre total d'octets traités par l'équilibreur de charge sur IPv4 et IPv6. + | +
| + `requestCount` + | + ++ Le nombre de requests traitées via IPv4 et IPv6. Les requêtes n’incrémentent cette métrique que lorsque le nœud d’équilibrage de charge a pu sélectionner une cible. Si une demande est rejetée avant qu'une cible ne soit choisie, elle n'est pas reflétée. + + Statistiques : la somme fournit la plus grande valeur. + | +
| + `rulesEvaluated` + | + ++ Le nombre de règles traitées par l'équilibreur de charge, compte tenu d'un taux de requêtes moyen sur une heure. + | +
| + `clientTlsNegotiationErrorCount` + | + ++ Nombre de connexions TLS initiées par le client qui n'ont pas établi de session avec l'équilibreur de charge. Les causes possibles incluent une incompatibilité de chiffrements ou de protocoles. + | +
| + `httpCodeElb5XXCount` + | + ++ Le nombre de codes d’erreur du serveur HTTP 5XX provenant de l’équilibreur de charge. Ce décompte n'inclut pas les codes de réponse générés par la cible. + | +
| + `httpCodeElb4XXCount` + | + ++ Le nombre de codes d’erreur client HTTP 4XX provenant de l’équilibreur de charge. Des erreurs client sont générées lorsque requests sont mal formulées ou incomplètes. Ces requests n'ont pas été reçues par la cible. + | +
| + `IpV6ProcessedBytes` + | + ++ Le nombre total d'octets traités par l'équilibreur de charge sur IPv6. + | +
| + `IpV6RequestCount` + | + ++ Le nombre de requests IPv6 reçues par l'équilibreur de charge. + | +
| + `lambdaTargetProcessedBytes` + | + ++ Le nombre total d'octets traités par l'équilibreur de charge pour requests et les réponses d'une fonction Lambda. + | +
| + métrique + | + ++ Description + | +
|---|---|
| + `requestCount` + | + ++ Le nombre moyen de requests que chaque cible d'un groupe cible reçoit. + + Statistiques : seule la somme est valide, ce qui représente la moyenne au lieu de la somme. + | +
| + `healthyHostCount` + | + ++ Le nombre de cibles considérées comme saines. + | +
| + `unHealthyHostCount` + | + ++ Le nombre de cibles considérées comme malsaines. + | +
| + `targetResponseTime` + | + ++ Le temps écoulé, en secondes, après que la demande quitte l'équilibreur de charge jusqu'à ce qu'une réponse de la cible soit reçue. + + Statistiques disponibles : + + * aws.applicationelb.target\_response\_time.p90 + * aws.applicationelb.target\_response\_time.p95 + * aws.applicationelb.target\_response\_time.p99 + | +
| + `httpCodeTarget2XXCount` + | + ++ Le nombre de codes de réponse HTTP `2XX` générés par la cible. Cela n’inclut aucun code de réponse généré par l’équilibreur de charge. + | +
| + `httpCodeTarget3XXCount` + | + ++ Le nombre de codes de réponse HTTP `3XX` générés par la cible. Cela n’inclut aucun code de réponse généré par l’équilibreur de charge. + | +
| + `httpCodeTarget4XXCount` + | + ++ Le nombre de codes de réponse HTTP `4XX` générés par la cible. Cela n’inclut aucun code de réponse généré par l’équilibreur de charge. + | +
| + `httpCodeTarget5XXCount` + | + ++ Le nombre de codes de réponse HTTP `5XX` générés par la cible. Cela n’inclut aucun code de réponse généré par l’équilibreur de charge. + | +
| + `lambdaInternalError` + | + ++ Le nombre de requests adressées à une fonction Lambda qui ont échoué en raison d'un problème interne à l'équilibreur de charge ou AWS Lambda. + | +
| + `lambdaUserError` + | + ++ Le nombre de requests adressées à une fonction Lambda qui ont échoué en raison d'un problème avec la fonction Lambda. + | +
| + métrique + | + ++ Description + | +
|---|---|
| + `activeFlowCount` + | + ++ Le nombre total de flux simultanés (ou connexions) des clients vers la cible. Cette métrique inclut les connexions dans les états `SYN_SENT` et `ESTABLISHED` . + + Les connexions TCP ne sont pas interrompues au niveau de l'équilibreur de charge, donc un client ouvrant une connexion TCP vers une cible compte comme un flux unique. + | +
| + `activeFlowCountTls` + | + ++ Le nombre total de flux TLS simultanés (ou de connexions) des clients vers la cible. Cette métrique inclut uniquement les connexions dans les états `ESTABLISHED` . + | +
| + `clientTlsNegotiationErrorCount` + | + ++ Nombre total de négociations TLS qui ont échoué lors de la négociation entre un client et un écouteur TLS. + | +
| + `consumedLcus` + | + ++ Le nombre d'unités de capacité d'équilibrage de charge (LCU) utilisées par votre équilibreur de charge. Vous payez pour le nombre de LCU que vous utilisez par heure. + | +
| + `newFlowCount` + | + ++ Le nombre total de nouveaux flux (ou connexions) établis entre les clients et la cible au cours de la période. + | +
| + `newFlowCountTls` + | + ++ Le nombre total de nouveaux flux TLS (ou connexions) établis entre les clients et la cible au cours de la période. + | +
| + `processedBytes` + | + ++ Le nombre total d'octets traités par l'équilibreur de charge, y compris les en-têtes TCP/IP. + | +
| + `processedBytesTls` + | + ++ Le nombre total d'octets traités par les écouteurs TLS. + | +
| + `targetTlsNegotiationErrorCount` + | + ++ Nombre total de négociations TLS qui ont échoué lors de la négociation entre un auditeur TLS et une cible. + | +
| + `tcpClientResetCount` + | + ++ Le nombre total de paquets de réinitialisation (RST) envoyés d'un client à une cible. Ces réinitialisations sont générées par le client et transmises par l'équilibreur de charge. + | +
| + `tcpElbResetCount` + | + ++ Le nombre total de paquets de réinitialisation (RST) générés par l'équilibreur de charge. + | +
| + `tcpTargetResetCount` + | + ++ Le nombre total de paquets de réinitialisation (RST) envoyés d'une cible à un client. Ces réinitialisations sont générées par la cible et transmises par l'équilibreur de charge. + | +
| + métrique + | + ++ Description + | +
|---|---|
| + `healthyHostCount` + | + ++ Le nombre de cibles considérées comme saines. + | +
| + `unHealthyHostCount` + | + ++ Le nombre de cibles considérées comme malsaines. + | +
| + métrique + | + ++ Description + | +
|---|---|
| + `4XXError` + | + ++ Le nombre d'erreurs côté client capturées + | +
| + `5XXError` + | + ++ Le nombre d’erreurs côté serveur capturées. + | +
| + `CacheHitCount` + | + ++ Le nombre de requests traitées à partir du cache API. + | +
| + `CacheMissCount` + | + ++ Le nombre de requests traitées depuis le backend lorsque la mise en cache de l'API est activée. + | +
| + `Count` + | + ++ Le nombre d'appels aux méthodes API. + | +
| + `IntegrationLatency` + | + ++ Le temps en millisecondes entre le moment où API Gateway relaie une requête au backend et le moment où elle reçoit une réponse du backend. + | +
| + `Latency` + | + ++ Le temps en millisecondes entre le moment où API Gateway reçoit une demande d'un client et le moment où elle renvoie une réponse au client. La latence inclut la latence d'intégration et d'autres frais généraux de la passerelle API. + | +
| + Dimensions + | + ++ Description + | +
|---|---|
| + `ApiName` + | + ++ Filtre les métriques API Gateway pour une API du nom d'API spécifié. + | +
| + `ApiName`, `Method`, `Resource`, `Stage` + | + ++ Filtre les métriques API Gateway pour une méthode API de l'API, de l'étape, de la ressource et de la méthode spécifiées. + | +
| + `ApiName`, `Stage` + | + ++ Filtre les métriques API Gateway pour une étape d'API de l'API et de l'étape spécifiées. + | +
| + métrique + | + ++ Description + | +
|---|---|
| + `4xx` + | + ++ Le nombre d’erreurs côté client capturées au cours d’une période donnée. + | +
| + `5xx` + | + ++ Le nombre d'erreurs côté serveur capturées sur une période donnée. + | +
| + `Count` + | + ++ Le nombre total requests API sur une période donnée. + | +
| + `IntegrationLatency` + | + ++ Le temps entre le moment où API Gateway relaie une demande au backend et le moment où elle reçoit une réponse du backend. + | +
| + `Latency` + | + ++ Le temps entre le moment où API Gateway reçoit une demande d'un client et le moment où elle renvoie une réponse au client. La latence inclut la latence d'intégration et d'autres frais généraux de la passerelle API. + | +
| + `DataProcessed` + | + ++ La quantité de données traitées en octets. + | +
| + Dimensions + | + ++ Description + | +
|---|---|
| + `ApiId` + | + ++ filtre les métriques API Gateway pour une API avec l'ID d'API spécifié. + | +
| + `ApiId`, `Stage` + | + ++ Filtre les métriques API Gateway pour une étape d'API avec l'ID d'API et l'ID d'étape spécifiés. + | +
| + `ApiId`, `Stage`,`Route` + | + ++ Filtre les métriques API Gateway pour une méthode API avec l'ID d'API, l'ID d'étape et l'ID d'itinéraire spécifiés. + | +
| + métrique (min, max, moyenne) + | + ++ Unité + | + ++ Description + | +
|---|---|---|
| + `2xxStatusResponses` + | + ++ compter + | + ++ Nombre de requests réussies au service + | +
| + `4xxStatusResponses` + | + ++ compter + | + ++ Nombre de requests échouées au service + | +
| + `ActiveInstances` + | + ++ compter + | + ++ Nombre d'instances actives + | +
| + `CPUUtilization` + | + ++ pourcentage + | + ++ Chargement du processeur de l'instance + | +
| + `MemoryUtilization` + | + ++ pourcentage + | + ++ Utilisation de la mémoire d'instance + | +
| + `RequestLatency` + | + ++ MS + | + ++ Combien de temps prend une demande + | +
| + `Requests` + | + ++ compter + | + ++ Nombre total de requests + | +
| + entité + | + ++ Type d'événement + | + ++ Fournisseur + | +
|---|---|---|
| + API + | + ++ `AwsAppSyncApiSample` + | + ++ `AwsAppSyncApi` + | +
| + métrique + | + ++ Unité + | + ++ Description + | +
|---|---|---|
| + `4XXError` + | + ++ Compter + | + ++ Le nombre d'erreurs capturées à la suite de requests non valides en raison d' configuration client incorrecte. En règle générale, ces erreurs se produisent n’importe où en dehors de l’exécution de GraphQL. Par exemple, il peut s'agir d'une charge utile JSON incorrecte ou d'une requête incorrecte dans la demande, lorsque le service est limité, ou même d'une mauvaise configuration potentielle des paramètres d'authentification. + | +
| + `5XXError` + | + ++ Compter + | + ++ Erreurs rencontrées lors de l'exécution d'une requête GraphQL. Par exemple, cela peut se produire lorsqu'une demande de requête est lancée pour un schéma vide ou incorrect, si l'ID du pool d'utilisateurs Amazon Cognito ou la région AWS n'est pas valide. Alternativement, cela peut également se produire si AWS AppSync rencontre un problème lors de l'exécution d'une requête. + | +
| + `Latency` + | + ++ Millisecondes + | + ++ Le temps entre le moment où AWS AppSync reçoit une demande d'un client et le moment où il renvoie une réponse au client. Cela n’inclut pas la latence du réseau rencontrée pour qu’une réponse atteigne les périphériques finaux. + | +
| + entité + | + ++ Type d'événement + | + ++ Fournisseur + | +
|---|---|---|
| + Groupe de travail + | + ++ `AwsAthenaWorkGroupSample` + | + ++ `AwsAthenaWorkGroup` + | +
| + métrique + | + ++ Unité + | + ++ Description + | +
|---|---|---|
| + `ProcessedBytes` + | + ++ Octets + | + ++ La quantité de données en mégaoctets qu'Athena a analysées par requête. Pour les requêtes qui ont été annulées (soit par l'utilisateur, soit automatiquement, si elles ont atteint la limite), cela inclut la quantité de données analysées avant l'heure d'annulation. + | +
| + `TotalExecutionTime` + | + ++ Millisecondes + | + ++ Le temps en secondes nécessaire à Athena pour exécuter la requête. + | +
| + métrique + | + ++ Description + | +
|---|---|
| + `groupDesiredCapacity` + | + ++ Le nombre d'instances que le groupe de mise à l'échelle automatique tente de maintenir. + | +
| + `groupInServiceInstances` + | + ++ Le nombre d'instances exécutées dans le cadre du groupe de mise à l'échelle automatique. + | +
| + `groupMaxSize` + | + ++ La taille maximale du groupe de mise à l'échelle automatique. + | +
| + `groupMinSize` + | + ++ La taille minimale du groupe de mise à l'échelle automatique. + | +
| + `groupPendingInstances` + | + ++ Le nombre d'instances en attente et pas encore en service. + | +
| + `groupStandbyInstances` + | + ++ Le nombre d'instances qui sont dans un état « veille ». + | +
| + `groupTerminatingInstances` + | + ++ Le nombre d'instances en cours de terminaison. + | +
| + `groupTotalInstances` + | + ++ Le nombre total d'instances dans le groupe Auto Scaling. + | +
+
+
+
+| + paramètres + | + ++ Taper + | + ++ Description + | +
|---|---|---|
| + `$userID` + | + ++ `string` + | + ++ Requis. Définit l'ID utilisateur. + | +
| + paramètres + | + ++ Taper + | + ++ Description + | +
|---|---|---|
| + `userID` + | + ++ `NSString` + | + ++ Requis. L'ID utilisateur à associer à la session en cours. + | +
| + paramètres + | + ++ Taper + | + ++ Description + | +
|---|---|---|
| + `options` + | + ++ `{ userId: string; }` + | + ++ Requis. Un objet qui contient l'ID utilisateur. + | +
| + `userId` + | + ++ `string` + | + ++ Requis. L'ID utilisateur à associer à la session en cours. + | +
| + paramètres + | + ++ Taper + | + ++ Description + | +
|---|---|---|
| + `userID` + | + ++ `string` + | + ++ Requis. L'ID utilisateur à associer à la session en cours. + | +
| + paramètres + | + ++ Taper + | + ++ Description + | +
|---|---|---|
| + `userID` + | + ++ `string` + | + ++ Requis. L'ID utilisateur à associer à la session en cours. + | +
| + paramètres + | + ++ Taper + | + ++ Description + | +
|---|---|---|
| + `userID` + | + ++ `string` + | + ++ Requis. L'ID utilisateur à associer à la session en cours. + | +
| + paramètres + | + ++ Taper + | + ++ Description + | +
|---|---|---|
| + `userID` + | + ++ `string` + | + ++ Requis. L'ID utilisateur à associer à la session en cours. + | +
| + paramètres + | + ++ Taper + | + ++ Description + | +
|---|---|---|
| + `userID` + | + ++ `string` + | + ++ Requis. L'ID utilisateur à associer à la session en cours. + | +
| + paramètres + | + ++ Taper + | + ++ Description + | +
|---|---|---|
| + `userID` + | + ++ `FString` + | + ++ Requis. L'ID utilisateur à associer à la session en cours. + | +
| + paramètres + | + ++ Taper + | + ++ Description + | +
|---|---|---|
| + `userID` + | + ++ `string` + | + ++ Requis. L'ID utilisateur à associer à la session en cours. + | +
+
+
+
+Consider the following when exporting a chart as CSV:
+
+* Les données sont toujours exportées en heure UTC
+* L'exportation ne prend pas en charge les fonctions d'agrégation telles que `average()`
+* L'exportation ne prend pas en charge la clause `COMPARE_WITH`
+* Dans certains scénarios, l'UI peut effectuer un formatage supplémentaire des données qui ne sont pas répliquées dans le fichier CSV exporté, ce qui peut entraîner de petites divergences (comme le rendu de -1.1E-17 sous la forme 0 dans l'UI mais pas dans le fichier CSV)
+* Vous ne pouvez pas exporter les résultats d'une requête inter-comptes.
+
+## requête et exploration des graphiques [#explore-chart-data]
+
+Pour plus de détails sur ce que vous pouvez faire avec les graphiques, voir [Options d'interrogation et de création de graphiques](/docs/new-relic-solutions/new-relic-one/ui-data/basic-ui-features/#data-analysis).
\ No newline at end of file
diff --git a/src/i18n/content/fr/docs/query-your-data/explore-query-data/dashboards/introduction-dashboards.mdx b/src/i18n/content/fr/docs/query-your-data/explore-query-data/dashboards/introduction-dashboards.mdx
new file mode 100644
index 00000000000..2b344d969cc
--- /dev/null
+++ b/src/i18n/content/fr/docs/query-your-data/explore-query-data/dashboards/introduction-dashboards.mdx
@@ -0,0 +1,168 @@
+---
+title: Créez des visualisations de données personnalisées avec un dashboard
+tags:
+ - Query your data
+ - Explore and query data
+ - Dashboards
+metaDescription: Introduction to New Relic dashboards. Explore and correlate your data with customized visualizations.
+freshnessValidatedDate: never
+translationType: machine
+---
+
+Grâce à notre UI, vous pouvez créer et partager des graphiques et des visualisations personnalisés et conviviaux. Accédez à notre dashboard pour collecter et représenter graphiquement les données spécifiques que vous souhaitez voir, de la manière dont vous souhaitez les voir, depuis n'importe où sur notre plateforme.
+
+## Pourquoi c'est important [#dashboards-features]
+
+Avec notre dashboard, vous pouvez personnaliser et comprendre les données que vous collectez. Explorez vos données et corrélez les sources connectées avec des graphiques et apprenez rapidement l'état de votre système et de vos applications pour un dépannage plus rapide et plus efficace.
+
+Utilisez le dashboard pour :
+
+* Générez des informations détaillées avec des visualisations interactives personnalisées à haute densité avec une UI cohérente.
+* Cartographiez tous les événements et attributs de partout sur notre plateforme. Pour plus d'informations, voir [Collecte de données](/docs/data-apis/understand-data/new-relic-data-types/).
+* [Ajoutez des attributs personnalisés](/docs/data-apis/custom-data/custom-events/apm-report-custom-events-attributes/#steps) ou [envoyez des types d'événements personnalisés](/docs/data-apis/ingest-apis/event-api/introduction-event-api/#workflow) à la plupart des événements afin de mieux comprendre votre entreprise et de voir des détails spécifiques sur la façon dont vos clients interagissent avec votre plateforme, tels que les pages vues, les transactions de l'hôte, etc.
+* [Gérez facilement vos graphiques et dashboards](#get-started) à l'aide de nos menus CRUD à accès rapide et de nos options d'édition.
+* Explorez et contextualisez les données avec [des info-bulles avancées et des fonctions de zoom](#key-visual-tools) pour monitorer ce que fait votre système en temps réel.
+* Recherchez dans votre dashboard des attributs et des mesures.
+* [Signalez des données personnalisées](/docs/data-apis/custom-data/get-custom-data-from-any-source/) à New Relic et à votre dashboard à partir de n'importe quelle source.
+* Share dashboards with stakeholders outside your New Relic organization via [publicly accessible live dashboard URLs](/docs/query-your-data/explore-query-data/dashboards/share-charts-dashboards-externally/#dashboard).
+
+## Démarrer avec les dashboards [#get-started]
+
+Allez à 
+
+
+
+ 
+
+ Vous pouvez également
+
+
+
+ Depuis l'index dashboard, il existe l'option [
+
+ Depuis l'index dashboard, il existe l'option [
+
+ Cette option vous permet :
+
+ * Pour changer le nom du dashboard. [Les noms sont consultables](/docs/query-your-data/explore-query-data/dashboards/introduction-dashboards/#dashboards-search), nous vous recommandons donc de lui donner un nom significatif qui vous aidera à localiser facilement votre dashboard .
+ * Pour modifier les [autorisations dudashboard](/docs/query-your-data/explore-query-data/dashboards/introduction-dashboards/#dashboards-permissions).
+
+ Dans le menu des paramètres, vous pouvez également voir quand le dashboard a été créé et le compte auquel il appartient. Ces valeurs ne peuvent pas être modifiées.
+
+ 
+ 
+ 
+
+
+
+
+
+Le taux de rafraîchissement dépend de la durée de la fenêtre temporelle que vous visualisez. Pour plus d'informations et d'exemples, voir [Intervalles d'actualisation des graphiques](/docs/insights/use-insights-ui/manage-dashboards/insights-chart-refresh-intervals).
+
+Pour modifier la plage horaire :
+
+* Sélectionnez l'une des options disponibles dans le menu déroulant (allant du dernier `5 minutes` au dernier `6 months`).
+* Personnalisez la plage horaire avec des horaires de début et de fin spécifiques à l'aide du menu personnalisé.
+
+Si vous ne souhaitez pas modifier l'intervalle de temps d'un graphique lorsque vous utilisez le sélecteur d'intervalle de temps :
+
+1. Cliquez sur le 
+
+
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ * Dans les tableaux :
+
+ 1. Modifiez le graphique et développez le menu 
+ | + | + .NET 프레임워크에 내장된 `System.Data.ODBC` 지우스페이스를 사용하세요. + + * 현재 지원되는 모든 .NET 프레임워크 버전에서 사용할 수 있습니다. + * 현재 Microsoft에서 지원하는 모든 버전의 .NET 프레임워크는 호환성이 검증되었습니다. + | ||
| + | + * 최근 검증된 호환 버전: 4.0.40 + * 알려진 비호환 버전: 4.0.44 이상 + | ||
| - 10.23.0 + 10.23.0 (`InvokeModelAsync`) 10.37.0 (`InvokeModelAsync`, `ConverseAsync`) + | + ++ 3.7.412.13 + | +||
| + 오픈AI + | + ++ 2.0.0 + | + ++ 10.37.0 (`CompleteChat`, `CompleteChatAsync`) + | + ++ 2.1.0 + | +
| + Azure.AI.오픈AI + | + ++ 2.0.0 + | + ++ 10.37.0 (`CompleteChat`, `CompleteChatAsync`) | - 3.7.412.4 + 2.1.0 | - 5.3.15 + 5.4.0 | @@ -1741,7 +1814,7 @@ translationType: machine- 9.0.1 + 9.0.2 | @@ -1859,7 +1932,7 @@ translationType: machine * 최소 지원 버전: 3.7.0 - * 최신 검증된 호환 버전: 3.7.400.86 + * 최신 검증된 호환 버전: 3.7.400.95 diff --git a/src/i18n/content/kr/docs/apm/agents/nodejs-agent/getting-started/compatibility-requirements-nodejs-agent.mdx b/src/i18n/content/kr/docs/apm/agents/nodejs-agent/getting-started/compatibility-requirements-nodejs-agent.mdx index 7610dbb177e..c95ccc7f2d8 100644 --- a/src/i18n/content/kr/docs/apm/agents/nodejs-agent/getting-started/compatibility-requirements-nodejs-agent.mdx +++ b/src/i18n/content/kr/docs/apm/agents/nodejs-agent/getting-started/compatibility-requirements-nodejs-agent.mdx @@ -253,23 +253,23 @@ Node.js 에이전트는 [npm(Node Package Manager) 저장소](https://npmjs.org/ | 패키지 이름 | 지원되는 최소 버전 | 최신 지원 버전 | \*에서 소개됨 | | --------------------------------- | ---------- | -------- | -------------------------------------- | -| `@apollo/gateway` | 2.3.0 | 2.9.3 | `@newrelic/apollo-server-plugin@1.0.0` | +| `@apollo/gateway` | 2.3.0 | 2.10.0 | `@newrelic/apollo-server-plugin@1.0.0` | | `@apollo/server` | 4.0.0 | 4.11.3 | `@newrelic/apollo-server-plugin@2.1.0` | -| `@aws-sdk/client-bedrock-runtime` | 3.474.0 | 3.744.0 | 11.13.0 | -| `@aws-sdk/client-dynamodb` | 3.0.0 | 3.744.0 | 8.7.1 | -| `@aws-sdk/client-sns` | 3.0.0 | 3.744.0 | 8.7.1 | -| `@aws-sdk/client-sqs` | 3.0.0 | 3.744.0 | 8.7.1 | -| `@aws-sdk/lib-dynamodb` | 3.377.0 | 3.744.0 | 8.7.1 | +| `@aws-sdk/client-bedrock-runtime` | 3.474.0 | 3.750.0 | 11.13.0 | +| `@aws-sdk/client-dynamodb` | 3.0.0 | 3.750.0 | 8.7.1 | +| `@aws-sdk/client-sns` | 3.0.0 | 3.750.0 | 8.7.1 | +| `@aws-sdk/client-sqs` | 3.0.0 | 3.750.0 | 8.7.1 | +| `@aws-sdk/lib-dynamodb` | 3.377.0 | 3.750.0 | 8.7.1 | | `@aws-sdk/smithy-client` | 3.47.0 | 3.374.0 | 8.7.1 | | `@elastic/elasticsearch` | 7.16.0 | 8.17.0 | 11.9.0 | | `@grpc/grpc-js` | 1.4.0 | 1.12.6 | 8.17.0 | | `@hapi/hapi` | 20.1.2 | 21.3.12 | 9.0.0 | | `@koa/router` | 11.0.2 | 13.1.0 | 3.2.0 | | `@langchain/core` | 0.1.17 | 0.3.40 | 11.13.0 | -| `@nestjs/cli` | 9.0.0 | 11.0.2 | 10.1.0 | +| `@nestjs/cli` | 9.0.0 | 11.0.4 | 10.1.0 | | `@opensearch-project/opensearch` | 2.1.0 | 3.3.0 | 12.10.0 | | `@prisma/client` | 5.0.0 | 6.3.1 | 11.0.0 | -| `@smithy/smithy-client` | 2.0.0 | 4.1.3 | 11.0.0 | +| `@smithy/smithy-client` | 2.0.0 | 4.1.5 | 11.0.0 | | `amqplib` | 0.5.0 | 0.10.5 | 2.0.0 | | `apollo-server` | 3.0.0 | 3.13.0 | `@newrelic/apollo-server-plugin@1.0.0` | | `apollo-server-express` | 3.0.0 | 3.13.0 | `@newrelic/apollo-server-plugin@1.0.0` | @@ -291,9 +291,9 @@ Node.js 에이전트는 [npm(Node Package Manager) 저장소](https://npmjs.org/ | `mysql` | 2.2.0 | 2.18.1 | 1.32.0 | | `mysql2` | 2.0.0 | 3.12.0 | 1.32.0 | | `next` | 13.4.19 | 15.1.7 | 12.0.0 | -| `openai` | 4.0.0 | 4.84.0 | 11.13.0 | -| `pg` | 8.2.0 | 8.13.2 | 9.0.0 | -| `pg-native` | 3.0.0 | 3.2.1 | 9.0.0 | +| `openai` | 4.0.0 | 4.85.1 | 11.13.0 | +| `pg` | 8.2.0 | 8.13.3 | 9.0.0 | +| `pg-native` | 3.0.0 | 3.2.2 | 9.0.0 | | `pino` | 7.0.0 | 9.6.0 | 8.11.0 | | `q` | 1.3.0 | 1.5.1 | 1.26.2 | | `redis` | 3.1.0 | 4.7.0 | 1.31.0 | diff --git a/src/i18n/content/kr/docs/opentelemetry/best-practices/opentelemetry-best-practices-resources.mdx b/src/i18n/content/kr/docs/opentelemetry/best-practices/opentelemetry-best-practices-resources.mdx index e0239c35c7b..baff924a266 100644 --- a/src/i18n/content/kr/docs/opentelemetry/best-practices/opentelemetry-best-practices-resources.mdx +++ b/src/i18n/content/kr/docs/opentelemetry/best-practices/opentelemetry-best-practices-resources.mdx @@ -100,56 +100,172 @@ Redis 서버는 수집기 [Redis 수신기](https://github.com/open-telemetry/op 뉴렐릭은 OpenTelemetry 에서 소스로 제공되는 엔터티 간의 관계를 지원합니다. 이러한 관계는 적절한 관계 기준이 충족되면 자동으로 합성됩니다. 다음은 현재 지원되는 관계와 필수 기준입니다. -### 호스트에 대한 서비스 [#service-to-host] +### OpenTelemetry Collector를 사용한 인프라 관계에 대한 서비스 [#service-to-infra-otel-collector] + +OpenTelemetry Collector를 사용하면 [인프라를 모니터링](/docs/opentelemetry/get-started/collector-infra-monitoring/opentelemetry-collector-infra-intro) 할 수 있습니다. 에서 생성된 권한화된 서비스 간에는 부분 관계가 지원됩니다.OpenTelemetry OpenTelemetry Collector + +서비스와 관련된 지원 관계는 다음과 같습니다. + +* [호스트](#service-to-host) +* [컨테이너](#service-to-container) + +#### 호스트 [#service-to-host] 서비스와 호스트 엔터티 간의 관계에서는 서비스에 `host.id` 리소스 속성이 포함되어야 하고 서비스가 실행 중인 호스트의 `host.id` 과 일치해야 합니다. -### Amazon CloudWatch Metric Streams +#### 컨테이너 [#service-to-container] + +서비스와 컨테이너 엔티티 간의 관계에는 서비스에 `container.id` 리소스 속성이 포함되어야 하며 해당 서비스가 실행 중인 컨테이너의 `container.id` 과 일치해야 합니다. + +### 뉴렐릭 인프라 에이전트를 사용한 서비스-하위 관계 [#service-to-infra-nr-infra-agent] + +[뉴렐릭 인프라 에이전트를](/docs/infrastructure/choose-infra-install-method) 사용하여 클러스터를 모니터링할 수 있습니다. OpenTelemetry 권한화된 서비스와 뉴렐릭 인프라 에이전트에서 생성된 부분 관계가 지원됩니다. + +이러한 관계가 작동하려면 서비스에서 내보낸 텔레메트리를 배포 에이전트가 내보낸 텔레메트리와 상호 연관시킬 수 있도록 구성해야 합니다. 이렇게 하려면 서비스의 텔레메트리에 서비스가 실행되고 있는 호스트, 컨테이너 등을 식별하는 리소스 속성을 포함해야 합니다. 이 작업은 일반적으로 해당 언어에 대한 OpenTelemetry SDK에서 제공하는 [리소스 감지기를](https://opentelemetry.io/docs/concepts/resources/#resource-detectors) 구성하거나 OpenTelemetry Collector의 [리소스 감지 프로세서를](https://github.com/open-telemetry/opentelemetry-collector-contrib/blob/main/processor/resourcedetectionprocessor/README.md) 사용하는 것만큼 쉽습니다. -AWS 에서 호스팅되는 뷰는 뉴렐릭이 [Amazon CloudWatch Metric Streams](/install/aws-cloudwatch/) 와 통합되어 모니터링될 수 있습니다. 이는 인프라를 모니터링하기 위한 OpenTelemetry 솔루션이 아닙니다. 그러나 뉴렐릭은 Amazon 사용하여 렌더링된 서비스와 리소스 모니터 간의 다양한 관계를 OpenTelemetry CloudWatch Metric Streams 지원합니다. +서비스와 관련된 지원 관계는 다음과 같습니다. + +* [호스트](#service-to-infra-nr-infra-agent-hosts) +* [컨테이너](#service-to-infra-nr-infra-agent-containers) + +#### 블루렐릭 인프라 에이전트를 사용한 호스트 모니터 [#service-to-infra-nr-infra-agent-hosts] + +OpenTelemetry 위임된 서비스와 뉴렐릭 인프라 에이전트에서 생성된 호스트 분리 간의 호스트 관계에는 다음 두 가지가 필요합니다. + +* `host.id` 리소스 속성은 서비스의 스프레드시트에 있어야 합니다. +* `host.id` 은 인프라 에이전트에서 파생된 [호스트의 ID](#service-to-infra-nr-infra-derive-host-identity) 와 상관 관계가 있어야 합니다. + +##### 호스트 정체성 도출 [#service-to-infra-nr-infra-derive-host-identity]
| + 측정, 관측을 지원 + | + ++ AWS 제품 + | +
|---|---|
| + + | + [다이나모DB](/docs/infrastructure/amazon-integrations/aws-integrations-list/aws-dynamodb-monitoring-integration) + | +
| + ✅ + | + ++ [엘라스티캐시](/docs/infrastructure/amazon-integrations/aws-integrations-list/aws-elasticache-monitoring-integration) + | +
| + ✅ + | + ++ [ElasticSearch](/docs/infrastructure/host-integrations/host-integrations-list/elasticsearch/elasticsearch-integration) + | +
| + + | + [키네시스 데이터 파이어호스](/docs/infrastructure/amazon-integrations/aws-integrations-list/aws-kinesis-data-firehose-monitoring-integration) + | +
| + + | + [키네시스 데이터 스트림](/docs/infrastructure/amazon-integrations/aws-integrations-list/aws-kinesis-data-streams-monitoring-integration) + | +
| + + | + [람다](/docs/infrastructure/amazon-integrations/aws-integrations-list/aws-lambda-monitoring-integration) + | +
| + ✅ + | + ++ [엠.엠.](/docs/infrastructure/amazon-integrations/aws-integrations-list/aws-mq-integration) + | +
| + ✅ + | + ++ [엠에스케이(MSK)](/docs/infrastructure/amazon-integrations/aws-integrations-list/aws-managed-kafka-msk-integration) + | +
| + + | + [SQS](/docs/infrastructure/amazon-integrations/aws-integrations-list/amazon-sqs-monitoring-integration) + | +
+
+
-
-
diff --git a/src/i18n/content/pt/docs/alerts/incident-management/response-intelligence-ai.mdx b/src/i18n/content/pt/docs/alerts/incident-management/response-intelligence-ai.mdx
new file mode 100644
index 00000000000..7f11eca7247
--- /dev/null
+++ b/src/i18n/content/pt/docs/alerts/incident-management/response-intelligence-ai.mdx
@@ -0,0 +1,63 @@
+---
+title: Inteligência de resposta com New Relic AI
+metaDescription: Learn to reduce the mean time to resolve issues and incidents by using New Relic AI with response intelligence.
+freshnessValidatedDate: never
+translationType: machine
+---
+
+
+
+A página de problemas com tecnologia de IA fornece um resumo conciso que inclui a entidade afetada, a gravidade do problema, uma explicação da condição do alerta e detalhes adicionais para auxiliar na depuração. Além disso, a página do problema inclui uma nova aba "visão geral" com três widgets que abordam as perguntas mais críticas que os socorristas fazem ao lidar com um problema.
+
+
+
+**O que é impactado?**Os socorristas precisam avaliar o "raio de explosão" para determinar a gravidade de um problema e decidir os próximos passos. Este widget fornece uma visão geral da entidade afetada juntamente com o impacto do aplicativo ou serviço no usuário final. + +**O que aconteceu anteriormente?**
Muitos problemas de TI tendem a ocorrer novamente. Saber se um problema já aconteceu antes, por que ocorreu e como foi resolvido pode economizar um tempo valioso dos socorristas durante um incidente. Para dar suporte a isso, os clientes podem usar o widget para vincular seus documentos retrospectivos ou post-mortem existentes. Ao aproveitar a geração aumentada de recuperação (RAG), a plataforma New Relic AI indexará e armazenará essas informações para referência contextual futura. Após a configuração, os socorristas verão um resumo de problemas anteriores semelhantes, juntamente com links para os documentos retrospectivos para análise detalhada. + +**O que verificar?**
Os socorristas geralmente precisam de orientação contextual sobre ações imediatas para mitigar um problema. Este widget fornece etapas personalizadas para ajudar a restaurar rapidamente os serviços aos níveis operacionais normais. Além disso, a aba Causas potenciais identifica causas prováveis por meio de análise causal, abrangendo uma gama de possíveis problemas de anomalia e desempenho. Para mais informações, consulte análise casual. + +## Análise causal + +O mecanismo de análise causal identifica possíveis sintomas que podem ter acionado um evento de alerta e sugere ações imediatas de mitigação para lidar com eles. + +Considere um cenário em que um aplicativo PHP encontra um vazamento de memória, levando a uma falha nas taxas de transferência SLI e acionando um alerta. Nosso mecanismo investiga movendo-se do nível de serviço para o aplicativo APM e depois para o contêiner de infraestrutura para detectar o sintoma. + +Como funciona o motor? O mecanismo de análise causal usa categorias de análise distintas, como implantação de evento, limites de recursos de infraestrutura e muito mais. Cada categoria é projetada para abordar diversas fontes potenciais de problemas de anomalia e desempenho. Essas categorias se concentram em tipos de dados e métricas específicos, permitindo análises precisas e identificação mais precisa de relações causais. + +No momento, New Relic suporta apenas análise causal para entidade APM . + +
+
+### Ações e visualizações de mitigação
+
+Para cada causa potencial identificada, o mecanismo oferece ações de mitigação personalizadas que orientam o usuário nas etapas necessárias para restaurar rapidamente os serviços e a entidade aos seus estados operacionais normais. Reconhecemos que muitos dos nossos clientes normalmente contam com NRQL para analisar consultas significativas, por isso fornecemos recursos visuais relevantes junto com a consulta subjacente para cada causa.
+
+### Análise gerada pela New Relic AI
+
+Em alguns cenários, nosso mecanismo causal pode não identificar uma causa orientada por algoritmo. No entanto, temos insights que, quando combinados com LLMs, podem oferecer etapas acionáveis. Para acessar esse recurso, você deve ter o direito ao New Relic AI habilitado.
\ No newline at end of file
diff --git a/src/i18n/content/pt/docs/browser/browser-monitoring/browser-pro-features/upload-source-maps-un-minify-js-errors.mdx b/src/i18n/content/pt/docs/browser/browser-monitoring/browser-pro-features/upload-source-maps-un-minify-js-errors.mdx
index a1ace5fc283..7ac7026b39a 100644
--- a/src/i18n/content/pt/docs/browser/browser-monitoring/browser-pro-features/upload-source-maps-un-minify-js-errors.mdx
+++ b/src/i18n/content/pt/docs/browser/browser-monitoring/browser-pro-features/upload-source-maps-un-minify-js-errors.mdx
@@ -5,9 +5,9 @@ freshnessValidatedDate: never
translationType: machine
---
-Nosso [