Usa métricas basadas en registros

En esta página, se abordan los conceptos básicos de la emisión de registros para crear SLI de disponibilidad y latencia. También se proporcionan ejemplos de implementación sobre cómo definir SLO mediante métricas basadas en registros.

El uso de elementos de datos en las entradas de registro para crear indicadores de nivel de servicio es una forma fácil de aprovechar las cargas útiles del registro existentes. De lo contrario, es posible agregar el registro a un servicio existente, lo que puede ser más fácil que crear instrumentación de métricas.

Registros y métricas

Los registros recopilan registros llamados entradas de registro que describen eventos específicos que ocurren en los sistemas informáticos. Los registros los escriben el código, los servicios de la plataforma en la que se ejecuta el código (por ejemplo, Dataflow) y la infraestructura de la que depende la plataforma (por ejemplo, las instancias de Compute Engine).

Debido a que los registros en los sistemas modernos descienden de los archivos de texto escritos en el disco (y, a veces, lo siguen siendo), una entrada de registro es análoga a una línea en un archivo de registro y se puede considerar la unidad de registro cuántica.

Una entrada de registro consta mínimamente de dos elementos:

Una marca de tiempo que indica cuándo ocurrió el evento o cuándo se transfirió al sistema de registro
La carga útil de texto, ya sea como datos de texto no estructurados o como datos estructurados, por lo general, en JSON

Los registros también pueden llevar metadatos asociados, en especial cuando se transfieren a Cloud Logging. Estos metadatos pueden incluir el recurso que escribe el registro, el nombre del registro y una gravedad para cada entrada.

Registros

Los registros se usan para dos propósitos principales:

Los registros de eventos describen eventos específicos que ocurren en el sistema. Puedes usar los registros de eventos para mostrar mensajes que garanticen a los usuarios que las acciones funcionan bien (“tarea realizada correctamente”) o proporcionar información cuando fallan las cosas (“se recibió una excepción del servidor”).
En los registros de transacciones, se describen los detalles de cada transacción que procesa un sistema o componente. Por ejemplo, un balanceador de cargas registra todas las solicitudes que recibe, ya sea que la solicitud se complete con éxito o no, y registra información adicional, como la URL solicitada, el código de respuesta HTTP y, posiblemente, la información, como el backend que se usó para entregar la solicitud.

Métricas

A diferencia de los registros, las métricas no suelen describir eventos específicos. Por lo general, las métricas se usan para representar el estado de un sistema a lo largo del tiempo. Una métrica está compuesta por una serie de datos que miden algo sobre tu sistema, y cada dato incluye una marca de tiempo y un valor numérico.

Las métricas también pueden tener metadatos asociados. La serie de datos, que se denomina serie temporal, puede incluir información como el nombre de la métrica, una descripción y, a menudo, etiquetas que especifican qué recurso escribe los datos. Para obtener información sobre el modelo de métrica de Monitoring, consulta Métricas, series temporales y recursos.

Métricas basadas en registros

Las métricas basadas en registros son métricas que se crean a partir de entradas de registro mediante la extracción de información de estas y la transformación en datos de series temporales. Cloud Logging proporciona mecanismos para crear dos tipos de métricas a partir de entradas de registro:

Métricas de contador, que cuentan la cantidad de entradas de registro que coinciden con un filtro en particular. Puedes usar una métrica de contador para determinar, por ejemplo, la cantidad de solicitudes o errores guardados en el registro.
Métricas de distribución, que usan expresiones regulares para analizar la carga útil en cada entrada de registro a fin de extraer valores numéricos como una distribución.

Para obtener más información sobre las métricas basadas en registros en Cloud Logging, consulta Usa métricas basadas en registros.

Usa métricas basadas en registros como SLI

Las métricas basadas en registros te permiten extraer datos de los registros en un formato que puedes usar para compilar SLI en Monitoring:

Puedes usar métricas de contador basadas en registros para expresar un SLI de disponibilidad basado en solicitudes.
Puedes usar una métrica de distribución basada en registros para expresar un SLI de latencia basado en solicitudes.

Ejemplos de entradas de registro

La aplicación Stack Doctor es un ejemplo de un servicio instrumentado para emitir mensajes de registro que contienen información sobre todas las solicitudes, los errores y la latencia en relación con el servicio. El código del servicio está disponible en el repositorio de GitHub stack-doctor.

El servicio genera entradas de registro de Cloud Logging en el registro projects/stack-doctor/logs/bunyan_log. La entrada de registro de cada tipo de evento incluye un valor message diferente. Las entradas de registro de diferentes tipos de eventos se ven de la siguiente manera:

En cada solicitud:

{
  "insertId": "..........iTRVT5MOK2VOsVe31bzrTD",
  "jsonPayload": {
    "pid": 81846,
    "time": "Mon Aug 31 2020 20:30:49 GMT-0700 (Pacific Daylight Time)",
    "hostname": "<hostname>",
    "level": 30,
    "message": "request made",
    "v": 0,
    "name": "sli-log"
  },
    "resource": {
    "type": "global",
    "labels": {
      "project_id": "stack-doctor"
    }
  },
  "timestamp": "2020-09-01T03:30:49.263999938Z",
  "severity": "INFO",
  "logName": "projects/stack-doctor/logs/bunyan_log",
  "receiveTimestamp": "2020-09-01T03:30:50.003471183Z"
}

En las solicitudes exitosas:

{
  "insertId": "..........qTRVT5MOK2VOsVe31bzrTD",
  "jsonPayload": {
    "name": "sli-log",
    "v": 0,
    "pid": 81846,
    "level": 30,
    "hostname": "<hostname>",
    "time": "Mon Aug 31 2020 20:30:49 GMT-0700 (Pacific Daylight Time)",
    "message": "success!"
  },
  "resource": {
    "type": "global",
    "labels": {
      "project_id": "stack-doctor"
    }
  },
  "timestamp": "2020-09-01T03:30:49.874000072Z",
  "severity": "INFO",
  "logName": "projects/stack-doctor/logs/bunyan_log",
  "receiveTimestamp": "2020-09-01T03:30:50.201547371Z"
}

En las solicitudes completadas:

{
  "insertId": "..........mTRVT5MOK2VOsVe31bzrTD",
  "jsonPayload": {
    "time": "Mon Aug 31 2020 20:30:49 GMT-0700 (Pacific Daylight Time)",
    "level": 30,
    "name": "sli-log",
    "message": "slept for 606 ms",
    "hostname": "<hostname>",
    "pid": 81846,
    "v": 0
  },
  "resource": {
    "type": "global",
    "labels": {
      "project_id": "stack-doctor"
    }
  },
  "timestamp": "2020-09-01T03:30:49.874000072Z",
  "severity": "INFO",
  "logName": "projects/stack-doctor/logs/bunyan_log",
  "receiveTimestamp": "2020-09-01T03:30:50.201547371Z"
}

En solicitudes con errores:

{
  "insertId": "..........DTRVT5MOK2VOsVe31bzrTD",
  "jsonPayload": {
    "hostname": "<hostname>",
    "level": 50,
    "pid": 81846,
    "message": "failure!",
    "name": "sli-log",
    "time": "Mon Aug 31 2020 20:30:44 GMT-0700 (Pacific Daylight Time)",
    "v": 0
  },
  "resource": {
    "type": "global",
    "labels": {
      "project_id": "stack-doctor"
    }
  },
  "timestamp": "2020-09-01T03:30:44.414999961Z",
  "severity": "ERROR",
  "logName": "projects/stack-doctor/logs/bunyan_log",
  "receiveTimestamp": "2020-09-01T03:30:46.182157077Z"
}

En función de estas entradas, puedes crear métricas basadas en registros que cuenten todas las solicitudes, cuenten los errores y realicen un seguimiento de la latencia de las solicitudes. Luego, puedes usar las métricas basadas en registros para crear SLI de disponibilidad y latencia.

Crea métricas basadas en registros para SLI

Antes de crear SLI con métricas basadas en registros, debes crear las métricas basadas en registros.

Para los SLI de disponibilidad con recuentos de solicitudes y errores, usa métricas de contador basadas en registros.
Para los SLI de latencia, usa métricas de distribución basadas en registros.

Después de crear las métricas basadas en registros, puedes encontrarlas en Monitoring si las buscas en el Explorador de métricas. En Monitoring, las métricas basadas en registros tienen el prefijo logging.googleapis.com/user.

Métricas para SLI de disponibilidad

Expresas un SLI de disponibilidad basado en solicitudes en la API de Cloud Monitoring mediante la estructura TimeSeriesRatio para configurar una proporción de solicitudes “correctas” o “incorrectas” en relación con el total. Esta proporción se usa en el campo goodTotalRatio de una estructura RequestBasedSli.

Debes crear métricas de contador basadas en registros que se puedan usar para construir esta proporción. Debes crear al menos dos de los siguientes elementos:

Una métrica que contabiliza el total de eventos. Usa esta métrica en la totalServiceFilter de la proporción.

Para el ejemplo "stack-doctor", puedes crear una métrica basada en registros que cuenta las entradas de registro en las que aparece la string de mensajes "solicitud realizada".
En una métrica que cuenta los eventos “incorrectos”, usa esta métrica en la badServiceFilter de la proporción.

Para el ejemplo "stack-doctor", puedes crear una métrica basada en registros que cuenta las entradas de registro en las que aparece la string de mensajes "¡Error!".
En una métrica que cuenta los eventos “correctos”, usa esta métrica en el goodServiceFilter de la proporción.

Para el ejemplo "stack-doctor", puedes crear una métrica basada en registros que cuenta las entradas de registro en las que aparece la string de mensajes "¡Es un éxito!".

El SLI descrito para este ejemplo se basa en una métrica de las solicitudes totales llamada log_based_total_requests y una métrica de errores llamado log_based_errors.

Puedes crear métricas basadas en registros mediante la consola de Google Cloud, la API de Cloud Logging o la CLI de Google Cloud. Para crear métricas de contador basadas en registros mediante la consola de Google Cloud, puedes usar el siguiente procedimiento:

En el panel de navegación de la consola de Google Cloud, selecciona Logging y, luego, Métricas basadas en registros:
Ir a Métricas basadas en registros

En la página de métricas basadas en registros, se muestra una tabla de métricas definidas por el usuario y una tabla de métricas definidas por el sistema.
Haz clic en la opción Crear métrica ubicada sobre la tabla de métricas definidas por el usuario.
En el panel Tipo de métrica, selecciona Contador.
En el panel Detalles, asígnale un nombre a tu métrica nueva. En el ejemplo de “stack-doctor”, ingresa log_based_total_requests o log_based_errors.

Puedes ignorar los otros campos de este ejemplo.
En el panel Selección de filtro, crea una consulta que recupere solo las entradas de registro que deseas contar en tu métrica.

Para el ejemplo "stack-doctor", la consulta de log_based_total_requests podría incluir lo siguiente:
```
resource.type="global"
logName="projects/stack-doctor/logs/bunyan_log"
jsonPayload.message="request made"
```
La consulta de logs_based_errors cambia la string del mensaje:
```
resource.type="global"
logName="projects/stack-doctor/logs/bunyan_log"
jsonPayload.message="failure!"
```
Haz clic en Obtener vista previa de los registros para verificar el filtro y ajustarlo si es necesario.
Ignora el panel Etiquetas para este ejemplo.
Haz clic en Crear métrica para finalizar el procedimiento.

Para obtener más información sobre cómo crear métricas de contador basadas en registros, consulta Crea una métrica de contador.

Métricas de SLI de latencia

Expresas un SLI de latencia basado en solicitudes en la API de Cloud Monitoring mediante una estructura DistributionCut, que se usa en el campo distributionCut de una estructura RequestBasedSli. Debes crear una métrica de distribución basada en registros para crear un SLI de latencia. En este ejemplo, se crea una métrica de distribución basada en registros llamada log_based_latency..

Puedes crear métricas basadas en registros mediante la consola de Google Cloud, la API de Cloud Logging o la CLI de Google Cloud. Para crear métricas de distribución basadas en registros mediante la consola de Google Cloud, puedes usar el siguiente procedimiento:

En el panel de navegación de la consola de Google Cloud, selecciona Logging y, luego, Métricas basadas en registros:
Ir a Métricas basadas en registros

En la página de métricas basadas en registros, se muestra una tabla de métricas definidas por el usuario y una tabla de métricas definidas por el sistema.
Haz clic en la opción Crear métrica ubicada sobre la tabla de métricas definidas por el usuario.
En el panel Tipo de métrica, selecciona Distribución.
En el panel Detalles, asígnale un nombre a tu métrica nueva. En el ejemplo de “stack-doctor”, ingresa log_based_latency.

Puedes ignorar los otros campos de este ejemplo.
En el panel Selección de filtro, crea una consulta que recupere solo las entradas de registro que deseas contar en tu métrica.

Para el ejemplo "stack-doctor", la consulta de log_based_latency podría incluir lo siguiente:
```
resource.type="global"
logName="projects/stack-doctor/logs/bunyan_log"
jsonPayload.message="slept for"
```
Especifica los siguientes campos para la consulta de filtro:
- Nombre del campo: json.message
- Expresión regular: \s(\d*)\s
  
  La string de mensaje para las solicitudes completadas tiene el formato “slept for n ms”. La expresión regular extrae el valor de latencia n de la string.
Ignora el panel Etiquetas para este ejemplo.
Haz clic en Crear métrica para finalizar el procedimiento.

Para obtener más información sobre la creación de métricas de distribución basadas en registros, consulta Crea métricas de distribución.

SLI de disponibilidad

En Cloud Monitoring, expresas un SLI de disponibilidad basado en solicitudes mediante una estructura TimeSeriesRatio. En el siguiente ejemplo, se muestra un SLO que usa las métricas log_based_total_requests y log_based_errors en la proporción. Este SLO espera que la proporción entre las solicitudes “correctas” y el total, sea de no menos del 98% durante un período progresivo de 24 horas:

{
 "serviceLevelIndicator": {
   "requestBased": {
     "goodTotalRatio": {
       "totalServiceFilter":
         "metric.type=\"logging.googleapis.com/user/log_based_total_requests\"
          resource.type=\"global\"",
       "badServiceFilter":
         "metric.type=\"logging.googleapis.com/user/log_based_errors\"
          resource.type=\"global\""
     }
   }
 },
 "goal": 0.98,
 "rollingPeriod": "86400s",
 "displayName": "Log-Based Availability"
}

SLI de latencia

En Cloud Monitoring, expresas un SLI de latencia basado en solicitudes mediante una estructura DistributionCut. En el siguiente ejemplo, se muestra un SLO que usa la métrica log_based_latency y espera que el 98% de las solicitudes sean inferiores a 500 ms durante un período progresivo de 24 horas:

{
  "serviceLevelIndicator": {
    "requestBased": {
      "distributionCut": {
        "distributionFilter":
          "metric.type=\"logging.googleapis.com/user/log_based_latency\"
          resource.type=\"global\"",
        "range": {
          "min": 0,
          "max": 500
        }
      }
    }
  },
  "goal": 0.98,
  "rollingPeriod": "86400s",
  "displayName": "98% requests under 500 ms"
}