Introduction

In today’s data-driven world, ensuring the reliability of your data pipelines is critical. Snowflake, a powerful cloud data platform, allows you to automate complex workflows using stored procedures. But what happens when a procedure fails? Manually checking logs or waiting for someone to notice isn’t efficient. Instead, imagine getting an instant notification in your team’s Slack channel the moment an error occurs. In this blog, I’ll walk you through how to set up real-time error alerts from Snowflake stored procedures to Slack using Snowflake’s External Access Integration and a Python-based approach. Whether you’re a data engineer or a Snowflake admin, this use case will help you stay on top of issues and keep your pipelines running smoothly.

Use Case Overview

The goal is simple: whenever a stored procedure in Snowflake encounters an error (e.g., a syntax error, data issue, or runtime exception), an alert is automatically sent to a designated Slack channel. This ensures your team can respond quickly, minimizing downtime and data discrepancies. We’ll leverage:

  • Snowflake Stored Procedures: To execute logic and handle errors.
  • External Access Integration: To securely connect Snowflake to Slack’s API.
  • Slack Webhooks: To send messages to a Slack channel.
  • Snowflake Tasks: To schedule and automate the process (optional).

Prerequisites

Before we dive in, ensure you have:

  1. A Snowflake account with a role that has privileges to:
    • Create stored procedures (CREATE PROCEDURE).
    • Create external access integrations (CREATE INTEGRATION).
    • Manage secrets (CREATE SECRET).
    • Access the SNOWFLAKE.ACCOUNT_USAGE schema (for error logging).
  2. A Slack workspace where you’re an admin or have permission to create apps and webhooks.
  3. Basic familiarity with Python and SQL.

Step-by-Step Guide

Step 1: Set Up a Slack Webhook

Slack webhooks are a simple way to send messages to a channel programmatically.

  1. Create a Slack App:
    • Go to api.slack.com/apps and click "Create An App."

      1.png, Mar 2025
       
    • Choose "From scratch," name your app (e.g., "Snowflake Alerts"), and select your workspace.

      2.png, Mar 2025
       
    • Enter an app name and choose a workspace from the dropdown menu and click on create App button.

      3.png, Mar 2025








       

 

2. Enable Incoming Webhooks:

  • In the app’s settings, navigate to "Incoming Webhooks" and toggle it on.

    5.png, Mar 2025
     
  • Click "Add New Webhook to Workspace," select your target channel (e.g., #snowflake-alerts), and copy the generated webhook URL (e.g., https://hooks.slack.com/services/TXXXX/BXXXX/XXXX).Test the Webhook (optional):


    6.png, Mar 2025

     

Step 2: Configure Snowflake External Access

Snowflake’s External Access Integration allows secure communication with external APIs like Slack.

  1. Create a Network Rule:
    • Define where Snowflake can send requests (Slack’s domain).

      CREATE OR REPLACE NETWORK RULE slack_network_rule MODE = EGRESS TYPE = HOST_PORT VALUE_LIST = ('hooks.slack.com');

  2. Store the Webhook URL as a Secret:
    • Securely store the Slack webhook URL in Snowflake.

      CREATE OR REPLACE SECRET slack_webhook_secret TYPE = GENERIC_STRING SECRET_STRING = 'https://hooks.slack.com/services/TXXXX/BXXXX/XXXX';

  3. Create an External Access Integration:
    • Link the network rule and secret to allow Snowflake to call Slack.

      CREATE OR REPLACE EXTERNAL ACCESS INTEGRATION slack_access_integration ALLOWED_NETWORK_RULES = (slack_network_rule) ALLOWED_AUTHENTICATION_SECRETS = (slack_webhook_secret) ENABLED = TRUE;

Step 3: Create a Stored Procedure with Error Handling

Let’s create a sample stored procedure that might fail and trigger an alert.

  1. Sample Procedure:
    • This procedure attempts a division operation that could fail (e.g., division by zero).

      CREATE OR REPLACE PROCEDURE process_data() RETURNS STRING LANGUAGE PYTHON RUNTIME_VERSION = '3.8' PACKAGES = ('snowflake-snowpark-python', 'requests') EXTERNAL_ACCESS_INTEGRATIONS = (slack_access_integration) SECRETS = ('slack_url' = slack_webhook_secret) HANDLER = 'main' AS $$ import snowflake.snowpark as snowpark import requests import json import _snowflake def send_slack_alert(webhook_url, message): payload = {"text": message} response = requests.post(webhook_url, data=json.dumps(payload), headers={'Content-Type': 'application/json'}) if response.status_code != 200: raise Exception(f"Slack alert failed: {response.text}") def main(session): webhook_url = _snowflake.get_generic_secret_string('slack_url') try: # Simulate a potential error result = session.sql("SELECT 10 / 0 AS result").collect() return "Procedure completed successfully" except Exception as e: error_msg = f"Error in process_data: {str(e)}" send_slack_alert(webhook_url, error_msg) return error_msg $$;

  2. Key Components:
    • Error Handling: The try/except block catches errors (e.g., division by zero).
    • Slack Alert: The send_slack_alert function sends the error message to Slack.
    • External Access: The procedure uses the integration and secret to access Slack.

Step 4: Test the Procedure

Run the procedure and check Slack:

CALL process_data();

  • Expected Output: Since 10 / 0 causes an error, you’ll see a message in your Slack channel like:

     

Step 5: Automate with a Snowflake Task (Optional)

To monitor errors proactively, wrap the procedure in a task and schedule it.

  1. Create a Task:

    CREATE OR REPLACE TASK monitor_data_task WAREHOUSE = 'COMPUTE_WH' SCHEDULE = '5 MINUTE' AS CALL process_data();

  2. Enable the Task:

    ALTER TASK monitor_data_task RESUME;

  • Result: The task runs every 5 minutes, and any errors trigger a Slack alert.

Step 6: Monitor and Refine

  • Check Snowflake’s Query History to confirm the procedure’s execution:

    SELECT * FROM snowflake.account_usage.query_history WHERE procedure_name = 'PROCESS_DATA' ORDER BY start_time DESC LIMIT 10;

  • Adjust the Slack message format or frequency based on your team’s needs.

Deep Dive: How It Works

  1. Snowflake’s Role:
    • The stored procedure executes your logic and catches errors using Python’s exception handling.
    • The requests library, included via Snowflake’s package support, sends an HTTP POST request to Slack.
  2. Security:
    • External Access Integration ensures only approved endpoints (Slack) are accessible.
    • Secrets keep the webhook URL encrypted and inaccessible to users without proper privileges.
  3. Scalability:
    • Tasks can scale this approach to monitor multiple procedures or run on a schedule.
    • You can extend the logic to log errors in a table for historical tracking.

Best Practices

  1. Role-Based Access Control (RBAC):
    • Use a custom role (not ACCOUNTADMIN) for creating and executing these objects:

      GRANT USAGE ON INTEGRATION slack_access_integration TO ROLE data_engineer;
      GRANT EXECUTE ON PROCEDURE process_data() TO ROLE data_engineer;

  2. Error Granularity:
    • Include query IDs or timestamps in Slack messages for easier debugging:

      error_msg = f"Error in process_data at {time.ctime()}: {str(e)} (Query ID: {session.get_query_id()})"

  3. Rate Limiting:
    • Avoid overwhelming Slack with too many alerts—consider aggregating errors if failures are frequent.

Conclusion

With this setup, you’ve turned Snowflake into a proactive alerting system, bridging your data platform with team communication via Slack. This use case is just the beginning—imagine alerting on data quality issues, pipeline delays, or cost anomalies. By leveraging Snowflake’s External Access Integration, Python stored procedures, and Slack webhooks, you’ve built a lightweight, secure, and scalable solution to keep your team informed.

Try this in your Snowflake environment! Share your thoughts or variations in the comments below. Need help troubleshooting? Reach out—I’d love to hear how you’re using Snowflake and Slack together.