Cloud Spanner fornisce tabelle integrate che archiviano le statistiche sulle letture. Puoi recuperare le statistiche da queste tabelle SPANNER_SYS.READ_STATS*
utilizzando le istruzioni SQL.
Quando utilizzare le statistiche di lettura
Le statistiche di lettura forniscono insight sull'utilizzo del database da parte di un'applicazione e sono utili per l'analisi dei problemi di prestazioni. Ad esempio, puoi controllare quali forme di lettura sono in esecuzione su un database, con quale frequenza vengono eseguite e spiegare le caratteristiche delle prestazioni di queste forme di lettura. Puoi utilizzare le statistiche di lettura per il tuo database per identificare le forme di lettura che comportano un elevato utilizzo della CPU. A livello generale, le statistiche di lettura ti aiuteranno a comprendere il comportamento del traffico in un database in termini di utilizzo delle risorse.
Limitazioni
Questo strumento è più adatto per analizzare flussi di letture simili che rappresentano la maggior parte dell'utilizzo della CPU. Non è utile per cercare letture che sono state eseguite una sola volta.
L'utilizzo della CPU monitorato in queste statistiche rappresenta l'utilizzo della CPU lato server di Spanner, escludendo l'utilizzo di precaricamento della CPU e alcuni altri overhead.
Le statistiche vengono raccolte secondo il criterio del "best effort". Di conseguenza, è possibile che le statistiche non vengano rilevate in caso di problemi con i sistemi sottostanti. Ad esempio, in caso di problemi di networking interni, è possibile che alcune statistiche non vengano registrate.
Disponibilità
I dati di SPANNER_SYS
sono disponibili solo tramite le interfacce SQL; ad esempio:
Pagina Spanner Studio di un database nella console Google Cloud
Il comando
gcloud spanner databases execute-sql
L'API
executeQuery
Altri metodi di lettura singola forniti da Spanner non supportano SPANNER_SYS
.
Utilizzo della CPU raggruppato per forma di lettura
Le seguenti tabelle monitorano le forme di lettura con il massimo utilizzo della CPU durante un periodo di tempo specifico:
SPANNER_SYS.READ_STATS_TOP_MINUTE
: leggi le statistiche di forma aggregate in intervalli di 1 minuto.SPANNER_SYS.READ_STATS_TOP_10MINUTE
: leggi le statistiche di forma aggregate per intervalli di 10 minuti.SPANNER_SYS.READ_STATS_TOP_HOUR
: leggi le statistiche di forma aggregate a intervalli di un'ora.
Queste tabelle hanno le seguenti proprietà:
Ogni tabella contiene dati per intervalli di tempo non sovrapposti della lunghezza specificata dal nome della tabella.
Gli intervalli sono basati sulle ore di orologio. Gli intervalli di 1 minuto terminano al minuto, gli intervalli di 10 minuti terminano ogni 10 minuti a partire dall'ora e gli intervalli di 1 ora terminano all'ora. Dopo ogni intervallo, Spanner raccoglie i dati da tutti i server e rende subito disponibili i dati nelle tabelle SPANNER_SYS.
Ad esempio, alle 11:59:30, gli intervalli più recenti disponibili per le query SQL sono:
- 1 minuto: 11:58:00-11:58:59
- 10 minuti: 11:40:00-11:49:59
- 1 ora: 10:00:00-10:59:59
Spanner raggruppa le statistiche per forma di lettura. Se è presente un tag, Fprint è l'hash del tag. Altrimenti, si tratta dell'hash del valore
READ_COLUMNS
.Ogni riga contiene statistiche per tutte le esecuzioni di una determinata forma di lettura per cui Spanner acquisisce le statistiche durante l'intervallo specificato.
Se Spanner non è in grado di archiviare le informazioni su ogni forma di lettura distinta eseguita durante l'intervallo, il sistema dà la priorità alle forme di lettura con il massimo utilizzo della CPU durante l'intervallo specificato.
Schema tabella
Nome colonna | Tipo | Descrizione |
---|---|---|
INTERVAL_END |
TIMESTAMP |
Fine dell'intervallo di tempo in cui si sono verificate le esecuzioni di lettura incluse. |
REQUEST_TAG |
STRING |
Il tag di richiesta facoltativo per questa operazione di lettura. Per maggiori informazioni sull'utilizzo dei tag, consulta la risoluzione dei problemi con i tag di richiesta. Le statistiche per più letture che hanno la stessa stringa tag sono raggruppate in una singola riga con "REQUEST_TAG" che corrisponde alla stringa tag. |
READ_TYPE |
STRING |
Indica se una lettura è PARTITIONED_READ o READ . Una lettura con
partitionToken ottenuta dall'API PartitionRead è rappresentata dal
tipo di lettura PARTITIONED_READ e dalle altre API di lettura da
READ .
|
READ_COLUMNS |
ARRAY<STRING> |
L'insieme di colonne che sono state lette. in ordine alfabetico. |
FPRINT |
INT64 |
L'hash del valore REQUEST_TAG , se presente. In caso contrario,
l'hash del valore READ_COLUMNS . |
EXECUTION_COUNT |
INT64 |
Numero di volte in cui Spanner ha eseguito il formato di lettura durante l'intervallo. |
AVG_ROWS |
FLOAT64 |
Numero medio di righe restituite dalla lettura. |
AVG_BYTES |
FLOAT64 |
Numero medio di byte di dati restituiti dalla lettura, escluso l'overhead di codifica della trasmissione. |
AVG_CPU_SECONDS |
FLOAT64 |
Numero medio di secondi di CPU lato server di Spanner per l'esecuzione della lettura, esclusi la CPU di precaricamento e altro overhead. |
AVG_LOCKING_DELAY_SECONDS |
FLOAT64 |
Numero medio di secondi di attesa a causa del blocco. |
AVG_CLIENT_WAIT_SECONDS |
FLOAT64 |
Numero medio di secondi di attesa perché il client non consuma i dati alla velocità con cui Spanner potrebbe generarli. |
AVG_LEADER_REFRESH_DELAY_SECONDS |
FLOAT64 |
Numero medio di secondi in attesa di confermare con il leader di Paxos che tutte le scritture sono state osservate. |
RUN_IN_RW_TRANSACTION_EXECUTION_COUNT |
INT64 |
Il numero di volte in cui la lettura è stata eseguita nell'ambito di una transazione di lettura-scrittura. Questa colonna consente di determinare se è possibile evitare contese del blocco spostando la lettura in una transazione di sola lettura. |
Esempi di query
Questa sezione include diversi esempi di istruzioni SQL che recuperano le statistiche di lettura. Puoi eseguire queste istruzioni SQL utilizzando le librerie client, lo strumento a riga di comando gcloud
o la console Google Cloud.
Elenca le statistiche di base per ogni formato di lettura in un determinato periodo di tempo
La seguente query restituisce i dati non elaborati per le forme più lette negli intervalli di tempo di 1 minuto più recenti.
SELECT fprint,
read_columns,
execution_count,
avg_cpu_seconds,
avg_rows,
avg_bytes,
avg_locking_delay_seconds,
avg_client_wait_seconds
FROM spanner_sys.read_stats_top_minute
ORDER BY interval_end DESC LIMIT 3;
Output query
Fprint | read_columns | execution_count | avg_cpu_seconds | avg_rows | avg_bytes | avg_locking_delay_seconds | avg_client_wait_seconds |
---|---|---|---|---|---|---|---|
125062082139 |
["Singers.id", "Singers.name"] |
8514387 |
0.000661355290396507 |
310.79 |
205 |
8.3232564943763752e-06 |
0 |
151238888745 |
["Singers.singerinfo"] |
3341542 |
6.5992827184280315e-05 |
12784 |
54 |
4.6859741349028595e-07 |
0 |
14105484 |
["Albums.id", "Albums.title"] |
9306619 |
0.00017855774721667873 |
1165.4 |
2964.71875 |
1.4328191393074178e-06 |
0 |
Elenca le forme di lettura, ordinate per utilizzo totale della CPU massimo
La seguente query restituisce le forme lette con il massimo utilizzo di CPU nell'ora più recente:
SELECT read_columns,
execution_count,
avg_cpu_seconds,
execution_count * avg_cpu_seconds AS total_cpu
FROM spanner_sys.read_stats_top_hour
WHERE interval_end =
(SELECT MAX(interval_end)
FROM spanner_sys.read_stats_top_hour)
ORDER BY total_cpu DESC LIMIT 3;
Output query
read_columns | execution_count | avg_cpu_seconds | total_cpu |
---|---|---|---|
["Singers.id", "Singers.name"] |
1647 |
0.00023380297430622681 |
0.2579 |
["Albums.id", "Albums.title"] |
720 |
0.00016738889440282034 |
0.221314999999999 |
["Singers.singerinfo""] |
3223 |
0.00037764625882302246 |
0.188053 |
Statistiche aggregate
SPANNER_SYS
contiene anche tabelle per archiviare le statistiche di lettura aggregate acquisite da Spanner in un periodo di tempo specifico:
SPANNER_SYS.READ_STATS_TOTAL_MINUTE
: statistiche aggregate per tutte le forme di lettura durante intervalli di 1 minuto.SPANNER_SYS.READ_STATS_TOTAL_10MINUTE
: statistiche aggregate per tutte le forme di lettura durante intervalli di 10 minuti.SPANNER_SYS.READ_STATS_TOTAL_HOUR
: statistiche aggregate per tutte le forme di lettura durante intervalli di 1 ora.
Le tabelle delle statistiche aggregate hanno le seguenti proprietà:
Ogni tabella contiene dati per intervalli di tempo non sovrapposti della lunghezza specificata dal nome della tabella.
Gli intervalli sono basati sulle ore di orologio. Gli intervalli di 1 minuto terminano al minuto, gli intervalli di 10 minuti terminano ogni 10 minuti a partire dall'ora e gli intervalli di 1 ora terminano all'ora.
Ad esempio, alle 11:59:30, gli intervalli più recenti disponibili per le query SQL sulle statistiche di lettura aggregate sono:
- 1 minuto: 11:58:00-11:58:59
- 10 minuti: 11:40:00-11:49:59
- 1 ora: 10:00:00-10:59:59
Ogni riga contiene statistiche per tutte le forme lette eseguite nel database durante l'intervallo specificato, aggregate insieme. C'è una sola riga per intervallo di tempo.
Le statistiche acquisite nelle tabelle
SPANNER_SYS.READ_STATS_TOTAL_*
potrebbero includere forme di lettura che Spanner non ha acquisito nelle tabelleSPANNER_SYS.READ_STATS_TOP_*
.Alcune colonne di queste tabelle sono esposte come metriche in Cloud Monitoring. Le metriche esposte sono:
- Numero di righe restituito
- Conteggio esecuzioni lettura
- Lettura tempo CPU
- Ritardi nei blocchi
- Tempo di attesa del client
- Ritardo aggiornamento leader
- Conteggio byte restituiti
Per saperne di più, consulta la sezione Metriche di Spanner.
Schema tabella
Nome colonna | Tipo | Descrizione |
---|---|---|
INTERVAL_END |
TIMESTAMP |
Fine dell'intervallo di tempo in cui si sono verificate le esecuzioni del formato di lettura incluso. |
EXECUTION_COUNT |
INT64 |
Numero di volte in cui Spanner ha eseguito il formato di lettura durante l'intervallo. |
AVG_ROWS |
FLOAT64 |
Numero medio di righe restituite dalle letture. |
AVG_BYTES |
FLOAT64 |
Numero medio di byte di dati restituiti dalle letture, escluso l'overhead di codifica di trasmissione. |
AVG_CPU_SECONDS |
FLOAT64 |
Numero medio di secondi di CPU lato server di Spanner per l'esecuzione della lettura, esclusi la CPU di precaricamento e altro overhead. |
AVG_LOCKING_DELAY_SECONDS |
FLOAT64 |
Numero medio di secondi di attesa a causa del blocco. |
AVG_CLIENT_WAIT_SECONDS |
FLOAT64 |
Numero medio di secondi di attesa a causa della limitazione. |
AVG_LEADER_REFRESH_DELAY_SECONDS |
FLOAT64 |
Numero medio di secondi dedicati al coordinamento delle letture tra le istanze in configurazioni per più regioni. |
RUN_IN_RW_TRANSACTION_EXECUTION_COUNT |
INT64 |
Il numero di volte in cui le letture sono state eseguite nell'ambito di transazioni di lettura/scrittura. Questa colonna consente di determinare se è possibile evitare contese del blocco spostando alcune letture in transazioni di sola lettura. |
Esempi di query
Questa sezione include diversi esempi di istruzioni SQL che recuperano statistiche di lettura aggregate. Puoi eseguire queste istruzioni SQL utilizzando le librerie client, lo strumento a riga di comando gcloud
o la console Google Cloud.
Trovare l'utilizzo totale della CPU per tutte le forme di lettura
La seguente query restituisce il numero di ore di CPU consumate dalle forme di lettura nell'ora più recente:
SELECT (avg_cpu_seconds * execution_count / 60 / 60)
AS total_cpu_hours
FROM spanner_sys.read_stats_total_hour
WHERE interval_end =
(SELECT MAX(interval_end)
FROM spanner_sys.read_stats_total_hour);
Output query
total_cpu_hours |
---|
0.00026186111111111115 |
Trovare il conteggio totale delle esecuzioni in un determinato periodo di tempo
La seguente query restituisce il numero totale di forme di lettura eseguite nell'intervallo di 1 minuto completo più recente:
SELECT interval_end,
execution_count
FROM spanner_sys.read_stats_total_minute
WHERE interval_end =
(SELECT MAX(interval_end)
FROM spanner_sys.read_stats_total_minute);
Output query
interval_end | execution_count |
---|---|
2020-05-28 11:02:00-07:00 |
12861966 |
Conservazione dei dati
Spanner conserva i dati di ogni tabella come minimo per i seguenti periodi di tempo:
SPANNER_SYS.READ_STATS_TOP_MINUTE
eSPANNER_SYS.READ_STATS_TOTAL_MINUTE
: intervalli relativi alle 6 ore precedenti.SPANNER_SYS.READ_STATS_TOP_10MINUTE
eSPANNER_SYS.READ_STATS_TOTAL_10MINUTE
: intervalli relativi ai 4 giorni precedenti.SPANNER_SYS.READ_STATS_TOP_HOUR
eSPANNER_SYS.READ_STATS_TOTAL_HOUR
: intervalli relativi ai 30 giorni precedenti.
Risolvere i problemi di utilizzo elevato della CPU con le statistiche di lettura
Le statistiche di lettura di Spanner sono utili nei casi in cui devi analizzare l'utilizzo elevato della CPU nel database Spanner o quando stai semplicemente cercando di comprendere le forme di lettura che richiedono un uso intensivo della CPU nel database. L'ispezione di forme di lettura che utilizzano quantità significative di risorse di database offre agli utenti di Spanner un potenziale modo per ridurre i costi operativi e possibilmente migliorare le latenze generali di sistema. Seguendo i passaggi riportati di seguito, ti mostreremo come utilizzare le statistiche di lettura per esaminare l'utilizzo elevato della CPU nel database.
Seleziona un periodo di tempo per l'indagine
Inizia la tua indagine cercando il momento in cui l'applicazione ha iniziato a riscontrare un utilizzo elevato della CPU. Ad esempio, nel seguente scenario il problema è iniziato a verificarsi intorno alle 17:20 del 28 maggio 2020.
Raccogli le statistiche di lettura per il periodo di tempo selezionato
Dopo aver selezionato un periodo di tempo in cui iniziare la nostra indagine, esamineremo le
statistiche raccolte nella tabella READ_STATS_TOTAL_10MINUTE
all'incirca in quel periodo.
I risultati di questa query potrebbero darci indizi su come sono cambiate la CPU e altre statistiche di lettura in quel periodo di tempo. La seguente query restituisce le
statistiche di lettura aggregate da 4:30 pm
a 7:30 pm
(inclusi).
SELECT
interval_end,
ROUND(avg_cpu_seconds,4) as avg_cpu_seconds,
execution_count,
avg_locking_delay_seconds
FROM SPANNER_SYS.READ_STATS_TOTAL_10MINUTE
WHERE
interval_end >= "2020-05-28T16:30:00"
AND interval_end <= "2020-05-28T19:30:00"
ORDER BY interval_end;
I dati che seguono sono un esempio del risultato ottenuto dalla nostra query.
interval_end | avg_cpu_seconds | execution_count | avg_locking_delay_seconds |
---|---|---|---|
28-05-2020 16:40:00-07:00 | 0.0004 | 11111421 | 8,3232564943763752e-06 |
28-05-2020 16:50:00-07:00 | 0.0002 | 8815637 | 8,98734051776406e-05 |
28-05-2020 17:00:00-07:00 | 0.0001 | 8260215 | 6.039129247846453e-06 |
28-05-2020 17:10:00-07:00 | 0.0001 | 8514387 | 9,0535466616680686e-07 |
28-05-2020 17:20:00-07:00 | 0.0006 | 13715466 | 2.6801485272173765e-06 |
28-05-2020 17:30:00-07:00 | 0.0007 | 12861966 | 4,6859741349028595e-07 |
28-05-2020 17:40:00-07:00 | 0.0007 | 3755954 | 2.7131391918005383e-06 |
28-05-2020 17:50:00-07:00 | 0.0006 | 4248137 | 1,4328191393074178e-06 |
28-05-2020 18:00:00-07:00 | 0.0006 | 3986198 | 2.6973481999639748e-06 |
28-05-2020 18:10:00-07:00 | 0.0006 | 3510249 | 3.7577083563017905e-06 |
28-05-2020 18:20:00-07:00 | 0.0004 | 3341542 | 4,0940589703795433e-07 |
28-05-2020 18:30:00-07:00 | 0.0002 | 8695147 | 1,9914494947583975e-05 |
28-05-2020 18:40:00-07:00 | 0.0003 | 11679702 | 1,8331461539001595e-05 |
28-05-2020 18:50:00-07:00 | 0.0003 | 9306619 | 1,2527332321222135e-05 |
28-05-2020 19:00:00-07:00 | 0.0002 | 8520508 | 6.2268448078447915e-06 |
28-05-2020 19:10:00-07:00 | 0.0006 | 13715466 | 2.6801485272173765e-06 |
28-05-2020 19:20:00-07:00 | 0.0005 | 11947323 | 3,3029114639321295e-05 |
28-05-2020 19:30:00-07:00 | 0.0002 | 8514387 | 9,0535466616680686e-07 |
Qui vediamo che il tempo di CPU medio, avg_cpu_seconds
, è più alto negli intervalli evidenziati. interval_end
con il valore
2020-05-28 19:20:00 ha un tempo di CPU più elevato, quindi sceglieremo quell'intervallo per
indagare ulteriormente nel passaggio successivo.
Scoprire quali forme di lettura causano un elevato utilizzo della CPU
Approfondendo un po' la tabella, ora eseguiamo una query nella tabella READ_STATS_TOP_10MINUTE
per l'intervallo selezionato nel passaggio precedente. I risultati di questa query possono aiutare a indicare quali forme di lettura causano un elevato utilizzo della CPU.
SELECT
read_columns,
ROUND(avg_cpu_seconds,4) as avg_cpu_seconds,
execution_count,
avg_rows
FROM SPANNER_SYS.READ_STATS_TOP_10MINUTE
WHERE
interval_end = "2020-05-28T19:20:00"
ORDER BY avg_cpu_seconds DESC LIMIT 3;
I seguenti dati come esempio del risultato ottenuto dalla nostra query,
restituendo informazioni sulle tre forme di lettura principali classificate in base a
avg_cpu_seconds
. Nota l'uso di ROUND
nella nostra query per limitare l'output di avg_cpu_seconds
a quattro cifre decimali.
read_columns | avg_cpu_seconds | execution_count | avg_rows |
---|---|---|---|
[TestHigherLatency._exists,TestHigherLatency.lang_status,TestHigherLatency.score,globalTagAffinity.shares] 1 |
0,4192 | 1182 | 11650,42216582 |
[TestHigherLatency._exists,TestHigherLatency.lang_status,TestHigherLatency.likes,globalTagAffinity.score] |
0,0852 | 4 | 12784 |
[TestHigherLatency._exists,TestHigherLatency.lang_status,TestHigherLatency.score,globalTagAffinity.ugcCount] |
0,0697 | 1140 | 310,7921052631 |
1 _exists
è un campo interno utilizzato per verificare se una determinata riga esiste o meno.
Uno dei motivi di un elevato utilizzo della CPU potrebbe essere l'inizio dell'esecuzione più frequente di alcune forme di lettura (execution_count
). Forse il numero medio di righe restituite dalla lettura è aumentato (avg_rows
). Se nessuna di queste proprietà del formato di lettura rivela qualcosa di interessante, puoi esaminare altre proprietà come avg_locking_delay_seconds
, avg_client_wait_seconds
o avg_bytes
.
Applicare le best practice per ridurre l'utilizzo elevato della CPU
Dopo aver seguito i passaggi precedenti, valuta se l'applicazione di una di queste best practice può risolvere il problema.
Il numero di volte in cui Spanner ha eseguito forme di lettura durante l'intervallo è un buon esempio di metrica che ha bisogno di una base di riferimento per indicare se una misurazione è ragionevole o un segnale di un problema. Una volta stabilito un valore di riferimento per la metrica, sarai in grado di rilevare ed esaminare la causa di eventuali deviazioni impreviste dal comportamento normale.
Se l'utilizzo della CPU è relativamente costante la maggior parte delle volte, ma improvvisamente mostra un picco che può essere correlato a un simile picco improvviso nelle richieste degli utenti o nel comportamento delle applicazioni, potrebbe indicare che tutto funziona come previsto.
Prova la seguente query per trovare le forme di lettura più ascoltate classificate in base al numero di volte in cui Spanner è stato eseguito per ogni forma di lettura:
SELECT interval_end, read_columns, execution_count FROM SPANNER_SYS.READ_STATS_TOP_MINUTE ORDER BY execution_count DESC LIMIT 10;
Se vuoi ottenere le latenze di lettura più basse, soprattutto quando utilizzi configurazioni di istanze su più regioni, utilizza letture inattive invece di letture efficaci per ridurre o rimuovere il componente
AVG_LEADER_REFRESH_DELAY_SECONDS
della latenza di lettura.Se esegui solo letture e puoi esprimere la lettura con un metodo di lettura singola, dovresti usare questo metodo. Le singole letture non si bloccano, a differenza delle transazioni di lettura-scrittura, pertanto è consigliabile utilizzare le transazioni di sola lettura anziché quelle più costose di lettura/scrittura quando non si scrivono dati.
Passaggi successivi
- Scopri altri strumenti di introspezione.
- Scopri altre informazioni memorizzate da Spanner per ogni database nelle tabelle di schema di informazioni del database.
- Scopri di più sulle best practice SQL per Spanner.
- Scopri di più su come indagare su un utilizzo elevato della CPU.