@@ -67,15 +111,15 @@ Al utilizar Google Cloud Dataflow para monitorizar métricas de pipelines Apache
La integración Google Cloud Dataflow no incluye eventos.
-### Checks de servicio
+### Checks de servicios
La integración Google Cloud Dataflow no incluye checks de servicio.
-## Resolución de problemas
+## Solucionar problemas
¿Necesitas ayuda? Ponte en contacto con el [servicio de asistencia de Datadog][5].
-## Leer más
+## Referencias adicionales
{{< partial name="whats-next/whats-next.html" >}}
diff --git a/content/es/integrations/nvidia_jetson.md b/content/es/integrations/nvidia_jetson.md
index 75629054624d3..8f3ad7a8918fc 100644
--- a/content/es/integrations/nvidia_jetson.md
+++ b/content/es/integrations/nvidia_jetson.md
@@ -16,7 +16,7 @@ assets:
service_checks:
metadata_path: assets/service_checks.json
source_type_id: 10134
- source_type_name: NVIDIA Jetson
+ source_type_name: Nvidia Jetson
author:
homepage: https://www.datadoghq.com
name: Datadog
@@ -24,20 +24,20 @@ author:
support_email: help@datadoghq.com
categories:
- iot
-custom_kind: integration
+custom_kind: integración
dependencies:
- https://github.com/DataDog/integrations-core/blob/master/nvidia_jetson/README.md
display_on_public_website: true
draft: false
git_integration_title: nvidia_jetson
integration_id: nvidia-jetson
-integration_title: NVIDIA Jetson
+integration_title: Nvidia Jetson
integration_version: ''
is_public: true
manifest_version: 2.0.0
name: nvidia_jetson
-public_title: NVIDIA Jetson
-short_description: Obtén métricas sobre tu placa NVIDIA Jetson
+public_title: Nvidia Jetson
+short_description: Obtén métricas sobre tu placa Nvidia Jetson
supported_os:
- linux
tile:
@@ -47,11 +47,11 @@ tile:
- Category::IoT
- Offering::Integration
configuration: README.md#Setup
- description: Obtén métricas sobre tu placa NVIDIA Jetson
+ description: Obtén métricas sobre tu placa Nvidia Jetson
media: []
overview: README.md#Overview
support: README.md#Support
- title: NVIDIA Jetson
+ title: Nvidia Jetson
---
@@ -60,13 +60,13 @@ tile:
## Información general
Este check monitoriza una placa [NVIDIA Jetson][1].
-Informa de las métricas recopiladas de `tegrastats`.
+Informa las métricas recopiladas de `tegrastats`.
## Configuración
### Instalación
-El check de NVIDIA Jetson está incluido en el paquete del [Datadog Agent][2].
+El check de NVIDIA Jetson está incluidoo en el paquete del [Datadog Agent ][2].
No es necesaria ninguna instalación adicional en tu servidor.
### Configuración
@@ -84,7 +84,7 @@ Ejecuta el [subcomando de estado del Agent][5] y busca `jetson` en la sección C
## Datos recopilados
### Métricas
-{{< get-metrics-from-git "nvidia-jetson" >}}
+{{< get-metrics-from-git "nvidia_jetson" >}}
Algunas métricas solo se notifican si `use_sudo` está configurado como verdadero:
@@ -113,4 +113,4 @@ La integración de NVIDIA Jetson no incluye ningún evento.
[4]: https://docs.datadoghq.com/es/agent/guide/agent-commands/#start-stop-restart-the-agent
[5]: https://docs.datadoghq.com/es/agent/guide/agent-commands/#agent-status-and-information
[6]: https://github.com/DataDog/integrations-core/blob/master/nvidia_jetson/metadata.csv
-[7]: https://docs.datadoghq.com/es/help/
+[7]: https://docs.datadoghq.com/es/help/
\ No newline at end of file
diff --git a/content/es/integrations/quarkus.md b/content/es/integrations/quarkus.md
new file mode 100644
index 0000000000000..0afbb4b71a7b1
--- /dev/null
+++ b/content/es/integrations/quarkus.md
@@ -0,0 +1,134 @@
+---
+app_id: quarkus
+categories:
+- métricas
+- recopilación de logs
+custom_kind: integración
+description: Monitoriza tu aplicación creada con Quarkus.
+integration_version: 2.0.0
+media: []
+supported_os:
+- linux
+- windows
+- macos
+title: Quarkus
+---
+## Información general
+
+Este control supervisa [Quarkus](https://quarkus.io/) a través del Datadog Agent.
+
+## Configuración
+
+Siga las siguientes instrucciones para instalar y configurar esta comprobación para un Agent que se ejecute en un host. Para entornos en contenedores, consulte las [Autodiscovery Plantillas de integración](https://docs.datadoghq.com/agent/kubernetes/integrations/) para obtener orientación sobre la aplicación de estas instrucciones.
+
+### Instalación
+
+La comprobación de Quarkus se incluye en el paquete [Datadog Agent](https://app.datadoghq.com/account/settings/agent/latest) a partir de Agent 7.62.
+No es necesaria ninguna instalación adicional en su servidor.
+
+### Configuración
+
+Siga [estos pasos](https://quarkus.io/guides/telemetry-micrometer-tutorial) para configurar la generación de métricas en Quarkus.
+
+Luego, configura el Agent:
+
+1. Edita el archivo `quarkus.d/conf.yaml`, en la carpeta `conf.d/` en la raíz de tu directorio de configuración Agent's para empezar a recoger tus datos de rendimiento de Quarkus. Consulte [sample quarkus.d/conf.yaml](https://github.com/DataDog/integrations-core/blob/master/quarkus/datadog_checks/quarkus/data/conf.yaml.example) para conocer todas las opciones de configuración disponibles.
+
+1. [Reinicie el Agent](https://docs.datadoghq.com/agent/guide/agent-commands/#start-stop-and-restart-the-agent).
+
+#### Recopilación de logs
+
+Siga [estos pasos](https://quarkus.io/guides/logging) para configurar Quarkus para que emita registros.
+
+La recopilación de logs está desactivada por defecto en el Datadog Agent. Actívala en tu archivo `datadog.yaml`:
+
+```yaml
+logs_enabled: true
+```
+
+Edita la sección `logs` de tu archivo `quarkus.d/conf.yaml` para empezar a recopilar tus logs de RabbitMQ:
+
+```yaml
+logs:
+ - tipo: file
+ ruta: /var/log/aplicación.log
+ source (fuente) quarkus
+ servicio: quarkus-app
+```
+
+### Validación
+
+[Ejecute el subcomando de estado de Agent(https://docs.datadoghq.com/agent/guide/agent-commands/#agent-status-and-information) y busque `quarkus` en la sección Comprobaciones.
+
+## Datos recopilados
+
+### Métricas
+
+| | |
+| --- | --- |
+| **quarkus.http_server.active_requests**
(indicador) | Solicitudes al servidor que están activas en este momento.
_Mostrado como solicitud_ |
+| **quarkus.http_server.bytes_read.count**
(count) | Número de veces que algunos bytes fueron recibidos por el servidor.|
+| **quarkus.http_server.bytes_read.max**
(calibre) | Número máximo de bytes recibidos actualmente por el servidor.
_Mostrado como byte_ |
+| **quarkus.http_server.bytes_read.sum**
(recuento) | Número total de bytes recibidos por el servidor desde que se inició.
_Mostrado como byte_ |
+| **quarkus.http_server.bytes_written.count**
(count) | Número de veces que algunos bytes fueron por el servidor.|
+| **quarkus.http_server.bytes_written.max**
(calibre) | Número máximo actual de bytes enviados por el servidor.
_Mostrado como byte_ |
+| **quarkus.http_server.bytes_written.sum**
(recuento) | Número total de bytes enviados por el servidor.
_Mostrado como byte_ |
+| **quarkus.http_server.connections.seconds.max**
(calibre) | La duración de las conexiones en segundos.
_Mostrado como segundo_ |
+| **quarkus.http_server.requests.seconds.count**
(count) | El número de solicitudes observadas hasta el momento.|
+| **quarkus.http_server.requests.seconds.max**
(indicador) | La mayor duración actual de la solicitud en segundos.
_Se muestra como segundo_ |
+| **quarkus.http_server.requests.seconds.sum**
(recuento) | Número total de segundos que han tardado todas las solicitudes hasta el momento.
_Se muestra como segundo_ |
+| **quarkus.jvm.buffer.count_buffers**
(calibre) | Una estimación del número de buffers en el pool.
_Shown as buffer_ |
+| **quarkus.jvm.buffer.memory_used.bytes**
(calibre) | Una estimación de la memoria que la máquina virtual Java está utilizando para este conjunto de búferes.
_Mostrado como byte_ |
+| **quarkus.jvm.buffer.total_capacity.bytes**
(calibre) | Una estimación de la capacidad total de los buffers en este pool.
_Mostrado como byte_ |
+| **quarkus.jvm.classes.loaded_classes**
(calibre) | Número de clases cargadas actualmente en la máquina virtual Java.|
+| **quarkus.jvm.gc.live_data_size.bytes**
(calibre) | Tamaño de la reserva de memoria heap de larga duración después de la recuperación.
_Mostrado como byte_ |
+| **quarkus.jvm.gc.max_data_size.bytes**
(calibre) | Tamaño máximo de la reserva de memoria heap de larga duración.
_Mostrado como byte_ |
+| **quarkus.jvm.gc.overhead**
(calibre) | Una aproximación del porcentaje de tiempo de CPU utilizado por las actividades de GC durante el último periodo de revisión retrospectiva o desde que comenzó la monitorización, lo que sea más corto, en el rango \[0..1\].|
+| **quarkus.jvm.memory.committed.bytes**
(calibre) | La cantidad de memoria en bytes que está comprometida para el uso de la máquina virtual Java.
_Mostrado como byte_ |
+| **quarkus.jvm.memory.max.bytes**
(calibre) | La cantidad máxima de memoria en bytes que se puede utilizar para la gestión de la memoria.
_Mostrado como byte_ |
+| **quarkus.jvm.memory.usage_after_gc**
(calibre) | Porcentaje del montón de larga duración utilizado tras el último evento de GC, en el rango \[0..1\].
_Mostrado como fracción_ |
+| **quarkus.jvm.memory.used.bytes**
(calibre) | La cantidad de memoria utilizada.
_Se muestra como byte_ |
+| **quarkus.jvm.threads.daemon_threads**
(calibre) | El número actual de hilos daemon vivos.
_Shown as thread_ |
+| **quarkus.jvm.threads.live_threads**
(calibre) | El número actual de hilos activos, incluidos los hilos demonio y no demonio.
_Mostrado como hilo_ |
+| **quarkus.jvm.threads.peak_threads**
(calibre) | El número máximo de hilos activos desde que se inició la máquina virtual Java o se reinició el número máximo.
_Shown as thread_ |
+| **quarkus.jvm.threads.states_threads**
(calibre) | El número actual de hilos.
_Shown as thread_ |
+| **quarkus.netty.allocator.memory.pinned**
(calibre) | Tamaño, en bytes, de la memoria que utiliza el búfer asignado.
_Mostrado como byte_ |
+| **quarkus.netty.allocator.memory.used**
(calibre) | Tamaño, en bytes, de la memoria que utiliza el asignador.
_Shown as byte_ |
+| **quarkus.netty.allocator.pooled.arenas**
(calibre) | Número de arenas para un asignador agrupado.
_Se muestra como byte_ |
+| **quarkus.netty.allocator.pooled.cache_size**
(calibre) | Tamaño, en bytes, de la caché para un asignador agrupado.
_Shown as byte_ |
+| **quarkus.netty.allocator.pooled.chunk_size**
(calibre) | Tamaño, en bytes, de los trozos de memoria para un asignador agrupado.
_Mostrado como byte_ |
+| **quarkus.netty.allocator.pooled.threadlocal_caches**
(calibre) | Número de cachés ThreadLocal para un asignador agrupado.|
+| **quarkus.netty.eventexecutor.tasks_pending**
(indicador) | Número de tareas pendientes en el ejecutor de eventos.
_Mostrado como tarea_ |
+| **quarkus.process.cpu.usage**
(calibre) | El uso reciente de cpu para el proceso de la Máquina Virtual Java.|
+| **quarkus.process.files.max_files**
(calibre) | El recuento máximo de descriptores de archivo.
_Shown as file_ |
+| **quarkus.process.files.open_files**
(calibre) | El recuento del descriptor de archivo abierto.
_Shown as file_ |
+| **quarkus.process.uptime.seconds**
(calibre) | El tiempo de actividad de la máquina virtual Java.
_Mostrado como segundo_ |
+| **quarkus.system.cpu.count**
(calibre) | El número de procesadores disponibles para la máquina virtual Java.|
+| **quarkus.system.cpu.usage**
(calibre) | El uso reciente de cpu del sistema en el que se está ejecutando la aplicación.|
+| **quarkus.system.load_average_1m**
(calibre) | La suma del número de entidades ejecutables en cola para los procesadores disponibles y el número de entidades ejecutables que se ejecutan en los procesadores disponibles promediado durante un periodo de tiempo.|
+| **quarkus.worker_pool.active**
(calibre) | Número de recursos de la reserva utilizados actualmente.|
+| **quarkus.worker_pool.idle**
(calibre) | Número de recursos de la reserva utilizados actualmente.|
+| **quarkus.worker_pool.queue.delay.seconds.count**
(count) | Número de artículos que pasaron tiempo en la cola de espera antes de ser procesados.|
+| **quarkus.worker_pool.queue.delay.seconds.max**
(calibre) | Tiempo máximo actual en la cola de espera antes de ser procesado.
_Se muestra como segundo_ |
+| **quarkus.worker_pool.queue.delay.seconds.sum**
(count) | Tiempo total pasado en la cola de espera antes de ser procesado.|
+| **quarkus.worker_pool.queue.size**
(calibre) | Número de elementos pendientes en la cola de espera.|
+| **quarkus.worker_pool.ratio**
(gauge) | Ratio de trabajadores que se están utilizando en este momento.
_Se muestra como fracción_ |
+| **quarkus.worker_pool.usage.seconds.count**
(count) | Número de veces que se han utilizado recursos del pool.
_Se muestra como segundo_ |
+| **quarkus.worker_pool.usage.seconds.max**
(calibre) | Tiempo máximo de utilización de los recursos del pool.
_Se muestra como segundo_ |
+| **quarkus.worker_pool.usage.seconds.sum**
(count) | Tiempo total de utilización de los recursos del pool.
_Se muestra como segundo_ |
+
+### Eventos
+
+La integración Quarkus no incluye eventos.
+
+### Checks de servicio
+
+**quarkus.openmetrics.health**
+
+Devuelve `CRITICAL` si el Agent es incapaz de conectarse al punto final Quarkus OpenMetrics, de lo contrario devuelve `OK`.
+
+_Estados: ok, crítico_
+
+## Solucionar problemas
+
+¿Necesita ayuda? Póngase en contacto con [Datadog support](https://docs.datadoghq.com/help/).
\ No newline at end of file
diff --git a/content/es/integrations/redisdb.md b/content/es/integrations/redisdb.md
new file mode 100644
index 0000000000000..5eb4c781f0ee4
--- /dev/null
+++ b/content/es/integrations/redisdb.md
@@ -0,0 +1,490 @@
+---
+app_id: "redis"
+app_uuid: "15f0ff37-2b36-4165-9606-758271d4a16d"
+assets:
+ dashboards:
+ redis: "assets/dashboards/overview.json"
+ integration:
+ auto_install: true
+ configuration:
+ spec: "assets/configuration/spec.yaml"
+ events:
+ creates_events: false
+ metrics:
+ check: "redis.net.clients"
+ metadata_path: "metadata.csv"
+ prefix: "redis"
+ process_signatures:
+ - "redis-server"
+ service_checks:
+ metadata_path: "assets/service_checks.json"
+ source_type_id: !!int "21"
+ source_type_name: "Redis"
+ monitors:
+ "Memory consumption is high": "assets/monitors/high_mem.json"
+ saved_views:
+ error_warning_status: "assets/saved_views/error_warning_status.json"
+ pid_overview: "assets/saved_views/pid_overview.json"
+ redis_pattern: "assets/saved_views/redis_pattern.json"
+ redis_processes: "assets/saved_views/redis_processes.json"
+author:
+ homepage: "https://www.datadoghq.com"
+ name: "Datadog"
+ sales_email: "info@datadoghq.com"
+ support_email: "help@datadoghq.com"
+categories:
+- "caching"
+- "data stores"
+- "log collection"
+- "tracing"
+custom_kind: "integración"
+dependencies:
+- "https://github.com/DataDog/integrations-core/blob/master/redisdb/README.md"
+display_on_public_website: true
+draft: false
+git_integration_title: "redisdb"
+integration_id: "redis"
+integration_title: "Redis"
+integration_version: "8.0.0"
+is_public: true
+manifest_version: "2.0.0"
+name: "redisdb"
+public_title: "Redis"
+short_description: "Realiza un seguimiento del rendimiento de Redis, el uso de memoria, los clientes bloqueados, las claves desalojadas y más"
+supported_os:
+- "linux"
+- "windows"
+- "macos"
+tile:
+ changelog: "CHANGELOG.md"
+ classifier_tags:
+ - "Category::Almacenamiento en caché"
+ - "Category::Almacenes de datos"
+ - "Category::Recopilación de logs"
+ - "Category::Rastreo"
+ - "Supported OS::Linux"
+ - "Supported OS::Windows"
+ - "Supported OS::macOS"
+ - "Offering::Integración"
+ configuration: "README.md#Configuración"
+ description: "Realiza un seguimiento del rendimiento de Redis, el uso de memoria, los clientes bloqueados, las claves desalojadas y más"
+ media: []
+ overview: "README.md#Información general"
+ resources:
+ - resource_type: "blog"
+ url: "https://www.datadoghq.com/blog/how-to-monitor-redis-performance-metrics"
+ support: "README.md#Soporte"
+ title: "Redis"
+---
+
+
+
+
+## Información general
+
+Tanto si utilizas Redis como base de datos, caché o cola de mensajes, esta integración realiza un seguimiento de los problemas con tus servidores Redis, servicios en la nube y partes de su infraestructura a las que sirven. Utiliza el check de Redis del Datadog Agent para recopilar métricas relacionados con:
+
+- Rendimiento
+- Uso de la memoria
+- Clientes bloqueados
+- Conexiones secundarias
+- Persistencia en disco
+- Claves caducadas y desalojadas
+- y mucho más
+
+## Configuración
+
+### Instalación
+
+El check de Redis está incluido en el paquete del [Datadog Agent][1], por lo que no necesitas instalar nada más en tus servidores Redis.
+
+### Configuración
+
+{{< tabs >}}
+{{% tab "Host" %}}
+
+#### Host
+
+Para configurar este check para un Agent que se ejecuta en un host:
+
+##### Recopilación de métricas
+
+1. Edita el archivo `redisdb.d/conf.yaml`, que se encuentra en la carpeta `conf.d/` en la [raíz del directorio de configuración del Agent][1]. Puede que sea necesario actualizar los siguientes parámetros. Para conocer todas las opciones de configuración disponibles, consulta el [redisdb.d/conf.yaml de ejemplo][2].
+
+ ```yaml
+ init_config:
+ instances:
+ ## @param host - string - required
+ ## Enter the host to connect to.
+ - host: localhost
+ ## @param port - integer - required
+ ## Enter the port of the host to connect to.
+ port: 6379
+
+ ## @param username - string - optional
+ ## The username to use for the connection. Redis 6+ only.
+ #
+ # username:
+
+ ## @param password - string - optional
+ ## The password to use for the connection.
+ #
+ # password:
+ ```
+
+2. Si utilizas Redis v6 o posterior y listas de control del acceso (ACL), asegúrate de que el usuario tiene al menos permisos `DB Viewer` a nivel de base de datos, permisos `Cluster Viewer`, si operas en un entorno de clúster, y reglas de ACL`+config|get +info +slowlog|get`. Para ver más detalles, consulta [Control del acceso a bases de datos][3].
+
+3. [Reinicia el Agent][4].
+
+##### Recopilación de logs
+
+Disponible para la versión 6.0 o posteriores del Agent
+
+1. La recopilación de logs se encuentra deshabilitada de manera predeterminada en el Datadog Agent. Habilítala en tu archivo `datadog.yaml`:
+
+ ```yaml
+ logs_enabled: true
+ ```
+
+2. Deselecciona y edita este bloque de configuración en la parte inferior de tu `redisdb.d/conf.yaml`:
+
+ ```yaml
+ logs:
+ - type: file
+ path: /var/log/redis_6379.log
+ source: redis
+ service: myapplication
+ ```
+
+ Cambia los valores de los parámetros `path` y `service` y configúralos para tu entorno. Consulta el [redisdb.yaml de ejemplo][2] para ver todas las opciones de configuración disponibles.
+
+3. [Reinicia el Agent][4].
+
+##### Recopilación de trazas (trazas)
+
+Datadog APM se integra con Redis para ver trazas en tu sistema distribuido. La recopilación de trazas está activada por defecto en el Datadog Agent v6 o posteriores. Para empezar a recopilar trazas:
+
+1. [Habilita la recopilación de trazas en Datadog][5].
+2. [Instrumenta la aplicación que realiza solicitudes a Redis][6].
+
+
+[1]: https://docs.datadoghq.com/agent/guide/agent-configuration-files/#agent-configuration-directory
+[2]: https://github.com/DataDog/integrations-core/blob/master/redisdb/datadog_checks/redisdb/data/conf.yaml.example
+[3]: https://docs.redis.com/latest/rs/security/passwords-users-roles/
+[4]: https://docs.datadoghq.com/agent/guide/agent-commands/#start-stop-and-restart-the-agent
+[5]: https://docs.datadoghq.com/tracing/send_traces/
+[6]: https://docs.datadoghq.com/tracing/setup/
+{{% /tab %}}
+{{% tab "Docker" %}}
+
+#### Docker
+
+Para configurar este check para un Agent que se ejecuta en un contenedor:
+
+##### Recopilación de métricas
+
+Configura [plantillas de integraciones de Autodiscovery][1] como etiquetas (labels) Docker en el contenedor de tu aplicación:
+
+```yaml
+LABEL "com.datadoghq.ad.check_names"='["redisdb"]'
+LABEL "com.datadoghq.ad.init_configs"='[{}]'
+LABEL "com.datadoghq.ad.instances"='[{"host":"%%host%%","port":"6379","password":"%%env_REDIS_PASSWORD%%"}]'
+```
+
+**Nota**: La lógica de variable de plantilla `"%%env_%%"` se utiliza para evitar almacenar la contraseña en texto simple, por lo que la variable de entorno`REDIS_PASSWORD` se debe definir en el contenedor del Agent. Para ver más detalles, consulta la documentación de la [variable de plantilla Autodiscovery][2]. Alternativamente, el Agent puede aprovechar el paquete `secrets` para trabajar con cualquier backend de [gestión de secretos][3] (como HashiCorp Vault o AWS Secrets Manager).
+
+##### Recopilación de logs
+
+Disponible para la versión 6.0 o posteriores del Agent
+
+La recopilación de logs se encuentra deshabilitada de manera predeterminada en el Datadog Agent. Para habilitarla, consulta la [recopilación de logs de Docker][4].
+
+Luego, configura [integraciones de logs][5] como etiquetas Docker:
+
+```yaml
+LABEL "com.datadoghq.ad.logs"='[{"source":"redis","service":""}]'
+```
+
+##### Recopilación de trazas
+
+APM para aplicaciones en contenedores es compatible con el Agent v6 o posteriores, pero requiere configuración adicional para empezar a recopilar trazas.
+
+Variables de entorno requeridas en el contenedor del Agent:
+
+| Parámetro | Valor |
+| -------------------- | -------------------------------------------------------------------------- |
+| `` | `api_key` |
+| `` | true |
+| `` | true |
+
+Para ver una lista completa de las variables de entorno disponibles y la configuración, consulta [Rastreo de aplicaciones Docker][6].
+
+Luego, [instrumenta el contenedor de tu aplicación que realiza solicitudes a Redis][7] y configura `DD_AGENT_HOST` con el nombre del contenedor de tu Agent.
+
+
+[1]: https://docs.datadoghq.com/agent/docker/integrations/?tab=docker
+[2]: https://docs.datadoghq.com/agent/faq/template_variables/
+[3]: https://docs.datadoghq.com/agent/guide/secrets-management/?tab=linux
+[4]: https://docs.datadoghq.com/agent/docker/log/?tab=containerinstallation#installation
+[5]: https://docs.datadoghq.com/agent/docker/log/?tab=containerinstallation#log-integrations
+[6]: https://docs.datadoghq.com/agent/docker/apm/?tab=linux
+[7]: https://docs.datadoghq.com/tracing/setup/
+{{% /tab %}}
+{{% tab "Kubernetes" %}}
+
+#### Kubernetes
+
+Para configurar este check para un Agent que se ejecuta en Kubernetes:
+
+##### Recopilación de métricas
+
+Para recopilar métricas, define los siguientes parámetros y valores en una [plantilla de Autodiscovery][1]. Puedes hacerlo con Kubernetes Annotations (que se muestra a continuación) en tu(s) pod(s) de Redis o con un [archivo local, ConfigMap, almacén de clave-valor, manifiesto de Datadog Operator, o Helm chart][2].
+
+| Parámetro | Valor |
+| -------------------- | -------------------------------------------------------------------------- |
+| `` | `["redisdb"]` |
+| `` | `[{}]` |
+| `` | `[{"host": "%%host%%","port":"6379","password":"%%env_REDIS_PASSWORD%%"}]` |
+
+**Anotaciones v1** (para el Datadog Agent v7.36 o anterior)
+
+```yaml
+apiVersion: v1
+kind: Pod
+metadata:
+ name: redis
+ annotations:
+ ad.datadoghq.com/redis.check_names: '["redisdb"]'
+ ad.datadoghq.com/redis.init_configs: '[{}]'
+ ad.datadoghq.com/redis.instances: |
+ [
+ {
+ "host": "%%host%%",
+ "port":"6379",
+ "password":"%%env_REDIS_PASSWORD%%"
+ }
+ ]
+ labels:
+ name: redis
+spec:
+ containers:
+ - name: redis
+ image: redis:latest
+ ports:
+ - containerPort: 6379
+```
+
+**Anotaciones v2** (para el Datadog Agent v7.36 o posterior)
+
+```yaml
+apiVersion: v1
+kind: Pod
+metadata:
+ name: redis
+ annotations:
+ ad.datadoghq.com/redis.checks: |
+ {
+ "redisdb": {
+ "init_config": {},
+ "instances": [
+ {
+ "host": "%%host%%",
+ "port":"6379",
+ "password":"%%env_REDIS_PASSWORD%%"
+ }
+ ]
+ }
+ }
+ labels:
+ name: redis
+spec:
+ containers:
+ - name: redis
+ image: redis:latest
+ ports:
+ - containerPort: 6379
+```
+
+**Nota**: La lógica de variable de plantilla `"%%env_%%"` se utiliza para evitar almacenar la contraseña en texto simple, por lo que la variable de entorno`REDIS_PASSWORD` se debe definir en el contenedor del Agent. Para ver más detalles, consulta la documentación de la [variable de plantilla Autodiscovery][3]. Alternativamente, el Agent puede aprovechar el paquete `secrets` para trabajar con cualquier backend de [gestión de secretos][4] (como HashiCorp Vault o AWS Secrets Manager).
+
+##### Recopilación de logs
+
+Disponible para la versión 6.0 o posteriores del Agent
+
+La recopilación de logs se encuentra deshabilitada de manera predeterminada en el Datadog Agent. Para habilitarla, consulta [Recopilación de logs de Kubernetes][5].
+
+A continuación, configura el siguiente parámetro en una [plantilla de Autodiscovery][1]. Puedes hacerlo con Kubernetes Annotations (que se muestra a continuación) en tu(s) pod(s) de Redis, o con un [archivo local, ConfigMap, almacén de clave-valor, manifiesto de Datadog Operator, o Helm chart][2].
+
+| Parámetro | Valor |
+| -------------------- | -------------------------------------------------------------------------- |
+| `` | `[{"source":"redis","service":""}]` |
+
+**Anotaciones v1/v2**
+
+```yaml
+apiVersion: v1
+kind: Pod
+metadata:
+ name: redis
+ annotations:
+ ad.datadoghq.com/redis.logs: '[{"source":"redis","service":""}]'
+ labels:
+ name: redis
+spec:
+ containers:
+ - name: redis
+ image: redis:latest
+ ports:
+ - containerPort: 6379
+```
+
+##### Recopilación de trazas
+
+APM para aplicaciones en contenedores es compatible con hosts que se ejecutan en la versión 6 o posteriores del Agent, pero requiere configuración adicional para empezar a recopilar trazas.
+
+Variables de entorno requeridas en el contenedor del Agent:
+
+| Parámetro | Valor |
+| -------------------- | -------------------------------------------------------------------------- |
+| `` | `api_key` |
+| `` | true |
+| `` | true |
+
+Para ver una lista completa de las variables de entorno y la configuración disponibles, consulta [Rastreo de aplicaciones Kubernetes][6] y la [configuración del DaemonSet de Kubernetes][7].
+
+A continuación, [instrumenta el contenedor de tu aplicación que realiza solicitudes a Redis][8].
+
+[1]: https://docs.datadoghq.com/agent/kubernetes/integrations/?tab=kubernetes
+[2]: https://docs.datadoghq.com/agent/kubernetes/integrations/?tab=kubernetes#configuration
+[3]: https://docs.datadoghq.com/agent/faq/template_variables/
+[4]: https://docs.datadoghq.com/agent/guide/secrets-management/?tab=linux
+[5]: https://docs.datadoghq.com/agent/kubernetes/log/?tab=containerinstallation#setup
+[6]: https://docs.datadoghq.com/agent/kubernetes/apm/?tab=java
+[7]: https://docs.datadoghq.com/agent/kubernetes/daemonset_setup/?tab=k8sfile#apm-and-distributed-tracing
+[8]: https://docs.datadoghq.com/tracing/setup/
+{{% /tab %}}
+{{% tab "ECS" %}}
+
+#### ECS
+
+Para configurar este check para un Agent que se ejecuta en ECS:
+
+##### Recopilación de métricas
+
+Configura [plantillas de integraciones de Autodiscovery][1] como etiquetas Docker en el contenedor de tu aplicación:
+
+```json
+{
+ "containerDefinitions": [{
+ "name": "redis",
+ "image": "redis:latest",
+ "dockerLabels": {
+ "com.datadoghq.ad.check_names": "[\"redisdb\"]",
+ "com.datadoghq.ad.init_configs": "[{}]",
+ "com.datadoghq.ad.instances": "[{\"host\":\"%%host%%\",\"port\":\"6379\",\"password\":\"%%env_REDIS_PASSWORD%%\"}]"
+ }
+ }]
+}
+```
+
+**Nota**: La lógica de variable de plantilla `"%%env_%%"` se utiliza para evitar almacenar la contraseña en texto simple, por lo que la variable de entorno`REDIS_PASSWORD` se debe definir en el contenedor del Agent. Para ver más detalles, consulta la documentación de la [variable de plantilla Autodiscovery][2]. Alternativamente, el Agent puede aprovechar el paquete `secrets` para trabajar con cualquier backend de [gestión de secretos][3] (como HashiCorp Vault o AWS Secrets Manager).
+
+##### Recopilación de logs
+
+Disponible para la versión 6.0 o posteriores del Agent
+
+La recopilación de logs se encuentra deshabilitada de manera predeterminada en el Datadog Agent. Para habilitarla, consulta la [recopilación de logs de ECS][4].
+
+Luego, configura [integraciones de logs][5] como etiquetas Docker:
+
+```yaml
+{
+ "containerDefinitions": [{
+ "name": "redis",
+ "image": "redis:latest",
+ "dockerLabels": {
+ "com.datadoghq.ad.logs": "[{\"source\":\"redis\",\"service\":\"\"}]"
+ }
+ }]
+}
+```
+
+##### Recopilación de trazas
+
+APM para aplicaciones en contenedores es compatible con el Agent v6 o posterior, pero requiere configuración adicional para empezar a recopilar trazas.
+
+Variables de entorno requeridas en el contenedor del Agent:
+
+| Parámetro | Valor |
+| -------------------- | -------------------------------------------------------------------------- |
+| `` | `api_key` |
+| `` | true |
+| `` | true |
+
+Para ver una lista completa de las variables de entorno disponibles y la configuración, consulta [Rastreo de aplicaciones Docker][6].
+
+Luego, [instrumenta el contenedor de tu aplicación que realiza solicitudes a Redis][7] y configura `DD_AGENT_HOST` en la [dirección IP privada de EC2][8].
+
+[1]: https://docs.datadoghq.com/agent/docker/integrations/?tab=docker
+[2]: https://docs.datadoghq.com/agent/faq/template_variables/
+[3]: https://docs.datadoghq.com/agent/guide/secrets-management/?tab=linux
+[4]: https://docs.datadoghq.com/agent/amazon_ecs/logs/?tab=linux
+[5]: https://docs.datadoghq.com/agent/docker/log/?tab=containerinstallation#log-integrations
+[6]: https://docs.datadoghq.com/agent/docker/apm/?tab=linux
+[7]: https://docs.datadoghq.com/tracing/setup/
+[8]: https://docs.datadoghq.com/agent/amazon_ecs/apm/?tab=ec2metadataendpoint#setup
+{{% /tab %}}
+{{< /tabs >}}
+
+### Validación
+
+[Ejecuta el subcomando de estado del Agent][2] y busca `redisdb` en la sección Checks.
+
+## Datos recopilados
+
+### Métricas
+{{< get-metrics-from-git "redisdb" >}}
+
+
+### Eventos
+
+El check de Redis no incluye eventos.
+
+### Checks de servicio
+{{< get-service-checks-from-git "redisdb" >}}
+
+
+## Solucionar problemas
+
+### El Agent no se puede conectar
+
+```shell
+ redisdb
+ -------
+ - instance #0 [ERROR]: 'Error 111 connecting to localhost:6379. Connection refused.'
+ - Collected 0 metrics, 0 events & 1 service check
+```
+
+Verifica que la información de conexión en `redisdb.yaml` es la correcta.
+
+### El Agent no se puede autenticar
+
+```shell
+ redisdb
+ -------
+ - instance #0 [ERROR]: 'NOAUTH Authentication required.'
+ - Collected 0 metrics, 0 events & 1 service check
+```
+
+Configura un `password` en `redisdb.yaml`.
+
+## Referencias adicionales
+
+Más enlaces, artículos y documentación útiles:
+
+- [Monitorización de métricas de rendimiento de Redis][3]
+
+
+[1]: https://app.datadoghq.com/account/settings/agent/latest
+[2]: https://docs.datadoghq.com/agent/guide/agent-commands/#agent-status-and-information
+[3]: https://www.datadoghq.com/blog/how-to-monitor-redis-performance-metrics
diff --git a/content/es/logs/_index.md b/content/es/logs/_index.md
index 6ad5002dce18c..72fcee74dfb2a 100644
--- a/content/es/logs/_index.md
+++ b/content/es/logs/_index.md
@@ -51,6 +51,9 @@ further_reading:
- link: https://www.datadoghq.com/architecture/a-guide-to-log-management-indexing-strategies-with-datadog/
tag: Centro de arquitectura
text: Guía de estrategias de indexación de la gestión de logs con Datadog
+- link: https://www.datadoghq.com/blog/archive-search/
+ tag: Blog
+ text: Busca en tus logs históricos de forma más eficiente con Datadog Archive Search
title: Gestión de logs
---
@@ -110,7 +113,7 @@ Comienza a explorar tus logs ingeridos en el [Log Explorer][1].
Aprende sin coste alguno sobre la capacidad real de computación en la nube y una cuenta de prueba de Datadog. Inscríbete hoy mismo para obtener más información sobre la recopilación, consulta, análisis, métricas, monitorización, procesamiento, almacenamiento y control de acceso de logs.
{{< /learning-center-callout >}}
-## Para leer más
+## Referencias adicionales
{{< partial name="whats-next/whats-next.html" >}}
diff --git a/content/es/logs/explorer/advanced_search.md b/content/es/logs/explorer/advanced_search.md
new file mode 100644
index 0000000000000..3fa2726aa264f
--- /dev/null
+++ b/content/es/logs/explorer/advanced_search.md
@@ -0,0 +1,84 @@
+---
+disable_toc: false
+further_reading:
+- link: logs/explorer/analytics
+ tag: Documentación
+ text: Realizar análisis de logs
+- link: /logs/explorer/export
+ tag: Documentación
+ text: Exportar vistas desde el Log Explorer
+- link: /logs/explorer/saved_views/
+ tag: Documentación
+ text: Información sobre las vistas guardadas
+title: Búsqueda avanzada
+---
+
+## Información general
+
+Cuando necesitas limitar aún más los resultados de una búsqueda de log, utiliza [subconsultas](#filter-logs-with-subqueries) para comparar tus resultados con un grupo secundario de logs, o filtra tus logs utilizando datos de tus [Tablas de referencia](#filter-logs-based-on-reference-tables).
+
+## Filtrar logs con subconsultas
+
+Utiliza subconsultas cuando desees filtrar los resultados de una consulta basándote en los resultados de una consulta secundaria. Consulta [ejemplos de subconsultas](#subquery-examples) para ver dos escenarios de ejemplo.
+
+Para añadir un filtro de subconsulta:
+
+1. Ve a [Log Explorer (Explorador de logs)][1].
+1. Introduce una consulta en la barra de búsqueda para filtrar tus logs. Esta es la consulta principal.
+1. Haz clic en **+ Add** (+ Añadir).
+1. En la sección **Add Query Filter** (Añadir filtro de consulta), selecciona **Logs**.
+
+Esto introduce nuevos elementos en el editor de consultas:
+
+{{< img src="logs/explorer/advanced_search/subquery.png" alt="El editor de subconsulta en la consulta de búsqueda principal" style="width:95%;" >}}
+
+1. En el campo **where** (dónde), utiliza el menú desplegable para seleccionar el atributo con el que deseas establecer la correlación. Los atributos disponibles son los de logs devueltos por la consulta principal.
+1. Define tu filtro de subconsulta en el campo **from** (de).
+1. En el menú desplegable **Select Column** (Seleccionar columna) que precede al filtro de la subconsulta, selecciona el atributo por el que deseas agrupar y ordenar los resultados de la subconsulta.
+1. Selecciona si deseas utilizar el operador **IN** o **NOT IN**:
+ - Los resultados del operador **IN** solo incluyen logs cuando el valor del atributo también se encuentra en los resultados de la subconsulta. Por ejemplo, si solo deseas ver logs generados por `service:a` y está asociado a un usuario que también es uno de los principales usuarios de `service:b`.
+ - Los resultados del operador **NOT IN** excluyen logs donde se encuentra el valor del atributo en los resultados de la subconsulta. Por ejemplo, si solo deseas ver logs `status:error`, pero también deseas filtrar logs `status:error` donde los usuarios asociados a esos logs acaben finalmente con un log `status:success`. Consulta [Filtrar logs desactualizados o sustituidos](#filter-outdated-or-superseded-logs) para ver un ejemplo detallado.
+1. Opcionalmente, reduce el número de valores de atributos de subconsulta con los que comparar. El valor por defecto y máximo es `1000`. Elige entre **top** (principal) (valores de mayor frecuencia) o **bottom** (inferior) (valores de menor frecuencia).
+
+### Ejemplos de subconsultas
+
+Los siguientes son escenarios en los que necesitas utilizar subconsultas para obtener la información que necesitas de tus logs.
+
+#### Filtrar logs obsoletos o sustituidos
+
+Supongamos que gestionas una plataforma de comercio electrónico. Se genera un log cada vez que uno de tus clientes intenta realizar un pedido. Deseas analizar tus logs para conocer el valor total de las compras potenciales perdidas debido a un problema continuo con tu sitio web.
+
+Sin embargo, te das cuenta de que un pedido puede fallar varias veces antes de completarse con éxito: lo que significa que para ese ID de pedido en particular, hay entradas de log en los resultados de búsqueda, tanto para logs `status:error` como para logs `status:success`. Si extrajeras listas de ID de pedido únicas de las dos consultas, este ID de pedido aparecería en ambas. Con las subconsultas, puedes obtener una lista mutuamente excluyente.
+
+En este ejemplo, solo estás interesado en logs para los pedidos que finalmente no tuvieron éxito. Para excluir los pedidos que finalmente tuvieron éxito utilizando la función de subconsulta:
+
+1. Define una subconsulta para logs `status:success`.
+1. Selecciona el operador **NOT IN** para excluir los pedidos del conjunto de resultados de la subconsulta.
+
+{{< img src="logs/explorer/advanced_search/filter_outdated_example.png" alt="El editor de consulta que muestra la configuración para filtrar pedidos que terminan teniendo éxito" style="width:100%;" >}}
+
+#### Correlación entre diferentes fuentes de log
+
+Supón que tienes un servicio llamado `network_directory` que supervisa todos los recursos internos de red y el acceso a esos recursos dentro de tu organización. Los eventos de log generados por este servicio incluyen atributos estándar (como `host`, `service`, `source`) y atributos personalizados como la dirección IP del cliente.
+
+Además, tienes otro servicio `device-manager` que rastrea todos los activos internos (infraestructura, dispositivos de los empleados, etc.).
+
+Estás investigando un ataque en curso y observas que hay un aumento significativo de solicitudes de API en casi todos tus endpoints. En primer lugar, deseas identificar las direcciones IP asociadas a volúmenes de solicitudes anómalos para poder bloquearlas en el cortafuegos. Sin embargo, tus servicios internos son algunos de los mayores consumidores de estos endpoints y necesitas excluirlos de tus resultados de consulta para evitar bloquearlos por error.
+
+En este ejemplo, utiliza `service:network_directory` como consulta principal y, a continuación, define un filtro de subconsulta para tu servicio `device-manager` para filtrar los resultados de los dispositivos reconocidos.
+
+{{< img src="logs/explorer/advanced_search/narrow_dataset_example.png" alt="El editor de consulta que muestra la configuración para filtrar los resultados para los dispositivos reconocidos" style="width:100%;" >}}
+
+## Filtrar logs a partir de tablas de referencia
+
+{{% filter_by_reference_tables %}}
+
+{{< img src="logs/explorer/advanced_search/reference_table_join_filter.png" alt="El Datadog Log Explorer con las opciones de búsqueda de la tabla de referencia resaltadas. Incluye pasos numerados alineados con las instrucciones previas" border="true" popup="true" style="width:100%;" >}}
+
+## Referencias adicionales
+
+{{< partial name="whats-next/whats-next.html" >}}
+
+
+[1]: https://app.datadoghq.com/logs
+[2]: /es/integrations/guide/reference-tables/?tab=manualupload
\ No newline at end of file
diff --git a/content/es/logs/log_configuration/archives.md b/content/es/logs/log_configuration/archives.md
index a1338be1ae980..d66c8e5ad8a09 100644
--- a/content/es/logs/log_configuration/archives.md
+++ b/content/es/logs/log_configuration/archives.md
@@ -24,7 +24,7 @@ title: Archivos de log
Configura tu cuenta de Datadog para reenviar todos los logs ingestados (ya sea que esté [indexado][1] o no) a un sistema de almacenamiento en la nube de tu propiedad. Conserva tus logs en un archivo optimizado para el almacenamiento durante más tiempo y cumple los requisitos de conformidad, al tiempo que mantienes la auditabilidad para investigaciones ad hoc, con [Recuperación][2].
-{{< img src="logs/archives/log_forwarding_archives_tab.png" alt="Pestaña Archivo en la página Reenvío de log" style="width:100%;">}}
+{{< img src="/logs/archives/log_forwarding_archives_122024.png" alt="Pestaña de Archivos en la página Reenvío de logs" style="width:100%;">}}
Ve a la página [**Log Forwarding**][3] (Reenvío de log) para configurar un archivo para el reenvío de logs ingeridos a tu propio bucket de almacenamiento alojado en la nube.
@@ -44,10 +44,6 @@ Consulta cómo [archivar tus logs con Pipelines de observabilidad][4] si deseas
{{< tabs >}}
{{% tab "AWS S3" %}}
-{{< site-region region="gov" >}}
-La configuración de archivos S3 mediante la delegación de roles tiene actualmente una disponibilidad limitada. Ponte en contacto con el servicio de asistencia de Datadog para solicitar esta función en tu cuenta Datadog for Government.
-{{< /site-region >}}
-
Si aún no está configurada, configura [la integración de AWS][1] para la cuenta de AWS que contiene tu bucket de S3.
* En el caso general, se trata de crear un rol que Datadog pueda utilizar para integrarse con AWS S3.
* En el caso específico de las cuentas de AWS China, utiliza claves de acceso como alternativa a la delegación de roles.
@@ -58,7 +54,7 @@ Si aún no está configurada, configura [la integración de AWS][1] para la cuen
Configura [la integración de Azure][1] dentro de la suscripción que contiene tu nueva cuenta de almacenamiento, si aún no lo has hecho. Esto implica [crear un registro de aplicación que Datadog pueda utilizar][2] para integrarla.
-**Nota:** No se admite el archivado en Azure ChinaCloud, GermanyCloud y GovCloud.
+**Nota:** El archivado en Azure ChinaCloud y Azure GermanyCloud no es compatible. El archivado en Azure GovCloud es compatible con la versión preliminar. Para solicitar acceso, ponte en contacto con el servicio de asistencia de Datadog.
[1]: https://app.datadoghq.com/account/settings#integrations/azure
[2]: /es/integrations/azure/?tab=azurecliv20#integrating-through-the-azure-portal
@@ -84,6 +80,10 @@ Configura la [integración de Google Cloud][1] para el proyecto que contiene tu
Entra en tu [consola de AWS][1] y [crea un bucket de S3][2] al que enviar tus archivos.
+{{< site-region region="gov" >}}
+ Datadog Archives no admiten nombres de bucket con puntos (.) cuando se integran con un endpoint FIPS de S3 que se basa en el direccionamiento de estilo virtual-host. Obtén más información en la documentación de AWS.
AWS FIPS y
AWS Virtual Hosting.
+{{< /site-region >}}
+
**Notas:**
- No pongas tu bucket a disposición del público.
@@ -126,7 +126,7 @@ Solo los usuarios de Datadog con el [permiso`logs_write_archive`][5] pueden crea
{{< tabs >}}
{{% tab "AWS S3" %}}
-1. [Crear una política][1] con las siguientes sentencias de permiso:
+1. [Crear una política][1] con las siguientes declaraciones de permiso:
```json
{
@@ -160,9 +160,9 @@ Solo los usuarios de Datadog con el [permiso`logs_write_archive`][5] pueden crea
2. Edita los nombres de los buckets.
3. Opcionalmente, especifica las rutas que contienen tus archivos de log.
4. Adjunta la nueva política al rol de integración de Datadog.
- * Ve a **Roles** en la consola de AWS IAM.
- * Localiza el rol utilizado por la integración de Datadog. Por defecto se llama **DatadogIntegrationRole**, pero el nombre puede variar si tu organización le ha cambiado el nombre. Haz clic en el nombre del rol para abrir la página de resumen del rol.
- * Haz clic en **Add permissions** (Añadir permisos), y luego en **Attach policies** (Adjuntar políticas).
+ * Ve a **Roles** en la consola IAM en AWS.
+ * Localiza el rol utilizado por la integración Datadog. Por defecto se llama **DatadogIntegrationRole**, pero el nombre puede variar si tu organización le ha cambiado el nombre. Haz clic en el nombre del rol para abrir la página de resumen del rol.
+ * Haz clic en **Add permissions** (Añadir permisos) y, luego, en **Attach policies** (Adjuntar políticas).
* Introduce el nombre de la política creada anteriormente.
* Haz clic en **Attach policies** (Adjuntar políticas).
@@ -202,54 +202,15 @@ Ve a la página de [Reenvío de log][6] y selecciona **Add a new archive** (Aña
* Si tu bucket restringe el acceso de red a las IP especificadas, añade las IP de los webhooks de {{< region-param key="ip_ranges_url" link="true" text="IP ranges list">}} a la lista de permitidos.
* Para el sitio **US1-FED**, puedes configurar Datadog para enviar logs a un destino fuera del entorno Datadog GovCloud. Datadog no se hace responsable de ningún log que abandone el entorno Datadog GovCloud. Además, Datatdog no se hace responsable de ninguna obligación o requisito que puedas tener en relación con FedRAMP, DoD Impact Levels, ITAR, conformidad de las exportaciones, residencia de datos o normativas similares aplicables a estos Logs una vez que abandonen el entorno Datadog GovCloud.
-{{< tabs >}}
-{{% tab "AWS S3" %}}
-
-Selecciona la combinación de cuenta y rol de AWS adecuada para tu bucket de S3.
-
-Introduce el nombre de tu bucket. **Opcional**: introduce un directorio de prefijo para todo el contenido de tus archivos de log.
-
-{{< img src="logs/archives/logs_archive_aws_setup.png" alt="Configura tu información de bucket de S3 en Datadog" style="width:75%;">}}
-
-{{% /tab %}}
-{{% tab "Azure Storage" %}}
-
-Selecciona el tipo de archivo **Azure Storage**, y el inquilino y cliente de Azure para la aplicación de Datadog que tiene el rol Storage Blob Data Contributor en tu cuenta de almacenamiento.
-
-Introduce el nombre de tu cuenta de almacenamiento y el nombre de contenedor para tu archivo. **Opcional**: introduce un directorio de prefijo para todo el contenido de tus archivos de log.
-
-{{< img src="logs/archives/logs_archive_azure_setup.png" alt="Configura tu información de cuenta de almacenamiento de Azure en Datadog" style="width:75%;">}}
-
-
-{{% /tab %}}
-{{% tab "Google Cloud Storage" %}}
-
-Selecciona el tipo de archivo **GCS** y la cuenta de servicio de GCS que tenga permisos para escribir en tu bucket de almacenamiento.
-
-Introduce el nombre de tu bucket. **Opcional**: introduce un directorio de prefijo para todo el contenido de tus archivos de log.
-
-{{< img src="logs/archives/logs_archive_gcp_setup.png" alt="Configura tu información de cuenta de almacenamiento de Azure en Datadog" style="width:75%;">}}
-
-{{% /tab%}}
-{{< /tabs>}}
+| Servicio | Pasos |
+|--------------------------|------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| **Amazon S3** | - Selecciona la combinación de la cuenta y rol de AWS adecuada para tu bucket de S3.
- Introduce el nombre de tu bucket.
**Opcional**: introduce un directorio prefijo para todo el contenido de tus archivos de log. |
+| **Almacenamiento de Azure** | - Selecciona el tipo de archivo **Azure Storage** (Almacenamiento de Azure), y el inquilino y cliente de Azure para la aplicación de Datadog que tiene el rol Storage Blob Data Contributor en tu cuenta de almacenamiento.
- Introduce el nombre de tu cuenta de almacenamiento y el nombre de contenedor para tu archivo.
**Opcional**: introduce un directorio prefijo para todo el contenido de tus archivos de log. |
+| **Google Cloud Storage** | - Seleccione el tipo de archivo **Google Cloud Storage** (Almacenamiento de Google Cloud) y la cuenta de servicio de GCS que tiene permisos para escribir en tu bucket de almacenamiento.
- Introduce el nombre de tu bucket.
**Opcional**: introduce un directorio prefijo para todo el contenido de tus archivos de log. |
### Configuración avanzada
-#### Permisos de Datadog
-
-Por defecto:
-
-* Todos los usuarios Admin de Datadog pueden crear, editar y reordenar. Consulta [Configurar archivos múltiples](#multiple-archives) para obtener más información.
-* Todos los usuarios de Datadog Admin y Standard pueden recuperar desde archivos.
-* Todos los usuarios, incluidos los Read Only (solo lectura) de Datadog, pueden acceder a logs recuperados.
-
-Utiliza este paso de configuración opcional para asignar roles en ese archivo y restringir quién puede:
-
-* Editar ese archivo de configuración. Consulta el permiso [`logs_write_archive`][9].
-* Recuperar desde ese archivo. Consulta los permisos [`logs_read_archives`][10] y [`logs_write_historical_view`][11].
-* Acceder a logs recuperados en caso de que utilices el permiso legacy [`read_index_data`][12].
-
-{{< img src="logs/archives/archive_restriction.png" alt="Restrinfir el acceso a archivos y logs recuperados" style="width:75%;">}}
+{{< img src="/logs/archives/log_archives_advanced_settings.png" alt="Configuración avanzada para añadir etiquetas opcionales y definir el tamaño máximo de análisis" style="width:100%;" >}}
#### Etiquetas de Datadog
@@ -258,16 +219,12 @@ Utiliza este paso de configuración opcional para:
* Incluir todas las etiquetas de log en tus archivos (activado por defecto en todos los archivos nuevos). **Nota**: Esto aumenta el tamaño de los archivos resultantes.
* Añadir etiquetas en los logs recuperados de acuerdo con tu política de Consultas de restricción. Consulta el permiso [`logs_read_data`][13].
-{{< img src="logs/archives/tags_in_out.png" alt="Configurar etiquetas de archivo" style="width:75%;">}}
-
#### Definir el tamaño máximo de escaneado
Utiliza este paso de configuración opcional para definir el volumen máximo de datos de log (en GB) que se pueden escanear para la recuperación en tus archivos de log.
Para los archivos con un tamaño máximo de escaneado definido, todos los usuarios deben estimar el tamaño del escaneado antes de que se les permita iniciar una recuperación. Si el tamaño de escaneado estimado es superior al permitido para ese archivo, los usuarios deben reducir el intervalo en el que solicitan la recuperación. La reducción del intervalo reducirá el tamaño del escaneado y permitirá al usuario iniciar una recuperación.
-{{< img src="logs/archives/max_scan_size.png" alt="Definir el tamaño máximo de escaneado en el archivo" style="width:75%;">}}
-
{{< site-region region="us3" >}}
#### Reglas del cortafuegos
@@ -276,8 +233,8 @@ Para los archivos con un tamaño máximo de escaneado definido, todos los usuari
No se admiten reglas de cortafuegos.
-{{% /tab%}}
-{{< /tabs>}}
+{{% /tab %}}
+{{< /tabs >}}
{{< /site-region >}}
#### Clase de almacenamiento
@@ -285,7 +242,7 @@ No se admiten reglas de cortafuegos.
{{< tabs >}}
{{% tab "AWS S3" %}}
-Puedes [establecer una configuración del ciclo de vida en tu bucket de S3][1] para realizar una transición automática de tus archivos de log a clases de almacenamiento óptimas.
+Puedes seleccionar una clase de almacenamiento para tu archivo o [establecer una configuración de ciclo de vida en tu bucket de S3][1] para realizar una transición automática de tus archivos de log a clases de almacenamiento óptimas.
La [recuperación][2] solo admite las siguientes clases de almacenamiento:
@@ -311,29 +268,56 @@ El archivado y la [recuperación][1] solo admiten los siguientes niveles de acce
Si deseas recuperar a partir de archivos de otro nivel de acceso, primero debes moverlos a uno de los niveles admitidos mencionados anteriormente.
[1]: /es/logs/archives/rehydrating/
-Accede a dashboards preconfigurados
+{{% /tab %}}
+{{% tab "Google Cloud Storage" %}}
+
+Archivo y [rehidratación][1] admite los siguientes niveles de acceso:
+- Standard (Estándar)
+- Nearline
+- Coldline
+- Archivo
+
+[1]: /es/logs/archives/rehydrating/
{{% /tab %}}
+
{{< /tabs >}}
-#### Cifrado del lado del servidor (SSE)
+#### Cifrado del lado del servidor (SSE) para archivos de S3
-{{< tabs >}}
-{{% tab "AWS S3" %}}
+Al crear o actualizar un archivo de S3 en Datadog, puedes optar por configurar **Advanced Encryption** (Cifrado avanzado). Hay tres opciones disponibles en el menú desplegable **Encryption Type** (Tipo de cifrado):
-##### SSE-S3
+- **Cifrado predeterminado a nivel de bucket de S3** (predeterminado): Datadog no anula la configuración de cifrado predeterminado de tu bucket de S3.
+- **Claves gestionadas de Amazon S3**: fuerza el cifrado del lado del servidor utilizando claves administradas de Amazon S3 ([SSE-S3][1]), independientemente del cifrado predeterminado del bucket de S3.
+- **AWS Key Management Service**: fuerza el cifrado del lado del servidor utilizando una clave gestionada por el cliente (CMK) de [AWS KMS][2], independientemente del cifrado predeterminado del bucket de S3. Deberás proporcionar el ARN de la CMK.
-El cifrado predeterminado para los buckets de Amazon S3 es el cifrado del lado del servidor con claves de administración de Amazon S3 ([SSE-S3][1]).
+[1]: https://docs.aws.amazon.com/AmazonS3/latest/userguide/UsingServerSideEncryption.html
+[2]: https://docs.aws.amazon.com/AmazonS3/latest/dev/UsingKMSEncryption.html
+{{< tabs >}}
+{{% tab "Default S3 Bucket-Level Encryption" %}}
-Para confirmar que tu bucket de S3 está cifrado con SSE-S3:
+Cuando se selecciona esta opción, Datadog no especifica ningún encabezado de cifrado en la solicitud de carga. Se aplicará el cifrado predeterminado de tu bucket de S3.
+
+Para configurar o comprobar la configuración del cifrado de tu bucket S3:
1. Navega hasta tu bucket de S3.
-1. Haz clic en la pestaña **Properties** (Propiedades).
-1. En la sección **Default Encryption** (Cifrado por defecto), comprueba que el **Encryption key type** (Tipo de clave de cifrado) es **Amazon S3 managed keys (SSE-S3)** (Claves administradas de Amazon S3 (SSE-S3)).
+2. Haz clic en la pestaña **Propiedades**.
+3. En la sección **Default Encryption** (Cifrado por defecto), configura o confirma el tipo de cifrado. Si tu cifrado utiliza [AWS KMS][1], asegúrate de que tienes una CMK válida y una política de CMK adjunta a tu CMK.
+
+[1]: https://docs.aws.amazon.com/AmazonS3/latest/dev/UsingKMSEncryption.html
+
+{{% /tab %}}
+{{% tab "Amazon S3 managed keys" %}}
+
+Esta opción garantiza que todos los objetos de archivo se carguen con [SSE_S3][1], utilizando claves gestionadas de Amazon S3. Esto anula cualquier configuración de cifrado predeterminada en el bucket de S3.
-##### SSE-KMS
+[1]: https://docs.aws.amazon.com/AmazonS3/latest/userguide/UsingServerSideEncryption.html
+{{% /tab %}}
+{{% tab "AWS Key Management Service" %}}
+
+Esta opción garantiza que todos los objetos de archivo se carguen utilizando una clave gestionada por el cliente (CMK) de [AWS KMS][1]. Esto anula cualquier configuración de cifrado predeterminada en el bucket de S3.
-Como alternativa, Datadog admite el cifrado del lado del servidor con una CMK de [AWS KMS][2]. Para habilitarla, sigue estos pasos:
+Asegúrate de haber completado los siguientes pasos para crear una CMK válida y una política de CMK. Deberás proporcionar el ARN de CMK para configurar correctamente este tipo de cifrado.
1. Crea tu CMK.
2. Adjunta una política de CMK a tu CMK con el siguiente contenido, sustituyendo según corresponda el número de cuenta de AWS y el nombre de rol de Datadog IAM:
@@ -389,15 +373,9 @@ Como alternativa, Datadog admite el cifrado del lado del servidor con una CMK de
}
```
-3. Ve a la pestaña **Properties** (Propiedades) en tu bucket de S3 y selecciona **Default Encryption** (Cifrado por defecto). Elige la opción "AWS-KMS", selecciona tu ARN de CMK y selecciona guardar.
-
-Para cualquier cambio en las claves de KMS existentes, ponte en contacto con el [soporte de Datadog][3] para obtener más ayuda.
-
-[1]: https://docs.aws.amazon.com/AmazonS3/latest/userguide/default-bucket-encryption.html
-[2]: https://docs.aws.amazon.com/AmazonS3/latest/dev/UsingKMSEncryption.html
-[3]: /es/help/
-{{< partial name="whats-next/whats-next.html" >}}
+3. Después de seleccionar **AWS Key Management Service** como tu **Encryption Type** (Tipo de cifrado) en Datadog, introduce tu ARN de la clave de AWS KMS.
+[1]: https://docs.aws.amazon.com/AmazonS3/latest/dev/UsingKMSEncryption.html
{{% /tab %}}
{{< /tabs >}}
@@ -405,7 +383,7 @@ Para cualquier cambio en las claves de KMS existentes, ponte en contacto con el
Una vez que los ajustes del archivo se hayan configurado correctamente en tu cuenta de Datadog, tus pipelines de procesamiento comenzarán a enriquecer todos los logs que se ingieran en Datadog. Estos logs se reenvían posteriormente a tu archivo.
-Sin embargo, después de crear o actualizar las configuraciones de los archivos, pueden pasar varios minutos antes de que se intente la siguiente carga de archivos. La frecuencia con la que se cargan los archivos puede variar. **Consulta tu bucket de almacenamiento de nuevo en 15 minutos** para asegurarte de que los archivos se están cargando correctamente desde tu cuenta de Datadog.
+Sin embargo, después de crear o actualizar las configuraciones de los archivos, pueden pasar varios minutos antes de que se intente la siguiente carga de archivos. La frecuencia con la que se cargan los archivos puede variar. **Consulta tu bucket de almacenamiento de nuevo en 15 minutos** para asegurarte de que los archivos se están cargando correctamente desde tu cuenta de Datadog.
Después, si el archivo sigue en estado pendiente, comprueba tus filtros de inclusión para asegurarte de que la consulta es válida y coincide con eventos de log en [Live Tail][14]. Cuando Datadog no consigue cargar logs en un archivo externo, debido a cambios involuntarios en la configuración o los permisos, el archivo de log correspondiente aparece resaltado en la página de configuración.
@@ -448,9 +426,9 @@ Dentro del archivo JSON comprimido, el contenido de cada evento tiene el siguien
}
```
-## Configurar tests de API y tests de API multupaso
+## Referencias adicionales
-Grabar pruebas de aplicaciones móviles
+{{< partial name="whats-next/whats-next.html" >}}
*Logging without Limits es una marca registrada de Datadog, Inc.
@@ -469,4 +447,4 @@ Grabar pruebas de aplicaciones móviles
[12]: /es/account_management/rbac/permissions#logs_read_index_data
[13]: /es/account_management/rbac/permissions#logs_read_data
[14]: /es/logs/explorer/live_tail/
-[15]: /es/service_management/events/explorer/
+[15]: /es/service_management/events/explorer/
\ No newline at end of file
diff --git a/content/es/logs/log_configuration/processors.md b/content/es/logs/log_configuration/processors.md
index f0cb4ca5683f3..a4adbc9d90c3a 100644
--- a/content/es/logs/log_configuration/processors.md
+++ b/content/es/logs/log_configuration/processors.md
@@ -686,7 +686,7 @@ El procesador de búsqueda realiza las siguientes acciones:
* Opcionalmente, si no encuentra el valor en la tabla de asignación, crea un atributo de destino con el valor de la tabla de referencia. Puedes seleccionar un valor para una [tabla de referencias][101] en la pestaña **Reference Table** (Tabla de referencia).
- {{< img src="logs/log_configuration/processor/lookup_processor_reference_table.png" alt="Procesador de búsqueda"
+ {{< img src="logs/log_configuration/processor/lookup_processor_reference_table.png" alt="Procesador de búsqueda" >}}
style="width:80%;">}}
diff --git a/content/es/metrics/summary.md b/content/es/metrics/summary.md
index 91de4856f2940..bdb19d672ea99 100644
--- a/content/es/metrics/summary.md
+++ b/content/es/metrics/summary.md
@@ -19,41 +19,49 @@ La [página Resumen de métricas][1] muestra una lista de tus métricas informad
Busca tus métricas por nombre de métrica o etiqueta (tag) utilizando los campos **Metric** (Métrica) o **Tag** (Etiqueta):
-{{< img src="metrics/summary/tag_advancedfiltering3.mp4" alt="La página de resumen de métricas con NOT team:* ingresado en la barra de búsqueda de Etiqueta" video=true style="width:75%;">}}
+{{< img src="metrics/summary/tag_advanced_filtering.png" alt="Página de resumen de métricas SIN equipo:* ingresado en la barra de búsqueda por etiquetas" style="width:75%;">}}
-El filtrado de etiquetas admite la sintaxis booleana y comodín para que puedas identificar rápidamente:
+También puede descubrir métricas relevantes utilizando el soporte mejorado de concordancia difusa en el campo de búsqueda de métricas:
+
+{{< img src="metrics/summary/metric_advanced_filtering_fuzzy.png" alt="The metrics summary Page ( página) with fuzzy search searching shopist checkout" style="width:75%;">}}
+
+El filtrado por etiquetas admite la sintaxis booleana y de comodín para que puedas identificar:
* Métricas que están etiquetadas con una clave de etiqueta concreta, por ejemplo, `team`: `team:*`
* Métricas a las que les falta una determinada clave de etiqueta, por ejemplo, `team`: `NOT team:*`
-
## Panel de facetas
Las barras de búsqueda proporcionan el conjunto más completo de acciones para filtrar la lista de métricas. No obstante, las facetas también pueden filtrar tus métricas por:
-- **Configuración**: Métricas con configuraciones de etiqueta
-- **Percentiles**: Métricas de distribución habilitada por percentiles/capacidades de consulta avanzada
+- **Configuración**: métricas con configuraciones de etiqueta
+- **Porcentajes**: métricas de distribución habilitadas por percentiles/capacidades de consulta avanzadas
- **Métricas históricas**: Métricas que tienen activada la ingesta de métricas históricas
-- **Actividad de consulta** (fase beta): Métricas no consultadas en la aplicación o por la API en los últimos 30 días
-- **Tipo de métrica**: Diferencia entre métricas de distribución y no distribución (counts, gauges, rates)
-- **Origen de métrica**: Producto a partir del cual se originó la métrica (por ejemplo, métricas generadas a partir de logs o tramos (spans) de APM). Para obtener más información sobre los distintos tipos de origen de métrica, consulta [Definiciones de origen de métrica][12].
+- **Actividad de consulta**: Métricas no consultada en Datadog o por la API en los últimos 30, 60 o 90 días
+- **Recursos relacionados**: Métricas que se están utilizando en dashboards, notebooks, monitores y SLOs
+- **Tipo de métrica**: diferencia entre métricas de distribución y no distribución (counts, gauges, rates)
+- **Origen de métricas**: Producto del que procede la métrica (por ejemplo, métricas generadas a partir de logs o tramos (spans) APM). Para obtener más información sobre los distintos tipos de origen de métricas, consulta [definiciones de orígenes de métricas][12].
+
+### Definiciones
-**Nota**: Una métrica incluida en un dashboard que no haya sido cargada por un usuario en los últimos 30 días no se consideraría consultada activamente.
+Una métrica está **sin consultar** si no se accedió a ella en monitores, SLOs, notebooks ejecutados, dashboards abiertos, llamadas a la API o si no se la utilizó en consultas del Explorador de métricas en los últimos 30, 60 o 90 días.
-{{< img src="metrics/summary/facets4.png" alt="Panel de facetas de métricas" style="width:75%;">}}
+Una métrica se considera **utilizada** si existe en un recurso, independientemente de si se consultó activamente.
+
+{{< img src="metrics/summary/facet_panel_2025-02-26.png" alt="Panel de facetas de métricas" style="width:75%;">}}
## Configuración de múltiples métricas
-Al hacer clic en **Configure Metrics** (Configurar métricas) se te ofrecen múltiples opciones que puedes utilizar para configurar más de una métrica a la vez:
+Si haces clic en **Configure Metrics** (Configurar métricas), verás varias opciones para configurar más de una métrica a la vez:
{{< img src="metrics/summary/configurationbuttons10-11-2024.png" alt="Botones de configuración en bloque" style="width:100%;">}}
* **Gestionar etiquetas**: configura etiquetas en múltiples métricas personalizadas coincidentes con un espacio de nombres utilizando Metrics without LimitsTM.
-{{< img src="metrics/summary/bulkconfig_new-compressed.mp4" alt="Configuración de etiqueta de métricas en bloque" video="true" style="width:100%;" >}}
+{{< img src="metrics/summary/tags-bulk-config.mp4" alt="Configuración en bloque de etiquetas de métricas" video="true" style="width:100%;" >}}
* **Activar o desactivar percentiles**: gestiona agregaciones de percentiles a través de múltiples métricas de distribución. Consulta la [página de Distribuciones][31] para obtener más información.
-{{< img src="metrics/summary/percentile_aggregations_toggle.png" alt="Cambiar el conmutador para gestionar agregaciones de percentiles" style="width:100%;">}}
+{{< img src="metrics/summary/percentile_aggregations_toggle_2025-04-16.png" alt="Cambia el conmutador para gestionar agregaciones de percentiles" style="width:100%;">}}
* **Activar o desactivar las métricas históricas**: gestiona la ingesta de datos históricos de métrica. Consulta la [página de Métricas históricas][30] para más información.
@@ -139,28 +147,31 @@ Para cualquier clave concreta de etiqueta, puedes:
[Más información sobre el etiquetado][5].
-## Activos relacionados con métricas
+### Activos relacionados con métricas
{{< img src="metrics/summary/related_assets_dashboards.png" alt="Activos relacionados para un nombre de métricas especificado" style="width:80%;">}}
Para determinar el valor de cualquier nombre de métrica para tu organización, utiliza Activos relacionados de métricas. Los activos relacionados de métricas se refieren a cualquier dashboard, notebook, monitor, o SLO que consulta una métrica en particular.
-1. Desplázate hasta la parte inferior del panel lateral de detalles de la métrica hasta la sección "Related Assets" (Activos relacionados).
-2. Haz clic en el botón desplegable para ver el tipo de activo relacionado que te interesa (dashboards, monitores, notebooks, SLOs). Además, puedes utilizar la barra de búsqueda para validar activos específicos.
+1. Desplázate hasta la parte inferior del panel lateral de detalles de la métrica, hasta la sección **Recursos relacionados**.
+2. Haz clic en el botón desplegable para ver el tipo de recurso relacionado que te interesa en (dashboards, monitores, notebooks, SLOs). Además, puedes utilizar la barra de búsqueda para validar activos específicos.
+
+## Explorador de la cardinalidad de etiquetas de métricas personalizadas
+{{< img src="metrics/tagsexplorer.png" alt="Explorador de la cardinalidad de etiquetas de métricas personalizadas para el nombre de una métrica que presenta picos" style="width:80%;">}}
+Para determinar por qué un nombre de métrica concreto está emitiendo un gran número de métricas personalizadas, o tiene picos, utiliza el explorador de la cardinalidad de etiquetas de métricas personalizadas. Esta opción te ayuda a identificar las claves de etiqueta que provocan el pico, que puedes excluir inmediatamente utilizando Metrics without LimitsTM para ahorrar costes.
## Metrics without LimitsTM
Metrics without LimitsTM te proporciona control sobre el tamaño de tus métricas personalizadas sin necesidad de realizar cambios en el Agent o a nivel de código.
**Nota:** Metrics without LimitsTM solo está disponible para métricas personalizadas.
-Puedes configurar etiquetas mediante el botón de configuración de etiquetas de métrica en bloque o el botón **Manage Tags** (Gestionar etiquetas) del panel lateral de detalles de métrica.
+Puedes [configurar etiquetas en bloque](#configuration-of-multiple-metrics) accediendo a **Configurar métricas -> Gestionar etiquetas** en la [página de Métricas][34] o haciendo clic en el botón **Manage Tags** (Gestionar etiquetas) del panel lateral de detalles de una métrica.
{{< img src="metrics/distributions/managetags.png" alt="Configuración de etiquetas en una distribución" style="width:80%;">}}
1. Haz clic en el nombre de tu métrica de distribución personalizada en la tabla **Metrics Summary** (Resumen de métricas) para abrir el panel lateral de detalles de métricas.
2. Haz clic en el botón **Gestionar etiquetas** para abrir el modal de configuración de etiquetas.
-
3. Seleccione **Include tags...** o **Exclude tags...** (Incluir etiquetas... o Excluir etiquetas...) para personalizar las etiquetas que deseas o no consultar. Para más información sobre la configuración de etiquetas, consulta la documentación de [Metrics without Limits][10].
4. Previsualiza los efectos de tu configuración de etiqueta propuesta con el estimador de cardinalidad antes de seleccionar **Save** (Guardar).
@@ -170,46 +181,33 @@ Puedes configurar etiquetas mediante el botón de configuración de etiquetas de
Una vez que se ha configurado tu métrica con Metrics without LimitsTM, puedes ver qué etiquetas siguen siendo consultables (las que contribuyen al volumen _Indexed Custom Metrics_). Y puedes volver a todas las etiquetas enviadas e ingeridas originalmente que contribuyen a tu volumen _Ingested Custom Metrics_.
-### Optimizar tu métrica con agregaciones en Modo Avanzado
-
-Para métricas personalizadas de tipo count, gauge o rate, puedes refinar aún más las configuraciones de tus métricas incluyendo opcionalmente agregaciones adicionales con el modo avanzado de Metrics without LimitsTM. Por defecto, Datadog almacena la combinación de agregación más consultada en función del tipo de métrica para preservar la precisión matemática de la consulta de tu métrica configurada, como se indica a continuación:
-
-- Los conteos/tasas de métricas se pueden consultar con agregaciones de tiempo/espacio de tipo `SUM`
-- Las gauge configuradas se pueden consultar en agregaciones de tiempo/espacio de `AVG`
-
-{{< img src="metrics/summary/customize_aggr_docs.jpg" alt="Ajusta las agregaciones en counts, tasas y gauges" style="width:80%;">}}
-
-Hay más agregaciones disponibles que pueden serte útiles. Puedes añadir o eliminar agregaciones en cualquier momento sin necesidad de realizar cambios en el Agent o en el código.
-
-**Nota**: La configuración de tu métrica count, rate o gauge y la eliminación de una agregación pueden afectar a los dashboards y monitores existentes.
-
### Definiciones del origen de una métrica
Esta tabla muestra la correspondencia entre el origen de una métrica tal y como se ve en la faceta y el lugar desde el que se envió:
| Origen de una métrica | Enviada desde |
| ------------------------| ----------------------------------------------------------------------------- |
-| Catálogo de APIs | Series temporales enviadas por el producto [API Catalog][13] de Datadog desde el endpoint APIM.
+| Catálogo de APIs | Series temporales enviadas por el producto [Catálogo de software][13] de Datadog desde el endpoint de APIM.
| APM | Series temporales enviadas por el producto APM de Datadog para métricas generadas a partir de métricas de trazas (traces) y tramos.
| Agent | Series temporales enviadas por el Datadog Agent, recopiladas de [integraciones del Agent][10], [integraciones incorporadas][9], [DogStatsD][32], o [checks personalizados del Agent][33].
-| CSM | Series temporales enviadas por el producto [Cloud Security Monitoring][14] de Datadog.
+| Cloud Security | Series temporales enviadas por el producto [Cloud Security][14] de Datadog.
| Integraciones en la nube | Series temporales recopiladas de proveedores de nube como AWS, Azure y Google Cloud, etc. de sus respectivas integraciones.
| DBM | Series temporales enviadas por el producto [Database Monitoring][15] de Datadog, que incluyen información sobre las actividades/consultas/bloqueos de MySQL, Oracle y Postgres.
| DSM | Series temporales enviadas por el producto [Data Streams Monitoring][16] de Datadog, para métricas generadas a partir de tramos y trazas de DSM.
| Datadog Exporter | Series temporales enviadas por el [OpenTelemetry Collector][17] o el [Datadog Exporter][18].
| Plataforma Datadog | Series temporales enviadas por métricas de admisión que se utilizan para [informar sobre el uso de métricas][11].
| Eventos | Series temporales generadas a partir de la plataforma de eventos de Datadog.
-| Observabilidad de LLM | Series temporales emitidas por el producto LLM Observability utilizando el servicio `lmobs_to_metrics`.
+| LLM Observability | Series temporales emitidas por el producto LLM Observability utilizando el servicio `lmobs_to_metrics`.
| Logs | Series temporales generadas a partir de la plataforma de [logs][28] de Datadog.
| API de métricas | Series temporales enviadas mediante el [endpoint de ingesta OTLP][21] y el receptor OTel con una contrapartida o con puntos en la integración Datadog para obtener métricas del uso estimado o el cliente API de Datadog.
-| NPM | Series temporales enviadas por el producto [Network Performance Monitoring][19] de Datadog.
+| CNM | Series temporales enviadas por el producto [Cloud Network Monitoring][19] de Datadog.
| Observability Pipelines | Series temporales enviadas por los [pipelines de observabilidad][20] de Datadog, incluidas las métricas de errores y rendimiento.
| Otro | Series temporales que no tienen una contrapartida en la integración DD.
| Procesos | Series temporales generadas a partir del producto [Processes][22] de Datadog.
| RUM | Series temporales generadas a partir del producto [Real User Monitoring][23] de Datadog.
| Integraciones SAAS | Series de tiempo recopiladas de plataformas SAAS populares como Slack, Docker, PagerDuty, etc.
| Serverless | Series temporales enviadas por la plataforma [serverless][24] de Datadog, incluyendo Function, App Services, Cloud Run y Container App Metrics.
-| Catálogo de servicios | Series temporales enviadas por el producto [Service Catalog][25] de Datadog, incluidas las métricas de [Scorecard][29].
+| Software Catalog | Series temporales enviadas por el producto [Catálogo de software][25] de Datadog, incluyendo las métricas de [scorecards][29].
| Synthetic Monitoring | Métricas de monitorización y tests continuos de Synthetic, generadas a partir del producto [Synthetic Monitoring][26] de Datadog.
| USM | Series temporales generadas a partir del producto [Universal Service Monitoring][27] de Datadog.
@@ -230,24 +228,25 @@ Esta tabla muestra la correspondencia entre el origen de una métrica tal y como
[10]: /es/integrations/agent_metrics/
[11]: /es/account_management/billing/usage_metrics/
[12]: /es/metrics/summary/#metric-origin-definitions
-[13]: /es/api_catalog/
+[13]: /es/software_catalog/endpoints/
[14]: /es/security/cloud_security_management/
[15]: /es/database_monitoring/
[16]: /es/data_streams/
-[17]: /es/opentelemetry/collector_exporter/otel_collector_datadog_exporter/?tab=onahost
+[17]: /es/opentelemetry/setup/collector_exporter/
[18]: /es/opentelemetry/collector_exporter/
-[19]: /es/network_monitoring/performance/
+[19]: /es/network_monitoring/cloud_network_monitoring/
[20]: /es/observability_pipelines/
-[21]: /es/opentelemetry/interoperability/otlp_ingest_in_the_agent/?tab=host
+[21]: /es/opentelemetry/setup/otlp_ingest_in_the_agent/
[22]: /es/integrations/process/
[23]: /es/monitors/types/real_user_monitoring/
[24]: /es/serverless/
-[25]: /es/service_catalog/
+[25]: /es/software_catalog/
[26]: /es/synthetics/
[27]: /es/universal_service_monitoring/
[28]: /es/logs/
-[29]: /es/service_catalog/scorecards/
+[29]: /es/software_catalog/scorecards/
[30]: /es/metrics/custom_metrics/historical_metrics/#bulk-configuration-for-multiple-metrics
[31]: /es/metrics/distributions/#bulk-configuration-for-multiple-metrics
[32]: /es/metrics/custom_metrics/dogstatsd_metrics_submission/
-[33]: /es/metrics/custom_metrics/agent_metrics_submission/
\ No newline at end of file
+[33]: /es/metrics/custom_metrics/agent_metrics_submission/
+[34]: https://app.datadoghq.com/metric/overview
\ No newline at end of file
diff --git a/content/es/network_monitoring/devices/profiles.md b/content/es/network_monitoring/devices/profiles.md
index 8c54b3623a081..7bb1759b5fd61 100644
--- a/content/es/network_monitoring/devices/profiles.md
+++ b/content/es/network_monitoring/devices/profiles.md
@@ -13,19 +13,29 @@ title: Perfiles NDM
## Información general
-La monitorización de dispositivos de red utiliza perfiles para indicar al Datadog Agent las métricas y las etiquetas (tags) asociadas que debe recopilar. Un perfil es una colección de identificadores de objetos asociados a un dispositivo.
+Network Device Monitoring utiliza perfiles para indicar al Datadog Agent las métricas y las etiquetas (tags) asociadas que debe recopilar. Un perfil es una colección de {{< tooltip text="OID (Identificadores de objetos)" tooltip="ID o dirección única de un dispositivo, que cuando se sondea devuelve el código de respuesta de ese valor." >}} asociados a un dispositivo.
## Configuración
+Puedes activar perfiles de dispositivos en Datadog utilizando el flujo de trabajo recomendado basado en la GUI (Gestor de perfiles SNMP) o a través de una configuración avanzada:
+
+**[Gestor de perfiles SNMP][9] (recomendado)**
+- Interfaz de usuario guiada para personalizar las métricas recopiladas de dispositivos de red, directamente desde la página de configuración de [Network Device Monitoring][8].
+- Elimina la necesidad de buscar identificadores de objetos (OID) en la documentación de los proveedores, recomendando automáticamente una lista de métricas relevantes y legibles por humanos.
+- No requiere configuración manual con archivos `.yaml`.
+- Aplica los cambios a escala a todos los Agents en un solo clic con la [configuración remota][11].
+
+**[Configuración avanzada][10]**
+- Crea y activa perfiles personalizados manualmente con archivos `.yaml`, especificando las métricas y las etiquetas (tags) del dispositivo.
+- Ideal para entornos grandes o dinámicos.
+
Por defecto, se cargan todos los perfiles del directorio de configuración del Agent. Para personalizar los perfiles específicos de la colección, haz referencia explícita a ellos por nombre de archivo en `definition_file` o proporciona una lista en línea en `definition`. Se puede hacer referencia a cualquiera de los perfiles de Datadog por su nombre. Se puede hacer referencia a perfiles personalizados adicionales por la ruta del archivo en la configuración o colocarlos en el directorio de configuración.
**Nota**: El perfil genérico es [generic-device.yaml][1], que admite enrutadores, conmutadores y otros dispositivos.
-
+## Términos y conceptos
-### Dispositivos sysObjectId asignados
+### Dispositivos sysOID asignados
Los perfiles permiten a la monitorización de dispositivos de red reutilizar las definiciones de métricas en varios tipos o instancias de dispositivos. Los perfiles definen qué métricas recopilar y cómo transformarlas en métricas de Datadog. Se espera que cada perfil monitorice una clase de dispositivos similares del mismo proveedor. El Datadog Agent los utiliza automáticamente comparando los sysObjectId del dispositivo de red con aquellos definidos en el archivo del perfil.
@@ -54,7 +64,7 @@ instances:
- ip_address: 192.168.34.11
profile: my-profile2
- ip_address: 192.168.34.13
- # Para este dispositivo, el Agent obtendrá el sysObjectID del dispositivo y utilizará la coincidencia más cercana
+ # For this device, the Agent will fetch the sysObjectID of the device and use the closest match
```
### Definición de métricas por perfil
@@ -65,7 +75,7 @@ Para ver más perfiles proporcionados por Datadog, consulta el [repositorio de G
### Definición de metadatos por perfil
-En la sección de metadatos de los perfiles, puedes definir dónde y cómo se recopilan los metadatos. Los valores pueden ser estáticos o proceder de un valor de identificador de objeto.
+En la sección de metadatos de los perfiles, puedes definir dónde y cómo se recopilan los metadatos. Los valores pueden ser estáticos o proceder de un valor de identificador de objeto (OID).
Para ver los campos admitidos, consulta la sección de [metadatos de dispositivos][4].
En la versión 7.52 y posteriores del Datadog Agent, existe un campo `device_type` para metadatos de dispositivos. Puede configurarse manualmente en el perfil y utilizarse para filtrar tipos específicos de dispositivos. Los valores aceptados son:
@@ -86,7 +96,7 @@ En la versión 7.52 y posteriores del Datadog Agent, existe un campo `device_typ
Para obtener más información sobre los formatos de los perfiles, consulta [Referencia de formatos de perfiles][5].
-## Para leer más
+## Referencias adicionales
{{< partial name="whats-next/whats-next.html" >}}
@@ -97,4 +107,8 @@ Para obtener más información sobre los formatos de los perfiles, consulta [Ref
[4]: https://github.com/DataDog/datadog-agent/blob/main/pkg/networkdevice/metadata/payload.go#L51-L76
[5]: https://datadoghq.dev/integrations-core/tutorials/snmp/profile-format/
[6]: https://app.datadoghq.com/devices/
-[7]: /es/network_monitoring/devices/guide/device_profiles/
\ No newline at end of file
+[7]: /es/network_monitoring/devices/guide/device_profiles/
+[8]: https://app.datadoghq.com/devices/profiles
+[9]: /es/network_monitoring/devices/guide/device_profiles/
+[10]: /es/network_monitoring/devices/guide/build-ndm-profile/
+[11]: /es/agent/remote_config/
\ No newline at end of file
diff --git a/content/es/network_monitoring/netflow/_index.md b/content/es/network_monitoring/netflow/_index.md
index 917f0d14140c4..cfeb6d0ee6a89 100644
--- a/content/es/network_monitoring/netflow/_index.md
+++ b/content/es/network_monitoring/netflow/_index.md
@@ -1,4 +1,6 @@
---
+aliases:
+- /es/network_monitoring/devices/netflow/
further_reading:
- link: /network_monitoring/devices/profiles
tag: Documentación
@@ -9,7 +11,6 @@ further_reading:
- link: https://www.datadoghq.com/blog/diagnose-network-performance-with-snmp-trap-monitoring/
tag: Blog
text: Monitorizar y diagnosticar problemas de rendimiento de red con SNMP Traps
-is_beta: true
title: Monitorización de NetFlow
---
@@ -36,18 +37,22 @@ network_devices:
netflow:
enabled: true
listeners:
- - flow_type: netflow9 # opciones: netflow5, netflow9, ipfix, sflow5
- port: 2055 # los dispositivos se deben configurar con el mismo número de puerto
+ - flow_type: netflow9 # choices: netflow5, netflow9, ipfix, sflow5
+ port: 2055 # devices need to be configured to the same port number
- flow_type: netflow5
port: 2056
- flow_type: ipfix
port: 4739
- flow_type: sflow5
port: 6343
+ ## Set to true to enable reverse DNS enrichment of private source and destination IP addresses in NetFlow records
+ reverse_dns_enrichment_enabled: false
```
Luego de guardar los cambios, [reinicia el Agent][4].
+**Nota**: Asegúrate de que tus [reglas de firewall][9] permiten el tráfico UDP entrante en los puertos configurados.
+
## Agregación
El Datadog Agent añade automáticamente los datos recibidos a NetFlow para limitar el número de registros enviados a la plataforma, al mismo tiempo que conserva la mayor parte de la información. Por defecto, los registros de flujos que tienen los mismos identificadores, como `source`, `destination address`, `port` y `protocol`, se agregan juntos en intervalos de cinco minutos. Además, el Datadog Agent puede detectar puertos efímeros y eliminarlos. Como resultado, es posible que aparezcan flujos con `port:*`.
@@ -78,6 +83,18 @@ En la pestaña **Configuración** en NetFlow, haz clic en **Add Enrichment** (A
{{< img src="network_device_monitoring/netflow/new_enrichment.png" alt="Modal de Asignación de nuevo enriquecimiento en la pestaña de configuración de NetFlow" width="80%" >}}
+### Enriquecimiento de IP privada con DNS inverso
+
+Activa el enriquecimiento de IP privada con DNS inverso para realizar búsquedas de DNS de nombres de host asociados a direcciones IP de origen o destino. Cuando se activa, el Agent realiza búsquedas con DNS inverso en IP de origen y destino dentro de rangos de direcciones privadas, enriqueciendo los registros NetFlow con los nombres de host correspondientes.
+
+Por [defecto][7], el enriquecimiento de IP con DNS inverso en tu archivo `datadog.yaml` está deshabilitado. Para habilitarlo, consulta la sección [Configuración](#configuration) de esta página.
+
+Busca **DNS** en la agrupación de Flujo de la sección de facetas para encontrar los flujos asociados con el enriquecimiento de IP con DNS inverso:
+
+{{< img src="network_device_monitoring/netflow/dns_ip_enrichment.png" alt="Captura de pantalla del destino DNS inverso y de las facetas de origen" width="100%" >}}
+
+**Nota**: Las entradas de DNS inverso se almacenan en caché y están sujetas a limitaciones de frecuencia para minimizar las consultas DNS y reducir la carga de los servidores DNS. Para obtener más información sobre las opciones de configuración, incluyendo la modificación del almacenamiento en caché predeterminado y la limitación de frecuencia, consulta el [archivo de configuración completo][8].
+
## Visualización
Puedes acceder a los datos recopilados por NetFlow Monitoring en la página de [**NetFlow**][5]. Pasa el cursor sobre un flujo de la lista para obtener información adicional sobre hosts, pods y contenedores, y acceder a las conexiones de red relacionadas.
@@ -155,6 +172,7 @@ Además de los campos, también puedes utilizar facetas predefinidas para empeza
| MAC de destino | La dirección MAC (Media Access Control) asociada a la IP de destino. |
| Máscara de destino | La máscara de subred asociada a la IP de destino. |
| Puerto de destino | El número del puerto de destino. |
+| Nombre de host DNS inverso de destino | El nombre de host DNS asociado a la IP de destino. |
| Código ISO de subdivisión del destino | El código ISO que representa la subdivisión (como estado o provincia) asociada a la IP de destino. |
| Nombre de la subdivisión de destino | El nombre de la subdivisión (como estado o provincia) asociada a la IP de destino. |
| Zona horaria de destino | La zona horaria asociada a la IP de destino. |
@@ -183,6 +201,7 @@ Además de los campos, también puedes utilizar facetas predefinidas para empeza
| MAC de origen | La dirección de MAC (Media Access Control) asociada a la IP de origen. |
| Máscara de origen | La máscara de subred asociada a la IP de origen. |
| Puerto de origen | El número del puerto de origen. |
+| Nombre de host DNS inverso de origen | El nombre de host DNS asociado a la IP de origen. |
| Código ISO de la subdivisión de origen | El código ISO que representa la subdivisión (como estado o provincia) asociada a la IP de origen. |
| Nombre de la subdivisión de origen | El nombre de la subdivisión (como estado o provincia) asociada a la IP de origen. |
| Zona horaria de origen | La zona horaria asociada a la IP de origen. |
@@ -202,7 +221,7 @@ Además, puedes consultar y visualizar **Bytes (ajustados) (@adjusted_bytes)** y
Para visualizar los bytes/paquetes sin procesar (muestreados) enviados por tus dispositivos, puedes consultar **Bytes (muestreados) (@bytes)** y **Paquetes (muestreados) (@packets)** en dashboards y notebooks.
-## Retención
+## Conservación
Los datos de NetFlow se conservan durante 30 días por defecto, con opciones de conservación de 15, 30, 60 y 90 días.
@@ -263,4 +282,7 @@ Utiliza el comando `netstat -s` para ver si hay algún paquete UDP perdido:
[3]: /es/agent/configuration/agent-configuration-files/?tab=agentv6v7#agent-main-configuration-file
[4]: /es/agent/configuration/agent-commands/?tab=agentv6v7#start-stop-and-restart-the-agent
[5]: https://app.datadoghq.com/devices/netflow
-[6]: /es/monitors/types/netflow/
\ No newline at end of file
+[6]: /es/monitors/types/netflow/
+[7]: https://github.com/DataDog/datadog-agent/blob/f6ae461a7d22aaf398de5a94d9330694d69560d6/pkg/config/config_template.yaml#L4201
+[8]: https://github.com/DataDog/datadog-agent/blob/f6ae461a7d22aaf398de5a94d9330694d69560d6/pkg/config/config_template.yaml#L4203-L4275
+[9]: /es/network_monitoring/devices/troubleshooting#traps-or-flows-not-being-received-at-all
\ No newline at end of file
diff --git a/content/es/notebooks/advanced_analysis/_index.md b/content/es/notebooks/advanced_analysis/_index.md
index ecf4eccb16f4d..3d69c570ce001 100644
--- a/content/es/notebooks/advanced_analysis/_index.md
+++ b/content/es/notebooks/advanced_analysis/_index.md
@@ -15,10 +15,6 @@ Analysis Features para notebooks no está disponible en el }}
- Advanced Analysis está en vista previa. Para activarlo, contacta con tu asesor de clientes.
-{{< /callout >}}
-
## Información general
La función de análisis de los notebooks permite realizar análisis avanzados de los datos de Datadog. Puedes unir varios conjuntos de datos, encadenar consultas y transformar los datos mediante transformaciones predefinidas o SQL, sin perder ninguna de las funciones que ofrecen los notebooks.
@@ -74,8 +70,8 @@ Puedes añadir o modificar columnas en tu celda de fuente de datos. Hay dos form
Puedes tomar consultas existentes del Log Explorer que incluyan [Campos calculados][4] y abrirlas en notebooks. Para transferir estas consultas desde el Log Explorer, haz clic en **More** (Más) y selecciona **Analyze in Notebooks** (Analizar en notebooks). Los campos calculados se convierten automáticamente en una celda de transformación.
También puedes crear campos calculados directamente en un notebook para definir un campo calculado a partir de fuentes de datos existentes. Estos campos pueden reutilizarse en análisis posteriores:
-1. Abre un espacio de trabajo con una fuente de datos.
-1. Añade una [celda de transformación](#transformation-cell).
+1. Abre un Workspace con una fuente de datos.
+1. Añade una [Celda de transformación](#transformation-cell).
1. Haz clic en **More operations** (Más operaciones).
1. Selecciona **Calculate** (Calcular).
diff --git a/content/es/opentelemetry/integrations/runtime_metrics/_index.md b/content/es/opentelemetry/integrations/runtime_metrics/_index.md
index 911dff290aa12..5dcff45523bfe 100644
--- a/content/es/opentelemetry/integrations/runtime_metrics/_index.md
+++ b/content/es/opentelemetry/integrations/runtime_metrics/_index.md
@@ -1,44 +1,249 @@
---
aliases:
- /es/opentelemetry/runtime_metrics/
+- /es/opentelemetry/integrations/runtime_metrics/go/
+- /es/opentelemetry/integrations/runtime_metrics/dotnet/
+- /es/opentelemetry/integrations/runtime_metrics/java/
+further_reading:
+- link: /tracing/metrics/runtime_metrics/
+ tag: Documentación
+ text: Métricas de tiempo de ejecución de APM
+- link: /opentelemetry/mapping/metrics_mapping/
+ tag: Documentación
+ text: Asignación de métricas de OpenTelemetry
title: Métricas de tiempo de ejecución de OpenTelemetry
-type: multi-code-lang
---
## Información general
-Las métricas de tiempo de ejecución son métricas de aplicación sobre el uso de memoria, la recopilación de elementos no usados o paralelización. Las bibliotecas de rastreo de Datadog proporcionan [la recopilación de métricas de tiempo de ejecución][5] para cada lenguaje compatible pero, además, OpenTelemetry (OTel) recopila métricas de tiempo de ejecución, que pueden ser enviadas a Datadog a través de los SDKs de OpenTelemetry.
+Las métricas de tiempo de ejecución proporcionan información sobre el rendimiento de las aplicaciones, incluido el uso de memoria, la recopilación de elementos no usados y la paralelización. Las bibliotecas de rastreo de Datadog ofrece [recopilación de métricas de tiempo de ejecución][5] para cada lenguaje compatible, y OpenTelemetry (OTel) también recopila métricas de tiempo de ejecución compatibles que pueden enviarse a Datadog a través de los SDKs de OpenTelemetry.
-Datadog recopila métricas de tiempo de ejecución de OpenTelemetry en los siguientes lenguajes:
+## Compatibilidad
+
+Datadog es compatible con las métricas en tiempo de ejecución de OpenTelemetry para los siguientes lenguajes:
- Java
- .NET
- Go
-## Convenciones de nomenclatura de la métrica
+Para más detalles sobre la asignación de métricas de host y contenedor, véase [OpenTelemetry Metrics Mapping][1].
-La métricas de tiempo de ejecución siguen diferentes convenciones de nomenclatura en función de su fuente: OpenTelemetry Collector y Exportador de Datadog, ingesta OTLP del Datadog Agent, o bibliotecas de rastreo de Datadog. Al utilizar las métricas de tiempo de ejecución de OpenTelemetry con Datadog, recibirás tanto las métricas de tiempo de ejecución original de OpenTelemetry como las métricas de tiempo de ejecución de Datadog asignadas para métricas equivalente. Las métricas de tiempo de ejecución tienen los siguientes prefijos que indican su fuente:
+## Instrucciones de instalación
-| OTel Collector y Exportador de Datadog | Ingesta OTLP de Datadog Agent | Biblioteca de rastreo de Datadog |
-| --- | --- | --- |
-| `otel.process.runtime.*` | `process.runtime.*` | `runtime..*` |
+### 1. Requisitos previos
+
+- Has configurado correctamente [las métricas de OpenTelemetry para enviarlas a Datadog][2].
+- Has instalado la [integración del lenguaje correspondiente en Datadog][3].
+
+### 2. Configurar la aplicación
+
+Selecciona tu lenguaje para ver las instrucciones de configuración del SDK de OpenTelemetry para enviar métricas en tiempo de ejecución:
+
+{{< tabs >}}
+{{% tab "Java" %}}
+
+#### Instrumentación automática
+
+Si utilizas [instrumentación automática de OpenTelemetry][3] para aplicaciones Java, las métricas de tiempo de ejecución están activadas por defecto.
+
+#### Instrumentación manual
+
+Si utilizas [instrumentación manual de OpenTelemetry][4], sigue las guías para tu versión de Java:
+- [Java 8][5]
+- [Java 17][6]
+
+[3]: https://opentelemetry.io/docs/instrumentation/java/automatic/
+[4]: https://opentelemetry.io/docs/instrumentation/java/manual/
+[5]: https://github.com/open-telemetry/opentelemetry-java-instrumentation/tree/main/instrumentation/runtime-telemetry/runtime-telemetry-java8/library
+[6]: https://github.com/open-telemetry/opentelemetry-java-instrumentation/tree/main/instrumentation/runtime-telemetry/runtime-telemetry-java17/library
+
+{{% /tab %}}
+
+{{% tab "Go" %}}
+
+Las aplicaciones de OpenTelemetry Go son [instrumentadas manualmente][3]. Para activar las métricas en tiempo de ejecución, consulta la documentación del [paquete de tiempo de ejecución][4].
+
+[3]: https://opentelemetry.io/docs/instrumentation/go/manual/
+[4]: https://pkg.go.dev/go.opentelemetry.io/contrib/instrumentation/runtime
+
+{{% /tab %}}
+
+{{% tab ".NET" %}}
+
+La versión mínima compatible del SDK de .NET OpenTelemetry es
1.5.0
+
+#### Instrumentación automática
+
+Si utilizas [instrumentación automática de OpenTelemetry][3] para aplicaciones .NET, las métricas de tiempo de ejecución están activadas por defecto.
+
+#### Instrumentación manual
+
+Si utilizas [instrumentación manual de OpenTelemetry][4], consulta la documentación de [biblioteca OpenTelemetry.Instrumentation.Runtime][5].
+
+#### Intervalo de exportación de métricas
-**Nota**: Las métricas de tiempo de ejecución de OpenTelemetry se asignan a Datadog por el nombre de métrica. No cambies el nombre de asignación de las métricas de host para las métricas de tiempo de ejecución de OpenTelemetry o se romperá.
+El intervalo de exportación predeterminado de métricas para el SDK de .NET OTel es diferente del intervalo predeterminado del SDK de Datadog .NET. Datadog recomienda configurar la variable de entorno [OTEL_METRIC_EXPORT_INTERVAL][7] en tu servicio de .NET para que coincida con el intervalo de exportación predeterminado de métricas de Datadog:
-Para más información sobre la asignación de métricas de host y contenedor, consulta [Asignación de métricas de OpenTelemetry][1].
+```
+OTEL_METRIC_EXPORT_INTERVAL=10000
+```
-## Configuración
+[3]: https://opentelemetry.io/docs/instrumentation/net/automatic/
+[4]: https://opentelemetry.io/docs/instrumentation/net/manual/
+[5]: https://github.com/open-telemetry/opentelemetry-dotnet-contrib/tree/main/src/OpenTelemetry.Instrumentation.Runtime
+[7]: https://opentelemetry.io/docs/specs/otel/configuration/sdk-environment-variables/#periodic-exporting-metricreader
-Selecciona tu lenguaje para ver las instrucciones de instalación y configuración del SDK de OpenTelemetry para enviar métricas de tiempo de ejecución:
+{{% /tab %}}
-{{< partial name="opentelemetry/otel-runtime-metrics.html" >}}
-
+{{< /tabs >}}
## Ver dashboards de métricas de tiempo de ejecución
-Una vez finalizada la configuración, ve tus métricas de tiempo de ejecución en la página de detalles del servicio (consulta el ejemplo de Java más abajo), la pestaña de métricas de la gráfica de llamas y en [dashboards de tiempo de ejecución predeterminados][7].
+Una vez finalizada la configuración, puedes ver las métricas de tiempo de ejecución en:
+- La página de detalles del servicio (véase el ejemplo de Java a continuación)
+- La pestaña de métricas de la gráfica de llamas
+- [Dashboard de tiempo de ejecución][7] por defecto
{{< img src="opentelemetry/otel_runtime_metrics_service_page.png" alt="Página de servicios que muestra las métricas de tiempo de ejecución de OpenTelemetry en la pestaña de Métricas de JVM" style="width:100%;" >}}
-[1]: /es/opentelemetry/guide/metrics_mapping/
+## Datos recopilados
+
+Cuando se utilizan las métricas en tiempo de ejecución de OpenTelemetry con Datadog, se reciben ambas:
+- Métricas originales en tiempo de ejecución de OpenTelemetry
+- Métricas de tiempo de ejecución de Datadog asignadas para métricas equivalentes
+
+Las métricas en tiempo de ejecución de OpenTelemetry tienen los siguientes prefijos basados en su fuente:
+
+| Fuente | Prefijo |
+| --- | --- |
+| [OTel Collector Datadog Exporter][100] | `otel.process.runtime.*` |
+| [Datadog Agent OTLP Ingest][101] | `process.runtime.*` |
+
+Las siguientes tablas enumeran las métricas de tiempo de ejecución de Datadog que son compatibles a través de la asignación de OpenTelemetry. "N/A" indica que no hay métrica equivalente de OpenTelemetry disponible.
+
+ Las métricas en tiempo de ejecución de OpenTelemetry se asignan a Datadog por el nombre métrica. No cambies el nombre de las métricas de host por métricas de tiempo de ejecución de OpenTelemetry, ya que esto rompe la asignación.
+
+[100]: /es/opentelemetry/setup/collector_exporter/
+[101]: /es/opentelemetry/setup/otlp_ingest_in_the_agent
+
+{{< tabs >}}
+{{% tab "Java" %}}
+
+| Métrica de Datadog | Descripción | Métrica de OpenTelemetry |
+| --- | --- | --- |
+| `jvm.heap_memory` | El total de memoria heap utilizada en Java. | `process.runtime.jvm.memory.usage`
`jvm.memory.used` |
+| `jvm.heap_memory_committed` | El total de memoria heap comprometida en Java para ser utilizada. | `process.runtime.jvm.memory.committed`
`jvm.memory.committed` |
+| `jvm.heap_memory_init` | La memoria heap inicial de Java asignada. | `process.runtime.jvm.memory.init`
`jvm.memory.init` |
+| `jvm.heap_memory_max` | La memoria heap máxima disponible en Java. | `process.runtime.jvm.memory.limit`
`jvm.memory.limit` |
+| `jvm.non_heap_memory` | El total de memoria no heap de Java utilizada. La memoria no heap es: `Metaspace + CompressedClassSpace + CodeCache`. | `process.runtime.jvm.memory.usage`
`jvm.memory.used` |
+| `jvm.non_heap_memory_committed` | El total de memoria no heap comprometida en Java para ser utilizada. | `process.runtime.jvm.memory.committed`
`jvm.memory.committed` |
+| `jvm.non_heap_memory_init` | La memoria no heap inicial de Java asignada. | `process.runtime.jvm.memory.init`
`jvm.memory.init` |
+| `jvm.non_heap_memory_max` | La memoria no heap máxima disponible en Java. | `process.runtime.jvm.memory.limit`
`jvm.memory.limit` |
+| `jvm.gc.old_gen_size` | El uso actual de memoria heap de Java del grupo de memoria Old Generation. | `process.runtime.jvm.memory.usage`
`jvm.memory.used` |
+| `jvm.gc.eden_size` | El uso actual de memoria heap de Java del grupo de memoria Eden. | `process.runtime.jvm.memory.usage`
`jvm.memory.used` |
+| `jvm.gc.survivor_size` | El uso actual de memoria heap de Java del grupo de memoria Survivor. | `process.runtime.jvm.memory.usage`
`jvm.memory.used` |
+| `jvm.gc.metaspace_size` | El uso actual de memoria no heap de Java del grupo de memoria Metaspace. | `process.runtime.jvm.memory.usage`
`jvm.memory.used` |
+| `jvm.thread_count` | El número de subprocesos en directo. | `process.runtime.jvm.threads.count`
`jvm.thread.count` |
+| `jvm.loaded_classes` | Número de clases cargadas actualmente. | `process.runtime.jvm.classes.current_loaded`
`jvm.class.count` |
+| `jvm.cpu_load.system` | Uso reciente de la CPU para todo el sistema. | `process.runtime.jvm.system.cpu.utilization`
`jvm.system.cpu.utilization` |
+| `jvm.cpu_load.process` | Uso reciente de la CPU en proceso. | `process.runtime.jvm.cpu.utilization`
`jvm.cpu.recent_utilization` |
+| `jvm.buffer_pool.direct.used` | Medida de la memoria utilizada por buffers. | `process.runtime.jvm.buffer.usage`
`jvm.buffer.memory.usage` |
+| `jvm.buffer_pool.direct.count` | Número de buffers directos en el grupo. | `process.runtime.jvm.buffer.count`
`jvm.buffer.count` |
+| `jvm.buffer_pool.direct.limit` | Medida de la capacidad total de memoria de buffers directos. | `process.runtime.jvm.buffer.limit`
`jvm.buffer.memory.limit` |
+| `jvm.buffer_pool.mapped.used` | Medida de la memoria utilizada por los buffers asignados. | `process.runtime.jvm.buffer.usage`
`jvm.buffer.memory.usage` |
+| `jvm.buffer_pool.mapped.count` | Número de buffers asignados en el grupo. | `process.runtime.jvm.buffer.count`
`jvm.buffer.count` |
+| `jvm.buffer_pool.mapped.limit` | Medida de la capacidad total de memoria de buffers asignados. | `process.runtime.jvm.buffer.limit`
`jvm.buffer.memory.limit` |
+| `jvm.gc.parnew.time` | El tiempo acumulado aproximado de recopilación de elementos no usados transcurrido. | N/A |
+| `jvm.gc.cms.count` | El número total de recopilaciones de elementos no usados que se han producido. | N/A |
+| `jvm.gc.major_collection_count` | El índice de las principales recopilaciones de elementos no usados. Configura `new_gc_metrics: true` para recibir esta métrica. | N/A |
+| `jvm.gc.minor_collection_count` | La tasa de recopilaciones secundarias de elementos no usados. Establece `new_gc_metrics: true` para recibir esta métrica. | N/A |
+| `jvm.gc.major_collection_time` | La fracción de tiempo empleado en la recopilación principal de elementos no usados. Configura `new_gc_metrics: true` para recibir esta métrica. | N/A |
+| `jvm.gc.minor_collection_time` | La fracción de tiempo empleado en la recopilación secundaria de elementos no usados. Configura `new_gc_metrics: true` para recibir esta métrica. | N/A |
+| `jvm.os.open_file_descriptors` | El número de descriptores de archivo abiertos. | N/A |
+
+{{% /tab %}}
+
+{{% tab "Go" %}}
+
+| Métrica de Datadog | Descripción | Métrica de OpenTelemetry |
+| --- | --- | --- |
+| `runtime.go.num_goroutine` | Número de goroutines generadas. | `process.runtime.go.goroutines` |
+| `runtime.go.num_cgo_call` | Número de llamadas CGO realizadas. |`process.runtime.go.cgo.calls` |
+| `runtime.go.mem_stats.lookups` | Número de búsquedas de punteros realizadas por el tiempo de ejecución. | `process.runtime.go.mem.lookups` |
+| `runtime.go.mem_stats.heap_alloc` | Bytes de objetos heap asignados. | `process.runtime.go.mem.heap_alloc` |
+| `runtime.go.mem_stats.heap_sys` | Bytes de memoria heap obtenidos del sistema operativo. | `process.runtime.go.mem.heap_sys` |
+| `runtime.go.mem_stats.heap_idle` | Bytes en tramos (spans) en reposo (no utilizados). | `process.runtime.go.mem.heap_idle` |
+| `runtime.go.mem_stats.heap_inuse` | Bytes de tramos en uso. | `process.runtime.go.mem.heap_inuse` |
+| `runtime.go.mem_stats.heap_released` | Bytes de memoria física devueltos al sistema operativo. | `process.runtime.go.mem.heap_released` |
+| `runtime.go.mem_stats.heap_objects` | Número de objetos heap asignados. | `process.runtime.go.mem.heap_objects` |
+| `runtime.go.mem_stats.pause_total_ns` | Nanosegundos acumulados en la recopilación de elementos no usados (GC). | `process.runtime.go.gc.pause_total_ns` |
+| `runtime.go.mem_stats.num_gc` | Número de ciclos de GC completados. | `process.runtime.go.gc.count` |
+| `runtime.go.num_cpu` | Número de CPUs detectadas por el tiempo de ejecución. | N/A |
+| `runtime.go.mem_stats.alloc` | Bytes de objetos heap asignados. | N/A |
+| `runtime.go.mem_stats.total_alloc` | Bytes acumulados asignados a objetos heap. | N/A |
+| `runtime.go.mem_stats.sys` | Total de bytes de memoria obtenidos del sistema operativo. | N/A |
+| `runtime.go.mem_stats.mallocs` | Recuento acumulativo de objetos heap asignados. | N/A |
+| `runtime.go.mem_stats.frees` | Recuento acumulativo de objetos heap liberados. | N/A |
+| `runtime.go.mem_stats.stack_inuse` | Bytes en tramos de stack. | N/A |
+| `runtime.go.mem_stats.stack_sys` | Bytes de memoria de stack obtenidos del sistema operativo. | N/A |
+| `runtime.go.mem_stats.m_span_inuse` | Bytes de las estructuras mspan asignadas. | N/A |
+| `runtime.go.mem_stats.m_span_sys` | Bytes de memoria obtenidos del sistema operativo para las estructuras mspan. | N/A |
+| `runtime.go.mem_stats.m_cache_inuse` | Bytes de estructuras mcache asignadas. | N/A |
+| `runtime.go.mem_stats.m_cache_sys` | Bytes de memoria obtenidos del sistema operativo para las estructuras mcache. | N/A |
+| `runtime.go.mem_stats.buck_hash_sys` | Bytes de memoria en tablas hash de buckets de perfiles. | N/A |
+| `runtime.go.mem_stats.gc_sys` | Bytes de memoria en metadatos de recopilación de elementos no usados. | N/A |
+| `runtime.go.mem_stats.other_sys` | Bytes de memoria en miscelánea fuera de heap. | N/A |
+| `runtime.go.mem_stats.next_gc` | Tamaño de heap objetivo del siguiente ciclo de GC. | N/A |
+| `runtime.go.mem_stats.last_gc` | Última recopilación de elementos no usados finalizada, en nanosegundos desde la epoch de UNIX. | N/A |
+| `runtime.go.mem_stats.num_forced_gc` | Número de ciclos de GC forzados por la aplicación que llama a la función de GC. | N/A |
+| `runtime.go.mem_stats.gc_cpu_fraction` | Fracción del tiempo de CPU disponible de este programa utilizado por la GC desde que se inició el programa. | N/A |
+| `runtime.go.gc_stats.pause_quantiles.min` | Distribución de los tiempos de pausa de la GC: valores mínimos. | N/A |
+| `runtime.go.gc_stats.pause_quantiles.25p` | Distribución de los tiempos de pausa de la GC: percentil 25. | N/A |
+| `runtime.go.gc_stats.pause_quantiles.50p` | Distribución de los tiempos de pausa de la GC: percentil 50. | N/A |
+| `runtime.go.gc_stats.pause_quantiles.75p` | Distribución de los tiempos de pausa de la GC: percentil 75. | N/A |
+| `runtime.go.gc_stats.pause_quantiles.max` | Distribución de los tiempos de pausa de la GC: valores máximos. | N/A |
+
+{{% /tab %}}
+
+{{% tab ".NET" %}}
+
+| Métrica de Datadog | Descripción | Métrica de OpenTelemetry |
+| --- | --- | --- |
+| `runtime.dotnet.threads.contention_count` | El número de veces que un subproceso se detuvo para esperar un bloqueo. | `process.runtime.dotnet.`
`monitor.lock_contention.count` |
+| `runtime.dotnet.exceptions.count` | El número de excepciones por primera vez. | `process.runtime.dotnet.`
`exceptions.count` |
+| `runtime.dotnet.gc.size.gen0` | El tamaño del heap de generación 0. | `process.runtime.dotnet.`
`gc.heap.size` |
+| `runtime.dotnet.gc.size.gen1` | El tamaño del heap de generación 1. | `process.runtime.dotnet.`
`gc.heap.size` |
+| `runtime.dotnet.gc.size.gen2` | El tamaño del heap de generación 2. | `process.runtime.dotnet.`
`gc.heap.size` |
+| `runtime.dotnet.gc.size.loh` | El tamaño del heap de grandes objetos. | `process.runtime.dotnet.`
`gc.heap.size` |
+| `runtime.dotnet.gc.count.gen0` | El número de recopilaciones de elementos no usados de generación 0. | `process.runtime.dotnet.`
`gc.collections.count` |
+| `runtime.dotnet.gc.count.gen1` | El número de recopilaciones de elementos no usados de generación 1. | `process.runtime.dotnet.`
`gc.collections.count` |
+| `runtime.dotnet.gc.count.gen2` | El número de recopilaciones de elementos no usados de generación 2. | `process.runtime.dotnet.`
`gc.collections.count` |
+| `runtime.dotnet.cpu.system` | El número de milisegundos de ejecución en el kernel. | N/A |
+| `runtime.dotnet.cpu.user` | El número de milisegundos de ejecución fuera del kernel. | N/A |
+| `runtime.dotnet.cpu.percent` | El porcentaje de CPU total utilizado por la aplicación. | N/A |
+| `runtime.dotnet.mem.committed` | Uso de memoria. | N/A |
+| `runtime.dotnet.threads.count` | El número de subprocesos. | N/A |
+| `runtime.dotnet.threads.workers_count` | El número de trabajadores en el grupo de subprocesos. (Solo.NET Core) | N/A |
+| `runtime.dotnet.threads.contention_time` | El tiempo acumulado que pasan los subprocesos esperando un bloqueo. (Solo .NET Core) | N/A |
+| `runtime.dotnet.gc.memory_load` | El porcentaje de la memoria total utilizada por el proceso. La recopilación de elementos no usados (GC) cambia su comportamiento cuando este valor supera el 85. (Solo .NET Core) | N/A |
+| `runtime.dotnet.gc.pause_time` | La cantidad de tiempo que la GC pausó los subprocesos de la aplicación. (Solo .NET Core) | N/A |
+| `runtime.dotnet.aspnetcore.`
`requests.total` | El número total de solicitudes HTTP recibidas por el servidor. (Solo .NET Core) | N/A |
+| `runtime.dotnet.aspnetcore.`
`requests.failed` | El número de solicitudes HTTP fallidas recibidas por el servidor. (Solo .NET Core) | N/A |
+| `runtime.dotnet.aspnetcore.`
`requests.current` | El número total de solicitudes HTTP que se han iniciado, pero aún no se han detenido. (Solo .NET Core) | N/A |
+| `runtime.dotnet.aspnetcore.`
`requests.queue_length` | La longitud actual de la cola de solicitudes HTTP del servidor. (Solo .NET Core) | N/A |
+| `runtime.dotnet.aspnetcore.`
`connections.total` | El número total de conexiones HTTP establecidas con el servidor. (Solo .NET Core) | N/A |
+| `runtime.dotnet.aspnetcore.`
`connections.current` | El número actual de conexiones HTTP activas al servidor. (Solo .NET Core) | N/A |
+| `runtime.dotnet.aspnetcore.`
`connections.queue_length` | La longitud actual de la cola de conexión del servidor HTTP. (Solo .NET Core) | N/A |
+
+{{% /tab %}}
+
+{{< /tabs >}}
+
+## Referencias adicionales
+
+{{< partial name="whats-next/whats-next.html" >}}
+
+[1]: /es/opentelemetry/mapping/metrics_mapping/
+[2]: /es/opentelemetry/setup/
+[3]: https://app.datadoghq.com/integrations
[5]: /es/tracing/metrics/runtime_metrics/
[7]: https://app.datadoghq.com/dash/integration/256/jvm-metrics
\ No newline at end of file
diff --git a/content/es/real_user_monitoring/browser/advanced_configuration.md b/content/es/real_user_monitoring/browser/advanced_configuration.md
index d1b8ff8bbce63..0ea3601184a2e 100644
--- a/content/es/real_user_monitoring/browser/advanced_configuration.md
+++ b/content/es/real_user_monitoring/browser/advanced_configuration.md
@@ -35,7 +35,7 @@ Existen varias formas de modificar los [datos y el contexto recopilados][1] por
## Sustituir los nombres de las vistas de RUM por defecto
-El SDK del RUM Browser genera automáticamente un [evento de vista][2] para cada nueva página visitada por tus usuarios o cuando se cambia la URL de la página (para aplicaciones de página única). El nombre de la vista se calcula a partir de la URL de la página actual, donde los ID alfanuméricos variables se eliminan automáticamente. Por ejemplo, `/dashboard/1234` se convierte en `/dashboard/?`.
+El SDK del RUM Browser genera automáticamente un [evento de vista][2] para cada nueva página visitada por tus usuarios o cuando se cambia la URL de la página (para aplicaciones de página única). El nombre de la vista se calcula a partir de la URL de la página actual, donde los ID alfanuméricos variables se eliminan automáticamente. Un segmento de ruta que contenga al menos un número se considera un ID de variable. Por ejemplo, `/dashboard/1234` y `/dashboard/9a` se convierten en `/dashboard/?`.
A partir de la [versión 2.17.0][3], puedes añadir nombres de vistas y asignarlos a un servicio dedicado propiedad de un equipo mediante el rastreo manual de eventos de vistas con la opción `trackViewsManually`:
@@ -360,7 +360,7 @@ import { datadogRum } from '@datadog/browser-rum';
datadogRum.setViewName('');
-// Ejemplo de código
+// Code example
datadogRum.setViewName('Checkout');
```
{{% /tab %}}
@@ -370,7 +370,7 @@ window.DD_RUM.onReady(function() {
window.DD_RUM.setViewName('');
})
-// Ejemplo de código
+// Code example
window.DD_RUM.onReady(function() {
window.DD_RUM.setViewName('Checkout');
})
@@ -380,7 +380,7 @@ window.DD_RUM.onReady(function() {
```javascript
window.DD_RUM && window.DD_RUM.setViewName('');
-// Ejemplo de código
+// Code example
window.DD_RUM && window.DD_RUM.setViewName('Checkout');
```
{{% /tab%}}
@@ -477,10 +477,7 @@ window.DD_RUM &&
Si un usuario pertenece a varios equipos, añade pares clave-valor adicionales en tus llamadas a la API de Global Context.
-El SDK del RUM Browser ignora:
-
-- Atributos añadidos fuera de `event.context`
-- Modificaciones realizadas en un contexto de evento de vista de RUM
+El SDK del RUM Browser ignora los atributos añadidos fuera de `eventos.context`.
### Enriquecer eventos de RUM con indicadores de funciones
@@ -531,27 +528,41 @@ window.DD_RUM &&
...
});
```
-{{% /tab%}}
-{{< /tabs>}}
+{{% /tab %}}
+{{< /tabs >}}
Puedes actualizar las siguientes propiedades de eventos:
-| Atributo | Tipo | Descripción |
-|-----------------------|-----------|-----------------------------------------------------------------------------------------------------|
-| `view.url` | Cadena | La URL de la página web activa. |
-| `view.referrer` | Cadena | La URL de la página web anterior desde la que se siguió un vínculo a la página solicitada actualmente. |
-| `view.name` | Cadena | El nombre de la vista actual. |
-| `service` | Cadena | El nombre de servicio para tu aplicación. |
-| `version` | Cadena | La versión de la aplicación, por ejemplo: 1.2.3, 6c44da20 y 2020.02.13. |
-| `action.target.name` | Cadena | El elemento con el que ha interactuado el usuario. Solo para acciones recopiladas automáticamente. |
-| `error.message` | Cadena | Un mensaje conciso, legible, de una línea, en el cual se explica el error. |
-| `error.stack ` | Cadena | La traza (trace) de stack tecnológico o la información adicional sobre el error. |
-| `error.resource.url` | Cadena | La URL del recurso que provocó el error. |
-| `resource.url` | Cadena | La URL del recurso. |
-| `context` | Objeto | Atributos añadidos con la [Global Context API](#global-context), la [View Context API](#view-context) o al generar eventos manualmente (por ejemplo, `addError` y **`addAction`**). |
+| Atributo | Tipo | Descripción |
+| ------------------------------ | ------ | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `view.url` | Cadena | La URL de la página web activa. |
+| `view.referrer` | Cadena | La URL de la página web anterior desde la que se siguió un vínculo a la página solicitada actualmente. |
+| `view.name` | Cadena | El nombre de la vista actual. |
+| `view.performance.lcp.resource_url` | Cadena | La URL de recursos para Largest Contentful Paint. |
+| `service` | Cadena | El nombre de servicio para tu aplicación. |
+| `version` | Cadena | La versión de la aplicación. Por ejemplo: 1.2.3, 6c44da20 o 2020.02.13. |
+| `action.target.name` | Cadena | El elemento con el que ha interactuado el usuario. Solo para acciones recopiladas automáticamente. |
+| `error.message` | Cadena | Un mensaje conciso, legible, de una línea, en el cual se explica el error. |
+| `error.stack ` | Cadena | La traza (trace) de stack tecnológico o la información adicional sobre el error. |
+| `error.resource.url` | Cadena | La URL del recurso que provocó el error. |
+| `resource.url` | Cadena | La URL del recurso. |
+| `long_task.scripts.source_url` | Cadena | La url del recurso de script |
+| `long_task.scripts.invoker` | Cadena | Un nombre significativo que indique cómo se ha llamado al script |
+| `context` | Objeto | Atributos añadidos con la [Global Context API](#global-context), la [View Context API](#view-context) o al generar eventos manualmente (por ejemplo, `addError` y **`addAction`**). |
El SDK del RUM Browser ignora las modificaciones realizadas en las propiedades de eventos no enumeradas anteriormente. Para obtener más información sobre las propiedades de eventos, consulta el [repositorio GitHub del SDK del RUM Browser][15].
+**Nota**: A diferencia de otros eventos, los eventos de vista se envían varias veces a Datadog para reflejar las actualizaciones que se producen durante su ciclo de vida. Una actualización de un evento de vista anterior puede seguir enviándose mientras una nueva vista está activa. Datadog recomienda tener en cuenta este comportamiento al modificar el contenido de un evento de vista.
+
+```javascript
+beforeSend: (event) => {
+ // discouraged, as the current view name could be applied to both the active view and the previous views
+ event.view.name = getCurrentViewName()
+
+ // recommended
+ event.view.name = getViewNameForUrl(event.view.url)
+}
+```
### Descartar un evento de RUM
Con la API `beforeSend`, descarta un evento de RUM devolviendo `false`:
@@ -604,28 +615,46 @@ window.DD_RUM &&
...
});
```
-{{% /tab%}}
-{{< /tabs>}}
+{{% /tab %}}
+{{< /tabs >}}
**Nota**: Los eventos de vistas no se pueden descartar.
## Sesión del usuario
-Añadir información del usuario a tus sesiones de RUM puede ayudar a:
+Añadir información del usuario a tus sesiones de RUM te ayuda a:
+
* Seguir el recorrido de un usuario concreto
* Conocer qué usuarios se han visto más afectados por los errores
* Monitorizar el rendimiento de tus usuarios más importantes
{{< img src="real_user_monitoring/browser/advanced_configuration/user-api.png" alt="API de usuario en la interfaz de usuario de RUM" >}}
-Los siguientes atributos son opcionales, pero Datadog recomienda proporcionar al menos uno de ellos:
+{{< tabs >}}
+{{% tab "6.4.0 and above" %}}
+
+Están disponibles los siguientes atributos:
+
+| Atributo | Tipo | Obligatorio | Descripción |
+|------------|------|------|----------------------------------------------------------------------------------------------------|
+| `usr.id` | Cadena | Sí | Identificador único de usuario. |
+| `usr.name` | Cadena | No | Nombre descriptivo, que se muestra por defecto en la interfaz de usuario de RUM. |
+| `usr.email` | Cadena | No | Correo electrónico del usuario, que se muestra en la interfaz de usuario de RUM si el nombre de usuario no está presente. También se usa para obtener Gravatars. |
+
+{{% /tab %}}
+{{% tab "Before 6.4.0" %}}
+
+Los siguientes atributos son opcionales, pero Datadog recomienda encarecidamente proporcionar al menos uno de ellos. Por ejemplo, debes establecer el ID de usuario en tus sesiones para ver los datos relevantes en algunos dashboards predeterminados de RUM, que dependen de `usr.id` como parte de la consulta.
| Atributo | Tipo | Descripción |
|------------|------|----------------------------------------------------------------------------------------------------|
-| `usr.id` | Cadena | Identificador de usuario único. |
+| `usr.id` | Cadena | Identificador único de usuario. |
| `usr.name` | Cadena | Nombre descriptivo, que se muestra por defecto en la interfaz de usuario de RUM. |
| `usr.email` | Cadena | Correo electrónico del usuario, que se muestra en la interfaz de usuario de RUM si el nombre de usuario no está presente. También se usa para obtener Gravatars. |
+{{% /tab %}}
+{{< /tabs >}}
+
Aumentar tus posibilidades de filtrado añadiendo atributos adicionales a los recomendados. Por ejemplo, añade información sobre el plan del usuario o a qué grupo de usuarios pertenece.
Cuando se realizan cambios en el objeto de la sesión del usuario, todos los eventos de RUM recopilados tras el cambio contienen la información actualizada.
@@ -672,8 +701,8 @@ window.DD_RUM && window.DD_RUM.setUser({
})
```
-{{% /tab%}}
-{{< /tabs>}}
+{{% /tab %}}
+{{< /tabs >}}
### Acceder a la sesión del usuario
@@ -697,8 +726,8 @@ window.DD_RUM.onReady(function() {
window.DD_RUM && window.DD_RUM.getUser()
```
-{{% /tab%}}
-{{< /tabs>}}
+{{% /tab %}}
+{{< /tabs >}}
### Añadir/sustituir la propiedad de la sesión del usuario
@@ -722,8 +751,8 @@ window.DD_RUM.onReady(function() {
window.DD_RUM && window.DD_RUM.setUserProperty('name', 'John Doe')
```
-{{% /tab%}}
-{{< /tabs>}}
+{{% /tab %}}
+{{< /tabs >}}
### Eliminar la propiedad de la sesión del usuario
@@ -746,8 +775,8 @@ window.DD_RUM.onReady(function() {
```javascript
window.DD_RUM && window.DD_RUM.removeUserProperty('name')
```
-{{% /tab%}}
-{{< /tabs>}}
+{{% /tab %}}
+{{< /tabs >}}
### Borrar la propiedad de la sesión del usuario
@@ -773,6 +802,152 @@ window.DD_RUM && window.DD_RUM.clearUser()
{{% /tab %}}
{{< /tabs >}}
+## Cuenta
+
+Para agrupar a los usuarios en conjuntos diferentes, utilice el concepto de cuenta.
+
+Están disponibles los siguientes atributos:
+
+| Atributo | Tipo | Obligatorio | Descripción |
+|----------------|--------|----------|------------------------------------------------------------|
+| `account.id` | Cadena | Sí | Identificador único de la cuenta. |
+| `account.name` | Cadena | No | Nombre descriptivo de la cuenta, mostrado por defecto en la interfaz de usuario RUM. |
+
+### Identificar cuenta
+
+`datadogRum.setAccount()`
+
+{{< tabs >}}
+{{% tab "NPM" %}}
+```javascript
+datadogRum.setAccount({
+ id: '1234',
+ name: 'Mi nombre de empresa',
+ ...
+})
+```
+{{% /tab %}}
+{{% tab "CDN asíncrono" %}}
+```javascript
+window.DD_RUM.onReady(function() {
+ window.DD_RUM.setAccount({
+ id: '1234',
+ name: 'Nombre de mi empresa',
+ ...
+ })
+})
+```
+{{% /tab %}}
+{{% tab "CDN síncrono" %}}
+```javascript
+window.DD_RUM && window.DD_RUM.setAccount({
+ id: '1234',
+ name: 'Nombre de mi empresa',
+ ...
+})
+```
+
+{{% /tab %}}
+{{< /tabs >}}
+
+### Cuenta de acceso
+
+`datadogRum.getAccount()`
+
+{{< tabs >}}
+{{% tab "NPM" %}}
+```javascript
+datadogRum.getAccount()
+```
+{{% /tab %}}
+{{% tab "CDN asíncrono" %}}
+```javascript
+window.DD_RUM.onReady(function() {
+ window.DD_RUM.getAccount()
+})
+```
+{{% /tab %}}
+{{% tab "CDN síncrono" %}}
+```javascript
+window.DD_RUM && window.DD_RUM.getAccount()
+```
+
+{{% /tab %}}
+{{< /tabs >}}
+
+### Añadir/Anular propiedad de cuenta
+
+`datadogRum.setAccountProperty('', )`
+
+{{< tabs >}}
+{{% tab "NPM" %}}
+```javascript
+datadogRum.setAccountProperty('name', 'Nombre de mi empresa')
+```
+{{% /tab %}}
+{{% tab "CDN asíncrono" %}}
+```javascript
+window.DD_RUM.onReady(function() {
+ window.DD_RUM.setAccountProperty('nombre', 'Nombre de mi empresa')
+})
+```
+{{% /tab %}}
+{{% tab "CDN síncrono" %}}
+```javascript
+window.DD_RUM && window.DD_RUM.setAccountProperty('name', 'Nombre de mi empresa')
+```
+
+{{% /tab %}}
+{{< /tabs >}}
+
+### Eliminar la propiedad de la cuenta
+
+`datadogRum.removeAccountProperty('')`
+
+{{< tabs >}}
+{{% tab "NPM" %}}
+```javascript
+datadogRum.removeAccountProperty('nombre')
+```
+{{% /tab %}}
+{{% tab "CDN asíncrono" %}}
+```javascript
+window.DD_RUM.onReady(function() {
+ window.DD_RUM.removeAccountProperty('nombre')
+})
+```
+{{% /tab %}}
+{{% tab "CDN síncrono" %}}
+```javascript
+window.DD_RUM && window.DD_RUM.removeAccountProperty('nombre')
+```
+{{% /tab %}}
+{{< /tabs >}}
+
+### Borrar propiedades de la cuenta
+
+`datadogRum.clearAccount()`
+
+{{< tabs >}}
+{{% tab "NPM" %}}
+```javascript
+datadogRum.clearAccount()
+```
+{{% /tab %}}
+{{% tab "CDN asíncrono" %}}
+```javascript
+window.DD_RUM.onReady(function() {
+ window.DD_RUM.clearAccount()
+})
+```
+{{% /tab %}}
+{{% tab "CDN síncrono" %}}
+```javascript
+window.DD_RUM && window.DD_RUM.clearAccount()
+```
+{{% /tab %}}
+{{< /tabs >}}
+
## Muestreo
Por defecto, no se aplica ningún muestreo al número de sesiones recopiladas. Para aplicar un muestreo relativo (en porcentaje) al número de sesiones recopiladas, utiliza el parámetro `sessionSampleRate` al inicializar el RUM.
@@ -814,8 +989,8 @@ window.DD_RUM &&
sessionSampleRate: 90,
});
```
-{{% /tab%}}
-{{< /tabs>}}
+{{% /tab %}}
+{{< /tabs >}}
Para una sesión muestreada, no se recopilan todas las páginas de vistas ni la telemetría asociada a esa sesión.
@@ -879,8 +1054,8 @@ acceptCookieBannerButton.addEventListener('click', () => {
window.DD_RUM && window.DD_RUM.setTrackingConsent('granted');
});
```
-{{% /tab%}}
-{{< /tabs>}}
+{{% /tab %}}
+{{< /tabs >}}
## Ver contexto
@@ -933,8 +1108,8 @@ window.DD_RUM && window.DD_RUM.setViewContextProperty('activity', {
amount: 23.42
});
```
-{{% /tab%}}
-{{< /tabs>}}
+{{% /tab %}}
+{{< /tabs >}}
### Sustituir el contexto de la vista
@@ -984,6 +1159,19 @@ window.DD_RUM &&
{{% /tab %}}
{{< /tabs >}}
+
+## Contexto de error
+
+### Adjuntar contexto de error local con dd_context
+
+Al capturar errores, se puede proporcionar contexto adicional en el momento en que se genera un error. En lugar de pasar información adicional a través de la API `addError()`, puedes adjuntar una propiedad `dd_context` directamente a la instancia de error. El SDK del RUM Browser detecta automáticamente esta propiedad y la fusiona en el contexto final del evento de error.
+
+{{< code-block lang="javascript" >}}
+const error = new Error('Something went wrong')
+error.dd_context = { component: 'Menu', param: 123, }
+throw error
+{{< /code-block >}}
+
## Contexto global
### Añadir la propiedad de contexto global
@@ -1029,8 +1217,8 @@ window.DD_RUM && window.DD_RUM.setGlobalContextProperty('activity', {
amount: 23.42
});
```
-{{% /tab%}}
-{{< /tabs>}}
+{{% /tab %}}
+{{< /tabs >}}
### Eliminar la propiedad de contexto global
@@ -1071,8 +1259,8 @@ window.DD_RUM &&
window.DD_RUM.removeGlobalContextProperty('codeVersion');
```
-{{% /tab%}}
-{{< /tabs>}}
+{{% /tab %}}
+{{< /tabs >}}
### Sustituir el contexto global
@@ -1120,8 +1308,8 @@ window.DD_RUM &&
});
```
-{{% /tab%}}
-{{< /tabs>}}
+{{% /tab %}}
+{{< /tabs >}}
### Borrar un contexto global
@@ -1150,8 +1338,8 @@ window.DD_RUM.onReady(function() {
window.DD_RUM && window.DD_RUM.clearGlobalContext();
```
-{{% /tab%}}
-{{< /tabs>}}
+{{% /tab %}}
+{{< /tabs >}}
### Leer el contexto global
@@ -1180,8 +1368,8 @@ window.DD_RUM.onReady(function() {
const context = window.DD_RUM && window.DD_RUM.getGlobalContext();
```
-{{% /tab%}}
-{{< /tabs>}}
+{{% /tab %}}
+{{< /tabs >}}
## Ciclo de vida de los contextos
@@ -1275,8 +1463,8 @@ window.DD_RUM && window.DD_RUM.init({
},
});
```
-{{% /tab%}}
-{{< /tabs>}}
+{{% /tab %}}
+{{< /tabs >}}
Cualquier consulta realizada en el Explorador RUM puede utilizar el atributo servicio para filtrar eventos.
@@ -1292,7 +1480,6 @@ Algunos eventos no pueden atribuirse a un origen, por lo que no tienen una pila
{{< partial name="whats-next/whats-next.html" >}}
-
[1]: /es/real_user_monitoring/browser/data_collected/
[2]: /es/real_user_monitoring/browser/monitoring_page_performance/
[3]: https://github.com/DataDog/browser-sdk/blob/main/CHANGELOG.md#v2170
@@ -1304,7 +1491,7 @@ Algunos eventos no pueden atribuirse a un origen, por lo que no tienen una pila
[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
+[12]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error
[13]: https://developer.mozilla.org/en-US/docs/Web/API/PerformanceLongTaskTiming
[14]: /es/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
diff --git a/content/es/security/application_security/terms.md b/content/es/security/application_security/terms.md
index 9924273ae9d7a..a68685d991e3e 100644
--- a/content/es/security/application_security/terms.md
+++ b/content/es/security/application_security/terms.md
@@ -1,15 +1,12 @@
---
disable_toc: false
further_reading:
-- link: /security/application_security/how-appsec-works
+- link: /security/application_security/how-it-works
tag: Documentación
- text: Cómo funciona Application Security
-- link: /security/application_security/threats/
+ text: Cómo funciona App and API Protection
+- link: /security/application_security
tag: Documentación
- text: Gestión de amenazas
-- link: /security/application_security/software_composition_analysis/
- tag: Documentación
- text: Análisis de la composición del software
+ text: App and API Protection
- link: https://www.datadoghq.com/blog/datadog-threat-intelligence/
tag: Blog
text: Acelerar las investigaciones de seguridad con la información sobre amenazas
@@ -17,61 +14,55 @@ further_reading:
title: Términos y conceptos
---
-Datadog Application Security monitoriza las amenazas y ofrece protección contra los ataques a nivel de aplicación que pretenden explotar vulnerabilidades a nivel de código. Aprovecha el contexto de ejecución del código en tiempo de ejecución, los datos de trazas y de errores, así como la atribución al usuario.
+Datadog App and API Protection supervisa las amenazas y ofrece protección contra los ataques a nivel de aplicación que pretenden explotar las vulnerabilidades a nivel de código. Aprovecha el contexto de ejecución del código en tiempo de ejecución, traza y los datos de errores, así como la atribución al usuario.
-## Términos generales de seguridad de las aplicaciones
+## Condiciones generales de App and API Protection
Intento de ataque
-: Qué regla de seguridad ha sido activada por la traza (trace).
+: Qué regla de seguridad ha sido activada por la traza.
-Biblioteca Datadog
-: También biblioteca de rastreo
-: Lenguaje de programación específico de la biblioteca incorporado en aplicaciones web. Datadog Application Security utiliza la biblioteca para la monitorización y la protección. APM utiliza la misma biblioteca para la instrumentación del código para el rastreo de telemetría.
+Biblioteca de Datadog
+: _también_ rastreador, biblioteca de rastreo
+: una biblioteca específica del lenguaje de programación incrustada en aplicaciones web. Datadog App and API Protection utiliza la biblioteca para monitorizar y proteger. APM utiliza la misma biblioteca para instrumentar código para rastrear telemetría.
Regla de detección
-: Definición de lógica condicional que se aplica a los datos ingeridos y a las configuraciones de la nube. Cuando al menos un caso definido en una regla coincide durante un periodo de tiempo determinado, Datadog genera una señal de seguridad.
+: Definición de lógica condicional que se aplica a los datos ingeridos y a las configuraciones de la nube. Cuando coincide al menos un caso definido en una regla durante un periodo de tiempo determinado, Datadog genera una _señal de seguridad_.
: Consulta [Reglas de detección][10].
Lista de permisos (antiguo filtro de exclusión)
-: Mecanismo para descartar trazas de seguridad marcadas por la biblioteca Datadog Application Security y las reglas WAF en la aplicación. Passlist se aplica a medida que las solicitudes se ingieren en Datadog (admisión). La lista de permisos ayuda a gestionar los falsos positivos y los costes de admisión.
+: Mecanismo para descartar las trazas de seguridad marcadas por la biblioteca de Datadog App and API Protection y las reglas WAF en la aplicación. La lista de permisos se aplica a medida que las solicitudes se ingieren en Datadog (admisión), y ayuda a gestionar los falsos positivos y los costes de admisión.
: Consulta [Filtros de exclusión][11] en la aplicación.
Reglas WAF en la aplicación (antiguas reglas de eventos)
-: Conjunto de reglas que se ejecutan en bibliotecas Datadog para detectar actividades de seguridad. Incluyen patrones de Web Application Firewall (WAF) que monitorizan los intentos de explotar vulnerabilidades conocidas.
+: Conjunto de reglas que se ejecutan en las bibliotecas de Datadog para detectar las actividades de seguridad. Incluyen patrones del firewall de aplicaciones web (WAF) que monitorizan los intentos de explotar las vulnerabilidades conocidas.
: Consulta [Reglas WAF en la aplicación][12].
-Tests interactivos de seguridad de las aplicaciones (IAST)
-: Método de tests de seguridad de aplicaciones que detecta proactivamente vulnerabilidades mientras la aplicación es ejecutada por un test automatizado, un testeador humano o cualquier actividad que interactúe con la funcionalidad de la aplicación.
-
Configuración remota
-: Mecanismo de la plataforma Datadog que habilita la actualización remota de la configuración del Agent. Utilizada por Datadog Application Security para actualizar las reglas WAF en la aplicación, activar el producto y bloquear a los atacantes.
+: Mecanismo de la plataforma Datadog que habilita la actualización remota de la configuración del Agent. Es utilizada por Datadog App and API Protection para actualizar las reglas WAF en la aplicación, activar el producto y bloquear a los atacantes.
: Consulta [Cómo funciona la configuración remota][8].
Servicio
: Una única aplicación web, microservicio, API o función. Normalmente sirve a una función empresarial.
Señal
-: Detección de un ataque a una aplicación que afecta a tus servicios. Las señales identifican amenazas significativas para que las revises y les des un tratamiento de alta prioridad.
+: Detección de un ataque a una aplicación que afecta a los servicios. Las señales identifican amenazas significativas para que se puedan revisar y darles un tratamiento de alta prioridad.
: Consulta [Explorador de señales][13] en la aplicación.
-Análisis de la composición del software (SCA)
-: Comparación de las bibliotecas de código abierto cargadas por tus servicios en bases de datos con vulnerabilidades conocidas. El SCA te ayuda a identificar dependencias vulnerables, bibliotecas obsoletas y problemas de licencia en bibliotecas de código abierto cargadas por tus servicios web.
-
Gravedad
-: Indicador de la rapidez con la que se debe clasificar y abordar un intento de ataque. Se basa en una combinación de factores, incluyendo el impacto potencial y el riesgo del ataque. Los valores son Crítico, Alto, Medio, Bajo, Información.
+: Indicador de la rapidez con la que se debe clasificar y abordar un intento de ataque. Se basa en una combinación de factores, incluido el impacto potencial y el riesgo del ataque. Los valores son Crítico, Alto, Medio, Bajo, Información.
-Rastreo de seguridad
+Traza de seguridad
: Rastreo distribuido cuya actividad de seguridad ha sido marcada por reglas WAF en la aplicación. La traza subyacente se comparte con APM, lo que permite investigaciones más profundas y rápidas.
Solicitud sospechosa
: Rastreo distribuido cuya actividad de seguridad ha sido marcada por reglas WAF en la aplicación. La traza subyacente se comparte con APM, lo que permite investigaciones más profundas y rápidas.
Asignación a usuarios
-: Mecanismo que asigna las solicitudes sospechosas a usuarios conocidos en tus sistemas.
-: Consulta [Seguimiento de la actividad del usuario][14].
+: Mecanismo que asigna las solicitudes sospechosas a usuarios que son conocidos en tus sistemas.
+: Consulta [Rastreo de la actividad del usuario][14].
Vulnerabilidad
-: Riesgo pasivo de una aplicación. De [OWASP][1]: "Una vulnerabilidad es un hueco o una debilidad en la aplicación. Puede ser un defecto de diseño o un error de implementación, que permite a un atacante causar daño a las partes interesadas de una aplicación. Las partes interesadas incluyen el propietario de la aplicación, los usuarios de la aplicación y otras entidades que dependen de la aplicación."
+: Riesgo pasivo de una aplicación. De [OWASP][1]: "Una vulnerabilidad es un hueco o una debilidad en la aplicación. Puede ser un defecto de diseño o un error de implementación que permite a un atacante causar daño a las partes interesadas de una aplicación. Las partes interesadas incluyen al propietario de la aplicación, a los usuarios de la aplicación y a otras entidades que dependen de la aplicación."
Calificación de trazas
: Proceso mediante el cual Datadog ayuda a comprender el impacto de las trazas, etiquetándolas
@@ -79,28 +70,36 @@ como `Harmful Safe or Unknown`.
: Consulta [Calificación de trazas][15].
Información sobre amenazas
-: Conjunto de reglas que se ejecutan en bibliotecas Datadog para detectar amenazas. Incluyen patrones de Web Application Firewall (WAF) que monitorizan los intentos de explotar vulnerabilidades conocidas.
+: Conjunto de reglas que se ejecutan en las bibliotecas de Datadog para detectar las amenazas. Incluyen patrones del firewall de aplicaciones web (WAF) que monitorizan los intentos de explotar las vulnerabilidades conocidas.
: Consulta [Información sobre amenazas][16].
-Atacantes sospechosos
-: Precursor de las IP marcadas. Para ser clasificadas como sospechosas, las IP deben haber alcanzado un umbral mínimo de tráfico de ataque, pero no el umbral para ser marcadas. Los umbrales no son configurables por el usuario.
-: Consulta [Explorador de atacantes][17]
+atacantes sospechosos
+: Precursor de las IP marcadas. Las IPs sospechosas han alcanzado un umbral mínimo de tráfico de ataque para ser clasificadas como sospechosas, pero no el umbral para Flagged. Los umbrales no son configurables por el usuario.
+: Véase [Atacantes Explorer][17]
+
+atacantes marcados
+: IPs que envían grandes cantidades de tráfico de ataque. Se recomienda revisar y bloquear las IP marcadas. Los umbrales no son configurables por el usuario.
+: Ver [Atacantes Explorer][17]
+
+huella digital del atacante
+: identificadores calculados a partir de las características de la solicitud para rastrear a un atacante a través de múltiples solicitudes.
+: ver [Huella digital del atacante][18]
-Atacantes marcados
-: Las IP que envían grandes cantidades de tráfico de ataque. Se recomienda revisar y bloquear las IP marcadas. Los umbrales no son configurables por el usuario.
-: Consulta [Explorador de atacantes][17]
+clúster atacante
+: Conjunto de atributos que identifican a un atacante en un ataque distribuido.
+: Ver [Agrupación ern clústeres de atacantes][19]
## Términos de ataques y vulnerabilidades conocidas
-Proyecto abierto de seguridad de las aplicaciones web (OWASP)
-: Fundación sin ánimo de lucro que dispone de varios proyectos para mejorar la seguridad de las aplicaciones web. OWASP es más conocido por el [OWASP Top 10][2], un amplio consenso sobre los riesgos de seguridad más críticos para las aplicaciones web.
+Open Web App and API Protection Project (OWASP)
+: Una fundación sin ánimo de lucro con varios proyectos para mejorar la seguridad de las aplicaciones web. OWASP es más conocida por el [OWASP Top 10][2], un amplio consenso sobre los riesgos de seguridad más críticos para las aplicaciones web.
-Secuencias de comandos en sitios cruzados (XSS)
+Secuencia de comandos en sitios cruzados o Cross-Site Scripting (XSS)
: Tipo de ataque de inyección en el que se inyectan scripts maliciosos en sitios web por lo demás benignos y de confianza.
: Consulta [XSS en OWASP][3].
Inyección de lenguaje de consulta estructurado (SQLi, Inyección SQL)
-: Tipo de ataque de inyección en el que se ejecuta una consulta SQL a través de los datos introducidos en la aplicación por el cliente. Los comandos SQL se inyectan en la entrada del plano de datos para afectar a la ejecución de comandos SQL predefinidos. Una inyección SQL exitosa puede leer datos confidenciales de la base de datos, modificar datos de la base de datos (Insertar/Actualizar/Borrar), ejecutar operaciones de administración en la base de datos (como apagar el DBMS), recuperar el contenido de un archivo dado presente en el sistema de archivos del DBMS y, en algunos casos, enviar comandos al sistema operativo.
+: Tipo de ataque de inyección en el que se ejecuta una consulta SQL a través de los datos que el cliente ha introducido en la aplicación. Los comandos SQL se inyectan en la entrada del plano de datos para afectar a la ejecución de los comandos SQL predefinidos. Una correcta inyección SQL puede leer datos confidenciales de la base de datos, modificarlos (Insertar/Actualizar/Borrar), ejecutar operaciones de administración (como apagar el DBMS), recuperar el contenido de un archivo dado presente en el sistema de archivos del DBMS y, en algunos casos, enviar comandos al sistema operativo.
: **Relacionado**: Cassandra Query Language Injection (CQLi), NoSQL Injection (NoSQLi) - Similar a SQLi pero para Cassandra Query Language y NoSQL.
: Consulta [Inyección SQL en OWASP][4].
@@ -109,16 +108,16 @@ Falsificación de solicitudes del lado del servidor (SSRF)
: Consulta [Falsificación de solicitudes del lado del servidor en OWASP][5].
Inclusión local de archivos (LFI)
-: Vulnerabilidad que permite a un atacante incluir un archivo localmente presente en el servidor durante el procesamiento de la solicitud. En la mayoría de los casos, esto permite al atacante leer información confidencial almacenada en archivos del servidor. En casos más graves, la explotación puede conducir a una secuencia de comandos en sitios cruzados o una ejecución remota del código.
-: Ver [Testing for LFI en OWASP][6].
+: Vulnerabilidad que permite a un atacante incluir un archivo localmente presente en el servidor durante el procesamiento de la solicitud. En la mayoría de los casos, esto permite al atacante leer información confidencial almacenada en los archivos del servidor. En los casos más graves, la explotación puede conducir a una secuencia de comandos en sitios cruzados (cross-site scripting) o a una ejecución remota del código.
+: Consulta [Tests para LFI en OWASP][6].
Inclusión remota de archivos (RFI)
-: Vulnerabilidad similar a la inclusión local de archivos, pero que permite a un atacante incluir un archivo remoto durante el procesamiento de la solicitud. Los archivos utilizados en los ataques de inclusión remota de archivos suelen contener código malicioso para PHP, JSP o tecnologías similares.
+: Vulnerabilidad similar a la inclusión local de archivos, pero que permite a un atacante incluir un archivo remoto durante el procesamiento de la solicitud. Los archivos utilizados en los ataques de inclusión remota de archivos suelen contener un código malicioso para PHP, JSP o tecnologías similares.
Ejecución remota de código (RCE)
-: Vulnerabilidad que permite a un atacante ejecutar código en una máquina de forma remota.
+: Vulnerabilidad que permite a un atacante ejecutar un código en una máquina de forma remota.
-Object-Graph Navigation Language Injection (OGNLi)
+Inyección de OGNLi (Object-Graph Navigation Language Injection)
: Vulnerabilidad que permite a un atacante ejecutar su propia expresión OGNL en una aplicación Java, lo que suele conducir a la ejecución remota del código.
: Consulta [OGNLi en OWASP Top 10][7].
@@ -138,9 +137,11 @@ Object-Graph Navigation Language Injection (OGNLi)
[8]: /es/agent/remote_config/
[10]: /es/security/detection_rules/
[11]: https://app.datadoghq.com/security/appsec/exclusions
-[12]: /es/security/application_security/threats/inapp_waf_rules
+[12]: /es/security/application_security/policies/inapp_waf_rules/
[13]: https://app.datadoghq.com/security?query=%40workflow.rule.type%3A%22Application%20Security%22&product=appsec&view=signal
-[14]: /es/security/application_security/threats/add-user-info/
-[15]: /es/security/application_security/threats/trace_qualification/
-[16]: /es/security/application_security/threats/threat-intelligence/
-[17]: /es/security/application_security/threats/attacker-explorer/
\ No newline at end of file
+[14]: /es/security/application_security/how-it-works/add-user-info/
+[15]: /es/security/application_security/how-it-works/trace_qualification/
+[16]: /es/security/application_security/how-it-works/threat-intelligence/
+[17]: /es/security/application_security/security_signals/attacker-explorer/
+[18]: /es/security/application_security/security_signals/attacker_fingerprint/
+[19]: /es/security/application_security/security_signals/attacker_clustering/
\ No newline at end of file
diff --git a/content/es/security/application_security/threats/_index.md b/content/es/security/application_security/threats/_index.md
index 6078b8bb2b892..154a9133bd9a5 100644
--- a/content/es/security/application_security/threats/_index.md
+++ b/content/es/security/application_security/threats/_index.md
@@ -1,32 +1,56 @@
---
further_reading:
-- link: /security/application_security/threats/add-user-info/
+- link: /security/application_security/how-it-works/add-user-info/
tag: Documentación
text: Seguimiento de la actividad de los usuarios
- link: /security/application_security/threats/library_configuration/
tag: Documentación
- text: Configuración de ASM
-- link: /security/application_security/software_composition_analysis/
+ text: Configuración de tu AAP
+- link: /security/code_security/software_composition_analysis/
tag: Documentación
text: Análisis de composición de software
-- link: /security/application_security/how-appsec-works/
+- link: /security/application_security/how-it-works/
tag: Documentación
- text: Cómo funciona ASM
-title: Gestión de las amenazas a las aplicaciones
+ text: Funcionamiento de la AAP
+title: App and API Protection
---
-La gestión de amenazas de ASM utiliza la telemetría de trazas (traces) de las aplicaciones instrumentadas por APM para identificar amenazas y ataques en los servicios en ejecución comparando el comportamiento observado con patrones de ataque conocidos, o identificando el abuso de la lógica de negocio.
+{{< site-region region="gov" >}}
+App and API Protection no es compatible con el
sitio Datadog seleccionado ({{< region-param key="dd_site_name" >}}).
+{{< /site-region >}}
-Las señales de seguridad planteadas por la monitorización de amenazas se resumen y aparecen en las vistas que ya visitas habitualmente para monitorizar el estado y el rendimiento de los servicios. El [catálogo de servicios][1] y las páginas individuales de servicios en APM proporcionan información sobre las señales de amenazas de las aplicaciones, lo que te permite investigar vulnerabilidades, bloquear atacantes y revisar exposiciones a ataques.
+Datadog App and API Protection (AAP) protege las aplicaciones web y las API frente a una amplia gama de amenazas para la seguridad, entre las que se incluyen:
-{{< img src="security/application_security/threats/threats-on-svc-cat_3.png" alt="Catálogo de servicios con servicios que muestran señales de amenaza" style="width:100%;" >}}
+- Intentos de uso de vulnerabilidades
+- Uso indebido y fraude en la aplicación
+- Abusos de API
-Para obtener más información sobre cómo funciona la gestión de amenazas, consulta [Cómo funciona ASM][4].
+Integrada en la plataforma Datadog, App and API Protection aprovecha los exhaustivos datos de Datadog (logs y trazas) para proporcionar visibilidad y seguridad completas del stack tecnológico en una plataforma unificada.
+
+App and API Protection permite a los equipos identificar y corregir rápidamente las amenazas. Su principal diferenciador es salvar la brecha entre seguridad y DevOps, promoviendo la colaboración entre los equipos de desarrollo, seguridad y operaciones.
+
+## Casos de uso
+
+Descubre las formas en que Datadog App and API Protection ayuda en casos de uso frecuentes:
+
+| Quieres... | Cómo puede ayudar Datadog AAP |
+| ----------- | ----------- |
+| **Protección de aplicaciones web:** Impide el uso de vulnerabilidades como la inyección SQL, la falsificación de solicitudes del lado del servidor y la inclusión de archivos locales. | Activa [Exploit Prevention][9] en tus servicios. App and API Protection bloquea los intentos en tiempo real y genera señales para su posterior investigación.|
+| **Abuso de aplicaciones y API:** Protege las aplicaciones contra el abuso de aplicaciones y API, como el relleno de credenciales y los ataques de apropiación de cuentas.| Aprovecha las [reglas de detección predefinidas][10] para notificaciones, como creaciones de cuentas inusuales o restablecimiento de contraseñas desde una IP, o campañas distribuidas de relleno de credenciales. Revisa las ventajas de la [protección predefinida contra la apropiación de cuentas][11].|
+| **Seguridad de API:** Conoce las API de tu organización, entiende la postura y las acciones necesarias para reducir el riesgo utilizando una lista priorizada de endpoints de API.| App and API Protection: - Realiza un inventario de todos tus endpoints de API. - Te proporciona una visibilidad de tu tráfico de API, incluyendo el abuso de API. - Destaca los riesgos en tus endpoints de API. Por ejemplo, endpoints vulnerables o no autenticados que procesan datos confidenciales.|
+
+## Señales de seguridad
+
+Las señales de seguridad emitidas por Threat Monitoring se resumen y se muestran en las vistas que visitas habitualmente para monitorizar la salud y el rendimiento de los servicios. El [Catálogo de software][1] y las páginas servicio individuales en APM proporcionan información sobre las señales de amenaza a las aplicaciones, lo que te permite investigar vulnerabilidades, bloquear atacantes y revisar las exposiciones a ataques.
+
+{{< img src="security/application_security/threats/threats-on-svc-cat_3.png" alt="Catálogo de software con servicios que muestran señales de amenaza" style="width:100%;" >}}
+
+Para obtener más información sobre el funcionamiento de App and API Protection, consulta [Funcionamiento de AAP][4].
## Exploración de las señales de amenaza
-Cuando los datos de amenazas de los servicios llegan a Datadog, la [información general de ASM][7] muestra un resumen de lo que está ocurriendo. Aquí, puedes habilitar la detección de vulnerabilidades, revisar los ataques, personalizar las alertas y los informes, y habilitar ASM en los servicios. Para investigar señales de actividad sospechosa, haz clic en el enlace **Review** (Revisar) del servicio.
+Cuando los datos de amenazas a tus servicios entran en Datadog, la [información general de AAP][7] muestra un resumen de lo que está ocurriendo. Aquí, puedes activar la detección de vulnerabilidades, revisar los ataques, personalizar las alertas y los informes, y activar AAP en tus servicios. Para investigar señales de actividad sospechosa, haz clic en el enlace **Review** (Revisar) del servicio.
En el [explorador de señales][2], filtra por atributos y facetas para encontrar amenazas críticas. Haz clic en una señal para ver sus detalles, incluida la información del usuario y su dirección IP, qué regla activó, el flujo del ataque, las trazas (traces) relacionadas y otras señales de seguridad. Desde esta página también puedes hacer clic para crear un caso y declarar un incidente. Para obtener más información, consulta [Investigación de las señales de seguridad][8].
@@ -35,20 +59,28 @@ En el [explorador de señales][2], filtra por atributos y facetas para encontrar
## Creación de reglas de WAF en la aplicación para identificar patrones de ataque
-Puedes [crear reglas de WAF en la aplicación][5] que definan qué aspecto tiene el comportamiento sospechoso en la aplicación, aumentando las reglas predeterminadas que vienen con ASM. A continuación, [especifica reglas personalizadas][6] para generar señales de seguridad a partir de los intentos de ataque desencadenados desde estas reglas, planteándolas en las vistas de la monitorización de amenazas para su investigación.
+Puedes [crear reglas WAF en la aplicación][5] que definan el comportamiento sospechoso en tu aplicación, aumentando las reglas por defecto que vienen con AAP. A continuación, [especifica reglas personalizadas][6] para generar señales de seguridad a partir de los intentos de ataque activador por estas reglas, mostrándolas en las vistas de Threat Monitor para su investigación.
-## Frena los ataques y a los atacantes con ASM Protect
+## Frenar los ataques y a los atacantes con AAP Protect
{{% asm-protect %}}
+## Desactivar la gestión y la protección de amenazas
+
+Para obtener información sobre la desactivación de la gestión y la protección de amenazas, consulta [Desactivación de la gestión y la protección de amenazas][12].
+
## Referencias adicionales
{{< partial name="whats-next/whats-next.html" >}}
[1]: https://app.datadoghq.com/services?lens=Security
[2]: https://app.datadoghq.com/security?query=%40workflow.rule.type%3A%22Application%20Security%22&column=time&order=desc&product=appsec&viz=stream&start=1694726477747&end=1695331277747&paused=false
-[4]: /es/security/application_security/how-appsec-works/
+[4]: /es/security/application_security/how-it-works/
[5]: /es/security/application_security/threats/inapp_waf_rules/
-[6]: /es/security/application_security/threats/custom_rules/
+[6]: /es/security/application_security/policies/custom_rules/
[7]: https://app.datadoghq.com/security/appsec?
-[8]: /es/security/application_security/threats/security_signals/
\ No newline at end of file
+[8]: /es/security/workload_protection/security_signals/
+[9]: /es/security/application_security/exploit-prevention/
+[10]: /es/security/default_rules/?category=cat-application-security
+[11]: /es/security/account_takeover_protection/
+[12]: /es/security/application_security/troubleshooting/#disabling-threat-management-and-protection
\ No newline at end of file
diff --git a/content/es/security/code_security/_index.md b/content/es/security/code_security/_index.md
index 5e73e248a75a7..5a72c1168fb2f 100644
--- a/content/es/security/code_security/_index.md
+++ b/content/es/security/code_security/_index.md
@@ -2,14 +2,21 @@
aliases:
- /es/code_analysis/
disable_toc: false
-title: Seguridad del código
+further_reading:
+- link: https://www.datadoghq.com/blog/monitor (noun)-mcp-servidores/
+ tag: Blog
+ text: Identificar los riesgos de seguridad más comunes en los servidores MCP
+title: Code Security
---
-Code Security escanea tu código de origen y bibliotecas de código abierto utilizadas en tus aplicaciones, tanto en tus repositorios como servicios en ejecución, proporcionando visibilidad de extremo a extremo desde el desarrollo hasta la producción. Abarca las siguientes capacidades:
+Code Security analiza tu código de origen y bibliotecas de código abierto utilizadas en tus aplicaciones, tanto en tus repositorios como servicios en ejecución, proporcionando visibilidad de extremo a extremo desde el desarrollo hasta la producción. Abarca las siguientes capacidades:
- [Static Code Analysis (SAST)][1] para identificar problemas de seguridad y calidad en el código de origen.
- [Software Composition Analysis (SCA)][2] para identificar dependencias de código abierto tanto en tus repositorios como en tus servicios
-- [Runtime Code Analysis (IAST)][3] para detectar vulnerabilidades a nivel de código en tus servicios
+- [Runtime Code Analysis (IAST)][3] para identificar vulnerabilidades en el código de origen dentro de tus servicios
+- [Secret Scanning][8] para identificar y validar secretos filtrados (en vista previa)
+- [Infrastructure as Code (IaC) Security][10] para identificar configuraciones de seguridad incorrectas en los archivos Terraform almacenados en tus repositorios
+- [Supply Chain Security](#supply-chain-security) para evitar que paquetes maliciosos entren en tu entorno de desarrollo y repositorios de código
Code Security ayuda a los equipos a implementar DevSecOps en toda la organización:
- **Desarrolladores:** detección temprana de vulnerabilidades, mejoras en la calidad del código, desarrollo más rápido, ya que los desarrolladores pasan menos tiempo depurando y parcheando.
@@ -43,10 +50,27 @@ Runtime Code Analysis (IAST) identifica vulnerabilidades a nivel de código en t
Puedes activar IAST en tus servicios instrumentados con Datadog APM. Consulta [Configuración de IAST][3] para empezar.
+## Secret Scanning
+Secret Scanning identifica y valida los secretos filtrados en tu código base. [Solicita acceso a la vista previa][9].
+
+## Supply Chain Security
+Los desarrolladores están siendo blanco activo de ataques a la cadena de suministro. Evita que entren paquetes maliciosos en tus entornos de desarrollo con Datadog Supply Chain Security Firewall, disponible en GitHub.
+{{< callout url="https://docs.google.com/forms/d/1Xqh5h1n3-jC7au2t30fdTq732dkTJqt_cb7C7T-AkPc" >}}
+ Para inscribirte como socio de diseño, haz clic en Solicitar acceso.
+{{< /callout >}}
+
+
+## Referencias adicionales
+
+{{< partial name="whats-next/whats-next.html" >}}
+
[1]: /es/security/code_security/static_analysis/
[2]: /es/security/code_security/software_composition_analysis/
[3]: /es/security/code_security/iast/
[4]: /es/security/code_security/software_composition_analysis/setup_static/
[5]: /es/security/code_security/software_composition_analysis/setup_runtime/
[6]: /es/security/code_security/static_analysis/setup/
-[7]: /es/security/code_security/iast/setup/
\ No newline at end of file
+[7]: /es/security/code_security/iast/setup/
+[8]: /es/security/code_security/secret_scanning/
+[9]: https://www.datadoghq.com/product-preview/secret-scanning/
+[10]: /es/security/code_security/iac_security
\ No newline at end of file
diff --git a/content/es/security/detection_rules/_index.md b/content/es/security/detection_rules/_index.md
index 09f4af277b7aa..8e5fa216e48c4 100644
--- a/content/es/security/detection_rules/_index.md
+++ b/content/es/security/detection_rules/_index.md
@@ -23,44 +23,44 @@ products:
name: Cloud SIEM
url: /security/cloud_siem/
- icon: cloud-security-management
- name: Cloud Security Management
+ name: Cloud Security
url: /security/cloud_security_management/
- icon: app-sec
- name: Application Security Management
+ name: App and API Protection
url: /security/application_security/
title: Reglas de detección
---
{{< product-availability >}}
-Las reglas de detección definen una lógica condicional que se aplica a todas las configuraciones de logs y de la nube. Cuando al menos un caso definido en una regla coincide durante un periodo determinado, se genera una señal de seguridad. Puedes ver estas señales en el [Signals Explorer][1].
+Las reglas de detección definen una lógica condicional que se aplica a todas las configuraciones de logs y de la nube. Cuando al menos un caso definido en una regla coincide durante un periodo determinado, se genera una señal de seguridad. Puedes ver estas señales en el [Explorador de señales][1].
## Reglas de detección predefinidas
-Datadog ofrece [reglas de detección predefinidas][2] para detectar técnicas de ataque y posibles errores de configuración. Cuando se publican nuevas reglas de detección, se importan automáticamente a tu cuenta, a tu biblioteca de Application Security Management y al Agent, según tu configuración.
+Datadog ofrece [reglas de detección predefinidas][2] para detectar técnicas de ataque y posibles errores de configuración. Cuando se publican nuevas reglas de detección, se importan automáticamente a tu cuenta, a tu biblioteca de App and API Protection y al Agent, según tu configuración.
Las reglas predefinidas están disponibles para los siguientes productos de seguridad:
- [Cloud SIEM][3] utiliza la detección de logs para analizar logs ingeridos en tiempo real.
-- Cloud Security Management (CSM):
- - [CSM Misconfigurations][4] utiliza reglas de detección de configuración en la nube y configuración de infraestructura para escanear el estado de tu entorno en la nube.
- - [CSM Threats][5] utiliza las reglas de Datadog Agent y de detección para Monitor y evaluar activamente la actividad del sistema.
- - [CSM Identity Risks][6] utiliza reglas de detección para detectar riesgos basados en IAM en tu infraestructura en la nube.
-- [Application Security Management][7] (ASM) aprovecha Datadog [APM][8], el [Datadog Agent ][9] y las reglas de detección para detectar amenazas en tu entorno de aplicación.
+- Cloud Security:
+ - [Cloud Security Misconfigurations][4] utiliza reglas de detección de configuración en la nube y configuración de infraestructura para analizar el estado de tu entorno en la nube.
+ - [Workload Protection][5] utiliza las reglas del Agent y de detección para monitorizar activamente y evaluar la actividad del sistema.
+ - [Cloud Security Identity Risks][6] utiliza reglas de detección para detectar riesgos basados en IAM en tu infraestructura de nube.
+- [App and API Protection][7] (AAP) aprovecha Datadog [APM][8], el [Datadog Agent][9] y las reglas de detección para detectar amenazas en el entorno de tu aplicación.
-## Normas de detección beta
+## Reglas de detección beta
El equipo de investigación de seguridad de Datadog añade continuamente nuevas reglas de detección de seguridad predefinidas. Aunque el objetivo es ofrecer detecciones de alta calidad con el lanzamiento de integraciones u otras nuevas funciones, a menudo es necesario observar el rendimiento de la detección a escala antes de poner la regla a disposición general. De este modo, el equipo de investigación de seguridad de Datadog dispone del tiempo necesario para perfeccionar o eliminar las posibilidades de detección que no cumplan nuestras normas.
## Reglas de detección personalizadas
-Puede haber situaciones en las que debes personalizar una regla según tu entorno o carga de trabajo. Por ejemplo, si usas ASM, es posible que desees personalizar una regla de detección que detecte a los usuarios que realizan acciones confidenciales desde una geolocalización en la que no opera tu empresa.
+Puede haber situaciones en las que necesites personalizar una regla según tu entorno o carga de trabajo. Por ejemplo, si utilizas AAP, es posible que quieras personalizar una regla de detección que detecte a los usuarios que realizan acciones confidenciales desde una geolocalización en la que no opera tu empresa.
Para [crear reglas personalizadas](#create-detection-rules), puedes clonar las reglas por defecto y editar las copias, o crear tus propias reglas desde cero.
## Buscar y filtrar reglas de detección
-Para ver las reglas de detección predefinidas y personalizadas en Datadog, ve a la página [**Security Settings**][10] (Configuración de seguridad). Las reglas aparecen en páginas separadas para cada producto (Application Security, Cloud Security Management y Cloud SIEM).
+Para ver las reglas de detección predefinidas y personalizadas en Datadog, ve a la página [**Parámetros de seguridad**][10]. Las reglas aparecen en páginas separadas para cada producto (Application Security, Cloud Security Management y Cloud SIEM).
Para buscar y filtrar las reglas, utiliza el cuadro de búsqueda y las facetas para consultar por valor. Por ejemplo, para mostrar solo las reglas de un tipo de regla determinado, pasa el ratón por encima del tipo de regla y selecciona `only`. También puedes filtrar por facetas como `source` y `severity` al investigar y clasificar las incidencias entrantes.
@@ -73,9 +73,9 @@ Para crear una regla de detección personalizada, haz clic en el botón **New Ru
Para obtener instrucciones detalladas, consulta los siguientes artículos:
- [Cloud SIEM][11]
-- [ASM][12]
-- [CSM Misconfigurations][13]
-- [CSM Threats][14]
+- [AAP][12]
+- [Cloud Security Misconfigurations][13]
+- [Workload Protection][14]
## Gestionar las reglas de detección
@@ -109,13 +109,36 @@ Para eliminar una regla personalizada, haz clic en el menú vertical de tres pun
**Nota**: Solo puedes eliminar reglas personalizadas. Para eliminar una regla predeterminada, debes [desactivarla](#enable-or-disable-rules).
+### Consultar el historial de versiones de una regla
+
+{{< img src="/security/security_monitoring/detection_rules/rule_version_history_20250207.png" alt="Historial de versiones del compromiso de un token de acceso GitHub OAuth" style="width:80%;" >}}
+
+Utiliza el historial de versiones de reglas para:
+- Ver las versiones anteriores de una regla de detección y comprender los cambios a lo largo del tiempo.
+- Ver quién realizó los cambios para mejorar la colaboración.
+- Comparar versiones con diferencias para analizar las modificaciones y el impacto de los cambios.
+
+Para ver el historial de versiones de una regla:
+1. Ve a la página [Parámetros de seguridad][15]. En el panel de navegación izquierdo:
+ - Para AAP: Haz clic en **App and API Protection** y luego en **Detection Rules** (Reglas de detección).
+ - Para Cloud Security: Haz clic en **Cloud Security** y luego en **Threat Detection Rules** (Reglas de detección de amenazas).
+ - Para Cloud SIEM: Haz clic en **Cloud SIEM** y luego en **Detection Rules** (Reglas de detección).
+1. Haz clic en la regla que te interese.
+1. En el editor de reglas, haz clic en **Version History** (Historial de versiones) para ver los cambios anteriores.
+1. Haz clic en una versión concreta para ver los cambios realizados.
+1. Haz clic en **Open Version Comparison** (Abrir comparación de versiones) para ver los cambios entre versiones.
+1. Selecciona las dos versiones que quieres comparar.
+ - Los datos resaltados en rojo indican datos modificados o eliminados.
+ - Los datos resaltados en verde indican los datos añadidos.
+1. Haz clic en **Unified** (Unificado) si quieres ver la comparación en el mismo panel.
+
### Restringir permisos de edición
{{% security-products/detection-rules-granular-access %}}
### Ver las señales generadas
-Para ver las señales de seguridad de una regla en el [Signals Explorer][1], haz clic en el menú vertical de tres puntos y selecciona **View generated signals** (Ver señales generadas). Esto es útil cuando se correlacionan señales a través de múltiples fuentes por regla, o cuando se completa una auditoría de reglas.
+Para ver las señales de seguridad de una regla en el [Explorador de señales][1], haz clic en el menú vertical de tres puntos y selecciona **View generated signals** (Ver señales generadas). Esto es útil cuando se correlacionan señales a través de múltiples fuentes por regla, o cuando se completa una auditoría de reglas.
### Exportar una regla como JSON
@@ -129,7 +152,7 @@ El proceso de obsolescencia de las reglas es el siguiente:
1. La regla incluye una advertencia con la fecha de obsolescencia. En la interfaz de usuario, la advertencia se muestra en la:
- Sección **Rule Details > Playbook** (Detalles de la regla > Guía) del panel lateral de señales
- - Panel lateral de configuraciones erróneas (solo CSM Misconfigurations)
+ - Panel lateral de Misconfigurations (sólo Cloud Security Misconfigurations)
- [Editor de reglas][10] para esa regla específica
2. Una vez que la regla se vuelve obsoleta, transcurre un periodo de 15 meses antes de que se elimine la regla. Esto se debe al periodo de conservación de señales de 15 meses. Durante este tiempo, puedes volver a habilitar la regla [clonando la regla][2](#clone-a-rule) en la interfaz de usuario.
3. Una vez eliminada la regla, ya no podrás clonarla ni volver a activarla.
@@ -142,13 +165,14 @@ El proceso de obsolescencia de las reglas es el siguiente:
[2]: /es/security/default_rules/
[3]: /es/security/cloud_siem/
[4]: /es/security/cloud_security_management/misconfigurations/
-[5]: /es/security/threats/
+[5]: /es/security/workload_protection/
[6]: /es/security/cloud_security_management/identity_risks/
[7]: /es/security/application_security/
[8]: /es/tracing/
[9]: /es/agent/
[10]: https://app.datadoghq.com/security/configuration/
-[11]: /es/security/cloud_siem/log_detection_rules/
-[12]: /es/security/application_security/threats/custom_rules/
+[11]: /es/security/cloud_siem/detection_rules/
+[12]: /es/security/application_security/policies/custom_rules/
[13]: /es/security/cloud_security_management/misconfigurations/custom_rules
-[14]: /es/security/threats/workload_security_rules?tab=host#create-custom-rules
\ No newline at end of file
+[14]: /es/security/workload_protection/workload_security_rules?tab=host#create-custom-rules
+[15]: https://app.datadoghq.com/security/configuration/
\ No newline at end of file
diff --git a/content/es/serverless/aws_lambda/installation/_index.md b/content/es/serverless/aws_lambda/installation/_index.md
index f7199dfe9656e..cc2fe9ad9c915 100644
--- a/content/es/serverless/aws_lambda/installation/_index.md
+++ b/content/es/serverless/aws_lambda/installation/_index.md
@@ -16,18 +16,22 @@ title: Instalar Serverless Monitoring para AWS Lambda
Si estás dando tus primeros pasos en Datadog, [regístrate para obtener una cuenta de Datadog][1] y luego sigue las instrucciones de instalación del Datadog Agent para [AWS Lambda][2] de modo que puedas instrumentar tu función de Lambda y lograr un inicio rápido con Datadog. Completar estos pasos configura tus funciones de Lambda para enviar métricas, logs y trazas (traces) a Datadog en tiempo real.
-{{< beta-callout-private url="https://docs.google.com/forms/d/e/1FAIpQLScw8XBxCyN_wjBVU2tWm-zX5oPIGF7BwUKcLSHY6MJsem259g/viewform?usp=sf_link" >}}
-¿Te interesa instrumentar funciones de AWS Lambda de forma masiva directamente desde la interfaz de usuario de Datadog? Para participar, solicita acceso a la próxima fase beta privada de instrumentación de Lambda en remoto.
-{{< /beta-callout-private >}}
+En GitHub hay
disponible una aplicación de ejemplo con instrucciones sobre cómo desplegarla con múltiples tiempos de ejecución y herramientas de infraestructura como código.
El proceso de inicio rápido configura tus funciones de Lambda de forma temporal. Para instrumentar funciones de Lambda de forma permanente, consulta las instrucciones de instalación detalladas en la siguiente sección.
## Instrucciones de instalación
-Para obtener instrucciones de instalación detalladas, selecciona el tiempo de ejecución de Lambda a continuación:
+Para los tiempos de ejecución de Node.js y Python, puedes utilizar la [instrumentación remota][5] para añadir instrumentación a tus funciones de AWS Lambda y mantenerlas instrumentadas de forma segura. Consulta [Instrumentación remota para AWS Lambda][5].
+
+Para otros tiempos de ejecución de Lambda (o para instrumentar tus funciones de Node.js o Python sin instrumentación remota) consulta las instrucciones de instalación detalladas:
{{< partial name="serverless/getting-started-languages.html" >}}
+## Soporte para el cumplimiento de FIPS
+
+Datadog proporciona monitorización conforme a FIPS para las funciones de AWS Lambda a través de capas de extensión de Lambda conformes a FIPS dedicadas y configuraciones específicas del tiempo de ejecución. Los componentes conformes con FIPS implementan criptografía certificada por FIPS y funcionan con cualquier sitio de Datadog, pero el cumplimiento de FIPS de extremo a extremo requiere el uso del sitio US1-FED. Si necesitas mantener la conformidad con FIPS mientras monitorizas tus funciones de Lambda, consulta la página de documentación [AWS Lambda FIPS Compliance][4] para obtener más detalles.
+
## Configuraciones avanzadas
Una vez finalizada la instalación y configurada la recopilación de telemetría, puedes utilizar las [configuraciones avanzadas][3] para hacer lo siguiente:
@@ -44,4 +48,6 @@ Una vez finalizada la instalación y configurada la recopilación de telemetría
[1]: https://app.datadoghq.com/signup/
[2]: https://app.datadoghq.com/signup/agent#lambda
-[3]: /es/serverless/configuration/
\ No newline at end of file
+[3]: /es/serverless/configuration/
+[4]: /es/serverless/aws_lambda/fips-compliance/
+[5]: /es/serverless/aws_lambda/remote_instrumentation
\ No newline at end of file
diff --git a/content/es/serverless/azure_functions/_index.md b/content/es/serverless/azure_functions/_index.md
index 07abc4300f3e2..53a5a0e09590e 100644
--- a/content/es/serverless/azure_functions/_index.md
+++ b/content/es/serverless/azure_functions/_index.md
@@ -3,11 +3,11 @@ title: Instala la monitorización serverless para Azure Functions
---
## Información general
-En esta página se explica cómo recopilar trazas (traces), rastrear métricas, métricas de tiempo de ejecución y métricas personalizadas de Azure Functions. Para recopilar métricas adicionales, instala la [integración de Datadog Azure][6].
+En este Page ( página) se explica cómo recopilar trazas, métricas de trace (traza), métricas de tiempo de ejecución y métricas personalizadas de sus Azure Functions. Para recopilar métricas adicionales, instale la [Datadog integración de Azure][5].
## Configuración
-{{< programming-lang-wrapper langs="nodejs,python" >}}
+{{< programming-lang-wrapper langs="nodejs,python,java,dotnet" >}}
{{< programming-lang lang="nodejs" >}}
1. **Instala dependencias**. Ejecuta los siguientes comandos:
```shell
@@ -15,11 +15,9 @@ En esta página se explica cómo recopilar trazas (traces), rastrear métricas,
npm install dd-trace
```
- Para usar la [instrumentación automática][1], utiliza `dd-trace` v5.25+.
-
Datadog recomienda anclar las versiones de paquete y actualizar periódicamente a las últimas versiones de `@datadog/serverless-compat` y de `dd-trace` para asegurarte de tener acceso a las mejoras y correcciones de errores.
-2. **Inicia la capa de compatibilidad serverless de Datadog e inicializa el rastreador de Node.js**. Añade las siguientes líneas al archivo de punto de entrada de tu aplicación principal (por ejemplo, `app.js`):
+2. **Inicie la capa de compatibilidad sin servidor Datadog e inicialice el trazador Node.js Datadog **. Añade las siguientes líneas al archivo de punto de entrada de tu aplicación principal (por ejemplo, `app.js`):
```js
require('@datadog/serverless-compat').start();
@@ -28,13 +26,11 @@ En esta página se explica cómo recopilar trazas (traces), rastrear métricas,
const tracer = require('dd-trace').init()
```
-3. (Opcional) **Habilita las métricas del tiempo de ejecución**. Consulta [Métricas del tiempo de ejecución de Node.js][2].
+3. **Configurar el trazador Datadog Node.js**
-4. (Opcional) **Habilita métricas personalizadas**. Consulta [Presentación de métricas: DogStatsD][3].
+ [Configuración de la biblioteca de seguimiento de Node.js][1]
-[1]: /es/tracing/trace_collection/automatic_instrumentation/?tab=singlestepinstrumentation
-[2]: /es/tracing/metrics/runtime_metrics/nodejs/?tab=environmentvariables
-[3]: /es/metrics/custom_metrics/dogstatsd_metrics_submission/?code-lang=nodejs
+[1]:/es/tracing/trace_collection/library_config/nodejs
{{< /programming-lang >}}
{{< programming-lang lang="python" >}}
1. **Instala dependencias**. Ejecuta los siguientes comandos:
@@ -43,27 +39,126 @@ En esta página se explica cómo recopilar trazas (traces), rastrear métricas,
pip install ddtrace
```
- Para usar la [instrumentación automática][1], utiliza `dd-trace` v2.19+.
-
Datadog recomienda utilizar las últimas versiones de `datadog-serverless-compat` y de `ddtrace` para asegurarte de tener acceso a las mejoras y correcciones de errores.
-2. **Inicializa el rastreador de Datadog Python y la capa de compatibilidad serverless**. Añade las siguientes líneas al archivo de punto de entrada de tu aplicación principal:
+2. **Inicie Datadog Serverless Compatibility Layer e inicialice Datadog Python tracer**. Añade las siguientes líneas al archivo de punto de entrada de tu aplicación principal:
```python
from datadog_serverless_compat import start
- from ddtrace import tracer, patch_all
+ import ddtrace.auto
start()
- patch_all()
```
-3. (Opcional) **Habilita las métricas del tiempo de ejecución**. Consulta [Métricas del tiempo de ejecución de Python][2].
+3. **Configurar el trazador Python Datadog **
-4. (Opcional) **Habilita métricas personalizadas**. Consulta [Presentación de métricas: DogStatsD][3].
+ [Configuración de la biblioteca de seguimiento de Python][1]
-[1]: /es/tracing/trace_collection/automatic_instrumentation/?tab=singlestepinstrumentation
-[2]: /es/tracing/metrics/runtime_metrics/python/
-[3]: /es/metrics/custom_metrics/dogstatsd_metrics_submission/?code-lang=python
+[1]:/es/tracing/trace_collection/library_config/python
+{{< /programming-lang >}}
+{{< programming-lang lang="java" >}}
+1. **Instalar dependencias**. Descarga los JAR de Datadog y despliégalos con tu función:
+ ```bash
+ wget -O dd-java-agent.jar 'https://dtdg.co/latest-java-tracer'
+ wget -O dd-serverless-compat-java-agent.jar 'https://dtdg.co/latest-serverless-compat-java-agent'
+ ```
+ Ver Datadog's [Maven Repository][1] para cualquier versión específica de Datadog Serverless Compatibility Layer.
+
+ Datadog recomienda actualizar periódicamente las versiones más recientes de `dd-serverless-compat-java-agent` y `dd-java-agent` para garantizar el acceso a las mejoras y correcciones de errores.
+
+2. **Inicie la capa de compatibilidad sin servidor Datadog e inicialice el rastreador Java Datadog **. Añade los siguientes argumentos `-javaagent` a las opciones de la JVM.:
+
+ ```bash
+ -javaagent:/path/to/dd-serverless-compat-java-agent.jar -javaagent:/path/to/dd-java-agent.jar
+ ```
+
+ **Nota**: la variable de entorno para establecer las opciones de JVM depende del plan de alojamiento (por ejemplo, Consumo, Elastic Premium, Dedicado). Consulte [Azure Functions Java developer guide][2] para obtener más detalles sobre la variable de entorno adecuada para su plan de alojamiento.
+
+3. **Configurar el trazador Java Datadog **
+
+ [Configuración de la biblioteca de seguimiento de Java][3]
+
+[1]: https://repo1.maven.org/maven2/com/datadoghq/dd-serverless-compat-java-agent/
+[2]: https://learn.microsoft.com/en-us/azure/azure-functions/functions-reference-java?tabs=bash%2Cconsumption#customize-jvm
+[3]: /es/tracing/trace_collection/library_config/java
+{{< /programming-lang >}}
+{{< programming-lang lang="dotnet" >}}
+1. **Instala dependencias**. Ejecuta los siguientes comandos:
+ ```shell
+ dotnet package add Datadog.Azure.Functions
+ ```
+
+ Datadog recomienda actualizar periódicamente a la última versión de `Datadog.AzureFunctions` para asegurarse de tener acceso a las mejoras y correcciones de errores.
+
+2. **Inicie la capa de compatibilidad sin servidor Datadog **.
+
+ Si su aplicación Azure Function utiliza el modelo Isolated Worker, añada las siguientes líneas a su archivo de punto de entrada de la aplicación principal:
+ ```csharp
+ Datadog.Serverless.CompatibilityLayer.Start();
+ ```
+
+ Si su aplicación Azure Function utiliza el modelo In-Process, añada una referencia de paquete NuGet a `Microsoft.Azure.Functions.Extensions`:
+ ```shell
+ dotnet package add Microsoft.Azure.Functions.Extensions
+ ```
+
+ Y añade el siguiente archivo `.cs` a tu aplicación:
+ ```csharp
+ using Datadog.Serverless;
+ using Microsoft.Azure.Functions.Extensions.DependencyInjection;
+
+ [assembly: FunctionsStartup(typeof(MyFunctionApp.Startup))]
+
+ namespace MyFunctionApp
+ {
+ public class Startup : FunctionsStartup
+ {
+ public override void Configure(IFunctionsHostBuilder builder)
+ {
+ Datadog.Serverless.CompatibilityLayer.Start();
+ }
+ }
+ }
+ ```
+
+3. **Configurar Instrumentación Automática**
+
+ Si su aplicación Azure Function se ejecuta en Windows, añada las siguientes variables de entorno a su aplicación Function:
+ ```
+ CORECLR_ENABLE_PROFILING=1
+
+ CORECLR_PROFILER={846F5F1C-F9AE-4B07-969E-05C26BC060D8}
+
+ CORECLR_PROFILER_PATH_64=
+ C:\home\site\wwwroot\datadog\win-x64\Datadog.Trace.ClrProfiler.Native.dll
+
+ CORECLR_PROFILER_PATH_32=
+ C:\home\site\wwwroot\datadog\win-x86\Datadog.Trace.ClrProfiler.Native.dll
+
+ DD_DOTNET_TRACER_HOME=C:\home\site\wwwroot\datadog
+
+ ```
+
+ Si su aplicación Azure Function se ejecuta en Linux, añada las siguientes variables de entorno a su aplicación Function:
+ ```
+ CORECLR_ENABLE_PROFILING=1
+
+ CORECLR_PROFILER={846F5F1C-F9AE-4B07-969E-05C26BC060D8}
+
+ CORECLR_PROFILER_PATH=
+ /home/site/wwwroot/datadog/linux-x64/Datadog.Trace.ClrProfiler.Native.so
+
+ DD_DOTNET_TRACER_HOME=/home/site/wwwroot/datadog
+
+ ```
+
+4. **Configurar el trazador Datadog.NET**
+
+ - [Configuración de la biblioteca de rastreo de .NET Core][1]
+ - [Configuración de la biblioteca de seguimiento de .NET Framework][2]
+
+[1]:/es/tracing/trace_collection/library_config/dotnet-core
+[2]:/es/tracing/trace_collection/library_config/dotnet-framework
{{< /programming-lang >}}
{{< /programming-lang-wrapper >}}
@@ -73,37 +168,27 @@ En esta página se explica cómo recopilar trazas (traces), rastrear métricas,
| Nombre | Valor |
| ---- | ----- |
- | `DD_API_KEY` | Tu [Clave de la API de Datadog][1]. |
+ | `DD_API_KEY` | Tu [clave de API Datadog][1]. |
| `DD_SITE` | Tu [sitio Datadog][2]. Por ejemplo, {{< region-param key=dd_site code="true" >}}. |
-7. **Configura el etiquetado de servicios unificado**. Puedes recopilar métricas desde tu Azure Functions mediante la instalación de la [integración de Datadog Azure][6]. Para correlacionar estas métricas con tu trazas (traces), primero configura las etiquetas (tags) `env`, `service` y `version` en tu recurso en Azure . A continuación, configura las siguientes variables de entorno. Puedes añadir etiquetas (tags) personalizados como `DD_TAGS`.
+7. **Configure el etiquetado de servicios unificados**. Puede recopilar métricas de sus funciones de Azure instalando la integración de Azure [Datadog ][5]. Para correlacionar estas métricas con sus trazas, primero configure las etiquetas `env`, `service`, y `version` en su recurso en Azure. A continuación, configura las siguientes variables de entorno.
| Nombre | Valor |
| ---- | ----- |
- | `DD_ENV` | Cómo deseas etiquetar tu variable de entorno para el [etiquetado de servicios unificado][9]. Por ejemplo, `prod`. |
- | `DD_SERVICE` | Cómo deseas etiquetar tu servicio para el [etiquetado de servicios unificado][9]. |
- | `DD_VERSION` | Cómo deseas etiquetar tu versión para el [etiquetado de servicios unificado][9]. |
- | `DD_TAGS` | Tus etiquetas (tags) personalizadas separadas por comas. Por ejemplo, `key1:value1,key2:value2`. |
+ | `DD_ENV` | Cómo quiere etiquetar su env para [Unified Service Tagging][7]. Por ejemplo, `prod`. |
+ | `DD_SERVICE` | Cómo desea etiquetar su servicio para [Unified Service Tagging][7]. |
+ | `DD_VERSION` | Cómo desea etiquetar su versión para [Etiquetado de Servicio Unificado][7]. |
## ¿Qué toca hacer ahora?
-- Puedes ver tus trazas (traces) de Azure Functions en [Trace Explorer][4]. Busca por el nombre del servicio que configuraste en la variable de entorno `DD_SERVICE` para ver tus trazas (traces).
-- Puedes utilizar la página [Serverless > Azure Funcitons][5] para ver tus trazas (traces) enriquecidas con la telemetría recopilada por la [integración de Datadog Azure][6].
-
-### Activa/desactiva métricas de trazas (traces)
-
-Las [métricas de trazas (traces)][3] están activados en forma predeterminada. Para configurar métricas de trazas, utiliza la siguiente variable de entorno:
-
-`DD_TRACE_STATS_COMPUTATION_ENABLED`
-: Activa (`true`) o desactiva (`false`) métricas de trazas. El valor predeterminado es `true`.
-
- **Valores**: `true`, `false`
+- Puede ver sus trazas de Azure Functions en [trace (traza) Explorer ][3]. Busque el nombre del servicio que estableció en la variable de entorno `DD_SERVICE` para ver sus trazas.
+- Puedes utilizar [Serverless > Azure Functions][4] Page ( página) para ver tus trazas enriquecidas con telemetría recogida por la [Datadog Azure integration][5].
## Solucionar problemas
### Activa logs de depuración
-Puedes recopilar [logs de depuración][7] para solucionar problemas. Para configurar logs de depuración, utiliza las siguientes variables de entorno:
+Puede recopilar [registros de depuración][6] para solucionar problemas. Para configurar los registros de depuración, utilice las siguientes variables de entorno:
`DD_TRACE_DEBUG`
: Activa (`true`) o desactiva (`false`) el registro de depuración para la biblioteca de Datadog Tracing. El valor predeterminado es `false`.
@@ -115,17 +200,10 @@ Puedes recopilar [logs de depuración][7] para solucionar problemas. Para config
**Valores**: `trace`, `debug`, `info`, `warn`, `error`, `critical`, `off`
-### Planes de Linux Consumption y acciones de GitHub
-
-Para utilizar una acción de GitHub para desplegar en una función de Linux Consumption, configura tu flujo de trabajo para utilizar un Azure Service Principal para RBAC. Consulta [Utilizar Azure Service Principal para RBAC como credencial de despliegue][8].
-
-
[1]: /es/account_management/api-app-keys/#add-an-api-key-or-client-token
[2]: /es/getting_started/site
-[3]: /es/tracing/metrics/metrics_namespace/
-[4]: https://app.datadoghq.com/apm/traces
-[5]: https://app.datadoghq.com/functions?cloud=azure&entity_view=function
-[6]: /es/integrations/azure/
-[7]: /es/tracing/troubleshooting/tracer_debug_logs/#enable-debug-mode
-[8]: https://github.com/Azure/functions-action?tab=readme-ov-file#using-azure-service-principal-for-rbac-as-deployment-credential
-[9]: /es/getting_started/tagging/unified_service_tagging/
\ No newline at end of file
+[3]: https://app.datadoghq.com/apm/traces
+[4]: https://app.datadoghq.com/functions?cloud=azure&entity_view=function
+[5]: /es/integrations/azure/
+[6]: /es/tracing/troubleshooting/tracer_debug_logs/#enable-debug-mode
+[7]: /es/getting_started/tagging/unified_service_tagging/
\ No newline at end of file
diff --git a/content/es/service_management/events/pipelines_and_processors/lookup_processor.md b/content/es/service_management/events/pipelines_and_processors/lookup_processor.md
index 3c6a3c4b68e72..6462ec5d32fb4 100644
--- a/content/es/service_management/events/pipelines_and_processors/lookup_processor.md
+++ b/content/es/service_management/events/pipelines_and_processors/lookup_processor.md
@@ -19,8 +19,7 @@ El procesador de búsqueda realiza las siguientes acciones:
**Tabla de referencia**
- {{< img src="logs/log_configuration/processor/lookup_processor_reference_table.png" alt="Procesador de búsqueda"
- style="width:80%;">}}
+ {{< img src="logs/log_configuration/processor/lookup_processor_reference_table.png" alt="Procesador de búsqueda" style="width:80%;" >}}
El límite de tamaño de la tabla de asignación es de 100 kB. Este límite se aplica a todos los procesadores de búsqueda de la plataforma. Sin embargo, las tablas de referencia admiten archivos de mayor tamaño.
diff --git a/content/es/synthetics/guide/uptime-percentage-widget.md b/content/es/synthetics/guide/uptime-percentage-widget.md
index fd901ecabb881..77254c73656a9 100644
--- a/content/es/synthetics/guide/uptime-percentage-widget.md
+++ b/content/es/synthetics/guide/uptime-percentage-widget.md
@@ -9,6 +9,9 @@ further_reading:
- link: /getting_started/synthetics/
tag: Documentación
text: Empezando con Synthetic Monitoring
+- link: https://www.datadoghq.com/blog/slo-synthetic-monitoring/
+ tag: Blog
+ text: Mejorar la precisión y el rendimiento de los SLOs con Datadog Synthetic Monitoring
title: Monitorizar tiempos de actividad de sitios web con SLOs
---
@@ -18,7 +21,7 @@ Para poder cumplir los acuerdos de nivel del servicio suscritos con clientes int
A continuación, te mostramos cómo lograrlo con la herramienta [Synthetic Monitoring][1] y el [widget de objetivos de nivel del servicio ][2] (SLOs). Para ello, usaremos `http://example.com/` como ejemplo.
-## Crear un test de Synthetics
+## Cree una supervisión en Synthetic Monitoring test
Para crear un [test de API de Synthetics][3] con `http://example.com/`, consulta [Crear un test de API simple][4].
@@ -37,7 +40,7 @@ Al hacer clic en **Test URL** (Probar URL), se rellenan las aserciones sobre el
{{< img src="synthetics/guide/uptime_slo/slo_target.png" alt="Objetivo del SLO" >}}
-4. Introduce un nombre, un mensaje y las etiquetas para detallar más el SLO.
+4. Introduce un nombre, un mensaje y las etiquetas (tags) para detallar más el SLO.
{{< img src="synthetics/guide/uptime_slo/slo_notif.png" alt="Notificación del SLO" >}}
diff --git a/content/es/tests/correlate_logs_and_tests/_index.md b/content/es/tests/correlate_logs_and_tests/_index.md
index de8f9cda263a5..034e9e4883b5e 100644
--- a/content/es/tests/correlate_logs_and_tests/_index.md
+++ b/content/es/tests/correlate_logs_and_tests/_index.md
@@ -11,8 +11,7 @@ title: Correlacionar logs y tests
Puedes correlacionar los datos de Test Optimization con [logs inyectados en Datadog][1], lo que te permite ver y analizar logs para casos de tests específicos.
-{{< img src="continuous_integration/correlate_logs_and_tests.png"
- alt="Examinar logs para casos de tests específicos con la correlación de logs y tests." style="width:90%" >}}
+{{< img src="continuous_integration/correlate_logs_and_tests.png" alt="Examinar logs para casos de tests específicos con la correlación de logs y tests." style="width:90%" >}}
## Configuración
diff --git a/content/es/tracing/dynamic_instrumentation/_index.md b/content/es/tracing/dynamic_instrumentation/_index.md
new file mode 100644
index 0000000000000..a0b14fe3cc774
--- /dev/null
+++ b/content/es/tracing/dynamic_instrumentation/_index.md
@@ -0,0 +1,240 @@
+---
+aliases:
+- /es/dynamic_instrumentation/how-it-works/
+- /es/dynamic_instrumentation/
+further_reading:
+- link: /dynamic_instrumentation/expression-language/
+ tag: Documentación
+ text: Más información sobre el lenguaje de expresión de Dynamic Instrumentation
+- link: dynamic_instrumentation/sensitive-data-scrubbing/
+ tag: Documentación
+ text: Eliminación de información confidencial de los datos de Dynamic Instrumentation
+- link: /tracing/trace_collection/dd_libraries
+ tag: Documentación
+ text: Más información sobre cómo instrumentar tu aplicación
+- link: /getting_started/tagging/unified_service_tagging/
+ tag: Documentación
+ text: Etiquetado de servicios unificado
+- link: /tracing/software_catalog/
+ tag: Documentación
+ text: Descubrir y catalogar los servicios que informan a Datadog
+- link: /metrics
+ tag: Documentación
+ text: Más información sobre métricas
+- link: https://www.datadoghq.com/blog/dynamic-instrumentation-application-logging/
+ tag: Blog
+ text: Utilizar Datadog Dynamic Instrumentation para añadir logs de aplicación sin
+ volver a desplegarlos
+is_beta: false
+private: false
+title: Instrumentación dinámica
+---
+
+{{% site-region region="gov" %}}
+
+ Dynamic Instrumentation no es compatible con el
sitioDatadog seleccionado ({{< region-param key="dd_site_name" >}}), ya que requiere que
la configuración remota esté activada.
+
+{{% /site-region %}}
+
+## Resumen
+
+Dynamic Instrumentation le permite añadir instrumentación en sus sistemas de producción en ejecución sin necesidad de reiniciar y en cualquier ubicación del código de su aplicación, incluyendo librerías de terceros. Puede añadir o modificar telemetría para logs, métricas, spans, y el etiquetado correspondiente, desde la interfaz de usuario de Datadog. Dynamic Instrumentation tiene una baja sobrecarga y no tiene efectos secundarios en su sistema.
+
+Si estás interesado en probar las últimas mejoras de la experiencia de usuario para Dynamic Instrumentation, considera la posibilidad de participar en la [Vista previa de autocompletar y búsqueda][17].
+
+## Introducción
+
+### Requisitos previos
+
+Dynamic Instrumentation requiere lo siguiente:
+
+- [Datadog Agent][1] 7.45.0 o superior esté instalado junto a su servicio.
+- [Configuración remota][2] esté habilitada en ese Agent.
+- Para aplicaciones Java, la biblioteca de seguimiento [`dd-trace (traza)-java`][3] 1.34.0 o superior.
+- Para aplicaciones Python, la biblioteca de seguimiento [`dd-trace (traza)-py`][4] 2.2.0 o superior.
+- Para aplicaciones .NET, biblioteca de seguimiento [`dd-trace (traza)-dotnet`][5] 2.54.0 o superior.
+- (Vista previa limitada) Para aplicaciones Node.js, biblioteca de seguimiento [`dd-trace (traza)-js`][18] 5.39.0 o superior.
+- (Vista previa limitada) Para aplicaciones Ruby, biblioteca de seguimiento [`dd-trace (traza)-rb`][19] 2.9.0 o superior.
+- (Vista previa limitada) Para aplicaciones PHP, biblioteca de seguimiento [`dd-trace (traza)-php`][20] 1.5.0 o superior.
+- Las etiquetas [Unified Service Tagging][6] `service`, `env`, y `version` se aplican a su implementación.
+- Recomendado, [autocompletar y buscar (en Vista previa)][17] está activado.
+- Recomendado, [source (fuente) Integración de código][7] está configurado para su servicio.
+- Se requiere el permiso **Dynamic Instrumentation Read Configuration** (`debugger_read`) para acceder a la página Dynamic Instrumentation. Page ( página)
+- El permiso **Dynamic Instrumentation Escribir Configuración** (`debugger_write`) es necesario para crear o modificar instrumentaciones.
+- El permiso **Dynamic Instrumentation Capturar Variables** (`debugger_capture_variables`) es necesario para utilizar la opción **Capturar parámetros de métodos y variables locales**.
+
+ Para más información sobre roles y sobre cómo asignar roles a los usuarios, consulta [Control de acceso basado en roles][8].
+
+### Crear un índice logs
+
+Dynamic Instrumentation crea " logs dinámicos" que se envían a Datadog y aparecen junto a los de su aplicación habitual logs.
+
+Si utiliza [Filtros de exclusión][9], asegúrese de que Dynamic Instrumentation log s no se filtren:
+
+1. Cree un índice logs y [configúrelo][10] con la retención deseada con **sin muestreo**.
+2. 2. Configure el filtro para que coincida con la etiqueta `source (fuente):dd_debugger`. Todos los Dynamic Instrumentation log s tienen esta source (fuente).
+3. Asegúrese de que el nuevo índice tiene prioridad sobre cualquier otro con filtros que coincidan con esa etiqueta, porque la primera coincidencia gana.
+
+### Habilitar Dynamic Instrumentation
+
+Para habilitar Dynamic Instrumentation en un servicio, vaya a [in-app setup Page ( página)][16].
+
+Para obtener instrucciones más detalladas, seleccione su tiempo de ejecución a continuación:
+
+{{< partial name="dynamic_instrumentation/dynamic-instrumentation-languages.html" >}}
+
+
+### Limitaciones
+
+- Dynamic Instrumentation aún no es compatible con Azure App Services o entornos sin servidor.
+- La compatibilidad total solo está disponible para aplicaciones creadas con Python, Java y .NET.
+- Existen vistas previas limitadas para aplicaciones creadas con Node.js, Ruby y PHP.
+- La biblioteca de seguimiento de Java no es compatible con las coroutines de Kotlin.
+
+## Explorar Dynamic Instrumentation
+
+Dynamic Instrumentation puede ayudarte a entender lo que tu aplicación está haciendo en tiempo de ejecución. Al añadir una sonda Dynamic Instrumentation estás exportando datos adicionales de tu aplicación, sin necesidad de cambiar el código o volver a desplegarlo.
+
+### Uso de sondas
+
+Una sonda te permite recoger datos de puntos específicos de tu código sin detener la ejecución del programa.
+
+Piense en el uso de sondas como una mejora de su capacidad de observación mediante la adición de logs dinámicas, métricas y periodos a una aplicación en ejecución sin necesidad de cambiar el código, desplegarlo o reiniciar un servicio. Puede recopilar datos inmediatamente sin perturbar la experiencia del usuario ni requerir despliegues prolongados.
+
+Como desarrollador, también puede pensar en una sonda como un "punto de interrupción sin ruptura". En la depuración tradicional, un punto de interrupción es un punto del programa en el que se detiene la ejecución, lo que permite al desarrollador inspeccionar el estado del programa en ese punto. Sin embargo, en entornos de producción reales, no es práctico ni posible detener la ejecución del programa. Las sondas llenan este vacío permitiendo inspeccionar el estado de las variables en entornos de producción de forma no intrusiva.
+
+### Creación de una sonda
+
+Todos los tipos de sonda requieren la misma configuración inicial:
+
+1. Vaya a [Dynamic Instrumentation Page ( página) ][12].
+1. Haga clic en **Crear sonda** en la parte superior derecha, o haga clic en el menú de tres puntos en un servicio y seleccione **Añadir una sonda para este servicio**.
+1. Si no están rellenados previamente, elija el servicio, el tiempo de ejecución, el entorno y la versión.
+1. En el código source (fuente), especifique dónde establecer la sonda seleccionando una clase y un método o un archivo y una línea de source (fuente). Si has optado por [autocompletar y buscar Vista previa][17], autocompletar muestra sugerencias para seleccionar una clase o un método.
+
+Consulte los tipos de sonda individuales a continuación para ver los pasos de creación específicos para cada tipo de sonda.
+
+También puede crear una sonda desde estos otros contextos:
+
+Perfiles
+: En un gráfico de llama del perfilador, puede crear una sonda para un método seleccionando **Instrumentar este marco con una sonda** en el menú contextual del marco.
+
+Error Tracking
+: En una pila trace (traza), sitúe el ratón sobre un marco de pila y haga clic en **Instrumentar**. Esto rellena previamente el formulario de creación de sonda con el contexto de la Emisión.
+
+
+### Creación de sondas log
+
+Una * sondalog * emite un log cuando se ejecuta.
+
+Para crear una sonda log:
+
+1. Selecciona **log** como tipo de sonda.
+1. Complete la [configuración genérica de la sonda](#creating-a-probe) (elija el servicio, el entorno, la versión y la ubicación de la sonda).
+1. Define una plantilla de mensaje log. Puede utilizar el lenguaje de expresión Dynamic Instrumentation para referenciar valores del contexto de ejecución.
+1. (En Preview) Opcionalmente habilita la captura de datos extra de la sonda.
+1. Opcionalmente, define una condición utilizando el lenguaje de expresión Dynamic Instrumentation. El mensaje log se emite cuando la expresión se evalúa como verdadera.
+
+log Las sondas se activan por defecto en todas las instancias de servicio que coincidan con el entorno y la versión especificados. Su velocidad de ejecución está limitada a un máximo de 5000 veces por segundo, en cada instancia de su servicio.
+
+Debe establecer una plantilla de mensaje log en cada sonda log. La plantilla admite la inclusión de [expresiones][15] entre llaves. Por ejemplo: `User {user.id} purchased {count(products)} products`.
+
+También puede establecer una condición en una sonda log utilizando el [lenguaje de expresiones][15]. La expresión debe evaluarse como booleana. La sonda se ejecuta si la expresión es verdadera, y no captura ni emite ningún dato si la expresión es falsa.
+
+{{< img src="dynamic_instrumentation/log_probe.png" alt="Creating a Dynamic Instrumentation log probe" >}}
+
+(En vista previa) Si activa **Capturar parámetros de método y variables locales** en la sonda log, todo el contexto de ejecución se añade al evento log:
+ - **argumentos de método**, **variables locales** y **campos**, con los siguientes límites predeterminados:
+ - Seguir referencias a tres niveles de profundidad (configurable en la UI).
+ - Los 100 primeros elementos dentro de colecciones.
+ - Los primeros 255 caracteres para valores de cadena.
+ - 20 campos dentro de objetos. Los campos estáticos no se recogen.
+ - Llamada a **pila trace (traza)**.
+ - **excepciones capturadas y no capturadas**.
+
+Las sondas con esta opción activada están limitadas a un acierto por segundo.
+
+Advertencia: Los datos capturados pueden contener información sensible, incluyendo datos personales, contraseñas y secretos como claves AWS.
Para garantizar que esta información se redacta correctamente:
+- Datadog Dynamic Instrumentation emplea varias técnicas para redactar la información sensible. Para obtener más información sobre los mecanismos predeterminados o sobre cómo ampliarlos para satisfacer sus necesidades, lea Depuración de datos confidenciales.
+- Desactive la opción Capturar parámetros de método y variables locales y seleccione explícitamente las variables que desea incluir en la plantilla de mensaje log. Hacer esto garantiza que las sondas de log contengan sólo datos relacionados con las variables que identifiques específicamente, reduciendo así el riesgo de fugas involuntarias de datos sensibles.
+- Si eres el administrador de tu cuenta Datadog y quieres evitar que otros usuarios puedan utilizar la opción Capturar parámetros de método y variables locales, puedes revocarles el permiso Dynamic Instrumentation Capturar variables
(debugger_capture_variables
).
Alternativamente, si necesita log estos datos pero desea mitigar el riesgo asociado a que sean accesibles en el producto Datadog, puede limitar qué usuarios de su organización pueden ver los datos capturados configurando una consulta de Restricción en source (fuente):dd_debugger
.
+
+### Creación de sondeos de métrica
+
+Un *sondeo de métrica* emite una métrica cuando se ejecuta.
+
+Para crear un sondeo de métrica:
+
+1. Selecciona **Metric** (Métrica) como tipo de sondeo.
+1. Completa la [configuración genérica del sondeo](#creating-a-probe) (elige un servicio, entorno, versión y localización del sondeo).
+1. Especifica un nombre para la métrica, que llevará el prefijo `dynamic.instrumentation.metric.probe.`.
+1. Selecciona un tipo de métrica (recuento, gauge, o histograma).
+1. Elige el valor de la métrica con el [lenguaje de expresión de Dynamic Instrumentation][15]. Puedes usar cualquier valor numérico que quieras del contexto de ejecución, como un parámetro de método, una variable local, un campo de clase o una expresión que produzca un valor numérico. Esto es opcional en el caso de las métricas de recuento, y si lo omites, cada invocación incrementará el recuento en uno.
+
+{{< img src="dynamic_instrumentation/metric_probe.png" alt="Creación de un sondeo de métrica de Dynamic Instrumentation" >}}
+
+Los sondeos de métrica se habilitan de manera automática en todas las instancias de servicio que coinciden con la versión y entorno configurados. Los sondeos de métrica no están limitados por la frecuencia y se ejecutan cada vez que se invoca el método o la línea.
+
+Los sondeos de métrica de Dynamic Instrumentation admiten los siguientes tipos de métricas:
+
+- **Recuento**: cuenta la cantidad de veces que se ejecuta una línea o método determinado. Se puede combinar con [expresiones de métricas][15] para usar el valor de una variable a fin de incrementar el recuento.
+- **Gauge**: genera un gauge basado en el último valor de una variable. Esta métrica requiere una [expresión de métrica][15].
+- **Histograma**: genera una distribución estadística de una variable. Esta métrica requiere una [expresión de métrica][15].
+
+### Creación de sondeos de tramo
+
+Un *sondeo de tramo* emite un tramo cuando se ejecuta un método.
+
+Para crear un sondeo de tramo:
+
+1. Selecciona **Span** (Tramo) como tipo de sondeo.
+1. Completa la [configuración genérica del sondeo](#creating-a-probe) (elige un servicio, entorno, versión y localización del sondeo).
+
+{{< img src="dynamic_instrumentation/span_probe.png" alt="Creación de un sondeo de tramo de Dynamic Instrumentation" >}}
+
+Puedes usar un *sondeo de tramo* como alternativa a [crear tramos nuevos con la instrumentación personalizada][13]. Si el método lanza una excepción, los detalles de la excepción se asocian a la nueva etiqueta `error` del tramo.
+
+### Creación de sondeos de etiqueta de tramo
+
+Un sondeo de *etiqueta de tramo* añade un valor de etiqueta a un tramo existente. Puedes añadir una etiqueta al tramo _activo_ o al tramo de _entrada de servicio_.
+Ten en cuenta que los tramos internos no se indexan de manera predeterminada y, por tanto, es posible que no se puedan buscar en APM.
+
+Para crear un sondeo de etiqueta de tramo:
+
+1. Selecciona **Span Tag** (Etiqueta de tramo) como tipo de sondeo.
+1. Completa la [configuración genérica del sondeo](#creating-a-probe) (elige un servicio, entorno, versión y localización del sondeo).
+1. Especifica un nombre para la etiqueta.
+1. Especifica el valor de la etiqueta con el [lenguaje de expresión de Dynamic Instrumentation][15].
+1. Opcionalmente, define una condición con el lenguaje de expresión de Dynamic Instrumentation. Solo se añadirá la etiqueta cuando la expresión se evalúe como verdadera.
+1. Opcionalmente, añade etiquetas adicionales, cada una con su nombre, expresión y condición opcional.
+
+
+{{< img src="dynamic_instrumentation/span_tag_probe.png" alt="Creación de un sondeo de etiqueta de tramo de Dynamic Instrumentation" >}}
+
+Puedes usar un *sondeo de etiqueta de tramo* como alternativa a [usar la instrumentación personalizada para añadir etiquetas en el código][14].
+
+
+## Referencias adicionales
+
+{{< partial name="whats-next/whats-next.html" >}}
+
+[1]: /es/agent/
+[2]: /es/agent/remote_config/
+[3]: https://github.com/DataDog/dd-trace-java
+[4]: https://github.com/DataDog/dd-trace-py
+[5]: https://github.com/DataDog/dd-trace-dotnet
+[6]: /es/getting_started/tagging/unified_service_tagging/
+[7]: /es/integrations/guide/source-code-integration/
+[8]: /es/account_management/rbac/permissions#apm
+[9]: /es/logs/log_configuration/indexes/#exclusion-filters
+[10]: /es/logs/log_configuration/indexes/#add-indexes
+[11]: /es/dynamic_instrumentation/how-it-works/
+[12]: https://app.datadoghq.com/dynamic-instrumentation
+[13]: /es/tracing/trace_collection/custom_instrumentation/java/#adding-spans
+[14]: /es/tracing/trace_collection/custom_instrumentation/java/#adding-tags
+[15]: /es/dynamic_instrumentation/expression-language
+[16]: https://app.datadoghq.com/dynamic-instrumentation/setup
+[17]: /es/dynamic_instrumentation/symdb/
+[18]: https://github.com/DataDog/dd-trace-js
+[19]: https://github.com/DataDog/dd-trace-rb
+[20]: https://github.com/DataDog/dd-trace-php
\ No newline at end of file
diff --git a/content/es/tracing/guide/instrument_custom_method.md b/content/es/tracing/guide/instrument_custom_method.md
index f0808bf6b9cee..49af6fce3b3bc 100644
--- a/content/es/tracing/guide/instrument_custom_method.md
+++ b/content/es/tracing/guide/instrument_custom_method.md
@@ -2,13 +2,14 @@
further_reading:
- link: /tracing/guide/alert_anomalies_p99_database/
tag: 3 minutos
- text: Alerta sobre latencia p99 anómala de un servicio de base de datos
+ text: Alertar sobre la latencia p99 anómala de un servicio de base de datos
- link: /tracing/guide/week_over_week_p50_comparison/
tag: 2 minutos
text: Comparar la latencia del servicio con la de la semana anterior
- link: /tracing/guide/slowest_request_daily/
tag: 3 minutos
- text: Depurar el rastreo más lento en el endpoint más lento de un servicio web
+ text: Depurar la traza (traza) más lenta en el endpoint más lento de un servicio
+ web
- link: /tracing/guide/
tag: ''
text: Todas las guías
@@ -22,23 +23,23 @@ _8 minutos para completarlo_
Nota: En esta página se describe el uso de OpenTracing para la instrumentación personalizada de aplicaciones. OpenTracing está obsoleto. Los conceptos presentados aquí todavía se aplican, pero, en su lugar, sigue las instrucciones y ejemplos de
Instrumentación personalizada con OpenTelemetry para tu idioma.
-Para proporcionarte una visibilidad profunda de tu lógica de negocio, la APM de Datadog te permite personalizar los tramos (spans) que componen tus rastreos en función de tus necesidades e implementación. Esto te permite rastrear cualquier método de tu código base e incluso componentes específicos dentro de los métodos. Puedes utilizar esto para optimizar y monitorizar áreas críticas de tu aplicación en la granularidad que funcione para ti.
+Para proporcionarte una visibilidad profunda de tu lógica de negocio, la APM de Datadog te permite personalizar los tramos (spans) que componen tus trazas en función de tus necesidades e implementación. Esto te permite rastrear cualquier método de tu código base e incluso componentes específicos dentro de los métodos. Puedes utilizar esto para optimizar y monitorizar áreas críticas de tu aplicación en la granularidad que funcione para ti.
-Datadog instrumenta muchos marcos no incluidos, como servicios web, bases de datos y cachés y te permite instrumentar tu propia lógica de negocio para tener la visibilidad exacta que necesitas. Mediante la creación de tramos para los métodos, puedes optimizar el tiempo y realizar un rastreo de los errores utilizando la gráfica de llamas y las monitorizaciones APM.
+Datadog instrumenta muchos marcos predefinidos, como servicios web, bases de datos y cachés y te permite instrumentar tu propia lógica de negocio para tener la visibilidad exacta que necesitas. Mediante la creación de tramos para los métodos, puedes optimizar el tiempo y rastrear errores utilizando la gráfica de llamas y las monitorizaciones de APM.
-## Instrumentación de tu código
+## Instrumentar tu código
-**Follow the example to get your code instrumented** (Seguir el ejemplo para instrumentar el código).
+**Follow the example to get your code instrumented** (Seguir el ejemplo para instrumentar tu código).
-En estos ejemplos se rastrea todo el método `BackupLedger.write` para medir su tiempo de ejecución y su estado.`BackupLedger.write` es una acción que guarda en la memoria el estado actual de un libro de contabilidad de transacciones antes de hacer una llamada a una base de datos de pagos para contabilizar un nuevo cargo de un cliente. Esto sucede cuando se accede al endpoint `charge` del servicio de pagos:
+En estos ejemplos se explica el rastreo de todo el método `BackupLedger.write` para medir su tiempo y estado de ejecución.`BackupLedger.write` es una acción que guarda en la memoria el estado actual de un libro de contabilidad de transacciones antes de hacer una llamada a una base de datos de pagos para contabilizar un nuevo cargo de un cliente. Esto sucede cuando se accede al endpoint `charge` del servicio de pagos:
{{< img src="tracing/guide/custom_span/custom_span_2_cropped.png" alt="Vista de análisis" style="width:90%;">}}
-El tramo `http.request POST /charge/` está tardando mucho sin tener ningún tramo secundario directo. Esta es una pista de que esta solicitud requiere más instrumentación para conocer mejor su comportamiento. Según el lenguaje de programación que utilices, deberás decorar tus funciones de forma diferente:
+El tramo `http.request POST /charge/` está tardando mucho sin tener ningún tramo secundario directo. Esta es una pista de que esta solicitud requiere más instrumentación para conocer mejor su comportamiento. Según el lenguaje de programación que utilices, decora tus funciones de forma diferente:
{{< programming-lang-wrapper langs="java,python,ruby,go,nodejs,.NET,php" >}}
{{< programming-lang lang="java" >}}
-En Java, la APM Datadog te permite Instrumentar tu código para generar tramos personalizados, ya sea utilizando decoradores de métodos o instrumentando bloques de código específicos.
+En Java, la APM Datadog te permite instrumentar tu código para generar tramos personalizados, ya sea utilizando decoradores de métodos o instrumentando bloques de código específicos.
**Instument a method with a decorator** (Instrumentar un método con un decorador):
@@ -49,7 +50,7 @@ import datadog.trace.api.Trace
public class BackupLedger {
- // Use @Trace annotation to trace custom methods
+ // Utiliza la anotación @Trace para rastrear métodos personalizados
@Trace
public void write(List transactions) {
for (Transaction transaction : transactions) {
@@ -73,18 +74,18 @@ import io.opentracing.util.GlobalTracer;
public class BackupLedger {
- // Use `@Trace` annotation to trace custom methods
+ // Utiliza la anotación `@Trace` para rastrear métodos personalizados
@Trace
public void write(List transactions) {
- for (Transaction transaction : transactions) {
- // Use `GlobalTracer` to trace blocks of inline code
+ para (Transaction transaction : transactions) {
+ // Utiliza `GlobalTracer` para rastrear bloques del código insertado
Tracer tracer = GlobalTracer.get();
- // Note: The scope in the try with resource block below
- // will be automatically closed at the end of the code block.
- // If you do not use a try with resource statement, you need
- // to call scope.close().
- try (Scope scope = tracer.buildSpan("BackupLedger.persist").startActive(true)) {
- // Add custom metadata to the span
+ // Nota: El ámbito en el siguiente bloque intentar con el recurso
+ // se cerrará automáticamente al final del bloque de código.
+ // Si no utilizas una instrucción probar con el recurso, deberás
+ // llamar a scope.close().
+ prueba (Scope scope = tracer.buildSpan("BackupLedger.persist").startActive(true)) {
+ // Añade metadatos personalizados al tramo
scope.span().setTag("transaction.id", transaction.getId());
ledger.put(transaction.getId(), transaction);
}
@@ -99,7 +100,7 @@ public class BackupLedger {
{{< /programming-lang >}}
{{< programming-lang lang="python" >}}
-En Python, la APM Datadog te permite Instrumentar tu código para generar tramos personalizados, ya sea utilizando decoradores de métodos o instrumentando bloques de código específicos.
+En Python, la APM Datadog te permite instrumentar tu código para generar tramos personalizados, ya sea utilizando decoradores de métodos o instrumentando bloques de código específicos.
**Instument a method with a decorator** (Instrumentar un método con un decorador):
@@ -110,10 +111,10 @@ from ddtrace import tracer
class BackupLedger:
- # Use `tracer.wrap` decorator to trace custom methods
+ # Utiliza el decorador `tracer.wrap` para rastrear métodos personalizados
@tracer.wrap()
def write(self, transactions):
- for transaction in transactions:
+ para una transacción en transacciones:
self.ledger[transaction.id] = transaction
# [...]
@@ -121,20 +122,20 @@ class BackupLedger:
**Instrument a specific code block** (Instrumentar un bloque de código específico):
-Este ejemplo añade tramos secundarios al tramo `BackupLedger.write` creado anteriormente. Este método añade un tramo secundario para cada transacción en el libro de contabilidad y una [etiqueta personalizada][1] con el ID de transacción específico.
+Este ejemplo añade tramos secundarios al tramo `BackupLedger.write` creado anteriormente. Este método añade un tramo secundario para cada transacción en el libro de contabilidad y una [etiqueta (tag) personalizada][1] con el ID de transacción específico.
```python
from ddtrace import tracer
class BackupLedger:
- # Use `tracer.wrap` decorator to trace custom methods
+ # Utiliza el decorador `tracer.wrap` para rastrear métodos personalizados
@tracer.wrap()
def write(self, transactions):
- for transaction in transactions:
- # Use `tracer.trace` context manager to trace blocks of inline code
- with tracer.trace('BackupLedger.persist') as span:
- # Add custom metadata to the "persist_transaction" span
+ para la transacción en transacciones:
+ # Utiliza el administrador del contexto `tracer.trace` para rastrear bloques del código insertado
+ con el tramo tracer.trace('BackupLedger.persist'):
+ # Añade metadatos personalizados al tramo "persist_transaction"
span.set_tag('transaction.id', transaction.id)
self.ledger[transaction.id] = transaction
@@ -155,11 +156,11 @@ require 'ddtrace'
class BackupLedger
def write(transactions)
- # Use global `Datadog::Tracing.trace` to trace blocks of inline code
+ # Utiliza `Datadog::Tracing.trace` global para rastrear bloques del código insertado
Datadog::Tracing.trace('BackupLedger.write') do |method_span|
transactions.each do |transaction|
Datadog::Tracing.trace('BackupLedger.persist') do |span|
- # Add custom metadata to the "persist_transaction" span
+ # Añade metadatos personalizados al tramo "persist_transaction"
span.set_tag('transaction.id', transaction.id)
ledger[transaction.id] = transaction
end
@@ -179,10 +180,14 @@ end
Este ejemplo crea un nuevo tramo para cada transacción contabilizada en el libro de contabilidad y añade una [etiqueta personalizada][1] con el ID de transacción específico al tramo.
+ {{% tracing-go-v2 %}}
+
```go
package ledger
-import "gopkg.in/DataDog/dd-trace-go.v1/ddtrace/tracer"
+import (
+ "github.com/DataDog/dd-trace-go/v2/ddtrace/tracer"
+)
// [...]
@@ -218,6 +223,8 @@ func (bl *BackupLedger) persistTransaction(ctx context.Context, transaction *Tra
```
[1]: /es/tracing/trace_collection/custom_instrumentation/otel_instrumentation/
+[2]: /es/tracing/trace_collection/custom_instrumentation/go/migration
+
{{< /programming-lang >}}
{{< programming-lang lang="nodejs" >}}
@@ -229,11 +236,11 @@ Este ejemplo crea un nuevo tramo para la llamada al método `BackupLedger.write`
const tracer = require('dd-trace')
function write (transactions) {
- // Use `tracer.trace` context manager to trace blocks of inline code
+ // Utiliza el administrador de contexto `tracer.trace` para rastrear bloques del código insertado
tracer.trace('BackupLedger.write', () => {
- for (const transaction of transactions) {
+ para (const transaction of transactions) {
tracer.trace('BackupLedger.persist' , (span) => {
- // Add custom metadata to the "persist_transaction" span
+ // Añade metadatos personalizados al tramo "persist_transaction"
span.setTag('transaction.id', transaction.id)
this.ledger[transaction.id] = transaction
})
@@ -250,21 +257,21 @@ function write (transactions) {
En .NET, la APM Datadog te permite instrumentar tu código para generar tramos personalizados instrumentando bloques de código específicos.
-Este ejemplo crea un nuevo tramo para cada transacción contabilizada en el libro de contabilida y añade una [etiqueta personalizada][1] con el ID de transacción específico al tramo.
+Este ejemplo crea un nuevo tramo para cada transacción contabilizada en el libro de contabilidad y añade una [etiqueta personalizada][1] con el ID de transacción específico al tramo.
```csharp
using Datadog.Trace;
public void Write(List transactions)
{
- // Use global tracer to trace blocks of inline code
- using (var scope = Tracer.Instance.StartActive("BackupLedger.write"))
+ // Utiliza el rastreador global para rastrear bloques del código insertado
+ utilizando (var scope = Tracer.Instance.StartActive("BackupLedger.write"))
{
foreach (var transaction in transactions)
{
- using (var scope = Tracer.Instance.StartActive("BackupLedger.persist"))
+ utilizando (var scope = Tracer.Instance.StartActive("BackupLedger.persist"))
{
- // Add custom metadata to the span
+ // Añade metadatos personalizados al tramo
scope.Span.SetTag("transaction.id", transaction.Id);
this.ledger[transaction.Id] = transaction;
}
@@ -319,15 +326,15 @@ Este ejemplo añade tramos secundarios al tramo `BackupLedger.write` creado ante
public function write(array $transactions) {
foreach ($transactions as $transaction) {
- // Use global tracer to trace blocks of inline code
+ // Utiliza el rastreador global para rastrear bloques del código insertado
$span = \DDTrace\start_span();
$span->name = 'BackupLedger.persist';
- // Add custom metadata to the span
+ // Añade metadatos personalizados al tramo
$span->meta['transaction.id'] = $transaction->getId();
$this->transactions[$transaction->getId()] = $transaction;
- // Close the span
+ // Cierra el tramo
\DDTrace\close_span();
}
@@ -354,19 +361,19 @@ Este ejemplo añade tramos secundarios al tramo `BackupLedger.write` creado ante
Ahora que has instrumentado tu lógica de negocio, es el momento de ver los resultados en la UI de la APM Datadog .
-1. Ve al **[Service Catalog][1]** (Catálogo de servicios) y haz clic en el servicio al que has añadido tramos personalizados, para abrir su página de servicios. En la página de servicios, haz clic en el **specific resource** (recurso específico) que has añadido, cambia el filtro de tiempo a `The past 15 minutes` y desplázate hacia abajo a la tabla de resumen de tramos:
+1. Ve a **[Software Catalog][1]** y haz clic en el servicio al que has añadido spans (tramos) personalizados, para abrir su page (página) de servicio. En la page (página) de servicio, haz clic en el **recurso específico** que has añadido, cambia el filtro de tiempo a `The past 15 minutes` y desplázate hacia abajo hasta la tabla resumen de spans (tramos):
{{< img src="tracing/guide/custom_span/custom_span_3.png" alt="Tabla de resumen de tramos" style="width:90%;">}}
-La tabla resumen tramos proporciona información agregada sobre los tramos que componen tus rastreos. Aquí puedes identificar tramos que se repiten una cantidad anormal de veces, lo cual indica algún bucle o ineficiencia de acceso a la base de datos (como el problema [`n+1`][2]).
+La tabla resumen tramos proporciona información agregada sobre los tramos que componen tus trazas. Aquí puedes identificar tramos que se repiten una cantidad anormal de veces, lo cual indica algún bucle o ineficiencia de acceso a la base de datos (como el problema [`n+1`][2]).
-2. Desplázate hacia abajo a **Traces list** (Lista de rastreos) y haz clic en uno de tus rastreos.
+2. Desplázate hacia abajo a **Traces list** (Lista de trazas) y haz clic en una de tus trazas.
{{< img src="tracing/guide/custom_span/custom_span_4_cropped.png" alt="Vista de análisis" style="width:90%;">}}
-Has añadido con éxito tramos personalizados a tu código base, y has hecho que estén disponibles en la gráfica de llamas y en [Análisis de la aplicación][3]. Este es el primer paso para aprovechar al máximo las herramientas de Datadog. Ahora puedes [añadir etiquetas personalizados a tus tramos][4] para hacerlos aún más potentes.
+Has añadido con éxito tramos personalizados a tu código base y has hecho que estén disponibles en la gráfica de llamas y en [Análisis de la aplicación][3]. Este es el primer paso para aprovechar al máximo las herramientas de Datadog. Ahora puedes [añadir etiquetas personalizadas a tus tramos][4] para hacerlos aún más potentes.
-## Leer más
+## Referencias adicionales
{{< partial name="whats-next/whats-next.html" >}}
diff --git a/content/es/tracing/metrics/runtime_metrics/_index.md b/content/es/tracing/metrics/runtime_metrics/_index.md
new file mode 100644
index 0000000000000..5a7553fe3b92f
--- /dev/null
+++ b/content/es/tracing/metrics/runtime_metrics/_index.md
@@ -0,0 +1,305 @@
+---
+aliases:
+- /es/tracing/advanced/runtime_metrics/
+- /es/tracing/metrics/runtime_metrics/dotnet
+- /es/tracing/metrics/runtime_metrics/java
+- /es/tracing/metrics/runtime_metrics/nodejs
+- /es/tracing/metrics/runtime_metrics/python
+- /es/tracing/metrics/runtime_metrics/ruby
+- /es/tracing/runtime_metrics/dotnet
+- /es/tracing/runtime_metrics/java
+- /es/tracing/runtime_metrics/nodejs
+- /es/tracing/runtime_metrics/python
+- /es/tracing/runtime_metrics/ruby
+description: Obtén información adicional sobre el rendimiento de una aplicación 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: Correlacionar 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: Explorar tus servicios, recursos y trazas (traces)
+title: Métricas de tiempo de ejecución
+---
+
+## Información general
+
+Las métricas de tiempo de ejecución monitorizan el uso de memoria, la recolección de basura y la paralelización de tu aplicación. Las bibliotecas de rastreo de Datadog recopilan automáticamente estas métricas de entornos compatibles y las envían al Agent.
+
+Estas métricas te permiten identificar cuellos de botella, solucionar problemas de rendimiento y optimizar el uso de los recursos. Al consultar las métricas de tiempo de ejecución junto con las trazas y los logs, obtendrás una visibilidad completa del estado y el rendimiento de tu aplicación.
+
+## Compatibilidad
+
+Las métricas de tiempo de ejecución están disponibles para varios lenguajes de programación y tiempos de ejecución, con distintos niveles de compatibilidad y opciones de configuración.
+
+{{< tabs >}}
+{{% tab "Java" %}}
+
+- **Activado por defecto**: Sí
+- **Versión de la biblioteca**: 0.29.0 o posterior
+- **Tiempos de ejecución**: Java 8 o posterior
+
+La recopilación de métricas de JMX no es compatible con los entornos AWS Lambda.
+
+{{% /tab %}}
+
+{{% tab "Python" %}}
+
+ - **Activado por defecto**: No
+ - **Versión de la biblioteca**: 0.30.0 o posterior
+ - **Nivel de compatibilidad**: Vista previa
+ - **Tiempos de ejecución**: Todas las versiones de Python compatibles
+
+{{% /tab %}}
+
+{{% tab "Ruby" %}}
+
+ - **Activado por defecto**: No
+ - **Versión de la biblioteca**: 0.44.0 o posterior
+ - **Tiempos de ejecución**: Todas las versiones de Ruby compatibles
+
+
+
+
+{{% /tab %}}
+
+{{% tab "Go" %}}
+
+ - **Activado por defecto**: No
+ - **Versión de la biblioteca**: 1.18.0 o posterior
+ - **Tiempos de ejecución**: Todas las versiones de Go compatibles
+
+{{% /tab %}}
+
+{{% tab "Node.js" %}}
+
+ - **Activado por defecto**: No
+ - **Versión de la biblioteca**: 3.0.0 o posterior
+ - **Tiempos de ejecución**: Todas las versiones de Node.js compatibles
+
+{{% /tab %}}
+
+{{% tab ".NET" %}}
+
+ - **Activado por defecto**: No
+ - **Versión de la biblioteca**: 1.23.0 o posterior
+ - **Tiempos de ejecución**: .NET Framework 4.6.1 o posterior y .NET Core 3.1 o posterior (incluyendo .NET 5 y posteriores).
+
+#### Permisos para Internet Information Services (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:
+
+```shell
+net localgroup "Performance Monitor Users" "IIS APPPOOL\DefaultAppPool" /add
+```
+
+{{% /tab %}}
+{{% tab "PHP" %}}
+
+No se admiten métricas en tiempo de ejecución para PHP.
+
+{{% /tab %}}
+{{% tab "C++" %}}
+
+No se admiten métricas en tiempo de ejecución para C++.
+
+{{% /tab %}}
+{{< /tabs >}}
+
+## Instrucciones de instalación
+
+Para configurar las métricas en tiempo de ejecución, debes configurar tanto el Datadog Agent como tu aplicación.
+
+### 1. Configurar el Datadog Agent
+
+Habilita [DogStatsD para el Agent][2]. Por defecto, el Datadog Agent está configurado para ingerir métricas con UDP a través del puerto `8125`.
+
+{{% collapse-content title="Configuración específica de contenedor" level="h4" expanded=false %}}
+
+Cuando el Agent se ejecuta en entornos de contenedores, es necesaria una configuración adicional:
+
+1. Define `dogstatsd_non_local_traffic: true` en tu [archivo de configuración principal`datadog.yaml`][8], o define la [variable de entorno][3] `DD_DOGSTATSD_NON_LOCAL_TRAFFIC=true`.
+2. Sigue estas instrucciones de configuración específica de contenedor:
+
+{{< partial name="apm/apm-runtime-metrics-containers.html" >}}
+
+
+
+{{< site-region region="us3,us5,eu,gov,ap1,ap2" >}}
+
+3. Define `DD_SITE` en el Datadog Agent como {{< region-param key="dd_site" code="true" >}} para asegurarte de que el Agent envía los datos a la localización Datadog correcta.
+
+{{< /site-region >}}
+
+{{% /collapse-content %}}
+
+### 2. Configurar la aplicación
+
+Configura las métricas de tiempo de ejecución en tu aplicación utilizando variables de entorno. Algunos lenguajes también permiten configurar métricas de tiempo de ejecución [directamente en el código](#code-based-configuration).
+
+#### Variables de entorno
+
+Utiliza las siguientes variables de entorno para configurar métricas de tiempo de ejecución en tu aplicación:
+
+`DD_RUNTIME_METRICS_ENABLED`
+: **Por defecto**: `true` para Java, `false` para todos los demás lenguajes
+**Descripción**: Activa la recopilación de métricas de tiempo de ejecución. Las métricas se envían al Datadog Agent, según lo configurado para la aplicación instrumentada.
+
+`DD_RUNTIME_METRICS_RUNTIME_ID_ENABLED`
+: **Por defecto**: `true` para Java, `false` para Node.js, Ruby y Python. No existe para .NET y Go. Siempre se indica `runtime_id`.
+**Descripción**: Habilita métricas en tiempo de ejecución mejoradas, proporcionando una etiqueta (tag) `runtime_id` junto con cada métrica. `runtime_id` representa el identificador de procesos de la aplicación y te permite correlacionar directamente las métricas de tiempo de ejecución con aplicaciones individuales en ejecución.
+
+`DD_AGENT_HOST`
+: **Por defecto**: `localhost`
+**Descripción**: Define la dirección del host para el envío de métricas de la biblioteca de rastreo. Puede ser un nombre de host o una dirección IP.
+
+`DD_DOGSTATSD_PORT`
+: **Por defecto**: `8125`
+**Descripción**: Define el puerto para el envío de métricas de la biblioteca de rastreo.
+
+#### Configuración basada en códigos
+
+Además de las variables de entorno, algunos lenguajes permiten configurar métricas de tiempo de ejecución directamente en el código.
+
+{{< tabs >}}
+{{% tab "Java" %}}
+
+Sólo puedes activar las métricas de tiempo de ejecución con [variables de entorno](#environment-variables).
+
+Sin embargo, puedes ampliar las métricas recopiladas añadiendo métricas JMX personalizadas. Para obtener más información, consulta la documentación de la [integración JMX][100].
+
+[100]: /es/integrations/java/
+{{% /tab %}}
+
+{{% tab "Python" %}}
+
+Puedes activar las métricas de tiempo de ejecución con [variables de entorno](#environment-variables) o en código:
+
+```python
+from ddtrace.runtime import RuntimeMetrics
+RuntimeMetrics.enable()
+```
+
+Esto sólo se aplica si no estás utilizando ddtrace-run
+{{% /tab %}}
+
+{{% tab "Ruby" %}}
+
+Puedes activar las métricas de tiempo de ejecución con [variables de entorno](#environment-variables) o en código:
+
+```ruby
+# config/initializers/datadog.rb
+require 'datadog/statsd'
+require 'datadog' # Use 'ddtrace' if you're using v1.x
+
+Datadog.configure do |c|
+ c.runtime_metrics.enabled = true
+
+ # Optionally, you can configure the DogStatsD instance used for sending runtime metrics.
+ # DogStatsD is automatically configured with default settings if `dogstatsd-ruby` is available.
+ # You can configure with host and port of Datadog agent; defaults to 'localhost:8125'.
+ c.runtime_metrics.statsd = Datadog::Statsd.new
+end
+```
+{{% /tab %}}
+
+{{% tab "Go" %}}
+
+Puedes activar las métricas de tiempo de ejecución con [variables de entorno](#environment-variables) o en código:
+
+```go
+// Basic configuration
+tracer.Start(tracer.WithRuntimeMetrics())
+
+// With custom DogStatsD address
+tracer.Start(
+ tracer.WithRuntimeMetrics(),
+ tracer.WithDogstatsdAddr("custom-host:8125")
+)
+```
+
+La opción `WithDogstatsdAddr` te permite especificar una dirección personalizada para el servidor DogStatsD. Utiliza la opción [`WithDogstatsdAddr`][101] (o [`WithDogstatsdAddress` v1][100]), si tu dirección difiere de la predeterminada `localhost:8125`. (Disponible para la v1.18.0 o posterior)
+
+[100]: https://pkg.go.dev/gopkg.in/DataDog/dd-trace-go.v1/ddtrace/tracer#WithDogstatsdAddress
+[101]: https://pkg.go.dev/github.com/DataDog/dd-trace-go/v2/ddtrace/tracer#WithDogstatsdAddr
+{{% /tab %}}
+
+{{% tab "Node.js" %}}
+
+Puedes activar las métricas de tiempo de ejecución con [variables de entorno](#environment-variables) o en código:
+
+```js
+const tracer = require('dd-trace').init({
+ // Other tracer options...
+ runtimeMetrics: true
+})
+```
+{{% /tab %}}
+
+{{% tab ".NET" %}}
+
+Sólo puedes activar las métricas de tiempo de ejecución con [variables de entorno](#environment-variables).
+
+{{% /tab %}}
+{{< /tabs >}}
+
+## Dashboards
+
+Una vez finalizada la configuración, puedes ver las métricas de tiempo de ejecución en:
+
+- Página con información del servicio instrumentado
+- Pestaña **Métricas** del gráfico de llama
+- Dashboards de tiempo de ejecución por defecto
+
+{{< img src="tracing/runtime_metrics/jvm_runtime_trace.png" alt="Traza de tiempo de ejecución de JVM" >}}
+
+## Solucionar problemas
+- Para asociar métricas de tiempo de ejecución dentro de los gráficos de llama, asegúrate de que la etiqueta `env` (que distingue entre mayúsculas y minúsculas) está configurada y coincide en todo tu entorno.
+- Para que las métricas de tiempo de ejecución aparezcan en la página del servicio al utilizar Fargate, asegúrate de que `DD_DOGSTATSD_TAGS` está configurado en la tarea de tu Agent y que la etiqueta `env` configurada coincide con la `env` del servicio instrumentado.
+
+## Datos recopilados
+
+Cada lenguaje compatible recopila un conjunto de métricas de tiempo de ejecución que proporcionan información sobre el uso de la memoria, la recolección de basura, el uso de la CPU y otros indicadores de rendimiento.
+
+{{< tabs >}}
+{{< tab "Java" >}}
+{{< get-metrics-from-git "java" >}}
+{{< /tab >}}
+
+{{< tab "Python" >}}
+{{< get-metrics-from-git "python" >}}
+{{< /tab >}}
+
+{{< tab "Ruby" >}}
+{{< get-metrics-from-git "ruby" >}}
+{{< /tab >}}
+
+{{< tab "Go" >}}
+{{< get-metrics-from-git "go" >}}
+{{< /tab >}}
+
+{{< tab "Node.js" >}}
+{{< get-metrics-from-git "node" >}}
+{{< /tab >}}
+
+{{< tab ".NET" >}}
+{{< get-metrics-from-git "dotnet" >}}
+{{< /tab >}}
+{{< /tabs >}}
+
+## Referencias adicionales
+
+{{< partial name="whats-next/whats-next.html" >}}
+
+[2]: /es/developers/dogstatsd/#setup
+[3]: /es/agent/docker/#dogstatsd-custom-metrics
+[7]: /es/developers/dogstatsd/unix_socket/
+[8]: /es/agent/configuration/agent-configuration-files/#main-configuration-file
\ No newline at end of file
diff --git a/content/es/tracing/services/deployment_tracking.md b/content/es/tracing/services/deployment_tracking.md
index 3e1245a9517a5..ae6413abf9912 100644
--- a/content/es/tracing/services/deployment_tracking.md
+++ b/content/es/tracing/services/deployment_tracking.md
@@ -8,13 +8,13 @@ further_reading:
- link: getting_started/tagging/unified_service_tagging/
tag: Documentación
text: Más información sobre el etiquetado de servicios unificado y las etiquetas
- (tags) reservadas
+ reservadas
- link: tracing/app_analytics
tag: Documentación
text: Utiliza la versión como una dimensión en tus consultas a App Analytics
title: Rastreo de despliegue
---
-## La etiqueta de versión
+## La etiqueta "version" (versión)
La etiqueta `version` está reservada dentro del etiquetado de servicios unificado. Se aplica a métricas de infraestructura (host, contenedor, proceso, y checks de NPM), métricas de traza ( trace), trazas (traces), perfiles y logs.
@@ -53,10 +53,10 @@ Un servicio configurado con etiquetas `version` tiene una sección de versión e
Por defecto, verás:
- Los nombres de las versiones desplegadas para este servicio a lo largo del tiempo.
-- Las horas a las que trazas que corresponden a esta versión fueron vistas por primera y última vez.
+- Las horas a las que las trazas que corresponden a esta versión fueron vistas por primera y última vez.
- Un indicador de Error Types (Tipos de error), que muestra cuántos tipos de error aparecen en cada versión que no aparecían en la versión inmediatamente anterior.
- > **Nota:** Este indicador muestra errores que no se veían en trazas de la versión anterior. No significa que esta versión haya introducido necesariamente estos errores. Buscar nuevos tipos de error puede ser una buena forma de empezar a investigar errores.
+ > **Nota:** Este indicador muestra errores que no se veían en trazas de la versión anterior. No significa que esta versión haya introducido necesariamente estos errores. Buscar nuevos tipos de error puede ser una buena forma de empezar a investigar errores.
- Solicitudes por segundo.
- Porcentaje de errores sobre el total de solicitudes.
@@ -70,11 +70,11 @@ Puedes añadir o eliminar columnas de este cuadro y tus selecciones se guardará
- Número total de errores.
- Latencia medida por p50, p75, p90, p95, p99 o máx.
-{{< img src="tracing/deployment_tracking/VersionComparison.png" alt="Versiones en la Página de servicios" style="width:100%;">}}
+{{< img src="tracing/deployment_tracking/VersionComparison.png" alt="Versiones en la página de servicios" style="width:100%;">}}
**Nota:** La sección de versiones solo aparece si hay más de una versión informando durante el intervalo de tiempo seleccionado en la parte superior de la página.
-## Comparación del despliegue
+## Comparación de despliegues
Haz clic en cualquier fila de la tabla de resumen de versiones para abrir una página de comparación de versiones, que te permitirá comparar dos versiones del mismo servicio. Por defecto, la versión seleccionada se comparará con la versión inmediatamente anterior, pero puedes cambiar esto para comparar dos versiones cualesquiera de los últimos 30 días.
@@ -222,13 +222,13 @@ Tiempo = 30
: `{service: foo, env: staging, cluster-name: us-staging, version: Y}`
Tiempo = 45
-: `{service: foo, env: dev-shopist, cluster-name: us-staging, version: Y}`
+: `{service: foo, env: staging, cluster-name: dev-shopist, version: Y}`
Tiempo máximo entre despliegues:
: `max:datadog.service.time_between_deployments{env: staging, cluster-name: *} = 25`
-## Leer más
+## Referencias adicionales
{{< partial name="whats-next/whats-next.html" >}}
diff --git a/content/fr/agent/_index.md b/content/fr/agent/_index.md
index c6445e3ab20df..60bae0815d2d2 100644
--- a/content/fr/agent/_index.md
+++ b/content/fr/agent/_index.md
@@ -6,13 +6,13 @@ aliases:
- /fr/agent/faq/the-datadog-agent-for-logs-or-traces-only
cascade:
- _target:
- path: /agent/basic_agent_usage/chef
lang: fr
+ path: /agent/basic_agent_usage/chef
tags:
- uninstall
- _target:
- path: /infrastructure/**/*
lang: fr
+ path: /infrastructure/**/*
algolia:
rank: 80
tags:
@@ -41,7 +41,7 @@ title: Agent
L'Agent v7 est disponible. Passez à la dernière version pour profiter des nouvelles fonctionnalités.
-## Présentation
+## Section Overview
L'Agent Datadog est un logiciel qui s'exécute sur vos hosts. Il recueille les événements et les métriques des hosts et les envoie à la plateforme Datadog, à partir de laquelle vous pouvez analyser vos données de surveillance et de performance. L'Agent Datadog est open source et son code source est disponible sur GitHub dans [DataDog/datadog-agent][1].
diff --git a/content/fr/agent/configuration/agent-configuration-files.md b/content/fr/agent/configuration/agent-configuration-files.md
new file mode 100644
index 0000000000000..a7b916e446adf
--- /dev/null
+++ b/content/fr/agent/configuration/agent-configuration-files.md
@@ -0,0 +1,76 @@
+---
+algolia:
+ category: guide
+ rank: 80
+ subcategory: Fichiers de configuration de l'Agent
+ tags:
+ - configuration de l'agent
+ - configuration de l'agent
+ - répertoire de l’agent
+aliases:
+- /fr/agent/faq/agent-configuration-files
+- /fr/agent/guide/agent-configuration-files
+title: Fichiers de configuration de l'Agent
+---
+
+## Fichier de configuration principal
+
+L'emplacement du fichier de configuration de l'Agent dépend du système d'exploitation.
+
+| Plateforme | Commande |
+|:-------------------------------------|:-------------------------------------|
+| AIX | `/etc/datadog-agent/datadog.yaml` |
+| Linux | `/etc/datadog-agent/datadog.yaml` |
+| macOS | `~/.datadog-agent/datadog.yaml` |
+| Windows | `%ProgramData%\Datadog\datadog.yaml` |
+
+Consultez le [fichier d'exemple 'config_template.yaml'][1] pour découvrir toutes les options de configuration disponibles.
+
+## Répertoire de configuration de l'Agent
+
+Les fichiers de checks des vérifications de l'Agent et des intégrations sont stockés dans le répertoire 'conf.d'. L'emplacement de ce répertoire varie selon le système d'exploitation.
+
+| Plateforme | Commande |
+|:-------------------------------------|:-------------------------------|
+| AIX | `/etc/datadog-agent/conf.d/` |
+| Linux | `/etc/datadog-agent/conf.d/` |
+| CentOS | `/etc/datadog-agent/conf.d/` |
+| Debian | `/etc/datadog-agent/conf.d/` |
+| Fedora | `/etc/datadog-agent/conf.d/` |
+| macOS | `~/.datadog-agent/conf.d/` |
+| RedHat | `/etc/datadog-agent/conf.d/` |
+| Source | `/etc/datadog-agent/conf.d/` |
+| Suse | `/etc/datadog-agent/conf.d/` |
+| Ubuntu | `/etc/datadog-agent/conf.d/` |
+| Windows | `%ProgramData%\Datadog\conf.d` |
+
+**Remarque** : les fichiers de taille nulle dans ce répertoire sont ignorés par l'Agent. Cela permet de prendre en charge les systèmes de provisioning qui ne permettent pas d'ignorer les fichiers modèles vides.
+
+### Fichiers de configuration des checks
+
+Pour chaque check de l'Agent, un exemple de configuration se trouve dans le fichier `conf.yaml.example` du dossier `