Envoyer des alertes Snowflake vers MS Teams

Étape 1 : créer un Webhook dans Teams

Dans Teams, créez un nouveau canal ou rendez-vous dans celui où vous souhaitez recevoir les alertes.

En haut à droite du canal, cliquez sur les 3 points, puis sur Gérer le canal.

Rendez-vous dans l'onglet Paramètres, section Connecteurs, puis cliquez sur Modifier.

Une liste de connecteurs s'affiche. Recherchez Webhook, puis cliquez sur Ajouter.

Sur l'écran suivant, vous pouvez charger une image pour le webhook. Je vais utiliser un joli logo Snowflake. Pensez à nommer le webhook, puis cliquez sur Créer.

Après avoir cliqué sur Créer, l'URL du webhook s'affiche. Cette URL contient votre secret : manipulez-la avec précaution. Pour l'instant, copiez-la et collez-la dans un bloc-notes.

Tester le Webhook

Vous pouvez utiliser cette commande CURL pour tester le webhook. Sous Windows, utilisez Git Bash.

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

Le message Hello, world devrait apparaître aussitôt dans votre canal Teams.

Bravo, votre nouveau Webhook est opérationnel !

Étape 2 : créer le secret Snowflake

L'URL du Webhook contient un secret. Remplacez la chaîne ci-dessous par la vôtre, puis exécutez cette commande dans Snowflake.

Rappel : les secrets sont des objets de niveau schéma. Soyez attentif au contexte base de données/schéma de votre worksheet, ou utilisez des noms entièrement qualifiés.

De mon côté, j'ai créé un secret nommé gmds_teams_secret dans le schéma public de la base de données analytics.

use schmea <database>.<schema>;

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

Pour être précis, le secret correspond à la dernière partie de l'URI suivante : https://org-name.webhook.office.com/webhookb2/webhook-id/IncomingWebhook/this-is-the-secret

Étape 3 : créer une intégration de notification webhook

Le secret étant en place, passons à la création de l'intégration de notification :

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

Étape 4 : envoyer la notification

Pour envoyer une notification, nous utilisons la procédure stockée intégrée SYSTEM$SEND_SNOWFLAKE_NOTIFICATION. Il faut transmettre la fonction SANITIZE_WEBHOOK_CONTENT à la procédure pour retirer les placeholders (par exemple SNOWFLAKE_WEBHOOK_SECRET) du message.

Voici le code que j'ai exécuté dans mon compte :

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 notification est arrivée instantanément dans Microsoft Teams !

Les fondations sont posées : place à un exemple concret.

Écrire une requête SQL pour détecter les pics et l'encapsuler dans une serverless task

La requête suivante compare l'utilisation récente (dernière heure complète) à l'utilisation horaire moyenne de chaque warehouse sur le dernier mois. Ici, nous signalons les warehouses dont l'utilisation a augmenté de 50 %.

Nous passons par une serverless task : c'est plus économique ! Il suffit d'omettre le nom du warehouse pour rendre la tâche serverless.

À titre d'exemple, je vais joindre par UNION un enregistrement factice pour garantir que chaque exécution de la tâche produise une ligne et une alerte.

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

Développer le code

SCHEDULE = 'USING CRON 2 * * * * America/New_York' signifie 2 minutes après chaque heure, tous les jours.

Créer une table pour stocker les résultats de la requête

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

Notez que cette table comporte quelques colonnes utilitaires avec des valeurs par défaut, qui ne figurent pas dans les résultats de la requête :

• alert_id : clé primaire
• inserted_at : indique à quel moment la tâche a inséré l'enregistrement.
• alert_sent : à false au départ, passe à true une fois l'alerte envoyée.

Tester la tâche et examiner les résultats

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

Créer une procédure pour envoyer l'alerte en cas de pic

Voici ce que nous voulons faire :

• Vérifier la table usage_spike_alerts à la recherche d'enregistrements non envoyés : alert_sent==false
• S'il y en a, les transmettre à Microsoft Teams.
• Marquer l'enregistrement comme envoyé.
• Afficher le nombre d'alertes envoyées dans la console 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
    """

Développer le code

Tester la procédure manuellement

Nous avons déjà inséré une ligne de test dans la table spikes. Exécutons la sproc et vérifions que :

• les enregistrements passent à alert_sent==true
• nous recevons bien le message dans Microsoft Teams

execute task monitor_warehouse_spikes;  -- si ce n'est pas déjà fait...
select * from usage_spike_alerts where not alert_sent; -- vérifier, sent = false
CALL send_usage_spike_alerts(); -- envoyer l'alerte
-- attendre l'arrivée de l'alerte
select * from usage_spike_alerts where not alert_sent; -- 0 ligne

Vous devriez avoir reçu une alerte dans Teams !

La mise en forme de l'alerte peut être un peu fastidieuse. N'hésitez pas à expérimenter avec le code Python pour soigner le rendu, et à partager votre approche avec nous !

Chaîner la tâche et la procédure

Nous voulons que la planification horaire de la tâche monitor_warehouse_spikes orchestre l'ensemble du processus ; veillons à ce que la procédure d'envoi de l'alerte s'exécute immédiatement après monitor_warehouse_spikes.

D'abord, encapsulez la procédure dans une serverless task et activez-la :

CREATE TASK send_usage_spike_alerts_task
AS
CALL send_usage_spike_alerts();

alter task send_usage_spike_alerts_task resume;

Ensuite, chaînez les tâches :

ALTER TASK send_usage_spike_alerts_task
ADD AFTER monitor_warehouse_spikes;

Testez :

1execute task monitor_warehouse_spikes;

Cette tâche devrait désormais ajouter les nouveaux enregistrements à la table et envoyer la ou les alertes vers Teams !

Lorsque la procédure send_usage_spike_alerts() est appelée directement, le message apparaît immédiatement dans Microsoft Teams. En chaînant send_usage_spike_alerts_task à monitor_warehouse_spikes, il faut compter jusqu'à 3 minutes avant l'arrivée de l'alerte.

Envoyer des alertes Snowflake vers Microsoft Teams est extrêmement pratique. Les cas d'usage de ce type d'alerting sont quasiment illimités !

Cet article vous a permis de découvrir comment :

• créer un Webhook dans Microsoft Teams ;
• créer un secret dans Snowflake ;
• créer une intégration Webhook dans Snowflake ;
• créer une tâche pour journaliser les pics d'utilisation des warehouses ;
• créer une procédure qui envoie des alertes en fonction d'une condition — ici, la présence de lignes dans une requête ;
• encapsuler une procédure dans une tâche ;
• chaîner des tâches entre elles.

Hâte de découvrir les cas d'usage que vous allez imaginer ! 🥂

Jeff est consultant en data et analytics, fort de plus de 15 ans d'expérience dans l'automatisation des insights et l'exploitation des données pour piloter les processus métier. Côté technologie, il est spécialisé sur Snowflake + dbt + Tableau. Côté secteurs, il a travaillé dans les services publics, les essais cliniques, l'édition, les biens de grande consommation et l'industrie manufacturière. N'hésitez pas à le contacter : [email protected].