Ejemplos

En esta página, se proporciona una introducción al lenguaje de consulta de Monitoring (MQL) mediante una serie de ejemplos. No se intenta abarcar todos los aspectos del lenguaje. MQL se documenta de manera integral en la referencia del lenguaje de consulta de Monitoring.

Puedes escribir una consulta específica de muchas formas. El lenguaje es muy flexible, y hay muchas combinación de teclas que puedes usar una vez que estés familiarizado con la sintaxis. Para obtener más información, lee Consultas estrictas y concisas.

Antes de comenzar

En estos ejemplos, se usa la pestaña del Editor de consultas en el Explorador de métricas. Para ejecutarlas, pega la consulta en el editor y haz clic en Ejecutar consulta. Para obtener una introducción a este editor, consulta Usa el Editor de consultas.

Es útil si estás familiarizado con algunos conceptos de Cloud Monitoring, incluidos los tipos de métricas, los tipos de recursos supervisados y las series temporales. Para obtener una introducción a estos conceptos, consulta Métricas, series temporales y recursos.

Modelo de datos

Las consultas de MQL recuperan y manipulan datos en la base de datos de series temporales de Cloud Monitoring. En esta sección, se presentan algunos de los conceptos y la terminología que están relacionados con esa base de datos. Para obtener información detallada, consulta el tema de referencia Modelo de datos.

Cada serie temporal se origina a partir de un solo tipo de recurso supervisado y recopila datos de un tipo de métrica. Los tipos de métricas y recursos supervisados tienen una estructura estándar, que está definida por un descriptor de recursos supervisados y un descriptor de métricas. Por ejemplo, el tipo de recurso podría ser gce_instance, una VM de Compute Engine, y el tipo de métrica podría ser compute.googleapis.com/instance/cpu/utilization, el uso de CPU de la VM de Compute Engine.

Estos descriptores también especifican un conjunto de etiquetas que se usan para recopilar información sobre otros atributos de la métrica o el tipo de recurso. Por ejemplo, los recursos suelen tener una etiqueta zone, que se usa para registrar la ubicación geográfica del recurso.

Se crea una serie temporal por cada combinación de valores de las etiquetas del par que consta de un descriptor de métricas y un descriptor de recursos supervisados.

Puedes encontrar las etiquetas disponibles para el tipo de recurso en la Lista de recursos supervisados, por ejemplo, gce_instance, y para el tipo de métricas en la Lista de métricas, por ejemplo, métricas de Compute Engine.

Para obtener más información sobre los tipos de recursos y métricas y sobre las etiquetas, consulta Componentes del modelo de métricas.

En la base de datos de Cloud Monitoring, se almacenan todas las series temporales de un tipo de recursos y métricas en particular en una tabla. El tipo de recurso y métrica actúa como el identificador de la tabla. Mediante esta consulta de MQL, se recupera la tabla de las series temporales en la que se registra el uso de CPU de las instancias de Compute Engine:

fetch gce_instance::compute.googleapis.com/instance/cpu/utilization

Las series temporales individuales de la tabla se identifican con los valores escritos para las etiquetas asociadas con los tipos de métricas y recursos.

Las consultas de MQL recuperan datos de series temporales de estas tablas y los transforman en tablas de resultados. Estas tablas de resultados se pueden pasar a otras operaciones. Por ejemplo, puedes aislar las series temporales escritas mediante recursos en una zona o un conjunto de zonas en particular si pasas la tabla recuperada como una entrada a una operación filter:

fetch gce_instance::compute.googleapis.com/instance/cpu/utilization
| filter zone =~ 'us-central.*'

La consulta anterior da como resultado una tabla que contiene solo las series temporales de los recursos de una zona que comienza con us-central:

Para estructurar las consultas de MQL, se pasa el resultado de una operación como una entrada a la siguiente. Este enfoque basado en tablas te permite vincular operaciones para manipular estos datos mediante el filtrado, la selección y otras operaciones conocidas de las bases de datos, como las uniones internas y externas. También puedes ejecutar una variedad de funciones en los datos de la serie temporal, ya que se pasan de una operación a otra.

Las operaciones y las funciones disponibles en MQL están documentadas por completo en la referencia del lenguaje de consulta de Monitoring.

Estructura de la consulta

Una consulta se compone de una o más operaciones. Las operaciones están vinculadas o canalizadas entre sí, de modo que el resultado de una operación sea la entrada de la siguiente. Por lo tanto, el resultado de una consulta depende del orden de las operaciones. Las siguientes son algunas de las acciones que puedes realizar:

  • Iniciar una consulta con fetch o con alguna otra operación de selección
  • Crear una consulta con varias operaciones canalizadas entre sí
  • Seleccionar un subconjunto de información deseada con las operaciones filter
  • Agregar información relacionada con las operaciones group_by
  • Observar los valores atípicos con las operaciones top y bottom
  • Combinar varias consultas con las operaciones { ; } y join
  • Usar las funciones y la operación value para procesar las proporciones y otros valores

No todas las consultas usan todas estas opciones.

En estos ejemplos, solo se presentan algunas de las operaciones y las funciones disponibles. Para obtener información detallada sobre la estructura de las consultas de MQL, consulta el tema de referencia de la Estructura de consulta.

En estos ejemplos, no se especifican dos aspectos que podrías esperar: los intervalos de tiempo y la alineación. En las siguientes secciones, se explica por qué.

Intervalos de tiempo

Cuando usas el Editor de consultas, el intervalo de tiempo de las consultas se establece de forma implícita mediante la configuración del gráfico. Según la configuración predeterminada, el intervalo de tiempo del gráfico es de 1 hora. Para obtener más información sobre los intervalos de tiempo del Editor de consultas, consulta Intervalos de tiempo, gráficos y el Editor de consultas.

Alineación

Muchas de las operaciones que se usan en estos ejemplos, como las operaciones join y group_by, dependen de todos los puntos de serie temporal de una tabla que ocurren en intervalos regulares. La acción de hacer que todos los puntos estén alineados en marcas de tiempo regulares se denomina alineación. Por lo general, se hace de forma implícita. No se muestra en ninguno de estos ejemplos.

MQL alinea automáticamente las tablas de las operaciones join y group_by, si es necesario, pero también te permite realizar la alineación de manera explícita.

  • Para obtener información general sobre el concepto de alineación, consulta Alineación: agregación dentro de series.

  • Para obtener información sobre la alineación en MQL, consulta el tema de referencia de la Alineación. La alineación se puede controlar de forma explícita mediante las operaciones align y every.

Recuperación y filtrado

Las consultas de MQL comienzan con la recuperación y la selección o el filtrado de los datos. En esta sección, se ilustran algunos procesos básicos de recuperación, agrupación y filtrado con MQL.

Recupera datos de series temporales

Una consulta siempre comienza con una operación fetch, que recupera series temporales del almacén de datos de Cloud Monitoring.

La consulta más simple consiste en una sola operación fetch y un argumento que identifica la serie temporal que se debe obtener, como la siguiente:

fetch gce_instance::compute.googleapis.com/instance/cpu/utilization

El argumento consta de un tipo de recursos supervisados, gce_instance, un par de caracteres de dos puntos, ::, y un tipo de métricas, compute.googleapis.com/instance/cpu/utilization.

Mediante esta consulta, se recuperan todas las series temporales escritas por instancias de Compute Engine para el tipo de métricas compute.googleapis.com/instance/cpu/utilization, que registra el uso de CPU de esas instancias.

Si ejecutas la consulta desde el Editor de consultas en el Explorador de métricas, obtendrás un gráfico en el que se muestra cada una de las series temporales solicitadas:

Gráfico en el que se muestran los datos de uso de CPU de las instancias de Compute Engine

Cada una de las series temporales solicitadas se muestra como una línea en el gráfico. En cada serie temporal, se incluye una lista de valores con marcas de tiempo de la métrica de uso de CPU de una instancia de VM en este proyecto.

En el almacenamiento de backend que usa Cloud Monitoring, las series temporales se almacenan en tablas. La operación fetch organiza las series temporales de los tipos de métricas y recursos supervisados especificados en una tabla, que luego muestra la operación fetch. Los datos que se muestran figuran en el gráfico.

La operación fetch se describe, junto con sus argumentos, en la página de referencia de fetch. Para obtener más información sobre los datos producidos por las operaciones, consulta las páginas de referencia de las series temporales y las tablas.

Filtros

Por lo general, las consultas constan de varias operaciones combinadas. La combinación más simple consiste en la canalización del resultado de una operación en la entrada de la siguiente mediante el operador de canalización, |. En el siguiente ejemplo, se ilustra el uso de una canalización destinada a ingresar la tabla en una operación de filtrado:

fetch gce_instance::compute.googleapis.com/instance/cpu/utilization
| filter instance_name =~ 'gke.*'

Esta consulta canaliza la tabla, que muestra la operación fetch en el ejemplo anterior, en una operación filter, que toma como una expresión que se evalúa como un valor booleano, en este caso, "instance_name inicia con gke".

La operación filter toma la tabla de entrada, quita la serie temporal para la que el filtro es falso y muestra la tabla resultante. En la siguiente captura de pantalla, se muestra el gráfico resultante:

En el gráfico, se muestran los resultados filtrados por

Si no tienes ningún nombre de instancia que comience con gke, cambia el filtro antes de probar esta consulta. Por ejemplo, si tienes instancias de VM con apache al comienzo de sus nombres, usa el siguiente filtro:

 | filter instance_name =~ 'apache.*'

La expresión filter se evalúa una vez en cada serie temporal de entrada. Si la expresión se evalúa como true, esa serie temporal se incluirá en el resultado. En este ejemplo, la expresión de filtrado hace coincidir una expresión regular, =~, en la etiqueta instance_name de cada serie temporal. Si el valor de la etiqueta coincide con la expresión regular 'gke.*', la serie temporal se incluirá en el resultado. De lo contrario, la serie temporal se descartará del resultado.

Para obtener más información sobre los filtros, consulta la página de referencia de filter. El predicado filter puede ser cualquier expresión arbitraria que muestre un valor booleano. Para obtener más información, consulta Expresiones.

Agrupación y agregación

La agrupación te permite agrupar series temporales en dimensiones específicas. Mediante la agregación, se combinan todas las series temporales de un grupo en una serie temporal de salida.

Mediante la siguiente consulta, se filtra el resultado de la operación inicial fetch con el fin de retener solo esas series temporales de los recursos en una zona que comienza con us-central. Luego, se agrupan las series temporales por zona y las combina mediante la agregación mean.

fetch gce_instance::compute.googleapis.com/instance/cpu/utilization
| filter zone =~ 'us-central.*'
| group_by [zone], mean(val())

En la tabla resultante de la operación group_by, hay una serie temporal por zona. En la siguiente captura de pantalla, se muestra el gráfico resultante:

En el gráfico, se muestra una recuperación filtrada agrupada por zona

La operación group_by toma dos argumentos, separados por una coma (,). Estos argumentos determinan el comportamiento preciso de la agrupación. En este ejemplo, group_by [zone], mean(val()), los argumentos actúan de la siguiente manera:

  • Mediante el primer argumento, [zone], se controla la agrupación de las series temporales. Esta es una expresión del mapa y, en este caso, especifica las etiquetas que se deben usar para la agrupación. El paso de agrupación recopila todas las series temporales de entrada que tienen los mismos valores zone de salida en un grupo, en este caso, la serie temporal recopilada de las VM de Compute Engine en una zona.

    La serie temporal de salida solo tiene una etiqueta zone, con el valor de copiado de la serie temporal de entrada en el grupo. Las otras etiquetas de la serie temporal de entrada se descartan de la serie temporal de salida.

    La expresión del mapa puede hacer mucho más que enumerar etiquetas. Para obtener más información, consulta la página de referencia de map.

  • El segundo argumento, mean(val()), controla cómo se combinan las series temporales de cada grupo o cómo se agregan en una serie temporal de salida. Cada punto en la serie temporal de salida de un grupo es el resultado del agregado de los puntos con la misma marca de tiempo de todas las series temporales de entrada en el grupo.

    El valor resultante de la agregación se determina mediante la función de agregación aplicada, que es mean en este ejemplo. La función se aplica a los valores de los puntos que se deben agregar, que muestra la función val(). En este ejemplo, obtienes la media del uso de CPU de las máquinas virtuales de la zona en cada punto de salida.

    La expresión mean(val()) es un ejemplo de una expresión de agregación.

Mediante la operación group_by, siempre se combina la agrupación y la agregación. Si especificas una agrupación, pero omites el argumento de agregación, group_by usa una agregación predeterminada, aggregate(val()), que selecciona una función adecuada para el tipo de datos. Consulta aggregate para ver la lista de las funciones de agregación predeterminadas.

Selecciona series temporales

En los ejemplos de esta sección, se ilustran formas de seleccionar series temporales específicas de una tabla de entrada.

Selecciona series temporales superiores o inferiores

Para ver los datos de las series temporales de las tres instancias de Compute Engine con el uso de CPU más alto dentro de tu proyecto, ingresa la siguiente consulta:

fetch gce_instance::compute.googleapis.com/instance/cpu/utilization
| top 3

En la siguiente captura de pantalla, se muestra el resultado de un proyecto:

Gráfico en el que se muestran las 3 series temporales de mayor uso

Puedes recuperar las series temporales con el menor uso de CPU si reemplazas top por bottom.

La operación top genera una tabla con una cantidad específica de series temporales seleccionadas de su tabla de entrada. Las series temporales incluidas en el resultado tienen el valor más alto en algún aspecto de la serie temporal. Aquí, el argumento 3 indica que se deben seleccionar tres series temporales.

Como esta consulta no especifica una forma de ordenar las series temporales, las muestra con el valor más grande en el punto más reciente. De manera opcional, puedes otorgar un argumento adicional a la operación top: una expresión que especifica cómo determinar qué serie temporal es la más grande. La consulta anterior es equivalente a la siguiente:

fetch gce_instance::compute.googleapis.com/instance/cpu/utilization
| top 3, val()

Mediante la expresión val(), se selecciona el valor del punto más reciente en cada serie temporal en la que se aplica, por lo que la consulta muestra las que tienen el valor más grande en el punto más reciente.

Puedes proporcionar una expresión que realice la agregación en algunos o en todos los puntos de una serie temporal para proporcionar el valor de ordenamiento. A continuación, se muestra la media de todos los puntos en los últimos 10 minutos:

fetch gce_instance::compute.googleapis.com/instance/cpu/utilization
| top 3, mean(val()).within(10m)

Si no se usa la función within, la función mean se aplica a los valores de todos los puntos que se muestran en la serie temporal.

La operación bottom funciona de manera similar. Mediante la siguiente consulta, se encuentra el valor del punto más grande de cada serie temporal con max(val()) y, luego, se seleccionan las tres series temporales en las que ese valor es el menor:

fetch gce_instance::compute.googleapis.com/instance/cpu/utilization
| bottom 3, max(val())

Esto se puede considerar como las transmisiones con los menores aumentos. En la siguiente captura de pantalla, se muestra un gráfico resultante:

Gráfico en el que se muestran las 3 series temporales de mayor uso

Selecciona el superior o el inferior de los grupos

Las operaciones de tabla top y bottom seleccionan series temporales de toda la tabla de entrada. Las operaciones top_by y bottom_by agrupan las series temporales en una tabla y, luego, eligen algunas de ellas.

Mediante la siguiente consulta, se seleccionan las series temporales de cada zona con el valor máximo más alto y lo siguiente:

fetch gce_instance::compute.googleapis.com/instance/cpu/utilization
| top_by [zone], 1, max(val())

Gráfico en el que se muestra el aumento más alto por zona

La expresión [zone] indica que un grupo consta de todas las series temporales con el mismo valor de la columna zone. El 1 en el top_by indica cuántas series temporales se deben seleccionar del grupo de cada zona. Mediante la expresión max(val()), se busca el valor más grande del rango de tiempo del gráfico en cada serie temporal.

Puedes usar cualquier función de agregación en lugar de max. Por ejemplo, a continuación, se usa el agregador mean y se usa within para especificar el rango de ordenamiento de 20 minutos. Se seleccionan las 2 series temporales principales de cada zona:

fetch gce_instance::compute.googleapis.com/instance/cpu/utilization
| top_by [zone], 2, mean(val()).within(20m)

Gráfico en el que se muestra los 2 aumentos medios más grandes por zona en 20 minutos

Ten en cuenta que solo hay una instancia en la zona us-central-c, por lo que se muestra una sola serie temporal. No hay "2 superiores" en el grupo.

Combina selecciones mediante union

Puedes combinar operaciones de selección como top y bottom para crear gráficos en los que se muestren ambos. Por ejemplo, mediante la siguiente consulta, se muestra la serie temporal única con el valor máximo y la serie temporal única con el valor mínimo:

fetch gce_instance::compute.googleapis.com/instance/cpu/utilization
| {
    top 1, max(val())
  ;
    bottom 1, min(val())
  }
| union

En el gráfico resultante, se muestran dos líneas, la que contiene el valor más alto y la que contiene el valor más bajo:

En el gráfico, se muestran las series temporales con los valores más altos y los más bajos.

Puedes usar llaves, { }, para especificar secuencias de operaciones, cada una de las cuales produce una tabla de series temporales como resultado. Las operaciones individuales están separadas por dos puntos, ;.

En este ejemplo, la operación fetch muestra una sola tabla, que se canaliza a cada una de las dos operaciones de la secuencia, una operación top y una operación bottom. Cada una de estas operaciones genera una tabla de resultados basada en la misma tabla de entrada. Luego, la operación union combina las dos tablas en una, que se muestra en el gráfico.

Obtén más información sobre la secuencia de varias operaciones mediante { } en el tema de referencia de la Estructura de consulta.

Calcula proporciones

Supongamos que compilaste un servicio web distribuido que se ejecuta en instancias de VM de Compute Engine y usa Cloud Load Balancing.

Deseas ver un gráfico en el que se muestre la proporción de solicitudes que muestran respuestas 500 HTTP (errores internos) con respecto a la cantidad total de solicitudes, es decir, la proporción entre solicitud y falla. En esta sección, se ilustran varias maneras de calcular la proporción entre las solicitudes y las fallas.

Cloud Load Balancing usa el tipo de recurso supervisado http_lb_rule. El tipo de recurso supervisado http_lb_rule tiene una etiqueta matched_url_path_rule que registra el prefijo de URL definido en la regla. El valor predeterminado es UNMATCHED.

El tipo de métrica loadbalancing.googleapis.com/https/request_count tiene una etiqueta response_code_class. Esta etiqueta captura la clase de los códigos de respuesta.

Usa outer_join y div

Mediante la siguiente consulta, se determinan las respuestas 500 para cada valor de la etiqueta matched_url_path_rule en cada recurso supervisado http_lb_rule de tu proyecto. Luego, se une esta tabla de recuento de fallas con la tabla original, que contiene los recuentos de todas las respuestas, y se dividen los valores para mostrar la proporción de las respuestas de falla con el total de respuestas:

fetch https_lb_rule::loadbalancing.googleapis.com/https/request_count
| {
    filter response_code_class = 500
  ;
    ident
  }
| group_by [matched_url_path_rule]
| outer_join 0
| div

En el siguiente gráfico, se muestra el resultado de un proyecto:

Gráfico en el que se muestra la proporción entre las fallas y el total de la solicitud mediante la unión

La operación fetch da como resultado una tabla de series temporales que contiene los recuentos de solicitudes de todas las consultas de balanceo de cargas. Esta tabla se procesa de dos maneras mediante las dos secuencias de operaciones entre llaves.

  • filter response_code_class = 500 muestra solo las series temporales que tienen la etiqueta response_code_class con el valor 500. La serie temporal resultante cuenta las solicitudes con códigos de respuesta HTTP 5xx (de error).

    Esta tabla es el numerador de la proporción.

  • La operación ident o de identidad muestra su entrada, por lo que muestra la tabla recuperada originalmente. Esa es la tabla que contiene las series temporales con recuentos para cada código de respuesta.

    Esta tabla es el denominador de la proporción.

Las tablas del numerador y el denominador, producidas por las operaciones filter y ident respectivamente, se procesan por separado mediante la operación group_by. La operación group_by agrupa las series temporales de cada tabla por el valor de la etiqueta matched_url_path_rule y suma los recuentos de cada valor de la etiqueta. En esta operación group_by, no se indica de manera explícita la función de agregador, por lo que se usa un valor predeterminado sum.

  • En la tabla filtrada, el resultado group_by es la cantidad de solicitudes que muestran una respuesta 500 para cada valor matched_url_path_rule.

  • En la tabla de identidad, los resultados de group_by son la cantidad total de solicitudes para cada valor matched_url_path_rule.

Estas tablas se canalizan a la operación outer_join, que vincula series temporales con valores de etiquetas coincidentes, una de cada una de las dos tablas de entrada. Las series temporales vinculadas se comprimen mediante la coincidencia de la marca de tiempo de cada punto temporal con la de un punto de la otra serie temporal. Para cada par de puntos coincidentes, outer_join produce un único punto de salida con dos valores, uno de cada una de las tablas de entrada. La combinación temporal con las mismas etiquetas que las dos series temporales de entrada genera la serie temporal comprimida.

Debido a que esta es una combinación externa, si un punto de la segunda tabla no tiene un punto coincidente en la primera, se debe proporcionar un valor de reemplazo. En este ejemplo, se usa un punto con el valor 0, el argumento de la operación outer_join.

Finalmente, la operación div toma cada punto con dos valores y divide los valores a fin de producir un único punto de salida: la proporción de 500 respuestas a todas las respuestas para cada mapa de URL.

En este caso, la string div es en realidad el nombre de la función div, que divide dos valores numéricos. Pero aquí se usa como una operación. Cuando se usan como operaciones, las funciones como div esperan dos valores en cada punto de entrada (que garantiza este objeto join) y producen un solo valor para el punto de salida correspondiente.

La parte | div de la consulta es un acceso directo para | value val(0) / val(1). La operación value permite que las expresiones arbitrarias de las columnas de valores de una tabla de entrada produzcan las columnas de valores de la tabla de salida. Para obtener más información, consulta las páginas de referencia de la operación value y de las expresiones.

Usando el repositorio ratio

La función div podría reemplazarse por cualquier función en dos valores, pero como las proporciones se usan con frecuencia, MQL proporciona una operación de tabla ratio que calcula las proporciones de forma directa.

La siguiente consulta es equivalente a la versión anterior mediante el uso de outer_join y div:

fetch https_lb_rule::loadbalancing.googleapis.com/https/request_count
| {
    filter response_code_class = 500
  ;
    ident
  }
| group_by [matched_url_path_rule]
| ratio

En esta versión, la operación ratio reemplaza las operaciones outer_join 0 | div de la versión anterior y produce el mismo resultado.

Usa group_by y /

Existe otra forma de calcular la proporción entre las respuestas de error y todas las respuestas. En este caso, debido a que el numerador y denominador de la proporción se derivan de la misma serie temporal, también puedes calcular la proporción mediante solo la agrupación. Mediante la siguiente consulta, se demuestra este enfoque:

fetch https_lb_rule::loadbalancing.googleapis.com/https/request_count
| group_by [matched_url_path_rule],
    sum(if(response_code_class = 500, val(), 0)) / sum(val())

Esta consulta usa una expresión de agregación basada en la proporción de dos sumas:

  • El primer elemento sum usa la función if para contar las etiquetas con valor de 500 y 0 para las demás. La función sum calcula el recuento de las solicitudes que mostraron 500.

  • El segundo elemento sum suma los recuentos de todas las solicitudes, val().

Las dos sumas se dividen, lo que da como resultado la proporción de 500 respuestas para todas las respuestas. Esta consulta produce el mismo resultado que las consultas de Usa outer_join y div y Usa ratio.

Usando el repositorio filter_ratio_by

Debido a que las proporciones se calculan con frecuencia mediante la división de dos sumas derivadas de la misma tabla, MQL proporciona la operación filter_ratio_by para este propósito. La siguiente consulta hace lo mismo que la versión anterior, que divide las sumas de forma explícita:

fetch https_lb_rule::loadbalancing.googleapis.com/https/request_count
| filter_ratio_by [matched_url_path_rule], response_code_class = 500

El primer operando de la operación filter_ratio_by, aquí [matched_url_path_rule], indica cómo agrupar las respuestas. La segunda operación, aquí response_code_class = 500, actúa como una expresión de filtrado para el numerador.

  • La tabla del denominador es el resultado de la agrupación de la tabla recuperada por matched_url_path_rule y agregada mediante sum.
  • La tabla del numerador es la tabla recuperada, filtrada por series temporales con un código de respuesta HTTP de 5xx y, luego, agrupada por matched_url_path_rule y agregada mediante sum.

Cambio de tiempo

A veces, querrás comparar lo que sucede en el momento con lo que sucedió antes. MQL proporciona la operación de tabla time_shift para mover datos anteriores al período actual, para poder compararlos con los valores actuales.

Proporciones en el tiempo

La siguiente consulta usa time_shift, join y div para calcular la proporción del uso medio en cada zona entre el momento actual y la semana pasada.

fetch gce_instance::compute.googleapis.com/instance/cpu/utilization
| group_by [zone], mean(val())
| {
    ident
  ;
    time_shift 1w
  }
| join | div

En el siguiente gráfico, se muestra un resultado posible de esta consulta:

Gráfico en el que se muestra la proporción de los datos actuales y desplazados en el tiempo

Las dos primeras operaciones recuperan las series temporales deseadas y, luego, las agrupan por zona y calculan los valores medios para cada una. La tabla resultante se pasa a dos operaciones. La primera operación, ident, pasa la tabla sin modificaciones.

La segunda operación, time_shift, agrega el período (1 semana) a las marcas de tiempo de los valores de la tabla, que cambia los datos desde la semana anterior. Este cambio hace que las marcas de tiempo de los datos más antiguos en la segunda tabla se alineen con las marcas de tiempo de los datos actuales en la primera tabla.

La tabla sin cambios y la tabla desplazada en el tiempo se combinan mediante el uso de una join interna. La join produce una tabla de series temporales en la que cada punto tiene dos valores: el uso actual y el uso de hace una semana. Luego, la consulta usa la operación div para calcular la proporción entre el valor actual y el valor de la semana anterior.

Datos anteriores y actuales

Si combinas time_shift con union, puedes crear un gráfico en el que se muestren los datos anteriores y actuales de forma simultánea. Por ejemplo, la siguiente consulta muestra el uso promedio actual y de la semana anterior. Mediante union, puedes mostrar estos dos resultados en el mismo gráfico.

fetch gce_instance::compute.googleapis.com/instance/cpu/utilization
| group_by []
| {
     add [when: "now"]
  ;
     add [when: "then"] | time_shift 1w
  }
| union

En el siguiente gráfico, se muestra un resultado posible de esta consulta:

Gráfico en el que se muestra el uso medio actual y anterior

Esta consulta recupera las series temporales deseadas y, luego, usa group_by [] para combinarlas en una sola serie temporal sin etiquetas, lo que deja solo los datos de uso de CPU. Este resultado se pasa a dos operaciones. La primera agrega una columna para una etiqueta nueva llamada when con el valor now. La segunda agrega una etiqueta llamada when con el valor then y pasa el resultado a la operación time_shift para cambiar los valores por una semana. Esta consulta usa el modificador del mapa add. Consulta Mapas para obtener más información.

Las dos tablas, que contienen datos para una sola serie temporal, se pasan a union, que produce una tabla que contiene las series temporales de ambas tablas de entrada.

Qué sigue

Para obtener una descripción general de las estructuras del lenguaje de MQL, consulta Acerca del lenguaje de MQL.

Para obtener una descripción completa de MQL, consulta la referencia del lenguaje de consulta de Monitoring.

Para obtener información sobre cómo interactuar con gráficos, incluidos los que genera el Editor de consultas, consulta Cómo trabajar con gráficos.