Referencia de las tablas del sistema de trabajos

Este artículo es una referencia sobre cómo usar las tablas del sistema de lakeflow para supervisar los trabajos en tu cuenta. Estas tablas incluyen registros de todas las áreas de trabajo de la cuenta implementadas en la misma región de nube. Para ver los registros de otra región, debe ver las tablas de un área de trabajo implementada en esa región.

Requisitos

• Un administrador de cuenta debe habilitar el esquema system.lakeflow. Consulte Habilitar esquemas de tablas del sistema.
• Para acceder a estas tablas del sistema, los usuarios deben:
  • Ser un administrador de metastore y un administrador de cuenta, o
  • Tener permisos USE y SELECT en los esquemas del sistema. Consulte Conceder acceso a las tablas del sistema.

Tablas de trabajos disponibles

Todas las tablas del sistema relacionadas con trabajos residen en el esquema system.lakeflow. Actualmente, el esquema hospeda cuatro tablas:

Referencia detallada del esquema

En las secciones siguientes se proporcionan referencias de esquema para cada una de las tablas del sistema relacionadas con los trabajos.

Esquema de tabla de trabajos

La tabla jobs es una tabla de dimensiones que cambia lentamente (SCD2). Cuando cambia una fila, se emite una nueva fila, reemplazando lógicamente a la anterior.

ruta de acceso de tabla: system.lakeflow.jobs

Ejemplo de consulta

-- Get the most recent version of a job
SELECT
  *,
  ROW_NUMBER() OVER(PARTITION BY workspace_id, job_id ORDER BY change_time DESC) as rn
FROM
  system.lakeflow.jobs QUALIFY rn=1

Esquema de tabla de tareas de trabajo

La tabla de tareas de trabajo es una tabla de dimensiones que cambia lentamente (SCD2). Cuando cambia una fila, se emite una nueva fila, reemplazando lógicamente a la anterior.

ruta de acceso de tabla: system.lakeflow.job_tasks

Ejemplo de consulta

-- Get the most recent version of a job task
SELECT
  *,
  ROW_NUMBER() OVER(PARTITION BY workspace_id, job_id ORDER BY change_time DESC) as rn
FROM
  system.lakeflow.job_tasks QUALIFY rn=1

Esquema de tabla de escala de tiempo de ejecución de trabajo

La tabla de escala de tiempo de ejecución del trabajo es inmutable y se completa en el momento en que se genera.

ruta de acceso a la tabla: system.lakeflow.job_run_timeline

Ejemplo de consulta

-- This query gets the daily job count for a workspace for the last 7 days:
SELECT
  workspace_id,
  COUNT(DISTINCT run_id) as job_count,
  to_date(period_start_time) as date
FROM system.lakeflow.job_run_timeline
WHERE
  period_start_time > CURRENT_TIMESTAMP() - INTERVAL 7 DAYS
GROUP BY ALL

-- This query returns the daily job count for a workspace for the last 7 days, distributed by the outcome of the job run.
SELECT
  workspace_id,
  COUNT(DISTINCT run_id) as job_count,
  result_state,
  to_date(period_start_time) as date
FROM system.lakeflow.job_run_timeline
WHERE
  period_start_time > CURRENT_TIMESTAMP() - INTERVAL 7 DAYS
  AND result_state IS NOT NULL
GROUP BY ALL

-- This query returns the average time of job runs, measured in seconds. The records are organized by job. A top 90 and a 95 percentile column show the average lengths of the job's longest runs.
with job_run_duration as (
    SELECT
        workspace_id,
        job_id,
        run_id,
        CAST(SUM(period_end_time - period_start_time) AS LONG) as duration
    FROM
        system.lakeflow.job_run_timeline
    WHERE
      period_start_time > CURRENT_TIMESTAMP() - INTERVAL 7 DAYS
    GROUP BY ALL
)
SELECT
    t1.workspace_id,
    t1.job_id,
    COUNT(DISTINCT t1.run_id) as runs,
    MEAN(t1.duration) as mean_seconds,
    AVG(t1.duration) as avg_seconds,
    PERCENTILE(t1.duration, 0.9) as p90_seconds,
    PERCENTILE(t1.duration, 0.95) as p95_seconds
FROM
    job_run_duration t1
GROUP BY ALL
ORDER BY mean_seconds DESC
LIMIT 100

-- This query provides a historical runtime for a specific job based on the `run_name` parameter. For the query to work, you must set the `run_name`.
SELECT
  workspace_id,
  run_id,
  SUM(period_end_time - period_start_time) as run_time
FROM system.lakeflow.job_run_timeline
WHERE
  run_type="SUBMIT_RUN"
  AND run_name = :run_name
  AND period_start_time > CURRENT_TIMESTAMP() - INTERVAL 60 DAYS
GROUP BY ALL

-- This query collects a list of retried job runs with the number of retries for each run.
with repaired_runs as (
    SELECT
    workspace_id, job_id, run_id, COUNT(*) - 1 as retries_count
    FROM system.lakeflow.job_run_timeline
    WHERE result_state IS NOT NULL
    GROUP BY ALL
    HAVING retries_count > 0
    )
SELECT
    *
FROM repaired_runs
ORDER BY retries_count DESC
    LIMIT 10;

Esquema de tabla de escala de tiempo de ejecución de tareas de trabajo

La tabla de escala de tiempo de ejecución de la tarea de trabajo es inmutable y completa en el momento en que se genera.

ruta de acceso de tabla: system.lakeflow.job_task_run_timeline

Patrones de Combinación Comunes

En las secciones siguientes se proporcionan consultas de ejemplo que resaltan los patrones de combinación usados habitualmente para las tablas del sistema de trabajos.

Combinar los trabajos y las tablas de escala de tiempo de ejecución de trabajos

Enriquecer la ejecución del trabajo con un nombre de trabajo

with jobs as (
    SELECT
        *,
        ROW_NUMBER() OVER (PARTITION BY workspace_id, job_id ORDER BY change_time DESC) as rn
    FROM system.lakeflow.jobs QUALIFY rn=1
)
SELECT
    job_run_timeline.*
    jobs.name
FROM system.lakeflow.job_run_timeline
    LEFT JOIN jobs USING (workspace_id, job_id)

Unir la escala de tiempo de ejecución del trabajo y las tablas de uso

Enriquecer cada registro de facturación con metadatos de ejecución de trabajos

SELECT
    t1.*,
    t2.*
FROM system.billing.usage t1
    LEFT JOIN system.lakeflow.job_run_timeline t2
        ON t1.workspace_id = t2.workspace_id
            AND t1.usage_metadata.job_id = t2.job_id
            AND t1.usage_metadata.job_run_id = t2.run_id
            AND t1.usage_start_time >= date_trunc("Hour", t2.period_start_time)
            AND t1.usage_start_time < date_trunc("Hour", t2.period_end_time) + INTERVAL 1 HOUR
WHERE
    billing_origin_product="JOBS"

Calcular el costo por ejecución de un trabajo

Esta consulta se combina con la tabla del sistema billing.usage para calcular un costo por ejecución de trabajo.

with jobs_usage AS (
  SELECT
    *,
    usage_metadata.job_id,
    usage_metadata.job_run_id as run_id,
    identity_metadata.run_as as run_as
  FROM system.billing.usage
  WHERE billing_origin_product="JOBS"
),
jobs_usage_with_usd AS (
  SELECT
    jobs_usage.*,
    usage_quantity * pricing.default as usage_usd
  FROM jobs_usage
    LEFT JOIN system.billing.list_prices pricing ON
      jobs_usage.sku_name = pricing.sku_name
      AND pricing.price_start_time <= jobs_usage.usage_start_time
      AND (pricing.price_end_time >= jobs_usage.usage_start_time OR pricing.price_end_time IS NULL)
      AND pricing.currency_code="USD"
),
jobs_usage_aggregated AS (
  SELECT
    workspace_id,
    job_id,
    run_id,
    FIRST(run_as, TRUE) as run_as,
    sku_name,
    SUM(usage_usd) as usage_usd,
    SUM(usage_quantity) as usage_quantity
  FROM jobs_usage_with_usd
  GROUP BY ALL
)
SELECT
  t1.*,
  MIN(period_start_time) as run_start_time,
  MAX(period_end_time) as run_end_time,
  FIRST(result_state, TRUE) as result_state
FROM jobs_usage_aggregated t1
  LEFT JOIN system.lakeflow.job_run_timeline t2 USING (workspace_id, job_id, run_id)
GROUP BY ALL
ORDER BY usage_usd DESC
LIMIT 100

Obtener registros de uso para trabajos de SUBMIT_RUN

SELECT
  *
FROM system.billing.usage
WHERE
  EXISTS (
      SELECT 1
      FROM system.lakeflow.job_run_timeline
      WHERE
        job_run_timeline.job_id = usage_metadata.job_id
        AND run_name = :run_name
        AND workspace_id = :workspace_id
  )

Unir el cronograma de ejecución de tareas y las tablas de clústeres

Enriquecer las ejecuciones de tareas de trabajo con metadatos de clústeres

with clusters as (
    SELECT
        *,
        ROW_NUMBER() OVER (PARTITION BY workspace_id, cluster_id ORDER BY change_time DESC) as rn
    FROM system.compute.clusters QUALIFY rn=1
),
exploded_task_runs AS (
  SELECT
    *,
    EXPLODE(compute_ids) as cluster_id
  FROM system.lakeflow.job_task_run_timeline
  WHERE array_size(compute_ids) > 0
)
SELECT
  exploded_task_runs.*,
  clusters.*
FROM exploded_task_runs t1
  LEFT JOIN clusters t2
    USING (workspace_id, cluster_id)

Buscar trabajos que se ejecutan en un proceso de uso completo

Esta consulta se une a la de la tabla del sistema compute.clusters para devolver los trabajos recientes que se ejecutan en proceso multiuso en lugar de proceso de trabajos.

with clusters AS (
  SELECT
    *,
    ROW_NUMBER() OVER(PARTITION BY workspace_id, cluster_id ORDER BY change_time DESC) as rn
  FROM system.compute.clusters
  WHERE cluster_source="UI" OR cluster_source="API"
  QUALIFY rn=1
),
job_tasks_exploded AS (
  SELECT
    workspace_id,
    job_id,
    EXPLODE(compute_ids) as cluster_id
  FROM system.lakeflow.job_task_run_timeline
  WHERE period_start_time >= CURRENT_DATE() - INTERVAL 30 DAY
),
all_purpose_cluster_jobs AS (
  SELECT
    t1.*,
    t2.cluster_name,
    t2.owned_by,
    t2.dbr_version
  FROM job_tasks_exploded t1
    INNER JOIN clusters t2 USING (workspace_id, cluster_id)
)
SELECT * FROM all_purpose_cluster_jobs LIMIT 10;

Panel de supervisión de trabajos

En el panel siguiente se usan tablas del sistema para ayudarle a empezar a supervisar los trabajos y el estado operativo. Incluye casos de uso comunes, como el seguimiento del rendimiento del trabajo, la supervisión de errores y el uso de recursos.

Para obtener información sobre cómo descargar el panel, consulte Supervisión de costes y rendimiento de trabajos con tablas del sistema

Solución de problemas

La tarea no está registrada en la tabla lakeflow.jobs

Si un trabajo no está visible en las tablas del sistema:

• El trabajo no se modificó en los últimos 365 días
  • Modifique cualquiera de los campos del trabajo presentes en el esquema para emitir un nuevo registro.
• El trabajo se creó en otra región
• Creación reciente de trabajos (retrasos en los datos)

No se puede encontrar un trabajo visto en la tabla job_run_timeline

No todas las ejecuciones de trabajos están visibles en todas partes. Aunque las entradas de JOB_RUN aparecen en todas las tablas relacionadas con el trabajo, WORKFLOW_RUN (ejecuciones de flujo de trabajo del cuaderno) solo se registran en job_run_timeline y SUBMIT_RUN (ejecuciones enviadas una sola vez) se registran únicamente en ambas tablas de cronología. Estas ejecuciones no se rellenan en otras tablas del sistema de trabajo, como jobs o job_tasks.

Consulte la tabla Tipos de ejecución siguiente para obtener un desglose detallado de dónde está visible y accesible cada tipo de ejecución.

Ejecución de trabajo no visible en la tabla billing.usage

En system.billing.usage, el usage_metadata.job_id solo se rellena para los trabajos que se ejecutan en computación en trabajos o computación sin servidor.

Además, los trabajos de WORKFLOW_RUN no tienen una atribución propia de usage_metadata.job_id o de usage_metadata.job_run_id en system.billing.usage. En su lugar, su uso de computación se atribuye al notebook principal que los activó. Esto significa que cuando un notebook inicia la ejecución de un flujo de trabajo, todos los costos de proceso aparecen en el uso del notebook principal, no como un trabajo de flujo de trabajo independiente.

Consulte referencia de metadatos de uso para obtener más información.

Calcular el costo de un trabajo que se ejecuta en una computación de propósito general

El cálculo preciso del costo para los trabajos que se ejecutan en recursos de cómputo dedicados no es posible con una precisión de 100%. Cuando un trabajo se ejecuta en un proceso interactivo (de uso completo), varias cargas de trabajo como cuadernos, consultas SQL u otros trabajos a menudo se ejecutan simultáneamente en ese mismo recurso de proceso. Dado que los recursos del clúster se comparten, no hay ninguna asignación directa de 1:1 entre los costos informáticos y las ejecuciones de trabajos individuales.

Para un seguimiento preciso del costo del trabajo, Databricks recomienda ejecutar trabajos en computación dedicada para trabajos o computación sin servidor, donde usage_metadata.job_id y usage_metadata.job_run_id permiten una atribución precisa de costos.

Si debe usar la computación de propósito general, puede hacer lo siguiente:

• Supervise el uso general del clúster y los costes en system.billing.usage en función de usage_metadata.cluster_id.
• Realice un seguimiento de las métricas del tiempo de ejecución del trabajo por separado.
• Tenga en cuenta que cualquier estimación de costos será aproximada debido a los recursos compartidos.

Consulte referencia de metadatos de uso para obtener más información sobre la atribución de costes.

Valores de referencia

En la sección siguiente se incluyen referencias para seleccionar columnas en tablas relacionadas con trabajos.

Valores de tipo de desencadenador

Los valores posibles para la columna trigger_type son:

• CONTINUOUS
• CRON
• FILE_ARRIVAL
• ONETIME
• ONETIME_RETRY

Valores de tipo de ejecución

Los valores posibles para la columna run_type son:

Valores de estado del resultado

Los valores posibles para la columna result_state son:

Valores de código de finalización

Los valores posibles para la columna termination_code son: