Spanner fornisce tabelle integrate che memorizzano le statistiche sulle letture. Puoi recuperare le statistiche da queste tabelle SPANNER_SYS.READ_STATS*
utilizzando istruzioni SQL.
Quando utilizzare le statistiche di lettura
Le statistiche di lettura forniscono informazioni su come un'applicazione utilizza il database e sono utili per analizzare i problemi di prestazioni. Ad esempio, puoi controllare quali forme di lettura vengono eseguite su un database, con quale frequenza vengono eseguite e spiegare le caratteristiche di rendimento 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 entrata 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 eseguite una sola volta.
L'utilizzo della CPU monitorato in queste statistiche rappresenta l'utilizzo della CPU lato server di Spanner, escluso l'utilizzo della CPU di prefetch e alcuni altri overhead.
Le statistiche vengono raccolte al meglio delle possibilità. Di conseguenza, è possibile che le statistiche non vengano registrate se si verificano problemi con i sistemi sottostanti. Ad esempio, se si verificano problemi di rete interni, è possibile che alcune statistiche non vengano registrate.
Accedere alle statistiche di lettura
Spanner fornisce le statistiche di lettura nello schema SPANNER_SYS
. Puoi utilizzare i seguenti metodi per accedere ai dati di SPANNER_SYS
:
La pagina Spanner Studio di un database nella console Google Cloud .
Il comando
gcloud spanner databases execute-sql
.Il metodo
executeSql
oexecuteStreamingSql
.
I seguenti metodi di lettura singola forniti da Spanner
non supportano SPANNER_SYS
:
- Esecuzione di una lettura coerente da una o più righe di una tabella.
- Esecuzione di una lettura obsoleta da una o più righe di una tabella.
- Lettura da una singola riga o da più righe in un indice secondario.
Utilizzo della CPU raggruppato per forma di lettura
Le tabelle seguenti 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 sulla forma aggregate in intervalli di 1 minuto.SPANNER_SYS.READ_STATS_TOP_10MINUTE
: Leggi le statistiche sulla forma aggregate in intervalli di 10 minuti.SPANNER_SYS.READ_STATS_TOP_HOUR
: leggi le statistiche sulla forma aggregate a intervalli di 1 ora.
Queste tabelle hanno le seguenti proprietà:
Ogni tabella contiene dati per intervalli di tempo non sovrapposti della durata specificata dal nome della tabella.
Gli intervalli si basano sugli orari. 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 li rende disponibili nelle tabelle SPANNER_SYS poco dopo.
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 in base alla forma di lettura. Se è presente un tag, FPRINT è l'hash del tag. In caso contrario, è l'hash del valore
READ_COLUMNS
.Ogni riga contiene statistiche per tutte le esecuzioni di una particolare forma di lettura per cui Spanner acquisisce statistiche durante l'intervallo specificato.
Se Spanner non è in grado di memorizzare le informazioni su ogni forma di lettura distinta eseguita durante l'intervallo, il sistema dà la priorità alle forme di lettura con l'utilizzo della CPU più elevato 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 saperne di più sull'utilizzo dei tag, consulta Risoluzione dei problemi con i tag delle richieste. Le statistiche per più letture che hanno la stessa stringa di tag sono raggruppate in una singola riga con `REQUEST_TAG` corrispondente a quella stringa di tag. |
READ_TYPE |
STRING |
Indica se una lettura è PARTITIONED_READ o
READ . Una lettura con un
partitionToken ottenuto dall'API PartitionRead è rappresentata dal
tipo di lettura PARTITIONED_READ e le altre API di lettura da
READ .
|
READ_COLUMNS |
ARRAY<STRING> |
Il set di colonne lette. Questi sono 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 la forma 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, escluse la CPU di prefetch e altre spese generali. |
AVG_LOCKING_DELAY_SECONDS |
FLOAT64 |
Numero medio di secondi trascorsi in attesa a causa del blocco. |
AVG_CLIENT_WAIT_SECONDS |
FLOAT64 |
Numero medio di secondi trascorsi in attesa perché il client non ha consumato i dati alla stessa velocità con cui Spanner poteva generarli. |
AVG_LEADER_REFRESH_DELAY_SECONDS |
FLOAT64 |
Numero medio di secondi trascorsi in attesa di conferma 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 ti aiuta a determinare se puoi evitare conflitti di blocco spostando la lettura in una transazione di sola lettura. |
AVG_DISK_IO_COST |
FLOAT64 |
Il costo medio di questa query in termini di carico del disco rigido Spanner. Utilizza questo valore per effettuare confronti relativi dei costi di I/O del disco rigido tra le letture che esegui nel database. L'esecuzione di query sui dati nello spazio di archiviazione HDD comporta un addebito in base alla capacità di carico del disco HDD dell'istanza. Un valore più alto indica che stai utilizzando un carico maggiore del disco HDD e la query potrebbe essere più lenta rispetto a se venisse eseguita su SSD. Inoltre, se il carico del disco HDD è al massimo della capacità, le prestazioni delle query potrebbero essere ulteriormente compromesse. Puoi monitorare la capacità totale di carico del disco HDD dell'istanza come percentuale. Per aggiungere ulteriore capacità di carico del disco HDD, puoi aggiungere altre unità di elaborazione o nodi all'istanza. Per ulteriori informazioni, vedi Modificare la capacità di calcolo. Per migliorare le prestazioni delle query, valuta anche la possibilità di spostare alcuni dati su SSD. Per i carichi di lavoro che consumano molte operazioni di I/O del disco, ti consigliamo di archiviare i dati a cui si accede di frequente su un archivio SSD. I dati a cui si accede dall'SSD non consumano la capacità di carico del disco HDD. Puoi archiviare tabelle, colonne o indici secondari selettivi sull'archiviazione SSD in base alle esigenze, mantenendo i dati a cui si accede di rado sull'archiviazione HDD. Per maggiori informazioni, consulta la panoramica dell'archiviazione a livelli. |
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, gcloud spanner o la Google Cloud console.
Elenca le statistiche di base per ogni forma 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 della 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 in base all'utilizzo totale della CPU più elevato
La seguente query restituisce le forme di lettura con l'utilizzo della CPU più elevato nell'ultima ora:
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 della 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
: Aggrega le statistiche 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 durata specificata dal nome della tabella.
Gli intervalli si basano sugli orari. 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 le statistiche di tutte le forme di lettura eseguite sul 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 vengono esposte come metriche in Cloud Monitoring. Le metriche esposte sono:
- Conteggio delle righe restituite
- Conteggio esecuzioni di lettura
- Tempo di CPU per la lettura
- Ritardi nella chiusura
- Tempo di attesa del client
- Ritardo aggiornamento leader
- Conteggio byte restituiti
Per ulteriori informazioni, 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 della forma di lettura incluse. |
EXECUTION_COUNT |
INT64 |
Numero di volte in cui Spanner ha eseguito la forma 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 della trasmissione. |
AVG_CPU_SECONDS |
FLOAT64 |
Numero medio di secondi di CPU lato server di Spanner per l'esecuzione della lettura, escluse la CPU di prefetch e altre spese generali. |
AVG_LOCKING_DELAY_SECONDS |
FLOAT64 |
Numero medio di secondi trascorsi in attesa a causa del blocco. |
AVG_CLIENT_WAIT_SECONDS |
FLOAT64 |
Numero medio di secondi trascorsi in attesa a causa della limitazione. |
AVG_LEADER_REFRESH_DELAY_SECONDS |
FLOAT64 |
Numero medio di secondi trascorsi a coordinare le letture tra le istanze nelle configurazioni multiregionali. |
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 ti aiuta a determinare se puoi evitare conflitti di blocco spostando alcune letture a transazioni di sola lettura. |
Esempi di query
Questa sezione include diversi esempi di istruzioni SQL che recuperano le statistiche di lettura aggregate. Puoi eseguire queste istruzioni SQL utilizzando le librerie client, gcloud spanner o la Google Cloud console.
Trova l'utilizzo totale della CPU in tutte le forme di lettura
La seguente query restituisce il numero di ore CPU consumate dalle forme di lettura nell'ultima ora:
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 della 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 della query
interval_end | execution_count |
---|---|
2020-05-28 11:02:00-07:00 |
12861966 |
Conservazione dei dati
Come minimo, Spanner conserva i dati per ogni tabella per i seguenti periodi di tempo:
SPANNER_SYS.READ_STATS_TOP_MINUTE
eSPANNER_SYS.READ_STATS_TOTAL_MINUTE
: intervalli che coprono le 6 ore precedenti.SPANNER_SYS.READ_STATS_TOP_10MINUTE
eSPANNER_SYS.READ_STATS_TOTAL_10MINUTE
: intervalli che coprono i 4 giorni precedenti.SPANNER_SYS.READ_STATS_TOP_HOUR
eSPANNER_SYS.READ_STATS_TOTAL_HOUR
: intervalli che coprono i 30 giorni precedenti.
Risolvere i problemi relativi all'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 solo cercando di comprendere le forme di lettura che utilizzano molta CPU nel database. L'ispezione delle forme di lettura che utilizzano quantità significative di risorse del database offre agli utenti di Spanner un modo potenziale per ridurre i costi operativi e possibilmente migliorare le latenze generali del sistema. Seguendo i passaggi riportati di seguito, ti mostreremo come utilizzare le statistiche di lettura per analizzare l'utilizzo elevato della CPU nel tuo database.
Seleziona un periodo di tempo da esaminare
Inizia l'indagine cercando un momento in cui l'applicazione ha iniziato a registrare un utilizzo elevato della CPU. Ad esempio, nello scenario seguente, il problema ha iniziato a verificarsi intorno alle 17:20 del 28 maggio 2020.
Raccogliere le statistiche di lettura per il periodo di tempo selezionato
Dopo aver selezionato un periodo di tempo per iniziare l'indagine, esamineremo le statistiche raccolte nella tabella READ_STATS_TOTAL_10MINUTE
in quel periodo.
I risultati di questa query potrebbero fornirci indizi su come sono cambiate le statistiche relative alla CPU e ad altre letture
in quel periodo di tempo. La seguente query restituisce le statistiche di lettura aggregate dal giorno 4:30 pm
al giorno 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 seguenti dati sono un esempio del risultato che otteniamo dalla nostra query.
interval_end | avg_cpu_seconds | execution_count | avg_locking_delay_seconds |
---|---|---|---|
2020-05-28 16:40:00-07:00 | 0,0004 | 11111421 | 8.3232564943763752e-06 |
2020-05-28 16:50:00-07:00 | 0,0002 | 8815637 | 8.98734051776406e-05 |
2020-05-28 17:00:00-07:00 | 0,0001 | 8260215 | 6.039129247846453e-06 |
2020-05-28 17:10:00-07:00 | 0,0001 | 8514387 | 9.0535466616680686e-07 |
2020-05-28 17:20:00-07:00 | 0,0006 | 13715466 | 2.6801485272173765e-06 |
2020-05-28 17:30:00-07:00 | 0,0007 | 12861966 | 4.6859741349028595e-07 |
2020-05-28 17:40:00-07:00 | 0,0007 | 3755954 | 2.7131391918005383e-06 |
2020-05-28 17:50:00-07:00 | 0,0006 | 4248137 | 1.4328191393074178e-06 |
2020-05-28 18:00:00-07:00 | 0,0006 | 3986198 | 2.6973481999639748e-06 |
2020-05-28 18:10:00-07:00 | 0,0006 | 3510249 | 3.7577083563017905e-06 |
2020-05-28 18:20:00-07:00 | 0,0004 | 3341542 | 4,0940589703795433e-07 |
2020-05-28 18:30:00-07:00 | 0,0002 | 8695147 | 1.9914494947583975e-05 |
2020-05-28 18:40:00-07:00 | 0,0003 | 11679702 | 1,8331461539001595e-05 |
2020-05-28 18:50:00-07:00 | 0,0003 | 9306619 | 1.2527332321222135e-05 |
2020-05-28 19:00:00-07:00 | 0,0002 | 8520508 | 6,2268448078447915e-06 |
2020-05-28 19:10:00-07:00 | 0,0006 | 13715466 | 2.6801485272173765e-06 |
2020-05-28 19:20:00-07:00 | 0,0005 | 11947323 | 3.3029114639321295e-05 |
2020-05-28 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 questo intervallo per
approfondire l'analisi nel passaggio successivo.
Individuare le forme di lettura che causano un elevato utilizzo della CPU
Se andiamo un po' più nel dettaglio, ora eseguiamo una query sulla tabella READ_STATS_TOP_10MINUTE
per
l'intervallo selezionato nel passaggio precedente. I risultati di questa query
possono aiutarti a capire quali forme di lettura causano un utilizzo elevato 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 sono un esempio del risultato restituito dalla query, che
restituisce informazioni sulle prime tre forme di lettura classificate in base a
avg_cpu_seconds
. Tieni presente l'utilizzo 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 l'esistenza o meno di una
determinata riga.
Uno dei motivi dell'elevato utilizzo della CPU potrebbe essere l'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à della forma di lettura rivela qualcosa di interessante, puoi esaminare altre proprietà come avg_locking_delay_seconds
, avg_client_wait_seconds
o avg_bytes
.
Applica le best practice per ridurre l'utilizzo elevato della CPU
Dopo aver completato i passaggi precedenti, valuta se l'applicazione di una di queste best practice può aiutarti.
Il numero di volte in cui Spanner ha eseguito le forme di lettura durante l'intervallo è un buon esempio di metrica che necessita di una baseline per indicare se una misurazione è ragionevole o è il segnale di un problema. Una volta stabilita una base di riferimento per la metrica, potrai rilevare e analizzare la causa di eventuali deviazioni impreviste dal comportamento normale.
Se l'utilizzo della CPU è relativamente costante per la maggior parte del tempo, ma mostra improvvisamente un picco che può essere correlato a un picco improvviso simile nelle richieste degli utenti o nel comportamento dell'applicazione, potrebbe essere un'indicazione che tutto funziona come previsto.
Prova la seguente query per trovare le forme di lettura più lette 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 cerchi le latenze di lettura più basse possibili, soprattutto quando utilizzi configurazioni di istanze multiregionali, utilizza letture non aggiornate anziché letture coerenti per ridurre o rimuovere il componente
AVG_LEADER_REFRESH_DELAY_SECONDS
della latenza di lettura.Se esegui solo letture e puoi esprimere la lettura utilizzando un unico metodo di lettura, devi utilizzare questo metodo. Le letture singole non bloccano, a differenza delle transazioni di lettura/scrittura, pertanto devi utilizzare transazioni di sola lettura anziché transazioni di lettura/scrittura più costose quando non scrivi dati.
Passaggi successivi
- Scopri di più su altri strumenti di introspezione.
- Scopri di più sulle altre informazioni archiviate da Spanner per ogni database nelle tabelle dello schema informativo del database.
- Scopri di più sulle best practice per SQL per Spanner.
- Scopri di più su come analizzare l'utilizzo elevato della CPU.