Query MQL di esempio

Questo documento introduce il Monitoring Query Language (MQL) attraverso esempi. Tuttavia, non cerca di coprire tutti gli aspetti della lingua. MQL corrente completamente documentata nella documentazione di riferimento sul linguaggio di query sul monitoraggio.

Per informazioni sugli strumenti basati su MQL sui criteri di avviso, consulta Criteri di avviso con MQL.

Puoi scrivere una determinata query in molti modi: la lingua è flessibile e ci sono molte scorciatoie che puoi utilizzare dopo familiarità con la sintassi. Per ulteriori informazioni, vedi Query in formato restrittivo.

Prima di iniziare

Per accedere all'editor di codice quando utilizzi Metrics Explorer, procedi nel seguente modo: seguenti:

1. Nella console Google Cloud, vai alla Pagina Esplora metriche:

   Vai a Esplora metriche

   Se utilizzi la barra di ricerca per trovare questa pagina, seleziona il risultato con il sottotitolo Monitoraggio.

2. Nella barra degli strumenti della riquadro Query Builder, seleziona il pulsante con  MQL o  PromQL.
3. Verifica che sia selezionato MQL con l'opzione Lingua. Il pulsante di attivazione/disattivazione della lingua si trova nella stessa barra degli strumenti. consente di formattare la query.

Per eseguire una query, incollala nell'editor e fai clic su Esegui query. Per un'introduzione a questo editor, vedi Utilizza l'editor di codice per MQL.

Una certa familiarità con i concetti di Cloud Monitoring, incluse le metriche di risorse monitorate e serie temporali è utile. Per un'introduzione a questi concetti, vedi Metriche, serie temporali e risorse.

Modello dati

Le query MQL recuperano e manipolano i dati in Cloud Monitoring un database di serie temporali. Questa sezione introduce alcuni dei concetti e la terminologia correlata al database. Per informazioni dettagliate, consulta l'argomento di riferimento Modello dei dati.

Ogni serie temporale ha origine da un unico tipo di risorsa monitorata e ogni serie temporale raccoglie dati di un solo tipo di metrica. Un descrittore di risorse monitorate definisce un tipo di risorsa monitorata. Analogamente, un descrittore della metrica definisce un tipo di metrica. Ad esempio, il tipo di risorsa potrebbe essere gce_instance, un macchina virtuale (VM) Compute Engine e il tipo di metrica potrebbe essere compute.googleapis.com/instance/cpu/utilization, l'utilizzo della CPU della VM di Compute Engine.

Questi descrittori specificano anche un insieme di etichette utilizzate Raccogliere informazioni su altri attributi della metrica o della risorsa di testo. Ad esempio, le risorse in genere hanno un'etichetta zone, utilizzata per registrare la posizione geografica della risorsa.

Viene creata una serie temporale per ogni combinazione di valori per le etichette della coppia di un descrittore della metrica e di una risorsa monitorata.

Puoi trovare le etichette disponibili per i tipi di risorse nella Elenco di risorse monitorate, ad esempio gce_instance. Per trovare le etichette relative ai tipi di metriche, consulta l'Elenco delle metriche. Ad esempio, vedi le metriche di Compute Engine.

Il database Cloud Monitoring archivia le serie temporali di un determinato metrica e tipo di risorsa in una tabella. La metrica e il tipo di risorsa fungono da identificatore della tabella. Questa query MQL recupera la tabella delle serie temporali che registra l'utilizzo della CPU per Compute Engine di Compute Engine:

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

Nella tabella è presente una serie temporale per ogni combinazione unica di metrica e delle etichette delle risorse.

Le query MQL recuperano i dati delle serie temporali da queste tabelle e trasformarlo in tabelle di output. Queste tabelle di output possono essere in altre operazioni. Ad esempio, puoi isolare le serie temporali scritte dalle risorse in un particolare una zona o un insieme di zone passando la tabella recuperata come input a un'operazione filter:

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

La query precedente genera una tabella che contiene solo la serie temporale dalle risorse in una zona che inizia con us-central.

Le query MQL sono strutturate in modo da passare l'output di un'operazione come input per l'operazione successiva. Questo approccio basato su tabelle ti consente operazioni insieme per manipolare questi dati mediante filtri, selezione e altro le operazioni di database già conosciute, come inner e outer join. Puoi anche eseguire varie funzioni sui dati nelle serie temporali vengono trasferite da un'operazione all'altra.

Le operazioni e le funzioni disponibili in MQL sono completamente documentate Riferimento per il monitoraggio del linguaggio di query.

Struttura delle query

Una query è composta da una o più operazioni. Le operazioni sono collegate, o pipe, in modo che l'output di un'operazione sia l'input a quella successiva. Pertanto, il risultato di una query dipende dall'ordine delle le operazioni. Ecco alcune delle cose che puoi fare:

• Avvia una query con un'operazione di selezione fetch o un'altra.
• Crea una query con più operazioni condotte insieme.
• Seleziona un sottoinsieme di informazioni con operazioni filter.
• Aggrega le informazioni correlate con le operazioni di group_by.
• Osserva i valori anomali con le operazioni top e bottom.
• Combina più query con operazioni { ; } e join.
• Utilizza l'operazione e le funzioni value per calcolare i rapporti e altri valori.

Non tutte le query utilizzano tutte queste opzioni.

Questi esempi introducono solo alcune delle operazioni e delle funzioni disponibili. Per informazioni dettagliate sulla struttura delle query MQL, consulta l'argomento di riferimento Struttura delle query.

Questi esempi non specificano due cose che potresti aspettarti per vedere gli intervalli di tempo e l'allineamento. Le sezioni seguenti spiegano il motivo.

Intervalli di tempo

Quando utilizzi l'editor di codice, le impostazioni del grafico definiscono per le query. Per impostazione predefinita, l'intervallo di tempo del grafico è impostato su un'ora.

Per modificare l'intervallo di tempo del grafico, utilizza il selettore dell'intervallo di tempo. Per Ad esempio, se vuoi visualizzare i dati dell'ultima settimana, seleziona Ultima settimana dal selettore dell'intervallo di tempo. Puoi anche specificare un'ora di inizio e di fine o specifica un orario in cui esplorare il mondo.

Per saperne di più sugli intervalli di tempo nell'editor di codice, consulta Intervalli di tempo, grafici e l'editor di codice.

Allineamento

Molte delle operazioni utilizzate in questi esempi, ad esempio join e group_by le operazioni, dipendono da tutti i punti delle serie temporali di una tabella che si verificano a intervalli regolari. L'atto di allineare tutti i punti in modo regolare i timestamp si chiama allineamento. Di solito, l'allineamento avviene in modo implicito nessuno degli esempi qui lo mostra.

MQL allinea automaticamente le tabelle per le operazioni join e group_by se necessario, ma MQL ti consente anche di eseguire l'allineamento in modo esplicito.

• Per informazioni generali sul concetto di allineamento, consulta la sezione Allineamento: l'aggregazione all'interno della serie.

• Per informazioni sull'allineamento in MQL, consulta la documentazione di riferimento Allineamento. L'allineamento può essere controllato esplicitamente utilizzando le operazioni align e every.

Recupera e filtra i dati

Le query MQL iniziano con il recupero, la selezione o il filtro di e i dati di Google Cloud. Questa sezione illustra alcune attività di recupero e usando MQL.

Recuperare i dati delle serie temporali

Una query inizia sempre con un'operazione fetch, che recupera il tempo da Cloud Monitoring.

La query più semplice è composta da una singola operazione fetch e da un argomento identifica le serie temporali da recuperare, come la seguente:

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

L'argomento è costituito da un tipo di risorsa monitorata, gce_instance, una coppia di due caratteri, ::, e un tipo di metrica, compute.googleapis.com/instance/cpu/utilization.

Questa query recupera le serie temporali scritte dalle istanze di Compute Engine per il tipo di metrica compute.googleapis.com/instance/cpu/utilization, che registra l'utilizzo della CPU da parte di queste istanze.

Se esegui la query dall'editor di codice in Metrics Explorer, viene visualizzato un grafico che mostra ciascuna delle serie temporali richieste:

Ogni serie temporale richiesta viene visualizzata come una linea nel grafico. Ciascuna Le serie temporali includono un elenco di valori con timestamp dell'utilizzo della CPU per un'istanza VM in questo progetto.

Nello spazio di archiviazione backend utilizzato da Cloud Monitoring, le serie temporali vengono tabelle. L'operazione fetch organizza le serie temporali per l'intervallo i tipi di risorse e metriche monitorate in una tabella, quindi restituisce la tabella. I dati restituiti vengono visualizzati nel grafico.

L'operazione fetch viene descritta, insieme ai suoi argomenti, nella Pagina di riferimento fetch. Per ulteriori informazioni sul generati dalle operazioni, consulta le pagine di riferimento per le serie temporali e tabelle.

Filtra operazioni

Le query in genere consistono in una combinazione di più operazioni. Il modo più semplice combinazione consiste nel trasmettere l'output di un'operazione all'input della successiva mediante l'operatore pipe |. L'esempio seguente illustra l'utilizzo di un barra verticale per inserire la tabella in un'operazione di filtro:

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

Questa query indirizza la tabella, restituita dall'operazione fetch mostrata in precedente, in un'operazione filter che prende come espressione che restituisce un valore booleano. In questo esempio, l'espressione significa "instance_name inizia con gke".

L'operazione filter prende la tabella di input e rimuove le serie temporali per che il filtro è false e restituisce la tabella risultante. Le seguenti screenshot mostra il grafico risultante:

Se non hai nomi di istanze che iniziano con gke, modifica il filtro prima di provare questa query. Ad esempio, se disponi Per le istanze VM con apache all'inizio del nome, usa quanto segue filtro:

 | filter instance_name =~ 'apache.*'

L'espressione filter viene valutata una volta per ogni serie temporale di input. Se l'espressione restituisce true, la serie temporale è inclusa nei come output. In questo esempio, l'espressione di filtro esegue un'espressione regolare corrispondente, =~, sull'etichetta instance_name di ogni serie temporale. Se il valore dell'etichetta corrisponda all'espressione regolare 'gke.*', quindi la serie temporale è incluso nell'output. In caso contrario, le serie temporali vengono eliminate dall'output.

Per ulteriori informazioni sui filtri, consulta Pagina di riferimento filter. Il predicato filter può essere qualsiasi espressione arbitraria che restituisca un valore booleano valore; per ulteriori informazioni, consulta la sezione Espressioni.

Raggruppa e aggrega

Il raggruppamento ti consente di raggruppare le serie temporali in base a dimensioni specifiche. L'aggregazione combina tutte le serie temporali di un gruppo in un'unica serie temporale di output.

La seguente query filtra l'output dell'operazione fetch iniziale per conservare solo quelle serie temporali dalle risorse in una zona che inizia con us-central. Quindi raggruppa le serie temporali per zona e le combina utilizzando l'aggregazione mean.

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

La tabella risultante dall'operazione group_by ha una serie temporale per zona. Il seguente screenshot mostra il grafico risultante:

L'operazione group_by accetta due argomenti, separati da un virgola, ,. Questi argomenti determinano l'esatto comportamento di raggruppamento. Nel nell'esempio group_by [zone], mean(val()), gli argomenti agiscono come segue:

• Il primo argomento, [zone], è un'espressione di mappa che determina delle serie temporali. In questo esempio, specifica le etichette in per il raggruppamento. Il passaggio di raggruppamento raccoglie tutte le serie temporali di input che hanno gli stessi valori zone di output in un gruppo. In questo esempio, raccoglie le serie temporali dalle VM di Compute Engine in in una zona.

  La serie temporale di output ha solo un'etichetta zone, con il valore copiato da la serie temporale di input nel gruppo. Altre etichette nella serie temporale di input vengono eliminati dalla serie temporale di output.

  L'espressione mappa può fare molto di più che elencare le etichette; per ulteriori informazioni, consulta la pagina di riferimento di map.

• Il secondo argomento, mean(val()), determina in che modo le serie temporali in ogni vengono combinati, o aggregati, in un'unica serie temporale di output. Ciascuna punto nella serie temporale dell'output per un gruppo è il risultato dell'aggregazione i punti con lo stesso timestamp di tutte le serie temporali di input nel gruppo.

  In questo esempio, la funzione di aggregazione mean determina il valore aggregato. La funzione val() restituisce i punti da aggregare, la funzione di aggregazione viene applicata a quei punti. In questo esempio, puoi ottenere la media dell'utilizzo della CPU di macchine nella zona in ogni punto temporale di output.

  L'espressione mean(val()) è un esempio espressione di aggregazione.

L'operazione group_by combina sempre il raggruppamento e l'aggregazione. Se specifichi un raggruppamento ma ometti l'argomento di aggregazione, group_by utilizza un'aggregazione predefinita, aggregate(val()), che seleziona un'aggregazione appropriata per il tipo di dati. Consulta l'elenco a aggregate delle funzioni di aggregazione predefinite.

Utilizza group_by con una metrica basata su log

Supponi di aver creato una metrica basata su log di distribuzione per estrarre il numero di punti dati elaborati da un insieme di voci lunghe che includono stringhe come seguenti:

... entry ID 1 ... Processed data points 1000 ...
... entry ID 2 ... Processed data points 1500 ...
... entry ID 3 ... Processed data points 1000 ...
... entry ID 4 ... Processed data points 500 ...

Per creare una serie temporale che mostri il conteggio di tutti i punti dati elaborati, un MQL come il seguente:

fetch global
| metric 'logging.googleapis.com/user/metric_name'
| group_by [], sum(sum_from(value))

Per creare una metrica di distribuzione basata su log, consulta Configurare le metriche di distribuzione.

Escludi le colonne da un gruppo

Puoi utilizzare il modificatore drop in una mappatura per escludere le colonne da una gruppo. Ad esempio, la metrica core_usage_time di Kubernetes ha sei colonne:

fetch k8s_container :: kubernetes.io/container/cpu/core_usage_time
| group_by [project_id, location, cluster_name, namespace_name, container_name]

Se non è necessario raggruppare pod_name, puoi escluderlo con drop:

fetch k8s_container :: kubernetes.io/container/cpu/core_usage_time
| group_by drop [pod_name]

Seleziona serie temporale

Gli esempi in questa sezione illustrano come selezionare un periodo di tempo specifico da una tabella di input.

Seleziona serie temporali superiore o inferiore

Per vedere i dati delle serie temporali per i tre modelli di Compute Engine istanze con il massimo utilizzo di CPU all'interno del progetto, inserisci seguente query:

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

Il seguente screenshot mostra il risultato di un progetto:

Puoi recuperare le serie temporali con l'utilizzo più basso della CPU: sostituzione di top con bottom.

L'operazione top genera una tabella con un numero specificato di serie temporale selezionata dalla relativa tabella di input. Le serie temporali incluse nel hanno il valore più grande per alcuni aspetti delle serie temporali.

Poiché questa query non specifica un modo per ordinare le serie temporali, restituisce le serie temporali con il valore più grande per il punto più recente. Per specificare come determinare quali serie temporali hanno il valore maggiore, può fornire un argomento all'operazione top. Ad esempio, query precedente equivale alla seguente query:

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

L'espressione val() seleziona il valore del punto più recente in ogni la serie temporale a cui è applicata. Di conseguenza, la query restituisce le serie temporali con il valore più alto per il punto più recente.

Puoi fornire un'espressione che esegua l'aggregazione su alcuni o tutti i punti in una serie temporale per assegnare il valore di ordinamento. Quanto segue prende la media di tutti i punti negli ultimi 10 minuti:

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

Se non viene utilizzata la funzione within, la funzione mean viene applicata ai valori di tutti i punti visualizzati nella serie temporale.

L'operazione bottom funziona in modo simile. La seguente query trova il valore del punto più grande in ogni serie temporale con max(val()), poi seleziona le tre serie temporali per le quali il valore è più piccolo:

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

Il seguente screenshot mostra un grafico che mostra gli stream con ai picchi più piccoli:

Escludi i risultati in alto o in basso n nelle serie temporali

Considera uno scenario in cui hai molte istanze VM di Compute Engine. Alcune di queste istanze consumano molta più memoria della maggior parte delle istanze, e questi outlier rendono più difficile vedere i modelli di utilizzo gruppo più ampio. I grafici sull'utilizzo della CPU hanno il seguente aspetto:

È consigliabile escludere i tre outlier dal grafico in modo da poter vedere gli schemi nel gruppo più ampio.

Per escludere le prime tre serie temporali in una query che recupera le serie temporali Per l'utilizzo della CPU di Compute Engine, usa l'operazione di tabella top per identificare le serie temporali e l'operazione della tabella outer_join per escludere dai risultati le serie temporali identificate. Puoi utilizzare lo seguente query:

fetch gce_instance::compute.googleapis.com/instance/cpu/utilization
| {
    top 3 | value [is_default_value: false()]
  ;
    ident
  }
| outer_join true(), _
| filter is_default_value
| value drop [is_default_value]

L'operazione fetch restituisce una tabella delle serie temporali per l'utilizzo della CPU da tutte le istanze. Questa tabella viene quindi elaborata in due tabelle risultanti:

• L'operazione della tabella top n genera una tabella che contiene il valore n serie con i valori più alti. In questo caso, n = 3. Il risultato contiene le tre serie temporali da escludere.

  La tabella contenente le prime tre serie temporali viene quindi confluita in una Operazione nella tabella value. Questa operazione aggiunge un'altra colonna a ciascuna delle serie temporali nella tabella delle prime tre. In questa colonna, A is_default_value, viene assegnato il valore booleano false per tutti serie temporali nella tabella delle prime tre.

• L'operazione ident restituisce la stessa tabella che è stata inoltrata al suo interno: la tabella originale delle serie temporali di utilizzo della CPU. Nessuna volta serie in questa tabella hanno la colonna is_default_value.

Le prime tre tabelle e la tabella originale vengono quindi inserite nel Operazione nella tabella outer_join. La terza tabella è quella di sinistra nel join, la tabella recuperata è quella giusta nel join. Il join esterno è configurato per fornire il valore true come valore per campo non esistente in una riga di cui viene unita. Il risultato outer join è una tabella unita, con le righe delle prime tre tabelle che mantengono la colonna is_default_value con il valore false e tutte le righe da la tabella originale che non era anch'essa nelle prime tre, ottenendo il valore is_default_value con il valore true.

La tabella risultante dal join viene quindi passata a filter operativa, che filtra le righe contenenti valore di false nella colonna is_default_value. La tabella risultante contiene le righe della tabella recuperata originariamente senza le righe dalla tabella delle prime tre. Questa tabella contiene l'insieme previsto di serie temporali, con l'aggiunta di is_default_column.

Il passaggio finale consiste nel rilasciare la colonna is_default_column aggiunta da il join, quindi la tabella di output ha le stesse colonne della sorgente recuperata .

Il seguente screenshot mostra il grafico della query precedente:

Puoi creare una query per escludere le serie temporali con il valore Utilizzo della CPU sostituendo top n con bottom n.

La possibilità di escludere gli outlier può essere utile nei casi in cui vuoi impostare un avviso senza che i valori anomali lo attivino costantemente. La seguente query di avviso utilizza la stessa logica di esclusione della query per monitorare l'utilizzo dei limiti di CPU da parte di un insieme di pod Kubernetes dopo aver escluso i primi due pod:

fetch k8s_container
| metric 'kubernetes.io/container/cpu/limit_utilization'
| filter (resource.cluster_name == 'CLUSTER_NAME' &&
          resource.namespace_name == 'NAMESPACE_NAME' &&
          resource.pod_name =~ 'POD_NAME')
| group_by 1m, [value_limit_utilization_max: max(value.limit_utilization)]
| {
    top 2 | value [is_default_value: false()]
  ;
    ident
  }
| outer_join true(), _
| filter is_default_value
| value drop [is_default_value]
| every 1m
| condition val(0) > 0.73 '1'

Seleziona in alto o in basso dai gruppi

Le operazioni tabella top e bottom selezionano le serie temporali dall'intera una tabella di input. top_by e bottom_by operazioni raggruppano le serie temporali in una tabella, quindi selezionano un certo numero serie temporali di ogni gruppo.

La query seguente seleziona le serie temporali in ciascuna zona con valore di picco:

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

L'espressione [zone] indica che un gruppo è composto da la serie temporale con lo stesso valore della colonna zone. Il 1 nel top_by indica quante serie temporali selezionare da ogni gruppo della zona. L'espressione max(val()) cerca il valore più grande in intervallo di tempo del grafico in ogni serie temporale.

Puoi utilizzare qualsiasi funzione di aggregazione al posto di max. Ad esempio, quanto segue utilizza l'aggregatore mean e utilizza within per specificare un intervallo di ordinamento di 20 minuti. Seleziona le prime 2 serie temporali in ciascuna zona:

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

Nell'esempio precedente, esiste solo un'istanza nella zona us-central-c, viene restituita solo una serie temporale; non esiste una "top 2" nel gruppo.

Combina le selezioni con union

Puoi combinare operazioni di selezione come top e bottom per creare grafici che mostrano entrambi. Ad esempio, la seguente query restituisce il singolo la serie temporale con il valore massimo e la singola serie temporale con il valore minimo valore:

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

Nota: il rientro e l'allineamento dei componenti della query sono per la leggibilità. MQL non è una lingua dipendente dallo spazio.

Il grafico risultante mostra due linee, quella contenente il valore più alto e quella con il valore più basso:

Puoi utilizzare le parentesi graffe, { }, per specificare sequenze di operazioni, ciascuna che genera una tabella di serie temporali come output. Le singole operazioni vengono separate da un punto e virgola, ;.

In questo esempio, l'operazione fetch restituisce una singola tabella, che viene inviato tramite pipe a ciascuna delle due operazioni nella sequenza, un'operazione top e un'operazione bottom. Ognuna di queste operazioni genera una tabella di output in base alla stessa tabella di input. L'operazione union combina quindi le due tabelle in una, che viene visualizzata nel grafico.

Scopri di più sulle operazioni di sequenza utilizzando { } nel riferimento nell'argomento Struttura della query.

Combinare serie temporali con valori diversi per un'unica etichetta

Supponi di avere più serie temporali per lo stesso tipo di metrica e vuoi combinarne alcuni. Se vuoi selezionarli in base ai valori di una singola etichetta, non puoi creare la query utilizzando l'interfaccia di Query Builder in Metrics Explorer. Devi filtrare in base a due o più valori diversi della stessa etichetta, ma lo strumento richiede che una serie temporale corrisponda a tutti i filtri da selezionare: la corrispondenza delle etichette è un test AND. Nessuna serie temporale può avere due diversi valori per la stessa etichetta, ma non puoi creare un test OR per i filtri in Query Builder.

La seguente query recupera le serie temporali per l'istanza Compute Engine Metrica instance/disk/max_read_ops_count per due Compute Engine specifici e allinea l'output su intervalli di 1 minuto:

fetch gce_instance
| metric 'compute.googleapis.com/instance/disk/max_read_ops_count'
| filter (resource.instance_id == '1854776029354445619' ||
          resource.instance_id == '3124475757702255230')
| every 1m

Il grafico seguente mostra un risultato di questa query:

Se vuoi trovare la somma dei valori massimi di max_read_ops_count relativi a questi due VM e sommarle, puoi:

• Trova il valore massimo per ogni serie temporale utilizzando il metodo Operatore di tabella group_by, che specifica lo stesso valore di 1 minuto periodo di allineamento e aggregazione nel periodo con l'aggregatore max per creare una colonna denominata max_val_of_read_ops_count_max nell'output .
• Trova la somma delle serie temporali utilizzando l'operatore di tabella group_by e l'aggregatore sum nella colonna max_val_of_read_ops_count_max.

Di seguito è riportata la query:

fetch gce_instance
| metric 'compute.googleapis.com/instance/disk/max_read_ops_count'
| filter (resource.instance_id == '1854776029354445619' ||
          resource.instance_id == '3124475757702255230')
| group_by 1m, [max_val_of_read_ops_count_max: max(value.max_read_ops_count)]
| every 1m
| group_by [], [summed_value: sum(max_val_of_read_ops_count_max)]

Il grafico seguente mostra un risultato di questa query:

Statistiche sul percentile di calcolo nel tempo e tra flussi

a calcolare separatamente un valore di flusso percentile su una finestra scorrevole per ogni utilizza un'operazione group_by temporale. Ad esempio, la query calcola il 99° percentile di un flusso su uno scorrimento di 1 ora finestra:

fetch gce_instance :: compute.googleapis.com/instance/cpu/utilization
| group_by 1h, percentile(val(), 99)
| every 1m

Per calcolare la stessa statistica percentile in un determinato momento tra flussi, anziché nel tempo all'interno di un flusso, utilizza un'operazione group_by spaziale:

fetch gce_instance :: compute.googleapis.com/instance/cpu/utilization
| group_by [], percentile(val(), 99)

Rapporti di calcolo

Supponi di aver creato un servizio web distribuito in esecuzione su Istanze VM di Compute Engine e utilizzi Cloud Load Balancing.

Vuoi vedere un grafico che mostri il rapporto tra le richieste che restituiscono HTTP 500 risposte (errori interni) al numero totale di richieste; cioè il rapporto tra richieste di guasti. Questa sezione illustra diversi modi per calcolare il rapporto tra richieste di guasti.

Cloud Load Balancing utilizza il tipo di risorsa monitorata http_lb_rule. Il tipo di risorsa monitorata http_lb_rule ha un Etichetta matched_url_path_rule che registra il prefisso degli URL definiti in per la regola; il valore predefinito è UNMATCHED.

La loadbalancing.googleapis.com/https/request_count il tipo di metrica ha un'etichetta response_code_class. Questa etichetta acquisisce il corso di codici di risposta.

Utilizza outer_join e div

La seguente query determina le risposte 500 per ogni valore di l'etichetta matched_url_path_rule in ogni http_lb_rule risorsa monitorata nel tuo progetto. Poi unisce questa tabella del numero di errori con l'originale tabella, che contiene tutti i conteggi delle risposte e suddivide i valori per mostrare il rapporto tra le risposte di errore e le risposte totali:

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

Il grafico seguente mostra il risultato di un progetto:

Le aree ombreggiate intorno alle linee del grafico sono bande min/max. per altre informazioni, consulta la sezione Bande min/max.

L'operazione fetch genera una tabella di serie temporali contenente i conteggi delle richiesta per tutte le query con bilanciamento del carico. Questa tabella viene elaborata in due modi le due sequenze di operazioni nelle parentesi graffe:

• filter response_code_class = 500 restituisce solo la serie temporale che hanno l'etichetta response_code_class con il valore 500. La serie temporale risultante conteggia le richieste con risposta HTTP 5xx (errore) i codici.

  Questa tabella è il numeratore del rapporto.

• L'operazione ident, o identity, genera il proprio input, quindi questa operazione restituisce la tabella recuperata originariamente. Questa è la tabella contiene serie temporali con i conteggi di ciascun codice di risposta.

  Questa tabella è il denominatore del rapporto.

Le tabelle numeratore e denominatore, prodotte da filter e ident operazioni vengono elaborate separatamente dall'operazione group_by. L'operazione group_by raggruppa le serie temporali in ogni tabella per il valore di l'etichetta matched_url_path_rule e somma i conteggi di ogni valore del parametro dell'etichetta. Questa operazione group_by non indica esplicitamente l'aggregatore , pertanto viene utilizzata l'impostazione predefinita sum.

• Per la tabella filtrata, il risultato di group_by è il numero di richieste restituendo una risposta 500 per ogni valore matched_url_path_rule.

• Per la tabella delle identità, il risultato di group_by è il numero totale di richieste per ogni valore matched_url_path_rule.

Queste tabelle vengono indirizzate all'operazione outer_join, che accoppia le serie temporali con i valori delle etichette corrispondenti, uno da ogni delle due tabelle di input. Le serie temporali accoppiate vengono compresse con la corrispondenza dei valori dal timestamp di ogni punto di una serie temporale al timestamp di un punto nell'altra serie temporale. Per ogni coppia di punti corrispondente, outer_join genera una un singolo punto di output con due valori, uno da ciascuna delle tabelle di input. La serie temporale compressa viene generata dal join con le stesse etichette del due serie temporali di input.

Con un join esterno, se un punto della seconda tabella non ha un punto corrispondente nel primo, è necessario specificare un valore sostitutivo. In questo Ad esempio, un punto con valore 0: l'argomento per outer_join operativa.

Nota: perché utilizzare 0 come valore? Se una risorsa monitorata non ha mai risposto una risposta 500, non sarà presente alcun valore di conteggio per le risposte 500. Il valore sostitutivo fornisce un valore pari a 0 per il conteggio.

Infine, l'operazione div prende ogni punto con due valori e divide il valore per produrre un singolo punto di output, ovvero il rapporto tra 500 risposte e tutte risposte per ogni mappa URL.

La stringa div qui è in realtà il nome della funzione div, che divide due valori numerici. Tuttavia, in questo caso viene utilizzata come operazione. Quando usate come operazioni, le funzioni come div prevedono due valori in ogni punto di input (che questo join garantisce) e produrrà un singolo valore per il corrispondente punto di output.

La parte | div della query è una scorciatoia per | value val(0) / val(1). L'operazione value consente espressioni arbitrarie nelle colonne dei valori di una tabella di input per produrre le colonne dei valori della tabella di output. Per ulteriori informazioni, consulta le pagine di riferimento per value e per le espressioni.

Utilizza ratio

La funzione div può essere sostituita con qualsiasi funzione su due valori, ma dato l'uso frequente dei rapporti, MQL fornisce Operazione nella tabella ratio che calcola direttamente i rapporti.

La seguente query equivale alla versione precedente, utilizzando outer_join e div:

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

In questa versione, l'operazione ratio sostituisce outer_join 0 | div nella versione precedente e produce lo stesso risultato.

Tieni presente che ratio utilizza outer_join per fornire un 0 per il numeratore solo se entrambi gli input numeratore e denominatore hanno le stesse etichette che identificano ogni serie temporale, come richiesto da MQL outer_join. Se il numeratore di input ha etichette aggiuntive, non ci sarà alcun output per nessun punto mancante nel denominatore.

Utilizza group_by e /

Esiste un altro modo per calcolare il rapporto tra le risposte di errore e tutte diverse. In questo caso, poiché il numeratore e il denominatore del rapporto derivano dalla stessa serie temporale, puoi anche calcolare il rapporto tramite raggruppamento. La seguente query mostra questo approccio:

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())

Questa query utilizza un'espressione di aggregazione basata su il rapporto di due somme:

• Il primo sum utilizza la funzione if per contare con un valore di 500 etichette e 0 per le altre. La funzione sum calcola il conteggio di richieste che hanno restituito 500 richieste.

• Il secondo sum somma il conteggio di tutte le richieste: val().

Le due somme vengono quindi divise, ottenendo il rapporto di 500 risposte per tutte diverse. Questa query produce lo stesso risultato di queste query in Utilizzo di outer_join e div e Utilizzo di ratio.

Utilizza filter_ratio_by

Poiché spesso i rapporti vengono calcolati dividendo due somme derivate da la stessa tabella, MQL fornisce la classe filter_ratio_by operativa a questo scopo. La seguente query fa la stessa cosa della versione precedente, che divide esplicitamente le somme:

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

Qui si trova il primo operando dell'operazione filter_ratio_by [matched_url_path_rule], indica come raggruppare le risposte. La la seconda operazione, qui response_code_class = 500, agisce come filtro per il numeratore.

• La tabella denominatore è il risultato del raggruppamento della tabella recuperata per matched_url_path_rule e aggregati utilizzando sum.
• La tabella numeratore è la tabella recuperata, filtrata in base alle serie temporali con un codice di risposta HTTP 5xx, quindi raggruppato per matched_url_path_rule e aggregati utilizzando sum.

Rapporti e metriche di quota

Per configurare query e avvisi per la quota serviceruntime alle metriche e alle quote specifiche delle risorse per monitorare per il consumo di quota, puoi usare MQL. Per ulteriori informazioni, Consulta Utilizzare le metriche delle quote.

Calcolo aritmetico

A volte potresti voler eseguire un'operazione aritmetica sui dati prima di creare un grafico. Ad esempio, potresti voler scalare le serie temporali, convertire i dati in scala logaritmica o tracciare la somma di due serie temporali. Per una lista delle funzioni aritmetiche disponibili in MQL, consulta la sezione Aritmetica.

Per scalare una serie temporale, utilizza la funzione mul. Ad esempio, la seguente query recupera la serie temporale e poi moltiplica ciascun valore di 10:

  fetch gce_instance
  | metric 'compute.googleapis.com/instance/disk/read_bytes_count'
  | mul(10)

Per sommare due serie temporali, configura la query per recuperare due tabelle di serie temporali, unire i risultati e chiamare la funzione add. Le seguenti esempio illustra una query che calcola la somma del numero di byte letti dalle istanze di Compute Engine e le scrive:

  fetch gce_instance
  | { metric 'compute.googleapis.com/instance/disk/read_bytes_count'
    ; metric 'compute.googleapis.com/instance/disk/write_bytes_count' }
  | outer_join 0
  | add

Per sottrarre il conteggio dei byte scritti dal conteggio dei byte letti, sostituisci add con sub nell'espressione precedente.

MQL utilizza le etichette nei set di tabelle restituite dal primo e il secondo recupero per determinare come unire le tabelle:

• Se la prima tabella contiene un'etichetta non trovata nella seconda tabella, MQL non può eseguire un'operazione outer_join sulla tabelle e pertanto viene segnalato un errore. Ad esempio, la seguente query causa un errore perché L'etichetta metric.instance_name è presente nella prima tabella, ma non nella seconda tabella:

   fetch gce_instance
    | { metric 'compute.googleapis.com/instance/disk/write_bytes_count'
      ; metric 'compute.googleapis.com/instance/disk/max_write_bytes_count' }
    | outer_join 0
    | add
  

  Un modo per risolvere questo tipo di errore è applicare clausole di raggruppamento per garantire le due tabelle hanno le stesse etichette. Ad esempio, puoi raggruppare tutti etichette delle serie temporali:

   fetch gce_instance
    | { metric 'compute.googleapis.com/instance/disk/write_bytes_count'
        | group_by []
      ; metric 'compute.googleapis.com/instance/disk/max_write_bytes_count'
        | group_by [] }
    | outer_join 0
    | add
  

• Se le etichette delle due tabelle corrispondono o se la seconda tabella contiene un etichetta non trovata nella prima tabella, il join esterno è consentito. Per esempio, la seguente query non causa un errore anche se L'etichetta metric.instance_name è presente nella seconda tabella, ma non nella prima:

   fetch gce_instance
    | { metric 'compute.googleapis.com/instance/disk/max_write_bytes_count'
      ; metric 'compute.googleapis.com/instance/disk/write_bytes_count' }
    | outer_join 0
    | sub
  

  Una serie temporale trovata nella prima tabella potrebbe avere valori delle etichette corrispondenti più serie temporali nella seconda tabella, quindi MQL esegue l'operazione di sottrazione per ogni accoppiamento.

Time shifting

A volte potresti voler confrontare ciò che sta succedendo ora con quello che è successo in passato. Per consentirti di confrontare i dati passati con quelli attuali, MQL fornisce l'operazione tabella time_shift da cui spostare i dati nel periodo di tempo attuale.

Rapporti nel tempo

La seguente query utilizza time_shift, join, e div per calcolare il rapporto dell'utilizzo medio in ogni zona tra oggi e una settimana fa.

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

Il seguente grafico mostra un possibile risultato di questa query:

Le prime due operazioni recuperano la serie temporale e poi raggruppano per zona, calcolando i valori medi di ciascuna. La tabella risultante viene quindi passato a due operazioni. La prima operazione, ident, viene superata senza modificare la tabella.

La seconda operazione, time_shift, aggiunge il periodo (1 settimana) alla timestamp per i valori nella tabella, che sposta i dati rispetto a una settimana fa in avanti. Questa modifica attiva i timestamp per i dati meno recenti nella seconda tabella si allinea con i timestamp dei dati correnti nella prima tabella.

La tabella non modificata e quella spostata in base al tempo vengono quindi combinate utilizzando un join interna. join produce una tabella di serie temporali in cui punto ha due valori: l'utilizzo attuale e l'utilizzo una settimana fa. La query utilizza quindi l'operazione div per calcolare il rapporto del valore attuale al valore della settimana.

Dati passati e presenti

Combinando time_shift e union, puoi creare un grafico che mostra dati passati e presenti contemporaneamente. Ad esempio, la seguente query restituisce l'utilizzo medio complessivo ora e di una settimana prima. Con union, puoi visualizzare questi due risultati sullo stesso grafico.

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

Il seguente grafico mostra un possibile risultato di questa query:

Questa query recupera la serie temporale e poi utilizza group_by [] per combinarle in un'unica serie temporale senza etichette, lasciando Punti dati relativi all'utilizzo della CPU. Questo risultato viene passato a due operazioni. La prima aggiunge una colonna per una nuova etichetta chiamata when con il valore now. Il secondo aggiunge un'etichetta chiamata when con il valore then e passa il risultato all'operazione time_shift per spostare i valori di una settimana. Questa query utilizza il modificatore di mappa add. vedi Maps per ulteriori informazioni.

Le due tabelle, ciascuna contenente dati per una singola serie temporale, vengono passate a union, che produce una tabella contenente le serie temporali di entrambi tabelle di input.

Passaggi successivi

Per una panoramica delle strutture linguistiche MQL, consulta Informazioni sul linguaggio MQL.

Per una descrizione completa di MQL, consulta Riferimento per il monitoraggio del linguaggio di query.

Per informazioni sull'interazione con i grafici, consulta Lavorare con i grafici.