diff --git a/content/es/account_management/billing/usage_attribution.md b/content/es/account_management/billing/usage_attribution.md
index 54c0e9ed743bc..d8c5445ff555e 100644
--- a/content/es/account_management/billing/usage_attribution.md
+++ b/content/es/account_management/billing/usage_attribution.md
@@ -15,19 +15,19 @@ title: Atribución de uso
## Información general
-
-La atribución de uso es una función avanzada del plan Enterprise. Si quieres usarla en otros planes, ponte en contacto con la persona encargada de tu cuenta o escribe a
success@datadoghq.com para solicitarla.
+
L
+Atribución de uso es una prestación incluida en el plan empresarial. Si quieres usarla en otros planes, ponte en contacto con la persona encargada de tu cuenta o escribe a
success@datadoghq.com para solicitarla.
Los administradores o usuarios con permiso de Lectura de uso pueden acceder a la Atribución de uso pestaña desde la sección Plan y uso en Datadog. La página de Atribución de uso proporciona la siguiente información y funcionalidad:
-- Acceder a listas del reparto de uso en función de las diferentes claves de etiquetas, y añadir o modificar claves nuevas (hasta un máximo de tres).
+- Consultar una lista del reparto de uso en función de las diferentes claves de etiquetas y añadir o modificar claves nuevas (hasta un máximo de tres).
- Resume el uso al final de cada mes y visualiza el uso a lo largo del tiempo desglosado por etiquetas (tags).
- Genera archivos CSV del mes hasta la fecha y por horas.
Esta función no es compatible con el uso de productos que no se pueden etiquetar durante la instrumentación. Por ejemplo, Usuarios de gestión de incidencias, Usuarios de pruebas y CI Pipeline, Espacio de pruebas paralelas y Audit Trail.
-## Primeros pasos
+## Empezando
Para empezar a recibir datos diarios, el administrador debe elegir etiquetas para el informe.
@@ -104,7 +104,7 @@ Para los clientes de facturación directa, los informes de atribución de costes
{{< img src="account_management/billing/usage_attribution/Cost-Attribution-Monthly.png" alt="Informe de Atribución de costes" style="width:100%;" >}}
-## Leer más
+## Referencias adicionales
{{< partial name="whats-next/whats-next.html" >}}
diff --git a/content/es/account_management/saml/mobile-idp-login.md b/content/es/account_management/saml/mobile-idp-login.md
index eb05016987afd..55c42dc30ac89 100644
--- a/content/es/account_management/saml/mobile-idp-login.md
+++ b/content/es/account_management/saml/mobile-idp-login.md
@@ -33,7 +33,7 @@ Para utilizar la aplicación móvil Datadog con SAML iniciado por el proveedor d
Cuando configures tu aplicación OneLogin, establece el valor del estado de retransmisión en la página **Application Details** (Detalles de la aplicación) en `dd_m_idp`.
{{< img src="account_management/saml/one-login-mobile-idp-relay-state.png" alt="Página de detalles de la aplicación de One Login" >}}
-### Okta
+### Audit Trail (trazas de auditoría)
Cuando configures tu aplicación Okta, establece el valor por defecto de RelayState en la página **Configure SAML** (Configurar SAML) en `dd_m_idp`.
{{< img src="account_management/saml/okta-mobile-idp-relay-state.png" alt="Página de configuración de SAML de Okta" >}}
diff --git a/content/es/account_management/saml/okta.md b/content/es/account_management/saml/okta.md
index bcd7252753e49..80e267b059167 100644
--- a/content/es/account_management/saml/okta.md
+++ b/content/es/account_management/saml/okta.md
@@ -30,7 +30,7 @@ Sigue las instrucciones de Okta [Create custom SAML app integrations (crear inte
| Campo de entrada del proveedor de identificación Okta | Valor esperado |
|-----------------------------|--------------------------------------------------------------------------------------------------------------------------------|
| URL de inicio de sesión único | URL del servicio de consumidor de afirmaciones (Encuentra esta URL en la [Configure SAML page (configurar página SAML)][3], en el campo *Assertion Consumer Service URL* [URL del servicio de consumidor de afirmaciones]). |
-| URL del receptor | URL del servicio de consumidor de afirmaciones (o haz clic en *Use this for Recipient URL and Destination URL* [Utilizar esta URL del receptor y URL de destino]) |
+| URL del receptor | URL del servicio de consumidor de afirmaciones (o haz clic en la casilla *Use this for Recipient URL and Destination URL* [Utilizar esta URL del receptor y URL de destino]) |
| URL de destino | URL del servicio de consumidor de afirmaciones (o haz clic en la casilla *Use this for Recipient URL and Destination URL* [Utilizar esta URL del receptor y URL de destino]) |
| URI de audiencia (ID de entidad del proveedor de servicios) | ID de entidad proveedora de servicios (Encuentra este ID en la [Configure SAML page (página Configurar SAML)][3], en el campo *Service Provider Entity ID* [ID de entidad proveedora de servicios]). |
| Formato de ID de nombre | EmailAddress |
@@ -64,7 +64,7 @@ Encontrarás información adicional sobre la configuración de SAML para tu cuen
En el caso de que necesitas para cargar un archivo `IDP.XML` a Datadog antes de ser capaz de completamente configurar la aplicación en Okta, ve [acquiring the idp.xml metadata file for a SAML template App article (el artículo sobre la adquisición del archivo de metadatos idp.xml para una app de plantilla SAML][6] para las instrucciones de marcador de posición de campo.
-## Leer más
+## Referencias adicionales
{{< partial name="whats-next/whats-next.html" >}}
diff --git a/content/es/agent/guide/heroku-ruby.md b/content/es/agent/guide/heroku-ruby.md
index b4f274b496ae3..2f603b184c702 100644
--- a/content/es/agent/guide/heroku-ruby.md
+++ b/content/es/agent/guide/heroku-ruby.md
@@ -615,10 +615,10 @@ Dirígete a la [sección de trazas de APM][19] para ver tus trazas:
{{< img src="agent/guide/heroku_ruby/traces.png" alt="Trazas de aplicaciones de Ruby en Datadog" >}}
-Navega al [catálogo de servicios][20] para ver todos tus servicios de aplicación y una vista de tu servicio de aplicación:
+Accede al [Catálogo de servicios][20] para ver todos tus servicios de aplicaciones y una vista de tus servicios de aplicaciones:
-{{< img src="agent/guide/heroku_ruby/ruby_service.png" alt="Service Catalog in Datadog" >}}
-{{< img src="agent/guide/heroku_ruby/service_page.png" alt="Ruby application service details page in Datadog" >}}
+{{< img src="agent/guide/heroku_ruby/ruby_service.png" alt="Catálogo de servicios en Datadog" >}}
+{{< img src="agent/guide/heroku_ruby/service_page.png" alt="Página de detalles de servicios de la aplicación Ruby en Datadog" >}}
## Logs
@@ -832,7 +832,7 @@ Agent (v7.27.0)
[...]
```
-## Leer más
+## Referencias adicionales
{{< partial name="whats-next/whats-next.html" >}}
diff --git a/content/es/api/latest/incident-services/_index.md b/content/es/api/latest/incident-services/_index.md
new file mode 100644
index 0000000000000..1475af30b1e56
--- /dev/null
+++ b/content/es/api/latest/incident-services/_index.md
@@ -0,0 +1,3 @@
+---
+title: Servicios de incidencias
+---
diff --git a/content/es/api/latest/okta-integration/_index.md b/content/es/api/latest/okta-integration/_index.md
new file mode 100644
index 0000000000000..df52d3cb77912
--- /dev/null
+++ b/content/es/api/latest/okta-integration/_index.md
@@ -0,0 +1,3 @@
+---
+title: Integración de Okta
+---
diff --git a/content/es/api/latest/opsgenie-integration/_index.md b/content/es/api/latest/opsgenie-integration/_index.md
new file mode 100644
index 0000000000000..098056c2d55a7
--- /dev/null
+++ b/content/es/api/latest/opsgenie-integration/_index.md
@@ -0,0 +1,3 @@
+---
+title: Integración de Opsgenie
+---
diff --git a/content/es/api/latest/service-definition/_index.md b/content/es/api/latest/service-definition/_index.md
new file mode 100644
index 0000000000000..49cb002145312
--- /dev/null
+++ b/content/es/api/latest/service-definition/_index.md
@@ -0,0 +1,3 @@
+---
+title: Definición de servicio
+---
diff --git a/content/es/containers/guide/clustercheckrunners.md b/content/es/containers/guide/clustercheckrunners.md
index 26172c3fd3449..823ac26f8c343 100644
--- a/content/es/containers/guide/clustercheckrunners.md
+++ b/content/es/containers/guide/clustercheckrunners.md
@@ -29,7 +29,7 @@ En primer lugar, [despliega el Cluster Agent][3].
A continuación, despliega el Cluster Check Runner utilizando [Datadog Operator][4] o [Helm][5]:
{{< tabs >}}
-{{% tab "Operator" %}}
+{{% tab "Datadog Operator" %}}
Con el Operador, puedes lanzar y gestionar todos estos recursos con un único manifiesto. Por ejemplo:
diff --git a/content/es/containers/kubernetes/configuration.md b/content/es/containers/kubernetes/configuration.md
new file mode 100644
index 0000000000000..d2f9ad63a702b
--- /dev/null
+++ b/content/es/containers/kubernetes/configuration.md
@@ -0,0 +1,863 @@
+---
+aliases:
+- /es/integrations/faq/gathering-kubernetes-events
+- /es/agent/kubernetes/event_collection
+- /es/agent/kubernetes/configuration
+title: Configurar mejor el Datadog Agent en Kubernetes
+---
+
+## Información general
+
+Después de haber instalado el Datadog Agent en tu entorno de Kubernetes, puedes elegir opciones de configuración adicionales.
+
+### Habilita a Datadog para recopilar:
+- [Trazas (traces) (APM)](#enable-apm-and-tracing)
+- [Eventos de Kubernetes](#enable-kubernetes-event-collection)
+- [NPM](#enable-npm-collection)
+- [Logs](#enable-log-collection)
+- [Procesos](#enable-process-collection)
+
+### Otras capacidades
+- [Datadog Cluster Agent](#datadog-cluster-agent)
+- [Integraciones](#integrations)
+- [Vista de contenedores](#containers-view)
+- [Orchestrator Explorer](#orchestrator-explorer)
+- [Servidor de métricas externas](#custom-metrics-server)
+
+### Más configuraciones
+- [Variables de entorno](#environment-variables)
+- [Métricas personalizadas de DogStatsD](#configure-dogstatsd)
+- [Asignación de etiqueta (tag)](#configure-tag-mapping)
+- [Secretos](#using-secret-files)
+- [Ignorar contenedores](#ignore-containers)
+- [Tiempo de ejecución del servidor de la API de Kubernetes](#kubernetes-api-server-timeout)
+- [Configuración del proxy](#proxy-settings)
+- [Autodiscovery](#Autodiscovery)
+- [Miscelánea](#miscellaneous)
+
+## Activar APM y rastreo
+
+{{< tabs >}}
+{{% tab "Datadog Operator" %}}
+
+Edita tu `datadog-agent.yaml` para establecer `features.apm.enabled` en `true`.
+
+```yaml
+apiVersion: datadoghq.com/v2alpha1
+kind: DatadogAgent
+metadata:
+ name: datadog
+spec:
+ global:
+ credentials:
+ apiKey:
+
+ features:
+ apm:
+ enabled: true
+```
+
+{{% k8s-operator-redeploy %}}
+
+{{% /tab %}}
+{{% tab "Helm" %}}
+
+En Helm, APM está **habilitado por defecto** sobre la canalización de UDS o Windows.
+
+Para comprobarlo, asegúrate de que `datadog.apm.socketEnabled` está configurado como `true` en tu `values.yaml`.
+
+```yaml
+datadog:
+ apm:
+ socketEnabled: true
+```
+
+{{% /tab %}}
+{{< /tabs >}}
+
+Para obtener más información, consulta [Recopilación de trazas de Kubernetes][16].
+
+## Activar la recopilación de eventos de Kubernetes
+
+Utiliza el [Datadog Cluster Agent][2] para recopilar eventos de Kubernetes.
+
+{{< tabs >}}
+{{% tab "Datadog Operator" %}}
+
+La recopilación de eventos está activada por defecto por el Datadog Operator. Esto se puede gestionar en la configuración `features.eventCollection.collectKubernetesEvents` en tu `datadog-agent.yaml`.
+
+```yaml
+apiVersion: datadoghq.com/v2alpha1
+kind: DatadogAgent
+metadata:
+ name: datadog
+spec:
+ global:
+ credentials:
+ apiKey:
+ site:
+
+ features:
+ eventCollection:
+ collectKubernetesEvents: true
+```
+
+{{% /tab %}}
+{{% tab "Helm" %}}
+
+Para recopilar eventos de Kubernetes con el Datadog Cluster Agent, asegúrate de que las opciones `clusterAgent.enabled`, `datadog.collectEvents` y `clusterAgent.rbac.create` están configuradas como `true` en tu archivo `datadog-values.yaml`.
+
+```yaml
+datadog:
+ collectEvents: true
+clusterAgent:
+ enabled: true
+ rbac:
+ create: true
+```
+
+Si no deseas utilizar la opción de Cluster Agent, puedes hacer que un Node Agent recopila eventos de Kubernetes configurando las opciones `datadog.leaderElection`, `datadog.collectEvents` y `agents.rbac.create` como `true` en tu archivo `datadog-values.yaml`.
+
+```yaml
+datadog:
+ leaderElection: true
+ collectEvents: true
+agents:
+ rbac:
+ create: true
+```
+
+[1]: /es/containers/cluster_agent
+
+{{% /tab %}}
+{{< /tabs >}}
+
+Para la configuración de DaemonSet, consulta [Recopilación de eventos de Cluster Agent en DaemonSet][14].
+
+## Activar la recopilación de NPM
+
+{{< tabs >}}
+{{% tab "Datadog Operator" %}}
+
+En tu `datadog-agent.yaml`, establece `features.npm.enabled` en `true`.
+
+```yaml
+apiVersion: datadoghq.com/v2alpha1
+kind: DatadogAgent
+metadata:
+ name: datadog
+spec:
+ global:
+ credentials:
+ apiKey:
+
+ features:
+ npm:
+ enabled: true
+```
+
+A continuación, aplica la nueva configuración:
+
+```shell
+kubectl apply -n $DD_NAMESPACE -f datadog-agent.yaml
+```
+
+{{% /tab %}}
+{{% tab "Helm" %}}
+
+Actualiza tu `datadog-values.yaml` con la siguiente configuración:
+
+```yaml
+datadog:
+ # (...)
+ networkMonitoring:
+ enabled: true
+```
+
+A continuación, actualiza tu tabla de Helm:
+
+```shell
+helm upgrade -f datadog-values.yaml datadog/datadog
+```
+
+{{% /tab %}}
+{{< /tabs >}}
+
+Para obtener más información, consulta [Monitorización de rendimiento de red][18].
+
+## Activar la recopilación de log
+
+{{< tabs >}}
+{{% tab "Datadog Operator" %}}
+En tu `datadog-agent.yaml`, establece `features.logCollection.enabled` y `features.logCollection.containerCollectAll` en `true`.
+
+```yaml
+apiVersion: datadoghq.com/v2alpha1
+kind: DatadogAgent
+metadata:
+ name: datadog
+spec:
+ global:
+ credentials:
+ apiKey:
+
+ features:
+ logCollection:
+ enabled: true
+ containerCollectAll: true
+```
+
+A continuación, aplica la nueva configuración:
+
+```shell
+kubectl apply -n $DD_NAMESPACE -f datadog-agent.yaml
+```
+
+{{% /tab %}}
+{{% tab "Helm" %}}
+Actualiza tu `datadog-values.yaml` con la siguiente configuración:
+
+```yaml
+datadog:
+ # (...)
+ logs:
+ enabled: true
+ containerCollectAll: true
+```
+
+A continuación, actualiza tu tabla de Helm:
+
+```shell
+helm upgrade -f datadog-values.yaml datadog/datadog
+```
+{{% /tab %}}
+{{< /tabs >}}
+
+Para obtener más información, consulta [Recopilación de log de Kubernetes][17].
+
+## Activar la recopilación de procesos
+
+{{< tabs >}}
+{{% tab "Datadog Operator" %}}
+En tu `datadog-agent.yaml`, establece `features.liveProcessCollection.enabled` en `true`.
+
+```yaml
+apiVersion: datadoghq.com/v2alpha1
+kind: DatadogAgent
+metadata:
+ name: datadog
+spec:
+ global:
+ credentials:
+ apiKey:
+
+ features:
+ liveProcessCollection:
+ enabled: true
+```
+
+A continuación, aplica la nueva configuración:
+
+```shell
+kubectl apply -n $DD_NAMESPACE -f datadog-agent.yaml
+```
+
+{{% /tab %}}
+{{% tab "Helm" %}}
+Actualiza tu `datadog-values.yaml` con la siguiente configuración:
+
+```yaml
+datadog:
+ # (...)
+ processAgent:
+ enabled: true
+ processCollection: true
+```
+
+A continuación, actualiza tu tabla de Helm:
+
+```shell
+helm upgrade -f datadog-values.yaml datadog/datadog
+```
+{{% /tab %}}
+{{< /tabs >}}
+
+Para obtener más información, consulta [Live Processes][23]
+## Datadog Cluster Agent
+
+Datadog Cluster Agent proporciona un enfoque optimizado y centralizado para recopilar datos de monitorización del clúster. Datadog recomienda encarecidamente el uso de Cluster Agent para la monitorización de Kubernetes.
+
+Datadog Operator v1.0.0+ y tabla de Helm v2.7.0+ **habilitan por defecto el Cluster Agent **. No es necesaria ninguna otra configuración.
+
+{{< tabs >}}
+{{% tab "Datadog Operator" %}}
+
+El Datadog Operator v1.0.0+ habilita el Cluster Agent por defecto. El Operator crea los RBAC necesarios y despliega Cluster Agent. Ambos Agents utilizan la misma clave de API.
+
+El Operador genera automáticamente un token aleatorio en un `Secret` de Kubernetes que lo compartirán el Datadog Agent y Cluster Agent para una comunicación segura.
+
+Puedes especificar manualmente este token en el campo `global.clusterAgentToken` de tu `datadog-agent.yaml`:
+
+```yaml
+apiVersion: datadoghq.com/v2alpha1
+kind: DatadogAgent
+metadata:
+ name: datadog
+spec:
+ global:
+ credentials:
+ apiKey:
+ appKey:
+ clusterAgentToken:
+```
+
+También puedes especificar este token haciendo referencia al nombre de un `Secret` existente y a la clave de datos que contiene este token:
+
+```yaml
+apiVersion: datadoghq.com/v2alpha1
+kind: DatadogAgent
+metadata:
+ name: datadog
+spec:
+ global:
+ credentials:
+ apiKey:
+ appKey:
+ clusterAgentTokenSecret:
+ secretName:
+ keyName:
+```
+
+**Nota**: Cuando se configura manualmente, este token debe tener 32 caracteres alfanuméricos.
+
+A continuación, aplica la nueva configuración:
+
+```shell
+kubectl apply -n $DD_NAMESPACE -f datadog-agent.yaml
+```
+
+{{% /tab %}}
+{{% tab "Helm" %}}
+
+La tabla de Helm v2.7.0+ activa por defecto el Cluster Agent.
+
+Para comprobarlo, asegúrate de que `clusterAgent.enabled` está configurado como `true` en tu `datadog-values.yaml`:
+
+```yaml
+clusterAgent:
+ enabled: true
+```
+
+Helm genera automáticamente un token aleatorio en un `Secret` de Kubernetes compartido por el Datadog Agent y Cluster Agent para una comunicación segura.
+
+Puedes especificar manualmente este token en el campo `clusterAgent.token` de tu `datadog-agent.yaml`:
+
+```yaml
+clusterAgent:
+ enabled: true
+ token:
+```
+
+Alternativamente, puedes especificar este token haciendo referencia al nombre de un `Secret` existente, donde el token se encuentra en una clave llamada `token`:
+
+```yaml
+clusterAgent:
+ enabled: true
+ tokenExistingSecret:
+```
+
+{{% /tab %}}
+{{< /tabs >}}
+
+Para más información, consulta la [documentación de Datadog Cluster Agent][2].
+
+## Servidor de métricas personalizadas
+
+Para utilizar la función [servidor de métricas personalizadas][22] de Cluster Agent, debes proporcionar una [clave de aplicación][24] de Datadog y activar el proveedor de métricas.
+
+{{< tabs >}}
+{{% tab "Datadog Operator" %}}
+En `datadog-agent.yaml`, proporcione una clave de aplicación en `spec.global.credentials.appKey` y establece `features.externalMetricsServer.enabled` en `true`.
+
+```yaml
+apiVersion: datadoghq.com/v2alpha1
+kind: DatadogAgent
+metadata:
+ name: datadog
+spec:
+ global:
+ credentials:
+ apiKey:
+ appKey:
+
+ features:
+ externalMetricsServer:
+ enabled: true
+```
+
+A continuación, aplica la nueva configuración:
+
+```shell
+kubectl apply -n $DD_NAMESPACE -f datadog-agent.yaml
+```
+{{% /tab %}}
+{{% tab "Helm" %}}
+En `datadog-values.yaml`, proporcione una clave de aplicación en `datadog.appKey` y establece `clusterAgent.metricsProvider.enabled` en `true`.
+
+```yaml
+datadog:
+ apiKey:
+ appKey:
+
+clusterAgent:
+ enabled: true
+ metricsProvider:
+ enabled: true
+```
+
+A continuación, actualiza tu tabla de Helm:
+
+```shell
+helm upgrade -f datadog-values.yaml datadog/datadog
+```
+
+{{% /tab %}}
+{{< /tabs >}}
+
+## Integraciones
+
+Una vez que Agent esté funcionando en tu clúster, utiliza [la característica Autodiscovery de Datadog][5] para recopilar métricas y logs automáticamente de tus pods.
+
+## Vista de contenedores
+
+Para utilizar el [Explorador de contenedores][3] de Datadog, active el Agent de proceso. Datadog Operator y la tabla de Helm **habilitan el Agent de proceso por defecto**. No es necesario ninguna otra configuración.
+
+{{< tabs >}}
+{{% tab "Datadog Operator" %}}
+
+De manera predeterminada, el Datadog Operator habilita el Process Agent.
+
+Para comprobarlo, asegúrate de que `features.liveContainerCollection.enabled` se haya establecido en `true` en tu `datadog-agent.yaml`:
+
+```yaml
+apiVersion: datadoghq.com/v2alpha1
+kind: DatadogAgent
+metadata:
+ name: datadog
+spec:
+ global:
+ credentials:
+ apiKey:
+ appKey:
+ features:
+ liveContainerCollection:
+ enabled: true
+```
+
+{{% /tab %}}
+{{% tab "Helm" %}}
+
+La tabla de Helm activa el Agent de proceso por defecto.
+
+Para comprobarlo, asegúrate de que `processAgent.enabled` está configurado como `true` en tu `datadog-values.yaml`:
+
+```yaml
+datadog:
+ # (...)
+ processAgent:
+ enabled: true
+```
+
+En algunas configuraciones, el Process Agent y Cluster Agent no pueden detectar de manera automática un nombre de clúster de Kubernetes. Si esto ocurre, la función no se inicia y aparece la siguiente advertencia en el log del Cluster Agent: `Orchestrator explorer enabled but no cluster name set: disabling.` En este caso, debes establecer `datadog.clusterName` en tu nombre de clúster en `values.yaml`.
+
+```yaml
+datadog:
+ #(...)
+ clusterName:
+ #(...)
+ processAgent:
+ enabled: true
+```
+
+[1]: https://github.com/DataDog/helm-charts
+[2]: https://github.com/DataDog/helm-charts/blob/master/charts/datadog/values.yaml
+{{% /tab %}}
+{{< /tabs >}}
+
+Consulta la documentación [Vista de contenedores][15] para obtener información adicional.
+
+## Orchestrator Explorer
+
+El Datadog Operator y la tabla de Helm **habilitan por defecto el [Orchestrator Explorer][20] de Datadog**. No es necesario ninguna otra configuración.
+
+{{< tabs >}}
+{{% tab "Datadog Operator" %}}
+
+Orchestrator Explorer está activado por defecto en el Datadog Operator.
+
+Para comprobarlo, asegúrate de que el parámetro `features.orchestratorExplorer.enabled` se haya establecido en `true` en tu `datadog-agent.yaml`:
+
+```yaml
+apiVersion: datadoghq.com/v2alpha1
+kind: DatadogAgent
+metadata:
+ name: datadog
+spec:
+ global:
+ credentials:
+ apiKey:
+ appKey:
+ features:
+ orchestratorExplorer:
+ enabled: true
+```
+
+{{% /tab %}}
+{{% tab "Helm" %}}
+
+La tabla de Helm habilita Orchestrator Explorer por defecto.
+
+Para comprobarlo, asegúrate de que el parámetro `orchestratorExplorer.enabled` está configurado como `true` en tu archivo `datadog-values.yaml`:
+
+```yaml
+datadog:
+ # (...)
+ processAgent:
+ enabled: true
+ orchestratorExplorer:
+ enabled: true
+```
+
+{{% /tab %}}
+{{< /tabs >}}
+
+Consulta la [documentación de Orchestrator Explorer][21] para obtener información adicional.
+
+## Configuración básica
+
+Utiliza los siguientes campos de configuración para configurar el Datadog Agent.
+
+{{< tabs >}}
+{{% tab "Datadog Operator" %}}
+
+| Parámetro (v2alpha1) | Descripción |
+| --------------------------- | ----------- |
+| `global.credentials.apiKey` | Configura tu clave de API Datadog. |
+| `global.credentials.apiSecret.secretName` | En lugar de `global.credentials.apiKey`, indica el nombre de un `Secret` de Kubernetes que contenga tu clave de API de Datadog.|
+| `global.credentials.apiSecret.keyName` | En lugar de `global.credentials.apiKey`, proporciona la clave del `Secret` de Kubernetes nombrada en `global.credentials.apiSecret.secretName`.|
+| `global.credentials.appKey` | Configura tu clave de aplicación de Datadog. Si utilizas el servidor de métricas externas, debes configurar una clave de aplicación de Datadog para el acceso de lectura a tus métricas. |
+| `global.credentials.appSecret.secretName` | En lugar de `global.credentials.apiKey`, indica el nombre de un `Secret` de Kubernetes que contenga la clave de tu aplicación de Datadog.|
+| `global.credentials.appSecret.keyName` | En lugar de `global.credentials.apiKey`, proporciona la clave del `Secret` de Kubernetes nombrada en `global.credentials.appSecret.secretName`.|
+| `global.logLevel` | Establece la intensidad del registro. Esto puede ser anulado por el contenedor. Los niveles de log válidos son: `trace`, `debug`, `info`, `warn`, `error`, `critical` y `off`. Por defecto: `info`. |
+| `global.registry` | Registro de imágenes a utilizar para todas las imágenes de Agent. Por defecto: `gcr.io/datadoghq`. |
+| `global.site` | Establece el [sitio de entrada][1] de Datadog al que se envían los datos del Agent. Tu sitio es {{< region-param key="dd_site" code="true" >}}. (Asegúrate de seleccionar el SITIO correcto a la derecha). |
+| `global.tags` | Un lista de etiquetas para adjuntar a cada métrica, evento y check de servicio recopilados. |
+
+Para consultar la lista completa de los campos de configuración para el Datadog Operator, vea la [especificación de Operator v2alpha1][2]. Para versiones anteriores, vea la [especificación de Operator v1alpha1][3]. Los campos de configuración también pueden consultarse mediante `kubectl explain datadogagent --recursive`.
+
+[1]: /es/getting_started/
+[2]: https://github.com/DataDog/datadog-operator/blob/main/docs/configuration.v2alpha1.md
+[3]: https://github.com/DataDog/datadog-operator/blob/main/docs/configuration.v1alpha1.md
+{{% /tab %}}
+{{% tab "Helm" %}}
+| Helm | Descripción |
+| ---- | ----------- |
+| `datadog.apiKey` | Configura tu clave de API de Datadog. |
+| `datadog.apiKeyExistingSecret` | En lugar de `datadog.apiKey`, proporciona el nombre de un `Secret` de Kubernetes existente que contenga tu clave de API de Datadog, configurada con el nombre de clave `api-key`. |
+| `datadog.appKey` | Configura tu clave de aplicación de Datadog. Si utilizas el servidor de métricas externas, debes configurar una clave de aplicación de Datadog para el acceso de lectura a tus métricas. |
+| `datadog.appKeyExistingSecret` | En lugar de `datadog.appKey`, proporciona el nombre de un `Secret` de Kubernetes existente que contenga tu clave de aplicación de Datadog, configurada con el nombre de clave `app-key`. |
+| `datadog.logLevel` | Establece la verbosidad del registro. Esto puede ser anulado por el contenedor. Los niveles válidos de log son: `trace`, `debug`, `info`, `warn`, `error`, `critical` y `off`. Por defecto: `info`. |
+| `registry` | Registro de imagen a utilizar para todas las imágenes del Agent. Por defecto: `gcr.io/datadoghq`. |
+| `datadog.site` | Establece el [sitio de entrada][1] de Datadog al que se envían los datos del Agent. Tu sitio es {{< region-param key="dd_site" code="true" >}}. (Asegúrate de seleccionar el SITIO correcto a la derecha). |
+| `datadog.tags` | Un lista de etiquetas para adjuntar a cada métrica, evento y check de servicio recopilados. |
+
+Si deseas consultar la lista completa de las variables de entorno para la tabla de Helm, consulta la [ lista completa de opciones][2] para `datadog-values.yaml`.
+
+[1]: /es/getting_started/site
+[2]: https://github.com/DataDog/helm-charts/tree/main/charts/datadog#all-configuration-options
+{{% /tab %}}
+{{% tab "DaemonSet" %}}
+| Variable de Ent | Descripción |
+|----------------------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| `DD_API_KEY` | Tu Datadog clave de API (**obligatorio**) |
+| `DD_ENV` | Establece la etiqueta global `env` para todos los datos emitidos. |
+| `DD_HOSTNAME` | Nombre de host a utilizar para métricas (si falla la detección automática) | | |
+| `DD_TAGS` | Etiquetas de host separadas por espacios. Por ejemplo: `simple-tag-0 tag-key-1:tag-value-1` |
+| `DD_SITE` | Sitio de destino para tus métricas, trazas y logs. Tu `DD_SITE` es {{< region-param key="dd_site" code="true">}}. Por defecto es `datadoghq.com`. |
+| `DD_DD_URL` | Opcional para anular la URL de envío de métrica. |
+| `DD_URL` (6.36+/7.36+) | Alias para `DD_DD_URL`. Ignorado si `DD_DD_URL` ya está configurado. |
+| `DD_CHECK_RUNNERS` | El Agent ejecuta todos los checks de forma concurrente por defecto (valor por defecto = `4` ejecutores). Para ejecutar checks secuencialmente, ajusta el valor en `1`. Si necesitas ejecutar un número elevado de checks (o checks lentos), el componente `collector-queue` podría retrasarse y el check de estado podría fallar. Puede aumentar el número de ejecutores para iniciar checks en paralelo. |
+| `DD_LEADER_ELECTION` | Si se están ejecutando múltiples instancias del Agent en tu clúster, establece esta variable en `true` para evitar la duplicación de la recopilación de eventos. |
+{{% /tab %}}
+{{< /tabs >}}
+
+## Variables de entorno
+El Datadog Agent en contenedores puede configurarse utilizando variables de entorno. Para una amplia lista de las variables de entorno compatibles, consulta la sección [variables de entorno][26] de la documentación del Docker Agent.
+
+### Ejemplos
+{{< tabs >}}
+{{% tab "Datadog Operator" %}}
+Al utilizar el Datadog Operator, puedes establecer variables de entorno adicionales en `override` para un componente con `[key].env []object`, o para un contenedor con `[key].containers.[key].env []object`. Se admiten las siguientes claves:
+
+- `nodeAgent`
+- `clusterAgent`
+- `clusterChecksRunner`
+
+Los ajustes de contenedor tienen prioridad sobre los ajustes de componente.
+
+```yaml
+apiVersion: datadoghq.com/v2alpha1
+kind: DatadogAgent
+metadata:
+ name: datadog
+spec:
+ override:
+ nodeAgent:
+ env:
+ - name:
+ value:
+ clusterAgent:
+ containers:
+ cluster-agent:
+ env:
+ - name:
+ value:
+```
+
+{{% /tab %}}
+{{% tab "Helm" %}}
+
+```yaml
+datadog:
+ env:
+ - name:
+ value:
+clusterAgent:
+ env:
+ - name:
+ value:
+```
+
+{{% /tab %}}
+{{% tab "DaemonSet" %}}
+Añade variables de entorno al DaemonSet o al despliegue (para Datadog Cluster Agent).
+```yaml
+apiVersion: apps/v1
+kind: DaemonSet
+metadata:
+ name: datadog
+spec:
+ template:
+ spec:
+ containers:
+ - name: agent
+ ...
+ env:
+ - name:
+ value:
+```
+
+{{% /tab %}}
+{{< /tabs >}}
+
+## Configurar DogStatsD
+
+DogStatsD puede enviar métricas personalizadas sobre UDP con el protocolo StatsD. **DogStatsD está habilitado por defecto por Datadog Operator y Helm**. Consulta la [documentación de DogStatsD][19] para obtener más información.
+
+Puedes utilizar las siguientes variables de entorno para configurar DogStatsD con DaemonSet:
+
+| Variable de Env | Descripción |
+|----------------------------------|------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| `DD_DOGSTATSD_NON_LOCAL_TRAFFIC` | Escucha los paquetes de DogStatsD de otros contenedores (obligatorio para enviar métricas personalizadas). |
+| `DD_HISTOGRAM_PERCENTILES` | Los percentiles de histogramas para calcular (separados por espacios). Por defecto es `0.95`. |
+| `DD_HISTOGRAM_AGGREGATES` | Los agregados del histograma a calcular (separados por espacios). El valor por defecto es `"max median avg count"`. |
+| `DD_DOGSTATSD_SOCKET` | Ruta al socket de Unix a escuchar. Debe estar en un volumen montado en `rw`. |
+| `DD_DOGSTATSD_ORIGIN_DETECTION` | Activa la detección de contenedores y etiquetado para las métricas de socket de Unix. |
+| `DD_DOGSTATSD_TAGS` | Etiquetas adicionales para anexar a todas las métricas, los eventos y los checks de servicios recibidos por este servidor de DogStatsD, por ejemplo: `"env:golden group:retrievers"`. |
+
+## Configurar la asignación de etiquetas
+
+Datadog recopila automáticamente etiquetas comunes de Kubernetes.
+
+Además, puedes asignar etiquetas de nodos de Kubernetes, etiquetas de pods y anotaciones a las etiquetas de Datadog. Utiliza las siguientes variables de entorno para configurar esta asignación:
+
+{{< tabs >}}
+{{% tab "Datadog Operator" %}}
+
+| Parámetro (v2alpha1) | Descripción |
+| --------------------------- | ----------- |
+| `global.namespaceLabelsAsTags` | Proporciona una asignación entre las etiquetas de espacio de nombres de Kubernetes y etiquetas de Datadog. `: ` |
+| `global.nodeLabelsAsTags` | Proporciona una asignación entre las etiquetas de nodo de Kubernetes y etiquetas de Datadog. `: ` |
+| `global.podAnnotationsAsTags` | Proporciona una asignación entre anotaciones de Kubernetes y etiquetas de Datadog. `: ` |
+| `global.podLabelsAsTags` | Proporciona una asignación entre las etiquetas de Kubernetes y las etiquetas de Datadog. `: ` |
+
+### Ejemplos
+
+```yaml
+apiVersion: datadoghq.com/v2alpha1
+kind: DatadogAgent
+metadata:
+ name: datadog
+spec:
+ global:
+ credentials:
+ apiKey:
+ namespaceLabelsAsTags:
+ env: environment
+ # :
+ nodeLabelsAsTags:
+ beta.kubernetes.io/instance-type: aws-instance-type
+ kubernetes.io/role: kube_role
+ # :
+ podLabelsAsTags:
+ app: kube_app
+ release: helm_release
+ # :
+ podAnnotationsAsTags:
+ iam.amazonaws.com/role: kube_iamrole
+ # :
+```
+
+{{% /tab %}}
+{{% tab "Helm" %}}
+
+| Helm | Descripción |
+| --------------------------- | ----------- |
+| `datadog.namespaceLabelsAsTags` | Proporciona una asignación entre las etiquetas de espacio de nombres de Kubernetes y etiquetas de Datadog. `: ` |
+| `datadog.nodeLabelsAsTags` | Proporciona una asignación entre las etiquetas de nodo de Kubernetes y etiquetas de Datadog. `: ` |
+| `datadog.podAnnotationsAsTags` | Proporciona una asignación entre anotaciones de Kubernetes y etiquetas de Datadog. `: ` |
+| `datadog.podLabelsAsTags` | Proporciona una asignación entre las etiquetas de Kubernetes y las etiquetas de Datadog. `: ` |
+
+### Ejemplos
+
+```yaml
+datadog:
+ # (...)
+ namespaceLabelsAsTags:
+ env: environment
+ # :
+ nodeLabelsAsTags:
+ beta.kubernetes.io/instance-type: aws-instance-type
+ kubernetes.io/role: kube_role
+ # :
+ podLabelsAsTags:
+ app: kube_app
+ release: helm_release
+ # :
+ podAnnotationsAsTags:
+ iam.amazonaws.com/role: kube_iamrole
+ # :
+```
+
+{{% /tab %}}
+{{< /tabs >}}
+
+## Usar archivos secretos
+
+Las credenciales de integración pueden almacenarse en los secretos de Docker o Kubernetes y utilizarse en las plantillas de Autodiscovery. Para obtener más información, consulta [Gestión de secretos][12].
+
+## Ignora los contenedores
+
+Excluye contenedores de la recopilación de logs, métricas y Autodiscovery. Datadog excluye los contenedores `pause` de Kubernetes y OpenShift por defecto. Estas listas de permisos y denegaciones se aplican únicamente a Autodiscovery; las trazas y DogStatsD no se ven afectados. Estas variables de entorno admiten expresiones regulares en sus valores.
+
+Consulta la página [Gestión de detección de contenedores][13] para ver ejemplos.
+
+**Nota**: Las métricas `kubernetes.containers.running`, `kubernetes.pods.running`, `docker.containers.running`, `.stopped`, `.running.total` y `.stopped.total` no se ven afectadas por estos ajustes. Se cuentan todos los contenedores.
+
+## Tiempo de espera del servidor de API de Kubernetes
+
+Por defecto, [el check de las métricas centrales de estado de Kubernetes][25] espera 10 segundos para recibir una respuesta del servidor de la API de Kubernetes. En el caso de clústeres de gran tamaño, es posible que se agote el tiempo de espera y se pierdan métricas.
+
+Puedes evitarlo al configurar la variable de entorno `DD_KUBERNETES_APISERVER_CLIENT_TIMEOUT` en un valor superior al predeterminado de 10 segundos.
+
+{{< tabs >}}
+{{% tab "Datadog Operator" %}}
+Actualiza tu `datadog-agent.yaml` con la siguiente configuración:
+
+```yaml
+apiVersion: datadoghq.com/v2alpha1
+kind: DatadogAgent
+metadata:
+ name: datadog
+spec:
+ override:
+ clusterAgent:
+ env:
+ - name: DD_KUBERNETES_APISERVER_CLIENT_TIMEOUT
+ value:
+```
+
+A continuación, aplica la nueva configuración:
+
+```shell
+kubectl apply -n $DD_NAMESPACE -f datadog-agent.yaml
+```
+
+{{% /tab %}}
+{{% tab "Helm" %}}
+Actualiza tu `datadog-values.yaml` con la siguiente configuración:
+
+```yaml
+clusterAgent:
+ env:
+ - name: DD_KUBERNETES_APISERVER_CLIENT_TIMEOUT
+ value:
+```
+
+A continuación, actualiza tu tabla de Helm:
+
+```shell
+helm upgrade -f datadog-values.yaml datadog/datadog
+```
+{{% /tab %}}
+{{< /tabs >}}
+
+## Configuraciones de proxy
+
+A partir del Agent v6.4.0 (y v6.5.0 para el Trace Agent), se pueden sobreescribir los valores de configuración de proxy del Agent con las siguientes variables de entorno:
+
+| Variable de Env | Descripción |
+|--------------------------|------------------------------------------------------------------------|
+| `DD_PROXY_HTTP` | Una URL de HTTP para usar como proxy para solicitudes de `http`. |
+| `DD_PROXY_HTTPS` | Una URL de HTTP para usar como proxy para solicitudes de `https`. |
+| `DD_PROXY_NO_PROXY` | Una lista separada por espacios de URLs para las que no se debe utilizar ningún proxy. |
+| `DD_SKIP_SSL_VALIDATION` | Una opción para comprobar si el Agent tiene problemas para conectarse a Datadog. |
+
+## Autodiscovery
+
+| Variable de Env | Descripción |
+|------------------------------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| `DD_LISTENERS` | Oyentes de Autodiscovery para ejecutar. |
+| `DD_EXTRA_LISTENERS` | Oyentes de Autodiscovery adicionales para ejecutar. Se añaden además de las variables definidas en la sección `listeners` del archivo de configuración `datadog.yaml`. |
+| `DD_CONFIG_PROVIDERS` | Los proveedores a los que el Agent debe llamar para recopilar las configuraciones de check. Los proveedores disponibles son:
`kubelet`: maneja plantillas incrustadas en anotaciones de pods.
`docker`: maneja plantillas incrustadas en etiquetas de contenedor.
`clusterchecks`: recupera configuraciones de check de clúster del Cluster Agent .
`kube_services`: controla servicios de Kubernetes para checks de clústeres. |
+| `DD_EXTRA_CONFIG_PROVIDERS` | Proveedores de configuración de Autodiscovery adicionales a utilizar. Se añaden además de las variables definidas en la sección `config_providers` del archivo de configuración `datadog.yaml`. |
+
+## Miscelánea
+
+| Variable de Env | Descripción |
+|-------------------------------------|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| `DD_PROCESS_AGENT_CONTAINER_SOURCE` | Sobreescribe la detección automática del origen del contenedor para forzar un único origen. Por ejemplo: `"docker"`, `"ecs_fargate"`, `"kubelet"`. Esto ya no es necesario a partir de Agent v7.35.0. |
+| `DD_HEALTH_PORT` | Configura esto como `5555` para exponer el check de estado del Agent en el puerto `5555`. |
+| `DD_CLUSTER_NAME` | Establece un identificador de clústeres de Kubernetes personalizado para evitar colisiones de alias de host. El nombre del clúster puede tener un máximo de 40 caracteres con las siguientes restricciones: solo letras minúsculas, números y guiones. Debe empezar por una letra. Debe terminar con un número o una letra. |
+| `DD_COLLECT_KUBERNETES_EVENTS ` | Habilita la recopilación de eventos con el Agent. Si estás ejecutando varias instancias del Agent en tu clúster, configura también `DD_LEADER_ELECTION` en `true`. |
+
+
+[1]: /es/agent/
+[2]: /es/containers/cluster_agent/
+[3]: https://app.datadoghq.com/containers
+[5]: /es/containers/kubernetes/integrations/
+[12]: /es/agent/configuration/secrets-management/
+[13]: /es/agent/guide/autodiscovery-management/
+[14]: /es/containers/guide/kubernetes_daemonset#cluster-agent-event-collection
+[15]: /es/infrastructure/containers/
+[16]: /es/containers/kubernetes/apm
+[17]: /es/containers/kubernetes/log
+[18]: /es/network_monitoring/performance/
+[19]: /es/developers/dogstatsd
+[20]: https://app.datadoghq.com/orchestration/overview
+[21]: /es/infrastructure/containers/orchestrator_explorer
+[22]: /es/containers/guide/cluster_agent_autoscaling_metrics/?tab=helm
+[23]: /es/infrastructure/process/
+[24]: /es/account_management/api-app-keys/#application-keys
+[25]: /es/integrations/kubernetes_state_core/
+[26]: /es/containers/docker/?tab=standard#environment-variables
\ No newline at end of file
diff --git a/content/es/dashboards/functions/count.md b/content/es/dashboards/functions/count.md
index 9d1ebe4d3c534..73d72adfdbb18 100644
--- a/content/es/dashboards/functions/count.md
+++ b/content/es/dashboards/functions/count.md
@@ -30,7 +30,7 @@ Ejemplo: `count_not_null(system.cpu.user{*} by {host})` devuelve una serie tempo
{{< img src="dashboards/funciones/count/count_not_null.png" alt="Conteo de valores no nulos" style="width:80%;">}}
-## Otras funciones
+## Otros funciones
{{< whatsnext desc="Consulta las demás funciones disponibles:" >}}
{{< nextlink href="/dashboards/functions/algorithms" >}}Algorítmica: implementa la detección de anomalías o outliers en la métrica.{{< /nextlink >}}
diff --git a/content/es/dashboards/guide/screenboard-api-doc.md b/content/es/dashboards/guide/screenboard-api-doc.md
index 91d5277f68afa..faf38464c5054 100644
--- a/content/es/dashboards/guide/screenboard-api-doc.md
+++ b/content/es/dashboards/guide/screenboard-api-doc.md
@@ -20,12 +20,12 @@ El endpoint `screenboard` permite crear, actualizar, eliminar y consultar screen
### Argumentos
* **`board_title`** [*required* (requerido)]:
- El nombre del dashboard.
-* **`description`** (descripción) [*opcional*, *por defecto*=**Ninguno**]:
- Una descripción del contenido de dashboard.
+ Nombre del dashboard.
+* **`description`** (descripción) [*opcional*, *default*=**None**]:
+ Descripción del contenido del dashboard.
* **`widgets`** [*required* (requerido)]:
Una lista de definiciones de widget. Para obtener una definición de widget, utiliza la *pestaña JSON* en la IU de la configuración de widget.
-* **`template_variables`** [*opcional*, *default*=**None**]:
+* **`template_variables`** [*optional*, *default*=**None**]:
Una lista de variables de plantilla para utilizar la plantilla dashboard.
* **`read_only`** [*opcional*, *default*=**False**]:
El estado de solo lectura del screenboard.
@@ -139,18 +139,18 @@ curl -X POST -H "Tipo de contenido: aplicación/json" \
### Argumentos
* **`board_title`** [*required* (requerido)]:
- El nombre del dashboard.
+ Nombre del dashboard.
* **`description`** (descripción) [*opcional*, *default*=**None**]:
- Una descripción del contenido de dashboard.
+ Descripción del contenido del dashboard.
* **`widgets`** [*required* (requerido)]:
- Una lista de definiciones widget. Para obtener una definición de widget, utiliza la *pestaña JSON* en la IU de la configuración de widget.
-* **`template_variables`** [*optional* (opcional), *default*=**None**]:
+ Una lista de definiciones de widget. Para obtener una definición de widget, utiliza la *pestaña JSON* en la IU de la configuración de widget.
+* **`template_variables`** [*optional*, *default*=**None**]:
Una lista de variables de plantilla para utilizar la plantilla dashboard.
* **`width`** [*optional* (opcional), *default*=**None**]:
Ancho de screenboard en píxeles
* **`height`** (altura) [*optional* (opcional), *default*=**None**]:
Altura de screenboard en píxeles.
-* **`read_only`** [*optional* (opcional), *default*=**False**]:
+* **`read_only`** [*opcional*, *default*=**False**]:
El estado de solo lectura del screenboard.
### Ejemplos
diff --git a/content/es/dashboards/widgets/pie_chart.md b/content/es/dashboards/widgets/pie_chart.md
index 57ce04406eeb8..34f0740f8cded 100644
--- a/content/es/dashboards/widgets/pie_chart.md
+++ b/content/es/dashboards/widgets/pie_chart.md
@@ -19,9 +19,9 @@ El widget de gráfico circular puede mostrar un único conjunto de datos con las
## Configuración
1. Selecciona una de las fuentes de datos disponibles.
-2. Configurar la consulta, consulta los siguientes recursos para obtener más información:
- * Métricas: consulta la documentación [querying (consulta)][1] para configurar una consulta métrica.
- * Events: consulta la documentación [log search (búsqueda de log)][2] para configurar una consulta de evento de log.
+2. Configura la consulta, consulta los siguientes recursos para obtener más información:
+ * Métricas: consulta la documentación [querying (de consulta)][1] para configurar una consulta métrica.
+ * Events: consulta la documentación [log search (buscar log)][2] para configurar una consulta de evento de log.
3. (Opcional) Modificar la consulta con una [fórmula][3].
4. Personaliza tu gráfico.
@@ -41,7 +41,7 @@ Por defecto, la opción **Automático** muestra una leyenda de Lado etiquetada d
### Enlaces contextuales
-Los [Context links (enlaces contextuales)][4] están activados por defecto y pueden activarse o desactivarse. Los enlaces contextuales sirven de puente entre el widget de dashboard y otras páginas (en Datadog o de terceros).
+Los [Context links (enlaces contextuales)][4] están activados por defecto y pueden activarse o desactivarse. Los enlaces contextuales enlazan widgets de dashboard con otras páginas (en Datadog o de terceros).
## Visualización e interacción
@@ -59,7 +59,7 @@ La visualización del widget de gráfico circular en pantalla completa muestra e
## API
-Este widget puede utilizarse con la **[API de dashboards][6]**. Ve la siguiente tabla para la [definición del esquema de JSON de widget][7]:
+Este widget puede utilizarse con la **[API de dashboards][6]**. Ve la siguiente tabla para la [definición del esquema JSON widget][7]:
El tipo de widget para gráfico circular es sunburst.
diff --git a/content/es/dashboards/widgets/top_list.md b/content/es/dashboards/widgets/top_list.md
index 0f95028ee2c41..7c0f2b655f97c 100644
--- a/content/es/dashboards/widgets/top_list.md
+++ b/content/es/dashboards/widgets/top_list.md
@@ -23,7 +23,7 @@ La visualización de lista principal te permite mostrar una lista de los valores
### Configuración
-1. Elige los datos para graficar:
+1. Elige los datos para los que crear gráficas:
* Métrica: consulta la documentación [querying (consulta)][1] para configurar una consulta métrica.
* Fuentes de datos de no métrica: consulta la [Trace search documentation (documentación de búsqueda de rastreo)][2] o [Log search documentation (documentación de búsqueda de log)][3] para configurar una consulta de evento.
@@ -42,7 +42,7 @@ Configurar las funciones del Modo de visualización opcional para añadir contex
#### Enlaces contextuales
-Los [Context links (enlaces contextuales)][4] están activados por defecto y pueden activarse o desactivarse. Los enlaces contextuales sirven de puente entre widgets de dashboard con otras páginas de Datadog, o con aplicaciones de terceros.
+Los [enlaces contextuales][4] están activados por defecto y pueden activarse o desactivarse. Los enlaces contextuales sirven de puente entre widgets de dashboard con otras páginas de Datadog, o con aplicaciones de terceros.
#### Hora mundial
@@ -50,7 +50,7 @@ En los screenboards y notebooks, elige si tu widget tiene un marco temporal pers
## API
-Este widget puede utilizarse con la **[Dashboards API (API de dashboards)][5]**. Ve la siguiente tabla para la [widget JSON schema definition (definición del esquema JSON widget][6]:
+Este widget se puede utilizar con la **[API de dashboards][5]**. Consulta la siguiente tabla para obtener la [definición del esquema JSON del widget)][6]:
{{< dashboards-widgets-api >}}
diff --git a/content/es/data_security/guide/tls_deprecation_1_2.md b/content/es/data_security/guide/tls_deprecation_1_2.md
index b68dcb016ee81..5e37f0b1e6d29 100644
--- a/content/es/data_security/guide/tls_deprecation_1_2.md
+++ b/content/es/data_security/guide/tls_deprecation_1_2.md
@@ -1,5 +1,4 @@
---
-kind: Guía
title: Aviso de obsolescencia del TLS para versiones anteriores a la v1.2
---
diff --git a/content/es/data_streams/go.md b/content/es/data_streams/go.md
index 4864aba343c93..cc350a8074f49 100644
--- a/content/es/data_streams/go.md
+++ b/content/es/data_streams/go.md
@@ -2,111 +2,88 @@
title: Configurar la monitorización de secuencias de datos para Go
---
-{{< site-region region="ap1" >}}
-La monitorización de secuencias de datos no es compatible en la región AP1.
-{{< /site-region >}}
-
### Requisitos previos
-Para empezar con la monitorización de secuencias de datos, necesitas versiones recientes de las bibliotecas del Datadog Agent y Data Streams Monitoring:
-* [Datadog Agent 7.34.0 y versiones posteriores][1]
-* [Data Streams Library 0.2 y versiones posteriores][2]
+Para empezar con Data Streams Monitoring, necesitas versiones recientes de las bibliotecas del Datadog Agent y de Data Streams Monitoring:
+* [Datadog Agent v7.34.0 o más reciente][1]
+* [dd-trace-go v1.56.1 o más reciente][2]
### Instalación
-Inicia una ruta de secuencias de datos con `datastreams.Start()` al principio de tu pipeline.
+- Configura la variable de entorno `DD_DATA_STREAMS_ENABLED=true`.
+- [Inicia el rastreador][3].
Existen dos tipos de instrumentación:
- Instrumentación para cargas de trabajo basadas en Kafka
-- Instrumentación personalizada para cualquier otro protocolo o tecnología de colas
-
-La URL predeterminada del Agent de trazas es localhost:8126
. Si esta es distinta para tu aplicación, usa la opción datastreams.Start(datastreams.WithAgentAddr("notlocalhost:8126"))
.
-
-### Instrumentación de Kafka
-
-1. Configura los productores para que llamen a `TraceKafkaProduce()` antes de enviar un mensaje de Kafka:
-
- ```go
- import (ddkafka "github.com/DataDog/data-streams-go/integrations/kafka")
- ...
- ctx = ddkafka.TraceKafkaProduce(ctx, &kafkaMsg)
- ```
+- Instrumentación personalizada para cualquier otra tecnología o protocolo de puesta en cola
- Esta función añade un nuevo punto de control a cualquier ruta existente en el contexto de Go proporcionado, o crea una nueva ruta si no se encuentra ninguna. A continuación, añade la ruta en los encabezados de tus mensajes de Kafka.
+### Cliente de Confluent Kafka
-2. Configura los consumidores para llamar a `TraceKafkaConsume()`:
+```ir
+importar (
+ ddkafka "gopkg.in/DataDog/dd-trace-go.v1/contrib/confluentinc/confluent-kafka-go/kafka.v2"
+)
- ```go
- import ddkafka "github.com/DataDog/data-streams-go/integrations/kafka"
- ...
- ctx = ddkafka.TraceKafkaConsume(ctx, &kafkaMsg, consumer_group)
- ```
+...
+// CREA UN PRODUCTOR CON ESTA ENVOLTURA
+productor, error:= ddkafka.NewProducer(&kafka.ConfigMap{
+ "bootstrap.servers": bootStrapServers,
+}, ddkafka.WithDataStreams())
- Esta función extrae la ruta por la que ha transcurrido un mensaje de Kafka hasta el momento. Establece un nuevo punto de control en la ruta para registrar el consumo de un mensaje y almacena la ruta en el contexto de Go proporcionado.
+```
- **Nota**: Tanto la salida `ctx` desde `TraceKafkaProduce()` como la salida `ctx` desde `TraceKafkaConsume()` contienen información sobre la ruta actualizada.
+Si un servicio consume datos de un punto y produce a otro punto, propague el contexto entre los dos lugares utilizando la estructura de contexto de Go:
+1. Extraer el contexto de los encabezados:
+ ```go
+ ctx = datastreams.ExtractFromBase64Carrier(ctx, ddsarama.NewConsumerMessageCarrier(message))
+ ```
-Para `TraceKafkaProduce()`, si envías varios mensajes de Kafka a la vez (fan-out), no reutilices el `ctx` de salida entre llamadas.
+2. Insértelo en el encabezado antes de producir aguas abajo:
+ ```go
+ datastreams.InjectToBase64Carrier(ctx, ddsarama.NewProducerMessageCarrier(message))
+ ```
-Para `TraceKafkaConsume()`, si añades varios mensajes para crear un número menor de cargas útiles (fan-in), llama a `MergeContext()` para fusionar los contextos en uno solo que pueda pasarse a la siguiente llamada `TraceKafkaProduce()`:
+### Cliente de Sarama Kafka
-```go
-import (
- datastreams "github.com/DataDog/data-streams-go"
- ddkafka "github.com/DataDog/data-streams-go/integrations/kafka"
+```ir
+importar (
+ ddsarama "gopkg.in/DataDog/dd-trace-go.v1/contrib/Shopify/sarama"
)
...
+configurar:= sarama.NewConfig()
+productor, error:= sarama.NewAsyncProducer([]string{bootStrapServers}, config)
-contexts := []Context{}
-for (...) {
- contexts.append(contexts, ddkafka.TraceKafkaConsume(ctx, &consumedMsg, consumer_group))
-}
-mergedContext = datastreams.MergeContexts(contexts...)
-
-...
-
-ddkafka.TraceKafkaProduce(mergedContext, &producedMsg)
+// AÑADE ESTA LÍNEA
+productor = ddsarama.WrapAsyncProducer(config, producer, ddsarama.WithDataStreams())
```
### Instrumentación manual
-También puedes utilizar la instrumentación manual. Por ejemplo, en HTTP, es posible propagar la ruta con cabeceras HTTP.
+También puedes utilizar la instrumentación manual. Por ejemplo, puedes propagar el contexto a través de Kinesis.
-Para insertar una ruta:
+#### Instrumentación de la llamada a producción
-```go
-req, err := http.NewRequest(...)
-...
-p, ok := datastreams.PathwayFromContext(ctx)
-if ok {
- req.Headers.Set(datastreams.PropagationKeyBase64, p.EncodeStr())
-}
-```
+1. Asegúrate de que tu mensaje sea compatible con la [interfaz TextMapWriter](https://github.com/DataDog/dd-trace-go/blob/main/datastreams/propagation.go#L37).
+2. Inserta el contexto en tu mensaje e instrumenta la llamada a producción llamando a:
-Para extraer una ruta:
-
-```go
-func extractPathwayToContext(req *http.Request) context.Context {
- ctx := req.Context()
- p, err := datastreams.DecodeStr(req.Header.Get(datastreams.PropagationKeyBase64))
- if err != nil {
- return ctx
- }
- ctx = datastreams.ContextWithPathway(ctx, p)
- _, ctx = datastreams.SetCheckpoint(ctx, "type:http")
+```ir
+ctx, ok := tracer.SetDataStreamsCheckpointWithParams(ctx, options.CheckpointParams{PayloadSize: getProducerMsgSize(msg)}, "direction:out", "type:kinesis", "topic:kinesis_arn")
+si ok {
+ datastreams.InjectToBase64Carrier(ctx, message)
}
+
```
-### Añadir una dimensión
+#### Instrumentación de la llamada al consumo
-Puedes añadir una dimensión adicional a las métricas de latencia de extremo a extremo con la etiqueta `event_type`:
+1. Asegúrate de que tu mensaje sea compatible con la [interfaz TextMapReader](https://github.com/DataDog/dd-trace-go/blob/main/datastreams/propagation.go#L44).
+2. Extrae el contexto de tu mensaje e instrumenta la llamada a consumir llamando a:
-```go
-_, ctx = datastreams.SetCheckpoint(ctx, "type:internal", "event_type:sell")
+```ir
+ ctx, ok := tracer.SetDataStreamsCheckpointWithParams(datastreams.ExtractFromBase64Carrier(context.Background(), message), options.CheckpointParams{PayloadSize: payloadSize}, "direction:in", "type:kinesis", "topic:kinesis_arn")
```
-Basta con añadir la etiqueta `event_type` para el primer servicio en cada ruta. Los datos de alta cardinalidad (como hosts o ID de solicitud) no se admiten como valores para la etiqueta `event_type`.
-
[1]: /es/agent
-[2]: https://github.com/DataDog/data-streams-go
\ No newline at end of file
+[2]: https://github.com/DataDog/dd-trace-go
+[3]: https://docs.datadoghq.com/es/tracing/trace_collection/library_config/go/
\ No newline at end of file
diff --git a/content/es/data_streams/java.md b/content/es/data_streams/java.md
new file mode 100644
index 0000000000000..54c89c2bc635e
--- /dev/null
+++ b/content/es/data_streams/java.md
@@ -0,0 +1,62 @@
+---
+further_reading:
+- link: /integrations/kafka/
+ tag: Documentación
+ text: Integración de Kafka
+- link: /tracing/service_catalog/
+ tag: Documentación
+ text: Catálogo de servicios
+title: Configurar la monitorización de flujos (streams) de datos para Java
+---
+
+{{< site-region region="ap1" >}}
+Monitorización de Secuencias de Datos no es compatible con la región AP1.
+{{< /site-region >}}
+
+### Requisitos previos
+
+Para empezar con la monitorización de flujos de datos, necesitas las versiones recientes de las bibliotecas del Datadog Agent y Java:
+* [Datadog Agent v7.34.0 o más reciente][1]
+* [APM habilitado con el Java Agent ][2]
+ * Kafka y RabbitMQ: v1.9.0 o posterior
+ * Amazon SQS: v1.27.0 o posterior
+
+### Instalación
+
+Java utiliza la instrumentación automática para inyectar y extraer metadatos adicionales requeridos por la monitorización de flujos de datos para medir latencias de extremo a extremo y la relación entre colas y servicios. Para habilitar la monitorización de flujos de datos, configura la variable de entorno `DD_DATA_STREAMS_ENABLED` en `true` en servicios que envían mensajes a (o que consumen mensajes de) Kafka, SQS o RabbitMQ.
+
+Además, configura la variable `DD_TRACE_REMOVE_INTEGRATION_SERVICE_NAMES_ENABLED` en `true` de modo que `DD_SERVICE` se utilice como nombre de servicio en trazas (traces).
+
+Por ejemplo:
+```yaml
+entorno:
+ - DD_DATA_STREAMS_ENABLED: "true"
+ - DD_TRACE_REMOVE_INTEGRATION_SERVICE_NAMES_ENABLED: "true"
+```
+
+Como alternativa, puedes configurar la propiedad del sistema `-Ddd.data.streams.enabled=true` ejecutando lo siguiente cuando inicies tu aplicación Java:
+
+```bash
+java -javaagent:/path/to/dd-java-agent.jar -Ddd.data.streams.enabled=true -Ddd.trace.remove.integration-service-names.enabled=true -jar path/to/your/app.jar
+```
+
+### Instalación con un solo clic
+Para configurar la monitorización de flujos de datos desde la interfaz de usuario Datadog sin necesidad de reiniciar tu servicio, utiliza la [Configuración en el tiempo de ejecución][5]. Ve a la página de servicios de APM y `Enable DSM`.
+
+{{< img src="data_streams/enable_dsm_service_catalog.png" alt="Habilita la monitorización de flujos de datos desde la sección Dependencias de la página de servicios de APM" >}}
+
+### Bibliotecas compatibles
+La monitorización de flujos de datos es compatible con la [biblioteca de confluent-kafka][3].
+
+### Monitorización de pipelines de SQS
+La monitorización de flujos de datos utiliza un [atributo de mensaje][4] para rastrear la ruta de un mensaje a través de una cola SQS. Como Amazon SQS tiene un límite máximo de 10 atributos de mensaje permitidos por mensaje, todos los mensajes transmitidos a través de los pipelines de datos deben tener 9 o menos atributos de mensaje configurados, lo que permite el atributo restante para la monitorización de flujos de datos.
+
+## Referencias adicionales
+
+{{< partial name="whats-next/whats-next.html" >}}
+
+[1]: /es/agent
+[2]: /es/tracing/trace_collection/dd_libraries/java/
+[3]: https://pypi.org/project/confluent-kafka/
+[4]: https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-message-metadata.html
+[5]: /es/agent/remote_config/?tab=configurationyamlfile#enabling-remote-configuration
\ No newline at end of file
diff --git a/content/es/developers/dogstatsd/datagram_shell.md b/content/es/developers/dogstatsd/datagram_shell.md
index dee8a4a13783d..8fbed080959bc 100644
--- a/content/es/developers/dogstatsd/datagram_shell.md
+++ b/content/es/developers/dogstatsd/datagram_shell.md
@@ -1,7 +1,7 @@
---
aliases:
- /es/developers/dogstatsd/data_types/
-description: Información general del formato de datagramas utilizado por DogStatsD,
+description: Información general sobre el formato de datagramas utilizado por DogStatsD,
así como del uso (avanzado) de shells.
further_reading:
- link: developers/dogstatsd
@@ -9,13 +9,13 @@ further_reading:
text: Introducción a DogStatsD
- link: developers/libraries
tag: Documentación
- text: API oficial y creada por la comunidad, y bibliotecas de clientes DogStatsD
+ text: API oficial y creada por la comunidad y bibliotecas de cliente de DogStatsD
title: Formato de datagramas y uso de shells
---
Esta sección especifica el formato de datagramas sin procesar para métricas, eventos y checks de servicios compatibles con DogStatsD. Los datagramas sin procesar están codificados en UTF-8. Esta sección no es de lectura obligatoria, si estás utilizando cualquiera de las [bibliotecas de clientes DogStatsD][1]. Pero si quieres escribir tu propia biblioteca o utilizar el shell para enviar métricas, entonces sigue leyendo.
-## Protocolo DogStatsD
+## Protocolo de DogStatsD
{{< tabs >}}
{{% tab "Metrics" (Métricas) %}}
@@ -24,11 +24,11 @@ Esta sección especifica el formato de datagramas sin procesar para métricas, e
| Parámetro | Obligatorio | Descripción |
| ----------------------------------- | -------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `` | Sí | Cadena que sólo contiene caracteres alfanuméricos ASCII, guiones bajos y puntos. Consulta la [política sobre nombres de métricas][101]. |
+| `` | Sí | Cadena que sólo contiene caracteres alfanuméricos ASCII, guiones bajos y puntos. Consulta la [política relativa a los nombres de métricas][101]. |
| `` | Sí | Número entero o flotante. |
-| `` | Sí | `c` para COUNT (Recuento), `g` para GAUGE (Indicador), `ms` para TIMER (Temporizador), `h` para HISTOGRAM (Histograma), `s` para SET (Configurar), `d` para DISTRIBUTION (Distribución). Para ver más detalles, consulta [Tipos de métricas][102]. |
-| ``ONSULTA | No | Un valor flotante entre `0` y `1`, inclusive. Sólo funciona con las métricas COUNT, HISTOGRAM, DISTRIBUTION, y TIMER. El valor por defecto es `1`, que muestrea el 100% del tiempo. |
-| `:,` | No | Lista de cadenas separadas por comas. Utiliza dos puntos para etiquetas (tags) (`env:prod`) de clave/valor. Para más información sobre la definición de etiquetas (tags), consulta [Empezando con las etiquetas][103]. |
+| `` | Sí | `c` para COUNT (Recuento), `g` para GAUGE (Indicador), `ms` para TIMER (Temporizador), `h` para HISTOGRAM (Histograma), `s` para SET (Conjunto), `d` para DISTRIBUTION (Distribución). Para ver más detalles, consulta [Tipos de métricas][102]. |
+| `` | No | Un valor flotante entre `0` y `1`, inclusive. Sólo funciona con las métricas COUNT, HISTOGRAM, DISTRIBUTION, y TIMER. El valor por defecto es `1`, que muestrea el 100% del tiempo. |
+| `:,` | No | Lista de cadenas separadas por comas. Utiliza dos puntos para etiquetas (tags) (`env:prod`) de clave/valor. Para más información sobre la definición de etiquetas, consulta [Empezando con las etiquetas][103]. |
Los siguientes son algunos ejemplos de datagramas:
@@ -39,14 +39,14 @@ Los siguientes son algunos ejemplos de datagramas:
- `users.online:1|c|#country:china`: incrementa la métrica y la etiqueta COUNT de los usuarios activos por país de origen.
- `users.online:1|c|@0.5|#country:china`: realiza un seguimiento de los usuarios activos de China y utiliza una frecuencia de muestreo.
-### Protocolo DogStatsD v1.1
+### Protocolo de DogStatsD v1.1
A partir del Agent `>=v6.25.0` y `=v7.25.0`, es posible empaquetar valores. Esta opción
es compatible con todos los tipos de métricas, excepto `SET`. Los valores se separan mediante un `:`, por ejemplo:
`:::||@|#:,`
-`TYPE`, `SAMPLE_RATE` y `TAGS` se comparten entre todos los valores. Esto produce la misma métrica que el envío de múltiples
+`TYPE`, `SAMPLE_RATE` y `TAGS` se comparten entre todos los valores. Esto genera las mismas métricas que el envío de múltiples
mensajes con un valor en cada uno. Esto es útil para las métricas HISTOGRAM, TIMING y DISTRIBUTION.
### Ejemplo de datagramas
@@ -54,7 +54,7 @@ mensajes con un valor en cada uno. Esto es útil para las métricas HISTOGRAM, T
- `page.views:1:2:32|d`: realiza un muestreo de la métrica DISTRIBUTION `page.views` tres veces con los valores `1`, `2` y `32`.
- `song.length:240:234|h|@0.5`: realiza un muestreo del histograma `song.length` como si se enviara la mitad del tiempo, dos veces. A cada valor se le aplica la frecuencia de muestreo de `0.5`.
-### Protocolo DogStatsD v1.2
+### Protocolo de DogStatsD v1.2
A partir del Agent `>=v6.35.0` y `=v7.35.0`, se admite un nuevo campo de ID de contenedor.
El Datadog Agent utiliza el valor del ID de contenedor para enriquecer las métricas de DogStatsD con etiquetas de contenedor adicionales.
@@ -63,29 +63,29 @@ El ID de contenedor lleva el prefijo `c:`, por ejemplo:
`:||#:,|c:`
-**Nota:** Configura `dogstatsd_origin_detection_client` como `true` en tu archivo `datadog.yaml` o la variable de entorno `DD_DogStatsD_ORIGIN_DETECTION_CLIENT=true` para indicar al Datadog Agent que extraiga el campo del ID de contenedor y adjuntar las etiquetas de contenedor correspondientes.
+**Nota:** Configura `dogstatsd_origin_detection_client` como `true` en tu archivo `datadog.yaml` o la variable de entorno `DD_DOGSTATSD_ORIGIN_DETECTION_CLIENT=true` para indicar al Datadog Agent que extraiga el campo del ID de contenedor y adjunte las etiquetas de contenedor correspondientes.
### Ejemplo de datagramas
- `page.views:1|g|#env:dev|c:83c0a99c0a54c0c187f461c7980e9b57f3f6a8b0c918c8d93df19a9de6f3fe1d`: el Datadog Agent añade etiquetas de contenedor como `image_name` y `image_tag` a la métrica `page.views`.
-Para obtener más información sobre las etiquetas de contenedor, consulta la documentación sobre el etiquetado [Kubernetes][104] y [Docker][105].
+Para obtener más información sobre las etiquetas de contenedor, consulta la documentación sobre el etiquetado en [Kubernetes][104] y [Docker][105].
-### Protocolo DogStatsD v1.3
+### Protocolo de DogStatsD v1.3
-Los Agents v6.40.0 y v7.40.0 y posteriores admiten un campo de marca temporal Unix opcional.
+Los Agents v6.40.0 y v7.40.0 y posteriores admiten un campo de marca de tiempo Unix opcional.
Cuando se proporciona este campo, el Datadog Agent no procesa ninguna métrica (sin agregación) y sólo se limita a enriquecer los métricas con etiquetas. Esto puede ser útil si ya estabas agregando tus métricas en tu aplicación y quieres enviarlas a Datadog sin ningún procesamiento adicional.
La marca de tiempo Unix debe ser un número positivo válido en el pasado. Sólo se admiten métricas GAUGE y COUNT.
-El valor es una marca de tiempo Unix (UTC) y debe tener el prefijo `T`, por ejemplo:
+El valor es una marca de tiempo Unix (UTC) y debe llevar el prefijo `T`, por ejemplo:
`:||#:,|T`
### Ejemplo de datagramas
-- `page.views:15|c|#env:dev|T1656581400`: un COUNT indicando que 15 vistas de páginas ocurrieron el 30 de junio de 2022 a las 9:30 UTC
+- `page.views:15|c|#env:dev|T1656581400`: una métrica COUNT que indica que 15 vistas de páginas ocurrieron el 30 de junio de 2022 a las 9:30 UTC
[101]: /es/metrics/#metric-name
[102]: /es/metrics/types/
@@ -104,7 +104,7 @@ El valor es una marca de tiempo Unix (UTC) y debe tener el prefijo `T`, por ejem
| `` | Sí | Texto del evento. Inserta saltos de línea con: `\\n`. |
| `` | Sí | Longitud (en bytes) del `` del archivo codificado en UTF-8 |
| `` | Sí | Longitud (en bytes) del `` del archivo codificado en UTF-8 |
-| `d:` | No | Añade una marca de tiempo al evento. El valor predeterminado es la marca de tiempo Unix actual. |
+| `d:` | No | Añade una marca de tiempo al evento. El valor predeterminado es la marca temporal Unix actual. |
| `h:` | No | Añade un nombre de host al evento. Por defecto es la instancia del Datadog Agent. |
| `k:` | No | Añade una clave de agregación para agrupar el evento con otros que tengan la misma clave. No existen valores por defecto. |
| `p:` | No | Configura como `normal` o `low`. El valor por defecto es `normal`. |
@@ -133,9 +133,9 @@ Se ha producido una excepción. No se puede analizar la solicitud:\\n{"foo: "bar
| `` | Sí | Nombre del check de servicio. |
| `` | Sí | Número entero correspondiente al estado del check (OK = `0`, WARNING (Advertencia) = `1`, CRITICAL (Crítico) = `2`, UNKNOWN (Desconocido) = `3`). |
| `d:` | No | Añade una marca de tiempo al check. El valor predeterminado es la marca de tiempo Unix actual. |
-| `h:` | No | Añade un nombre de host al evento (no por defecto). |
-| `#:,` | No | Configura las etiquetas del evento. Una lista de cadenas separadas por coma (no por defecto). |
-| `m:` | No | Mensaje que describe el estado actual del check de servicio. Este campo debe situarse en último lugar entre los campos de metadatos (sin valor por defecto). |
+| `h:` | No | Añade un nombre de host al evento (no existen valores por defecto). |
+| `#:,` | No | Configura las etiquetas del evento. Una lista de cadenas separadas por comas (no existen valores por defecto). |
+| `m:` | No | Mensaje que describe el estado actual del check de servicio. Este campo debe situarse en último lugar entre los campos de metadatos (no existen valores por defecto). |
El siguiente es un ejemplo de datagrama:
@@ -158,11 +158,11 @@ DogStatsD crea un mensaje que contiene información sobre tu métrica, evento o
El formato para enviar métricas es:
-``texto
+``text
:||@|#:,
```
-Los siguientes ejemplos envían puntos de datos para una métrica gauge llamada `custom_metric` con la etiqueta `shell`.
+Los siguientes ejemplos envían puntos de datos para una métrica GAUGE llamada `custom_metric` con la etiqueta `shell`.
En Linux:
@@ -184,7 +184,7 @@ En Windows:
PS C:\> .\send-statsd.ps1 "custom_metric:123|g|#shell"
```
-En cualquier plataforma con Python (en Windows, se puede utilizar el intérprete Python integrado del Agent, que se encuentra en `%ProgramFiles%\Datadog\Datadog Agent\embedded\python.exe`, para el Agent versión 6.11 y anteriores, y en `%ProgramFiles%\Datadog\Datadog Agent\embedded\python.exe`, para el Agent versión 6.12 y posteriores):
+En cualquier plataforma con Python (en Windows, se puede utilizar el intérprete Python integrado del Agent, que se encuentra en `%ProgramFiles%\Datadog\Datadog Agent\embedded\python.exe`, para el Agent versión 6.11 y anteriores, y en `%ProgramFiles%\Datadog\Datadog Agent\embedded\python.exe`, para el Agent versión 6.12 y posteriores):
### Python 2
@@ -207,7 +207,7 @@ sock.sendto("custom_metric:60|g|#shell", ("localhost", 8125))
El formato para enviar eventos es:
-```texto
+```text
_e{.length,.length}:||d:|h:|p:|t:|#:,.
```
@@ -236,7 +236,7 @@ PS C:> .\send-statsd.ps1 "_e{$($title.length),$($text.Length)}:$title|$text|#she
El formato para enviar checks de servicios es:
-```texto
+```text
_sc|||d:|h:|#:|m:
```
diff --git a/content/es/developers/guide/what-best-practices-are-recommended-for-naming-metrics-and-tags.md b/content/es/developers/guide/what-best-practices-are-recommended-for-naming-metrics-and-tags.md
index 4a0352d797657..8667d32c792b2 100644
--- a/content/es/developers/guide/what-best-practices-are-recommended-for-naming-metrics-and-tags.md
+++ b/content/es/developers/guide/what-best-practices-are-recommended-for-naming-metrics-and-tags.md
@@ -26,7 +26,6 @@ La convención de nomenclatura es un arte y posiblemente una de las decisiones m
* Solo puede contener caracteres alfanuméricos ASCII, guiones bajos y puntos. Los demás caracteres se convierten en guiones bajos.
* No debe superar los 200 caracteres (aunque, desde el punto de vista de la interfaz de usuario, es preferible que tenga menos de 100).
* No se admite Unicode.
-* Es recomendado para evitar espacios.
Las métricas informadas por el Agent tienen un formato pseudojerárquico de puntos, por ejemplo: `http.nginx.response_time`. Se describe como pseudojerárquico porque en realidad no se impone una jerarquía, pero la estructura se utiliza para inferir ciertas relaciones, por ejemplo: "_Veo que hostA y hostB informan de `http.nginx.*`, deben ser frontend web"_).
@@ -46,7 +45,7 @@ Datadog recomienda utilizar el etiquetado de servicios unificado al asignar etiq
Ejemplos de claves de etiqueta de métrica comunes son `instance`, `name` y `role`.
-## Leer más
+## Referencias adicionales
{{< partial name="whats-next/whats-next.html" >}}
diff --git a/content/es/getting_started/incident_management/_index.md b/content/es/getting_started/incident_management/_index.md
index 747c953514189..5e8b0b1de8d12 100644
--- a/content/es/getting_started/incident_management/_index.md
+++ b/content/es/getting_started/incident_management/_index.md
@@ -191,7 +191,7 @@ Asimismo, puedes declarar y editar incidencias y comunicarte rápidamente con tu
{{< img src="service_management/incidents/incidents-list-mobile.png" style="width:100%; background:none; border:none; box-shadow:none;" alt="Monitores en Mobile App">}}
-## Leer más
+## Referencias adicionales
{{< partial name="whats-next/whats-next.html" >}}
@@ -206,7 +206,7 @@ Asimismo, puedes declarar y editar incidencias y comunicarte rápidamente con tu
[9]: /es/service_management/incident_management/#status-levels
[10]: /es/service_management/incident_management/incident_settings
[11]: https://app.datadoghq.com/incidents/settings
-[12]: /es/service_management/mobile/
+[12]: /es/mobile/
[13]: https://apps.apple.com/app/datadog/id1391380318
[14]: https://play.google.com/store/apps/details?id=com.datadog.app
[15]: https://app.datadoghq.com/dashboard/lists
diff --git a/content/es/integrations/google_cloud_run.md b/content/es/integrations/google_cloud_run.md
new file mode 100644
index 0000000000000..27a9c5c8bfb3f
--- /dev/null
+++ b/content/es/integrations/google_cloud_run.md
@@ -0,0 +1,105 @@
+---
+categories:
+- nube
+- contenedores
+- nube de Google
+- colección de logs
+- orquestación
+custom_kind: integración
+dependencies: []
+description: Recopila métricas, trazas (traces) y logs de todo tus clústeres y analízalos
+ en Datadog.
+doc_link: https://docs.datadoghq.com/integrations/google_cloud_run/
+draft: false
+further_reading:
+- link: https://www.datadoghq.com/blog/monitor-google-cloud-run-with-datadog/
+ tag: Blog
+ text: Monitoriza Google Cloud Run con Datadog
+- link: https://docs.datadoghq.com/integrations/google_cloud_run_for_anthos/
+ tag: Documentación
+ text: Google Cloud Run para Anthos
+git_integration_title: google_cloud_run
+has_logo: true
+integration_id: google-cloud-run
+integration_title: Google Cloud Run
+integration_version: ''
+is_public: true
+manifest_version: '1.0'
+name: google_cloud_run
+public_title: Integración de Datadog y Google Cloud Run
+short_description: Recopila métricas, trazas (traces) y logs de todos tus clústeres
+ y analízalos en Datadog.
+version: '1.0'
+---
+
+
+## Información general
+
+Cloud Run es una plataforma de computación administrada que permite ejecutar contenedores sin estado invocables mediante solicitudes HTTP.
+
+Habilita esta integración e instrumenta tu contenedor para ver todas tus métricas, trazas (traces) y logs de Cloud Run en Datadog.
+
+Para más información sobre Cloud Run para Anthos, consulta la [documentación de Google Cloud Run para Anthos][1].
+
+## Configuración
+
+### Recopilación de métricas
+
+#### Instalación
+
+Configura la [integración de Google Cloud Platform][2] para empezar a recopilar métricas de forma predefinida. Para configurar métricas personalizadasconsulta la [documentación serverless ][3].
+
+### APM
+
+#### integración
+Google Cloud Run también expone [logs de auditoría][4].
+Los logs de Google Cloud Run se recopilan con Google Cloud Logging y se envían a un trabajo de Dataflow a través de un tema Cloud Pub/Sub. Si todavía no lo has hecho, [configura el registro con la plantilla Datadog Dataflow][5].
+
+Una vez hecho esto, exporta tus logs de Google Cloud Run logs desde Google Cloud Logging al tema Pub/Sub:
+
+1. Ve a la [página de Google Cloud Logging][6] y filtra los logs de Google Cloud Run.
+2. Haz clic en **Crear receptor** y asigna el nombre correspondiente al receptor.
+3. Elige "Cloud Pub/Sub" como destino y selecciona el tema Pub/Sub creado para tal fin. **Nota**: El tema Pub/Sub puede estar ubicado en un proyecto diferente.
+
+ {{< img src="integrations/google_cloud_pubsub/creating_sink2.png" alt="Exportar logs de Google Cloud Pub/Sub Logs a Pub Sub" >}}
+
+4. Haz clic en **Crear** y espera a que aparezca el mensaje de confirmación.
+
+#### Registro directo
+Para más información sobre el registro directo de aplicaciones en Datadog desde tus servicios de Cloud Run, consulta la [documentación serverless ][3].
+
+### Rastreo
+
+Para obtener más información sobre las instrucciones de configuración especializadas del Agent para Google Cloud Run totalmente administrado, consulta la [documentación serverless][3].
+
+## Datos recopilados
+
+### Métricas
+{{< get-metrics-from-git "google_cloud_run" >}}
+
+
+### Eventos
+
+La integración de las funciones de Google Cloud no incluye ningún evento.
+
+### Checks de servicios
+
+La integración de las funciones de Google Cloud no incluye ningún check de servicios.
+
+
+## Resolución de problemas
+
+¿Necesitas ayuda? Ponte en contacto con el [servicio de asistencia de Datadog][8].
+
+## Leer más
+
+{{< partial name="whats-next/whats-next.html" >}}
+
+[1]: https://docs.datadoghq.com/es/integrations/google_cloud_run_for_anthos/
+[2]: https://docs.datadoghq.com/es/integrations/google_cloud_platform/
+[3]: https://docs.datadoghq.com/es/serverless/google_cloud_run
+[4]: https://cloud.google.com/run/docs/audit-logging
+[5]: https://docs.datadoghq.com/es/integrations/google_cloud_platform/#log-collection
+[6]: https://console.cloud.google.com/logs/viewer
+[7]: https://github.com/DataDog/dogweb/blob/prod/integration/google_cloud_run/google_cloud_run_metadata.csv
+[8]: https://docs.datadoghq.com/es/help/
\ No newline at end of file
diff --git a/content/es/integrations/guide/source-code-integration.md b/content/es/integrations/guide/source-code-integration.md
new file mode 100644
index 0000000000000..8cefccc76f244
--- /dev/null
+++ b/content/es/integrations/guide/source-code-integration.md
@@ -0,0 +1,581 @@
+---
+description: Configura la integración del código fuente que se integra con APM para
+ vincular tu telemetría con tus repositorios, incorporar información git en artefactos
+ de tu pipeline CI y utilizar la integración GitHub para generar fragmentos de código
+ en línea.
+further_reading:
+- link: /integrations/github/
+ tag: Documentación
+ text: Más información sobre la integración GitHub
+- link: /tracing/error_tracking/
+ tag: Documentación
+ text: Más información sobre el seguimiento de errores para servicios de backend
+- link: /profiler/
+ tag: Documentación
+ text: Más información sobre el Continuous Profiler
+- link: /serverless/aws_lambda/configuration/?tab=datadogcli#link-errors-to-your-source-code
+ tag: Documentación
+ text: Más información sobre la monitorización serverless
+- link: /tests/developer_workflows/
+ tag: Documentación
+ text: Más información sobre la visibilidad de los tests
+- link: /code_analysis/
+ tag: Documentación
+ text: Más información sobre el análisis de código
+- link: /security/application_security/
+ tag: Documentación
+ text: Más información sobre Application Security Monitoring
+- link: /logs/error_tracking/
+ tag: Documentación
+ text: Más información sobre el seguimiento de errores para logs
+- link: https://www.datadoghq.com/blog/live-debugging/
+ tag: Blog
+ text: Solucionar eficazmente los errores de producción con la depuración en directo
+ de Datadog
+title: Integración del código fuente de Datadog
+---
+
+## Información general
+
+La integración del código fuente de Datadog te permite conectar tu telemetría con tus repositorios Git. Permite depurar la trazas (traces) de stack tecnológico, perfiles lentos y otros problemas accediendo a las líneas pertinentes de tu código fuente.
+
+{{< img src="integrations/guide/source_code_integration/inline-code-snippet.png" alt="Fragmento de código en línea de una clase RuntimeException de Java, con un botón para visualizar el código en GitHub" style="width:100%;">}}
+
+
+## Configuración
+
+Se requiere el Datadog Agent v7.35.0 o posterior.
+
+Si ya tienes [APM][6] configurado, ve a [**Integraciones** > **Vincular código fuente**][7] y configura la integración del código fuente para tus servicios de backend.
+
+## Etiquetado de tu telemetría con información Git
+
+Tu telemetría debe estar etiquetada con información Git que vincule la versión de la aplicación en ejecución con un repositorio y una confirmación concretos.
+
+Para los lenguajes compatibles, Datadog recomienda [integrar información Git](#embed-git-information-in-your-build-artifacts) en los artefactos desplegados, que luego es extraída por las [bibliotecas de rastreo de Datadog][9] automáticamente.
+
+Para otros lenguajes y configuraciones, puedes [configurar el etiquetado de la telemetría](#configure-telemetry-tagging) tú mismo.
+
+### Integrar información Git en tus artefactos de compilación
+
+Puedes integrar la URL del repositorio y el hash de confirmación en tu artefacto de compilación. Las [bibliotecas de rastreo de Datadog][9] utilizan esta información para añadir automáticamente las etiquetas (tags) correctas a la telemetría de tu servicio APM.
+
+Selecciona uno de los siguientes lenguajes que sea compatible con la integración de información Git:
+
+{{< tabs >}}
+{{% tab "Go" %}}
+
+Se requiere la biblioteca del cliente Go versión 1.48.0 o posterior.
+
+#### Contenedores
+
+Si utilizas contenedores Docker, tienes tres opciones: utilizar Docker, utilizar la biblioteca de rastreo de Datadog o configurar tu aplicación con variables de entorno `DD_GIT_*`.
+
+##### Opción 1: Docker
+
+{{% sci-docker %}}
+
+##### Opción 2: Biblioteca de rastreo de Datadog
+
+{{% sci-dd-tracing-library %}}
+
+##### Opción 3: Variables de entorno `DD_GIT_*`
+
+{{% sci-dd-git-env-variables %}}
+
+#### Serverless
+
+Si utilizas la opción serverless, tienes tres opciones en función de la configuración de tu aplicación serverless.
+
+##### Opción 1: Herramientas de Datadog
+
+{{% sci-dd-serverless %}}
+
+##### Opción 2: Biblioteca de rastreo de Datadog
+
+{{% sci-dd-tracing-library %}}
+
+##### Opción 3: Variables de entorno `DD_GIT_*`
+
+{{% sci-dd-git-env-variables %}}
+
+#### Host
+
+Si utilizas un host, tienes dos opciones.
+
+##### Opción 1: Biblioteca de rastreo de Datadog
+
+{{% sci-dd-tracing-library %}}
+
+##### Opción 2: Variables de entorno `DD_GIT_*`
+
+{{% sci-dd-git-env-variables %}}
+
+[101]: https://tip.golang.org/doc/go1.18
+[102]: https://www.npmjs.com/package/@datadog/datadog-ci
+[103]: https://docs.datadoghq.com/es/serverless/libraries_integrations/plugin/
+[104]: https://github.com/DataDog/datadog-cdk-constructs
+
+{{% /tab %}}
+
+{{% tab "Python" %}}
+
+Se requiere la biblioteca del cliente Python versión 1.12.0 o posterior.
+
+#### Contenedores
+
+Si utilizas contenedores Docker, tienes tres opciones: utilizar Docker, utilizar la biblioteca de rastreo de Datadog o configurar tu aplicación con variables de entorno `DD_GIT_*`.
+
+##### Opción 1: Docker
+
+{{% sci-docker %}}
+
+##### Opción 2: Herramientas de configuración o archivo de parámetros unificados del proyecto Python
+
+{{% sci-dd-setuptools-unified-python %}}
+
+##### Opción 3: Variables de entorno `DD_GIT_*`
+
+{{% sci-dd-git-env-variables %}}
+
+[101]: https://github.com/DataDog/dd-trace-go
+[102]: https://github.com/DataDog/hatch-datadog-build-metadata#readme
+
+#### Serverless
+
+Si utilizas la opción serverless, tienes tres opciones en función de la configuración de tu aplicación serverless.
+
+##### Opción 1: Herramientas de Datadog
+
+{{% sci-dd-serverless %}}
+
+##### Opción 2: Herramientas de configuración o archivo de parámetros unificados del proyecto Python
+
+{{% sci-dd-setuptools-unified-python %}}
+
+##### Opción 3: Variables de entorno `DD_GIT_*`
+
+{{% sci-dd-git-env-variables %}}
+
+#### Host
+
+Si utilizas un host, tienes dos opciones.
+
+##### Opción 2: Herramientas de configuración o archivo de parámetros unificados del proyecto Python
+
+{{% sci-dd-setuptools-unified-python %}}
+
+##### Opción 2: Variables de entorno `DD_GIT_*`
+
+{{% sci-dd-git-env-variables %}}
+
+{{% /tab %}}
+{{% tab ".NET" %}}
+
+Se requiere la biblioteca del cliente .NET versión 2.24.1 o posterior.
+
+#### Contenedores
+
+Si utilizas contenedores Docker, tienes tres opciones: utilizar Docker, utilizar la biblioteca de rastreo de Datadog o configurar tu aplicación con variables de entorno `DD_GIT_*`.
+
+##### Opción 1: Docker
+
+{{% sci-docker %}}
+
+##### Opción 2: Microsoft SourceLink
+
+{{% sci-microsoft-sourcelink %}}
+
+##### Opción 3: Variables de entorno `DD_GIT_*`
+
+{{% sci-dd-git-env-variables %}}
+
+#### Serverless
+
+Si utilizas la opción serverless, tienes tres opciones en función de la configuración de tu aplicación serverless.
+
+##### Opción 1: Herramientas de Datadog
+
+{{% sci-dd-serverless %}}
+
+##### Opción 2: Microsoft SourceLink
+
+{{% sci-microsoft-sourcelink %}}
+
+##### Opción 3: Variables de entorno `DD_GIT_*`
+
+{{% sci-dd-git-env-variables %}}
+
+#### Host
+
+Si utilizas un host, tienes dos opciones: utilizar Microsoft SourceLink o configurar tu aplicación con variables de entorno `DD_GIT_*`.
+
+##### Opción 1: Microsoft SourceLink
+
+{{% sci-microsoft-sourcelink %}}
+
+##### Opción 2: Variables de entorno `DD_GIT_*`
+
+{{% sci-dd-git-env-variables %}}
+
+{{% /tab %}}
+{{% tab "NodeJS" %}}
+
+Se requiere la biblioteca del cliente NodeJS versión 3.21.0 o posterior.
+
+#### Contenedores
+
+Si utilizas contenedores Docker, tienes dos opciones: utilizar Docker o configurar tu aplicación con variables de entorno `DD_GIT_*`.
+
+##### Opción 1: Docker
+
+{{% sci-docker %}}
+
+##### Opción 2: Variables de entorno `DD_GIT_*`
+
+{{% sci-dd-git-env-variables %}}
+
+#### Serverless
+
+Si utilizas la opción serverless, tienes dos opciones en función de la configuración de tu aplicación serverless.
+
+##### Opción 1: Herramientas de Datadog
+
+{{% sci-dd-serverless %}}
+
+##### Opción 2: Variables de entorno `DD_GIT_*`
+
+{{% sci-dd-git-env-variables %}}
+
+#### Host
+
+Si utilizas un host, configura tu aplicación con variables de entorno `DD_GIT_*`.
+
+{{% sci-dd-git-env-variables %}}
+
+{{% /tab %}}
+{{% tab "Ruby" %}}
+
+Se requiere la biblioteca del cliente Ruby versión 1.6.0 o posterior.
+
+#### Contenedores
+
+Si utilizas contenedores Docker, tienes dos opciones: utilizar Docker o configurar tu aplicación con la variable de entorno `DD_TAGS`.
+
+##### Opción 1: Docker
+
+{{% sci-docker-ddtags %}}
+
+##### Opción 2: Variable de entorno `DD_TAGS`
+
+{{% sci-dd-tags-env-variable %}}
+
+#### Serverless
+
+Si utilizas la opción serverless, tienes dos opciones en función de la configuración de tu aplicación serverless.
+
+##### Opción 1: Herramientas de Datadog
+
+{{% sci-dd-serverless %}}
+
+##### Opción 2: Variable de entorno `DD_TAGS`
+
+{{% sci-dd-tags-env-variable %}}
+
+#### Host
+
+Si utilizas un host, configura tu aplicación con la variable de entorno `DD_TAGS`.
+
+{{% sci-dd-tags-env-variable %}}
+
+{{% /tab %}}
+{{% tab "Java" %}}
+
+Se requiere la biblioteca del cliente Java versión 1.12.0 o posterior.
+
+Si utilizas contenedores Docker, tienes dos opciones: utilizar Docker o configurar tu aplicación con variables de entorno `DD_GIT_*`.
+
+##### Opción 1: Docker
+
+{{% sci-docker %}}
+
+##### Opción 2: Variables de entorno `DD_GIT_*`
+
+{{% sci-dd-git-env-variables %}}
+
+#### Serverless
+
+Si utilizas la opción serverless, tienes dos opciones en función de la configuración de tu aplicación serverless.
+
+##### Opción 1: Herramientas de Datadog
+
+{{% sci-dd-serverless %}}
+
+##### Opción 2: Variables de entorno `DD_GIT_*`
+
+{{% sci-dd-git-env-variables %}}
+
+#### Host
+
+Si utilizas un host, configura tu aplicación con variables de entorno `DD_GIT_*`.
+
+{{% sci-dd-git-env-variables %}}
+
+{{% /tab %}}
+{{% tab "PHP" %}}
+
+Se requiere la biblioteca del cliente PHP versión 1.2.0 o posterior.
+
+Si utilizas contenedores Docker, tienes dos opciones: utilizar Docker o configurar tu aplicación con variables de entorno `DD_GIT_*`.
+
+##### Opción 1: Docker
+
+{{% sci-docker %}}
+
+##### Opción 2: Variables de entorno `DD_GIT_*`
+
+{{% sci-dd-git-env-variables %}}
+
+#### Host
+
+Si utilizas un host, configura tu aplicación con variables de entorno `DD_GIT_*`.
+
+{{% sci-dd-git-env-variables %}}
+
+{{% /tab %}}
+{{< /tabs >}}
+
+### Compilación dentro de un contenedor Docker
+
+Si tu proceso de compilación se ejecuta en CI dentro de un contenedor Docker, realiza los siguientes pasos para asegurarte de que la compilación puede acceder a la información Git:
+
+1. Añade el siguiente texto a tu archivo `.dockerignore`. Esto te asegura que el proceso de compilación pueda acceder a un subconjunto de la carpeta `.git`, lo que le permite determinar el hash de confirmación Git y la URL del repositorio.
+
+ ```
+ !.git/HEAD
+ !.git/config
+ !.git/refs
+ ```
+
+2. Añade la siguiente línea de código a tu `Dockerfile`. Asegúrate de colocarla antes de que se ejecute la compilación real.
+
+ ```
+ COPY .git ./.git
+ ```
+
+### Configuración del etiquetado de telemetría
+
+Para los lenguajes no compatibles, utiliza las etiquetas `git.commit.sha` y `git.repository_url` para vincular los datos a una confirmación específica. Asegúrate de que la etiqueta `git.repository_url` no contiene protocolos. Por ejemplo, si la URL de tu repositorio es `https://github.com/example/repo`, el valor de la etiqueta `git.repository_url` debe ser `github.com/example/repo`.
+
+## Sincronización de los metadatos de tu repositorio
+
+Para vincular tu telemetría con el código fuente, los metadatos de tu repositorio deben estar sincronizados con Datadog. Datadog no almacena el contenido real de los archivos de tu repositorio, sólo los objetos Git commit y tree.
+
+### Proveedores Git
+
+La integración del código fuente admite los siguientes proveedores Git:
+
+| Proveedor | Compatibilidad con enlaces contextuales | Compatibilidad con fragmentos de código |
+|---|---|---|
+| SaaS GitHub (github.com) | Sí | Sí |
+| GitHub Enterprise Server | Sí | Sí |
+| SaaS GitLab (gitlab.com) | Sí | Sí |
+| GitLab autogestionado | Sí | No |
+| Bitbucket | Sí | No |
+| Servicios Azure DevOps | Sí | No |
+| Azure DevOps Server | Sí | No |
+
+{{< tabs >}}
+{{% tab "GitHub" %}}
+
+Instala la [integración GitHub][101] de Datadog en el [cuadro de integración GitHub][102] para permitir que Datadog sincronice los metadatos de tu repositorio automáticamente. Cuando especifiques los permisos en el cuadro de integración, selecciona al menos permisos de **Lectura** para **Contenidos**.
+
+Configurar la integración GitHub también te permite ver fragmentos de código en línea en [**Seguimiento de errores**][103], [**Continuous Profiler**][104], [**Monitorización serverless**][105], [**CI Visibility**][106] y [**Application Security Monitoring**][107].
+
+[101]: https://docs.datadoghq.com/es/integrations/github/
+[102]: https://app.datadoghq.com/integrations/github/
+[103]: /es/logs/error_tracking/backend/?tab=serilog#setup
+[104]: /es/integrations/guide/source-code-integration/?tab=continuousprofiler#links-to-git-providers
+[105]: /es/serverless/aws_lambda/configuration/?tab=datadogcli#link-errors-to-your-source-code
+[106]: /es/tests/developer_workflows/#open-tests-in-github-and-your-ide
+[107]: /es/security/application_security/
+
+{{% /tab %}}
+{{% tab "GitLab" %}}
+
+
+
+Para vincular la telemetría con tu código fuente, carga los metadatos de tu repositorio con el comando [`datadog-ci git-metadata upload`][2].
+
+Cuando se ejecuta `datadog-ci git-metadata upload` dentro de un repositorio Git, Datadog recibe la URL del repositorio, la función SHA de confirmación de la rama actual y una lista de rutas de archivos rastreados.
+
+Ejecuta este comando para cada confirmación que necesites sincronizar con Datadog.
+
+Si utilizas [gitlab.com][1], esto también te permite ver fragmentos de código en línea en [**Seguimiento de errores**][3], [**Continuous Profiler**][4], [**Monitorización serverless**][5], [**CI Visibility**][6] y [**Application Security Monitoring**][7].
+
+### Validación
+
+Para asegurarte de que los datos se están recopilando, ejecuta `datadog-ci git-metadata upload` en tu pipeline CI.
+
+Puedes esperar ver el siguiente resultado:
+
+```
+Reporting commit 007f7f466e035b052415134600ea899693e7bb34 from repository git@my-git-server.com:my-org/my-repository.git.
+180 tracked file paths will be reported.
+✅ Handled in 0.077 seconds.
+```
+
+[1]: https://gitlab.com
+[2]: https://github.com/DataDog/datadog-ci/tree/master/src/commands/git-metadata
+[3]: /es/logs/error_tracking/backend/?tab=serilog#setup
+[4]: /es/integrations/guide/source-code-integration/?tab=continuousprofiler#links-to-git-providers
+[5]: /es/serverless/aws_lambda/configuration/?tab=datadogcli#link-errors-to-your-source-code
+[6]: /es/tests/developer_workflows/#open-tests-in-github-and-your-ide
+[7]: /es/security/application_security/
+
+{{% /tab %}}
+{{% tab "Otros proveedores Git" %}}
+
+
+
+Para vincular la telemetría con tu código fuente, carga los metadatos de tu repositorio con el comando [`datadog-ci git-metadata upload`][2].
+
+Cuando se ejecuta `datadog-ci git-metadata upload` dentro de un repositorio Git, Datadog recibe la URL del repositorio, la función SHA de confirmación de la rama actual y una lista de rutas de archivos rastreados.
+
+Ejecuta este comando para cada confirmación que necesites sincronizar con Datadog.
+
+### Validación
+
+Para asegurarte de que los datos se están recopilando, ejecuta `datadog-ci git-metadata upload` en tu pipeline CI.
+
+Puedes esperar ver el siguiente resultado:
+
+```
+Reporting commit 007f7f466e035b052415134600ea899693e7bb34 from repository git@my-git-server.com:my-org/my-repository.git.
+180 tracked file paths will be reported.
+✅ Handled in 0.077 seconds.
+```
+
+[1]: https://github.com/DataDog/datadog-ci/tree/master/src/commands/git-metadata
+{{% /tab %}}
+{{< /tabs >}}
+
+## Uso
+
+### Enlaces a proveedores Git
+
+{{< tabs >}}
+{{% tab "Seguimiento de errores" %}}
+En [Seguimiento de errores][1], puedes ver los enlaces desde los marcos de stack tecnológico hasta su repositorio de origen.
+
+1. Ve a [**APM** > **Seguimiento de errores**][2].
+2. Haz clic en un problema. El panel **Detalles de problemas** aparece a la derecha.
+3. En **Último evento**, haz clic en el botón **View** (Ver) a la derecha de un marco o selecciona **Ver archivo**, **VerGit blame** o **Ver confirmación** para regresar a tu herramienta de gestión de código fuente.
+
+{{< img src="integrations/guide/source_code_integration/error-tracking-panel-full.png" alt="Botón de visualización de un repositorio con tres opciones (ver archivo, ver blame y ver confirmación) disponibles a la derecha de una traza de stack tecnológico de error en Seguimiento de errores, junto con fragmentos de código en línea en la traza del stack tecnológico" style="width:100%;">}}
+
+Si utilizas la integración GitHub o si alojas tus repositorios en la instancia SaaS de GitLab (gitlab.com), haz clic en **Connect to preview** (Conectar para previsualizar), en los marcos de stack tecnológico. Puedes ver fragmentos de código en línea directamente en la traza de stack tecnológico.
+
+[1]: /es/tracing/error_tracking/
+[2]: https://app.datadoghq.com/apm/error-tracking
+
+{{% /tab %}}
+{{% tab "Continuous Profiler" %}}
+
+En el [Continuous Profiler][1], puedes ver una vista previa del código fuente de los marcos de perfiles.
+
+1. Ve a [**APM** > **Búsqueda de perfiles**][2].
+2. Pasa el cursor sobre un método en el gráfico de llamas.
+3. Si es necesario, pulsa `Opt` o `Alt` para habilitar la vista previa.
+
+{{< img src="integrations/guide/source_code_integration/profiler-source-code-preview.png" alt="Vista previa del código fuente en el Continuous Profiler" style="width:100%;">}}
+
+También puedes ver los enlaces desde los marcos de perfiles hasta su repositorio de origen. Esto es compatible con los perfiles desglosados por línea, método o archivo.
+
+1. Ve a [**APM** > **Búsqueda de perfiles**][2].
+2. Pasa el cursor sobre un método en el gráfico de llamas. A la derecha aparece un icono con tres puntos con la etiqueta **Más acciones**.
+3. Haz clic en **More actions** > **View in repo** (Más acciones > Ver en repositorio) para abrir la traza en su repositorio de código fuente.
+
+{{< img src="integrations/guide/source_code_integration/profiler-link-to-git.png" alt="Enlace a GitHub desde el Continuous Profiler" style="width:100%;">}}
+
+[1]: /es/profiler/
+[2]: https://app.datadoghq.com/profiling/search
+{{% /tab %}}
+{{% tab "Monitorización serverless" %}}
+
+Puedes ver los enlaces de los errores en tus trazas de stack tecnológico, asociadas a funciones Lambda, hasta su repositorio de origen en **Monitorización serverless**.
+
+1. Ve a [**Infraestructura** > **Serverless**][101] y haz clic en la pestaña **AWS**.
+2. Haz clic en una función Lambda y luego en el botón **Open Trace** (Abrir traza) para una invocación con una traza de stack tecnológico asociada.
+3. Haz clic en **View Code** (Ver código) para abrir el error en su repositorio de código fuente.
+
+Si utilizas la integración GitHub, haz clic en **Connect to preview** (Conectar para previsualizar) en los cuadros de error. Puedes ver fragmentos de código en línea directamente en la traza de stack tecnológico de la función Lambda.
+
+{{< img src="integrations/guide/source_code_integration/serverless-aws-function-errors.mp4" alt="Enlace a GitHub desde Monitorización serverless" video="true" >}}
+
+[101]: https://app.datadoghq.com/functions?cloud=aws&entity_view=lambda_functions
+
+{{% /tab %}}
+{{% tab "Visibilidad de los tests" %}}
+
+En **Visibilidad de los tests**, puedes ver los enlaces de ejecuciones de tests fallidas hasta su repositorio de origen.
+
+1. Ve a [**Entrega de software** > **Visibilidad de los tests** > **Ejecuciones de tests**][101] y selecciona un test fallido.
+2. Haz clic en el botón **View on GitHub** (Ver en GitHub) para abrir el test en su repositorio de código fuente.
+
+{{< img src="integrations/guide/source_code_integration/test_run_blurred.png" alt="Enlace a GitHub desde el Explorador de CI Visibility" style="width:100%;">}}
+
+Para obtener más información, consulta [Mejora de los flujos de trabajo de los desarrolladores con Datadog][102].
+
+[101]: https://app.datadoghq.com/ci/test-runs
+[102]: /es/tests/developer_workflows/#open-tests-in-github-and-your-ide
+
+{{% /tab %}}
+{{% tab "Análisis de código" %}}
+
+En **Análisis de código**, puedes ver los enlaces desde los Análisis estáticos y los Análisis de composición del software fallidos hasta su repositorio de fuentes.
+
+1. Ve a [**Entrega de software** > **Visibilidad de los tests** > **Análisis de código**][101] y selecciona un repositorio.
+2. En **Vulnerabilidades del código** o **Calidad del código**, haz clic en una vulnerabilidad o violación del código. En la sección **Detalles**, haz clic en el botón **View Code** (Ver código) para abrir el código marcado en su repositorio de código fuente.
+
+{{< img src="integrations/guide/source_code_integration/code-analysis-scan.png" alt="Enlace a GitHub desde la vista de Vulnerabilidades del código en Análisis del código" style="width:100%;">}}
+
+Para obtener más información, consulta la [documentación de Análisis del código][102].
+
+[101]: https://app.datadoghq.com/ci/code-analysis
+[102]: /es/code_analysis/
+
+{{% /tab %}}
+{{% tab "Application Security Monitoring" %}}
+
+En **Application Security Monitoring**, puedes ver los enlaces de errores en tus trazas de stack tecnológico asociadas a señales de seguridad, hasta su repositorio fuente.
+
+1. Ve a [**Seguridad** > **Seguridad de la aplicación**][101] y selecciona una señal de seguridad.
+2. Desplázate hasta la sección **Trazas**, en la pestaña **Señales relacionadas**, y haz clic en una traza de stack tecnológico asociada.
+3. Haz clic en **View Code** (Ver código) para abrir el error en su repositorio de código fuente.
+
+Si utilizas la integración GitHub, haz clic en **Connect to preview** (Conectar para previsualizar) en los cuadros de error. Puedes ver fragmentos de código en línea directamente en la traza de stack tecnológico de la señal de seguridad.
+
+{{< img src="integrations/guide/source_code_integration/asm-signal-trace-blur.png" alt="Enlace a GitHub desde Application Security Monitoring" style="width:100%;">}}
+
+[101]: https://app.datadoghq.com/security/appsec
+
+{{% /tab %}}
+{{< /tabs >}}
+
+## Referencias adicionales
+
+{{< partial name="whats-next/whats-next.html" >}}
+
+[1]: https://app.datadoghq.com/apm/error-tracking
+[2]: https://app.datadoghq.com/integrations/github/
+[3]: https://docs.github.com/en/developers/apps/getting-started-with-apps/about-apps
+[5]: /es/integrations/github/
+[6]: /es/tracing/
+[7]: https://app.datadoghq.com/source-code/setup/apm
+[8]: /es/tracing/error_tracking/
+[9]: /es/tracing/trace_collection/dd_libraries/
\ No newline at end of file
diff --git a/content/es/logs/guide/detect-unparsed-logs.md b/content/es/logs/guide/detect-unparsed-logs.md
index 3631bdef92674..701d2d0285023 100644
--- a/content/es/logs/guide/detect-unparsed-logs.md
+++ b/content/es/logs/guide/detect-unparsed-logs.md
@@ -6,7 +6,6 @@ further_reading:
- link: /logs/faq/log-parsing-best-practice
tag: Documentación
text: Prácticas recomendadas para el análisis de logs
-kind: Guía
title: Monitorizar y consultar logs sin analizar
---
diff --git a/content/es/logs/guide/getting-started-lwl.md b/content/es/logs/guide/getting-started-lwl.md
index a3c56c2f363f4..1c5d4413ab47e 100644
--- a/content/es/logs/guide/getting-started-lwl.md
+++ b/content/es/logs/guide/getting-started-lwl.md
@@ -15,23 +15,22 @@ further_reading:
- link: /logs/logs_to_metrics/
tag: Documentación
text: Aprender a generar métricas a partir de logs consumidos
-kind: Guía
-title: Guía Logging Without LimitsTM
+title: Guía de Logging Without LimitsTM
---
{{< img src="logs/lwl_marketecture_20231030.png" alt="Logging without LimitsTM" >}}
## Información general
-Las aplicaciones basadas en la nube pueden generar logs a un ritmo de millones por minuto. Pero como tus logs no son todos igual de valiosos en todo momento, Datadog [Logging without LimitsTM][1] proporciona flexibilidad desacoplando [consumo e indexado de logs][2].
+Las aplicaciones basadas en la nube pueden generar logs a un ritmo de millones por minuto. Pero como tus logs no son todos igualmente valiosos en todo momento, Datadog [Logging without LimitsTM][1] proporciona flexibilidad, desacoplando [consumo e indexado de logs][2].
Esta guía identifica componentes clave de Logging Without LimitsTM como [patrones](#2-identify-high-volume-logging-patterns), [filtros de exclusión](#3-create-a-log-pattern-exclusion-filter), [métricas basadas en logs](#4-generate-metrics-to-track-excluded-logs) y [monitores](#create-an-anomaly-detection-monitor) que pueden ayudar a organizar mejor el Explorador de logs y monitorizar tus KPI a lo largo del tiempo.
## 1. Identificar tu estado de servicio con más logs
-Tu estado de servicio con más logs contiene varios logs, algunos de los cuales pueden ser irrelevantes para solucionar problemas. Por ejemplo, es posible que quieras investigar todos los logs de códigos de respuesta 4xx y 5xx, pero excluir todos los logs de códigos de respuesta 200 del Explorador de logs, para agilizar la resolución de problemas durante una interrupción importante o un evento. Si primero identificas el estado del servicio correspondiente, podrás averiguar rápidamente qué estado de servicio genera más logs y es mejor excluir de la [vista del Explorador de logs][3].
+Tu estado de servicio con más logs contiene varios logs, algunos de los cuales pueden ser irrelevantes para la resolución de problemas. Por ejemplo, es posible que quieras investigar todos los logs de códigos de respuesta 4xx y 5xx, pero excluir todos los logs de códigos de respuesta 200 del Explorador de logs, para agilizar la resolución de problemas durante una interrupción importante o un evento. Si primero identificas el estado de servicio correspondiente, podrás averiguar rápidamente qué estado de servicio genera más logs y conviene excluir de la [vista del Explorador de logs][3].
-{{< img src="logs/guide/getting-started-lwl/identify_logging_service.mp4" alt="Identifica un estado de servicio con más logs" video=true style="width:100%;">}}
+{{< img src="logs/guide/getting-started-lwl/identify_logging_service.mp4" alt="Identificar un estado de servicio con más logs" video=true style="width:100%;">}}
**Para identificar tu estado de servicio con más logs**:
@@ -39,22 +38,22 @@ Tu estado de servicio con más logs contiene varios logs, algunos de los cuales
2. Debajo de la barra de búsqueda, configura el grupo `*` de recuento por `service` y limítalo a `top 10`.
3. Selecciona **Top List** (Lista principal), en el menú desplegable situado junto a Hide controls (Ocultar controles).
4. Haz clic en el primer servicio de la lista y selecciona **Search for** (Buscar), en el menú desplegable. Esto genera una búsqueda, visible en la barra de búsqueda de arriba, basada en tu faceta de servicio.
-5. Cambia de la agrupación por `service` a la agrupación por `status`. Esto genera una lista de estados principales de tus servicios.
+5. Cambia de la agrupación por `service` a la agrupación por `status`. Esto genera una lista de estados principales de tu servicio.
6. Haz clic en el primer estado de la lista y selecciona **Search for** (Buscar), en el menú desplegable. Esto añade tu faceta de estado a la búsqueda.
-**Nota**: Estos pasos pueden aplicarse a cualquier consulta de gestión de logs de gran volumen para generar una lista principal. Puedes agrupar por cualquier faceta, como `host` o `network.client.ip`, en lugar de `service` o `status`.
+**Nota**: Estos pasos pueden aplicarse a cualquier consulta de gestión de logs de gran volumen, para generar una lista principal. Puedes agrupar por cualquier faceta, como `host` o `network.client.ip`, en lugar de `service` o `status`.
## 2. Identificar patrones de gestión de logs de gran volumen
-Ahora que ya has identificado tu estado de servicio con más logs, cambia a la [vista de patrones][4], situada junto a la vista de gráficos en la parte superior izquierda del Explorador de logs, a fin de ver automáticamente los patrones de tus logs para el contexto seleccionado.
+Ahora que ya has identificado tu estado de servicio con más logs, cambia a la [vista de patrones][4], situada junto a la vista de gráficos en la parte superior izquierda del Explorador de logs, a fin de ver automáticamente tus patrones de logs para el contexto seleccionado.
-Un contexto se compone de un intervalo de tiempo y una consulta de búsqueda. Cada patrón viene con secciones resaltadas para llevarte directamente a sus funciones características. Un minigráfico muestra una cronología aproximada del volumen de sus logs para ayudarte a identificar en qué se diferencia ese patrón de otros. Las secciones de logs que varían dentro del patrón se resaltan para ayudarte a identificar rápidamente las diferencias entre las líneas de logs.
+Un contexto se compone de un intervalo de tiempo y una consulta de búsqueda. Cada patrón viene con secciones resaltadas para llevarte directamente a sus funciones características. Un minigráfico muestra una cronología aproximada del volumen de sus logs para ayudarte a identificar en qué se diferencia ese patrón de otros. Las secciones de logs que varían dentro del patrón se resaltan para ayudarte a identificar rápidamente las diferencias entre líneas de logs.
-Haz clic en el patrón del log que quieres excluir, para ver un ejemplo de logs subyacentes.
+Haz clic en el patrón de log que quieres excluir, para ver un ejemplo de logs subyacentes.
{{< img src="logs/guide/getting-started-lwl/patterns_context_panel.jpg" alt="Contexto de los patrones" style="width:100%;">}}
-La vista de patrones es útil para identificar y filtrar patrones ruidosos. Muestra el número de logs que coinciden con un patrón, divididos por servicio y estado. Haz clic en el primer patrón para ver un log detallado de eventos relacionados con tu estado. Un panel contextual se rellena con información sobre el patrón de tu estado más ruidoso.
+La vista de patrones es útil para identificar y filtrar patrones ruidosos. Muestra el número de logs que coinciden con un patrón, divididos por servicio y estado. Haz clic en el primer patrón para ver un log detallado con los eventos relacionados con tu estado. Un panel contextual se rellena con información sobre el patrón de tu estado más ruidoso.
## 3. Crear un filtro de exclusión de patrones de logs
@@ -71,37 +70,37 @@ El panel contextual de patrones enumera todas las instancias (eventos) de un pat
**Nota**: Si un log coincide con varios filtros de exclusión, sólo se aplica la regla del primer filtro de exclusión. Un log no es muestreado o excluido varias veces por diferentes filtros de exclusión.
-En este ejemplo, el servicio `email-api-py` con el estado `INFO` y el patrón `response code from ses 200` se filtra con un filtro de exclusión. La eliminación de cualquier patrón de gestión de logs de gran volumen similar a este del Explorador de logs te ayuda a reducir el ruido y a identificar problemas más rápidamente. Sin embargo, estos logs **sólo** son excluidos de la indexación. Se siguen consumiendo y están disponibles para su visualización en [Live Tail][5] y pueden enviarse a [archivos de logs][6] o utilizarse para [generar métricas][7].
+En este ejemplo, el servicio `email-api-py` con el estado `INFO` y el patrón `response code from ses 200` se filtra utilizando un filtro de exclusión. La eliminación de cualquier patrón de gestión de logs de gran volumen similar al del Explorador de logs te ayuda a reducir el ruido e identificar problemas más rápidamente. Sin embargo, estos logs **sólo** se excluyen de la indexación, ya que se siguen consumiendo, están disponibles para su visualización en [Live Tail][5] y pueden enviarse a [archivos de logs][6] o utilizarse para [generar métricas][7].
{{< img src="logs/guide/getting-started-lwl/live_tail.png" alt="Página de Live Tail que muestra una lista de logs y el menú desplegable del intervalo de tiempo" style="width:100%;">}}
-Los filtros de exclusión pueden deshabilitarse en cualquier momento, cambiando la opción de deshabilitación situada a la derecha del filtro. También pueden modificarse y eliminarse, situándose sobre el filtro y seleccionando la opción para editar o eliminar.
+Los filtros de exclusión pueden deshabilitarse en cualquier momento, cambiando la opción de deshabilitación situada a la derecha del filtro. También pueden modificarse y eliminarse, situándose sobre el filtro y seleccionando la opción para editarlos o eliminarlos.
## 4. Generar métricas para realizar un seguimiento de logs excluidos
-Una vez que un patrón de logs se excluye del Explorador de logs, puedes seguir realizando un seguimiento de los KPI a lo largo del tiempo, en el nivel de consumo, mediante la creación de una nueva [métrica personalizada basada en logs][8].
+Una vez que un patrón de log se excluye del Explorador de logs, puedes seguir realizando un seguimiento de los KPI a lo largo del tiempo, en el nivel de consumo, creando una nueva [métrica personalizada basada en logs][8].
### Añadir una nueva métrica basada en logs
-**Para generar una nueva métrica basada en logs en tu patrón de logs**:
+**Para generar una nueva métrica basada en logs en tu patrón de log**:
1. Ve a la página [Generar métricas][9].
1. Haz clic en **New Metric** (Nueva métrica), en la esquina superior derecha.
-1. Introduce un nombre para tu métrica. loguear Los nombres de métricas basadas en logs deben seguir la convención de nomenclatura para métricas.
+1. Introduce un nombre para tu métrica. Los nombres de métricas basadas en logs deben seguir la convención de nomenclatura para métricas.
1. En **Define Query** (Definir consulta), introduce la consulta de búsqueda que has copiado y pegado en el filtro de exclusión de patrones. Por ejemplo: `service:web-store status:info "updating recommendations with customer_id" "url shops"`, como en el ejemplo anterior.
-1. Selecciona el campo del que quieres realizar un seguimiento: selecciona `*` para generar un recuento de todos los logs que coinciden con tu consulta o introduce una medida (por ejemplo, `@duration`) para agregar un valor numérico y crear su correspondiente recuento, mínimo, máximo, suma y media de métricas agregadas.
-1. Añade dimensiones al grupo: selecciona atributos de logs o claves de etiqueta (tag) para aplicarlos a las métricas basadas en logs para transformarlos en etiquetas siguiendo el formato de `:`. Las métricas basadas en logs se consideran métricas personalizadas. Evita agrupar por atributos no limitados o de cardinalidad extremadamente alta como marcas de tiempo, ID de usuario, ID de solicitud o ID de sesión, para evitar un impacto negativo en tu facturación.
+1. Selecciona el campo del que quieres realizar un seguimiento: selecciona `*` para generar un recuento de todos los logs que coinciden con tu consulta o introduce una medida (por ejemplo, `@duration`) para agregar un valor numérico y crear sus correspondientes métricas agregadas de recuento, mínimo, máximo, suma y promedio.
+1. Añade dimensiones al grupo: selecciona atributos de logs o claves de etiqueta (tag) para aplicarlos a las métricas basadas en logs y así transformarlos en etiquetas que sigan el formato de `:`. Las métricas basadas en logs se consideran métricas personalizadas. Evita agrupar por atributos no limitados o de cardinalidad extremadamente alta como marcas de tiempo, ID de usuario, ID de solicitud o ID de sesión, para evitar un impacto negativo en tu facturación.
### Crear un monitor de detección de anomalías
-La [detección de anomalías][10] es una función algorítmica que identifica cuándo una métrica se comporta de forma diferente a como lo ha hecho en el pasado. La creación de un monitor de detección de anomalías para tus logs excluidos te avisa de cualquier cambio según tus condiciones de alerta configuradas.
+La [detección de anomalías][10] es una función algorítmica que identifica cuando una métrica se comporta de forma diferente a como lo ha hecho en el pasado. La creación de un monitor de detección de anomalías para tus logs excluidos te avisa de cualquier cambio, dependiendo de tus condiciones de alerta configuradas.
**Para configurar un monitor de detección de anomalías**:
1. Ve a la página [Nuevo Monitor][11].
1. Selecciona **Anomaly* (Anomalía).
1. Introduce la métrica basada en logs definida en la sección anterior.
-1. Configura las condiciones de alerta y añade la información adicional necesaria para que tú o tu equipo sepan qué está ocurriendo.
+1. Configura las condiciones de alerta y añade la información adicional necesaria para que tú o tu equipo reciban alertas y puedan saber lo que está ocurriendo.
1. Haz clic en **Create** (Crear).
Cuando se detecta una anomalía, se envía una alerta a todos los que están etiquetados. Esta alerta también se puede encontrar en la página de [monitores activados][12].
@@ -112,12 +111,12 @@ En esta guía has aprendido a utilizar Logging without LimitsTM para:
1. [Identificar tu estado de servicio con más logs](#1-identify-your-most-logged-service-status)
2. [Identificar patrones de gestión de logs de gran volumen](#2-identify-high-volume-logging-patterns)
-3. [Crear un filtro de exclusión de patrones de logs](#3-create-a-log-pattern-exclusion-filter)
+3. [Crear un filtro de exclusión de patrones de log](#3-create-a-log-pattern-exclusion-filter)
4. [Generar métricas para realizar un seguimiento de logs excluidos](#4-generate-metrics-to-track-excluded-logs)
* [Añadir una nueva métrica basada en logs](#add-a-new-log-based-metric)
* [Crear un monitor de detección de anomalías](#create-an-anomaly-detection-monitor)
-Para obtener más información sobre Logging Without LimitsTM y cómo utilizar mejor algunas funciones como el Explorador de logs, Live Tail y los patrones de logs, consulta los siguientes enlaces.
+Para obtener más información sobre Logging Without LimitsTM y cómo utilizar mejor algunas funciones como el Explorador de logs, Live Tail y los patrones de log, consulta los siguientes enlaces.
## Leer más
diff --git a/content/es/monitors/guide/create-cluster-alert.md b/content/es/monitors/guide/create-cluster-alert.md
index cce149def9f2d..567e90cdff046 100644
--- a/content/es/monitors/guide/create-cluster-alert.md
+++ b/content/es/monitors/guide/create-cluster-alert.md
@@ -31,6 +31,6 @@ En este ejemplo, quieres recibir una notificación cuando el 40 por ciento de lo
Este monitor rastrea el porcentaje de hosts que han tenido un uso de CPU superior al 50 por ciento durante los últimos diez minutos y genera un notificación si más del 40 por ciento de esos hosts cumplen la condición especificada.
-{{< img src="monitors/faq/cluster-status.png" alt="cluster-alert-status" >}}
+## Referencias adicionales
{{< partial name="whats-next/whats-next.html" >}}
\ No newline at end of file
diff --git a/content/es/monitors/guide/monitor-arithmetic-and-sparse-metrics.md b/content/es/monitors/guide/monitor-arithmetic-and-sparse-metrics.md
index 7b95fff17b945..6fcc259a9e636 100644
--- a/content/es/monitors/guide/monitor-arithmetic-and-sparse-metrics.md
+++ b/content/es/monitors/guide/monitor-arithmetic-and-sparse-metrics.md
@@ -53,7 +53,7 @@ Se verían sobre todo evaluaciones "omitidas".
| Ruta | Evaluación | Resultado |
|:--------------------|:----------------------------------------|:-------|
-| `classic_eval_path` | **1/Nan + Nan/1 + ... + 1/Nan + Nan/1** | N/D |
+| `classic_eval_path` | **1/Nan + Nan/1 + ... + 1/Nan + Nan/1** | N/A |
Ajustando la interpolación, puedes asegurarte que haya métricas en cada intervalo de tiempo.
diff --git a/content/es/monitors/guide/non_static_thresholds.md b/content/es/monitors/guide/non_static_thresholds.md
index a7bf460bed117..7ea0e96cf7fec 100644
--- a/content/es/monitors/guide/non_static_thresholds.md
+++ b/content/es/monitors/guide/non_static_thresholds.md
@@ -6,7 +6,6 @@ further_reading:
- link: /monitors/types/anomaly/
tag: Documentación
text: Monitor de anomalías
-kind: Guía
title: Cómo monitorizar umbrales no estáticos
---
@@ -14,7 +13,7 @@ title: Cómo monitorizar umbrales no estáticos
Un monitor de métricas típico activa una alerta si una única métrica supera un umbral específico. Por ejemplo, puedes configurar una alerta para que se active si el uso del disco supera el 80%. Este enfoque es eficiente para muchos casos de uso, pero ¿qué ocurre cuando el umbral es una variable en lugar de un número absoluto?
-Los monitores con la tecnología Watchdog (a saber, de [anomalías][1] y [outliers][2]) son particularmente útiles cuando no hay una definición explícita de que tu métrica está desviada. Sin embargo, cuando sea posible, deberías utilizar monitores normales con condiciones de alerta adaptadas para maximizar la precisión y minimizar el tiempo de alerta para tu caso de uso específico.
+Los monitores con la tecnología Watchdog (a saber, de [anomalías][1] y [outliers][2]) son particularmente útiles cuando no hay una indicación explícita de que tu métrica se encuentra desviada. Sin embargo, cuando sea posible, deberías utilizar monitores normales con condiciones de alerta adaptadas para maximizar la precisión y minimizar el tiempo de alerta para tu caso de uso específico.
Esta guía cubre casos de uso comunes de alertas sobre umbrales no estáticos:
- [Alerta sobre una métrica que se desvía, fuera de las **variaciones temporarias**](#seasonal-threshold)
@@ -24,18 +23,18 @@ Esta guía cubre casos de uso comunes de alertas sobre umbrales no estáticos:
### Contexto
-Eres responsable de un equipo encargado de un sitio web de comercio electrónico y quieres:
+Eres responsable del equipo encargado de un sitio web de comercio electrónico y quieres:
- recibir alertas de tráfico inesperadamente bajo en tu página de inicio
- captar incidentes más localizados como los que afectan a los proveedores públicos de Internet
- anticipar situaciones de fallo desconocidas
El tráfico de tu sitio web varía de la noche al día y de los días laborables a los fines de semana. No existe un número absoluto para cuantificar lo que significa "inesperadamente bajo". Sin embargo, el tráfico sigue un patrón predecible en el que puedes considerar una diferencia del 10% como un indicador fiable de un problema, como por ejemplo un incidente localizado que afecta a los proveedores de Internet pública.
-{{< img src="monitors/guide/non_static_thresholds/seasonal_line_graph.png" alt="Line graph of a periodic or seasonal metric" (Gráfico de líneas de una métrica periódica o temporaria) style="width:100%;" >}}
+{{< img src="monitors/guide/non_static_thresholds/seasonal_line_graph.png" alt="Gráfico de líneas de una métrica periódica o temporaria" style="width:100%;" >}}
### Monitor
-Tu equipo mide el número de conexiones en su servidor web NGINX utilizando la métrica [`nginx.requests.total_count`][3].
+Tu equipo mide el número de conexiones en tu servidor web NGINX utilizando la métrica [`nginx.requests.total_count`][3].
La **solicitud** consta de 3 partes:
1. Una consulta para obtener el número actual de solicitudes.
@@ -43,14 +42,14 @@ La **solicitud** consta de 3 partes:
3. Consultas "fórmula" que calculan la relación entre las dos primeras consultas.
A continuación, define la agregación temporal:
-- Eliges el marco temporal. Cuanto mayor sea el marco temporal, más datos se evaluarán para detectar una anomalía. Los marcos temporales más amplios también pueden dar lugar a más alertas de monitores, así que empieza con 1 hora y luego ajusta el marco temporal a tus necesidades.
-- Eliges la agregación. Dado que se trata de una métrica de recuento que realiza un cociente, `average` (o `sum`) es una elección natural.
+- Elige el marco temporal. Cuanto mayor sea el marco temporal, más datos se evaluarán para detectar una anomalía. Los marcos temporales más amplios también pueden dar lugar a más alertas de monitores, así que empieza con 1 hora y luego ajusta el marco temporal según tus necesidades.
+- Elige la agregación. Dado que se trata de una métrica de recuento que ejecuta una proporción, `average` (o `sum`) es una elección natural.
El umbral que aparece en la siguiente captura de pantalla se ha configurado en 0,9 para permitir una diferencia del 10% entre el valor de la primera consulta (actual) y el de la segunda (semana anterior).
{{< tabs >}}
-{{% tab "UI Configuration" %}}
-{{< img src="monitors/guide/non_static_thresholds/seasonal_threshold_config.png" alt="Configuration to add week_before timeshift to metric query and set formula a/b" Configuración para añadir la serie temporal _semana_anterior_ a la consulta de la métrica y establecer la fórmula a/b) style="width:100%;" >}}
+{{% tab "Configuración de la interfaz de usuario" %}}
+{{< img src="monitors/guide/non_static_thresholds/seasonal_threshold_config.png" alt="Configuración para añadir la serie temporal _semana_anterior_ a la consulta de la métrica y establecer la fórmula a/b" style="width:100%;" >}}
{{% /tab %}}
{{% tab "JSON Example" (Ejemplo de JSON) %}}
@@ -83,26 +82,26 @@ El umbral que aparece en la siguiente captura de pantalla se ha configurado en 0
## Umbral de referencia
### Contexto
-Eres responsable del equipo de control de calidad encargado de los procesos de compra en tu sitio web de comercio electrónico. Quieres asegurarte de que tus clientes tendrán una buena experiencia y podrán comprar tus productos sin problemas. Un indicador de ello es la tasa de errores.
+Eres responsable del equipo de control de calidad encargado de los procesos de compra en tu sitio web de comercio electrónico. Quieres asegurarte de que tus clientes tengan una buena experiencia y puedan comprar tus productos sin problemas. Un indicador de esto es la tasa de error.
-El tráfico no es el mismo a lo largo del día, por lo que obtener 50 errores/minuto un viernes por la tarde es menos preocupante que obtener 50 errores/minuto un domingo por la mañana. Monitorizar la tasa de errores, más que los errores en sí, ofrece una visión fiable de la apariencia de las métricas saludables y las no saludables.
+El tráfico no es el mismo a lo largo del día, por lo que obtener 50 errores/minuto un viernes por la tarde es menos preocupante que obtener 50 errores/minuto un domingo por la mañana. Monitorizar la tasa de error, más que los errores en sí, ofrece una visión fiable de la apariencia que tienen las métricas saludables y las no saludables.
-Recibe alertas cuando la tasa de errores es alta, pero también cuando el volumen de ocurrencias es lo suficientemente significativo.
+Recibe alertas cuando la tasa de error es alta, pero también cuando el volumen de ocurrencias es suficientemente significativo.
### Monitor
Crea 3 monitores en total:
1. Un [monitor de métricas para alertar sobre el número total de ocurrencias.](#metric-monitor-to-alert-on-the-total-number-of-hits)
-1. Un [monitor de métricas para calcular el porcentaje de error.](#metric-monitor-to-calculate-the-error-rate)
+1. Un [monitor de métricas para calcular la tasa de error.](#metric-monitor-to-calculate-the-error-rate)
1. Un [monitor compuesto que activa una alerta si los dos primeros monitores están en estado de ALERTA.](#composite-monitor)
#### Monitor de métricas para alertar sobre el número total de ocurrencias
-El primer monitor registra el número total de ocurrencias, tanto de aciertos como de fallos. Este monitor determina si la tasa de errores debe activar una alerta.
+El primer monitor registra el número total de ocurrencias, tanto de aciertos como de fallos. Este monitor determina si la tasa de error debe activar una alerta.
{{< tabs >}}
-{{% tab "UI Configuration" %}}
- {{< img src="monitors/guide/non_static_thresholds/reference_total_hits.png" alt="Metric monitor configuration with formula to calculate total hits" (Configuración de un monitor de métricas que muestra la fórmula para calcular el total de ocurrencias) style="width:100%;" >}}
+{{% tab "Configuración de la interfaz de usuario" %}}
+ {{< img src="Configuración de un monitor de métricas que muestra la fórmula para calcular el total de ocurrencias" style="width:100%;" >}}
{{% /tab %}}
@@ -131,13 +130,13 @@ El primer monitor registra el número total de ocurrencias, tanto de aciertos co
{{% /tab %}}
{{< /tabs >}}
-#### Monitor de métricas para calcular el porcentaje de error
+#### Monitor de métricas para calcular la tasa de error
El segundo monitor calcula la tasa de error. Crea una consulta sobre el número de errores dividido por el número total de ocurrencias para obtener la tasa de error `a / a+b`:
{{< tabs >}}
-{{% tab "UI Configuration" %}}
- {{< img src="monitors/guide/non_static_thresholds/reference_error_rate.png" alt="Metric monitor configuration with formula to calculate error rate" (Configuración de un monitor de métricas que muestra la fórmula para calcular la tasa de error) style="width:100%;" >}}
+{{% tab "Configuración de la interfaz de usuario" %}}
+ {{< img src="monitors/guide/non_static_thresholds/reference_error_rate.png" alt="Configuración de un monitor de métricas que muestra la fórmula para calcular la tasa de error" style="width:100%;" >}}
{{% /tab %}}
{{% tab "JSON Example" (Ejemplo de JSON) %}}
@@ -169,11 +168,11 @@ El segundo monitor calcula la tasa de error. Crea una consulta sobre el número
#### Monitor compuesto
-El último monitor es un monitor compuesto que envía una alerta sólo si los dos monitores anteriores también están en estado de **ALERTA**.
+El último monitor es un monitor compuesto que envía alertas sólo si los dos monitores anteriores también están en estado de **ALERTA**.
-{{< img src="monitors/guide/non_static_thresholds/reference_composite_monitor_config.png" alt="Example composite monitor configuration showing boolean logic to alert if both monitors are in ALERT state" (Ejemplo de configuración de un monitor compuesto que muestra una lógica booleana para alertar si los dos monitores están en estado de ALERTA) style="width:100%;" >}}
+{{< img src="monitors/guide/non_static_thresholds/reference_composite_monitor_config.png" alt="Ejemplo de configuración de un monitor compuesto que muestra una lógica booleana para alertar cuando los dos monitores están en estado de ALERTA" style="width:100%;" >}}
-## Leer más
+## Lectura adicional
{{< partial name="whats-next/whats-next.html" >}}
diff --git a/content/es/monitors/guide/scoping_downtimes.md b/content/es/monitors/guide/scoping_downtimes.md
index b0830ec1e7a34..fb0025ec9200d 100644
--- a/content/es/monitors/guide/scoping_downtimes.md
+++ b/content/es/monitors/guide/scoping_downtimes.md
@@ -11,23 +11,22 @@ further_reading:
tag: Guía
text: Suprimir alertas a través de la API de tiempos de inactividad y la interfaz
de usuario
-kind: Guía
-title: Delimitación del tiempo de inactividad
+title: Delimitación de los tiempos de inactividad
---
## Información general
-Los tiempos de inactividad se programan para cierres del sistema, mantenimientos fuera de línea o actualizaciones sin activar tus monitores. Los tiempos de inactividad silencian todas las alertas y notificaciones de monitor, pero no impiden las transiciones de estado de los monitores.
+Los tiempos de inactividad se programan para cierres del sistema, mantenimientos fuera de línea o actualizaciones sin activar tus monitores. Los tiempos de inactividad silencian todas las alertas y notificaciones de monitores, pero no impiden las transiciones de estado de los monitores.
-En la mayoría de los casos, no querrás silenciar completamente **todas** las notificaciones de monitores debido al riesgo de perder importantes alertas que no estén relacionadas con ningún mantenimiento programado.
+En la mayoría de los casos, no querrás silenciar completamente **todas** las notificaciones de monitores, ya que correrías el riesgo de perder importantes alertas que no están relacionadas con ningún mantenimiento programado.
-Esta guía muestra cómo delimitar adecuadamente los tiempos de Inactividad a través de la interfaz de usuario para la delimitación de los tiempos de Inactividad en un proceso de dos pasos:
+Esta guía muestra cómo delimitar adecuadamente los tiempos de inactividad a través de la interfaz de usuario para la delimitación de los tiempos de inactividad en un proceso de dos pasos:
1. [Selecciona el o los monitores en el/los que quieres aplicar el tiempo de inactividad.](#choose-which-monitors-to-silence)
2. [Delimita la consulta para filtrar las notificaciones _exactas_ que quieres silenciar en cada uno de los monitores.](#granularly-scope-downtimes)
-## Elige qué monitors silenciar
+## Elige qué monitores silenciar
-Define a qué monitores quieres asignar el tiempo de inactividad. Hay tres opciones diferentes: asignarlo a un monitor específico, a varios monitores o a todos los monitores.
+Define a qué monitores quieres asignar los tiempos de inactividad. Hay tres opciones diferentes: asignarlos a un monitor específico, a varios monitores o a todos los monitores.
### Seleccionar un monitor específico
@@ -35,34 +34,32 @@ Puedes optar por silenciar temporalmente un monitor específico. Por ejemplo, si
En la configuración del tiempo de inactividad, selecciona **Por nombre de monitor** y busca el monitor deseado.
-### Seleccionar múltiples monitores en función de las etiquetas (tags) de monitor
+### Seleccionar varios monitores en función de las etiquetas (tags) de monitor
-Las etiquetas de monitor son independientes de las etiquetas enviadas por el Agent o por integraciones y de las etiquetas asignadas a los datos que estás consultando.
+Las etiquetas de monitor son independientes de las etiquetas enviadas por el Agent o por las integraciones y de las etiquetas asignadas a los datos que estás consultando.
-Los tiempos de inactividad en monitores pueden programarse en función de tus etiquetas de monitor y luego delimitarse mediante las etiquetas agrupadas en la consulta del monitor. Selecciona `By monitor Tags` e introduce las etiquetas del monitor que quieres seleccionar.
+Los tiempos de inactividad en monitores pueden programarse en función de tus etiquetas de monitor y luego delimitarse mediante las etiquetas agrupadas en la consulta del monitor. Selecciona `By Monitor Tags` e introduce las etiquetas del monitor que quieres seleccionar.
**Nota**: Las etiquetas son aditivas, lo que significa que una entrada de `env:dev team:automations` se asignará a monitores que tengan **ambas** etiquetas: `env:dev` Y `team:automations`.
### Seleccionar todos los monitores
-Para ambas opciones, `By monitor Name` o `By monitor Tags`, puedes optar por asignarlas a todos los monitores seleccionando el primer elemento del menú desplegable etiquetado como `All monitors`.
+Para ambas opciones, `By Monitor Name` o `By Monitor Tags`, puedes optar por asignarlas a todos los monitores seleccionando el primer elemento del menú desplegable etiquetado como `All Monitors`.
-## Delimitar tiempos de inactividad de forma granular
+## Delimitar tiempos de inactividad de forma específica
-Utiliza el contexto de grupo para aplicar filtros adicionales a tu tiempo de inactividad y tener un control granular sobre los monitores que quieres silenciar. El contexto de grupo de un tiempo de inactividad se empareja **con** el objetivo específico del monitor. Si seleccionas varios monitores utilizando etiquetas de monitor, primero tendrás que buscar los monitores etiquetados en consecuencia antes del emparejamiento con el contexto de grupo.
+Utiliza el contexto de grupo para aplicar filtros adicionales a tu tiempo de inactividad y tener un control específico sobre los monitores que quieres silenciar. El contexto de grupo de un tiempo de inactividad se empareja **con** el objetivo específico del monitor. Si seleccionas varios monitores utilizando etiquetas de monitor, primero tendrás que buscar los monitores etiquetados en consecuencia antes del emparejamiento con el contexto de grupo.
Los ejemplos de esta guía muestran cómo el `Group scope` puede aplicarse a monitores en los que está configurada la [agrupación de alertas múltiples][2].
### Silenciar monitores con una etiqueta específica
1. Para programar un tiempo de inactividad en un solo grupo (en este caso, `service:web-store`), introduce ese grupo en el campo `Group scope`.
-2. Haz clic en **Preview affected monitors** (Previsualizar monitores afectados) para comprobar que el monitor elegido sigue en el contexto, para que las alertas del grupo `service:web-store` se silencien durante el tiempo de inactividad programado.
+2. Haz clic en **Preview affected monitors** (Previsualizar monitores afectados) para comprobar que el monitor elegido sigue en el contexto, a fin de que las alertas del grupo `service:web-store` se silencien durante el tiempo de inactividad programado.
-{{< img src="monitors/downtimes/downtime_example_byname.png" alt="Downtime example of 'By Monitor Name' with preview of affected monitors" (Ejemplo de tiempo de inactividad "Por nombre de monitor" que muestra la vista previa de los monitores afectados) style="width:90%;">}}
+{{< img src="monitors/downtimes/downtime_example_byname.png" alt="Ejemplo de tiempo de inactividad "Por nombre de monitor" que muestra la vista previa de los monitores afectados" style="width:90%;">}}
-Una vez que se inicia el tiempo de inactividad programado, sólo se silencian las alertas del grupo `service:web-store` de este monitor.
-
-{{< img src="monitors/downtimes/downtime_examplebyname1_monitor.png" alt="Evaluation graph showing downtime for group service:web-store" (Gráfico de evaluación que muestra el tiempo de inactividad del grupo service:web-store) style="width:90%;">}}
+Una vez que se inicia el tiempo de inactividad programado, sólo se silencian las alertas del grupo `service:web-store` de ese monitor.
Esto silencia cualquier alerta que incluya la etiqueta `service:web-store`, por ejemplo:
@@ -77,7 +74,7 @@ Esto silencia cualquier alerta que incluya la etiqueta `service:web-store`, por
1. Para programar un tiempo de inactividad en varios grupos (por ejemplo, `service:web-store` y `env:prod`), introduce ese grupo en el campo `Group scope`.
2. Haz clic en **Preview affected monitors** (Previsualizar monitores afectados) para verificar los monitores que se encuentran en el contexto.
-3. Una vez que se inicia el tiempo de inactividad programado, las alertas se silencian para el grupo:
+3. Una vez que se inicia el tiempo de inactividad programado, se silencian las alertas del grupo:
`env:prod` **Y** `service:web-store`
| Grupo de monitores | Silenciado |
@@ -104,33 +101,29 @@ Consulta `env:(dev OR staging)`
### Silenciar monitores mediante contextos con comodines
-La ejecución de importantes actualizaciones dentro de tu infraestructura no es poco frecuente. Los tiempos de inactividad pueden ayuda silenciar todas las entidades afectadas, sin demasiado scripting adicional. Por ejemplo, podrías estar actualizando todos los hosts de un determinado servicio. Estos hosts podrían seguir ciertas convenciones de nomenclatura de tu organización, como mostrar su aplicación relacionada como prefijo. Esto podría resultar en cientos de hosts con nombres como `host:mydemoapplication-host-1`y `host:mydemoapplication-host-2`.
+La ejecución de importantes actualizaciones dentro de tu infraestructura no es poco frecuente. Los tiempos de inactividad pueden ayudar silenciar todas las entidades afectadas, sin demasiado scripting adicional. Por ejemplo, podrías estar actualizando todos los hosts de un determinado servicio. Estos hosts podrían seguir ciertas convenciones de nomenclatura de tu organización, como llevar los nombres de sus aplicaciones relacionadas como prefijo. Esto podría resultar en cientos de hosts con nombres como `host:mydemoapplication-host-1`y `host:mydemoapplication-host-2`.
Crea un tiempo de inactividad delimitado por `host:mydemoapplication-*`. Esto empareja y silencia todos los hosts que tienen el prefijo correspondiente. También puedes aplicar el método inverso, en el que el tiempo de inactividad está delimitado por `host:*-mydemoapplication`. Esto empareja y silencia todos los hosts que terminan con `mydemoapplication`.
### Excluir grupos para no silenciarlos
-Si estás ejecutando tu aplicación y tu infraestructura en varios entornos, probablemente tengas un entorno de producción y varios entornos de no producción (por ejemplo, de test, de regresión o de demostración). Para evitar recibir alertas de entornos de no producción, puedes configurar un tiempo de inactividad delimitado por: `env:* -env:prod`. Este contexto apunta a todas las alertas que tienen el conjunto de etiquetas `env` y luego excluye tu entorno de producción como un paso secundario.
+Si estás ejecutando tu aplicación y tu infraestructura en varios entornos, probablemente tengas un entorno de producción y varios entornos de no producción (por ejemplo, de test, de regresión o de demostración). Para evitar recibir alertas de entornos de no producción, puedes configurar un tiempo de inactividad delimitado por: `env:* -env:prod`. Este contexto agrupa todas las alertas que tienen el conjunto de etiquetas `env` y luego excluye tu entorno de producción como un paso secundario.
### Múltiples monitores delimitados con la misma etiqueta
-1. El *monitor A* es un monitor de alerta múltiple para hosts que informan de una métrica promediada entre múltiples grupos de `service`.
-2. El *monitor B* es un monitor de alerta múltiple para hosts que informan de la misma métrica para `service:web-store`.
-3. El tiempo de inactividad se programa para cualquier monitor que tiene la etiqueta de monitor `downtime:true`.
+1. El *monitor A* es un monitor de alerta múltiple para hosts que informan de una métrica promediada entre varios grupos de `service`.
+2. El *monitor B* es un monitor de alerta múltiple para hosts que informan sobre la misma métrica para `service:web-store`.
+3. El tiempo de inactividad se programa para cualquier monitor que tenga la etiqueta de monitor `downtime:true`.
4. Este tiempo de inactividad se limita al grupo `service:web-store`.
5. Haz clic en **Preview affected monitors** (Previsualizar monitores afectados) para verificar los monitores que están en el contexto. En este ejemplo se muestra que ambos monitores tienen el grupo `service:web-store` en el contexto.
-{{< img src="monitors/downtimes/downtime_examplebytag1_downtime.png" alt="downtime example of 'By Monitor Tags' with preview of affected monitors" (Ejemplo de tiempo de inactividad "Por etiquetas de monitor" que muestra la previsualización de los monitores afectados) style="width:80%;">}}
-
-6. El *monitor A* muestra que ha comenzado el tiempo de inactividad, pero sólo para el grupo en el contexto: `service:web-store`
-
-{{< img src="monitors/downtimes/downtime_examplebytag1_monitor.png" alt="Evaluation graph showing downtime for group service:web-store" (Gráfico de evaluación que muestra el tiempo de inactividad del grupo group service:web-store) style="width:80%;">}}
+{{< img src="monitors/downtimes/downtime_examplebytag1_downtime.png" alt="Ejemplo de tiempo de inactividad "Por etiquetas de monitor" que muestra la previsualización de los monitores afectados" style="width:80%;">}}
-7. El *monitor B* muestra que ha comenzado el tiempo de inactividad para `service:web-store`. Dado que todos los grupos de monitores (por `host`) pertenecen a `service:web-store`, el resultado es que todos los hosts están silenciados durante el tiempo de inactividad de este monitor.
+6. El *monitor A* muestra que se ha iniciado el tiempo de inactividad, pero sólo para el grupo en el contexto: `service:web-store`
-{{< img src="monitors/downtimes/downtime_examplebytag1_monitor2.png" alt="Evaluation graph showing downtime for group service:web-store and both affected hosts" (Gráfico de evaluación que muestra el tiempo de inactividad del grupo service:web-store y ambos hosts afectados) style="width:80%;">}}
+7. El *monitor B* muestra que se ha iniciado el tiempo de inactividad para `service:web-store`. Debido a que todos los grupos de monitores (por `host`) pertenecen a `service:web-store`, todos los hosts estarán silenciados durante el tiempo de inactividad de este monitor.
-## Leer más
+## Referencias adicionales
{{< partial name="whats-next/whats-next.html" >}}
diff --git a/content/es/monitors/types/ci.md b/content/es/monitors/types/ci.md
index 5d89dcefad5a6..213ee6cfb864c 100644
--- a/content/es/monitors/types/ci.md
+++ b/content/es/monitors/types/ci.md
@@ -25,7 +25,7 @@ title: Monitor CI
## Resumen
-Una vez que [CI Visibility está habilitado][1] para tu organización, puedes crear un pipeline CI o un monitor de tests CI.
+Una vez que [CI Visibility esté habilitado][1] para tu organización, podrás crear un pipeline CI o un monitor de tests CI.
Los monitores CI te permiten visualizar los datos de CI y configurar alertas sobre ellos. Por ejemplo, crea un monitor de pipelines CI para recibir alertas sobre un pipeline o una tarea que haya fallado. Crea un un monitor de tests CI para recibir alertas sobre tests fallidos o lentos.
@@ -43,31 +43,31 @@ Elige entre un monitor de **Pipelines** o **Tests**:
### Definir la consulta de búsqueda
1. Crea una consulta de búsqueda utilizando la misma lógica de una búsqueda del explorador de pipelines CI.
-2. Selecciona el nivel de evento de pipeline CI:
+2. Selecciona el nivel de eventos de pipelines CI:
* **Pipeline**: evalúa la ejecución de un pipeline completo, normalmente compuesto por una o varias tareas.
* **Stage** (Etapa): evalúa la ejecución de un grupo de una o varias tareas en los proveedores CI compatibles
* **Job** (Tarea): evalúa la ejecución de un grupo de comandos.
* **Command** (Comando): evalúa manualmente eventos de [comandos personalizados][1] instrumentados que son comandos individuales que se ejecutan en una tarea.
* **All** (Todo): evalúa todos los tipos de eventos.
3. Elige monitorizar un recuento de eventos de pipelines CI, una faceta o una medida:
- * **CI Pipeline event count** (Recuento de eventos de pipelines CI): utiliza la barra de búsqueda (opcional) y **no** selecciones una faceta o una medida. Datadog evalúa el número de eventos de pipeline CI, a lo largo de un periodo de tiempo seleccionado, y luego lo compara con las condiciones del umbral.
- * **Dimensión**: selecciona la dimensión (faceta cualitativa) para emitir alertas sobre el `Unique value count` de la faceta.
+ * **CI Pipeline event count** (Recuento de eventos de pipelines CI): utiliza la barra de búsqueda (opcional) y **no** selecciones una faceta o una medida. Datadog evalúa el número de eventos de pipelines CI, a lo largo de un periodo de tiempo seleccionado, y luego lo compara con las condiciones del umbral.
+ * **Dimensión** (Dimensión): selecciona la dimensión (faceta cualitativa) para emitir alertas sobre el `Unique value count` de la faceta.
* **Measure* (Medida): selecciona la medida (faceta cuantitativa) para emitir alertas sobre el valor numérico de la medida del pipeline CI (similar a un monitor de métricas). Selecciona la agregación (`min`, `avg`, `sum`, `median`, `pc75`, `pc90`, `pc95`, `pc98`, `pc99` o `max`).
-4. Agrupa los eventos de pipeline CI por múltiples dimensiones (opcional):
+4. Agrupa los eventos de pipelines CI por múltiples dimensiones (opcional):
* Todos los eventos de pipelines CI que coinciden con la consulta se agregan a grupos basados en el valor de hasta cuatro facetas.
5. Configura la estrategia de agrupación de alertas (opcional):
- * Si la consulta tiene un `group by`, las alertas múltiples aplican la alerta a cada origen, en función de tus parámetros de grupo. Se genera un evento de alerta para cada grupo que cumple las condiciones establecidas. Por ejemplo, podrías agrupar una consulta por `@ci.pipeline.name` para recibir una alerta separada para cada nombre de pipeline CI, cuando el número de errores es elevado.
+ * Si la consulta tiene un `group by`, las alertas múltiples aplican la alerta a cada origen, en función de tus parámetros de grupo. Se genera un evento de alerta para cada grupo que cumple las condiciones establecidas. Por ejemplo, podrías agrupar una consulta por `@ci.pipeline.name`, para recibir una alerta separada para cada nombre de pipeline CI cuando el número de errores es elevado.
-{{< img src="monitors/monitor_types/ci_pipelines/define-the-search-query.png" alt="Consulta de Status:Error de CI configurado para agruparse por nombre de test" style="width:100%;" >}}
+{{< img src="monitors/monitor_types/ci_pipelines/define-the-search-query.png" alt="Consulta de estado de error de CI configurado para agruparse por nombre de test" style="width:100%;" >}}
#### Mediante fórmulas y funciones
Se pueden crear monitores de pipelines CI utilizando fórmulas y funciones. Esto puede utilizarse, por ejemplo, para crear monitores de la **tasa** de ocurrencia de un evento, como por ejemplo la tasa de fallo de un pipeline (tasa de error).
-El siguiente ejemplo es un monitor de tasa de error de pipeline que utiliza una fórmula que calcula la proporción del "número de eventos de pipeline fallidos" (`ci.status=error`) sobre el "número de eventos de pipeline totales" (sin filtro), agrupados por `ci.pipeline.name` (para ser alertados una vez por cada pipeline). Para obtener más información, consulta [Información general en la sección Funciones][2].
+El siguiente ejemplo es un monitor de tasa de error de pipeline que utiliza una fórmula que calcula la proporción del "número de eventos de pipeline fallidos" (`ci.status=error`) sobre el "número de eventos de pipelines totales" (sin filtro), agrupados por `ci.pipeline.name` (para ser alertados una vez por cada pipeline). Para obtener más información, consulta [Información general en la sección Funciones][2].
{{< img src="monitors/monitor_types/ci_pipelines/define-the-Buscar-query-fnf.png" alt="Monitor definido a través de las etapas a, b, c, donde las etapas a, b son consultas y la etapa c calcula la tasa a partir de las dos etapas anteriores." style="width:1000%;" >}}
-Nota: Sólo se pueden utilizar hasta 2 consultas para crear la fórmula de evaluación por monitor.
+Nota: Sólo se pueden utilizar hasta 2 consultas por monitor para crear la fórmula de evaluación.
[1]: /es/continuous_integration/pipelines/custom_commands/
[2]: /es/dashboards/functions/#overview
@@ -76,18 +76,18 @@ El siguiente ejemplo es un monitor de tasa de error de pipeline que utiliza una
### Definir la consulta de búsqueda
-1. Tipos frecuentes de monitores (opcional): proporciona una plantilla de consulta para cada uno de los tipos frecuentes de monitores, **Nuevos tests defectuosos**, **Fallos en los tests** y **Rendimiento de los tests**, que luego puedes personalizar. Para obtener más información sobre esta característica, consulta [Realizar un seguimiento de nuevos tests defectuosos](#track-new-flaky-tests).
+1. Tipos frecuentes de monitores (opcional): Proporciona una plantilla de consulta para cada uno de los tipos frecuentes de monitores, **Nuevos tests defectuosos**, **Fallos en los tests** y **Rendimiento de los tests**, que luego puedes personalizar. Para obtener más información sobre esta característica, consulta [Realizar un seguimiento de nuevos tests defectuosos](#track-new-flaky-tests).
2. Crea una consulta de búsqueda utilizando la misma lógica de una búsqueda del explorador de tests CI. Por ejemplo, puedes buscar tests fallidos para la rama `main` del test de servicio `myapp` utilizando la siguiente consulta: `@test.status:fail @git.branch:main @test.service:myapp`.
3. Elige monitorizar un recuento de eventos de tests CI, una faceta o una medida:
- * **CI Test event count** (Recuento de eventos de tests CI): utiliza la barra de búsqueda (opcional) y **no** selecciones una faceta o una medida. Datadog evalúa el número de eventos de tests CI, a lo largo de un periodo de tiempo seleccionado, y luego lo compara con las condiciones del umbral.
- * **Dimensión**: selecciona la dimensión (faceta cualitativa) para emitir alertas sobre el `Unique value count` de la faceta.
+ * **CI Test event count** (Recuento de eventos de tests CI): utiliza la barra de búsqueda (opcional) y **no** selecciones una faceta o una medida. Datadog evalúa el número de eventos de tests de pipelines CI, a lo largo de un periodo de tiempo seleccionado, y luego lo compara con las condiciones del umbral.
+ * **Dimensión** (Dimensión): selecciona la dimensión (faceta cualitativa) para emitir alertas sobre el `Unique value count` de la faceta.
* **Measure* (Medida): selecciona la medida (faceta cuantitativa) para emitir alertas sobre el valor numérico de la faceta del pipeline CI (similar a un monitor de métricas). Selecciona la agregación (`min`, `avg`, `sum`, `median`, `pc75`, `pc90`, `pc95`, `pc98`, `pc99` o `max`).
4. Agrupa los eventos de tests CI por múltiples dimensiones (opcional):
* Todos los eventos de tests CI que coinciden con la consulta se agregan a grupos basados en el valor de hasta cuatro facetas.
5. Configura la estrategia de agrupación de alertas (opcional):
* Si la consulta tiene un `group by`, se envía una alerta para cada origen en función de los parámetros del grupo. Se genera un evento de alerta para cada grupo que cumple las condiciones establecidas. Por ejemplo, puedes agrupar una consulta por `@test.full_name` para recibir una alerta distinta para cada nombre completo de test CI, cuando el número de errores es elevado. El nombre completo del test es una combinación del grupo de tests y el nombre del test, por ejemplo: `MySuite.myTest`. En Swift, el nombre completo del test es una combinación del grupo de tests, del conjunto de tests y del nombre del test, por ejemplo: `MyBundle.MySuite.myTest`.
-{{< img src="monitors/monitor_types/ci_pipelines/define-the-search-query.png" alt="Consulta de Status:Error de CI configurado para agruparse por nombre de pipeline" style="width:100%;" >}}
+{{< img src="monitors/monitor_types/ci_pipelines/define-the-search-query.png" alt="Consulta de estado de error de CI configurado para agruparse por nombre de pipeline" style="width:100%;" >}}
#### Ejecución de tests con diferentes parámetros o configuraciones
Utiliza `@test.fingerprint` en el monitor `group by` cuando tengas tests con el mismo nombre completo de test, pero diferentes parámetros o configuraciones de test. De esta forma, las alertas se activan para ejecuciones de tests con parámetros o configuraciones de test específicos. El uso de `@test.fingerprint` proporciona el mismo nivel de especificidad que la sección Estados de tests fallado y defectuoso, en la página **Información general sobre las confirmaciones**.
@@ -100,7 +100,7 @@ El uso de `@test.full_name` en este caso activa la alerta, aunque el test haya s
Puedes crear monitores de tests CI utilizando fórmulas y funciones. Esto puede utilizarse, por ejemplo, para crear monitores de la **tasa** de ocurrencia de un evento, como por ejemplo la tasa de fallo de un test (tasa de error).
-El siguiente ejemplo es un monitor de la tasa de errores de tests que utiliza una fórmula que calcula la proporción del "número de eventos de test fallidos" (`@test.status:fail`) sobre el "número de eventos de test totales" (sin filtro), agrupados por `@test.full_name` (para ser alertados una vez por test). Para obtener más información, consulta [Información general en la sección Funciones][1].
+El siguiente ejemplo es un monitor de la tasa de errores de tests que utiliza una fórmula para calcular la proporción del "número de eventos de test fallidos" (`@test.status:fail`) sobre el "número de eventos de test totales" (sin filtro), agrupados por `@test.full_name` (para ser alertados una vez por test). Para obtener más información, consulta [Información general en la sección Funciones][1].
{{< img src="monitors/monitor_types/ci_tests/define-the-Buscar-query-fnf.png" alt="Monitor definido a través de las etapas a, b, c, donde las etapas a, b son consultas y la etapa c calcula la tasa a partir de las dos etapas anteriores."style="width:100%;" >}}
@@ -127,10 +127,10 @@ En la sección `Notification message` de tu monitor, añade un texto similar al
[2]: /es/monitors/notify/variables/?tab=is_match#conditional-variables
{{% /tab %}}
{{< /tabs >}}
-### Definir las condiciones de alerta
+### Definir condiciones de alerta
-* Se activa cuando la métrica es `above`, `above or equal to`, `below` o `below or equal to`
-* El umbral durante los últimos `5 minutes`, `15 minutes`, la última `1 hour` o el último`custom` para configurar un valor entre `1 minute` y `2 days`
+* Se activa cuando la métrica es `above`, `above or equal to`, `below`, o `below or equal to`
+* El umbral durante los últimos `5 minutes`, `15 minutes`, `1 hour` o `custom` para configurar un valor entre `1 minute` y `2 days`
* Umbral de alerta ``
* Umbral de advertencia ``
@@ -140,13 +140,13 @@ Para obtener instrucciones detalladas sobre las opciones avanzadas de alerta (co
### Notificaciones
-Para obtener instrucciones detalladas sobre la sección **Configurar notificaciones y automatizaciones**, consulta la página [Notificaciones][4].
+Para obtener instrucciones detalladas sobre la sección **Configure notifications and automations** (Configurar notificaciones y automatizaciones), consulta la página [Notificaciones][4].
#### Ejemplos y lista de los principales valores de incumplimiento
Cuando se activa una test CI o un monitor de pipelines, pueden añadirse ejemplos o valores al mensaje de notificación.
-| Configuración del monitor | Puede añadirse al mensaje de notificación |
+| Configuración del monitor | Puede añadirse al mensaje de notificación |
|----------------------------------|--------------------------------------|
| Recuento de alertas simples no agrupadas | Hasta 10 ejemplos. |
| Recuento de alertas simples agrupadas | Hasta 10 valores de facetas o medidas. |
@@ -169,14 +169,14 @@ Incluye una tabla con 10 ejemplos de pipelines CI en la notificación de alerta:
#### Comportamiento de las notificaciones cuando no hay datos
-Un monitor que utiliza un recuento de eventos para su consulta de evaluación se resolverá, después del período de evaluación especificado sin datos, activando una notificación. Por ejemplo, un monitor configurado para enviar alertas sobre el número de errores de pipelines a través de una ventana de evaluación de cinco minutos se resolverá automáticamente después de cinco minutos sin ninguna ejecución de pipelines.
+Un monitor que utiliza un recuento de eventos para su consulta de evaluación se resolverá después del período de evaluación especificado sin datos activando una notificación. Por ejemplo, un monitor configurado para enviar alertas sobre el número de errores de pipelines a través de una ventana de evaluación de cinco minutos se resolverá automáticamente después de cinco minutos sin ninguna ejecución de pipelines.
-Como alternativa, Datadog recomienda utilizar fórmulas de tasa. Por ejemplo, en lugar de utilizar un monitor del número de fallos de pipelines (recuento), utiliza un monitor de la tasa de fallos de pipelines (fórmula), como `(number of pipeline failures)/(number of all pipeline executions)`. En este caso, cuando no haya datos, el denominador `(number of all pipeline executions)` será `0`, haciendo que la división `x/0` sea imposible de evaluar. El monitor mantendrá el estado conocido previo, en lugar de evaluarlo como `0`.
+Como alternativa, Datadog recomienda utilizar fórmulas de tasa. Por ejemplo, en lugar de utilizar un monitor del número de fallos de pipelines (recuento), utiliza un monitor de la tasa de fallos de pipelines (fórmula), como por ejemplo `(number of pipeline failures)/(number of all pipeline executions)`. En este caso, cuando no haya datos, el denominador `(number of all pipeline executions)` será `0`, lo que hará que la división `x/0` sea imposible de evaluar. El monitor mantendrá el estado conocido previo, en lugar de evaluarlo como `0`.
De este modo, si el monitor se activa debido a una explosión de fallos de pipelines que hace que la tasa de error supere el umbral del monitor, no se desactivará hasta que la tasa de error esté por debajo del umbral, lo que puede ocurrir en cualquier momento posterior.
## Ejemplos de monitores
-A continuación se describen los casos de uso de monitores frecuentes. Las consultas de monitores pueden modificarse para filtrar por ramas específicas, autores o cualquier otra faceta de la aplicación.
+A continuación se describen los casos frecuentes de uso de monitores. Las consultas de monitores pueden modificarse para filtrar por ramas específicas, autores o cualquier otra faceta de la aplicación.
### Activar alertas por retroceso del rendimiento
La métrica `duration` puede utilizarse para identificar el pipeline y realizar tests de los retrocesos del rendimiento en cualquier rama. El envío de alertas sobre esta métrica puede evitar que los retrocesos del rendimiento se introduzcan en tu código base.
@@ -186,22 +186,22 @@ La métrica `duration` puede utilizarse para identificar el pipeline y realizar
### Realizar un seguimiento de nuevos tests defectuosos
Los monitores de tests tienen los tipos de monitores frecuentes `New Flaky Test`, `Test Failures` y `Test Performance` para facilitar la configuración del monitor. Estos monitores envían alertas cuando se añaden nuevos tests defectuosos a tu código base. La consulta se agrupa por `Test Full Name` para que no recibas alertas sobre el mismo test defectuoso más de una vez.
-Una ejecución de test se marca como `flaky` si presenta fallos en la misma confirmación, después de algunos reintentos. Si presenta fallos varias veces (porque se han realizado varios reintentos), se añade la etiqueta (tag) `is_flaky` al primer test detectado como defectuoso.
+Una ejecución de test se marca como `flaky` si presenta defectos en la misma confirmación después de algunos reintentos. Si presenta defectos varias veces (porque se han realizado varios reintentos), se añade la etiqueta (tag) `is_flaky` al primer test detectado como defectuoso.
-Una ejecución de test se marca como `new flaky` si ese test en particular no se ha detectado como defectuoso en la misma rama o en la rama predeterminada. Sólo la primera ejecución de test que se detecta como un nuevo fallo se marca con la etiqueta `is_new_flaky` (independientemente del número de reintentos).
+Una ejecución de test se marca como `new flaky` si ese test en particular no se ha detectado como defectuoso en la misma rama o en la rama predeterminada. Sólo la primera ejecución del test que se detecta como un nuevo defecto se marca con la etiqueta `is_new_flaky` (independientemente del número de reintentos).
-{{< img src="ci/flaky_test_monitor.png" alt="Monitor de test CI defectuoso" style="width:100%;">}}
+{{< img src="ci/flaky_test_monitor.png" alt="Monitor de tests CI defectuosos" style="width:100%;">}}
Para obtener más información, consulta [Buscar y administrar tests CI][6].
### Mantener el porcentaje de cobertura del código
Las [métricas personalizadas][5], como el porcentaje de cobertura del código, pueden crearse y utilizarse en monitores. El siguiente monitor envía alertas cuando la cobertura del código cae por debajo de un determinado porcentaje, lo que puede ayudar con el mantenimiento del rendimiento de los tests a lo largo del tiempo.
-{{< img src="ci/codecoveragepct_monitor_light.png" alt="Monitor de test CI defectuoso" style="width:100%;">}}
+{{< img src="ci/codecoveragepct_monitor_light.png" alt="Monitor de tests CI defectuosos" style="width:100%;">}}
Para obtener más información, consulta [Cobertura del código][7].
-## Leer más
+## Para leer más
{{< partial name="whats-next/whats-next.html" >}}
diff --git a/content/es/monitors/types/process.md b/content/es/monitors/types/process.md
index 7873889f9499d..52e96fcdf3a63 100644
--- a/content/es/monitors/types/process.md
+++ b/content/es/monitors/types/process.md
@@ -21,12 +21,12 @@ title: Monitor de procesos en directo
## Información general
-Los monitores de procesos en directo se basan en los datos recopilados por el [Agente de procesos][1]. Crea monitores que avisen o alerten basándose en el recuento de cualquier grupo de procesos en hosts o etiquetas (tags).
+Los monitores de procesos en directo se basan en los datos recopilados por el [Agent de procesos][1]. Crea monitores que avisen o alerten en función del recuento de cualquier grupo de procesos en hosts o etiquetas (tags).
Los monitores de procesos en directo tienen una mayor utilidad en los siguientes casos:
- Asegurar que se están ejecutando suficientes instancias de un proceso de larga duración no contenedorizado.
-- Indicar cuando un proceso específico se está ejecutando.
+- Indicar cuándo un proceso específico se está ejecutando.
**Nota**: Sólo los procesos de larga duración son recopilados por el Agent. Los monitores en procesos que duran menos de 20 segundos pueden ser defectuosos.
@@ -35,7 +35,7 @@ Los monitores de procesos en directo tienen una mayor utilidad en los siguientes
Hay dos formas de crear un monitor de procesos en directo:
- Utilizar la navegación principal: **Monitors --> New Monitor --> Live Process* (Monitores > Nuevo monitor > Proceso en directo).
-- En la [página de procesos en directo][4], busca un proceso que quieras monitorizar. A continuación, haz clic en el menú desplegable situado junto a **+New Metric** (+Nueva métrica) y haz clic en **Create monitor* (Crear monitor)*.
+- En la [página de procesos en directo][4], busca un proceso que quieras monitorizar. A continuación, haz clic en el menú desplegable situado junto a **+New Metric** (+Nueva métrica) y haz clic en **Create monitor** (Crear monitor)*.
### Seleccionar procesos
@@ -45,7 +45,7 @@ Puedes utilizar etiquetas o un texto de búsqueda impreciso para filtrar todos l
Después de definir tu búsqueda, se muestra un gráfico sobre las entradas de las búsquedas, con una aproximación del número total de procesos encontrados. Se recomienda que el monitor se limite a unos pocos miles de procesos. Utiliza etiquetas adicionales para reducir la búsqueda o considera la posibilidad de dividir un monitor en varios, si es necesario. Para obtener datos más específicos, consulta la [página de procesos en directo][4].
-#### Búsqueda de etiquetas
+#### Búsqueda por etiquetas
Filtra los procesos que quieres monitorizar por etiquetas. Datadog recomienda intentar filtrar procesos por sus etiquetas antes de utilizar la búsqueda de texto completo.
@@ -68,18 +68,18 @@ Si no puedes delimitar un proceso para lograr la especificidad que buscas utiliz
`Multi Alert`: aplica la alerta a cada fuente en función de tus parámetros de grupo. Recibirás una alerta por cada grupo que cumple las condiciones establecidas.
-### Definir tus condiciones de alerta
+### Definir condiciones de alerta
- La posición del recuento del proceso fue `above`, `above or equal to`, `below` o `below or equal to`
-- del umbral durante los últimos `5 minutes`, `15 minutes`, `1 hour` o mayor. Además, puedes utilizar `custom` para establecer un valor entre 5 minutos y 24 horas.
+- al umbral durante los últimos `5 minutes`, `15 minutes`, `1 hour`, o mayor. Además, puedes utilizar `custom` para configurar un valor entre 5 minutos y 24 horas.
-En este caso, el recuento del proceso se refiere al número de todos las procesos coincidentes que estuvieron vivos durante el intervalo de tiempo.
+En este caso, el recuento del proceso se refiere al número de todos las procesos coincidentes que estuvieron activos durante el intervalo de tiempo.
-Utiliza umbrales para establecer un valor numérico que active una alerta. Datadog tiene dos tipos de notificaciones: alerta y advertencia. Los monitores de procesos en vivo se recuperan automáticamente en función del umbral de alerta o advertencia.
+Utiliza umbrales para establecer un valor numérico que active una alerta. Datadog cuenta con dos tipos de notificaciones: alertas y advertencias. Los monitores de procesos en directo se recuperan automáticamente en función del umbral de alerta o advertencia.
#### Prácticas recomendadas para la selección de periodos de tiempo
-Los monitores de procesos en directo utilizan una [ventana temporal móvil][7] para evaluar el recuento de procesos. En otras palabras, cada minuto, el monitor analiza los últimos X minutos y se activa si se cumple la condición de alerta. Se desaconseja el uso de ventanas de evaluación de menos de 5 minutos para evitar falsos positivos debidos a interrupciones esporádicas de la red entre el Agent del proceso y Datadog.
+Los monitores de procesos en directo utilizan una [ventana temporal móvil][7] para evaluar el recuento de procesos. En otras palabras, cada minuto, el monitor analiza los últimos X minutos y se activa si se cumple la condición de alerta. Se desaconseja el uso de ventanas de evaluación de menos de 5 minutos para evitar falsos positivos debidos a interrupciones esporádicas de la red entre el Agent de procesos y Datadog.
### Condiciones de alerta avanzadas
@@ -87,14 +87,14 @@ Para obtener instrucciones detalladas sobre las opciones avanzadas de alerta (re
### Notificaciones
-Para obtener instrucciones detalladas sobre la sección **Configurar notificaciones y automatizaciones**, consulta la página [Notificaciones][6].
+Para obtener instrucciones detalladas sobre la sección **Configure notifications and automations** (Configurar notificaciones y automatizaciones), consulta la página [Notificaciones][6].
-## Leer más
+## Para leer más
{{< partial name="whats-next/whats-next.html" >}}
[1]: /es/infrastructure/process/
-[2]: https://app.datadoghq.com/monitors#create/live_process
+[2]: https://app.datadoghq.com/monitors/create/live_process
[3]: /es/infrastructure/process/#search-syntax
[4]: https://app.datadoghq.com/process
[5]: /es/monitors/configuration/#advanced-alert-conditions
diff --git a/content/es/network_monitoring/performance/setup.md b/content/es/network_monitoring/performance/setup.md
new file mode 100644
index 0000000000000..9ba5b7f70d42d
--- /dev/null
+++ b/content/es/network_monitoring/performance/setup.md
@@ -0,0 +1,498 @@
+---
+aliases:
+- /es/network_performance_monitoring/installation/
+description: Recopila tus datos de red con el Agent.
+further_reading:
+- link: https://www.datadoghq.com/blog/network-performance-monitoring
+ tag: Blog
+ text: Network Performance Monitoring
+- link: https://www.datadoghq.com/blog/monitor-containers-with-npm/
+ tag: Blog
+ text: Datadog NPM con contenedores y redes con mallas de servicios
+- link: /network_monitoring/devices
+ tag: Documentación
+ text: Monitorización de dispositivos de red
+- link: https://www.datadoghq.com/blog/monitor-consul-with-datadog-npm/
+ tag: Blog
+ text: Datadog NPM ya es compatible con la red Consul
+title: Configuración de Network Performance Monitoring
+---
+
+Datadog Network Performance Monitoring (NPM) te ofrece visibilidad del tráfico de red entre servicios, contenedores, zonas de disponibilidad y cualquier otra etiqueta (tag) en Datadog para que puedas:
+
+- Localizar dependencias de servicios inesperadas o latentes.
+- Optimizar la costosa comunicación entre regiones o nubes múltiples.
+- Identificar las interrupciones en las regiones proveedoras de la nube y las herramientas de terceros.
+- Solucionar problemas de detección de servicios defectuosos con métricas del servidor DNS.
+
+Network Performance Monitoring requiere el [Datadog Agent v6.14 o posterior][1]. Dado que las métricas se recopilan automáticamente en versiones superiores del Agent, consulta la [sección de configuración de métricas][2] para configurar la monitorización DNS.
+
+## Plataformas compatibles
+
+### Sistemas operativos
+
+#### Sistema operativo Linux
+
+La recopilación de datos se realiza utilizando eBPF, por lo que Datadog requiere mínimamente plataformas que tengan versiones del kernel Linux subyacente 4.4.0 o posteriores o que tengan backports de las características de eBPF. NPM es compatible con las siguientes distribuciones de Linux:
+
+- Ubuntu v16.04 o posterior
+- Debian v9 o posterior
+- Fedora v26 o posterior
+- SUSE v15 o posterior
+- Amazon AMI v2016.03 o posterior
+- Amazon Linux v2
+- CentOS/RHEL v7.6 o posterior
+
+**Nota:** Existe una excepción al requisito del kernel v4.4.0 o posterior para [CentOS/RHEL v7.6 o posterior][3]. La función [DNS Resolution][4] no es compatible con CentOS/RHEL v7.6.
+
+#### Sistema operativo Windows
+
+La recopilación de datos se realiza mediante un controlador de dispositivo kernel de red. La compatibilidad está disponible a partir del Datadog Agent versión 7.27.1, para versiones de Windows 2012 R2 (y sistemas operativos de escritorio equivalentes, incluido Windows 10) y posteriores.
+
+#### macOS
+
+Datadog Network Performance Monitoring no es compatible con plataformas macOS.
+
+### Contenedores
+
+NPM te ayuda a visualizar la arquitectura y el rendimiento de tus entornos contenedorizados y orquestados, con compatibilidad para [Docker][5], [Kubernetes][6], [ECS][7] y otras tecnologías de contenedor. Las integraciones de contenedores de Datadog te permiten agregar tráfico por entidades significativas, como contenedores, tareas, pods, clústeres y despliegues, con etiquetas predefinidas como `container_name`, `task_name` y `kube_service`.
+
+NPM no es compatible con Autopilot de Google Kubernetes Engine (GKE).
+
+### Herramientas de enrutamiento en la red
+
+#### Istio
+
+Con NPM, puedes asignar la comunicación de red entre contenedores, pods y servicios a través de la malla de servicios Istio.
+
+Datadog monitoriza todos los aspectos de tu entorno Istio para que también puedas:
+
+- Evaluar el estado de Envoy y el plano de control de Istio con [logs][8].
+- Desglosar el rendimiento de tu malla de servicios con [métricas][8] de solicitudes, ancho de banda y consumo de recursos.
+- Examinar trazas (traces) distribuidas de aplicaciones que realizan transacciones a lo largo de la malla con [APM][9].
+
+NPM es compatible con Istio v1.6.4 o posterior con el [Datadog Agent v7.24.1 o posterior][1].
+
+Para obtener más información sobre la monitorización de tu entorno Istio con Datadog, [consulta el blog de Istio][10].
+
+#### Cilium
+
+Network Performance Monitoring es compatible con instalaciones **Cilium**, siempre que se cumplan los siguientes requisitos:
+1) Cilium v1.6 y posteriores, y
+2) Kernel v5.1.16 y posteriores, o v4.19.57 y posteriores para kernels 4.19.x
+
+### Sistemas de aprovisionamiento
+
+Network Performance Monitoring es compatible con el uso de los siguientes sistemas de aprovisionamiento:
+
+- Daemonset / Helm v1.38.11 o posterior: Consulta el [Helm Chart de Datadog][11]
+- Chef v12.7 o posterior: Consulta la [receta de Datadog Chef][12]
+- Ansible v2.6 o posterior: Consulta el [rol Ansible de Datadog][13]
+
+## Configuración
+
+Dado que la potencia y el enfoque de esta herramienta se centran en el análisis del tráfico entre endpoints de red y la asignación de dependencias red, recomendamos instalarla en un subconjunto significativo de tu infraestructura y en un **mínimo de 2 hosts** para maximizar su valor.
+
+{{< tabs >}}
+{{% tab "Agent (Linux)" %}}
+
+Para habilitar Network Performance Monitoring con el Datadog Agent, utiliza las siguientes configuraciones:
+
+1. **Si utilizas una versión del Agent anterior a v6.14 o posterior**, habilita primero [la recopilación de procesos en directo][1], de lo contrario, omite este paso.
+
+2. Copia la configuración de ejemplo de sonda del sistema:
+
+ ```shell
+ sudo -u dd-agent install -m 0640 /etc/datadog-agent/system-probe.yaml.example /etc/datadog-agent/system-probe.yaml
+ ```
+
+3. Edita `/etc/datadog-agent/system-probe.yaml` para definir el indicador de habilitación como `true`:
+
+ ```yaml
+ network_config: # use system_probe_config for Agent's older than 7.24.1
+ ## @param enabled - boolean - optional - default: false
+ ## Set to true to enable Network Performance Monitoring.
+ #
+ enabled: true
+ ```
+
+4. **Si estás ejecutando una versión del Agent anterior a v6.18 o v7.18**, inicia manualmente la sonda del sistema y habilítala para que se inicie al arrancar (a partir de v6.18 y v7.18, la sonda del sistema se inicia automáticamente al arrancar el Agent):
+
+ ```shell
+ sudo systemctl start datadog-agent-sysprobe
+ sudo systemctl enable datadog-agent-sysprobe
+ ```
+
+ **Nota**: Si el comando `systemctl` no está disponible en tu sistema, inícialo con el siguiente comando: `sudo service datadog-agent-sysprobe start` y luego configúralo para que se inicie al arrancar, antes de que se inicie `datadog-agent`.
+
+5. [Reinicia el Agent][2].
+
+ ```shell
+ sudo systemctl restart datadog-agent
+ ```
+
+ **Nota**: Si el comando `systemctl` no está disponible en tu sistema, ejecuta el siguiente comando: `sudo service datadog-agent restart`.
+
+### Sistemas habilitados por SELinux
+
+En sistemas con SELinux habilitado, el binario de la sonda del sistema necesita permisos especiales para utilizar las funciones de eBPF.
+
+El paquete RPM del Datadog Agent para sistemas basados en CentOS incluye una [política SELinux][3] para conceder estos permisos al binario de la sonda del sistema.
+
+Si necesitas utilizar Network Performance Monitoring en otros sistemas con SELinux habilitado, haz lo siguiente:
+
+1. Modifica la [política SELinux][3] de base para que coincida con tu configuración de SELinux.
+ Dependiendo de tu sistema, algunos tipos o atributos pueden no existir (o pueden tener nombres diferentes).
+
+2. Compila la política en un módulo; suponiendo que el archivo de tu política se llame `system_probe_policy.te`:
+
+ ```shell
+ checkmodule -M -m -o system_probe_policy.mod system_probe_policy.te
+ semodule_package -o system_probe_policy.pp -m system_probe_policy.mod
+ ```
+
+3. Aplica el módulo a tu sistema SELinux:
+
+ ```shell
+ semodule -v -i system_probe_policy.pp
+ ```
+
+4. Cambia el tipo de binario de la sonda del sistema para utilizar el que está definido en la política; suponiendo que el directorio de instalación de tu Agent sea `/opt/datadog-agent`:
+
+ ```shell
+ semanage fcontext -a -t system_probe_t /opt/datadog-agent/embedded/bin/system-probe
+ restorecon -v /opt/datadog-agent/embedded/bin/system-probe
+ ```
+
+5. [Reinicia el Agent][2].
+
+**Nota**: Estas instrucciones requieren tener algunas funciones de SELinux instaladas en el sistema (`checkmodule`, `semodule`, `semodule_package`, `semanage` y `restorecon`), disponibles en la mayoría de las distribuciones estándar (Ubuntu, Debian, RHEL, CentOS, SUSE). Consulta tu distribución para ver más detalles sobre cómo instalarlas.
+
+Si estas funciones no existen en tu distribución, sigue el mismo procedimiento pero en este caso utiliza las funciones proporcionadas por tu distribución.
+
+
+[1]: /es/infrastructure/process/?tab=linuxwindows#installation
+[2]: /es/agent/configuration/agent-commands/#restart-the-agent
+[3]: https://github.com/DataDog/datadog-agent/blob/master/cmd/agent/selinux/system_probe_policy.te
+{{% /tab %}}
+{{% tab "Agent (Windows)" %}}
+
+La recopilación de datos de Windows depende de un controlador de filtro para recopilar los datos de red.
+
+Para habilitar Network Performance Monitoring en hosts de Windows:
+
+1. Instala el [Datadog Agent][1] (versión 7.27.1 o posterior) con el componente del controlador de red habilitado.
+
+ [OBSOLETO] (versión 7.44 o anterior) Durante la instalación, pasa `ADDLOCAL="MainApplication,NPM"` al comando `msiexec` o selecciona "Network Performance Monitoring" cuando ejecutes la instalación del Agent a través de la GUI.
+
+1. Edita `C:\ProgramData\Datadog\system-probe.yaml` para definir el indicador habilitado como `true`:
+
+ ```yaml
+ network_config:
+ enabled: true
+ ```
+3. [Reinicia el Agent][2].
+
+ Para PowerShell (`powershell.exe`):
+ ```shell
+ restart-service -f datadogagent
+ ```
+ Para Command Prompt (`cmd.exe`):
+ ```shell
+ net /y stop datadogagent && net start datadogagent
+ ```
+**Nota**: Network Performance Monitoring sólo monitoriza hosts de Windows y no contenedores de Windows.
+
+
+[1]: /es/agent/basic_agent_usage/windows/?tab=commandline
+[2]: /es/agent/configuration/agent-commands/#restart-the-agent
+{{% /tab %}}
+{{% tab "Kubernetes" %}}
+
+Para habilitar Network Performance Monitoring con Kubernetes utilizando Helm, añade lo siguiente a tu archivo `values.yaml`.
+**Se requiere Helm chart v2.4.39 o posterior**. Para obtener más información, consulta la [documentación de Datadog Helm Chart][1].
+
+ ```yaml
+ datadog:
+ networkMonitoring:
+ enabled: true
+ ```
+
+**Nota**: Si recibes un error de permisos al configurar NPM en tu entorno Kubernetes: `Error: error enabling protocol classifier: permission denied`, añade lo siguiente a tu `values.yaml`. (Consulta esta [sección][5] en el Helm chart):
+
+ ```yaml
+ agents:
+ podSecurity:
+ apparmor:
+ enabled: true
+ ```
+
+Si no utilizas Helm, puedes habilitar Network Performance Monitoring con Kubernetes desde cero:
+
+1. Descarga la plantilla [datadog-agent.yaml manifest][2].
+2. Sustituye `` por tu [clave de API Datadog][3].
+3. (Opcional) **Configura tu sitio Datadog**. Si utilizas el sitio Datadog EU, configura la variable de entorno `DD_SITE` como `datadoghq.eu` en el manifiesto `datadog-agent.yaml`.
+4. **Despliega el DaemonSet** con el comando:
+
+ ```shell
+ kubectl apply -f datadog-agent.yaml
+ ```
+
+Si el [Agent ya se ejecuta con un manifiesto][4]:
+
+1. Añade la anotación `container.apparmor.security.beta.kubernetes.io/system-probe: unconfined` en la plantilla `datadog-agent`:
+
+ ```yaml
+ spec:
+ selector:
+ matchLabels:
+ app: datadog-agent
+ template:
+ metadata:
+ labels:
+ app: datadog-agent
+ name: datadog-agent
+ annotations:
+ container.apparmor.security.beta.kubernetes.io/system-probe: unconfined
+ ```
+
+2. Habilita el proceso de recopilación y la sonda del sistema con las siguientes variables de entorno en el DaemonSet del Agent. Si estás ejecutando un contenedor por cada proceso del Agent, añade las siguientes variables de entorno al Agent de proceso, de lo contrario, añádelas al contenedor del Agent.
+
+ ```yaml
+ # (...)
+ env:
+ # (...)
+ - name: DD_PROCESS_AGENT_ENABLED
+ value: 'true'
+ - name: DD_SYSTEM_PROBE_ENABLED
+ value: 'true'
+ - name: DD_SYSTEM_PROBE_EXTERNAL
+ value: 'true'
+ - name: DD_SYSPROBE_SOCKET
+ value: /var/run/sysprobe/sysprobe.sock
+ ```
+
+3. Monta los siguientes volúmenes adicionales en el contenedor `datadog-agent`:
+
+ ```yaml
+ # (...)
+ spec:
+ serviceAccountName: datadog-agent
+ containers:
+ - name: datadog-agent
+ image: 'gcr.io/datadoghq/agent:latest'
+ # (...)
+ volumeMounts:
+ - name: procdir
+ mountPath: /host/proc
+ readOnly: true
+ - name: cgroups
+ mountPath: /host/sys/fs/cgroup
+ readOnly: true
+ - name: debugfs
+ mountPath: /sys/kernel/debug
+ - name: sysprobe-socket-dir
+ mountPath: /var/run/sysprobe
+ ```
+
+4. Añade una nueva sonda del sistema como elemento adicional del Agent:
+
+ ```yaml
+ # (...)
+ spec:
+ serviceAccountName: datadog-agent
+ containers:
+ - name: datadog-agent
+ image: 'gcr.io/datadoghq/agent:latest'
+ # (...)
+ - name: system-probe
+ image: 'gcr.io/datadoghq/agent:latest'
+ imagePullPolicy: Always
+ securityContext:
+ capabilities:
+ add:
+ - SYS_ADMIN
+ - SYS_RESOURCE
+ - SYS_PTRACE
+ - NET_ADMIN
+ - NET_BROADCAST
+ - NET_RAW
+ - IPC_LOCK
+ - CHOWN
+ command:
+ - /opt/datadog-agent/embedded/bin/system-probe
+ env:
+ - name: DD_SYSPROBE_SOCKET
+ value: /var/run/sysprobe/sysprobe.sock
+ resources:
+ requests:
+ memory: 150Mi
+ cpu: 200m
+ limits:
+ memory: 150Mi
+ cpu: 200m
+ volumeMounts:
+ - name: procdir
+ mountPath: /host/proc
+ readOnly: true
+ - name: cgroups
+ mountPath: /host/sys/fs/cgroup
+ readOnly: true
+ - name: debugfs
+ mountPath: /sys/kernel/debug
+ - name: sysprobe-socket-dir
+ mountPath: /var/run/sysprobe
+ ```
+
+5. Por último, añada los siguientes volúmenes a tu manifiesto:
+
+ ```yaml
+ volumes:
+ - name: sysprobe-socket-dir
+ emptyDir: {}
+ - name: debugfs
+ hostPath:
+ path: /sys/kernel/debug
+ ```
+
+
+[1]: https://github.com/DataDog/helm-charts/blob/master/charts/datadog/README.md#enabling-system-probe-collection
+[2]: /resources/yaml/datadog-agent-npm.yaml
+[3]: https://app.datadoghq.com/organization-settings/api-keys
+[4]: /es/agent/kubernetes/
+[5]: https://github.com/DataDog/helm-charts/blob/main/charts/datadog/values.yaml#L1519-L1523
+{{% /tab %}}
+{{% tab "Operator" %}}
+El Datadog Operator está disponible de forma general en la versión `1.0.0` y concilia la versión `v2alpha1` del recurso personalizado del Datadog Agent.
+
+[El Datadog Operator][1] permite desplegar el Datadog Agent en Kubernetes y OpenShift e informa sobre la situación y los errores de despliegue en el estado de tu recurso personalizado. Además, sus opciones de configuración de nivel superior limitan el riesgo de configuraciones erróneas.
+
+Para habilitar Network Performance Monitoring en Operator, utiliza la siguiente configuración:
+
+```yaml
+apiVersion: datadoghq.com/v2alpha1
+metadata:
+ name: placeholder
+ namespace: placeholder
+spec:
+ features:
+ npm:
+ enabled: true
+```
+
+[1]: https://github.com/DataDog/datadog-operator
+{{% /tab %}}
+{{% tab "Docker" %}}
+
+Para habilitar Network Performance Monitoring en Docker, utiliza la siguiente configuración al iniciar el Agent contenedor:
+
+```shell
+docker run --cgroupns host \
+--pid host \
+-e DD_API_KEY="" \
+-e DD_SYSTEM_PROBE_NETWORK_ENABLED=true \
+-e DD_PROCESS_AGENT_ENABLED=true \
+-v /var/run/docker.sock:/var/run/docker.sock:ro \
+-v /proc/:/host/proc/:ro \
+-v /sys/fs/cgroup/:/host/sys/fs/cgroup:ro \
+-v /sys/kernel/debug:/sys/kernel/debug \
+--security-opt apparmor:unconfined \
+--cap-add=SYS_ADMIN \
+--cap-add=SYS_RESOURCE \
+--cap-add=SYS_PTRACE \
+--cap-add=NET_ADMIN \
+--cap-add=NET_BROADCAST \
+--cap-add=NET_RAW \
+--cap-add=IPC_LOCK \
+--cap-add=CHOWN \
+gcr.io/datadoghq/agent:latest
+```
+
+Sustituye `` por tu [clave de API Datadog][1].
+
+Si utilizas `docker-compose`, añade lo siguiente al servicio del Datadog Agent.
+
+```
+version: '3'
+services:
+ datadog:
+ image: "gcr.io/datadoghq/agent:latest"
+ environment:
+ - DD_SYSTEM_PROBE_NETWORK_ENABLED=true
+ - DD_PROCESS_AGENT_ENABLED=true
+ - DD_API_KEY=
+ volumes:
+ - /var/run/docker.sock:/var/run/docker.sock:ro
+ - /proc/:/host/proc/:ro
+ - /sys/fs/cgroup/:/host/sys/fs/cgroup:ro
+ - /sys/kernel/debug:/sys/kernel/debug
+ cap_add:
+ - SYS_ADMIN
+ - SYS_RESOURCE
+ - SYS_PTRACE
+ - NET_ADMIN
+ - NET_BROADCAST
+ - NET_RAW
+ - IPC_LOCK
+ - CHOWN
+ security_opt:
+ - apparmor:unconfined
+```
+
+[1]: https://app.datadoghq.com/organization-settings/api-keys
+{{% /tab %}}
+{{% tab "ECS" %}}
+Para configurar en Amazon ECS, consulta la página de documentación de [Amazon ECS][1].
+
+
+[1]: /es/agent/amazon_ecs/#network-performance-monitoring-collection-linux-only
+{{% /tab %}}
+{{< /tabs >}}
+
+{{< site-region region="us,us3,us5,eu" >}}
+### Resolución mejorada
+
+Opcionalmente, habilita la recopilación de recursos para integraciones en la nube para permitir a Network Performance Monitoring detectar entidades gestionadas por la nube.
+- Instala la [integración Azure][101] para obtener visibilidad de los balanceadores de carga y las pasarelas de aplicaciones de Azure.
+- Instala la [integración AWS][102] para obtener visibilidad del balanceador de carga AWS. **Debes habilitar la recopilación de métricas ENI y EC2**.
+
+Para obtener más información sobre estas funciones, consulta la [resolución mejorada de servicios en la nube][103].
+
+### Conexiones fallidas (beta privada)
+
+Las conexiones fallidas están en beta privada. Para empezar a ver
métricas de conexiones fallidas, ponte en contacto con tu representante de Datadog y solicita acceso.
+
+Para permitir que el Agent empiece a recopilar datos sobre conexiones fallidas, añade el siguiente indicador a tu archivo `/etc/datadog-agent/system-probe.yaml` (`C:\ProgramData\Datadog\system-probe.yaml` para Windows).
+
+```yaml
+network_config: # utilizar la configuración de la sonda del sistema para versiones del Agent anteriores a v7.24.1
+ ## @param habilitado - booleano - opcional - por defecto: falso
+ ## Configurar como verdadero para habilitar Network Performance Monitoring.
+ #
+ enabled: true
+ enable_tcp_failed_connections: true
+
+```
+
+[101]: /es/integrations/azure
+[102]: /es/integrations/amazon_web_services/#resource-collection
+[103]: /es/network_monitoring/performance/network_analytics/#cloud-service-enhanced-resolution
+
+{{< /site-region >}}
+
+## Referencias adicionales
+{{< partial name="whats-next/whats-next.html" >}}
+
+[1]: https://app.datadoghq.com/account/settings/agent/latest
+[2]: https://docs.datadoghq.com/es/network_monitoring/dns/#setup
+[3]: https://www.redhat.com/en/blog/introduction-ebpf-red-hat-enterprise-linux-7
+[4]: /es/network_monitoring/dns/
+[5]: https://docs.datadoghq.com/es/agent/docker/
+[6]: https://docs.datadoghq.com/es/agent/kubernetes/
+[7]: https://docs.datadoghq.com/es/agent/amazon_ecs
+[8]: https://docs.datadoghq.com/es/integrations/istio/
+[9]: https://docs.datadoghq.com/es/tracing/setup_overview/proxy_setup/?tab=istio
+[10]: https://www.datadoghq.com/blog/istio-datadog/
+[11]: https://github.com/DataDog/helm-charts/blob/master/charts/datadog/README.md#enabling-system-probe-collection
+[12]: https://github.com/DataDog/chef-datadog
+[13]: https://github.com/DataDog/ansible-datadog/blob/master/README.md#system-probe
\ No newline at end of file
diff --git a/content/es/real_user_monitoring/browser/tracking_user_actions.md b/content/es/real_user_monitoring/browser/tracking_user_actions.md
index a76164592de4e..003bae254a719 100644
--- a/content/es/real_user_monitoring/browser/tracking_user_actions.md
+++ b/content/es/real_user_monitoring/browser/tracking_user_actions.md
@@ -5,7 +5,7 @@ algolia:
further_reading:
- link: https://www.datadoghq.com/blog/real-user-monitoring-with-datadog/
tag: Blog
- text: Presentación del Real User Monitoring de Datadog
+ text: Presentación del Real User Monitoring (RUM) de Datadog
- link: /real_user_monitoring/explorer/
tag: Documentación
text: Explorar tus vistas en Datadog
@@ -44,7 +44,7 @@ El SDK del RUM Browser realiza un rastreo automático de los clics. Se crea una
## Métricas del tiempo de acción
-Para obtener información sobre los atributos por defecto para todos los tipos de eventos de RUM, consulta [Datos de RUM Browser recopilados][3].
+Para obtener información sobre los atributos predeterminados para todos los tipos de eventos de RUM, consulta [Datos de RUM Browser recopilados][3].
| Métrica | Tipo | Descripción |
|--------------|--------|--------------------------|
@@ -124,4 +124,4 @@ Para más información, consulta [Enviar acciones personalizadas][5].
[3]: /es/real_user_monitoring/browser/data_collected/#default-attributes
[4]: https://github.com/DataDog/browser-sdk/blob/main/CHANGELOG.md#v2160
[5]: /es/real_user_monitoring/guide/send-rum-custom-actions
-[6]: /es/real_user_monitoring/session_replay/privacy_options#mask-action-names
\ No newline at end of file
+[6]: /es/data_security/real_user_monitoring/#mask-action-names
\ No newline at end of file
diff --git a/content/es/real_user_monitoring/mobile_and_tv_monitoring/data_collected/_index.md b/content/es/real_user_monitoring/mobile_and_tv_monitoring/data_collected/_index.md
new file mode 100644
index 0000000000000..2c5a83de97d9b
--- /dev/null
+++ b/content/es/real_user_monitoring/mobile_and_tv_monitoring/data_collected/_index.md
@@ -0,0 +1,27 @@
+---
+further_reading:
+- link: https://github.com/DataDog/dd-sdk-android
+ tag: Código fuente
+ text: Código fuente de dd-sdk-android
+- link: https://github.com/DataDog/dd-sdk-ios
+ tag: Código fuente
+ text: Código fuente de dd-sdk-ios
+- link: https://github.com/DataDog/dd-sdk-flutter
+ tag: Código fuente
+ text: Código fuente de dd-sdk-flutter
+- link: https://github.com/DataDog/dd-sdk-reactnative
+ tag: Código fuente
+ text: Código fuente de dd-sdk-reactnative
+- link: https://github.com/DataDog/dd-sdk-roku
+ tag: Código fuente
+ text: Código fuente de dd-sdk-roku
+- link: /real_user_monitoring
+ tag: Documentación
+ text: Explorar RUM de Datadog
+title: Datos recopilados
+type: multi-code-lang
+---
+
+Para obtener información sobre la recopilación de datos en la monitorización de RUM, elige una plataforma:
+
+{{< partial name="rum/rum-getting-started-mobile-data-collected.html" >}}
\ No newline at end of file
diff --git a/content/es/real_user_monitoring/mobile_and_tv_monitoring/setup/codepush.md b/content/es/real_user_monitoring/mobile_and_tv_monitoring/setup/codepush.md
index 32cb0360439e2..4e8f9b7ade4f0 100644
--- a/content/es/real_user_monitoring/mobile_and_tv_monitoring/setup/codepush.md
+++ b/content/es/real_user_monitoring/mobile_and_tv_monitoring/setup/codepush.md
@@ -108,7 +108,7 @@ Crea un archivo gitignored `datadog-ci.json` en la raíz de tu proyecto que cont
}
```
-También puedes exportarlas como variables de entorno `Datadog_API_KEY` y `Datadog_SITE`.
+También puedes exportarlas como variables de entorno `DATADOG_API_KEY` y `DATADOG_SITE`.
Cuando lances un nuevo paquete de CodePush, especifica un directorio de salida para los mapas de fuente y el paquete:
@@ -155,6 +155,14 @@ Para obtener la `codepushVersion`, puedes codificarla o utilizar [`CodePush.getU
A continuación, carga tus mapas de fuente mediante el comando [`datadog-ci react-native upload`][5] y asegúrate de que el argumento `--release-version` coincide con lo establecido en la configuración del SDK.
+## Envío de datos cuando el dispositivo está desconectado
+
+RUM garantiza la disponibilidad de los datos cuando el dispositivo del usuario está desconectado. En caso de zonas con baja conexión de red o cuando la carga de la batería del dispositivo es demasiado baja, todos los eventos de RUM se almacenan primero en el dispositivo local en lotes.
+
+Cada lote sigue la especificación de entrada. Se envían tan pronto como la red está disponible y la batería está lo suficientemente cargada como para garantizar que el SDK de Datadog no afecte la experiencia del usuario final. Si la red no está disponible mientras tu aplicación está en primer plano o si falla una carga de datos, el lote se conserva hasta que se lo pueda enviar con éxito.
+
+Esto significa que incluso si los usuarios abren tu aplicación mientras están desconectados, no se pierde ningún dato. Para garantizar que el SDK no utilice demasiado espacio de disco, los datos del disco se descartan automáticamente si son demasiado antiguos.
+
## Referencias adicionales
{{< partial name="whats-next/whats-next.html" >}}
diff --git a/content/es/real_user_monitoring/mobile_and_tv_monitoring/setup/flutter.md b/content/es/real_user_monitoring/mobile_and_tv_monitoring/setup/flutter.md
index 48a3bcaec7f68..a1868be6544e4 100644
--- a/content/es/real_user_monitoring/mobile_and_tv_monitoring/setup/flutter.md
+++ b/content/es/real_user_monitoring/mobile_and_tv_monitoring/setup/flutter.md
@@ -29,9 +29,9 @@ Datadog Real User Monitoring (RUM) te permite visualizar y analizar el rendimien
### Especificar los detalles de la aplicación en la interfaz de usuario
-1. En Datadog, ve a [**Experiencia digital** > **Añadir una aplicación**][1].
+1. En Datadog, navega a [**Digital Experience** > **Add an Application**][1] (Experiencia digital > Añadir una aplicación).
2. Elige `Flutter` como tipo de aplicación.
-3. Proporciona un nombre de aplicación para generar un ID de aplicación Datadog y un token de cliente únicos.
+3. Proporciona un nombre de aplicación para generar un ID de aplicación de Datadog y un token de cliente únicos.
4. Para desactivar la recopilación automática de datos del usuario para la IP del cliente o los datos de geolocalización, desactiva las casillas de esas configuraciones. Para obtener más información, consulta [Recopilación de datos de RUM Flutter][7].
{{< img src="real_user_monitoring/flutter/flutter-new-application.png" alt="Crear una aplicación RUM para Flutter en Datadog" style="width:90%;">}}
@@ -43,23 +43,23 @@ Para garantizar la seguridad de tus datos, utiliza un token de cliente. Para obt
En primer lugar, asegúrate de tener tu entorno configurado correctamente para cada plataforma.
-Datadog es compatible con la monitorización de Flutter para iOS y Android para Flutter 3.0+.
+Datadog es compatible con la monitorización de Flutter para iOS y Android para Flutter 3.0+.
-Datadog no es compatible oficialmente con Flutter Web, pero el actual SDK de Flutter para aplicaciones móviles permite obtener alguna monitorización predefinida. Estas son las limitaciones conocidas:
+Datadog no es compatible oficialmente con Flutter Web, pero el actual SDK de Flutter para aplicaciones móviles permite obtener alguna monitorización predefinida. Estas son las limitaciones conocidas:
* Todas las acciones notificadas desde Flutter se etiquetan con el tipo `custom`.
* No se admiten acciones de ejecución prolongada (`startAction` / `stopAction`).
- * No se admite la notificación manual de recursos RUM (`startResource` / `stopResource`).
+ * No se admite la notificación manual de recursos de RUM (`startResource` / `stopResource`).
* Los asignadores de eventos no son compatibles actualmente.
* Las etiquetas (tags) en los registradores no son compatibles actualmente.
* `addUserExtraInfo` no es compatible.
* `stopSession` no es compatible.
-No está prevista la compatibilidad con Flutter Web, pero las prioridades de Datadog se reevalúan a menudo en función de tus comentarios. Si tienes una aplicación Flutter Web y quieres utilizar Datadog RUM para monitorizar tu rendimiento, ponte en contacto con tu equipo de atención al cliente y solicita esta función.
+No está prevista la compatibilidad con Flutter Web, pero las prioridades de Datadog se reevalúan a menudo en función de tus comentarios. Si tienes una aplicación Flutter Web y quieres utilizar Datadog RUM para monitorizar tu rendimiento, ponte en contacto con tu equipo de atención al cliente y solicita esta característica.
#### iOS
-Tu archivo Podfile iOS, ubicado en `ios/Podfile`, debe tener `use_frameworks!` configurado en true (que es el valor predeterminado en Flutter) y debe configurar su versión de iOS de destino >= 11.0.
+Tu archivo iOS Podfile, ubicado en `ios/Podfile`, debe tener `use_frameworks!` configurado en true (que es el valor predeterminado en Flutter) y debes configurar su versión de iOS de destino >= 11.0.
Esta restricción suele comentarse en la línea superior del Podfile y debe decir:
@@ -75,7 +75,7 @@ Para Android, tu versión de `minSdkVersion` debe ser >= 21 y si estás utilizan
### Web
-Para Web, añade lo siguiente a tu `index.html` debajo de la etiqueta `head` etiquetar, para el sitio **{{}}**:
+Para Web, añade lo siguiente a tu `index.html` debajo de la etiqueta `head` , para el sitio **{{}}**:
{{< site-region region="us" >}}
```html
@@ -123,7 +123,7 @@ Esto carga los SDK del navegador Datadog entregados por CDN para logs y RUM. La
dependencies:
datadog_flutter_plugin: ^2.0.0
```
-2. Crea un objeto de configuración para cada función de Datadog (como logs o RUM) con el siguiente fragmento. Si no pasas una configuración para una función determinada, esa función se desactiva.
+2. Crea un objeto de configuración para cada característica de Datadog (como logs o RUM) con el siguiente fragmento. Si no pasas una configuración para una característica determinada, esa característica se desactiva.
```dart
// Determine the user's consent to be tracked
@@ -140,7 +140,7 @@ Esto carga los SDK del navegador Datadog entregados por CDN para logs y RUM. La
);
```
-Para más información sobre las opciones disponibles de configuración, consulta la [Documentación del objeto de Configuración Datadog][3].
+Para más información sobre las opciones disponibles de configuración, consulta la [Documentación del objeto DatadogConfiguration][3].
Para garantizar la seguridad de tus datos, utiliza un token de cliente. No puedes utilizar claves de la API de Datadog para configurar el complemento de Datadog Flutter.
@@ -149,7 +149,7 @@ Para garantizar la seguridad de tus datos, utiliza un token de cliente. No puede
## Instrumentar tu solicitud
-### Inicializar el biblioteca
+### Inicializar la biblioteca
Puedes inicializar RUM utilizando uno de dos métodos de tu archivo `main.dart`.
@@ -161,7 +161,7 @@ Puedes inicializar RUM utilizando uno de dos métodos de tu archivo `main.dart`.
})
```
-2. Como alternativa, configura manualmente [Rastreo de errores][4] y el rastreo de recursos. `DatadogSdk.runApp` llama a `WidgetsFlutterBinding.ensureInitialized`, por lo que si no utilizas `DatadogSdk.runApp`, deberá llamar a este método antes de llamar a `DatadogSdk.instance.initialize`.
+2. Como alternativa, configura manualmente [Rastreo de errores][4] y el rastreo de recursos. `DatadogSdk.runApp` llama a `WidgetsFlutterBinding.ensureInitialized`, por lo que si no utilizas `DatadogSdk.runApp`, deberás llamar a este método antes de llamar a `DatadogSdk.instance.initialize`.
```dart
WidgetsFlutterBinding.ensureInitialized();
@@ -183,15 +183,15 @@ Puedes inicializar RUM utilizando uno de dos métodos de tu archivo `main.dart`.
runApp(const MyApp());
```
-### Muestrear sesiones de RUM
+### Muestreo de sesiones de RUM
-Para controlar los datos que tu aplicación envía a Datadog RUM, puedes especificar una frecuencia de muestreo para las sesiones RUM mientras inicializas el SDK de Flutter RUM como un porcentaje entre 0 y 100. De forma predeterminada, `sessionSamplingRate` se configura en 100 (mantener todas las sesiones).
+Para controlar los datos que tu aplicación envía a Datadog RUM, puedes especificar una frecuencia de muestreo para las sesiones de RUM, mientras inicializas el SDK de Flutter RUM como un porcentaje entre 0 y 100. De forma predeterminada, `sessionSamplingRate` se configura en 100 (conservar todas las sesiones).
-Por ejemplo, para conservar solo el 50% de las sesiones, utiliza:
+Por ejemplo, para conservar solo el 50 % de las sesiones, utiliza:
```dart
-final config = DatadogConfiguration(
- // other configuration...
+configuración final = DatadogConfiguration(
+ // otra configuración...
rumConfiguration: DatadogRumConfiguration(
applicationId: '',
sessionSamplingRate: 50.0,
@@ -201,13 +201,13 @@ final config = DatadogConfiguration(
### Configurar el consentimiento del rastreo
-Para cumplir con la normativa GDPR, el SDK de Datadog Flutter requiere el valor `trackingConsent` en la inicialización.
+Para cumplir con la normativa del Reglamento general de protección de datos (RGPD), el SDK de Datadog Flutter requiere el valor `trackingConsent` en la inicialización.
Configura `trackingConsent` en uno de los siguientes valores:
- `TrackingConsent.pending`: El SDK de Datadog Flutter comienza a recopilar y procesar los datos por lotes, pero no los envía a Datadog. Espera al nuevo valor de consentimiento de rastreo para decidir qué hacer con los datos procesados por lotes.
- `TrackingConsent.granted`: El SDK de Datadog Flutter comienza a recopilar los datos y los envía a Datadog.
-- `TrackingConsent.notGranted`: El SDK de Flutter Datadog no recopila ningún dato, lo que significa que no se envía ningún log, traza (trace) ni eventos de RUM a Datadog.
+- `TrackingConsent.notGranted`: El SDK de Flutter Datadog no recopila ningún dato, lo que significa que no se envía ningún log, traza (trace) ni evento de RUM a Datadog.
Para cambiar el valor del consentimiento del rastreo después de la inicialización del SDK, utiliza la llamada a la API `DatadogSdk.setTrackingConsent`.
@@ -224,7 +224,7 @@ El complemento de Datadog Flutter puede rastrear automáticamente rutas con nomb
```dart
MaterialApp(
- home: HomeScreen(),
+ inicio: HomeScreen(),
navigatorObservers: [
DatadogNavigationObserver(DatadogSdk.instance),
],
@@ -299,12 +299,12 @@ Para activar [Rastreo distribuido][6] de Datadog, configura la propiedad `Datado
- `firstPartyHosts` no permite comodines, pero coincide con cualquier subdominio de un dominio determinado. Por ejemplo, `api.example.com` coincide con `staging.api.example.com` y `prod.api.example.com`, no con `news.example.com`.
-- `DatadogRumConfiguration.traceSampleRate` configura una tasa de muestreo por defecto del 20%. Si deseas que todas las solicitudes de recursos generen una traza distribuida completa, configura este valor en `100.0`.
+- `DatadogRumConfiguration.traceSampleRate` configura una tasa de muestreo por defecto del 20 %. Si deseas que todas las solicitudes de recursos generen una traza distribuida completa, configura este valor en `100.0`.
## Rastreo automático de las acciones
-Utiliza [`RumUserActionDetector`][13] para rastrear las pulsaciones del usuario que se producen en un determinado árbol de widget:
+Utiliza [`RumUserActionDetector`][13] para rastrear las pulsaciones del usuario que se producen en un determinado árbol de widgets:
``dart
RumUserActionDetector(
@@ -318,11 +318,11 @@ RumUserActionDetector(
);
```
-`RumUserActionDetector` detecta automáticamente las acciones pulsadas del usuario que se producen en su árbol y las envía a RUM. Detecta interacciones con varios widgets frecuentes de Flutter.
+`RumUserActionDetector` detecta automáticamente las acciones pulsadas del usuario que se producen en su árbol y las envía a RUM. Detecta interacciones con varios widgets frecuentes de Flutter.
Para la mayoría de los tipos de botones, el detector busca un widget `Text` secundario, que utiliza para la descripción de la acción. En otros casos, busca un objeto `Semantics` secundario o un `Icon` con su propiedad `Icon.semanticsLabel` configurada.
-Alternativamente, puede encerrar cualquier árbol de widgets con una [`RumUserActionAnnotation`][14], que utiliza la descripción proporcionada al informar de las acciones del usuario detectadas en el árbol secundario, sin cambiar la semántica del árbol.
+Alternativamente, puedes encerrar cualquier árbol de widgets con una [`RumUserActionAnnotation`][14], que utiliza la descripción proporcionada al informar de las acciones del usuario detectadas en el árbol secundario, sin cambiar la semántica del árbol.
```dart
Contenedor(
@@ -350,6 +350,15 @@ Contenedor(
);
```
+## Envío de datos cuando el dispositivo está desconectado
+
+RUM garantiza la disponibilidad de los datos cuando el dispositivo del usuario está desconectado. En los casos de zonas con baja conexión de red o cuando la carga de la batería del dispositivo es demasiado baja, todos los eventos de RUM se almacenan primero en el dispositivo local por lotes. Se envían en cuanto red está disponible y la carga de la batería es lo suficientemente alta como para garantizar que el SDK de RUM de Flutter no afecte a la experiencia del usuario final. Si la red no está disponible cuando la aplicación se ejecuta en primer plano o si falla una carga de datos, el lote se guarda hasta que pueda enviarse correctamente.
+
+Esto significa que incluso si los usuarios abren tu aplicación mientras están desconectados, no se pierde ningún dato.
+
+**Nota**: Los datos del disco se eliminan automáticamente si se vuelven demasiado antiguos para garantizar que el SDK de Flutter RUM no utilice demasiado espacio del disco.
+
+
## Referencias adicionales
{{< partial name="whats-next/whats-next.html" >}}
diff --git a/content/es/real_user_monitoring/mobile_and_tv_monitoring/setup/ios.md b/content/es/real_user_monitoring/mobile_and_tv_monitoring/setup/ios.md
index 5fe0ed07d5b52..2e1ed96a8d8e8 100644
--- a/content/es/real_user_monitoring/mobile_and_tv_monitoring/setup/ios.md
+++ b/content/es/real_user_monitoring/mobile_and_tv_monitoring/setup/ios.md
@@ -461,6 +461,15 @@ RUM.enable(
[iOS Crash Reporting and Error Tracking][17] muestra cualquier problema en tu aplicación y los últimos errores disponibles. Puedes ver los detalles y atributos de los errores, incluido JSON, en el [RUM Explorer][18].
+## Envío de datos cuando el dispositivo está desconectado
+
+RUM garantiza la disponibilidad de los datos cuando el dispositivo del usuario está desconectado. En casos de zonas con baja conexión de red o cuando la carga de la batería del dispositivo es demasiado baja, todos los eventos de RUM se almacenan primero en el dispositivo local en lotes. Se envían tan pronto como la red esté disponible y la carga de la batería sea lo suficientemente alta como para garantizar que el SDK de RUM para iOS no afecte a la experiencia del usuario final. Si la red no está disponible mientras tu aplicación está en primer plano o si falla una carga de datos, el lote se conserva hasta que se lo pueda enviar con éxito.
+
+Esto significa que incluso si los usuarios abren tu aplicación mientras están desconectados, no se pierde ningún dato.
+
+**Nota**: Los datos en el disco se descartan automáticamente si se hacen demasiado viejos para garantizar que el SDK de RUM para iOS no utilice demasiado espacio del disco.
+
+
## Versiones compatibles
Consulta [Versiones compatibles][19] para ver una lista versiones de sistemas operativos y plataformas que son compatibles con el SDK de RUM iOS.
diff --git a/content/es/real_user_monitoring/mobile_and_tv_monitoring/setup/reactnative.md b/content/es/real_user_monitoring/mobile_and_tv_monitoring/setup/reactnative.md
index 85eae312a2231..383f6956b76c0 100644
--- a/content/es/real_user_monitoring/mobile_and_tv_monitoring/setup/reactnative.md
+++ b/content/es/real_user_monitoring/mobile_and_tv_monitoring/setup/reactnative.md
@@ -361,6 +361,15 @@ Utiliza una de las integraciones de Datadog para realizar un rastreo automático
Si tienes algún problema para configurar el rastreo de vistas con `@datadog/mobile-react-navigation`, puedes consultar este [ejemplo de aplicación][16] de Datadog como referencia.
+## Envío de datos cuando el dispositivo está desconectado
+
+RUM garantiza la disponibilidad de los datos cuando el dispositivo del usuario está desconectado. En casos de zonas con baja conexión de red o cuando la carga de la batería del dispositivo es demasiado baja, todos los eventos de RUM se almacenan primero en el dispositivo local en lotes. Se envían tan pronto como la red esté disponible y la carga de la batería sea lo suficientemente alta como para asegurar que el SDK de React Native de RUM no afecte a la experiencia del usuario final. Si la red no está disponible cuando tu aplicación está ejecutándose en primer plano o si falla una carga de datos, el lote se conserva hasta que pueda enviarse correctamente.
+
+Esto significa que incluso si los usuarios abren tu aplicación mientras están desconectados, no se pierde ningún dato.
+
+**Nota**: Los datos del disco se eliminan automáticamente si se vuelven demasiado antiguos para garantizar que el SDK de React Native de RUM no utilice demasiado espacio del disco.
+
+
## Rastrear eventos en segundo plano
El rastreo de eventos en segundo plano puede dar lugar a sesiones adicionales, lo que puede afectar a la facturación. Si tienes dudas, contacta con el equipo de soporte de Datadog.
diff --git a/content/es/real_user_monitoring/mobile_and_tv_monitoring/troubleshooting/android.md b/content/es/real_user_monitoring/mobile_and_tv_monitoring/troubleshooting/android.md
index 2a49c767b9787..d7153c8da75ad 100644
--- a/content/es/real_user_monitoring/mobile_and_tv_monitoring/troubleshooting/android.md
+++ b/content/es/real_user_monitoring/mobile_and_tv_monitoring/troubleshooting/android.md
@@ -39,31 +39,23 @@ Para cumplir con la normativa del Reglamento general de protección de datos (RG
El consentimiento de rastreo puede ser uno de los siguientes valores:
- `TrackingConsent.PENDING`: (Predeterminado) El SDK comienza a recopilar los datos y a procesarlos por lotes, pero no los envía al
- punto de conexión de recopilación. El SDK espera el nuevo valor del consentimiento de rastreo para decidir qué hacer con los datos procesados por lotes.
-- `TrackingConsent.GRANTED`: el SDK comienza a recopilar los datos y los envía al punto de conexión de recopilación de datos.
+ endpoint de recopilación. El SDK espera el nuevo valor del consentimiento de rastreo para decidir qué hacer con los datos procesados por lotes.
+- `TrackingConsent.GRANTED`: el SDK comienza a recopilar los datos y los envía al endpoint de recopilación de datos.
- `TrackingConsent.NOT_GRANTED`: El SDK no recopila ningún dato. No puedes enviar manualmente ningún log, traza ni
evento de RUM.
Para actualizar el consentimiento de rastreo después de inicializar el SDK, llama a `Datadog.setTrackingConsent(
)`. El SDK cambia de comportamiento de acuerdo con el nuevo consentimiento. Por ejemplo, si el consentimiento de rastreo actual es `TrackingConsent.PENDING` y lo actualizas a:
-- `TrackingConsent.GRANTED`: el SDK envía todos los datos actuales procesados por lotes y los datos futuros directamente al punto de conexión de recopilación de datos.
+- `TrackingConsent.GRANTED`: el SDK envía todos los datos actuales procesados por lotes y los datos futuros directamente al endpoint de recopilación de datos.
- `TrackingConsent.NOT_GRANTED`: el SDK borra todos los datos procesados por lotes y no recopila datos futuros.
-## Envío de datos cuando el dispositivo está desconectado
-
-RUM garantiza la disponibilidad de los datos cuando el dispositivo del usuario está desconectado. En caso de zonas con baja conexión de red o cuando la carga de la batería del dispositivo es demasiado baja, todos los eventos de RUM se almacenan primero en el dispositivo local en lotes.
-
-Cada lote sigue la especificación de entrada. Se envían tan pronto como la red está disponible y la batería está lo suficientemente cargada como para garantizar que el SDK de Datadog no afecte la experiencia del usuario final. Si la red no está disponible mientras tu aplicación está en primer plano o si falla una carga de datos, el lote se conserva hasta que se lo pueda enviar con éxito.
-
-Esto significa que incluso si los usuarios abren tu aplicación mientras están desconectados, no se pierde ningún dato. Para garantizar que el SDK no utilice demasiado espacio de disco, los datos del disco se descartan automáticamente si son demasiado antiguos.
-
## Migración a la versión 2.0.0
Si has estado utilizando el SDK v1, se introdujeron algunos cambios de última hora en la versión `2.0.0`. Consulta la [guía para la migración][2] para obtener más información.
## Referencias adicionales
-{{< nombre parcial="whats-next/whats-next.html" >}}
+{{< partial name="whats-next/whats-next.html" >}}
[1]: /es/help
[2]: https://github.com/DataDog/dd-sdk-android/blob/develop/MIGRATION.MD
\ No newline at end of file
diff --git a/content/es/real_user_monitoring/mobile_and_tv_monitoring/troubleshooting/ios.md b/content/es/real_user_monitoring/mobile_and_tv_monitoring/troubleshooting/ios.md
index e5d9b6ba9ba76..35d4b4f85e858 100644
--- a/content/es/real_user_monitoring/mobile_and_tv_monitoring/troubleshooting/ios.md
+++ b/content/es/real_user_monitoring/mobile_and_tv_monitoring/troubleshooting/ios.md
@@ -84,14 +84,6 @@ clase privada YourCustomDelegateURLSessionDelegate: NSObject, URLSessionTaskDele
* implementar `URLSessionDataDelegate` y reenviar:
* [`urlSession(_:dataTask:didReceive:)`][6]
-## Envío de datos cuando el dispositivo está desconectado
-
-RUM garantiza la disponibilidad de los datos cuando el dispositivo del usuario está desconectado. En casos de zonas con baja conexión de red o cuando la carga de la batería del dispositivo es demasiado baja, todos los eventos de RUM se almacenan primero en el dispositivo local en lotes. Se envían tan pronto como la red esté disponible y la carga de la batería sea lo suficientemente alta como para garantizar que el SDK de RUM para iOS no afecte a la experiencia del usuario final. Si la red no está disponible mientras tu aplicación está en primer plano o si falla una carga de datos, el lote se conserva hasta que se lo pueda enviar con éxito.
-
-Esto significa que incluso si los usuarios abren tu aplicación mientras está desconectada, no se pierde ningún dato.
-
-**Nota**: Los datos en el disco se descartan automáticamente si se hacen demasiado viejos para garantizar que el SDK de RUM para iOS no utilice demasiado espacio del disco.
-
## Referencias adicionales
{{< partial name="whats-next/whats-next.html" >}}
diff --git a/content/es/real_user_monitoring/mobile_and_tv_monitoring/troubleshooting/reactnative.md b/content/es/real_user_monitoring/mobile_and_tv_monitoring/troubleshooting/reactnative.md
index e6924dc00b26e..57768b6166469 100644
--- a/content/es/real_user_monitoring/mobile_and_tv_monitoring/troubleshooting/reactnative.md
+++ b/content/es/real_user_monitoring/mobile_and_tv_monitoring/troubleshooting/reactnative.md
@@ -1,8 +1,7 @@
---
code_lang: reactnative
code_lang_weight: 50
-description: Aprenda a solucionar problemas con la monitorización
- de React Native.
+description: Aprenda a solucionar problemas con la monitorización de React Native.
further_reading:
- link: https://github.com/DataDog/dd-sdk-reactnative
tag: Código fuente
@@ -20,9 +19,9 @@ Si experimentas un comportamiento inesperado con Datadog React Native RUM, utili
## No se envían datos a Datadog
-Sigue estas instrucciones en orden cuando se haya instalado el SDK y la aplicación compile, pero Datadog no reciba ningún dato.
+Sigue estas instrucciones en orden cuando se haya instalado el SDK y la compilación de la aplicación, pero Datadog no reciba ningún dato.
-### Haz un check de la configuración
+### Check la configuración
A veces, no se envía ningún dato debido a un pequeño error en la configuración.
@@ -33,7 +32,7 @@ Estas son algunas de las cosas más frecuentes para hacer un check:
- Si has configurado un `Proxy` en la configuración de Datadog, check que se haya configurado correctamente.
- Check que estés **rastreando vistas** (todos los eventos deben estar adjuntos a una vista) y **enviando eventos**.
-### Revisar logs de SDK en React Native
+### Revisar los logs de SDK en React Native
- Configura `config.verbosity = SdkVerbosity.DEBUG`, que importa `SdkVerbosity` desde `@datadog/mobile-react-native`.
- Los logs comienzan a aparecer en la consola de JavaScript, como la siguiente salida:
@@ -67,14 +66,14 @@ Si utilizas `DdSdkReactNative.initialize` para iniciar el SDK de Datadog, llama
A partir de la versión del SDK `1.2.0`, puedes inicializar el SDK utilizando el componente `DatadogProvider`. Este componente incluye un buffer de eventos de RUM que se asegura de que el SDK se inicialice antes de enviar cualquier dato a Datadog, lo que evita que se produzca este problema.
-Para utilizarlo, consulta la [Guía de migración al proveedor de Datadog][1].
+Para utilizarlo, consulta la [Guía para la migración al proveedor de Datadog][1].
[1]: https://github.com/DataDog/dd-sdk-reactnative/blob/develop/docs/migrating_to_datadog_provider.md
{{% /pestaña %}}
{{< /pestañas >}}
-### Revisión de logs nativos
+### Revisión de los logs nativos
Revisar los logs nativos puede darte más información sobre lo que podría estar fallando.
@@ -86,7 +85,7 @@ Revisar los logs nativos puede darte más información sobre lo que podría esta
{{< img src="real_user_monitoring/react_native/troubleshooting-xcode-logs.png" alt="Revisar los logs nativos puede ayudarte a averiguar por qué no se está enviando ningún dato" >}}
-Puedes filtrar Logs por "DATADOG" y buscar cualquier error.
+Puedes filtrar los logs por "DATADOG" y buscar cualquier error.
Si efectivamente estás enviando eventos, deberías ver los siguientes logs:
@@ -117,7 +116,7 @@ Si utilizas `DdSdkReactNative.initialize` para iniciar el SDK de Datadog, llama
A partir de la versión del SDK `1.2.0`, puedes inicializar el SDK utilizando el componente `DatadogProvider`. Este componente incluye un buffer de eventos de RUM que se asegura de que el SDK se inicialice antes de enviar cualquier dato a Datadog, lo que evita que se produzca este problema.
-Para utilizarlo, consulta la [Guía de migración al proveedor de Datadog ][1].
+Para utilizarlo, consulta la [Guía para la migración al proveedor de Datadog ][1].
[1]: https://github.com/DataDog/dd-sdk-reactnative/blob/develop/docs/migrating_to_datadog_provider.md
@@ -158,7 +157,7 @@ En este ejemplo, el último log indica que el lote de datos de RUM se ha enviado
Si aparece el siguiente mensaje de error
```
-Símbolos indefinidos para la arquitectura x86_64:
+Símbolos no definidos para la arquitectura x86_64:
"static Foundation.JSONEncoder.OutputFormatting.withoutEscapingSlashes.getter : Foundation.JSONEncoder.OutputFormatting", referenciado desde:
static (extensión en Datadog):Foundation.JSONEncoder.default() -> Foundation.JSONEncoder en libDatadogSDK.a(JSONEncoder.o)
...
@@ -206,7 +205,7 @@ Fallo en la ejecución de la tarea ':app:processReleaseMainManifest'.
> No es posible que Java.lang.String Java.io.File.path final privado de campo sea accesible: el módulo Java.base no "abre Java.io" al módulo sin nombre @1bbf7f0e
```
-Estás utilizando Java 17, que no es compatible con tu versión de React Native. Cambia a Java 11 para resolver el problema.
+Estás utilizando Java 17, que no es compatible con tu versión de React Native. Cambia a Java 11 para solucionar el problema.
### java.lang.UnsupportedClassVersionError
@@ -279,18 +278,9 @@ dependencias {
}
```
-## Envío de datos cuando el dispositivo está desconectado
-
-RUM garantiza la disponibilidad de los datos cuando el dispositivo del usuario está desconectado. En casos de zonas con bajas conexiones de red o cuando la carga de la batería del dispositivo es demasiado baja, todos los eventos de RUM se almacenan primero en el dispositivo local en lotes. Se envían tan pronto como la red esté disponible y la carga de la batería sea lo suficientemente alta como para asegurar que el SDK de React Native de RUM no afecte a la experiencia del usuario final. Si la red no está disponible cuando tu aplicación está ejecutándose en primer plano o si falla una carga de datos, el lote se conserva hasta que pueda enviarse correctamente.
-
-Esto significa que incluso si los usuarios abren tu aplicación mientras están desconectados, no se pierde ningún dato.
-
-**Nota**: Los datos del disco se eliminan automáticamente si se vuelven demasiado antiguos para garantizar que el SDK de React Native de RUM no utilice demasiado espacio del disco.
-
## Referencias adicionales
-{{< nombre parcial="whats-next/whats-next.html" >}}
-
+{{< partial name="whats-next/whats-next.html" >}}
[1]: /es/help
[2]: https://github.com/JakeWharton/pidcat
diff --git a/content/es/security/application_security/how-appsec-works.md b/content/es/security/application_security/how-appsec-works.md
index 7a4c7c33e515a..43f697f797ed6 100644
--- a/content/es/security/application_security/how-appsec-works.md
+++ b/content/es/security/application_security/how-appsec-works.md
@@ -39,13 +39,17 @@ Las funciones de monitorización y detección de amenazas de Datadog identifican
-### Identificar las bibliotecas de servicios vulnerables
+### Identificar vulnerabilidades en las bibliotecas de código abierto utilizadas por servicios
El [Análisis de la composición del software][5] de Datadog utiliza varias fuentes de datos de vulnerabilidades conocidas relacionadas con bibliotecas de software de código abierto, además de información proporcionada por el equipo de investigación de seguridad de Datadog, para emparejar las bibliotecas de las que depende tu aplicación en tiempo de ejecución con tus vulnerabilidades potenciales, y recomendar correcciones.
+### Identificar vulnerabilidades a nivel de código en servicios
+
+Datadog [Code Security][28] identifica las vulnerabilidades a nivel de código en servicios y proporciona información práctica y correcciones recomendadas. Utiliza un enfoque de Tests interactivos de seguridad de aplicaciones (IAST) para encontrar vulnerabilidades en el código de las aplicaciones. IAST utiliza la instrumentación incrustada en el código, de forma similar a Application Performance Monitoring (APM), lo que permite a Datadog identificar vulnerabilidades utilizando el tráfico legítimo de la aplicación en lugar de depender de tests externos que pueden requerir configuración adicional o una programación periódica. Datadog Code Security proporciona automáticamente la información que los equipos necesitan para localizar una vulnerabilidad en una aplicación, desde el nombre del archivo afectado hasta el método y el número de línea exactos.
+
## Compatibilidad
-Para que Datadog Application Security sea compatible con tu configuración de Datadog, debes tener APM habilitado y [enviando trazas a Datadog][6]. Application Security utiliza las mismas bibliotecas que APM, por lo que no necesitas desplegar o mantener otra biblioteca.
+Para que Datadog Application Security sea compatible con tu configuración de Datadog, debes tener APM habilitado y [enviando trazas (traces) a Datadog][6]. Application Security utiliza las mismas bibliotecas que APM, por lo que no necesitas desplegar ni mantener otra biblioteca.
Los pasos para habilitar Datadog Application Security son específicos de cada lenguaje de tiempo de ejecución. Consulta si tu lenguaje es compatible con los requisitos previos de Application Security de cada producto.
@@ -53,7 +57,7 @@ Los pasos para habilitar Datadog Application Security son específicos de cada l
Datadog Application Security para AWS Lambda proporciona una amplia visibilidad de los atacantes que tienen como objetivo tus funciones. Gracias al rastreo distribuido, que te proporciona una descripción del ataque rica en contexto, puedes evaluar el impacto y corregir la amenaza de forma eficaz.
-Consulta [Habilitar Application Security para serverless][8] para obtener más información sobre cómo configurarlo.
+Consulta [Habilitar Application Security para Serverless][8] para obtener más información sobre cómo configurarlo.
## Rendimiento
@@ -71,9 +75,9 @@ Los datos de las trazas de seguridad se conservan durante 90 días. Los datos de
## Privacidad de los datos
-De forma predeterminada, Application Security recopila información de las trazas de seguridad para ayudarte a entender por qué la solicitud se ha marcado como sospechosa. Antes de enviar los datos, Application Security los analiza en busca de patrones y palabras clave que indiquen que los datos son confidenciales. Si los datos se consideran confidenciales, se sustituyen por una marca ``. Esto indica que la solicitud era sospechosa, pero que los datos de la solicitud no pudieron ser recopilados por motivos de seguridad de los datos.
+De forma predeterminada, Application Security recopila información de las trazas de seguridad para ayudarte a comprender por qué la solicitud se ha marcado como sospechosa. Antes de enviar los datos, Application Security los analiza en busca de patrones y palabras clave que indiquen que los datos son confidenciales. Si los datos se consideran confidenciales, se sustituyen por una marca ``. Esto indica que la solicitud era sospechosa, pero que los datos de la solicitud no pudieron ser recopilados por motivos de seguridad de los datos.
-Los siguientes son algunos ejemplos de datos que se marcan como confidenciales por defecto:
+Los siguientes son algunos ejemplos de datos que se marcan como confidenciales de forma predeterminada:
* `pwd`, `password`, `ipassword`, `pass_phrase`
* `secret`
* `key`, `api_key`, `private_key`, `public_key`
@@ -102,40 +106,40 @@ Las señales de seguridad se crean automáticamente cuando Datadog detecta ataqu
## Clasificación del intento de ataque
-Utilizando la información del rastreo distribuido, los intentos de ataque se clasifican como seguros, desconocidos o dañinos.
-* Los intentos de ataque clasificados como seguros no pueden vulnerar tu aplicación, por ejemplo, cuando un ataque de inyección PHP apunta a un servicio escrito en Java.
+Mediante la utilización de la información del rastreo distribuido, los intentos de ataque se clasifican como seguros, desconocidos o dañinos.
+* Los intentos de ataque clasificados como seguros no pueden vulnerar tu aplicación, por ejemplo, cuando un ataque de inserción PHP apunta a un servicio escrito en Java.
* La clasificación de desconocido se asigna cuando no hay suficiente información para emitir un juicio definitivo sobre la probabilidad de éxito del ataque.
-* Se muestra una clasificación dañina cuando hay pruebas de que el atacante ha encontrado alguna vulnerabilidad a nivel del código.
+* Se muestra una clasificación de dañino cuando hay pruebas de que el atacante ha encontrado alguna vulnerabilidad a nivel del código.
## Cobertura de la monitorización de amenazas
-Datadog Application Security incluye más de 100 firmas de ataque que te ayudan a protegerte contra [muchos tipos diferentes de ataques][14], incluyendo, pero sin limitarse, las siguientes categorías:
+Datadog Application Security incluye más de 100 firmas de ataque que te ayudan a protegerte contra [muchos tipos diferentes de ataques][14], incluidas, entre otras, las siguientes categorías:
* Inyecciones SQL
* Inyecciones de código
* Inyecciones de shell
* Inyecciones NoSQL
-* Cross-Site Scripting (XSS) reflejado
+* Cross-Site Scripting (XSS)
* Falsificación de solicitudes del lado del servidor (SSRF)
## Detección de vulnerabilidades integrada
-Datadog Application Security ofrece capacidades de detección incorporadas que te avisan de las vulnerabilidades detectadas en tus dependencias de código abierto. Los detalles de esa información se muestran en el [Explorador de vulnerabilidades][15] e identifican la gravedad, los servicios afectados, la infraestructura potencialmente vulnerable y las instrucciones para solucionar los riesgos detectados.
+Datadog Application Security ofrece funciones de detección integradas que te avisan de las vulnerabilidades detectadas en el código de tu aplicación y en las dependencias de código abierto. Los detalles de esa información se muestran en el [Explorador de vulnerabilidades][15], identificando la gravedad, los servicios afectados, la infraestructura potencialmente vulnerable y las instrucciones de corrección para solucionar los riesgos surgidos.
-Para obtener más información, consulta [Análisis de la composición del software][5].
+Para más información, consulta [Seguridad del código][28] y [Análisis de la composición del software][5].
## Seguridad de la API
La seguridad de la API está en fase beta privada.
-Datadog Application Security proporciona visibilidad de las amenazas dirigidas a tus API. Utiliza el [Catálogo de API][27] para monitorizar la salud y las métricas de rendimiento de las API, donde puedes ver los ataques dirigidos a tus API. Esta vista incluye la IP del atacante y la información de autenticación, así como las cabeceras de solicitud que muestran detalles sobre cómo se ha formado el ataque. Utilizando Application Security y la gestión de las API, puedes tener una visión completa de la superficie de ataque a tu API y responder para mitigar las amenazas.
+Datadog Application Security proporciona visibilidad de las amenazas dirigidas a tus API. Utiliza el [Catálogo de API][27] para monitorizar el mantenimiento y las métricas de rendimiento de las API, donde puedes ver los ataques dirigidos a tus API. Esta vista incluye la IP y la información de autenticación del atacante, así como los encabezados de la solicitud que muestran detalles sobre cómo se formó el ataque. Utilizando Application Security y la gestión de las API, puedes tener una visión completa de la superficie de ataque a tu API y responder para mitigar las amenazas.
-## Cómo Datadog Application Security protege contra Log4Shell
+## Cómo protege Datadog Application Security contra Log4Shell
-Datadog Application Security identifica las cargas útiles de ataque Log4j Log4Shell y proporciona una visibilidad de las aplicaciones vulnerables que intentan cargar código malicioso de forma remota. Cuando se combina con el resto de [Cloud SIEM][16] de Datadog, puedes investigar la actividad habitual posterior a la explotación y corregir los servicios web Java potencialmente vulnerables que actúan como vectores de ataque.
+Datadog Application Security identifica las cargas útiles de ataque Log4j Log4Shell y proporciona una visibilidad de las aplicaciones vulnerables que intentan cargar un código malicioso de forma remota. Cuando se combina con el resto de [Cloud SIEM de Datadog][16], puedes investigar para identificar la actividad frecuente posterior a la explotación y corregir en forma proactiva los servicios web Java potencialmente vulnerables que actúan como vectores del ataque.
## Referencias adicionales
@@ -159,4 +163,5 @@ Datadog Application Security identifica las cargas útiles de ataque Log4j Log4S
[17]: /es/security/application_security/threats/library_configuration/#data-security-considerations
[25]: /es/security/application_security/threats/add-user-info#adding-business-logic-information-login-success-login-failure-any-business-logic-to-traces
[26]: /es/agent/remote_config/#enabling-remote-configuration
-[27]: /es/tracing/api_catalog/
\ No newline at end of file
+[27]: /es/tracing/api_catalog/
+[28]: /es/security/application_security/code_security/
\ No newline at end of file
diff --git a/content/es/security/cloud_security_management/troubleshooting/vulnerabilities.md b/content/es/security/cloud_security_management/troubleshooting/vulnerabilities.md
index 6daceda65aa1a..cae37de55a8ac 100644
--- a/content/es/security/cloud_security_management/troubleshooting/vulnerabilities.md
+++ b/content/es/security/cloud_security_management/troubleshooting/vulnerabilities.md
@@ -47,15 +47,6 @@ ERROR | (pkg/workloadmeta/collectors/internal/containerd/image_sbom_trivy.go:80
La solución para este problema es establecer la opción de configuración `discard_unpacked_layers=false` en el archivo de configuración de contenedor.
-## Ver métricas relacionadas
-
-1. Ve a **[Metrics > Summary][4]** (Métricas > Resumen) en Datadog.
-2. Buscar las siguientes métricas para ayudar a solucionar problemas:
- - `datadog.agent.sbom_attempts`: rastrea los intentos de recopilación de sbom por `source` y `type`.
- - `datadog.agent.sbom_generation_duration`: mide el tiempo que se tarda en generar SBOMs en segundos.
- - `datadog.agent.sbom_errors`: número de fallos sbom por `source`, `type` y `reason`.
- - `datadog.agent.export_size`: el tamaño del archivo escrito en disco.
-
## Referencias adicionales
{{< partial name="whats-next/whats-next.html" >}}
diff --git a/content/es/serverless/step_functions/enhanced-metrics.md b/content/es/serverless/step_functions/enhanced-metrics.md
index ba7f2bcb0d44b..2b48759568512 100644
--- a/content/es/serverless/step_functions/enhanced-metrics.md
+++ b/content/es/serverless/step_functions/enhanced-metrics.md
@@ -30,9 +30,6 @@ Están disponibles las siguientes métricas mejoradas de Step Functions.
`aws.states.enhanced.task.execution.task_duration`
: Distribución de las duraciones de las tareas individuales.
-`aws.states.enhanced.task.execution.tasks_timed_out`
-: Counts el número total de tareas que han agotado el tiempo de espera.
-
`aws.states.enhanced.state.run_duration`
: gauge para las duraciones de las ejecuciones de un estado.
diff --git a/content/es/tracing/metrics/runtime_metrics/dotnet.md b/content/es/tracing/metrics/runtime_metrics/dotnet.md
new file mode 100644
index 0000000000000..4ff1e1f82a676
--- /dev/null
+++ b/content/es/tracing/metrics/runtime_metrics/dotnet.md
@@ -0,0 +1,79 @@
+---
+aliases:
+- /es/tracing/runtime_metrics/dotnet
+code_lang: dotnet
+code_lang_weight: 50
+description: Obtén información adicional sobre el rendimiento de tu aplicación .NET
+ con las métricas de tiempo de ejecución asociadas a tus trazas (traces).
+further_reading:
+- link: tracing/other_telemetry/connect_logs_and_traces
+ tag: Documentación
+ text: Conecta tus logs y trazas
+- link: tracing/trace_collection/custom_instrumentation
+ tag: Documentación
+ text: Instrumenta tu aplicación de forma manual para crear trazas.
+- link: tracing/glossary/
+ tag: Documentación
+ text: Explora tus servicios, recursos y trazas
+- link: https://www.datadoghq.com/blog/dotnet-runtime-metrics/
+ tag: Blog
+ text: Monitorizar métricas de tiempo de ejecución de .NET con Datadog
+title: Métricas de tiempo de ejecución de .NET
+type: multi-code-lang
+---
+
+## Compatibilidad de las métricas de tiempo de ejecución
+
+- .NET Framework 4.6.1 o posterior
+- .NET Core 3.1
+- .NET 5
+- .NET 6
+- .NET 7
+- .NET 8
+
+## Configuración automática
+
+Habilita la recopilación de métricas de tiempo de ejecución en .NET Tracer 1.23.0+ con la variable de entorno `DD_RUNTIME_METRICS_ENABLED=true`.
+
+Ve las métricas de tiempo de ejecución en correlación con tus servicios de .NET. Consulta el [Catálogo de servicios][1] en Datadog.
+
+Por defecto, las métricas de tiempo de ejecución de tu aplicación se envían al Datadog Agent con DogStatsD por el puerto `8125`. Asegúrate de que [DogStatsD está habilitado para el Agent][2].
+
+Si estás ejecutando el Agent como un contenedor, asegúrate de que `DD_DOGSTATSD_NON_LOCAL_TRAFFIC` [se establece en true][3] y que el puerto `8125` está abierto en el Agent. Además, para:
+
+- **Kubernetes**: _debes_ [vincular el puerto DogStatsD a un puerto host][4].
+- **ECS**: [Establece los indicadores apropiados en la definición de tu tarea][5].
+
+Alternativamente, el Agent puede ingerir métricas con un Unix Domain Socket (UDS) como alternativa al transporte UDP. Para más información, lee [DogStatsD en Unix Domain Socket][7].
+
+## Datos recopilados
+
+Las siguientes métricas se recopilan por defecto después de activar las metricas de .NET.
+
+{{< get-metrics-from-git "dotnet" >}}
+
+Además de mostrar estas métricas en tu Página de servicios de APM, Datadog proporciona un [dashboard de tiempo de ejecución de .NET predeterminado][6].
+
+## Permisos adicionales para IIS
+
+En .NET Framework, las métricas se recopilan mediante contadores de rendimiento. Los usuarios en sesiones de inicio de sesión no interactivas (que incluyen cuentas de grupos de aplicaciones IIS y algunas cuentas de servicio) deben añadirse al grupo **Usuarios de monitorización de rendimiento** para acceder a los datos del contador.
+
+Los grupos de aplicaciones IIS utilizan cuentas especiales que no aparecen en lista de usuarios. Para añadirlas al grupo de usuarios de monitorización de rendimiento, busca `IIS APPPOOL\`. Por ejemplo, el usuario para el DefaultAppPool sería `IIS APPPOOL\DefaultAppPool`.
+
+Puedes hacer esto desde la interfaz de usuario "Gestión de ordenadores" o desde una acción de comando del administrador:
+
+```
+net localgroup "Performance Monitor Users" "IIS APPPOOL\DefaultAppPool" /add
+```
+
+## Leer más
+
+{{< partial name="whats-next/whats-next.html" >}}
+
+[1]: https://app.datadoghq.com/services
+[2]: /es/developers/dogstatsd/#setup
+[3]: /es/agent/docker/#dogstatsd-custom-metrics
+[4]: /es/developers/dogstatsd/?tab=kubernetes#agent
+[5]: /es/agent/amazon_ecs/#create-an-ecs-task
+[6]: https://app.datadoghq.com/dash/integration/30412/net-runtime-metrics
+[7]: /es/developers/dogstatsd/unix_socket/
\ No newline at end of file
diff --git a/content/es/tracing/metrics/runtime_metrics/java.md b/content/es/tracing/metrics/runtime_metrics/java.md
new file mode 100644
index 0000000000000..61b14e3961335
--- /dev/null
+++ b/content/es/tracing/metrics/runtime_metrics/java.md
@@ -0,0 +1,67 @@
+---
+aliases:
+- /es/tracing/runtime_metrics/java
+code_lang: java
+code_lang_weight: 10
+description: Obtén información adicional sobre el rendimiento de tu aplicación Java
+ con las métricas de tiempo de ejecución asociadas a tus trazas (traces).
+further_reading:
+- link: tracing/other_telemetry/connect_logs_and_traces
+ tag: Documentación
+ text: Conecta tus logs y trazas
+- link: tracing/trace_collection/custom_instrumentation
+ tag: Documentación
+ text: Instrumenta tu aplicación de forma manual para crear trazas.
+- link: tracing/glossary/
+ tag: Documentación
+ text: Explora tus servicios, recursos y trazas
+title: Métricas de tiempo de ejecución de Java
+type: multi-code-lang
+---
+
+## Configuración automática
+
+La recopilación de métricas de JVM está habilitada por defecto para Java Tracer v0.29.0+. Puedes deshabilitarla con un parámetro de configuración en el cliente de rastreo, ya sea mediante una propiedad del sistema, `-Ddd.jmxfetch.enabled=false`, or through an environment variable, `DD_JMXFETCH_ENABLED=false. `. As of v0.64.0+, you can also use the `variable de entorno DD_RUNTIME_METRICS_ENABLED=false` para deshabilitarla.
+
+Las métricas de tiempo de ejecución de JVM se pueden ver en correlación con tus servicios de Java. Consulta el [Catálogo de servicios][1] en Datadog.
+
+{{< img src="tracing/runtime_metrics/jvm-runtime.png" alt="Tiempo de ejecución de JVM" >}}
+
+Por defecto, las métricas de tiempo de ejecución de tu aplicación se envían al Datadog Agent con DogStatsD por el puerto `8125`. Asegúrate de que [DogStatsD está habilitado para el Agent][2].
+
+Si estás ejecutando el Agent como un contenedor, asegúrate de que `DD_DOGSTATSD_NON_LOCAL_TRAFFIC` [se establece en true][3] y que el puerto `8125` está abierto en el Agent. Además, para:
+
+- **Kubernetes**: _debes_ [vincular el puerto DogStatsD a un puerto host][4].
+- **ECS**: [Establece los indicadores apropiados en la definición de tu tarea][5].
+
+Alternativamente, el Agent puede ingerir métricas con un Unix Domain Socket (UDS) como alternativa al transporte UDP. Para más información, lee [DogStatsD en Unix Domain Socket][9].
+
+**Notas**:
+
+- Para la interfaz de usuario de tiempo de ejecución, se admite `dd-trace-java` >= [`0.24.0`][6].
+- Para asociar métricas de JVM dentro de las gráficas de llamas, asegúrate de que `env: tag` (distingue entre mayúsculas y minúsculas) está configurada y coincide en tu entorno.
+- Para que las métricas de JVM aparezcan en la Página de servicios cuando usas Fargate, asegúrate de que `DD_DOGSTATSD_TAGS` está configurado en tu tarea del Agent, y coincide con la `env: tag` de ese servicio.
+
+## Datos recopilados
+
+Las siguientes métricas se recopilan por defecto por proceso de JVM después de activar las métricas de JVM.
+
+{{< get-metrics-from-git "java" >}}
+
+Además de mostrar estas métricas en tu Página de servicios de APM, Datadog proporciona un [dashboard de tiempo de ejecución de JVM predeterminado][7].
+
+Se pueden añadir métricas de JVM adicionales mediante archivos de configuración que se pasan utilizando `dd.jmxfetch.config.dir` y `dd.jmxfetch.config`. También puedes activar integraciones de JMX y Datadog existentes de forma individual con el parámetro `dd.jmxfetch..enabled=true`. Esto introduce automáticamente la configuración de los archivos de configuración de JMX existentes de Datadog. Consulta [integración de JMX][8] para obtener más información sobre la configuración.
+
+## Leer más
+
+{{< partial name="whats-next/whats-next.html" >}}
+
+[1]: https://app.datadoghq.com/services
+[2]: /es/developers/dogstatsd/#setup
+[3]: /es/agent/docker/#dogstatsd-custom-metrics
+[4]: /es/developers/dogstatsd/?tab=kubernetes#agent
+[5]: /es/agent/amazon_ecs/#create-an-ecs-task
+[6]: https://github.com/DataDog/dd-trace-java/releases/tag/v0.24.0
+[7]: https://app.datadoghq.com/dash/integration/256/jvm-runtime-metrics
+[8]: /es/integrations/java/#configuration
+[9]: /es/developers/dogstatsd/unix_socket/
\ No newline at end of file
diff --git a/content/es/tracing/metrics/runtime_metrics/nodejs.md b/content/es/tracing/metrics/runtime_metrics/nodejs.md
new file mode 100644
index 0000000000000..0bf20f6879f7b
--- /dev/null
+++ b/content/es/tracing/metrics/runtime_metrics/nodejs.md
@@ -0,0 +1,82 @@
+---
+aliases:
+- /es/tracing/runtime_metrics/nodejs
+code_lang: nodejs
+code_lang_weight: 40
+description: Obtén información adicional sobre el rendimiento de tu aplicación Node.js
+ con las métricas de tiempo de ejecución asociadas a tus trazas (traces).
+further_reading:
+- link: tracing/other_telemetry/connect_logs_and_traces
+ tag: Documentación
+ text: Conecta tus logs y trazas
+- link: tracing/trace_collection/custom_instrumentation
+ tag: Documentación
+ text: Instrumenta tu aplicación de forma manual para crear trazas.
+- link: tracing/glossary/
+ tag: Documentación
+ text: Explora tus servicios, recursos y trazas
+title: Métricas de tiempo de ejecución de Node.js
+type: multi-code-lang
+---
+
+
+Esta función está en fase beta pública.
+
+
+## Configuración automática
+
+La recopilación de métricas de tiempo de ejecución puede activarse con un parámetro de configuración en el cliente de rastreo, ya sea a través de la opción del rastreador: `tracer.init({ runtimeMetrics: true })` o a través de la variable de entorno: `DD_RUNTIME_METRICS_ENABLED=true`
+
+
+ {{< tabs >}}
+{{% tab "Environment variables" %}}
+
+```shell
+export DD_RUNTIME_METRICS_ENABLED=true
+export DD_ENV=prod
+export DD_SERVICE=my-web-app
+export DD_VERSION=1.0.3
+```
+
+{{% /tab %}}
+{{% tab "In code" %}}
+
+```js
+const tracer = require('dd-trace').init({
+ env: 'prod',
+ service: 'my-web-app',
+ version: '1.0.3',
+ runtimeMetrics: true
+})
+```
+
+{{% /tab %}}
+{{< /tabs >}}
+
+Las métricas de tiempo de ejecución se pueden ver en correlación con tus servicios de Node. Consulta el [Catálogo de servicios][1] en Datadog.
+
+Por defecto, las métricas de tiempo de ejecución de tu aplicación se envían al Datadog Agent con DogStatsD en el puerto `8125`. Asegúrate de que [DogStatsD está habilitado para el Agent][2].
+Si estás ejecutando el Agent como un contenedor, asegúrate de que `DD_DOGSTATSD_NON_LOCAL_TRAFFIC` [está configurado como true][3] y que el puerto `8125` está abierto en el Agent.
+En Kubernetes, [vincula el puerto de DogStatsD a un puerto host][4]; en ECS, [establece los indicadores apropiados en tu definición de tarea][5].
+
+Alternativamente, el Agent puede ingerir métricas con un Unix Domain Socket (UDS) como alternativa al transporte UDP. Para más información, lee [DogStatsD en Unix Domain Socket][7].
+
+## Datos recopilados
+
+Las siguientes métricas se recopilan por defecto después de activar las métricas de tiempo de ejecución.
+
+{{< get-metrics-from-git "node" >}}
+
+Además de mostrar estas métricas en tu Página de servicios de APM, Datadog proporciona un [dashboard de tiempo de ejecución de Node predeterminado][6].
+
+## Leer más
+
+{{< partial name="whats-next/whats-next.html" >}}
+
+[1]: https://app.datadoghq.com/services
+[2]: /es/metrics/custom_metrics/dogstatsd_metrics_submission/#setup
+[3]: /es/agent/docker/#dogstatsd-custom-metrics
+[4]: /es/developers/dogstatsd/?tab=kubernetes#agent
+[5]: /es/agent/amazon_ecs/#create-an-ecs-task
+[6]: https://app.datadoghq.com/dash/integration/30269/node-runtime-metrics
+[7]: /es/developers/dogstatsd/unix_socket/
\ No newline at end of file
diff --git a/content/es/tracing/trace_explorer/search.md b/content/es/tracing/trace_explorer/search.md
index 7f4a1349c7235..d594db07923fe 100644
--- a/content/es/tracing/trace_explorer/search.md
+++ b/content/es/tracing/trace_explorer/search.md
@@ -25,7 +25,6 @@ Selecciona una vista de lista de principales, y agrupa la consulta por `resource
{{< img src="tracing/trace_explorer/search/trace_explorer_top_list_search.png" alt="Búsqueda de lista de Trace Explorer. La opción Visualizar como está establecida en Lista de principales." style="width:100%;">}}
{{< site-region region="us,eu,us3,us5,ap1" >}}
-**Nota**: Las consultas `key:value` **no** requieren que se [declare una faceta][1] de antemano.
[1]: /es/tracing/trace_explorer/query_syntax/#facets
{{< /site-region >}}
diff --git a/content/fr/integrations/azure.md b/content/fr/integrations/azure.md
index b8e1e71923dc9..e5d959cf8fc4d 100644
--- a/content/fr/integrations/azure.md
+++ b/content/fr/integrations/azure.md
@@ -9,6 +9,7 @@ categories:
- log collection
- network
- notifications
+custom_kind: integration
dependencies: []
description: Recueillez des métriques à partir d'instances et de nombreux services
Azure.
@@ -70,32 +71,31 @@ integration_id: azure
integration_title: Microsoft Azure
integration_version: ''
is_public: true
-custom_kind: integration
manifest_version: '1.0'
monitors:
- '[Azure App Gateway] Backend Hosts': assets/monitors/app_gateway_backend_hosts.json
- '[Azure App Gateway] CPU Utilization': assets/monitors/app_gateway_cpu_utilization.json
- '[Azure App Gateway] Failed Requests': assets/monitors/app_gateway_failed_requests.json
- '[Azure App Gateway] Response HTTP Status Anomaly': assets/monitors/app_gateway_http_status_anomalies.json
- '[Azure App Service] App Service Errors': assets/monitors/app_service_app_service_errors.json
- '[Azure App Service] App Service Plan CPU Utilization': assets/monitors/app_service_cpu.json
- '[Azure App Service] App Service Plan Memory Utilization': assets/monitors/app_service_memory.json
- '[Azure App Service] Connections': assets/monitors/app_service_connections.json
- '[Azure App Service] Function App Errors': assets/monitors/app_service_function_app_errors.json
- '[Azure App Service] Requests': assets/monitors/app_service_requests.json
- '[Azure App Service] Response Time': assets/monitors/app_service_response_times.json
- '[Azure SQL Database] CPU Utilization': assets/monitors/sql_db_cpu_percent.json
- '[Azure SQL Database] DTU Consumption': assets/monitors/sql_db_dtu_consumption_percent.json
- '[Azure SQL Database] Deadlock Anomalies': assets/monitors/sql_db_deadlock_anomalies.json
- '[Azure SQL Database] Failed Connections': assets/monitors/sql_db_connections_failed.json
- '[Azure SQL Database] Georeplication Link Status ': assets/monitors/sql_db_replication_links.json
- '[Azure SQL Database] Storage Utilization': assets/monitors/sql_db_storage_percent.json
- '[Azure VM] CPU Utilization Monitor': assets/monitors/vm_cpu_utilization.json
- '[Azure VM] Resource Health Status Monitor': assets/monitors/vm_resource_health_status.json
- '[Azure] API Rate Limit': assets/monitors/rate_limits.json
- '[Azure] Integration Errors': assets/monitors/integration_errors.json
- '[Azure] Resource Quotas': assets/monitors/resource_quotas.json
- '[Azure] Service Health Events': assets/monitors/service_health_events.json
+ API Rate Limit: assets/monitors/rate_limits.json
+ App Service Errors is high: assets/monitors/app_service_app_service_errors.json
+ App Service Plan CPU Utilization is high: assets/monitors/app_service_cpu.json
+ App Service Plan Memory Utilization is high: assets/monitors/app_service_memory.json
+ App gateway CPU Utilization is high: assets/monitors/app_gateway_cpu_utilization.json
+ Backend Hosts Anomaly: assets/monitors/app_gateway_backend_hosts.json
+ Connections Anomaly: assets/monitors/app_service_connections.json
+ DTU Consumption: assets/monitors/sql_db_dtu_consumption_percent.json
+ Deadlock Anomalies: assets/monitors/sql_db_deadlock_anomalies.json
+ Failed Connections is high: assets/monitors/sql_db_connections_failed.json
+ Failed Requests is high: assets/monitors/app_gateway_failed_requests.json
+ Function App Errors is high: assets/monitors/app_service_function_app_errors.json
+ Georeplication Link Status: assets/monitors/sql_db_replication_links.json
+ Integration Errors: assets/monitors/integration_errors.json
+ Requests Anomaly: assets/monitors/app_service_requests.json
+ Resource Health Status: assets/monitors/vm_resource_health_status.json
+ Resource Quotas is high: assets/monitors/resource_quotas.json
+ Response HTTP Status Anomaly: assets/monitors/app_gateway_http_status_anomalies.json
+ Response Time Anomaly: assets/monitors/app_service_response_times.json
+ SQL DB CPU Utilization is high: assets/monitors/sql_db_cpu_percent.json
+ Service Health Events: assets/monitors/service_health_events.json
+ Storage Utilization is high: assets/monitors/sql_db_storage_percent.json
+ VM CPU Utilization is high: assets/monitors/vm_cpu_utilization.json
name: azure
public_title: Intégration Datadog/Microsoft Azure
short_description: Recueillez des métriques à partir d'instances et de nombreux services
@@ -110,7 +110,7 @@ L'intégration Azure de Datadog permet de recueillir des métriques et des logs
**Tous les sites** : tous les sites Datadog peuvent utiliser le processus d'inscription d'application afin de mettre en place la collecte des métriques. Ils peuvent également tous configurer un Event Hub de façon à envoyer les logs de la plateforme Azure. _Dans la mesure où l'intégration Azure permet de surveiller la région chinoise d'Azure, toute utilisation des services Datadog en Chine occidentale (ou en connexion avec des environnements se situant au sein de la Chine occidentale) est sujette à l'avertissement figurant à la section [Emplacements de service restreints][1] (en anglais) de notre site Web._
-**US3** : si votre organisation utilise le site Datadog US3, vous pouvez tirer profit de l'intégration native Azure pour simplifier la gestion et la collecte des données de votre environnement Azure. Il est recommandé d'utiliser dès que possible cette méthode. Il vous suffit de créer une ressource Datadog dans Azure afin d'associer vos abonnements Azure à votre organisation Datadog. Il n'est alors pas nécessaire d'utiliser le processus d'inscription d'application pour la collecte des métriques ni de configurer un Event Hub pour l'envoi des logs.
+**US3** : si votre organisation utilise le site Datadog US3, vous pouvez tirer profit de l'intégration Azure native pour simplifier la gestion et la collecte des données de votre environnement Azure. Il est recommandé d'utiliser dès que possible cette méthode. Il vous suffit de créer une ressource Datadog dans Azure afin d'associer vos abonnements Azure à votre organisation Datadog. Il n'est alors pas nécessaire d'utiliser le processus d'inscription d'application pour la collecte des métriques ni de configurer un Event Hub pour l'envoi des logs.
Associez Microsoft Azure pour :
- Obtenir des métriques sur des machines virtuelles Azure sans avoir nécessairement à installer l'Agent Datadog
diff --git a/content/fr/monitors/guide/create-cluster-alert.md b/content/fr/monitors/guide/create-cluster-alert.md
index 631a508d48024..e116856afe33c 100644
--- a/content/fr/monitors/guide/create-cluster-alert.md
+++ b/content/fr/monitors/guide/create-cluster-alert.md
@@ -6,7 +6,6 @@ further_reading:
- link: /monitors/notify/
tag: Documentation
text: Configurer les notifications de vos monitors
-
title: Créer des alertes de cluster pour être informé lorsqu'un pourcentage de groupes
possèdent un état critique
---
@@ -31,6 +30,6 @@ Pour cet exemple, imaginons que vous souhaitez recevoir une notification lorsque
Ce monitor surveille le pourcentage de hosts qui ont utilisé plus de 50 % du CPU au cours des 10 dernières minutes. Il génère une notification lorsque plus de 40 % de ces hosts répondent à la condition définie.
-{{< img src="monitors/faq/cluster-status.png" alt="statut-alerte-cluster" >}}
+## Pour aller plus loin
{{< partial name="whats-next/whats-next.html" >}}
\ No newline at end of file
diff --git a/content/fr/real_user_monitoring/browser/advanced_configuration.md b/content/fr/real_user_monitoring/browser/advanced_configuration.md
new file mode 100644
index 0000000000000..a614c4c62e73e
--- /dev/null
+++ b/content/fr/real_user_monitoring/browser/advanced_configuration.md
@@ -0,0 +1,1037 @@
+---
+aliases:
+- /fr/real_user_monitoring/installation/advanced_configuration/
+- /fr/real_user_monitoring/browser/modifying_data_and_context/
+further_reading:
+- link: /real_user_monitoring/browser/tracking_user_actions
+ tag: Documentation
+ text: Suivi des actions utilisateur
+- link: https://www.datadoghq.com/blog/real-user-monitoring-with-datadog/
+ tag: Blog
+ text: Real User Monitoring
+- link: /real_user_monitoring/browser/data_collected/
+ tag: Documentation
+ text: Données Browser RUM recueillies
+- link: /real_user_monitoring/explorer/
+ tag: Documentation
+ text: Explorer vos vues dans Datadog
+- link: /real_user_monitoring/explorer/visualize/
+ tag: Documentation
+ text: Appliquer des visualisations sur vos événements
+- link: /logs/log_configuration/attributes_naming_convention
+ tag: Documentation
+ text: Attributs standard Datadog
+title: Configuration avancée
+---
+
+## Section Overview
+
+Vous pouvez modifier les [données et le contexte collectés][1] par la fonctionnalité RUM de diverses façons afin de mieux répondre à vos besoins. Par exemple :
+
+- Protection des données sensibles, telles que les informations personnelles.
+- Connexion d'une session utilisateur à votre identification interne de cet utilisateur afin de faciliter l'assistance.
+- Réduction de la quantité de données RUM recueillies, à l'aide d'un échantillonnage des données.
+- Ajout de données de contexte en plus des attributs par défaut afin de mieux déterminer l'origine des données.
+
+## Remplacer les noms de vue RUM par défaut
+
+Le SDK Browser RUM génère automatiquement un [événement de vue][2] chaque fois qu'un utilisateur consulte une nouvelle page, ou lorsque l'URL de la page est modifiée (pour les applications monopages). Un nom de vue est généré à partir de l'URL de la page active, et les ID alphanumériques de variable sont supprimés automatiquement : par exemple, `/dashboard/1234` devient `/dashboard/?`.
+
+Depuis la [version 2.17.0][3], vous pouvez ajouter des noms de vue et les attribuer à un service dédié appartenant à une équipe, en effectuant un suivi manuel des événements de vue avec l'option `trackViewsManually` :
+
+1. Définissez `trackViewsManually` sur true lors de l'initialisation du SDK Browser RUM.
+
+ {{< tabs >}}
+ {{% tab "NPM" %}}
+ ```javascript
+ import { datadogRum } from '@datadog/browser-rum';
+
+ datadogRum.init({
+ ...,
+ trackViewsManually: true,
+ ...
+ });
+ ```
+ {{% /tab %}}
+ {{% tab "CDN asynchrone" %}}
+ ```javascript
+ window.DD_RUM.onReady(function() {
+ window.DD_RUM.init({
+ ...,
+ trackViewsManually: true,
+ ...
+ })
+ })
+ ```
+ {{% /tab %}}
+ {{% tab "CDN synchrone" %}}
+ ```javascript
+ window.DD_RUM &&
+ window.DD_RUM.init({
+ ...,
+ trackViewsManually: true,
+ ...
+ });
+ ```
+ {{% /tab %}}
+ {{< /tabs >}}
+
+2. Vous devez lancer des vues pour chaque nouvelle page ou chaque changement de route (pour les applications monopages). Les données RUM sont recueillies à l'initialisation de la vue. Depuis la [version 4.13.0][17], vous avez également la possibilité de définir le nom et la version du service associé.
+
+ - View Name : correspond par défaut au chemin d'URL de la page.
+ - Service : correspond pas défaut au service par défaut spécifié lors de la création de votre application RUM.
+ - Version : correspond pas défaut à la version par défaut spécifiée lors de la création de votre application RUM.
+
+ Pour en savoir plus, consultez la section [Surveillance Browser RUM][4].
+
+
+ Latest version
+ The following example manually tracks the pageviews on the checkout
page in a RUM application. Use checkout
for the view name and associate the purchase
service with version 1.2.3
.
+
+ {{< tabs >}}
+ {{% tab "NPM" %}}
+ ```javascript
+ datadogRum.startView({
+ name: 'checkout',
+ service: 'purchase',
+ version: '1.2.3'
+ })
+ ```
+
+ {{% /tab %}}
+ {{% tab "CDN async" %}}
+ ```javascript
+ window.DD_RUM.onReady(function() {
+ window.DD_RUM.startView({
+ name: 'checkout',
+ service: 'purchase',
+ version: '1.2.3'
+ })
+ })
+ ```
+ {{% /tab %}}
+ {{% tab "CDN sync" %}}
+ ```javascript
+ window.DD_RUM && window.DD_RUM.startView({
+ name: 'checkout',
+ service: 'purchase',
+ version: '1.2.3'
+ })
+ ```
+ {{% /tab %}}
+ {{< /tabs >}}
+
+
+
+ before v4.13.0
+ The following example manually tracks the pageviews on the checkout
page in a RUM application. No service or version can be specified.
+
+ {{< tabs >}}
+ {{% tab "NPM" %}}
+ ```javascript
+ datadogRum.startView('checkout')
+ ```
+
+ {{% /tab %}}
+ {{% tab "CDN async" %}}
+ ```javascript
+ window.DD_RUM.onReady(function() {
+ window.DD_RUM.startView('checkout')
+ })
+ ```
+ {{% /tab %}}
+ {{% tab "CDN sync" %}}
+ ```javascript
+ window.DD_RUM && window.DD_RUM.startView('checkout')
+ ```
+ {{% /tab %}}
+ {{< /tabs >}}
+
+
+
+Si vous utilisez React, Angular, Vue ou tout autre framework frontend, Datadog recommande d'implémenter la logique `startView` au niveau du routeur du framework.
+
+### Instrumentation du routeur de React
+
+Pour remplacer les noms par défaut de la vue du RUM afin de les aligner avec leur définition dans votre application React, vous devez suivre les étapes ci-dessous.
+
+**Remarque** : ces instructions sont spécifiques à la bibliothèque **React Router v6**.
+
+1. Définissez `trackViewsManually` sur `true` lorsque vous initialisez le SDK RUM Browser, comme décrit [plus haut](#remplacer-les-noms-de-la-vue-du-rum-par-defaut).
+
+2. Lancez des vues sur chaque changement de route.
+
+ {{< tabs >}}
+ {{% tab "NPM" %}}
+ ```javascript
+ import { matchRoutes, useLocation } from 'react-router-dom';
+ import { routes } from 'path/to/routes';
+ import { datadogRum } from "@datadog/browser-rum";
+
+ export default function App() {
+ // Track every route change with useLocation API
+ let location = useLocation();
+
+ useEffect(() => {
+ const routeMatches = matchRoutes(routes, location.pathname);
+ const viewName = routeMatches && computeViewName(routeMatches);
+ if (viewName) {
+ datadogRum.startView({name: viewName});
+ }
+ }, [location.pathname]);
+
+ ...
+ }
+
+ // Compute view name out of routeMatches
+ function computeViewName(routeMatches) {
+ let viewName = "";
+ for (let index = 0; index < routeMatches.length; index++) {
+ const routeMatch = routeMatches[index];
+ const path = routeMatch.route.path;
+ // Skip pathless routes
+ if (!path) {
+ continue;
+ }
+
+ if (path.startsWith("/")) {
+ // Handle absolute child route paths
+ viewName = path;
+ } else {
+ // Handle route paths ending with "/"
+ viewName += viewName.endsWith("/") ? path : `/${path}`;
+ }
+ }
+
+ return viewName || '/';
+ }
+ ```
+
+ {{% /tab %}}
+ {{% tab "CDN asynchrone" %}}
+ ```javascript
+ import { matchRoutes, useLocation } from 'react-router-dom';
+ import { routes } from 'path/to/routes';
+
+ export default function App() {
+ // Track every route change with useLocation API
+ let location = useLocation();
+
+ useEffect(() => {
+ const routeMatches = matchRoutes(routes, location.pathname);
+ const viewName = routeMatches && computeViewName(routeMatches);
+ if (viewName) {
+ DD_RUM.onReady(function() {
+ DD_RUM.startView({name: viewName});
+ });
+ }
+ }, [location.pathname]);
+
+ ...
+ }
+
+ // Compute view name out of routeMatches
+ function computeViewName(routeMatches) {
+ let viewName = "";
+ for (let index = 0; index < routeMatches.length; index++) {
+ const routeMatch = routeMatches[index];
+ const path = routeMatch.route.path;
+ // Skip pathless routes
+ if (!path) {
+ continue;
+ }
+
+ if (path.startsWith("/")) {
+ // Handle absolute child route paths
+ viewName = path;
+ } else {
+ // Handle route paths ending with "/"
+ viewName += viewName.endsWith("/") ? path : `/${path}`;
+ }
+ }
+
+ return viewName || '/';
+ }
+ ```
+ {{% /tab %}}
+ {{% tab "CDN synchrone" %}}
+ ```javascript
+ import { matchRoutes, useLocation } from 'react-router-dom';
+ import { routes } from 'path/to/routes';
+
+ export default function App() {
+ // Track every route change with useLocation API
+ let location = useLocation();
+
+ useEffect(() => {
+ const routeMatches = matchRoutes(routes, location.pathname);
+ const viewName = routeMatches && computeViewName(routeMatches);
+ if (viewName) {
+ window.DD_RUM &&
+ window.DD_RUM.startView({name: viewName});
+ }
+ }, [location.pathname]);
+
+ ...
+ }
+
+ // Compute view name out of routeMatches
+ function computeViewName(routeMatches) {
+ let viewName = "";
+ for (let index = 0; index < routeMatches.length; index++) {
+ const routeMatch = routeMatches[index];
+ const path = routeMatch.route.path;
+ // Skip pathless routes
+ if (!path) {
+ continue;
+ }
+
+ if (path.startsWith("/")) {
+ // Handle absolute child route paths
+ viewName = path;
+ } else {
+ // Handle route paths ending with "/"
+ viewName += viewName.endsWith("/") ? path : `/${path}`;
+ }
+ }
+
+ return viewName || '/';
+ }
+ ```
+ {{% /tab %}}
+ {{< /tabs >}}
+
+## Enrichir et contrôler les données RUM
+
+Le SDK Browser RUM enregistre les événements RUM et renseigne les attributs principaux correspondants. La fonction de rappel `beforeSend` vous permet d'accéder à chaque événement recueilli par le SDK Browser RUM avant qu'il ne soit envoyé à Datadog.
+
+L'interception d'événements RUM vous permet d'effectuer les opérations suivantes :
+
+- Enrichir vos événements RUM avec des attributs de contexte supplémentaires
+- Modifier vos événements RUM pour en modifier le contenu ou pour effacer les séquences sensibles (consultez la [liste des propriétés modifiables](#modifier-le-contenu-d-un-evenement-rum))
+- Ignorer des événements RUM sélectionnés
+
+Depuis la [version 2.13.0][5], `beforeSend` prend deux arguments : `event`, qui fait référence à l'événement généré par le SDK Browser RUM, et `context`, qui fait référence au contexte qui a déclenché la création de l'événement RUM.
+
+```javascript
+function beforeSend(event, context)
+```
+
+Voici les valeurs possibles pour `context` :
+
+| Type d'événement RUM | Contexte |
+|------------------|---------------------------|
+| Vue | [Location][6] |
+| Action | [Event][7] |
+| Ressource (XHR) | [XMLHttpRequest][7] et [PerformanceResourceTiming][8] |
+| Ressource (Fetch) | [Request][10], [Response][11] et [PerformanceResourceTiming][9] |
+| Ressource (autre) | [PerformanceResourceTiming][9] |
+| Erreur | [Error][12] |
+| Tâche longue | [PerformanceLongTaskTiming][13] |
+
+Pour en savoir plus, consultez le [guide pour enrichir et contrôler les données RUM][14].
+
+### Enrichir des événements RUM
+
+En plus des attributs ajoutés avec l'[API de contexte global](#contexte-global) ou la [collecte de données Feature Flag](#enrichir-des-evenements-du-rum-avec-des-feature-flags), vous pouvez associer d'autres attributs de contexte à l'événement. Par exemple, ajoutez des tags à vos événements de ressource RUM à l'aide des données extraites à partir d'un objet de réponse Fetch :
+
+{{< tabs >}}
+{{% tab "NPM" %}}
+```javascript
+import { datadogRum } from '@datadog/browser-rum';
+
+datadogRum.init({
+ ...,
+ beforeSend: (event, context) => {
+ // collecter des en-têtes de réponse d'une ressource RUM
+ if (event.type === 'resource' && event.resource.type === 'fetch') {
+ event.context.responseHeaders = Object.fromEntries(context.response.headers)
+ }
+ return true
+ },
+ ...
+});
+```
+{{% /tab %}}
+{{% tab "CDN asynchrone" %}}
+```javascript
+window.DD_RUM.onReady(function() {
+ window.DD_RUM.init({
+ ...,
+ beforeSend: (event, context) => {
+ // collecter des en-têtes de réponse d'une ressource RUM
+ if (event.type === 'resource' && event.resource.type === 'fetch') {
+ event.context.responseHeaders = Object.fromEntries(context.response.headers)
+ }
+ return true
+ },
+ ...
+ })
+})
+```
+{{% /tab %}}
+{{% tab "CDN synchrone" %}}
+```javascript
+window.DD_RUM &&
+ window.DD_RUM.init({
+ ...,
+ beforeSend: (event, context) => {
+ // collecter des en-têtes de réponse d'une ressource RUM
+ if (event.type === 'resource' && event.resource.type === 'fetch') {
+ event.context.responseHeaders = Object.fromEntries(context.response.headers)
+ }
+ return true
+ },
+ ...
+ });
+```
+{{% /tab %}}
+{{< /tabs >}}
+
+Lorsqu'un utilisateur appartient à plusieurs équipes, ajoutez des paires key-value supplémentaires dans vos appels de l'API de contexte global.
+
+Le SDK Browser RUM ignore :
+
+- les attributs ajoutés en dehors de `event.context` ;
+- les modifications apportées à un contexte d'événement de vue RUM.
+
+### Enrichir des événements du RUM avec des feature flags
+
+Vous pouvez [enrichir les données de vos événements RUM avec des feature flags][14] afin d'obtenir davantage de contexte et de visibilité sur le suivi des performances. Vous pouvez ainsi identifier les utilisateurs qui sont exposés à une expérience utilisateur spécifique et déterminer si cette expérience nuit aux performances de ces utilisateurs.
+
+### Modifier le contenu d'un événement RUM
+
+Par exemple, pour censurer les adresses e-mail de vos URL d'applications Web :
+
+{{< tabs >}}
+{{% tab "NPM" %}}
+```javascript
+import { datadogRum } from '@datadog/browser-rum';
+
+datadogRum.init({
+ ...,
+ beforeSend: (event) => {
+ // supprimez l'adresse e-mail de l'url de la vue
+ event.view.url = event.view.url.replace(/email=[^&]*/, "email=REDACTED")
+ },
+ ...
+});
+```
+{{% /tab %}}
+{{% tab "CDN asynchrone" %}}
+```javascript
+window.DD_RUM.onReady(function() {
+ window.DD_RUM.init({
+ ...,
+ beforeSend: (event) => {
+ // supprimer l'e-mail de l'url de la vue
+ event.view.url = event.view.url.replace(/email=[^&]*/, "email=REDACTED")
+ },
+ ...
+ })
+})
+```
+{{% /tab %}}
+{{% tab "CDN synchrone" %}}
+```javascript
+window.DD_RUM &&
+ window.DD_RUM.init({
+ ...,
+ beforeSend: (event) => {
+ // supprimez l'adresse e-mail de l'url de la vue
+ event.view.url = event.view.url.replace(/email=[^&]*/, "email=REDACTED")
+ },
+ ...
+ });
+```
+{{% /tab %}}
+{{< /tabs >}}
+
+Vous pouvez modifier les propriétés d'événement suivantes :
+
+| Attribut | Type | Rôle |
+|-----------------------|-----------|-----------------------------------------------------------------------------------------------------|
+| `view.url` | Chaîne | L'URL de la page Web active. |
+| `view.referrer` | Chaîne | L'URL de la page Web précédente à partir de laquelle l'utilisateur a accédé à la page actuelle. |
+| `view.name` | Chaîne | Le nom de la vue actuelle. |
+| `action.target.name` | Chaîne | L'élément avec lequel l'utilisateur a interagi. Uniquement pour les actions recueillies automatiquement. |
+| `error.message` | Chaîne | Un message d'une ligne lisible et concis décrivant l'erreur. |
+| `error.stack ` | Chaîne | La stack trace ou toutes informations complémentaires relatives à l'erreur. |
+| `error.resource.url` | Chaîne | L'URL de la ressource qui a déclenché l'erreur. |
+| `resource.url` | Chaîne | L'URL de la ressource. |
+| `context` | Objet | Attributs ajoutés avec l'[API de contexte global](#contexte-global) ou lors de la génération manuelle d'événements (par exemple, `addError` et `addAction`). La valeur `context` des événements de vue RUM est en lecture seule. |
+
+Le SDK Browser RUM ne tient pas compte des modifications apportées aux propriétés d'événement non répertoriées ci-dessus. Pour en savoir plus les propriétés d'événement, consultez le [référentiel GitHub du SDK Browser RUM][15].
+
+### Ignorer un événement RUM
+
+L'API `beforeSend` vous permet d'ignorer un événement RUM en renvoyant `false` :
+
+{{< tabs >}}
+{{% tab "NPM" %}}
+
+```javascript
+import { datadogRum } from '@datadog/browser-rum';
+
+datadogRum.init({
+ ...,
+ beforeSend: (event) => {
+ if (shouldDiscard(event)) {
+ return false
+ }
+ ...
+ },
+ ...
+});
+```
+{{% /tab %}}
+{{% tab "CDN asynchrone" %}}
+```javascript
+window.DD_RUM.onReady(function() {
+ window.DD_RUM.init({
+ ...,
+ beforeSend: (event) => {
+ if (shouldDiscard(event)) {
+ return false
+ },
+ ...
+ },
+ ...
+ })
+})
+```
+{{% /tab %}}
+{{% tab "CDN synchrone" %}}
+```javascript
+window.DD_RUM &&
+ window.DD_RUM.init({
+ ...,
+ beforeSend: (event) => {
+ if (shouldDiscard(event)) {
+ return false
+ }
+ ...
+ },
+ ...
+ });
+```
+{{% /tab %}}
+{{< /tabs >}}
+
+**Remarque** : les événements de la vue ne peuvent pas être ignorés.
+
+## Session utilisateur
+
+L'ajout des informations utilisateur à vos sessions RUM permet :
+* le suivi du parcours d'un utilisateur donné ;
+* l'identification des utilisateurs les plus touchés par les erreurs ;
+* la surveillance des performances de vos utilisateurs les plus importants.
+
+{{< img src="real_user_monitoring/browser/advanced_configuration/user-api.png" alt="API Utilisateurs dans l'interface RUM" >}}
+
+Les attributs suivants sont facultatifs, mais Datadog vous recommande d'en renseigner au moins un :
+
+| Attribut | Type | Rôle |
+|------------|------|----------------------------------------------------------------------------------------------------|
+| `usr.id` | Chaîne | Identifiant d'utilisateur unique. |
+| `usr.name` | Chaîne | Nom courant de l'utilisateur, affiché par défaut dans l'interface RUM. |
+| `usr.email` | Chaîne | Adresse e-mail de l'utilisateur, affichée dans l'interface RUM si le nom de l'utilisateur n'est pas connu. Elle sert également à récupérer des Gravatars. |
+
+Améliorez vos capacités de filtrage en ajoutant d'autres attributs en plus de ceux recommandés. Par exemple, ajoutez des informations à propos de l'abonnement de l'utilisateur ou du groupe d'utilisateurs auquel il appartient.
+
+Lorsque vous modifiez l'objet de la session utilisateur, tous les événements RUM recueillis après la modification contiennent les informations les plus récentes.
+
+**Remarque** : lorsque vous supprimez les informations relatives à la session de l'utilisateur, comme pour une déconnexion, les informations de l'utilisateur sur la dernière vue avant la déconnexion sont conservées, mais pas celles sur les vues ultérieures ni au niveau de la session, car les données de session utilisent les valeurs de la dernière vue.
+
+### Identifier une session utilisateur
+
+`datadogRum.setUser()`
+
+{{< tabs >}}
+{{% tab "NPM" %}}
+```javascript
+datadogRum.setUser({
+ id: '1234',
+ name: 'John Doe',
+ email: 'john@doe.com',
+ plan: 'premium',
+ ...
+})
+```
+{{% /tab %}}
+{{% tab "CDN asynchrone" %}}
+```javascript
+window.DD_RUM.onReady(function() {
+ window.DD_RUM.setUser({
+ id: '1234',
+ name: 'John Doe',
+ email: 'john@doe.com',
+ plan: 'premium',
+ ...
+ })
+})
+```
+{{% /tab %}}
+{{% tab "CDN synchrone" %}}
+```javascript
+window.DD_RUM && window.DD_RUM.setUser({
+ id: '1234',
+ name: 'John Doe',
+ email: 'john@doe.com',
+ plan: 'premium',
+ ...
+})
+```
+
+{{% /tab %}}
+{{< /tabs >}}
+
+### Accéder à une session utilisateur
+
+`datadogRum.getUser()`
+
+{{< tabs >}}
+{{% tab "NPM" %}}
+```javascript
+datadogRum.getUser()
+```
+{{% /tab %}}
+{{% tab "CDN asynchrone" %}}
+```javascript
+window.DD_RUM.onReady(function() {
+ window.DD_RUM.getUser()
+})
+```
+{{% /tab %}}
+{{% tab "CDN synchrone" %}}
+```javascript
+window.DD_RUM && window.DD_RUM.getUser()
+```
+
+{{% /tab %}}
+{{< /tabs >}}
+
+### Ajouter ou remplacer une propriété de session utilisateur
+
+`datadogRum.setUserProperty('', )`
+
+{{< tabs >}}
+{{% tab "NPM" %}}
+```javascript
+datadogRum.setUserProperty('name', 'John Doe')
+```
+{{% /tab %}}
+{{% tab "CDN asynchrone" %}}
+```javascript
+window.DD_RUM.onReady(function() {
+ window.DD_RUM.setUserProperty('name', 'John Doe')
+})
+```
+{{% /tab %}}
+{{% tab "CDN synchrone" %}}
+```javascript
+window.DD_RUM && window.DD_RUM.setUserProperty('name', 'John Doe')
+```
+
+{{% /tab %}}
+{{< /tabs >}}
+
+### Supprimer une propriété de session utilisateur
+
+`datadogRum.removeUserProperty('')`
+
+{{< tabs >}}
+{{% tab "NPM" %}}
+```javascript
+datadogRum.removeUserProperty('name')
+```
+{{% /tab %}}
+{{% tab "CDN asynchrone" %}}
+```javascript
+window.DD_RUM.onReady(function() {
+ window.DD_RUM.removeUserProperty('name')
+})
+```
+{{% /tab %}}
+{{% tab "CDN synchrone" %}}
+```javascript
+window.DD_RUM && window.DD_RUM.removeUserProperty('name')
+```
+{{% /tab %}}
+{{< /tabs >}}
+
+### Effacer une propriété de session utilisateur
+
+`datadogRum.clearUser()`
+
+{{< tabs >}}
+{{% tab "NPM" %}}
+```javascript
+datadogRum.clearUser()
+```
+{{% /tab %}}
+{{% tab "CDN asynchrone" %}}
+```javascript
+window.DD_RUM.onReady(function() {
+ window.DD_RUM.clearUser()
+})
+```
+{{% /tab %}}
+{{% tab "CDN synchrone" %}}
+```javascript
+window.DD_RUM && window.DD_RUM.clearUser()
+```
+{{% /tab %}}
+{{< /tabs >}}
+
+## Échantillonnage
+
+Par défaut, aucun échantillonnage n'est appliqué au nombre de sessions recueillies. Pour appliquer un échantillonnage relatif (en pourcentage), utilisez le paramètre `sessionSampleRate` lors de l'initialisation de RUM.
+
+L'exemple suivant recueille seulement 90 % de toutes les sessions pour une application RUM donnée :
+
+{{< tabs >}}
+{{% tab "NPM" %}}
+```javascript
+import { datadogRum } from '@datadog/browser-rum';
+
+datadogRum.init({
+ applicationId: '',
+ clientToken: '',
+ site: '',
+ sessionSampleRate: 90,
+});
+```
+{{% /tab %}}
+{{% tab "CDN asynchrone" %}}
+```javascript
+window.DD_RUM.onReady(function() {
+ window.DD_RUM.init({
+ clientToken: '',
+ applicationId: '',
+ site: '',
+ sessionSampleRate: 90,
+ })
+})
+```
+{{% /tab %}}
+{{% tab "CDN synchrone" %}}
+```javascript
+window.DD_RUM &&
+ window.DD_RUM.init({
+ clientToken: '',
+ applicationId: '',
+ site: '',
+ sessionSampleRate: 90,
+ });
+```
+{{% /tab %}}
+{{< /tabs >}}
+
+Lorsqu'une session est exclue en raison d'un échantillonnage, aucune vue de page ni aucune donnée de télémétrie associée à cette session ne sont recueillies.
+
+## Consentement au suivi de lʼutilisateur
+
+Pour répondre aux exigences du RGPD, le CCPA et dʼautres régulations similaires, le SDK RUM Browser vous permet de fournir la valeur de consentement au suivi à son initialisation. Pour en savoir plus sur le consentement au suivi, consultez la section relative à la [sécurité des données][18].
+
+Le paramètre dʼinitialisation `trackingConsent` peut prendre l'une des valeurs suivantes :
+
+1. `.granted` : le SDK RUM Browser commence à recueillir les données et les envoie à Datadog.
+2. `"not-granted"` : le SDK RUM Browser ne recueille aucune donnée.
+
+Pour modifier la valeur de consentement au suivi après l'initialisation du SDK RUM Browser, utilisez l'appel d'API `setTrackingConsent()`. Le SDK RUM Browser modifie son comportement en tenant compte de la nouvelle valeur.
+
+* lorsque la valeur passe de `"granted"` à `"not-granted"`, la session du RUM sʼarrête et les données ne sont plus envoyées à Datadog.
+* lorsque la valeur passe de `"not-granted"` à `"granted"`, une nouvelle session RUM est créée si aucune autre session préalable nʼest active. La collecte de données reprend alors.
+
+Cet état n'est pas synchronisé entre les onglets ni conservé entre les navigations. Il est de votre responsabilité de fournir la décision de l'utilisateur lors de l'initialisation du SDK RUM Browser ou en utilisant `setTrackingConsent()`.
+
+Lorsque `setTrackingConsent()` est utilisé avant `init()`, la valeur fournie est prioritaire sur le paramètre d'initialisation.
+
+{{< tabs >}}
+{{% tab "NPM" %}}
+```javascript
+import { datadogRum } from '@datadog/browser-rum';
+
+datadogRum.init({
+ ...,
+ trackingConsent: 'not-granted'
+});
+
+acceptCookieBannerButton.addEventListener('click', function() {
+ datadogRum.setTrackingConsent('granted');
+});
+```
+{{% /tab %}}
+{{% tab "CDN asynchrone" %}}
+```javascript
+window.DD_RUM.onReady(function() {
+ window.DD_RUM.init({
+ ...,
+ trackingConsent: 'not-granted'
+ });
+});
+
+acceptCookieBannerButton.addEventListener('click', () => {
+ window.DD_RUM.onReady(function() {
+ window.DD_RUM.setTrackingConsent('granted');
+ });
+});
+```
+{{% /tab %}}
+{{% tab "CDN synchrone" %}}
+```javascript
+window.DD_RUM && window.DD_RUM.init({
+ ...,
+ trackingConsent: 'not-granted'
+});
+
+acceptCookieBannerButton.addEventListener('click', () => {
+ window.DD_RUM && window.DD_RUM.setTrackingConsent('granted');
+});
+```
+{{% /tab %}}
+{{< /tabs >}}
+
+## Contexte global
+
+### Ajouter une propriété de contexte global
+
+Une fois la fonctionnalité RUM initialisée, ajoutez du contexte supplémentaire à l'ensemble des événements RUM recueillis depuis votre application avec l'API `setGlobalContextProperty(key: string, value: any)` :
+
+{{< tabs >}}
+{{% tab "NPM" %}}
+```javascript
+import { datadogRum } from '@datadog/browser-rum';
+
+datadogRum.setGlobalContextProperty('', );
+
+// Exemple de code
+datadogRum.setGlobalContextProperty('activity', {
+ hasPaid: true,
+ amount: 23.42
+});
+```
+{{% /tab %}}
+{{% tab "CDN asynchrone" %}}
+```javascript
+window.DD_RUM.onReady(function() {
+ window.DD_RUM.setGlobalContextProperty('', '');
+})
+
+// Exemple de code
+window.DD_RUM.onReady(function() {
+ window.DD_RUM.setGlobalContextProperty('activity', {
+ hasPaid: true,
+ amount: 23.42
+ });
+})
+```
+{{% /tab %}}
+{{% tab "CDN synchrone" %}}
+```javascript
+window.DD_RUM && window.DD_RUM.setGlobalContextProperty('', '');
+
+// Exemple de code
+window.DD_RUM && window.DD_RUM.setGlobalContextProperty('activity', {
+ hasPaid: true,
+ amount: 23.42
+});
+```
+{{% /tab %}}
+{{< /tabs >}}
+
+### Supprimer une propriété de contexte global
+
+Vous pouvez supprimer une propriété de contexte global précédemment définie.
+
+{{< tabs >}}
+{{% tab "NPM" %}}
+
+```javascript
+import { datadogRum } from '@datadog/browser-rum';
+datadogRum.removeGlobalContextProperty('');
+
+// Exemple de code
+datadogRum.removeGlobalContextProperty('codeVersion');
+```
+
+{{% /tab %}}
+{{% tab "CDN asynchrone" %}}
+```javascript
+window.DD_RUM.onReady(function() {
+ window.DD_RUM.removeGlobalContextProperty('');
+})
+
+// Exemple de code
+window.DD_RUM.onReady(function() {
+ window.DD_RUM.removeGlobalContextProperty('codeVersion');
+})
+```
+{{% /tab %}}
+{{% tab "CDN synchrone" %}}
+
+```javascript
+window.DD_RUM &&
+ window.DD_RUM.removeGlobalContextProperty('');
+
+// Exemple de code
+window.DD_RUM &&
+ window.DD_RUM.removeGlobalContextProperty('codeVersion');
+```
+
+{{% /tab %}}
+{{< /tabs >}}
+
+
+### Remplacer le contexte global
+
+Remplacez le contexte par défaut de tous vos événements RUM avec l'API `setGlobalContext(context: Context)` :
+
+{{< tabs >}}
+{{% tab "NPM" %}}
+
+```javascript
+import { datadogRum } from '@datadog/browser-rum';
+datadogRum.setGlobalContext({ '': '' });
+
+// Exemple de code
+datadogRum.setGlobalContext({
+ codeVersion: 34,
+});
+```
+
+{{% /tab %}}
+{{% tab "CDN asynchrone" %}}
+```javascript
+window.DD_RUM.onReady(function() {
+ window.DD_RUM.setGlobalContext({ '': '' });
+})
+
+// Exemple de code
+window.DD_RUM.onReady(function() {
+ window.DD_RUM.setGlobalContext({
+ codeVersion: 34,
+ })
+})
+```
+{{% /tab %}}
+{{% tab "CDN synchrone" %}}
+
+```javascript
+window.DD_RUM &&
+ window.DD_RUM.setGlobalContext({ '': '' });
+
+// Exemple de code
+window.DD_RUM &&
+ window.DD_RUM.setGlobalContext({
+ codeVersion: 34,
+ });
+```
+
+{{% /tab %}}
+{{< /tabs >}}
+
+### Effacer le contexte global
+
+Vous pouvez effacer le contexte global à l'aide du paramètre `clearGlobalContext`.
+
+{{< tabs >}}
+{{% tab "NPM" %}}
+
+```javascript
+import { datadogRum } from '@datadog/browser-rum';
+
+datadogRum.clearGlobalContext();
+```
+
+{{% /tab %}}
+{{% tab "CDN asynchrone" %}}
+```javascript
+window.DD_RUM.onReady(function() {
+ window.DD_RUM.clearGlobalContext();
+});
+```
+{{% /tab %}}
+{{% tab "CDN synchrone" %}}
+
+```javascript
+window.DD_RUM && window.DD_RUM.clearGlobalContext();
+```
+
+{{% /tab %}}
+{{< /tabs >}}
+
+### Lire le contexte global
+
+Une fois la fonctionnalité RUM initialisée, lisez le contexte global avec l'API `getGlobalContext()` :
+
+{{< tabs >}}
+{{% tab "NPM" %}}
+
+```javascript
+import { datadogRum } from '@datadog/browser-rum';
+
+const context = datadogRum.getGlobalContext();
+```
+
+{{% /tab %}}
+{{% tab "CDN asynchrone" %}}
+```javascript
+window.DD_RUM.onReady(function() {
+ const context = window.DD_RUM.getGlobalContext();
+});
+```
+{{% /tab %}}
+{{% tab "CDN synchrone" %}}
+
+```javascript
+const context = window.DD_RUM && window.DD_RUM.getGlobalContext();
+```
+
+{{% /tab %}}
+{{< /tabs >}}
+
+## Cycle de vie du contexte
+
+Par défaut, le contexte global et le contexte utilisateur sont stockés dans la mémoire de la page actuelle, ce qui signifie qu'ils ne sont pas :
+
+- conservés après une actualisation complète de la page
+- partagés sur divers onglets ou diverses fenêtres de la même session
+
+Pour les ajouter à tous les événements de la session, ils doivent être joints à chaque page.
+
+Depuis le lancement de l'option de configuration `storeContextsAcrossPages`, avec la version 4.49.0 du SDK Browser, ces contextes peuvent être stockés dans [`localStorage`][19]. Ainsi :
+
+- Les contextes sont préservés après une actualisation complète
+- Les contextes sont synchronisés entre les onglets ouverts depuis la même origine
+
+Toutefois, cette fonctionnalité possède certaines **limites** :
+
+- Il n'est pas conseillé de définir des informations personnelles identifiables (ou Personable Identifiable Information - PII) dans ces contextes, car les données stockées dans `localStorage` sont conservées après la fin de la session de l'utilisateur.
+- Cette fonctionnalité n'est pas compatible avec les options de `trackSessionAcrossSubdomains` car les données de `localStorage` ne sont partagées qu'avec la même origine (login.site.com ≠ app.site.com).
+- `localStorage` est limité à 5 MiB par origine. Ainsi, les données spécifiques à une application, les contextes Datadog et les autres données tierces stockées de façon locale doivent respecter cette limite pour éviter tout problème.
+
+## Pour aller plus loin
+
+{{< partial name="whats-next/whats-next.html" >}}
+
+[1]: /fr/real_user_monitoring/browser/data_collected/
+[2]: /fr/real_user_monitoring/browser/monitoring_page_performance/
+[3]: https://github.com/DataDog/browser-sdk/blob/main/CHANGELOG.md#v2170
+[4]: /fr/real_user_monitoring/browser/setup
+[5]: https://github.com/DataDog/browser-sdk/blob/main/CHANGELOG.md#v2130
+[6]: https://developer.mozilla.org/en-US/docs/Web/API/Location
+[7]: https://developer.mozilla.org/en-US/docs/Web/API/Event
+[8]: https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequest
+[9]: https://developer.mozilla.org/en-US/docs/Web/API/PerformanceResourceTiming
+[10]: https://developer.mozilla.org/en-US/docs/Web/API/Request
+[11]: https://developer.mozilla.org/en-US/docs/Web/API/Response
+[12]: https://developer.mozilla.org/en-US/docs/Web//Reference/Global_Objects/Error
+[13]: https://developer.mozilla.org/en-US/docs/Web/API/PerformanceLongTaskTiming
+[14]: /fr/real_user_monitoring/guide/enrich-and-control-rum-data
+[15]: https://github.com/DataDog/browser-sdk/blob/main/packages/rum-core/src/rumEvent.types.ts
+[16]: /fr/logs/log_configuration/attributes_naming_convention/#user-related-attributes
+[17]: https://github.com/DataDog/browser-sdk/blob/main/CHANGELOG.md#v4130
+[18]: /fr/data_security/real_user_monitoring/#browser-rum-use-of-cookies
+[19]: https://developer.mozilla.org/en-US/docs/Web/API/Window/localStorage
\ No newline at end of file
diff --git a/content/fr/synthetics/guide/synthetic-test-monitors.md b/content/fr/synthetics/guide/synthetic-test-monitors.md
index 43197213831a0..40a05b0b689a9 100644
--- a/content/fr/synthetics/guide/synthetic-test-monitors.md
+++ b/content/fr/synthetics/guide/synthetic-test-monitors.md
@@ -17,8 +17,6 @@ title: Utiliser des monitors de test Synthetic
Lorsque vous créez un test Synthetic, Datadog crée automatiquement un monitor associé. Vous pouvez configurer des notifications lorsque le monitor du test Synthetic envoie une alerte.
-{{< img src="synthetics/guide/synthetics_test_monitors/synthetic_test_monitor.png" alt="Monitor de test Synthetic" style="width:100%;">}}
-
## Créer un monitor de test Synthetic
Vous ne pouvez pas créer ni importer de monitor de test Synthetic dans
Monitors.
diff --git a/content/fr/tracing/trace_collection/automatic_instrumentation/dd_libraries/php.md b/content/fr/tracing/trace_collection/automatic_instrumentation/dd_libraries/php.md
new file mode 100644
index 0000000000000..741b494b9d2df
--- /dev/null
+++ b/content/fr/tracing/trace_collection/automatic_instrumentation/dd_libraries/php.md
@@ -0,0 +1,492 @@
+---
+aliases:
+- /fr/tracing/languages/php
+- /fr/agent/apm/php/
+- /fr/tracing/php/
+- /fr/tracing/setup/php
+- /fr/tracing/setup_overview/php
+- /fr/tracing/setup_overview/setup/php
+- /fr/tracing/faq/php-tracer-manual-installation/
+- /fr/tracing/trace_collection/dd_libraries/php/
+code_lang: php
+code_lang_weight: 40
+further_reading:
+- link: /tracing/guide/trace-php-cli-scripts/
+ tag: Guide
+ text: Tracer des scripts CLI PHP
+- link: https://www.datadoghq.com/blog/monitor-php-performance/
+ tag: Blog
+ text: Surveillance PHP avec APM et le tracing distribué de Datadog
+- link: https://github.com/DataDog/dd-trace-php
+ tag: Code source
+ text: Code source
+- link: https://github.com/DataDog/dd-trace-php/blob/master/CONTRIBUTING.md
+ tag: Code source
+ text: Contribuer au projet open source
+- link: /tracing/glossary/
+ tag: Documentation
+ text: Explorer vos services, ressources et traces
+title: Tracer des applications PHP
+type: multi-code-lang
+---
+## Exigences de compatibilité
+
+La version minimale requise de PHP pour la dernière version de `dd-trace-php` est PHP 7. Si vous utilisez PHP 5, vous pouvez encore utiliser le traceur PHP jusqu'à la version [0.99] (https://github.com/Datadog/dd-tracer-PHP/releases/tagger/0.99.0). PHP 5 est en fin de cycle de vie à partir de la version 1.0 de la bibliothèque PHP.
+
+Pour obtenir la liste complète des frameworks et versions PHP pris en charge (y compris les anciennes versions et les versions de maintenance), consultez la page relative aux [exigences de compatibilité][1].
+
+## Prise en main
+
+Avant de commencer, vérifiez que vous avez bien [installé et configuré l'Agent][14].
+
+### Installer l'extension
+
+Téléchargez le programme d'installation officiel :
+
+```shell
+curl -LO https://github.com/DataDog/dd-trace-php/releases/latest/download/datadog-setup.php
+```
+
+Pour Alpine Linux, vous devez installer `libgcc_s` avant d'exécuter le programme d'installation :
+
+```shell
+apk add libgcc
+```
+
+Exécutez le programme d'installation :
+
+```shell
+# Installation complète : APM, ASM et profiling
+php datadog-setup.php --php-bin=all --enable-appsec --enable-profiling
+
+# APM seulement
+php datadog-setup.php --php-bin=all
+
+# APM et ASM
+php datadog-setup.php --php-bin=all --enable-appsec
+
+# APM et profiling
+php datadog-setup.php --php-bin=all --enable-profiling
+```
+
+
+Remarque : Windows ne prend en charge que l'APM. N'utilisez pas les marqueurs --enable-appsec
et --enable-profiling
lorsque vous tracez les applications PHP sur Windows.
+
+
+Cette commande installe l'extension sur l'ensemble des binaires PHP détectés sur le host ou le conteneur. Si vous ne précisez pas `--php-bin` dans la commande, le programme d'installation s'exécute en mode interactif et vous demande de sélectionner les binaires pertinents pour l'installation. La valeur de `--php-bin` peut être définie sur le chemin d'un binaire spécifique si jamais `dd-trace-php` doit être uniquement installé sur ce binaire.
+
+Redémarrez PHP (PHP-FPM ou le SAPI Apache), puis accédez à un endpoint de votre application pour lequel le tracing est activé. Pour afficher les traces générées, consultez la page relative aux [traces d'APM][5].
+
+Si vous ne spécifiez pas `--enable-appsec`, l'extension AppSec se charge peu de temps après le démarrage et n'est pas activée par défaut. Cela entraîne immédiatement un court-circuit, avec une surcharge des performances négligeable.
+
+
+
Remarque :
+quelques minutes peuvent s'écouler avant que les traces soient visibles dans l'interface. Si elles n'apparaissent toujours pas une fois ce délai passé, créez une page
phpinfo()
depuis la machine du host et faites défiler jusqu'à la section `ddtrace`. Vous y trouverez les checks de diagnostic qui ont échoué, pour vous aider à identifier les éventuels problèmes.
+
+
+
+Apache ZTS :
+si le binaire CLI PHP créé est de type NTS (non thread-safe), puisqu'Apache utilise une version ZTS (Zend thread-safe) de PHP, vous devez modifier manuellement le chargement de l'extension pour le binaire ZTS. Exécutez /chemin/vers/zts-php --ini
pour déterminer l'emplacement du fichier .ini
de Datadog, puis ajoutez le suffixe -zts
du nom du fichier. Par exemple, remplacez extension=ddtrace-20210902.so
par extension=ddtrace-20210902-zts.so
.
+
+
+
+SELinux :
+Si les stratégies httpd de SELinux sont configurées sur le host, la fonctionnalité du traceur peut être limitée, à moins que l'écriture et l'exécution de fichiers temporaires ne soient explicitement autorisées dans la configuration SELinux :
+
+`allow httpd_t httpd_tmpfs_t:file { execute execute_no_trans };`
+
+
+
+## Instrumentation automatique
+
+Par défaut, le tracing est automatiquement activé. Une fois l'extension installée, **ddtrace** trace votre application et envoie les traces à l'Agent.
+
+Par défaut, Datadog prend en charge tous les frameworks Web. L'instrumentation automatique fonctionne en modifiant l'exécution de PHP pour wrapper certaines fonctions et méthodes afin de les tracer. Le traceur PHP prend en charge l'instrumentation automatique pour plusieurs bibliothèques.
+
+L'instrumentation automatique capture :
+
+* Le temps d'exécution de la méthode
+* Les données de trace pertinentes, telles que l'URL et les codes de réponse de statut pour les requêtes Web ou les requêtes SQL pour l'accès à la base de données
+* Les exceptions non traitées, y compris les stack traces le cas échéant
+* Le nombre total de traces (p. ex. les requêtes Web) transmises via le système
+
+## Configuration
+
+Au besoin, configurez la bibliothèque de tracing pour envoyer des données de télémétrie relatives aux performances de l'application, notamment en configurant le tagging de service unifié. Consultez la section [Configuration de la bibliothèque][6] pour en savoir plus.
+
+## Tracer des scripts CLI à exécution courte et longue
+
+Des étapes supplémentaires sont requises pour instrumenter les scripts CLI. Consultez la section [Tracer des scripts CLI PHP][7] pour en savoir plus.
+
+## Mise à niveau
+
+Pour mettre à niveau le traceur PHP, [téléchargez la dernière version][5] et suivez les mêmes étapes que lors de l'[installation de l'extension](#installer-l-extension).
+
+Une fois l'installation terminée, redémarrez PHP (PHP-FPM ou le SAPI Apache).
+
+**Remarque** : si vous utilisez une mise en cache secondaire dans OPcache en définissant le paramètre `opcache.file_cache`, supprimez le dossier de cache.
+
+## Suppression
+
+Pour supprimer le tracer PHP :
+
+1. Pour php-fpm, arrêtez le service php-fpm ou le serveur Web Apache.
+2. Dissociez les fichiers `98-ddtrace.ini` and `99-ddtrace-custom.ini` de votre dossier de configuration PHP.
+3. Pour php-fpm, redémarrez le service php-fpm ou le serveur Web Apache.
+
+**Remarque** : si vous utilisez une mise en cache secondaire dans OPcache en définissant le paramètre `opcache.file_cache`, supprimez le dossier de cache.
+
+## Dépanner un crash d'application
+
+Si jamais le traceur PHP entraîne le crash de votre application, généralement en raison d'une erreur de segmentation, il est préférable d'obtenir un core dump ou une trace Valgrind et de contacter l'assistance Datadog.
+
+### Installer les symboles de debugging
+
+Pour que les core dumps soient lisibles, les symboles de debugging pour les binaires PHP doivent être installés sur le système qui exécute PHP.
+
+Pour vérifier si les symboles de debugging sont installés pour PHP ou PHP-FPM, utilisez `gdb`.
+
+Installez `gdb` :
+
+```
+apt|yum install -y gdb
+```
+
+Exécutez `gdb` avec le binaire souhaité. Par exemple pour PHP-FPM :
+
+```
+gdb php-fpm
+```
+
+Si la sortie de `gdb` contient une ligne similaire au texte ci-dessous, alors les symboles de debugging sont déjà installés.
+
+```
+...
+Reading symbols from php-fpm...Reading symbols from /usr/lib/debug/chemin/vers/un/fichier.debug...done.
+...
+```
+
+Si la sortie de `gdb` contient une ligne similaire au texte ci-dessous, alors les symboles de debugging doivent être installés :
+
+```
+...
+Reading symbols from php-fpm...(no debugging symbols found)...done.
+...
+```
+
+
+#### Centos
+
+Installez le package `yum-utils` qui fournit le programme `debuginfo-install` :
+
+```
+yum install -y yum-utils
+```
+
+Trouvez le nom du package pour vos binaires PHP. Celui-ci peut varier en fonction de la méthode d'installation de PHP :
+
+```
+yum list installed | grep php
+```
+
+Installez les symboles de debugging. Par exemple, pour le package `php-fpm` :
+
+```
+debuginfo-install -y php-fpm
+```
+
+**Remarque** : si le référentiel qui fournit les binaires PHP n'est pas activé par défaut, il peut être activé lors de l'exécution de la commande `debuginfo-install`. Par exemple :
+
+```
+debuginfo-install --enablerepo=remi-php74 -y php-fpm
+```
+
+#### Debian
+
+##### PHP installé depuis la DPA Sury Debian
+
+Si PHP a été installé depuis la [DPA Sury Debian][8], les symboles de debugging sont déjà disponibles à partir de la DPA. Par exemple, pour PHP-FPM 7.2 :
+
+```
+apt update
+apt install -y php7.2-fpm-dbgsym
+```
+
+##### PHP installé depuis un autre package
+
+Le projet Debian tient à jour une page wiki avec [des instructions pour installer les symboles de debugging][9].
+
+Modifiez le fichier `/etc/apt/sources.list` :
+
+```
+# ... laisser tous les packages existants ici
+
+# ajouter un `deb` deb http://deb.debian.org/debian-debug/ $RELEASE-debug main
+# Par exemple, pour buster
+deb http://deb.debian.org/debian-debug/ buster-debug main
+```
+
+Mettez à jour `apt` :
+
+```
+apt update
+```
+
+Essayez d'abord d'utiliser les noms canoniques des packages pour les symboles de debugging. Par exemple, si le nom du package est `php7.2-fpm`, essayez :
+
+```
+apt install -y php7.2-fpm-dbgsym
+
+# Si la ligne ci-dessus ne fonctionne pas
+
+apt install -y php7.2-fpm-dbg
+```
+
+Si les symboles de debugging sont introuvables, utilisez l'utilitaire `find-dbgsym-packages`. Installez le binaire :
+
+```
+apt install -y debian-goodies
+```
+
+Tentez de trouver les symboles de debugging à l'aide du chemin complet vers le binaire ou de l'ID d'un processus en cours d'exécution :
+
+```
+find-dbgsym-packages /usr/sbin/php-fpm7.2
+```
+
+Installez le package à l'aide du nom renvoyé, si vous l'avez trouvé :
+
+```
+apt install -y php7.2-fpm-{nom-du-package-renvoyé-par-les-packages-dbgsym}
+```
+
+#### Ubuntu
+
+##### PHP installé depuis `ppa:ondrej/php`
+
+Si PHP a été installé depuis [`ppa:ondrej/php`][10], modifiez le fichier source apt `/etc/apt/sources.list.d/ondrej-*.list` en ajoutant le composant `main/debug`.
+
+Avant :
+
+```deb http://ppa.launchpad.net/ondrej/php/ubuntu main```
+
+Après :
+
+```deb http://ppa.launchpad.net/ondrej/php/ubuntu main main/debug```
+
+Mettez à jour et installez les symboles de debugging. Par exemple, pour PHP-FPM 7.2 :
+
+```
+apt update
+apt install -y php7.2-fpm-dbgsym
+```
+##### PHP installé depuis un autre package
+
+Trouvez le nom du package pour vos binaires PHP. Celui-ci peut varier en fonction de la méthode d'installation de PHP :
+
+```
+apt list --installed | grep php
+```
+
+**Remarque** : dans certains cas, `php-fpm` peut être un méta-package qui renvoie vers le vrai package, par exemple `php7.2-fpm` pour PHP-FPM 7.2. Dans ce cas, le nom est celui du vrai package.
+
+Essayez d'abord d'utiliser les noms canoniques des packages pour les symboles de debugging. Par exemple, si le nom du package est `php7.2-fpm`, essayez :
+
+```
+apt install -y php7.2-fpm-dbgsym
+
+# Si la ligne ci-dessus ne fonctionne pas
+
+apt install -y php7.2-fpm-dbg
+```
+
+Si les packages `-dbg` et `-dbgsym` sont introuvables, activez les référentiels `ddebs`. Pour obtenir des instructions détaillées concernant l'[installation des symboles de debugging][11] depuis les `ddebs`, consultez la documentation Ubuntu.
+
+Par exemple, pour Ubuntu 18.04+, activez le référentiel `ddebs` :
+
+```
+echo "deb http://ddebs.ubuntu.com $(lsb_release -cs) main restricted universe multiverse" | tee -a /etc/apt/sources.list.d/ddebs.list
+
+echo "deb http://ddebs.ubuntu.com $(lsb_release -cs)-updates main restricted universe multiverse" | tee -a /etc/apt/sources.list.d/ddebs.list
+```
+
+Importez la clé de signature (assurez-vous qu'[elle est correcte][12]) :
+
+```
+apt install ubuntu-dbgsym-keyring
+apt-key adv --keyserver keyserver.ubuntu.com --recv-keys
+apt update
+```
+
+Essayez d'ajouter les noms canoniques des packages pour les symboles de debugging. Par exemple, si le nom du package est `php7.2-fpm`, essayez :
+
+```
+apt install -y php7.2-fpm-dbgsym
+
+# Si la ligne ci-dessus ne fonctionne pas
+
+apt install -y php7.2-fpm-dbg
+```
+
+Si les symboles de debugging sont introuvables, utilisez l'utilitaire `find-dbgsym-packages`. Installez le binaire :
+
+```
+apt install -y debian-goodies
+```
+
+Tentez de trouver les symboles de debugging à l'aide du chemin complet vers le binaire ou de l'ID d'un processus en cours d'exécution :
+
+```
+find-dbgsym-packages /usr/sbin/php-fpm7.2
+```
+
+Installez le package à l'aide du nom renvoyé, si vous l'avez trouvé :
+
+```
+apt install -y php7.2-fpm-{nom-du-package-renvoyé-par-les-packages-dbgsym}
+```
+
+### Obtenir un core dump
+
+Il peut s'avérer difficile d'obtenir un core dump pour les applications PHP, notamment pour PHP-FPM. Voici quelques conseils pour vous aider :
+
+1. Passez en revue le log d'erreur de l'application pour déterminer si PHP-FPM a généré un core dump :
+ - Recherchez l'expression `(SIGSEGV - core dumped)`, afin de trouver un message confirmant l'enregistrement d'un core dump. Exemple : `WARNING: [pool www] child exited on signal 11 (SIGSEGV - core dumped) after seconds from start`.
+ - Recherchez l'expression `(SIGSEGV)`, afin de trouver un message confirmant le non-enregistrement d'un core dump. Exemple : `WARNING: [pool www] child exited on signal 11 (SIGSEGV) after seconds from start`.
+1. Accédez au core dump en exécutant `cat /proc/sys/kernel/core_pattern`. La valeur par défaut étant généralement `core`, un fichier `core` est donc généré dans le dossier racine Web.
+
+Si aucun core dump n'a été généré, vérifiez les configurations suivantes et modifiez-les en fonction de vos besoins :
+
+1. Si `/proc/sys/kernel/core_pattern` contient un chemin comprenant des répertoires imbriqués, assurez-vous que le chemin d'accès avec les répertoires complets existe.
+1. Si l'utilisateur qui exécute les workers du pool PHP-FPM n'est pas `root` (`www-data` est généralement utilisé), attribuez à cet utilisateur des autorisations d'écriture dans le répertoire des core dumps.
+1. Assurez-vous que la valeur de `/proc/sys/fs/suid_dumpable` n'est pas `0`. Définissez-la sur `1` ou `2`, sauf si vous exécutez le pool de workers PHP-FPM en tant que `root`. Vérifiez vos options avec votre administrateur système.
+1. Assurez-vous que la valeur de `rlimit_core` est adéquate dans la configuration du pool PHP-FPM. Vous pouvez retirer cette limite, avec `rlimit_core = unlimited`.
+1. Assurez-vous que la valeur de `ulimit` est adéquate dans votre système. Vous pouvez retirer cette limite, avec `ulimit -c unlimited`.
+1. Si votre application s'exécute dans un conteneur Docker et que vous souhaitez modifier `/proc/sys/*`, vous devez effectuer les changements sur la machine du host. Contactez votre administrateur système pour découvrir les différentes options qui s'offrent à vous. Si vous le pouvez, essayez de reproduire le problème dans vos environnements staging ou test.
+
+### Obtention d'un core dump à partir d'un site conteneur Docker
+
+Utilisez les informations ci-dessous pour savoir comment obtenir un core dump dans un conteneur Docker :
+
+1. Le site conteneur Docker doit être exécuté en tant que conteneur privilégié, et la valeur `ulimit` pour les fichiers du core doit être fixée à son maximum, comme indiqué dans les exemples ci-dessous.
+ - Si vous utilisez la commande `docker run`, ajoutez les arguments `--privileged` et `--ulimit core=99999999999`
+ - Si vous utilisez `docker compose`, ajoutez ce qui suit au fichier `docker-compose.yml` :
+```yaml
+privileged: true
+ulimits:
+ core: 99999999999
+```
+2. Lorsque vous exécutez le conteneur (et avant de lancer l'application PHP ), vous devez exécuter les commandes suivantes :
+```
+ulimit -c unlimited
+echo '/tmp/core' > /proc/sys/kernel/core_pattern
+echo 1 > /proc/sys/fs/suid_dumpable
+```
+
+### Obtenir une trace Valgrind
+
+Pour obtenir des informations plus détaillées sur le crash, exécutez l'application avec Valgrind. Contrairement aux core dumps, cette méthode fonctionne toujours dans un conteneur sans privilège.
+
+
+Remarque : une application exécutée à travers Valgrind est considérablement plus lente que lorsqu'elle est exécutée nativement. Cette méthode est uniquement recommandée en dehors d'un environnement de production.
+
+
+Installez Valgrind avec votre gestionnaire de package. Exécutez l'application avec Valgrind le temps de générer quelques requêtes.
+
+Pour une application CLI, exécutez :
+{{< code-block lang=shell >}}
+USE_ZEND_ALLOC=0 valgrind -- php chemin/vers/script.php
+{{< /code-block >}}
+Si vous utilisez `php-fpm`, exécutez :
+{{< code-block lang="shell" >}}
+USE_ZEND_ALLOC=0 valgrind --trace-children=yes -- php-fpm -F --fpm-config
+{{< /code-block >}}
+Si vous utilisez Apache, exécutez :
+{{< code-block lang="shell" >}}
+(. /etc/apache2/envvars; USE_ZEND_ALLOC=0 valgrind --trace-children=yes -- apache2 -X)`
+{{< /code-block >}}
+
+Par défaut, la trace Valgrind obtenue est générée vers stderr ; suivez la [documentation officielle][13] (en anglais) pour la générer vers une autre cible. La sortie devrait ressembler à l'exemple ci-dessous pour un processus PHP-FPM :
+
+```
+==322== Conditional jump or move depends on uninitialised value(s)
+==322== at 0x41EE82: zend_string_equal_val (zend_string.c:403)
+==322== ...
+==322== ...
+==322==
+==322== Process terminating with default action of signal 11 (SIGSEGV): dumping core
+==322== at 0x73C8657: kill (syscall-template.S:81)
+==322== by 0x1145D0F2: zif_posix_kill (posix.c:468)
+==322== by 0x478BFE: ZEND_DO_ICALL_SPEC_RETVAL_UNUSED_HANDLER (zend_vm_execute.h:1269)
+==322== by 0x478BFE: execute_ex (zend_vm_execute.h:53869)
+==322== by 0x47D9B0: zend_execute (zend_vm_execute.h:57989)
+==322== by 0x3F6782: zend_execute_scripts (zend.c:1679)
+==322== by 0x394F0F: php_execute_script (main.c:2658)
+==322== by 0x1FFE18: main (fpm_main.c:1939)
+==322==
+==322== Process terminating with default action of signal 11 (SIGSEGV)
+==322== ...
+==322== ...
+==322==
+==322== HEAP SUMMARY:
+==322== in use at exit: 3,411,619 bytes in 22,428 blocks
+==322== total heap usage: 65,090 allocs, 42,662 frees, 23,123,409 bytes allocated
+==322==
+==322== LEAK SUMMARY:
+==322== definitely lost: 216 bytes in 3 blocks
+==322== indirectly lost: 951 bytes in 32 blocks
+==322== possibly lost: 2,001,304 bytes in 16,840 blocks
+==322== still reachable: 1,409,148 bytes in 5,553 blocks
+==322== of which reachable via heuristic:
+==322== stdstring : 384 bytes in 6 blocks
+==322== suppressed: 0 bytes in 0 blocks
+==322== Rerun with --leak-check=full to see details of leaked memory
+==322==
+==322== Use --track-origins=yes to see where uninitialised values come from
+==322== For lists of detected and suppressed errors, rerun with: -s
+==322== ERROR SUMMARY: 18868 errors from 102 contexts (suppressed: 0 from 0)
+```
+
+### Obtenir une strace
+
+Certains problèmes étant causés par des facteurs externes, il peut être utile d'obtenir une `strace`.
+
+
+Remarque : une application exécutée à travers strace
est considérablement plus lente que lorsqu'elle est exécutée nativement. Cette méthode est uniquement recommandée en dehors d'un environnement de production.
+
+
+Installez `strace` avec votre gestionnaire de package. Lorsque vous générez une `strace` afin de l'envoyer à l'assistance Datadog, assurez-vous d'utiliser l'option `-f` pour suivre les processus enfant.
+
+Pour une application CLI, exécutez :
+{{< code-block lang="shell" >}}
+strace -f php chemin/vers/script.php
+{{< /code-block >}}
+
+Pour `php-fpm`, exécutez :
+{{< code-block lang="shell" >}}
+strace -f php-fpm -F --fpm-config
+{{< /code-block >}}
+
+Pour Apache, exécutez :
+{{< code-block lang="shell" >}}
+(. /etc/apache2/envvars; strace -f apache2 -X)
+{{< /code-block >}}
+
+## Pour aller plus loin
+
+{{< partial name="whats-next/whats-next.html" >}}
+
+[1]: /fr/tracing/compatibility_requirements/php
+[2]: https://app.datadoghq.com/apm/service-setup
+[3]: /fr/tracing/glossary/
+[4]: https://app.datadoghq.com/apm/traces
+[5]: https://github.com/DataDog/dd-trace-php/releases
+[6]: /fr/tracing/trace_collection/library_config/php/
+[7]: /fr/tracing/guide/trace-php-cli-scripts/
+[8]: https://packages.sury.org/php/
+[9]: https://wiki.debian.org/HowToGetABacktrace
+[10]: https://launchpad.net/~ondrej/+archive/ubuntu/php
+[11]: https://wiki.ubuntu.com/Debug%20Symbol%20Packages
+[12]: https://wiki.ubuntu.com/Debug%20Symbol%20Packages#Getting_-dbgsym.ddeb_packages
+[13]: https://valgrind.org/docs/manual/manual-core.html#manual-core.comment
+[14]: /fr/tracing/trace_collection/automatic_instrumentation/?tab=datadoglibraries#install-and-configure-the-agent
\ No newline at end of file
diff --git a/content/ja/account_management/authn_mapping/_index.md b/content/ja/account_management/authn_mapping/_index.md
index 7f384f94a99a6..911c79987ac91 100644
--- a/content/ja/account_management/authn_mapping/_index.md
+++ b/content/ja/account_management/authn_mapping/_index.md
@@ -25,7 +25,7 @@ Datadog UI では、ユーザー管理の **Mappings** タブでマッピング
AuthN Mapping を JSON の本文から新しく作成します。新規作成された AuthN Mapping を返します。
-| Method | エンドポイントのパス | ペイロードの要件 |
+| メソッド | エンドポイントのパス | ペイロードの要件 |
|--------|----------------------|------------------|
| `POST` | `/v2/authn_mappings` | JSON |
diff --git a/content/ja/account_management/saml/google.md b/content/ja/account_management/saml/google.md
index 95517200ddca4..e49bda042e61b 100644
--- a/content/ja/account_management/saml/google.md
+++ b/content/ja/account_management/saml/google.md
@@ -20,7 +20,7 @@ title: Google SAML IdP
前提として、Datadog の [SAML 構成ページ][2]で、**IDP initiated SSO** にチェックを入れる必要があります。
Application Name
-: Can be anything
+: 任意の名前
Description
: 任意の説明
@@ -40,11 +40,11 @@ Signed Response
Name ID
: **Basic Information** と **Primary Email** を選択します
-## Attribute mapping
+## 属性のマッピング
* urn:oid:1.3.6.1.4.1.5923.1.1.1.6、基本情報、メインのメールアドレス
-Also add:
+以下も追加してください。
* urn:oid:2.5.4.4、基本情報、姓
* urn:oid:2.5.4.42、基本情報、名
diff --git a/content/ja/account_management/saml/okta.md b/content/ja/account_management/saml/okta.md
index 58d6a5d8ba6b4..8406b040020e6 100644
--- a/content/ja/account_management/saml/okta.md
+++ b/content/ja/account_management/saml/okta.md
@@ -29,10 +29,10 @@ Okta の[カスタム SAML アプリのインテグレーションを作成す
| Okta IDP 入力フィールド | 予測値 |
|-----------------------------|--------------------------------------------------------------------------------------------------------------------------------|
-| シングルサインオン URL | Assertion Consumer Service URL (Find this URL on the [Configure SAML page][3], in the *Assertion Consumer Service URL* field.) |
+| シングルサインオン URL | Assertion Consumer Service URL (この URL は [Configure SAML ページ][3]の *Assertion Consumer Service URL* フィールドで確認できます) |
| Recipient URL | Assertion Consumer Service URL (または *Use this for Recipient URL and Destination URL* チェックボックスをオンにします) |
| Destination URL | Assertion Consumer Service URL (または *Use this for Recipient URL and Destination URL* チェックボックスをオンにします) |
-| Audience URI (SP Entity ID) | Service Provider Entity ID (Find this ID on the [Configure SAML page][3], in the *Service Provider Entity ID* field.) |
+| Audience URI (SP Entity ID) | サービスプロバイダーのエンティティ ID (この ID は [Configure SAML ページ][3]の *Service Provider Entity ID* フィールドで確認できます) |
| Name ID Format | EmailAddress |
| 応答 | Signed |
| Assertion Signature | Signed |
@@ -55,7 +55,7 @@ Okta の[カスタム SAML アプリのインテグレーションを作成す
これは [AuthN Mapping][4] を使用している場合にのみ必要です。
-| Name | 名前形式 (オプション) | 値 |
+| 名前 | 名前形式 (オプション) | 値 |
|----------|------------------------|---------------------------------------------------------------------------------------------------------------------------|
| memberOf | 指定なし | 正規表現 `.*` に一致 (このメソッドはすべてのグループを取得します。お使いのユースケースに適合しない場合は IDP 管理者にお問い合わせください) |
diff --git a/content/ja/agent/basic_agent_usage/puppet.md b/content/ja/agent/basic_agent_usage/puppet.md
index 3602a45470e44..1bbfc3bdf649b 100644
--- a/content/ja/agent/basic_agent_usage/puppet.md
+++ b/content/ja/agent/basic_agent_usage/puppet.md
@@ -17,7 +17,7 @@ Datadog Puppet モジュールは Linux および Windows をサポートし、P
puppet module install datadog-datadog_agent
```
-#### Upgrading
+#### アップグレード
- デフォルトでは、Datadog Agent v7.x がインストールされます。以前のバージョンの Agent を使用するには、設定 `agent_major_version` を変更します。
- `agent5_enable` は `agent_major_version` に置き換えられたため使用されなくなりました。
@@ -305,7 +305,7 @@ class { "datadog_agent":
| `non_local_traffic` | 他のノードがこのノードを介してトラフィックをリレーできるようにします。 |
| `apm_enabled` | APM Agent を有効にするブール値(デフォルトは false)。 |
| `process_enabled` | プロセス Agent を有効にするブール値(デフォルトは false)。 |
-| `scrub_args` | A boolean to enable the process cmdline scrubbing (defaults to true). |
+| `scrub_args` | プロセスのコマンドラインスクラビングを有効にするブール値(デフォルトは true)。 |
| `custom_sensitive_words` | スクラビング機能で使用されるデフォルトのものを超える単語を追加するための配列(デフォルトは `[]`)。 |
| `logs_enabled` | ログ Agent を有効にするブール値(デフォルトは false)。 |
| `windows_npm_install` | Windows NPM ドライバーのインストールを有効にするためのブール値 (デフォルトは false)。 |
diff --git a/content/ja/agent/basic_agent_usage/redhat.md b/content/ja/agent/basic_agent_usage/redhat.md
index effd5389624fc..516806da03ce8 100644
--- a/content/ja/agent/basic_agent_usage/redhat.md
+++ b/content/ja/agent/basic_agent_usage/redhat.md
@@ -51,7 +51,7 @@ Agent v6 & v7 では、オペレーティングシステムから提供される
| サービスとして実行中の Agent の停止 | `sudo systemctl stop datadog-agent` |
| サービスとして実行中の Agent の再起動 | `sudo systemctl restart datadog-agent` |
| Agent サービスのステータス | `sudo systemctl status datadog-agent` |
-| Status page of running Agent | `sudo datadog-agent status` |
+| 実行中の Agent のステータスページ | `sudo datadog-agent status` |
| フレアの送信 | `sudo datadog-agent flare` |
| コマンドの使用方法の表示 | `sudo datadog-agent --help` |
| チェックの実行 | `sudo -u dd-agent -- datadog-agent check ` |
diff --git a/content/ja/agent/basic_agent_usage/saltstack.md b/content/ja/agent/basic_agent_usage/saltstack.md
index 91d79fe3cead6..e258428ee10f1 100644
--- a/content/ja/agent/basic_agent_usage/saltstack.md
+++ b/content/ja/agent/basic_agent_usage/saltstack.md
@@ -11,7 +11,7 @@ Datadog SaltStack Formula は、Datadog Agent および Agent ベースのイン
Datadog SaltStack Formula は、Debian および RedHat ベースのシステムにのみインストールできます。
-### Installation
+### インストール
以下の手順で、Datadog Formula を `base` Salt 環境に追加します。別の Salt 環境に追加する場合は、参照先の `base` を お使いの Salt 環境名に変更してください。
@@ -138,9 +138,9 @@ file_roots:
```text
datadog:
config:
- api_key:
+ api_key:
install_settings:
- agent_version:
+ agent_version:
checks:
directory:
config:
diff --git a/content/ja/agent/guide/_index.md b/content/ja/agent/guide/_index.md
index 33c1d74b968ea..21bfc21907190 100644
--- a/content/ja/agent/guide/_index.md
+++ b/content/ja/agent/guide/_index.md
@@ -18,8 +18,8 @@ title: Agent ガイド
{{< /whatsnext >}}
{{< whatsnext desc="Windows guides:" >}}
- {{< nextlink href="agent/guide/datadog-agent-manager-windows" >}}Datadog Agent Manager for Windows{{< /nextlink >}}
- {{< nextlink href="agent/guide/windows-agent-ddagent-user" >}}Datadog Windows Agent user{{< /nextlink >}}
+ {{< nextlink href="agent/guide/datadog-agent-manager-windows" >}}Windows 用 Datadog Agent Manager{{< /nextlink >}}
+ {{< nextlink href="agent/guide/windows-agent-ddagent-user" >}}Datadog Windows Agent ユーザー{{< /nextlink >}}
{{< /whatsnext >}}
{{< whatsnext desc="Cloud infrastructure guides:" >}}
diff --git a/content/ja/agent/guide/agent-5-autodiscovery.md b/content/ja/agent/guide/agent-5-autodiscovery.md
index 7a2f65b854fe7..f3603cffd3b03 100644
--- a/content/ja/agent/guide/agent-5-autodiscovery.md
+++ b/content/ja/agent/guide/agent-5-autodiscovery.md
@@ -252,7 +252,7 @@ spec:
- containerPort: 80
```
-#### Apache and HTTP checks
+#### Apache チェックと HTTP チェック
Deployment からポッドを定義する場合は、テンプレートアノテーションを Deployment のメタデータに追加しないでください。Agent はこれを参照しません。以下のように指定して、アノテーションを追加します。
diff --git a/content/ja/agent/guide/python-3.md b/content/ja/agent/guide/python-3.md
index fb8753f03d577..31b23f7d2df6b 100644
--- a/content/ja/agent/guide/python-3.md
+++ b/content/ja/agent/guide/python-3.md
@@ -136,7 +136,7 @@ Python 2 は Unicode テキストとバイナリコード化されたデータ
| type | リテラル | Python 2 | Python 3 |
|---------|---------|----------|----------|
-| bytes | b'...' | バイナリ | バイナリ |
+| バイト | b'...' | バイナリ | バイナリ |
| str | '...' | バイナリ | テキスト |
| unicode | u'...' | テキスト | テキスト |
diff --git a/content/ja/agent/logs/_index.md b/content/ja/agent/logs/_index.md
index 252458d89a5cb..843978a989a85 100644
--- a/content/ja/agent/logs/_index.md
+++ b/content/ja/agent/logs/_index.md
@@ -75,7 +75,7 @@ Windows では、パス `:\\\\.log`
{{% tab "TCP/UDP" %}}
-To gather logs from your `` application that forwards its logs to TCP port **10518**, create a `.d/conf.yaml` file at the root of your [Agent's configuration directory][1] with the following content:
+TCP ポート **10518** にログを転送する `` アプリケーションからログを収集するには、[Agent の構成ディレクトリ][1]のルートに以下の内容の `.d/conf.yaml` ファイルを作成します。
```yaml
logs:
diff --git a/content/ja/agent/troubleshooting/site.md b/content/ja/agent/troubleshooting/site.md
index e40deebf3d725..0a21e7e4c315e 100644
--- a/content/ja/agent/troubleshooting/site.md
+++ b/content/ja/agent/troubleshooting/site.md
@@ -4,7 +4,7 @@ title: Agent サイトの問題
デフォルトでは、Agent はそのデータを Datadog US サイト: `app.datadoghq.com` に送信します。組織が別のサイトにある場合は、[Agent メイン構成ファイル][1]の `site` パラメーターを更新するか、`DD_SITE` 環境変数を設定する必要があります。
-To update the Datadog documentation to your site, use the selector on the right. You are currently viewing documentation for: {{< region-param key="dd_full_site" code="true" >}}.
+Datadog のドキュメントをサイトに更新するには、右側のセレクターを使用します。現在、{{< region-param key="dd_full_site" code="true" >}} のドキュメントを表示しています。
`DD_SITE` 変数を {{< region-param key="dd_site" code="true" >}} に設定するか、`datadog.yaml` の `site` パラメーターを更新します。
diff --git a/content/ja/cloud_cost_management/recommendations/_index.md b/content/ja/cloud_cost_management/recommendations/_index.md
new file mode 100644
index 0000000000000..b0aac48e96bbb
--- /dev/null
+++ b/content/ja/cloud_cost_management/recommendations/_index.md
@@ -0,0 +1,129 @@
+---
+description: Cost Recommendations を使用して、組織のクラウドリソースの支出を削減する方法を学びましょう。
+further_reading:
+- link: /cloud_cost_management/
+ tag: ドキュメント
+ text: Cloud Cost Management について
+private: true
+title: Cloud Cost Recommendations
+---
+
+{{< callout url = "#" btn_hidden = "true" >}}
+Cloud Cost Recommendations は AWS をサポートする公開ベータ版で、Cloud Cost Management を設定している場合に自動的に有効になります。
+{{< /callout >}}
+
+## 概要
+
+[Cloud Cost Recommendations][1] は、クラウドリソースの使用を最適化することでクラウド支出を削減するための提案を提供します。
+
+{{< img src="cloud_cost/recommendations/cost_recommendations.png" alt="Cloud Cost Recommendations ページで、毎月の潜在的な節約額、年間の潜在的な節約額、およびオープンケースの合計数を示す概要タブ" style="width:100%;" >}}
+
+レコメンデーションは、請求データと可観測性データを組み合わせて、孤立した、レガシーの、または過剰にプロビジョニングされたクラウドリソースを特定します。
+
+## セットアップ
+
+レコメンデーションを受け取りたい各 AWS アカウントについて、
+
+1. [Cloud Cost Management][2] を構成して、請求データを Datadog に送信します。
+1. [AWS インテグレーションタイル][4]の **Resource Collection** タブで[リソースコレクション][3]を有効にします。
+1. [Datadog Agent][5] をインストールします (過剰にプロビジョニングされたリソースのレコメンデーションに必要)。
+
+## レコメンデーションタイプ
+
+Datadog は、可観測性データと基盤となるクラウドプロバイダーの請求データを組み合わせて、一連のレコメンデーションを生成します。各レコメンデーションタイプの詳細なロジックは、レコメンデーション生成に使用された可観測性メトリクスやコストデータと共に、[**Recommendations** ページ][1]で確認できます。
+
+{{< img src="cloud_cost/recommendations/overprovisioned_k8s_containers_sidepanel.png" alt="広告オークションサービスで過剰にプロビジョニングされている Kubernetes コンテナと、その使用状況を変更するための推奨される次のステップ、および調査メトリクスを表示するサイドパネル。" style="width:100%;" >}}
+
+レコメンデーションは毎日実行され、お客様のアカウントで自動的に更新されます。新しいレコメンデーションがリリースされると、Datadog は自動的にアカウントに追加します。
+
+### リソースレコメンデーションの終了
+
+Datadog は、クラウド環境をスキャンして、削除可能な孤立したリソースを特定します。
+
+未使用の EC2 インスタンス
+: CPU 使用率が 5% 未満、メモリ使用率が 10% 未満の EC2 インスタンス。
+
+未接続の EBS ボリューム
+: EC2 インスタンスから切り離されたボリューム。
+
+未使用の EBS ボリューム
+: 稼働していない EC2 インスタンスに接続されたボリューム。
+
+未使用の RDS インスタンス
+: データベース接続が 0、レプリカラグが 0 の RDS インスタンス。
+
+放棄された S3 マルチパートアップロード
+: 不完全なマルチパートのアップロード ([Storage Lens メトリクス][6]が必要)。
+
+未使用の Redshift クラスター
+: データベース接続が 0 の Redshift クラスター。
+
+未使用の Elasticache Redis クラスター
+: キャッシュヒット数 0、レプリケーションバイト数 0 の Elasticache Redis クラスター。
+
+未使用の MQ ブローカー
+: 接続数が 0 の MQ ブローカー。
+
+古い ECR イメージ
+: ECR イメージのバイトが 180 日以上古い。
+
+OpenSearch クラスター
+: 接続数が 0 の OpenSearch クラスター。
+
+未使用の Classic Elastic Load Balancer
+: EC2 インスタンスに接続されていない、アクティブな接続のない Classic Elastic Load Balancer。
+
+未使用のネットワーク Elastic ロードバランサー
+: 処理バイト数が 0 のネットワークロードバランサー。
+
+未使用のアプリケーションロードバランサー
+: トラフィックが処理されていないアプリケーションロードバランサー。
+
+未使用の NAT ゲートウェイ
+: 送信されたバイトがない NAT ゲートウェイ。
+
+アイドル状態の Elastic IP アドレス
+: AWS のコストと使用レポートにおいて、アイドル状態の課金がある Elastic IP アドレス。
+
+### リソース移行のレコメンデーション
+
+Datadog は、レガシーなハードウェアで稼働しているリソースを表示します。コストを削減し、リソースのパフォーマンスを向上させるために、これらのリソースのアップグレードを検討することができます。
+
+レガシー EC2 インスタンス
+: 旧世代の、新しいインスタンスタイプにアップグレードできる EC2 インスタンス。
+
+GP2 EBS ボリューム
+: GP2 の、コスト削減とパフォーマンス向上のために GP3 にアップグレードできる EBS ボリューム。
+
+I01 EBS ボリューム
+: I01 の、コスト削減とパフォーマンス向上のために GP3 にアップグレードできる EBS ボリューム。
+
+### リソースサイズ適正化のレコメンデーション
+
+Datadog は、使用率が低い、または過剰にプロビジョニングされている個々のリソースを特定します。コスト削減とリソースのパフォーマンス向上のために、サイズと構成の調整を検討することができます。
+
+EC2 インスタンスのダウンサイジング
+: オートスケーリンググループに属さず、CPU とメモリの使用率が 50% 未満の EC2 インスタンス。
+
+
+オーバープロビジョニングされた Kubernetes コンテナ
+: CPU とメモリの使用率が 30% 未満のコンテナ。
+
+
+オーバープロビジョニングされた EBS ボリュームのスループット
+: スループット量が使用量を上回っている EBS ボリューム。
+
+
+オーバープロビジョニングされた EBS ボリュームの IOPS
+: IOPS の量が使用量を超えている EBS ボリューム。
+
+## 参考資料
+
+{{< partial name="whats-next/whats-next.html" >}}
+
+[1]: https://app.datadoghq.com/cost/recommendations
+[2]: /ja/cloud_cost_management/aws/#setup
+[3]: /ja/integrations/amazon_web_services/#resource-collection
+[4]: https://app.datadoghq.com/integrations/aws
+[5]: /ja/agent/
+[6]: /ja/integrations/amazon_s3_storage_lens/
\ No newline at end of file
diff --git a/content/ja/continuous_integration/_index.md b/content/ja/continuous_integration/_index.md
index 385ed52746867..969eb95b25509 100644
--- a/content/ja/continuous_integration/_index.md
+++ b/content/ja/continuous_integration/_index.md
@@ -20,6 +20,9 @@ further_reading:
- link: /continuous_integration/pipelines/
tag: ドキュメント
text: ビルドの問題を解決するためにパイプラインデータを調査する
+- link: /account_management/billing/ci_visibility
+ tag: ドキュメント
+ text: CI Visibility の請求に関する注意事項について
- link: /continuous_integration/tests/
tag: ドキュメント
text: 問題のあるテストを見つけて修正するために、テストデータを調査する
@@ -28,7 +31,7 @@ further_reading:
text: 静的 Web アプリケーションを監視するためのベストプラクティス
- link: https://www.datadoghq.com/blog/best-practices-for-ci-cd-monitoring/
tag: ブログ
- text: CI/CD モニタリングのベストプラクティス
+ text: CI/CD 監視のベストプラクティス
- link: https://www.datadoghq.com/blog/best-practices-for-monitoring-software-testing/
tag: ブログ
text: CI/CD のソフトウェアテストを監視するためのベストプラクティス
@@ -44,8 +47,8 @@ title: Continuous Integration Visibility
このページでは、継続的インテグレーション (CI) のメトリクスとデータを Datadog のダッシュボードに取り込む方法について説明します。CI パイプラインで Continuous Testing テストを実行したい場合は、
Continuous Testing と CI/CD のセクションを参照してください。
-{{< learning-center-callout header="Join an enablement webinar session" hide_image="true" btn_title="Sign Up" btn_url="https://www.datadoghq.com/technical-enablement/sessions/?tags.topics-0=CI">}}
- Join the Introduction to CI Visibility session to understand how Datadog CI Visibility enhances the efficiency of CI pipelines and how to configure the Testing Visibility and Pipeline Visibility products.
+{{< learning-center-callout header="イネーブルメントウェビナーセッションに参加" hide_image="true" btn_title="登録" btn_url="https://www.datadoghq.com/technical-enablement/sessions/?tags.topics-0=CI">}}
+ Datadog CI Visibility がどのようにして CI パイプラインの効率を高めるのか、また、Testing Visibility と Pipeline Visibility 製品の構成方法について学ぶために、CI Visibility 入門セッションにご参加ください。
{{< /learning-center-callout >}}
diff --git a/content/ja/dashboards/functions/rank.md b/content/ja/dashboards/functions/rank.md
index 0f492794c4eea..44d206df2b5d7 100644
--- a/content/ja/dashboards/functions/rank.md
+++ b/content/ja/dashboards/functions/rank.md
@@ -25,7 +25,7 @@ title: ランク
- `sum`: すべてのメトリクス値の合計。
- `last`: 最後のメトリクス値。
- `l2norm`: 時系列の[ノルム][1]を使用して (常に正の値)、系列をランク付けします。
- - `area`: Signed area under the curve being graphed, which can be negative
+ - `area`: グラフの曲線の下の符号付き面積。負の場合もあります。
* `DIR`: ランク付けの方向。以下のいずれかを選択します。
- `asc`: 結果を昇順でランク付けします。
diff --git a/content/ja/dashboards/guide/_index.md b/content/ja/dashboards/guide/_index.md
index 7219e60a36c60..fc8ab4ebb7d29 100644
--- a/content/ja/dashboards/guide/_index.md
+++ b/content/ja/dashboards/guide/_index.md
@@ -38,10 +38,6 @@ title: グラフ作成ガイド
{{< nextlink href="/dashboards/guide/how-weighted-works" >}}weighted() の仕組みは?{{< /nextlink >}}
{{< /whatsnext >}}
-{{< whatsnext desc="DDSQL Editor:" >}}
- {{< nextlink href="/dashboards/guide/ddsql_use_cases" >}}Common DDSQL queries and use cases{{< /nextlink >}}
-{{< /whatsnext >}}
-
{{< whatsnext desc="非推奨の API:" >}}
{{< nextlink href="dashboards/guide/screenboard-api-doc" >}}スクリーンボード API{{< /nextlink >}}
{{< nextlink href="dashboards/guide/timeboard-api-doc" >}}タイムボード API{{< /nextlink >}}
diff --git a/content/ja/dashboards/guide/screenboard-api-doc.md b/content/ja/dashboards/guide/screenboard-api-doc.md
index 1776ec802741a..c8aea0c419e9d 100644
--- a/content/ja/dashboards/guide/screenboard-api-doc.md
+++ b/content/ja/dashboards/guide/screenboard-api-doc.md
@@ -22,7 +22,7 @@ title: スクリーンボード API
* **`board_title`** [必須]:
ダッシュボードの名前。
* **`description`** [オプション、デフォルト = **None**]:
- A description of the dashboard's content.
+ ダッシュボードの内容の説明。
* **`widgets`** [必須]:
ウィジェット定義のリスト。ウィジェット定義を取得するには、ウィジェット構成 UI で JSON タブを使用します。
* **`template_variables`** [オプション、デフォルト = **None**]:
diff --git a/content/ja/dashboards/querying/_index.md b/content/ja/dashboards/querying/_index.md
index d235e48e4574d..a2a4e06c00b15 100644
--- a/content/ja/dashboards/querying/_index.md
+++ b/content/ja/dashboards/querying/_index.md
@@ -60,7 +60,7 @@ Datadog では、メトリクス、ログ、トレース、モニター、ダッ
- `from` ドロップダウン内の[高度なフィルタリング][7]を使用して、ブール型またはワイルドカードでフィルタリングされたクエリを評価します。
- テンプレート変数を使用して、クエリを動的にフィルターします。タグキーと一緒に `$` を追加すると、グラフはテンプレート変数のドロップダウンで選択したタグを自動的に適用します。詳細は[テンプレート変数のドキュメント][16]を参照してください。
-To learn more about tags, see the [Tagging documentation][8].
+タグの詳細は、[タグ付けに関するドキュメント][8]を参照してください。
### 集計、ロールアップする
diff --git a/content/ja/dashboards/widgets/_index.md b/content/ja/dashboards/widgets/_index.md
index 92ab142cb54ed..00c8aee3d589d 100644
--- a/content/ja/dashboards/widgets/_index.md
+++ b/content/ja/dashboards/widgets/_index.md
@@ -9,196 +9,196 @@ further_reading:
text: カスタムリンク
- link: https://www.datadoghq.com/blog/observability-pipelines-transform-and-enrich-logs/
tag: blog
- text: Transform and enrich your logs with Datadog Observability Pipelines
+ text: Datadog Observability Pipelines によるログの変換と強化
title: ウィジェット
---
-## Overview
+## 概要
-Widgets are building blocks for your dashboards. They allow you to visualize and correlate your data across your infrastructure.
+ウィジェットは、ダッシュボードの構成要素です。ウィジェットによって、インフラストラクチャー全体のデータを視覚化し、相関させることができます。
-### Graphs
-{{< whatsnext desc="Generic widgets to graph data from Datadog products: ">}}
+### グラフ
+{{< whatsnext desc="Datadog 製品のデータをグラフ化する汎用ウィジェット: ">}}
{{< nextlink href="/dashboards/widgets/change"
- img="dashboards/widgets/icons/change_light_large.png">}} Change {{< /nextlink >}}
+ img="dashboards/widgets/icons/change_light_large.png">}} 変化 {{< /nextlink >}}
{{< nextlink href="/dashboards/widgets/distribution"
- img="dashboards/widgets/icons/distribution_light_large.png">}} Distribution{{< /nextlink >}}
+ img="dashboards/widgets/icons/distribution_light_large.png">}} ディストリビューション{{< /nextlink >}}
{{< nextlink href="/dashboards/widgets/funnel"
- img="dashboards/widgets/icons/funnel_light_large.png">}} Funnel{{< /nextlink >}}
+ img="dashboards/widgets/icons/funnel_light_large.png">}} ファネル{{< /nextlink >}}
{{< nextlink href="/dashboards/widgets/geomap"
- img="dashboards/widgets/icons/geomap_light_large.png">}} Geomap{{< /nextlink >}}
+ img="dashboards/widgets/icons/geomap_light_large.png">}} ジオマップ{{< /nextlink >}}
{{< nextlink href="/dashboards/widgets/heat_map"
- img="dashboards/widgets/icons/heatmap_light_large.png">}} Heatmap{{< /nextlink >}}
+ img="dashboards/widgets/icons/heatmap_light_large.png">}} ヒートマップ{{< /nextlink >}}
{{< nextlink href="/dashboards/widgets/pie_chart"
- img="dashboards/widgets/icons/pie_light_large.png">}} Pie Chart{{< /nextlink >}}
+ img="dashboards/widgets/icons/pie_light_large.png">}} 円グラフ{{< /nextlink >}}
{{< nextlink href="/dashboards/widgets/query_value"
- img="dashboards/widgets/icons/query-value_light_large.png">}} Query Value{{< /nextlink >}}
- {{< nextlink href="/dashboards/widgets/sankey" img="dashboards/widgets/icons/sankey_light_large.svg">}} Sankey{{< /nextlink >}}
+ img="dashboards/widgets/icons/query-value_light_large.png">}} クエリ値{{< /nextlink >}}
+ {{< nextlink href="/dashboards/widgets/sankey" img="dashboards/widgets/icons/sankey_light_large.svg">}} サンキー{{< /nextlink >}}
{{< nextlink href="/dashboards/widgets/scatter_plot"
- img="dashboards/widgets/icons/scatter-plot_light_large.png">}} Scatter Plot{{< /nextlink >}}
+ img="dashboards/widgets/icons/scatter-plot_light_large.png">}} 散布図{{< /nextlink >}}
{{< nextlink href="/dashboards/widgets/table"
- img="dashboards/widgets/icons/table_light_large.png">}} Table{{< /nextlink >}}
+ img="dashboards/widgets/icons/table_light_large.png">}} テーブル{{< /nextlink >}}
{{< nextlink href="/dashboards/widgets/treemap"
- img="dashboards/widgets/icons/treemap_light_large.png">}} Treemap{{< /nextlink >}}
+ img="dashboards/widgets/icons/treemap_light_large.png">}} ツリーマップ{{< /nextlink >}}
{{< nextlink href="/dashboards/widgets/timeseries"
- img="dashboards/widgets/icons/timeseries_light_large.png">}} Timeseries{{< /nextlink >}}
+ img="dashboards/widgets/icons/timeseries_light_large.png">}} 時系列{{< /nextlink >}}
{{< nextlink href="/dashboards/widgets/top_list"
- img="dashboards/widgets/icons/top-list_light_large.png">}} Top List{{< /nextlink >}}
+ img="dashboards/widgets/icons/top-list_light_large.png">}} トップリスト{{< /nextlink >}}
{{< /whatsnext >}}
-### Groups
-{{< whatsnext desc="Display your widgets under groups: ">}}
+### グループ
+{{< whatsnext desc="グループの下にウィジェットを表示します。 ">}}
{{< nextlink href="/dashboards/widgets/group"
- img="dashboards/widgets/icons/group_default_light_large.svg">}} Group{{< /nextlink >}}
+ img="dashboards/widgets/icons/group_default_light_large.svg">}} グループ{{< /nextlink >}}
{{< nextlink href="/dashboards/widgets/powerpack"
- img="dashboards/widgets/icons/group_powerpack_light_large.svg">}} Powerpack{{< /nextlink >}}
+ img="dashboards/widgets/icons/group_powerpack_light_large.svg">}} パワーパック{{< /nextlink >}}
{{< nextlink href="/dashboards/widgets/split_graph"
- img="dashboards/widgets/icons/group-split_light_small.svg">}} Split Graph{{< /nextlink >}}
+ img="dashboards/widgets/icons/group-split_light_small.svg">}} スプリットグラフ{{< /nextlink >}}
{{< /whatsnext >}}
-### Annotations and embeds
-{{< whatsnext desc="Decoration widgets to visually structure and annotate dashboards: ">}}
+### アノテーションと埋め込み
+{{< whatsnext desc="ダッシュボードを視覚的に構成し、注釈を付けるための装飾ウィジェット: ">}}
{{< nextlink href="/dashboards/widgets/free_text"
- img="dashboards/widgets/icons/free-text_light_large.png">}} Free Text{{< /nextlink >}}
+ img="dashboards/widgets/icons/free-text_light_large.png">}} フリーテキスト{{< /nextlink >}}
{{< nextlink href="/dashboards/widgets/iframe"
img="dashboards/widgets/icons/iframe_light_large.png">}} Iframe{{< /nextlink >}}
{{< nextlink href="/dashboards/widgets/image"
- img="dashboards/widgets/icons/image_light_large.png">}} Image{{< /nextlink >}}
+ img="dashboards/widgets/icons/image_light_large.png">}} 画像{{< /nextlink >}}
{{< nextlink href="/dashboards/widgets/note"
- img="dashboards/widgets/icons/notes_light_large.png">}} Notes and Links{{< /nextlink >}}
+ img="dashboards/widgets/icons/notes_light_large.png">}} 注意事項とリンク{{< /nextlink >}}
{{< /whatsnext >}}
-### Lists and streams
-{{< whatsnext desc="Display a list of events and issues coming from different sources: ">}}
+### リストとストリーム
+{{< whatsnext desc="さまざまなソースからのイベントや問題のリストを表示します。 ">}}
{{< nextlink href="/dashboards/widgets/list"
- img="dashboards/widgets/icons/change_light_large.png">}} List{{< /nextlink >}}
+ img="dashboards/widgets/icons/change_light_large.png">}} リスト{{< /nextlink >}}
{{< /whatsnext >}}
-### Alerting and response
-{{< whatsnext desc="Summary widgets to display Monitoring information: ">}}
+### アラートと対応
+{{< whatsnext desc="モニタリング情報を表示するサマリーウィジェット: ">}}
{{< nextlink href="/dashboards/widgets/alert_graph"
- img="dashboards/widgets/icons/alert-graph_light_large.png">}} Alert Graph{{< /nextlink >}}
+ img="dashboards/widgets/icons/alert-graph_light_large.png">}} アラートグラフ{{< /nextlink >}}
{{< nextlink href="/dashboards/widgets/alert_value"
- img="dashboards/widgets/icons/alert-value_light_large.png">}}Alert Value{{< /nextlink >}}
+ img="dashboards/widgets/icons/alert-value_light_large.png">}}アラート値{{< /nextlink >}}
{{< nextlink href="/dashboards/widgets/check_status"
- img="dashboards/widgets/icons/check-status_light_large.png">}} Check Status{{< /nextlink >}}
+ img="dashboards/widgets/icons/check-status_light_large.png">}} チェックステータス{{< /nextlink >}}
{{< nextlink href="/dashboards/widgets/monitor_summary"
- img="dashboards/widgets/icons/monitor-summary_light_large.png">}} Monitor Summary{{< /nextlink >}}
+ img="dashboards/widgets/icons/monitor-summary_light_large.png">}} モニターサマリー{{< /nextlink >}}
{{< nextlink href="/dashboards/widgets/run_workflow"
- img="dashboards/widgets/icons/run-workflow_light_small.svg">}} Run Workflow{{< /nextlink >}}
+img="dashboards/widgets/icons/run-workflow_light_small.svg">}} Run Workflow{{< /nextlink >}}
{{< /whatsnext >}}
-### Architecture
-{{< whatsnext desc="Visualize infrastructure and architecture data: ">}}
+### アーキテクチャ
+{{< whatsnext desc="インフラストラクチャーとアーキテクチャーのデータを視覚化します。 ">}}
{{< nextlink href="/dashboards/widgets/hostmap"
- img="dashboards/widgets/icons/host-map_light_large.png">}} Hostmap{{< /nextlink >}}
+ img="dashboards/widgets/icons/host-map_light_large.png">}} ホストマップ{{< /nextlink >}}
{{< nextlink href="/dashboards/widgets/topology_map"
- img="dashboards/widgets/icons/service-map_light_large.png">}} Topology Map{{< /nextlink >}}
+ img="dashboards/widgets/icons/service-map_light_large.png">}} トポロジーマップ{{< /nextlink >}}
{{< nextlink href="/dashboards/widgets/service_summary"
- img="dashboards/widgets/icons/service-summary_light_large.png">}} Service Summary{{< /nextlink >}}
+ img="dashboards/widgets/icons/service-summary_light_large.png">}} サービスサマリー{{< /nextlink >}}
{{< /whatsnext >}}
-### Performance and reliability
-{{< whatsnext desc="Site reliability visualizations: ">}}
- {{< nextlink href="/dashboards/widgets/profiling_flame_graph"
- img="dashboards/widgets/icons/profiling_flame_graph.svg">}} Profiling Flame Graph{{< /nextlink >}}
+### パフォーマンスと信頼性
+{{< whatsnext desc="サイトの信頼性の視覚化: ">}}
+{{< nextlink href="/dashboards/widgets/profiling_flame_graph"
+ img="dashboards/widgets/icons/profiling_flame_graph.svg">}} プロファイリングフレームグラフ{{< /nextlink >}}
{{< nextlink href="/dashboards/widgets/slo"
- img="dashboards/widgets/icons/slo-summary_light_large.png">}} Service Level Objective (SLO) Summary{{< /nextlink >}}
+ img="dashboards/widgets/icons/slo-summary_light_large.png">}} サービスレベル目標 (SLO) サマリー{{< /nextlink >}}
{{< nextlink href="/dashboards/widgets/slo_list"
- img="dashboards/widgets/icons/slo-list_light_large.png">}} Service Level Objective (SLO){{< /nextlink >}}
+ img="dashboards/widgets/icons/slo-list_light_large.png">}} サービスレベル目標 (SLO){{< /nextlink >}}
{{< /whatsnext >}}
-## Full screen
+## 全画面
-You can view most widgets in full screen mode and do the following:
+ほとんどのウィジェットをフルスクリーンモードで表示し、以下の操作を行うことができます。
-* Change time frames
-* Move backward or forward by the time frame selected
-* Pause the graph at the current time or view the live graph
-* Reset the time frame
-* Export the graph to a dashboard, notebook, or copy the query
-* Download the data producing the graph in a CSV format
+* タイムフレームを変更する
+* 選択したタイムフレームだけ前後に移動する
+* 現在の時間にグラフを一時停止するか、ライブグラフを表示する
+* タイムフレームをリセットする
+* ダッシュボードやノートブックにグラフをエクスポートしたり、クエリをコピーする
+* グラフを生成するデータを CSV 形式でダウンロードする
-To access the widget overview directly, click the full-screen button on the top right-hand corner of the widget.
+ウィジェットの概要に直接アクセスするには、ウィジェットの右上にあるフルスクリーンボタンをクリックします。
-Additional options are available for [timeseries widgets][1].
+[時系列ウィジェット][1]では追加のオプションが利用可能です。
-## Custom links
+## カスタムリンク
-Custom links connect data values to URLs such as a Datadog page or your AWS console.
+カスタムリンクは、データ値を Datadog のページや AWS コンソールなどの URL へ接続します。
-To customize interactions with data inline your generic widgets, see [Custom Links][2].
+一般的なウィジェットのインラインデータとのインタラクションをカスタマイズするには、[カスタムリンク][2]を参照してください。
-## Unit override
+## 単位のオーバーライド
-Customize unit values displayed on widgets to add context to your data. For more use cases and information, see the [Customize your visualizations with unit overrides][3].
-- **Unit override**: choose to display units in the family of 'memory', and have Datadog take care of displaying the appropriate scale depending on data (such as megabytes or gigabytes).
-- **Unit and scale override**: fix units to a single scale (display data in megabytes regardless of value).
-- **Define custom units**: define completely custom units (like 'tests' instead of a generic count).
+ウィジェットに表示される単位値をカスタマイズして、データにコンテキストを追加できます。その他の使用例や情報については、[単位オーバーライドで可視化をカスタマイズする][3]を参照してください。
+- **Unit override**: 選択することで、「メモリ」ファミリーの単位が表示され、Datadog がデータに応じて適切なスケールを表示するようにします (メガバイトやギガバイトなど)。
+- **Unit and scale override**: 単位を単一のスケールに固定します (値に関係なくデータをメガバイトで表示)。
+- **Define custom units**: 完全にカスタマイズされた単位を定義します (一般的なカウントの代わりに「テスト」のような)。
-This is not an alternative for assigning units to your data.
-{{< whatsnext desc="Set units at the organization level: ">}}
- {{< nextlink href="/metrics/units/">}} Set Metrics Units{{< /nextlink >}}
- {{< nextlink href="/logs/explorer/facets/#units">}} Set units for Event-based queries{{< /nextlink >}}
+これは、データに単位を割り当てるための代替手段ではありません。
+{{< whatsnext desc="組織レベルでの単位設定: ">}}
+ {{< nextlink href="/metrics/units/">}} メトリクス単位の設定{{< /nextlink >}}
+ {{< nextlink href="/logs/explorer/facets/#units">}} イベントベースクエリの単位設定{{< /nextlink >}}
{{< /whatsnext >}}
-## Global time selector
+## グローバルタイムセレクター
-To use the global time selector, at least one time-based widget must be set to use `Global Time`. Make the selection in the widget editor under **Set display preferences**, or add a widget (global time is the default time setting).
+グローバルタイムセレクターを使うには、1 つ以上の時間ベースのウィジェットが `Global Time` を使うように設定されている必要があります。**Set display preferences** でウィジェットのエディターで選択するか、またはウィジェットを追加します (グローバルタイムはデフォルトの時間設定です)。
-The global time selector sets the same time frame for all widgets using the `Global Time` option on the same dashboard. Select a moving window in the past (for example, `Past 1 Hour` or `Past 1 Day`) or a fixed period with the `Select from calendar...` option or [enter a custom time frame][11]. If a moving window is chosen, the widgets are updated to move along with the time window.
+グローバルタイムセレクターは、同一のダッシュボード上で `Global Time` オプションを使用するすべてのウィジェットに対して同一のタイムフレームを設定します。過去の移動ウィンドウ (例: `Past 1 Hour`、`Past 1 Day`) を選択するか、固定期間を選択します。固定期間は、`Select from calendar...` オプションを使用します。または、[カスタムタイムフレームを入力][11]します。移動ウィンドウを選択した場合、ウィジェットはタイムウィンドウに沿って移動します。
-Widgets not linked to global time show the data for their local time frame as applied to the global window. For example, if the global time selector is set to January 1, 2019 through January 2, 2019, a widget set with the local time frame for `Past 1 Minute` shows the last minute of January 2, 2019 from 11:59 pm.
+グローバルタイムにリンクされていないウィジェットは、グローバルウィンドウに適用されたローカルタイムフレームに対応するデータを表示します。たとえば、グローバルタイムセレクターが 2019 年 1 月 1 日から 2019 年 1 月 2 日に設定されている場合、ローカルタイムフレームが `Past 1 Minute` に設定されているウィジェットには、2019 年 1 月 2 日の午後 11 時 59 分からの最後の 1 分が表示されます。
-## Copy and paste widgets
+## ウィジェットのコピーと貼り付け
-
+
-Widgets can be copied on [Dashboards][4], [Notebooks][5], [APM Service][6], and the [APM resource][7] page by using `Ctrl + C` (`Cmd + C` for Mac), or by selecting the share icon and choosing "Copy".
+ウィジェットを[ダッシュボード][4]、[ノートブック][5]、[APM サービス][6]、および [APM リソース][7]ページにコピーするには、`Ctrl + C` (Mac の場合は `Cmd + C`) を使用するか、共有アイコンを選択して "Copy" を選択します。
-The copied widgets can be pasted within Datadog by using `Ctrl + V` (`Cmd + V` for Mac) on:
+コピーされたウィジェットは、次の場所で `Ctrl + V`(Mac の場合は `Cmd + V`)を使用して Datadog 内に貼り付けることができます。
-* **Dashboards**: Adds a new widget positioned under your mouse cursor.
-* **Notebooks**: Adds a new cell at the end of the notebook.
+* **ダッシュボード**: マウスカーソルの下に新しいウィジェットを追加します。
+* **ノートブック**: ノートブックの最後に新しいセルを追加します。
-You can also paste the widget into your favorite chat program that displays link previews (like Slack or Microsoft Teams). This displays a snapshot image of your graph along with a direct link to your widget.
+また、リンクのプレビューを表示するお気に入りのチャットプログラム(Slack や Microsoft Teams など)にウィジェットを貼り付けることもできます。これにより、グラフのスナップショット画像とウィジェットへの直接リンクが表示されます。
-### Groups of widgets
+### ウィジェットのグループ
-Timeboard group widgets can be copied by hovering over the group widget area and using `Ctrl + C` (`Cmd + C` for Mac) or by selecting the share icon and choosing "Copy".
+タイムボードグループウィジェットをコピーするには、グループウィジェット領域にカーソルを合わせて `Ctrl + C`(Mac の場合は `Cmd + C`)を使用するか、共有アイコンを選択して "Copy" を選択します。
-**Note**: When pasting graphs to screenboards or notebooks, individual widgets within the group are pasted.
+**注**: スクリーンボードまたはノートブックにグラフを貼り付ける場合、グループ内の個々のウィジェットが貼り付けられます。
-To copy multiple screenboard widgets (edit mode only), `shift + click` on the widgets and use `Ctrl + C` (`Cmd + C` for Mac).
+複数のスクリーンボードウィジェットをコピーするには(編集モードのみ)、ウィジェットを `shift + クリック`し、`Ctrl + C`(Mac の場合は `Cmd + C`)を使用します。
-**Note**: This only works when sharing within Datadog. It does not generate a preview image.
+**注**: これは、Datadog 内で共有する場合にのみ機能します。プレビュー画像は生成されません。
-## Widget graphs
+## ウィジェットグラフ
-### Export
+### エクスポート
-| Format | Instructions |
+| 形式 | 手順 |
| ----- | ----------------------- |
-| PNG | To download a widget in PNG format, click the export button in the upper right hand side of the widget, and select **Download as PNG**. |
-| CSV | To download data from a timeseries, table, or top list widget in CSV format, click the export button in the upper right hand side of the widget, and select **Download as CSV**.|
+| PNG | ウィジェットを PNG 形式でダウンロードするには、ウィジェットの右上にあるエクスポートボタンをクリックし、**Download as PNG** を選択します。 |
+| CSV | 時系列、テーブル、またはトップリストウィジェットからデータを CSV 形式でダウンロードするには、ウィジェットの右上にあるエクスポートボタンをクリックし、**Download as CSV** を選択します。|
-### Graph menu
+### グラフメニュー
-Click on any dashboard graph to open an options menu:
+ダッシュボードグラフをクリックするとオプションメニューが開きます。
-| Option | Description |
+| オプション | 説明 |
|------------------------|--------------------------------------------------------------------|
-| Send snapshot | Create and send a snapshot of your graph. |
-| Find correlated metrics| Find correlations from APM services, integrations, and dashboards. |
-| View in full screen | View the graph in [full screen mode][5]. |
-| Lock cursor | Lock the cursor in place on the page. |
-| View related processes | Jump to the [Live Processes][6] page scoped to your graph. |
-| View related hosts | Jump to the [Host Map][7] page scoped to your graph. |
-| View related logs | Jump to the [Log Explorer][8] page scoped to your graph. |
-| View related traces | Populate a [Traces][9] panel scoped to your graph. |
-| View related profiles | Jump to the [Profiling][10] page scoped to your graph. |
-
-## Further Reading
+| スナップショットを送信 | グラフのスナップショットを作成および送信します。 |
+| 相関関係のあるメトリクスを検索| APM サービス、インテグレーション、ダッシュボードの相関関係を検索します。 |
+| View in full screen | グラフを[全画面モード][5]で表示します。 |
+| カーソルをロック | ページに配置されたカーソルをロックします。 |
+| View related processes | グラフ参照範囲の[ライブプロセス][6]ページへジャンプします。 |
+| View related hosts | グラフ参照範囲の[ホストマップ][7]ページへジャンプします。 |
+| View related logs | グラフ参照範囲の[ログエクスプローラー][8]ページへジャンプします。 |
+| 関連トレースを表示 | グラフ参照範囲の[トレース][9]パネルに入力します。 |
+| 関連プロファイルを表示 | グラフ参照範囲の[プロファイリング][10]ページへジャンプします。 |
+
+## その他の参考資料
{{< partial name="whats-next/whats-next.html" >}}
diff --git a/content/ja/dashboards/widgets/table.md b/content/ja/dashboards/widgets/table.md
index b0be5d7486ef2..b935f54015424 100644
--- a/content/ja/dashboards/widgets/table.md
+++ b/content/ja/dashboards/widgets/table.md
@@ -49,7 +49,7 @@ widget_type: query_table
## N/A 値
テーブルウィジェットの列は、それぞれ独立してクエリが実行されます。名前が同じで重複するグループはリアルタイムで結合されて、テーブルの行が作成されます。このプロセスの結果、重複するグループがなく、セルに N/A が表示される状況が発生する可能性があります。これを回避するには、次の対策を講じます。
- * Extend the limit of queries to higher numbers, to maximize overlap between columns
+ * クエリ数の上限を大きくして、できるだけ多くの列が組み合わさるようにします。
* インサイトを"生み出している"と思われる列でテーブルをソートします。
## API
diff --git a/content/ja/dashboards/widgets/timeseries.md b/content/ja/dashboards/widgets/timeseries.md
index 7ed426606cf7d..67cc3523e9c15 100644
--- a/content/ja/dashboards/widgets/timeseries.md
+++ b/content/ja/dashboards/widgets/timeseries.md
@@ -33,7 +33,7 @@ widget_type: Timeseries
* Indexed Span: Indexed Span クエリの構成については、[トレース検索に関するドキュメント][4]を参照してください。
* ログイベント: ログイベントクエリの構成については、[ログ検索に関するドキュメント][5]を参照してください。
-2. Customize your graph with the available [options](#display-options).
+2. [オプション](#display-options)を使用して、グラフをカスタマイズします。
## 表示オプション
diff --git a/content/ja/dashboards/widgets/top_list.md b/content/ja/dashboards/widgets/top_list.md
index 3c211c7dc1ee7..913c920513f5e 100644
--- a/content/ja/dashboards/widgets/top_list.md
+++ b/content/ja/dashboards/widgets/top_list.md
@@ -29,7 +29,7 @@ widget_type: トップリスト
2. オプション: [グラフ表示](#graph-display)の追加構成を参照してください。
-### Options
+### オプション
#### グラフ表示
diff --git a/content/ja/data_security/pci_compliance.md b/content/ja/data_security/pci_compliance.md
index bfb100188f22f..4fec15e38b3b0 100644
--- a/content/ja/data_security/pci_compliance.md
+++ b/content/ja/data_security/pci_compliance.md
@@ -30,24 +30,12 @@ Datadog は、PCI に準拠したログ管理およびアプリケーション
{{% tab "ログ管理" %}}
-
-PCI DSS 準拠のためには、
監査証跡を有効にし、その状態を維持する必要があります。
-
-
-PCI 準拠の Datadog 組織をセットアップするには、以下の手順に従います。
-
{{% pci-logs %}}
{{% /tab %}}
{{% tab "APM" %}}
-
-PCI DSS 準拠のためには、
監査証跡を有効にし、その状態を維持する必要があります。
-
-
-PCI 準拠の Datadog 組織をセットアップするには、以下の手順に従います。
-
{{% pci-apm %}}
{{% /tab %}}
diff --git a/content/ja/database_monitoring/setup_oracle/selfhosted.md b/content/ja/database_monitoring/setup_oracle/selfhosted.md
index c899fe0cf5494..743037aedd678 100644
--- a/content/ja/database_monitoring/setup_oracle/selfhosted.md
+++ b/content/ja/database_monitoring/setup_oracle/selfhosted.md
@@ -87,7 +87,7 @@ CREATE USER datadog IDENTIFIED BY &password ;
{{< /tabs >}}
-### Securely store your password
+### パスワードを安全に保管
{{% dbm-secret %}}
### ビューの作成
@@ -126,19 +126,19 @@ Oracle Agent のコンフィギュレーションファイル `/etc/datadog-agen
init_config:
instances:
- server: ':'
- service_name: "" # The Oracle CDB service name
+ service_name: "" # Oracle CDB サービス名
username: 'c##datadog'
password: 'ENC[datadog_user_database_password]'
dbm: true
- tags: # Optional
+ tags: # オプション
- 'service:'
- 'env:'
- server: ':'
- service_name: "" # The Oracle CDB service name
+ service_name: "" # Oracle CDB サービス名
username: 'c##datadog'
password: 'ENC[datadog_user_database_password]'
dbm: true
- tags: # Optional
+ tags: # オプション
- 'service:'
- 'env:'
```
diff --git a/content/ja/database_monitoring/setup_sql_server/rds.md b/content/ja/database_monitoring/setup_sql_server/rds.md
index 719e5b1714b50..31c7a2e62b812 100644
--- a/content/ja/database_monitoring/setup_sql_server/rds.md
+++ b/content/ja/database_monitoring/setup_sql_server/rds.md
@@ -61,7 +61,7 @@ CREATE USER datadog FOR LOGIN datadog;
これは、RDS が `CONNECT ANY DATABASE` の付与を許可していないため、必要です。Datadog Agent は、データベース固有のファイル I/O 統計情報を収集するために、各データベースに接続する必要があります。
-### Securely store your password
+### パスワードを安全に保管
{{% dbm-secret %}}
## Agent のインストール
diff --git a/content/ja/database_monitoring/setup_sql_server/selfhosted.md b/content/ja/database_monitoring/setup_sql_server/selfhosted.md
index 09ce927d795fb..3e21d7289491a 100644
--- a/content/ja/database_monitoring/setup_sql_server/selfhosted.md
+++ b/content/ja/database_monitoring/setup_sql_server/selfhosted.md
@@ -72,7 +72,7 @@ CREATE USER datadog FOR LOGIN datadog;
{{% /tab %}}
{{< /tabs >}}
-### Securely store your password
+### パスワードを安全に保管
{{% dbm-secret %}}
## Agent のインストール
diff --git a/content/ja/developers/dogstatsd/datagram_shell.md b/content/ja/developers/dogstatsd/datagram_shell.md
index 8dfdac2f2d3be..c28dcf436a6ae 100644
--- a/content/ja/developers/dogstatsd/datagram_shell.md
+++ b/content/ja/developers/dogstatsd/datagram_shell.md
@@ -24,21 +24,21 @@ title: データグラム形式とシェルの使用方法
| パラメーター | 必須 | 説明 |
| ----------------------------------- | -------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `` | はい | ASCII 英数字、アンダースコア、およびピリオドのみを含む文字列。[メトリクス命名ポリシー][101]を参照してください。 |
-| `` | Yes | 整数または浮動小数点数。 |
+| `` | はい | 整数または浮動小数点数。 |
| `` | はい | COUNT の場合は `c`、GAUGE の場合は `g`、TIMER の場合は `ms`、HISTOGRAM の場合は `h`、SET の場合は `s`、DISTRIBUTION の場合は `d`。詳細は[メトリクスタイプ][102]を参照してください。 |
-| `` | いいえ | A float between `0` and `1`, inclusive. Only works with COUNT, HISTOGRAM, DISTRIBUTION, and TIMER metrics. The default is `1`, which samples 100% of the time. |
+| `` | いいえ | `0` から `1` までの浮動小数点数。COUNT、HISTOGRAM、DISTRIBUTION、TIMER メトリクスでのみ機能します。デフォルトは `1` で、100% の時間をサンプリングします。 |
| `:,` | いいえ | カンマで区切られた文字列のリスト。キー/値タグにはコロンを使用します (`env:prod`)。タグの定義に関するガイダンスについては、[タグの概要][103]を参照してください。 |
以下に、データグラムの例を示します。
- `page.views:1|c` : `page.views` COUNT メトリクスを増やします。
- `fuel.level:0.5|g`: 燃料タンクが半分空になったことを記録します。
-- `song.length:240|h|@0.5`: Sample the `song.length` histogram as if it was sent half of the time.
+- `song.length:240|h|@0.5`: 半分の時間だけ送信したように `song.length` ヒストグラムをサンプリングします。
- `users.uniques:1234|s`: サイトへのユニークビジターを追跡します。
- `users.online:1|c|#country:china`: アクティブユーザー COUNT メトリクスを増やし、所属国ごとにタグ付けします。
- `users.online:1|c|@0.5|#country:china`: アクティブな中国ユーザーを追跡し、サンプルレートを使用します。
-### DogStatsD protocol v1.1
+### DogStatsD プロトコル v1.1
Agent `>=v6.25.0` && `