Monitoramento de tabelas de eventos e alertas para tabelas dinâmicas

Este tópico discute como consultar uma tabela de eventos que fornece informações sobre seu status de atualização e como configurar alertas sobre novos dados em uma tabela de eventos.

Consulte uma tabela de eventos para monitorar as atualizações

Quando uma tabela dinâmica é atualizada, você pode configurar o Snowflake para registrar um evento que forneça informações sobre o status da operação de atualização. O evento é registrado na tabela de evento ativa associada à tabela dinâmica.

Por exemplo, suponha que você tenha associado uma tabela de eventos a um banco de dados. Quando uma tabela dinâmica nesse banco de dados é atualizada, o Snowflake registra um evento nessa tabela de evento.

Você pode consultar os eventos registrados nessa tabela de evento ativa para monitorar as atualizações da tabela dinâmica.

Por exemplo, para obter o carimbo de data/hora, o nome da tabela dinâmica, o ID de consulta e a mensagem de erro para erros com tabelas dinâmicas no banco de dados my_db, faça o seguinte:

SELECT
    timestamp,
    resource_attributes:"snow.executable.name"::VARCHAR AS dt_name,
    resource_attributes:"snow.query.id"::VARCHAR AS query_id,
    value:message::VARCHAR AS error
  FROM my_event_table
  WHERE
    resource_attributes:"snow.executable.type" = 'DYNAMIC_TABLE' AND
    resource_attributes:"snow.database.name" = 'MY_DB' AND
    value:state = 'FAILED'
  ORDER BY timestamp DESC;

+-------------------------+------------------+--------------------------------------+---------------------------------------------------------------------------------+
| TIMESTAMP               | DT_NAME          | QUERY_ID                             | ERROR                                                                           |
|-------------------------+------------------+--------------------------------------+---------------------------------------------------------------------------------|
| 2025-02-17 21:40:45.444 | MY_DYNAMIC_TABLE | 01ba7614-0107-e56c-0000-a995024f304a | SQL compilation error:                                                          |
|                         |                  |                                      | Failure during expansion of view 'MY_DYNAMIC_TABLE': SQL compilation error:     |
|                         |                  |                                      | Object 'MY_DB.MY_SCHEMA.MY_BASE_TABLE' does not exist or not authorized.        |
+-------------------------+------------------+--------------------------------------+---------------------------------------------------------------------------------+

O exemplo a seguir recupera todas as colunas de erros upstream com tabelas dinâmicas no esquema my_schema:

SELECT *
  FROM my_event_table
  WHERE
    resource_attributes:"snow.executable.type" = 'DYNAMIC_TABLE' AND
    resource_attributes:"snow.schema.name" = 'MY_SCHEMA' AND
    value:state = 'UPSTREAM_FAILURE'
  ORDER BY timestamp DESC;

+-------------------------+-----------------+-------------------------+-------+----------+-------------------------------------------------+-------+------------------+-------------+-----------------------------+-------------------+-------------------------------+-----------+
| TIMESTAMP               | START_TIMESTAMP | OBSERVED_TIMESTAMP      | TRACE | RESOURCE | RESOURCE_ATTRIBUTES                             | SCOPE | SCOPE_ATTRIBUTES | RECORD_TYPE | RECORD                      | RECORD_ATTRIBUTES | VALUE                         | EXEMPLARS |
|-------------------------+-----------------+-------------------------+-------+----------+-------------------------------------------------+-------+------------------+-------------+-----------------------------+-------------------+-------------------------------+-----------|
| 2025-02-17 21:40:45.486 | NULL            | 2025-02-17 21:40:45.486 | NULL  | NULL     | {                                               | NULL  | NULL             | EVENT       | {                           | NULL              | {                             | NULL      |
|                         |                 |                         |       |          |   "snow.database.id": 49,                       |       |                  |             |   "name": "refresh.status", |                   |   "state": "UPSTREAM_FAILURE" |           |
|                         |                 |                         |       |          |   "snow.database.name": "MY_DB",                |       |                  |             |   "severity_text": "WARN"   |                   | }                             |           |
|                         |                 |                         |       |          |   "snow.executable.id": 487426,                 |       |                  |             | }                           |                   |                               |           |
|                         |                 |                         |       |          |   "snow.executable.name": "MY_DYNAMIC_TABLE_2", |       |                  |             |                             |                   |                               |           |
|                         |                 |                         |       |          |   "snow.executable.type": "DYNAMIC_TABLE",      |       |                  |             |                             |                   |                               |           |
|                         |                 |                         |       |          |   "snow.owner.id": 2601,                        |       |                  |             |                             |                   |                               |           |
|                         |                 |                         |       |          |   "snow.owner.name": "DATA_ADMIN",              |       |                  |             |                             |                   |                               |           |
|                         |                 |                         |       |          |   "snow.owner.type": "ROLE",                    |       |                  |             |                             |                   |                               |           |
|                         |                 |                         |       |          |   "snow.schema.id": 411,                        |       |                  |             |                             |                   |                               |           |
|                         |                 |                         |       |          |   "snow.schema.name": "MY_SCHEMA"               |       |                  |             |                             |                   |                               |           |
|                         |                 |                         |       |          | }                                               |       |                  |             |                             |                   |                               |           |
+-------------------------+-----------------+-------------------------+-------+----------+-------------------------------------------------+-------+------------------+-------------+-----------------------------+-------------------+-------------------------------+-----------+

Para obter informações sobre a função que você precisa usar para consultar a tabela de eventos e as condições que podem ser usadas para filtrar os resultados, consulte Configure um alerta sobre novos dados.

Configure alertas sobre novos dados para monitorar as atualizações

Conforme mencionado anteriormente, quando uma tabela dinâmica é atualizada, um evento é registrado na tabela de eventos para indicar se a atualização foi bem-sucedida ou não. Você pode configurar um alerta sobre novos dados para monitorar a tabela de eventos. Você pode configurar o alerta para enviar uma notificação quando houver falha na atualização.

As próximas seções explicam como configurar o registro de eventos para capturar os eventos, como configurar o alerta e como interpretar os eventos registrados na tabela de eventos:

Nota

O registro de eventos para tabelas dinâmicas gera custos. Consulte Custos da coleta de dados de telemetria.

Defina o nível de gravidade dos eventos a serem capturados

Nota

Se você não definir o nível de gravidade, nenhum evento será capturado.

Para configurar os eventos da tabela dinâmica a serem registrados na tabela de eventos, defina o nível de gravidade dos eventos que você deseja capturar na tabela de eventos. Os eventos são capturados nos seguintes níveis:

  • ERROR: atualizar eventos de falha.

  • WARN: falhas na atualização de tabelas dinâmicas upstream e eventos de falha de atualização.

  • INFO: eventos de atualização bem-sucedidos, falhas na atualização de tabelas dinâmicas upstream e eventos de falha de atualização.

Para definir o nível, defina o parâmetro LOG_EVENT_LEVEL para a conta ou o objeto. Você pode definir o nível para:

  • Todos os objetos da conta.

  • Todos os objetos em um banco de dados ou esquema.

  • Uma tabela dinâmica específica.

Por exemplo:

  • Para capturar eventos de tabela dinâmica no nível ERROR para todos os objetos compatíveis na conta, execute ALTER ACCOUNT SET LOG_EVENT_LEVEL:

    ALTER ACCOUNT SET LOG_EVENT_LEVEL = ERROR;

    A configuração de LOG_EVENT_LEVEL no nível da conta aplica-se a eventos de log (tipo de registro EVENT) para cargas de trabalho compatíveis na conta, incluindo tabelas dinâmicas. Ela não substitui LOG_LEVEL para mensagens de log de APIs de registro. Para obter mais informações, consulte Parâmetros.

  • Para capturar eventos no nível INFO para todos os objetos compatíveis no banco de dados my_db, execute ALTER DATABASE … SET LOG_EVENT_LEVEL:

    ALTER DATABASE my_db SET LOG_EVENT_LEVEL = INFO;

    Semelhante ao caso de definir o nível na conta, a definição do nível no banco de dados afeta os eventos de log dos tipos de objeto compatíveis no banco de dados.

  • Para capturar eventos no nível WARN para a tabela dinâmica my_dynamic_table, execute ALTER DYNAMIC TABLE … SET LOG_EVENT_LEVEL:

    ALTER DYNAMIC TABLE my_dynamic_table SET LOG_EVENT_LEVEL = WARN;

Configure um alerta sobre novos dados

Após definir o nível de gravidade dos eventos de registro, você pode configurar um alerta sobre novos dados para monitorar a tabela de eventos em busca de novos eventos que indiquem uma falha em uma atualização dinâmica da tabela. Um alerta sobre novos dados é acionado quando novas linhas na tabela de eventos são inseridas e atendem à condição especificada no alerta.

Nota

Para criar o alerta sobre novos dados, você deve usar uma função que tenha recebido os privilégios necessários para consultar a tabela de eventos.

Na condição de alerta, para consultar os eventos da tabela dinâmica, selecione as linhas em que resource_attributes:"snow.executable.type" = 'DYNAMIC_TABLE'. Para restringir a lista de eventos, você pode filtrar nas seguintes colunas:

  • Para restringir os resultados a tabelas dinâmicas em um banco de dados específico, use resource_attributes:"snow.database.name".

  • Para retornar eventos em que a atualização falhou devido a um erro na tabela dinâmica, use value:state = 'FAILED'.

  • Para retornar eventos em que a atualização falhou devido a um erro em uma tabela dinâmica upstream, use value:state = 'UPSTREAM_FAILURE'.

Para obter informações sobre os valores registrados para um evento de tabela dinâmica, consulte Informações registradas para eventos de tabela dinâmica.

Nota

A coluna timestamp na tabela de eventos armazena valores em UTC. Se você usar um alerta programado com um filtro de carimbo de data/hora (por exemplo, timestamp > DATEADD('minute', -5, CURRENT_TIMESTAMP())), converta o carimbo de data/hora atual em UTC para garantir comparações precisas:

timestamp > DATEADD('minute', -5, CONVERT_TIMEZONE('UTC', CURRENT_TIMESTAMP()))

Por exemplo, a seguinte instrução cria um alerta para novos dados que executa uma ação quando as atualizações falham para tabelas dinâmicas no banco de dados my_db. O exemplo considera que:

CREATE ALERT my_alert_on_dt_refreshes
  IF( EXISTS(
    SELECT * FROM SNOWFLAKE.TELEMETRY.EVENT_TABLE
      WHERE resource_attributes:"snow.executable.type" = 'dynamic_table'
        AND resource_attributes:"snow.database.name" = 'my_db'
        AND record:"name" = 'refresh.status'
        AND record:"severity_text" = 'ERROR'
        AND value:"state" = 'FAILED'))
  THEN
    BEGIN
      LET result_str VARCHAR;
      (SELECT ARRAY_TO_STRING(ARRAY_AGG(name)::ARRAY, ',') INTO :result_str
         FROM (
           SELECT resource_attributes:"snow.executable.name"::VARCHAR name
             FROM TABLE(RESULT_SCAN(SNOWFLAKE.ALERT.GET_CONDITION_QUERY_UUID()))
             LIMIT 10
         )
      );
      CALL SYSTEM$SEND_SNOWFLAKE_NOTIFICATION(
        SNOWFLAKE.NOTIFICATION.TEXT_PLAIN(:result_str),
        '{"my_slack_integration": {}}'
      );
    END;

Informações registradas para eventos de tabela dinâmica

Quando uma tabela dinâmica é atualizada, um evento é registrado na tabela de eventos. As seções a seguir descrevem a linha da tabela de eventos que representa o evento:

Valores da coluna da tabela de eventos

Quando uma tabela dinâmica é atualizada, uma linha com os seguintes valores é inserida na tabela de eventos.

Nota

Se uma coluna não estiver listada abaixo, o valor da coluna será NULL para o evento.

Coluna

Tipo de dados

Descrição

timestamp

TIMESTAMP_NTZ

O carimbo de data/hora UTC em que um evento foi criado.

observed_timestamp

TIMESTAMP_NTZ

Uma hora UTC usada para registros. Atualmente, esse é o mesmo valor que está na coluna timestamp.

resource_attributes

OBJECT

Atributos que identificam a tabela dinâmica que foi atualizada.

record_type

STRING

O tipo de evento, que é EVENT para atualizações dinâmicas de tabelas.

record

OBJECT

Detalhes sobre o status da atualização da tabela dinâmica.

value

VARIANT

O status da atualização da tabela dinâmica e, se a atualização falhar, a mensagem de erro da falha.

Pares chave-valor na coluna resource_attributes

A coluna resource_attributes contém um valor OBJECT com os seguintes pares chave-valor:

Nome de atributo

Tipo de atributo

Descrição

Exemplo

snow.database.id

INTEGER

O identificador interno/gerado pelo sistema do banco de dados que contém a tabela dinâmica.

12345

snow.database.name

VARCHAR

O nome do banco de dados que contém a tabela dinâmica.

MY_DATABASE

snow.executable.id

INTEGER

O identificador interno/gerado pelo sistema da tabela dinâmica que foi atualizada.

12345

snow.executable.name

VARCHAR

O nome da tabela dinâmica que foi atualizada.

MY_DYNAMIC_TABLE

snow.executable.type

VARCHAR

O tipo do objeto. O valor é DYNAMIC_TABLE para eventos de tabela dinâmica.

DYNAMIC_TABLE

snow.owner.id

INTEGER

O identificador interno/gerado pelo sistema da função com o privilégio OWNERSHIP na tabela dinâmica.

12345

snow.owner.name

VARCHAR

O nome da função com o privilégio OWNERSHIP na tabela dinâmica.

MY_ROLE

snow.owner.type

VARCHAR

O tipo de função que possui o objeto, por exemplo ROLE. . Se um Snowflake Native App possui o objeto, o valor é APPLICATION. . Snowflake retorna NULL se você excluir o objeto porque um objeto excluído não tem uma função de proprietário.

ROLE

snow.query.id

VARCHAR

ID da consulta que atualizou a tabela dinâmica.

01ba7614-0107-e56c-0000-a995024f304a

snow.schema.id

INTEGER

O identificador interno/gerado pelo sistema do esquema que contém a tabela dinâmica.

12345

snow.schema.name

VARCHAR

O nome do esquema que contém a tabela dinâmica.

MY_SCHEMA

snow.warehouse.id

INTEGER

O identificador interno/gerado pelo sistema do warehouse usado para atualizar a tabela dinâmica.

12345

snow.warehouse.name

VARCHAR

O nome do warehouse usado para atualizar a tabela dinâmica.

MY_WAREHOUSE

Pares chave-valor na coluna record

A coluna record contém um valor OBJECT com os seguintes pares chave-valor:

Chave

Tipo

Descrição

Exemplo

name

VARCHAR

O nome do evento. O valor é refresh.status para atualizações de tabelas dinâmicas.

refresh.status

severity_text

VARCHAR

O nível de gravidade do evento, que é um dos seguintes valores:

  • INFO: a atualização foi bem-sucedida.

  • ERROR: a atualização falhou.

  • WARN: a atualização de uma tabela dinâmica upstream falhou.

INFO

Pares chave-valor na coluna value

A coluna value contém um valor VARIANT com os seguintes pares chave-valor:

Chave

Tipo

Descrição

Exemplo

state

VARCHAR

O estado da atualização, que pode ser um dos seguintes valores:

  • SUCCEEDED: a atualização foi bem-sucedida.

  • FAILED: a atualização falhou.

  • UPSTREAM_FAILURE: a atualização falhou devido a uma falha na atualização de uma tabela dinâmica da qual essa tabela dinâmica depende.

SUCCEEDED

message

VARCHAR

Se o valor em state for FAILED, esta coluna incluirá uma mensagem de erro.

SQL compilation error:\nFailure during expansion of view 'MY_DYNAMIC_TABLE': SQL compilation error:\nObject 'MY_DB.MY_SCHEMA.MY_BASE_TABLE' does not exist or not authorized.

Consultar intervalos de pipeline para rastrear atualizações

Além dos eventos, o Snowflake pode registrar intervalos de pipeline para atualizações de tabelas dinâmicas. Eventos e intervalos são dois mecanismos de observabilidade separados:

  • Eventos (controlados por LOG_LEVEL) fornecem atualização de logs por tabela dinâmica, indicando se cada atualização foi bem-sucedida ou falhou.

  • Intervalos (controlados por TRACE_LEVEL) fornecem observabilidade mais detalhada no nível do pipeline, incluindo IDs de rastreamento correlacionados em um pipeline, motivos para ignorar e topologia de dependência.

Os intervalos capturam estados adicionais para os quais os eventos não são emitidos, incluindo atualizações SKIPPED devido a saltos upstream ou ciclos de atualização em que o agendador ignorou a atualização para minimizar o atraso da tabela dinâmica e dos respectivos consumidores.

Nota

O registro de intervalos para tabelas dinâmicas incorre em custos. Consulte Custos da coleta de dados de telemetria.

Habilitar intervalos de pipeline

Para habilitar intervalos de pipeline para atualizações de tabelas dinâmicas, defina o parâmetro TRACE_LEVEL como ALWAYS no nível do banco de dados ou esquema:

ALTER SCHEMA my_db.my_schema SET TRACE_LEVEL = 'ALWAYS';

Você também pode defini-lo no nível do banco de dados para capturar intervalos para todas as tabelas dinâmicas no banco de dados:

ALTER DATABASE my_db SET TRACE_LEVEL = 'ALWAYS';

Consultar dados de intervalos

Para consultar os intervalos de pipeline para atualizações de tabelas dinâmicas, filtre por linhas em que record_type = 'SPAN' e record:"name" = 'table_refresh':

SELECT
    resource_attributes:"snow.executable.name"::STRING AS dt_name,
    record_attributes:"snow.dynamic_table.state"::STRING AS state,
    record_attributes:"snow.dynamic_table.state_reason"::STRING AS state_reason,
    record_attributes:"snow.dynamic_table.data_timestamp"::STRING AS data_timestamp,
    trace:"trace_id"::STRING AS trace_id,
    trace:"span_id"::STRING AS span_id,
    record:"status":"code"::STRING AS status_code
  FROM my_event_table
  WHERE record_type = 'SPAN'
    AND record:"name" = 'table_refresh'
  ORDER BY start_timestamp ASC;

Atributos de intervalo (record_attributes)

Cada linha de intervalo inclui os seguintes atributos na coluna record_attributes, específica para atualizações de tabelas dinâmicas:

Nome de atributo

Tipo

Descrição

snow.dynamic_table.state

STRING

O estado da atualização: SUCCEEDED, FAILED ou SKIPPED.

snow.dynamic_table.state_reason

STRING

Por que a tabela dinâmica foi ignorada ou falhou. NULL em caso de sucesso. Possíveis valores:

  • QUERY_FAILURE: a consulta de atualização falhou.

  • UPSTREAM_FAILURE: uma tabela dinâmica upstream não foi atualizada.

  • UPSTREAM_SKIP: uma tabela dinâmica upstream foi ignorada.

  • NOT_EFFECTIVE_TICK_TO_REFRESH: O pipeline já está atrasado, ignorando esta operação de atualização para minimizar o atraso desta tabela dinâmica e dos respectivos consumidores.

snow.dynamic_table.data_timestamp

STRING

O carimbo de data/hora transacional quando a atualização foi avaliada. (Isso pode ocorrer um pouco antes da hora real da atualização.) Todos os dados nos objetos base recebidos antes deste carimbo de data/hora estão incluídos na tabela dinâmica.

Nota

Os intervalos abrangem os estados SKIPPED (com motivos UPSTREAM_SKIP e NOT_EFFECTIVE_TICK_TO_REFRESH) para os quais os eventos não são emitidos. Se precisar de visibilidade sobre as atualizações ignoradas, use intervalos em vez de eventos.

Rastrear uma atualização de pipeline

Esta seção aborda como usar intervalos de pipeline para rastrear um ciclo de atualização completo: encontrar os intervalos relevantes, recuperar o pipeline completo e diagnosticar falhas ou saltos.

Exemplo de cenário de pipeline

Considere um pipeline linear de quatro tabelas dinâmicas:

DT1 --> DT2 --> DT3 --> DT4

Neste exemplo, DT1 e DT2 são atualizados com sucesso, mas há falha em DT3 devido a um erro de consulta. Porque DT3 falhou, DT4 é automaticamente ignorado com o motivo UPSTREAM_FAILURE.

As etapas a seguir mostram como recuperar e interpretar os intervalos de pipeline neste cenário.

Etapa 1: Encontrar o intervalo para uma tabela dinâmica

Para investigar a atualização de uma tabela dinâmica específica, consulte a tabela de eventos referente ao intervalo mais recente. Filtre por nome de banco de dados, esquema e tabela dinâmica para garantir que você corresponda ao objeto correto:

SELECT
    trace:"span_id"::STRING AS span_id,
    trace:"trace_id"::STRING AS trace_id,
    resource_attributes:"snow.executable.name"::STRING AS dt_name,
    record_attributes:"snow.dynamic_table.data_timestamp"::STRING AS data_timestamp,
    record_attributes:"snow.dynamic_table.state"::STRING AS state,
    record_attributes:"snow.dynamic_table.state_reason"::STRING AS state_reason,
    resource_attributes:"snow.query.id"::STRING AS query_id,
    start_timestamp,
    timestamp AS end_timestamp
  FROM my_event_table
  WHERE record_type = 'SPAN'
    AND record:"name" = 'table_refresh'
    AND resource_attributes:"snow.database.name" = 'MY_DB'
    AND resource_attributes:"snow.schema.name" = 'MY_SCHEMA'
    AND resource_attributes:"snow.executable.name" = 'DT3'
  ORDER BY start_timestamp DESC
  LIMIT 5;

+----------+------------------+---------+-------------------------+-----------+--------------+--------------------------------------+-------------------------+-------------------------+
| SPAN_ID  | TRACE_ID         | DT_NAME | DATA_TIMESTAMP          | STATE     | STATE_REASON | QUERY_ID                             | START_TIMESTAMP          | END_TIMESTAMP           |
|----------+------------------+---------+-------------------------+-----------+--------------+--------------------------------------+-------------------------+-------------------------|
| a1b2c3d4 | 4f3e2d1c0b9a8877 | DT3     | 2026-02-13T10:00:00.000 | FAILED    | QUERY_FAILURE| 01ba7614-0107-e56c-0000-a995024f304a | 2026-02-13 10:02:01.000 | 2026-02-13 10:02:20.000 |
| e5f6a7b8 | 7a8b9c0d1e2f3344 | DT3     | 2026-02-13T09:55:00.000 | SUCCEEDED | NULL         | 01ba7614-0107-e56c-0000-a995024f2f9b | 2026-02-13 09:57:01.000 | 2026-02-13 09:57:18.000 |
+----------+------------------+---------+-------------------------+-----------+--------------+--------------------------------------+-------------------------+-------------------------+

O valor trace_id identifica o ciclo de atualização. Todos os intervalos de tabela dinâmica em uma única atualização de pipeline compartilham o mesmo trace_id. Use esse valor na próxima etapa para recuperar todos os intervalos do mesmo ciclo de atualização.

Etapa 2: Recuperar o pipeline completo

Consulte todos os intervalos que compartilham o mesmo trace_id para ver cada tabela dinâmica no ciclo de atualização. Inclua record:"links" para capturar o gráfico de dependências e DATEDIFF para calcular a duração de cada operação de atualização:

SELECT
    trace:"span_id"::STRING AS span_id,
    trace:"trace_id"::STRING AS trace_id,
    resource_attributes:"snow.executable.name"::STRING AS dt_name,
    record_attributes:"snow.dynamic_table.state"::STRING AS state,
    record_attributes:"snow.dynamic_table.state_reason"::STRING AS state_reason,
    resource_attributes:"snow.query.id"::STRING AS query_id,
    start_timestamp,
    timestamp AS end_timestamp,
    DATEDIFF('second', start_timestamp, timestamp) AS duration_sec,
    record:"links" AS upstream_links
  FROM my_event_table
  WHERE record_type = 'SPAN'
    AND record:"name" = 'table_refresh'
    AND trace:"trace_id" = '4f3e2d1c0b9a8877'
  ORDER BY start_timestamp ASC;

+----------+------------------+---------+-----------+-----------------+--------------------------------------+-------------------------+-------------------------+--------------+---------------------------------------------+
| SPAN_ID  | TRACE_ID         | DT_NAME | STATE     | STATE_REASON    | QUERY_ID                             | START_TIMESTAMP          | END_TIMESTAMP           | DURATION_SEC | UPSTREAM_LINKS                              |
|----------+------------------+---------+-----------+-----------------+--------------------------------------+-------------------------+-------------------------+--------------+---------------------------------------------|
| f1e2d3c4 | 4f3e2d1c0b9a8877 | DT1     | SUCCEEDED | NULL            | 01ba7614-0107-e56c-0000-a995024f3001 | 2026-02-13 10:01:00.000 | 2026-02-13 10:01:30.000 |           30 | []                                          |
| b5a6c7d8 | 4f3e2d1c0b9a8877 | DT2     | SUCCEEDED | NULL            | 01ba7614-0107-e56c-0000-a995024f3002 | 2026-02-13 10:01:31.000 | 2026-02-13 10:02:00.000 |           29 | [{"span_id": "f1e2d3c4", ...}]              |
| a1b2c3d4 | 4f3e2d1c0b9a8877 | DT3     | FAILED    | QUERY_FAILURE   | 01ba7614-0107-e56c-0000-a995024f304a | 2026-02-13 10:02:01.000 | 2026-02-13 10:02:20.000 |           19 | [{"span_id": "b5a6c7d8", ...}]              |
| c9d0e1f2 | 4f3e2d1c0b9a8877 | DT4     | SKIPPED   | UPSTREAM_FAILURE| NULL                                 | 2026-02-13 10:02:20.000 | 2026-02-13 10:02:20.000 |            0 | [{"span_id": "a1b2c3d4", ...}]              |
+----------+------------------+---------+-----------+-----------------+--------------------------------------+-------------------------+-------------------------+--------------+---------------------------------------------+

Com base nesse resultado, você pode ver a imagem completa do ciclo de atualização:

  • DT1 e DT2 foram bem-sucedidos (30 e 29 segundos, respectivamente).

  • DT3 falhou após 19 segundos devido a uma falha na consulta.

  • DT4 foi ignorado imediatamente (representado por um intervalo de duração zero) porque sua dependência upstream falhou.

  • A coluna UPSTREAM_LINKS mostra as dependências diretas de cada tabela dinâmica por span_id.

Etapa 3: Identificar a causa raiz de uma falha ou um salto

Quando uma tabela dinâmica é ignorada ou falha, você pode rastrear suas dependências upstream por meio dos links de intervalos para encontrar a causa raiz. Esta consulta resolve os links de intervalos de uma tabela dinâmica específica de volta para os outros intervalos no pipeline:

WITH pipeline AS (
  SELECT
    trace:"span_id"::STRING AS span_id,
    resource_attributes:"snow.executable.name"::STRING AS dt_name,
    record_attributes:"snow.dynamic_table.state"::STRING AS state,
    record_attributes:"snow.dynamic_table.state_reason"::STRING AS state_reason,
    resource_attributes:"snow.query.id"::STRING AS query_id,
    record:"links" AS upstream_links
  FROM my_event_table
  WHERE record_type = 'SPAN'
    AND record:"name" = 'table_refresh'
    AND record_attributes:"snow.dynamic_table.data_timestamp" = '2026-02-13T10:00:00.000'
),
target_links AS (
  SELECT f.value:"span_id"::STRING AS upstream_span_id
  FROM pipeline,
  LATERAL FLATTEN(input => upstream_links) f
  WHERE dt_name = 'DT4'
)
SELECT
  p.dt_name AS upstream_dt,
  p.state AS upstream_state,
  p.state_reason AS upstream_reason,
  p.query_id AS upstream_query_id
FROM target_links tl
JOIN pipeline p ON tl.upstream_span_id = p.span_id;

+-------------+----------------+-----------------+--------------------------------------+
| UPSTREAM_DT | UPSTREAM_STATE | UPSTREAM_REASON | UPSTREAM_QUERY_ID                    |
|-------------+----------------+-----------------+--------------------------------------|
| DT3         | FAILED         | QUERY_FAILURE   | 01ba7614-0107-e56c-0000-a995024f304a |
+-------------+----------------+-----------------+--------------------------------------+

Neste exemplo, DT4 foi ignorado porque sua dependência upstream DT3 falhou com QUERY_FAILURE. Você pode usar o query_id para investigar em mais detalhes a consulta com falha (por exemplo, chamando GET_QUERY_OPERATOR_STATS ou verificando o histórico de consultas).

Para cadeias de dependência mais longas, repita o mesmo padrão: substitua o nome da tabela dinâmica de destino para subir ainda mais até atingir um intervalo com state = 'FAILED' e state_reason = 'QUERY_FAILURE', que é a causa raiz.

Encontrar o impacto downstream de uma falha

Para saber quais tabelas dinâmicas foram afetadas por uma falha específica, inverta a pesquisa do link de intervalo. Esta consulta encontra todas as tabelas dinâmicas em que record:"links" faz referência ao span_id da tabela dinâmica com falha:

WITH pipeline AS (
  SELECT
    trace:"span_id"::STRING AS span_id,
    resource_attributes:"snow.executable.name"::STRING AS dt_name,
    record_attributes:"snow.dynamic_table.state"::STRING AS state,
    record_attributes:"snow.dynamic_table.state_reason"::STRING AS state_reason,
    record:"links" AS upstream_links
  FROM my_event_table
  WHERE record_type = 'SPAN'
    AND record:"name" = 'table_refresh'
    AND record_attributes:"snow.dynamic_table.data_timestamp" = '2026-02-13T10:00:00.000'
)
SELECT p.dt_name, p.state, p.state_reason
FROM pipeline p,
LATERAL FLATTEN(input => p.upstream_links) f
WHERE f.value:"span_id"::STRING = 'a1b2c3d4';

+---------+---------+-----------------+
| DT_NAME | STATE   | STATE_REASON    |
|---------+---------+-----------------|
| DT4     | SKIPPED | UPSTREAM_FAILURE|
+---------+---------+-----------------+

Isso retorna os dependentes diretos da tabela dinâmica com falha. Para encontrar todas as tabelas dinâmicas afetadas transitivamente, repita a consulta com o span_id de cada dependente para descer ainda mais.

Usar ferramentas compatíveis com OpenTelemetry

Os intervalos de pipeline para tabelas dinâmicas seguem o modelo de dados padrão OpenTelemetry. Como todos os intervalos em um ciclo de atualização compartilham o mesmo trace:"trace_id", é possível exportá-los da tabela de eventos para ferramentas compatíveis com OpenTelemetry para visualização.

Essas ferramentas podem renderizar o pipeline como uma linha do tempo de rastreamento, mostrando a duração e o status da operação de atualização de cada tabela dinâmica e os relacionamentos de dependência codificados nos links de intervalos.