Enviando alertas do Snowflake para o MS Teams

Passo 1: criar um Webhook no Teams

No Teams, crie um novo canal ou acesse o canal em que você quer receber os alertas.

No canto superior direito do canal, clique nos 3 pontos e depois em "Gerenciar canal".

Acesse a aba Configurações, seção Conectores, e clique em Editar.

Você verá uma lista de Conectores. Procure por "Webhook" e clique em "Adicionar".

Na próxima tela, dá para fazer upload de uma imagem para o webhook. Vou usar um logo bacana do Snowflake. Não esqueça de dar um nome ao webhook e clique em "Criar".

Depois de clicar em "Criar", a URL do webhook vai aparecer. Essa URL contém o seu secret, então cuide bem dela. Por enquanto, copie a URL e cole em um bloco de notas.

Testando o Webhook

Você pode usar este comando CURL para testar o webhook. Se estiver no Windows, use o Git Bash.

curl -X POST https://paste-your-url-with-secret-here \
-H "Content-Type: application/json" \
-d '{"text": "Hello, world"}'

Na hora, a mensagem "Hello, world" já deve aparecer no seu canal do Teams.

Parabéns, seu novo Webhook está funcionando!

Passo 2: criar o Secret no Snowflake

A URL do Webhook contém um secret. Substitua a string do secret abaixo pela sua e rode este comando no Snowflake.

Lembrete: secrets são objetos a nível de schema. Atenção ao contexto de database e schema da sua worksheet, ou use nomes totalmente qualificados.

No meu caso, criei um secret chamado gmds_teams_secret no schema public do database analytics.

use schmea <database>.<schema>;

CREATE OR REPLACE SECRET gmds_teams_secret
  TYPE = GENERIC_STRING
  SECRET_STRING = 'this-is-the-secret';

Para deixar claro, o secret é a última parte da URI mostrada aqui: https://org-name.webhook.office.com/webhookb2/webhook-id/IncomingWebhook/this-is-the-secret

Passo 3: criar uma integração de notificação via webhook

Agora que o secret está criado, vamos montar a Notification Integration:

CREATE OR REPLACE NOTIFICATION INTEGRATION gmds_teams_webhook_integration
  TYPE=WEBHOOK
  ENABLED=TRUE
  WEBHOOK_URL='https://org-name/webhook.office.com/webhookb2/webhook-id/IncomingWebhook/SNOWFLAKE_WEBHOOK_SECRET'
  WEBHOOK_SECRET=analytics.public.gmds_teams_secret
  WEBHOOK_BODY_TEMPLATE='{"text": "SNOWFLAKE_WEBHOOK_MESSAGE"}'
  WEBHOOK_HEADERS=('Content-Type'='application/json');

Passo 4: enviar a notificação

Para enviar uma notificação, usamos a stored procedure nativa SYSTEM$SEND_SNOWFLAKE_NOTIFICATION. Precisamos passar a função SANITIZE_WEBHOOK_CONTENT para a procedure, a fim de remover o placeholder (ou seja, SNOWFLAKE_WEBHOOK_SECRET) da mensagem.

Veja o código que rodei na minha conta:

CALL SYSTEM$SEND_SNOWFLAKE_NOTIFICATION(
  SNOWFLAKE.NOTIFICATION.TEXT_PLAIN(
    SNOWFLAKE.NOTIFICATION.SANITIZE_WEBHOOK_CONTENT('This is a test Teams Alert from my Snowflake Account')
  ),
  SNOWFLAKE.NOTIFICATION.INTEGRATION('gmds_teams_webhook_integration')
);

A notificação chegou no Microsoft Teams na hora!

Com a engrenagem básica funcionando, vamos para um exemplo do mundo real.

Monte uma query SQL para identificar picos de uso do warehouse e encapsule em uma task serverless

A query a seguir compara o uso recente (última hora completa) com a média de uso por hora de cada warehouse no último mês. Aqui, vamos sinalizar warehouses com aumento de uso de 50%.

Estamos usando uma task serverless porque isso economiza dinheiro! Basta omitir o nome do warehouse para tornar a task serverless.

A título de exemplo, vou fazer um union com um registro fictício para garantir que toda execução da task gere uma linha e um alerta.

CREATE OR REPLACE TASK monitor_warehouse_spikes
SCHEDULE = 'USING CRON 2 * * * * America/New_York'
SERVERLESS_TASK_MIN_STATEMENT_SIZE = 'XSMALL'
SERVERLESS_TASK_MAX_STATEMENT_SIZE = 'XSMALL'
as
insert into usage_spike_alerts (warehouse_name,last_hour_credits,avg_monthly_credits,credit_diff,percent_increase)
WITH last_hour_usage AS (
    SELECT
        warehouse_name,
        sum(credits_used) AS last_hour_credits
    FROM
        snowflake.account_usage.warehouse_metering_history
    WHERE
        start_time >= DATEADD(hour, -2, CURRENT_TIMESTAMP)
        AND end_time <= CURRENT_TIMESTAMP

Expandir código

SCHEDULE = 'USING CRON 2 * * * * America/New_York' significa 2 minutos após cada hora cheia, todos os dias.

Crie uma tabela para guardar os resultados da query

CREATE or replace TABLE usage_spike_alerts (
    alert_id INT AUTOINCREMENT PRIMARY KEY,
    warehouse_name STRING NOT NULL,
    last_hour_credits FLOAT NOT NULL,
    avg_monthly_credits FLOAT NOT NULL,
    credit_diff FLOAT NOT NULL,
    percent_increase FLOAT NOT NULL,
    inserted_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    alert_sent boolean default false
);

Repare que essa tabela tem algumas colunas auxiliares com valores padrão, que não vêm dos resultados da query:

• alert_id: chave primária
• inserted_at: ajuda a saber quando a task inseriu o registro.
• alert_sent: começa como false e vira true depois que o alerta é enviado.

Teste a task e confira os resultados

execute task monitor_warehouse_spikes;
select * from usage_spike_alerts where not alert_sent;

Crie uma procedure para disparar o alerta quando houver um pico

O que queremos fazer:

• Verificar na tabela usage_spike_alerts se existem registros não enviados: alert_sent==false
• Se houver, mandá-los para o Microsoft Teams.
• Marcar o registro como enviado.
• Mostrar no console SQL quantos alertas foram enviados.

CREATE OR REPLACE PROCEDURE send_usage_spike_alerts()
RETURNS STRING
LANGUAGE PYTHON
RUNTIME_VERSION = '3.8'
PACKAGES = ('snowflake-snowpark-python')
HANDLER = 'send_alerts'
AS $$
import snowflake.snowpark as snowpark

def send_alerts(session):
    query = """
        SELECT warehouse_name, last_hour_credits, avg_monthly_credits, credit_diff, percent_increase
        FROM usage_spike_alerts
        WHERE alert_sent = FALSE
    """

Expandir código

Teste a procedure manualmente

Já inserimos uma linha de teste na tabela "spikes". Vamos rodar a sproc e garantir que:

• Os registros sejam atualizados para alert_sent==true
• A mensagem chegue no Microsoft Teams

execute task monitor_warehouse_spikes;  -- caso ainda não tenha rodado...
select * from usage_spike_alerts where not alert_sent; -- confira, sent = false
CALL send_usage_spike_alerts(); -- envia o alerta
-- aguarde o alerta chegar
select * from usage_spike_alerts where not alert_sent; -- 0 linhas

Você deve ter recebido um alerta no Teams!

Formatar o alerta pode ser meio chato. Fica a dica: brinque com o código Python para deixar o alerta com uma aparência mais bonita, e depois conta pra gente como fez!

Encadeie a task e a procedure

Queremos que o agendamento por hora da task monitor_warehouse_spikes dê conta de todo o processo, do início ao fim; então vamos garantir que, depois de a task monitor_warehouse_spikes rodar, a procedure que envia o alerta também seja executada.

Primeiro, encapsule a procedure em uma task serverless e ative-a:

CREATE TASK send_usage_spike_alerts_task
AS
CALL send_usage_spike_alerts();

alter task send_usage_spike_alerts_task resume;

Em seguida, encadeie as tasks:

ALTER TASK send_usage_spike_alerts_task
ADD AFTER monitor_warehouse_spikes;

Teste:

1execute task monitor_warehouse_spikes;

Essa task agora deve adicionar os novos registros à tabela e enviar o(s) alerta(s) para o Teams!

Quando a procedure send_usage_spike_alerts() é chamada diretamente, a mensagem chega no Microsoft Teams na hora. Já quando encadeamos a task send_usage_spike_alerts_task à task monitor_warehouse_spikes, o alerta pode levar até 3 minutos para chegar.

Enviar alertas do Snowflake para o Microsoft Teams é extremamente útil. Os casos de uso para esse tipo de alerta são infinitos!

Com este artigo, você aprendeu a:

• Criar um Webhook no Microsoft Teams.
• Criar um Secret no Snowflake.
• Criar uma Webhook Integration no Snowflake.
• Criar uma task para registrar picos de uso de warehouse.
• Criar uma procedure para enviar alertas com base em uma condição. Neste caso, a existência de linhas em uma query.
• Encapsular uma procedure em uma task.
• Encadear tasks.

Mal posso esperar para conhecer os casos de uso que você vai criar! 🥂

Jeff é Consultor de Dados e Analytics, com mais de 15 anos de experiência em automatizar insights e usar dados para conduzir processos de negócio. Do ponto de vista tecnológico, é especialista em Snowflake + dbt + Tableau. Já em termos de negócios, tem vivência em Serviços Públicos, Ensaios Clínicos, Editorial, CPG e Manufatura. Entre em contato quando quiser: [email protected].