diff --git a/src/content/docs/infrastructure/google-cloud-platform-integrations/gcp-integrations-list/google-vertexai-monitoring-integration.mdx b/src/content/docs/infrastructure/google-cloud-platform-integrations/gcp-integrations-list/google-vertexai-monitoring-integration.mdx index 2a59c5d6510..047c84bc841 100644 --- a/src/content/docs/infrastructure/google-cloud-platform-integrations/gcp-integrations-list/google-vertexai-monitoring-integration.mdx +++ b/src/content/docs/infrastructure/google-cloud-platform-integrations/gcp-integrations-list/google-vertexai-monitoring-integration.mdx @@ -686,17 +686,19 @@ This integration collects GCP data for VertexAI. - + + - + - + + @@ -790,17 +792,19 @@ This integration collects GCP data for VertexAI.
- Metric -
+ Metric + - Unit - + Unit + - Description - + Description +
- + + - + - + + @@ -852,17 +856,19 @@ This integration collects GCP data for VertexAI.
- Metric -
+ Metric + - Unit - + Unit + - Description - + Description +
- + + - + - + + diff --git a/src/i18n/content/es/docs/apis/rest-api-v2/migrate-to-nrql.mdx b/src/i18n/content/es/docs/apis/rest-api-v2/migrate-to-nrql.mdx index 2f778c24bad..58acc109c7c 100644 --- a/src/i18n/content/es/docs/apis/rest-api-v2/migrate-to-nrql.mdx +++ b/src/i18n/content/es/docs/apis/rest-api-v2/migrate-to-nrql.mdx @@ -60,7 +60,7 @@ FROM Metric WHERE appId = $APP_ID AND metricTimesliceName = 'HttpDispatcher' ``` -| Valor (RPM) | Función NRQL | | -------------------------- | ------------------------------------------------------------------------------------------------- | | `average_response_time` | `average(newrelic.timeslice.value) * 1000` | | `calls_per_minute` | `rate(count(newrelic.timeslice.value), 1 minute)` | | `call_count` | `count(newrelic.timeslice.value)` | | `min_response_time` | `min(newrelic.timeslice.value) * 1000` | | `max_response_time` | `max(newrelic.timeslice.value) * 1000` | | `average_exclusive_time` | `average(newrelic.timeslice.value['totalExclusive'] / newrelic.timeslice.value['count']) * 1000` | | `average_value` | `average(newrelic.timeslice.value)` | | `total_call_time_per_minute` | `rate(sum(newrelic.timeslice.value), 1 minute)` | | `requests_per_minute` | `rate(count(newrelic.timeslice.value), 1 minute)` | | `standard_deviation` | `stddev(newrelic.timeslice.value) * 1000` | | `average_time` | `average(newrelic.timeslice.value) * 1000` | | `count` | `count(newrelic.timeslice.value)` | | `used_bytes_by_host` | `average(newrelic.timeslice.value) * 1024 * 1024` | | `used_mb_by_host` | `average(newrelic.timeslice.value)` | | `total_used_mb` | `sum(newrelic.timeslice.value)` | | `average_call_time` | `average(newrelic.timeslice.value) * 1000` | | `total_value` | `sum(newrelic.timeslice.value)` | | `min_value` | `min(newrelic.timeslice.value)` | | `max_value` | `max(newrelic.timeslice.value)` | | `rate` | `rate(sum(newrelic.timeslice.value), 1 second)` | | `throughput` | `rate(count(newrelic.timeslice.value), 1 second)` | | `as_percentage` | `average(newrelic.timeslice.value) * 100` | | `errors_per_minute` | `rate(count(newrelic.timeslice.value), 1 minute)` | | `error_count` | `count(newrelic.timeslice.value)` | | `total_time` | `sum(newrelic.timeslice.value) * 1000` | | `sessions_active` | `average(newrelic.timeslice.value)` | | `total_visits` | `sum(newrelic.timeslice.value)` | | `percent` | `average(newrelic.timeslice.value) * 100` | | `percent(CPU/User Time)` | `100 * sum(newrelic.timeslice.value) / $TIME_WINDOW_IN_SECONDS` | | `time_percentage` | `100 * sum(newrelic.timeslice.value) / $TIME_WINDOW_IN_SECONDS` | | `utilization` | `100 * sum(newrelic.timeslice.value) / $TIME_WINDOW_IN_SECONDS` | | `visits_percentage` | `100 * sum(newrelic.timeslice.value) / $TIME_WINDOW_IN_SECONDS` | +\| Valor (RPM) | Función NRQL | | -------------------------- | ------------------------------------------------------------------------------------------------- | | `average_response_time` | `average(newrelic.timeslice.value) * 1000` | | `calls_per_minute` | `rate(count(newrelic.timeslice.value), 1 minute)` | | `call_count` | `count(newrelic.timeslice.value)` | | `min_response_time` | `min(newrelic.timeslice.value) * 1000` | | `max_response_time` | `max(newrelic.timeslice.value) * 1000` | | `average_exclusive_time` | `average(newrelic.timeslice.value['totalExclusive'] / newrelic.timeslice.value['count']) * 1000` | | `average_value` | `average(newrelic.timeslice.value)` | | `total_call_time_per_minute` | `rate(sum(newrelic.timeslice.value), 1 minute)` | | `requests_per_minute` | `rate(count(newrelic.timeslice.value), 1 minute)` | | `standard_deviation` | `stddev(newrelic.timeslice.value) * 1000` | | `average_time` | `average(newrelic.timeslice.value) * 1000` | | `count` | `count(newrelic.timeslice.value)` | | `used_bytes_by_host` | `average(newrelic.timeslice.value) * 1024 * 1024` | | `used_mb_by_host` | `average(newrelic.timeslice.value)` | | `total_used_mb` | `sum(newrelic.timeslice.value)` | | `average_call_time` | `average(newrelic.timeslice.value) * 1000` | | `total_value` | `sum(newrelic.timeslice.value)` | | `min_value` | `min(newrelic.timeslice.value)` | | `max_value` | `max(newrelic.timeslice.value)` | | `rate` | `rate(sum(newrelic.timeslice.value), 1 second)` | | `throughput` | `rate(count(newrelic.timeslice.value), 1 second)` | | `as_percentage` | `average(newrelic.timeslice.value) * 100` | | `errors_per_minute` | `rate(count(newrelic.timeslice.value), 1 minute)` | | `error_count` | `count(newrelic.timeslice.value)` | | `total_time` | `sum(newrelic.timeslice.value) * 1000` | | `sessions_active` | `average(newrelic.timeslice.value)` | | `total_visits` | `sum(newrelic.timeslice.value)` | | `percent` | `average(newrelic.timeslice.value) * 100` | | `percent(CPU/User Time)` | `100 * sum(newrelic.timeslice.value) / $TIME_WINDOW_IN_SECONDS` | | `time_percentage` | `100 * sum(newrelic.timeslice.value) / $TIME_WINDOW_IN_SECONDS` | | `utilization` | `100 * sum(newrelic.timeslice.value) / $TIME_WINDOW_IN_SECONDS` | | `visits_percentage` | `100 * sum(newrelic.timeslice.value) / $TIME_WINDOW_IN_SECONDS` | Si la función incluye `$TIME_WINDOW_IN_SECONDS`, significa que debes reemplazarla con la ventana de tiempo que deseas consultar. @@ -68,13 +68,13 @@ Por ejemplo, si consulta un intervalo de tiempo de 30 minutos, reemplazará `$TI ### Apdex métricas -| Valor (RPM) | Función NRQL | | ------------- | ---------------------------------------------------------------------------------- | | `score` | `apdex(newrelic.timeslice.value)` | | `s` | `apdex(newrelic.timeslice.value)` o `count(newrelic.timeslice.value)` | | `t` | `apdex(newrelic.timeslice.value)` o `sum(newrelic.timeslice.value)` | | `f` | `apdex(newrelic.timeslice.value)` o `sum(newrelic.timeslice.value['totalExclusive'])`| | `count` | `apdex(newrelic.timeslice.value)` | | `value` | `apdex(newrelic.timeslice.value)` | | `threshold` | `max(newrelic.timeslice.value)` | | `threshold_min` | `min(newrelic.timeslice.value)` | +\| Valor (RPM) | Función NRQL | | ------------- | ---------------------------------------------------------------------------------- | | `score` | `apdex(newrelic.timeslice.value)` | | `s` | `apdex(newrelic.timeslice.value)` o `count(newrelic.timeslice.value)` | | `t` | `apdex(newrelic.timeslice.value)` o `sum(newrelic.timeslice.value)` | | `f` | `apdex(newrelic.timeslice.value)` o `sum(newrelic.timeslice.value['totalExclusive'])`| | `count` | `apdex(newrelic.timeslice.value)` | | `value` | `apdex(newrelic.timeslice.value)` | | `threshold` | `max(newrelic.timeslice.value)` | | `threshold_min` | `min(newrelic.timeslice.value)` | ### Métricas para EndUser & Mobile Estas métricas devolverán el mismo resultado que obtendría de la REST API v2, pero algunos resultados pueden diferir de lo que ve en la New Relic UI. Esto se debe a que la UI emplea evento en lugar de datos de intervalo de tiempo. Si desea obtener los mismos resultados que la UI, debe consultar el evento directamente. -| Valor (RPM) | Función NRQL | | ----------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | | `average_response_time` | `sum(newrelic.timeslice.value) / count(newrelic.timeslice.value) * 1000 `| | `error_percentage` | `(filter(count(newrelic.timeslice.value), WHERE metricTimesliceName = 'EndUser/errors') / filter(count(newrelic.timeslice.value), WHERE metricTimesliceName = 'Browser'))`| | `average_fe_response_time` | `sum(newrelic.timeslice.value['totalExclusive']) / count(newrelic.timeslice.value) * 1000` | | `average_be_response_time` | `1000 * (sum(newrelic.timeslice.value) - sum(newrelic.timeslice.value['totalExclusive'])) / count(newrelic.timeslice.value)` | | `average_network_time` | `(sum(newrelic.timeslice.value) - sum(newrelic.timeslice.value['totalExclusive']) - sum(newrelic.timeslice.value['sumOfSquares'])) / count(newrelic.timeslice.value)` | | `total_network_time` | `(sum(newrelic.timeslice.value) - sum(newrelic.timeslice.value['totalExclusive']) - sum(newrelic.timeslice.value['sumOfSquares']))` | | `network_time_percentage` | `(sum(newrelic.timeslice.value) - sum(newrelic.timeslice.value['totalExclusive']) - sum(newrelic.timeslice.value['sumOfSquares'])) / $TIME_WINDOW_IN_SECONDS` | | `total_fe_time` | `sum(newrelic.timeslice.value['totalExclusive'])` | | `fe_time_percentage` | `100 * sum(newrelic.timeslice.value['totalExclusive']) / $TIME_WINDOW_IN_SECONDS` | | `average_dom_content_load_time` | `average(newrelic.timeslice.value) * 1000` | | `average_queue_time` | `average(newrelic.timeslice.value['totalExclusive']) * 1000` | | `total_queue_time` | `sum(newrelic.timeslice.value['totalExclusive']) * 1000` | | `total_dom_content_time` | `sum(newrelic.timeslice.value) * 1000` | | `total_app_time` | `sum(newrelic.timeslice.value['sumOfSquares'])` | | `average_app_time` | `sum(newrelic.timeslice.value['sumOfSquares']) / count(newrelic.timeslice.value)` | | `average_sent_bytes` | `sum(newrelic.timeslice.value['totalExclusive']) * 1000` | | `average_received_bytes` | `1000 * sum(newrelic.timeslice.value) / count(newrelic.timeslice.value)` | | `launch_count` | `count(newrelic.timeslice.value)` | +\| Valor (RPM) | Función NRQL | | ----------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | | `average_response_time` | `sum(newrelic.timeslice.value) / count(newrelic.timeslice.value) * 1000 `| | `error_percentage` | `(filter(count(newrelic.timeslice.value), WHERE metricTimesliceName = 'EndUser/errors') / filter(count(newrelic.timeslice.value), WHERE metricTimesliceName = 'Browser'))`| | `average_fe_response_time` | `sum(newrelic.timeslice.value['totalExclusive']) / count(newrelic.timeslice.value) * 1000` | | `average_be_response_time` | `1000 * (sum(newrelic.timeslice.value) - sum(newrelic.timeslice.value['totalExclusive'])) / count(newrelic.timeslice.value)` | | `average_network_time` | `(sum(newrelic.timeslice.value) - sum(newrelic.timeslice.value['totalExclusive']) - sum(newrelic.timeslice.value['sumOfSquares'])) / count(newrelic.timeslice.value)` | | `total_network_time` | `(sum(newrelic.timeslice.value) - sum(newrelic.timeslice.value['totalExclusive']) - sum(newrelic.timeslice.value['sumOfSquares']))` | | `network_time_percentage` | `(sum(newrelic.timeslice.value) - sum(newrelic.timeslice.value['totalExclusive']) - sum(newrelic.timeslice.value['sumOfSquares'])) / $TIME_WINDOW_IN_SECONDS` | | `total_fe_time` | `sum(newrelic.timeslice.value['totalExclusive'])` | | `fe_time_percentage` | `100 * sum(newrelic.timeslice.value['totalExclusive']) / $TIME_WINDOW_IN_SECONDS` | | `average_dom_content_load_time` | `average(newrelic.timeslice.value) * 1000` | | `average_queue_time` | `average(newrelic.timeslice.value['totalExclusive']) * 1000` | | `total_queue_time` | `sum(newrelic.timeslice.value['totalExclusive']) * 1000` | | `total_dom_content_time` | `sum(newrelic.timeslice.value) * 1000` | | `total_app_time` | `sum(newrelic.timeslice.value['sumOfSquares'])` | | `average_app_time` | `sum(newrelic.timeslice.value['sumOfSquares']) / count(newrelic.timeslice.value)` | | `average_sent_bytes` | `sum(newrelic.timeslice.value['totalExclusive']) * 1000` | | `average_received_bytes` | `1000 * sum(newrelic.timeslice.value) / count(newrelic.timeslice.value)` | | `launch_count` | `count(newrelic.timeslice.value)` | ### Seriales temporales y resúmenes diff --git a/src/i18n/content/es/docs/browser/browser-monitoring/browser-pro-features/session-replay.mdx b/src/i18n/content/es/docs/browser/browser-monitoring/browser-pro-features/session-replay.mdx new file mode 100644 index 00000000000..eabee30ff24 --- /dev/null +++ b/src/i18n/content/es/docs/browser/browser-monitoring/browser-pro-features/session-replay.mdx @@ -0,0 +1,428 @@ +--- +title: Session Replay +metaDescription: Play back user interactions to debug faster and improve page performance. +freshnessValidatedDate: '2024-11-11T00:00:00.000Z' +translationType: machine +--- + +Session Replay captura la interacción en su aplicación sitio web y mapea otros telemetry data para ayudarlo a comprender las rutas de sus usuarios. Session Replay se puede emplear para la resolución de problemas y mejorar la experiencia del usuario final, tales como: + +* **Resolución de problemas Errores de JavaScript**: soluciona la causa de un error viendo qué estaba haciendo el usuario cuando ocurrió el error. Por ejemplo, si un usuario final recibe un error al intentar completar una transacción de comercio electrónico, puede usar Session Replay para ver qué pasos tomó y qué datos ingresó antes de que ocurriera el error. Esto puede ayudarle a identificar y solucionar rápidamente la causa raíz del problema. +* **Mejorar la experiencia del usuario**: descubra áreas de su aplicación web que están causando frustración en el usuario. Por ejemplo, es posible que vea que el usuario se pierde en su navegación o hace clic en botones que no hacen nada. +* **Identificación de problemas en los recorridos de los usuarios clave**: identifique áreas de su aplicación web que están causando problemas de rendimiento. Por ejemplo, si Session Replay revela que la página `/cart/checkout` está experimentando un tiempo de carga de la página excesivo, priorizaría corregir este recorrido crítico del usuario. + +Screenshot of session replay details + +## Cómo funciona Session Replay [#how-it-works] + +Cuando un usuario carga su página web, Session Replay toma una instantánea del modelo de objetos de documento (DOM), que representa la estructura y los elementos visuales de la página. Para garantizar información de estilo precisa, el agente del browser accede a sus archivos CSS. Luego, el agente integra estos estilos directamente en la grabación de repetición, eliminando la necesidad de hacer referencia a archivos CSS externos durante la reproducción. A medida que el usuario interactúa con la página, una biblioteca dentro del agente del browser captura cualquier cambio realizado en el DOM. Estos datos capturados se almacenan de forma segura en la base de datos de New Relic. + +Las repeticiones se almacenan hasta: + +* 4 horas de sesión de usuario +* 30 minutos de inactividad + +De forma predeterminada, los datos de eventos browser se almacenan durante 8 días, pero la retención real de datos depende de su cuenta. + +Para obtener más detalles sobre Session Replay, consulte las siguientes secciones: + +* [Consumo de datos](#data-consumption): Ver o proyectar el consumo de datos. +* [Preocupaciones de privacidad y seguridad del usuario](#data-security): conozca cómo protegemos sus datos de usuario y cumplimos con los requisitos de privacidad. +* [Session Replay y el rendimiento de su aplicación](#app-performance): aprenda cómo Session Replay minimiza el impacto en el rendimiento de su aplicación. + +## Empezar [#get-started] + + + + ### Habilitar Session Replay [#enable-configure-settings] + + 1. Vaya a **[one.newrelic.com](https://one.newrelic.com/all-capabilities) > All Capabilities > Browser**. + 2. Seleccione la aplicación de su browser . + 3. En el menú de la izquierda, haga clic en **Application settings**. + 4. En la página de configuración de la aplicación, asegúrese de que esté seleccionado **Pro** o **Pro + SPA** agente del navegador. Session Replay no está disponible para el agente Lite del navegador. + 5. Active las configuraciones **Session traces** y **Session replay** . + + + + ### Configurar tasas de muestreo [#configure-sampling-rates] + + Establezca una frecuencia de muestreo (0%-100%) para las siguientes muestras: + + * **User sessions** registra una muestra aleatoria de todas las sesiones de usuario. + + * **Errored session** registra una muestra aleatoria de todas las sesiones con errores. El agente almacena en el búfer una ventana deslizante de datos durante hasta 30 segundos en el lado del cliente y, si se producen errores, los datos almacenados en el búfer se recopilarán y se registrará el resto de la sesión. Si no se produce un error, la repetición nunca se recopila. + + Por ejemplo, si establece la tasa de muestreo de la sesión en 50% y la tasa de muestreo de error en 100%, significa que: + + * Se grabará la mitad de todas las sesiones de usuario. + + * Todas las sesiones con errores serán grabadas, incluso si no forman parte de la muestra del 50%. + + + + ### (Opcional) Configurar ajustes de privacidad [#configure-privacy-settings] + + De forma predeterminada, todo el texto y las entradas se reemplazan con asteriscos. A continuación se muestra un ejemplo de cómo se ve una repetición con privacidad predeterminada: + + Example of default privacy settings + + Si esta configuración es apropiada, continúe con el siguiente paso. + + Si necesita personalizar qué contenido o entrada del usuario se captura, tiene opciones para enmascarar, bloquear o ignorar clases y atributos específicos de contenido o entrada del usuario. Asegúrese de consultar con su equipo de privacidad antes de cambiar la configuración de privacidad. + + ### Enmascarar texto sensible [#mask-text] + + Puede enmascarar texto confidencial, lo que significa que el texto se reemplazará con asteriscos (\*). Por ejemplo, puede enmascarar el ID de cuenta de un usuario que se muestra en una URL. + + Para especificar qué entrada debe enmascararse, tiene algunas opciones: + + * En la página **Application settings** , agregue sus propios selectores de CSS o marque las casillas de enmascaramiento. Tenga en cuenta que el uso de selectores de enmascarar **no** enmascarará la entrada del usuario, por lo que si necesita ocultar la entrada del usuario, le recomendamos utilizar selectores de bloque. + + Screenshot of mask settings in the ui + + * Agregue nuestra clase CSS `nr-mask` o atributo `data-nr-mask` al HTML de su página web. Por ejemplo, para enmascarar el ID de una cuenta para que no se muestre en la URL, agregue `nr-mask` al `
` que contiene el ID de la cuenta: + + ```html +
Account ID: 99881123
+ ``` + + Estas opciones utilizan un asterisco (\*) para enmascarar todo el texto de ese elemento, ocultando el texto real pero revelando la cantidad de caracteres ingresados. Sin embargo, los asteriscos no son números válidos, por lo que enmascarar campos específicos del tipo de número, como números de teléfono o de tarjeta de crédito, dará como resultado un campo en blanco en una repetición. + + ### Bloquear contenido del sitio [#block-content] + + Puedes bloquear secciones enteras de contenido en tu sitio, lo que significa que la sección aparecerá como un marcador de posición vacío en Session Replay. Por ejemplo, si tiene una imagen en su página web Acerca de nosotros y no necesita capturarla, puede bloquear la clase que contiene la imagen. + + Para bloquear clases o atributos específicos, tienes algunas opciones: + + * En la página de configuración de la aplicación, agregue sus selectores CSS en el campo \**Bloquear selectores* . + + Screenshot of session replay settings + + * Agregue manualmente nuestra clase CSS `nr-block` o atributo `data-nr-block` al HTML de su página web. Por ejemplo, si desea bloquear texto e imágenes irrelevantes de Session Replay, agregue `nr-block` a `
`: + + ```html + + + Sample image and text + + +
+ Image description +
+ + + ``` + + ### Ignorar la entrada del usuario [#ignore-input] + + Puede ignorar los cambios en un campo de entrada del usuario, lo que significa que el campo de entrada seguirá mostrar en la repetición, pero no mostrará los cambios en el valor. Por ejemplo, puede ignorar la clase que contiene los campos de dirección de email o tarjeta de crédito. Los campos de entrada de contraseña siempre están enmascarados.  + + Para ignorar la entrada, agregue la clase CSS `nr-ignore` al nombre de clase del campo de entrada. Por ejemplo, si desea ignorar información confidencial en una página de facturación, agregue `class="nr-ignore"` a ``: + + ```html +
+

Sensitive Information

+

Credit card number:

+

Expiration date:

+

CVV code:

+
+ ``` + + + + ### (Para copiar/pegar desplegar agente) Actualizar manualmente el fragmento de JavaScript [#update-snippet] + + Si implementa el agente del navegador usando el método copiar/pegar, deberá copiar/pegar desde la UI nuevamente. Esto se debe a que cuando habilita Session Replay, el fragmento de JavaScript se actualiza para incluir las nuevas actualizaciones de configuración. + + Para actualizar su código de agente: + + 1. Vaya a la página **Application Settings** y copie el fragmento de JavaScript. + + Screenshot of the application settings page. + + 2. Pégalo en tu código donde estaba el fragmento anterior. + + 3. Desplegar tu aplicación. + + + + ### Ver la repetición de la sesión en New Relic [#view-data] + + Puede encontrar Session Replay en dos lugares: + + * En la página **Session replay** : + + 1. Vaya a **[one.newrelic.com > All Capabilities](https://one.newrelic.com/all-capabilities) > Browser**. + + 2. Seleccione la aplicación de su browser . + + 3. En el menú de la izquierda, desplácese hacia abajo y haga clic en **Session replay**. + + 4. Haga clic en cada repetición para ver los detalles de la sesión. + + screenshot of the session replay page in browser + + * En la página **Errors inbox** : + + 1. En el menú browser de la izquierda, haga clic en **Errors**. + + 2. Haga clic en las páginas **Triage** y **Group errors** para ver las repeticiones adjuntas a los errores. + + Screenshot of replays in errors inbox + + + + + Algunas configuraciones, incluida la habilitación o deshabilitación de la reproducción de sesión y el ajuste de las frecuencias de ejemplificación para el rendimiento general y los errores, se movieron a la configuración del lado del servidor. Por ejemplo, luego de actualizar estas configuraciones para el método de instalación copiar/pegar, no es necesario volver a implementar el script. Esto es aplicable para el agente del browser versión `1.259.0` o superior. + + +## Resolución de problemas [#troubleshoot] + + + + ### Problema + + La característica Session Replay está habilitada, pero no ves ninguna repetición. + + ### Solución + + Aquí hay algunas posibles soluciones: + + * Verifique sus tasas de muestreo. Hay muestreo tanto para repeticiones como para errores. + + * Asegúrate de tener permiso para ver repeticiones. + + * Asegúrate de estar utilizando la versión Pro o Pro+SPA del agente del navegador. Session Replay no funciona con el agente Lite del navegador. + + * Asegúrese de que su agente del navegador cumpla con estos requisitos: + + * Versión del agente v1.260.0 o superior. Recomendamos [actualizar a la última versión del agente](/docs/release-notes/new-relic-browser-release-notes/browser-agent-release-notes) a medida que continuamos realizando mejoras. + * Tipo de agente: Pro o Pro+SPA. Session Replay no funciona con el agente Lite del navegador. + * [El seguimiento de sesiones](/docs/browser/browser-monitoring/browser-pro-features/session-traces-explore-webpages-life-cycle/#requirements) está habilitado. + + * El de su final browser admite la de usuario a browsernivel de API necesaria para grabar una Session Replay (verifique la compatibilidad en [MutationObserver](https://caniuse.com/mutationobserver)). + + * En [Errors Inbox](/docs/errors-inbox/errors-inbox/), filtra tus vistas para que siempre veas una repetición. De forma predeterminada, los datos de eventos browser se almacenan durante 8 días, pero la retención real de datos depende de su cuenta. + + * Si está utilizando el método de copiar y pegar desplegable, asegúrese de [actualizar su código de agente](#update-snippet). + + * Si está utilizando el método de implementación APM, es posible que deba esperar un momento para que Session Replay se habilite automáticamente. Si aún no ve datos, intente reiniciar el agente. + + * Si [elimina](https://docs.newrelic.com/docs/data-apis/manage-data/drop-data-using-nerdgraph/) datos de eventos de PageView, es posible que la repetición de sesión no se muestre en la UI. + + + + ### Problema + + Estás viendo repeticiones, pero no se muestran correctamente. + + Esto puede deberse a que sus archivos CSS están alojados en un dominio separado y las medidas de seguridad de intercambio de recursos entre orígenes (CORS) impiden que nuestro agente acceda a los archivos CSS. Esto puede dar como resultado repeticiones incompletas o inexactas, ya que es posible que falte información de estilo esencial. + + Esto es lo que sucede detrás de escena: + + * Session Replay funciona reconstruyendo el DOM del usuario, que incluye la estructura y los elementos visuales de su sitio web. Para lograr esto, nuestro agente necesita acceder a sus archivos CSS para capturar con precisión información de estilo. Luego incorporamos estos estilos directamente en la grabación de repetición, eliminando la necesidad de hacer referencia a los archivos CSS originales durante la reproducción. + + * Si sus archivos CSS están alojados en un dominio separado, CORS puede impedir que nuestro agente acceda a ellos. + + ### Solución + + Para asegurarse de que sus archivos CSS sean accesibles, agregue el atributo `crossorigin="anonymous"` a sus elementos `` dentro de su código HTML. Este atributo indica al browser que permita el acceso entre orígenes para esos archivos CSS específicos, lo que permite a nuestro agente del navegador registrar e integrar la información de estilo. + + A continuación se muestra un ejemplo de cómo agregar el atributo `crossorigin="anonymous"` : + + ```html + + ``` + + + + ### Problema + + La función de reproducción de sesión está habilitada, pero no ves datos de reproducción para el contenido iframe. + + ### Solución + + El comportamiento de Session Replay en escenarios iframe depende del origen del iframe y de la ubicación del agente del browser. + + Suponiendo que un sitio web consta de una ventana de nivel superior con un iframe secundario, aquí hay algunas posibles soluciones: + + * **Iframes del mismo origen**: + + * Si coloca el agente del browser en la ventana de nivel superior, Session Replay captura tanto la ventana como el iframe. + * Si coloca el agente del browser en el iframe, Session Replay solo captura lo que está en el iframe. + * Si coloca el agente del browser tanto en la ventana de nivel superior como en el iframe, Session Replay captura lo que sucede independientemente tanto en la ventana como en el iframe, lo que da como resultado dos sesiones separadas. + + * **Iframes de origen cruzado**: + + * Si coloca el agente del browser en la ventana de nivel superior, Session Replay solo captura lo que hay en la ventana. El iframe aparecerá en blanco en la repetición de la sesión. + * Si coloca el agente del browser en el iframe de nivel superior, Session Replay solo captura lo que está en el iframe. + + La repetición de sesión **no** es compatible con `` elementos. + + + +## Grabar manualmente la repetición de la sesión [#manual-replays] + +Si es necesario, puede `force` mediante programación una Session Replay para iniciar o detener la grabación empleando métodos API . A continuación se muestran algunos casos de uso: + +* Permitir que el usuario opte por la grabación de interacciones. Por ejemplo, si aparece una ventana emergente que pregunta "¿Permitir que se grabe esta sesión para analizar el rendimiento?" y un usuario consiente: + + 1. Llame a `newrelic.recordReplay()` para iniciar la grabación. + 2. Una vez que se complete la sesión o se retire el consentimiento, use `newrelic.pauseReplay()` para dejar de capturar datos. + +* Grabe sesiones según criterios específicos, como: + + * Comience a grabar solo sesiones en URL específicas, como el flujo de pago de un producto. + * Detenga la grabación de páginas confidenciales como `/billing` o `/health-records`. + +Consulte la documentación de la API para obtener instrucciones: + +* [`newrelic.recordReplay`](/docs/browser/new-relic-browser/browser-apis/recordReplay/) +* [`newrelic.pauseReplay`](/docs/browser/new-relic-browser/browser-apis/pauseReplay/) + +## Deshabilitar el seguimiento automático Session Replay [#auto-replays] + +Puede evitar que la reproducción de sesión se inicie automáticamente, incluso cuando se muestrea, estableciendo la opción de configuración API `autoStart` en `false`. Esto resulta útil en escenarios en los que es necesario priorizar acciones específicas sobre la ejemplificación automática. Por ejemplo, es posible que no desee que Session Replay se ejecute automáticamente en páginas confidenciales, como las que cumplen con HIPAA. En tales casos, puede emplear la API `.start()` para activar manualmente la característica de reproducción luego de obtener el consentimiento del usuario (y su aplicación llama a `.start()`). + +La configuración `autoStart: false` indica al agente que posponga su inicialización hasta que se llame explícitamente mediante `.start()`. Esto garantiza que la reproducción de sesión no se creará en absoluto, incluso si el backend toma muestras de su aplicación para grabar. + + + Llamar a `.start()` no garantiza que se grabará una Session Replay . Simplemente retrasa la importación del módulo y la evaluación de los resultados de la ejemplificación hasta este punto. Si necesita forzar una grabación, consulte [Grabar manualmente la reproducción de la sesión](#manual-replays). + + +Para comenzar a emplear esta API, consulte [`newrelic.start`](/docs/browser/new-relic-browser/browser-apis/start/). + +## Utilice Nerdgraph para configurar los ajustes de reproducción [#nerdgraph-mutation] + +Puede configurar los ajustes Session Replay usando nuestra [API NerdGraph](/docs/apis/nerdgraph/get-started/introduction-new-relic-nerdgraph/) en lugar de usar la UI. Este método es útil si necesita realizar cambios masivos, como aplicar frecuencias de muestreo a múltiples entidades browser . + +Aquí hay un ejemplo de mutación y variables para crear una nueva aplicación browser con la configuración predeterminada: + +
- Metric -
+ Metric + - Unit - + Unit + - Description - + Description +
+ + + + + + + + + + + + + + + +
+ Mutación + + Variables +
+ ```graphql + mutation SessionReplayConfigUpdate($guid: EntityGuid!, $settings: AgentApplicationSettingsUpdateInput!) { + agentApplicationSettingsUpdate(guid: $guid, settings: $settings) { + browserSettings { + sessionReplay { + blockSelector + errorSamplingRate + maskTextSelector + enabled + collectFonts + inlineImages + inlineStylesheet + samplingRate + maskAllInputs + maskInputOptions { + color + date + datetimeLocal + email + month + number + range + search + select + tel + text + textArea + time + url + week + } + } + } + errors { + field + errorClass + description + } + } + } + ``` + + ```json + { + "sessionReplay": { + "enabled": true, + "collectFonts": true, + "blockSelector": ".private-fields", + "maskTextSelector": "*", + "inlineStylesheet": false, + "maskAllInputs": true, + "maskInputOptions": { + "color": true, + "date": true, + "textArea": true + }, + "samplingRate": 9.99, + "errorSamplingRate": 1.11 + } + } + ``` +
+ +## Consumo de datos [#data-consumption] + +Session Replay sigue el mismo precio de consumo que los otros bytes de su browser . La cantidad de bytes producidos depende del recuento, la duración y los niveles de actividad del usuario de las sesiones, así como de la complejidad del DOM de su sitio. + +La forma más precisa de proyectar su costo por repetición es habilitar la característica durante un periodo de prueba corto y medir su consumo real. Alternativamente, puedes usar un promedio de 5,3 MB por repetición como una aproximación aproximada, aunque ten en cuenta que el costo real puede variar significativamente. Una fórmula sencilla para proyectar sus costos aproximados es: `sessions` x `sampling_rate` x `gb_per_replay` x `cost_per_gb`. He aquí un ejemplo: + +``` +1 million (sessions) x 5% (sampling_rate) x 0.0053 (gb_per_replay) x $0.35 (cost_per_gb) = $92.75 for 50,000 replays +``` + +Para controlar su consumo, [ajuste sus tasas de muestreo](#configure-sampling-rates). + +## Preocupaciones de seguridad y privacidad del usuario [#data-security] + +Priorizamos la privacidad de los datos y creamos Session Replay con configuraciones predeterminadas estables para minimizar la exposición potencial de información confidencial de los clientes. Puede [personalizar aún más la configuración de privacidad](#configure-privacy-settings) para satisfacer sus necesidades específicas. + +Session Replay no captura capturas de pantalla ni videos. En cambio, registra solo los cambios de estado DOM esenciales necesarios para reconstruir la interacción del usuario. Esto reduce significativamente la cantidad de datos almacenados. + +### Cumplimiento de las leyes de privacidad de datos + +New Relic actúa como procesador de datos según GDPR y proveedor de servicios según CCPA. Esto significa que procesamos datos de acuerdo con sus instrucciones. En última instancia, el cumplimiento de estas leyes depende de cómo implemente Session Replay dentro de su aplicación. + +De forma predeterminada, todo el texto y las entradas del usuario, incluidos los datos personales, están enmascarados dentro de las grabaciones. Puede desenmascarar selectivamente elementos específicos si es necesario, pero la configuración predeterminada garantiza que ninguna información de identificación personal sea fácilmente visible. Este enfoque proporciona una base estable para la privacidad de los datos y al mismo tiempo ofrece flexibilidad para sus necesidades específicas. + +## Session Replay y el rendimiento de tu app [#app-performance] + +Session Replay minimiza el impacto en el rendimiento de su aplicación con: + +* **Impacto inicial mínimo**: Session Replay se carga de forma asincrónica después de cargar la página completa, lo que garantiza que no interfiera con el rendimiento métrico de la carga temprana de la página. + +* **Seguimiento de mutaciones DOM **: una vez cargado, Session Replay monitorea los cambios DOM y los informa como carga comprimida. El tamaño de estas cargas se correlaciona con la complejidad del árbol DOM . + +* **Técnicas de optimización del rendimiento**: el tamaño de la carga útil también puede aumentar si el DOM es grande. Sin embargo, Session Replay utiliza una serie de técnicas para reducir el tamaño de la carga, como por ejemplo: + + * Compresión GZIP + + * Reducción de duplicación + + * Recolección estratégica de carga: solo envía una carga grande (comprimida) cuando se captura el DOM completo, lo que generalmente solo ocurre cuando se importa por primera vez la característica de reproducción. Después de eso, solo enviará pequeñas cargas relacionadas con las acciones del usuario. El agente del browser recogerá lo que ocurra primero de lo siguiente: + + * La carga útil alcanza más de 64 KB comprimidos + * Pasan 60 segundos + * La visibilidad de la página cambia (cambio de pestaña, enfoque, navegación, etc.) + * La sesión termina \ No newline at end of file diff --git a/src/i18n/content/es/docs/browser/new-relic-browser/browser-apis/recordReplay.mdx b/src/i18n/content/es/docs/browser/new-relic-browser/browser-apis/recordReplay.mdx index 2bd23b34c67..ff653549517 100644 --- a/src/i18n/content/es/docs/browser/new-relic-browser/browser-apis/recordReplay.mdx +++ b/src/i18n/content/es/docs/browser/new-relic-browser/browser-apis/recordReplay.mdx @@ -28,7 +28,6 @@ Browser API utilizada para forzar una repetición para comenzar a grabar. `newrelic.recordReplay()` Se puede llamar para forzar manualmente una repetición para comenzar a grabar. Debes cumplir con los siguientes requisitos: * La cuenta tiene derecho a grabar repeticiones. -* El seguimiento de sesiones está habilitado * El rastreo de sesión está habilitado * El observador de mutación browser global está presente en la versión actual del browser que se está utilizando. * La característica Session Replay se importa normalmente o se establece en `autoStart: false` y ya se ha "iniciado". diff --git a/src/i18n/content/es/docs/infrastructure/google-cloud-platform-integrations/gcp-integrations-list/google-vertexai-monitoring-integration.mdx b/src/i18n/content/es/docs/infrastructure/google-cloud-platform-integrations/gcp-integrations-list/google-vertexai-monitoring-integration.mdx new file mode 100644 index 00000000000..48bdd733836 --- /dev/null +++ b/src/i18n/content/es/docs/infrastructure/google-cloud-platform-integrations/gcp-integrations-list/google-vertexai-monitoring-integration.mdx @@ -0,0 +1,902 @@ +--- +title: Integración de monitoreo de Google VertexAI +tags: + - Integrations + - Google Cloud Platform integrations + - GCP integrations list +metaDescription: 'New Relic Google VertexAI integration: the data it reports and how to enable it.' +freshnessValidatedDate: never +translationType: machine +--- + +[La integración de New Relic](/docs/infrastructure/introduction-infra-monitoring) incluye una integración para informar sus datos de ejecución de GCP a nuestros productos. Aquí explicamos cómo activar la integración y qué datos recopila. + +## Activar la integración [#activate] + +Para habilitar la integración, siga los procedimientos estándar para [conectar su servicio GCP a New Relic](/docs/connect-google-cloud-platform-services-infrastructure). + +## Configuración y sondeo [#polling] + +Puede cambiar la frecuencia de sondeo y filtrar datos usando [las opciones de configuración](/docs/integrations/new-relic-integrations/getting-started/configure-polling-frequency-data-collection-cloud-integrations). + +Información [de sondeo](/docs/integrations/google-cloud-platform-integrations/getting-started/polling-intervals-gcp-integrations) predeterminada para la integración de GCP Run: + +* New Relic intervalo de sondeo: 5 minutos + +## Buscar y utilizar datos [#find-data] + +Para encontrar sus datos de integración, vaya a **[one.newrelic.com > All capabilities](https://one.newrelic.com/all-capabilities) > Infrastructure > GCP** y seleccione una integración. + +Los datos se adjuntan a los siguientes [tipos de eventos](/docs/data-apis/understand-data/new-relic-data-types/#event-data): + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ Entidad + + Tipo de evento + + Proveedor +
+ Extremo + + `GcpVertexAiEndpointSample` + + `GcpVertexAiEndpoint` +
+ Tienda caracteristica + + `GcpVertexAiFeaturestoreSample` + + `GcpVertexAiFeaturestore` +
+ Tienda característica online + + `GcpVertexAiFeatureOnlineStoreSample` + + `GcpVertexAiFeatureOnlineStore` +
+ Ubicación + + `GcpVertexAiLocationSample` + + `GcpVertexAiLocation` +
+ Índice + + `GcpVertexAiIndexSample` + + `GcpVertexAiIndex` +
+ PipelineJob + + `GcpVertexAiPipelineJobSample` + + `GcpVertexAiPipelineJob` +
+ +Para obtener más información sobre cómo utilizar sus datos, consulte [Comprender y utilizar los datos de integración](/docs/infrastructure/integrations/find-use-infrastructure-integration-data). + +## Datos métricos [#metrics] + +Esta integración recopila datos de GCP para VertexAI. + +### Datos extremos de VertexAI + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ Métrica + + Unidad + + Descripción +
+ `prediction.online.accelerator.duty_cycle` + + Por ciento + + Fracción de tiempo promedio durante el último periodo de muestra durante el cual los aceleradores estuvieron procesando activamente. +
+ `prediction.online.accelerator.memory.bytes_used` + + Bytes + + Cantidad de memoria aceleradora asignada por la réplica del modelo de despliegue. +
+ `prediction.online.error_count` + + Contar + + Número de errores de predicción en línea. +
+ `prediction.online.memory.bytes_used` + + Bytes + + Cantidad de memoria asignada por la réplica del modelo de despliegue y actualmente en uso. +
+ `prediction.online.network.received_bytes_count` + + Bytes + + Número de bytes recibidos a través de la red por la réplica del modelo de desplegar. +
+ `prediction.online.network.sent_bytes_count` + + Bytes + + Número de bytes enviados a través de la red por la réplica del modelo de desplegar. +
+ `prediction.online.prediction_count` + + Contar + + Número de predicciones en línea. +
+ `prediction.online.prediction_latencies` + + Milisegundos + + Latencia de predicción online del modelo desplegar. +
+ `prediction.online.private.prediction_latencies` + + Milisegundos + + Latencia de predicción online del modelo privado desplegar. +
+ `prediction.online.replicas` + + Contar + + Número de réplicas activas empleadas por el modelo desplegar. +
+ `prediction.online.response_count` + + Contar + + Número de códigos de respuesta de predicción en línea diferentes. +
+ `prediction.online.target_replicas` + + Contar + + Número objetivo de réplicas activas necesarias para el modelo de despliegue. +
+ +### Datos de VertexAI Featurestore + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ Métrica + + Unidad + + Descripción +
+ `featurestore.cpu_load` + + Por ciento + + La carga promedio de CPU para un nodo en el almacenamiento en línea de Featurestore. +
+ `featurestore.cpu_load_hottest_node` + + Por ciento + + La carga de CPU para el nodo más activo en el almacenamiento en línea de Featurestore. +
+ `featurestore.node_count` + + Contar + + La cantidad de nodos para el almacenamiento en línea de Featurestore. +
+ `featurestore.online_entities_updated` + + Contar + + Número de entidad actualizada en el almacenamiento en línea de Featurestore. +
+ `featurestore.online_serving.latencies` + + Milisegundos + + Latencia de servicio online por EntityType. +
+ `featurestore.online_serving.request_bytes_count` + + Bytes + + Tamaño de la solicitud por EntityType. +
+ `featurestore.online_serving.request_count` + + Contar + + Recuento de servicios en línea de Featurestore por EntityType. +
+ `featurestore.online_serving.response_size` + + Bytes + + Tamaño de respuesta por EntityType. +
+ `featurestore.storage.billable_processed_bytes` + + Bytes + + Número de bytes facturados por datos fuera de línea procesados. +
+ `featurestore.storage.stored_bytes` + + Bytes + + Bytes almacenados en Featurestore. +
+ `featurestore.streaming_write.offline_processed_count` + + Contar + + Número de solicitudes de escritura en streaming procesadas para almacenamiento sin conexión. +
+ `featurestore.streaming_write.offline_write_delays` + + Segundos + + Tiempo (en segundos) desde que se llama a la API de escritura hasta que se escribe en el almacenamiento fuera de línea. +
+ +### Datos de VertexAI FeatureOnlineStore + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ Métrica + + Unidad + + Descripción +
+ `featureonlinestore.online_serving.request_count` + + Contar + + Número de recuento de porciones por FeatureView. +
+ `featureonlinestore.online_serving.serving_bytes_count` + + Bytes + + Tamaño de respuesta de publicación por FeatureView. +
+ `featureonlinestore.online_serving.serving_latencies` + + Milisegundos + + Latencia de servicio en línea mediante FeatureView. +
+ `featureonlinestore.running_sync` + + Milisegundos + + Número de sincronizaciones en ejecución en un momento determinado. +
+ `featureonlinestore.serving_data_ages` + + Segundos + + Medida de la antigüedad de los datos de servicio en segundos. +
+ `featureonlinestore.serving_data_by_sync_time` + + Contar + + Desglose de datos en Feature Online Store por timestamp sincronizada. +
+ `featureonlinestore.storage.bigtable_cpu_load` + + Por ciento + + La carga promedio de CPU de los nodos en Feature Online Store. +
+ `featureonlinestore.storage.bigtable_cpu_load_hottest_node` + + Por ciento + + La carga de CPU del nodo más caliente en Feature Online Store. +
+ `featureonlinestore.storage.bigtable_nodes` + + Contar + + El número de nodos de Feature Online Store(Bigtable). +
+ `featureonlinestore.storage.stored_bytes` + + Contar + + Bytes almacenados en Feature Online Store. +
+ +### Datos de ubicación de VertexAI + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ Métrica + + Unidad + + Descripción +
+ `online_prediction_requests_per_base_model` + + Contar + + Número de solicitudes por modelo base. +
+ `quota.online_prediction_requests_per_base_model.exceeded` + + Contar + + Número de intentos de superar el límite de la métrica de cuota. +
+ `quota.online_prediction_requests_per_base_model.limit` + + Contar + + Límite actual de la métrica de cuota. +
+ `quota.online_prediction_requests_per_base_model.usage` + + Contar + + Uso actual en la métrica de cuota. +
+ `executing_vertexai_pipeline_jobs` + + Contar + + Número de trabajos de canalización que se ejecutan. +
+ `executing_vertexai_pipeline_tasks` + + Contar + + Número de tareas de canalización que se ejecutan. +
+ +### Datos del índice VertexAI + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ Métrica + + Unidad + + Descripción +
+ `matching_engine.stream_update.datapoint_count` + + Contar + + Número de puntos de datos insertados o eliminados correctamente. +
+ `matching_engine.stream_update.latencies` + + Milisegundos + + La latencia entre el usuario recibe una UpsertDatapointsResponse o RemoveDatapointsResponse y esa actualización surte efecto. +
+ `matching_engine.stream_update.request_count` + + Contar + + Número de solicitudes de actualización de flujo. +
+ +### Datos del trabajo de pipeline de VertexAI + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ Métrica + + Unidad + + Descripción +
+ `pipelinejob.duration` + + Segundos + + Segundos de tiempo de ejecución del trabajo de canalización que se ejecuta (desde la creación hasta el final). +
+ `pipelinejob/task_completed_count` + + Contar + + Número total de tareas de canalización completadas. +
\ No newline at end of file diff --git a/src/i18n/content/es/docs/service-level-management/create-slm.mdx b/src/i18n/content/es/docs/service-level-management/create-slm.mdx index 76f154304b7..46ce61036b3 100644 --- a/src/i18n/content/es/docs/service-level-management/create-slm.mdx +++ b/src/i18n/content/es/docs/service-level-management/create-slm.mdx @@ -51,7 +51,7 @@ Por ejemplo, en un nivel alto, una experiencia clave del usuario en New Relic po Para esa experiencia del usuario, podríamos crear un SLO como: -| periodo | objetivo | categoría | indicador | | ------------ | ------ | -------- | ------------------------------------------------------------------- | | últimos 28 días | 99,9% | latencia | los datos ingeridos por un usuario están disponibles para consulta en menos de 1 minuto | +\| periodo | objetivo | categoría | indicador | | ------------ | ------ | -------- | ------------------------------------------------------------------- | | últimos 28 días | 99,9% | latencia | los datos ingeridos por un usuario están disponibles para consulta en menos de 1 minuto | Tenga en cuenta que estos tipos de experiencia del usuario generalmente involucran más de un servicio y se extienden a través de múltiples límites de equipos y organizaciones. @@ -59,7 +59,7 @@ Al aumentar la granularidad de la experiencia subyacente del usuario, otra exper Este SLO podría verse así: -| periodo | objetivo | categoría | indicador | | ------------ | ------ | ------------ | ------------------------------------------------- | | últimos 28 días | 99.9% | disponibilidad | el usuario interactúa exitosamente con la dashboard UI | +\| periodo | objetivo | categoría | indicador | | ------------ | ------ | ------------ | ------------------------------------------------- | | últimos 28 días | 99.9% | disponibilidad | el usuario interactúa exitosamente con la dashboard UI | Como ejemplo de llevar la granularidad demasiado lejos, agregar un widget de gráfico en un dashboard también es una experiencia del usuario. Sin embargo, la creación de un SLO específico para esta acción no proporciona valor adicional en comparación con el SLO anterior sobre la interacción exitosa de los usuarios con la dashboard UI.