Spanner proporciona tablas integradas que almacenan estadísticas sobre las lecturas. Puedes obtener estadísticas de estas tablas SPANNER_SYS.READ_STATS*
mediante instrucciones de SQL.
Cuándo usar estadísticas de lectura
Las estadísticas de lectura proporcionan información sobre cómo una aplicación está usando la base de datos. son útiles para investigar problemas de rendimiento. Por ejemplo, puedes verificar qué formas de lectura se ejecutan en una base de datos, con qué frecuencia y explicar las características de rendimiento de estas formas de lectura. Puedes usar las estadísticas de lectura de tu base de datos para identificar formas leídas que generan un alto uso de la CPU. En términos generales, las estadísticas de lectura te ayudarán a comprender del tráfico que entra a una base de datos en términos de uso de recursos.
Limitaciones
Esta herramienta es más adecuada para analizar flujos de lecturas similares que representan la mayor parte del uso de la CPU. No es recomendable para buscar lecturas que solo se ejecutaron una vez.
El uso de CPU que se registra en estas estadísticas representa el uso de CPU del servidor, sin incluir el uso de CPU de carga previa y algunas otras sobrecargas.
Las estadísticas se recopilan sobre la base del mejor esfuerzo. Como resultado, es las estadísticas que se pasen por alto si existen problemas con y sistemas. Por ejemplo, si hay problemas internos de red, es posible para que se pasen por alto algunas estadísticas.
Disponibilidad
Los datos SPANNER_SYS
solo están disponibles a través de interfaces de SQL; por ejemplo:
La página de Spanner Studio de una base de datos en la consola de Google Cloud
El comando
gcloud spanner databases execute-sql
La API de
executeQuery
Otros métodos de lectura única que proporciona Spanner no son compatibles.
SPANNER_SYS
Uso de CPU agrupado por forma de lectura
En las siguientes tablas, se realiza un seguimiento de las formas de lectura con el mayor uso de CPU durante un período específico:
SPANNER_SYS.READ_STATS_TOP_MINUTE
: Lee las estadísticas de formas agregadas en intervalos de 1 minuto.SPANNER_SYS.READ_STATS_TOP_10MINUTE
: Lee las estadísticas de formas agregadas en intervalos de 10 minutos.SPANNER_SYS.READ_STATS_TOP_HOUR
: Lee las estadísticas de formas agregadas en intervalos de 1 hora.
Estas tablas tienen las siguientes propiedades:
Cada tabla contiene datos de intervalos de tiempo no superpuestos de la longitud que se especifica en el nombre de la tabla.
Los intervalos se basan en tiempos de reloj. Los intervalos de 1 minuto finalizan en el minuto 10 Los intervalos de minutos finalizan cada 10 minutos a partir de la hora y en intervalos de 1 hora finalizan a la hora. Después de cada intervalo, Spanner recopila datos de todas servidores y luego pone los datos a disposición en las tablas SPANNER_SYS en breve a partir de ese momento.
Por ejemplo, a las 11:59:30 a.m., los intervalos más recientes disponibles para las consultas de SQL son los siguientes:
- 1 minuto: de 11:58:00 a 11:58:59 a.m.
- 10 minutos: de 11:40:00 a 11:49:59 a.m.
- 1 hora: de 10:00:00 a 10:59:59 a.m.
Spanner agrupa las estadísticas por forma de lectura. Si hay una etiqueta presente, FPRINT es el hash de la etiqueta. De lo contrario, es el hash del valor
READ_COLUMNS
.Cada fila contiene estadísticas para todas las ejecuciones de una forma de lectura específica. para las que Spanner captura estadísticas durante el intervalo especificado.
Si Spanner no puede almacenar información sobre todas las operaciones de lectura forma durante el intervalo, el sistema prioriza las formas leídas con el el mayor uso de CPU durante el intervalo especificado.
Esquema de la tabla
Nombre de la columna | Tipo | Descripción |
---|---|---|
INTERVAL_END |
TIMESTAMP |
Fin del intervalo en el que se produjeron las ejecuciones de consultas incluidas |
REQUEST_TAG |
STRING |
La etiqueta de solicitud opcional para esta operación de lectura. Para obtener más información sobre el uso de etiquetas, consulta Solución de problemas con etiquetas de solicitud. Estadísticas para lecturas múltiples que tengan la misma cadena de etiqueta se agrupan en una sola fila con el `REQUEST_TAG` coincide con esa string de etiqueta. |
READ_TYPE |
STRING |
Indica si una operación de lectura es PARTITIONED_READ o
READ Una lectura con un
El valor de partitionToken obtenido de la API de PartitionRead se representa con
El tipo de lectura de PARTITIONED_READ y las otras APIs de lectura por
READ
|
READ_COLUMNS |
ARRAY<STRING> |
El conjunto de columnas que se leyeron. Estos se encuentran en orden alfabético. |
FPRINT |
INT64 |
El hash del valor REQUEST_TAG si está presente. De lo contrario, es el hash del valor READ_COLUMNS . |
EXECUTION_COUNT |
INT64 |
Cantidad de veces que Spanner ejecutó la forma de lectura durante el durante un intervalo de tiempo determinado. |
AVG_ROWS |
FLOAT64 |
Promedio de filas que mostró la consulta. |
AVG_BYTES |
FLOAT64 |
Promedio de bytes de datos que mostró la lectura, sin incluir la sobrecarga de codificación de transmisión. |
AVG_CPU_SECONDS |
FLOAT64 |
Cantidad promedio de segundos de CPU del servidor de Spanner que ejecutan la sin incluir la carga previa de la CPU y otras sobrecargas. |
AVG_LOCKING_DELAY_SECONDS |
FLOAT64 |
Promedio de segundos de espera debido al bloqueo. |
AVG_CLIENT_WAIT_SECONDS |
FLOAT64 |
Cantidad promedio de segundos pasados en espera debido a que el cliente no consume a la velocidad con la que Spanner podría generarlos. |
AVG_LEADER_REFRESH_DELAY_SECONDS |
FLOAT64 |
Es la cantidad promedio de segundos de espera para confirmar con el líder de Paxos que se observaron todas las escrituras. |
RUN_IN_RW_TRANSACTION_EXECUTION_COUNT |
INT64 |
Es la cantidad de veces que se ejecutó la lectura como parte de una transacción de lectura y escritura. Esta columna te ayuda a determinar si puedes evitar las contenciones de bloqueo la operación de lectura a una transacción de solo lectura. |
Consultas de ejemplo
En esta sección, se incluyen varias instrucciones de SQL de ejemplo que recuperan estadísticas de consultas. Puedes ejecutar estas instrucciones de SQL con el bibliotecas cliente gcloud spanner o el Consola de Google Cloud.
Enumera las estadísticas básicas de cada forma leída en un período determinado
La siguiente consulta muestra los datos sin procesar de las formas de lectura principales en los intervalos de tiempo más recientes de 1 minuto.
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;
Resultado de la consulta
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 |
Enumera las formas de lectura, ordenadas por uso de CPU total más alto
La siguiente consulta muestra las formas leídas con el mayor uso de CPU en la hora más reciente:
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;
Resultado de la consulta
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 |
Estadísticas agregadas
SPANNER_SYS
también contiene tablas para almacenar las estadísticas de lectura agregadas que se capturan
Spanner en un período específico:
SPANNER_SYS.READ_STATS_TOTAL_MINUTE
: Estadísticas agregadas para todas las formas de lectura durante intervalos de 1 minuto.SPANNER_SYS.READ_STATS_TOTAL_10MINUTE
: Estadísticas agregadas para todas las formas de lectura durante intervalos de 10 minutos.SPANNER_SYS.READ_STATS_TOTAL_HOUR
: Agrega estadísticas para todas las formas de lectura durante intervalos de 1 hora.
Las tablas conjuntas de estadísticas tienen las siguientes propiedades:
Cada tabla contiene datos de intervalos de tiempo no superpuestos de la longitud que se especifica en el nombre de la tabla.
Los intervalos se basan en tiempos de reloj. Los intervalos de 1 minuto finalizan en el minuto, los intervalos de 10 minutos finalizan cada 10 minutos a partir de la hora y los intervalos de 1 hora finalizan en la hora.
Por ejemplo, a las 11:59:30 a.m., los intervalos más recientes disponibles para las consultas de SQL en las estadísticas de lectura agregadas son los siguientes:
- 1 minuto: de 11:58:00 a 11:58:59 a.m.
- 10 minutos: de 11:40:00 a 11:49:59 a.m.
- 1 hora: de 10:00:00 a 10:59:59 a.m.
Cada fila contiene estadísticas de todas las formas de lectura que se ejecutan en la base de datos durante el intervalo especificado combinadas. Solo hay una fila por intervalo de tiempo.
Es posible que las estadísticas capturadas en las tablas
SPANNER_SYS.READ_STATS_TOTAL_*
incluir formas leídas que Spanner no capturó en elSPANNER_SYS.READ_STATS_TOP_*
tablas.Algunas columnas de estas tablas se exponen como métricas en Cloud Monitoring. Las métricas expuestas son las siguientes:
- Recuento de filas mostradas
- Recuento de ejecuciones de lectura
- Tiempo de CPU de lectura
- Demoras en el bloqueo
- Tiempo de espera del cliente
- Retraso en la actualización de líderes
- Recuento de bytes mostrados
Para obtener más información, consulta Métricas de Spanner.
Esquema de la tabla
Nombre de la columna | Tipo | Descripción |
---|---|---|
INTERVAL_END |
TIMESTAMP |
Fin del intervalo de tiempo en el que ocurrieron las ejecuciones de formas de lectura incluidas. |
EXECUTION_COUNT |
INT64 |
Cantidad de veces que Spanner ejecutó la forma de lectura durante el durante un intervalo de tiempo determinado. |
AVG_ROWS |
FLOAT64 |
Cantidad promedio de filas que mostraron las lecturas. |
AVG_BYTES |
FLOAT64 |
Promedio de bytes de datos que mostró la consulta, sin incluir la sobrecarga de codificación de transmisión. |
AVG_CPU_SECONDS |
FLOAT64 |
Cantidad promedio de segundos de CPU del servidor de Spanner que ejecutan la sin incluir la carga previa de la CPU y otras sobrecargas. |
AVG_LOCKING_DELAY_SECONDS |
FLOAT64 |
Promedio de segundos de espera debido al bloqueo. |
AVG_CLIENT_WAIT_SECONDS |
FLOAT64 |
Promedio de segundos de espera debido a la limitación. |
AVG_LEADER_REFRESH_DELAY_SECONDS |
FLOAT64 |
Cantidad promedio de segundos dedicados a coordinar las lecturas instancias en parámetros de configuración multirregionales. |
RUN_IN_RW_TRANSACTION_EXECUTION_COUNT |
INT64 |
Es la cantidad de veces que se ejecutaron las lecturas como parte de las transacciones de lectura y escritura. Esta columna te ayuda a determinar si puedes evitar las contenciones de bloqueo algunas lecturas a transacciones de solo lectura. |
Consultas de ejemplo
En esta sección, se incluyen varias instrucciones de SQL de ejemplo que recuperan estadísticas de consultas. Puedes ejecutar estas instrucciones de SQL con el bibliotecas cliente gcloud spanner o la Consola de Google Cloud.
Conoce el uso de CPU total en todas las formas de lectura
La siguiente consulta muestra la cantidad de horas de CPU que consumen las formas de lectura de la hora más reciente:
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);
Resultado de la consulta
total_cpu_hours |
---|
0.00026186111111111115 |
Conoce el recuento total de ejecuciones en un período determinado
La siguiente consulta muestra la cantidad total de formas de lectura ejecutadas en el intervalo completo de 1 minuto más reciente:
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);
Resultado de la consulta
interval_end | execution_count |
---|---|
2020-05-28 11:02:00-07:00 |
12861966 |
Retención de datos
Como mínimo, Spanner conserva los datos de cada tabla durante el siguiente tiempo períodos:
SPANNER_SYS.READ_STATS_TOP_MINUTE
ySPANNER_SYS.READ_STATS_TOTAL_MINUTE
: Intervalos que abarcan las 6 horas anteriores.SPANNER_SYS.READ_STATS_TOP_10MINUTE
ySPANNER_SYS.READ_STATS_TOTAL_10MINUTE
: Intervalos que abarcan los 4 días anteriores.SPANNER_SYS.READ_STATS_TOP_HOUR
ySPANNER_SYS.READ_STATS_TOTAL_HOUR
: Intervalos que abarcan los 30 días anteriores.
Soluciona problemas de uso elevado de CPU con la lectura de estadísticas
Las estadísticas de lectura de Spanner son útiles en los casos en los que necesitas investigar el alto uso de la CPU en tu base de datos de Spanner o cuando para entender las formas de lectura que consumen mucho CPU en tu base de datos. Inspección de formas de lectura que usan cantidades significativas de recursos de base de datos ofrece a los usuarios de Spanner una manera potencial de reducir los costos operativos y, posiblemente, y mejoran las latencias generales del sistema. Sigue estos pasos para descubrir cómo usar las estadísticas de lectura para investigar el alto uso de CPU en tu base de datos.
Selecciona un período para investigar
Para comenzar la investigación, busca un momento en el que la aplicación comience a experimentar un uso alto de CPU. Por ejemplo, en la siguiente situación, el problema comenzó alrededor de las 5:20 p.m. del 28 de mayo de 2020.
Recopila estadísticas de lectura del período seleccionado
Después de seleccionar un período para comenzar nuestra investigación, veremos las estadísticas recopiladas en la tabla READ_STATS_TOTAL_10MINUTE
alrededor de ese momento.
Los resultados de esta consulta podrían darnos pistas sobre cómo la CPU y otras operaciones
las estadísticas cambiaron en ese período. La siguiente consulta devuelve
estadísticas de lectura agregadas del 4:30 pm
al 7:30 pm
(inclusive).
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;
Los siguientes datos son un ejemplo del resultado que obtenemos de nuestra consulta.
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 |
Aquí vemos que el tiempo de CPU promedio, avg_cpu_seconds
, es mayor en
intervalos destacados. El interval_end
con el valor
2020-05-28 19:20:00 tiene un tiempo de CPU más alto, así que elegiremos ese intervalo para
investigaremos más a fondo en el siguiente paso.
Descubre qué formas de lectura provocan un alto uso de CPU
Para profundizar un poco más, ahora consultamos la tabla READ_STATS_TOP_10MINUTE
para
el intervalo que se seleccionó en el paso anterior. Los resultados de esta consulta
puede ayudar a indicar qué formas de lectura causan un uso elevado de la 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;
Los siguientes datos son un ejemplo del resultado que obtenemos de nuestra consulta:
devolver información sobre las tres principales formas leídas según
avg_cpu_seconds
Ten en cuenta el uso de ROUND
en nuestra consulta para restringir
el resultado de avg_cpu_seconds
con 4 decimales.
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
es un campo interno que se utiliza para verificar si un
si cierta fila existe o no.
Una de las razones del uso alto de CPU es que comienzas a ejecutar algunas formas de lectura con mayor frecuencia (execution_count
). Es posible que aumente la cantidad promedio de filas que mostró la lectura (avg_rows
). Si ninguna de esas propiedades de la forma de lectura revela algo interesante, puedes examinar otras propiedades, como avg_locking_delay_seconds
, avg_client_wait_seconds
o avg_bytes
.
Aplica las prácticas recomendadas para reducir el uso elevado de CPU
Una vez que hayas completado los pasos anteriores, considera si proporcionar cualquiera de estas prácticas recomendadas ayudará a tu situación.
La cantidad de veces que Spanner ejecutó formas de lectura durante el intervalo es un buen ejemplo de una métrica que necesita un modelo de referencia para indicar si una es razonable o indica un problema. Después de establecer una base de referencia para la métrica, podrás detectar e investigar la causa de cualquier variación inesperada del comportamiento normal.
Si el uso de CPU es relativamente constante en la mayoría de los casos, pero de repente muestra un aumento que se puede correlacionar con un aumento repentino similar en las solicitudes de los usuarios o el comportamiento de la aplicación, podría ser un indicador de que todo funciona como debería.
Prueba la siguiente consulta para encontrar las formas más leídas clasificadas por la cantidad de Cantidad de veces que se ejecutó Spanner para cada forma de lectura:
SELECT interval_end, read_columns, execution_count FROM SPANNER_SYS.READ_STATS_TOP_MINUTE ORDER BY execution_count DESC LIMIT 10;
Si estás buscando las latencias de lectura más bajas posibles, especialmente cuando con parámetros de configuración de instancias multirregionales, usa lecturas inactivas en lugar de sólidas de lectura para reducir o quitar la
AVG_LEADER_REFRESH_DELAY_SECONDS
de latencia de lectura.Si solo realizas operaciones de lectura y puedes expresar tu lectura con un único método de lectura, debes usar ese método. Soltero/a las lecturas no se bloquean, a diferencia de las transacciones de lectura y escritura, por lo que debes de solo lectura frente a las más costosas de lectura y escritura cuando no escribir datos.
¿Qué sigue?
- Obtén más información sobre otras herramientas de introspección.
- Obtén más información sobre otros datos que Spanner almacena para cada base de datos en la tablas de esquema de información de la base de datos.
- Obtén más información sobre las prácticas recomendadas de SQL para Spanner
- Obtén más información sobre la investigación de la alta capacidad de CPU de aplicaciones.