Envía alertas a MS Teams desde Snowflake

Paso 1: Crea un Webhook en Teams

Dentro de Teams, crea un canal nuevo o ve al canal donde quieres que lleguen las alertas.

En la esquina superior derecha del canal, haz clic en los 3 puntos y luego en "Administrar canal".

Ve a la pestaña Configuración, sección Conectores, y haz clic en Editar.

Aparecerá un listado de Conectores. Busca "Webhook" y haz clic en "Agregar".

En la siguiente pantalla puedes subir una imagen para el webhook. Yo voy a usar un buen logo de Snowflake. No olvides ponerle nombre al webhook y haz clic en "Crear".

Al hacer clic en "Crear" se mostrará la URL del webhook. Esa URL contiene tu secret, así que manéjala con cuidado. Por ahora, cópiala y pégala en un bloc de notas.

Prueba el Webhook

Puedes usar este comando CURL para probar el webhook. Si estás en Windows, usa Git Bash.

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

Casi al instante deberías ver el mensaje "Hello, world" en tu canal de Teams.

¡Listo, tu nuevo Webhook ya funciona!

Paso 2: Crea el Secret en Snowflake

La URL del Webhook contiene un secret. Reemplaza la cadena del secret de abajo por la tuya y ejecuta este comando en Snowflake.

Recuerda: los secrets son objetos a nivel de schema. Presta atención al contexto de database y schema de tu worksheet, o usa nombres totalmente calificados.

En mi caso, creé un secret llamado gmds_teams_secret en el schema public de la database analytics.

use schmea <database>.<schema>;

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

Para que quede claro, el secret es la última parte de la URI que se muestra aquí: https://org-name.webhook.office.com/webhookb2/webhook-id/IncomingWebhook/this-is-the-secret

Paso 3: Crea una notification integration con webhook

Ya que creamos el secret, vamos a crear la 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');

Paso 4: Envía la notificación

Para enviar una notificación usamos el stored procedure integrado SYSTEM$SEND_SNOWFLAKE_NOTIFICATION. Hay que pasarle la función SANITIZE_WEBHOOK_CONTENT al procedimiento para eliminar el placeholder (es decir, SNOWFLAKE_WEBHOOK_SECRET) del mensaje.

Este es el código que ejecuté en mi cuenta:

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')
);

¡La notificación llegó a Microsoft Teams al instante!

Ya tenemos las piezas básicas en su lugar; pasemos a un ejemplo real.

Arma una consulta SQL para detectar picos de uso del warehouse y envuélvela en un task serverless

La siguiente consulta compara el uso reciente (la última hora completada) contra el uso promedio por hora de cada warehouse durante el último mes. En este caso, marcaremos los warehouses cuyo uso haya aumentado un 50%.

Usamos un task serverless porque nos ahorra dinero. Basta con omitir el nombre del warehouse para que el task sea serverless.

A modo de ejemplo, voy a hacer un union con un registro ficticio para garantizar que cada ejecución del task produzca una fila y dispare una 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 después de cada hora, todos los días.

Crea una tabla para almacenar los resultados de la consulta

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
);

Ten en cuenta que esta tabla incluye algunas columnas auxiliares con valores por defecto que no provienen de los resultados de la consulta:

• alert_id: clave primaria
• inserted_at: nos permite saber cuándo el task insertó el registro.
• alert_sent: arranca en false y pasa a true después de enviar la alerta.

Prueba el task y revisa los resultados

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

Crea un procedimiento que envíe la alerta si hay un pico

Esto es lo que queremos hacer:

• Revisar la tabla usage_spike_alerts en busca de registros sin enviar: alert_sent==false
• Si hay registros pendientes, mandarlos a Microsoft Teams.
• Marcar el registro como enviado.
• Mostrar la cantidad de alertas enviadas en la consola SQL.

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

Prueba el procedimiento manualmente

Ya insertamos una fila de prueba en la tabla "spikes". Ejecutemos el sproc y comprobemos que:

• Los registros se actualicen a alert_sent==true
• Recibamos el mensaje en Microsoft Teams

execute task monitor_warehouse_spikes;  -- si aún no lo hiciste...
select * from usage_spike_alerts where not alert_sent; -- revísalo, sent = false
CALL send_usage_spike_alerts(); -- envía la alerta
-- espera a que llegue la alerta
select * from usage_spike_alerts where not alert_sent; -- 0 filas

¡Deberías haber recibido una alerta en Teams!

Darle formato a la alerta puede ser un poco tedioso. Te animo a experimentar con el código en Python para enviarla con un formato más vistoso. ¡Cuéntanos cómo te fue!

Encadena el task y el procedimiento

Queremos que la programación horaria del task monitor_warehouse_spikes se encargue del proceso de punta a punta; asegurémonos de que, después de ejecutar el task monitor_warehouse_spikes, también se ejecute el procedimiento que envía la alerta.

Primero, envuelve el procedimiento en un task serverless y actívalo:

CREATE TASK send_usage_spike_alerts_task
AS
CALL send_usage_spike_alerts();

alter task send_usage_spike_alerts_task resume;

Después, encadena los tasks:

ALTER TASK send_usage_spike_alerts_task
ADD AFTER monitor_warehouse_spikes;

Pruébalo:

1execute task monitor_warehouse_spikes;

¡Ahora este task debería agregar los nuevos registros a la tabla y enviar la(s) alerta(s) a Teams!

Cuando llamas al procedimiento send_usage_spike_alerts() directamente, el mensaje aparece en Microsoft Teams al instante. Al encadenar el task send_usage_spike_alerts_task con monitor_warehouse_spikes, la alerta puede tardar hasta 3 minutos en llegar.

Enviar alertas de Snowflake a Microsoft Teams es de una utilidad enorme. ¡Los casos de uso para este tipo de alertas son infinitos!

Con este artículo ya sabes cómo:

• Crear un Webhook en Microsoft Teams.
• Crear un Secret en Snowflake.
• Crear una Webhook Integration en Snowflake.
• Crear un task para registrar picos de uso del warehouse.
• Crear un procedimiento que envía alertas según una condición. En este caso, la existencia de filas en una consulta.
• Envolver un procedimiento dentro de un task.
• Encadenar varios tasks.

¡Tengo muchas ganas de conocer los casos de uso que se te ocurran! 🥂

Jeff es consultor de Datos y Analítica con más de 15 años de experiencia automatizando insights y aprovechando los datos para controlar procesos de negocio. En lo tecnológico, se especializa en Snowflake + dbt + Tableau. En lo sectorial, ha trabajado en Servicios Públicos, Ensayos Clínicos, Publishing, CPG y Manufactura. Escríbele cuando quieras a [email protected].