` with a valid AWS region, such as `us-east-1`.
+
+3. Redirija la función manejadora
+
+ - Establezca el manejador de su función a `datadog_lambda.handler.handler`.
+ - Establezca la variable de entorno `DD_LAMBDA_HANDLER` a su manejador original, por ejemplo, `myfunc.handler`.
+
+ **Nota**: Si está utilizando una herramienta de seguridad o monitoreo de terceros que es incompatible con la redirección del manejador de Datadog, puede [Aplique el envoltorio de Datadog en el código de su función][6] en su lugar.
+
+4. Configure el sitio de Datadog, la clave de API y el rastreo
+
+ - Establezca la variable de entorno `DD_SITE` a {{< region-param key="dd_site" code="true" >}} (Asegúrese de que el SITIO correcto esté seleccionado a la derecha).
+ - Establezca la variable de entorno `DD_API_KEY_SECRET_ARN` con el ARN del secreto de AWS donde su [clave de API de Datadog][7] está almacenada de forma segura. La clave necesita ser almacenada como una cadena de texto sin formato, en lugar de estar dentro de un blob JSON. Se requiere el permiso `secretsmanager:GetSecretValue`. Para pruebas rápidas, puede usar `DD_API_KEY` en su lugar y establecer la clave de API de Datadog en texto sin formato.
+ - Establezca la variable de entorno `DD_TRACE_ENABLED` a `true`.
+
+5. (Solo AWS Chalice) Registre el middleware
+
+ Si está utilizando [AWS Chalice][8], debe instalar `datadog-lambda` usando `pip`, y registrar `datadog_lambda_wrapper` como un [middleware][9] en su `app.py`:
+
+ ```python
+ from chalice import Chalice, ConvertToMiddleware
+ from datadog_lambda.wrapper import datadog_lambda_wrapper
+
+ app = Chalice(app_name='hello-chalice')
+
+ app.register_middleware(ConvertToMiddleware(datadog_lambda_wrapper))
+
+ @app.route('/')
+ def index():
+ return {'hello': 'world'}
+ ```
+
+[1]: https://docs.aws.amazon.com/lambda/latest/dg/configuration-layers.html
+[2]: https://github.com/UnitedIncome/serverless-python-requirements#cross-compiling
+[3]: https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-cli-command-reference-sam-build.html
+[4]: https://docs.aws.amazon.com/lambda/latest/dg/python-package.html#python-package-dependencies
+[5]: https://pypi.org/project/datadog-lambda/
+[6]: https://docs.datadoghq.com/es/serverless/guide/handler_wrapper
+[7]: https://app.datadoghq.com/organization-settings/api-keys
+[8]: https://aws.github.io/chalice/
+[9]: https://aws.github.io/chalice/topics/middleware.html
+{{% /tab %}}
+{{< /tabs >}}
+
+{{% svl-tracing-env %}}
+
+## Cumplimiento de FIPS {#fips-compliance}
+
+{{% svl-lambda-fips %}}
+
+## AWS Lambda y VPC {#aws-lambda-and-vpc}
+
+{{% svl-lambda-vpc %}}
+
+## ¿Qué sigue? {#whats-next}
+
+- Agregue etiquetas personalizadas a su telemetría utilizando la variable de entorno `DD_TAGS`
+- Configure [la recolección de payloads][12] para capturar los payloads de solicitud y respuesta JSON de sus funciones
+- Si está utilizando la Lambda Extension de Datadog, desactive los registros de Lambda del Forwarder de Datadog
+- Consulte [Configurar Monitoreo Serverless para AWS Lambda][3] para más capacidades
+
+### Seguimiento de la lógica de negocio personalizada {#monitor-custom-business-logic}
+
+Para el seguimiento de su lógica de negocio personalizada, envíe una métrica o un span personalizado utilizando el código de muestra a continuación. Para opciones adicionales, consulte [el envío de métricas personalizadas para aplicaciones serverless][4] y la guía de APM para [instrumentación personalizada][5].
+
+```python
+import time
+from ddtrace import tracer
+from datadog_lambda.metric import lambda_metric
+
+def lambda_handler(event, context):
+ # add custom tags to the lambda function span,
+ # does NOT work when X-Ray tracing is enabled
+ current_span = tracer.current_span()
+ if current_span:
+ current_span.set_tag('customer.id', '123456')
+
+ # submit a custom span
+ with tracer.trace("hello.world"):
+ print('Hello, World!')
+
+ # submit a custom metric
+ lambda_metric(
+ metric_name='coffee_house.order_value',
+ value=12.45,
+ tags=['product:latte', 'order:online']
+ )
+
+ return {
+ 'statusCode': 200,
+ 'body': get_message()
+ }
+
+# trace a function
+@tracer.wrap()
+def get_message():
+ return 'Hello from serverless!'
+```
+
+## Lectura Adicional {#further-reading}
+
+{{< partial name="whats-next/whats-next.html" >}}
+
+[1]: https://app.datadoghq.com/functions
+[2]: /es/serverless/guide/troubleshoot_serverless_monitoring/
+[3]: /es/serverless/configuration/
+[4]: /es/serverless/aws_lambda/metrics/?code-lang=python
+[5]: /es/tracing/custom_instrumentation/python/
+[6]: /es/security/application_security/serverless/
+[7]: https://github.com/DataDog/datadog-lambda-extension
+[8]: https://github.com/DataDog/datadog-lambda-extension/issues
+[9]: /es/serverless/aws_lambda/distributed_tracing/#span-auto-linking
+[10]: https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Streams.html
+[11]: /es/serverless/aws_lambda/remote_instrumentation
+[12]: /es/serverless/aws_lambda/configuration?tab=datadogcli#collect-the-request-and-response-payloads
\ No newline at end of file
diff --git a/content/es/tracing/code_origin/_index.md b/content/es/tracing/code_origin/_index.md
index cb0e275acbd..1182ca6ed90 100644
--- a/content/es/tracing/code_origin/_index.md
+++ b/content/es/tracing/code_origin/_index.md
@@ -2,135 +2,168 @@
aliases:
- /es/tracing/code_origins/
- /es/tracing/guide/code_origins/
-description: Más información sobre cómo utilizar Code Origin para entender dónde
- se originan tus tramos en tu código base
+description: Aprende a usar Code Origin para entender de dónde provienen tus tramos
+ en tu base de código.
further_reading:
- link: /tracing/glossary/
tag: Documentación
- text: Más información sobre términos y conceptos de APM
+ text: Aprende sobre términos y conceptos de APM
- link: /tracing/trace_collection/
tag: Documentación
- text: Aprende a configurar APM tracing con su aplicación
+ text: Aprende a configurar el trazado de APM con tu aplicación
- link: /tracing/services/service_page/
tag: Documentación
- text: Más información sobre servicios en Datadog
+ text: Aprende más sobre los servicios en Datadog
- link: /tracing/services/resource_page/
tag: Documentación
- text: Profundizar en el rendimiento de tus recursos y trazas
+ text: Profundiza en el rendimiento de tus recursos y trazas
- link: /tracing/live_debugger/
tag: Documentación
- text: Más información sobre cómo depurar servicios de producción con Live Debugger
+ text: Aprende a depurar servicios en producción con Live Debugger
- link: /dynamic_instrumentation/
tag: Documentación
- text: Más información sobre cómo añadir tramos personalizados con Dynamic Instrumentation
-title: Code Origin para tramos (spans)
+ text: Aprende a agregar tramos personalizados con Instrumentación Dinámica
+title: Code Origin para Tramos
---
+## Resumen {#overview}
-{{< beta-callout url="#" btn_hidden="true" >}}
-Code Origin está actualmente en Vista previa. Para unirte a la vista previa, sigue las siguientes instrucciones para activar la función en tus servicios compatibles.
-
-Para enviar preguntas, comentarios o solicitudes relacionadas con Code Origin, rellena este formulario con tus datos.
-{{< /beta-callout >}}
-
-## Información general
-
-Code Origin detecta las localizaciones exactas en tu código base donde se crean tramos APM. Cuando se activa en un servicio compatible, añade automáticamente la ruta del archivo, el número de la línea y el nombre de la función a cada [tramo de entrada de servicios][12], lo que facilita:
+Code Origin captura las ubicaciones exactas en tu base de código donde se crean los tramos de APM. Cuando está habilitado en un servicio compatible, agrega automáticamente la ruta del archivo, el número de línea y el nombre de la función a cada [tramo de entrada del servicio][12], facilitando así:
- Depurar problemas de rendimiento
- Entender el flujo de ejecución del código
- Identificar cuellos de botella en el rendimiento
-En el Explorador de trazas, selecciona un tramo de un servicio habilitado para ver detalles de Code Origin en la pestaña Información general:
+En Trace Explorer, selecciona un tramo de un servicio habilitado para ver los detalles de Code Origin en la pestaña Resumen:
{{< img src="tracing/code_origin/code_origin_details_spotlight.png" alt="Detalles de Code Origin" style="width:100%;">}}
-## Empezando
+## Introducción {#getting-started}
-### Requisitos previos
+### Requisitos previos {#prerequisites}
- [Datadog APM][6] está configurado para capturar tramos.
-- La [integración del código fuente][7] (necesaria para la vista previa del código) está habilitada.
-- Tu servicio cumple los [requisitos de compatibilidad](#compatibility-requirements).
+- [Integración de código fuente][7] está habilitada (requerida para las vistas previas de código).
+- Su servicio cumple con los [requisitos de compatibilidad](#compatibility-requirements).
+
+### Requisitos de compatibilidad {#compatibility-requirements}
+
+{{% tabs %}}
+
+{{% tab "Java" %}}
+
+| Versión del SDK | Frameworks |
+|---|---|
+| 1.47.0+ | Spring Boot/Data, servidores gRPC, Micronaut 4, consumidores de Kafka |
+
+**Limitación:** En JDK 18 y versiones anteriores, las clases compiladas con la `-parameters` bandera pueden no ser compatibles. Spring 6+, Spring Boot 3+ y Scala utilizan esta bandera por defecto.
+
+{{% /tab %}}
+
+{{% tab "Python" %}}
+
+| Versión del SDK | Frameworks |
+|---|---|
+| 2.15.0+ | Django, Flask, Starlette y derivados |
-### Requisitos de compatibilidad
+{{% /tab %}}
-| Lenguaje en tiempo de ejecución | Versión de librería de rastreo | Marcos |
-|---|---|---|
-| Java | 1.47.0 o posterior | Spring Boot/Data, servidores gRPC, Micronaut 4, consumidores Kafka|
-| Python | 2.15.0+ | Django, Flask, Starlette y derivados|
-| Node.js | 4.49.0 o posterior | Fastify|
-| .NET | 3.15.0 o posterior | ASP.NET, ASP.NET Core|
+{{% tab "Node.js" %}}
-### Activar Code Origin
+| Versión del SDK | Frameworks |
+|---|---|
+| 4.49.0+ | Fastify |
+| 5.54.0+ | Express |
-Ejecuta tu servicio con la siguiente variable de entorno:
+**Nota:** NestJS no es compatible, aunque el marco subyacente sea Express o Fastify.
+
+{{% /tab %}}
+
+{{% tab ".NET" %}}
+
+| Versión del SDK | Frameworks |
+|---|---|
+| 3.15.0+ | ASP.NET, ASP.NET Core |
+
+{{% /tab %}}
+
+{{% tab "PHP" %}}
+
+| Versión del SDK | Frameworks |
+|---|---|
+| 1.11.0+ | Todos los frameworks web compatibles |
+
+{{% /tab %}}
+
+{{% /tabs %}}
+
+### Habilitar origen de código {#enable-code-origin}
+
+Ejecute su servicio con la siguiente variable de entorno:
```shell
export DD_CODE_ORIGIN_FOR_SPANS_ENABLED=true
```
- En aplicaciones Node.js transpiladas (por ejemplo, TypeScript), asegúrate de generar y publicar mapas de fuentes con la aplicación desplegada y de ejecutar Node.js con el marcador
--enable-source-maps. De lo contrario, las vistas previas del código no funcionarán. Para ver más detalles, consulta la documentación de la
integración del código fuente de Node.js.
+ Para aplicaciones de Node.js transpileadas (por ejemplo, TypeScript), asegúrese de generar y publicar mapas del código fuente con la aplicación desplegada, ejecute Node.js con el
--enable-source-mapsla bandera, y use la versión 5.59.0 o más reciente del rastreador de Node.js. De lo contrario, las vistas previas de código no funcionan. Consulte la documentación de
Integración de Código Fuente de Node.js para más detalles.
+: **Requisito previo:** Esta métrica existe para cualquier servicio APM con version tagging habilitado a través de [unified service tagging][1].
**Descripción:** El tiempo en segundos transcurrido entre un despliegue de un servicio y el despliegue de la versión más reciente anterior a ese.
-**Tipo de métrica:** [Distribución][2]
-**Etiquetas:** La métrica está etiquetada con `env` del servicio, `service`, y [second primary tag][3].
+**Tipo de métrica:** [Distribution][2]
+**Etiquetas:** La métrica está etiquetada con el `env` del servicio, `service`, y [second primary tag][3].
### Ejemplos {#examples}
-Si tienes un servicio que despliega la versión A en el tiempo = 0 y la versión B en el tiempo = 10, entonces el valor de la métrica `datadog.service.time_between_deployments` es 10:
+Si tiene un servicio que despliega la versión A en el tiempo = 0 y la versión B en el tiempo = 10, entonces el valor de la métrica `datadog.service.time_between_deployments` es 10:
Tiempo = 0
-: `{service: foo, env: prod, nombre-del-clúster: dev-shopist, versión: A}`
+: `{service: foo, env: prod, clúster: dev-shopist, Versión: A}`
Tiempo = 10
-: `{service: foo, env: prod, nombre_del_clúster: dev-shopist, versión: B}`
+: `{service: foo, env: prod, clúster: dev-shopist, Versión: B}`
Tiempo entre despliegues
: `datadog.service.time_between_deployments{env: prod, cluster_name: dev-shopist} = 10`
-Si despliegas la versión X en el tiempo = 20 en el clúster `dev-shopist`, la versión Y en el tiempo = 30 en el clúster `us-staging`, y la versión Y nuevamente en el tiempo = 45 en el clúster `dev-shopist`, el valor `max` de la métrica `datadog.service.time_between_deployments` para cualquier clúster es 25 (el tiempo de la Y más reciente menos la última X):
+Si despliega la versión X a tiempo = 20 en el clúster `dev-shopist`, la versión Y a tiempo = 30 en el clúster `us-staging`, y la versión Y nuevamente a tiempo = 45 en el clúster `dev-shopist`, el valor `max` de la métrica `datadog.service.time_between_deployments` para cualquier clúster es 25 (el tiempo de la Y más reciente menos la última X):
Tiempo = 20
: `{service: foo, env: staging, cluster-name: dev-shopist, version: X}`
diff --git a/content/es/tracing/trace_collection/dd_libraries/dotnet-framework.md b/content/es/tracing/trace_collection/dd_libraries/dotnet-framework.md
new file mode 100644
index 00000000000..7ec0b5009fe
--- /dev/null
+++ b/content/es/tracing/trace_collection/dd_libraries/dotnet-framework.md
@@ -0,0 +1,300 @@
+---
+algolia:
+ tags:
+ - C#
+ - APM
+aliases:
+- /es/tracing/dotnet
+- /es/tracing/languages/dotnet
+- /es/tracing/setup/dotnet
+- /es/tracing/setup_overview/dotnet
+- /es/agent/apm/dotnet/
+- /es/tracing/dotnet-framework
+- /es/tracing/languages/dotnet-framework
+- /es/tracing/setup/dotnet-framework
+- /es/agent/apm/dotnet-framework/
+- /es/tracing/setup_overview/dotnet-framework
+- /es/tracing/setup_overview/setup/dotnet
+- /es/tracing/setup_overview/setup/dotnet-framework
+- /es/tracing/trace_collection/automatic_instrumentation/dd_libraries/dotnet-framework
+code_lang: dotnet-framework
+code_lang_weight: 70
+further_reading:
+- link: /tracing/other_telemetry/connect_logs_and_traces/dotnet/
+ tag: Documentación
+ text: Conectar los registros de la aplicación .NET a las trazas
+- link: /tracing/metrics/runtime_metrics/dotnet/
+ tag: Documentación
+ text: Métricas de tiempo de ejecución
+- link: /serverless/azure_app_services/
+ tag: Documentación
+ text: Extensión de Microsoft Azure App Service
+- link: /tracing/glossary/
+ tag: Documentación
+ text: Explora tus servicios, recursos y trazas
+- link: https://www.datadoghq.com/blog/net-monitoring-apm/
+ tag: Blog
+ text: .NET monitoreo con Datadog APM y trazado distribuido
+- link: https://www.datadoghq.com/blog/asp-dotnet-core-monitoring/
+ tag: Blog
+ text: Monitorea aplicaciones ASP.NET Core en contenedores
+- link: https://www.datadoghq.com/blog/deploy-dotnet-core-aws-fargate/
+ tag: Blog
+ text: Monitorea aplicaciones ASP.NET Core en contenedores en AWS Fargate
+- link: https://www.datadoghq.com/blog/dotnet-datadog-continuous-profiler/
+ tag: Blog
+ text: Optimiza el rendimiento de tu aplicación .NET con el Continuous Profiler de
+ Datadog
+- link: https://github.com/DataDog/dd-trace-dotnet/tree/master/tracer/samples
+ tag: Código fuente
+ text: Ejemplos de instrumentación personalizada
+- link: https://github.com/DataDog/dd-trace-dotnet
+ tag: Código fuente
+ text: Código fuente
+title: Trazado de aplicaciones .NET Framework
+type: multi-code-lang
+---
+## Requisitos de compatibilidad {#compatibility-requirements}
+
+### Runtimes de .NET Framework soportados {#supported-net-framework-runtimes}
+
+El trazador .NET soporta instrumentación en .NET Framework >= 4.6.1.
+
+Para una lista completa de la biblioteca de .NET Framework de Datadog y el soporte de arquitectura de procesador (incluyendo versiones heredadas y de mantenimiento), consulta [Requisitos de Compatibilidad][1].
+
+## Instalación y primeros pasos {#installation-and-getting-started}
+
+
+ Para configurar Datadog APM en entornos Serverless, como AWS Lambda o Azure Functions, consulte
Serverless.
+
+ Nota: La instrumentación automática de Datadog se basa en la API de perfilado de .NET CLR. Esta API permite solo un suscriptor (por ejemplo, Datadog APM). Para garantizar la máxima visibilidad, ejecute solo una solución APM en su entorno de aplicación.
+
+
+### Instalación {#installation}
+
+Antes de comenzar, asegúrese de haber [instalado y configurado el Agente][12].
+
+1. [Instale el SDK.](#install-the-sdk)
+3. [Habilite el SDK para su servicio.](#enable-the-sdk-for-your-service)
+4. [Vea sus datos en vivo.](#view-your-live-data)
+
+### Instale el SDK {#install-the-sdk}
+
+Después de instalar y configurar su Agente de Datadog, el siguiente paso es agregar el SDK directamente en la aplicación para instrumentarla. Lea más sobre [información de compatibilidad][1].
+
+Instale el trazador de Datadog .NET a nivel de máquina para que todos los servicios en la máquina estén instrumentados o a nivel de aplicación, para que los desarrolladores puedan gestionar la instrumentación a través de las dependencias de la aplicación. Para ver las instrucciones de instalación a nivel de máquina, haga clic en la pestaña de Windows. Para ver las instrucciones de instalación por aplicación, haga clic en la pestaña de NuGet.
+
+{{< tabs >}}
+
+{{% tab "Windows" %}}
+
+Para instalar el trazador .NET a nivel de máquina:
+
+1. Descargue el [.NET Tracer MSI installer][1]. Utilice el instalador MSI x64 si está ejecutando Windows de 64 bits; esto puede instrumentar tanto aplicaciones de 64 bits como de 32 bits. Solo elige el instalador x86 si estás ejecutando Windows de 32 bits. A partir de la versión 3.0.0, solo se proporciona el instalador x64, ya que no soportamos sistemas operativos de 32 bits.
+
+2. Ejecuta el instalador MSI de .NET Tracer con privilegios de administrador.
+
+También puedes automatizar la configuración de MSI ejecutando lo siguiente en PowerShell: `Start-Process -Wait msiexec -ArgumentList '/qn /i datadog-apm.msi'`
+
+[1]: https://github.com/DataDog/dd-trace-dotnet/releases
+{{% /tab %}}
+
+{{% tab "NuGet" %}}
+
+
+ Nota: Esta instalación no instrumenta aplicaciones que se ejecutan en IIS. Para aplicaciones que se ejecutan en IIS, sigue el proceso de instalación a nivel de máquina de Windows.
+
+
+Para instalar el .NET Tracer por aplicación:
+
+1. Agrega el `Datadog.Trace.Bundle` [paquete de NuGet][1] a tu aplicación.
+
+
+[1]: https://www.nuget.org/packages/Datadog.Trace.Bundle
+{{% /tab %}}
+
+{{< /tabs >}}
+
+### Habilita el SDK para tu servicio {#enable-the-sdk-for-your-service}
+
+Para habilitar el .NET Tracer para tu servicio, establece las variables de entorno requeridas y reinicia la aplicación.
+
+Para información sobre los diferentes métodos para establecer variables de entorno, consulta [Configuración de variables de entorno del proceso](#configuring-process-environment-variables).
+
+{{< tabs >}}
+
+{{% tab "Windows" %}}
+
+#### Servicios de Información de Internet (IIS) {#internet-information-services-iis}
+
+1. El instalador MSI de .NET Tracer agrega todas las variables de entorno requeridas. No hay variables de entorno que necesites configurar.
+
+2. Para instrumentar automáticamente aplicaciones alojadas en IIS, detén y reinicia IIS completamente ejecutando los siguientes comandos como administrador:
+
+ ```cmd
+ net stop /y was
+ net start w3svc
+ # Also, start any other services that were stopped when WAS was shut down.
+ ```
+
+
+ Nota: Siempre utiliza los comandos anteriores para detener y reiniciar completamente IIS para habilitar el SDK. Evita usar la aplicación GUI del Administrador de IIS o iisreset.exe.
+
+
+
+#### Servicios fuera de IIS {#services-outside-iis}
+
+
+ Nota: El runtime de .NET intenta cargar la biblioteca de .NET en cualquier proceso de .NET que se inicie con estas variables de entorno configuradas. Deberías limitar la instrumentación solo a las aplicaciones que necesitan ser instrumentadas. No configures estas variables de entorno globalmente, ya que esto causa que todos los procesos de .NET en el servidor sean instrumentados.
+
+
+1. Configura las siguientes variables de entorno requeridas para que la instrumentación automática se adjunte a tu aplicación:
+
+ ```
+ COR_ENABLE_PROFILING=1
+ ```
+2. Para aplicaciones independientes y servicios de Windows, reinicia manualmente la aplicación.
+
+{{% /tab %}}
+
+{{% tab "NuGet" %}}
+
+Sigue las instrucciones en el archivo readme del paquete, también disponible en [`dd-trace-dotnet` repositorio][1].
+Los ejemplos de Docker también están disponibles en el [repositorio][2].
+
+[1]: https://github.com/DataDog/dd-trace-dotnet/blob/master/docs/Datadog.Trace.Bundle/README.md
+[2]: https://github.com/DataDog/dd-trace-dotnet/tree/master/tracer/samples/NugetDeployment
+
+{{% /tab %}}
+
+{{< /tabs >}}
+
+### Ve tus datos en vivo {#view-your-live-data}
+
+Después de habilitar el .NET Tracer para tu servicio:
+
+1. Reinicia tu servicio.
+
+2. Crea carga de aplicación.
+
+3. En Datadog, navega a [**APM** > **Trazas de APM**][3].
+
+## Configuración {#configuration}
+
+Si es necesario, configura el SDK para enviar datos de telemetría de rendimiento de la aplicación, incluyendo la configuración de Unified Service Tagging. Lee [Configuración de la Biblioteca][4] para más detalles.
+
+## Instrumentación personalizada {#custom-instrumentation}
+
+La instrumentación personalizada depende de su instrumentación automática e incluye pasos adicionales según el método:
+
+{{< tabs >}}
+
+{{% tab "Windows" %}}
+
+
+Nota: A partir de la versión 3.0.0, la instrumentación personalizada requiere que también utilice la instrumentación automática. Debería esforzarse por mantener sincronizadas las versiones de los paquetes de instrumentación automática y personalizada (por ejemplo: MSI y NuGet), y asegurarse de no mezclar versiones principales de los paquetes.
+
+
+Para utilizar la instrumentación personalizada en su aplicación .NET:
+
+1. Instrumente su aplicación utilizando la instrumentación automática.
+2. Agregue el `Datadog.Trace` [paquete de NuGet][1] a su aplicación.
+3. En el código de su aplicación, acceda al rastreador global a través de la propiedad `Datadog.Trace.Tracer.Instance` para crear nuevos tramos.
+
+[1]: https://www.nuget.org/packages/Datadog.Trace
+
+{{% /tab %}}
+
+{{% tab "NuGet" %}}
+
+Para utilizar la instrumentación personalizada en su aplicación .NET:
+
+1. En el código de su aplicación, acceda al rastreador global a través de la propiedad `Datadog.Trace.Tracer.Instance` para crear nuevos tramos.
+
+{{% /tab %}}
+
+{{< /tabs >}}
+
+Para obtener más información sobre cómo agregar tramos y etiquetas para la instrumentación personalizada, consulte la [.NET Documentación de Instrumentación Personalizada][5].
+
+## Configurando variables de entorno del proceso {#configuring-process-environment-variables}
+
+Para adjuntar la instrumentación automática a su servicio, establezca las variables de entorno requeridas antes de iniciar la aplicación. Consulte la sección [Habilitar el SDK para su servicio](#enable-the-sdk-for-your-service) para identificar qué variables de entorno establecer según su método de instalación del Tracer .NET y siga los ejemplos a continuación para configurar correctamente las variables de entorno según el entorno de su servicio instrumentado.
+
+
+ Nota: El runtime de .NET intenta cargar la biblioteca de .NET en cualquier proceso de .NET que se inicie con estas variables de entorno configuradas. Deberías limitar la instrumentación solo a las aplicaciones que necesitan ser instrumentadas. No configures estas variables de entorno globalmente, ya que esto causa que todos los procesos de .NET en el host sean instrumentados.
+
+
+#### Servicios de Windows {#windows-services}
+
+{{< tabs >}}
+
+{{% tab "Editor del Registro" %}}
+
+En el Editor del Registro, cree un valor de cadena múltiple llamado `Environment` en la clave `HKLM\System\CurrentControlSet\Services\` y establezca los datos del valor en:
+
+```text
+COR_ENABLE_PROFILING=1
+```
+
+{{< img src="tracing/setup/dotnet/RegistryEditorFramework.png" alt="Usando el Editor del Registro para crear variables de entorno para un servicio de Windows" >}}
+
+{{% /tab %}}
+
+{{% tab "PowerShell" %}}
+
+```powershell
+Set-ItemProperty HKLM:SYSTEM\CurrentControlSet\Services\ -Name Environment -Value 'COR_ENABLE_PROFILING=1'
+```
+{{% /tab %}}
+
+{{< /tabs >}}
+
+#### IIS {#iis}
+
+Después de instalar el MSI, no se necesita configuración adicional para instrumentar automáticamente sus sitios de IIS. Para establecer variables de entorno adicionales que son heredadas por todos los sitios de IIS, realice los siguientes pasos:
+
+1. Abra el Editor del Registro, busque el valor de cadena múltiple llamado `Environment` en la clave `HKLM\System\CurrentControlSet\Services\WAS`, y agregue las variables de entorno, una por línea. Por ejemplo, para agregar inyección de registros y métricas de tiempo de ejecución, agregue las siguientes líneas a los datos del valor:
+ ```text
+ DD_LOGS_INJECTION=true
+ DD_RUNTIME_METRICS_ENABLED=true
+ ```
+2. Ejecute los siguientes comandos para reiniciar IIS:
+ ```cmd
+ net stop /y was
+ net start w3svc
+ # Also, start any other services that were stopped when WAS was shut down.
+ ```
+
+{{< img src="tracing/setup/dotnet/RegistryEditorIIS.png" alt="Usando el Editor del Registro para crear variables de entorno para todos los sitios de IIS" >}}
+
+#### Aplicaciones de consola {#console-applications}
+
+Para instrumentar automáticamente una aplicación de consola, establezca las variables de entorno desde un archivo por lotes antes de iniciar su aplicación:
+
+```bat
+rem Set required environment variables
+SET COR_ENABLE_PROFILING=1
+
+rem (Optionally) Set additional Datadog environment variables, for example:
+SET DD_LOGS_INJECTION=true
+SET DD_RUNTIME_METRICS_ENABLED=true
+
+rem Start application
+dotnet.exe example.dll
+```
+
+## Lectura adicional {#further-reading}
+
+{{< partial name="whats-next/whats-next.html" >}}
+
+
+[1]: /es/tracing/compatibility_requirements/dotnet-framework
+[2]: /es/agent/
+[3]: https://app.datadoghq.com/apm/traces
+[4]: /es/tracing/trace_collection/library_config/dotnet-framework/
+[5]: /es/tracing/trace_collection/custom_instrumentation/dotnet/
+[11]: /es/tracing/trace_collection/library_injection_local/
+[12]: /es/tracing/trace_collection/automatic_instrumentation/?tab=datadoglibraries#install-and-configure-the-agent
\ No newline at end of file
diff --git a/content/es/tracing/trace_collection/dd_libraries/go.md b/content/es/tracing/trace_collection/dd_libraries/go.md
new file mode 100644
index 00000000000..329bd26ffb1
--- /dev/null
+++ b/content/es/tracing/trace_collection/dd_libraries/go.md
@@ -0,0 +1,298 @@
+---
+aliases:
+- /es/tracing/go/
+- /es/tracing/languages/go
+- /es/agent/apm/go/
+- /es/tracing/setup/go
+- /es/tracing/setup_overview/go
+- /es/tracing/setup_overview/setup/go
+- /es/tracing/trace_collection/automatic_instrumentation/dd_libraries/go
+code_lang: go
+code_lang_weight: 20
+further_reading:
+- link: https://github.com/DataDog/dd-trace-go/tree/v1
+ tag: Código fuente
+ text: Código fuente del SDK
+- link: https://pkg.go.dev/github.com/DataDog/dd-trace-go/v2/ddtrace
+ tag: Sitio externo
+ text: Documentación de la API del SDK
+- link: https://pkg.go.dev/github.com/DataDog/dd-trace-go/v2/ddtrace
+ tag: Sitio externo
+ text: Documentación de la API del SDK para v2
+- link: https://github.com/DataDog/orchestrion
+ tag: Código fuente
+ text: Código fuente de Orchestrion
+- link: /tracing/glossary/
+ tag: Documentación
+ text: Explora tus servicios, recursos y trazas
+title: Trazando aplicaciones Go
+type: multi-code-lang
+---
+## Requisitos de compatibilidad {#compatibility-requirements}
+
+El rastreador de Go requiere Go `1.18+` y el Agente de Datadog `>= 5.21.1`. Para una lista completa de las versiones de Go y el soporte de frameworks de Datadog (incluyendo versiones heredadas y de mantenimiento), consulta la página de [Requisitos de Compatibilidad][1].
+
+{{% tracing-go-v2 %}}
+
+## Introducción {#getting-started}
+
+Antes de comenzar, asegúrate de haber [instalado y configurado el Agente][5].
+
+Hay dos formas de instrumentar tu aplicación Go:
+
+1. **Instrumentación en tiempo de compilación**:
+ - Asegura la máxima cobertura de tu instrumentación de trazado.
+ - No requiere modificaciones en el código fuente, lo que lo hace ideal para integrar a nivel de CI/CD.
+1. **Instrumentación manual**:
+
+ Utiliza dd-trace-go junto con nuestros paquetes de integración para generar automáticamente tramos sobre las bibliotecas que elijas. Esta opción:
+ - Te brinda control total sobre qué partes de tu aplicación son rastreadas.
+ - Requiere modificar el código fuente de la aplicación.
+
+Consulta las instrucciones en la sección correspondiente a tu preferencia a continuación:
+
+{{< tabs >}}
+
+{{% tab "Instrumentación en tiempo de compilación" %}}
+
+### Descripción general {#overview}
+
+[Orchestrion][6] agrega automáticamente instrumentación a las aplicaciones de Go durante la compilación, eliminando la necesidad de cambios en el código. Proporciona una cobertura de rastreo integral y habilita características de seguridad exclusivas:
+
+- Cobertura de rastreo integral:
+ - Instrumenta tu código y todas las dependencias, incluida la biblioteca estándar de Go
+ - Instrumenta tu código durante la compilación, previniendo brechas en la cobertura de rastreo debido a la instrumentación manual pasada por alto
+- Protección exclusiva [App y API][7] **Prevención de explotación** característica. [Prevención de explotación][15] es una implementación de Protección de Aplicaciones en Tiempo de Ejecución (RASP) e incluye métodos RASP como Inclusión de Archivos Locales (LFI).
+
+### Requisitos {#requirements}
+
+- Soporta las dos últimas versiones de tiempo de ejecución de Go (de acuerdo con [la política de lanzamiento oficial de Go][8]).
+- Las aplicaciones deben ser gestionadas utilizando [módulos de Go][10]. Se admite la venta de módulos.
+
+
+### Instalar Orchestrion {#install-orchestrion}
+
+Para instalar y configurar Orchestrion:
+
+1. Instalar Orchestrion:
+ ```sh
+ go install github.com/DataDog/orchestrion@latest
+ ```
+ Asegúrate de que $(go env GOBIN) o $(go env GOPATH)/bin está en tu $PATH.
+
+1. Registra Orchestrion en el `go.mod` de tu proyecto:
+ ```sh
+ orchestrion pin
+ ```
+ Consulta la salida de `orchestrion pin -help` para obtener más información sobre las opciones de personalización disponibles.
+1. Confirma los cambios en tu sistema de control de versiones (a menos que estés integrando `orchestrion` directamente en tu canalización de CI/CD):
+ ```sh
+ git add go.mod go.sum orchestrion.tool.go
+ git commit -m "chore: enable orchestrion"
+ ```
+
+ Ahora puedes gestionar tu dependencia de `orchestrion` como cualquier otra dependencia utilizando el archivo `go.mod`.
+
+### Uso {#usage}
+
+Utiliza uno de estos métodos para habilitar Orchestrion en tu proceso de construcción:
+
+#### Anteponer `orchestrion` a tus comandos habituales de `go`: {#prepend-orchestrion-to-your-usual-go-commands}
+ ```sh
+ orchestrion go build .
+ orchestrion go run .
+ orchestrion go test ./...
+ ```
+#### Agrega el argumento `-toolexec="orchestrion toolexec"` a tus comandos de `go`: {#add-the-toolexecorchestrion-toolexec-argument-to-your-go-commands}
+ ```sh
+ go build -toolexec="orchestrion toolexec" .
+ go run -toolexec="orchestrion toolexec" .
+ go test -toolexec="orchestrion toolexec" ./...
+ ```
+#### Modifica la variable de entorno `$GOFLAGS` para inyectar Orchestrion, y utiliza los comandos `go` normalmente: {#modify-the-goflags-environment-variable-to-inject-orchestrion-and-use-go-commands-normally}
+ ```sh
+ # Make sure to include the quotes as shown below, as these are required for
+ # the Go toolchain to parse GOFLAGS properly!
+ export GOFLAGS="${GOFLAGS} '-toolexec=orchestrion toolexec'"
+ go build .
+ go run .
+ go test ./...
+ ```
+
+### Personalización de trazas {#trace-customization}
+
+#### Configurando el etiquetado de servicio unificado {#setting-up-unified-service-tagging}
+
+Las aplicaciones instrumentadas por `orchestrion` soportan el Etiquetado de Servicio Unificado (UST). Puedes establecer etiquetas UST para tus trazas configurando la variable de entorno correspondiente en el entorno de **ejecución** de tu aplicación:
+
+| Entorno de Etiquetas Unificadas | |
+|-------------|--------------|
+| `env` | `DD_ENV` |
+| `service` | `DD_SERVICE` |
+| `version` | `DD_VERSION` |
+
+Para más información, consulta la [documentación de Etiquetado de Servicio Unificado][14].
+
+#### Configuración del trazador {#tracer-configuration}
+
+Consulta [Configuración de la Biblioteca][16] para instrucciones de configuración.
+
+#### Crea tramos de traza personalizados {#create-custom-trace-spans}
+
+Los tramos de traza personalizados pueden ser creados automáticamente para cualquier función anotada con el comentario de directiva `//dd:span`:
+
+{{}}
+//dd:span custom_tag:tag_value
+func CriticalPathFunction() {
+ // ... implementation details ...
+}
+{{}}
+
+Esto también funciona con expresiones literales de función:
+
+{{}}
+//dd:span custom_tag:tag_value
+handler := func(w http.ResponseWriter, r *http.Request) {
+ // ... implementation details ...
+}
+{{}}
+
+#### Nombre de la Operación {#operation-name}
+
+El nombre de la operación (`span.name`) se determina automáticamente utilizando la siguiente precedencia:
+1. Una etiqueta `span.name:customOperationName` explícita especificada como un argumento de directiva
+2. El nombre declarado de la función (esto no se aplica a expresiones literales de función, que son anónimas)
+3. El valor de la primera etiqueta proporcionada a la lista de argumentos de directiva
+
+{{}}
+//dd:span tag-name:spanName other-tag:bar span.name:operationName
+func tracedFunction() {
+ // This function will be represented as a span named "operationName"
+}
+
+//dd:span tag-name:spanName other-tag:bar
+func otherTracedFunction() {
+ // This function will be represented as a span named "otherTracedFunction"
+}
+
+//dd:span tag-name:spanName other-tag:bar
+tracedFunction := func() {
+ // This function will be represented as a span named "spanName"
+}
+{{}}
+
+#### Resultados de Error {#error-results}
+
+Si la función anotada devuelve un `error` resultado, cualquier error devuelto por la función se adjuntará automáticamente al intervalo de traza correspondiente:
+
+{{}}
+//dd:span
+func failableFunction() (any, error) {
+ // This span will have error information attached automatically.
+ return nil, errors.ErrUnsupported
+}
+{{}}
+
+#### Prevenga la instrumentación de algún código {#prevent-instrumentation-of-some-code}
+
+Puede usar la directiva `//orchestrion:ignore` para evitar que `orchestrion` realice _cualquier_ modificación en el código anotado.
+
+Esto se puede usar para evitar que la instrumentación del lado del llamador se aplique a ubicaciones específicas:
+
+{{}}
+import "database/sql"
+
+// Caller-side instrumentation normally happens within this function...
+func normal() {
+ // The following assignment will NOT be modified to add any caller-side
+ // instrumentation as it is opted out by the orchestrion:ignore directive:
+ //orchestrion:ignore
+ db, err := sql.Open("driver-name", "database=example")
+ // ...
+}
+
+// Caller-side instrumentation will NOT happen in the following function
+// as it is annotated with orchestrion:ignore.
+//orchestrion:ignore
+func excluded() {
+ // The following assignment will NOT be modified to add any caller-side
+ // instrumentation as the surrounding context is excluded by an
+ // orchestrion:ignore directive:
+ db, err := sql.Open("driver-name", "database=example")
+ // ...
+}
+{{}}
+
+Parte de la instrumentación realizada por `orchestrion` se hace del lado del llamado (o del lado de la biblioteca), lo que significa que la integración se agrega directamente dentro de la dependencia misma. En tales casos, no es posible optar localmente por no participar en tales integraciones.
+
+#### Use el SDK {#use-the-sdk}
+
+Puede usar el [SDK][4] en su aplicación construida con Orchestrion. Esto es útil para instrumentar marcos que aún no son compatibles con Orchestrion. Sin embargo, tenga en cuenta que esto puede resultar en tramos de traza duplicados en el futuro a medida que se expanda el soporte de Orchestrion. Revise las [notas de la versión][11] al actualizar su dependencia `orchestrion` para mantenerse informado sobre nuevas características y ajustar su instrumentación manual según sea necesario.
+
+#### Utilice el perfilador continuo {#use-the-continuous-profiler}
+
+Su aplicación construida con Orchestrion incluye instrumentación de [perfilador continuo][12].
+Para habilitar el perfilador, establezca la variable de entorno `DD_PROFILING_ENABLED=true` en tiempo de ejecución.
+
+#### Elimine integraciones {#remove-integrations}
+
+Puede eliminar integraciones modificando las importaciones en el archivo `orchestrion.tool.go`.
+También puede crear su propio archivo `orchestrion.tool.go` antes de ejecutar `orchestrion`.
+Podría hacer esto si no desea una integración,
+o si desea reducir el número de dependencias transitivas para integraciones que su programa no utiliza.
+Por defecto, Orchestrion importa `github.com/DataDog/dd-trace-go/orchestrion/all/v2`,
+que importa cada biblioteca para la cual hay una integración de Orchestrion.
+Puede reemplazar esta importación con importaciones de solo las integraciones que desea utilizar.
+Consulte [el código fuente del SDK][17] para la lista de integraciones compatibles.
+
+**Nota**: Si elige importar integraciones específicas, debe actualizar manualmente `orchestrion.tool.go` cada vez que desee agregar una nueva integración.
+
+### Construyendo con Docker {#building-with-docker}
+
+Para obtener más información sobre cómo crear una imagen de Docker adecuada, consulte [Creando un Dockerfile para APM para Go][18].
+
+### Solución de problemas {#troubleshooting}
+
+Para solucionar problemas de compilaciones que `orchestrion` gestiona, consulte [Solución de problemas de instrumentación en tiempo de compilación de Go][13].
+
+[4]: https://pkg.go.dev/github.com/DataDog/dd-trace-go/v2/ddtrace
+[6]: https://github.com/DataDog/orchestrion
+[7]: /es/security/application_security/exploit-prevention
+[8]: https://go.dev/doc/devel/release#policy
+[10]: https://pkg.go.dev/cmd/go#hdr-Modules__module_versions__and_more
+[11]: https://github.com/DataDog/orchestrion/releases
+[12]: /es/profiler
+[13]: /es/tracing/troubleshooting/go_compile_time/
+[14]: /es/getting_started/tagging/unified_service_tagging/
+[15]: /es/security/application_security/exploit-prevention/
+[16]: /es/tracing/trace_collection/library_config/go/#traces
+[17]: https://github.com/DataDog/dd-trace-go/blob/main/orchestrion/all/orchestrion.tool.go
+[18]: /es/tracing/guide/orchestrion_dockerfile/
+
+{{% /tab %}}
+
+{{% tab "Instrumentación manual" %}}
+
+### Agrega el SDK a tu aplicación {#add-the-sdk-to-your-application}
+
+Primero, importa e inicia el SDK en tu código siguiendo la documentación de [Configuración de la Biblioteca][3]. Consulta la [documentación de la API][6] (o la [documentación de la API v1][4]) para obtener instrucciones de configuración y detalles sobre el uso de la API.
+
+### Activa las integraciones de Go para crear tramos {#activate-go-integrations-to-create-spans}
+
+Activa las [integraciones de Go][1] para generar tramos. Datadog cuenta con una serie de paquetes plugables que proporcionan soporte inmediato para instrumentar una serie de bibliotecas y frameworks. Una lista de estos paquetes se puede encontrar en la página de [Requisitos de Compatibilidad][1]. Importa estos paquetes en tu aplicación y sigue las instrucciones de configuración que se enumeran junto a cada integración.
+
+[1]: /es/tracing/compatibility_requirements/go
+[3]: /es/tracing/trace_collection/library_config/go/
+[4]: https://pkg.go.dev/gopkg.in/DataDog/dd-trace-go.v1/ddtrace
+[6]: https://pkg.go.dev/github.com/DataDog/dd-trace-go/v2/ddtrace
+
+{{% /tab %}}
+
+{{< /tabs >}}
+
+## Lectura adicional {#further-reading}
+
+{{< partial name="whats-next/whats-next.html" >}}
+
+[1]: /es/tracing/compatibility_requirements/go
+[5]: /es/tracing/trace_collection/automatic_instrumentation/?tab=datadoglibraries#install-and-configure-the-agent
\ No newline at end of file
diff --git a/content/es/tracing/trace_collection/dd_libraries/php.md b/content/es/tracing/trace_collection/dd_libraries/php.md
index 31c6f7f4e50..a15362835a9 100644
--- a/content/es/tracing/trace_collection/dd_libraries/php.md
+++ b/content/es/tracing/trace_collection/dd_libraries/php.md
@@ -2,7 +2,7 @@
aliases:
- /es/tracing/languages/php
- /es/agent/apm/php/
-- /es/tracing/PHP/
+- /es/tracing/php/
- /es/tracing/setup/php
- /es/tracing/setup_overview/php
- /es/tracing/setup_overview/setup/php
@@ -13,33 +13,33 @@ code_lang_weight: 40
further_reading:
- link: /tracing/guide/trace-php-cli-scripts/
tag: Guía
- text: Rastreo de scripts de CLI PHP
+ text: Trazado de scripts CLI de PHP
- link: https://www.datadoghq.com/blog/monitor-php-performance/
tag: Blog
- text: Monitorización PHP con Datadog APM y rastreo distribuido
+ text: Monitoreo de PHP con Datadog APM y trazado distribuido
- link: https://github.com/DataDog/dd-trace-php
tag: Código fuente
- text: Código de origen
+ text: Código fuente
- link: https://github.com/DataDog/dd-trace-php/blob/master/CONTRIBUTING.md
tag: Código fuente
- text: Contribuir al proyecto de código abierto
+ text: Contribuyendo al proyecto de código abierto
- link: /tracing/glossary/
tag: Documentación
- text: Explorar tus servicios, recursos y trazas (traces)
+ text: Explora tus servicios, recursos y trazas
title: Rastreo de aplicaciones PHP
type: multi-code-lang
---
-## Requisitos de compatibilidad
+## Requisitos de compatibilidad {#compatibility-requirements}
-El requisito mínimo de versión de PHP para la última versión de `dd-trace-php` es PHP 7. Si estás utilizando PHP 5, puedes seguir utilizando el rastreador PHP hasta la versión [0.99](https://github.com/DataDog/dd-trace-php/releases/tag/0.99.0). PHP 5 es EOL a partir de la versión 1.0 de PHP biblioteca.
+El requisito mínimo de versión de PHP para la última versión de `dd-trace-php` es PHP 7. Si estás usando PHP 5, aún puedes usar el rastreador de PHP hasta la versión [0.99](https://github.com/DataDog/dd-trace-php/releases/tag/0.99.0). PHP 5 está al final de su vida útil desde la versión 1.0 de la biblioteca PHP.
-Para ver la lista completa de compatibilidad de versiones PHP y de frameworks de Datadog (incluidas las versiones heredadas y de mantenimiento), consulta la página de [requisitos de compatibilidad][1].
+Para una lista completa de la versión de PHP y el soporte de frameworks de Datadog (incluyendo versiones heredadas y de mantenimiento), consulta la página de [Requisitos de Compatibilidad][1].
-## Empezando
+## Comenzando {#getting-started}
-Antes de empezar, asegúrate de haber [instalado y configurado el Agent][14].
+Antes de comenzar, asegúrate de haber [instalado y configurado el Agente][14].
-### Instalación de la extensión
+### Instala la extensión {#install-the-extension}
Descarga el instalador oficial:
@@ -47,7 +47,7 @@ Descarga el instalador oficial:
curl -LO https://github.com/DataDog/dd-trace-php/releases/latest/download/datadog-setup.php
```
-Si utilizas Alpine Linux, debes instalar `libgcc_s` antes de ejecutar el instalador:
+En caso de que estés usando Alpine Linux, necesitas instalar `libgcc_s` antes de ejecutar el instalador:
```shell
apk add libgcc
@@ -70,96 +70,96 @@ php datadog-setup.php --php-bin=all --enable-profiling
```
-Nota: Solo APM es compatible con Windows. No uses las opciones --enable-appsec y --enable-profiling cuando rastreas aplicaciones PHP en Windows.
+Nota: Solo APM es compatible en Windows. No utilice el --enable-appsec y --enable-profiling banderas al rastrear aplicaciones PHP en Windows.
-Este comando instala la extensión a todos los binarios PHP que se encuentran en el host o el contenedor. Si `--PHP-bin` se omite, el instalador ejecuta el modo interactivo y pide al usuario que seleccione los binarios para la instalación. El valor de `--PHP-bin` puede ser una ruta a un binario específico en caso de que `dd-rastrear-PHP` sólo deba instalarse en dichos binarios.
+Este comando instala la extensión en todos los binarios de PHP encontrados en el host o contenedor. Si se omite `--php-bin`, el instalador se ejecuta en modo interactivo y le pide al usuario que seleccione los binarios para la instalación. El valor de `--php-bin` puede ser una ruta a un binario específico en caso de que `dd-trace-php` deba instalarse solo en dicho binario.
-Reinicia PHP (PHP-FPM o SAPI de Apache) y visita un endpoint de tu aplicación, habilitado para el rastreo. Para ver las trazas generadas, ve a la [página de trazas APM][4].
+Reinicie PHP (PHP-FPM o el SAPI de Apache) y visite un punto de conexión habilitado para trazado de su aplicación. Para ver las trazas generadas, vaya a la [página de trazas de APM][4].
-Cuando no especificas `--enable-appsec`, la extensión AppSec se carga poco después del inicio y no está activada por defecto. Se cortocircuita inmediatamente, causando una sobrecarga de rendimiento insignificante.
+Cuando no especifique `--enable-appsec`, la extensión de AppSec se carga brevemente al inicio y no está habilitada por defecto. Se interrumpe inmediatamente, causando una sobrecarga de rendimiento negligible.
-Pueden pasar algunos minutos hasta que aparezcan las trazas en la interfaz de usuario. Si las trazas siguen sin aparecer después de unos minutos, crea una página
phpinfo() desde la máquina host y desplázate hasta `ddtrace`. Los checks de diagnóstico fallidos aparecen en esta sección para ayudarte a identificar cualquier problema.
+Puede tardar unos minutos antes de que las trazas aparezcan en la interfaz de usuario. Si las trazas aún no aparecen después de unos minutos, cree un
phpinfo() página desde la máquina host y desplácese hacia abajo hasta el `ddtrace`. Las comprobaciones de diagnóstico fallidas aparecen en esta sección para ayudar a identificar cualquier problema.
Apache ZTS:
-Si el binario CLI PHP se ha creado como NTS (no seguro para subprocesos), mientras que Apache utiliza una versión ZTS (seguro para subprocesos Zend) de PHP, necesitas cambiar manualmente la carga de extensión del binario ZTS. Ejecuta /path/to/php-zts --ini para ver dónde se encuentra el archivo .ini de Datadog, y luego añade el sufijo -zts del nombre del archivo. Por ejemplo, de extension=ddtrace-20210902.so a extension=ddtrace-20210902-zts.so.
+Si el binario de PHP CLI se compila como NTS (no seguro para hilos), mientras que Apache utiliza una versión ZTS (segura para hilos de Zend) de PHP, necesita cambiar manualmente la carga de la extensión para el binario ZTS. Ejecutar /path/to/php-zts --ini encontrar dónde se encuentra el archivo de Datadog, luego agregar el .ini sufijo del nombre del archivo. -zts Por ejemplo, de a extension=ddtrace-20210902.so . extension=ddtrace-20210902-zts.soSELinux:
-SELinux:
-Si las políticas de SELinux httpd están configuradas en el host, la funcionalidad del rastreador puede verse limitada, a menos que la escritura y ejecución de archivos temporales esté explícitamente permitida en la configuración de SELinux:
+Si las políticas de SELinux de httpd están configuradas en el host, la funcionalidad del SDK puede estar limitada, a menos que se permita explícitamente la escritura y ejecución de archivos temporales en la configuración de SELinux:
+Si las políticas de SELinux de httpd están configuradas en el servidor, la funcionalidad del SDK puede estar limitada, a menos que se permita explícitamente la escritura y ejecución de archivos temporales en la configuración de SELinux.
`allow httpd_t httpd_tmpfs_t:file { execute execute_no_trans };`
-## Instrumentación automática
+## Instrumentación automática {#automatic-instrumentation}
-El rastreo se activa automáticamente por defecto. Una vez instalada la extensión, **ddtrace** rastrea tu aplicación y envía trazas al Agent.
+El trazado se habilita automáticamente por defecto. Una vez que la extensión está instalada, **ddtrace** traza su aplicación y envía trazas al Agente.
-Datadog es compatible con todos los frameworks de trabajo web listos para utilizar. La instrumentación automática funciona modificando el tiempo de ejecución de PHP para envolver ciertas funciones y métodos para rastrearlas. El rastreador PHP admite la instrumentación automática para varias bibliotecas.
+La instrumentación automática funciona modificando el entorno de ejecución de PHP para envolver ciertas funciones y métodos y así poder trazarlos. El rastreador de PHP admite instrumentación automática para varias bibliotecas. La instrumentación automática captura:
-Capturas de instrumentación automática:
+Tiempo de ejecución del método
-* Tiempo de ejecución del método
-* Datos de rastreo pertinentes, como códigos de respuesta URL y de estado para solicitudes web o consultas SQL para el acceso a bases de datos.
-* Excepciones no controladas, incluyendo trazas de stacks tecnológicos, si están disponibles
-* Recuento total de trazas (por ejemplo, solicitudes web) que circulan por el sistema
+* Datos de traza relevantes, como URL y códigos de respuesta de estado para solicitudes web o consultas SQL para acceso a bases de datos
+* Excepciones no controladas, incluidos los rastros de pila si están disponibles
+* Un conteo total de trazas (por ejemplo, solicitudes web) fluyendo a través del sistema
+* Configuración
-## Configuración
+## {#configuration}
-Si es necesario, configura la biblioteca de rastreo para enviar datos de telemetría del rendimiento de la aplicación, según tus necesidades, incluyendo la configuración del etiquetado unificado de servicios. Para obtener más detalles, consulta la [configuración de bibliotecas][6].
+Si es necesario, configure el SDK para enviar datos de telemetría de rendimiento de la aplicación según lo requiera, incluyendo la configuración de la Etiquetación de Servicio Unificada. Lea [Configuración de la Biblioteca][6] para más detalles.
-Para controlar la ingesta de trazas por servicio o recurso (incluido el uso de comodines en los nombres de los recursos), consulta [Control de la ingesta de trazas con muestreo basado en recursos][15].
+Para controlar la ingestión de trazas por servicio o recurso (incluyendo el uso de comodines en los nombres de recursos), consulte [Controlar la ingestión de trazas con muestreo basado en recursos][15].
-## Rastreo de scripts de CLI de corta y larga ejecución
+## Trazando scripts de CLI de corta y larga duración {#tracing-short-and-long-running-cli-scripts}
-Se requieren pasos adicionales para instrumentar scripts de CLI. Para obtener más información, consulta [Rastreo de scripts de CLI PHP][7].
+Se requieren pasos adicionales para instrumentar scripts de CLI. Lea [Traza de Scripts PHP CLI][7] para más información.
-## Actualización
+## Actualizando {#upgrading}
-Para actualizar el rastreador PHP, [descarga la última versión][5] y sigue los mismos pasos que para [instalar la extensión](#install-the-extension).
+Para actualizar el rastreador de PHP, [descargue la última versión][5] y siga los mismos pasos que [instalando la extensión](#install-the-extension).
-Una vez finalizada la instalación, reinicia PHP (PHP-FPM o SAPI de Apache).
+Una vez completada la instalación, reinicie PHP (PHP-FPM o el SAPI de Apache).
-**Nota**: Si estás utilizando caché de segundo nivel en OPcache configurando el parámetro `opcache.file_cache`, elimina la carpeta de caché.
+**Nota**: Si está utilizando caché de segundo nivel en OPcache configurando el parámetro `opcache.file_cache`, elimine la carpeta de caché.
-## Eliminación
+## Eliminando {#removing}
-Para eliminar el rastreador PHP:
+Para eliminar el rastreador de PHP:
-1. Para php-fpm, detén el servicio php-fpm, si no, detén el servidor web Apache.
-2. Desvincula los archivos `98-ddtrace.ini` y `99-ddtrace-custom.ini` de tu carpeta de configuración PHP.
-3. Para php-fpm, reinicia el servicio php-fpm, si no, reinicia el servidor web Apache.
+1. Para php-fpm, detenga el servicio php-fpm, de lo contrario, detenga el servidor web Apache.
+2. Desvincule los archivos `98-ddtrace.ini` y `99-ddtrace-custom.ini` de su carpeta de configuración de PHP.
+3. Para php-fpm, reinicie el servicio php-fpm, de lo contrario, reinicie el servidor web Apache.
-**Nota**: Si estás utilizando caché de segundo nivel en OPcache configurando el parámetro `opcache.file_cache`, elimina la carpeta de caché.
+**Nota**: Si está utilizando caché de segundo nivel en OPcache configurando el parámetro `opcache.file_cache`, elimine la carpeta de caché.
-## Solucionar problemas de fallos de una aplicación
+## Resolviendo un fallo de aplicación {#troubleshooting-an-application-crash}
-En el caso inusual de un fallo de la aplicación causado por el rastreador PHP, normalmente debido a un fallo de segmentación, lo mejor es lograr un volcado de núcleo o una traza Valgrind y ponerse en contacto con el servicio de asistencia de Datadog.
+En el inusual evento de un fallo de aplicación causado por el rastreador de PHP, típicamente debido a un fallo de segmentación, lo mejor que se puede hacer es obtener un volcado de núcleo o un trazo de Valgrind y contactar al soporte de Datadog.
-### Instalación de símbolos de depuración
+### Instalar símbolos de depuración {#install-debug-symbols}
-Para que los volcados de núcleo sean legibles, los símbolos de depuración de los binarios PHP deben estar instalados en el sistema que ejecuta PHP.
+Para que los volcados de núcleo sean legibles, los símbolos de depuración para los binarios de PHP deben estar instalados en el sistema que ejecuta PHP.
-Para comprobar si están instalados los símbolos de depuración para PHP o PHP-FPM, utiliza `gdb`.
+Para verificar si los símbolos de depuración están instalados para PHP o PHP-FPM, use `gdb`.
-Instala `gdb`:
+Instale `gdb`:
```
apt|yum install -y gdb
```
-Ejecuta `gdb` con el binario de interés. Por ejemplo, para PHP-FPM:
+Ejecute `gdb` con el binario de interés. Por ejemplo, para PHP-FPM:
```
gdb php-fpm
```
-Si el resultado de `gdb` contiene una línea similar al texto siguiente, entonces los símbolos de depuración ya están instalados.
+Si la salida de `gdb` contiene una línea similar al texto a continuación, entonces los símbolos de depuración ya están instalados.
```
...
@@ -167,7 +167,7 @@ Reading symbols from php-fpm...Reading symbols from /usr/lib/debug/path/to/some/
...
```
-Si el resultado de `gdb` contiene una línea similar al texto siguiente, entonces los símbolos de depuración deben instalarse.
+Si la salida de `gdb` contiene una línea similar al texto a continuación, entonces es necesario instalar los símbolos de depuración:
```
...
@@ -176,48 +176,48 @@ Reading symbols from php-fpm...(no debugging symbols found)...done.
```
-#### CentOS
+#### Centos {#centos}
-Instala el paquete `yum-utils` que proporciona el programa `debuginfo-install`:
+Instale el paquete `yum-utils` que proporciona el programa `debuginfo-install`:
```
yum install -y yum-utils
```
-Busca el nombre de paquete de tus binarios PHP. Puede variar dependiendo del método de instalación de PHP:
+Encuentre el nombre del paquete para sus binarios de PHP, puede variar dependiendo del método de instalación de PHP:
```
yum list installed | grep php
```
-Instala los símbolos de depuración. Por ejemplo, para el paquete `php-fpm` :
+Instale los símbolos de depuración. Por ejemplo, para el paquete `php-fpm`:
```
debuginfo-install -y php-fpm
```
-**Nota**: Si el repositorio que proporciona los binarios PHP no está habilitado por defecto, puede habilitarse al ejecutar el comando `debuginfo-install`. Por ejemplo:
+**Nota**: Si el repositorio que proporciona los binarios de PHP no está habilitado por defecto, se puede habilitar al ejecutar el comando `debuginfo-install`. Por ejemplo:
```
debuginfo-install --enablerepo=remi-php74 -y php-fpm
```
-#### Debian
+#### Debian {#debian}
-##### PHP instalado desde el DPA Debian Sury
+##### PHP instalado desde el DPA de Sury Debian {#php-installed-from-the-sury-debian-dpa}
-Si PHP se ha instalado desde el [DPA Debian Sury][8], los símbolos de depuración ya están disponibles en el DPA. Por ejemplo, para PHP-FPM 7.2:
+Si PHP fue instalado desde el [DPA de Sury Debian][8], los símbolos de depuración ya están disponibles desde el DPA. Por ejemplo, para PHP-FPM 7.2:
```
apt update
apt install -y php7.2-fpm-dbgsym
```
-##### PHP instalado desde un paquete diferente
+##### PHP instalado desde un paquete diferente {#php-installed-from-a-different-package}
-El proyecto Debian tiene una página wiki con las [instrucciones para instalar símbolos de depuración][9].
+El proyecto Debian mantiene una página wiki con [instrucciones para instalar símbolos de depuración][9].
-Edita el archivo `/etc/apt/sources.list`:
+Edite el archivo `/etc/apt/sources.list`:
```
# ... leave here all the pre-existing packages
@@ -227,13 +227,13 @@ Edita el archivo `/etc/apt/sources.list`:
deb http://deb.debian.org/debian-debug/ buster-debug main
```
-Actualiza `apt`:
+Actualizar `apt`:
```
apt update
```
-Prueba primero nombres canónicos de paquetes para los símbolos de depuración. Por ejemplo, si el nombre del paquete es `php7.2-fpm`, intenta:
+Intente nombres de paquetes canónicos para los símbolos de depuración, primero. Por ejemplo, si el nombre del paquete es `php7.2-fpm`, intenta:
```
apt install -y php7.2-fpm-dbgsym
@@ -243,29 +243,29 @@ apt install -y php7.2-fpm-dbgsym
apt install -y php7.2-fpm-dbg
```
-Si no encuentras símbolos de depuración, utiliza la herramienta `find-dbgsym-packages`. Instala el binario:
+Si no se pueden encontrar los símbolos de depuración, utiliza la herramienta de utilidad `find-dbgsym-packages`. Instala el binario:
```
apt install -y debian-goodies
```
-Intenta encontrar símbolos de depuración desde la ruta completa al binario o desde el identificador de procesos de un proceso en ejecución:
+Intenta encontrar los símbolos de depuración desde la ruta completa al binario o el id del proceso de un proceso en ejecución:
```
find-dbgsym-packages /usr/sbin/php-fpm7.2
```
-Instala el nombre de paquete resultante, si lo encuentras:
+Instala el nombre del paquete resultante, si se encuentra:
```
apt install -y php7.2-fpm-{package-name-returned-by-find-dbgsym-packages}
```
-#### Ubuntu
+#### Ubuntu {#ubuntu}
-##### PHP instalado desde `ppa:ondrej/php`
+##### PHP instalado desde `ppa:ondrej/php` {#php-installed-from-ppaondrejphp}
-Si PHP se ha instalado desde [`ppa:ondrej/php`][10], edita el archivo fuente apt `/etc/apt/sources.list.d/ondrej-*.list` añadiendo el componente `main/debug`.
+Si PHP fue instalado desde el [`ppa:ondrej/php`][10], edita el archivo de origen de apt `/etc/apt/sources.list.d/ondrej-*.list` añadiendo el componente `main/debug`.
Antes:
@@ -275,23 +275,23 @@ Después:
```deb http://ppa.launchpad.net/ondrej/php/ubuntu main main/debug```
-Actualiza e instale los símbolos de depuración. Por ejemplo, para PHP-FPM 7.2:
+Actualiza e instala los símbolos de depuración. Por ejemplo, para PHP-FPM 7.2:
```
apt update
apt install -y php7.2-fpm-dbgsym
```
-##### PHP instalado desde un paquete diferente
+##### PHP instalado desde un paquete diferente {#php-installed-from-a-different-package-1}
-Busca el nombre de paquete de tus binarios PHP. Puede variar dependiendo del método de instalación de PHP:
+Encuentre el nombre del paquete para sus binarios de PHP, puede variar dependiendo del método de instalación de PHP:
```
apt list --installed | grep php
```
-**Nota**: En algunos casos `php-fpm` puede ser un metapaquete que hace referencia al paquete real, por ejemplo `php7.2-fpm` en el caso de PHP-FPM 7.2. En este caso, el nombre de paquete es este último.
+**Nota**: En algunos casos `php-fpm` puede ser un metapaquete que se refiere al paquete real, por ejemplo `php7.2-fpm` en el caso de PHP-FPM 7.2. En este caso, el nombre del paquete es el último.
-Prueba primero nombres canónicos de paquetes para los símbolos de depuración. Por ejemplo, si el nombre del paquete es `php7.2-fpm`, intenta:
+Intente nombres de paquetes canónicos para los símbolos de depuración, primero. Por ejemplo, si el nombre del paquete es `php7.2-fpm`, intenta:
```
apt install -y php7.2-fpm-dbgsym
@@ -301,9 +301,9 @@ apt install -y php7.2-fpm-dbgsym
apt install -y php7.2-fpm-dbg
```
-Si los paquetes `-dbg` y `-dbgsym` no se pueden encontrar, habilita los respositorios `ddebs`. Para obtener información detallada sobre cómo [instalar símbolos de depuración][11] desde los `ddebs`, consulta la documentación de Ubuntu.
+Si no se pueden encontrar los paquetes `-dbg` y `-dbgsym`, habilita los repositorios `ddebs`. Se puede encontrar información detallada sobre cómo [instalar símbolos de depuración][11] desde el `ddebs` en la documentación de Ubuntu.
-Por ejemplo, para Ubuntu v18.04 y posterior, habilita el repositorio `ddebs`:
+Por ejemplo, para Ubuntu 18.04+, habilite el repositorio `ddebs`:
```
echo "deb http://ddebs.ubuntu.com $(lsb_release -cs) main restricted universe multiverse" | tee -a /etc/apt/sources.list.d/ddebs.list
@@ -311,7 +311,7 @@ echo "deb http://ddebs.ubuntu.com $(lsb_release -cs) main restricted universe mu
echo "deb http://ddebs.ubuntu.com $(lsb_release -cs)-updates main restricted universe multiverse" | tee -a /etc/apt/sources.list.d/ddebs.list
```
-Importa la clave de firma (asegúrate de que la [clave de firma es correcta][12]):
+Importe la clave de firma (asegúrese de que la [clave de firma sea correcta][12]):
```
apt install ubuntu-dbgsym-keyring
@@ -319,7 +319,7 @@ apt-key adv --keyserver keyserver.ubuntu.com --recv-keys exited on signal 11 (SIGSEGV - core dumped) after seconds from start`.
- - Busca `(SIGSEGV)`, ya que un mensaje como éste indica que el núcleo no ha sido volcado: `WARNING: [pool www] child exited on signal 11 (SIGSEGV) after seconds from start`.
-1. Localiza el volcado de núcleo ejecutando `cat /proc/sys/kernel/core_pattern`. El valor por defecto suele ser `core`, lo que significa que se generará un archivo llamado `core` en la carpeta raíz de la web.
+1. Determine si PHP-FPM generó un volcado de núcleo revisando el registro de errores de la aplicación:
+ - Busque `(SIGSEGV - core dumped)` porque un mensaje como este significa que se ha volcado: `WARNING: [pool www] child exited on signal 11 (SIGSEGV - core dumped) after seconds from start`.
+ - Busque `(SIGSEGV)` porque un mensaje como este indica que el núcleo no fue volcado: `WARNING: [pool www] child exited on signal 11 (SIGSEGV) after seconds from start`.
+1. Localice el volcado de núcleo ejecutando `cat /proc/sys/kernel/core_pattern`. El valor predeterminado es típicamente `core`, lo que significa que se generará un archivo llamado `core` en la carpeta raíz del servidor web.
-Si no se ha generado ningún volcado de núcleo, comprueba las siguientes configuraciones y cámbielas, si es necesario:
+Si no se generó un volcado de núcleo, verifique las siguientes configuraciones y cámbielas según sea necesario:
-1. Si `/proc/sys/kernel/core_pattern` contiene una ruta que incluye directorios anidados, asegúrate de que existe la ruta completa del directorio.
-1. Si el usuario que ejecuta el pool de trabajadores PHP-FPM no es `root` (un nombre de usuario común es `www-data`), proporciónale permisos de escritura en el directorio de volcados de núcleo.
-1. Asegúrate de que el valor de `/proc/sys/fs/suid_dumpable` no es `0`. Configúralo en `1` o `2`, a menos que ejecutes pool de trabajadores PHP-FPM como `root`. Consulta tus opciones con el administrador del sistema.
-1. Asegúrate de que tienes un `rlimit_core` adecuado en la sección de configuración del pool PHP-FPM. Puedes configurarlo como ilimitado: `rlimit_core = unlimited`.
-1. Asegúrate de que dispones de un conjunto `ulimit` en tu sistema. Puedes configurarlo como ilimitado: `ulimit -c unlimited`.
-1. Si tu aplicación se ejecuta en un contenedor Docker, los cambios en `/proc/sys/*` deben realizarse en la máquina host. Ponte en contacto con el administrador del sistema para conocer las opciones disponibles. Si puedes, intenta recrear la incidencia en tus entornos de test o de staging.
+1. Si `/proc/sys/kernel/core_pattern` contiene una ruta que incluye directorios anidados, asegúrese de que la ruta completa del directorio exista.
+1. Si el usuario que ejecuta los trabajadores del grupo PHP-FPM es algo diferente a `root` (un nombre de usuario común es `www-data`), otorgue a ese usuario permisos de escritura en el directorio de volcados de núcleo.
+1. Asegúrese de que el valor de `/proc/sys/fs/suid_dumpable` no sea `0`. Establezca el valor en `1` o `2` a menos que ejecute el grupo de trabajadores PHP-FPM como `root`. Consulte sus opciones con su administrador del sistema.
+1. Asegúrese de tener un `rlimit_core` adecuado en la sección de configuración del grupo PHP-FPM. Puede establecerlo en ilimitado: `rlimit_core = unlimited`.
+1. Asegúrese de tener un `ulimit` adecuado configurado en su sistema. Puede configurarlo como ilimitado: `ulimit -c unlimited`.
+1. Si su aplicación se ejecuta en un contenedor Docker, los cambios en `/proc/sys/*` deben realizarse en la máquina host. Contacte a su administrador del sistema para conocer las opciones disponibles para usted. Si puede, intente recrear la incidencia en sus entornos de prueba o de preparación.
-### Obtener un volcado de núcleo desde dentro de un contenedor Docker
+### Obteniendo un volcado de núcleo desde dentro de un contenedor Docker {#obtaining-a-core-dump-from-within-a-docker-container}
-Utiliza la siguiente información para ayudarte a obtener un volcado de núcleo en un contenedor Docker:
+Utilice la información a continuación para ayudar a obtener un volcado de núcleo en un contenedor Docker:
+
+1. El contenedor Docker necesita ejecutarse como un contenedor privilegiado, y el valor `ulimit` para los archivos de núcleo debe establecerse en su máximo, como se muestra en los ejemplos a continuación.
+ - Si usa el comando `docker run`, agregue los argumentos `--privileged` y `--ulimit core=99999999999`
+ - Si usa `docker compose`, agregue lo siguiente al archivo `docker-compose.yml`:
-1. El contenedor Docker necesita ejecutarse como contenedor privilegiado y el valor `ulimit` para los archivos del núcleo necesita ser ajustado a su máximo, como se muestra en los siguientes ejemplos.
- - Si utilizas el comando `docker run`, añade los argumentos `--privileged` y `--ulimit core=99999999999`.
- - Si utilizas `docker compose`, añade los siguiente al archivo `docker-compose.yml`:
```yaml
privileged: true
ulimits:
core: 99999999999
```
-2. Cuando ejecutes el contenedor (y antes de iniciar la aplicación PHP), debes ejecutar los siguientes comandos:
+2. Al ejecutar el contenedor (y antes de iniciar la aplicación PHP) debe ejecutar los siguientes comandos:
+
```
ulimit -c unlimited
echo '/tmp/core' > /proc/sys/kernel/core_pattern
echo 1 > /proc/sys/fs/suid_dumpable
```
-### Obtener una traza Valgrind
+### Obteniendo una traza de Valgrind {#obtaining-a-valgrind-trace}
-Para obtener más detalles sobre el fallo, ejecuta la aplicación con Valgrind. A diferencia de los volcados de núcleo, este método siempre opera en un contenedor sin privilegios.
+Para obtener más detalles sobre el fallo, ejecute la aplicación con Valgrind. A diferencia de los volcados de núcleo, este enfoque siempre funciona en un contenedor no privilegiado.
-Nota: Una aplicación que se ejecuta a través de Valgrind es órdenes de magnitud más lenta que cuando se ejecuta de forma nativa. Este método se recomienda para entornos que no sean de producción.
+Nota: Una aplicación que se ejecuta a través de Valgrind es órdenes de magnitud más lenta que cuando se ejecuta de forma nativa. Este método se recomienda para entornos no productivos.
-Instala Valgrind con tu gestor de paquetes. Ejecuta la aplicación con Valgrind lo suficiente para generar unas cuantas solicitudes.
+Instale Valgrind con su gestor de paquetes. Ejecute la aplicación con Valgrind lo suficiente como para generar algunas solicitudes.
-For a CLI application, run:
+Para una aplicación CLI, ejecute:
{{< code-block lang=shell >}}
USE_ZEND_ALLOC=0 valgrind -- php path/to/script.php
{{< /code-block >}}
-When running `php-fpm` run:
+Al ejecutar `php-fpm`, ejecute:
{{< code-block lang="shell" >}}
USE_ZEND_ALLOC=0 valgrind --trace-children=yes -- php-fpm -F --fpm-config
{{< /code-block >}}
-When using Apache, run:
+Al usar Apache, ejecute:
{{< code-block lang="shell" >}}
(. /etc/apache2/envvars; USE_ZEND_ALLOC=0 valgrind --trace-children=yes -- apache2 -X)`
{{< /code-block >}}
-La traza de Valgrind resultante se imprime por defecto en el error estándar. Para imprimir en un destino diferente, consulta la [documentación oficial][13]. El resultado esperado es similar al ejemplo siguiente para un proceso PHP-FPM:
+La traza de Valgrind resultante se imprime por defecto en el error estándar, consulte la [documentación oficial][13] para imprimir en un destino diferente. La salida esperada es similar al ejemplo a continuación para un proceso PHP-FPM:
```
==322== Conditional jump or move depends on uninitialised value(s)
@@ -448,32 +450,32 @@ La traza de Valgrind resultante se imprime por defecto en el error estándar. Pa
==322== ERROR SUMMARY: 18868 errors from 102 contexts (suppressed: 0 from 0)
```
-### Obtener un strace
+### Obteniendo un strace {#obtaining-a-strace}
-Algunos problemas son causados por factores externos, por lo que puede ser valioso disponer de un `strace`.
+Algunos problemas son causados por factores externos, por lo que puede ser valioso tener un `strace`.
-Nota: Una aplicación que se ejecuta a través de strace es órdenes de magnitud más lenta que cuando se ejecuta de forma nativa. Este método se recomienda para entornos que no sean de producción.
+Nota: Una aplicación que se ejecuta a través de strace es órdenes de magnitud más lenta que cuando se ejecuta de forma nativa. Este método se recomienda para entornos no productivos.
-Instala el `strace` con tu gestor de paquetes. Cuando generes un `strace` para enviarlo al servicio de asistencia de Datadog, asegúrate de utilizar la opción `-f` para seguir a procesos secundarios.
+Instale `strace` con su gestor de paquetes. Al generar un `strace` para enviar al soporte de Datadog, asegúrese de usar la opción `-f` para seguir los procesos secundarios.
-Para una aplicación de CLI, ejecuta:
+Para una aplicación CLI, ejecute:
{{< code-block lang="shell" >}}
strace -f php path/to/script.php
{{< /code-block >}}
Para `php-fpm`, ejecute:
{{< code-block lang="shell" >}}
-strace -f PHP-fpm -F --fpm-config
+strace -f php-fpm -F --fpm-config
{{< /code-block >}}
-Para Apache, ejecuta:
+Para Apache, ejecute:
{{< code-block lang="shell" >}}
(. /etc/apache2/envvars; strace -f apache2 -X)
{{< /code-block >}}
-## Referencias adicionales
+## Lectura adicional {#further-reading}
{{< partial name="whats-next/whats-next.html" >}}
diff --git a/content/es/tracing/trace_pipeline/ingestion_controls.md b/content/es/tracing/trace_pipeline/ingestion_controls.md
index e2afcb75496..a3c86165ee0 100644
--- a/content/es/tracing/trace_pipeline/ingestion_controls.md
+++ b/content/es/tracing/trace_pipeline/ingestion_controls.md
@@ -6,145 +6,144 @@ aliases:
- /es/tracing/app_analytics/
- /es/tracing/guide/ingestion_control_page/
- /es/tracing/trace_ingestion/ingestion_controls
-description: Aprende a controlar las velocidades de consumo con APM.
+description: Aprende a controlar las tasas de ingestión con APM.
further_reading:
- link: /tracing/trace_pipeline/ingestion_mechanisms/
tag: Documentación
- text: Mecanismos de consumo
+ text: Mecanismos de Ingestión
- link: /tracing/trace_pipeline/metrics/
tag: Documentación
- text: Métricas de uso
-title: Controles del consumo
+ text: Métricas de Uso
+title: Controles de Ingestión
---
+{{< img src="tracing/apm_lifecycle/ingestion_sampling_rules.png" style="width:100%; background:none; border:none; box-shadow:none;" alt="Reglas de Muestreo de Ingestión" >}}
-{{< img src="tracing/apm_lifecycle/ingestion_sampling_rules.png" style="width:100%; background:none; border:none; box-shadow:none;" alt="Reglas para el muestreo del consumo" >}}
+Los controles de ingestión afectan qué trazas son enviadas por tus aplicaciones a Datadog. Las [Métricas de APM][1] siempre se calculan en función de todas las trazas y no se ven afectadas por los controles de ingestión.
-Los controles de ingesta afectan a qué trazas envían tus aplicaciones a Datadog. Las [métricas de APM][1] siempre se calculan basándose en todas las trazas y no se ven afectadas por los controles de ingesta.
+La página de Ingestion Control proporciona visibilidad sobre la configuración de ingestión de tus aplicaciones y servicios. Desde la [página de Ingestion Control][2]:
-La página de Ingestion Control proporciona visibilidad de la configuración de ingesta de tus aplicaciones y servicios. Desde la [página de Ingestion Control][2]:
+- Obtén visibilidad sobre la configuración de ingestión a nivel de servicio.
+- Ajusta las tasas de muestreo de trazas para servicios o puntos finales de alto rendimiento para gestionar mejor el presupuesto de ingestión.
+- Ajusta las tasas de muestreo de trazas para servicios o puntos finales de bajo rendimiento y tráfico raro para aumentar la visibilidad.
+- Entiende cuáles [mecanismos de ingestión][11] son responsables de muestrear la mayoría de tus trazas.
+- Investiga y actúa sobre posibles problemas de configuración de ingestión, como recursos limitados de CPU o RAM para el Agente.
-- Obtén visibilidad de tu configuración de ingesta a nivel de servicio.
-- Ajusta las tasas de muestreo de traza para los endpoints o servicios de alto rendimiento con el fin de gestionar mejor el presupuesto de ingesta.
-- Ajusta las tasas de muestreo de trazas en caso de bajo rendimiento, servicios de tráfico poco frecuente o endpoints para aumentar la visibilidad.
-- Comprende qué [mecanismos de ingesta][11] son responsables de la toma de muestras de la mayor parte de tus trazas.
-- Investigar y actuar ante posibles problemas de configuración del consumo, como recursos limitados de la CPU o la RAM para el Agent.
+{{< img src="tracing/trace_indexing_and_ingestion/ingestion_control_page.png" style="width:100%;" alt="Descripción General de la Página de Control de Ingestión" >}}
-{{< img src="tracing/trace_indexing_and_ingestion/ingestion_control_page.png" style="width:100%;" alt="Información general de la página de Ingestion Control" >}}
+## Entendiendo tu configuración de ingestión {#understanding-your-ingestion-configuration}
-## Comprender tu configuración de ingesta
+Utiliza los datos en el encabezado de control de ingestión para monitorear tu ingestión de trazas. El encabezado muestra la cantidad total de datos ingeridos en la última hora, tu uso mensual estimado y el porcentaje de tu límite mensual de ingestión asignado, calculado en función de tu infraestructura activa de APM (como hosts, tareas de Fargate y funciones sin servidor).
-Utiliza los datos del encabezado de control de ingesta para monitorizar tu ingesta de trazas. El encabezado muestra la cantidad total de datos ingeridos durante la última hora, tu uso mensual estimado y el porcentaje de tu límite de ingesta mensual asignado, calculado en función de tu infraestructura activa de APM (como hosts, tareas de Fargate y funciones sin servidor).
+Si el uso mensual está por debajo de `100%`, los datos ingeridos proyectados se ajustan dentro de tu asignación mensual. Un valor de uso mensual superior a `100%` significa que se proyecta que los datos ingeridos mensualmente superen su asignación mensual.
-Si el uso mensual es inferior a `100%`, los datos ingeridos proyectados se ajustan a tu asignación mensual. Un valor de uso mensual superior a `100%` significa que se prevé que los datos mensuales ingeridos superen tu asignación mensual.
+### Niveles de ingestión por servicio {#ingestion-levels-by-service}
-### Niveles de ingesta por servicio
-
-La tabla de servicios contiene información sobre los volúmenes consumidos y la configuración del consumo, desglosada por servicio:
+La tabla de servicios contiene información sobre los volúmenes ingeridos y la configuración de ingestión, desglosada por servicio:
Tipo
: El tipo de servicio: servicio web, base de datos, caché, navegador, etc...
Nombre
-: El nombre de cada servicio que envía trazas a Datadog. La tabla contiene servicios raíz y no raíz para los que se consumieron datos en la última hora.
+: El nombre de cada servicio que envía trazas a Datadog. La tabla contiene servicios raíz y no raíz para los cuales se ingirió datos en la última hora.
-Trazas/s consumidas
-: Número promedio de trazas por segundo consumidas partiendo del servicio durante la última hora.
+Trazas ingeridas/s
+: Número promedio de trazas por segundo ingeridas desde el servicio en la última hora.
-Bytes/s ingeridos
-: número medio de bytes por segundo ingeridos en servicio durante la última hora.
+Bytes ingeridos/s
+: Número promedio de bytes por segundo ingeridos para el servicio en la última hora.
-Bytes/s de bajada
-: número medio de bytes por segundo ingeridos para los que el servicio _toma la decisión de muestreo_. Esto incluye los bytes de todos los tramos de servicio descendentes en el stack tecnológico de llamadas que siguen a la decisión tomada en el encabezado de la traza. Los datos de esta columna se basan en la dimensión `sampling_service`, establecida en las métricas `datadog.estimated_usage.apm.ingested_bytes`. Para obtener más información, lee [métricas de uso de APM][15].
+Bytes descendentes/s
+: Número promedio de bytes por segundo ingeridos para los cuales el servicio _toma la decisión de muestreo_. Esto incluye los bytes de todos los spans de servicios descendentes en la pila de llamadas que siguen la decisión tomada al inicio de la traza. Los datos de esta columna se basan en la dimensión `sampling_service`, establecida en las métricas `datadog.estimated_usage.apm.ingested_bytes`. Para más información, lea [métricas de uso de APM][15].
Desglose del tráfico
-: Un desglose detallado del tráfico muestreado y no muestreado para trazas partiendo del servicio. Consulta [Desglose del tráfico](#traffic-breakdown) para obtener más información.
+: Un desglose detallado del tráfico muestreado y no muestreado para trazas que comienzan desde el servicio. Vea [Desglose del tráfico](#traffic-breakdown) para más información.
-Configuración de ingesta
-: muestra `Automatic` si se aplica el [mecanismo de muestreo por defecto basado en encabezados][4] del Agent. Si la ingesta se configuró con [reglas de muestreo de trazas][8], el servicio se marca como `Configured`; se establece una etiqueta `Local` cuando la regla de muestreo se aplica desde la configuración en la biblioteca de rastreo, se establece una etiqueta `Remote` cuando la regla de muestreo se aplica de forma remota, desde la interfaz de usuario. Para obtener más información sobre la configuración de la ingesta para un servicio, lee sobre [cambiar la tasa de ingesta predeterminada](#configure-the-service-ingestion-rate).
+Configuración de Ingesta
+: Muestra `Automatic` si el [mecanismo de muestreo basado en el encabezado por defecto][4] del Datadog Agent se aplica. Si la ingesta fue configurada con [reglas de muestreo de trazas][8], el servicio se marca como `Configured`; se establece una etiqueta `Local` cuando la regla de muestreo se aplica desde la configuración en el SDK, y se establece una etiqueta `Remote` cuando la regla de muestreo se aplica de forma remota, desde la interfaz de usuario. Para más información sobre cómo configurar la ingesta para un servicio, lee sobre [cambiar la tasa de ingesta por defecto](#configure-the-service-ingestion-rate).
Infraestructura
-: Hosts, contenedores y funciones en los cuales se ejecuta el servicio.
+: Hosts, contenedores y funciones en los que se está ejecutando el servicio.
Estado del servicio
-: Muestra `Limited Resource` cuando se descartan algunos tramos debido a que el Datadog Agent alcanza los límites de la CPU o de la RAM configurados [en su configuración][9], `Legacy Setup` cuando algunos tramos se consumen a través del [mecanismo de App Analytics][7] legacy o `OK` de otro modo.
+: Muestra `Limited Resource` cuando algunos spans son descartados debido a que el Datadog Agent alcanza los límites de CPU o RAM establecidos [en su configuración][9], `Legacy Setup` cuando algunos spans son ingeridos a través del antiguo [mecanismo de App Analytics][7], o `OK` de otra manera.
-Filtra la página por el entorno, la configuración y el estado para ver los servicios para los cuales necesitas tomar una decisión. Para reducir el volumen del consumo global, ordena la tabla por la columna `Downstream Bytes/s` para ver los servicios responsables de la mayor parte de tu consumo.
+Filtra la página por entorno, configuración y estado para ver los servicios para los cuales necesitas tomar una acción. Para reducir el volumen global de ingesta, ordena la tabla por la `Downstream Bytes/s` columna para ver los servicios responsables de la mayor parte de tu ingesta.
-**Nota**: La tabla tiene la tecnología de las [métricas de uso][10] `datadog.estimated_usage.apm.ingested_spans` y `datadog.estimated_usage.apm.ingested_bytes`. Estas métricas están etiquetadas por `service`, `env` y `ingestion_reason`.
+**Nota**: La tabla está alimentada por las [métricas de uso][10] `datadog.estimated_usage.apm.ingested_spans` y `datadog.estimated_usage.apm.ingested_bytes`. Estas métricas están etiquetadas por `service`, `env` y `ingestion_reason`.
-#### Desglose del tráfico
+#### Desglose de tráfico {#traffic-breakdown}
-La columna Desglose del tráfico desglosa el destino de todas las trazas a partir del servicio. Te ofrece una estimación de la parte del tráfico que se ingiere y se abandona, y por qué motivos.
+La columna de Desglose de Tráfico desglosa el destino de todas las trazas que comienzan desde el servicio. Te da una estimación de la parte del tráfico que es ingerido y descartado, y por qué razones.
-{{< img src="tracing/trace_indexing_and_ingestion/service_traffic_breakdown.png" style="width:100%;" alt="Desglose del tráfico del consumo de trazas" >}}
+{{< img src="tracing/trace_indexing_and_ingestion/service_traffic_breakdown.png" style="width:100%;" alt="Desglose de tráfico de la ingesta de trazas" >}}
El desglose se compone de las siguientes partes:
-- **Trazas completas consumidas** (azul): El porcentaje de las trazas consumidas por Datadog.
-- **Trazas completas no retenidas** (gris): el porcentaje de trazas que no han sido ingeridas por Datadog. Algunas trazas pueden ser descartadas porque:
+- **Trazas completas ingeridas** (azul): El porcentaje de trazas que han sido ingeridas por Datadog.
+- **Trazas completas no retenidas** (gris): El porcentaje de trazas que no han sido ingeridas por Datadog. Algunas trazas pueden ser descartadas porque:
- 1. Por defecto, el [Agent establece automáticamente una tasa de muestreo][4] en servicios, en función del tráfico de servicio.
- 2. El servicio está configurado para ingerir un determinado porcentaje de trazas mediante [reglas de muestreo][8].
+ 1. Por defecto, el [Agente establece automáticamente una tasa de muestreo][4] en los servicios, dependiendo del tráfico del servicio.
+ 2. El servicio está configurado para ingerir un cierto porcentaje de trazas utilizando [reglas de muestreo][8].
-- **Trazas completas eliminadas por el limitador de tasa del rastreador** (naranja): cuando eliges establecer manualmente la tasa de ingesta de servicio como un porcentaje con las reglas de muestreo de trazas, se habilita automáticamente un limitador de tasa, establecido en 100 trazas por segundo de forma predeterminada. Consulta la documentación [limitador de tasa][8] para cambiar esta tasa.
+- **Trazas completas descartadas por el limitador de tasa del SDK** (naranja): Cuando eliges establecer manualmente la tasa de ingesta del servicio como un porcentaje con reglas de muestreo de trazas, un limitador de tasa se habilita automáticamente, configurado por defecto a 100 trazas por segundo. Consulta la documentación del [limitador de tasa][8] para cambiar esta tasa.
-- **Trazas descartadas debido al límite de la CPU o la RAM del Agent** (rojo): Con este mecanismo se pueden descartar tramos y crear trazas incompletas. Para solucionarlo, aumenta la asignación de la CPU y la memoria para la infraestructura en la cual se ejecuta el Agent.
+- **Trazas descartadas debido al límite de CPU o RAM del Agente** (rojo): Este mecanismo puede descartar tramos y crear trazas incompletas. Para solucionar esto, aumenta la asignación de CPU y memoria para la infraestructura en la que se ejecuta el Agente.
-## Configuración de la ingesta para un servicio
+## Configurando la ingestión para un servicio {#configuring-ingestion-for-a-service}
-Haz clic en servicio para ver el resumen de ingesta de servicio, que ofrece información práctica y opciones de configuración para gestionar la ingestión de trazas del servicio.
+Haz clic en cualquier servicio para ver el Resumen de Ingestión del Servicio, que proporciona información útil y opciones de configuración para gestionar la ingestión de trazas de ese servicio.
-### Configuración de ingesta para un servicio
+### Configuración de ingestión para un servicio {#ingestion-configuration-for-a-service}
-#### Tasas de muestreo por recurso
+#### Tasas de muestreo por recurso {#sampling-rates-by-resource}
-La tabla enumera las tasas de muestreo aplicadas por recurso del servicio.
+La tabla lista las tasas de muestreo aplicadas por recurso del servicio.
{{< img src="/tracing/trace_indexing_and_ingestion/resource_sampling_rates.png" alt="Tabla de tasas de muestreo por recurso" style="width:100%;">}}
-- La columna `Ingested bytes` muestra los bytes ingeridos de tramos (spans) del servicio y el recurso, mientras que la columna `Downstream bytes` muestra los bytes ingeridos desde tramos en los que la decisión de muestreo se toma a partir de ese servicio y recurso, incluidos los bytes de los servicios de descarga en la cadena de llamadas.
-- La columna `Configuration` muestra desde dónde se está aplicando la frecuencia de muestreo de recursos:
- - `Automatic` si se aplica el [mecanismo de muestreo por defecto basado en el encabezado][4] del Agent.
- - `Local Configured` si se ha establecido localmente una [regla de muestreo][8] en la biblioteca de rastreo.
- - `Remote Configured` si se ha configurado una regla de muestreo remota desde la interfaz de usuario de Datadog. Para saber cómo configurar reglas de muestreo desde la página de Ingestion Control, lee la sección sobre [configuración remota de reglas de muestreo](#configure-the-service-ingestion-rates-by-resource).
+- La columna `Ingested bytes` muestra los bytes ingeridos de los tramos del servicio y recurso, mientras que la columna `Downstream bytes` muestra los bytes ingeridos de los tramos donde se toma la decisión de muestreo comenzando desde ese servicio y recurso, incluyendo bytes de servicios descendentes en la cadena de llamadas.
+- La columna `Configuration` muestra de dónde se está aplicando la tasa de muestreo del recurso:
+ - `Automatic` si se aplica el [mecanismo de muestreo basado en cabeza por defecto][4] del Agente.
+ - `Local Configured` si se estableció una [regla de muestreo][8] localmente en el SDK.
+ - `Remote Configured` si se estableció una regla de muestreo remota desde la interfaz de usuario de Datadog. Para aprender a configurar reglas de muestreo desde la página de Control de Ingestión, lee la sección sobre [configuración remota de reglas de muestreo](#configure-the-service-ingestion-rates-by-resource).
-**Nota**: Si el servicio no toma decisiones de muestreo, los recursos de servicio se colapsarán bajo la fila `Resources not making sampling decisions`.
+**Nota**: Si el servicio no está tomando decisiones de muestreo, los recursos del servicio se colapsarán bajo la fila `Resources not making sampling decisions`.
-**Nota**: En periodos cortos (1-4 horas), la tasa de muestreo efectiva puede mostrarse por debajo del 100 % incluso cuando está configurada al 100 %. Este es un comportamiento esperado debido a los cálculos estadísticos que necesitan más puntos de datos para converger. Todas las trazas se siguen capturando correctamente. Para una visualización más precisa, consulta las tasas de muestreo en periodos más largos.
+**Nota**: En intervalos de tiempo cortos (1-4 horas), la Tasa de Muestreo Efectiva puede mostrar menos del 100% incluso cuando está configurada al 100%. Este es un comportamiento esperado debido a cálculos estadísticos que necesitan más puntos de datos para converger. Todos los rastros aún se están capturando correctamente. Para la visualización más precisa, observe las tasas de muestreo durante períodos de tiempo más largos.
-#### Motivos de ingesta y responsables del muestreo
+#### Razones de ingestión y tomadores de decisiones de muestreo {#ingestion-reasons-and-sampling-decision-makers}
-Explora el **Desglose de motivos del consumo** para ver qué mecanismos son responsables del consumo de tu servicio. Cada motivo del consumo está relacionado con un [mecanismo de consumo][11] específico. Después de cambiar tu configuración del consumo del servicio, puedes observar el aumento o la disminución de los bytes y tramos consumidos en esta gráfica de series temporales basado en los datos consumidos en la última hora.
+Explore el **desglose de razones de ingestión** para ver qué mecanismos son responsables de la ingestión de su servicio. Cada razón de ingestión se relaciona con un mecanismo de ingestión específico [mecanismo de ingestión][11]. Después de cambiar la configuración de ingestión de su servicio, puede observar el aumento o disminución de bytes y tramos ingeridos en este gráfico de series temporales basado en la última hora de datos ingeridos.
-Si la mayor parte de tu volumen de consumo del servicio se debe a decisiones tomadas por servicios upstream, investiga el detalle de la lista principal de los **Tomadores de decisiones de muestreo**. Por ejemplo, si tu servicio es no raíz, (lo que significa que **nunca decide** muestrear trazas), observa todos los servicios upstream responsables de tu consumo del servicio no raíz. Configura los servicios raíz upstream para reducir tu volumen total de consumo.
+Si la mayor parte del volumen de ingestión de su servicio se debe a decisiones tomadas por servicios ascendentes, investigue el detalle de la lista de los **tomadores de decisiones de muestreo**. Por ejemplo, si su servicio no es raíz (es decir, que **nunca decide** muestrear trazas), observe todos los servicios ascendentes responsables de la ingestión de ese servicio. Configure los servicios raíz ascendentes para reducir su volumen total de ingestión.
-Para investigar más a fondo, utiliza [APM Trace - Dashboard de uso estimado][12], que ofrece información sobre el consumo global, así como gráficas de desglose por el `service`, la `env` y el `ingestion reason`.
+Para investigaciones adicionales, utilice el [tablero de Uso Estimado de APM traza][12], que proporciona información global de ingestión así como gráficos de desglose por `service`, `env` y `ingestion reason`.
-#### Versiones del Agent y de las bibliotecas de rastreo
+#### Versiones de Datadog Agent y SDK {#agent-and-sdk-versions}
-Consulta las versiones del **Datadog Agent y de las bibliotecas de rastreo** que utiliza tu servicio. Compara las versiones en uso con las últimas versiones publicadas para asegurarte de estar ejecutando Agents y bibliotecas actualizadas.
+Vea las **versiones de Datadog Agent y SDK** que su servicio está utilizando. Compare las versiones en uso con las versiones más recientes lanzadas para asegurarse de que está utilizando Datadog Agents y bibliotecas recientes y actualizadas.
-{{< img src="tracing/trace_indexing_and_ingestion/agent_tracer_version.png" style="width:90%;" alt="Versiones del Agent y de las bibliotecas de rastreo" >}}
+{{< img src="tracing/trace_indexing_and_ingestion/agent_tracer_version.png" style="width:90%;" alt="Versiones de Agente y SDK" >}}
-### Gestión de las tasas de muestreo de los servicios
+### Gestionando las tasas de muestreo de los servicios {#managing-services-sampling-rates}
-Para controlar las tasas de muestreo de un servicio, es posible que desees utilizar:
-- **Muestreo adaptativo**: ajusta automáticamente las tasas de muestreo para que coincidan con un presupuesto de volumen de ingesta mensual configurado.
-- **Muestreo basado en recursos**: establece manualmente tasas de muestreo explícitas por recurso.
+Para controlar las tasas de muestreo de un servicio, puede que desee utilizar:
+- **Muestreo adaptativo**: Ajustar automáticamente las tasas de muestreo para coincidir con un presupuesto de volumen de ingestión mensual configurado.
+- **Muestreo basado en recursos**: Establecer manualmente tasas de muestreo explícitas por recurso.
-Las configuraciones de estas estrategias pueden aplicarse **de forma remota** a través de la interfaz de usuario de Datadog. Este método permite que los cambios surtan efecto inmediatamente sin necesidad de volver a desplegar el servicio. Para el **muestreo basado en recursos**, también tienes la opción de aplicar las configuraciones **localmente** actualizando los archivos de configuración de tu servicio y volviendo a desplegarlo.
+Las configuraciones para estas estrategias se pueden aplicar **Remotamente** a través de la interfaz de usuario de Datadog. Este método permite que los cambios surtan efecto de inmediato sin necesidad de volver a implementar su servicio. Para **Muestreo basado en recursos**, también tiene la opción de aplicar configuraciones **localmente** actualizando los archivos de configuración de su servicio y volviendo a implementar.
-El uso de **Remote Configuration** para las tasas de ingesta de servicios tiene requisitos específicos.
+El uso de **Configuración Remota** para las tasas de ingestión del servicio tiene requisitos específicos.
-{{% collapse-content title="Requisitos de Remote Configuration" level="h4" expanded="false" id="remote-configuration-requirements" %}}
+{{% collapse-content title="Requisitos de Configuración Remota" level="h4" expanded="false" id="remote-configuration-requirements" %}}
-- Datadog Agent [7.41.1][19] o posterior.
-- [Configuración remota][3] activada para tu Agent.
-- [Permisos] `APM Remote Configuration Write`[20]. Si no tienes estos permisos, pide a tu administrador de Datadog que actualice tus permisos desde Parámetros de organización.
+- Datadog Agent [7.41.1][19] o superior.
+- [Configuración Remota][3] habilitada para su Datadog Agent.
+- `APM Remote Configuration Write` [permisos][20]. Si no tiene estos permisos, pida a su administrador de Datadog que actualice sus permisos desde la configuración de su organización.
-A continuación, se indica la versión mínima de biblioteca de rastreo necesaria para esta función:
+Encuentre a continuación la versión mínima del SDK requerida para la función:
-| Lenguaje | Versión mínima requerida |
+| Idioma | Versión mínima requerida |
|----------|--------------------------|
| Java | v1.34.0 |
| Go | v1.64.0 |
@@ -157,93 +156,93 @@ A continuación, se indica la versión mínima de biblioteca de rastreo necesari
{{% /collapse-content %}}
-#### Muestreo adaptativo
+#### Muestreo adaptativo {#adaptive-sampling}
-Utiliza el muestreo adaptativo para que Datadog gestione las tasas de muestreo de los servicios en tu nombre. Especifica un volumen de ingesta mensual objetivo para uno o varios servicios sin perder de vista todos los servicios y endpoints.
+Utiliza el muestreo adaptativo para permitir que Datadog gestione las tasas de muestreo de los servicios en tu nombre. Especifica un volumen de ingestión mensual objetivo para uno o varios servicios mientras mantienes visibilidad sobre todos los servicios y puntos de conexión.
Para configurar el muestreo adaptativo:
-1. Navega hasta la página [Ingestion Control][2].
-2. Haz clic en un servicio para ver el **Service Ingestion Summary** (Resumen de ingesta de servicios).
-3. Haz clic en **Manage Ingestion Rate** (Gestionar tasa de ingesta).
-4. Elige **Datadog adaptive sampling rates** (Tasas de muestreo adaptativo de Datadog) como estrategia de muestreo de tu servicio.
-5. Haz clic en **Apply** (Aplicar).
+1. Navega a la página de [Ingestion Control][2].
+2. Haz clic en un servicio para ver el **Resumen de Ingestión del Servicio**.
+3. Haz clic en **Gestionar Tasa de Ingestión**.
+4. Elige **tasas de muestreo adaptativo de Datadog** como la estrategia de muestreo de tu servicio.
+5. Haz clic en **Aplicar**.
-
+
-Para más información, consulta [Muestreo adaptativo][17].
+Para más información, consulta [Muestreo Adaptativo][17].
-#### Muestreo basado en recursos
+#### Muestreo basado en recursos {#resource-based-sampling}
Para configurar tasas de muestreo personalizadas para el servicio por nombre de recurso:
-1. Navega hasta la página [Ingestion Control][2].
-2. Haz clic en un servicio para ver el **Service Ingestion Summary** (Resumen de ingesta de servicios).
-3. Haz clic en **Manage Ingestion Rate** (Gestionar tasa de ingesta).
-4. Haz clic en **Custom sampling rates only** (Solo tasas de muestreo personalizadas).
-5. Haz clic en **Add new rule** (Añadir nueva regla) para establecer tasas de muestreo para algunos recursos.
- **Nota**: Las reglas de muestreo utilizan la coincidencia de patrones glob, por lo que puedes utilizar comodines (`*`) para coincidir con varios recursos al mismo tiempo.
- {{< img src="/tracing/trace_indexing_and_ingestion/sampling_configuration_custom.png" alt="Modal de configuración" style="width:100%;">}}
+1. Navega a la página de [Ingestion Control][2].
+2. Haz clic en un servicio para ver el **Resumen de Ingestión del Servicio**.
+3. Haz clic en **Gestionar tasa de ingestión**.
+4. Haz clic en **Solo tasas de muestreo personalizadas**.
+5. Haz clic en **Agregar nueva regla** para establecer tasas de muestreo para algunos recursos.
+ **Nota**: Las reglas de muestreo utilizan coincidencia de patrones globos, por lo que puedes usar comodines (`*`) para coincidir con múltiples recursos al mismo tiempo.
+ {{< img src="/tracing/trace_indexing_and_ingestion/sampling_configuration_custom.png" alt="Modal de Configuración" style="width:100%;">}}
6. Aplica la configuración **Remotamente** o **Localmente**:
{{< tabs >}}
-{{% tab "Remotely" %}}
+{{% tab "Remotamente" %}}
-Esta opción aplica la configuración mediante Remote Configurtion, por lo que **no es necesario** volver a desplegar el servicio para que el cambio surta efecto. Puedes observar los cambios de configuración desde [Live Search Explorer][100].
+Esta opción aplica la configuración utilizando Configuración Remota, por lo que **no necesitas** volver a implementar el servicio para que el cambio surta efecto. Puedes observar los cambios de configuración desde el [Explorador de Búsqueda en Vivo][100].
-Haz clic en **Apply** (Aplicar) para guardar la configuración.
+Haz clic en **Aplicar** para guardar la configuración.
-Los recursos que se han configurado remotamente aparecen como `Configured Remote` en la columna **Configuration** (Configuración).
+Los recursos que han sido configurados de forma remota se muestran como `Configured Remote` en la columna de **Configuración**.
-
+
[100]: /es/tracing/trace_explorer/?tab=listview#live-search-for-15-minutes
{{% /tab %}}
-{{% tab "Locally" %}}
+{{% tab "Localmente" %}}
-Esta opción genera la configuración para que la apliques manualmente.
+Esta opción genera configuración para que la apliques manualmente.
1. Aplica la configuración generada a tu servicio.
- **Nota**: El valor del nombre del servicio distingue mayúsculas y minúsculas. Debe coincidir con el nombre de tu servicio.
-1. Vuelve a desplegar el servicio.
-1. Confirma que se ha aplicado el nuevo porcentaje consultando la columna **Traffic Breakdown** (Desglose del tráfico). Los recursos que se han configurado localmente aparecen como `Configured Local` en la columna **Configuration** (Configuración).
+ **Nota**: El valor del nombre del servicio es sensible a mayúsculas y minúsculas. Debería coincidir con el caso de tu nombre de servicio.
+1. Vuelve a implementar el servicio.
+1. Confirma que el nuevo porcentaje ha sido aplicado revisando la columna de **Desglose de Tráfico**. Los recursos que han sido configurados localmente se muestran como `Configured Local` en la columna de **Configuración**.
{{% /tab %}}
{{< /tabs >}}
-## Gestión de la configuración de la ingesta del Datadog Agent
+## Gestionando la configuración de ingesta del Agente de Datadog {#managing-datadog-agent-ingestion-configuration}
-Haz clic en **Configure Datadog Agent Ingestion** (Configurar la ingesta del Datadog Agent) para gestionar las tasas de muestreo por defecto basadas en encabezados, el muestreo de errores y el muestreo poco frecuente.
+Haz clic en **Configurar la Ingesta del Agente de Datadog** para gestionar las tasas de muestreo basadas en encabezados por defecto, muestreo de errores y muestreo raro.
-{{< img src="tracing/trace_indexing_and_ingestion/agent_level_configurations_modal.png" style="width:70%;" alt="Modalidad de configuración en el nivel del Agent" >}}
+{{< img src="tracing/trace_indexing_and_ingestion/agent_level_configurations_modal.png" style="width:70%;" alt="Modal de Configuración a Nivel de Agente" >}}
-- **[Head-based sampling][4]** (Muestreo basado en la fase inicial): Cuando no se establecen reglas para el muestreo de un servicio, el Datadog Agent calcula automáticamente las frecuencias de muestreo que se aplicarán a tus servicios con un objetivo de **10 trazas por segundo por Agent**. Cambia este número de destino de trazas en Datadog o configura `DD_APM_MAX_TPS` localmente en el nivel del Agent.
-- **[Muestreo de tramos (spans) de error][5]**: Para las trazas no capturadas por el muestreo basado en la fase inicial, el Datadog Agent captura trazas de error locales **hasta 10 trazas por segundo por Agent**. Cambia este número de destino de trazas en Datadog o configura `DD_APM_ERROR_TPS` localmente en el nivel del Agent.
-- **[Muestreo de tramos poco frecuentes][6]**: Para las trazas no capturadas por el muestreo basado en la fase inicial, el Datadog Agent captura trazas poco frecuentes locales **hasta 5 trazas por segundo por Agent**. Esta opción está desactivada por defecto. Habilita la recopilación de trazas poco frecuentes en Datadog o configura `DD_APM_ENABLE_RARE_SAMPLER` localmente en el nivel del Agent.
+- **[Muestreo basado en encabezado][4]**: Cuando no se establecen reglas de muestreo para un servicio, el Agente de Datadog calcula automáticamente las tasas de muestreo que se aplicarán a tus servicios, apuntando a **10 trazas por segundo por Agente**. Cambia este número objetivo de trazas en Datadog, o configúralo `DD_APM_TARGET_TPS` localmente a nivel de Agente.
+- **[Muestreo de errores en trazas][5]**: Para las trazas que no son capturadas por el muestreo basado en encabezado, el Agente de Datadog captura trazas de errores locales **hasta 10 trazas por segundo por Agente**. Cambia este número objetivo de trazas en Datadog, o establece `DD_APM_ERROR_TPS` localmente a nivel del Agente.
+- **[Muestreo de trazas raras][6]**: Para trazas que no son capturadas por el muestreo basado en encabezado, el Agente de Datadog captura trazas raras locales **hasta 5 trazas por segundo por Agente**. Esta configuración está deshabilitada por defecto. Habilita la recolección de trazas raras en Datadog, o establece `DD_APM_ENABLE_RARE_SAMPLER` localmente a nivel del Agente.
-Con la configuración remota, no es necesario reiniciar el Agent para actualizar estos parámetros. Haz clic en `Apply` para guardar los cambios de configuración, y la nueva configuración entrará en vigor inmediatamente. La configuración remota de los parámetros de muestreo del Agent está disponible si utilizas el Agent versión [7.42.0][13] o posterior.
+Con la configuración remota, no es necesario reiniciar el Agente para actualizar estos parámetros. Haz clic en `Apply` para guardar los cambios de configuración, y la nueva configuración entra en efecto de inmediato. La configuración remota para los parámetros de muestreo del Agente está disponible si estás utilizando la versión del Agente [7.42.0][13] o superior.
-**Nota**: La sección `Other Ingestion Reasons` (gris) del gráfico circular representa otros motivos de ingesta que _no son configurables_ en el nivel del Datadog Agent.
+**Nota**: La sección `Other Ingestion Reasons` (gris) del gráfico circular representa otras razones de ingestión que _no son configurables_ a nivel del Agente de Datadog.
-**Nota**: Los parámetros configurados en forma remota tienen prioridad sobre las configuraciones locales como las variables de entorno y la configuración de `datadog.yaml`.
+**Nota**: Los parámetros configurados de forma remota tienen prioridad sobre las configuraciones locales, como las variables de entorno y `datadog.yaml` la configuración.
-## Precedencia de las reglas de muestreo
+## Prioridad de las reglas de muestreo {#sampling-rules-precedence}
-Si las reglas de muestreo se establecen en varias ubicaciones, se aplican las siguientes reglas de precedencia en orden, donde las reglas que aparecen en primer lugar en la lista pueden anular las reglas de precedencia inferior:
+Si se establecen reglas de muestreo en múltiples ubicaciones, se aplican las siguientes reglas de prioridad en orden, donde las reglas que aparecen primero en la lista pueden anular las reglas de menor prioridad:
-1. Reglas de muestreo configuradas remotamente, establecidas a través de [muestreo basado en recursos](#configure-the-service-ingestion-rates-by-resource)
+1. Reglas de muestreo configuradas de forma remota, establecidas a través de [muestreo basado en recursos](#configure-the-service-ingestion-rates-by-resource)
1. [Reglas de muestreo adaptativo][17]
1. [Reglas de muestreo configuradas localmente][8] (`DD_TRACE_SAMPLING_RULES`)
-1. [Tasa de muestreo global configurada remotamente][8]
+1. [Tasa de muestreo global configurada de forma remota][8]
1. [Tasa de muestreo global configurada localmente][8] (`DD_TRACE_SAMPLE_RATE`)
-1. [Tasas del trace agent controladas indirectamente con la configuración del Agent](#managing-datadog-agent-ingestion-configuration) de forma remota o local (`DD_APM_MAX_TPS`)
+1. [Tasas del agente de traza controladas indirectamente con configuraciones del Agent](#managing-datadog-agent-ingestion-configuration) de forma remota o local (`DD_APM_TARGET_TPS`)
-En otras palabras, Datadog utiliza las siguientes reglas de precedencia:
-- Configuración del rastreador > configuración del Agent
+Dicho de otra manera, Datadog utiliza las siguientes reglas de precedencia:
+- Configuraciones del trazador > Configuraciones del Agent
- Reglas de muestreo > Tasa de muestreo global
- Remoto > Local
-## Referencias adicionales
+## Lectura adicional {#further-reading}
{{< partial name="whats-next/whats-next.html" >}}
diff --git a/content/fr/account_management/billing/custom_metrics.md b/content/fr/account_management/billing/custom_metrics.md
index 957159f3d89..f915ac0861b 100644
--- a/content/fr/account_management/billing/custom_metrics.md
+++ b/content/fr/account_management/billing/custom_metrics.md
@@ -1,116 +1,117 @@
---
+algolia:
+ tags:
+ - custom metrics billing
aliases:
- /fr/integrations/faq/what-standard-integrations-emit-custom-metrics/
further_reading:
-- link: /observability_pipelines/guide/custom-metrics-governance
+- link: /metrics/custom_metrics/
tag: Documentation
- text: Utiliser des pipelines d'observabilité pour contrôler vos métriques custom
+ text: En savoir plus sur les métriques personnalisées
+- link: /metrics/guide/custom_metrics_governance/
+ tag: Guide
+ text: Meilleures pratiques pour la gouvernance des métriques personnalisées
title: Facturation des métriques custom
---
+## Aperçu {#overview}
-Si une métrique n'est pas envoyée depuis l'une des [plus de {{< translate key="integration_count" >}} intégrations Datadog][1], elle est considérée comme une [métrique custom][2][(1)](#integrations-standard).
+Si une métrique n'est pas soumise par l'une des [plus de {{< translate key="integration_count" >}} intégrations Datadog][1], elle est considérée comme une [métrique personnalisée][2]. Certaines intégrations standard peuvent également potentiellement émettre des métriques personnalisées. Pour plus d'informations, voir [métriques personnalisées et intégrations standard][14].
-**Une métrique custom correspond à une combinaison unique de nom de métrique et de valeurs de tag (y compris le tag du host)**. En général, les métriques envoyées par [DogStatsD][25] ou via un [check d'Agent custom][26] sont des métriques custom.
+**Une métrique personnalisée est identifiée de manière unique par une combinaison d'un nom de métrique et de valeurs de balise (y compris la balise hôte)**. En général, toute métrique que vous envoyez en utilisant [DogStatsD][3] ou via un [Agent Check personnalisé][4] est une métrique personnalisée.
-Le nombre de métriques custom mensuelles facturables (qui est indiqué sur la page Usage) est calculé à partir de la formule suivante : Total de métriques custom distinctes pour chaque heure d'un mois donné / nombre d'heures du mois. Cette formule permet d'obtenir une moyenne mensuelle.
+Votre utilisation mensuelle des métriques personnalisées facturables (réflétée sur la page d'utilisation) est calculée en prenant le total de toutes les métriques personnalisées distinctes (également connues sous le nom de séries temporelles) pour chaque heure d'un mois donné, et en le divisant par le nombre d'heures dans le mois pour obtenir une valeur moyenne mensuelle. Votre utilisation facturable n'est pas impactée par la fréquence de soumission des points de données ou le nombre de requêtes que vous exécutez sur vos métriques.
-Les utilisateurs de Metrics without Limits™ peuvent consulter les volumes mensuels facturables pour les métriques custom _ingérées_ et _indexées_ sur leur page Usage. En savoir plus sur les métriques custom ingérées et indexées et sur la solution [Metrics without Limits™][3].
+Les utilisateurs de Metrics without Limits™ voient les volumes mensuels facturables pour _ingérés_ et _indexés_ des métriques personnalisées sur leur page d'utilisation. En savoir plus sur les métriques personnalisées ingérées et indexées et [Metrics without Limits™][5].
-## Calcul du nombre de métriques custom
+## Comptage des métriques personnalisées {#counting-custom-metrics}
-Le nombre de métriques custom associées à un nom de métrique donné dépend du [type de métrique envoyé][4]. Vous trouverez ci-dessous des exemples de calculs basés sur le scénario suivant :
+Le nombre de métriques personnalisées associées à un nom de métrique particulier dépend de son [type de soumission de métrique][6]. Voici des exemples de la façon de compter vos métriques personnalisées en fonction du scénario suivant :
-Une métrique intitulée `request.Latency` est envoyée à partir de deux hosts (`host:A`,`host:B`) afin de mesurer la latence des requêtes envoyées à vos endpoints. Vous envoyez cette métrique avec deux clés de tag :
+Supposons que vous soumettiez une métrique, `request.Latency`, depuis deux hôtes (`host:A`,`host:B`), qui mesure la latence de vos requêtes d'endpoint. Vous soumettez cette métrique avec deux clés de balise :
-- `endpoint`, qui a pour valeur `endpoint:X` ou `endpoint:Y` ;
-- `status`, qui a pour valeur `status:200` ou `status:400`.
+- `endpoint`, qui a la valeur `endpoint:X` ou `endpoint:Y`.
+- `status`, qui a la valeur `status:200` ou `status:400`.
-Imaginons que dans vos données, `endpoint:X` est pris en charge par les deux hosts mais échoue uniquement pour `host:B`. Imaginons également que les requêtes envoyées à `endpoint:Y` réussissent toujours et apparaissent uniquement pour `host:B`, comme illustré ci-dessous :
+Supposons que dans vos données, `endpoint:X` soit pris en charge par les deux hôtes, mais échoue uniquement sur `host:B`. Supposons également que les demandes à `endpoint:Y` soient toujours réussies et n'apparaissent que sur `host:B` comme indiqué ci-dessous :
-{{< img src="account_management/billing/custom_metrics/request_latency.png" alt="Latence des requêtes" style="width:80%;">}}
+{{< img src="account_management/billing/custom_metrics/request_latency.png" alt="Latence de la demande" style="width:80%;">}}
{{< tabs >}}
-{{% tab "Count, Rate"%}}
+{{% tab "Nombre, Taux"%}}
La même logique est appliquée pour calculer le nombre de métriques custom pour les métriques de type [COUNT][1] et [RATE][2].
-Le nombre de combinaisons de valeurs de tag uniques envoyées pour une métrique RATE avec ce schéma de tagging est de **quatre** :
+Le nombre de combinaisons de valeurs de balises uniques soumises pour une métrique de TAUX avec ce schéma de balisage est **quatre** :
- `host:A`, `endpoint:X`, `status:200`
- `host:B`, `endpoint:X`, `status:200`
- `host:B`, `endpoint:X`, `status:400`
- `host:B`, `endpoint:Y`, `status:200`
-Ici, la métrique `request.Latency` envoie donc **quatre métriques custom**.
+Cela se traduit par `request.Latency` rapportant **quatre métriques personnalisées**.
-### Conséquences de l'ajout de tags
+### Effet de l'ajout de balises {#effect-of-adding-tags}
-L'ajout de tags **n'augmente pas forcément** le nombre de métriques custom. Le nombre de métriques custom dépend généralement du tag le plus granulaire ou le plus détaillé. Imaginons que vous mesurez la température aux États-Unis et que votre métrique `temperature` est taguée en fonction du pays et de la région. Vous envoyez ce qui suit à Datadog :
+L'ajout de balises **peut ne pas** entraîner plus de métriques personnalisées. Votre nombre de métriques personnalisées évolue généralement avec la balise la plus granulaire ou détaillée. Supposons que vous mesuriez la température aux États-Unis, et que vous ayez étiqueté votre `temperature` métrique par pays et région. Vous soumettez ce qui suit à Datadog :
-| Nom de la métrique | Valeurs de tag |
+| Nom de la métrique | Valeurs de balises |
|---------------|------------------------------------|
| `temperature` | `country:USA`, `region: Northeast` |
| `temperature` | `country:USA`, `region: Southeast` |
-Imaginons que vous souhaitiez ajouter le tag `city`, qui prend trois valeurs différentes : `NYC`, `Miami` et `Orlando`. Comme le montre le tableau ci-dessous, l'ajout de ce tag augmente le nombre de métriques custom étant donné qu'il rend vos données plus granulaires :
+Supposons que vous souhaitiez ajouter la balise `city` qui a trois valeurs : `NYC`, `Miami` et `Orlando`. L'ajout de cette balise augmente le nombre de métriques personnalisées car elle fournit plus de détails et de granularité à votre ensemble de données comme indiqué ci-dessous :
-| Nom de la métrique | Valeurs de tag |
+| Nom de la métrique | Valeurs de balises |
|---------------|-----------------------------------------------------|
| `temperature` | `country:USA`, `region: Northeast`, `city: NYC` |
| `temperature` | `country:USA`, `region: Southeast`, `city: Orlando` |
| `temperature` | `country:USA`, `region: Southeast`, `city: Miami` |
-Le nombre de métriques custom envoyées par la métrique `temperature` dépend du tag le plus granulaire, c'est-à-dire `city`.
+Le nombre de métriques personnalisées rapportées par `temperature` évolue avec le tag le plus granulaire, `city`.
-Imaginons que vous souhaitiez appliquer le tag `state` à votre métrique `temperature`, et que ce tag prenne deux valeurs : `NY` et `Florida`. La température est alors associée aux tags suivants : `country`, `region`, `state` et `city`. La granularité du tag `state` n'étant pas supérieure à celle du tag `city`, l'ajout de ce tag n'augmente pas la granularité de vos données.
+Supposons que vous souhaitiez également taguer votre métrique de température par `state` (qui a deux valeurs : `NY` et `Florida`). Cela signifie que vous taguez la température par les tags : `country`, `region`, `state` et `city`. Ajouter le tag d'état n'augmente pas le niveau de granularité déjà présent dans votre ensemble de données fourni par le tag de la ville.
Pour connaître la température en Floride, vous pouvez combiner les métriques custom suivantes :
- `temperature{country:USA, state:Florida, city:Orlando}`
- `temperature{country:USA, state:Florida, city:Miami}`
-**Remarque** : l'ordre des tags n'a pas d'influence sur le nombre de métriques custom. Les combinaisons suivantes correspondent à la même métrique custom :
+**Remarque** : Le réordonnancement des valeurs de tag n'ajoute pas d'unicité. Les combinaisons suivantes sont la même métrique personnalisée :
- `temperature{country:USA, state:Florida, city:Miami}`
- `temperature{state:Florida, city:Miami, country:USA}`
-### Configurer des tags et des agrégations avec Metrics without Limits™
-
-La configuration de tags et d'agrégations à l'aide de [Metrics without Limits™][3] peut avoir une incidence sur les volumes de métriques custom. Metrics without Limits™ dissocie les coûts d'ingestion des coûts d'indexation. Ainsi, vous pouvez continuer à envoyer toutes vos données à Datadog (toutes les informations sont ingérées) et ajouter des tags à une liste d'autorisation afin que seuls ces tags puissent être interrogés sur la plateforme Datadog. Comme le volume de données ingérées par Datadog pour les métriques que vous avez configurées est maintenant différent du volume de données indexées, qui est plus petit, deux volumes distincts s'affichent sur votre page Usage et sur la page Metrics Summary.
+### Configurer des tags avec Metrics without Limits™ {#configure-tags-with-metrics-without-limits}
-- **Ingested Custom Metrics** : le volume initial de métriques custom basé sur tous les tags ingérés (qui ont été envoyés par le code).
-- **Indexed Custom Metrics** : le volume de métriques custom pouvant être interrogées sur la plateforme Datadog (en fonction des configurations Metrics without Limits™).
+Les volumes de métriques personnalisées peuvent être impactés par la configuration des tags en utilisant [Metrics without Limits™][3]. Metrics without Limits™ découple les coûts d'ingestion des coûts d'indexation -- vous pouvez continuer à envoyer à Datadog toutes vos données (tout est ingéré) et vous pouvez spécifier une liste blanche de tags que vous souhaitez garder interrogeables sur la plateforme Datadog. Étant donné que le volume de données que Datadog ingère pour vos métriques configurées diffère maintenant du volume plus petit restant que vous avez indexé, vous verrez deux volumes distincts sur votre page d'utilisation ainsi que sur la page de résumé des métriques.
+
+- **Métriques personnalisées ingérées** : Le volume original de métriques personnalisées basé sur tous les tags ingérés (envoyés par code)
+- **Métriques personnalisées indexées** : Le volume de métriques personnalisées qui reste interrogeable sur la plateforme Datadog (basé sur toute configuration de Metrics without Limits™)
-**Remarque : seules les métriques configurées rentrent en compte dans le calcul du volume des métriques custom.** Si vous n'avez pas configuré Metrics without Limits™ pour une métrique, seul le volume des métriques custom indexées vous est facturé.
+**Remarque : Seules les métriques configurées contribuent à votre volume de métriques personnalisées ingérées.** Si une métrique n'est pas configurée avec Metrics without Limits™, vous ne payez que pour son volume de métriques personnalisées indexées.
-#### Dans quels cas les métriques custom ingérées ou indexées vous sont-elles facturées ?
-Pour les métriques non configurées avec Metrics without Limits™, vous payez pour les métriques custom indexées.
+#### Quand êtes-vous facturé pour les métriques ingérées par rapport aux métriques indexées ? {#when-are-you-charged-for-ingested-vs-indexed-custom-metrics}
+Pour les métriques non configurées avec Metrics without Limits™, vous payez pour les métriques personnalisées indexées.
-| | Métriques custom indexées
(en fonction du nombre moyen mensuel de métriques custom par heure) |
+| | Métriques personnalisées indexées
(basées sur le nombre moyen mensuel de métriques personnalisées par heure) |
|--------------------------------------|-------------------------------------------------------------------------------------------------------------------------------|
-| Quota de l'abonnement | - Pro : 100 métriques custom indexées par host
- Enterprise : 200 métriques custom indexées par host |
-| Dépassement du quota | Si vous dépassez le quota de votre abonnement, chaque palier de 100 métriques custom indexées supplémentaires vous est facturé le montant indiqué dans votre contrat actuel. |
+| Allocation de compte | - Pro : 100 métriques personnalisées indexées par hôte
- Entreprise : 200 métriques personnalisées indexées par hôte |
+| Utilisation supérieure à l'allocation de compte | Pour chaque 100 métriques personnalisées ingérées au-delà de l'allocation de compte, vous payez 0,10 $. Pour chaque 100 métriques personnalisées indexées au-delà de l'allocation de compte, vous payez un montant spécifié dans votre contrat actuel. |
-Pour les métriques configurées avec Metrics without Limits™ (des tags/agrégations sont configurés), vous payez pour les métriques custom ingérées et les métriques custom indexées.
+Pour les métriques configurées avec Metrics without Limits™ (les balises sont configurées), vous payez pour les métriques personnalisées ingérées et les métriques personnalisées indexées.
-| | Métriques custom ingérées | Indexed Custom Metrics |
+| | Métriques personnalisées ingérées | Métriques personnalisées indexées |
|--------------------------------------|---------------------------------------------------------------------------------------------------|-------------------------------------------------------------------------------------------------------------------------------|
-| Quota de l'abonnement | - Pro : 100 métriques custom ingérées par host
- Enterprise : 200 métriques custom ingérées par host | - Pro : 100 métriques custom indexées par host
- Enterprise : 200 métriques custom indexées par host |
-| Dépassement du quota | Si vous dépassez le quota de votre abonnement, chaque palier de 100 métriques custom ingérées supplémentaires vous est facturé 0,10 $. | Si vous dépassez le quota de votre abonnement, chaque palier de 100 métriques custom indexées supplémentaires vous est facturé le montant indiqué dans votre contrat actuel. |
+| Allocation de compte | - Pro : 100 métriques personnalisées ingérées par hôte
- Entreprise : 200 métriques personnalisées ingérées par hôte | - Pro : 100 métriques personnalisées indexées par hôte
- Entreprise : 200 métriques personnalisées indexées par hôte |
+| Utilisation supérieure à l'allocation de compte | Pour chaque 100 métriques personnalisées ingérées au-delà de l'allocation de compte, vous payez 0,10 $. | Pour chaque 100 métriques personnalisées indexées au-delà de l'allocation de compte, vous payez un montant spécifié dans votre contrat actuel. |
-Imaginons que vous souhaitiez utiliser Metrics without Limits™ pour réduire le volume de votre métrique `request.Latency` en conservant uniquement les tags `endpoint` et `status`. Vous obtenez les trois combinaisons de tags uniques suivantes :
+Supposons que vous souhaitiez utiliser Metrics without Limits™ pour réduire la taille de votre `request.Latency` métrique en ne conservant que les balises `endpoint` et `status`. Cela donne les trois combinaisons de balises uniques suivantes :
- `endpoint:X`, `status:200`
- `endpoint:X`, `status:400`
- `endpoint:Y`, `status:200`
-Une ces tags configurés, la métrique `request.Latency` envoie **3 métriques custom indexées** au total. En se basant sur les tags envoyés initialement sur cette métrique, le volume initial de métriques custom **ingérées** pour la métrique `request.Latency` est de **4 métriques custom ingérées**.
-
-Par défaut, Datadog stocke la combinaison des agrégations les plus souvent interrogées en fonction du type de métrique afin d'assurer la précision mathématique de la requête associée à la métrique que vous avez configurée.
-
-- Les métriques count/rate configurées peuvent être interrogées à l'aide d'agrégations temporelles/spatiales de type `SUM`.
-
-Vous pouvez ajouter d'autres agrégations en cas de besoin. Le nombre de métriques custom indexées dépend du nombre d'agrégations activées.
+En raison de la configuration des balises, `request.Latency` rapportant un total de **3 métriques personnalisées indexées** . Sur la base des balises d'origine envoyées sur cette métrique, le volume original de **métriques personnalisées ingérées** de `request.Latency` est **4 métriques personnalisées ingérées**.
En savoir plus sur [Metrics without Limits™][3].
@@ -119,25 +120,25 @@ En savoir plus sur [Metrics without Limits™][3].
[3]: /fr/metrics/metrics-without-limits
{{% /tab %}}
{{% tab "Gauge" %}}
-Le nombre de combinaisons de valeurs de tag uniques envoyées pour une métrique GAUGE avec ce schéma de tagging est de **quatre** :
+Le nombre de combinaisons de valeurs de balises uniques soumises pour une métrique GAUGE avec ce schéma de balisage est **quatre** :
- `host:A`, `endpoint:X`, `status:200`
- `host:B`, `endpoint:X`, `status:200`
- `host:B`, `endpoint:X`, `status:400`
- `host:B`, `endpoint:Y`, `status:200`
-Ici, la métrique `request.Latency` envoie donc **quatre métriques custom**.
+Cela se traduit par `request.Latency` rapportant **quatre métriques personnalisées**.
-### Conséquences de l'ajout de tags
+### Effet de l'ajout de balises {#effect-of-adding-tags-1}
-L'ajout de tags **n'augmente pas forcément** le nombre de métriques custom. Le nombre de métriques custom dépend généralement du tag le plus granulaire ou le plus détaillé. Imaginons que vous mesurez la température aux États-Unis et que votre métrique `temperature` est taguée en fonction du pays et de la région. Vous envoyez ce qui suit à Datadog :
+L'ajout de balises **peut ne pas** entraîner plus de métriques personnalisées. Votre nombre de métriques personnalisées évolue généralement avec la balise la plus granulaire ou détaillée. Supposons que vous mesuriez la température aux États-Unis, et que vous ayez étiqueté votre `temperature` métrique par pays et région. Vous soumettez ce qui suit à Datadog :
-| Nom de la métrique | Valeurs de tag |
+| Nom de la métrique | Valeurs de balises |
|---------------|------------------------------------|
| `temperature` | `country:USA`, `region: Northeast` |
| `temperature` | `country:USA`, `region: Southeast` |
-Imaginons que vous souhaitiez ajouter le tag `city`, qui prend trois valeurs différentes : `NYC`, `Miami` et `Orlando`. Comme le montre le tableau ci-dessous, l'ajout de ce tag augmente le nombre de métriques custom étant donné qu'il rend vos données plus granulaires :
+Supposons que vous souhaitiez ajouter la balise `city` qui a trois valeurs : `NYC`, `Miami` et `Orlando`. L'ajout de ce tag augmente le nombre de métriques personnalisées car il fournit plus de détail et de granularité à votre ensemble de données, comme indiqué ci-dessous :
| Nom de la métrique | Valeurs de tag |
|---------------|-----------------------------------------------------|
@@ -145,49 +146,55 @@ Imaginons que vous souhaitiez ajouter le tag `city`, qui prend trois valeurs dif
| `temperature` | `country:USA`, `region: Southeast`, `city: Orlando` |
| `temperature` | `country:USA`, `region: Southeast`, `city: Miami` |
-Le nombre de métriques custom envoyées par la métrique `temperature` dépend du tag le plus granulaire, c'est-à-dire `city`.
+Le nombre de métriques personnalisées rapportées par `temperature` évolue avec le tag le plus granulaire, `city`.
-Imaginons que vous souhaitiez appliquer le tag `state` à votre métrique `temperature`, et que ce tag prenne deux valeurs : `NY` et `Florida`. La température est alors associée aux tags suivants : `country`, `region`, `state` et `city`. La granularité du tag `state` n'étant pas supérieure à celle du tag `city`, l'ajout de ce tag n'augmente pas la granularité de vos données.
+Supposons que vous souhaitiez également étiqueter votre métrique de température par `state` (qui a deux valeurs : `NY` et `Florida`). Cela signifie que vous étiquetez la température par `country`, `region`, `state`, et `city`. Ajouter le tag état n'augmente pas le niveau de granularité déjà présent dans votre ensemble de données fourni par le tag ville.
Pour connaître la température en Floride, vous pouvez combiner les métriques custom suivantes :
- `temperature{country:USA, state:Florida, city:Orlando}`
- `temperature{country:USA, state:Florida, city:Miami}`
-**Remarque** : l'ordre des tags n'a pas d'influence sur le nombre de métriques custom. Les combinaisons suivantes correspondent à la même métrique custom :
+**Remarque **: Le réordonnancement des valeurs de tag n'ajoute pas d'unicité. Les combinaisons suivantes sont la même métrique personnalisée :
- `temperature{country:USA, state:Florida, city:Miami}`
- `temperature{state:Florida, city:Miami, country:USA}`
-### Configurer des tags et des agrégations avec Metrics without Limits™
-
-La configuration de tags et d'agrégations à l'aide de [Metrics without Limits™][3] peut avoir une incidence sur les volumes de métriques custom. Metrics without Limits™ dissocie les coûts d'ingestion des coûts d'indexation. Ainsi, vous pouvez continuer à envoyer toutes vos données à Datadog (toutes les informations sont ingérées) et ajouter des tags à une liste d'autorisation afin que seuls ces tags puissent être interrogés sur la plateforme Datadog. Comme le volume de données ingérées par Datadog pour les métriques que vous avez configurées est maintenant différent du volume de données indexées, qui est plus petit, deux volumes distincts s'affichent sur votre page Usage et sur la page Metrics Summary.
+### Configurer des tags avec Metrics without Limits™ {#configure-tags-with-metrics-without-limits-1}
-- **Ingested Custom Metrics** : le volume initial de métriques custom basé sur tous les tags ingérés (qui ont été envoyés par le code).
-- **Indexed Custom Metrics** : le volume de métriques custom pouvant être interrogées sur la plateforme Datadog (en fonction des configurations Metrics without Limits™).
+Les volumes de métriques personnalisées peuvent être impactés par la configuration des tags utilisant [Metrics without Limits™][4]. Metrics without Limits™ découple les coûts d'ingestion des coûts d'indexation -- vous pouvez donc continuer à envoyer à Datadog toutes vos données (tout est ingéré) et vous pouvez spécifier une liste blanche de tags que vous souhaitez garder interrogeables sur la plateforme Datadog. Étant donné que le volume de données que Datadog ingère pour vos métriques configurées diffère maintenant du volume plus petit restant que vous avez indexé, vous verrez deux volumes distincts sur votre page d'utilisation ainsi que sur la page de résumé des métriques.
+
+- **Métriques personnalisées ingérées** : Le volume original de métriques personnalisées basé sur tous les tags ingérés (envoyés par code)
+- **Métriques personnalisées indexées** : Le volume de métriques personnalisées qui reste interrogeable sur la plateforme Datadog (basé sur toute configuration de Metrics without Limits™)
-**Remarque : seules les métriques configurées rentrent en compte dans le calcul du volume des métriques custom.** Si vous n'avez pas configuré Metrics without Limits™ pour une métrique, seul le volume des métriques custom indexées vous est facturé.
+**Remarque : Seules les métriques configurées contribuent à votre volume de métriques personnalisées ingérées.** Si une métrique n'est pas configurée avec Metrics without Limits™, vous ne payez que pour son volume de métriques personnalisées indexées.
-#### Dans quels cas les métriques custom ingérées ou indexées vous sont-elles facturées ?
-Pour les métriques non configurées avec Metrics without Limits™, vous payez pour les métriques custom indexées.
+#### Quand êtes-vous facturé pour les métriques ingérées par rapport aux métriques indexées ? {#when-are-you-charged-for-ingested-vs-indexed-custom-metrics-1}
+Pour les métriques non configurées avec Metrics without Limits™, vous payez pour les métriques personnalisées indexées.
-| | Métriques custom indexées
(en fonction du nombre moyen mensuel de métriques custom par heure) |
+| | Métriques personnalisées indexées
(basées sur le nombre moyen mensuel de métriques personnalisées par heure) |
|--------------------------------------|-------------------------------------------------------------------------------------------------------------------------------|
-| Quota de l'abonnement | - Pro : 100 métriques custom indexées par host
- Enterprise : 200 métriques custom indexées par host |
-| Dépassement du quota | Si vous dépassez le quota de votre abonnement, chaque palier de 100 métriques custom indexées supplémentaires vous est facturé le montant indiqué dans votre contrat actuel. |
+| Allocation de compte | - Pro : 100 métriques personnalisées indexées par hôte
- Entreprise : 200 métriques personnalisées indexées par hôte |
+| Utilisation supérieure à l'allocation de compte | Pour chaque 100 métriques personnalisées indexées au-delà de l'allocation de compte, vous payez un montant spécifié dans votre contrat actuel. |
-Pour les métriques configurées avec Metrics without Limits™ (des tags/agrégations sont configurés), vous payez pour les métriques custom ingérées et les métriques custom indexées.
+Pour les métriques configurées avec Metrics without Limits™ (les tags sont configurés), vous payez pour les métriques personnalisées ingérées et les métriques personnalisées indexées.
-| | Métriques custom ingérées | Indexed Custom Metrics |
+| | Métriques personnalisées ingérées | Métriques personnalisées indexées |
|--------------------------------------|---------------------------------------------------------------------------------------------------|-------------------------------------------------------------------------------------------------------------------------------|
-| Quota de l'abonnement | - Pro : 100 métriques custom ingérées par host
- Enterprise : 200 métriques custom ingérées par host | - Pro : 100 métriques custom indexées par host
- Enterprise : 200 métriques custom indexées par host |
-| Dépassement du quota | Si vous dépassez le quota de votre abonnement, chaque palier de 100 métriques custom ingérées supplémentaires vous est facturé 0,10 $. | Si vous dépassez le quota de votre abonnement, chaque palier de 100 métriques custom indexées supplémentaires vous est facturé le montant indiqué dans votre contrat actuel. |
-
-Par défaut, Datadog stocke de la façon suivante la combinaison des agrégations les plus souvent interrogées en fonction du type de métrique afin d'assurer la précision mathématique de la requête associée à la métrique que vous avez configurée :
+| Allocation de compte | - Pro : 100 métriques personnalisées ingérées par hôte
- Entreprise : 200 métriques personnalisées ingérées par hôte | - Pro : 100 métriques personnalisées indexées par hôte
- Entreprise : 200 métriques personnalisées indexées par hôte |
+| Utilisation supérieure à l'allocation de compte | Pour chaque 100 métriques personnalisées ingérées au-delà de l'allocation de compte, vous payez 0,10 $. | Pour chaque 100 métriques personnalisées indexées au-delà de l'allocation de compte, vous payez un montant spécifié dans votre contrat actuel. |
-- Les métriques gauge configurées peuvent être interrogées à l'aide d'agrégations temporelles/spatiales de type `AVG/AVG`.
+Par défaut, les agrégations suivantes peuvent être utilisées pour les requêtes :
+- grouper par `SUM` et rollup par `AVG`
+- grouper par `MAX` et rollup par `AVG`
+- grouper par `MIN` et rollup par `AVG`
+- grouper par `AVG` et rollup par `SUM`
+- grouper par `SUM` et rollup par `SUM`
+- grouper par `MAX` et rollup par `MAX`
+- grouper par `MIN` et rollup par `MIN`
+- grouper par `SUM` et rollup par `COUNT`
-Vous pouvez ajouter d'autres agrégations en cas de besoin. Le nombre de métriques custom indexées dépend du nombre d'agrégations activées.
+Votre nombre de métriques personnalisées indexées **n'évolue pas** avec le nombre d'agrégations activées.
En savoir plus sur [Metrics without Limits™][1].
@@ -195,83 +202,83 @@ En savoir plus sur [Metrics without Limits™][1].
{{% /tab %}}
{{% tab "Histogram" %}}
-**Par défaut, une métrique HISTOGRAM génère cinq métriques custom pour chaque combinaison unique de nom de métrique et de valeurs de tag**, ce qui correspond aux agrégations effectuées côté Agent (`max`, `median`, `avg`, `95pc` et `count`). [En savoir plus sur les métriques HISTOGRAM][1].
+**Une métrique HISTOGRAM génère par défaut cinq métriques personnalisées pour chaque combinaison unique de nom de métrique et de valeurs de tag** pour prendre en charge les agrégations côté Agent `max`, `median`, `avg`, `95pc` et `count`. [En savoir plus sur le type de métrique HISTOGRAM][1].
-Le nombre de combinaisons de valeurs de tag uniques envoyées pour une métrique HISTOGRAM avec ce schéma de tagging est de **quatre** :
+Le nombre de combinaisons de valeurs de tag uniques soumises pour une métrique HISTOGRAM avec ce schéma de tagging est **quatre** :
- `host:A`, `endpoint:X`, `status:200`
- `host:B`, `endpoint:X`, `status:200`
- `host:B`, `endpoint:X`, `status:400`
- `host:B`, `endpoint:Y`, `status:200`
-Par défaut, l'Agent génère cinq métriques custom pour chacune des quatre combinaisons de valeur de tag uniques d'origine, soit une métrique custom [pour chaque agrégation activée côté Agent][2] : `avg`, `count`, `median`, `95percentile` et `max`. Ainsi, `request.Latency` envoie **4\*5 = 20 métriques custom** au total.
+Par défaut, l'Agent génère cinq métriques personnalisées pour chacune des quatre combinaisons uniques de valeurs de tag d'origine pour tenir compte [de chaque agrégation côté Agent activée][2] : `avg`, `count`, `median`, `95percentile` et `max`. Par conséquent, `request.Latency` rapporte un total de **4\*5 = 20 métriques personnalisées**.
-**Remarque** : l'ajout d'agrégations à vos métriques HISTOGRAM augmente le nombre de métriques custom distinctes envoyées. La désactivation d'agrégations réduit le nombre de métriques custom envoyées.
+**Remarque** : Ajouter des agrégations à vos métriques HISTOGRAM augmente le nombre de métriques personnalisées distinctes rapportées. La suppression des agrégations diminue le nombre de métriques personnalisées rapportées.
-- Configurez les agrégations que vous souhaitez envoyer à Datadog à l'aide du paramètre `histogram_aggregates` dans votre [fichier de configuration datadog.yaml][3]. Par défaut, seules les agrégations `max`, `median`, `avg` et `count` sont envoyées à Datadog. Les agrégations `sum` et `min` sont également disponibles si vous le souhaitez.
-- Configurez les agrégations par centile que vous souhaitez envoyer à Datadog à l'aide du paramètre `histogram_percentiles` dans votre [fichier de configuration datadog.yaml][2]. Par défaut, seul le 95e centile, `95percentile`, est envoyé à Datadog.
+- Configurez l'agrégation que vous souhaitez envoyer à Datadog avec le paramètre `histogram_aggregates` dans votre [fichier de configuration datadog.yaml][3]. Par défaut, seules les agrégations `max`, `median`, `avg` et `count` sont envoyées à Datadog. `sum` et `min` sont également disponibles si désiré.
+- Configurez l'agrégation de percentile que vous souhaitez envoyer à Datadog avec le paramètre `histogram_percentiles` dans votre [fichier de configuration datadog.yaml][3]. Par défaut, seul le percentile `95percentile`, le 95e percentile, est envoyé à Datadog.
[1]: /fr/metrics/types/?tab=histogram#metric-types
[2]: /fr/metrics/types/?tab=histogram#definition
-[3]: /fr/agent/guide/agent-configuration-files/#agent-main-configuration-file
+[3]: /fr/agent/configuration/agent-configuration-files/#agent-main-configuration-file
{{% /tab %}}
{{% tab "Distribution" %}}
-**Par défaut, une métrique DISTRIBUTION génère cinq métriques custom pour chaque combinaison unique de nom de métrique et de valeurs de tag**, ce qui correspond à la distribution statistique globale des valeurs. Ces cinq métriques custom reflètent les agrégations effectuées côté serveur, `count`, `sum`, `min`, `max` et `avg`. [En savoir plus sur les métriques de type DISTRIBUTION][1].
+**Une métrique de DISTRIBUTION génère par défaut cinq métriques personnalisées pour chaque combinaison unique de nom de métrique et de valeurs de tag** afin de représenter la distribution statistique globale des valeurs. Ces cinq métriques personnalisées représentent des agrégations côté serveur de `count`, `sum`, `min`, `max` et `avg`. [En savoir plus sur le type de métrique DISTRIBUTION][1].
-Le nombre de combinaisons de valeurs de tag uniques envoyées pour une métrique DISTRIBUTION avec ce schéma de tagging est de **quatre**.
+Le nombre de combinaisons uniques de valeurs de tag soumises pour une métrique de DISTRIBUTION avec ce schéma de tagging est **quatre**.
- `host:A`, `endpoint:X`, `status:200`
- `host:B`, `endpoint:X`, `status:200`
- `host:B`, `endpoint:X`, `status:400`
- `host:B`, `endpoint:Y`, `status:200`
-Le nombre de métriques custom envoyées par une [métrique DISTRIBUTION][1] correspond au nombre de combinaisons uniques de nom de métrique et de valeurs de tag multiplié par cinq. Ainsi, la métrique `request.Latency` envoie **5\*4 = 20 métriques custom** au total.
+Le nombre de métriques personnalisées d'une [métrique de DISTRIBUTION][1] est cinq fois la combinaison unique de nom de métrique et de valeurs de tag. Cela donne `request.Latency` un total de **5\*4 = 20 métriques personnalisées**.
-##### Ajout d'agrégations par centile
+##### Ajout d'agrégations de percentile {#adding-percentile-aggregations}
-Vous pouvez ajouter des agrégations par centile (`p50`, `p75`, `p90`, `p95` et `p99`) pour votre métrique de distribution, afin d'obtenir cinq fois plus de combinaisons uniques nom de métrique/valeur de tag (**5 \* 4 = 20 métriques customs**). Avec les agrégations par centile, le nombre total de métriques custom généré par cette métrique de distribution atteint 40 (**2 * (5 \* 4) = 40**).
+Vous pouvez inclure des agrégations de percentile (`p50`, `p75`, `p90`, `p95` et `p99`) sur votre métrique de distribution. L'inclusion de ces agrégations de percentile supplémentaires entraîne un volume supplémentaire de cinq fois la combinaison unique de nom de métrique et de valeurs de tag (**5\*4 = 20 métriques personnalisées**). Par conséquent, le nombre total de métriques personnalisées émises par cette métrique de distribution avec des agrégations de percentile est **2 * (5\*4) = 40 métriques personnalisées**.
-Le tableau ci-dessous résume l'impact de l'ajout d'agrégations par centile pour une distribution de métrique.
+Le tableau ci-dessous résume l'impact de l'ajout d'agrégations par centile pour une distribution de métrique.
-| Métriques | Nombre de métriques custom facturables |
+| Métriques | Nombre de métriques personnalisées facturables |
|-------------------------------------------------------------------------------------------|-----------------------------------|
-| Nombre de métriques custom générées par une distribution standard (count, sum, min, max et avg) | `5 * (combinaisons de valeurs de tag)` |
-| Nombre de métriques custom générées par l'ajout des agrégations par centile (p50, p75, p90, p95 et p99) | `5 * (combinaisons de valeurs de tag)` |
-| Total | `2 * 5(combinaisons de valeurs de tag)` |
+| Nombre de métriques personnalisées d'une distribution de base (compte, somme, min, max, avg) | `5*(tag value combinations)` |
+| Nombre de métriques personnalisées incluant des agrégations de percentile (p50, p75, p90, p95, p99) | `5*(tag value combinations)` |
+| Total | `2*5(tag value combinations)` |
-### Configurer des tags avec Metrics without Limits™
+### Configurer des tags avec Metrics without Limits™ {#configure-tags-with-metrics-without-limits-2}
-La configuration de tags et d'agrégations à l'aide de [Metrics without Limits™][3] peut avoir une incidence sur les volumes de métriques custom. Metrics without Limits™ dissocie les coûts d'ingestion des coûts d'indexation. Ainsi, vous pouvez continuer à envoyer toutes vos données à Datadog (toutes les informations sont ingérées) et ajouter des tags à une liste d'autorisation afin que seuls ces tags puissent être interrogés sur la plateforme Datadog. Comme le volume de données ingérées par Datadog pour les métriques que vous avez configurées est maintenant différent du volume de données indexées, qui est plus petit, deux volumes distincts s'affichent sur votre page Usage et sur la page Metrics Summary.
+Les volumes de métriques personnalisées peuvent être affectés par la configuration des tags et des agrégations en utilisant [Metrics without Limits™][2]. Metrics without Limits™ découple les coûts d'ingestion des coûts d'indexation -- vous pouvez continuer à envoyer à Datadog toutes vos données (tout est ingéré) et vous pouvez spécifier une liste blanche de tags que vous souhaitez garder interrogeables sur la plateforme Datadog. Étant donné que le volume de données que Datadog ingère pour vos métriques configurées diffère maintenant du volume plus petit restant que vous avez indexé, vous verrez deux volumes distincts sur votre page d'utilisation ainsi que sur la page de résumé des métriques.
+
+- **Métriques personnalisées ingérées** : Le volume original de métriques personnalisées sur toutes les balises ingérées (envoyées par code)
+- **Métriques personnalisées indexées** : Le volume de métriques personnalisées qui reste interrogeable sur la plateforme Datadog (en fonction de toute configuration Metrics without Limits™)
-- **Ingested Custom Metrics** : le volume initial de métriques custom basé sur tous les tags ingérés (qui ont été envoyés par le code).
-- **Indexed Custom Metrics** : le volume de métriques custom pouvant être interrogées sur la plateforme Datadog (en fonction des configurations Metrics without Limits™).
+**Remarque : Seules les métriques configurées contribuent à votre volume de métriques personnalisées ingérées.** Si une métrique n'est pas configurée avec Metrics without Limits™, vous ne payez que pour son volume de métriques personnalisées indexées.
-**Remarque : seules les métriques configurées rentrent en compte dans le calcul du volume des métriques custom.** Si vous n'avez pas configuré Metrics without Limits™ pour une métrique, seul le volume des métriques custom indexées vous est facturé.
+#### Quand êtes-vous facturé pour les métriques personnalisées ingérées par rapport aux métriques personnalisées indexées ? {#when-are-you-charged-for-ingested-vs-indexed-custom-metrics-2}
+Pour les métriques non configurées avec Metrics without Limits™, vous payez pour les métriques personnalisées indexées.
-#### Dans quels cas les métriques custom ingérées ou indexées vous sont-elles facturées ?
-Pour les métriques non configurées avec Metrics without Limits™, vous payez pour les métriques custom indexées.
-
-| | Métriques custom indexées
(en fonction du nombre moyen mensuel de métriques custom par heure) |
+| | Métriques personnalisées indexées
(basé sur le nombre moyen mensuel de métriques personnalisées par heure) |
|--------------------------------------|-------------------------------------------------------------------------------------------------------------------------------|
-| Quota de l'abonnement | - Pro : 100 métriques custom indexées par host
- Enterprise : 200 métriques custom indexées par host |
-| Dépassement du quota | Si vous dépassez le quota de votre abonnement, chaque palier de 100 métriques custom indexées supplémentaires vous est facturé le montant indiqué dans votre contrat actuel. |
+| Allocation de compte | - Pro : 100 métriques personnalisées indexées par hôte
- Entreprise : 200 métriques personnalisées indexées par hôte |
+| Utilisation supérieure à l'allocation de compte | Pour chaque 100 métriques personnalisées indexées au-delà de l'allocation de compte, vous payez un montant spécifié dans votre contrat actuel. |
-Pour les métriques configurées avec Metrics without Limits™ (des tags/agrégations sont configurés), vous payez pour les métriques custom ingérées et les métriques custom indexées.
+Pour les métriques configurées avec Metrics without Limits™ (les balises/agrégations sont configurées), vous payez pour les métriques personnalisées ingérées et les métriques personnalisées indexées.
-| | Métriques custom ingérées | Indexed Custom Metrics |
+| | Métriques personnalisées ingérées | Métriques personnalisées indexées |
|--------------------------------------|---------------------------------------------------------------------------------------------------|-------------------------------------------------------------------------------------------------------------------------------|
-| Quota de l'abonnement | - Pro : 100 métriques custom ingérées par host
- Enterprise : 200 métriques custom ingérées par host | - Pro : 100 métriques custom indexées par host
- Enterprise : 200 métriques custom indexées par host |
-| Dépassement du quota | Si vous dépassez le quota de votre abonnement, chaque palier de 100 métriques custom ingérées supplémentaires vous est facturé 0,10 $. | Si vous dépassez le quota de votre abonnement, chaque palier de 100 métriques custom indexées supplémentaires vous est facturé le montant indiqué dans votre contrat actuel. |
+| Allocation de compte | - Pro : 100 métriques personnalisées ingérées par hôte
- Entreprise : 200 métriques personnalisées ingérées par hôte | - Pro : 100 métriques personnalisées indexées par hôte
- Entreprise : 200 métriques personnalisées indexées par hôte |
+| Utilisation supérieure à l'allocation de compte | Pour chaque 100 métriques personnalisées ingérées au-delà de l'allocation de compte, vous payez 0,10 $. | Pour chaque 100 métriques personnalisées indexées au-delà de l'allocation de compte, vous payez un montant spécifié dans votre contrat actuel. |
-Imaginons que vous souhaitiez conserver uniquement les tags `endpoint` et `status` associés à la métrique `request.Latency`. Vous obtenez alors les trois combinaisons de tags uniques suivantes :
+Supposons que vous souhaitiez conserver uniquement les balises `endpoint` et `status` associées à la métrique `request.Latency`. Cela donne les trois combinaisons de balises uniques suivantes :
- `endpoint:X`, `status:200`
- `endpoint:X`, `status:400`
- `endpoint:Y`, `status:200`
-Le nombre de métriques custom envoyées par une [métrique DISTRIBUTION][1] correspond au nombre de combinaisons uniques de nom de métrique et de valeurs de tag multiplié par cinq. Une fois les tags configurés, la métrique `request.Latency` envoie **5\*3 = 15 métriques custom indexées** au total. En se basant sur les tags envoyés initialement sur cette métrique, le volume initial de métriques custom **ingérées** pour la métrique `request.Latency` est de **20 métriques custom ingérées**.
+Le nombre de métriques personnalisées d'une [métrique de DISTRIBUTION][1] est cinq fois la combinaison unique de nom de métrique et de valeurs de tag. En raison de la personnalisation des balises, `request.Latency` rapportant un total de **5\*3 = 15 métriques personnalisées indexées**. Basé sur les balises originales envoyées sur cette métrique, le volume original de métriques personnalisées **ingérées** de `request.Latency` est **20 métriques personnalisées ingérées**.
En savoir plus sur [Metrics without Limits™][2].
@@ -280,72 +287,45 @@ En savoir plus sur [Metrics without Limits™][2].
{{% /tab %}}
{{< /tabs >}}
-## Suivi des métriques custom
-
-Les administrateurs (c'est-à-dire les utilisateurs disposant du rôle [Admin de Datadog][5]) peuvent consulter le nombre moyen mensuel de métriques custom **ingérées** et **indexées** par heure. Le tableau des principales métriques custom affiche également le nombre moyen de métriques custom **indexées** sur la [page des détails d'utilisation][6]. Consultez la documentation sur les [détails d'utilisation][7] pour en savoir plus.
-
-Pour suivre en temps réel le nombre de métriques custom associées à un nom de métrique donné, accédez à la [page Résumé des métriques][8] et cliquez sur le nom de métrique souhaité. Vous pouvez visualiser le nombre de métriques custom **ingérées** et **indexées** dans le volet latéral des détails de la métrique.
-{{< img src="account_management/billing/custom_metrics/mwl_sidepanel_ingested.jpg" alt="Volet latéral affichant le résumé des métriques" style="width:80%;">}}
+## Suivi des métriques personnalisées {#tracking-custom-metrics}
+Les utilisateurs administratifs (ceux ayant [des rôles d'administrateur Datadog][7]) peuvent voir le nombre moyen mensuel de **métriques personnalisées ingérées** et **indexées** par heure. Le tableau des métriques personnalisées les plus importantes indique également le nombre moyen de **métriques personnalisées indexées** sur la [page des détails d'utilisation][8]. Consultez la documentation [Détails d'utilisation][9] pour plus d'informations.
-## Allocation
+Pour un suivi en temps réel du nombre de métriques personnalisées pour un nom de métrique particulier, cliquez sur le nom de la métrique sur la [page de résumé des métriques][10]. Vous pouvez voir le nombre de **métriques personnalisées ingérées** et **indexées** sur le panneau latéral des détails de la métrique.
-Vous avez droit à un certain quota de métriques custom **ingérées** et **indexées** en fonction de votre abonnement Datadog :
+{{< img src="account_management/billing/custom_metrics/mwl_sidepanel_ingested_3142025.jpg" alt="Panneau latéral du résumé des métriques" style="width:80%;">}}
-- Pro : 100 métriques custom ingérées par host et 100 métriques custom indexées par host
-- Enterprise : 200 métriques custom ingérées par host et 200 métriques custom indexées par host
-Ces quotas sont calculés pour l'ensemble de votre infrastructure. Par exemple, si vous utilisez l'offre Pro avec 3 hosts, 300 métriques custom indexées vous sont attribuées. Ces 300 métriques custom indexées peuvent être réparties équitablement entre chaque host ou toutes être attribuées à un seul host. Pour cet exemple, le graphique ci-dessous illustre des scénarios respectant le quota de métriques custom autorisé :
+## Allocation {#allocation}
-{{< img src="account_management/billing/custom_metrics/host_custom_metrics.png" alt="Quotas pour les métriques custom" >}}
+Un certain nombre de **métriques personnalisées ingérées** et **indexées** vous est alloué en fonction de votre plan tarifaire Datadog :
-Le nombre de métriques custom facturables est calculé en fonction du nombre moyen de métriques custom (pour tous les hosts facturés) par heure et sur un mois donné. Le nombre de métriques custom ingérées facturables augmente uniquement si vous avez utilisé Metrics without Limits™ pour configurer votre métrique. Contactez le [service commercial][9] ou votre [chargé de compte][10] pour discuter de vos métriques custom ou pour acheter un forfait de métriques custom supplémentaire.
+- Pro : 100 métriques personnalisées ingérées par hôte et 100 métriques personnalisées indexées par hôte
+- Entreprise : 200 métriques personnalisées ingérées par hôte et 200 métriques personnalisées indexées par hôte
-## Intégrations standard
+Ces allocations sont comptées sur l'ensemble de votre infrastructure. Par exemple, si vous êtes sur le plan Pro et licencié pour trois hôtes, 300 métriques personnalisées indexées sont allouées. Les 300 métriques personnalisées indexées peuvent être réparties également entre chaque hôte, ou les 300 métriques personnalisées indexées peuvent être utilisées par un seul hôte. Pour cet exemple, le graphique ci-dessous indique des scénarios respectant le nombre de métriques custom attribuées :
-Les intégrations standard suivantes peuvent potentiellement générer des métriques custom.
+{{< img src="account_management/billing/custom_metrics/host_custom_metrics.png" alt="Allocations pour les métriques personnalisées" >}}
-| Types d'intégrations | Intégrations |
-|------------------------------------------------|------------------------------------------------------------------------------------|
-| Limitées à 350 métriques custom par défaut. | [ActiveMQ XML][11] / [Go-Expvar][12] / [Java-JMX][13] |
-| Aucune limite appliquée à la collecte de métriques custom par défaut. | [Nagios][14] / [Check PDH][15] / [OpenMetrics][16] / [Windows Services][17] / [WMI][18] / [Prometheus][27] |
-| Peuvent être configurées pour collecter des métriques custom. | [MySQL][19] / [Oracle][20] / [Postgres][21] / [SQL Server][22] |
-| Métriques custom envoyées depuis des intégrations cloud | [AWS][23] |
+Le nombre facturable de métriques personnalisées indexées est basé sur le nombre moyen de métriques personnalisées (provenant de tous les hôtes payants) par heure sur un mois donné. Le nombre facturable de métriques personnalisées ingérées n'augmente que si vous avez utilisé Metrics without Limits™ pour configurer votre métrique. Contactez [Ventes][11] ou votre [Responsable du succès client][12] pour discuter des métriques personnalisées pour votre compte ou pour acheter un package supplémentaire de métriques personnalisées.
-## Dépannage
+## Dépannage {#troubleshooting}
-Pour toute question technique, contactez [l'assistance Datadog][24].
+Pour des questions techniques, contactez [le support Datadog][13].
-Pour toute question concernant la facturation, contactez votre [chargé de compte][10].
-
-## Pour aller plus loin
-
-{{< partial name="whats-next/whats-next.html" >}}
+Pour des questions de facturation, contactez votre [Responsable du succès client][12].
[1]: /fr/integrations/
[2]: /fr/metrics/custom_metrics/
-[3]: /fr/metrics/metrics-without-limits
-[4]: /fr/metrics/types/#metric-types
-[5]: /fr/account_management/users/default_roles/
-[6]: https://app.datadoghq.com/billing/usage
-[7]: /fr/account_management/billing/usage_details/
-[8]: https://app.datadoghq.com/metric/summary
-[9]: mailto:sales@datadoghq.com
-[10]: mailto:success@datadoghq.com
-[11]: /fr/integrations/activemq/#activemq-xml-integration
-[12]: /fr/integrations/go_expvar/
-[13]: /fr/integrations/java/
-[14]: /fr/integrations/nagios/
-[15]: /fr/integrations/pdh_check/
-[16]: /fr/integrations/openmetrics/
-[17]: /fr/integrations/windows_service/
-[18]: /fr/integrations/wmi_check/
-[19]: /fr/integrations/mysql/
-[20]: /fr/integrations/oracle/
-[21]: /fr/integrations/postgres/
-[22]: /fr/integrations/sqlserver/
-[23]: /fr/integrations/amazon_web_services/
-[24]: /fr/help/
-[25]: /fr/metrics/custom_metrics/dogstatsd_metrics_submission/
-[26]: /fr/metrics/custom_metrics/agent_metrics_submission/
-[27]: /fr/integrations/prometheus
\ No newline at end of file
+[3]: /fr/metrics/custom_metrics/dogstatsd_metrics_submission/
+[4]: /fr/metrics/custom_metrics/agent_metrics_submission/
+[5]: /fr/metrics/metrics-without-limits
+[6]: /fr/metrics/types/#metric-types
+[7]: /fr/account_management/users/default_roles/
+[8]: https://app.datadoghq.com/billing/usage
+[9]: /fr/account_management/plan_and_usage/usage_details/
+[10]: https://app.datadoghq.com/metric/summary
+[11]: mailto:sales@datadoghq.com
+[12]: mailto:success@datadoghq.com
+[13]: /fr/help/
+[14]: /fr/metrics/custom_metrics/#standard-integrations
\ No newline at end of file
diff --git a/content/fr/containers/kubernetes/_index.md b/content/fr/containers/kubernetes/_index.md
index 1fb340d35a0..c60017b376a 100644
--- a/content/fr/containers/kubernetes/_index.md
+++ b/content/fr/containers/kubernetes/_index.md
@@ -10,14 +10,18 @@ aliases:
- /fr/integrations/faq/container-integration-event/
- /fr/integrations/faq/why-is-the-kubernetes-check-failing-with-a-connecttimeout-error-to-port-10250/
- /fr/agent/kubernetes/
+description: Installez et configurez l'Agent Datadog sur Kubernetes
further_reading:
+- link: https://learn.datadoghq.com/courses/getting-started-k8s
+ tag: Centre d'apprentissage
+ text: Introduction à l'observabilité de Kubernetes
- link: https://app.datadoghq.com/release-notes?category=Container%20Monitoring
tag: Notes de version
text: Découvrez les dernières versions des conteneurs Datadog (connexion à l'application
requise).
- link: /agent/guide/autodiscovery-management
tag: Documentation
- text: Limiter la collecte de données à un sous-ensemble de conteneurs
+ text: Limitez la collecte de données à un sous-ensemble de conteneurs
- link: /agent/guide/docker-deprecation
tag: Documentation
text: Dépréciation du runtime Docker dans Kubernetes
@@ -25,36 +29,73 @@ further_reading:
tag: Validation des bases
text: Participer à une session interactive pour obtenir des informations grâce sur
la surveillance Kubernetes
+- link: https://www.datadoghq.com/blog/watermark-pod-autoscaler/
+ tag: Blog
+ text: Un guide pour mettre à l'échelle vos pods Kubernetes avec le Watermark Pod
+ Autoscaler
+- link: https://www.datadoghq.com/blog/kubernetes-operator-performance
+ tag: Blog
+ text: Surveillez vos opérateurs Kubernetes pour garantir le bon fonctionnement des
+ applications
title: Kubernetes
---
+{{< learning-center-callout header="Participez à une session de webinaire de formation." hide_image="true" btn_title="Inscrivez-vous" btn_url="https://www.datadoghq.com/technical-enablement/sessions/?tags.topics-0=Kubernetes">}}
+ Cette session de formation de base se concentrera sur la manière dont Datadog peut surveiller Kubernetes. Apprenez à configurer Datadog pour Kubernetes et comment commencer. Explorez les différentes vues et outils que Datadog propose pour visualiser et analyser les métriques, les traces et les journaux de votre cluster et de vos applications.
+{{< /learning-center-callout >}}
-## Présentation
+## Installation de l'Agent {#agent-installation}
-Exécutez l'Agent Datadog dans votre cluster Kubernetes pour commencer à recueillir les métriques, traces et logs issus de votre cluster et de vos applications.
+Vous pouvez installer l'Agent en utilisant soit le [Datadog Operator][4] soit le Helm chart en suivant le [guide d'installation dans l'application de Fleet Automation][5]. Cette interface guidée vous permet de :
+- Sélectionnez votre distribution Kubernetes (par exemple EKS, AKS ou GKE)
+- Générez des commandes Helm et kubectl avec votre clé API préremplie
+- Activez des fonctionnalités telles que APM, la gestion des journaux, l’étiquetage et d’autres fonctionnalités de télémétrie via une configuration basée sur l’interface utilisateur
-**Remarque** : l'Agent v6.0+ prend uniquement en charge Kubernetes v1.7.6+. Pour les versions antérieures de Kubernetes, consultez la section [Versions antérieures de Kubernetes][1].
-Pour les commandes de l'Agent, consultez les [guides sur les commandes de l'Agent][2].
+{{< img src="agent/basic_agent_usage/agent_install_k8.png" alt="Étapes d'installation dans l'application pour l'Agent Datadog sur Kubernetes." style="width:90%;">}}
-Pour en savoir plus sur lʼAgent de cluster Datadog, qui propose une approche simplifiée de la collecte des données de surveillance au niveau du cluster, consultez la section [Agent de cluster pour Kubernetes][3].
-{{< whatsnext desc="Cette section aborde les sujets suivants :">}}
- {{< nextlink href="/agent/kubernetes/installation">}}Installation : Installer l'Agent Datadog dans un environnement Kubernetes.{{< /nextlink >}}
- {{< nextlink href="/agent/kubernetes/configuration">}}Configuration supplémentaire : Recueillir des événements, remplacer les paramètres de proxy, envoyer des métriques custom avec DogStatsD, configurer des listes d'inclusion et d'exclusion de conteneurs, et consulter la liste complète des variables d'environnement disponibles.{{< /nextlink >}}
- {{< nextlink href="/agent/kubernetes/distributions">}}Distributions : Passer en revue les configurations de base pour les principales distributions Kubernetes, y compris AWS Elastic Kubernetes Service (EKS), Azure Kubernetes Service (AKS), Google Kubernetes Engine (GKE), Red Hat OpenShift, Rancher et Oracle Container Engine for Kubernetes (OKE).{{< /nextlink >}}
- {{< nextlink href="/agent/kubernetes/apm">}}APM : Configurer la collecte de traces : configurer l'Agent pour qu'il accepte les traces, configurer vos pods pour qu'ils communiquent avec l'Agent, et configurer vos traceurs d'application pour qu'ils génèrent des traces.{{< /nextlink >}}
- {{< nextlink href="/agent/kubernetes/log">}}Collecte de logs : Configurer la collecte de logs dans un environnement Kubernetes.{{< /nextlink >}}
- {{< nextlink href="/agent/kubernetes/tag">}}Extraction de tags : Configurer l'Agent afin de créer et d'attribuer des tags à l'ensemble des métriques, traces et logs générés par un conteneur, pod ou nœud, en fonction d'étiquettes ou d'annotations Kubernetes.{{< /nextlink >}}
- {{< nextlink href="/agent/kubernetes/integrations">}}Intégrations et Autodiscovery : Configurer des intégrations dans un environnement Kubernetes avec la fonctionnalité Autodiscovery de Datadog.{{< /nextlink >}}
- {{< nextlink href="/agent/kubernetes/prometheus">}}Prometheus et OpenMetrics : Recueillir vos métriques Prometheus et OpenMetrics exposées à partir d'une application exécutée dans Kubernetes.{{< /nextlink >}}
- {{< nextlink href="/agent/kubernetes/control_plane">}}Surveillance du plan de contrôle : Surveiller le serveur d'API Kubernetes, le controller manager, le scheduler et etcd.{{< /nextlink >}}
- {{< nextlink href="/agent/kubernetes/data_collected">}}Données collectées : Consulter la liste des métriques collectées par l'Agent lorsqu'il est déployé sur votre cluster Kubernetes.{{< /nextlink >}}
+Le flux Datadog Operator installe le Datadog Operator et utilise des ressources personnalisées pour configurer votre couverture d'observabilité.
+
+Le flux Helm Chart installe les composants Datadog de manière plus directe et offre des options similaires pour les fonctionnalités d'observabilité.
+
+Les deux options vous permettent de gérer une configuration : le Datadog Operator ou le Helm chart crée le DaemonSet de l'Agent Datadog, le déploiement du Cluster Agent et toutes leurs dépendances pour votre surveillance basée sur Kubernetes
+
+Voir [Versions prises en charge][6] pour la liste complète des versions de Kubernetes prises en charge par l'Agent Datadog.
+
+
+### Installation manuelle {#manual-installation}
+
+L'[outil d'installation dans l'application de Fleet Automation][5] fournit un moyen guidé de construire vos configurations. Vous pouvez également consulter la [documentation d'installation de Kubernetes][7] pour les étapes sur la façon de déployer et de configurer manuellement le Datadog Operator ou le Helm chart Datadog dans votre environnement
+
+Datadog recommande d'utiliser le Datadog Operator ou le Helm chart Datadog pour déployer toutes les ressources Kubernetes pour vous Si vous devez déployer tous les manifests directement, consultez la [documentation complète d'installation manuelle de Kubernetes][8].
+
+Pour les commandes de l'Agent, consultez les [guides des commandes de l'Agent][9]. Pour des informations sur le Datadog Cluster Agent et son rôle, consultez [Cluster Agent for Kubernetes][3].
+
+{{< whatsnext desc="Cette section comprend les sujets suivants :">}}
+ {{< nextlink href="/agent/kubernetes/installation">}}Installation : Installez l'Agent Datadog dans un environnement Kubernetes.{{< /nextlink >}}
+ {{< nextlink href="/agent/kubernetes/configuration">}}Configuration supplémentaire : Collectez des événements, remplacez les paramètres du proxy, envoyez des métriques personnalisées avec DogStatsD, configurez des listes blanches et des listes noires de conteneurs, et consultez la liste complète des variables d'environnement disponibles.{{< /nextlink >}}
+ {{< nextlink href="/agent/kubernetes/distributions">}}Distributions : Examinez les configurations de base pour les principales distributions Kubernetes, y compris AWS Elastic Kubernetes Service (EKS), Azure Kubernetes Service (AKS), Google Kubernetes Engine (GKE), Red Hat OpenShift, Rancher et Oracle Container Engine for Kubernetes (OKE).{{< /nextlink >}}
+ {{< nextlink href="/agent/kubernetes/apm">}}APM : Configurez la collecte de traces : configurez l'Agent pour accepter les traces, configurez vos Pods pour communiquer avec l'Agent, et configurez vos SDK d'application pour émettre des traces.{{< /nextlink >}}
+ {{< nextlink href="/agent/kubernetes/appsec">}}Protection des applications et des API : Activez automatiquement la protection des applications et des API pour vos proxys d'entrée et passerelles Kubernetes afin de détecter les menaces et de protéger les API à la périphérie.{{< /nextlink >}}
+ {{< nextlink href="/agent/kubernetes/csi">}}Pilote CSI : Installez et configurez le pilote CSI Datadog, et montez le socket UDS de DogStatsD et de l'Agent de traces en utilisant les volumes CSI Datadog.{{< /nextlink >}}
+ {{< nextlink href="/agent/kubernetes/log">}}Collecte de journaux : Configurez la collecte de journaux dans un environnement Kubernetes.{{< /nextlink >}}
+ {{< nextlink href="/agent/kubernetes/tag">}}Extraction de balises : Configurez l'Agent pour créer et attribuer des balises à toutes les métriques, traces et journaux émis par un conteneur, un Pod ou un nœud, en fonction des étiquettes ou des annotations Kubernetes.{{< /nextlink >}}
+ {{< nextlink href="/agent/kubernetes/integrations">}}Intégrations et autodécouverte : Pour configurer des intégrations dans un environnement Kubernetes, utilisez la fonctionnalité d'autodécouverte de Datadog.{{< /nextlink >}}
+ {{< nextlink href="/agent/kubernetes/prometheus">}}Prometheus et OpenMetrics : Collectez vos métriques Prometheus et OpenMetrics exposées depuis votre application s'exécutant à l'intérieur de Kubernetes.{{< /nextlink >}}
+ {{< nextlink href="/agent/kubernetes/control_plane">}}Surveillance du plan de contrôle : Surveillez le serveur API Kubernetes, le gestionnaire de contrôleur, le planificateur et etcd.{{< /nextlink >}}
+ {{< nextlink href="/agent/kubernetes/data_collected">}}Données collectées : Consultez la liste des métriques collectées par l'Agent lorsqu'il est déployé sur votre cluster Kubernetes.{{< /nextlink >}}
{{< /whatsnext >}}
-## Pour aller plus loin
+## Lectures complémentaires {#further-reading}
{{< partial name="whats-next/whats-next.html" >}}
[1]: /fr/agent/faq/kubernetes-legacy/
[2]: /fr/agent/configuration/agent-commands/
-[3]: /fr/containers/cluster_agent/
\ No newline at end of file
+[3]: /fr/containers/cluster_agent/
+[4]: https://docs.datadoghq.com/fr/containers/datadog_operator/
+[5]: https://app.datadoghq.com/fleet/install-agent/latest?platform=kubernetes
+[6]: /fr/containers/kubernetes/installation?tab=datadogoperator#minimum-kubernetes-and-datadog-agent-versions
+[7]: /fr/containers/kubernetes/installation
+[8]: https://docs.datadoghq.com/fr/containers/guide/kubernetes_daemonset/
+[9]: /fr/agent/configuration/agent-commands/
\ No newline at end of file
diff --git a/content/fr/database_monitoring/_index.md b/content/fr/database_monitoring/_index.md
index 8c27ed8f277..a1aca2dc6d8 100644
--- a/content/fr/database_monitoring/_index.md
+++ b/content/fr/database_monitoring/_index.md
@@ -8,15 +8,29 @@ cascade:
rank: 70
description: En savoir plus sur la solution Database Monitoring et se lancer
further_reading:
+- link: https://www.datadoghq.com/blog/analyzing-roundtrip-query-latency
+ tag: Blog
+ text: Analyse de la latence des requêtes aller-retour
+- link: https://www.datadoghq.com/blog/database-monitoring-recommendations/
+ tag: Blog
+ text: Améliorez les performances de vos hosts de base de données et de vos requêtes
+ grâce aux recommandations de Database Monitoring (en anglais)
- link: https://www.datadoghq.com/blog/database-performance-monitoring-datadog
tag: Blog
- text: Surveiller et visualiser les performances de vos bases de données
+ text: Surveillez et visualisez les performances de vos bases de données
- link: https://www.datadoghq.com/blog/sql-server-and-azure-managed-services-database-monitoring/
tag: Blog
text: Surveiller des bases de données gérées par SQL Server et Azure avec Database Monitoring
+- link: https://www.datadoghq.com/blog/mongodb-database-monitoring/
+ tag: Blog
+ text: Suivre et dépanner les performances de MongoDB avec Datadog Database Monitoring
+- link: https://www.datadoghq.com/blog/datadog-database-research/
+ tag: Blog
+ text: Comment les architectures de microservices ont façonné l'utilisation des technologies
+ de base de données ?
- link: /database_monitoring/data_collected/
tag: Documentation
- text: Données collectées
+ text: Data Collected
- link: /database_monitoring/troubleshooting/
tag: Documentation
text: Dépannage
@@ -24,84 +38,118 @@ further_reading:
tag: Validation des bases
text: Prenez part à une session interactive pour améliorer la solution Database
Monitoring
+- link: https://learn.datadoghq.com/courses/database-monitoring
+ tag: Centre d'apprentissage
+ text: Surveillance d'une base de données Postgres avec Datadog DBM
title: Database Monitoring
---
+{{< learning-center-callout header="Rejoindre une session de webinaire d'initiation" hide_image="true" btn_title="Inscrivez-vous" btn_url="https://www.datadoghq.com/technical-enablement/sessions/?tags.topics-0=Database">}}
+ Avec la surveillance de base de données, apprenez à identifier rapidement les requêtes coûteuses et lentes. Plongez dans les détails d'exécution précis pour résoudre les goulets d'étranglement.
+{{< /learning-center-callout >}}
-{{< img src="database_monitoring/dbm-overview.png" alt="Database Monitoring" style="width:100%;">}}
-
-La solution Database Monitoring de Datadog vous permet d'analyser en détail vos bases de données parmi l'ensemble de vos hosts. Consultez les métriques de performance de vos requêtes, les plans d'exécution et les métriques issues de vos hosts depuis une plateforme centralisée afin de mieux surveiller la santé et les performances de vos bases de données tout en traitant chaque problème dès qu'il est détecté.
+La surveillance de base de données Datadog offre une visibilité approfondie sur les bases de données de tous vos hôtes. Explorez les métriques de performance des requêtes historiques, les plans d'explication et les métriques au niveau de l'hôte, le tout en un seul endroit, pour comprendre la santé et la performance de vos bases de données et résoudre les problèmes au fur et à mesure qu'ils surviennent.
-## Prise en main
+## Commencer {#getting-started}
-La solution Database Monitoring Datadog prend en charge la surveillance des versions cloud gérées et auto-hébergées de **Postgres**, **MySQL**, **Oracle** et **SQL Server**. Pour commencer à utiliser cette fonctionnalité, configurez votre base de données et installez l'Agent Datadog. Suivez les instructions de configuration correspondant à votre type de base de données :
+La surveillance des bases de données Datadog prend en charge les versions auto-hébergées et gérées dans le cloud de **Postgres**, **MySQL**, **Oracle**, **SQL Server**, **MongoDB**, **Amazon DocumentDB** et **ClickHouse**. Pour commencer avec la surveillance de base de données Datadog, configurez votre base de données et installez l'Agent Datadog. Pour les instructions d'installation, sélectionnez votre technologie de base de données :
-### Postgres
+### Postgres {#postgres}
{{< partial name="dbm/dbm-setup-postgres" >}}
-### MySQL
+### MySQL {#mysql}
{{< partial name="dbm/dbm-setup-mysql" >}}
-### Oracle
+### Oracle {#oracle}
{{< partial name="dbm/dbm-setup-oracle" >}}
-### SQL Server
+### SQL Server {#sql-server}
{{< partial name="dbm/dbm-setup-sql-server" >}}
-## Explorer la solution Database Monitoring Datadog
+### MongoDB {#mongodb}
-Accédez à Database Monitoring en cliquant sur **[APM > Databases][1]** depuis l'interface.
+{{< partial name="dbm/dbm-setup-mongodb" >}}
+
-### Analyser en détail les métriques de performance de vos requêtes
+### Amazon DocumentDB {#amazon-documentdb}
+
+{{< partial name="dbm/dbm-setup-documentdb" >}}
+
+
+### ClickHouse {#clickhouse}
+
+{{< partial name="dbm/dbm-setup-clickhouse" >}}
+
-La [vue Query Metrics][2] affiche l'historique des performances de vos requêtes normalisées. Visualisez les tendances de performance en fonction d'une infrastructure ou de tags personnalisés spécifiques, tels que la zone de disponibilité du centre de données, et définissez des alertes pour être informé en cas d'anomalie.
+## Explorez la surveillance de base de données Datadog {#explore-datadog-database-monitoring}
-- Identifiez les requêtes lentes et celles qui sollicitent le plus longtemps votre base de données.
-- Visualisez les métriques de base de données non capturées par APM, comme le nombre de lignes mises à jour et renvoyées.
-- Filtrez et regroupez vos requêtes en fonction de dimensions arbitraires, comme une équipe, un utilisateur, un cluster ou un host.
+Accédez à [Database Monitoring][1] dans Datadog.
+
+### Plongez dans les métriques de performance des requêtes {#dig-into-query-performance-metrics}
+
+La vue [Métriques de requêtes][2] montre la performance historique des requêtes normalisées. Visualisez les tendances de performance par infrastructure ou par balises personnalisées telles que la zone de disponibilité du centre de données, et définissez des alertes pour les anomalies.
+
+- Identifiez les requêtes lentes et celles qui consomment le plus de temps.
+- Affichez les métriques au niveau de la base de données non capturées par l'APM, telles que les lignes mises à jour/retournées.
+- Filtrez et regroupez les requêtes par dimensions arbitraires telles que l'équipe, l'utilisateur, le cluster et l'hôte.
{{< img src="database_monitoring/dbm-query-metrics-2.png" alt="Database Monitoring" style="width:100%;">}}
-### Explorer des exemples de requête
+### Explorez des échantillons de requêtes {#explore-query-samples}
-La [vue Query Samples][3] vous aide à identifier les requêtes qui s'exécutent à un instant donné. Comparez chaque exécution aux performances moyennes de la requête et de requêtes connexes.
+La vue [Échantillons de requêtes][3] vous aide à comprendre quelles requêtes s'exécutent à un moment donné. Comparez chaque exécution à la performance moyenne de la requête et des requêtes connexes.
-- Identifiez les requêtes anormalement lentes mais peu fréquentes qui ne sont pas capturées par les métriques.
-- Identifiez les anomalies dans les temps et les coûts d'exécution de vos requêtes.
-- Attribuez l'exécution d'une requête spécifique à un utilisateur, une application ou un host client.
+- Identifiez les requêtes anormalement lentes mais peu fréquentes non capturées par les métriques.
+- Trouvez des valeurs aberrantes dans le temps d'exécution ou le coût d'exécution d'une requête.
+- Attribuez une exécution de requête spécifique à un utilisateur, une application ou un hôte client.
{{< img src="database_monitoring/dbm-query-sample-2.png" alt="Database Monitoring" style="width:100%;">}}
-### Consulter chaque opération d'une requête avant son exécution
+### Comprenez avant d'exécuter {#understand-before-you-run}
-Les [plans d'exécution][4] vous aident à comprendre comment la base de données compte exécuter vos requêtes.
+Les [plans d'exécution][4] vous permettent de déterminer comment une base de données va exécuter vos requêtes.
-- Visualisez en détail chaque opération pour identifier les goulots d'étranglement.
-- Améliorez l'efficacité de vos requêtes et limitez les analyses séquentielles de vastes tables pour réduire vos coûts.
-- Consultez l'évolution du plan d'une requête.
+- Passez en revue chaque opération pour identifier les goulets d'étranglement.
+- Améliorez l'efficacité des requêtes et économisez sur les analyses séquentielles coûteuses sur de grandes tables.
+- Voyez comment le plan d'une requête évolue au fil du temps.
{{< img src="database_monitoring/dbm-explain-plan-3.png" alt="Database Monitoring" style="width:100%;">}}
-### Visualiser toutes vos données dans des dashboards enrichis
+### Collectez des métriques personnalisées {#collect-custom-metrics}
+
+Utilisez [`custom_queries`][7] pour collecter des métriques de vos propres tables de base de données — état de l'application, compteurs d'affaires, profondeurs de file d'attente, ou toute donnée que vous souhaitez corréler avec la performance des requêtes.
+
+### Visualisez tout sur des tableaux de bord enrichis {#visualize-everything-on-enriched-dashboards}
-Identifiez rapidement vos problèmes en visualisant vos métriques de base de données et vos métriques système au sein de dashboards d'intégration détaillés pour les instances auto-hébergées et celles gérées dans le cloud. Dupliquez des dashboards pour les personnaliser et les enrichir avec vos propres métriques. Cliquez sur le lien **Dashboards** en haut des pages Query Metrics et Query Samples pour accéder aux dashboards Database Monitoring.
+Identifiez rapidement les zones problématiques en visualisant ensemble les métriques de la base de données et du système sur des tableaux de bord d'intégration enrichis pour les instances auto-hébergées et gérées dans le cloud. Clonez les tableaux de bord pour les personnaliser et les améliorer avec vos propres métriques personnalisées. Cliquez sur le lien {{< ui >}}Dashboards{{< /ui >}} en haut des pages Métriques de requête et Échantillons de requête pour accéder aux tableaux de bord de surveillance de la base de données.
{{< img src="database_monitoring/dbm-dashboard-postgres.png" alt="Database Monitoring" style="width:100%;">}}
-### Optimiser les performances et la santé des hosts
+### Optimisez la santé et la performance de l'hôte {#optimize-host-health-and-performance}
+
+Sur la [page des bases de données][1], vous pouvez évaluer la santé et l'activité de vos hôtes de base de données. Triez et filtrez la liste pour prioriser les hôtes avec des alertes déclenchées, un volume de requêtes élevé et d'autres critères. Cliquez sur un hôte individuel pour voir des détails tels que sa configuration, les requêtes de blocage courantes et les services appelants. Voir [Explorer les hôtes de base de données][5] pour plus de détails.
+
+{{< img src="database_monitoring/databases-list.png" alt="La page des bases de données dans Datadog" style="width:90%;" >}}
+
+### Voir les recommandations d'optimisation {#view-optimization-recommendations}
+
+La [page des recommandations][6] met en évidence les problèmes et les opportunités d'optimisation, vous aidant à gagner du temps en priorisant ce qui est le plus important. Sélectionnez une recommandation pour voir les détails, y compris un résumé du problème, ainsi que les étapes potentielles à suivre pour résoudre le problème.
+
+{{< img src="database_monitoring/recommendations-page.png" alt="La page des recommandations dans Datadog" style="width:90%;" >}}
-Depuis la [page Databases][1], vous pouvez évaluer la santé et l'activité des hosts de vos bases de données. Triez et filtrez la liste pour mettre en avant les hosts pour lesquels des alertes ont été déclenchées, ceux avec un important volume de requête, etc. Cliquez sur un host spécifique pour afficher ses détails, notamment sa configuration, ses principales requêtes bloquées et les services appelés. Consultez la section [Explorer les hosts de base de données][5] pour en savoir plus.
-{{< img src="database_monitoring/databases-list.png" alt="La page Databases dans Datadog" style="width:90%;" >}}
+## Lectures complémentaires {#further-reading}
-## Pour aller plus loin
+{{< learning-center-callout header="Essayez de surveiller une base de données Postgres avec Datadog DBM dans le Centre d'apprentissage" btn_title="Inscrivez-vous maintenant" btn_url="https://learn.datadoghq.com/courses/database-monitoring">}}
+ Le Centre d'apprentissage Datadog est rempli de cours pratiques pour vous aider à en apprendre davantage sur ce sujet. Inscrivez-vous gratuitement pour identifier les inefficacités et optimiser votre base de données Postgres.
+{{< /learning-center-callout >}}
{{< partial name="whats-next/whats-next.html" >}}
@@ -109,4 +157,6 @@ Depuis la [page Databases][1], vous pouvez évaluer la santé et l'activité des
[2]: /fr/database_monitoring/query_metrics/
[3]: /fr/database_monitoring/query_samples/
[4]: /fr/database_monitoring/query_metrics/#explain-plans
-[5]: /fr/database_monitoring/database_hosts/
\ No newline at end of file
+[5]: /fr/database_monitoring/database_hosts/
+[6]: /fr/database_monitoring/recommendations/
+[7]: /fr/database_monitoring/custom_metrics/
\ No newline at end of file
diff --git a/content/fr/database_monitoring/guide/aurora_autodiscovery.md b/content/fr/database_monitoring/guide/aurora_autodiscovery.md
index e8128e24ba6..7e99a226a75 100644
--- a/content/fr/database_monitoring/guide/aurora_autodiscovery.md
+++ b/content/fr/database_monitoring/guide/aurora_autodiscovery.md
@@ -1,37 +1,37 @@
---
aliases:
- /fr/database_monitoring/aurora_autodiscovery
-title: Configurer Database Monitoring pour les clusters Amazon Aurora DB
+title: Configuration de la surveillance de base de données pour les clusters de bases
+ de données Amazon Aurora
---
+Ce guide suppose que vous avez configuré la surveillance de base de données pour vos bases de données Amazon Aurora [Postgres][1] ou [MySQL][11].
-Ce guide part du principe que vous avez configuré Database Monitoring pour vos bases de données Amazon Aurora [Postgres][1] ou [MySQL][11].
-
-## Avant de commencer
+## Avant de commencer {#before-you-begin}
Bases de données prises en charge
: Postgres, MySQL
-Versions de l'Agent prises en charge
+Versions d'agent prises en charge
: 7.53.0+
-## Présentation
+## Aperçu {#overview}
-La fonctionnalité [Autodiscovery][4] de Datadog vous permet de configurer la surveillance dans des infrastructures dynamiques. Utilisez cette fonctionnalité pour surveiller vos clusters Aurora sans avoir à lister les endpoints individuels des hosts de base de données (par exemple, `postgres.d/conf.yaml`). Cela est particulièrement utile pour les clusters qui utilisent [Aurora Auto Scaling][6], qui ajuste dynamiquement le nombre de réplicas Aurora en fonction des variations de connectivité ou de charge de travail. Autodiscovery découvre et surveille automatiquement les instances des endpoints primaires et des réplicas.
+L'[Autodécouverte][4] de Datadog vous permet de configurer la surveillance dans des infrastructures dynamiques. Vous pouvez utiliser cette fonctionnalité pour surveiller vos clusters Aurora sans avoir à lister les points de terminaison des hôtes de base de données individuels (par exemple, `postgres.d/conf.yaml`). Cela est particulièrement utile pour les clusters qui utilisent [Aurora Auto Scaling][6], qui ajuste dynamiquement le nombre d'Aurora Replicas en réponse aux variations de connectivité ou de charge de travail. L'autodécouverte découvre et surveille automatiquement les instances d'endpoint primary et replica.
-Avec Autodiscovery et Database Monitoring, définissez des modèles de configuration pour les checks Postgres ou MySQL et spécifiez les clusters auxquels appliquer chaque check.
+Avec l'autodécouverte et la surveillance de base de données, vous pouvez définir des modèles de configuration pour les checks Postgres ou MySQL et spécifier à quels clusters appliquer chaque check.
-## Activer Autodiscovery pour les clusters Aurora
+## Activation de l'autodécouverte pour les clusters Aurora {#enabling-autodiscovery-for-aurora-clusters}
-1. [Accorder des autorisations AWS](#accorder-des-autorisations-aws)
-2. [Configurer les tags Aurora](#configurer-les-tags-aurora)
-3. [Configurer l'Agent Datadog](#configurer-lagent-datadog)
-4. [Créer un modèle de configuration](#créer-un-modèle-de-configuration)
+1. [Accorder des autorisations AWS](#grant-aws-permissions)
+2. [Configurer les balises Aurora](#configure-aurora-tags)
+3. [Configurer le Datadog Agent](#configure-the-datadog-agent)
+4. [Créer un modèle de configuration](#create-a-configuration-template)
-### Accorder des autorisations AWS
+### Accorder des autorisations AWS {#grant-aws-permissions}
-L'Agent Datadog doit disposer de l'autorisation d'exécuter `rds:DescribeDBClusters` et `rds:DescribeDBInstances` dans votre compte AWS. Datadog recommande d'attacher une politique de rôle IAM à l'instance EC2 sur laquelle l'Agent s'exécute.
+Le Datadog Agent nécessite l'autorisation d'exécuter `rds:DescribeDBClusters` et `rds:DescribeDBInstances` dans votre compte AWS. Datadog recommande d'attacher une politique de rôle IAM à l'instance EC2 sur laquelle le Datadog Agent s'exécute.
-Exemple de politique accordant ces autorisations :
+Un exemple de politique qui accorde ces autorisations :
```json
{
@@ -54,17 +54,17 @@ Exemple de politique accordant ces autorisations :
Vous pouvez également attacher la politique [`AmazonRDSReadOnlyAccess`][3].
-### Configurer les tags Aurora
+### Configurer les balises Aurora {#configure-aurora-tags}
-Le listener découvre tous les clusters Aurora du compte et de la région où l'Agent s'exécute et auxquels le tag `datadoghq.com/scrape:true` est appliqué. Vous pouvez également configurer l'Agent pour découvrir les clusters avec des tags spécifiques.
+Le listener découvre tous les clusters Aurora dans le compte et la région où l'Agent est en cours d'exécution et qui ont la balise `datadoghq.com/scrape:true` appliquée. Vous pouvez également configurer le Datadog Agent pour découvrir des clusters avec des balises spécifiques.
-Appliquez ces tags au cluster DB (rôle : `Regional cluster`). Pour plus d'informations sur l'application de tags aux ressources RDS, consultez la section [documentation AWS][7].
+Vous devez appliquer ces balises au cluster de base de données (Rôle : `Regional cluster`). Pour plus d'informations sur l'étiquetage des ressources RDS, consultez la [documentation AWS][7].
-Si vous configurez `tags` comme un tableau vide, Autodiscovery découvrira tous les clusters du compte et de la région.
+Si vous configurez `tags` comme un tableau vide, l'Autodécouverte découvrira tous les clusters dans le compte et la région.
-### Configurer l'Agent Datadog
+### Configurer le Datadog Agent {#configure-the-datadog-agent}
-Autodiscovery utilise un listener de service de l'Agent qui découvre tous les endpoints des hosts de base de données dans un cluster Aurora et transfère les endpoints découverts au pipeline de planification des checks de l'Agent existant. Configurez le listener dans le fichier `datadog.yaml` :
+L'autodécouverte utilise un listener de service du Datadog Agent, qui découvre tous les endpoints des hôtes de base de données dans un cluster Aurora et transmet les endpoints découverts au pipeline de planification des checks existants. Vous pouvez configurer le listener dans le fichier `datadog.yaml` :
```yaml
database_monitoring:
@@ -73,7 +73,7 @@ database_monitoring:
enabled: true
```
-**Remarque** : l'Agent ne découvre que les instances Aurora s'exécutant dans la même région que l'Agent. Pour déterminer la région de l'instance, l'Agent utilise [IMDS (Instance Metadata Service)][8]. Si votre instance EC2 requiert `IMDSv2`, configurez l'Agent pour utiliser `IMDSv2` en définissant `ec2_prefer_imdsv2: true` dans `datadog.yaml`, comme indiqué ci-dessous :
+**Remarque** : Le Datadog Agent ne découvre que les instances Aurora s'exécutant dans la même région où il s'exécute. Pour déterminer la région de l'instance, le Datadog Agent utilise [IMDS (Instance Metadata Service)][8]. Si votre instance EC2 nécessite `IMDSv2`, vous devez configurer le Datadog Agent pour utiliser `IMDSv2` en définissant `ec2_prefer_imdsv2: true` dans `datadog.yaml`, comme indiqué ci-dessous :
``` yaml {hl_lines=[1]}
ec2_prefer_imdsv2: true
@@ -81,11 +81,12 @@ database_monitoring:
autodiscovery:
aurora:
enabled: true
+
```
-Par défaut, le listener ne découvre que les clusters Aurora du compte et de la région où l'Agent s'exécute, et uniquement ceux portant le tag `datadoghq.com/scrape:true`. Vous pouvez également configurer le listener pour découvrir les clusters avec des tags spécifiques.
+By default, the listener only discovers Aurora clusters in the account and region where the Agent is running, and only those with the `datadoghq.com/scrape:true` tag. You can also configure the listener to discover clusters with specific tags.
-Pour spécifier des tags personnalisés pour la découverte de clusters Aurora dans le fichier `datadog.yaml` :
+To specify custom tags for Aurora cluster discovery in the `datadog.yaml` file:
``` yaml {hl_lines=["5-6"]}
database_monitoring:
@@ -96,7 +97,7 @@ database_monitoring:
- "my-cluster-tag-key:value"
```
-Pour surveiller tous les clusters du compte et de la région :
+To monitor all clusters in the account and region:
``` yaml {hl_lines=["5"]}
database_monitoring:
@@ -104,9 +105,10 @@ database_monitoring:
aurora:
enabled: true
tags: []
+
```
-Le listener interroge l'API AWS pour obtenir la liste des hosts en boucle. La fréquence à laquelle le listener interroge l'API AWS, en secondes, est configurable dans le fichier `datadog.yaml` :
+The listener queries the AWS API for the list of hosts in a loop. The frequency with which the listener queries the AWS API, in seconds, is configurable in the `datadog.yaml` file:
``` yaml {hl_lines=["5"]}
database_monitoring:
@@ -116,7 +118,7 @@ database_monitoring:
discovery_interval: 300
```
-Le listener fournit une variable `%%extra_dbm%%` qui peut être utilisée pour activer ou désactiver DBM pour l'instance. Cette valeur est par défaut `true` si le tag `datadoghq.com/dbm:true` est présent. Pour spécifier un tag personnalisé pour cette valeur, utilisez `dbm_tag` :
+The listener provides an `%%extra_dbm%%` variable that can be used to enable or disable DBM for the instance. This value defaults to `true` if the tag `datadoghq.com/dbm:true` is present. To specify a custom tag for this value use `dbm_tag`:
``` yaml {hl_lines=["5"]}
database_monitoring:
@@ -124,11 +126,12 @@ database_monitoring:
aurora:
enabled: true
dbm_tag: "use_dbm:true"
+
```
-La valeur `%%extra_dbm%%` est true si le tag est présent, et false dans le cas contraire. Elle ne prend pas la valeur du tag.
+The `%%extra_dbm%%` value is true if the tag is present, and false otherwise. It does not set its value to the value of the tag.
-Le listener fournit une variable `%%extra_global_view_db%%` qui peut être utilisée pour définir le `global_view_db` de l'instance. Cette valeur est par défaut celle du tag `datadoghq.com/global_view_db`. Pour spécifier un tag personnalisé pour cette valeur, utilisez `global_view_db_tag` :
+The listener provides an `%%extra_global_view_db%%` variable that can be used to set the `global_view_db` for the instance. This value defaults to the value of the tag `datadoghq.com/global_view_db`. To specify a custom tag for this value use `global_view_db_tag`:
``` yaml {hl_lines=["5"]}
database_monitoring:
@@ -138,21 +141,21 @@ database_monitoring:
global_view_db_tag: "my_db_tag"
```
-### Créer un modèle de configuration
+### Create a configuration template
-L'Agent Datadog prend en charge les modèles de configuration pour les intégrations Postgres et MySQL. Définissez un modèle de configuration pour les clusters Aurora que vous souhaitez surveiller.
+The Datadog Agent supports configuration templates for the Postgres and MySQL integrations. Define a configuration template for the Aurora clusters you wish to monitor.
{{< tabs >}}
{{% tab "Postgres" %}}
-Commencez par ajouter un `ad_identifier` pour Postgres géré par Aurora dans votre fichier de modèle de configuration (`postgres.d/conf_aws_aurora.yaml`) :
+Tout d'abord, ajoutez un `ad_identifier` pour Postgres géré par Aurora à votre modèle de configuration (`postgres.d/conf_aws_aurora.yaml`) :
```yaml
ad_identifiers:
- _dbm_postgres_aurora
```
-Définissez ensuite le reste du modèle. Utilisez des [variables de modèle](#variables-de-modèle-prises-en-charge) pour les paramètres susceptibles de changer, comme `host` et `port`.
+Ensuite, définissez le reste du modèle. Utilisez [les variables de modèle](#supported-template-variables) pour les paramètres qui peuvent changer, tels que `host` et `port`.
```yaml
ad_identifiers:
@@ -173,17 +176,17 @@ instances:
- "region:%%extra_region%%"
```
-Dans cet exemple, les variables de modèle `%%host%%`, `%%port%%`, `%%extra_dbclusteridentifier%%`, `%%extra_dbm%%` et `%%extra_region%%` sont dynamiquement renseignées avec les informations du cluster Aurora.
+Dans cet exemple, les variables de modèle `%%host%%`, `%%port%%`, `%%extra_dbclusteridentifier%%`, `%%extra_dbm%%` et `%%extra_region%%` sont peuplées dynamiquement avec des informations provenant du cluster Aurora.
-#### Authentification
+#### Authentification {#authentication}
-Si vous utilisez un mot de passe pour l'authentification, notez que le mot de passe fourni dans ce fichier de modèle sera utilisé pour chaque base de données découverte.
+Si vous utilisez un mot de passe pour l'authentification, notez que le mot de passe fourni dans ce fichier modèle sera utilisé dans chaque base de données découverte.
-{{% collapse-content title="Stocker votre mot de passe de manière sécurisée" level="h5" id="securely-store-your-password" %}}
-##### Stocker votre mot de passe de manière sécurisée
+{{% collapse-content title="Stockez votre mot de passe en toute sécurité" level="h5" id="securely-store-your-password" %}}
+##### Stockez votre mot de passe en toute sécurité {#securely-store-your-password}
{{% dbm-secret %}}
-Le modèle de configuration exemple suivant est appliqué à chaque instance découverte dans le cluster Aurora :
+Le modèle de configuration d'exemple suivant est appliqué à chaque instance découverte dans le cluster Aurora :
``` yaml {hl_lines=[8]}
ad_identifiers:
@@ -201,13 +204,14 @@ instances:
tags:
- "dbclusteridentifier:%%extra_dbclusteridentifier%%"
- "region:%%extra_region%%"
+
```
{{% /collapse-content %}}
-{{% collapse-content title="Authentification IAM" level="h5" id="iam-authentication" %}}
-##### Authentification IAM
+{{% collapse-content title="IAM Authentication" level="h5" id="iam-authentication" %}}
+##### IAM Authentication
-Pour utiliser l'[authentification IAM][2] afin de vous connecter à votre cluster Aurora, utilisez le modèle suivant :
+To use [IAM authentication][2] to connect to your Aurora cluster, use the following template:
``` yaml {hl_lines=["12-13"]}
ad_identifiers:
@@ -228,14 +232,14 @@ instances:
- "region:%%extra_region%%"
```
-La variable de modèle `%%extra_managed_authentication_enabled%%` prend la valeur `true` si l'instance utilise l'authentification IAM.
+The template variable `%%extra_managed_authentication_enabled%%` resolves to `true` if the instance is using IAM authentication.
[2]: /fr/database_monitoring/guide/managed_authentication/?tab=aurora#configure-iam-authentication
{{% /collapse-content %}}
{{% collapse-content title="Custom global_view_db (7.75.0+)" level="h5" id="global-view-db" %}}
-##### Base de données de vue globale personnalisée
+##### Custom global_view_db {#custom-global-view-database}
-Pour définir une base de données de vue globale personnalisée pour la découverte automatique de bases de données, assurez-vous d'utiliser la version 7.75.0 ou ultérieure de l'Agent et utilisez le modèle suivant :
+Pour définir un Custom global_view_db pour l'autodécouverte de base de données, assurez-vous d'utiliser le Datadog Agent version 7.75.0 ou supérieure et utilisez le modèle suivant :
``` yaml {hl_lines=["11"]}
ad_identifiers:
@@ -248,26 +252,27 @@ instances:
dbm: true
database_autodiscovery:
enabled: true
- global_view_db: "%%global_view_db%%"
+ global_view_db: "%%extra_global_view_db%%"
aws:
instance_endpoint: "%%host%%"
region: "%%extra_region%%"
tags:
- "dbclusteridentifier:%%extra_dbclusteridentifier%%"
- "region:%%extra_region%%"
+
```
{{% /collapse-content %}}
{{% /tab %}}
{{% tab "MySQL" %}}
-Commencez par ajouter un `ad_identifier` pour MySQL géré par Aurora dans votre fichier de modèle de configuration (`mysql.d/conf_aws_aurora.yaml`) :
+First, add an `ad_identifier` for Aurora-managed MySQL to your configuration template (`mysql.d/conf_aws_aurora.yaml`) file:
```yaml
ad_identifiers:
- _dbm_mysql_aurora
```
-Définissez ensuite le reste du modèle. Utilisez des [variables de modèle](#variables-de-modèle-prises-en-charge) pour les paramètres susceptibles de changer, comme `host` et `port`.
+Then, define the remainder of the template. Use [template variables](#supported-template-variables) for parameters that may change, such as `host` and `port`.
```yaml
ad_identifiers:
@@ -286,17 +291,17 @@ instances:
- "region:%%extra_region%%"
```
-Dans cet exemple, les variables de modèle `%%host%%`, `%%port%%`, `%%extra_dbclusteridentifier%%`, `%%extra_dbm%%` et `%%extra_region%%` sont dynamiquement renseignées avec les informations du cluster Aurora.
+In this example, the template variables `%%host%%`, `%%port%%`, `%%extra_dbclusteridentifier%%`, `%%extra_dbm%%`, and `%%extra_region%%` are dynamically populated with information from the Aurora cluster.
-#### Authentification
+#### Authentication
-Si vous utilisez un mot de passe pour l'authentification, notez que le mot de passe fourni dans ce fichier de modèle sera utilisé pour chaque base de données découverte.
+If you are using password for authentication note that the password provided in this template file will be used across every database discovered.
-{{% collapse-content title="Stocker votre mot de passe de manière sécurisée" level="h5" id="securely-store-your-password" %}}
-##### Stocker votre mot de passe de manière sécurisée
+{{% collapse-content title="Stockez votre mot de passe en toute sécurité" level="h5" id="securely-store-your-password" %}}
+##### Stockez votre mot de passe en toute sécurité {#securely-store-your-password-1}
{{% dbm-secret %}}
-Le modèle de configuration exemple suivant est appliqué à chaque instance découverte dans le cluster Aurora :
+Le modèle de configuration d'exemple suivant est appliqué à chaque instance découverte dans le cluster Aurora :
``` yaml {hl_lines=[8]}
ad_identifiers:
@@ -314,13 +319,14 @@ instances:
tags:
- "dbclusteridentifier:%%extra_dbclusteridentifier%%"
- "region:%%extra_region%%"
+
```
{{% /collapse-content %}}
-{{% collapse-content title="Authentification IAM (7.67.0+)" level="h5" id="iam-authentication" %}}
-##### Authentification IAM
+{{% collapse-content title="IAM Authentication (7.67.0+)" level="h5" id="iam-authentication" %}}
+##### IAM Authentication
-Pour utiliser l'[authentification IAM][2] afin de vous connecter à votre instance RDS, assurez-vous d'utiliser la version 7.67.0 ou ultérieure de l'Agent et utilisez le modèle suivant :
+To use [IAM authentication][2] to connect to your RDS instance, make sure that you are using Agent version 7.67.0 or above and use the following template:
``` yaml {hl_lines=["12-13"]}
ad_identifiers:
@@ -341,26 +347,26 @@ instances:
- "region:%%extra_region%%"
```
-La variable de modèle `%%extra_managed_authentication_enabled%%` prend la valeur `true` si l'instance utilise l'authentification IAM.
+The template variable `%%extra_managed_authentication_enabled%%` resolves to `true` if the instance is using IAM authentication.
[2]: /fr/database_monitoring/guide/managed_authentication/?tab=aurora#configure-iam-authentication
{{% /collapse-content %}}
{{% /tab %}}
{{< /tabs >}}
-Pour plus d'informations sur la configuration d'Autodiscovery avec des intégrations, consultez la section [documentation Autodiscovery][5].
+Pour plus d'informations sur la configuration de l'autodécouverte avec des intégrations, consultez la [documentation sur l'autodécouverte][5].
-#### Template variables utilisables
+#### Variables de modèle prises en charge {#supported-template-variables}
-| Template variable | Source |
+| Variable de modèle | Source |
|:-----------------------------------------|:----------------------------------------------------------------------------------------------------------------------------------------------|
| %%host%% | L'endpoint de l'instance Aurora |
| %%port%% | Le port de l'instance Aurora |
-| %%extra_region%% | La région AWS où l'instance est hébergée |
-| %%extra_dbclusteridentifier%% | L'identifiant du cluster Aurora découvert |
-| %%extra_dbm%% | Indique si DBM est activé sur le cluster. Déterminé par la présence de `dbm_tag`, dont la valeur par défaut est `datadoghq.com/dbm:true`. |
-| %%extra_managed_authentication_enabled%% | Indique si l'authentification IAM est activée sur le cluster.
Utilisé pour déterminer si l'authentification gérée doit être utilisée pour la connexion. |
-| %%global_view_db%% | La valeur de `global_view_db_tag`, dont la valeur par défaut est `datadoghq.com/global_view_db`. |
+| %%extra_region%% | La région AWS où se trouve l'instance |
+| %%extra_dbclusteridentifier%% | L'identifiant du cluster de l'Aurora découvert |
+| %%extra_dbm%% | Indique si DBM est activé sur le cluster. Déterminé par la présence de `dbm_tag`, qui par défaut est `datadoghq.com/dbm:true`. |
+| %%extra_managed_authentication_enabled%% | Indique si l'authentification IAM est activée sur le cluster.
Ceci est utilisé pour déterminer si l'authentification gérée doit être utilisée pour la connexion. |
+| %%extra_global_view_db%% | La valeur de `global_view_db_tag`, qui par défaut est `datadoghq.com/global_view_db`. |
[1]: /fr/database_monitoring/setup_postgres/aurora/?tab=postgres10
[3]: https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AmazonRDSReadOnlyAccess.html
diff --git a/content/fr/database_monitoring/setup_sql_server/rds.md b/content/fr/database_monitoring/setup_sql_server/rds.md
index d41f8042350..df94eed359f 100644
--- a/content/fr/database_monitoring/setup_sql_server/rds.md
+++ b/content/fr/database_monitoring/setup_sql_server/rds.md
@@ -1,6 +1,6 @@
---
-description: Installer et configurer Database Monitoring pour SQL Server géré sur
- RDS.
+description: Installez et configurez la surveillance de la base de données pour SQL
+ Server géré sur RDS.
further_reading:
- link: /integrations/sqlserver/
tag: Documentation
@@ -10,40 +10,41 @@ further_reading:
text: Résoudre les problèmes courants
- link: /database_monitoring/guide/sql_deadlock/
tag: Documentation
- text: Configurer la surveillance des deadlocks
+ text: Configurez la surveillance des blocages.
- link: /database_monitoring/guide/sql_extended_events/
tag: Documentation
- text: Configurer la collecte des fins de requêtes et des erreurs de requêtes
+ text: Configurez la collecte de l'achèvement des requêtes et des erreurs de requête.
- link: /database_monitoring/guide/parameterized_queries/
tag: Documentation
- text: Capture des valeurs de paramètres de requêtes SQL
-title: Configuration de Database Monitoring pour SQL Server sur Amazon RDS
+ text: Capturez les valeurs des paramètres de requête SQL.
+title: Configuration de la surveillance de la base de données pour SQL Server sur
+ Amazon RDS.
---
+La solution Database Monitoring vous permet de bénéficier d'une visibilité complète sur vos bases de données Microsoft SQL Server, en exposant des métriques de requête, des échantillons de requête, des plans d'exécution, des états, des failovers et des événements de base de données.
-La solution Database Monitoring vous permet de bénéficier d'une visibilité complète sur vos bases de données Microsoft SQL Server, en exposant des métriques de requête, des échantillons de requête, des plans d'exécution, ainsi que des états, des failovers et des événements de base de données.
+Pour activer la solution Database Monitoring pour votre base de données, suivez les étapes ci-dessous :
-Pour activer la solution Database Monitoring pour votre base de données, suivez les étapes ci-dessous :
+1. [Configurez l'intégration AWS](#configure-the-aws-integration)
+1. [Accordez l'accès à l'Agent](#grant-the-agent-access)
+1. [Installez l'Agent](#install-the-agent)
+1. [Installez l'intégration RDS](#install-the-rds-integration)
-1. [Configurer l'intégration AWS](#configurer-lintegration-aws)
-1. [Accorder un accès à l'Agent](#accorder-un-acces-a-l-agent)
-1. [Installer l'Agent](#installer-l-agent)
-1. [Installer l'intégration RDS](#installer-l-integration-rds)
+## Avant de commencer {#before-you-begin}
-## Avant de commencer
-
-Versions de SQL Server prises en charge : 2014, 2016, 2017, 2019, 2022
+Versions de SQL Server prises en charge
+: 2014, 2016, 2017, 2019, 2022
{{% dbm-sqlserver-before-you-begin %}}
-## Configurer l'intégration AWS
+## Configurez l'intégration AWS {#configure-the-aws-integration}
-Activez la **collecte standard** dans la section **Collecte de ressources** de votre [carré d'intégration Amazon Web Services][2].
+Activez {{< ui >}}Standard Collection{{< /ui >}} dans la section {{< ui >}}Resource Collection{{< /ui >}} de votre [tuile d'intégration Amazon Web Services][2].
-## Accorder un accès à l'Agent
+## Accordez l'accès à l'Agent {#grant-the-agent-access}
-L'Agent Datadog requiert un accès en lecture seule au serveur de la base de données, afin de pouvoir recueillir les statistiques et requêtes.
+L'Agent Datadog requiert un accès en lecture seule pour le serveur de la base de données, afin de pouvoir recueillir les statistiques et requêtes.
-Créez une connexion en lecture seule pour vous connecter au serveur et attribuez les autorisations requises :
+Créez une connexion en lecture seule pour vous connecter au serveur en attribuant les autorisations requises :
```SQL
USE [master];
@@ -67,26 +68,27 @@ GRANT VIEW ANY DEFINITION to datadog;
GO
```
-Créez l'utilisateur `datadog` dans chaque base de données de l'application supplémentaire :
+Créez l'utilisateur `datadog` dans chaque base de données d'application supplémentaire :
+
```SQL
USE [database_name];
CREATE USER datadog FOR LOGIN datadog;
```
-Cela est nécessaire car RDS n'autorise pas l'octroi de `CONNECT ANY DATABASE`. L'Agent Datadog doit se connecter à chaque base de données pour collecter les statistiques d'E/S de fichiers spécifiques à chaque base de données.
+Ceci est requis car RDS ne permet pas d'accorder `CONNECT ANY DATABASE`. L'Agent Datadog doit se connecter à chaque base de données pour collecter des statistiques spécifiques aux fichiers I/O de la base de données.
-### Stocker votre mot de passe de manière sécurisée
+### Stockez votre mot de passe de manière sécurisée {#securely-store-your-password}
{{% dbm-secret %}}
-## Installer l'Agent
+## Installez l'Agent {#install-the-agent}
-AWS n'accordant pas d'accès direct à l'hôte, l'Agent Datadog doit être installé sur un hôte distinct depuis lequel il peut communiquer avec l'hôte SQL Server. Plusieurs options sont disponibles pour installer et exécuter l'Agent.
+Parce qu'AWS ne permet pas l'accès direct à l'hôte, l'Agent Datadog doit être installé sur un hôte séparé où il peut communiquer avec l'hôte SQL Server. Il existe plusieurs options pour installer et exécuter l'Agent.
{{< tabs >}}
-{{% tab "Windows Host" %}}
+{{% tab "Hôte Windows" %}}
{{% dbm-alwayson-cloud-hosted %}}
-Pour commencer à collecter des données de télémétrie SQL Server, [installez l'Agent Datadog][1], puis créez le fichier de configuration de l'Agent SQL Server à l'emplacement `C:\ProgramData\Datadog\conf.d\sqlserver.d\conf.yaml`. Consultez le [fichier de configuration d'exemple][2] pour obtenir toutes les options de configuration disponibles.
+Pour commencer à collecter la télémétrie SQL Server, [installez l'Agent Datadog][1], puis créez le fichier de configuration de l'Agent SQL Server à `C:\ProgramData\Datadog\conf.d\sqlserver.d\conf.yaml`. Référez-vous au [fichier de configuration d'exemple][2] pour toutes les options de configuration disponibles.
```yaml
init_config:
@@ -105,25 +107,26 @@ instances:
instance_endpoint: ''
```
-Pour utiliser l'[authentification Windows][4], définissez `connection_string: "Trusted_Connection=yes"` et ne remplissez pas les champs `username` et `password`.
+Pour utiliser [l'authentification Windows][4], définissez `connection_string: "Trusted_Connection=yes"` et omettez les champs `username` et `password`.
+
+Utilisez les balises `service` et `env` pour lier votre télémétrie de base de données à d'autres télémétries via un schéma de balisage commun. Consultez [Balisage de service unifié][5] pour des détails sur l'utilisation de ces balises dans Datadog.
-Utilisez les tags `service` et `env` pour associer vos données de télémétrie de base de données à d'autres données de télémétrie via un schéma de tagging commun. Consultez la section [Tagging de service unifié][5] pour en savoir plus sur l'utilisation de ces tags dans Datadog.
+### Pilotes pris en charge {#supported-drivers}
-### Pilotes compatibles
+#### Microsoft ADO {#microsoft-ado}
-#### Microsoft ADO
+Le fournisseur [ADO][6] recommandé est le [Pilote OLE DB de Microsoft][7]. Assurez-vous que le pilote est installé sur l'hôte où l'Agent fonctionne.
-Le fournisseur [ADO][6] recommandé est [Microsoft OLE DB Driver][7]. Vérifiez que le pilote est installé sur l'hôte sur lequel l'Agent s'exécute.
```yaml
connector: adodbapi
-adoprovider: MSOLEDBSQL19 # Remplacer cette valeur par MSOLEDBSQL pour la version 18 et les versions antérieures
+adoprovider: MSOLEDBSQL19 # Replace with MSOLEDBSQL for versions 18 and lower
```
Les deux autres fournisseurs, `SQLOLEDB` et `SQLNCLI`, sont considérés comme obsolètes par Microsoft et ne doivent pas être utilisés.
-#### ODBC
+#### ODBC {#odbc}
-Le pilote ODBC recommandé est [Microsoft ODBC Driver][8]. À partir de l'Agent 7.51, ODBC Driver 18 for SQL Server est inclus par défaut dans l'Agent Linux. Pour Windows, vérifiez que le pilote est installé sur l'hôte sur lequel l'Agent s'exécute.
+Le pilote ODBC recommandé est le [Pilote ODBC de Microsoft][8]. À partir de l'Agent 7.51, le Pilote ODBC 18 pour SQL Server est inclus par défaut dans l'Agent Linux. Pour Windows, assurez-vous que le pilote est installé sur l'hôte où l'Agent fonctionne.
```yaml
connector: odbc
@@ -132,9 +135,9 @@ driver: 'ODBC Driver 18 for SQL Server'
Une fois la configuration de l'Agent terminée, [redémarrez l'Agent Datadog][9].
-### Validation
+### Valider {#validate}
-[Lancez la sous-commande status de l'Agent][10] et cherchez `sqlserver` dans la section **Checks**. Accédez à la page [Databases][11] dans Datadog pour commencer le processus de validation.
+[Exécutez la sous-commande d'état de l'Agent][10] et recherchez `sqlserver` sous la section **Vérifications**. Naviguez vers la page [Databases][11] dans Datadog pour commencer.
[1]: https://app.datadoghq.com/account/settings/agent/latest?platform=windows
[2]: https://github.com/DataDog/integrations-core/blob/master/sqlserver/datadog_checks/sqlserver/data/conf.yaml.example
@@ -149,16 +152,16 @@ Une fois la configuration de l'Agent terminée, [redémarrez l'Agent Datadog][9]
[11]: https://app.datadoghq.com/databases
{{% /tab %}}
-{{% tab "Linux Host" %}}
+{{% tab "Hôte Linux" %}}
{{% dbm-alwayson-cloud-hosted %}}
Pour commencer à recueillir des données de télémétrie pour SQL Server, commencez par [installer l'Agent Datadog][1].
-Sur Linux, vous devez également installer un pilote ODBC SQL Server, tel que [Microsoft ODBC Driver][2]. Une fois l'installation terminée, copiez les fichiers `odbc.ini` et `odbcinst.ini` dans le dossier `/opt/datadog-agent/embedded/etc`.
+Sur Linux, vous devez également installer un pilote ODBC pour SQL Server, tel que [le pilote ODBC de Microsoft][2]. Après l'installation, copiez les fichiers `odbc.ini` et `odbcinst.ini` dans le dossier `/opt/datadog-agent/embedded/etc`.
-Utilisez le connecteur `odbc` et spécifiez le bon pilote, tel qu'indiqué dans le fichier `odbcinst.ini`.
+Utilisez le connecteur `odbc` et spécifiez le pilote approprié comme indiqué dans le fichier `odbcinst.ini`.
-Créez le fichier conf de l'Agent SQL Server `/etc/datadog-agent/conf.d/sqlserver.d/conf.yaml`. Consultez l'[exemple de fichier conf][3] pour découvrir toutes les options de configuration disponibles.
+Créez le fichier de configuration de l'Agent SQL Server `/etc/datadog-agent/conf.d/sqlserver.d/conf.yaml`. Consultez le [fichier de configuration d'exemple][3] pour toutes les options de configuration disponibles.
```yaml
init_config:
@@ -177,13 +180,13 @@ instances:
instance_endpoint: ''
```
-Utilisez les tags `service` et `env` pour associer vos données de télémétrie de base de données à d'autres données de télémétrie via un schéma de tagging commun. Consultez la section [Tagging de service unifié][5] pour en savoir plus sur l'utilisation de ces tags dans Datadog.
+Utilisez les balises `service` et `env` pour lier votre télémétrie de base de données à d'autres télémétries via un schéma de balisage commun. Consultez [Balisage de service unifié][5] pour des détails sur l'utilisation de ces balises dans Datadog.
Une fois la configuration de l'Agent terminée, [redémarrez l'Agent Datadog][6].
-### Validation
+### Valider {#validate-1}
-[Lancez la sous-commande status de l'Agent][7] et cherchez `sqlserver` dans la section **Checks**. Accédez à la page [Databases][8] dans Datadog pour commencer le processus de validation.
+[Exécutez la sous-commande d'état de l'Agent][7] et recherchez `sqlserver` dans la section **Vérifications**. Naviguez vers la page [Databases][8] dans Datadog pour commencer.
[1]: https://app.datadoghq.com/account/settings/agent/latest
[2]: https://docs.microsoft.com/en-us/sql/connect/odbc/linux-mac/installing-the-microsoft-odbc-driver-for-sql-server
@@ -200,9 +203,9 @@ Une fois la configuration de l'Agent terminée, [redémarrez l'Agent Datadog][6]
Pour configurer l'Agent Database Monitoring qui s'exécute dans un conteneur Docker, définissez des [modèles d'intégration Autodiscovery][1] en tant qu'étiquettes Docker sur le conteneur de votre Agent.
-**Remarque** : pour que le processus de découverte automatique des étiquettes fonctionne, l'Agent doit être autorisé à lire le socket Docker.
+**Remarque** : L'Agent doit avoir l'autorisation de lecture sur le socket Docker pour que l'Autodécouverte des étiquettes fonctionne.
-Remplacez les valeurs afin qu'elles correspondent à votre compte et votre environnement. Consultez l'[exemple de fichier conf][2] pour découvrir toutes les options de configuration disponibles.
+Remplacez les valeurs pour correspondre à votre compte et à votre environnement. Consultez le [fichier de configuration d'exemple][2] pour toutes les options de configuration disponibles.
```bash
export DD_API_KEY=xxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
@@ -230,11 +233,11 @@ docker run -e "DD_API_KEY=${DD_API_KEY}" \
registry.datadoghq.com/agent:${DD_AGENT_VERSION}
```
-Utilisez les tags `service` et `env` pour lier la télémétrie de votre base de données à d'autres données de télémétrie, par l'intermédiaire d'un schéma de tagging commun. Consultez la section [Tagging de service unifié][4] pour découvrir comment ces tags sont exploités dans l'ensemble de la plateforme Datadog.
+Utilisez les balises `service` et `env` pour lier votre télémétrie de base de données à d'autres télémétries via un schéma de balisage commun. Consultez [l'étiquetage de service unifié][4] pour des informations sur l'utilisation de ces balises dans Datadog.
-### Validation
+### Valider {#validate-2}
-[Lancez la sous-commande status de l'Agent][5] et cherchez `sqlserver` dans la section **Checks**. Sinon, accédez à la page [Databases][6] dans Datadog pour commencer le processus de validation.
+[Exécutez la sous-commande d'état de l'Agent][5] et recherchez `sqlserver` dans la section **Vérifications**. Alternativement, naviguez vers la page [Databases][6] dans Datadog pour commencer.
[1]: /fr/agent/faq/template_variables/
[2]: https://github.com/DataDog/integrations-core/blob/master/sqlserver/datadog_checks/sqlserver/data/conf.yaml.example
@@ -247,13 +250,13 @@ Utilisez les tags `service` et `env` pour lier la télémétrie de votre base de
{{% tab "Kubernetes" %}}
{{% dbm-alwayson-cloud-hosted %}}
-Si vous exécutez un cluster Kubernetes, utilisez l'[Agent de cluster de Datadog][1] pour activer Database Monitoring. Si les checks de cluster ne sont pas déjà activés, [suivez ces instructions][2] pour les activer avant de continuer.
+Si vous exécutez un cluster Kubernetes, utilisez [l'Agent de cluster Datadog][1] pour activer la surveillance des bases de données. Si les vérifications de cluster ne sont pas déjà activées, [suivez ces instructions][2] pour les activer avant de continuer.
-### Operator
+### Opérateur {#operator}
-Suivez les étapes ci-dessous pour configurer l'intégration SQL Server en vous appuyant sur les [instructions relatives à l'Operator dans Kubernetes et les intégrations][6] comme référence.
+Suivez les étapes ci-dessous pour configurer l'intégration SQL Server, en utilisant les [instructions de l'Opérateur dans Kubernetes et Intégrations][6] comme référence.
-1. Créez ou mettez à jour le fichier `datadog-agent.yaml` avec la configuration suivante :
+1. Créez ou mettez à jour le fichier `datadog-agent.yaml` avec la configuration suivante :
```yaml
apiVersion: datadoghq.com/v2alpha1
@@ -301,18 +304,18 @@ Suivez les étapes ci-dessous pour configurer l'intégration SQL Server en vous
instance_endpoint:
```
-2. Appliquez les modifications à l'Operator Datadog à l'aide de la commande suivante :
+2. Appliquez les modifications à l'Opérateur Datadog en utilisant la commande suivante :
```shell
kubectl apply -f datadog-agent.yaml
```
-### Helm
+### Helm {#helm}
-Suivez les étapes ci-dessous pour installer l'[Agent de cluster de Datadog][1] sur votre cluster Kubernetes. Remplacez les valeurs pour qu'elles correspondent à votre compte et à votre environnement.
+Complétez les étapes suivantes pour installer le [Datadog Cluster Agent][1] sur votre cluster Kubernetes. Remplacez les valeurs pour correspondre à votre compte et à votre environnement.
-1. Suivez les [instructions d'installation de l'Agent Datadog][3] pour Helm.
-2. Mettez à jour votre fichier de configuration YAML (`datadog-values.yaml` dans les instructions d'installation de l'Agent de cluster) pour y inclure les éléments suivants :
+1. Complétez les [instructions d'installation de l'Agent Datadog][3] pour Helm.
+2. Mettez à jour votre fichier de configuration YAML (`datadog-values.yaml` dans les instructions d'installation du Cluster Agent) pour inclure ce qui suit :
```yaml
clusterAgent:
confd:
@@ -344,12 +347,12 @@ Suivez les étapes ci-dessous pour installer l'[Agent de cluster de Datadog][1]
```
-Pour Windows, ajoutez --set targetSystem=windows à la commande helm install.
+Pour Windows, ajoutez --set targetSystem=windows au helm install commande.
-### Configuration avec des fichiers montés
+### Configurez avec des fichiers montés {#configure-with-mounted-files}
-Pour configurer un check de cluster avec un fichier de configuration monté, montez le fichier de configuration dans le conteneur de l'Agent de cluster à l'emplacement suivant : `/conf.d/sqlserver.yaml`.
+Pour configurer un contrôle de cluster avec un fichier de configuration monté, montez le fichier de configuration dans le conteneur du Cluster Agent sur le chemin : `/conf.d/sqlserver.yaml`.
```yaml
cluster_check: true # Required for cluster checks
@@ -370,9 +373,9 @@ instances:
instance_endpoint:
```
-### Configuration avec les annotations de service Kubernetes
+### Configurez avec des annotations de service Kubernetes {#configure-with-kubernetes-service-annotations}
-Plutôt que de monter un fichier, vous pouvez déclarer la configuration de l'instance en tant que service Kubernetes. Pour configurer ce check pour un Agent s'exécutant sur Kubernetes, créez un service avec la syntaxe suivante :
+Au lieu de monter un fichier, vous pouvez déclarer la configuration de l'instance en tant que Service Kubernetes. Pour configurer ce contrôle pour un Agent fonctionnant sur Kubernetes, créez un service en utilisant la syntaxe suivante :
```yaml
apiVersion: v1
@@ -405,11 +408,11 @@ spec:
name: sqlserver
```
-Consultez les [spécifications de l'intégration SQL Server][4] pour en savoir plus sur la définition des champs `deployment_type` et `name`.
+Consultez la [spécification d'intégration SQL Server][4] pour des informations supplémentaires sur la définition des champs `deployment_type` et `name` :
L'Agent de cluster enregistre automatiquement cette configuration et commence à exécuter le check SQL Server.
-Pour éviter d'exposer le mot de passe de l'utilisateur `datadog` en clair, utilisez le [package de gestion des secrets][5] de l'Agent et déclarez le mot de passe à l'aide de la syntaxe `ENC[]`.
+Pour éviter d'exposer le mot de passe de l'utilisateur `datadog` en texte clair, utilisez le [package de gestion des secrets][5] de l'Agent et déclarez le mot de passe en utilisant la syntaxe `ENC[]`.
[1]: /fr/agent/cluster_agent
@@ -423,14 +426,14 @@ Pour éviter d'exposer le mot de passe de l'utilisateur `datadog` en clair, util
{{< /tabs >}}
-## Exemples de configuration de l'Agent
+## Exemples de configurations d'Agent {#example-agent-configurations}
{{% dbm-sqlserver-agent-config-examples %}}
-## Installer l'intégration RDS
+## Installez l'intégration RDS {#install-the-rds-integration}
-Pour collecter des métriques de base de données et des logs plus complets depuis AWS, installez l'[intégration RDS][1].
+Pour collecter des métriques et des journaux de base de données plus complets d'AWS, installez l'[intégration RDS][1].
-## Pour aller plus loin
+## Lectures complémentaires {#further-reading}
{{< partial name="whats-next/whats-next.html" >}}
diff --git a/content/fr/database_monitoring/setup_sql_server/selfhosted.md b/content/fr/database_monitoring/setup_sql_server/selfhosted.md
index 4f0ce3b5f4c..9bbb121d09c 100644
--- a/content/fr/database_monitoring/setup_sql_server/selfhosted.md
+++ b/content/fr/database_monitoring/setup_sql_server/selfhosted.md
@@ -9,13 +9,13 @@ further_reading:
text: Résoudre les problèmes courants
- link: /database_monitoring/guide/sql_deadlock/
tag: Documentation
- text: Configurer la surveillance des deadlocks
+ text: Configurer la surveillance des blocages
- link: /database_monitoring/guide/sql_extended_events/
tag: Documentation
- text: Configurer la collecte des fins de requêtes et des erreurs de requêtes
+ text: Configurer la collecte des complétions et des erreurs de requêtes
- link: /database_monitoring/guide/parameterized_queries/
tag: Documentation
- text: Capturer les valeurs des paramètres de requêtes SQL
+ text: Capturer les valeurs des paramètres de requête SQL
- link: https://www.datadoghq.com/blog/migrate-sql-workloads-to-azure-with-datadog/
tag: Blog
text: Planifier votre migration Azure pour les workloads SQL avec Datadog
@@ -25,28 +25,28 @@ further_reading:
Monitoring Datadog
title: Configuration de Database Monitoring pour SQL Server auto-hébergé
---
+La solution Database Monitoring vous permet de bénéficier d'une visibilité complète sur vos bases de données Microsoft SQL Server, en exposant des métriques de requête, des échantillons de requête, des plans d'exécution, des états, des failovers et des événements de base de données.
-La solution Database Monitoring vous permet de bénéficier d'une visibilité complète sur vos bases de données Microsoft SQL Server, en exposant des métriques de requête, des échantillons de requête, des plans d'exécution, ainsi que des états, des failovers et des événements de base de données.
+Pour activer la solution Database Monitoring pour votre base de données, suivez les étapes ci-dessous :
-Pour activer la solution Database Monitoring pour votre base de données, suivez les étapes ci-dessous :
+1. [Accorder l'accès à l'Agent](#grant-the-agent-access)
+1. [Installer l'Agent](#install-the-agent)
-1. [Accorder un accès à l'Agent](#accorder-un-acces-a-l-agent)
-1. [Installer l'Agent](#installer-l-agent)
+## Avant de commencer {#before-you-begin}
-## Avant de commencer
-
-Versions de SQL Server prises en charge : 2012, 2014, 2016, 2017, 2019, 2022
+Versions de SQL Server prises en charge
+: 2012, 2014, 2016, 2017, 2019, 2022, 2025 (nécessite l'Agent 7.79+)
{{% dbm-sqlserver-before-you-begin %}}
-## Accorder un accès à l'Agent
+## Accorder l'accès à l'Agent {#grant-the-agent-access}
-L'Agent Datadog requiert un accès en lecture seule pour le serveur de base de données, afin de pouvoir recueillir les statistiques et requêtes.
+L'Agent Datadog requiert un accès en lecture seule au serveur de base de données afin de pouvoir recueillir les statistiques et requêtes.
-Créez une connexion en lecture seule pour vous connecter au serveur et attribuez les autorisations requises :
+Créez une connexion en lecture seule pour vous connecter au serveur en attribuant les autorisations requises :
{{< tabs >}}
-{{% tab "SQL Server 2014 et versions ultérieures" %}}
+{{% tab "SQL Server 2014+" %}}
```SQL
CREATE LOGIN datadog WITH PASSWORD = '';
@@ -61,7 +61,7 @@ CREATE USER datadog FOR LOGIN datadog;
GRANT SELECT to datadog;
```
{{% /tab %}}
-{{% tab "SQL Server 2012" %}}
+{{% tab "SQL Server 2012" %}}
```SQL
CREATE LOGIN datadog WITH PASSWORD = '';
@@ -75,7 +75,8 @@ CREATE USER datadog FOR LOGIN datadog;
GRANT SELECT to datadog;
```
-Créez l'utilisateur `datadog` dans chaque base de données de l'application supplémentaire :
+Créer le `datadog` utilisateur dans chaque base de données d'application supplémentaire :
+
```SQL
USE [database_name];
CREATE USER datadog FOR LOGIN datadog;
@@ -83,27 +84,27 @@ CREATE USER datadog FOR LOGIN datadog;
{{% /tab %}}
{{< /tabs >}}
-### Stocker votre mot de passe en toute sécurité
+### Stockez votre mot de passe de manière sécurisée {#securely-store-your-password}
{{% dbm-secret %}}
-## Installer l'Agent
+## Installer l'Agent {#install-the-agent}
Il est conseillé d'installer directement l'Agent sur le host SQL Server. En effet, cette approche permet à l'Agent de recueillir de nombreuses données de télémétrie système (processeur, mémoire, disque, réseau), en plus des données de télémétrie propres à SQL Server.
{{< tabs >}}
-{{% tab "Windows Host" %}}
+{{% tab "Hôte Windows" %}}
{{% dbm-alwayson %}}
{{% dbm-sqlserver-agent-setup-windows %}}
{{% /tab %}}
-{{% tab "Linux Host" %}}
+{{% tab "Hôte Linux" %}}
{{% dbm-alwayson %}}
{{% dbm-sqlserver-agent-setup-linux %}}
{{% /tab %}}
{{< /tabs >}}
-## Exemples de configuration de l'Agent
+## Exemples de configurations d'Agent {#example-agent-configurations}
{{% dbm-sqlserver-agent-config-examples %}}
-## Pour aller plus loin
+## Lectures complémentaires {#further-reading}
{{< partial name="whats-next/whats-next.html" >}}
\ No newline at end of file
diff --git a/content/fr/events/pipelines_and_processors/grok_parser.md b/content/fr/events/pipelines_and_processors/grok_parser.md
new file mode 100644
index 00000000000..837dc19ebbc
--- /dev/null
+++ b/content/fr/events/pipelines_and_processors/grok_parser.md
@@ -0,0 +1,665 @@
+---
+aliases:
+- /fr/service_management/events/pipelines_and_processors/grok_parser/
+description: Créez des règles grok personnalisées pour analyser le message complet
+ ou des attributs spécifiques des événements bruts en données structurées
+title: Parser Grok
+---
+## Aperçu {#overview}
+
+Créez des règles grok personnalisées pour analyser le message complet ou un attribut spécifique de votre événement brut. En tant que meilleure pratique, il est recommandé d'utiliser au maximum 10 règles d'analyse dans un processeur grok.
+
+
+{{< img src="service_management/events/grok-parser.png" alt="Exemple d'analyse 1" style="width:80%;">}}
+
+
+Cliquez sur **Analyser mes événements** pour démarrer un ensemble de trois règles d'analyse pour les événements circulant dans le pipeline sous-jacent. Affinez la nomination des attributs à partir de là, et ajoutez de nouvelles règles pour d'autres types d'événements si nécessaire. Cette fonctionnalité nécessite que les événements correspondants soient indexés et effectivement en cours de traitement ; vous pouvez temporairement désactiver ou réduire les filtres d'exclusion pour que cela fonctionne pour vous.
+
+Cliquez sur un échantillon pour le sélectionner et déclencher son évaluation par rapport à la règle de parsing. Le résultat s'affiche alors en bas de l'écran.
+
+Jusqu'à cinq échantillons peuvent être enregistrés avec le processeur, et chaque échantillon peut avoir jusqu'à 5000 caractères de longueur. Tous les échantillons affichent un statut (correspondance ou non correspondance), ce qui met en évidence si l'une des règles d'analyse du parseur grok correspond à l'échantillon.
+
+
+### Syntaxe Grok {#grok-syntax}
+
+Le parseur Grok extrait des attributs de messages texte semi-structurés. Grok est livré avec des modèles réutilisables pour analyser des entiers, des adresses IP, des noms d'hôtes, et plus encore. Ces valeurs doivent être envoyées au parseur grok sous forme de chaînes.
+
+Vous pouvez écrire des règles d'analyse avec la syntaxe `%{MATCHER:EXTRACT:FILTER}` :
+
+* **Correspondant** : Une règle (éventuellement une référence à une autre règle de jeton) qui décrit ce à quoi s'attendre (nombre, mot, non espace, etc.).
+
+* **Extraire** (optionnel) : Un identifiant représentant la destination de capture pour le morceau de texte correspondant au *Correspondant*.
+
+* **Filtre** (optionnel) : Un post-traitement de la correspondance pour la transformer.
+
+Exemple pour un événement non structuré classique :
+
+```text
+john connected on 11/08/2017
+```
+
+Avec la règle de parsing suivante :
+
+```text
+MyParsingRule %{word:user} connected on %{date("MM/dd/yyyy"):date}
+```
+
+Après traitement, l'événement structuré suivant est généré :
+
+{{< img src="logs/processing/processors/_parser.png" alt="Exemple d'analyse 1" style="width:80%;">}}
+
+**Remarque** :
+
+* Si vous avez plusieurs règles d'analyse dans un seul parseur Grok :
+ * Une seule peut correspondre à un événement donné. La première qui correspond, de haut en bas, est celle qui effectue l'analyse.
+ * Chaque règle peut référencer des règles d'analyse définies au-dessus d'elle dans la liste.
+* Vous devez avoir des noms de règles uniques au sein du même parseur Grok.
+* Le nom de la règle doit contenir uniquement : des caractères alphanumériques, `_` et `.`. Il doit commencer par un caractère alphanumérique.
+* Les propriétés avec des valeurs nulles ou vides ne sont pas affichées.
+* Le matcher regex applique un `^` implicite, pour correspondre au début d'une chaîne, et un `$`, pour correspondre à la fin d'une chaîne.
+* Certains événements peuvent produire de grands espaces vides. Utilisez `\n` et `\s+` pour tenir compte des nouvelles lignes et des espaces vides.
+
+### Correspondant et filtre {#matcher-and-filter}
+
+Voici la liste de tous les matchers et de tous les filtres implémentés en natif par Datadog :
+
+{{< tabs >}}
+{{% tab "Correspondants" %}}
+
+`date("pattern"[, "timezoneId"[, "localeId"]])`
+: Correspond à une date avec le modèle spécifié et l'analyse pour produire un timestamp Unix. [Voir les exemples du Correspondant de date](#parsing-dates).
+
+`regex("pattern")`
+: Correspond à une regex. [Vérifiez les exemples du Correspondant regex](#regex).
+
+`notSpace`
+: Correspond à toute chaîne jusqu'à l'espace suivant.
+
+`boolean("truePattern", "falsePattern")`
+: Correspond et analyse un booléen, définissant éventuellement les modèles vrai et faux (par défaut à `true` et `false`, en ignorant la casse).
+
+`numberStr`
+: Correspond à un nombre décimal à virgule flottante et l'analyse comme une chaîne.
+
+`number`
+: Correspond à un nombre décimal à virgule flottante et l'analyse comme un nombre à double précision.
+
+`numberExtStr`
+: Correspond à un nombre à virgule flottante (avec prise en charge de la notation scientifique) et l'analyse comme une chaîne.
+
+`numberExt`
+: Correspond à un nombre à virgule flottante (avec prise en charge de la notation scientifique) et l'analyse comme un nombre à double précision.
+
+`integerStr`
+: Correspond à un nombre entier et l'analyse comme une chaîne.
+
+`integer`
+: Correspond à un nombre entier et l'analyse comme un nombre entier.
+
+`integerExtStr`
+: Correspond à un nombre entier (avec prise en charge de la notation scientifique) et l'analyse comme une chaîne.
+
+`integerExt`
+: Correspond à un nombre entier (avec prise en charge de la notation scientifique) et l'analyse comme un nombre entier.
+
+`word`
+: Correspond à des caractères de a-z, A-Z, 0-9, y compris le caractère _ (soulignement).
+
+`doubleQuotedString`
+: Correspond à une chaîne entre guillemets doubles.
+
+`singleQuotedString`
+: Correspond à une chaîne entre guillemets simples.
+
+`quotedString`
+: Correspond à une chaîne entre guillemets doubles ou simples.
+
+`uuid`
+: Correspond à un UUID.
+
+`mac`
+: Correspond à une adresse MAC.
+
+`ipv4`
+: Correspond à un IPV4.
+
+`ipv6`
+: Correspond à un IPV6.
+
+`ip`
+: Correspond à une IP (v4 ou v6).
+
+`hostname`
+: Correspond à un nom d'hôte.
+
+`ipOrHost`
+: Correspond à un nom d'hôte ou à une IP.
+
+`port`
+: Correspond à un numéro de port.
+
+`data`
+: Correspond à toute chaîne, y compris les espaces et les nouvelles lignes. Équivalent à `.*` en regex. Utilisez lorsque aucun des modèles ci-dessus n'est approprié.
+
+{{% /tab %}}
+{{% tab "Filtres" %}}
+
+`number`
+: Analyse une correspondance en tant que nombre à double précision.
+
+`integer`
+: Analyse une correspondance en tant que nombre entier.
+
+`boolean`
+: Analyse les chaînes 'true' et 'false' en tant que booléens en ignorant la casse.
+
+`nullIf("value")`
+: Renvoie null si la correspondance est égale à la valeur fournie.
+
+`json`
+: Analyse le JSON correctement formaté.
+
+`rubyhash`
+: Analyse un hash Ruby correctement formaté tel que `{name => "John", "job" => {"company" => "Big Company", "title" => "CTO"}}`.
+
+`useragent([decodeuricomponent:true/false])`
+: Analyse un agent utilisateur et renvoie un objet JSON contenant l'appareil, le système d'exploitation et le navigateur représentés par l'agent. [Vérifiez le processeur d'agent utilisateur][1].
+
+`querystring`
+: Extrait toutes les paires clé-valeur dans une chaîne de requête d'URL correspondante (par exemple, `?productId=superproduct&promotionCode=superpromo`).
+
+`decodeuricomponent`
+: Décode les composants URI. Par exemple, il transforme `%2Fservice%2Ftest` en `/service/test`.
+
+`lowercase`
+: Renvoie la chaîne en minuscules.
+
+`uppercase`
+: Renvoie la chaîne en majuscules.
+
+`keyvalue([separatorStr[, characterAllowList[, quotingStr[, delimiter]]]])`
+: Extrait le motif clé-valeur et renvoie un objet JSON. Voir les [exemples de filtre clé-valeur](#key-value-or-logfmt).
+
+`xml`
+: Analyse le XML correctement formaté. Voir les [exemples de filtre XML](#parsing-xml).
+
+`csv(headers[, separator[, quotingcharacter]])`
+: Analyse correctement les lignes CSV ou TSV formatées. Voir les [exemples de filtre CSV](#parsing-csv).
+
+`scale(factor)`
+: Multiplie la valeur numérique attendue par le facteur fourni.
+
+`array([[openCloseStr, ] separator][, subRuleOrFilter)`
+: Analyse une séquence de chaînes de tokens et la renvoie sous forme de tableau. Voir l'exemple de [liste à tableau](#list-to-array).
+
+`url`
+: Analyse une URL et renvoie tous les membres tokenisés (domaine, paramètres de requête, port, etc.) dans un objet JSON.
+{{% /tab %}}
+{{< /tabs >}}
+
+## Paramètres avancés {#advanced-settings}
+
+En bas de vos tuiles de processeur Grok, il y a une section **Paramètres avancés** :
+
+{{< img src="logs/processing/parsing/advanced_settings.png" alt="Paramètres avancés" style="width:80%;">}}
+
+### Analyse d'un attribut de texte spécifique {#parsing-a-specific-text-attribute}
+
+Utilisez le champ **Extraire de** pour appliquer votre processeur Grok sur un attribut de texte donné au lieu de l'attribut par défaut `message`.
+
+Par exemple, considérez un événement contenant un `command.line` attribut qui doit être analysé comme une paire clé-valeur. Vous pourriez analyser cet événement comme suit :
+
+{{< img src="logs/processing/parsing/parsing_attribute.png" alt="Analyse de la ligne de commande" style="width:80%;">}}
+
+### Utilisation de règles d'aide pour factoriser plusieurs règles d'analyse {#using-helper-rules-to-factorize-multiple-parsing-rules}
+
+Utilisez le champ **Règles d'aide** pour définir des tokens pour vos règles d'analyse. Les règles d'aide vous aident à factoriser les motifs Grok à travers vos règles d'analyse. Ceci est utile lorsque vous avez plusieurs règles dans le même parseur Grok qui utilisent les mêmes tokens.
+
+Exemple pour un événement non structuré classique :
+
+```text
+john id:12345 connected on 11/08/2017 on server XYZ in production
+```
+
+Utilisez la règle de parsing suivante :
+
+```text
+MyParsingRule %{user} %{connection} %{server}
+```
+
+Avec les auxiliaires suivants :
+
+```text
+user %{word:user.name} id:%{integer:user.id}
+connection connected on %{date("MM/dd/yyyy"):connect_date}
+server on server %{notSpace:server.name} in %{notSpace:server.env}
+```
+
+{{< img src="logs/processing/parsing/helper_rules.png" alt="règles d'aide" style="width:80%;">}}
+
+## Exemples {#examples}
+
+Voici des exemples d'utilisation des parsers :
+
+* [Valeur clé ou logfmt](#key-value-or-logfmt)
+* [Analyse des dates](#parsing-dates)
+* [Modèles alternés](#alternating-pattern)
+* [Attribut optionnel](#optional-attribute)
+* [JSON imbriqué](#nested-json)
+* [Regex](#regex)
+* [Listes et tableaux](#list-to-array)
+* [ Format Glog](#glog-format)
+* [XML](#parsing-xml)
+* [CSV](#parsing-csv)
+
+### Valeur clé ou logfmt {#key-value-or-logfmt}
+
+Ceci est le filtre de base clé-valeur : `keyvalue([separatorStr[, characterAllowList[, quotingStr[, delimiter]]]])` où :
+
+* `separatorStr` : définit le séparateur entre les clés et les valeurs. Par défaut, c'est `=`.
+* `characterAllowList` : définit des caractères de valeur supplémentaires non échappés en plus de la valeur par défaut `\\w.\\-_@`. Utilisé uniquement pour les valeurs non citées (par exemple, `key=@valueStr`).
+* `quotingStr` : définit les guillemets, remplaçant la détection par défaut des guillemets : `<>`, `""`, `''`.
+* `delimiter` : définit le séparateur entre les différentes paires clé-valeur (par exemple, `|` est le délimiteur dans `key1=value1|key2=value2`). Par défaut, c'est ` ` (espace normal), `,` et `;`.
+
+Utilisez des filtres tels que **keyvalue** pour mapper plus facilement des chaînes à des attributs pour les formats keyvalue ou logfmt :
+
+**Événement :**
+
+```text
+user=john connect_date=11/08/2017 id=123 action=click
+```
+
+**Règle :**
+
+```text
+rule %{data::keyvalue}
+```
+
+{{< img src="logs/processing/parsing/parsing_example_2.png" alt="Exemple de parsing 2" style="width:80%;">}}
+
+Vous n'avez pas besoin de spécifier le nom de vos paramètres car ils sont déjà contenus dans l'événement.
+Si vous ajoutez un attribut **extract** `my_attribute` dans votre modèle de règle, vous verrez :
+
+{{< img src="logs/processing/parsing/parsing_example_2_bis.png" alt="Exemple de parsing 2 bis" style="width:80%;">}}
+
+Si `=` n'est pas le séparateur par défaut entre vos clés et valeurs, ajoutez un paramètre dans votre règle de parsing avec un séparateur.
+
+**Événement :**
+
+```text
+user: john connect_date: 11/08/2017 id: 123 action: click
+```
+
+**Règle :**
+
+```text
+rule %{data::keyvalue(": ")}
+```
+
+{{< img src="logs/processing/parsing/key_value_parser.png" alt="Analyseur clé-valeur" style="width:80%;" >}}
+
+Si l'événement contient des caractères spéciaux dans une valeur d'attribut, comme `/` dans une URL par exemple, ajoutez-le à la liste blanche dans la règle de parsing :
+
+**Événement :**
+
+```text
+url=https://app.datadoghq.com/event/stream user=john
+```
+
+**Règle :**
+
+```text
+rule %{data::keyvalue("=","/:")}
+```
+
+{{< img src="logs/processing/parsing/key_value_allowlist.png" alt="Liste blanche des clés et valeurs" style="width:80%;" >}}
+
+Autres exemples :
+
+| **Chaîne brute** | **Règle de parsing** | **Résultat** |
+|:-----------------------------|:------------------------------------------------------|:--------------------------------------|
+| key=valueStr | `%{data::keyvalue}` | {"key": "valueStr"} |
+| key=\ | `%{data::keyvalue}` | {"key": "valueStr"} |
+| "key"="valueStr" | `%{data::keyvalue}` | {"key": "valueStr"} |
+| key:valueStr | `%{data::keyvalue(":")}` | {"key": "valueStr"} |
+| key:"/valueStr" | `%{data::keyvalue(":", "/")}` | {"key": "/valueStr"} |
+| /key:/valueStr | `%{data::keyvalue(":", "/")}` | {"/key": "/valueStr"} |
+| key:={valueStr} | `%{data::keyvalue(":=", "", "{}")}` | {"key": "valueStr"} |
+| key1=value1\|key2=value2 | %{data::keyvalue("=", "", "", "|")} | {"key1": "value1", "key2": "value2"} |
+| key1="value1"\|key2="value2" | %{data::keyvalue("=", "", "", "|")} | {"key1": "value1", "key2": "value2"} |
+
+**Exemple de chaîne de citation multiple** : Lorsque plusieurs chaînes de citation sont définies, le comportement par défaut est remplacé par un caractère de citation défini.
+La clé-valeur correspond toujours aux entrées sans aucun caractère de citation, quel que soit ce qui est spécifié dans `quotingStr`. Lorsque des caractères de citation sont utilisés, le `characterAllowList` est ignoré car tout ce qui se trouve entre les caractères de citation est extrait.
+
+**Événement :**
+
+ ```text
+ key1:=valueStr key2:= key3:="valueStr3"
+ ```
+
+**Règle :**
+
+ ```text
+ rule %{data::keyvalue(":=","","<>")}
+ ```
+
+**Résultat :**
+
+ ```json
+ {"key1": "valueStr", "key2": "/valueStr2"}
+ ```
+
+**Remarque** :
+
+* Les valeurs vides (`key=`) ou les valeurs `null` (`key=null`) ne sont pas affichées dans le JSON de sortie.
+* Si vous définissez un filtre *clévaleur* sur un `data` objet, et que ce filtre n'est pas respecté, alors un JSON vide `{}` est retourné (par exemple, entrée : `key:=valueStr`, règle de parsing : `rule_test %{data::keyvalue("=")}`, sortie : `{}`).
+* Définir `""` comme `quotingStr` conserve la configuration par défaut pour la citation.
+
+### Parsing des dates {#parsing-dates}
+
+Le date matcher transforme votre horodatage au format EPOCH (unité de mesure **millisecondes**).
+
+| **Chaîne brute** | **Règle de parsing** | **Résultat** |
+|:-------------------------------------|:----------------------------------------------------------|:------------------------|
+| 14:20:15 | `%{date("HH:mm:ss"):date}` | {"date": 51615000} |
+| 02:20:15 PM | `%{date("hh:mm:ss a"):date}` | {"date": 51615000} |
+| 11/10/2014 | `%{date("dd/MM/yyyy"):date}` | {"date": 1412978400000} |
+| Jeu Jun 16 08:29:03 2016 | `%{date("EEE MMM dd HH:mm:ss yyyy"):date}` | {"date": 1466065743000} |
+| Mar Nov 1 08:29:03 2016 | `%{date("EEE MMM d HH:mm:ss yyyy"):date}` | {"date": 1466065743000} |
+| 06/Mar/2013:01:36:30 +0900 | `%{date("dd/MMM/yyyy:HH:mm:ss Z"):date}` | {"date": 1362501390000} |
+| 2016-11-29T16:21:36.431+0000 | `%{date("yyyy-MM-dd'T'HH:mm:ss.SSSZ"):date}` | {"date": 1480436496431} |
+| 2016-11-29T16:21:36.431+00:00 | `%{date("yyyy-MM-dd'T'HH:mm:ss.SSSZZ"):date}` | {"date": 1480436496431} |
+| 06/Feb/2009:12:14:14.655 | `%{date("dd/MMM/yyyy:HH:mm:ss.SSS"):date}` | {"date": 1233922454655} |
+| 2007-08-31 19:22:22.427 ADT | `%{date("yyyy-MM-dd HH:mm:ss.SSS z"):date}` | {"date": 1188598942427} |
+| Jeu 16 juin 2016 08:29:031 | `%{date("EEE MMM dd HH:mm:ss yyyy","Europe/Paris"):date}` | {"date": 1466058543000} |
+| Jeu 16 juin 2016 08:29:031 | `%{date("EEE MMM dd HH:mm:ss yyyy","UTC+5"):date}` | {"date": 1466047743000} |
+| Jeu 16 juin 2016 08:29:031 | `%{date("EEE MMM dd HH:mm:ss yyyy","+3"):date}` | {"date": 1466054943000} |
+
+1 Utilisez le `timezone` paramètre si vous effectuez vos propres localisations et que vos horodatages ne sont _pas_ en UTC.
+Les formats pris en charge pour les fuseaux horaires sont :
+
+* `GMT`, `UTC`, `UT` ou `Z`
+* `+h`, `+hh`, `+hh:mm`, `-hh:mm`, `+hhmm`, `-hhmm`, `+hh:mm:ss`, `-hh:mm:ss`, `+hhmmss` ou `-hhmmss`. La plage maximale prise en charge est de +18:00 à -18:00 inclus.
+* Les fuseaux horaires commençant par `UTC+`, `UTC-`, `GMT+`, `GMT-`, `UT+` ou `UT-`. La plage maximale prise en charge est de +18:00 à -18:00 inclus.
+* Identifiants de fuseaux horaires extraits de la base de données TZ. Pour plus d'informations, consultez [noms de la base de données TZ][2].
+
+**Remarque** : L'analyse d'une date **ne** définit pas sa valeur comme la date officielle de l'événement. Pour cela, utilisez le [Remappeur de date d'événement][3] dans un processeur ultérieur.
+
+### Modèle alternatif {#alternating-pattern}
+
+Si vous avez des événements avec deux formats possibles qui diffèrent par un seul attribut, définissez une règle unique en utilisant l'alternance avec `(|)`. Cette règle est équivalente à un OU booléen.
+
+**Événement** :
+
+```text
+john connected on 11/08/2017
+12345 connected on 11/08/2017
+```
+
+**Règle** :
+Notez que "id" est un entier et non une chaîne.
+
+```text
+MyParsingRule (%{integer:user.id}|%{word:user.firstname}) connected on %{date("MM/dd/yyyy"):connect_date}
+```
+
+**Résultats** :
+
+{{< img src="logs/processing/parsing/parsing_example_4.png" alt="Exemple de parsing 4" style="width:80%;" >}}
+
+{{< img src="logs/processing/parsing/parsing_example_4_bis.png" alt="Exemple de parsing 4 bis" style="width:80%;" >}}
+
+### Attribut optionnel {#optional-attribute}
+
+Certains événements contiennent des valeurs qui n'apparaissent qu'une partie du temps. Dans ce cas, rendez l'extraction d'attributs optionnelle avec `()?`.
+
+**Événement** :
+
+```text
+john 1234 connected on 11/08/2017
+```
+
+**Règle** :
+
+```text
+MyParsingRule %{word:user.firstname} (%{integer:user.id} )?connected on %{date("MM/dd/yyyy"):connect_date}
+```
+
+**Remarque** : Une règle ne correspondra pas si vous incluez un espace après le premier mot dans la section optionnelle.
+
+{{< img src="logs/processing/parsing/parsing_example_5.png" alt="Exemple de parsing 5" style="width:80%;" >}}
+
+{{< img src="logs/processing/parsing/parsing_example_5_bis.png" alt="Exemple de parsing 5 bis" style="width:80%;" >}}
+
+### JSON imbriqué {#nested-json}
+
+Utilisez le filtre `json` pour analyser un objet JSON imbriqué après un préfixe de texte brut :
+
+**Événement** :
+
+```text
+Sep 06 09:13:38 vagrant program[123]: server.1 {"method":"GET", "status_code":200, "url":"https://app.datadoghq.com/logs/pipelines", "duration":123456}
+```
+
+**Règle** :
+
+```text
+parsing_rule %{date("MMM dd HH:mm:ss"):timestamp} %{word:vm} %{word:app}\[%{number:logger.thread_id}\]: %{notSpace:server} %{data::json}
+```
+
+{{< img src="logs/processing/parsing/nested_json.png" alt="Exemple de parsing de JSON imbriqué" style="width:80%;" >}}
+
+### Regex {#regex}
+
+**Événement** :
+
+```text
+john_1a2b3c4 connected on 11/08/2017
+```
+
+**Règle** :
+
+```text
+MyParsingRule %{regex("[a-z]*"):user.firstname}_%{regex("[a-zA-Z0-9]*"):user.id} .*
+```
+
+{{< img src="logs/processing/parsing/regex_parsing.png" alt="Exemple de parsing 6" style="width:80%;" >}}
+
+### Liste en tableau {#list-to-array}
+
+Utilisez le filtre `array([[openCloseStr, ] separator][, subRuleOrFilter)` pour extraire une liste dans un tableau dans un seul attribut. Le `subRuleOrFilter` est optionnel et accepte ces [filtres][4].
+
+**Événement** :
+
+```text
+Users [John, Oliver, Marc, Tom] have been added to the database
+```
+
+**Règle** :
+
+```text
+myParsingRule Users %{data:users:array("[]",",")} have been added to the database
+```
+
+{{< img src="logs/processing/parsing/array_parsing.png" alt="Exemple de parsing 6" style="width:80%;" >}}
+
+**Événement** :
+
+```text
+Users {John-Oliver-Marc-Tom} have been added to the database
+```
+
+**Règle** :
+
+```text
+myParsingRule Users %{data:users:array("{}","-")} have been added to the database
+```
+
+**Règle utilisant `subRuleOrFilter`** :
+
+```text
+myParsingRule Users %{data:users:array("{}","-", uppercase)} have been added to the database
+```
+
+### Format Glog {#glog-format}
+
+Les composants Kubernetes enregistrent parfois au format `glog` ; cet exemple provient de l'élément Kube Scheduler dans la bibliothèque Pipeline.
+
+Exemple d'événement :
+
+```text
+W0424 11:47:41.605188 1 authorization.go:47] Authorization is disabled
+```
+
+Règles de parsing :
+
+```text
+kube_scheduler %{regex("\\w"):level}%{date("MMdd HH:mm:ss.SSSSSS"):timestamp}\s+%{number:logger.thread_id} %{notSpace:logger.name}:%{number:logger.lineno}\] %{data:msg}
+```
+
+JSON extrait :
+
+```json
+{
+ "level": "W",
+ "timestamp": 1587728861605,
+ "logger": {
+ "thread_id": 1,
+ "name": "authorization.go"
+ },
+ "lineno": 47,
+ "msg": "Authorization is disabled"
+}
+```
+
+### Analyse XML {#parsing-xml}
+
+Le parser de XML permet de transformer des messages au format XML en JSON.
+
+**Événement :**
+
+```text
+
+ Harry Potter
+ J K. Rowling
+ 2005
+
+```
+
+**Règle :**
+
+```text
+rule %{data::xml}
+```
+
+**Résultat :**
+
+ ```json
+{
+ "book": {
+ "year": "2005",
+ "author": "J K. Rowling",
+ "category": "CHILDREN",
+ "title": {
+ "lang": "en",
+ "value": "Harry Potter"
+ }
+ }
+}
+ ```
+
+**Notes** :
+
+* Si le XML contient des balises ayant à la fois un attribut et une valeur de chaîne entre les deux balises, un attribut `value` est généré. Par exemple : `Harry Potter` est converti en `{"title": {"lang": "en", "value": "Harry Potter" } }`.
+* Les balises répétées sont automatiquement converties en tableaux. Par exemple : `Harry PotterEveryday Italian` est converti en `{ "bookstore": { "book": [ "Harry Potter", "Everyday Italian" ] } }`.
+
+### Parsing CSV {#parsing-csv}
+
+Utilisez le filtre **CSV** pour associer plus facilement les chaînes aux attributs lorsqu'elles sont séparées par un caractère donné (`,` par défaut).
+
+Le filtre CSV est défini comme `csv(headers[, separator[, quotingcharacter]])` où :
+
+* `headers` : Définit les noms de clés séparés par `,`. Les noms de clés doivent commencer par un caractère alphabétique et peuvent contenir tout caractère alphanumérique en plus de `_`.
+* `separator` : Définit les séparateurs utilisés pour séparer les différentes valeurs. Un seul caractère est accepté. Par défaut : `,`. **Remarque** : Utilisez `tab` pour le `separator` afin de représenter le caractère de tabulation pour les TSV.
+* `quotingcharacter` : Définit le caractère de citation. Un seul caractère est accepté. Par défaut : `"`
+
+**Remarque** :
+
+* Les valeurs contenant un caractère séparateur doivent être citées.
+* Les valeurs entre guillemets contenant un caractère de citation doivent être échappées avec un caractère de citation. Par exemple, `""` dans une valeur citée représente `"`.
+* Si l'événement ne contient pas le même nombre de valeurs que le nombre de clés dans l'en-tête, le parseur CSV associera les premières.
+* Les entiers et les doubles sont automatiquement convertis si possible.
+
+**Événement** :
+
+{{< code-block lang="text" >}}
+John,Doe,120,Jefferson St.,Riverside
+{{< /code-block >}}
+
+**Règle** :
+
+{{< code-block lang="text" >}}
+myParsingRule %{data:user:csv("first_name,name,st_nb,st_name,city")}
+{{< /code-block >}}
+
+**Résultat :**
+
+{{< code-block lang="json" >}}
+{
+ "user": {
+ "first_name": "John",
+ "name": "Doe",
+ "st_nb": 120,
+ "st_name": "Jefferson St.",
+ "city": "Riverside"
+ }
+}
+{{< /code-block >}}
+
+Autres exemples :
+
+| **Chaîne brute** | **Règle de parsing** | **Résultat** |
+|:-----------------------------|:-------------------------------------------------------------------------|:------------------------------------------------|
+| `John,Doe` | `%{data::csv("firstname,name")}` | {"firstname": "John", "name":"Doe"} |
+| `"John ""Da Man""",Doe` | `%{data::csv("firstname,name")}` | {"firstname": "John \"Da Man\"", "name":"Doe"} |
+| `'John ''Da Man''',Doe` | `%{data::csv("firstname,name",",","'")}` | {"firstname": "John 'Da Man'", "name":"Doe"} |
+| John|Doe | %{data::csv("firstname,name","|")} | {"firstname": "John", "name":"Doe"} |
+| `value1,value2,value3` | `%{data::csv("key1,key2")}` | {"key1": "value1", "key2":"value2"} |
+| `value1,value2` | `%{data::csv("key1,key2,key3")}` | {"key1": "value1", "key2":"value2"} |
+| `value1,,value3` | `%{data::csv("key1,key2,key3")}` | {"key1": "value1", "key3":"value3"} |
+| Value1 Value2 Value3 (TSV) | `%{data::csv("key1,key2,key3","tab")}` | {"key1": "value1", "key2": "value2", "key3":"value3"} |
+
+### Utilisez le data matcher pour éliminer le texte inutile {#use-data-matcher-to-discard-unneeded-text}
+
+Si vous avez un événement où, après avoir analysé ce qui est nécessaire et sachant que le texte après ce point peut être éliminé, vous pouvez utiliser le data matcher pour le faire. Pour l'exemple d'événement suivant, vous pouvez utiliser le `data` matcher pour éliminer le `%` à la fin.
+
+**Événement** :
+
+```
+Usage: 24.3%
+```
+
+**Règle** :
+
+```
+MyParsingRule Usage\:\s+%{number:usage}%{data:ignore}
+```
+
+**Résultat** :
+
+```
+{
+ "usage": 24.3,
+ "ignore": "%"
+}
+```
+
+### Caractères de contrôle ASCII {#ascii-control-characters}
+
+Si vos événements contiennent des caractères de contrôle ASCII, ils sont sérialisés lors de l'ingestion. Ceci peut être géré en échappant explicitement la valeur sérialisée dans votre parseur grok.
+
+
+[1]: https://github.com/google/re2/wiki/Syntax
+[2]: https://en.wikipedia.org/wiki/List_of_tz_database_time_zones
+[3]: /fr/events/pipelines_and_processors/date_remapper
+[4]: /fr/events/pipelines_and_processors/grok_parser/?tab=filters&tabs=filters#matcher-and-filter
\ No newline at end of file
diff --git a/content/fr/getting_started/tracing/_index.md b/content/fr/getting_started/tracing/_index.md
index 24433d9b48e..7a799101411 100644
--- a/content/fr/getting_started/tracing/_index.md
+++ b/content/fr/getting_started/tracing/_index.md
@@ -1,6 +1,9 @@
---
aliases:
- /fr/getting_started/tracing/distributed-tracing
+description: Configurez la surveillance des performances des applications (APM) pour
+ identifier les goulets d'étranglement, résoudre les problèmes et envoyer des traces
+ à Datadog.
further_reading:
- link: /tracing/
tag: Documentation
@@ -19,30 +22,29 @@ further_reading:
text: Participer à une session interactive pour maîtriser la solution APM
title: Débuter avec le tracing APM
---
-
-## Présentation
+## Aperçu {#overview}
La solution Application Performance Monitoring (APM) de Datadog vous permet dʼanalyser vos applications en détail, et ainsi d'identifier les goulets d'étranglement, de résoudre les problèmes et d'optimiser vos services.
Ce guide explique comment bien débuter avec lʼAPM et envoyer votre première trace à Datadog :
-1. Configurez la solution APM de Datadog pour envoyer des traces à Datadog.
+1. Configurez Datadog APM pour envoyer des traces à Datadog.
1. Exécutez votre application pour générer des données.
1. Explorez les données collectées dans Datadog.
-## Prérequis
+## Conditions préalables {#prerequisites}
Pour compléter ce guide, vous avez besoin des éléments suivants :
-1. [Créez un compte Datadog][1] si vous ne l'avez pas encore fait.
-1. Recherchez ou créez une [clé dʼAPI Datadog][2].
-1. Démarrez un host ou une VM Linux.
+1. [Créez un compte Datadog][1] si vous ne l'avez pas déjà fait.
+1. Trouvez ou créez une [clé API Datadog][2].
+1. Démarrez un hôte ou une VM Linux.
-## Créer une application
+## Créez une application {#create-an-application}
Pour créer une application à observer dans Datadog :
-1. Sur votre host ou VM Linux, créez une nouvelle application Python nommée `hello.py`. Par exemple, `nano hello.py`.
+1. Sur votre hôte ou VM Linux, créez une nouvelle application Python nommée `hello.py`. Par exemple, `nano hello.py`.
1. Ajoutez le code suivant à `hello.py` :
{{< code-block lang="python" filename="hello.py" collapsible="true" disable_copy="false" >}}
@@ -50,23 +52,23 @@ Pour créer une application à observer dans Datadog :
import random
app = Flask(__name__)
-
+
quotes = [
- « Ne vous efforcez pas de réussir, mais plutôt d'être utile. - Albert Einstein »,
- « Avoir confiance en nos capacités est la moitié du travail. - Theodore Roosevelt »,
- « L'avenir appartient à ceux qui croient en la beauté de leurs rêves. - Eleanor Roosevelt »
+ "Strive not to be a success, but rather to be of value. - Albert Einstein",
+ "Believe you can and you're halfway there. - Theodore Roosevelt",
+ "The future belongs to those who believe in the beauty of their dreams. - Eleanor Roosevelt"
]
-
+
@app.route('/')
def index():
quote = random.choice(quotes)+"\n"
return quote
-
+
if __name__ == '__main__':
app.run(host='0.0.0.0', port=5050)
{{< /code-block >}}
-## Configurer l'APM Datadog
+## Configurez Datadog APM {#set-up-datadog-apm}
Pour configurer la solution APM de Datadog sans avoir à modifier le code de votre application ni le processus de déploiement, utilisez lʼinstrumentation APM en une étape. Vous pouvez aussi configurer la solution APM à l'aide des bibliothèques de [traçage de Datadog][8].
@@ -74,13 +76,13 @@ Pour configurer la solution APM de Datadog sans avoir à modifier le code de vot
1. Exécutez la commande d'installation :
```shell
- DD_API_KEY= DD_SITE="" DD_APM_INSTRUMENTATION_ENABLED=host DD_APM_INSTRUMENTATION_LIBRARIES=python:3 DD_ENV= bash -c "$(curl -L https://install.datadoghq.com/scripts/install_script_agent7.sh)"
+ DD_API_KEY= DD_SITE="" DD_APM_INSTRUMENTATION_ENABLED=host DD_APM_INSTRUMENTATION_LIBRARIES=python:4 DD_ENV= bash -c "$(curl -L https://install.datadoghq.com/scripts/install_script_agent7.sh)"
```
+
+ Replace `` with your [Datadog API key][2], `` with your [Datadog site][7], and `` with the environment your Agent is installed on (for example, `development`).
- Remplacez `` par votre [clé dʼAPI Datadog][2], `` par votre [site Datadog][7] et `` par lʼenvironnement sur lequel votre Agent est installé (par exemple, `development`).
-
-1. Redémarrez les services sur votre host ou VM.
-1. Vérifiez que lʼAgent est exécuté :
+1. Redémarrez les services sur votre hôte ou VM.
+1. Vérifiez que l'Agent fonctionne :
```shell
sudo datadog-agent status
@@ -88,19 +90,19 @@ Pour configurer la solution APM de Datadog sans avoir à modifier le code de vot
Cette approche permet dʼinstaller automatiquement lʼAgent Datadog, dʼactiver lʼAPM Datadog et [dʼinstrumenter][5] votre application au moment de l'exécution.
-## Exécuter l'application
+## Exécutez l'application {#run-the-application}
Lorsque vous configurez lʼAPM Datadog avec lʼinstrumentation en une étape, Datadog instrumente automatiquement votre application au moment de l'exécution.
Pour exécuter `hello.py` :
-1. Créez un environnement Python virtuel dans le répertoire actuel :
+1. Créez un environnement virtuel Python dans le répertoire courant :
```shell
python3 -m venv ./venv
```
-1. Activez lʼenvironnement virtuel `venv` :
+1. Activez l'environnement virtuel `venv` :
```shell
source ./venv/bin/activate
@@ -113,14 +115,14 @@ Pour exécuter `hello.py` :
pip install flask
```
-1. Nommez le service et exécutez `hello.py` :
+1. Définissez le nom du service et exécutez `hello.py` :
```shell
export DD_SERVICE=hello
python3 hello.py
```
-## Tester l'application
+## Testez l'application {#test-the-application}
Testez l'application pour envoyer des traces à Datadog :
@@ -129,43 +131,43 @@ Testez l'application pour envoyer des traces à Datadog :
```shell
curl http://0.0.0.0:5050/
```
-1. Confirmer qu'une citation aléatoire est renvoyée.
+1. Confirmez qu'une citation aléatoire est renvoyée.
```text
Believe you can and you're halfway there. - Theodore Roosevelt
```
Chaque fois que vous exécutez la commande `curl`, une nouvelle trace est envoyée à Datadog.
-## Explorez les traces dans Datadog
+## Explorez les traces dans Datadog {#explore-traces-in-datadog}
-1. Dans Datadog, accédez à [**APM** > **Services**][3]. Vous devriez voir un service Python nommé `hello` :
+1. Dans Datadog, allez à [**APM** > **Services**][3]. Vous devriez voir un service Python nommé `hello` :
- {{< img src="/getting_started/apm/service-catalog.png" alt="Le Software Catalog affiche le nouveau service Python." style="width:100%;" >}}
+ {{< img src="/getting_started/apm/service-catalog.png" alt="Le catalogue de logiciels montre le nouveau service Python." style="width:100%;" >}}
-1. Sélectionnez le service pour afficher ses métriques de performances, telles que la latence, le débit et les taux d'erreur.
-1. Accédez à [**APM** > **Traces**][4]. Vous devriez voir une trace pour le service `hello` :
+1. Sélectionnez le service pour voir ses métriques de performance, telles que la latence, le débit et les taux d'erreur.
+1. Allez à [**APM** > **Traces**][4]. Vous devriez voir une trace pour le service `hello` :
- {{< img src="/getting_started/apm/trace-explorer.png" alt="Le Trace explorer affiche la trace correspondant au service hello." style="width:100%;" >}}
+ {{< img src="/getting_started/apm/trace-explorer.png" alt="L'explorateur de traces montre la trace pour le service hello." style="width:100%;" >}}
-1. Sélectionnez une trace pour en voir les détails, y compris le flame graph, qui permet d'identifier les goulets d'étranglement en matière de performances.
+1. Sélectionnez une trace pour voir ses détails, y compris le graphique de flamme, qui aide à identifier les goulets d'étranglement de performance.
-## Configuration avancée de l'APM
+## Configuration avancée de l'APM {#advanced-apm-setup}
-Jusqu'à ce stade, vous avez laissé Datadog instrumenter automatiquement l'application `hello.py` à l'aide de l'instrumentation en une seule étape. Cette approche est conseillée si vous souhaitez capturer les traces essentielles dans les bibliothèques et langages courants sans toucher au code ni installer des bibliothèques manuellement.
+Jusqu'à présent, vous avez laissé Datadog instrumenter automatiquement l'application `hello.py` en utilisant Single Step Instrumentation. Cette approche est recommandée si vous souhaitez capturer des traces essentielles à travers des bibliothèques et des langages courants sans toucher au code ou installer manuellement des bibliothèques.
Toutefois, si vous avez besoin de recueillir des traces à partir d'un code personnalisé ou si vous souhaitez un contrôle plus précis, vous pouvez ajouter [l'instrumentation personnalisée][6].
-Pour illustrer ceci, vous allez importer la bibliothèque de tracing Python de Datadog dans `hello.py` et créer une span et un tag de span personnalisés.
+Pour illustrer cela, vous allez importer le SDK Python de Datadog dans `hello.py` et créer un span personnalisé ainsi qu'une balise de span personnalisée.
Pour ajouter des instrumentations personnalisées :
-1. Installez la bibliothèque de tracing Datadog :
+1. Installez le SDK Datadog :
```shell
pip install ddtrace
```
-1. Ajoutez les lignes surlignées au code dans `hello.py` pour créer un tag de span personnalisé `get_quote` et un tag de span personnalisé `quote` :
+1. Ajoutez les lignes surlignées au code dans `hello.py` pour créer une balise de span personnalisée `get_quote` et une balise de span personnalisée `quote` :
{{< highlight python "hl_lines=3 15 17" >}}
from flask import Flask
@@ -175,9 +177,9 @@ Pour ajouter des instrumentations personnalisées :
app = Flask(__name__)
quotes = [
- « Ne vous efforcez pas de réussir, mais plutôt d'être utile. - Albert Einstein »,
- « Avoir confiance en nos capacités est la moitié du travail. - Theodore Roosevelt »,
- « L'avenir appartient à ceux qui croient en la beauté de leurs rêves. - Eleanor Roosevelt »
+ "Strive not to be a success, but rather to be of value. - Albert Einstein",
+ "Believe you can and you're halfway there. - Theodore Roosevelt",
+ "The future belongs to those who believe in the beauty of their dreams. - Eleanor Roosevelt"
]
@app.route('/')
@@ -191,24 +193,35 @@ Pour ajouter des instrumentations personnalisées :
app.run(host='0.0.0.0', port=5050)
{{< /highlight >}}
-1. Exécutez `hello.py` dans lʼenvironnement virtuel mentionné plus haut :
+1. Exécutez `hello.py` dans l'environnement virtuel mentionné précédemment :
```shell
ddtrace-run python hello.py
```
-1. Exécutez quelques commandes `curl` dans une invite de commande distincte :
+1. Exécutez quelques commandes `curl` dans une invite de commande séparée :
```shell
curl http://0.0.0.0:5050/
```
-1. Dans Datadog, accédez à [**APM** > **Traces**][4].
+1. Dans Datadog, allez à [**APM** > **Traces**][4].
1. Sélectionnez la trace **hello**.
-1. Recherchez la nouvelle span personnalisée `get_quote` dans le flame graph et survolez-la :
+1. Trouvez le nouveau span personnalisé `get_quote` dans le graphique de flamme et survolez-le :
+
+ {{< img src="/getting_started/apm/custom-instrumentation.png" alt="Le span personnalisé get_quote s'affiche dans le graphique de flamme. Au survol, la balise de span quote est affichée. " style="width:100%;" >}}
+
+1. Remarquez que la balise de span personnalisée `quote` s'affiche dans l'onglet **Info**.
+
+## Quelle est la prochaine étape ? {#whats-next}
+
+Après avoir configuré le traçage et que votre application envoie des données à Datadog, explorez des fonctionnalités APM supplémentaires :
+
+### Catalogue de logiciels {#software-catalog}
- {{< img src="/getting_started/apm/custom-instrumentation.png" alt="La span personnalisée get_quote sʼaffiche dans le flame graph. Lorsquʼon la survole, le tag de span de la citation sʼaffiche. " style="width:100%;" >}}
+[Catalogue de logiciels][9] fournit une vue consolidée de vos services, combinant des métadonnées de propriété, des informations de performance, une analyse de sécurité et une allocation des coûts en un seul endroit. Configurez [les métadonnées de service][10] à l'aide de balises, d'annotations ou d'un fichier `service.datadog.yaml` pour enrichir vos services avec des informations de propriété, des runbooks et des liens de documentation.
-1. Remarquez que le tag de span personnalisé `quote` s'affiche dans lʼonglet **Info**.
+### Ingestion et conservation des traces {#trace-ingestion-and-retention}
+Contrôlez les coûts et gérez le volume de données en configurant [les contrôles d'ingestion][11] et [les filtres de conservation][12]. Les contrôles d'ingestion vous permettent de personnaliser les taux d'échantillonnage au niveau de l'Agent Datadog ou du SDK, tandis que les filtres de conservation déterminent quels spans sont indexés pour la recherche et l'analyse.
-## Pour aller plus loin
+## Lectures complémentaires {#further-reading}
{{< partial name="whats-next/whats-next.html" >}}
@@ -219,4 +232,8 @@ Pour ajouter des instrumentations personnalisées :
[5]: /fr/tracing/glossary/#instrumentation
[6]: /fr/tracing/trace_collection/custom_instrumentation/
[7]: /fr/getting_started/site/
-[8]: /fr/tracing/trace_collection/automatic_instrumentation/dd_libraries/
\ No newline at end of file
+[8]: /fr/tracing/trace_collection/automatic_instrumentation/dd_libraries/
+[9]: /fr/internal_developer_portal/software_catalog/
+[10]: /fr/internal_developer_portal/software_catalog/entity_model/
+[11]: /fr/tracing/trace_pipeline/ingestion_controls/
+[12]: /fr/tracing/trace_pipeline/trace_retention/
\ No newline at end of file
diff --git a/content/fr/incident_response/status_pages/_index.md b/content/fr/incident_response/status_pages/_index.md
new file mode 100644
index 00000000000..94f3caf1557
--- /dev/null
+++ b/content/fr/incident_response/status_pages/_index.md
@@ -0,0 +1,226 @@
+---
+aliases:
+- /fr/service_management/status_pages/
+further_reading:
+- link: https://www.datadoghq.com/blog/status-pages
+ tag: Blog
+ text: Tenez les parties prenantes informées avec les pages de statut Datadog
+- link: /incident_response/incident_management/
+ tag: Documentation
+ text: En savoir plus sur la gestion des incidents
+- link: /incident_response/on-call/
+ tag: Documentation
+ text: En savoir plus sur la planification des astreintes
+- link: /incident_response/incident_management/integrations/status_pages
+ tag: Documentation
+ text: Intégrez les pages de statut Datadog avec la gestion des incidents
+title: Pages de statut
+---
+## Aperçu {#overview}
+
+{{< img src="service_management/status_pages/shopist_status_page2.png" alt="Exemple de page de statut montrant les composants de service avec leur statut actuel et les mises à jour récentes des incidents" style="width:100%;" >}}
+
+Les pages de statut font partie de la suite de réponse aux incidents de Datadog, aux côtés de l'astreinte et de la gestion des incidents. Cela permet à votre équipe de communiquer de manière proactive **la disponibilité des services**, **les incidents** et **la maintenance planifiée** avec les clients ou les parties prenantes internes via une page web partageable.
+
+Utilisez les pages de statut pour :
+
+* Partager la disponibilité des systèmes et des fonctionnalités critiques
+* Communiquer clairement les interruptions de service pendant les incidents
+* Annoncer la maintenance programmée et les temps d'arrêt prévus à l'avance
+* Réduire le volume de support entrant avec des notifications par e-mail proactives
+
+## Configurer les autorisations {#configure-permissions}
+
+Il existe trois autorisations RBAC qui sont pertinentes pour les pages de statut. Les utilisateurs ayant le rôle d'administrateur Datadog disposent de toutes les autorisations nécessaires.
+
+Pour créer, mettre à jour ou publier des pages de statut, vous devez avoir les autorisations RBAC `status_pages_settings_read`, `status_pages_settings_write` et `status_pages_incident_write`. Pour plus d'informations, voir [Contrôle d'accès][1].
+
+
+
+
+ | Nom |
+ Description |
+ Rôle par défaut |
+
+
+
+
+ Paramètres des pages de statut en lecture
status_pages_settings_read |
+ Consultez la liste des pages de statut, les paramètres de chaque page de statut, leurs avis et les pages de statut internes lancées. |
+ Rôle en lecture seule Datadog |
+
+
+ Paramètres des pages de statut en écriture
status_pages_settings_write |
+ Créez et lancez de nouvelles pages de statut, et configurez les paramètres des pages de statut. |
+ Rôle administrateur Datadog |
+
+
+ Avis sur les pages de statut en écriture
status_pages_incident_write |
+ Publiez et mettez à jour les incidents. |
+ Rôle administrateur Datadog |
+
+
+
+
+## Créez une page de statut {#create-a-status-page}
+
+1. Dans Datadog, accédez à [**Status Pages**][2].
+1. Cliquez sur **Create Status Page** et suivez le processus d'intégration :
+
+ | Champ | Description |
+ | ----------------- | ----------- |
+ | **Type de page de statut** | Choisissez qui peut accéder à la page :
- **Public** - Quiconque ayant le lien peut voir
- **Interne** - Seuls les utilisateurs authentifiés au sein de votre organisation Datadog peuvent voir |
+ | **Nom de la page** | Affiché comme l'en-tête de la page (si aucun logo n'est téléchargé).
*Exemple : Plateforme Cloud Acme* |
+ | **Préfixe de domaine** | Utilisé comme préfixe de sous-domaine de votre page de statut. Pour plus d'informations sur les domaines personnalisés, consultez la section [Définir un domaine personnalisé](#set-a-custom-domain).
*Exemple : shopist → shopist.statuspage.datadoghq.com*
- Doit être **globalement unique**
- En minuscules, alphanumériques et avec des traits d’union
- Peut affecter les liens s'il est modifié ultérieurement |
+ | **Abonnements** *(facultatif)* | Permettre aux utilisateurs de recevoir des notifications par e-mail concernant les mises à jour de la page de statut. Lorsque les abonnements sont activés, les utilisateurs peuvent s'inscrire pour être informés des nouveaux avis et mises à jour. Vous pouvez activer ou désactiver les abonnements pour chaque page de statut. **Remarque** : [Les abonnements par e-mail](#email-subscriptions) sont à double opt-in, l'e-mail doit être confirmé. |
+ | **Logo de l'entreprise, Favicon ou image d'en-tête d'e-mail** *(facultatif)* | Téléchargez un logo, un favicon ou une image pour personnaliser l'apparence de votre page de statut et des notifications par e-mail. |
+1. (Facultatif) [Ajoutez des composants](#add-components) pour montrer l'état des services individuels.
+1. Cliquez sur **Save Settings**.
+ Une page de statut
n'est pas Live après avoir enregistré vos paramètres. Pour rendre la page disponible,
publish your status page.
*Example: Increased error rates in US region* |
+| **Status** | Current state of the issue:
- Investigating
- Identified
- Monitoring
- Resolved |
+| **Message** | Additional details for your users
*Example: We are aware of the issue and are actively working on a fix.* |
+| **Components impacted** | One or more components affected by the degradation |
+| **Impact** | Impact level per component:
- Operational
- Degraded Performance
- Partial Outage
- Major Outage |
+| **Notify subscribers** | Toggle to send updates to subscribed users |
+
+{{< img src="service_management/status_pages/publish_status_page_degradation.png" alt="Exemple de modal de publication d'avis pour les dégradations" style="width:60%;" >}}
+
+Après qu'un avis de dégradation a été examiné et publié, il :
+- Appears on the **Status Pages List** under Active Notices.
+- Updates the uptime bars for impacted components.
+- Is visible in the notice history timeline.
+
+Vous pouvez publier des mises à jour au fil du temps et marquer l'avis comme **Resolved** lorsque le problème est entièrement atténué.
+
+### Backfill a degradation {#backfill-a-degradation}
+
+Les dégradations renseignées rétroactivement permettent de documenter rétroactivement les interruptions de service qui n'ont pas été annoncées auparavant. Chaque mise à jour peut se voir attribuer son horodatage d'origine, de sorte que la chronologie des incidents apparaisse avec précision dans votre historique de disponibilité.
+
+Depuis une page de statut, sélectionnez le menu déroulant à côté de **Publish Notice**, sélectionnez **Publish Backfilled Notice** > **Degradation**, puis fournissez :
+
+| Field| Description|
+| ---- | ---- |
+| **Notice title** | Short, clear description of the incident
*Example: Increased error rates in US region* |
+| **Mises à jour** | Exactement deux mises à jour horodatées représentant le début et la fin de la dégradation. Chaque mise à jour nécessite un horodatage de début, un statut (En cours d'investigation ou Résolu), une description et les composants affectés. |
+
+{{< img src="service_management/status_pages/publish_status_page_backfill_degradation.png" alt="Exemple de modal de publication d'avis rétroactif pour les dégradations" style="width:60%;" >}}
+
+### Planifier une fenêtre de maintenance {#schedule-a-maintenance-window}
+
+{{< img src="service_management/status_pages/shopist_maintenance_example.png" alt="Exemple de page d'état montrant les composants de service en cours de maintenance" style="width:100%;" >}}
+
+Les fenêtres de maintenance vous permettent de communiquer de manière proactive sur les temps d'arrêt ou l'impact sur le service prévus avant qu'ils ne se produisent. Contrairement aux dégradations qui sont utilisées pour des incidents imprévus, les fenêtres de maintenance sont planifiées à l'avance pour des mises à niveau d'infrastructure, de la maintenance système, des migrations de bases de données et d'autres travaux prévus. Cela vous permet de tenir les clients informés et de réduire le volume de support.
+
+Depuis la page d'état, cliquez sur **Planifier la maintenance**, ou cliquez sur **Publier un avis** et sélectionnez **Maintenance planifiée**. Ensuite, fournissez les détails suivants :
+
+| Champ | Description |
+| ---- | ---- |
+| **Titre de l'avis** | Description claire de l'activité de maintenance
*Exemple : Mise à niveau de l'infrastructure de la base de données* |
+| **Fenêtre de maintenance** | Heure de début et de fin prévue pour la maintenance |
+| **Messages** | Messages qui sont publiés automatiquement au fur et à mesure de l'avancement de la maintenance |
+| **Composants impactés** | Composants affectés pendant la fenêtre de maintenance |
+| **Notifier les abonnés** | Basculer pour envoyer une notification préalable aux abonnés |
+
+{{< img src="service_management/status_pages/publish_status_page_maintenance.png" alt="Exemple de modal de publication d'avis pour les fenêtres de maintenance" style="width:60%;" >}}
+
+Après révision et planification, la fenêtre de maintenance :
+- Apparaît sous **Maintenance à venir** sur la page d'état
+- Met automatiquement à jour le statut des composants à **Maintenance** lorsque la fenêtre commence
+- Renvoie les composants à **Opérationnel** lorsque la fenêtre se termine (sauf si contourné manuellement)
+
+Vous pouvez publier des mises à jour si les plans changent ou reprogrammer la fenêtre de maintenance si nécessaire.
+
+### Remplir une fenêtre de maintenance {#backfill-a-maintenance-window}
+
+Les fenêtres de maintenance rétroactives vous permettent de documenter rétroactivement les temps d'arrêt prévus qui n'avaient pas été annoncés auparavant. Chaque mise à jour peut se voir attribuer son horodatage d'origine, de sorte que la chronologie de maintenance apparaisse avec précision dans votre historique de disponibilité.
+
+Depuis une page d'état, sélectionnez le menu déroulant à côté de **Publier un avis**, sélectionnez **Publier un avis rétroactif** > **Maintenance planifiée**, puis fournissez :
+
+| Champ | Description |
+| ---- | ---- |
+| **Titre de l'avis** | Description claire de l'activité de maintenance
*Exemple : Mise à niveau de l'infrastructure de base de données* |
+| **Mises à jour** | Exactement deux mises à jour horodatées représentant le début et la fin de la fenêtre de maintenance. Chaque mise à jour nécessite un horodatage de début, un statut (En cours ou Terminé), une description et les composants affectés. |
+
+{{< img src="service_management/status_pages/publish_status_page_backfill_maintenance.png" alt="Exemple de modal de publication d'avis rétroactif pour les fenêtres de maintenance" style="width:60%;" >}}
+
+## Abonnements par e-mail {#email-subscriptions}
+
+Les abonnements par e-mail sur les pages d'état sont **double opt-in**. Après avoir saisi un e-mail pour s'abonner, les utilisateurs reçoivent un e-mail de confirmation et doivent cliquer sur le lien de confirmation pour activer leur abonnement. Au cours de ce processus, les utilisateurs peuvent choisir de recevoir des notifications pour l'ensemble de la page d'état ou sélectionner des composants spécifiques qu'ils souhaitent surveiller. Un fuseau horaire préféré peut être configuré pour le formatage des horodatages dans les notifications. Les utilisateurs peuvent gérer leurs préférences et mettre à jour leurs abonnements à tout moment via le lien de gestion des abonnements inclus dans les e-mails de notification.
+
+Pour les pages d'état **internes**, le processus d'abonnement est le même, mais les utilisateurs doivent se connecter à la même organisation Datadog pour confirmer leur abonnement et recevoir des notifications.
+
+{{< img src="/service_management/status_pages/status_pages_subscription_1.png" alt="Capture d'écran du modal d'abonnement à la page d'état avec les champs remplis" style="width:70%;" >}}
+
+## Définir un domaine personnalisé {#set-a-custom-domain}
+
+Pour correspondre à votre image de marque, vous avez la possibilité de mapper votre page d'état à un domaine personnalisé comme `status.acme.com`.
+
+1. Depuis votre page de statut, cliquez sur **Paramètres**.
+1. Sélectionnez **Domaine personnalisé**.
+1. Suivez les instructions pour entrer votre domaine et ajouter des enregistrements DNS.
+1. Datadog détecte automatiquement la configuration DNS et provisionne un certificat SSL.
+
+Les domaines personnalisés nécessitent un accès à votre fournisseur DNS pour ajouter un enregistrement CNAME ou A.
+
+**Remarque** :
+
+- La propagation DNS peut prendre plusieurs minutes.
+- Vous pouvez revenir au domaine par défaut de Datadog à tout moment.
+- Assurez-vous que les modifications DNS sont effectuées par quelqu'un ayant accès à votre registraire de domaine.
+
+## Lectures complémentaires {#further-reading}
+
+{{< partial name="whats-next/whats-next.html" >}}
+
+[1]: /fr/account_management/rbac/
+[2]: https://app.datadoghq.com/status-pages
\ No newline at end of file
diff --git a/content/fr/llm_observability/instrumentation/otel_instrumentation.md b/content/fr/llm_observability/instrumentation/otel_instrumentation.md
new file mode 100644
index 00000000000..f3710aabb6a
--- /dev/null
+++ b/content/fr/llm_observability/instrumentation/otel_instrumentation.md
@@ -0,0 +1,571 @@
+---
+description: Instrumentez les applications LLM avec OpenTelemetry en utilisant les
+ conventions sémantiques GenAI et envoyez les traces à Datadog LLM Observability
+ sans le SDK Datadog.
+title: 'Instrumentation OpenTelemetry :'
+---
+## Aperçu {#overview}
+En utilisant les conventions sémantiques standardisées d'OpenTelemetry pour les opérations d'IA générative, vous pouvez instrumenter vos applications LLM avec n'importe quelle bibliothèque ou framework compatible OpenTelemetry et visualiser les traces dans LLM Observability.
+
+LLM Observability prend en charge l'ingestion des traces OpenTelemetry qui suivent les [conventions sémantiques OpenTelemetry 1.37+ pour l'IA générative][1]. Cela vous permet d'envoyer des traces LLM directement depuis des applications instrumentées avec OpenTelemetry à Datadog sans nécessiter le SDK Datadog LLM Observability ou un Datadog Agent.
+
+## Prérequis {#prerequisites}
+
+- Une [clé API Datadog][2]
+- Une application instrumentée avec OpenTelemetry qui émet des traces suivant les [conventions sémantiques OpenTelemetry 1.37+ pour l'IA générative][1]
+
+Pour envoyer des évaluations externes directement à l'API pour les spans OpenTelemetry, vous devez inclure le source:otel tag dans l'évaluation. Lors de la référence aux spans, fournissez span_id et trace_id sous forme de chaînes décimales. OpenTelemetry utilise des identifiants hexadécimaux nativement, donc convertissez-les en décimal avant de soumettre les évaluations. Par exemple, utilisez la fonction de Python int(hex_span_id, 16) pour convertir un identifiant de span hexadécimal en son équivalent décimal.
+
+Pour des informations sur l'utilisation du suivi des invites avec les spans OpenTelemetry, consultez Suivi des invites - Instrumentation OpenTelemetry.
+
+Vous pouvez également utiliser des spans OpenTelemetry à l'intérieur de Expériences LLM Observability. En définissant DD_TRACE_OTEL_ENABLED=1, les spans OTel créés à l'intérieur d'une tâche d'expérience apparaissent automatiquement comme des enfants du span d'expérience.
+
+## Configuration {#setup}
+
+Pour envoyer des traces OpenTelemetry à LLM Observability, configurez votre exportateur OpenTelemetry avec les paramètres suivants :
+
+### Configuration {#configuration}
+
+Définissez les variables d'environnement suivantes dans votre application :
+
+```
+OTEL_EXPORTER_OTLP_TRACES_PROTOCOL=http/protobuf
+OTEL_EXPORTER_OTLP_TRACES_ENDPOINT={{< region-param key="otlp_trace_endpoint" code="true" >}}
+OTEL_EXPORTER_OTLP_TRACES_HEADERS=dd-api-key=,dd-otlp-source=llmobs
+```
+
+Remplacez `` par votre [clé API Datadog][2].
+
+Si votre framework prenait auparavant en charge une version de spécification OpenTelemetry antérieure à 1.37, vous devez également définir :
+
+```
+OTEL_SEMCONV_STABILITY_OPT_IN=gen_ai_latest_experimental
+```
+
+Cette variable d'environnement active les traces OpenTelemetry conformes à la version 1.37+ pour les frameworks qui prennent désormais en charge les conventions sémantiques de la version 1.37+, mais qui prenaient auparavant en charge des versions plus anciennes (comme [strands-agents][5]).
+
+**Remarque** :
+* Si vous utilisez une bibliothèque OpenTelemetry autre que le SDK OpenTelemetry par défaut, vous devrez peut-être configurer l'endpoint, le protocole et les en-têtes différemment selon l'API de la bibliothèque. Consultez la documentation de votre bibliothèque pour la méthode de configuration appropriée.
+* Lors de l'utilisation de l'instrumentation OpenTelemetry, certaines données envoyées à LLM Observability peuvent également être écrites dans les traces APM correspondantes. Si vous protégez des données sensibles, envisagez également de configurer un ensemble de données restreint sur APM pour correspondre à vos contrôles d'accès LLM Observability. Consultez [Contrôle d'accès aux données][8] pour plus d'informations.
+
+#### Utilisation de strands-agents {#using-strands-agents}
+
+Si vous utilisez la [`strands-agents` bibliothèque][5], vous devez définir une variable d'environnement supplémentaire pour activer les traces conformes à OpenTelemetry v1.37+ :
+
+```
+OTEL_SEMCONV_STABILITY_OPT_IN=gen_ai_latest_experimental
+```
+
+Cette variable d'environnement garantit que `strands-agents` émet des traces suivant les conventions sémantiques OpenTelemetry v1.37+ pour l'IA générative, qui sont requises par LLM Observability.
+
+### Instrumentation {#instrumentation}
+
+Pour générer des traces compatibles avec LLM Observability, choisissez l'une des méthodes suivantes :
+
+- Utilisez une bibliothèque OpenTelemetry ou un package d'instrumentation qui émet des spans suivant les [conventions sémantiques OpenTelemetry 1.37+ pour l'IA générative][1].
+- Créez une instrumentation OpenTelemetry personnalisée qui produit des spans avec les attributs `gen_ai.*` requis, tels que définis dans les conventions sémantiques.
+
+Après le démarrage de votre application, les traces apparaissent automatiquement dans la page [**Traces d'observabilité LLM**][3]. Pour rechercher vos traces dans l'interface utilisateur, utilisez l'attribut `ml_app`, qui est automatiquement défini sur la valeur de l'attribut `service` de votre span racine OpenTelemetry.
+
+
+
+ OpenLLMetry version 0.47+ est pris en charge. Consultez l'exemple OpenLLMetry.
+ OpenInference n'est pas pris en charge.
+ Il peut y avoir un délai de 3 à 5 minutes entre l'envoi des traces et leur apparition sur la page des Traces d'observabilité LLM. Si vous avez APM activé, les traces apparaissent immédiatement sur la page des Traces APM.
+
+
Tout gen_ai.* Les attributs qui ne sont pas explicitement mappés aux champs de portée d'observabilité LLM sont placés dans les étiquettes de la portée LLM, avec une limite de 256 caractères par valeur. Les valeurs dépassant cette limite sont tronquées. Tous les autres non-gen_ai attributs sont supprimés.
+
+### Mappages d'attributs OpenLLMetry {#openllmetry-attribute-mappings}
+
+Cette section documente les mappages d'attributs spécifiques à OpenLLMetry qui diffèrent ou étendent les conventions sémantiques standard d'OpenTelemetry GenAI.
+
+#### Résolution du type de portée {#span-kind-resolution-1}
+
+`llm.request.type` est utilisé comme solution de repli lorsque `gen_ai.operation.name` est absent.
+
+| `llm.request.type` | Observabilité LLM `span.kind` |
+|--------------------|-------------------|
+| `chat` | `llm` |
+| `completion` | `llm` |
+| `embedding` | `embedding` |
+| `rerank` | `workflow` |
+| `unknown`, *(par défaut)* | `workflow` |
+
+#### Informations sur le modèle {#model-information-1}
+
+| OpenLLMetry Attribute | LLM Observability Field | Notes |
+|-----------------------|--------------|-------|
+| `gen_ai.system` | `meta.model_provider` | Solution de repli lorsque `gen_ai.provider.name` est absent |
+
+#### Métriques d'utilisation des jetons {#token-usage-metrics-1}
+
+| OpenLLMetry Attribute | LLM Observability Field | Notes |
+|-----------------------|--------------|-------|
+| `llm.usage.total_tokens` | `metrics.total_tokens` | Solution de repli lorsque `gen_ai.usage.total_tokens` est absent |
+
+#### Messages d'entrée et de sortie {#input-and-output-messages-1}
+
+OpenLLMetry utilise des attributs indexés au lieu de tableaux JSON. Ce sont les sources de la plus basse priorité et ne sont utilisées que lorsque aucune source standard OTel n'existe.
+
+##### Attributs de prompt (entrée) {#prompt-attributes-input}
+
+| Attribut OpenLLMetry | Description |
+|-----------------------|-------------|
+| `gen_ai.prompt..role` | Rôle du message (utilisateur, système, assistant, outil) |
+| `gen_ai.prompt..content` | Contenu du message |
+| `gen_ai.prompt..tool_call_id` | ID d'appel d'outil pour les messages de réponse d'outil |
+
+##### Attributs de complétion (sortie) {#completion-attributes-output}
+
+| Attribut OpenLLMetry | Description |
+|-----------------------|-------------|
+| `gen_ai.completion..role` | Rôle du message |
+| `gen_ai.completion..content` | Contenu du message |
+| `gen_ai.completion..finish_reason` | Raison de la fin de la complétion |
+
+##### Mapping {#mapping}
+
+Les messages sont convertis au format compatible OTel et traités normalement :
+
+| OpenLLMetry Source | LLMObs Field |
+|--------------------|--------------|
+| `gen_ai.prompt.*` | `meta.input.messages` (llm) / `meta.input.value` (autres) |
+| `gen_ai.completion.*` | `meta.output.messages` (llm) / `meta.output.value` (autres) |
+
+#### Appels d'outils {#tool-calls}
+
+Les appels d'outils sont imbriqués dans les attributs de complétion.
+
+| Attribut OpenLLMetry | Correspond à |
+|-----------------------|---------|
+| `gen_ai.completion..tool_calls..name` | `tool_calls[].name` |
+| `gen_ai.completion.