diff --git a/content/es/api/latest/integrations/_index.md b/content/es/api/latest/integrations/_index.md new file mode 100644 index 00000000000..4ceeab13a9d --- /dev/null +++ b/content/es/api/latest/integrations/_index.md @@ -0,0 +1,3 @@ +--- +title: integraciones +--- diff --git a/content/es/error_tracking/frontend/mobile/expo.md b/content/es/error_tracking/frontend/mobile/expo.md new file mode 100644 index 00000000000..69c825941b6 --- /dev/null +++ b/content/es/error_tracking/frontend/mobile/expo.md @@ -0,0 +1,442 @@ +--- +code_lang: expo +code_lang_weight: 30 +description: Configura Error Tracking y los informes de fallos de las aplicaciones + móviles de Expo en Datadog" +further_reading: +- link: https://www.datadoghq.com/blog/debug-android-crashes/ + tag: Blog + text: Para depurar los fallos de Android de forma más rápida con Datadog +- link: https://www.datadoghq.com/blog/ios-crash-reporting-datadog/ + tag: Blog + text: Para depurar los fallos de iOS de forma más eficaz con Datadog +- link: /error_tracking/ + tag: Documentación + text: Más información sobre el seguimiento de errores +- link: /error_tracking/explorer + tag: Documentación + text: Visualizar los datos de Error Tracking en el Explorer +title: Notificación de fallos y seguimiento de errores de Expo +type: lenguaje de código múltiple +--- + +## Información general + +Activa Expo Crash Reporting y Error Tracking para obtener informes exhaustivos de fallos y tendencias de errores para tus aplicaciones móviles de Expo. + +Con esta función, puedes acceder a: + +- Dashboards y atributos de fallos agregados Expo +- Informes de fallos de iOS simbolizados y de Android desofuscados +- Análisis de tendencias con el seguimiento de errores de Expo + +Para simbolizar los stack traces y desenmascarar los bloqueos de Android, carga los archivos `.dSYM`, los archivos de asignación de Proguard y los mapas fuente en Datadog mediante el complemento de configuración `expo-datadog`. + +Los símbolos de depuración se utilizan para desenmascarar stack traces, lo que ayuda a depurar errores. Con un ID de compilación único que se genera, Datadog hace coincidir automáticamente los stack traces correctos con los símbolos de depuración correspondientes. Esto garantiza que, independientemente de cuándo se hayan cargado los símbolos de depuración (ya sea durante las compilaciones de preproducción o de producción), se disponga de la información correcta para un control de calidad eficaz al revisar los fallos y errores notificados en Datadog. + +**Nota:** Error Tracking puede utilizarse como producto independiente o junto con [Real User Monitoring (RUM)][12]. Si utilizas RUM, Error Tracking ya está incluido. Consulta la [Documentación de configuración de RUM Expo][3] para la configuración específica de RUM. + +Tus informes de bloqueos aparecen en [**Error Tracking**][1]. + +## Configuración + +### Paso 1: Instalar paquetes + +Instala los paquetes necesarios para Expo Error Tracking: + +{{< tabs >}} +{{% tab "NPM" %}} +```sh +npm install expo-datadog @datadog/mobile-react-native +npm install @datadog/datadog-ci --save-dev +``` +{{% /tab %}} + +{{% tab "Yarn" %}} +```sh +yarn add expo-datadog @datadog/mobile-react-native +yarn add -D @datadog/datadog-ci +``` +{{% /tab %}} +{{< /tabs >}} + +### Paso 2: Navegación del seguimiento de vistas + +Para que las sesiones de Error Tracking aparezcan en Datadog, debes implementar el seguimiento de vistas, que puede inicializarse manual o automáticamente. + +#### Rastreo manual + +Puedes iniciar y detener manualmente una vista utilizando los siguientes métodos `startView()` y `stopView()`: + +```js +import { DdRum } from 'expo-datadog'; + +// Start a view with a unique view identifier, a custom view name, and an object to attach additional attributes to the view +DdRum.startView( + '', // has to be unique, for example it can be ViewName-unique-id + 'View Name', + { 'custom.foo': 'something' }, + Date.now() +); +// Stops a previously started view with the same unique view identifier, and an object to attach additional attributes to the view +DdRum.stopView('', { 'custom.bar': 42 }, Date.now()); +``` + +#### Rastreo automático + +El rastreo automático de vistas es compatible con los siguientes módulos: + +- Navegación de React: [@Datadog/mobile-react-navigation][7] +- Navegación de React Native: [@Datadog/mobile-react-native-navigation][8] + +Ejemplo con React Navigation: + +```tsx + { + DdRumReactNavigationTracking.startTrackingViews( + navigationRef.current, + ); + }}> +``` + +### Paso 3: Inicializar el kit de desarrollo de software (SDK) + +Añade el siguiente código a tu archivo de inicialización para configurar Error Tracking: + +```js +import { CoreConfiguration } from 'expo-datadog'; + +const config = new CoreConfiguration( + '', + '', + trackingConsent, + { + site: 'US1', // Optional: Select your Datadog website ("US1", "US3", "US5", "EU1", or "US1_FED"). Default is "US1". + rumConfiguration: { + applicationId: '', // RUM Application ID + trackInteractions: true, // Track user interactions (set to false if using Error Tracking only) + trackResources: true, // Track XHR resources (set to false if using Error Tracking only) + trackErrors: true, // Track errors + sessionSampleRate: 80, // Optional: Sample sessions, for example: 80% of sessions are sent to Datadog. Default is 100%. + nativeCrashReportEnabled: true // Optional: Enable or disable native crash reports. + }, + logsConfiguration: {}, // Enable Logs + traceConfiguration: {} // Enable Traces + } +) + +await DdSdkReactNative.initialize(config); +``` + +**Nota:** Si estás utilizando Error Tracking como producto independiente sin RUM, puedes establecer los parámetros de interacción del usuario y seguimiento de recursos XHR en `false`. Sin embargo, el paso 2 de seguimiento de vistas sigue siendo necesario para que se creen sesiones de Error Tracking. + +### Paso 4: Configurar el complemento de Expo + +Añade `expo-datadog` a tus complementos en el archivo `app.json`: + +```json +{ + "expo": { + "plugins": ["expo-datadog"] + } +} +``` + +Este complemento carga automáticamente dSYM, mapas fuente y archivos de mapas Proguard en cada compilación de EAS. + +#### Opciones de configuración del complemento + +Puedes personalizar el comportamiento del complemento con estas opciones: + +| Parámetro | Valor predeterminado | Descripción | +| ----------------------------- | ------- | ---------------------------------------------------------------------------------------------------------------------------------- | +| `iosDsyms` | `true` | Permite la carga de archivos dSYMS para la simbolización de fallos nativos de iOS. | +| `iosSourcemaps` | `true` | Habilita la carga de mapas de origen JavaScript en compilaciones de iOS. | +| `androidSourcemaps` | `true` | Habilita la carga de mapas de origen JavaScript en compilaciones de Android. | +| `androidProguardMappingFiles` | `true` | Habilita la carga de archivos de asignación Proguard para desofuscar fallos nativos de Android (sólo se aplica si la ofuscación está habilitada). | +| `datadogGradlePluginVersion` | `"1.+"` | Versión de `dd-sdk-android-gradle-plugin` utilizada para cargar los archivos de asignación Proguard. | + +Ejemplo con configuración personalizada: + +```json +{ + "expo": { + "plugins": [ + [ + "expo-datadog", + { + "errorTracking": { + "iosDsyms": true, + "iosSourcemaps": true, + "androidSourcemaps": true, + "androidProguardMappingFiles": true + } + } + ] + ] + } +} +``` + +### Paso 5: Configurar los secretos de EAS + +Los secretos de Expo Application Services (EAS) son variables de entorno seguras que almacenan información confidencial como claves de API para tus compilaciones de Expo. Ejecuta `eas secret:create` para configurar tus credenciales de Datadog: + +```sh +# Set your Datadog API key +eas secret:create --scope project --name DATADOG_API_KEY --value + +# Set your Datadog site (optional, defaults to datadoghq.com) +eas secret:create --scope project --name DATADOG_SITE --value datadoghq.eu +``` + +### Paso 6: Configurar los mapas fuente para una simbología precisa + +#### Opción A: Utiliza el complemento de Datadog Metro (recomendado) + +Partiendo de `@datadog/mobile-react-native@2.10.0` y `@datadog/datadog-ci@v3.13.0`, añade el complemento de Datadog Metro a tu `metro.config.js`: + +```js +const { getDatadogExpoConfig } = require("@datadog/mobile-react-native/metro"); +const config = getDatadogExpoConfig(__dirname); +module.exports = config; +``` + +#### Opción B: Inyección manual de ID de depuración + +Alternativamente, utiliza el comando `datadog-ci react-native inject-debug-id` para adjuntar manualmente un ID de depuración único a tu paquete de aplicaciones y mapa fuente. Consulta la [documentación del comando][5] para obtener instrucciones de uso. + +### Paso 7: Añadir datos del repositorio git (solo EAS) + +Si utilizas EAS para crear tu aplicación Expo, establece `cli.requireCommit` en `true` en tu archivo `eas.json` para añadir los datos del repositorio git a tus archivos de asignación: + +```json +{ + "cli": { + "requireCommit": true + } +} +``` + +## Para test tu implementación + +Para verificar la configuración de Expo Error Tracking, debes emitir un error en tu aplicación y confirmar que el error aparece en Datadog. + +Para test tu implementación + +1. Ejecuta tu aplicación en un simulador, emulador o dispositivo real. Si estás ejecutando en iOS, asegúrate de que el depurador no está conectado. De lo contrario, Xcode captura el fallo antes de que lo haga el SDK de Datadog. +2. Ejecuta un código que contenga un error o bloqueo. Por ejemplo: + + ```javascript + const throwError = () => { + throw new Error("My Error") + } + ``` + +3. Para los informes de error ofuscados que no provocan un fallo, puedes verificar la simbolización y la desofuscación en [**Rastreo de errores**][1]. +4. Para los fallos, después de que se produzcan, reinicia tu aplicación y espera a que el SDK de React Native cargue el informe del fallo en [**Rastreo de errores**][1]. + +Para asegurarse de que tus mapas fuente se envían y enlazan correctamente con tu aplicación, también puedes generar colisiones con el paquete [`react-native-performance-limiter`][6]. + +Instálalo con yarn o npm y luego vuelve a instalar tus pods: + +```shell +yarn add react-native-performance-limiter # or npm install react-native-performance-limiter +(cd ios && pod install) +``` + +Genera un fallo en el subproceso de JavaScript desde tu aplicación: + +```javascript +import { crashJavascriptThread } from 'react-native-performance-limiter'; + +const crashApp = () => { + crashJavascriptThread('custom error message'); +}; +``` + +Vuelve a compilar tu aplicación para la versión para enviar los nuevos mapas fuente, desencadenar el fallo y esperar en la página [Error Tracking][1] que aparezca el error. + +Para probar la carga de tus archivos dSYM y de asignación Proguard, genera un fallo en el subproceso principal nativo: + +```javascript +import { crashNativeMainThread } from 'react-native-performance-limiter'; + +const crashApp = () => { + crashNativeMainThread('custom error message'); +}; +``` + +## Expo Go + +Si estás utilizando Expo Go, cambia a las compilaciones de desarrollo (recomendado) o sigue utilizando Expo Go sin Datadog, mientras lo ejecutas en tu aplicación independiente (no recomendado). + +### Cambia de Expo Go a las compilaciones de desarrollo + +Las [compilaciones de desarrollo][9] de tu aplicación son compilaciones de depuración que contienen el paquete `expo-dev-client`. + +1. Habilita el [código nativo personalizado para ejecutar][10] con `expo run:android` y `expo run:ios`. +2. Para empezar a utilizar tu aplicación de desarrollo, ejecuta `expo install expo-dev-client` y `expo start --dev-client`. Se instala y se inicia el [paquete `expo-dev-client`][11] para ejecutar el código nativo añadido en el modo de desarrollador. + +### Desarrollar con Expo Go + +Cuando tu aplicación se ejecuta dentro de Expo Go, no puedes añadir ningún código nativo personalizado que no forme parte de la aplicación Expo Go. Dado que el kit de desarrollo de software (SDK) de React Native depende de cierto código nativo personalizado para ejecutarse, puedes desarrollar tu aplicación dentro de Expo Go sin Datadog y utilizar Datadog en tus compilaciones independientes. + +Tu aplicación se bloquea en Expo Go cuando se llama a algún código nativo (que no está incluido). Para utilizar Datadog con tu aplicación independiente y seguir utilizando Expo Go en el desarrollo, añade el siguiente archivo TypeScript a tu proyecto: + +```typescript +// mockDatadog.ts +// Datadog does not recommend this approach, consider moving to Expo development builds instead. +// This file is not officially maintained and might not be up-to-date with new releases. + +import { DdLogs, DdTrace, DdRum, DdSdkReactNative } from 'expo-datadog'; + +if (__DEV__) { + const emptyAsyncFunction = () => new Promise(resolve => resolve()); + + DdLogs.debug = emptyAsyncFunction; + DdLogs.info = emptyAsyncFunction; + DdLogs.warn = emptyAsyncFunction; + DdLogs.error = emptyAsyncFunction; + + DdTrace.startSpan = () => + new Promise(resolve => resolve('fakeSpanId')); + DdTrace.finishSpan = emptyAsyncFunction; + DdRum.startView = emptyAsyncFunction; + DdRum.stopView = emptyAsyncFunction; + DdRum.startAction = emptyAsyncFunction; + DdRum.stopAction = emptyAsyncFunction; + DdRum.addAction = emptyAsyncFunction; + DdRum.startResource = emptyAsyncFunction; + DdRum.stopResource = emptyAsyncFunction; + DdRum.addError = emptyAsyncFunction; + DdRum.addTiming = emptyAsyncFunction; + + DdSdkReactNative.initialize = emptyAsyncFunction; + DdSdkReactNative.setUserInfo = emptyAsyncFunction; + DdSdkReactNative.clearUserInfo = emptyAsyncFunction; + DdSdkReactNative.addUserExtraInfo = emptyAsyncFunction; + DdSdkReactNative.clearAllData = emptyAsyncFunction; + DdSdkReactNative.addAttributes = emptyAsyncFunction; + DdSdkReactNative.removeAttributes = emptyAsyncFunction; + DdSdkReactNative.setTrackingConsent = emptyAsyncFunction; + DdSdkReactNative.setAccountInfo = emptyAsyncFunction; + DdSdkReactNative.addAccountExtraInfo = emptyAsyncFunction; + DdSdkReactNative.clearAccountInfo = emptyAsyncFunction; +} +``` + +A continuación, impórtalo antes de inicializar el SDK de React Native de Datadog: + +```typescript +import './mockDatadog'; +import { CoreConfiguration, DdSdkReactNative } from 'expo-datadog'; + +const config = new CoreConfiguration(/* your config */); +DdSdkReactNative.initialize(config); +``` + +## Opciones de configuración adicionales + +{{% collapse-content title="Desactivar las cargas de archivos" level="h4" expanded=false id="disable-file-uploads" %}} + +Puedes desactivar la carga de algunos archivos estableciendo los parámetros `iosDsyms`, `iosSourcemaps`, `androidProguardMappingFiles`, o `androidSourcemaps` en `false`. + +```json +{ + "expo": { + "plugins": [ + [ + "expo-datadog", + { + "errorTracking": { + "iosDsyms": false + } + } + ] + ] + } +} +``` + +Si quieres deshabilitar **cualquier carga de archivos**, elimina `expo-datadog` de la lista de complementos. + +{{% /collapse-content %}} + +{{% collapse-content title="Lista de mapas fuente cargados" level="h4" expanded=false id="list-uploaded-source-maps" %}} + +Para verificar que tus mapas fuente, dSYMs y archivos de asignación Proguard se han cargado correctamente y están disponibles para la simbolización, puedes hacer una lista de todos los símbolos de depuración cargados. + +Consulta la página [Símbolos de depuración de RUM][13] para ver todos los símbolos cargados. + +{{% /collapse-content %}} + +{{% collapse-content title="Especifica una versión de lanzamiento personalizada" level="h4" expanded=false id="specify-custom-release-version" %}} + +Utiliza la variable de entorno `DATADOG_RELEASE_VERSION` para especificar una versión diferente para tus mapas fuente, a partir de `@datadog/mobile-react-native@2.3.5` y `@datadog/datadog-ci@v2.37.0`. + +Cuando el SDK se inicializa con un sufijo de versión, debes anular manualmente la versión de lanzamiento para que el mapa fuente y las versiones de compilación coincidan. + +{{% /collapse-content %}} + +{{% collapse-content title="Usar Expo con Datadog y Sentry" level="h4" expanded=false id="use-expo-with-datadog-sentry" %}} + +Los complementos de configuración de Datadog y Sentry utilizan expresiones regulares para modificar la fase de compilación de iOS "Empaquetar código e imágenes React Native" para enviar el mapa fuente. Esto puede hacer que las compilaciones de EAS fallen con un error `error: Found argument 'datadog-ci' which wasn't expected, or isn't valid in this context`. + +Para utilizar ambos complementos, asegúrate de añadir el complemento `expo-datadog` primero en orden en tu archivo `app.json`: + +``` +"plugins": [ + "expo-datadog", + "sentry-expo" +] +``` + +Si estás utilizando `expo-dev-client` y ya tienes el complemento `expo-datadog`, revierte sus cambios en el archivo `project.pbxproj` antes de añadir `sentry-expo` y ejecutar `npx expo prebuild` con ambos complementos. + +{{% /collapse-content %}} + +{{% collapse-content title="Comprobar los límites de tamaño de los archivos del mapa fuente" level="h4" expanded=false id="check-source-map-size" %}} + +El tamaño de los mapas fuente y los archivos de mapas está limitado a **500 MB** cada uno, mientras que los archivos dSYM pueden llegar a **2 GB** cada uno. + +Para calcular el tamaño de los mapas de origen y del paquete, ejecuta el siguiente comando: + +```shell +npx react-native bundle \ + --dev false \ + --platform ios \ + --entry-file index.js \ + --bundle-output build/main.jsbundle \ + --sourcemap-output build/main.jsbundle.map + +sourcemapsize=$(wc -c build/main.jsbundle.map | awk '{print $1}') +bundlesize=$(wc -c build/main.jsbundle | awk '{print $1}') +payloadsize=$(($sourcemapsize + $bundlesize)) + +echo "Size of source maps and bundle is $(($payloadsize / 1000000))MB" +``` + +Si aún no existe un directorio `build`, créalo primero ejecutando `mkdir build` y, a continuación, ejecuta el comando anterior. + +{{% /collapse-content %}} + +## Referencias adicionales + +{{< partial name="whats-next/whats-next.html" >}} + +[1]: https://app.datadoghq.com/rum/error-tracking +[2]: https://github.com/DataDog/expo-datadog +[3]: /es/real_user_monitoring/mobile_and_tv_monitoring/react_native/setup/expo/ +[4]: https://app.datadoghq.com/source-code/setup/rum +[5]: https://github.com/DataDog/datadog-ci/blob/master/packages/datadog-ci/src/commands/react-native/README.md#inject-debug-id +[6]: https://www.npmjs.com/package/react-native-performance-limiter +[7]: https://www.npmjs.com/package/@datadog/mobile-react-navigation +[8]: https://www.npmjs.com/package/@datadog/mobile-react-native-navigation +[9]: https://docs.expo.dev/development/introduction/ +[10]: https://docs.expo.dev/workflow/customizing/#releasing-apps-with-custom-native-code-to +[11]: https://docs.expo.dev/development/getting-started/ +[12]: /es/real_user_monitoring/ +[13]: https://app.datadoghq.com/source-code/setup/rum \ No newline at end of file diff --git a/content/es/integrations/eventstore.md b/content/es/integrations/eventstore.md index f3bacad2875..6a91b1e4236 100644 --- a/content/es/integrations/eventstore.md +++ b/content/es/integrations/eventstore.md @@ -1,81 +1,32 @@ --- app_id: eventstore -app_uuid: b0c2527f-671e-4a98-aa74-807d7f1826e3 -assets: - integration: - auto_install: true - configuration: - spec: assets/configuration/spec.yaml - events: - creates_events: false - metrics: - check: eventstore.proc.mem - metadata_path: metadata.csv - prefix: eventstore. - service_checks: - metadata_path: assets/service_checks.json - source_type_id: 10221 - source_type_name: EventStore -author: - homepage: https://github.com/DataDog/integrations-extras - name: Comunidad - sales_email: help@datadoghq.com - support_email: help@datadoghq.com categories: - almacenamiento en caché - almacenes de datos custom_kind: integración -dependencies: -- https://github.com/DataDog/integrations-extras/blob/master/eventstore/README.md -display_on_public_website: true -draft: false -git_integration_title: eventstore -integration_id: eventstore -integration_title: EventStore +description: Recopilación de métricas de EventStore integration_version: 2.1.0 -is_public: true -manifest_version: 2.0.0 -name: eventstore -public_title: EventStore -short_description: Recopilación de métricas de EventStore +media: [] supported_os: - Linux - Windows - macOS -tile: - changelog: CHANGELOG.md - classifier_tags: - - Categoría::Almacenamiento en caché - - Categoría::Almacenes de datos - - Sistema operativo compatible::Linux - - Sistema operativo compatible::Windows - - Sistema operativo compatible::macOS - - Oferta::Integración - configuration: README.md#Configuración - description: Recopilación de métricas de EventStore - media: [] - overview: README.md#Información general - support: README.md#Soporte - title: EventStore +title: EventStore --- - - - - ## Información general Obtén métricas de EventStore en tiempo real para: -* Visualizar y monitorizar colas de EventStore -* Captura todas las métricas disponibles en los siguientes endpoints de API: estadísticas, información de nodos, proyecciones no transitorias, suscripciones, gossip de clústeres (la lista de los endpoints susceptibles de scraping es configurable). +- Visualizar y monitorizar colas de EventStore +- Captura todas las métricas disponibles en los siguientes endpoints de API: estadísticas, información de nodos, proyecciones no transitorias, suscripciones, gossip de clústeres (la lista de los endpoints susceptibles de scraping es configurable). ## Configuración -El check de EventStore no está incluido en el paquete de [Datadog Agent][1], por lo que es necesario instalarlo. +El check de EventStore no está incluido en el paquete del [Datadog Agent](https://app.datadoghq.com/account/settings/agent/latest), por lo que es necesario instalarlo. ### Instalación -Para el Agent v7.21/v6.21 o posteriores, sigue las siguientes instrucciones para instalar el check de EventStore en tu host. Para realizar la instalación con el Docker Agent o con versiones anteriores del Agent, consulta [Uso de integraciones de la comunidad][2]. +Para el Agent v7.21+ / v6.21+, sigue las instrucciones a continuación para instalar el check de EventStore en tu host. Consulta [Usar integraciones comunitarias](https://docs.datadoghq.com/agent/guide/use-community-integrations/) para realizar la instalación con el Docker Agent o versiones anteriores del Agent. 1. Ejecuta el siguiente comando para instalar la integración del Agent: @@ -83,18 +34,18 @@ Para el Agent v7.21/v6.21 o posteriores, sigue las siguientes instrucciones para datadog-agent integration install -t datadog-eventstore== ``` -2. Configura tu integración como una [integración][3] de base. +1. Configura tu integración de forma similar a las [integraciones](https://docs.datadoghq.com/getting_started/integrations/) centrales. ### Configuración -1. Edita el archivo `eventstore.d/conf.yaml`, que se encuentra en la carpeta `conf.d/` en la raíz del [directorio de configuración de tu Agent][4], para empezar a recopilar tus [métricas](#metrics) de EventStore. - Consulta el [eventstore.d/conf.yaml de ejemplo][5] para conocer todas las opciones de configuración disponibles. +1. Edita el archivo `eventstore.d/conf.yaml` en la carpeta `conf.d/` en la raíz del [directorio de configuración del Agent](https://docs.datadoghq.com/agent/guide/agent-configuration-files/#agent-configuration-directory) para comenzar a recopilar [métricas](#metrics) de EventStore. + Consulta el [eventstore.d/conf.yaml de ejemplo](https://github.com/DataDog/integrations-extras/blob/master/eventstore/datadog_checks/eventstore/data/conf.yaml.example) para conocer todas las opciones de configuración disponibles. -2. [Reinicia el Agent][6]. +1. [Reinicia el Agent](https://docs.datadoghq.com/agent/guide/agent-commands/#start-stop-restart-the-agent). ### Validación -Ejecuta el [subcomando de estado del Agent][7] y busca `eventstore` en la sección **Checks**. +[Ejecuta el subcomando de estado del Agent](https://docs.datadoghq.com/agent/guide/agent-commands/#service-status) y busca `eventstore` en la sección Checks. ## Compatibilidad @@ -103,27 +54,103 @@ El check es compatible con las principales plataformas. ## Datos recopilados ### Métricas -{{< get-metrics-from-git "eventstore" >}} +| | | +| --- | --- | +| **eventstore.proc.mem**
(gauge) | Uso actual de la memoria
_Se muestra como byte_ | +| **eventstore.proc.cpu**
(gauge) | Uso actual de la CPU| +| **eventstore.proc.threads**
(gauge) | Subprocesos actuales| +| **eventstore.proc.contentions_rate**
(gauge) | contenciones actuales| +| **eventstore.proc.thrown_exceptions_rate**
(gauge) | número de excepciones| +| **eventstore.proc.disk.read_bytes**
(gauge) | Lecturas de disco (Bytes)
_Se muestra como byte_ | +| **eventstore.proc.disk.write_bytes**
(gauge) | Escrituras en disco (Bytes)
_Se muestra como byte_ | +| **eventstore.proc.disk.read_ops**
(gauge) | Lecturas de disco (Ops)| +| **eventstore.proc.disk.write_ops**
(gauge) | Escrituras en disco (Ops)| +| **eventstore.tcp.connections**
(gauge) | Conexiones Tcp| +| **eventstore.tcp.receiving_speed**
(gauge) | Recepción Tcp| +| **eventstore.tcp.sending_speed**
(gauge) | Envío Tcp| +| **eventstore.tcp.in_send**
(gauge) | Entrada Tcp| +| **eventstore.tcp.measure_time**
(gauge) | Medida Tcp| +| **eventstore.tcp.pending_received**
(gauge) | Tcp Pendiente| +| **eventstore.tcp.pending_send**
(gauge) | Tcp Pendiente| +| **eventstore.tcp.received_bytes.since_last_run**
(gauge) | Received_Bytes Since_Last| +| **eventstore.tcp.received_bytes.total**
(gauge) | Bytes de Received_Bytes| +| **eventstore.tcp.sent_bytes.since_last_run**
(gauge) | Sent_Bytes Since_Last| +| **eventstore.tcp.sent_bytes.total**
(gauge) | Total de Sent_Bytes| +| **eventstore.gc.allocation_speed**
(gauge) | Velocidad de asignación| +| **eventstore.gc.items_count.gen0**
(gauge) | Elementos Count.Gen0| +| **eventstore.gc.size.gen0**
(gauge) | Gen0 Gen0| +| **eventstore.gc.items_count.gen1**
(gauge) | Elementos Count.Gen1| +| **eventstore.gc.size.gen1**
(gauge) | Gen1 Gen1| +| **eventstore.gc.items_count.gen2**
(gauge) | Elementos Count.Gen2| +| **eventstore.gc.size.gen2**
(gauge) | Gen2 Gen2| +| **eventstore.gc.large_heap_size**
(gauge) | Tamaño de Large_Heap| +| **eventstore.gc.time_in_gc**
(gauge) | Recopilación de elementos no usados Time_In| +| **eventstore.gc.total_bytes_in_heaps**
(gauge) | Heaps de Total_Bytes_In
_Se muestra como byte_ | +| **eventstore.sys.free_mem**
(gauge) | Memoria libre| +| **eventstore.es.queue.avg_items_per_second**
(gauge) | Cola media de elementos por segundo| +| **eventstore.es.queue.avg_processing_time**
(gauge) | Cola media de tiempo de procesamiento| +| **eventstore.es.queue.current_idle_time**
(gauge) | Cola actual de tiempo de inactividad| +| **eventstore.es.queue.current_processing_time**
(gauge) | Cola actual de tiempo de procesamiento| +| **eventstore.es.queue.idle_time_percent**
(gauge) | Porcentaje de tiempo inactivo en cola| +| **eventstore.es.queue.length**
(gauge) | Longitud de la cola Longitud de la cola| +| **eventstore.es.queue.length_current_try_peak**
(gauge) | Pico de intentos actual de la longitud de la cola| +| **eventstore.es.queue.length_lifetime_peak**
(gauge) | Duración del pico de la longitud de la cola| +| **eventstore.es.queue.total_items_processed**
(gauge) | Elementos procesados del total de la cola| +| **eventstore.es.writer.flush_size.last**
(gauge) | Tamaño de la última descarga del escritor| +| **eventstore.es.writer.flush_delay_ms.last**
(gauge) | Retardo de la última descarga del escritor (ms)
_Se muestra en milisegundos_ | +| **eventstore.es.writer.flush_size.mean**
(gauge) | Tamaño medio de la descarga del escritor| +| **eventstore.es.writer.flush_delay_ms.mean**
(gauge) | Retardo medio de descarga del escritor (ms)| +| **eventstore.es.writer.flush_size.max**
(gauge) | Tamaño máximo de descarga del escritor (tamaño)| +| **eventstore.es.writer.flush_delay_ms.max**
(gauge) | Retardo máximo de descarga del escritor (ms)| +| **eventstore.es.writer.queued_flush_messages**
(gauge) | Mensajes de descarga en cola del escritor| +| **eventstore.es.read_index.cached_record**
(gauge) | Registro en caché del índice de lectura| +| **eventstore.es.read_index.not_cached_record**
(gauge) | Registro no almacenado en caché del índice de lectura| +| **eventstore.es.read_index.cached_stream_info**
(gauge) | Información de flujo en caché del índice de lectura| +| **eventstore.es.read_index.not_cached_stream_info**
(gauge) | Información del flujo no almacenada en caché del índice de lectura| +| **eventstore.es.read_index.cached_trans_info**
(gauge) | Información de transacción en caché del índice de lectura| +| **eventstore.es.read_index.not_cached_trans_info**
(gauge) | Información de transacción no almacenada en caché del índice de lectura| +| **eventstore.is_leader**
(gauge) | El nodo del clúster es un líder| +| **eventstore.is_follower**
(gauge) | El nodo del clúster es un seguidor| +| **eventstore.is_readonlyreplica**
(gauge) | El nodo del clúster es una réplica de solo lectura| +| **eventstore.running_projections.none**
(gauge) | El nodo no ejecuta proyecciones| +| **eventstore.running_projections.system**
(gauge) | El nodo ejecuta proyecciones del sistema| +| **eventstore.running_projections.all**
(gauge) | El nodo ejecuta todo tipo de proyecciones| +| **eventstore.projection.core_processing_time**
(gauge) | Tiempo de procesamiento del núcleo de proyección| +| **eventstore.projection.version**
(gauge) | Versión de proyección| +| **eventstore.projection.epoch**
(gauge) | Época de proyección| +| **eventstore.projection.reads_in_progress**
(gauge) | Lecturas de proyección en curso| +| **eventstore.projection.writes_in_progress**
(gauge) | Escrituras de proyección en curso| +| **eventstore.projection.partitions_cached**
(gauge) | Particiones de proyección en caché| +| **eventstore.projection.running**
(gauge) | La proyección está en ejecución| +| **eventstore.projection.progress**
(gauge) | Progreso de la proyección| +| **eventstore.projection.events_processed_after_restart**
(gauge) | Eventos de proyección procesados tras el reinicio| +| **eventstore.projection.buffered_events**
(gauge) | Eventos de proyección en buffer| +| **eventstore.projection.write_pending_events_before_checkpoint**
(gauge) | Eventos de escritura de proyección pendientes antes del punto de control| +| **eventstore.projection.write_pending_events_after_checkpoint**
(gauge) | Eventos de escritura de proyección pendientes después del punto de control| +| **eventstore.subscription.live**
(gauge) | La suscripción está activa| +| **eventstore.subscription.average_items_per_second**
(gauge) | Media de elementos de suscripción por segundo| +| **eventstore.subscription.items_processed**
(gauge) | Elementos de suscripción procesados| +| **eventstore.subscription.last_processed_event_number**
(gauge) | Número del último evento de suscripción procesado| +| **eventstore.subscription.last_known_event_number**
(gauge) | Número del último evento de suscripción conocido| +| **eventstore.subscription.connections**
(gauge) | Conexiones de suscripción| +| **eventstore.subscription.messages_in_flight**
(gauge) | Mensajes de suscripción en vuelo| +| **eventstore.cluster.member_alive**
(gauge) | El miembro del clúster está activo| +| **eventstore.cluster.last_commit_position**
(gauge) | Última posición confirmada del miembro del clúster| +| **eventstore.cluster.writer_checkpoint**
(gauge) | Punto de control del escritor del miembro del clúster| +| **eventstore.cluster.chaser_checkpoint**
(gauge) | Punto de control del buscador del miembro del clúster| +| **eventstore.cluster.epoch_position**
(gauge) | Posición de época del miembro del clúster| +| **eventstore.cluster.epoch_number**
(gauge) | Número de época del miembro del clúster| +| **eventstore.cluster.node_priority**
(gauge) | Prioridad del nodo miembro del clúster| ### Eventos El check de EventStore no incluye eventos. -### Checks de servicios +### Checks de servicio El check de EventStore no incluye checks de servicio. ## Solucionar problemas -¿Necesitas ayuda? Ponte en contacto con el [encargado de mantenimiento][9] de esta integración. - -[1]: https://app.datadoghq.com/account/settings/agent/latest -[2]: https://docs.datadoghq.com/es/agent/guide/use-community-integrations/ -[3]: https://docs.datadoghq.com/es/getting_started/integrations/ -[4]: https://docs.datadoghq.com/es/agent/guide/agent-configuration-files/#agent-configuration-directory -[5]: https://github.com/DataDog/integrations-extras/blob/master/eventstore/datadog_checks/eventstore/data/conf.yaml.example -[6]: https://docs.datadoghq.com/es/agent/guide/agent-commands/#start-stop-restart-the-agent -[7]: https://docs.datadoghq.com/es/agent/guide/agent-commands/#service-status -[8]: https://github.com/DataDog/integrations-extras/blob/master/eventstore/metadata.csv -[9]: https://github.com/DataDog/integrations-extras/blob/master/eventstore/manifest.json \ No newline at end of file +¿Necesitas ayuda? Ponte en contacto con el [responsable](https://github.com/DataDog/integrations-extras/blob/master/eventstore/manifest.json) de esta integración. \ No newline at end of file diff --git a/content/es/integrations/gatekeeper.md b/content/es/integrations/gatekeeper.md index 2cf2d4f0f7f..6368346802c 100644 --- a/content/es/integrations/gatekeeper.md +++ b/content/es/integrations/gatekeeper.md @@ -1,30 +1,5 @@ --- app_id: gatekeeper -app_uuid: 9c48b05d-ee74-4557-818e-14456c6f427b -assets: - dashboards: - Gatekeeper base dashboard: assets/dashboards/gatekeeper_overview.json - integration: - auto_install: true - configuration: - spec: assets/configuration/spec.yaml - events: - creates_events: false - metrics: - check: gatekeeper.constraints - metadata_path: metadata.csv - prefix: gatekeeper. - service_checks: - metadata_path: assets/service_checks.json - source_type_id: 10148 - source_type_name: Gatekeeper - logs: - source: gatekeeper -author: - homepage: https://github.com/DataDog/integrations-extras - name: Comunidad - sales_email: ara.pulido@datadoghq.com - support_email: ara.pulido@datadoghq.com categories: - nube - conformidad @@ -32,51 +7,22 @@ categories: - rastreo - seguridad custom_kind: integración -dependencies: -- https://github.com/DataDog/integrations-extras/blob/master/gatekeeper/README.md -display_on_public_website: true -draft: false -git_integration_title: gatekeeper -integration_id: gatekeeper -integration_title: Gatekeeper +description: Integración de Gatekeeper integration_version: 1.0.0 -is_public: true -manifest_version: 2.0.0 -name: gatekeeper -public_title: Gatekeeper -short_description: Integración de Gatekeeper +media: [] supported_os: - Linux -tile: - changelog: CHANGELOG.md - classifier_tags: - - Categoría::Nube - - Categoría::Cumplimiento - - Categoría::Configuración y despliegue - - Categoría::Contenedores - - Categoría::Seguridad - - Sistema operativo compatible::Linux - - Oferta::Integración - configuration: README.md#Configuración - description: Integración de Gatekeeper - media: [] - overview: README.md#Información general - support: README.md#Soporte - title: Gatekeeper +title: Gatekeeper --- - - - - ## Información general -Este check recopila métricas de [OPA Gatekeeper][1]. +Este check recopila métricas de [OPA Gatekeeper](https://github.com/open-policy-agent/gatekeeper). -![Dashboard de información general de Gatekeeper][2] +![Dashboard de información general de Gatekeeper](https://raw.githubusercontent.com/DataDog/integrations-extras/master/gatekeeper/images/gatekeeper_dashboard.png) ## Configuración -Sigue las instrucciones que se indican a continuación con el fin de instalar y configurar este check para un Agent que se ejecuta en un clúster de Kubernetes. También consulta las [plantillas de integración de Autodiscovery][3] para obtener orientación sobre la aplicación de estas instrucciones. +Sigue las instrucciones a continuación para instalar y configurar este check para un Agent que se ejecute en un clúster de Kubernetes. Consulta también las [plantillas de integración de Autodiscovery](https://docs.datadoghq.com/agent/kubernetes/integrations/) para obtener orientación sobre la aplicación de estas instrucciones. ### Instalación @@ -93,28 +39,31 @@ RUN agent integration install -r -t datadog-gatekeeper== Para instalar el check de Gatekeeper en tu clúster de Kubernetes: -1. Instala el [kit de herramientas para desarrolladores][4]. -2. Clona el repositorio `integrations-extras`: +1. Instala el [kit de herramientas para desarrolladores](https://docs.datadoghq.com/developers/integrations/python/). + +1. Clona el repositorio `integrations-extras`: ```shell git clone https://github.com/DataDog/integrations-extras.git. ``` -3. Actualiza la configuración de `ddev` con la ruta de `integrations-extras/`: +1. Actualiza la configuración de `ddev` con la ruta de `integrations-extras/`: ```shell ddev config set repos.extras ./integrations-extras ``` -4. Para crear el paquete de `gatekeeper`, ejecuta: +1. Para crear el paquete de `gatekeeper`, ejecuta: ```shell ddev -e release build gatekeeper ``` -5. [Descarga el manifiesto del Agent para instalar el Datadog Agent como DaemonSet][5]. -6. Crea dos `PersistentVolumeClaim`, uno para el código de checks y otro para la configuración. -7. Añádelos como volúmenes a tu plantilla de pods del Agent y úsalos para los checks y configuración: +1. [Descarga el manifiesto del Agent para instalar el Datadog Agent como DaemonSet](https://docs.datadoghq.com/agent/kubernetes/daemonset_setup/?tab=k8sfile). + +1. Crea dos `PersistentVolumeClaim`, uno para el código de checks y otro para la configuración. + +1. Añádelos como volúmenes a tu plantilla de pods del Agent y úsalos para los checks y configuración: ```yaml env: @@ -138,67 +87,91 @@ Para instalar el check de Gatekeeper en tu clúster de Kubernetes: claimName: agent-conf-claim ``` -8. Despliega el Datadog Agent en tu clúster de Kubernetes: +1. Despliega el Datadog Agent en tu clúster de Kubernetes: ```shell kubectl apply -f agent.yaml ``` -9. Copia el archivo .whl del artefacto de la integración en tus nodos de Kubernetes o súbelo a una URL pública. +1. Copia el archivo .whl del artefacto de la integración en tus nodos de Kubernetes o súbelo a una URL pública. -10. Ejecuta el siguiente comando para instalar la rueda de integraciones con el Agent: +1. Ejecuta el siguiente comando para instalar la rueda de integraciones con el Agent: - ```shell - kubectl exec ds/datadog -- agent integration install -w /.whl - ``` + ```shell + kubectl exec ds/datadog -- agent integration install -w /.whl + ``` -11. Ejecuta los siguientes comandos para copiar los checks y la configuración en los PVCs correspondientes: +1. Ejecuta los siguientes comandos para copiar los checks y la configuración en los PVCs correspondientes: - ```shell - kubectl exec ds/datadog -- sh - # cp -R /opt/datadog-agent/embedded/lib/python3.8/site-packages/datadog_checks/* /checksd - # cp -R /etc/datadog-agent/conf.d/* /confd - ``` + ```shell + kubectl exec ds/datadog -- sh + # cp -R /opt/datadog-agent/embedded/lib/python3.8/site-packages/datadog_checks/* /checksd + # cp -R /etc/datadog-agent/conf.d/* /confd + ``` -12. Reinicia los pods del Datadog Agent. +1. Reinicia los pods del Datadog Agent. ### Configuración -1. Edita el archivo `gatekeeper/conf.yaml`, en la carpeta `/confd` que has añadido al pod del Agent para empezar a recopilar tus datos de rendimiento de Gatekeeper. Consulta el [gatekeeper/conf.yaml de ejemplo][6] para conocer todas las opciones de configuración disponibles. +1. Edita el archivo `gatekeeper/conf.yaml`, en la carpeta `/confd` que añadiste al pod del Agent para empezar a recopilar los datos de rendimiento de tu gatekeeper. Ve el [gatekeeper/conf.yaml de ejemplo](https://github.com/DataDog/integrations-extras/blob/master/gatekeeper/datadog_checks/gatekeeper/data/conf.yaml.example) para conocer todas las opciones de configuración disponibles. -2. [Reinicia el Agent][7]. +1. [Reinicia el Agent](https://docs.datadoghq.com/agent/guide/agent-commands/#start-stop-and-restart-the-agent). ### Validación -[Ejecuta el subcomando de estado del Agent][8] y busca `gatekeeper` en la sección Checks. +[Ejecuta el subcomando de estado del Agent](https://docs.datadoghq.com/agent/guide/agent-commands/#agent-status-and-information) y busca `gatekeeper` en la sección Checks. ## Datos recopilados ### Métricas -{{< get-metrics-from-git "gatekeeper" >}} +| | | +| --- | --- | +| **gatekeeper.audit.duration.seconds.sum**
(count) | Latencia de la operación de auditoría en segundos
_Se muestra como segundo_ | +| **gatekeeper.audit.duration.seconds.count**
(count) | Latencia de la operación de auditoría en segundos
_Se muestra como segundo_ | +| **gatekeeper.audit.last_run_time**
(gauge) | Marca de tiempo de la última operación de auditoría| +| **gatekeeper.constraint_template_ingestion.duration.seconds.sum**
(count) | Distribución del tiempo que se tardó en ingerir una plantilla de restricciones en segundos
_Se muestra como segundo_ | +| **gatekeeper.constraint_template_ingestion.duration.seconds.count**
(count) | Distribución del tiempo que se tardó en ingerir una plantilla de restricciones en segundos
_Se muestra como segundo_ | +| **gatekeeper.constraint_template_ingestion.count**
(count) | Número total de acciones de ingesta de plantillas de restricciones| +| **gatekeeper.violations**
(gauge) | Número total de infracciones por restricción| +| **gatekeeper.constraints**
(gauge) | Número actual de restricciones conocidas| +| **gatekeeper.constraint_templates**
(gauge) | Número de plantillas de restricciones observadas| +| **gatekeeper.request.duration.seconds.sum**
(count) | \[Obsoleto desde Gatekeeper v3.4.0\] El tiempo de respuesta en segundos
_Se muestra como segundo_ | +| **gatekeeper.request.duration.seconds.count**
(count) | \[Obsoleto desde Gatekeeper v3.4.0\] El tiempo de respuesta en segundos
_Se muestra como segundo_ | +| **gatekeeper.request.count**
(count) | \[Obsoleto desde Gatekeeper v3.4.0\] Número total de solicitudes que se dirigen al webhook| +| **gatekeeper.sync**
(gauge) | Número total de recursos de cada tipo que se almacenan en caché| +| **gatekeeper.sync.duration.seconds.sum**
(count) | Latencia de la operación de sincronización en segundos
_Se muestra como segundo_ | +| **gatekeeper.sync.duration.seconds.count**
(count) | Latencia de la operación de sincronización en segundos
_Se muestra como segundo_ | +| **gatekeeper.sync.last_run_time**
(gauge) | Marca de tiempo de la última operación de sincronización| +| **gatekeeper.watch.intended**
(gauge) | El número total de Grupos/Versiones/Tipos que el gestor de vigilancia tiene instrucciones de vigilar.| +| **gatekeeper.watch.watched**
(gauge) | El número total de Grupos/Versiones/Tipos vigilados actualmente por el gestor de vigilancia.| +| **gatekeeper.validation.request.count**
(count) | Número de solicitudes enviadas al webhook de validación| +| **gatekeeper.validation.request.duration.seconds.sum**
(count) | El tiempo de respuesta en segundo
_Se muestra como segundo_ | +| **gatekeeper.validation.request.duration.seconds.count**
(count) | El tiempo de respuesta en segundo
_Se muestra como segundo_ | +| **gatekeeper.mutator.ingestion.count**
(count) | Número total de acciones de ingesta de Mutator| +| **gatekeeper.mutator.ingestion.duration.seconds.sum**
(count) | La distribución de las duraciones de ingesta de Mutator
_Se muestra como segundo_ | +| **gatekeeper.mutator.ingestion.duration.seconds.count**
(count) | La distribución de las duraciones de ingesta de Mutator
_Se muestra como segundo_ | +| **gatekeeper.mutators**
(gauge) | Número actual de objetos de Mutator| +| **gatekeeper.mutator.conflicting.count**
(gauge) | Número actual de objetos de Mutator en conflicto| ### Eventos Gatekeeper no incluye eventos. -### Checks de servicios -{{< get-service-checks-from-git "gatekeeper" >}} +### Checks de servicio +**gatekeeper.prometheus.health** -## Solucionar problemas +Devuelve `CRITICAL` si el agent no consigue conectarse al endpoint de métricas de Prometheus, en caso contrario, devuelve `OK`. + +_Estados: ok, critical_ -¿Necesitas ayuda? Ponte en contacto con el [servicio de asistencia de Datadog][11]. +**gatekeeper.health** +Devuelve `CRITICAL` si el agent no consigue conectar con el endpoint de estado del gatekeeper, `OK` si devuelve 200, `WARNING` en caso contrario. + +_Estados: ok, warning, critical_ + +## Solucionar problemas -[1]: https://github.com/open-policy-agent/gatekeeper -[2]: https://raw.githubusercontent.com/DataDog/integrations-extras/master/gatekeeper/images/gatekeeper_dashboard.png -[3]: https://docs.datadoghq.com/es/agent/kubernetes/integrations/ -[4]: https://docs.datadoghq.com/es/developers/integrations/python/ -[5]: https://docs.datadoghq.com/es/agent/kubernetes/daemonset_setup/?tab=k8sfile -[6]: https://github.com/DataDog/integrations-extras/blob/master/gatekeeper/datadog_checks/gatekeeper/data/conf.yaml.example -[7]: https://docs.datadoghq.com/es/agent/guide/agent-commands/#start-stop-and-restart-the-agent -[8]: https://docs.datadoghq.com/es/agent/guide/agent-commands/#agent-status-and-information -[9]: https://github.com/DataDog/integrations-extras/blob/master/gatekeeper/metadata.csv -[10]: https://github.com/DataDog/integrations-extras/blob/master/gatekeeper/assets/service_checks.json -[11]: https://docs.datadoghq.com/es/help/ \ No newline at end of file +¿Necesitas ayuda? Ponte en contacto con el [soporte de Datadog](https://docs.datadoghq.com/help/). \ No newline at end of file diff --git a/content/es/integrations/gatling-enterprise.md b/content/es/integrations/gatling-enterprise.md new file mode 100644 index 00000000000..3db776214c1 --- /dev/null +++ b/content/es/integrations/gatling-enterprise.md @@ -0,0 +1,107 @@ +--- +aliases: +- /es/integrations/gatling_enterprise +app_id: gatling-enterprise +categories: +- herramientas de desarrollo +- tests +custom_kind: integración +description: Recopilación de métricas de TEST de carga de Gatling Enterprise +integration_version: 1.2.0 +media: +- caption: 'Dashboard de información general de Gatling Enterprise: respuestas y solicitudes' + image_url: images/app.datadoghq.com_dashboard_n9p-inx-6jn_gatling-enterprise-overview_fromUser=false&refresh_mode=sliding&from_ts=1747402829806&to_ts=1747403729806&live=true + (2) 1.png + media_type: imagen +- caption: 'Dashboard de información general de Gatling Enterprise: tiempo de respuesta' + image_url: images/app.datadoghq.com_dashboard_n9p-inx-6jn_gatling-enterprise-overview_fromUser=false&refresh_mode=sliding&from_ts=1747402829806&to_ts=1747403729806&live=true + (2) 1-1.png + media_type: imagen +- caption: 'Dashboard de información general de Gatling Enterprise: usuarios' + image_url: images/app.datadoghq.com_dashboard_n9p-inx-6jn_gatling-enterprise-overview_fromUser=false&refresh_mode=sliding&from_ts=1747402829806&to_ts=1747403729806&live=true + (2) 1-2.png + media_type: imagen +supported_os: +- linux +title: Gatling Enterprise +--- +## Información general + +Gatling Enterprise es una plataforma de tests de carga diseñada para ayudar a los equipos a validar la escalabilidad y el rendimiento de las aplicaciones en condiciones de tráfico reales. + +Con la integración de Datadog, los equipos pueden investigar problemas de rendimiento correlacionando métricas de carga de tests como tiempos de respuesta, rendimiento y errores con datos de infraestructura rastreados en Datadog. + +Gatling Enterprise envía métricas a Datadog, lo que permite a los equipos de ingeniería y SRE centralizar las perspectivas de rendimiento y mejorar la toma de decisiones en torno a la escalabilidad y la fiabilidad. + +## Configuración + +> Nota**: Esta integración está disponible para los clientes de Gatling Enterprise. Para obtener más información sobre Gatling Enterprise y empezar de forma gratuita, visita [gatling.io/products](https://gatling.io/products). + +1. En Datadog, ve a **Integrations** (Integraciones), selecciona el cuadro de Gatling Enterprise y haz clic en **Install Integration** (Instalar integración). + +1. En tu instalación del plano de control de Gatling, edita tu [archivo de configuración](https://docs.gatling.io/reference/install/cloud/private-locations/introduction/). En la sección `system-properties`, añade los parámetros siguientes. Sustituye YOUR_API_KEY por tu [clave de API de Datadog](https://docs.datadoghq.com/account_management/api-app-keys/) y utiliza el [sitio de Datadog](https://docs.datadoghq.com/getting_started/site/) correcto para tu organización: + +```bash +control-plane { + locations = [ + { + id = "prl_example" + # ... other configuration for your location + system-properties { + "gatling.enterprise.dd.api.key" = "YOUR_API_KEY" # Fill your API key here + "gatling.enterprise.dd.site" = "datadoghq.com" # Replace with your Datadog site + } + } + ] +} +``` + +3. Despliega y reinicia tu plano de control + +## Datos recopilados + +La integración de Gatling Enterprise recopila todas las métricas de bases de datos, nodos y particiones. + +### Métricas + +| | | +| --- | --- | +| **gatling_enterprise.user.start_count**
(count) | Número de usuarios inyectados
_Se muestra como usuario_ | +| **gatling_enterprise.user.end_count**
(count) | Número de usuarios detenidos
_Se muestra como usuario_ | +| **gatling_enterprise.user.concurrent**
(count) | Número de usuarios concurrentes
_Se muestra como usuario_ | +| **gatling_enterprise.request.count**
(count) | Número de solicitudes
_Se muestra como solicitud_ | +| **gatling_enterprise.response.count**
(count) | Número de respuestas
_Se muestra como respuesta_ | +| **gatling_enterprise.response.response_time.max**
(gauge) | Tiempo máximo de respuesta
_Se muestra en milisegundos_ | +| **gatling_enterprise.response.response_time.min**
(gauge) | Tiempo mínimo de respuesta
_Se muestra en milisegundos_ | +| **gatling_enterprise.response.response_time.p95**
(gauge) | Tiempo de respuesta para los percentiles 95 (95 % de las solicitudes)
_Se muestra en milisegundos_ | +| **gatling_enterprise.response.response_time.p99**
(gauge) | Tiempo de respuesta para los percentiles 99 (99 % de las solicitudes)
_Se muestra en milisegundos_ | +| **gatling_enterprise.response.response_time.p999**
(gauge) | Tiempo de respuesta para los percentiles 99,9 (99,9 % de las solicitudes)
_Se muestra en milisegundos_ | +| **gatling_enterprise.response.code**
(count) | Códigos de estado HTTP de la respuesta| +| **gatling_enterprise.request.bits**
(count) | Uso de ancho de banda saliente
_Se muestra como bit_ | +| **gatling_enterprise.response.bits**
(count) | Uso de ancho de banda entrante
_Se muestra como bit_ | +| **gatling_enterprise.request.tcp.open_count**
(count) | Número de solicitudes TCP abiertas
_Se muestra como solicitud_ | +| **gatling_enterprise.request.tcp.close_count**
(count) | Número de solicitudes TCP cerradas
_Se muestra como solicitud_ | +| **gatling_enterprise.response.tcp.count**
(count) | Número de solicitudes TCP
_Se muestra como solicitud_ | +| **gatling_enterprise.response.tls.count**
(count) | Número de respuestas TSL
_Se muestra como respuesta_ | +| **gatling_enterprise.response.tcp.connect_time.min**
(gauge) | Tiempo mínimo de conexión de respuesta TCP
_Se muestra en milisegundos_ | +| **gatling_enterprise.response.tcp.connect_time.max**
(gauge) | Tiempo máximo de conexión de respuesta TCP
_Se muestra en milisegundos_ | +| **gatling_enterprise.response.tcp.connect_time.p95**
(gauge) | Tiempo de conexión de la respuesta TCP para los percentiles 95 (95 % de las solicitudes)
_Se muestra en milisegundos_ | +| **gatling_enterprise.response.tcp.connect_time.p99**
(gauge) | Tiempo de conexión de la respuesta TCP para los percentiles 99 (99 % de las solicitudes)
_Se muestra en milisegundos_ | +| **gatling_enterprise.response.tcp.connect_time.p999**
(gauge) | Tiempo de conexión de la respuesta TCP para los percentiles 99,9 (99,9 % de las solicitudes)
_Se muestra en milisegundos_ | +| **gatling_enterprise.response.tls.handshake_time.min**
(gauge) | Tiempo mínimo de handshake de respuesta TLS
_Se muestra en milisegundos_ | +| **gatling_enterprise.response.tls.handshake_time.max**
(gauge) | Tiempo máximo de handshake de respuesta TLS
_Se muestra en milisegundos_ | +| **gatling_enterprise.response.tls.handshake_time.p95**
(gauge) | Tiempo de protocolo de respuesta TLS para los percentiles 95 (95 % de las solicitudes)
_Se muestra en milisegundos_ | +| **gatling_enterprise.response.tls.handshake_time.p99**
(gauge) | Tiempo de protocolo de respuesta TLS para los percentiles 99 (99 % de las solicitudes)
_Se muestra en milisegundos_ | +| **gatling_enterprise.response.tls.handshake_time.p999**
(gauge) | Tiempo de protocolo de respuesta TLS para los percentiles 99,9 (99,9 % de las solicitudes)
_Se muestra en milisegundos_ | + +## Desinstalación + +1. En Datadog, ve a **Integrations** (Integraciones), selecciona el cuadro de Gatling Enterprise y haz clic en **Uninstall Integration** (Desinstalar integración). + +1. En tu instalación del plano de control de Gatling, edita tu [archivo de configuración](https://docs.gatling.io/reference/install/cloud/private-locations/introduction). En la sección `system-properties`, elimina las líneas que contienen `gatling.enterprise.dd`. + +1. Despliega y reinicia tu plano de control. + +## Soporte + +¿Necesitas ayuda? Ponte en contacto con el [soporte de Gatling Enterprise](https://gatlingcorp.atlassian.net/servicedesk/customer/portal/8). \ No newline at end of file diff --git a/content/es/integrations/gearman.md b/content/es/integrations/gearman.md new file mode 100644 index 00000000000..6a15726be34 --- /dev/null +++ b/content/es/integrations/gearman.md @@ -0,0 +1,126 @@ +--- +aliases: +- /es/integrations/gearmand +app_id: gearman +categories: +- recopilación de logs +custom_kind: integración +description: Rastrea el número de trabajos en cola y en ejecución, en total o por + tarea. +integration_version: 5.0.0 +media: [] +supported_os: +- linux +- macos +title: Gearman +--- +## Información general + +Recopila métricas de Gearman para: + +- Visualizar el rendimiento de Gearman. +- Saber cuántas tareas están en cola o en ejecución. +- Correlacionar el rendimiento de Gearman con el del resto de tus aplicaciones. + +## Configuración + +### Instalación + +El check de Gearman está incluido en el paquete del [Datadog Agent](https://app.datadoghq.com/account/settings/agent/latest), por lo que no necesitas instalar nada más en tus servidores de trabajo de Gearman. + +### Configuración + +{{< tabs >}} + +{{% tab "Host" %}} + +#### host + +Para configurar este check para un Agent que se ejecuta en un host: + +1. Edita el archivo `gearmand.d/conf.yaml`, en la carpeta `conf.d/` en la raíz del [directorio de configuración del Agent](https://docs.datadoghq.com/agent/guide/agent-configuration-files/#agent-configuration-directory) para empezar a recopilar tus datos de rendimiento de Gearman. Consulta el [gearmand.d/conf.yaml de ejemplo](https://github.com/DataDog/integrations-core/blob/master/gearmand/datadog_checks/gearmand/data/conf.yaml.example) para conocer todas las opciones de configuración disponibles. + + ```yaml + init_config: + + instances: + - server: localhost + port: 4730 + ``` + +1. [Reinicia el Agent](https://docs.datadoghq.com/agent/guide/agent-commands/#start-stop-and-restart-the-agent) + +{{% /tab %}} + +{{% tab "Containerized" %}} + +#### En contenedores + +Para entornos en contenedores, consulta las [plantillas de integración de Autodiscovery](https://docs.datadoghq.com/agent/kubernetes/integrations/) para obtener orientación sobre la aplicación de los parámetros que se indican a continuación. + +| Parámetro | Valor | +| -------------------- | -------------------------------------- | +| `` | `gearmand` | +| `` | en blanco o `{}` | +| `` | `{"server":"%%host%%", "port":"4730"}` | + +{{% /tab %}} + +{{< /tabs >}} + +#### Recopilación de logs + +1. La recopilación de logs está desactivada en forma predeterminada en el Datadog Agent, actívala en tu archivo `datadog.yaml`: + + ```yaml + logs_enabled: true + ``` + +1. Añade este bloque de configuración a tu archivo `gearmand.d/conf.yaml` para empezar a recopilar tus logs de Gearman: + + ```yaml + logs: + - type: file + path: /var/log/gearmand.log + source: gearman + ``` + + Cambia el valor del parámetro `path` en función de tu entorno. Consulta el [gearmand.d/conf.yaml de ejemplo](https://github.com/DataDog/integrations-core/blob/master/gearmand/datadog_checks/gearmand/data/conf.yaml.example) para conocer todas las opciones de configuración disponibles. + +1. [Reinicia el Agent](https://docs.datadoghq.com/agent/guide/agent-commands/#start-stop-and-restart-the-agent). + +Consulta la [recopilación de logs de Kubernetes](https://docs.datadoghq.com/agent/kubernetes/log/) para obtener información sobre la configuración del Agent para la recopilación de logs en entornos de Kubernetes. + +### Validación + +[Ejecuta el subcomando `status` del Agent](https://docs.datadoghq.com/agent/guide/agent-commands/#agent-status-and-information) y busca `gearmand` en la sección Checks. + +## Datos recopilados + +### Métricas + +| | | +| --- | --- | +| **gearman.queued**
(gauge) | El número total de trabajos en la cola.
_Se muestra como tarea_ | +| **gearman.queued_by_task**
(gauge) | El número de trabajos en la cola por tarea.
_Se muestra como tarea_ | +| **gearman.running**
(gauge) | El número total de trabajos de Gearman en ejecución.
_Se muestra como tarea_ | +| **gearman.running_by_task**
(gauge) | El número de trabajos de Gearman en ejecución por tarea.
_Se muestra como tarea_ | +| **gearman.unique_tasks**
(gauge) | El número de todas las funciones registradas con Gearman.
_Se muestra como tarea_ | +| **gearman.workers**
(gauge) | El número total de workers de Gearman capaces.
_Se muestra como proceso_ | +| **gearman.workers_by_task**
(gauge) | El número de workers de Gearman capaces por tarea.
_Se muestra como proceso_ | + +### Eventos + +El check de Gearman no incluye eventos. + +### Checks de servicio + +**gearman.can_connect** + +Devuelve `CRITICAL` si el check del Agent no puede conectarse a la instancia de Gearman supervisada. En caso contrario, devuelve `OK`. + +_Estados: ok, critical_ + +## Solucionar problemas + +¿Necesitas ayuda? Ponte en contacto con el [soporte de Datadog](https://docs.datadoghq.com/help/). \ No newline at end of file diff --git a/content/es/integrations/google-cloud-firebase.md b/content/es/integrations/google-cloud-firebase.md new file mode 100644 index 00000000000..86ac5f4b908 --- /dev/null +++ b/content/es/integrations/google-cloud-firebase.md @@ -0,0 +1,107 @@ +--- +aliases: +- /es/integrations/google_cloud_firebase +app_id: google-cloud-firebase +categories: +- nube +- google cloud +- recopilación de logs +- móvil +custom_kind: integración +description: Firebase es una plataforma móvil que te ayuda a desarrollar aplicaciones + rápidamente. +media: [] +title: Google Cloud Firebase +--- +## Información general + +Firebase es una plataforma móvil que te ayuda a desarrollar rápidamente aplicaciones de alta calidad, a hacer crecer tu base de usuarios y a ganar más dinero. + +Obtén métricas de Google Firebase para: + +- Visualizar el rendimiento de tus bases de datos y tus servicios de alojamiento Firebase. +- Correlacionar el rendimiento de tus herramientas Firebase con tus aplicaciones. + +## Configuración + +### Instalación + +Si aún no lo has hecho, configura primero la [integración de Google Cloud Platform](https://docs.datadoghq.com/integrations/google-cloud-platform/). No es necesario realizar ningún otro paso de instalación. + +### Recopilación de logs + +Los logs de Firebase se recopilan con Google Cloud Logging y se envían a un trabajo de Dataflow a través de un tema Cloud Pub/Sub. Si aún no lo has hecho, [configura la generación de logs con la plantilla de Datadog Dataflow](https://docs.datadoghq.com/integrations/google-cloud-platform/#log-collection). + +Una vez hecho esto, exporta tus logs de Google Firebase desde Google Cloud Logging al tema Pub/Sub: + +1. Ve a la [página Google Cloud Logging](https://console.cloud.google.com/logs/viewer) y filtra los logs de Firebase. +1. Haz clic en **Create Export** (Crear exportación) y asigna un nombre al sumidero. +1. Elige "Cloud Pub/Sub" como destino y selecciona el tema Pub/Sub creado para tal fin. **Nota**: El tema Pub/Sub puede encontrarse en un proyecto diferente. +1. Haz clic en **Create** (Crear) y espera a que aparezca el mensaje de confirmación. + +## Datos recopilados + +### Métricas + +| | | +| --- | --- | +| **gcp.firebaseappcheck.resources.verification_count**
(count) | Verificaciones realizadas por un servicio de integración para un recurso de destino.| +| **gcp.firebaseappcheck.services.verification_count**
(count) | Verificaciones realizadas por un servicio integrador.| +| **gcp.firebaseauth.phone_auth.phone_verification_count**
(count) | Recuento detallado de la verificación telefónica.| +| **gcp.firebasedatabase.io.database_load**
(gauge) | Porcentaje de carga de la base de datos de E/S agrupada por tipo.
_Se muestra como porcentaje_ | +| **gcp.firebasedatabase.io.persisted_bytes_count**
(count) | Bytes de datos persistentes en disco.
_Se muestra en bytes_ | +| **gcp.firebasedatabase.io.sent_responses_count**
(count) | Número de respuestas enviadas o transmitidas a los clientes.
_Se muestra en bytes_ | +| **gcp.firebasedatabase.io.utilization**
(gauge) | Porcentaje de uso de E/S.
_Se muestra como porcentaje_ | +| **gcp.firebasedatabase.network.active_connections**
(gauge) | Número de conexiones pendientes.
_Se muestra como conexión_ | +| **gcp.firebasedatabase.network.api_hits_count**
(count) | Número de aciertos en tu base de datos agrupados por tipo.| +| **gcp.firebasedatabase.network.broadcast_load**
(gauge) | Uso del tiempo necesario para preparar y enviar transmisiones a los clientes.| +| **gcp.firebasedatabase.network.disabled_for_overages**
(gauge) | Indica si la base de datos Firebase ha sido desactivada por excesos en la red.| +| **gcp.firebasedatabase.network.https_requests_count**
(count) | Número de solicitudes HTTPS recibidas.| +| **gcp.firebasedatabase.network.monthly_sent**
(gauge) | Total de bytes salientes enviados agregados y restablecidos mensualmente.
_Se muestra en bytes_ | +| **gcp.firebasedatabase.network.monthly_sent_limit**
(gauge) | Límite de red mensual para la base de datos Firebase.
_Se muestra en bytes_ | +| **gcp.firebasedatabase.network.sent_bytes_count**
(count) | Uso de ancho de banda saliente para la base de datos Firebase.
_Se muestra en bytes_ | +| **gcp.firebasedatabase.network.sent_payload_and_protocol_bytes_count**
(count) | Uso de ancho de banda saliente sin sobrecarga de cifrado.
_Se muestra en bytes_ | +| **gcp.firebasedatabase.network.sent_payload_bytes_count**
(count) | Uso de ancho de banda saliente sin cifrado ni protocolo.
_Se muestra en bytes_ | +| **gcp.firebasedatabase.rules.evaluation_count**
(count) | Número de evaluaciones de reglas de seguridad de bases de datos en tiempo real de Firebase realizadas.| +| **gcp.firebasedatabase.storage.disabled_for_overages**
(gauge) | Indica si la base de datos Firebase ha sido desactivada por exceso de almacenamiento.| +| **gcp.firebasedatabase.storage.limit**
(gauge) | Límite de almacenamiento para la base de datos Firebase.
_Se muestra en bytes_ | +| **gcp.firebasedatabase.storage.total_bytes**
(gauge) | Tamaño total del almacenamiento de la base de datos Firebase.
_Se muestra en bytes_ | +| **gcp.firebasedataconnect.connector.datasource_latencies.avg**
(count) | Media de la latencia de las fuentes de datos consultadas por la operación predefinida ejecutada por el conector.
_Se muestra en milisegundos_ | +| **gcp.firebasedataconnect.connector.datasource_latencies.samplecount**
(count) | Recuento de muestras de la latencia de las fuentes de datos consultadas por la operación predefinida ejecutada por el conector.
_Se muestra en milisegundos_ | +| **gcp.firebasedataconnect.connector.datasource_latencies.sumsqdev**
(count) | Suma de la desviación al cuadrado de la latencia de las fuentes de datos consultadas por la operación predefinida ejecutada por el conector.
_Se muestra en milisegundos_ | +| **gcp.firebasedataconnect.connector.datasource_request_bytes_count**
(count) | Número de bytes enviados a la fuente de datos consultada por la operación predefinida ejecutada por el conector.
_Se muestra en bytes_ | +| **gcp.firebasedataconnect.connector.datasource_response_bytes_count**
(count) | Número de bytes devueltos por la fuente de datos consultada por la operación predefinida ejecutada por el conector.
_Se muestra en bytes_ | +| **gcp.firebasedataconnect.connector.network.sent_bytes_count**
(count) | Número de bytes transferidos por el conector.
_Se muestra en bytes_ | +| **gcp.firebasedataconnect.connector.operation_count**
(count) | Número de operaciones predefinidas ejecutadas por el conector.| +| **gcp.firebasedataconnect.connector.operation_latencies.avg**
(count) | Media de la latencia de las operaciones predefinidas ejecutadas por el conector.
_Se muestra en milisegundos_ | +| **gcp.firebasedataconnect.connector.operation_latencies.samplecount**
(count) | Recuento de muestras de la latencia de las operaciones predefinidas ejecutadas por el conector.
_Se muestra en milisegundos_ | +| **gcp.firebasedataconnect.connector.operation_latencies.sumsqdev**
(count) | Suma de la desviación al cuadrado de la latencia de las operaciones predefinidas ejecutadas por el conector.
_Se muestra en milisegundos_ | +| **gcp.firebasedataconnect.service.datasource_latencies.avg**
(count) | Media de la latencia de las fuentes de datos consultadas por por operaciones administrativas arbitrarias ejecutadas directamente en el servicio.
_Se muestra en milisegundos_ | +| **gcp.firebasedataconnect.service.datasource_latencies.samplecount**
(count) | Recuento de muestras de la latencia de las fuentes de datos consultadas por operaciones administrativas arbitrarias ejecutadas directamente en el servicio.
_Se muestra en milisegundos_ | +| **gcp.firebasedataconnect.service.datasource_latencies.sumsqdev**
(count) | Suma de la desviación al cuadrado de la latencia de las fuentes de datos consultadas por operaciones administrativas arbitrarias ejecutadas directamente en el servicio.
_Se muestra en milisegundos_ | +| **gcp.firebasedataconnect.service.datasource_request_bytes_count**
(count) | Número de bytes enviados a la fuente de datos consultada por operaciones administrativas arbitrarias ejecutadas directamente en el servicio.
_Se muestra en bytes_ | +| **gcp.firebasedataconnect.service.datasource_response_bytes_count**
(count) | Número de bytes devueltos por las fuentes de datos consultadas por operaciones administrativas arbitrarias ejecutadas directamente en el servicio.
_Se muestra en bytes_ | +| **gcp.firebasedataconnect.service.network.sent_bytes_count**
(count) | Número de bytes transferidos por operaciones administrativas arbitrarias ejecutadas directamente en el servicio.
_Se muestra en bytes_ | +| **gcp.firebasedataconnect.service.operation_count**
(count) | Número de operaciones administrativas arbitrarias ejecutadas directamente en el servicio.| +| **gcp.firebasedataconnect.service.operation_latencies.avg**
(count) | Media de la latencia de las operaciones administrativas arbitrarias ejecutadas directamente en el servicio.
_Se muestra en milisegundos_ | +| **gcp.firebasedataconnect.service.operation_latencies.samplecount**
(count) | Recuento de muestras de la latencia de las operaciones administrativas arbitrarias ejecutadas directamente en el servicio.
_Se muestra en milisegundos_ | +| **gcp.firebasedataconnect.service.operation_latencies.sumsqdev**
(count) | Suma de la desviación al cuadrado de la latencia de las operaciones administrativas arbitrarias ejecutadas directamente en el servicio.
_Se muestra en milisegundos_ | +| **gcp.firebaseextensions.extension.version.active_instances**
(gauge) | Número de instancias activas de la versión de extensión publicada.| +| **gcp.firebasehosting.network.monthly_sent**
(gauge) | Total de bytes salientes enviados, agregados y restablecidos mensualmente.
_Se muestra en bytes_ | +| **gcp.firebasehosting.network.monthly_sent_limit**
(gauge) | Límite de red mensual para Firebase Hosting.
_Se muestra en bytes_ | +| **gcp.firebasehosting.network.sent_bytes_count**
(count) | Uso de ancho de banda saliente para Firebase Hosting.
_Se muestra en bytes_ | +| **gcp.firebasehosting.storage.limit**
(gauge) | Límite de almacenamiento para Firebase Hosting.
_Se muestra en bytes_ | +| **gcp.firebasehosting.storage.total_bytes**
(gauge) | Tamaño del almacenamiento de Firebase Hosting.
_Se muestra en bytes_ | +| **gcp.firebasestorage.rules.evaluation_count**
(count) | Número de evaluaciones de reglas de seguridad de almacenamiento en la nube de Firebase realizadas en respuesta a solicitudes de escritura o lectura.| + +### Eventos + +La integración Google Firebase no incluye eventos. + +### Checks de servicio + +La integración Google Firebase no incluye checks de servicio. + +## Solucionar problemas + +¿Necesitas ayuda? Ponte en contacto con el [servicio de asistencia de Datadog](https://docs.datadoghq.com/help/). \ No newline at end of file diff --git a/content/es/integrations/google-cloud-firestore.md b/content/es/integrations/google-cloud-firestore.md new file mode 100644 index 00000000000..0897bd608ad --- /dev/null +++ b/content/es/integrations/google-cloud-firestore.md @@ -0,0 +1,88 @@ +--- +aliases: +- /es/integrations/google_cloud_firestore +app_id: google-cloud-firestore +categories: +- nube +- almacenes de datos +- google cloud +- recopilación de logs +- móvil +custom_kind: integración +description: Base de datos flexible y escalable para el desarrollo móvil, web y de + servidor de Firebase y Google Cloud. +media: [] +title: Google Cloud Firestore +--- +## Información general + +Google Cloud Firestore es una base de datos flexible y escalable para el desarrollo móvil, web y de servidor de Firebase y Google Cloud Platform. + +Utiliza la integración Google Cloud Platform en Datadog para recopilar métricas de Google Cloud Firestore. + +## Configuración + +### Instalación + +Si aún no lo has hecho, configura primero la [integración de Google Cloud Platform](https://docs.datadoghq.com/integrations/google-cloud-platform/). No hay más pasos de instalación. + +### Recopilación de logs + +Los logs de Google Cloud Firestore se recopilan con Google Cloud Logging y se envían a un trabajo de Dataflow a través de un tema Cloud Pub/Sub. Si aún no lo has hecho, [configura la generación de logs con la plantilla de Datadog Dataflow](https://docs.datadoghq.com/integrations/google-cloud-platform/#log-collection). + +Una vez hecho esto, exporta tus logs de Google Cloud Firestore de Google Cloud Logging al tema Pub/Sub: + +1. Ve a la [página de Google Cloud Logging](https://console.cloud.google.com/logs/viewer) y filtra los logs de Google Cloud Firestore. +1. Haz clic en **Create Export** (Crear exportación) y asigna un nombre al sumidero. +1. Elige "Cloud Pub/Sub" como destino y selecciona el tema Pub/Sub creado para tal fin. **Nota**: El tema Pub/Sub puede encontrarse en un proyecto diferente. +1. Haz clic en **Create** (Crear) y espera a que aparezca el mensaje de confirmación. + +## Datos recopilados + +### Métricas + +| | | +| --- | --- | +| **gcp.firestore.api.request_count**
(count) | Recuento de llamadas a la API de Firestore.| +| **gcp.firestore.api.request_latencies.avg**
(count) | Latencia media de las solicitudes de Firestore v1, Datastore v1 y Datastore v3 desde el frontend.
_Se muestra en segundos_ | +| **gcp.firestore.api.request_latencies.samplecount**
(count) | Recuento de muestras de las latencias de las solicitudes de Firestore v1, Datastore v1 y Datastore v3 de no-transmisión desde el frontend.
_Se muestra en segundos_ | +| **gcp.firestore.api.request_latencies.sumsqdev**
(count) | Suma de la desviación al cuadrado de las latencias de las solicitudes de Firestore v1, Datastore v1 y Datastore v3 de no-transmisión desde el frontend.
_Se muestra en segundos_ | +| **gcp.firestore.composite_indexes_per_database**
(gauge) | Número actual de índices compuestos por base de datos.| +| **gcp.firestore.document.delete_count**
(count) | Número de documentos eliminados con éxito.| +| **gcp.firestore.document.delete_ops_count**
(count) | Número de documentos eliminados con éxito.| +| **gcp.firestore.document.read_count**
(count) | Número de lecturas de documentos correctas a partir de consultas o búsquedas.| +| **gcp.firestore.document.read_ops_count**
(count) | Número de lecturas de documentos correctas a partir de consultas o búsquedas.| +| **gcp.firestore.document.ttl_deletion_count**
(count) | Recuento total de documentos eliminados por servicios TTL.| +| **gcp.firestore.document.ttl_expiration_to_deletion_delays.avg**
(count) | Tiempo medio transcurrido entre la expiración de un documento con TTL y su eliminación efectiva.
_Se muestra en segundos_ | +| **gcp.firestore.document.ttl_expiration_to_deletion_delays.samplecount**
(count) | Recuento de muestras del tiempo transcurrido entre la expiración de un documento con TTL y su eliminación efectiva.
_Se muestra en segundos_ | +| **gcp.firestore.document.ttl_expiration_to_deletion_delays.sumsqdev**
(count) | Suma de la desviación al cuadrado del tiempo transcurrido entre la expiración de un documento con TTL y su eliminación efectiva.
_Se muestra en segundos_ | +| **gcp.firestore.document.write_count**
(count) | Número de escrituras de documentos realizadas con éxito.| +| **gcp.firestore.document.write_ops_count**
(count) | Número de escrituras de documentos realizadas con éxito.| +| **gcp.firestore.field_configurations_per_database**
(gauge) | Número actual de configuraciones de campo por base de datos.| +| **gcp.firestore.network.active_connections**
(gauge) | Número de conexiones activas. Cada cliente móvil tendrá una conexión. Cada escuchador en un SDK de administración tendrá una conexión.| +| **gcp.firestore.network.snapshot_listeners**
(gauge) | Número de escuchadores de snapshots registrados actualmente en todos los clientes conectados.| +| **gcp.firestore.query_stat.per_query.result_counts.avg**
(count) | Distribución media del número de resultados obtenidos por consulta. Se excluyen las consultas en tiempo real. Nota: Esta métrica sirve para observar el rendimiento. No es relevante para los cálculos de facturación. Para entender cómo contribuyen las operaciones de lectura a tu factura, utiliza `firestore.googleapis.com/document/read_ops_count`.| +| **gcp.firestore.query_stat.per_query.result_counts.samplecount**
(count) | Recuento de muestras de la distribución del número de resultados obtenidos por consulta. Se excluyen las consultas en tiempo real. Nota: Esta métrica sirve para observar el rendimiento. No es relevante para los cálculos de facturación. Para entender cómo contribuyen las operaciones de lectura a tu factura, utiliza `firestore.googleapis.com/document/read_ops_count`.| +| **gcp.firestore.query_stat.per_query.result_counts.sumsqdev**
(count) | Suma de la desviación al cuadrado de la distribución del número de resultados obtenidos por consulta. Se excluyen las consultas en tiempo real. Nota: Esta métrica sirve para observar el rendimiento. No es relevante para los cálculos de facturación. Para entender cómo contribuyen las operaciones de lectura a tu factura, utiliza `firestore.googleapis.com/document/read_ops_count`.| +| **gcp.firestore.query_stat.per_query.scanned_documents_counts.avg**
(count) | Distribución media del número de documentos analizados por consulta. Se excluyen las consultas en tiempo real. Nota: Esta métrica sirve para observar el rendimiento. No es relevante para los cálculos de facturación. Para entender cómo contribuyen las operaciones de lectura a tu factura, utiliza `firestore.googleapis.com/document/read_ops_count`.| +| **gcp.firestore.query_stat.per_query.scanned_documents_counts.samplecount**
(count) | Recuento de muestras de la distribución del número de documentos analizados por consulta. Se excluyen las consultas en tiempo real. Nota: Esta métrica sirve para observar el rendimiento. No es relevante para los cálculos de facturación. Para entender cómo contribuyen las operaciones de lectura a tu factura, utiliza `firestore.googleapis.com/document/read_ops_count`.| +| **gcp.firestore.query_stat.per_query.scanned_documents_counts.sumsqdev**
(count) | Suma de la desviación al cuadrado de la distribución del número de documentos analizados por consulta. Se excluyen las consultas en tiempo real. Nota: Esta métrica sirve para observar el rendimiento. No es relevante para los cálculos de facturación. Para entender cómo contribuyen las operaciones de lectura a tu factura, utiliza `firestore.googleapis.com/document/read_ops_count`.| +| **gcp.firestore.query_stat.per_query.scanned_index_entries_counts.avg**
(count) | Distribución media del número de entradas de índice analizadas por consulta. Se excluyen las consultas en tiempo real. Nota: Esta métrica sirve para observar el rendimiento. No es relevante para los cálculos de facturación. Para entender cómo contribuyen las operaciones de lectura a tu factura, utiliza `firestore.googleapis.com/document/read_ops_count`.| +| **gcp.firestore.query_stat.per_query.scanned_index_entries_counts.samplecount**
(count) | Recuento de muestras de la distribución del número de entradas de índice analizadas por consulta. Se excluyen las consultas en tiempo real. Nota: Esta métrica sirve para observar el rendimiento. No es relevante para los cálculos de facturación. Para entender cómo contribuyen las operaciones de lectura a tu factura, utiliza `firestore.googleapis.com/document/read_ops_count`.| +| **gcp.firestore.query_stat.per_query.scanned_index_entries_counts.sumsqdev**
(count) | Suma de la desviación al cuadrado de la distribución del número de entradas de índice analizadas por consulta. Se excluyen las consultas en tiempo real. Nota: Esta métrica sirve para observar el rendimiento. No es relevante para los cálculos de facturación. Para entender cómo contribuyen las operaciones de lectura a tu factura, utiliza `firestore.googleapis.com/document/read_ops_count`.| +| **gcp.firestore.quota.composite_indexes_per_database.exceeded**
(count) | Número de intentos de superar el límite de la métrica de cuota `firestore.googleapis.com/composite_indexes_per_database`.| +| **gcp.firestore.quota.composite_indexes_per_database.limit**
(gauge) | Límite actual de la métrica de cuota `firestore.googleapis.com/composite_indexes_per_database`.| +| **gcp.firestore.quota.composite_indexes_per_database.usage**
(gauge) | Uso actual de la métrica de cuota `firestore.googleapis.com/composite_indexes_per_database`.| +| **gcp.firestore.rules.evaluation_count**
(count) | Número de evaluaciones de reglas de seguridad de Cloud Firestore realizadas en respuesta a solicitudes de escritura (crear, actualizar, eliminar) o lectura (obtener, enumerar).| + +### Eventos + +La integración Google Cloud Firestore no incluye eventos. + +### Checks de servicio + +La integración Google Cloud Firestore no incluye checks de servicio. + +## Solucionar problemas + +¿Necesitas ayuda? Ponte en contacto con el [servicio de asistencia de Datadog](https://docs.datadoghq.com/help/). \ No newline at end of file diff --git a/content/es/integrations/google-cloud-functions.md b/content/es/integrations/google-cloud-functions.md new file mode 100644 index 00000000000..380e1c3ee00 --- /dev/null +++ b/content/es/integrations/google-cloud-functions.md @@ -0,0 +1,75 @@ +--- +aliases: +- /es/integrations/google_cloud_functions +app_id: google-cloud-functions +categories: +- nube +- google cloud +- recopilación de logs +custom_kind: integración +description: Una solución de computación asíncrona basada en eventos que permite la + creación de pequeñas funciones de propósito único. +media: [] +title: Google Cloud Functions +--- +## Información general + +Google Cloud Functions es una solución informática asíncrona, ligera y basada en eventos que permite crear pequeñas funciones de un solo propósito. + +Obtén métricas de Google Functions para: + +- Visualizar el rendimiento de tus funciones. +- Correlacionar el rendimiento de tus funciones con tus aplicaciones. + +## Configuración + +### Recopilación de métricas + +#### Instalación + +Si aún no lo has hecho, configura primero la [integración de Google Cloud Platform](https://docs.datadoghq.com/integrations/google-cloud-platform/). No hay más pasos de instalación. + +### Recopilación de logs + +Los logs de Google Cloud Functions se recopilan con Google Cloud Logging y se envían a un trabajo de Dataflow a través de un tema Cloud Pub/Sub. Si aún no lo has hecho, [configura la generación de logs con la plantilla de Datadog Dataflow](https://docs.datadoghq.com/integrations/google-cloud-platform/#log-collection). + +Una vez hecho esto, exporta tus logs de Google Cloud Functions de Google Cloud Logging al tema Pub/Sub: + +1. Ve a la [página de Google Cloud Logging](https://console.cloud.google.com/logs/viewer) y filtra logs de Google Cloud Functions. +1. Haz clic en **Create sink** (Crear sumidero) y asigna al sumidero el nombre correspondiente. +1. Elige "Cloud Pub/Sub" como destino y selecciona el tema Pub/Sub creado para tal fin. **Nota**: El tema Pub/Sub puede encontrarse en un proyecto diferente. +1. Haz clic en **Create** (Crear) y espera a que aparezca el mensaje de confirmación. + +## Datos recopilados + +### Métricas + +| | | +| --- | --- | +| **gcp.cloudfunctions.function.active_instances**
(gauge) | Número de instancias de función activas.
_Se muestra como instancia_ | +| **gcp.cloudfunctions.function.execution_count**
(count) | Número de ejecuciones de funciones.
_Se muestra como ocurrencia_ | +| **gcp.cloudfunctions.function.execution_times.avg**
(gauge) | Media de los tiempos de ejecución de funciones.
_Se muestra en nanosegundos_ | +| **gcp.cloudfunctions.function.execution_times.p95**
(gauge) | Percentil 95 de los tiempos de ejecución de funciones.
_Se muestra en nanosegundos_ | +| **gcp.cloudfunctions.function.execution_times.p99**
(gauge) | Percentil 90 de los tiempos de ejecución de funciones.
_Se muestra en nanosegundos_ | +| **gcp.cloudfunctions.function.execution_times.samplecount**
(count) | Recuento de muestras de los tiempos de ejecución de funciones.
_Se muestra como ocurrencia_ | +| **gcp.cloudfunctions.function.execution_times.sumsqdev**
(gauge) | Suma de la desviación al cuadrado de los tiempos de ejecución de funciones.
_Se muestra en nanosegundos_ | +| **gcp.cloudfunctions.function.instance_count**
(gauge) | Número de instancias de función desglosadas por estado.
_Se muestra como instancia_ | +| **gcp.cloudfunctions.function.network_egress**
(gauge) | Tráfico de red saliente de una función.
_Se muestra en bytes_ | +| **gcp.cloudfunctions.function.user_memory_bytes.avg**
(gauge) | Uso medio de memoria de la función durante la ejecución.
_Se muestra en bytes_ | +| **gcp.cloudfunctions.function.user_memory_bytes.p95**
(gauge) | Percentil 95 del uso de memoria de la función durante la ejecución.
_Se muestra en bytes_ | +| **gcp.cloudfunctions.function.user_memory_bytes.p99**
(gauge) | Percentil 99 del uso de memoria de la función durante la ejecución.
_Se muestra en bytes_ | +| **gcp.cloudfunctions.function.user_memory_bytes.samplecount**
(count) | Recuento de muestras del uso de memoria de la función.
_Se muestra como ocurrencia_ | +| **gcp.cloudfunctions.function.user_memory_bytes.sumsqdev**
(gauge) | Suma de la desviación al cuadrado del uso de memoria de la función.
_Se muestra en bytes_ | +| **gcp.cloudfunctions.pending_queue.pending_requests**
(gauge) | Número de solicitudes pendientes.| + +### Eventos + +La integración Google Cloud Functions no incluye eventos. + +### Checks de servicio + +La integración Google Cloud Functions no incluye checks de servicio. + +## 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/google-cloud-interconnect.md b/content/es/integrations/google-cloud-interconnect.md new file mode 100644 index 00000000000..fb1845c5e35 --- /dev/null +++ b/content/es/integrations/google-cloud-interconnect.md @@ -0,0 +1,90 @@ +--- +aliases: +- /es/integrations/google_cloud_interconnect +app_id: google-cloud-interconnect +categories: +- nube +- google cloud +- recopilación de logs +- red +custom_kind: integración +description: Extiende tu red on-premises a la red de Google a través de una conexión + de alta disponibilidad y baja latencia. +media: [] +title: Google Cloud Interconnect +--- +## Información general + +Google Cloud Interconnect amplía tu red on-premises a red de Google a través de una conexión de alta disponibilidad y baja latencia. + +Utiliza la integración Google Cloud Platform en Datadog para recopilar métricas de Google Cloud Interconnect. + +## Configuración + +### Instalación + +Si aún no lo has hecho, configura primero la [integración de Google Cloud Platform](https://docs.datadoghq.com/integrations/google-cloud-platform/). No hay más pasos de instalación. + +### Recopilación de logs + +Los logs de Google Cloud Interconnect se recopilan con Google Cloud Logging y se envían a un trabajo de Dataflow a través de un tema Cloud Pub/Sub. Si aún no lo has hecho, [configura la generación de logs con la plantilla de Datadog Dataflow](https://docs.datadoghq.com/integrations/google-cloud-platform/#log-collection). + +Una vez hecho esto, exporta tus logs de Google Cloud Interconnect de Google Cloud Logging al tema Pub/Sub: + +1. Ve a la [página de Google Cloud Logging](https://console.cloud.google.com/logs/viewer) y filtra los logs de Google Cloud Interconnect. +1. Haz clic en **Create Export** (Crear exportación) y asigna un nombre al sumidero. +1. Elige "Cloud Pub/Sub" como destino y selecciona el tema Pub/Sub creado para tal fin. **Nota**: El tema Pub/Sub puede encontrarse en un proyecto diferente. +1. Haz clic en **Create** (Crear) y espera a que aparezca el mensaje de confirmación. + +## Datos recopilados + +### Métricas + +| | | +| --- | --- | +| **gcp.interconnect.network.attachment.capacity**
(gauge) | Capacidad de red del anexo.| +| **gcp.interconnect.network.attachment.egress_dropped_packets_count**
(count) | Número de paquetes salientes descartados desde el último muestreo.
_Se muestra como paquete_ | +| **gcp.interconnect.network.attachment.ingress_dropped_packets_count**
(count) | Número de paquetes entrantes descartados desde el último muestreo.
_Se muestra como paquete_ | +| **gcp.interconnect.network.attachment.received_bytes_count**
(count) | Número de bytes entrantes recibidos.
_Se muestra en bytes_ | +| **gcp.interconnect.network.attachment.received_bytes_count_by_l3_protocol**
(count) | Número de bytes entrantes recibidos por el protocolo L3.
_Se muestra en bytes_ | +| **gcp.interconnect.network.attachment.received_packets_count**
(count) | Número de paquetes entrantes recibidos.
_Se muestra como paquete_ | +| **gcp.interconnect.network.attachment.received_packets_count_by_l3_protocol**
(count) | Número de paquetes entrantes recibidos por el protocolo L3.
_Se muestra como paquete_ | +| **gcp.interconnect.network.attachment.sent_bytes_count**
(count) | Número de bytes salientes enviados.
_Se muestra en bytes_ | +| **gcp.interconnect.network.attachment.sent_bytes_count_by_l3_protocol**
(count) | Número de bytes salientes enviados por el protocolo L3.
_Se muestra en bytes_ | +| **gcp.interconnect.network.attachment.sent_packets_count**
(count) | Número de paquetes salientes enviados.
_Se muestra como paquete_ | +| **gcp.interconnect.network.attachment.sent_packets_count_by_l3_protocol**
(count) | Número de paquetes salientes enviados por el protocolo L3.
_Se muestra como paquete_ | +| **gcp.interconnect.network.interconnect.capacity**
(gauge) | Capacidad activa de la interconexión.
_Se muestra en bytes_ | +| **gcp.interconnect.network.interconnect.dropped_packets_count**
(count) | Número de paquetes salientes descartados debido a la congestión del enlace.
_Se muestra como paquete_ | +| **gcp.interconnect.network.interconnect.link.aai.bytes_count**
(count) | Número de bytes en la interconexión que tienen activado el reconocimiento de aplicaciones.
_Se muestra en bytes_ | +| **gcp.interconnect.network.interconnect.link.aai.packets_count**
(count) | Número de paquetes en la interconexión que tiene activado el reconocimiento de aplicaciones.
_Se muestra como paquete_ | +| **gcp.interconnect.network.interconnect.link.macsec.operational**
(gauge) | Estado operativo de MACsec (si está activado) en el enlace físico.| +| **gcp.interconnect.network.interconnect.link.macsec.receive_dropped_packets_count**
(count) | Número de paquetes de entrada MACsec descartados en el enlace físico.
_Se muestra como paquete_ | +| **gcp.interconnect.network.interconnect.link.macsec.receive_errors_count**
(count) | Número de errores de entrada MACSEC en el enlace físico.
_Se muestra como error_ | +| **gcp.interconnect.network.interconnect.link.macsec.received_control_packets_count**
(count) | Número de paquetes de control de entrada MACsec en el enlace físico.
_Se muestra como paquete_ | +| **gcp.interconnect.network.interconnect.link.macsec.received_data_packets_count**
(count) | Número de paquetes de datos de entrada MACsec en el enlace físico.
_Se muestra como paquete_ | +| **gcp.interconnect.network.interconnect.link.macsec.send_dropped_packets_count**
(count) | Número de paquetes de salida MACsec descartados en el enlace físico.
_Se muestra como paquete_ | +| **gcp.interconnect.network.interconnect.link.macsec.send_errors_count**
(count) | Número de errores de salida MACsec en el enlace físico.
_Se muestra como error_ | +| **gcp.interconnect.network.interconnect.link.macsec.sent_control_packets_count**
(count) | Número de paquetes de control de salida MACsec en el enlace físico.
_Se muestra como paquete_ | +| **gcp.interconnect.network.interconnect.link.macsec.sent_data_packets_count**
(count) | Número de paquetes de datos de salida MACsec en el enlace físico.
_Se muestra como paquete_ | +| **gcp.interconnect.network.interconnect.link.operational**
(gauge) | Si el estado operativo del circuito es up.| +| **gcp.interconnect.network.interconnect.link.rx_power**
(gauge) | Nivel de luz recibido a través del circuito físico.| +| **gcp.interconnect.network.interconnect.link.tx_power**
(gauge) | Nivel de luz transmitido por el circuito físico.| +| **gcp.interconnect.network.interconnect.operational**
(gauge) | Si el estado operativo de la interconexión es up.| +| **gcp.interconnect.network.interconnect.receive_errors_count**
(count) | Número de errores encontrados al recibir paquetes.
_Se muestra como error_ | +| **gcp.interconnect.network.interconnect.received_bytes_count**
(count) | Número de bytes entrantes recibidos.
_Se muestra en bytes_ | +| **gcp.interconnect.network.interconnect.received_unicast_packets_count**
(count) | Número de paquetes unicast entrantes recibidos.
_Se muestra como paquete_ | +| **gcp.interconnect.network.interconnect.send_errors_count**
(count) | Número de errores encontrados durante el envío de paquetes.
_Se muestra como error_ | +| **gcp.interconnect.network.interconnect.sent_bytes_count**
(count) | Número de bytes salientes enviados.
_Se muestra en bytes_ | +| **gcp.interconnect.network.interconnect.sent_unicast_packets_count**
(count) | Número de paquetes unicast salientes enviados.
_Se muestra como paquete_ | + +### Eventos + +La integración Google Cloud Interconnect no incluye eventos. + +### Checks de servicio + +La integración Google Cloud Interconnect no incluye checks de servicio. + +## Solucionar problemas + +¿Necesitas ayuda? Ponte en contacto con el [servicio de asistencia de Datadog](https://docs.datadoghq.com/help/). \ No newline at end of file diff --git a/content/es/integrations/google-cloud-iot.md b/content/es/integrations/google-cloud-iot.md new file mode 100644 index 00000000000..f589862bb60 --- /dev/null +++ b/content/es/integrations/google-cloud-iot.md @@ -0,0 +1,62 @@ +--- +aliases: +- /es/integrations/google_cloud_iot +app_id: google-cloud-iot +categories: +- nube +- google cloud +- iot +- recopilación de logs +custom_kind: integración +description: Conecta, gestiona e ingiere datos de forma fácil y segura de millones + de dispositivos dispersos por todo el mundo. +media: [] +title: Google Cloud IoT +--- +## Información general + +Cloud IoT es un servicio totalmente gestionado que permite conectar, gestionar e ingerir datos de forma fácil y segura desde millones de dispositivos dispersos por todo el mundo. + +Utiliza la integración de Google Cloud Platform con Datadog para recopilar métricas de Google Cloud IoT. + +## Configuración + +### Instalación + +Si aún no lo has hecho, configura primero la [integración de Google Cloud Platform](https://docs.datadoghq.com/integrations/google-cloud-platform/). No hay más pasos de instalación. + +### Recopilación de logs + +Los logs de Google Cloud IoT se recopilan con Google Cloud Logging y se envían a un trabajo de Dataflow a través de un tema Cloud Pub/Sub. Si aún no lo has hecho, [configura la generación de logs con la plantilla de Datadog Dataflow](https://docs.datadoghq.com/integrations/google-cloud-platform/#log-collection). + +Una vez hecho esto, exporta tus logs de Google Cloud IoT de Google Cloud Logging al tema Pub/Sub: + +1. Ve a la [página de Google Cloud Logging](https://console.cloud.google.com/logs/viewer) y filtra logs de Google Cloud IoT. +1. Haz clic en **Create Export** (Crear exportación) y asigna un nombre al sumidero. +1. Elige "Cloud Pub/Sub" como destino y selecciona el tema Pub/Sub creado para tal fin. **Nota**: El tema Pub/Sub puede encontrarse en un proyecto diferente. +1. Haz clic en **Create** (Crear) y espera a que aparezca el mensaje de confirmación. + +## Datos recopilados + +### Métricas + +| | | +| --- | --- | +| **gcp.cloudiot.device.active_devices**
(gauge) | Recuento del número de dispositivos que han enviado datos recientemente a Cloud IoT Core.
_Se muestra como dispositivo_ | +| **gcp.cloudiot.device.billing_bytes_count**
(gauge) | Recuento del número de bytes facturables transferidos por dispositivos.
_Se muestra en bytes_ | +| **gcp.cloudiot.device.error_count**
(count) | Recuento delta de errores de comunicación con dispositivos, agrupados por tipo de error.
_Se muestra como error_ | +| **gcp.cloudiot.device.operation_count**
(count) | Recuento delta de operaciones realizadas agrupadas por tipo de operación.
_Se muestra como operación_ | +| **gcp.cloudiot.device.received_bytes_count**
(count) | Recuento delta del número de bytes recibidos de dispositivos.
_Se muestra en bytes_ | +| **gcp.cloudiot.device.sent_bytes_count**
(count) | Recuento delta del número de bytes enviados por dispositivos.
_Se muestra en bytes_ | + +### Eventos + +La integración Google Cloud IoT no incluye eventos. + +### Checks de servicio + +La integración Google Cloud IoT no incluye checks de servicio. + +## Solucionar problemas + +¿Necesitas ayuda? Ponte en contacto con el [servicio de asistencia de Datadog](https://docs.datadoghq.com/help/). \ No newline at end of file diff --git a/content/es/integrations/google-cloud-loadbalancing.md b/content/es/integrations/google-cloud-loadbalancing.md new file mode 100644 index 00000000000..4b8914ba5a7 --- /dev/null +++ b/content/es/integrations/google-cloud-loadbalancing.md @@ -0,0 +1,140 @@ +--- +aliases: +- /es/integrations/google_cloud_loadbalancing +app_id: google-cloud-loadbalancing +categories: +- nube +- configuración y despliegue +- google cloud +- recopilación de logs +custom_kind: integración +description: Distribuye los recursos de computación en una o varias regiones para + una alta disponibilidad, y un escalado y un autoescalado eficientes. +media: [] +title: Balanceo de carga de Google Cloud +--- +## Información general + +Google Cloud Load Balancing te ofrece la posibilidad de distribuir recursos informáticos con balanceo de carga en una o varias regiones, para satisfacer tus requisitos de alta disponibilidad, colocar tus recursos detrás de una única IP anycast y escalar aumentando o reduciendo tus recursos con el Autoscaling inteligente. + +Utiliza la integración Google Cloud Platform en Datadog para recopilar métricas de Google Cloud Load Balancing. + +## Configuración + +### Recopilación de métricas + +#### Instalación + +Si aún no lo has hecho, configura primero la [integración de Google Cloud Platform](https://docs.datadoghq.com/integrations/google-cloud-platform/). No hay más pasos de instalación. + +### Recopilación de logs + +Los logs del balanceador de carga HTTP de Google Cloud se recopilan con Google Cloud Logging y se envían a un trabajo de Dataflow a través de un tema de Cloud Pub/Sub. Si aún no lo has hecho, [configura la generación de logs con la plantilla de Datadog Dataflow](https://docs.datadoghq.com/integrations/google-cloud-platform/#log-collection). + +Una vez hecho esto, exporta tus logs del Balanceador de carga HTTP de Google Cloud HTTP de Google Cloud Logging al tema Pub/Sub: + +1. Ve a la [página de Google Cloud Logging](https://console.cloud.google.com/logs/viewer) y filtra los logs del balanceador de carga HTTP de Google Cloud. +1. Haz clic en **Create sink** (Crear sumidero) y asigna al sumidero el nombre correspondiente. +1. Elige "Cloud Pub/Sub" como destino y selecciona el tema Pub/Sub creado para tal fin. **Nota**: El tema Pub/Sub puede encontrarse en un proyecto diferente. +1. Haz clic en **Create** (Crear) y espera a que aparezca el mensaje de confirmación. + +## Datos recopilados + +### Métricas + +| | | +| --- | --- | +| **gcp.loadbalancing.https.backend_latencies.avg**
(gauge) | Latencia media de la solicitud enviada por el proxy al backend hasta que el proxy recibe el último byte de respuesta del backend.
_Se muestra en milisegundos_ | +| **gcp.loadbalancing.https.backend_latencies.p95**
(gauge) | Percentil 95 de latencia de la solicitud enviada por el proxy al backend hasta que el proxy recibe el último byte de respuesta del backend.
_Se muestra en milisegundos_ | +| **gcp.loadbalancing.https.backend_latencies.p99**
(gauge) | Percentil 99 de latencia de la solicitud enviada por el proxy al backend hasta que el proxy recibe el último byte de respuesta del backend.
_Se muestra en milisegundos_ | +| **gcp.loadbalancing.https.backend_latencies.samplecount**
(count) | Recuento de muestras de la latencia de la solicitud enviada por el proxy al backend hasta que el proxy recibe el último byte de respuesta del backend.
_Se muestra como muestra_ | +| **gcp.loadbalancing.https.backend_latencies.sumsqdev**
(gauge) | Suma de la desviación al cuadrado de la latencia de la solicitud enviada por el proxy al backend hasta que el proxy recibe el último byte de respuesta del backend.
_Se muestra en milisegundos_ | +| **gcp.loadbalancing.https.backend_request_bytes_count**
(count) | Número de bytes enviados como solicitudes desde el balanceador de carga HTTP(S) externo a los backends.
_Se muestra en bytes_ | +| **gcp.loadbalancing.https.backend_request_count**
(count) | Número de solicitudes atendidas por los backends del balanceador de carga HTTP(S).
_Se muestra como solicitud_ | +| **gcp.loadbalancing.https.backend_response_bytes_count**
(count) | Número de bytes enviados como respuestas desde los backends (o caché) al balanceador de carga HTTP(S).
_Se muestra en bytes_ | +| **gcp.loadbalancing.https.external.regional.backend_latencies.avg**
(count) | Media de una distribución de la latencia calculada desde que la solicitud fue enviada por el proxy al backend hasta que el proxy recibió el último byte de respuesta del backend. Para las extensiones de servicio, este valor representa la suma de las latencias de cada par `ProcessingRequest` y `ProcessingResponse` entre el balanceador de carga y el backend de la extensión.
_Se muestra en milisegundos_ | +| **gcp.loadbalancing.https.external.regional.backend_latencies.samplecount**
(count) | Recuento de muestras de una distribución de la latencia calculada desde que la solicitud fue enviada por el proxy al backend hasta que el proxy recibió el último byte de respuesta del backend. Para las extensiones de servicio, este valor representa la suma de las latencias de cada par `ProcessingRequest` y `ProcessingResponse` entre el balanceador de carga y el backend de la extensión.
_Se muestra en milisegundos_ | +| **gcp.loadbalancing.https.external.regional.backend_latencies.sumsqdev**
(count) | Suma de la desviación al cuadrado de una distribución de la latencia calculada desde que la solicitud fue enviada por el proxy al backend hasta que el proxy recibió el último byte de respuesta del backend. Para extensiones de servicio, este valor representa la suma de latencias de cada par `ProcessingRequest` y `ProcessingResponse` entre el balanceador de carga y el backend de la extensión.
_Se muestra en milisegundos_ | +| **gcp.loadbalancing.https.external.regional.backend_request_bytes_count**
(count) | Número de bytes enviados como solicitudes desde el balanceador de carga HTTP(S) externo regional a los backends. Para las extensiones de servicio, este valor representa el número total de bytes enviados desde el balanceador de carga al backend de la extensión.
_Se muestra en bytes_ | +| **gcp.loadbalancing.https.external.regional.backend_request_count**
(count) | Número de solicitudes atendidas por los backends del balanceador de carga HTTP(S) externo regional. Para las extensiones de servicio, este valor representa el número total de flujos (streams) gRPC entre el balanceador de carga y el backend de la extensión.| +| **gcp.loadbalancing.https.external.regional.backend_response_bytes_count**
(count) | Número de bytes enviados como respuesta desde los backends al balanceador de carga HTTP(S) externo regional. Para las extensiones de servicio, este valor representa el número total de bytes recibidos por el balanceador de carga desde el backend de la extensión.
_Se muestra en bytes_ | +| **gcp.loadbalancing.https.external.regional.request_bytes_count**
(count) | Número de bytes enviados como solicitudes de los clientes al balanceador de carga HTTP(S).
_Se muestra en bytes_ | +| **gcp.loadbalancing.https.external.regional.request_count**
(count) | Número de solicitudes atendidas por el balanceador de carga HTTP(S).| +| **gcp.loadbalancing.https.external.regional.response_bytes_count**
(count) | Número de bytes enviados como respuestas desde el balanceador de carga HTTP(S) a los clientes.
_Se muestra en bytes_ | +| **gcp.loadbalancing.https.external.regional.total_latencies.avg**
(count) | Media de una distribución de la latencia calculada desde que el proxy recibió la solicitud hasta que el proxy obtuvo el ACK del cliente en el último byte de respuesta.
_Se muestra en milisegundos_ | +| **gcp.loadbalancing.https.external.regional.total_latencies.samplecount**
(count) | Recuento de muestras de una distribución de la latencia calculada desde que el proxy recibió la solicitud hasta que el proxy obtuvo el ACK del cliente en el último byte de respuesta.
_Se muestra en milisegundos_ | +| **gcp.loadbalancing.https.external.regional.total_latencies.sumsqdev**
(count) | Suma de la desviación al cuadrado de una distribución de la latencia calculada desde que el proxy recibió la solicitud hasta que el proxy obtuvo el ACK del cliente en el último byte de respuesta.
_Se muestra en milisegundos_ | +| **gcp.loadbalancing.https.frontend_tcp_rtt.avg**
(gauge) | Tiempo de ida y vuelta (RTT) medio de cada conexión entre el cliente y el proxy.
_Se muestra en milisegundos_ | +| **gcp.loadbalancing.https.frontend_tcp_rtt.p95**
(gauge) | Percentil 95 del RTT de cada conexión entre el cliente y el proxy.
_Se muestra en milisegundos_ | +| **gcp.loadbalancing.https.frontend_tcp_rtt.p99**
(gauge) | Percentil 99 del RTT de cada conexión entre el cliente y el proxy.
_Se muestra en milisegundos_ | +| **gcp.loadbalancing.https.frontend_tcp_rtt.samplecount**
(count) | Recuento de muestras del RTT de cada conexión entre el cliente y el proxy.
_Se muestra como muestra_ | +| **gcp.loadbalancing.https.frontend_tcp_rtt.sumsqdev**
(gauge) | Suma de la desviación al cuadrado del RTT de cada conexión entre el cliente y el proxy.
_Se muestra en milisegundos_ | +| **gcp.loadbalancing.https.internal.backend_latencies.avg**
(gauge) | Media de la latencia calculada de la solicitud enviada por el proxy al backend hasta que el proxy recibió el último byte de respuesta del backend.
_Se muestra en milisegundos_ | +| **gcp.loadbalancing.https.internal.backend_latencies.p95**
(gauge) | Percentil 95 de la latencia calculada de la solicitud enviada por el proxy al backend hasta que el proxy recibió el último byte de respuesta del backend.
_Se muestra en milisegundos_ | +| **gcp.loadbalancing.https.internal.backend_latencies.p99**
(gauge) | Percentil 99 de la latencia calculada de la solicitud enviada por el proxy al backend hasta que el proxy recibió el último byte de respuesta del backend.
_Se muestra en milisegundos_ | +| **gcp.loadbalancing.https.internal.backend_latencies.samplecount**
(count) | Recuento de muestras de la latencia calculada de la solicitud enviada por el proxy al backend hasta que el proxy recibió el último byte de respuesta del backend.
_Se muestra como muestra_ | +| **gcp.loadbalancing.https.internal.backend_latencies.sumsqdev**
(gauge) | Suma de la desviación al cuadrado de la latencia calculada de la solicitud enviada por el proxy al backend hasta que el proxy recibió el último byte de respuesta del backend.
_Se muestra en milisegundos_ | +| **gcp.loadbalancing.https.internal.backend_request_bytes_count**
(count) | Número de bytes enviados como solicitudes desde el balanceador de carga HTTP(S) interno a los backends. Para las extensiones de servicio, este valor representa el número total de bytes enviados desde el balanceador de carga al backend de la extensión.
_Se muestra en bytes_ | +| **gcp.loadbalancing.https.internal.backend_request_count**
(count) | Número de solicitudes atendidas por los backends del balanceador de carga HTTP(S) interno. Para las extensiones de servicio, este valor representa el número total de flujos gRPC entre el balanceador de carga y el backend de la extensión.| +| **gcp.loadbalancing.https.internal.backend_response_bytes_count**
(count) | Número de bytes enviados como respuesta desde los backends al balanceador de carga HTTP(S) interno. Para las extensiones de servicio, este valor representa el número total de bytes recibidos por el balanceador de carga desde el backend de la extensión.
_Se muestra en bytes_ | +| **gcp.loadbalancing.https.internal.request_bytes_count**
(count) | Número de bytes enviados como solicitudes de los clientes al balanceador de carga HTTP(S).
_Se muestra en bytes_ | +| **gcp.loadbalancing.https.internal.request_count**
(count) | Número de solicitudes atendidas por los backends del balanceador de carga HTTP(S).
_Se muestra como solicitud_ | +| **gcp.loadbalancing.https.internal.response_bytes_count**
(count) | Número de bytes enviados como respuestas desde el balanceador de carga HTTP(S) a los clientes.
_Se muestra en bytes_ | +| **gcp.loadbalancing.https.internal.total_latencies.avg**
(gauge) | Media de la latencia calculada desde que el proxy recibió la solicitud hasta que el proxy ve el ACK del cliente en el último byte de respuesta.
_Se muestra en milisegundos_ | +| **gcp.loadbalancing.https.internal.total_latencies.p95**
(gauge) | Percentil 95 de la latencia calculada desde que el proxy recibió la solicitud hasta que el proxy ve el ACK del cliente en el último byte de respuesta.
_Se muestra en milisegundos_ | +| **gcp.loadbalancing.https.internal.total_latencies.p99**
(gauge) | Percentil 99 de la latencia calculada desde que el proxy recibió la solicitud hasta que el proxy ve el ACK del cliente en el último byte de respuesta.
_Se muestra en milisegundos_ | +| **gcp.loadbalancing.https.internal.total_latencies.samplecount**
(count) | Recuento de muestras de la latencia calculada desde que el proxy recibió la solicitud hasta que el proxy ve el ACK del cliente en el último byte de respuesta.
_Se muestra como muestra_ | +| **gcp.loadbalancing.https.internal.total_latencies.sumsqdev**
(gauge) | Suma de la desviación al cuadrado de la latencia calculada desde que el proxy recibió la solicitud hasta que el proxy ve el ACK del cliente en el último byte de respuesta.
_Se muestra en milisegundos_ | +| **gcp.loadbalancing.https.request_bytes_count**
(count) | Bytes enviados como solicitudes de clientes al balanceador de carga L7.
_Se muestra en bytes_ | +| **gcp.loadbalancing.https.request_count**
(count) | Número de solicitudes atendidas por el balanceador de carga L7.
_Se muestra como solicitud_ | +| **gcp.loadbalancing.https.response_bytes_count**
(count) | Bytes enviados como respuestas del balanceador de carga L7 a los clientes.
_Se muestra en bytes_ | +| **gcp.loadbalancing.https.total_latencies.avg**
(gauge) | Latencia media calculada desde que el proxy recibió la solicitud hasta que el proxy ve el ACK del cliente en el último byte de respuesta.
_Se muestra en milisegundos_ | +| **gcp.loadbalancing.https.total_latencies.p95**
(gauge) | Percentil 95 de la latencia calculada desde que el proxy recibió la solicitud hasta que el proxy ve el ACK del cliente en el último byte de respuesta.
_Se muestra en milisegundos_ | +| **gcp.loadbalancing.https.total_latencies.p99**
(gauge) | Percentil 99 de la latencia calculada desde que el proxy recibió la solicitud hasta que el proxy ve el ACK del cliente en el último byte de respuesta.
_Se muestra en milisegundos_ | +| **gcp.loadbalancing.https.total_latencies.samplecount**
(count) | Recuento de muestras de la latencia calculada desde que el proxy recibió la solicitud hasta que el proxy ve el ACK del cliente en el último byte de respuesta.
_Se muestra como muestra_ | +| **gcp.loadbalancing.https.total_latencies.sumsqdev**
(gauge) | Suma de la desviación al cuadrado de la latencia calculada desde que el proxy recibió la solicitud hasta que el proxy ve el ACK del cliente en el último byte de respuesta.
_Se muestra en milisegundos_ | +| **gcp.loadbalancing.l3.external.egress_bytes_count**
(count) | Número de bytes enviados desde el backend NetLB al cliente del flujo. Para los flujos TCP, solo cuenta los bytes en el flujo de la aplicación.
_Se muestra en bytes_ | +| **gcp.loadbalancing.l3.external.egress_packets_count**
(count) | Número de paquetes enviados desde el backend NetLB al cliente del flujo.
_Se muestra como paquete_ | +| **gcp.loadbalancing.l3.external.ingress_bytes_count**
(count) | Número de bytes enviados desde el cliente al backend NetLB. Para flujos TCP, solo cuenta los bytes en el flujo de la aplicación.
_Se muestra en bytes_ | +| **gcp.loadbalancing.l3.external.ingress_packets_count**
(count) | Número de paquetes enviados desde el cliente al backend NetLB.
_Se muestra como paquete_ | +| **gcp.loadbalancing.l3.external.rtt_latencies.avg**
(gauge) | RTT medio medido en conexiones TCP para flujos NetLB.
_Se muestra en milisegundos_ | +| **gcp.loadbalancing.l3.external.rtt_latencies.p95**
(gauge) | Percentil 95 del RTT medido en conexiones TCP para flujos NetLB.
_Se muestra en milisegundos_ | +| **gcp.loadbalancing.l3.external.rtt_latencies.p99**
(gauge) | Percentil 99 del RTT medido en conexiones TCP para flujos NetLB.
_Se muestra en milisegundos_ | +| **gcp.loadbalancing.l3.external.rtt_latencies.samplecount**
(count) | Recuento de muestras del RTT medido en conexiones TCP para flujos NetLB.
_Se muestra como muestra_ | +| **gcp.loadbalancing.l3.external.rtt_latencies.sumsqdev**
(gauge) | Suma de la desviación al cuadrado del RTT medido en conexiones TCP para flujos NetLB.
_Se muestra en milisegundos_ | +| **gcp.loadbalancing.l3.internal.egress_bytes_count**
(recuento) | Número de bytes enviados desde el backend ILB al cliente (para los flujos TCP solo cuenta los bytes en el flujo de la aplicación).
_Se muestra en bytes_ | +| **gcp.loadbalancing.l3.internal.egress_packets_count**
(count) | Número de paquetes enviados desde el backend ILB al cliente del flujo.
_Se muestra como paquete_ | +| **gcp.loadbalancing.l3.internal.ingress_bytes_count**
(count) | Número de bytes enviados desde el cliente al backend ILB (para los flujos TCP solo cuenta los bytes en el flujo de la aplicación).
_Se muestra en bytes_ | +| **gcp.loadbalancing.l3.internal.ingress_packets_count**
(count) | Número de paquetes enviados desde el cliente al backend ILB.
_Se muestra como paquete_ | +| **gcp.loadbalancing.l3.internal.rtt_latencies.avg**
(gauge) | RTT medio medido en conexiones TCP para flujos ILB.
_Se muestra en milisegundos_ | +| **gcp.loadbalancing.l3.internal.rtt_latencies.p95**
(gauge) | Percentil 95 del RTT medido en conexiones TCP para flujos ILB.
_Se muestra en milisegundos_ | +| **gcp.loadbalancing.l3.internal.rtt_latencies.p99**
(gauge) | Percentil 99 del RTT medido en conexiones TCP para flujos ILB.
_Se muestra en milisegundos_ | +| **gcp.loadbalancing.l3.internal.rtt_latencies.samplecount**
(count) | Recuento de muestras de las latencias de RTT.
_Se muestra como muestra_ | +| **gcp.loadbalancing.l3.internal.rtt_latencies.sumsqdev**
(gauge) | Suma de la desviación al cuadrado de las latencias de RTT.
_Se muestra en milisegundos_ | +| **gcp.loadbalancing.l4_proxy.egress_bytes_count**
(count) | Número de bytes enviados desde la máquina virtual al cliente utilizando el proxy.
_Se muestra en bytes_ | +| **gcp.loadbalancing.l4_proxy.ingress_bytes_count**
(count) | Número de bytes enviados desde el cliente a la máquina virtual utilizando el proxy.
_Se muestra en bytes_ | +| **gcp.loadbalancing.l4_proxy.tcp.closed_connections_count**
(count) | Número de conexiones finalizadas a través del balanceador de carga proxy TCP o proxy SSL.| +| **gcp.loadbalancing.l4_proxy.tcp.new_connections_count**
(count) | Número de conexiones abiertas a través del balanceador de carga proxy TCP o proxy SSL.| +| **gcp.loadbalancing.subnet.proxy_only.addresses**
(gauge) | Número actual de direcciones de solo proxy por estado.| +| **gcp.loadbalancing.tcp_ssl_proxy.closed_connections**
(count) | Número de conexiones finalizadas a través del proxy TCP/SSL.
_Se muestra como conexión_ | +| **gcp.loadbalancing.tcp_ssl_proxy.egress_bytes_count**
(count) | Número de bytes enviados desde la máquina virtual al cliente utilizando el proxy.
_Se muestra en bytes_ | +| **gcp.loadbalancing.tcp_ssl_proxy.frontend_tcp_rtt.avg**
(gauge) | RTT medio suavizado medido por el stack tecnológico TCP del proxy. Cada minuto pasan bytes de la capa de aplicación del proxy al cliente.
_Se muestra en milisegundos_ | +| **gcp.loadbalancing.tcp_ssl_proxy.frontend_tcp_rtt.p95**
(gauge) | Percentil 95 del RTT suavizado medido por el stack tecnológico TCP del proxy. Cada minuto pasan bytes de la capa de aplicación del proxy al cliente.
_Se muestra en milisegundos_ | +| **gcp.loadbalancing.tcp_ssl_proxy.frontend_tcp_rtt.p99**
(gauge) | Percentil 99 del RTT suavizado medido por el stack tecnológico TCP del proxy. Cada minuto pasan bytes de la capa de aplicación del proxy al cliente.
_Se muestra en milisegundos_ | +| **gcp.loadbalancing.tcp_ssl_proxy.frontend_tcp_rtt.samplecount**
(count) | Recuento de muestras del RTT suavizado medido por el stack tecnológico TCP del proxy. Cada minuto pasan bytes de la capa de aplicación del proxy al cliente.
_Se muestra como muestra_ | +| **gcp.loadbalancing.tcp_ssl_proxy.frontend_tcp_rtt.sumsqdev**
(gauge) | Suma de la desviación al cuadrado del RTT suavizado medido por el stack tecnológico TCP del proxy. Cada minuto pasan bytes de la capa de aplicación del proxy al cliente.
_Se muestra en milisegundos_ | +| **gcp.loadbalancing.tcp_ssl_proxy.ingress_bytes_count**
(count) | Número de bytes enviados desde el cliente a la máquina virtual utilizando el proxy.
_Se muestra en bytes_ | +| **gcp.loadbalancing.tcp_ssl_proxy.new_connections**
(count) | Número de conexiones creadas a través del proxy TCP/SSL.
_Se muestra como conexión_ | +| **gcp.loadbalancing.tcp_ssl_proxy.open_connections**
(count) | Número actual de conexiones pendientes a través del proxy TCP/SSL.
_Se muestra como conexión_ | + +### Eventos + +La integración Google Cloud Load Balancing no incluye eventos. + +### Checks de servicio + +La integración Google Cloud Load Balancing no incluye checks de servicio. + +## Solucionar problemas + +¿Necesitas ayuda? Ponte en contacto con el [servicio de asistencia de Datadog](https://docs.datadoghq.com/help/). \ No newline at end of file diff --git a/content/es/integrations/google-cloud-redis.md b/content/es/integrations/google-cloud-redis.md new file mode 100644 index 00000000000..f0d0183dfe1 --- /dev/null +++ b/content/es/integrations/google-cloud-redis.md @@ -0,0 +1,186 @@ +--- +aliases: +- /es/integrations/google_cloud_redis +app_id: google-cloud-redis +categories: +- nube +- almacenes de datos +- google cloud +- recopilación de logs +custom_kind: integración +description: Un servicio de almacén de datos en memoria gestionado en infraestructura + escalable, seguro y de alta disponibilidad. +media: [] +title: Google Cloud Redis +--- +## Información general + +Google Cloud Memorystore para Redis proporciona un servicio de almacén de datos en memoria totalmente gestionado construido sobre una infraestructura escalable, segura y de alta disponibilidad. + +Utiliza la integración Google Cloud Platform en Datadog para recopilar métricas de Google Cloud Memorystore para Redis. + +## Configuración + +### Instalación + +Si aún no lo has hecho, configura primero la [integración de Google Cloud Platform](https://docs.datadoghq.com/integrations/google-cloud-platform/). No hay más pasos de instalación. + +### Recopilación de logs + +Los logs de Google Cloud Memorystore para Redis se recopilan con Google Cloud Logging y se envían a un job (generic) de Dataflow a través de un tema de Cloud Pub/Sub. Si aún no lo has hecho, [configura el registro con la plantilla Datadog Dataflow](https://docs.datadoghq.com/integrations/google-cloud-platform/#log-collection). + +Una vez hecho esto, exporta tus logs de Google Cloud Memorystore para Redis de Google Cloud Logging al tema Pub/Sub: + +1. Ve a la [page (página) Google Cloud Logging](https://console.cloud.google.com/logs/viewer) y filtra logs de Google Cloud Memorystore para Redis. +1. Haz clic en **Create Export** (Crear exportación) y asigna un nombre al sumidero. +1. Elige "Cloud Pub/Sub" como destino y selecciona el tema Pub/Sub creado para tal fin. **Nota**: El tema Pub/Sub puede encontrarse en un proyecto diferente. +1. Haz clic en **Create** (Crear) y espera a que aparezca el mensaje de confirmación. + +## Datos recopilados + +### Métricas + +| | | +| --- | --- | +| **gcp.redis.clients.blocked**
(gauge) | Número de clientes bloqueados.| +| **gcp.redis.clients.connected**
(gauge) | Número de connections (conexiones) de clientes.
_Mostrado como connection (conexión)_ | +| **gcp.redis.cluster.clients.average_connected_clients**
(gauge) | Número medio actual de connections (conexiones) de clientes en todo el clúster.| +| **gcp.redis.cluster.clients.maximum_connected_clients**
(gauge) | Número máximo actual de connections (conexiones) de clientes en el clúster.| +| **gcp.redis.cluster.clients.total_connected_clients**
(gauge) | Número actual de connections (conexiones) de clientes al clúster.| +| **gcp.redis.cluster.commandstats.total_calls_count**
(count) | Count de comandos de Redis.| +| **gcp.redis.cluster.commandstats.total_usec_count**
(count) | El tiempo total consumido por comando.
_Mostrado como microsegundo_ | +| **gcp.redis.cluster.cpu.average_utilization**
(gauge) | Utilización media de la CPU en todo el clúster de 0,0 a 1,0.| +| **gcp.redis.cluster.cpu.maximum_utilization**
(gauge) | Utilización máxima de la CPU en todo el clúster de 0,0 a 1,0.| +| **gcp.redis.cluster.cross_cluster_replication.secondary_average_replication_offset_diff**
(gauge) | Diferencia media de desplazamiento de replicación entre las particiones principales y las particiones secundarias.
_Mostrado como byte_ | +| **gcp.redis.cluster.cross_cluster_replication.secondary_maximum_replication_offset_diff**
(gauge) | Diferencia máxima de desplazamiento de replicación entre las particiones principales y las particiones secundarias.
_Mostrado como byte_ | +| **gcp.redis.cluster.cross_cluster_replication.secondary_replication_links**
(gauge) | Número de enlaces de replicación entre un clúster principal y un clúster secundario.| +| **gcp.redis.cluster.keyspace.total_keys**
(gauge) | Número de claves almacenadas en la instancia de clúster.| +| **gcp.redis.cluster.memory.average_utilization**
(gauge) | Utilización media de memoria en todo el clúster de 0,0 a 1,0.| +| **gcp.redis.cluster.memory.maximum_utilization**
(gauge) | Utilización máxima de memoria en todo el clúster de 0,0 a 1,0.| +| **gcp.redis.cluster.memory.size**
(gauge) | Tamaño de la memoria del clúster.
_Mostrado como byte_ | +| **gcp.redis.cluster.memory.total_used_memory**
(gauge) | Uso total de memoria del clúster.
_Mostrado como byte_ | +| **gcp.redis.cluster.node.clients.blocked_clients**
(gauge) | Número de connections (conexiones) de cliente bloqueadas por el nodo del clúster.| +| **gcp.redis.cluster.node.clients.connected_clients**
(gauge) | Número de clientes conectados al nodo del clúster.| +| **gcp.redis.cluster.node.commandstats.calls_count**
(count) | Número total de llamadas para este comando en el nodo del clúster en un minuto.| +| **gcp.redis.cluster.node.commandstats.usec_count**
(count) | El tiempo total consumido por comando en el nodo del clúster.
_Mostrado como microsegundo_ | +| **gcp.redis.cluster.node.cpu.utilization**
(gauge) | Utilización de la CPU para el nodo del clúster de 0,0 a 1,0.| +| **gcp.redis.cluster.node.cross_cluster_replication.follower_replication_offset_diff**
(gauge) | Diferencia de desplazamiento de replicación en bytes entre un nodo replicador y su nodo seguidor, notificada por el nodo replicador.
_Mostrado como byte_ | +| **gcp.redis.cluster.node.cross_cluster_replication.role**
(gauge) | Rol de replicación entre clústeres del nodo.| +| **gcp.redis.cluster.node.keyspace.total_keys**
(gauge) | Número de claves almacenadas en el nodo del clúster.| +| **gcp.redis.cluster.node.memory.usage**
(gauge) | Uso total de memoria del nodo de clúster.
_Mostrado como byte_ | +| **gcp.redis.cluster.node.memory.utilization**
(gauge) | Utilización de la memoria en el nodo del clúster de 0,0 a 1,0.| +| **gcp.redis.cluster.node.persistence.aof_fsync_errors_count**
(count) | Count de errores AOF fsync en el nodo del clúster.| +| **gcp.redis.cluster.node.persistence.aof_fsync_lag**
(gauge) | Desfase de AOF entre la memoria y el almacén persistente en el nodo del clúster.
_Mostrado como segundo_ | +| **gcp.redis.cluster.node.persistence.aof_last_bgrewrite_status**
(gauge) | Indica el éxito de la última operación AOF bgrewrite en el nodo del clúster.| +| **gcp.redis.cluster.node.persistence.aof_last_write_status**
(gauge) | Indica el éxito de la última operación de escritura AOF en el nodo del clúster.| +| **gcp.redis.cluster.node.persistence.aof_rewrites_count**
(count) | Count de reescrituras AOF en el nodo del clúster.| +| **gcp.redis.cluster.node.persistence.auto_restore_count**
(count) | Count de restauraciones desde el archivo de volcado en el nodo del clúster.| +| **gcp.redis.cluster.node.persistence.current_save_keys_total**
(gauge) | Número de claves al principio de la operación de guardado actual.| +| **gcp.redis.cluster.node.persistence.rdb_bgsave_in_progress**
(gauge) | Indica si hay un RDB BGSAVE en curso en el nodo del clúster.| +| **gcp.redis.cluster.node.persistence.rdb_last_bgsave_status**
(gauge) | Indica el éxito del último BGSAVE en el nodo del clúster.| +| **gcp.redis.cluster.node.persistence.rdb_last_save_age**
(gauge) | Mide el tiempo en segundos, desde la última instantánea realizada con éxito.
_Mostrado como segundo_ | +| **gcp.redis.cluster.node.persistence.rdb_next_save_time_until**
(gauge) | Mide el tiempo en segundos que queda hasta la siguiente instantánea.
_Mostrado como segundo_ | +| **gcp.redis.cluster.node.persistence.rdb_saves_count**
(count) | Count de RDB guardadas en el nodo del clúster.| +| **gcp.redis.cluster.node.replication.offset**
(gauge) | Mide los bytes de desplazamiento de replicación del nodo del clúster.
_Mostrado como byte_ | +| **gcp.redis.cluster.node.server.uptime**
(gauge) | Mide el tiempo de actividad del nodo del clúster.
_Mostrado como segundo_ | +| **gcp.redis.cluster.node.stats.connections_received_count**
(count) | Count del total de connections (conexiones) de clientes creadas en el último minuto en el nodo del clúster.| +| **gcp.redis.cluster.node.stats.evicted_keys_count**
(count) | Count de claves desalojadas por el nodo del clúster.| +| **gcp.redis.cluster.node.stats.expired_keys_count**
(count) | Count de eventos de expiración de claves en el nodo del clúster.| +| **gcp.redis.cluster.node.stats.keyspace_hits_count**
(count) | Count de búsquedas con éxito de claves en el nodo del clúster.| +| **gcp.redis.cluster.node.stats.keyspace_misses_count**
(count) | Count de búsquedas fallidas de claves en el nodo del clúster.| +| **gcp.redis.cluster.node.stats.net_input_bytes_count**
(count) | Count de bytes de red entrantes recibidos por el nodo de clúster.
_Mostrado como byte_ | +| **gcp.redis.cluster.node.stats.net_output_bytes_count**
(count) | Count de bytes de red salientes enviados desde el nodo del clúster.
_Mostrado como byte_ | +| **gcp.redis.cluster.node.stats.rejected_connections_count**
(count) | Número de connections (conexiones) rechazadas debido al límite máximo de clientes del nodo del clúster.| +| **gcp.redis.cluster.persistence.aof_fsync_lags.avg**
(gauge) | La distribución media del desfase AOF entre la memoria y el almacén persistente en todo el clúster.
_Mostrado como segundo_ | +| **gcp.redis.cluster.persistence.aof_fsync_lags.samplecount**
(gauge) | El count de ejemplos para la distribución del desfase AOF entre la memoria y el almacén persistente en todo el clúster.
_Mostrado como segundo_ | +| **gcp.redis.cluster.persistence.aof_fsync_lags.sumsqdev**
(gauge) | La suma de la desviación al cuadrado para la distribución del desfase AOF entre la memoria y el almacén persistente en todo el clúster.
_Mostrado como segundo_ | +| **gcp.redis.cluster.persistence.aof_rewrite_count**
(count) | Count de reescrituras AOF en todo el clúster.| +| **gcp.redis.cluster.persistence.rdb_last_success_ages.avg**
(gauge) | La antigüedad media de las instantáneas RDB en todo el cluster.
_Mostrado como segundo_ | +| **gcp.redis.cluster.persistence.rdb_last_success_ages.samplecount**
(gauge) | El count de ejemplo para la antigüedad de las instantáneas RDB en todo el clúster.
_Mostrado como segundo_ | +| **gcp.redis.cluster.persistence.rdb_last_success_ages.sumsqdev**
(gauge) | La suma de la desviación al cuadrado para la antigüedad de las instantáneas RDB en todo el cluster.
_Mostrado como segundo_ | +| **gcp.redis.cluster.persistence.rdb_saves_count**
(count) | Count de RDB guardadas en todo el clúster.| +| **gcp.redis.cluster.replication.average_ack_lag**
(gauge) | Demora media de acuse de recibo de replicación (en segundos) de la réplica en todo el clúster.
_Mostrado como segundo_ | +| **gcp.redis.cluster.replication.average_offset_diff**
(gauge) | Diferencia media de desplazamiento de replicación (en bytes) en todo el clúster.
_Mostrado como byte_ | +| **gcp.redis.cluster.replication.maximum_ack_lag**
(gauge) | Demora máxima de acuse de recibo de replicación (en segundos) de la réplica en todo el clúster.
_Mostrado como segundo_ | +| **gcp.redis.cluster.replication.maximum_offset_diff**
(gauge) | Diferencia máxima de desplazamiento de replicación (en bytes) en todo el clúster.
_Mostrado como byte_ | +| **gcp.redis.cluster.stats.average_evicted_keys**
(gauge) | Número medio de claves desalojadas debido a la capacidad de memoria.| +| **gcp.redis.cluster.stats.average_expired_keys**
(gauge) | Número medio de eventos de expiración de claves.| +| **gcp.redis.cluster.stats.average_keyspace_hits**
(gauge) | Número medio de búsquedas de claves realizadas con éxito en todo el clúster.| +| **gcp.redis.cluster.stats.average_keyspace_misses**
(gauge) | Número medio de búsquedas fallidas de claves en todo el clúster.| +| **gcp.redis.cluster.stats.maximum_evicted_keys**
(gauge) | Número máximo de claves desalojadas por capacidad de memoria.| +| **gcp.redis.cluster.stats.maximum_expired_keys**
(gauge) | Número máximo de eventos de expiración de claves.| +| **gcp.redis.cluster.stats.maximum_keyspace_hits**
(gauge) | Número máximo de búsquedas correctas de claves en todo el clúster.| +| **gcp.redis.cluster.stats.maximum_keyspace_misses**
(gauge) | Número máximo de búsquedas fallidas de claves en todo el clúster.| +| **gcp.redis.cluster.stats.total_connections_received_count**
(count) | Count de connections (conexiones) de clientes creadas en el último minuto.| +| **gcp.redis.cluster.stats.total_evicted_keys_count**
(count) | Número total de claves desalojadas debido a la capacidad de memoria.| +| **gcp.redis.cluster.stats.total_expired_keys_count**
(count) | Número total de eventos de expiración de claves.| +| **gcp.redis.cluster.stats.total_keyspace_hits_count**
(count) | Número total de búsquedas de claves realizadas con éxito en todo el clúster.| +| **gcp.redis.cluster.stats.total_keyspace_misses_count**
(count) | Número total de búsquedas fallidas de claves en todo el clúster.| +| **gcp.redis.cluster.stats.total_net_input_bytes_count**
(count) | Count de bytes de red entrantes recibidos por el clúster.
_Mostrado como byte_ | +| **gcp.redis.cluster.stats.total_net_output_bytes_count**
(count) | Count de bytes de red salientes enviados desde el clúster.
_Mostrado como byte_ | +| **gcp.redis.cluster.stats.total_rejected_connections_count**
(count) | Count de connections (conexiones) de clientes rechazadas debido al límite máximo de clientes.| +| **gcp.redis.commands.calls**
(count) | Número total de llamadas para este comando.| +| **gcp.redis.commands.total_time**
(gauge) | La cantidad de tiempo en microsegundos que tardó este comando en el último segundo.
_Mostrado como microsegundo_ | +| **gcp.redis.commands.usec_per_call**
(gauge) | Tiempo medio por llamada a lo largo de 1 minuto por comando.
_Mostrado como segundo_ | +| **gcp.redis.keyspace.avg_ttl**
(gauge) | TTL medio de las claves de esta base de datos.
_Mostrado como milisegundo_ | +| **gcp.redis.keyspace.keys**
(gauge) | Número de claves almacenadas en esta base de datos.
_Mostrado como clave_ | +| **gcp.redis.keyspace.keys_with_expiration**
(gauge) | Número de claves con caducidad en esta base de datos.
_Mostrado como clave_ | +| **gcp.redis.persistence.rdb.bgsave_in_progress**
(gauge) | Marca que indica que se está guardando un RDB.| +| **gcp.redis.rdb.enabled**
(gauge) | Indica si la instantánea está en modo RDB.| +| **gcp.redis.rdb.recovery.attempts_since_last_success**
(gauge) | Indica el número de intentos de recuperación desde el último intento de recuperación con éxito.| +| **gcp.redis.rdb.recovery.elapsed_time**
(gauge) | Indica el tiempo creciente transcurrido para una recuperación en curso a partir de una instantánea RDB. 0 significa que la recuperación está inactiva o completada.
_Mostrado como segundo_. | +| **gcp.redis.rdb.recovery.estimated_recovery_time**
(gauge) | Indica el tiempo de recuperación previsto cuando se utiliza la última instantánea correcta para la recuperación.
_Mostrado como segundo_ | +| **gcp.redis.rdb.recovery.estimated_remaining_time**
(gauge) | Indica el tiempo restante para finalizar la recuperación de una instantánea RDB. 0 significa que la recuperación está inactiva o completada.
_Mostrado como segundo_. | +| **gcp.redis.rdb.recovery.in_progress**
(gauge) | Indica si la recuperación de una instantánea RDB está en curso. Cuando el valor de la métrica es true, entonces hay una recuperación en curso.| +| **gcp.redis.rdb.recovery.last_duration**
(gauge) | Indica el tiempo que se tardó en restaurar la última instantánea.
_Mostrado como segundo_ | +| **gcp.redis.rdb.recovery.last_status**
(gauge) | Indica el estado de la recuperación más reciente.| +| **gcp.redis.rdb.recovery.loaded_bytes_count**
(count) | Durante una recuperación, indica cuántos bytes se han cargado. 0 si la recuperación no está activa.
_Mostrado como byte_. | +| **gcp.redis.rdb.recovery.total_bytes_count**
(count) | Indica el tamaño en bytes de la instantánea.
_Mostrado como byte_ | +| **gcp.redis.rdb.snapshot.attempt_count**
(count) | Indica el número de intentos de instantáneas cada minuto.| +| **gcp.redis.rdb.snapshot.elapsed_time**
(gauge) | Indica el aumento del tiempo transcurrido durante la creación de la instantánea actual.
_Mostrado como segundo_ | +| **gcp.redis.rdb.snapshot.in_progress**
(gauge) | Indica si la instantánea RDB está en curso. Cuando el valor de la métrica es true, entonces hay una instantánea RDB en curso.| +| **gcp.redis.rdb.snapshot.last_status**
(gauge) | Indica el estado del intento de instantánea más reciente.| +| **gcp.redis.rdb.snapshot.last_success_age**
(gauge) | Indica el tiempo transcurrido desde el inicio de la última instantánea correcta.
_Mostrado como segundo_ | +| **gcp.redis.rdb.snapshot.last_success_duration**
(gauge) | Indica el tiempo total necesario para escribir la última instantánea con éxito, sin incluir los intentos fallidos.
_Mostrado como segundo_ | +| **gcp.redis.rdb.snapshot.time_until_next_run**
(gauge) | Segundos hasta la siguiente instantánea programada.
_Mostrado como segundo_ | +| **gcp.redis.replication.master.slaves.lag**
(gauge) | El número de segundos que la réplica se atrasa con respecto a la principal.
_Mostrado como segundo_ | +| **gcp.redis.replication.master.slaves.offset**
(gauge) | El número de bytes reconocidos por las réplicas.
_Mostrado como byte_ | +| **gcp.redis.replication.master_repl_offset**
(gauge) | El número de bytes que el maestro ha producido y enviado a las réplicas. Debe compararse con el desplazamiento de bytes de replicación de la réplica.
_Mostrado como byte_. | +| **gcp.redis.replication.offset_diff**
(gauge) | El número de bytes que no se han replicados a la réplica. Es la diferencia entre el desplazamiento de bytes de replicación (maestro) y el desplazamiento de bytes de replicación (réplica).
_Mostrado como byte_. | +| **gcp.redis.replication.role**
(gauge) | Devuelve un valor que indica el rol del nodo. 1 indica maestro y 0 indica réplica.| +| **gcp.redis.search.attributes**
(gauge) | Indica el número de atributos en la búsqueda vectorial.| +| **gcp.redis.search.background_indexing_in_progress**
(gauge) | Indica si la indexación en segundo plano está en curso. Cuando el valor de la métrica es true, la indexación en segundo plano está en curso.| +| **gcp.redis.search.indexed_hash_keys**
(gauge) | Indica el número de claves hash indexadas en la búsqueda vectorial.| +| **gcp.redis.search.indexes**
(gauge) | Indica el número de índices en la búsqueda vectorial.| +| **gcp.redis.search.query_requests_count**
(count) | Indica el count de solicitudes de consulta contadas.| +| **gcp.redis.search.used_memory_bytes**
(gauge) | Indica la memoria utilizada en bytes en la búsqueda vectorial.
_Mostrado como byte_ | +| **gcp.redis.server.uptime**
(gauge) | Tiempo de actividad en segundos.
_Mostrado como segundo_ | +| **gcp.redis.stats.cache_hit_ratio**
(gauge) | Porcentaje de aciertos de caché como fracción.| +| **gcp.redis.stats.connections.total**
(gauge) | Número total de connections (conexiones) aceptadas por el servidor.
_Mostrado como connection (conexión)_ | +| **gcp.redis.stats.cpu_utilization**
(gauge) | CPU, en segundos de utilización, consumida por el servidor Redis desglosado por relación sistema/usuario y principal/secundario.
_Mostrado como segundo_ | +| **gcp.redis.stats.cpu_utilization_main_thread**
(count) | Segundos de CPU consumidos por el subproceso principal del servidor Redis, desglosados por espacio de sistema/usuario y relación principal/secundario.
_Mostrado como segundo_ | +| **gcp.redis.stats.evicted_keys**
(count) | Número de claves desalojadas debido al límite máximo de memoria.
_Mostrado como clave_ | +| **gcp.redis.stats.expired_keys**
(count) | Número total de eventos de expiración de claves.
_Mostrado como clave_ | +| **gcp.redis.stats.keyspace_hits**
(count) | Número de búsquedas correctas de claves en el diccionario principal.
_Mostrado como clave_ | +| **gcp.redis.stats.keyspace_misses**
(count) | Número de búsquedas fallidas de claves en el diccionario principal.
_Mostrado como clave_ | +| **gcp.redis.stats.memory.maxmemory**
(gauge) | Cantidad máxima de memoria que Redis puede consumir.
_Mostrado como byte_ | +| **gcp.redis.stats.memory.system_memory_overload_duration**
(count) | La cantidad de tiempo en microsegundos que la instancia está en modo de sobrecarga de memoria del sistema.
_Mostrado como microsegundo_ | +| **gcp.redis.stats.memory.system_memory_usage_ratio**
(gauge) | Uso de la memoria como proporción de la memoria máxima del sistema.
_Mostrado como fracción_ | +| **gcp.redis.stats.memory.usage**
(gauge) | Número total de bytes asignados por Redis.
_Mostrado como byte_ | +| **gcp.redis.stats.memory.usage_ratio**
(gauge) | Utilización de memoria como proporción de la memoria máxima.
_Mostrado como fracción_ | +| **gcp.redis.stats.network_traffic**
(count) | Número total de bytes enviados hacia o desde redis (incluidos bytes de los propios comandos, datos de carga útil y delimitadores).
_Mostrado como byte_ | +| **gcp.redis.stats.pubsub.channels**
(gauge) | Número global de canales Pub/Sub con suscripciones de clientes.| +| **gcp.redis.stats.pubsub.patterns**
(gauge) | Número global de patrones Pub/Sub con suscripciones de clientes.| +| **gcp.redis.stats.reject_connections_count**
(count) | Número de connections (conexiones) rechazadas debido al límite máximo de clientes.| + +### Eventos + +La integración Google Cloud Memorystore para Redis no incluye eventos. + +### Checks de servicio + +La integración Google Cloud Memorystore para Redis no incluye checks de servicio. + +## Solucionar problemas + +¿Necesitas ayuda? Ponte en contacto con [asistencia técnica de Datadog](https://docs.datadoghq.com/help/). \ No newline at end of file diff --git a/content/es/integrations/google-cloud-run.md b/content/es/integrations/google-cloud-run.md new file mode 100644 index 00000000000..1e5ad98c89b --- /dev/null +++ b/content/es/integrations/google-cloud-run.md @@ -0,0 +1,166 @@ +--- +aliases: +- /es/integrations/google_cloud_run +app_id: google-cloud-run +categories: +- nube +- contenedores +- google cloud +- recopilación de logs +- orquestación +custom_kind: integración +description: Ejecuta contenedores sin estado invocados mediante solicitudes HTTP en + una plataforma informática gestionada. +further_reading: +- link: https://www.datadoghq.com/blog/monitoring-cloud-run-datadog/ + tag: blog + text: Monitorizar Cloud Run con Datadog +- link: https://www.datadoghq.com/blog/collecting-cloud-run-metrics/ + tag: blog + text: Cómo recopilar métricas de Google Cloud Run +- link: https://www.datadoghq.com/blog/key-metrics-for-cloud-run-monitoring/ + tag: blog + text: Métricas clave para monitorizar Google Cloud Run +- link: https://docs.datadoghq.com/integrations/google_cloud_run_for_anthos/ + tag: documentación + text: Documentación de Google Cloud Run +media: [] +title: Google Cloud Run +--- +## Información general + +Cloud Run es una plataforma de computación administrada que permite ejecutar contenedores sin estado que se pueden invocar mediante solicitudes HTTP. + +Habilita esta integración e instrumenta tu contenedor para ver todas tus métricas, trazas (traces) y logs de Cloud Run en Datadog. + +Para obtener más información sobre Cloud Run para Anthos, consulta la [documentación de Google Cloud Run para Anthos](https://docs.datadoghq.com/integrations/google-cloud-run-for-anthos/). + +## Configuración + +### Recopilación de métricas + +#### Instalación + +Configura la [integración de Google Cloud Platform](https://docs.datadoghq.com/integrations/google-cloud-platform/) para empezar a recopilar métricas predefinidas. Para configurar métricas personalizadas, consulta la [Documentación de Serverless](https://docs.datadoghq.com/serverless/google_cloud_run). + +### Recopilación de logs + +#### Integración + +Google Cloud Run también expone [logs de auditoría](https://cloud.google.com/run/docs/audit-logging). +Los logs de Google Cloud Run se recopilan con Google Cloud Logging y se envían a un job (generic) de Dataflow a través de un tema de Cloud Pub/Sub. Si aún no lo has hecho, [configura el registro con la plantilla Datadog Dataflow](https://docs.datadoghq.com/integrations/google-cloud-platform/#log-collection). + +Una vez hecho esto, exporta tus logs de Google Cloud Run de Google Cloud Logging al tema Pub/Sub: + +1. Ve a la [page (página) Google Cloud Logging](https://console.cloud.google.com/logs/viewer) y filtra logs de Google Cloud Run. + +1. Haz clic en **Create sink** (Crear sumidero) y asigna al sumidero el nombre correspondiente. + +1. Elige "Cloud Pub/Sub" como destino y selecciona el tema Pub/Sub creado para tal fin. **Nota**: El tema Pub/Sub puede encontrarse en un proyecto diferente. + + {{< img src="integrations/google_cloud_pubsub/creating_sink2.png" alt="Exporta logs de Google Cloud Pub/Sub a Pub Sub" >}} + +1. Haz clic en **Create** (Crear) y espera a que aparezca el mensaje de confirmación. + +#### Registro directo + +Para obtener más información sobre el registro de aplicación directa a Datadog desde tus servicios Cloud Run, consulta la [documentación Serverless](https://docs.datadoghq.com/serverless/google_cloud_run). + +### Rastreo + +Para obtener más información sobre las instrucciones de configuración especializadas del Agent para Google Cloud Run totalmente gestionado, consulta la [Documentación serverless](https://docs.datadoghq.com/serverless/google_cloud_run). + +## Datos recopilados + +### Métricas + +| | | +| --- | --- | +| **gcp.run.container.billable_instance_time**
(rate) | Tiempo facturable agregado de todas las instancias de contenedor de la revisión (ms/s).
_Mostrado como milisegundo_ | +| **gcp.run.container.completed_probe_attempt_count**
(count) | Número de intentos de sondeo de check de estado completados y sus resultados.| +| **gcp.run.container.completed_probe_count**
(count) | Número de sondeos de check de estado completadas y sus resultados.| +| **gcp.run.container.containers**
(gauge) | Número de instancias de contenedor existentes, desglosadas por estado.| +| **gcp.run.container.cpu.allocation_time**
(rate) | Asignación de CPU del contenedor de la revisión en segundos.
_Mostrado como núcleo_ | +| **gcp.run.container.cpu.usage.avg**
(gauge) | El uso medio real de la CPU del contenedor en segundos de CPU desglosado por el campo de métricas, el nombre del contenedor.
_Mostrado como segundo_ | +| **gcp.run.container.cpu.usage.samplecount**
(gauge) | El count de ejemplo para el uso real de la CPU del contenedor en segundos de CPU desglosado por el campo de métricas, el nombre del contenedor.
_Mostrado como segundo_ | +| **gcp.run.container.cpu.usage.sumsqdev**
(gauge) | La suma de la desviación al cuadrado para el uso real de la CPU del contenedor en segundos de CPU desglosada por el campo de métricas, el nombre del contenedor.
_Mostrado como segundo_ | +| **gcp.run.container.cpu.utilizations.avg**
(gauge) | La distribución media de la distribución de la utilización de la CPU del contenedor en todas las instancias del contenedor de la revisión.
_Mostrado como fracción_ | +| **gcp.run.container.cpu.utilizations.p95**
(gauge) | La distribución del percentil 95 de la distribución de la utilización de la CPU del contenedor en todas las instancias del contenedor de la revisión.
_Mostrado como fracción_. | +| **gcp.run.container.cpu.utilizations.p99**
(gauge) | La distribución del percentil 99 de la utilización de la CPU del contenedor en todas las instancias del contenedor de la revisión.
_Mostrado como fracción_. | +| **gcp.run.container.cpu.utilizations.samplecount**
(count) | Count de ejemplos de la distribución de los tiempos de solicitud de servicio en milisegundos.
_Mostrado como fracción_ | +| **gcp.run.container.gpu.memory_usages.avg**
(gauge) | La distribución media del uso de memoria GPU del contenedor en todas las instancias del contenedor.
_Mostrado como byte_ | +| **gcp.run.container.gpu.memory_usages.samplecount**
(gauge) | El count de ejemplos para la distribución del uso de memoria GPU del contenedor en todas las instancias del contenedor.
_Mostrado como byte_ | +| **gcp.run.container.gpu.memory_usages.sumsqdev**
(gauge) | La suma de la desviación al cuadrado de la distribución del uso de memoria GPU del contenedor en todas las instancias del contenedor.
_Mostrado como byte_ | +| **gcp.run.container.gpu.memory_utilizations.avg**
(gauge) | Distribución de la utilización media de la memoria GPU del contenedor en todas las instancias del contenedor.| +| **gcp.run.container.gpu.memory_utilizations.samplecount**
(gauge) | El count de ejemplos para la distribución de la utilización de la memoria GPU del contenedor en todas las instancias del contenedor.| +| **gcp.run.container.gpu.memory_utilizations.sumsqdev**
(gauge) | La suma de la desviación al cuadrado para la distribución de la utilización de la memoria GPU del contenedor en todas las instancias del contenedor.| +| **gcp.run.container.gpu.utilizations.avg**
(gauge) | Distribución de la utilización media de la GPU del contenedor en todas las instancias del contenedor.| +| **gcp.run.container.gpu.utilizations.samplecount**
(gauge) | El count de ejemplos para la distribución de la utilización de la GPU del contenedor en todas las instancias del contenedor.| +| **gcp.run.container.gpu.utilizations.sumsqdev**
(gauge) | La suma de la desviación al cuadrado de la distribución de la utilización de la GPU del contenedor en todas las instancias del contenedor.| +| **gcp.run.container.instance_count**
(gauge) | El número de instancias del contenedor que existen, desglosadas por estado.
_Mostrado como contenedor_ | +| **gcp.run.container.max_request_concurrencies.avg**
(gauge) | Media del número máximo de solicitudes concurrentes atendidas por cada instancia del contenedor durante un minuto.
_Mostrado como solicitud_ | +| **gcp.run.container.max_request_concurrencies.p95**
(gauge) | Distribución del percentil 95 del número máximo de solicitudes concurrentes atendidas por cada instancia del contenedor durante un minuto.
_Mostrado como solicitud_ | +| **gcp.run.container.max_request_concurrencies.p99**
(gauge) | Distribución del percentil 99 del número máximo de solicitudes concurrentes atendidas por cada instancia del contenedor durante un minuto.
_Mostrado como solicitud_ | +| **gcp.run.container.max_request_concurrencies.samplecount**
(count) | Count de ejemplos de la distribución del número máximo de solicitudes concurrentes atendidas por cada instancia del contenedor durante un minuto.
_Mostrado como solicitud_ | +| **gcp.run.container.memory.allocation_time**
(rate) | Asignación de memoria del contenedor de la revisión en Gigabyte-segundos.
_Mostrado como gibibyte_ | +| **gcp.run.container.memory.usage.avg**
(gauge) | El uso medio real de la memoria del contenedor en bytes desglosado por el campo de métricas, el nombre del contenedor.
_Mostrado como byte_ | +| **gcp.run.container.memory.usage.samplecount**
(gauge) | El count de ejemplos para el uso real de la memoria del contenedor en bytes desglosado por el campo de métricas, el nombre del contenedor.
_Mostrado como byte_ | +| **gcp.run.container.memory.usage.sumsqdev**
(gauge) | La suma de la desviación al cuadrado para el uso real de memoria del contenedor en bytes desglosado por el campo de métricas, el nombre del contenedor.
_Mostrado como byte_ | +| **gcp.run.container.memory.utilizations.avg**
(gauge) | Media de la distribución de la utilización de la memoria del contenedor en todas las instancias del contenedor de la revisión.
_Mostrado como fracción_ | +| **gcp.run.container.memory.utilizations.p95**
(gauge) | Distribución del percentil 95 de la distribución de la utilización de la memoria del contenedor en todas las instancias del contenedor de la revisión.
_Mostrado como fracción_. | +| **gcp.run.container.memory.utilizations.p99**
(gauge) | Distribución del percentil 99 de la distribución de la utilización de la memoria del contenedor en todas las instancias del contenedor de la revisión.
_Mostrado como fracción_. | +| **gcp.run.container.memory.utilizations.samplecount**
(count) | Count de ejemplos de la distribución de la utilización de la memoria del contenedor en todas las instancias del contenedor de la revisión.
_Mostrado como fracción_. | +| **gcp.run.container.network.received_bytes_count**
(count) | El socket entrante y el tráfico de respuesta HTTP de revisión, en bytes.
_Mostrado como byte_ | +| **gcp.run.container.network.sent_bytes_count**
(count) | El socket saliente y el tráfico de respuesta HTTP de revisión, en bytes.
_Mostrado como byte_ | +| **gcp.run.container.network.throttled_inbound_bytes_count**
(count) | Bytes entrantes perdidos debido a la alternancia de la red.
_Mostrado como byte_ | +| **gcp.run.container.network.throttled_inbound_packets_count**
(count) | Paquetes entrantes perdidos debido a la alternancia de la red.
_Mostrado como byte_ | +| **gcp.run.container.network.throttled_outbound_bytes_count**
(count) | Bytes salientes perdidos debido a la alternancia de la red.
_Mostrado como byte_ | +| **gcp.run.container.network.throttled_outbound_packets_count**
(count) | Paquetes salientes perdidos debido a la alternancia de la red.
_Mostrado como byte_ | +| **gcp.run.container.probe_attempt_latencies.avg**
(count) | La distribución media del tiempo empleado en ejecutar un único intento de sondeo antes del éxito o el fracaso en milisegundos.
_Mostrado como milisegundo_ | +| **gcp.run.container.probe_attempt_latencies.samplecount**
(count) | El count de ejemplos para la distribución del tiempo empleado en ejecutar un único intento de sondeo antes del éxito o el fracaso en milisegundos.
_Mostrado como milisegundo_ | +| **gcp.run.container.probe_attempt_latencies.sumsqdev**
(count) | La suma de la desviación al cuadrado para la distribución del tiempo empleado en ejecutar un único intento de sondeo antes del éxito o el fracaso en milisegundos.
_Mostrado como milisegundo_ | +| **gcp.run.container.probe_latencies.avg**
(count) | La distribución media del tiempo empleado en ejecutar un sondeo antes del éxito o el fracaso en milisegundos.
_Mostrado como milisegundo_ | +| **gcp.run.container.probe_latencies.samplecount**
(count) | El count de ejemplos para la distribución del tiempo empleado en ejecutar un sondeo antes del éxito o el fracaso en milisegundos.
_Mostrado como milisegundo_ | +| **gcp.run.container.probe_latencies.sumsqdev**
(count) | La suma de la desviación al cuadrado para la distribución del tiempo empleado en ejecutar un sondeo antes del éxito o el fracaso en milisegundos.
_Mostrado como milisegundo_ | +| **gcp.run.container.startup_latencies.avg**
(count) | La distribución media del tiempo empleado en iniciar una nueva instancia del contenedor en milisegundos.
_Mostrado como milisegundo_ | +| **gcp.run.container.startup_latencies.samplecount**
(count) | El count de ejemplos para la distribución del tiempo empleado en iniciar una nueva instancia del contenedor en milisegundos.
_Mostrado como milisegundo_ | +| **gcp.run.container.startup_latencies.sumsqdev**
(count) | La suma de la desviación al cuadrado para la distribución del tiempo empleado en iniciar una nueva instancia del contenedor en milisegundos.
_Mostrado como milisegundo_ | +| **gcp.run.infrastructure.cloudsql.connection_latencies.avg**
(count) | La distribución media de la latencia en microsegundos para las connections (conexiones) originadas desde Cloud Run a CloudSQL.
_Mostrado como microsegundo_ | +| **gcp.run.infrastructure.cloudsql.connection_latencies.samplecount**
(count) | El count de ejemplos para la distribución de latencia en microsegundos para connections (conexiones) originadas desde Cloud Run a CloudSQL.
_Mostrado como microsegundo_ | +| **gcp.run.infrastructure.cloudsql.connection_latencies.sumsqdev**
(count) | La suma de la desviación al cuadrado para la distribución de la latencia en microsegundos para connections (conexiones) originadas desde Cloud Run a CloudSQL.
_Mostrado como microsegundo_ | +| **gcp.run.infrastructure.cloudsql.connection_refused_count**
(count) | Número total de connections (conexiones) rechazadas originadas desde Cloud Run a CloudSQL.| +| **gcp.run.infrastructure.cloudsql.connection_request_count**
(count) | Número total de solicitudes de connection (conexión) originadas desde Cloud Run a CloudSQL.| +| **gcp.run.infrastructure.cloudsql.received_bytes_count**
(count) | Número de bytes recibidos por Cloud Run desde CloudSQL a través de la red.
_Mostrado como byte_ | +| **gcp.run.infrastructure.cloudsql.sent_bytes_count**
(count) | Número de bytes enviados por Cloud Run a CloudSQL a través de la red.
_Mostrado como byte_ | +| **gcp.run.job.completed_execution_count**
(count) | Número de ejecuciones completadas de job (generic) y su resultado.| +| **gcp.run.job.completed_task_attempt_count**
(count) | Número de intentos de tarea completados y su correspondiente resultado de salida.| +| **gcp.run.job.running_executions**
(gauge) | Número de ejecuciones de job (generic) en curso.| +| **gcp.run.job.running_task_attempts**
(gauge) | Número de intentos de tareas en ejecución.| +| **gcp.run.pending_queue.pending_requests**
(gauge) | Número de solicitudes pendientes.| +| **gcp.run.request_count**
(count) | El número de solicitudes de servicio.
_Mostrado como solicitud_ | +| **gcp.run.request_latencies.avg**
(gauge) | Distribución media de los tiempos de solicitud de servicio en milisegundos.
_Mostrado como milisegundo_ | +| **gcp.run.request_latencies.p95**
(gauge) | La distribución del percentil 95 de los tiempos de solicitud de servicio en milisegundos.
_Mostrado como milisegundo_ | +| **gcp.run.request_latencies.p99**
(gauge) | La distribución del percentil 99 de los tiempos de solicitud de servicio en milisegundos.
_Mostrado como milisegundo_ | +| **gcp.run.request_latencies.samplecount**
(count) | Count de ejemplos de la distribución de los tiempos de solicitud de servicio en milisegundos.
_Mostrado como milisegundo_ | +| **gcp.run.request_latencies.sumsqdev**
(gauge) | Suma de la desviación al cuadrado de la distribución de los tiempos de solicitud de servicio en milisegundos.
_Mostrado como milisegundo_ | +| **gcp.run.enhanced.cold_start**
(count) | Número de veces que un contenedor o función se inicializó con un arranque en frío.| +| **gcp.run.enhanced.shutdown**
(count) | Número de veces que se apaga un contenedor o una función.| +| **gcp.run.job.enhanced.task.started**
(count) | Número de veces que se ha iniciado una tarea.| +| **gcp.run.job.enhanced.task.ended**
(count) | Número de veces que ha finalizado una tarea.| +| **gcp.run.job.enhanced.task.duration**
(gauge) | Duración media de una tarea en la ejecución.
_Mostrado como milisegundo_ | + +### Eventos + +La integración Google Cloud Functions no incluye eventos. + +### Checks de servicio + +La integración Google Cloud Functions no incluye checks de servicio. + +## Solucionar problemas + +¿Necesitas ayuda? Ponte en contacto con el [servicio de asistencia de Datadog](https://docs.datadoghq.com/help/). + +## Referencias adicionales + +{{< partial name="whats-next/whats-next.html" >}} \ No newline at end of file diff --git a/content/es/integrations/guide/gcp-metric-discrepancy.md b/content/es/integrations/guide/gcp-metric-discrepancy.md new file mode 100644 index 00000000000..cc94ebdde1f --- /dev/null +++ b/content/es/integrations/guide/gcp-metric-discrepancy.md @@ -0,0 +1,84 @@ +--- +description: Pasos para solucionar la discrepancia en las métricas de Google Cloud +further_reading: +- link: https://docs.datadoghq.com/integrations/google-cloud-platform/ + tag: Integración + text: Integración con Google Cloud +title: Discrepancia en las métricas de Google Cloud +--- + +## Información general + +Utiliza esta guía para solucionar discrepancias en las métricas entre Google Cloud y Datadog. + +## Discrepancias en las métricas + +Datadog ingiere los valores brutos más detallados de Google Cloud. Toda la agregación que se ve en Datadog se realiza en Datadog. La ingesta de métricas de Datadog importa los valores brutos de Google como indicadores (gauge), y cualquier otra agregación se realiza en Datadog. Los siguientes pasos concilian la métrica `gcp.redis.stats.cpu_utilization` entre Google Cloud y Datadog. + +1. Busca la métrica correspondiente en Google Cloud. + + Para la integración con Google Cloud, Datadog convierte las métricas de Google Cloud al formato `gcp.Google_Cloud_SERVICE_NAME.METRIC_NAME`. Para la [métrica de ejemplo][1], el nombre del servicio de Google Cloud es **redis**, y el nombre de la métrica es **stats/cpu_utilization**. El nombre completo de la métrica es `redis.googleapis.com/stats/cpu_utilization`. + +2. Encuentra las dimensiones más detalladas. + + Estas incluyen todas las **etiquetas de recursos**: `project_id`,`region`, `instance_id`, `node_id`, y **etiquetas de métricas**: `role`, `space`, `relationship`. Consulta la [documentación de Google Cloud][2] para otras métricas. + + {{< img src="integrations/guide/gcp-metric-discrepancy/labels_definition.png" alt="definición de etiquetas en la documentación de GCP" >}} + + El tipo de recurso está asociado a cada métrica bajo un servicio de Google Cloud. A continuación, se muestran los tipos de recursos admitidos para el servicio **redis**. El tipo de recurso de la métrica de ejemplo es `redis_instance`. `redis_instance` tiene **Etiquetas de recursos**: `project_id`,`region`, `instance_id`, `node_id`. + - [redis.googleapis.com/Cluster][3] + - [redis_instance][4] + - [redis.googleapis.com/ClusterNode][5] + + {{< img src="integrations/guide/gcp-metric-discrepancy/redis_instance.png" alt="etiquetas de recursos de redis_instance" >}} + +3. Grafica la métrica en el Google Cloud Metrics Explorer. + + Busca `redis.googleapis.com/stats/cpu_utilization`. + - Hora: 1 hora (idealmente en UTC) + - Espacio de nombres: Cloud Memorystore Redis Instance + - Nombre de la métrica: CPU Seconds + - Filtro: (dimensiones más detalladas) project_id, region, instance_id, node_id, role, space, relationship. + - Agregación: Sum (debe mostrar los mismos valores cuando se utiliza mean, min, max, sum, o none si se utilizan las dimensiones más detalladas) + - Intervalo mínimo: 1 m + + {{< img src="integrations/guide/gcp-metric-discrepancy/gcp_metric_explorer.png" alt="gcp metric explorer" >}} + +4. Grafica la métrica en el Datadog Metrics Explorer. + + {{< img src="integrations/guide/gcp-metric-discrepancy/datadog_metric_explorer.png" alt="datadog metric explorer" >}} + + En la mayoría de los casos, tras completar los pasos 1 a 4, verás exactamente los mismos valores tanto en Google Cloud como en Datadog. Sin embargo, en nuestro ejemplo, aparece una discrepancia a las 01:40:00 PM. + + - **Datadog**: 108.71ms + - **Google Cloud**: 0.0018119s + + {{< img src="integrations/guide/gcp-metric-discrepancy/gcp_value.png" alt="valor de gcp" >}} + + {{< img src="integrations/guide/gcp-metric-discrepancy/datadog_value.png" alt="valor de datadog" >}} + + +5. Comprende las funciones de alineación de Google Cloud. + + Esta discrepancia se produce porque, por defecto, Google Cloud aplica una alineación de tasas para esta métrica. Para más detalles, consulta la documentación de [función de alineación][6] de Google Cloud. Haz clic en `configure aligner` para ver que la función de alineación se establece automáticamente en **rate** (tasa) (0,108711 / 60 ≃ 0,0018119). + + {{< img src="integrations/guide/gcp-metric-discrepancy/gcp_aligner.png" alt="alineador de gcp" >}} + + {{< img src="integrations/guide/gcp-metric-discrepancy/gcp_rate.png" alt="tasa de gcp" >}} + +6. Ajusta la función de alineación en Google Cloud. + + Cambia la función de alineación a `delta`, `min`, `max`, `sum` o `mean`. Suponiendo que estás utilizando las dimensiones más detalladas, el valor en Google Cloud debe coincidir con el valor en Datadog. + + {{< img src="integrations/guide/gcp-metric-discrepancy/gcp_delta.png" alt="gcp delta" >}} + +## Referencias adicionales + +{{< partial name="whats-next/whats-next.html" >}} + +[1]: https://cloud.google.com/monitoring/api/metrics_gcp_p_z#gcp-redis:~:text=of%20%5Bprimary%2C%20replica%5D.-,stats/cpu_utilization,-GA%20%E2%80%83(project) +[2]: https://cloud.google.com/monitoring/api/metrics_gcp +[3]: https://cloud.google.com/monitoring/api/resources#tag_redis.googleapis.com/Cluster +[4]: https://cloud.google.com/monitoring/api/resources#tag_redis_instance +[5]: https://cloud.google.com/monitoring/api/resources#tag_redis.googleapis.com/ClusterNode +[6]: https://cloud.google.com/monitoring/api/v3/aggregation#alignment-intro \ No newline at end of file diff --git a/content/es/logs/guide/google-cloud-log-forwarding.md b/content/es/logs/guide/google-cloud-log-forwarding.md new file mode 100644 index 00000000000..3def193ceb0 --- /dev/null +++ b/content/es/logs/guide/google-cloud-log-forwarding.md @@ -0,0 +1,292 @@ +--- +further_reading: +- link: https://www.datadoghq.com/blog/stream-logs-datadog-dataflow-template/ + tag: Blog + text: Transmitir tus logs de Google Cloud a Datadog con Dataflow +title: Configuración del reenvío de logs de Google Cloud +--- + +## Información general + +El reenvío de logs desde tu entorno de Google Cloud permite la monitorización casi en tiempo real de los recursos y las actividades que tienen lugar en tu organización o carpeta. Puedes configurar [monitores de logs][5] para recibir notificaciones de problemas, utilizar [Cloud SIEM][6] para detectar amenazas o aprovechar [Watchdog][7] para identificar incidentes desconocidos o comportamientos anómalos. + +Los logs son reenviados por [Google Cloud Dataflow][4] utilizando la [plantilla Datadog Dataflow][3]. Este método te permite agrupar y comprimir los eventos de logs antes de reenviarlos a Datadog, que es la forma más eficiente de reenviar logs. Puedes especificar qué logs se reenvían utilizando filtros de inclusión y exclusión. + +## Instalación + +{{% collapse-content title="Inicio rápido (recomendado)" level="h4" id="quick-start-log-setup" %}} +#### Elige el método de configuración del inicio rápido si... + +- Estás configurando el reenvío de logs desde Google Cloud por primera vez. +- Prefieres un flujo de trabajo basado en la interfaz de usuario y quieres minimizar el tiempo necesario para crear y configurar los recursos necesarios. +- Quieres automatizar los pasos de configuración en scripts o pipelines de CI/CD. + +##### Permisos previos + +{{% google-cloud-logging-setup-permissions %}} + +##### Instrucciones + +1. En el [cuadro de integración con Google Cloud][100], haz clic en el botón **Configure Log Collection** (Configurar la recopilación de logs). +1. Selecciona **Quick Start** (Inicio rápido). Se genera automáticamente un script de instalación, configurado con tus credenciales y tu sitio Datadog. +1. Copia el script de instalación. Puedes ejecutar el script localmente o en Google Cloud Shell: + - Localmente: Puede ser más rápido, pero requiere tus credenciales de Google Cloud y la [CLI de gcloud][101] instalada en tu máquina. + - [Google Cloud Shell][102]: Haz clic en **Open Google Cloud Shell** (Abrir Google Cloud Shell) para ejecutar el script. +1. Después de ejecutar el script, vuelve al cuadro de integración con Google Cloud. +1. En la sección **Select Projects** (Seleccionar proyectos), selecciona las carpetas y proyectos desde los que se reenviarán logs. Si seleccionas una carpeta, los logs se reenviarán desde todos sus proyectos secundarios.
+ **Nota**: En esta sección solo aparecen las carpetas y proyectos para los que tienes el acceso y los permisos necesarios. Asimismo, las carpetas y proyectos sin nombre para mostrar no aparecen. +1. En la sección **Dataflow Job Configuration** (Configuración del trabajo de Dataflow), especifica las opciones de configuración del trabajo de Dataflow: + - Selecciona la configuración del despliegue (región de Google Cloud y proyecto para alojar los recursos creados: temas y suscripciones Pub/Sub, un sumidero de enrutamiento de logs, una entrada de Secret Manager, una cuenta de servicio, un bucket de Cloud Storage y un trabajo de Dataflow). + - Selecciona la configuración del escalado (número de workers y número máximo de workers). + - Selecciona la configuración del rendimiento (número máximo de solicitudes paralelas y tamaño del lote). + - Selecciona las opciones de ejecución. +1. En la sección **Advanced Configuration** (Configuración avanzada), especifica opcionalmente el tipo de máquinas virtuales de tus workers de Dataflow. Si no se selecciona ningún tipo de máquina, Dataflow elige automáticamente un tipo de máquina adecuado en función de tus requisitos de trabajo. +1. Opcionalmente puedes especificar filtros de inclusión y exclusión utilizando el [lenguaje de consulta de la generación de logs] de Google Cloud[105]. +1. Revisa los pasos a ejecutar en la sección **Complete Setup** (Finalizar configuración). Si todo sale según lo esperado, haz clic en **Complete Setup**. + + +[100]: https://app.datadoghq.com/integrations/gcp +[101]: https://docs.cloud.google.com/sdk/docs/install +[102]: https://docs.cloud.google.com/shell/docs +[104]: https://docs.cloud.google.com/dataflow/docs/guides/enable-dataflow-prime +[105]: https://cloud.google.com/logging/docs/view/logging-query-language +{{% /collapse-content %}} + +{{% collapse-content title="Terraform" level="h4" id="terraform-log-setup" %}} +#### Elige el método de configuración de Terraform si... + +- Gestionas la infraestructura como código y quieres mantener la integración de Datadog Google Cloud bajo control de versiones. +- Necesitas configurar varias carpetas o proyectos de forma coherente con bloques de proveedores reutilizables. +- Quieres un proceso de despliegue repetible y auditable que se adapte a tu entorno gestionado por Terraform. + +##### Permisos previos + +{{% google-cloud-logging-setup-permissions %}} + +##### Instrucciones + +{{< tabs >}} +{{% tab "Configuración de Datadog basada en la interfaz de usuario" %}} + +1. En el [cuadro de integración con Google Cloud][200], haz clic en el botón **Configure Log Collection** (Configurar la recopilación de logs). +1. Selecciona **Terraform**. +1. En la sección **Select Projects** (Seleccionar proyectos), selecciona las carpetas y proyectos desde los que se reenviarán logs. Si seleccionas una carpeta, los logs se reenviarán desde todos sus proyectos secundarios.
+ **Nota**: En esta sección solo aparecen las carpetas y proyectos para los que tienes el acceso y los permisos necesarios. Asimismo, las carpetas y proyectos sin nombre para mostrar no aparecen. +1. En la sección **Dataflow Job Configuration** (Configuración del trabajo de Dataflow), especifica las opciones de configuración del trabajo de Dataflow: + - Selecciona la configuración del despliegue (región de Google Cloud y proyecto para alojar los recursos creados: temas y suscripciones Pub/Sub, un sumidero de enrutamiento de logs, una entrada de Secret Manager, una cuenta de servicio, un bucket de Cloud Storage y un trabajo de Dataflow). + - Selecciona la configuración del escalado (número máximo de workers). + - Selecciona la configuración del rendimiento (número máximo de solicitudes paralelas y tamaño del lote). + - Selecciona las opciones de ejecución (Streaming Engine está activado por defecto. Lee más sobre sus [ventajas][201]). +1. En la sección **Advanced Configuration** (Configuración avanzada), especifica opcionalmente el tipo de máquinas virtuales de tus workers de Dataflow. Si no se selecciona ningún tipo de máquina, Dataflow elige automáticamente un tipo de máquina adecuado en función de tus requisitos de trabajo. +1. Opcionalmente puedes especificar filtros de inclusión y exclusión utilizando el [lenguaje de consulta de la generación de logs] de Google Cloud[203]. + + +[200]: https://app.datadoghq.com/integrations/gcp +[201]: https://docs.cloud.google.com/dataflow/docs/streaming-engine#benefits +[202]: https://docs.cloud.google.com/dataflow/docs/guides/enable-dataflow-prime +[203]: https://cloud.google.com/logging/docs/view/logging-query-language +{{% /tab %}} + +{{% tab "Configuración manual con el módulo Terraform" %}} +Consulta las instrucciones del repositorio [`terraform-gcp-datadog-integration`][300] para configurar y gestionar la infraestructura necesaria a través de Terraform. + +[300]: https://github.com/GoogleCloudPlatform/terraform-gcp-datadog-integration?tab=readme-ov-file#log-collection-integration---google-cloud-platform-to-datadog +{{% /tab %}} +{{< /tabs >}} +{{% /collapse-content %}} + +{{% collapse-content title="Manual" level="h4" id="manual-logging-setup" %}} +Las instrucciones de esta sección le guiarán a través del proceso de: + +1. Creación de un [tema][401] y una [suscripción pull][402] Pub/Sub para recibir logs de un sumidero de logs configurado. +2. Creación de una cuenta de servicio de worker de Dataflow personalizada para proporcionar [mínimo privilegio][403] a tus workers de pipelines de Dataflow. +3. Creación de un [sumidero de logs][404] para publicar logs en el tema Pub/Sub. +4. Creación de un trabajo de Dataflow utilizando la [plantilla de Datadog][400] para transmitir logs desde la suscripción Pub/Sub a Datadog. + +Tienes control total sobre qué logs se envían a Datadog a través de los filtros de generación de logs que creas en el sumidero de logs, incluidos los logs GCE y GKE. Consulta la [página Lenguaje de consulta de generación de logs][405] de Google para obtener información sobre la escritura de filtros. Para ver un examen detallado de la arquitectura creada, consulta [Transmitir logs desde Google Cloud a Datadog][9] en el Centro de arquitectura en la nube. + +**Nota**: Debes activar la **API de flujo de datos** para utilizar Google Cloud Dataflow. Consulta [Activación de API][407] en la documentación de Google Cloud para obtener más información. + +Para recopilar logs de aplicaciones que se ejecutan en GCE o GKE, también puedes utilizar el [Datadog Agent][408]. + +#### 1. Crear un tema y una suscripción Cloud Pub/Sub + +1. Ve a la [consola de Cloud Pub/Sub][409] y crea un nuevo tema. Selecciona la opción **Add a default subscription** (Añadir una suscripción por defecto) para simplificar la configuración. + + **Nota**: También puedes configurar manualmente una [suscripción Cloud Pub/Sub][410] con el tipo de entrega **Pull**. Si creas tu suscripción Pub/Sub manualmente, deja la casilla `Enable dead lettering` **desmarcada**. Para obtener más información, consulta [Funciones de Pub/Sub no compatibles][411]. + +{{< img src="integrations/google_cloud_platform/create_a_topic.png" alt="Página Crear un tema en la consola de Google Cloud con la casilla Añadir una suscripción por defecto seleccionada" style="width:80%;">}} + +2. Proporciona un nombre explícito para ese tema como `export-logs-to-datadog` y haz clic en **Create** (Crear). + +3. Crea un tema adicional y una suscripción por defecto para gestionar cualquier mensaje de log rechazado por la API de Datadog. El nombre de este tema se utiliza en la plantilla de Datadog Dataflow como parte de la configuración de la ruta del [parámetro de plantilla][412] `outputDeadletterTopic`. Cuando hayas inspeccionado y corregido cualquier problema en los mensajes fallidos, reenvíalos al tema `export-logs-to-datadog` original ejecutando un trabajo de [plantilla Pub/Sub a Pub/Sub][413]. + +4. Datadog recomienda crear un secreto en [Secret Manager][414], con el valor válido de tu clave de API de Datadog, para utilizarlo posteriormente en la plantilla de Datadog Dataflow. + +
+Las suscripciones Cloud Pub/Sub en la nube están sujetas a las cuotas y limitaciones de Google Cloud. Si el número de logs que tienes supera esas limitaciones, Datadog te recomienda dividir tus logs en varios temas. Consulta la sección Monitor the Pub/Sub Log Forwarding (Monitorizar el reenvío de logs de Pub/Sub) para obtener información sobre cómo configurar notificaciones de monitor si te acercas a esos límites. +
+ +#### 2. Crear una cuenta de servicio de worker de Dataflow personalizada + +El comportamiento predeterminado de los workers de pipelines de Dataflow consiste en utilizar la [cuenta de servicio de Compute Engine por defecto][416] de tu proyecto, que concede permisos a todos los recursos del proyecto. Si estás reenviando logs desde un entorno de **Producción**, deberías crear una cuenta de servicio de worker personalizada con solo los roles y permisos necesarios, y asignar esta cuenta de servicio a tus workers de pipelines de Dataflow. + +1. Ve a la página [Cuentas de servicio][417] en la consola de Google Cloud y selecciona tu proyecto. +2. Haz clic en **CREATE SERVICE ACCOUNT** (Crear cuenta de servicio) y asigna un nombre descriptivo a la cuenta de servicio. Haz clic en **CREATE AND CONTINUE** (Crear y continuar). +3. Añade los roles en la tabla de permisos necesarios y haz clic en **DONE** (Listo). + +##### Permisos necesarios + +[Administrador de Dataflow][418] +: `roles/dataflow.admin`
Permite que esta cuenta de servicio realice tareas administrativas de Dataflow. + +[Worker de Dataflow][419] +: `roles/dataflow.worker`
Permite que esta cuenta de servicio realice operaciones de Dataflow. + +[Visor de Pub/Sub][420] +: `roles/pubsub.viewer`
Permite que esta cuenta de servicio vea mensajes de la suscripción Pub/Sub con tus logs de Google Cloud. + +[Abonado de Pub/Sub][421] +: `roles/pubsub.subscriber`
Permite que esta cuenta de servicio consuma mensajes de la suscripción Pub/Sub con tus logs de Google Cloud. + +[Editor de Pub/Sub][422] +: `roles/pubsub.publisher`
Permite que esta cuenta de servicio publique mensajes fallidos en una suscripción independiente, lo que permite analizar o reenviar logs. + +[Secret Manager Secret Accessor][423] +: `roles/secretmanager.secretAccessor`
Permite que esta cuenta de servicio acceda a la clave de API de Datadog en Secret Manager. + +[Administración de objetos de almacenamiento][424] +: `roles/storage.objectAdmin`
Permite que esta cuenta de servicio lea y escriba en el bucket de Cloud Storage especificado para los archivos de staging. + +**Nota**: Si no creas una cuenta de servicio personalizada para los workers de pipelines de Dataflow, asegúrate de que la cuenta de servicio predeterminada de Compute Engine tenga los permisos requeridos anteriores. + +#### 3. Exportar logs desde un tema Google Cloud Pub/Sub + +1. Ve a la [página del Logs Explorer][425] en la consola de Google Cloud. +2. En la pestaña de **Log Router** (Enrutador de logs), selecciona **Create Sink** (Crear sumidero de datos). +3. Indica un nombre para el sumidero de datos. +4. Elige _Cloud Pub/Sub_ como destino y selecciona el tema Cloud Pub/Sub creado para tal fin. **Nota**: El tema Cloud Pub/Sub puede encontrarse en un proyecto diferente. + {{< img src="integrations/google_cloud_pubsub/creating_sink2.png" alt="Exportar logs de Google Cloud Pub/Sub a Pub Sub" >}} +5. Elige los logs que quieres incluir en el sumidero con un filtro opcional de inclusión o exclusión. Puedes filtrar los logs con una consulta de búsqueda o utilizar la [función de muestreo][426]. Por ejemplo, para incluir sólo el 10% de los logs con un nivel de `severity` de `ERROR`, crea un filtro de inclusión con `severity="ERROR" AND sample(insertId, 0.1)`. + {{< img src="integrations/google_cloud_platform/sink_inclusion_filter_2.png" alt="Filtro de inclusión de un sumidero de generación de logs de Google Cloud con una consulta de gravedad=ERROR y muestra(insertId, 0.1)" >}} +6. Haz clic en **Create Sink** (Crear sink). + +**Nota**: Es posible crear varias exportaciones desde Google Cloud Logging al mismo tema Cloud Pub/Sub con diferentes sumideros. + +#### 4. Crear y ejecutar el trabajo de Dataflow + +1. Ve a la página [Crear trabajo a partir de una plantilla][427] en la consola de Google Cloud. +2. Asigna un nombre al trabajo y selecciona un endpoint regional de Dataflow. +3. Selecciona `Pub/Sub to Datadog` en el desplegable **Plantilla de Dataflow**. Aparecerá la sección **Parámetros requeridos**. + 1. Selecciona la suscripción de entrada en el desplegable **Pub/Sub input subscription** (Suscripción de entrada Pub/Sub). + 1. Introduce lo siguiente en el campo **Datadog Logs API URL** (URL de la API de logs de Datadog): + 
https://{{< region-param key="http_endpoint" code="true" >}}
+ + **Nota**: Asegúrate de que el selector de sitios de Datadog a la derecha de la página está configurado con tu [sitio Datadog][428] antes de copiar la URL de arriba. + + 1. Selecciona el tema creado para recibir fallos de mensajes en el desplegable **Output deadletter Pub/Sub topic** (Tema de salida Pub/Sub sin entregar). + 1. Especifica una ruta para los archivos temporales en tu bucket de almacenamiento en el campo **Temporary location** (Ubicación temporal). + + {{< img src="integrations/google_cloud_platform/dataflow_parameters.png" alt="Parámetros requeridos en la plantilla de Datadog Dataflow" style="width:80%;">}} + +4. En **Parámetros opcionales**, marca `Include full Pub/Sub message in the payload`. + +5. Si creaste un secreto en Secret Manager con el valor de tu clave de API Datadog, como se menciona en el [paso 1](#1-create-a-cloud-pubsub-topic-and-subscription), introduce el **nombre de recurso** del secreto en el campo **ID de Google Cloud Secret Manager**. + + {{< img src="integrations/google_cloud_platform/dataflow_template_optional_parameters.png" alt="Parámetros opcionales en la plantilla de Datadog Dataflow con los campos ID de Google Cloud Secret Manager y Fuente de la clave de API pasada, resaltados" style="width:80%;">}} + + Consulta [Parámetros de plantilla][412] en la plantilla de Dataflow para obtener información detallada sobre el uso de las demás opciones disponibles: + + - `apiKeySource=KMS` con `apiKeyKMSEncryptionKey` configurada con tu ID de clave de [Cloud KMS][429] y `apiKey`, configurada con la clave de API cifrada. + - **No recomendado**: `apiKeySource=PLAINTEXT` con `apiKey` configurada con la clave de API en texto sin formato. + +6. Si creaste una cuenta de servicio de worker personalizada, selecciónala en el desplegable **Correo electrónico de cuenta de servicio**. + + {{< img src="integrations/google_cloud_platform/dataflow_template_service_account.png" alt="Parámetros opcionales en la plantilla de Datadog Dataflow con el correo electrónico de la cuenta de servicio resaltado" style="width:80%;">}} + +7. Haz clic en **RUN JOB** (Ejecutar trabajo). + +**Nota**: Si tienes una VPC compartida, consulta la página [Especificar una red y subred][430] en la documentación de Dataflow para obtener directrices sobre cómo especificar los parámetros `Network` y `Subnetwork`. + +[400]: https://cloud.google.com/dataflow/docs/guides/templates/provided/pubsub-to-datadog +[401]: https://cloud.google.com/pubsub/docs/create-topic +[402]: https://cloud.google.com/pubsub/docs/create-subscription +[403]: https://cloud.google.com/iam/docs/using-iam-securely#least_privilege +[404]: https://cloud.google.com/logging/docs/export/configure_export_v2#creating_sink +[405]: https://cloud.google.com/logging/docs/view/logging-query-language +[406]: https://cloud.google.com/architecture/partners/stream-cloud-logs-to-datadog +[407]: https://cloud.google.com/apis/docs/getting-started#enabling_apis +[408]: https://docs.datadoghq.com/es/agent/ +[409]: https://console.cloud.google.com/cloudpubsub/topicList +[410]: https://console.cloud.google.com/cloudpubsub/subscription/ +[411]: https://cloud.google.com/dataflow/docs/concepts/streaming-with-cloud-pubsub#unsupported-features +[412]: https://cloud.google.com/dataflow/docs/guides/templates/provided/pubsub-to-datadog#template-parameters +[413]: https://cloud.google.com/dataflow/docs/guides/templates/provided/pubsub-to-pubsub +[414]: https://console.cloud.google.com/security/secret-manager +[415]: https://cloud.google.com/pubsub/quotas#quotas +[416]: https://cloud.google.com/compute/docs/access/service-accounts#default_service_account +[417]: https://console.cloud.google.com/iam-admin/serviceaccounts +[418]: https://cloud.google.com/dataflow/docs/concepts/access-control#dataflow.admin +[419]: https://cloud.google.com/dataflow/docs/concepts/access-control#dataflow.worker +[420]: https://cloud.google.com/pubsub/docs/access-control#pubsub.viewer +[421]: https://cloud.google.com/pubsub/docs/access-control#pubsub.subscriber +[422]: https://cloud.google.com/pubsub/docs/access-control#pubsub.publisher +[423]: https://cloud.google.com/secret-manager/docs/access-control#secretmanager.secretAccessor +[424]: https://cloud.google.com/storage/docs/access-control/iam-roles/ +[425]: https://console.cloud.google.com/logs/viewer +[426]: https://cloud.google.com/logging/docs/view/logging-query-language#sample +[427]: https://console.cloud.google.com/dataflow/createjob +[428]: https://docs.datadoghq.com/es/getting_started/site/ +[429]: https://cloud.google.com/kms/docs +[430]: https://cloud.google.com/dataflow/docs/guides/specifying-networks#shared +{{% /collapse-content %}} + +{{% collapse-content title="Suscripción Pub/Sub Push (legacy)" level="h4" id="pub-sub-push-logging-setup" %}} +La recopilación de logs de Google Cloud con una suscripción Pub/Sub Push pronto estará **obsoleta**. + +La documentación anterior de la suscripción **Push** sólo se mantiene para solucionar problemas o modificar configuraciones legacy. + +Datadog recomienda utilizar una suscripción **Pull** con la plantilla de Datadog Dataflow, tal y como se describe en las secciones de configuración [Inicio rápido](#quick-start-log-setup) y [Terraform](#terraform-log-setup). +{{% /collapse-content %}} + +Consulta la guía [Transmitir logs desde Google Cloud a Datadog][1] en el Centro de arquitectura de Google Cloud para obtener una explicación más detallada de los pasos y la arquitectura implicados en el reenvío de logs. Para profundizar en las ventajas de la plantilla Pub/Sub a Datadog, consulta [Transmitir tus logs desde Google Cloud a Datadog con Dataflow][2] en el blog de Datadog. + +## Validación + +Los nuevos eventos de generación de logs enviados al tema Cloud Pub/Sub aparecen en el [Datadog Log Explorer][8]. + +**Nota**: Puedes utilizar la [Calculadora de precios de Google Cloud][9] para calcular los posibles costes. + +## Monitorizar el reenvío de logs de Cloud Pub/Sub + +La [integración de Google Cloud Pub/Sub][10] proporciona métricas útiles para monitorizar el estado del reenvío de logs: + + - `gcp.pubsub.subscription.num_undelivered_messages` para el número de mensajes pendientes de entrega + - `gcp.pubsub.subscription.oldest_unacked_message_age` para la antigüedad del mensaje no confirmado más antiguo de una suscripción + +Utiliza las métricas anteriores con un [monitor de métricas][11] para recibir alertas de los mensajes de tus suscripciones de entrada y salida. + +## Monitorizar el pipeline de Dataflow + +Utiliza la [integración de Google Cloud Dataflow][12] de Datadog para monitorizar todos los aspectos de tus pipelines de Dataflow. Puedes ver todas tus métricas claves de Dataflow en el dashboard predefinido, enriquecido con datos contextuales, como información sobre las instancias GCE que ejecutan tus cargas de trabajo de Dataflow y el rendimiento de tu Pub/Sub. + +También puedes utilizar un [monitor recomendado][13] preconfigurado para definir notificaciones sobre aumentos en el tiempo de backlog de tu pipeline. Para obtener más información, consulta [Monitorizar tus pipelines de Dataflow con Datadog][14] en el blog de Datadog. + +## Referencias adicionales + +{{< partial name="whats-next/whats-next.html" >}} + +[1]: https://cloud.google.com/architecture/partners/stream-cloud-logs-to-datadog +[2]: https://www.datadoghq.com/blog/stream-logs-datadog-dataflow-template/ +[3]: https://cloud.google.com/dataflow/docs/guides/templates/provided/pubsub-to-datadog +[4]: https://cloud.google.com/dataflow +[5]: /es/monitors/types/log/ +[6]: /es/security/cloud_siem/ +[7]: /es/watchdog/ +[8]: https://app.datadoghq.com/logs +[9]: https://cloud.google.com/products/calculator +[10]: /es/integrations/google-cloud-pubsub/ +[11]: /es/monitors/types/metric/ +[12]: /es/integrations/google-cloud-dataflow/ +[13]: https://www.datadoghq.com/blog/datadog-recommended-monitors/ +[14]: https://www.datadoghq.com/blog/monitor-dataflow-pipelines-with-datadog/ \ No newline at end of file diff --git a/content/es/logs/guide/google-cloud-logging-recommendations.md b/content/es/logs/guide/google-cloud-logging-recommendations.md new file mode 100644 index 00000000000..ff903c96698 --- /dev/null +++ b/content/es/logs/guide/google-cloud-logging-recommendations.md @@ -0,0 +1,97 @@ +--- +further_reading: +- link: /logs/explorer/ + tag: Documentación + text: Aprender a explorar tus logs +title: Recomendaciones para la configuración del reenvío de logs de Google Cloud +--- + +{{< jqmath-vanilla >}} + +## Información general + +En esta guía se recomiendan parámetros de configuración para el reenvío de logs a través de la integración con Google Cloud. + +## Recomendaciones de configuración + +### Tipo de máquina + +Configura `--worker-machine-type` como `n2-standard-4` para obtener la mejor relación rendimiento-coste. Este tipo de worker admite alrededor de 12.000 EPS. + +### Recuento de máquinas + +El autoescalado de Dataflow ajusta el número de workers en función de la carga. Puedes configurar `--max-workers` para limitar el número de workers necesarios para los picos de EPS, lo que puede ayudar a evitar el exceso de aprovisionamiento. + +El almacenamiento de máquinas de workers se aprovisiona estáticamente: + +Un pipeline de autoescalado aprovisiona un disco persistente para cada worker de transmisión potencial. El tamaño de disco por defecto es de 400 GB. `--max-workers` define el máximo y los discos se instalan en los workers que se están ejecutando, incluso al inicio. + +Cada worker puede adjuntar hasta 15 discos persistentes, por lo que el mínimo de workers iniciales es ⌈--max-workers/15⌉. Por ejemplo, con `--max-workers=25`: + +- El almacenamiento se fija en 25 discos persistentes (10 TB en total). +- Calcula escalas desde un mínimo de 2 workers (⌈25/15⌉) hasta 20. +Los grandes discos no utilizados pueden añadir costes si solo unos pocos workers trabajan la mayor parte del tiempo. + +Para dimensionar tus workers, sigue estos pasos: + +1. Calcula el promedio de eventos por segundo (EPS) con la siguiente fórmula: + +$$(\text"Average EPS" ≃ {\text"Daily log volume (Terabytes)"} / {\text"Average message size (Kilobytes)"} × 10^9 / {24 × 3600})$$ + +Ejemplo: 1 TB al día y mensajes de 1 KB da alrededor de 11,500 EPS. + +2. Calcula el pico sostenido de EPS con la siguiente fórmula, en la que el multiplicador N representa la naturaleza impredecible del volumen de generación de logs: + +$$(\text"Peak EPS" = N × \text"Average EPS")$$ + +Ejemplo: Con N=2 y 11,500 de EPS medio, el pico de EPS es de alrededor de 23.000. + +3. Calcula el número máximo necesario de vCPU con la siguiente fórmula: + +$$(\text"Max vCPU" = ⌈{\text"Peak EPS"} / 3000⌉)$$ + +Ejemplo: 23.000 EPS pico ⇒ ⌈23/3⌉ = 8 núcleos vCPU. + +**Nota**: Una sola vCPU en el pipeline de Datadog Dataflow procesa típicamente alrededor de 3000 EPS (asumiendo que no hay límites de baja tasa). Un worker de `n2-standard-4` (4 vCPU) maneja hasta unos 12.000 EPS. + +4. Calcule el número máximo de workers de Dataflow con la siguiente fórmula: + +$$(\text"Max workers" = ⌈{\text"Max vCPU"} / 4⌉)$$ + +Ejemplo: 8 vCPU y 4 vCPU por worker ⇒ 2 workers. + +En este ejemplo, `--max-workers` se configura en `2`. Utiliza tus propios valores para el dimensionamiento de la producción. + +### Paralelismo + +Configura el parámetro `parallelism` al doble del total de vCPU a través del número máximo de workers en la plantilla Pub/Sub a Datadog Dataflow. + +Esto maximiza las conexiones paralelas al endpoint de logs de Datadog y aumenta el EPS. + +El valor por defecto `1` desactiva el paralelismo y limita el rendimiento. Anúlalo para obtener de dos a cuatro conexiones por vCPU con el máximo de workers. Como orientación, multiplica el número máximo de workers por vCPU por worker y, a continuación, duplica el resultado. + +Para determinar el número total de conexiones paralelas a Datadog a través de todos los workers de Dataflow, utiliza la siguiente fórmula: + +$$(\text"Parallelism" = {\text"Max vCPU"} × 2)$$ + +Ejemplo: 4 vCPU ⇒ 4 × 2 = 8. + +Para este ejemplo, deberías configurar el parámetro de paralelismo en un valor de `8` basándote en el cálculo del ejemplo anterior. Sin embargo, recuerda utilizar tus propios valores y cálculos exclusivos cuando despliegues esta arquitectura de referencia en tu entorno. + +### Recuento de lotes + +Configura el parámetro `batchCount` en 10-50 eventos por solicitud para enviar lotes en lugar de eventos individuales a Datadog. + +La agrupación por lotes aumenta los EPS y reduce la carga en el endpoint de logs de Datadog. Si tu caso de uso puede tolerar un retraso máximo de almacenamiento en buffer de dos segundos, utiliza 10-50 eventos por solicitud. + +$$(\text"batchCount" ≥ 10)$$ + +En este ejemplo con mensajes de 1 KB, agrupa al menos 10 eventos por solicitud. Ajusta este valor en función de tu entorno. + +Para ver más detalles sobre rendimiento y optimización de costes, consulta [Planificar tu pipeline de Datadog][1]. + +## Referencias adicionales + +{{< partial name="whats-next/whats-next.html" >}} + +[1]: https://docs.cloud.google.com/dataflow/docs/guides/plan-pipelines \ No newline at end of file diff --git a/content/es/real_user_monitoring/application_monitoring/react_native/setup/expo.md b/content/es/real_user_monitoring/application_monitoring/react_native/setup/expo.md new file mode 100644 index 00000000000..1aa9455c3ff --- /dev/null +++ b/content/es/real_user_monitoring/application_monitoring/react_native/setup/expo.md @@ -0,0 +1,494 @@ +--- +aliases: +- /es/real_user_monitoring/reactnative/expo/ +- /es/real_user_monitoring/reactnative-expo/ +- /es/real_user_monitoring/mobile_and_tv_monitoring/setup/expo +- /es/real_user_monitoring/mobile_and_tv_monitoring/expo/setup +code_lang: expo +code_lang_weight: 2 +description: Monitoriza tus proyectos de React Native utilizando Expo y Expo Go con + Datadog. +further_reading: +- link: /real_user_monitoring/application_monitoring/react_native/advanced_configuration + tag: Documentación + text: Configuración avanzada de RUM React Native +- link: https://github.com/DataDog/dd-sdk-reactnative + tag: Código fuente + text: Código fuente de dd-sdk-reactnative +- link: https://www.datadoghq.com/blog/react-native-monitoring/ + tag: Blog + text: Monitorizar aplicaciones React Native +- link: real_user_monitoring/explorer/ + tag: Documentación + text: Aprender a explorar tus datos de RUM +title: Expo Setup +type: multi-code-lang +--- + +## Información general + +Esta página describe cómo instrumentar tus aplicaciones Expo para [Real User Monitoring (RUM)][1] con el kit de desarrollo de software (SDK) de React Native. RUM incluye capacidades de Error Tracking para informes de fallos y análisis de errores. + +**Nota:** Si has adquirido Error Tracking como producto independiente (sin RUM), consulta en su lugar la [documentación de configuración de Error Tracking Expo][2]. + +El SDK de React Native de RUM es compatible con Expo y Expo Go. Para utilizarlo, instala `expo-datadog` y `@datadog/mobile-react-native`. + +`expo-datadog` es compatible con Expo a partir del SDK 45 y las versiones del complemento siguen las versiones de Expo. Por ejemplo, si utilizas Expo SDK 45, utiliza `expo-datadog` versión `45.x.x`. Datadog recomienda utilizar **Expo SDK 45** como versión mínima; las versiones anteriores pueden requerir pasos manuales. + +Si tienes algún problema al configurar el kit de desarrollo de software (SDK) de Datadog con una aplicación Expo, puedes consultar nuestra [aplicación de ejemplo][3] como referencia. + +## Configuración + +Para instalar con NPM, ejecuta: + +```sh +npm install expo-datadog @datadog/mobile-react-native +``` + +Para instalar con Yarn, ejecuta: + +```sh +yarn add expo-datadog @datadog/mobile-react-native +``` + +### Rastrear la navegación de la vista + +Para ver cómo las sesiones de RUM se rellenan en Datadog, es necesario implementar el rastreo de la vista, que se puede inicializar de forma manual o automática. + +#### Rastreo manual + +Puedes iniciar y detener manualmente una vista utilizando los siguientes métodos `startView()` y `stopView()`. + +```js +import { + DdRum +} from 'expo-datadog'; + +// Start a view with a unique view identifier, a custom view name, and an object to attach additional attributes to the view +DdRum.startView( + '', // has to be unique, for example it can be ViewName-unique-id + 'View Name', + { 'custom.foo': 'something' }, + Date.now() +); +// Stops a previously started view with the same unique view identifier, and an object to attach additional attributes to the view +DdRum.stopView('', { 'custom.bar': 42 }, Date.now()); +``` + +### Rastreo automático + +El rastreo automático de vistas es compatible con los siguientes módulos: + +- React Navigation: [@Datadog/mobile-react-navigation][10] +- React Native Navigation: [@Datadog/mobile-react-native-navigation][11] + +En este proyecto de ejemplo de Datadog, el rastreo de la vista se consigue a través de `@datadog/mobile-react-navigation` y se configura utilizando el `NavigationContainer`: + +```tsx + { + DdRumReactNavigationTracking.startTrackingViews( + navigationRef.current, + ); + }}> +``` + +## Utilización + +### Inicializar la biblioteca con el contexto de la aplicación + +Añade el siguiente fragmento de código a tu archivo de inicialización: + +```js +import { + SdkVerbosity, + DatadogProvider, + DatadogProviderConfiguration, + RumConfiguration, + LogsConfiguration, + TraceConfiguration +} from 'expo-datadog'; + +import { DatadogProviderConfiguration } from '@datadog/mobile-react-native'; + +const config = new DatadogProviderConfiguration( + '', + '', + // Optional: Configure the Datadog Site to target. Default is 'US1'. + site: 'US1', + // Optional: Set the reported service name (by default, it uses the package name or bundleIdentifier of your Android or iOS app respectively) + service: 'com.example.reactnative', + // Optional: Let the SDK print internal logs above or equal to the provided level. Default is undefined (meaning no logs) + verbosity: SdkVerbosity.WARN, + // Enable RUM + rumConfiguration: { + // Required: RUM Application ID + applicationId: '', + // Track user interactions (set to false if using Error Tracking only) + trackInteractions: true, + // Track XHR resources (set to false if using Error Tracking only) + trackResources: true, + // Track errors + trackErrors: true, + // Optional: Sample sessions, for example: 80% of sessions are sent to Datadog. Default is 100%. + sessionSampleRate: 80, + // Optional: Enable or disable native crash reports. + nativeCrashReportEnabled: true, + // Optional: Sample tracing integrations for network calls between your app and your backend + // (in this example, 80% of calls to your instrumented backend are linked from the RUM view to + // the APM view. Default is 20%). + // You need to specify the hosts of your backends to enable tracing with these backends + resourceTraceSampleRate: 80, + firstPartyHosts: [ + { + match: 'example.com', + propagatorTypes: [ + PropagatorType.DATADOG, + PropagatorType.TRACECONTEXT + ] + } + ] + }, + // Enable Logs with default configuration + logsConfiguration: {}, + // Enable Trace with default configuration + traceConfiguration: {} +); + +// Wrap the content of your App component in a DatadogProvider component, passing it your configuration: +export default function App() { + return ( + + + + ); +} + +// Once the Datadog React Native SDK for RUM is initialized, you need to setup view tracking to be able to see data in a dashboard +``` + +#### Ejemplo de tarifas de las sesiones + +Para controlar los datos que tu aplicación envía a Datadog RUM, puedes especificar una tasa de muestreo para las sesiones de RUM mientras [inicializas el kit de desarrollo de software (SDK) de Expo][4]. Para configurar esta tasa, utiliza el parámetro `config.sessionSamplingRate` y especifica un porcentaje entre 0 y 100. + +### Cargar mapas fuente en las compilaciones de EAS + +Para activar la notificación de fallos y la simbología de errores, añade `expo-datadog` a tus complementos en el archivo `app.json`: + +```json +{ + "expo": { + "plugins": ["expo-datadog"] + } +} +``` + +Este complemento se encarga de cargar los dSYM, los mapas fuente y los archivos de asignación de Proguard en cada compilación de EAS. + +Añade `@datadog/datadog-ci` como dependencia de desarrollo. Este paquete contiene scripts para cargar los mapas fuente. Puedes instalarlo con NPM: + +```sh +npm install @datadog/datadog-ci --save-dev +``` + +o con Yarn: + +```sh +yarn add -D @datadog/datadog-ci +``` + +Ejecuta `eas secret:create` para configurar `DATADOG_API_KEY` en tu clave de la API de Datadog y `DATADOG_SITE` en el host de tu sitio Datadog (por ejemplo, `datadoghq.com`). + +#### Configura los mapas fuente para una simbología precisa + +**Opción A: Utilizar el complemento de Datadog Metro (recomendado)** + +Partiendo de `@datadog/mobile-react-native@2.10.0` y `@datadog/datadog-ci@v3.13.0`, añade el complemento de Datadog Metro a tu `metro.config.js`: + +```js +const { getDatadogExpoConfig } = require("@datadog/mobile-react-native/metro"); +const config = getDatadogExpoConfig(__dirname); +module.exports = config; +``` + +**Opción B: Inyección manual de ID de depuración** + +Alternativamente, utiliza el comando `datadog-ci react-native inject-debug-id` para adjuntar manualmente un ID de depuración único a tu paquete de aplicaciones y mapa fuente. Consulta la [documentación del comando][5] para obtener instrucciones de uso. + +#### Añadir datos del repositorio git (solo EAS) + +Si utilizas EAS para crear tu aplicación Expo, establece `cli.requireCommit` en `true` en tu archivo `eas.json` para añadir los datos del repositorio git a tus archivos de asignación: + +```json +{ + "cli": { + "requireCommit": true + } +} +``` + +## Rastrear pantallas de Expo Router + +Si utilizas [Expo Router][6], rastrea tus pantallas en tu archivo `app/_layout.js`: + +```javascript +import { useEffect } from 'react'; +import { usePathname, useSearchParams, useSegments, Slot } from 'expo-router'; + +export default function Layout() { + const pathname = usePathname(); + const segments = useSegments(); + const viewKey = segments.join('/'); + + useEffect(() => { + DdRum.startView(viewKey, pathname); + }, [viewKey, pathname]); + + // Export all the children routes in the most basic way. + return ; +} +``` + +## Expo Go + +Si estás utilizando Expo Go, cambia a las compilaciones de desarrollo (recomendado) o sigue utilizando Expo Go sin Datadog, mientras lo ejecutas en tu aplicación independiente (no recomendado). + +### Cambia de Expo Go a las compilaciones de desarrollo + +Las [compilaciones de desarrollo][7] de tu aplicación son compilaciones de depuración que contienen el paquete `expo-dev-client`. + +1. Activa el [código nativo personalizado para ejecutar][8] con `expo run:android` y `expo run:ios`. +2. Para empezar a utilizar tu aplicación de desarrollo, ejecuta `expo install expo-dev-client` y `expo start --dev-client`. Se instala y se inicia el [paquete `expo-dev-client`][9] para ejecutar el código nativo añadido en el modo de desarrollador. + +### Desarrollar con Expo Go + +Cuando tu aplicación se ejecuta dentro de Expo Go, no puedes añadir ningún código nativo personalizado que no forme parte de la aplicación Expo Go. Dado que el kit de desarrollo de software (SDK) de React Native depende de cierto código nativo personalizado para ejecutarse, puedes desarrollar tu aplicación dentro de Expo Go sin Datadog y utilizar Datadog en tus compilaciones independientes. + +Tu aplicación se bloquea en Expo Go cuando se llama a algún código nativo (que no está incluido). Para utilizar Datadog con tu aplicación independiente y seguir utilizando Expo Go en el desarrollo, añade el siguiente archivo TypeScript a tu proyecto: + +```typescript +// mockDatadog.ts +// Datadog does not recommend this approach, consider moving to Expo development builds instead. +// This file is not officially maintained and might not be up-to-date with new releases. + +import { DdLogs, DdTrace, DdRum, DdSdkReactNative } from 'expo-datadog'; + +if (__DEV__) { + const emptyAsyncFunction = () => new Promise(resolve => resolve()); + + DdLogs.debug = emptyAsyncFunction; + DdLogs.info = emptyAsyncFunction; + DdLogs.warn = emptyAsyncFunction; + DdLogs.error = emptyAsyncFunction; + + DdTrace.startSpan = () => + new Promise(resolve => resolve('fakeSpanId')); + DdTrace.finishSpan = emptyAsyncFunction; + DdRum.startView = emptyAsyncFunction; + DdRum.stopView = emptyAsyncFunction; + DdRum.startAction = emptyAsyncFunction; + DdRum.stopAction = emptyAsyncFunction; + DdRum.addAction = emptyAsyncFunction; + DdRum.startResource = emptyAsyncFunction; + DdRum.stopResource = emptyAsyncFunction; + DdRum.addError = emptyAsyncFunction; + DdRum.addTiming = emptyAsyncFunction; + DdRum.getCurrentSessionId = emptyAsyncFunction; + + DdSdkReactNative.initialize = emptyAsyncFunction; + DdSdkReactNative.setUserInfo = emptyAsyncFunction; + DdSdkReactNative.addUserExtraInfo = emptyAsyncFunction; + DdSdkReactNative.clearUserInfo = emptyAsyncFunction; + DdSdkReactNative.removeUserInfo = emptyAsyncFunction; + DdSdkReactNative.addAttributes = emptyAsyncFunction; + DdSdkReactNative.removeAttributes = emptyAsyncFunction; + DdSdkReactNative.addAttribute = emptyAsyncFunction; + DdSdkReactNative.removeAttribute = emptyAsyncFunction; + DdSdkReactNative.setTrackingConsent = emptyAsyncFunction; +} +``` + +A continuación, impórtalo antes de inicializar el SDK de React Native de Datadog: + +```typescript +import './mockDatadog'; +import { CoreConfiguration } from 'expo-datadog'; + +const config = new CoreConfiguration(/* your config */); +DdSdkReactNative.initialize(config); +``` + +### Rastreo de las interacciones de los usuarios + +Datadog recomienda configurar el seguimiento de interacciones mediante el complemento Datadog React Native Babel (`@datadog/mobile-react-native-babel-plugin`). Este complemento enriquece automáticamente los componentes de React con metadatos contextuales, lo que mejora la precisión del seguimiento de interacciones y permite una serie de opciones de configuración. + +#### Instalación + +Para instalar con NPM, ejecuta: + +```sh +npm install @datadog/mobile-react-native-babel-plugin +``` + +Para instalar con Yarn, ejecuta: + +```sh +yarn add @datadog/mobile-react-native-babel-plugin +``` + +#### Configurar Babel + +Añade el complemento a tu archivo de configuración de Babel (`babel.config.js`, `.babelrc` o similar): + +```js +module.exports = { + presets: ["babel-preset-expo"], + plugins: ['@datadog/mobile-react-native-babel-plugin'] +}; +``` + +#### Uso básico + +Una vez instalado y configurado, el complemento rastrea automáticamente las interacciones en los componentes estándar de React Native. No se requieren cambios de código adicionales para el uso básico. + +#### Opciones de configuración + +Puedes personalizar el comportamiento del complemento para adaptarlo a las necesidades de tu aplicación: + +```js +module.exports = { + presets: ["babel-preset-expo"], + plugins: [ + [ + '@datadog/mobile-react-native-babel-plugin', + { + sessionReplay: { + // Enable SVG tracking for Session Replay (default: false) + svgTracking: true + }, + components: { + // Use component content as action name (default: true) + useContent: true, + // Prefix actions with component name (default: true) + useNamePrefix: true, + }, + }, + ], + ], +}; +``` +#### Seguimiento de componentes personalizados + +Para los componentes personalizados, puedes configurar un comportamiento de seguimiento específico: + +```js +module.exports = { + presets: ["babel-preset-expo"], + plugins: [ + [ + '@datadog/mobile-react-native-babel-plugin', + { + components: { + tracked: [ + { + name: 'CustomButton', + // Prop your component uses as content (if available) + // When not set, the plugin tries to find the most likely match + contentProp: 'label', + handlers: [{event: 'onPress', action: 'TAP'}], + }, + { + name: 'CustomInput', + handlers: [{event: 'onFocus', action: 'TAP'}], + }, + ], + }, + }, + ], + ], +}; +``` + +#### Nombres de acción personalizados + +Puedes especificar nombres de acción personalizados para los componentes utilizando la configuración `actionNameAttribute`: + +```js +module.exports = { + presets: ["babel-preset-expo"], + plugins: [ + [ + '@datadog/mobile-react-native-babel-plugin', + { + actionNameAttribute: 'data-dd-action-name', + }, + ], + ], +}; +``` + +A continuación, utilízalo en tus componentes: + +```jsx + +``` + +## Envío de datos cuando el dispositivo está desconectado + +El SDK de React Native garantiza la disponibilidad de los datos cuando el dispositivo del usuario está desconectado. En casos de zonas con bajo alcance de red o cuando la carga de la batería del dispositivo es demasiado baja, todos los eventos se almacenan primero en el dispositivo local en lotes. Se envían apenas la red vuelve a estar disponible y la carga de la batería es lo suficientemente alta como para garantizar que el SDK de React Native no afecte a la experiencia del usuario final. Si la red no está disponible con tu aplicación ejecutándose en primer plano, o si falla una carga de datos, el lote se guarda hasta que pueda enviarse correctamente. + +Esto significa que incluso si los usuarios abren tu aplicación mientras están desconectados, no se pierde ningún dato. + +**Nota**: Los datos del disco se eliminan automáticamente si se vuelven demasiado antiguos, para garantizar que el SDK de React Native no utilice demasiado espacio en disco. + +## Envío de datos cuando el dispositivo está desconectado + +RUM garantiza la disponibilidad de los datos cuando el dispositivo del usuario está desconectado. En el caso de zonas con poca red, o cuando la batería del dispositivo está demasiado baja, todos los eventos se almacenan primero en el dispositivo local por lotes. + +Cada lote sigue la especificación de entrada. Se envían tan pronto como la red está disponible y la batería está lo suficientemente cargada como para garantizar que el SDK de Datadog no afecte la experiencia del usuario final. Si la red no está disponible mientras tu aplicación está en primer plano o si falla una carga de datos, el lote se conserva hasta que se lo pueda enviar con éxito. + +Esto significa que incluso si los usuarios abren tu aplicación mientras están desconectados, no se pierde ningún dato. Para garantizar que el SDK no utilice demasiado espacio de disco, los datos del disco se descartan automáticamente si son demasiado antiguos. + +## Solucionar problemas + +### La aplicación produce muchos recursos de /logs + +Cuando el rastreo de recursos está activado y la verbosidad del kit de desarrollo de software (SDK) está configurada en `DEBUG`, cada recurso activa una llamada de `/logs` al servidor de desarrollo de Expo para imprimir el log, que a su vez crea un nuevo recurso de RUM y crea así un bucle infinito. +Los patrones más comunes de la URL del host del servidor de desarrollo de Expo se filtran con el SDK, por lo tanto, es posible que no te encuentres con este error en la mayoría de las situaciones. +Si se produce este error, añade el siguiente asignador de recursos para filtrar las llamadas: + +```js +import { CoreConfiguration } from 'expo-datadog'; + +import Constants from 'expo-constants'; + +const config = new CoreConfiguration(/* your config */); +config.rumConfiguration.resourceEventMapper = event => { + if ( + event.resourceContext?.responseURL === + `http://${Constants.expoConfig.hostUri}/logs` + ) { + return null; + } + return event; +}; +``` + +## Referencias adicionales + +{{< partial name="whats-next/whats-next.html" >}} + +[1]: /es/real_user_monitoring/ +[2]: /es/error_tracking/frontend/mobile/expo/ +[3]: https://github.com/DataDog/dd-sdk-reactnative-examples/tree/main/rum-expo-react-navigation +[4]: /es/real_user_monitoring/application_monitoring/react_native/setup/expo#initialize-the-library-with-application-context +[5]: /es/real_user_monitoring/error_tracking/mobile/expo/#use-the-datadog-ci-react-native-inject-debug-id-command +[6]: https://expo.github.io/router/docs/ +[7]: https://docs.expo.dev/development/introduction/ +[8]: https://docs.expo.dev/workflow/customizing/#releasing-apps-with-custom-native-code-to +[9]: https://docs.expo.dev/development/getting-started/ +[10]: https://www.npmjs.com/package/@datadog/mobile-react-navigation +[11]: https://www.npmjs.com/package/@datadog/mobile-react-native-navigation \ No newline at end of file diff --git a/content/es/real_user_monitoring/error_tracking/mobile/expo.md b/content/es/real_user_monitoring/error_tracking/mobile/expo.md index 789d9f0dedc..322bb11be82 100644 --- a/content/es/real_user_monitoring/error_tracking/mobile/expo.md +++ b/content/es/real_user_monitoring/error_tracking/mobile/expo.md @@ -68,6 +68,72 @@ Ejecuta `eas secret:create` para definir `DATADOG_SITE` en el host de tu sitio D ## Obtener trazas de stack tecnológico desofuscadas +### Utilizar la configuración de Datadog Expo + +A partir de `@datadog/mobile-react-native@2.10.0` y `@datadog/datadog-ci@v3.13.0`, el kit de desarrollo de software (SDK) exporta un complemento de Datadog Metro, que adjunta un ID de depuración único a tu paquete de aplicaciones y mapa fuente. + +Añádelo a tu `metro.config.js` para permitir una simbolización precisa de los stack traces en Datadog: + +```js +// const { getDefaultConfig } = require("expo/metro-config"); +const { getDatadogExpoConfig } = require("@datadog/mobile-react-native/metro"); +// const config = getDefaultConfig(__dirname); +const config = getDatadogExpoConfig(__dirname); +module.exports = config; +``` + +### Cargar mapas fuente para las actualizaciones de EAS + +Al crear una [actualización de EAS](https://docs.expo.dev/eas-update/introduction/), es necesario cargar los mapas fuente correspondientes en Datadog. De este modo se garantiza la exactitud de Error Tracking y la simbología. + +#### 1. Crear la actualización del EAS + +Ejecuta el comando de actualización como de costumbre: + +``` +eas update --channel [channel-name] --message "[message]" +``` + +Esto genera una carpeta `dist` en la raíz de tu proyecto. + +#### 2. Localizar los mapas fuente + +Dentro de la carpeta `dist`, encuentra los paquetes generados y los mapas fuente: + +* Ejemplo de rutas: + + * `./dist/_expo/static/js/ios` + * `./dist/_expo/static/js/android` + +* Pares de archivos que puedes ver: + + * Hermes: `.hbc` (conjunto) y `.hbc.map` (mapa fuente) + * JSC: `.js` o `.jsbundle` (conjunto) y `*.map` (mapa fuente) + +#### 3. Cargar los mapas fuente + +Asegúrate de tener instalada la última versión de `datadog-ci`. +Para cada plataforma (Android e iOS), carga los símbolos de depuración utilizando: + +``` +npx datadog-ci react-native upload \ + --platform [ios OR android] \ + --service com.example.service \ + --bundle [BUNDLE_FILE] \ + --sourcemap [SOURCEMAP_FILE] \ + --release-version [YOUR_RELEASE_VERSION] \ + --build-version [YOUR_BUILD_VERSION] +``` + +Los mapas fuente incluyen un ID de depuración único generado a partir del contenido del paquete. +Este ID cambia con cada actualización del EAS. Como resultado, **aunque el servicio, la versión y la versión de compilación sigan siendo los mismos, Datadog siempre recibirá una nueva carga de mapa fuente**. + +### Utiliza el comando `datadog-ci react-native inject-debug-id` + +Como alternativa a la configuración de Expo, a partir de `@datadog/mobile-react-native@2.10.0` y `@datadog/datadog-ci@v3.13.0`, puedes utilizar el comando `datadog-ci react-native inject-debug-id` para adjuntar manualmente un ID de depuración único a tu paquete de aplicaciones y mapa fuente. + +Las instrucciones de uso están disponibles en la [página de documentación del comando][5]. + ### Añade los datos del repositorio Git a tus archivos de asignación en Expo Application Services (EAS) Si estás utilizando EAS para crear tu aplicación Expo, configura `cli.requireCommit` como `true` en tu archivo `eas.json` para añadir los datos del repositorio Git a tus archivos de asignación. @@ -79,21 +145,19 @@ Si estás utilizando EAS para crear tu aplicación Expo, configura `cli.requireC } } ``` +### Lista de los mapas fuente cargados + +Consulta la página [Símbolos de depuración RUM][4] para ver todos los símbolos cargados. ## Limitaciones -{{< site-region region="us,us3,us5,eu,gov" >}} -Los mapas de origen, los archivos de asignación y los archivos dSYM tienen un límite de **500** MB cada uno. -{{< /site-region >}} -{{< site-region region="ap1" >}} -Los mapas de origen, los archivos de asignación y los archivos dSYM tienen un límite de **500** MB cada uno. -{{< /site-region >}} +El tamaño de los mapas fuente y los archivos de mapas está limitado a **500 MB** cada uno, mientras que los archivos dSYM pueden llegar a **2 GB** cada uno. ## Para probar tu implementación Para verificar la configuración de las notificaciones de fallos y el seguimiento de errores de Expo, necesitas generar un error en tu aplicación y confirmar que el error aparece en Datadog. -Para probar tu aplicación: +Para probar tu implementación 1. Ejecuta tu aplicación en un simulador, emulador o dispositivo real. Si estás ejecutando en iOS, asegúrate de que el depurador no está conectado. De lo contrario, Xcode captura el fallo antes de que lo haga el SDK de Datadog. 2. Ejecuta código que contenga un error o fallo. Por ejemplo: @@ -107,7 +171,7 @@ Para probar tu aplicación: 3. Para los informes de error ofuscados que no provocan un fallo, puedes verificar la simbolización y la desofuscación en [**Rastreo de errores**][1]. 4. Para los fallos, después de que se produzcan, reinicia tu aplicación y espera a que el SDK de React Native cargue el informe del fallo en [**Rastreo de errores**][1]. -Para asegurarte de que tus mapas de origen se envían y vinculan correctamente con tu aplicación, también puedes generar fallos con el paquete [`react-native-performance-limiter`][14]. +Para asegurarte de que tus mapas fuente se envían y enlazan correctamente con tu aplicación, también puedes generar fallos con el paquete [`react-native-performance-limiter`][14]. Instálalo con yarn o npm y luego vuelve a instalar tus pods: @@ -126,7 +190,7 @@ const crashApp = () => { }; ``` -Vuelve a crear tu aplicación para que envíe los nuevos mapas de origen, activa el fallo y espera a que aparezca el error en la página [Rastreo de errores][1]. +Vuelve a compilar tu aplicación para la versión para enviar los nuevos mapas fuente, desencadenar el fallo y esperar en la página [Error Tracking][1] que aparezca el error. ``` ## Opciones de configuración adicionales @@ -157,7 +221,7 @@ Si quieres deshabilitar **cualquier carga de archivos**, elimina `expo-datadog` ### Uso de Expo con Datadog y Sentry -Los complementos de configuración de Datadog y Sentry utilizan expresiones regulares para modificar la fase de compilación de iOS "Empaquetar código e imágenes React Native" para enviar el mapa de origen. Esto puede hacer que las compilaciones de EAS fallen con un error `error: Found argument 'datadog-ci' which wasn't expected, or isn't valid in this context`. +Los complementos de configuración de Datadog y Sentry utilizan expresiones regulares para modificar la fase de compilación de iOS "Empaquetar código e imágenes React Native" para enviar el mapa fuente. Esto puede hacer que las compilaciones de EAS fallen con un error `error: Found argument 'datadog-ci' which wasn't expected, or isn't valid in this context`. Para utilizar ambos complementos, asegúrate de añadir el complemento `expo-datadog` primero en orden en tu archivo `app.json`: @@ -176,4 +240,6 @@ Si estás utilizando `expo-dev-client` y ya tienes el complemento `expo-datadog` [1]: https://app.datadoghq.com/rum/error-tracking [2]: https://github.com/DataDog/expo-datadog -[3]: /es/real_user_monitoring/mobile_and_tv_monitoring/setup/expo/#usage \ No newline at end of file +[3]: /es/real_user_monitoring/application_monitoring/react_native/setup/expo/#usage +[4]: https://app.datadoghq.com/source-code/setup/rum +[5]: https://github.com/DataDog/datadog-ci/blob/master/packages/datadog-ci/src/commands/react-native/README.md#inject-debug-id \ No newline at end of file diff --git a/content/es/security/application_security/setup/compatibility/gcp-service-extensions.md b/content/es/security/application_security/setup/compatibility/gcp-service-extensions.md new file mode 100644 index 00000000000..b6a8b750cf7 --- /dev/null +++ b/content/es/security/application_security/setup/compatibility/gcp-service-extensions.md @@ -0,0 +1,39 @@ +--- +aliases: +- /es/security/application_security/threats/setup/compatibility/gcp-service-extensions +code_lang: gcp-service-extensions +code_lang_weight: 40 +title: Requisitos de compatibilidad de las extensiones de servicio GCP de App and + API Protection +type: lenguaje de código múltiple +--- + +En la siguiente tabla se enumeran las capacidades de App and API Protection para las extensiones de servicio GCP según la versión de imagen de llamada de extensiones de servicio de Datadog especificada: + +| Función de protección de las aplicaciones y las API | Versión mínima de la imagen de llamada de las extensiones de servicio de App and API Protection | +|------------------------------------------|--------------------------------------------------------------------------| +| Detección de amenazas | 1.71.0 | +| Protección frente a amenazas | 1.71.0 | +| Personalizar la respuesta a las solicitudes bloqueadas | 1.71.0 | +| Seguridad de la API | v2.2.2 | +| App and API Protection independiente | v2.2.2 | +| Rastreo automático de los eventos de actividad de los usuarios | no compatible | + +Consulta las [limitaciones][1] de la integración de las extensiones de servicio GCP de App and API Protection. + +### Soporte para el procesamiento del cuerpo + +La llamada a extensiones de servicio de Datadog admite el procesamiento de cuerpos de solicitud y respuesta para los siguientes tipos de carga útil: + +| Tipo de carga útil | Versión mínima de la imagen de llamada de las extensiones de servicio de App and API Protection | +|--------------|--------------------------------------------------------------------------| +| JSON | v2.2.2 | + +## Compatibilidad con extensiones de servicio GCP de App and API Protection + +
Las extensiones de servicio GCP de App and API Protection están en vista previa.
+ +
Si quieres que agreguemos la compatibilidad para alguna función que aún no es compatible, háznoslo saber. Rellena este breve formulario para enviarnos tu información.
+ +[1]: /es/security/application_security/setup/gcp/service-extensions \ No newline at end of file diff --git a/content/es/security/application_security/setup/kubernetes/gateway-api.md b/content/es/security/application_security/setup/kubernetes/gateway-api.md new file mode 100644 index 00000000000..c1d2a832592 --- /dev/null +++ b/content/es/security/application_security/setup/kubernetes/gateway-api.md @@ -0,0 +1,195 @@ +--- +aliases: +- /es/security/application_security/threats/setup/threat_detection/gateway_api +- /es/security/application_security/threats_detection/gateway_api +- /es/security/application_security/setup/gateway-api +further_reading: +- link: https://github.com/DataDog/dd-trace-go/tree/main/contrib/k8s.io/gateway-api + tag: Código fuente + text: Código fuente de la integración de Gateway API +- link: /security/default_rules/?category=cat-application-security + tag: Documentación + text: Reglas predefinidas de App and API Protection +- link: /security/application_security/troubleshooting + tag: Documentación + text: Solución de problemas de App and API Protection +title: Activación de AAP para Gateway API en Kubernetes +--- + +
+ AAP para Gateway API es experimental. Sigue las instrucciones a continuación para probarla. +
+ +## Información general + +**Datadog AppSec Gateway API Request Mirror** mejora la seguridad de las aplicaciones al aprovechar la funcionalidad **RequestMirror** de las Gateway APIs de Kubernetes para duplicar el tráfico a un endpoint de Datadog App &API Protection. Esto permite la detección y el análisis en tiempo real de posibles ataques a nivel de aplicación, la detección de endpoints de API, etc., todo ello sin afectar al flujo de solicitudes principal. + +## Requisitos previos + +- Un clúster de Kubernetes con [CRDs de Gateway API instalados][9]. +- Un [controlador compatible con el filtro RequestMirror de Gateway API][10]. +- [Go][11] 1.23+ instalado en tu máquina local. + +## Habilitación de la detección de amenazas + +### Instalación + +1. **Despliega el Datadog Agent** en tu clúster de Kubernetes siguiendo la [guía de instalación de Kubernetes][12]. + +2. **Configura el Datadog Agent** para [admitir cargas útiles de AppSec entrantes][13] usando APM como transporte. + +3. **Despliega AppSec Gateway API Request Mirror** en el espacio de nombres de tu elección (por ejemplo, `datadog`) junto con su servicio: + + ```bash + kubectl apply -f https://raw.githubusercontent.com/DataDog/dd-trace-go/refs/heads/main/contrib/k8s.io/gateway-api/cmd/request-mirror/deployment.yml + ``` + +4. **Verifica el despliegue**: + + ```bash + kubectl get pods -l app=request-mirror + ``` + +5. **Parchea tus recursos de Gateway** para permitir el acceso al espacio de nombres con el despliegue: + + ```bash + git clone https://github.com/DataDog/dd-trace-go.git + cd dd-trace-go + go run ./contrib/k8s.io/gateway-api/cmd/patch-gateways + ``` + + Utiliza el indicador `-help` para ver las opciones para personalizar el comportamiento de parcheo. + +6. **Parchea tus recursos HTTPRoute** para redirigir el tráfico al servicio: + + ```bash + go run ./contrib/k8s.io/gateway-api/cmd/patch-httproutes + ``` + + Este comando añade un filtro [RequestMirror][14] a todos los recursos de `HTTPRoute` en todos los espacios de nombres. Utiliza el indicador `-help` para las opciones de configuración. + + **Nota**: La ejecución regular de este comando garantiza que cualquier recurso `HTTPRoute` recién creado incluya automáticamente el filtro `RequestMirror`. Considera añadir el parche resultante a tu pipeline de Continuous Integration Continuous Delivery donde se modifican los recursos `HTTPRoute`. + +{{% appsec-getstarted-2-plusrisk %}} + +{{< img src="/security/application_security/appsec-getstarted-threat-and-vuln_2.mp4" alt="Vídeo que muestra el explorador de señales y detalles y el explorador de vulnerabilidades y detalles." video="true" >}} + +## Configuración + +### Variables de entorno + +El despliegue de Gateway API Request Mirror puede configurarse con las siguientes variables de entorno: + +| Variable de entorno | Valor por defecto | Descripción | +|--------------------------------------|---------------|----------------------------------------------------------------------------------------------------------------------------| +| `DD_REQUEST_MIRROR_LISTEN_ADDR` | `:8080` | Dirección y puerto donde el servicio de réplica de solicitudes escucha las solicitudes de réplica entrantes. | +| `DD_REQUEST_MIRROR_HEALTHCHECK_ADDR` | `:8081` | Dirección y puerto donde se sirve el endpoint de check de estado | + +Configura el Datadog Agent para recibir trazas (traces) de la integración utilizando las siguientes variables de entorno: + +| Variable de entorno | Valor por defecto | Descripción | +|----------------------------------------|---------------|-----------------------------------------------------------------------| +| `DD_AGENT_HOST` | `localhost` | Nombre del host donde se ejecuta el Datadog Agent | +| `DD_TRACE_AGENT_PORT` | `8126` | Puerto del Datadog Agent para la recopilación de trazas | + +### Ejemplo de despliegue + +El despliegue por defecto crea un servicio que escucha en el puerto 8080 para las solicitudes de réplica y expone un endpoint de check de estado en el puerto 8081: + +```yaml +apiVersion: apps/v1 +kind: Deployment +metadata: + name: request-mirror + labels: + app.kubernetes.io/component: request-mirror + app.kubernetes.io/name: datadog +spec: + strategy: + type: RollingUpdate + selector: + matchLabels: + app: request-mirror + template: + metadata: + labels: + app: request-mirror + spec: + containers: + - name: request-mirror + image: ghcr.io/datadog/dd-trace-go/request-mirror:latest + ports: + - containerPort: 8080 + name: http + livenessProbe: + httpGet: + path: / + port: 8081 + readinessProbe: + httpGet: + path: / + port: 8081 + env: + - name: DD_AGENT_HOST + value: "datadog-agent" # Adjust to your Agent service name +--- +apiVersion: v1 +kind: Service +metadata: + name: request-mirror +spec: + selector: + app: request-mirror + ports: + - name: http + port: 8080 + targetPort: 8080 +``` + +## Integración del rastreador de Datadog Go y Gateway API + +
+ La integración de AAP Gateway API se basa en el rastreador de Datadog Go. Sigue el mismo proceso de publicación que el rastreador, y sus imágenes de Docker están etiquetadas con la versión del rastreador correspondiente. +
+ +La integración de Gateway API utiliza el [rastreador de Datadog Go][6] y hereda todas las variables de entorno del rastreador. Puedes encontrar más información en [Configuración de la biblioteca de rastreo de Go][7] y [Configuración de la biblioteca de AAP][8]. + +## Activación del rastreo de APM + +Por defecto, las trazas de réplica de solicitud no habilitarán el producto APM de Datadog. Si deseas utilizar Application & API Protection sin la funcionalidad de rastreo de APM, este es el comportamiento predeterminado. + +Para habilitar el rastreo de APM, establece la variable de entorno `DD_APM_TRACING_ENABLED=true` en el despliegue de la réplica de solicitud. + +Si deseas desactivar explícitamente el rastreo de APM mientras utilizas App and API Protection: + +1. Configura tu despliegue con la variable de entorno `DD_APM_TRACING_ENABLED=false` además de la variable de entorno `DD_APPSEC_ENABLED=true`. +2. Esta configuración reduce la cantidad de datos de APM enviados a Datadog al mínimo requerido por los productos App and API Protection. + +Para más detalles, consulta [App and API Protection independiente][15]. + +## Limitaciones + +La integración de Gateway API tiene las siguientes limitaciones: + +- No puede acceder a las respuestas HTTP +- No se puede aplicar el bloqueo de solicitudes +- Solo se admite json para analizar los cuerpos de las solicitudes HTTP. + +Para un análisis más detallado y otras funciones de AAP, considera la posibilidad de probar otras integraciones de AAP. + +## Referencias adicionales + +{{< partial name="whats-next/whats-next.html" >}} + +[1]: https://app.datadoghq.com/account/settings#agent +[2]: /es/agent/remote_config/?tab=configurationyamlfile#enabling-remote-configuration +[6]: https://github.com/DataDog/dd-trace-go +[7]: /es/tracing/trace_collection/library_config/go/ +[8]: /es/security/application_security/policies/library_configuration/ +[9]: https://gateway-api.sigs.k8s.io/guides/#installing-gateway-api +[10]: https://gateway-api.sigs.k8s.io/implementations +[11]: https://go.dev/doc/install +[12]: /es/containers/kubernetes/installation/ +[13]: /es/tracing/guide/setting_up_apm_with_kubernetes_service/ +[14]: https://gateway-api.sigs.k8s.io/guides/http-request-mirroring/ +[15]: /es/security/application_security/setup/standalone/ \ No newline at end of file diff --git a/content/es/tracing/trace_pipeline/generate_metrics.md b/content/es/tracing/trace_pipeline/generate_metrics.md index 8288830689f..9a05aa3345d 100644 --- a/content/es/tracing/trace_pipeline/generate_metrics.md +++ b/content/es/tracing/trace_pipeline/generate_metrics.md @@ -2,78 +2,93 @@ aliases: - /es/tracing/span_to_metrics/ - /es/tracing/generate_metrics/ -description: Generar métricas personalizadas a partir de tramos (spans) consumidos. +description: Genera métricas personalizadas a partir de tramos ingestados y trazas + completas. further_reading: - link: tracing/trace_pipeline tag: Documentación - text: Personaliza el consumo de trazas (traces) y retén las trazas importantes. + text: Personalizar la ingesta de trazas y retener trazas importantes - link: tracing/trace_search_and_analytics/query_syntax tag: Documentación - text: Utiliza consultas y monitores de Analytics en función de las trazas (traces) - retenidas. + text: Utilizar consultas y monitores de Analytics en función de las trazas retenidas +- link: tracing/trace_explorer/trace_queries + tag: Documentación + text: Utilizar las consultas avanzadas de trazas para crear métricas a partir de + trazas específicas +- link: tracing/metrics/metrics_namespace + tag: Documentación + text: Monitorizar el 100 % del tráfico de tu aplicación con métricas de trazas - link: https://registry.terraform.io/providers/DataDog/datadog/latest/docs/resources/spans_metric tag: Sitio externo text: Crear y administrar métricas en función de tramos con Terraform -title: Generar métricas a partir de tramos +title: Generar métricas personalizadas a partir de tramos y trazas --- {{< img src="tracing/apm_lifecycle/span_based_metrics.png" style="width:100%; background:none; border:none; box-shadow:none;" alt="Métricas en función de tramos" >}} -Generar métricas a partir del 100% de los tramos consumidos, independientemente de si los tramos están indexados por un [filtro de retención][1]. - -Utiliza métricas personalizadas para consultas y comparaciones fijas específicas, mientras creas filtros de retención para permitir consultas e investigaciones arbitrarias de la traza retenida y su gráfica de llamas. +Genera métricas personalizadas a partir de los tramos ingestados para realizar un seguimiento de las tendencias, alimentar dashboards y activar los monitores, incluso para los tramos y las trazas que no se conservan para el análisis completo de la traza. -**Nota sobre facturación:** Las métricas creadas a partir del consumo de tramos se facturan como [Métricas personalizadas][2]. +Las métricas personalizadas se crean a partir de tramos ingestados por Datadog APM, independientemente de si un [filtro de retención][1] indexa esos tramos. Extrae valores numéricos de los tramos (como recuentos, duraciones o etiquetas personalizadas) o trazas (duración de extremo a extremo de la traza) y los almacena como [métricas personalizadas][3] de larga duración con una retención de 15 meses. -Por ejemplo, es posible que desees utilizar métricas personalizadas para visualizar anomalías, crear paneles y monitores y ver las tendencias de cualquier parámetro que sea importante para el contexto de tu negocio. Todas las métricas generadas están disponibles durante 15 meses como [métricas personalizadas][3] de Datadog. +**Notas:** +- Datadog genera automáticamente [Métricas de trazas][13] que capturan recuentos de solicitudes, tasas de error y distribuciones de latencia para el 100 % del tráfico de tu aplicación. +- Los tramos disponibles para la generación de métricas personalizadas dependen de tus [ajustes de control de ingesta de APM][12]. Los tramos eliminados por muestreo o filtrado no pueden generar métricas. -| Motivo | Métricas personalizadas generadas a partir de tramos | Filtros de retención | -| -------------------------------------- | -------------------------------------- | --------------------------------- | -| Período de retención | 15 meses | 15 días | -| Detección de anomalías | Crea un [Monitor de anomalías][4] en función de las métricas generadas. | Utiliza Analytics para comparar el comportamiento de los últimos 15 días y mira las trazas completas para investigar la causa raíz. | -| Investigación de trazas coincidentes con el contexto completo | N/A - Las métricas personalizadas no dan lugar a ninguna retención de trazas asociadas. | Conserva exactamente las trazas relevantes para tu contexto de negocio con los [filtros de retención][1]. | -| Granularidad del comportamiento | Crea métricas personalizadas para endpoints importantes u otros grupos con baja cardinalidad. | Utiliza [Trace Explorer][5] para endpoints específicos o utiliza la opción "Agrupar por" en [Analytics][6]. | -| Pronóstico o matemáticas complejas | Crea un [Monitor de pronóstico][7] en función de las métricas generadas. | N/D | -Para generar métricas a partir de tramos, en la página [Instalación y configuración de APM][8], selecciona la pestaña [Generar métricas][9] y haz clic en el botón **New Metric** (Nueva métrica). +Utiliza métricas personalizadas de tramos para: +- Visibilidad detallada de la latencia a nivel de tramo, las tasas de error o el rendimiento a nivel de etiqueta. +- Alimentación de monitores de [anomalías][4] o [previsiones][7] con métricas de baja latencia y alta resolución. +- Extracción de señales clave para tendencias o alertas sin conservar la totalidad del tramo. -
+#### Cuándo utilizar métricas personalizadas a partir de trazas -{{< img src="tracing/span_to_metrics/GenerateMetrics.png" style="width:100%;" alt="Generar métricas a partir de tramos consumidos" >}} +Datadog permite generar métricas a partir de [consultas de trazas][15]. +Utiliza métricas personalizadas a partir de trazas para: +- Métricas derivadas del contexto completo de la traza, como la duración total de la traza o las operaciones por traza. +- Alerta sobre condiciones que requieren un conocimiento completo de la traza (por ejemplo, detección de consultas N+1 o patrones de fan-out). +- Extracción de señales clave para tendencias o alertas sin conservar la totalidad de la traza. -## Crear una métrica en función del tramo +## Crear una métrica a partir de tramos o trazas {{< img src="tracing/span_to_metrics/createspantometrics.png" style="width:100%;" alt="Cómo crear una métrica" >}} -1. **Define la consulta métrica:** Empieza por añadir una consulta para filtrar el conjunto de datos que necesites. La [sintaxis de la consulta][10] es la misma que en el Buscador de APM y Analytics. - -1. **Define el campo que deseas rastrear:** Selecciona `*` para generar un número de todos los tramos que coincidan con tu consulta o ingresa un atributo (por ejemplo, `@cassandra_row_count`) para agregar un valor numérico y crear su correspondiente número, mínimo, máximo, suma y promedio de métricas agregadas. Si el tipo de atributo es una medida, el valor de la métrica es el valor del atributo del tramo. - - **Nota**: los atributos de tramos que no sean valores numéricos no pueden utilizarse para la agregación. A fin de generar un métrica para contar los valores distintos de un atributo del tramo (por ejemplo, contar el número de ID de usuario que llegan a un endpoint específico), añade esta dimensión al selector `group by` y utiliza la función `count_nonzero` para contar el número de valores de etiquetas (tags). - -1. **Especifica la dimensión agrupar por:** Por defecto, los métricas generadas a partir de tramos no tendrán ninguna etiqueta, a menos que se añada en forma explícita. Cualquier atributo o etiqueta que exista en tus tramos puede utilizarse para crear etiquetas de métricas . +1. Ve a [**APM** > **Generate Metrics**][14] (Generar métricas). +2. Haz clic en **New Metric** (Nueva métrica). +3. Nombra tu métrica siguiendo la [convención de nombres de métricas][11]. No se permiten nombres de métricas que empiecen por `trace.*`. +4. Selecciona el tipo de métrica: **Spans** (Tramos) o **Traces** (Trazas). Ambos utilizan la misma [sintaxis de consulta][10] que APM Search and Analytics. +5. Define la consulta de métrica para filtrar e incluir solo los tramos o trazas que desees medir. +6. Elige el valor a agregar: + - Selecciona `*` para contar todos los tramos o trazas coincidentes. + - Introduce un atributo numérico (por ejemplo, `@cassandra_row_count`) para agregar y realizar un seguimiento del recuento, el mínimo, el máximo, la suma o los percentiles. +7. Establecer dimensiones de agrupación. Por defecto, las métricas no tienen etiquetas a menos que las añadas. Utiliza cualquier atributo o etiqueta de tramo para crear etiquetas de métrica. +8. Obtén una vista previa del resultado para ver el impacto en tiempo real de tu consulta a través de la visualización de datos y la coincidencia de tramos o trazas en la vista previa en directo. +9. Haz clic en **Crear métrica**. -1. **Comprueba la vista previa de Analytics en vivo y Buscar la consulta:** Puedes ver el efecto de tu consulta en tiempo real en la visualización de datos y los tramos coincidentes considerados para tu consulta en una vista previa en vivo. +
Las métricas basadas en tramos se consideran métricas personalizadas y se facturan en consecuencia. Evita agrupar por atributos no limitados o de cardinalidad extremadamente alta, como marcas de tiempo, ID de usuario, ID de solicitud o ID de sesión, para no afectar a tu facturación.
-1. **Nomenclatura de tu métrica:** Los nombres de las métricas deben seguir la [convención de nomenclatura de métricas][11]. Los nombres de las métricas que empiecen con `trace.*` no están permitidos y no se guardarán. -
Las métricas en función de tramos se consideran métricas personalizadas y se facturan en consecuencia. Evita agrupar por atributos no limitados o de cardinalidad extremadamente alta, como marcas de tiempo, ID de usuario, ID de solicitud o ID de sesión para no afectar tu facturación.
- -## Actualizar métricas en función de tramos existentes +## Actualizar las métricas existentes {{< img src="tracing/span_to_metrics/editspantometrics.png" style="width:100%;" alt="Editar una métrica existente" >}} Tras crear una métrica, solo se pueden actualizar dos campos: -| Campo | Motivo | +| Campo | Motivo | |----------------------------------------|-------------------------------------------------------------------------------------------------------------------------| -| Flujo (stream) filtro de consulta | Cambia el conjunto de tramos coincidentes que se agregarán en métricas. | -| Grupos de agregación | Actualiza las etiquetas para administrar la cardinalidad de los métricas generadas. | +| Flujo (stream) filtro de consulta | Cambia el conjunto de tramos coincidentes que se agregarán en métricas. | +| Grupos de agregación | Actualiza las etiquetas para administrar la cardinalidad de los métricas generadas. | **Nota**: Para cambiar el tipo o el nombre de la métrica, crea una nueva métrica y elimina la anterior. -## Leer más + +## Disponibilidad de datos + +Las métricas generadas a partir de las trazas se emiten cuando finaliza una traza. En el caso de las trazas de larga duración, el retraso aumenta en consecuencia (por ejemplo, una métrica de traza de 45 minutos no puede emitirse hasta la finalización de la traza). + +Cuando utilices métricas personalizadas a partir de trazas en monitores, ten en cuenta esta latencia para evitar falsos positivos. + +## Referencias adicionales {{< partial name="whats-next/whats-next.html" >}} @@ -89,3 +104,7 @@ Tras crear una métrica, solo se pueden actualizar dos campos: [9]: https://app.datadoghq.com/apm/traces/generate-metrics [10]: /es/tracing/trace_explorer/query_syntax/ [11]: /es/metrics/#naming-metrics +[12]: /es/tracing/trace_pipeline/ingestion_controls +[13]: /es/tracing/metrics/metrics_namespace/ +[14]: https://app.datadoghq.com/apm/traces/generate-metrics +[15]: /es/tracing/trace_explorer/trace_queries \ No newline at end of file diff --git a/content/fr/api/latest/integrations/_index.md b/content/fr/api/latest/integrations/_index.md new file mode 100644 index 00000000000..e186d92ed19 --- /dev/null +++ b/content/fr/api/latest/integrations/_index.md @@ -0,0 +1,3 @@ +--- +title: Intégrations +--- diff --git a/content/ja/api/latest/integrations/_index.md b/content/ja/api/latest/integrations/_index.md new file mode 100644 index 00000000000..441262f38e5 --- /dev/null +++ b/content/ja/api/latest/integrations/_index.md @@ -0,0 +1,3 @@ +--- +title: インテグレーション +--- diff --git a/content/ko/api/latest/integrations/_index.md b/content/ko/api/latest/integrations/_index.md new file mode 100644 index 00000000000..2bad36f4383 --- /dev/null +++ b/content/ko/api/latest/integrations/_index.md @@ -0,0 +1,3 @@ +--- +title: Integrations +---