1pip install slack-sdk python-dotenv requests psutil

1SLACK_BOT_TOKEN=xoxb-your-token-here
2SLACK_CHANNEL_ID=C01234567  # Get this from channel details

1from slack_sdk import WebClient
2import os
3from dotenv import load_dotenv
4
5load_dotenv()
6
7client = WebClient(token=os.getenv('SLACK_BOT_TOKEN'))
8
9response = client.chat_postMessage(
10    channel=os.getenv('SLACK_CHANNEL_ID'),
11    text="Hello from Python! Bot is online. 🤖"
12)
13
14print(f"Message sent: {response['ts']}")

1import os
2from slack_sdk import WebClient
3from slack_sdk.errors import SlackApiError
4from dotenv import load_dotenv
5import schedule
6import time
7from datetime import datetime
8
9# Load environment variables
10load_dotenv()
11
12# Initialize Slack client
13client = WebClient(token=os.getenv('SLACK_BOT_TOKEN'))
14channel_id = os.getenv('SLACK_CHANNEL_ID')
15
16def post_standup_reminder():
17    """Post daily standup reminder to Slack channel"""
18    try:
19        # Create message with formatting
20        message = {
21            "channel": channel_id,
22            "blocks": [
23                {
24                    "type": "header",
25                    "text": {
26                        "type": "plain_text",
27                        "text": "⏰ Daily Standup Reminder",
28                        "emoji": True
29                    }
30                },
31                {
32                    "type": "section",
33                    "text": {
34                        "type": "mrkdwn",
35                        "text": "*Time for daily standup!*\n\nPlease share:\n• What you completed yesterday\n• What you're working on today\n• Any blockers"
36                    }
37                },
38                {
39                    "type": "divider"
40                },
41                {
42                    "type": "context",
43                    "elements": [
44                        {
45                            "type": "mrkdwn",
46                            "text": f"Sent: {datetime.now().strftime('%I:%M %p')}"
47                        }
48                    ]
49                }
50            ]
51        }
52        
53        # Send message
54        response = client.chat_postMessage(**message)
55        print(f"✅ Standup reminder sent at {datetime.now()}")
56        
57    except SlackApiError as e:
58        print(f"❌ Error sending message: {e.response['error']}")
59
60def run_bot():
61    """Schedule and run the bot"""
62    # Schedule reminder for 9:00 AM on weekdays
63    schedule.every().monday.at("09:00").do(post_standup_reminder)
64    schedule.every().tuesday.at("09:00").do(post_standup_reminder)
65    schedule.every().wednesday.at("09:00").do(post_standup_reminder)
66    schedule.every().thursday.at("09:00").do(post_standup_reminder)
67    schedule.every().friday.at("09:00").do(post_standup_reminder)
68    
69    print("🤖 Standup reminder bot is running...")
70    print("Scheduled for: Mon-Fri at 9:00 AM")
71    
72    # Keep the bot running
73    while True:
74        schedule.run_pending()
75        time.sleep(60)  # Check every minute
76
77if __name__ == "__main__":
78    # For testing, send immediately
79    post_standup_reminder()
80    
81    # Uncomment to run on schedule:
82    # run_bot()

1def post_weekly_report():
2    """Post weekly report with action buttons"""
3    message = {
4        "channel": channel_id,
5        "text": "Weekly Report Available",  # Fallback for notifications
6        "blocks": [
7            {
8                "type": "section",
9                "text": {
10                    "type": "mrkdwn",
11                    "text": "*📊 Weekly Report - Jan 28, 2026*\n\nYour weekly metrics summary is ready for review."
12                }
13            },
14            {
15                "type": "section",
16                "fields": [
17                    {
18                        "type": "mrkdwn",
19                        "text": "*Sales:*\n$45,230"
20                    },
21                    {
22                        "type": "mrkdwn",
23                        "text": "*New Leads:*\n127"
24                    },
25                    {
26                        "type": "mrkdwn",
27                        "text": "*Support Tickets:*\n34"
28                    },
29                    {
30                        "type": "mrkdwn",
31                        "text": "*Customer Satisfaction:*\n4.7/5.0"
32                    }
33                ]
34            },
35            {
36                "type": "actions",
37                "elements": [
38                    {
39                        "type": "button",
40                        "text": {
41                            "type": "plain_text",
42                            "text": "View Full Report"
43                        },
44                        "url": "https://dashboard.company.com/reports/weekly",
45                        "style": "primary"
46                    },
47                    {
48                        "type": "button",
49                        "text": {
50                            "type": "plain_text",
51                            "text": "Download PDF"
52                        },
53                        "url": "https://dashboard.company.com/reports/weekly.pdf"
54                    }
55                ]
56            }
57        ]
58    }
59    
60    client.chat_postMessage(**message)

1import psutil
2import requests
3from slack_sdk import WebClient
4import os
5from dotenv import load_dotenv
6import time
7
8load_dotenv()
9
10client = WebClient(token=os.getenv('SLACK_BOT_TOKEN'))
11channel_id = os.getenv('SLACK_ALERT_CHANNEL')  # Use dedicated alerts channel
12
13# Configuration
14CPU_THRESHOLD = 80  # Alert if CPU > 80%
15MEMORY_THRESHOLD = 85  # Alert if memory > 85%
16DISK_THRESHOLD = 90  # Alert if disk > 90%
17CHECK_INTERVAL = 60  # Check every 60 seconds
18
19def check_system_health():
20    """Check system metrics and return issues"""
21    issues = []
22    
23    # Check CPU usage
24    cpu_percent = psutil.cpu_percent(interval=1)
25    if cpu_percent > CPU_THRESHOLD:
26        issues.append({
27            "metric": "CPU Usage",
28            "value": f"{cpu_percent}%",
29            "threshold": f"{CPU_THRESHOLD}%",
30            "severity": "warning" if cpu_percent < 90 else "critical"
31        })
32    
33    # Check memory usage
34    memory = psutil.virtual_memory()
35    if memory.percent > MEMORY_THRESHOLD:
36        issues.append({
37            "metric": "Memory Usage",
38            "value": f"{memory.percent}%",
39            "threshold": f"{MEMORY_THRESHOLD}%",
40            "severity": "warning" if memory.percent < 95 else "critical"
41        })
42    
43    # Check disk usage
44    disk = psutil.disk_usage('/')
45    if disk.percent > DISK_THRESHOLD:
46        issues.append({
47            "metric": "Disk Usage",
48            "value": f"{disk.percent}%",
49            "threshold": f"{DISK_THRESHOLD}%",
50            "severity": "critical"
51        })
52    
53    return issues
54
55def check_website_uptime(url):
56    """Check if website is responding"""
57    try:
58        response = requests.get(url, timeout=10)
59        if response.status_code == 200:
60            return True, response.elapsed.total_seconds()
61        else:
62            return False, f"HTTP {response.status_code}"
63    except requests.exceptions.RequestException as e:
64        return False, str(e)
65
66def send_alert(issues):
67    """Send alert to Slack with issue details"""
68    # Determine overall severity
69    has_critical = any(issue['severity'] == 'critical' for issue in issues)
70    severity_emoji = "🚨" if has_critical else "⚠️"
71    severity_text = "CRITICAL" if has_critical else "WARNING"
72    
73    # Build message blocks
74    blocks = [
75        {
76            "type": "header",
77            "text": {
78                "type": "plain_text",
79                "text": f"{severity_emoji} System Alert: {severity_text}"
80            }
81        }
82    ]
83    
84    # Add each issue
85    for issue in issues:
86        blocks.append({
87            "type": "section",
88            "fields": [
89                {
90                    "type": "mrkdwn",
91                    "text": f"*Metric:*\n{issue['metric']}"
92                },
93                {
94                    "type": "mrkdwn",
95                    "text": f"*Current:*\n{issue['value']}"
96                },
97                {
98                    "type": "mrkdwn",
99                    "text": f"*Threshold:*\n{issue['threshold']}"
100                },
101                {
102                    "type": "mrkdwn",
103                    "text": f"*Severity:*\n{issue['severity'].upper()}"
104                }
105            ]
106        })
107        blocks.append({"type": "divider"})
108    
109    # Add timestamp
110    blocks.append({
111        "type": "context",
112        "elements": [
113            {
114                "type": "mrkdwn",
115                "text": f"Detected at {datetime.now().strftime('%Y-%m-%d %I:%M:%S %p')}"
116            }
117        ]
118    })
119    
120    # Send alert
121    client.chat_postMessage(
122        channel=channel_id,
123        text=f"System Alert: {severity_text}",  # Fallback
124        blocks=blocks
125    )
126    
127    print(f"🚨 Alert sent: {len(issues)} issues detected")
128
129def send_recovery_notification(metric):
130    """Send recovery notification when issue is resolved"""
131    client.chat_postMessage(
132        channel=channel_id,
133        text=f"✅ Recovered: {metric} has returned to normal levels"
134    )
135
136def monitor_loop():
137    """Main monitoring loop"""
138    print("🤖 Monitoring bot started...")
139    print(f"Checking every {CHECK_INTERVAL} seconds")
140    
141    alert_active = {}  # Track active alerts to avoid spam
142    
143    while True:
144        # Check system health
145        issues = check_system_health()
146        
147        # Check website uptime
148        website_up, response_data = check_website_uptime("https://yourwebsite.com")
149        if not website_up:
150            issues.append({
151                "metric": "Website Status",
152                "value": "DOWN",
153                "threshold": "UP",
154                "severity": "critical"
155            })
156        
157        # Send alerts for new issues
158        if issues:
159            new_issues = [i for i in issues if i['metric'] not in alert_active]
160            if new_issues:
161                send_alert(new_issues)
162                for issue in new_issues:
163                    alert_active[issue['metric']] = True
164        
165        # Check for recovered issues
166        current_metrics = {issue['metric'] for issue in issues}
167        for metric in list(alert_active.keys()):
168            if metric not in current_metrics:
169                send_recovery_notification(metric)
170                del alert_active[metric]
171        
172        # Wait before next check
173        time.sleep(CHECK_INTERVAL)
174
175if __name__ == "__main__":
176    monitor_loop()

1import psycopg2  # For PostgreSQL database
2from slack_sdk import WebClient
3import os
4import time
5
6client = WebClient(token=os.getenv('SLACK_BOT_TOKEN'))
7sales_channel = "C01234567"  # Your sales channel ID
8
9def check_new_leads():
10    """Check database for new high-value leads"""
11    conn = psycopg2.connect(
12        host="localhost",
13        database="crm",
14        user="app",
15        password=os.getenv('DB_PASSWORD')
16    )
17    
18    cursor = conn.cursor()
19    
20    # Query for leads created in last 5 minutes with high value indicators
21    query = """
22        SELECT id, company_name, contact_name, email, 
23               company_size, estimated_value, source
24        FROM leads
25        WHERE created_at > NOW() - INTERVAL '5 minutes'
26          AND (company_size > 100 OR estimated_value > 50000)
27        ORDER BY created_at DESC
28    """
29    
30    cursor.execute(query)
31    leads = cursor.fetchall()
32    
33    cursor.close()
34    conn.close()
35    
36    return leads
37
38def notify_sales_team(lead):
39    """Send formatted lead notification to sales channel"""
40    lead_id, company, contact, email, size, value, source = lead
41    
42    message = {
43        "channel": sales_channel,
44        "text": f"New high-value lead: {company}",
45        "blocks": [
46            {
47                "type": "header",
48                "text": {
49                    "type": "plain_text",
50                    "text": f"🎯 New High-Value Lead: {company}"
51                }
52            },
53            {
54                "type": "section",
55                "fields": [
56                    {
57                        "type": "mrkdwn",
58                        "text": f"*Contact:*\n{contact}"
59                    },
60                    {
61                        "type": "mrkdwn",
62                        "text": f"*Email:*\n{email}"
63                    },
64                    {
65                        "type": "mrkdwn",
66                        "text": f"*Company Size:*\n{size} employees"
67                    },
68                    {
69                        "type": "mrkdwn",
70                        "text": f"*Est. Value:*\n${value:,}"
71                    },
72                    {
73                        "type": "mrkdwn",
74                        "text": f"*Source:*\n{source}"
75                    }
76                ]
77            },
78            {
79                "type": "actions",
80                "elements": [
81                    {
82                        "type": "button",
83                        "text": {
84                            "type": "plain_text",
85                            "text": "View in CRM"
86                        },
87                        "url": f"https://crm.company.com/leads/{lead_id}",
88                        "style": "primary"
89                    },
90                    {
91                        "type": "button",
92                        "text": {
93                            "type": "plain_text",
94                            "text": "Claim Lead"
95                        },
96                        "value": f"claim_{lead_id}",
97                        "action_id": "claim_lead"
98                    }
99                ]
100            }
101        ]
102    }
103    
104    client.chat_postMessage(**message)
105    print(f"✅ Notified team about lead: {company}")
106
107def lead_monitoring_loop():
108    """Continuously monitor for new leads"""
109    print("🤖 Lead monitoring bot started...")
110    
111    notified_leads = set()  # Track already-notified leads
112    
113    while True:
114        leads = check_new_leads()
115        
116        for lead in leads:
117            lead_id = lead[0]
118            if lead_id not in notified_leads:
119                notify_sales_team(lead)
120                notified_leads.add(lead_id)
121        
122        # Check every 5 minutes
123        time.sleep(300)
124
125if __name__ == "__main__":
126    lead_monitoring_loop()

1from flask import Flask, request, jsonify
2from slack_sdk import WebClient
3import os
4from dotenv import load_dotenv
5import json
6
7load_dotenv()
8
9app = Flask(__name__)
10client = WebClient(token=os.getenv('SLACK_BOT_TOKEN'))
11
12def lookup_customer(email):
13    """Query database for customer information"""
14    # This would query your actual database
15    # Simplified example:
16    customers = {
17        "john@acme.com": {
18            "name": "John Smith",
19            "company": "Acme Corp",
20            "plan": "Enterprise",
21            "mrr": 5000,
22            "signup_date": "2025-06-15",
23            "status": "active"
24        },
25        "sarah@techco.com": {
26            "name": "Sarah Johnson",
27            "company": "TechCo",
28            "plan": "Professional",
29            "mrr": 500,
30            "signup_date": "2025-11-20",
31            "status": "active"
32        }
33    }
34    
35    return customers.get(email.lower())
36
37@app.route('/slack/commands', methods=['POST'])
38def handle_command():
39    """Handle incoming slash commands from Slack"""
40    # Parse command data
41    data = request.form
42    command = data.get('command')
43    text = data.get('text').strip()
44    user_id = data.get('user_id')
45    channel_id = data.get('channel_id')
46    response_url = data.get('response_url')
47    
48    # Validate command
49    if command != '/customer':
50        return jsonify({
51            "response_type": "ephemeral",
52            "text": "Unknown command"
53        })
54    
55    # Validate input
56    if not text or '@' not in text:
57        return jsonify({
58            "response_type": "ephemeral",
59            "text": "Please provide a customer email address.\nUsage: `/customer customer@email.com`"
60        })
61    
62    # Look up customer
63    customer = lookup_customer(text)
64    
65    if not customer:
66        return jsonify({
67            "response_type": "ephemeral",
68            "text": f"❌ No customer found with email: {text}"
69        })
70    
71    # Build response
72    response = {
73        "response_type": "in_channel",  # Visible to everyone
74        "blocks": [
75            {
76                "type": "header",
77                "text": {
78                    "type": "plain_text",
79                    "text": f"👤 Customer: {customer['name']}"
80                }
81            },
82            {
83                "type": "section",
84                "fields": [
85                    {
86                        "type": "mrkdwn",
87                        "text": f"*Company:*\n{customer['company']}"
88                    },
89                    {
90                        "type": "mrkdwn",
91                        "text": f"*Plan:*\n{customer['plan']}"
92                    },
93                    {
94                        "type": "mrkdwn",
95                        "text": f"*MRR:*\n${customer['mrr']:,}/month"
96                    },
97                    {
98                        "type": "mrkdwn",
99                        "text": f"*Status:*\n{customer['status'].upper()}"
100                    },
101                    {
102                        "type": "mrkdwn",
103                        "text": f"*Customer Since:*\n{customer['signup_date']}"
104                    }
105                ]
106            },
107            {
108                "type": "context",
109                "elements": [
110                    {
111                        "type": "mrkdwn",
112                        "text": f"Requested by <@{user_id}>"
113                    }
114                ]
115            }
116        ]
117    }
118    
119    return jsonify(response)
120
121if __name__ == '__main__':
122    # For production, use gunicorn or similar WSGI server
123    app.run(port=5000, debug=True)

1@app.route('/slack/actions', methods=['POST'])
2def handle_actions():
3    """Handle button clicks and interactions"""
4    # Parse the interaction payload
5    payload = json.loads(request.form['payload'])
6    action = payload['actions'][0]
7    user = payload['user']
8    
9    if action['action_id'] == 'claim_lead':
10        lead_id = action['value'].split('_')[1]
11        
12        # Update database to assign lead to user
13        assign_lead_to_user(lead_id, user['id'])
14        
15        # Update the message
16        return jsonify({
17            "replace_original": True,
18            "text": f"✅ Lead claimed by <@{user['id']}>"
19        })
20    
21    return jsonify({"text": "Action processed"})
22
23def assign_lead_to_user(lead_id, user_id):
24    """Assign lead in database"""
25    # Database update logic here
26    pass

1[Unit]
2Description=Slack Monitoring Bot
3After=network.target
4
5[Service]
6Type=simple
7User=appuser
8WorkingDirectory=/opt/slack-bot
9Environment="PATH=/opt/slack-bot/venv/bin"
10ExecStart=/opt/slack-bot/venv/bin/python bot.py
11Restart=always
12
13[Install]
14WantedBy=multi-user.target

1sudo systemctl enable slack-bot
2sudo systemctl start slack-bot
3sudo systemctl status slack-bot

1FROM python:3.10-slim
2
3WORKDIR /app
4
5COPY requirements.txt .
6RUN pip install --no-cache-dir -r requirements.txt
7
8COPY . .
9
10CMD ["python", "bot.py"]

1docker build -t slack-bot .
2docker run -d --name slack-bot \
3  --env-file .env \
4  --restart unless-stopped \
5  slack-bot

1import json
2from slack_sdk import WebClient
3import os
4
5client = WebClient(token=os.environ['SLACK_BOT_TOKEN'])
6
7def lambda_handler(event, context):
8    """Triggered by CloudWatch Events (cron)"""
9    
10    # Your bot logic
11    client.chat_postMessage(
12        channel=os.environ['SLACK_CHANNEL'],
13        text="Scheduled notification from Lambda"
14    )
15    
16    return {
17        'statusCode': 200,
18        'body': json.dumps('Notification sent')
19    }

1import time
2
3def send_multiple_notifications(messages):
4    """Send multiple messages with rate limiting"""
5    for message in messages:
6        client.chat_postMessage(**message)
7        time.sleep(1)  # 1 message per second to avoid rate limits

1from slack_sdk.errors import SlackApiError
2
3try:
4    client.chat_postMessage(channel="#alerts", text="Alert")
5except SlackApiError as e:
6    if e.response['error'] == 'channel_not_found':
7        print("Channel doesn't exist or bot not invited")
8    elif e.response['error'] == 'not_in_channel':
9        print("Bot needs to be invited to channel")
10    else:
11        print(f"Unexpected error: {e.response['error']}")

1import logging
2
3logging.basicConfig(
4    level=logging.INFO,
5    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
6    handlers=[
7        logging.FileHandler('bot.log'),
8        logging.StreamHandler()
9    ]
10)
11
12logger = logging.getLogger(__name__)
13
14logger.info("Bot started")
15logger.warning("CPU threshold exceeded")
16logger.error("Failed to send notification")

1# Good
2slack_token = os.getenv('SLACK_BOT_TOKEN')
3
4# Bad
5slack_token = "xoxb-12345-secret-token"  # Never do this!