Visualizzazione JOBS_TIMELINE

La visualizzazione INFORMATION_SCHEMA.JOBS_TIMELINE contiene metadati BigQuery quasi in tempo reale per intervallo di tempo per tutti i job inviati nel progetto corrente. Questa visualizzazione contiene i job attualmente in esecuzione e completati.

Autorizzazioni obbligatorie

Per eseguire query sulla visualizzazione INFORMATION_SCHEMA.JOBS_TIMELINE, devi disporre dell'autorizzazione Identity and Access Management (IAM) bigquery.jobs.listAll per il progetto. Ciascuno dei seguenti ruoli IAM predefiniti include l'autorizzazione richiesta:

• Proprietario progetto
• Amministratore BigQuery

Per saperne di più sulle autorizzazioni BigQuery, consulta Controllo dell'accesso con IAM.

Schema

Quando esegui una query sulle viste INFORMATION_SCHEMA.JOBS_TIMELINE_BY_*, i risultati della query contengono una riga per ogni secondo di esecuzione di ogni job BigQuery. Ogni periodo inizia a un intervallo di un secondo intero e dura esattamente un secondo.

La vista INFORMATION_SCHEMA.JOBS_TIMELINE_BY_* ha lo schema seguente:

Conservazione dei dati

Questa visualizzazione contiene i job attualmente in esecuzione e la cronologia dei job degli ultimi 180 giorni.

Ambito e sintassi

Le query su questa visualizzazione devono includere un qualificatore di regione. Se non specifichi un qualificatore regionale, i metadati vengono recuperati da tutte le regioni. La tabella seguente spiega l'ambito della regione per questa visualizzazione:

• (Facoltativo) PROJECT_ID: l'ID del tuo Google Cloud progetto. Se non specificato, viene utilizzato il progetto predefinito.
• REGION: qualsiasi nome della regione del set di dati. Ad esempio: `region-us`.

Esempi

Per eseguire la query su un progetto diverso da quello predefinito, aggiungi l'ID progetto nel seguente formato:

`PROJECT_ID`.`region-REGION_NAME`.INFORMATION_SCHEMA.VIEW

L'esempio seguente calcola l'utilizzo degli slot per ogni secondo dell'ultimo giorno:

SELECT
  period_start,
  SUM(period_slot_ms) AS total_slot_ms,
FROM
  `reservation-admin-project.region-us`.INFORMATION_SCHEMA.JOBS_TIMELINE
WHERE
  period_start BETWEEN TIMESTAMP_SUB(CURRENT_TIMESTAMP(), INTERVAL 1 DAY) AND CURRENT_TIMESTAMP()
GROUP BY
  period_start
ORDER BY
  period_start DESC;

+---------------------+---------------+
|    period_start     | total_slot_ms |
+---------------------+---------------+
| 2020-07-29 03:52:14 |     122415176 |
| 2020-07-29 03:52:15 |     141107048 |
| 2020-07-29 03:52:16 |     173335142 |
| 2020-07-28 03:52:17 |     131107048 |
+---------------------+---------------+

Puoi controllare l'utilizzo di una prenotazione specifica con WHERE reservation_id = "…". Per i job di script, il job principale segnala anche l'utilizzo totale degli slot dei job secondari. Per evitare il doppio conteggio, utilizza WHERE statement_type != "SCRIPT" per escludere il job principale.

Numero di job RUNNING e PENDING nel tempo

Per eseguire la query su un progetto diverso da quello predefinito, aggiungi l'ID progetto nel seguente formato:

`PROJECT_ID`.`region-REGION_NAME`.INFORMATION_SCHEMA.VIEW

L'esempio seguente calcola il numero di job RUNNING e PENDING ogni secondo dell'ultimo giorno:

SELECT
  period_start,
  SUM(IF(state = "PENDING", 1, 0)) as PENDING,
  SUM(IF(state = "RUNNING", 1, 0)) as RUNNING
FROM
  `reservation-admin-project.region-us`.INFORMATION_SCHEMA.JOBS_TIMELINE
WHERE
  period_start BETWEEN TIMESTAMP_SUB(CURRENT_TIMESTAMP(), INTERVAL 1 DAY) AND CURRENT_TIMESTAMP()
GROUP BY
  period_start;

Il risultato è simile al seguente:

+---------------------+---------+---------+
|    period_start     | PENDING | RUNNING |
+---------------------+---------+---------+
| 2020-07-29 03:52:14 |       7 |      27 |
| 2020-07-29 03:52:15 |       1 |      21 |
| 2020-07-29 03:52:16 |       5 |      21 |
| 2020-07-29 03:52:17 |       4 |      22 |
+---------------------+---------+---------+

Utilizzo delle risorse da parte dei job in un momento specifico

Per eseguire la query su un progetto diverso da quello predefinito, aggiungi l'ID progetto nel seguente formato:

`PROJECT_ID`.`region-REGION_NAME`.INFORMATION_SCHEMA.VIEW

L'esempio seguente restituisce il job_id di tutti i job in esecuzione in un momento specifico insieme all'utilizzo delle risorse durante quel periodo di un secondo:

SELECT
  job_id,
  period_slot_ms
FROM
  `reservation-admin-project.region-us`.INFORMATION_SCHEMA.JOBS_TIMELINE_BY_PROJECT
WHERE
  period_start = '2020-07-29 03:52:14'
  AND (statement_type != 'SCRIPT' OR statement_type IS NULL);

Il risultato è simile al seguente:

+------------------+
| job_id | slot_ms |
+------------------+
| job_1  | 2415176 |
| job_2  | 4417245 |
| job_3  |  427416 |
| job_4  | 1458122 |
+------------------+

Corrispondenza del comportamento di utilizzo degli slot dai grafici delle risorse amministrative

Puoi utilizzare i grafici delle risorse amministrative per monitorare lo stato di integrità, l'utilizzo degli slot e il rendimento dei job BigQuery della tua organizzazione nel tempo. L'esempio seguente esegue query sulla visualizzazione INFORMATION_SCHEMA.JOBS_TIMELINE per una cronologia dell'utilizzo degli slot a intervalli di un'ora, in modo simile alle informazioni disponibili nei grafici delle risorse amministrative.

DECLARE
  start_time timestamp DEFAULT TIMESTAMP(START_TIME);
DECLARE
  end_time timestamp DEFAULT TIMESTAMP(END_TIME);

WITH
  snapshot_data AS (
  SELECT
    UNIX_MILLIS(period_start) AS period_start,
    IFNULL(SUM(period_slot_ms), 0) AS period_slot_ms,
    DIV(UNIX_MILLIS(period_start), 3600000 * 1) * 3600000 * 1 AS time_ms
  FROM (
    SELECT
      *
    FROM
      `PROJECT_ID.region-US`.INFORMATION_SCHEMA.JOBS_TIMELINE_BY_PROJECT
    WHERE
      ((job_creation_time >= TIMESTAMP_SUB(start_time, INTERVAL 1200 MINUTE)
          AND job_creation_time < TIMESTAMP(end_time))
        AND period_start >= TIMESTAMP(start_time)
        AND period_start < TIMESTAMP(end_time))
      AND (statement_type != "SCRIPT"
        OR statement_type IS NULL)
      AND REGEXP_CONTAINS(reservation_id, "^PROJECT_ID:") )
  GROUP BY
    period_start,
    time_ms ),
  converted_percentiles_data AS (
  SELECT
    time_ms,
    100 - CAST(SAFE_DIVIDE(3600000 * 1 * 1 / 1000, COUNT(*)) AS INT64) AS converted_percentiles,
  FROM
    snapshot_data
  GROUP BY
    time_ms ),
  data_by_time AS (
  SELECT
    time_ms,
  IF
    (converted_percentiles <= 0, 0, APPROX_QUANTILES(period_slot_ms, 100)[SAFE_OFFSET(converted_percentiles)] / 1000) AS p99_slots,
    SUM(period_slot_ms) / (3600000 * 1) AS avg_slots
  FROM
    snapshot_data
  JOIN
    converted_percentiles_data AS c
  USING
    (time_ms)
  GROUP BY
    time_ms,
    converted_percentiles )
SELECT
  time_ms,
  TIMESTAMP_MILLIS(time_ms) AS time_stamp,
  IFNULL(avg_slots, 0) AS avg_slots,
  IFNULL(p99_slots, 0) AS p99_slots,
FROM (
  SELECT
    time_ms * 3600000 * 1 AS time_ms
  FROM
    UNNEST(GENERATE_ARRAY(DIV(UNIX_MILLIS(start_time), 3600000 * 1), DIV(UNIX_MILLIS(end_time), 3600000 * 1) - 1, 1)) AS time_ms )
LEFT JOIN
  data_by_time
USING
  (time_ms)
ORDER BY
  time_ms DESC;

Calcolare la percentuale di tempo di esecuzione in cui era presente lavoro in attesa

Per eseguire la query su un progetto diverso da quello predefinito, aggiungi l'ID progetto nel seguente formato:

`PROJECT_ID`.`region-REGION_NAME`.INFORMATION_SCHEMA.VIEW

L'esempio seguente restituisce un valore float che rappresenta la percentuale della durata totale di esecuzione del job in cui il valore di period_estimated_runnable_units era diverso da zero, il che significa che il job richiedeva più slot. Un valore elevato indica che il job ha subito una contesa di slot, mentre un valore basso indica che il job non ha richiesto slot per la maggior parte del tempo di esecuzione, il che significa che la contesa di slot è stata minima o nulla.

Se il valore risultante è elevato, puoi provare ad aggiungere più slot per vedere l'impatto e capire se la contesa degli slot è l'unico collo di bottiglia.

SELECT ROUND(COUNTIF(period_estimated_runnable_units > 0) / COUNT(*) * 100, 1) as execution_duration_percentage
FROM `myproject`.`region-us`.INFORMATION_SCHEMA.JOBS_TIMELINE
WHERE job_id = 'my_job_id'
GROUP BY job_id

Se conosci la data di esecuzione della query, aggiungi una clausola DATE(period_start) = 'YYYY-MM-DD' alla query per ridurre la quantità di byte elaborati e velocizzare l'esecuzione. Ad esempio, DATE(period_start) = '2025-08-22'.

Il risultato è simile al seguente:

+-------------------------------+
| execution_duration_percentage |
+-------------------------------+
|                          96.7 |
+-------------------------------+