Slack Bot 구축 실전 가이드 — Python Bolt SDK, 이벤트 핸들링, 슬래시 커맨드

# 1단계: Slack API 사이트에서 앱 생성
# https://api.slack.com/apps 접속
# "Create New App" -> "From scratch" 선택
# App Name: "MySlackBot", Workspace 선택

# 2단계: OAuth & Permissions에서 Bot Token Scopes 설정
# 필요한 스코프 목록:
#   chat:write          - 메시지 전송
#   chat:write.public   - 미참여 공개 채널에 메시지 전송
#   commands            - 슬래시 커맨드 등록
#   im:history          - DM 메시지 읽기
#   im:read             - DM 채널 정보 접근
#   channels:history    - 공개 채널 메시지 읽기
#   channels:read       - 채널 목록/정보 조회
#   users:read          - 사용자 프로필 조회
#   reactions:read      - 리액션 정보 읽기
#   reactions:write     - 리액션 추가
#   files:write         - 파일 업로드

# 3단계: Event Subscriptions 활성화
# Subscribe to bot events:
#   message.im          - DM 수신
#   message.channels    - 채널 메시지 수신
#   app_mention         - @봇 멘션 수신
#   app_home_opened     - 앱 홈 탭 열기
#   reaction_added      - 리액션 추가 이벤트
#   reaction_removed    - 리액션 제거 이벤트

# 4단계: Interactivity & Shortcuts 활성화
# 모달, 버튼, 셀렉트 메뉴 등 인터랙티브 기능 사용에 필요

# 5단계: Socket Mode 활성화 (개발/간편 배포용)
# Settings -> Socket Mode -> Enable Socket Mode
# App-Level Token 생성 (connections:write 스코프)

# Python 3.9+ 권장
python -m venv .venv
source .venv/bin/activate

# 핵심 의존성 설치
pip install slack-bolt==1.27.0 slack-sdk python-dotenv

# 프로젝트 디렉토리 구조
mkdir -p slack-bot/{handlers,services,utils}
touch slack-bot/{app.py,.env,requirements.txt}
touch slack-bot/handlers/{__init__.py,commands.py,events.py,actions.py,modals.py}
touch slack-bot/services/{__init__.py,notification.py}
touch slack-bot/utils/{__init__.py,rate_limiter.py,logger.py}

# 디렉토리 구조 확인
# slack-bot/
# ├── app.py                 # 메인 앱 엔트리포인트
# ├── .env                   # 환경변수 (토큰 등)
# ├── requirements.txt
# ├── Dockerfile
# ├── handlers/
# │   ├── __init__.py
# │   ├── commands.py        # 슬래시 커맨드 핸들러
# │   ├── events.py          # 이벤트 핸들러 (메시지, 멘션)
# │   ├── actions.py         # 버튼/셀렉트 액션 핸들러
# │   └── modals.py          # 모달 뷰 핸들러
# ├── services/
# │   ├── __init__.py
# │   └── notification.py    # 알림 서비스
# └── utils/
#     ├── __init__.py
#     ├── rate_limiter.py    # 레이트 리밋 유틸리티
#     └── logger.py          # 로깅 설정

# app.py
import os
import logging
from dotenv import load_dotenv
from slack_bolt import App
from slack_bolt.adapter.socket_mode import SocketModeHandler

load_dotenv()

# 로깅 설정
logging.basicConfig(
    level=logging.INFO,
    format="%(asctime)s [%(levelname)s] %(name)s: %(message)s",
)
logger = logging.getLogger(__name__)

# Bolt App 초기화
app = App(
    token=os.environ["SLACK_BOT_TOKEN"],
    signing_secret=os.environ.get("SLACK_SIGNING_SECRET"),
)


# ===== 글로벌 미들웨어 =====
@app.middleware
def log_request(logger, body, next):
    """모든 요청을 로깅하는 미들웨어"""
    logger.info(f"Request type: {body.get('type', 'unknown')}")
    next()


# ===== 이벤트 핸들러 등록 =====
from handlers.events import register_event_handlers
from handlers.commands import register_command_handlers
from handlers.actions import register_action_handlers
from handlers.modals import register_modal_handlers

register_event_handlers(app)
register_command_handlers(app)
register_action_handlers(app)
register_modal_handlers(app)


# ===== 글로벌 에러 핸들러 =====
@app.error
def global_error_handler(error, body, logger):
    logger.exception(f"Unhandled error: {error}")
    logger.debug(f"Request body: {body}")


# ===== 실행 =====
if __name__ == "__main__":
    logger.info("Slack Bot starting in Socket Mode...")
    handler = SocketModeHandler(app, os.environ["SLACK_APP_TOKEN"])
    handler.start()

# handlers/events.py
import re
from datetime import datetime


def register_event_handlers(app):
    """이벤트 핸들러를 앱에 등록"""

    # --- 앱 멘션 처리 ---
    @app.event("app_mention")
    def handle_app_mention(event, say, client, logger):
        """@봇 멘션 시 호출"""
        user_id = event["user"]
        text = event.get("text", "")
        channel = event["channel"]

        # 멘션 텍스트에서 봇 ID 제거
        clean_text = re.sub(r"<@\w+>", "", text).strip()

        try:
            user_info = client.users_info(user=user_id)
            display_name = user_info["user"]["real_name"]
        except Exception as e:
            logger.error(f"Failed to fetch user info: {e}")
            display_name = "사용자"

        if "도움" in clean_text or "help" in clean_text.lower():
            say(
                channel=channel,
                blocks=[
                    {
                        "type": "section",
                        "text": {
                            "type": "mrkdwn",
                            "text": (
                                f"안녕하세요 {display_name}님!\n\n"
                                "*사용 가능한 명령어:*\n"
                                "- `/task` - 작업 생성\n"
                                "- `/status` - 서비스 상태 조회\n"
                                "- `/oncall` - 온콜 담당자 확인\n"
                                "- DM으로 자유롭게 질문하세요!"
                            ),
                        },
                    }
                ],
            )
        else:
            say(
                channel=channel,
                text=f"{display_name}님, 말씀하신 내용을 확인하겠습니다.",
                thread_ts=event.get("ts"),  # 스레드로 응답
            )

    # --- DM 메시지 처리 ---
    @app.event("message")
    def handle_message(event, say, logger):
        """채널/DM 메시지 이벤트 처리"""
        # 봇 자신의 메시지, 편집, 삭제 이벤트 무시
        if event.get("bot_id") or event.get("subtype"):
            return

        channel_type = event.get("channel_type", "")
        text = event.get("text", "")
        user_id = event.get("user", "")

        # DM 메시지만 자동 응답
        if channel_type == "im":
            logger.info(f"DM from {user_id}: {text[:50]}...")

            # 키워드 기반 분기 처리
            if "장애" in text or "incident" in text.lower():
                say(
                    text="장애 보고를 등록하시겠습니까?",
                    blocks=[
                        {
                            "type": "section",
                            "text": {
                                "type": "mrkdwn",
                                "text": "장애 보고를 등록하시겠습니까?",
                            },
                            "accessory": {
                                "type": "button",
                                "text": {"type": "plain_text", "text": "장애 보고"},
                                "action_id": "open_incident_modal",
                                "style": "danger",
                            },
                        }
                    ],
                )
            else:
                say(f"메시지를 받았습니다. 자세한 도움이 필요하시면 `/help`를 입력해주세요.")

    # --- 리액션 이벤트 처리 ---
    @app.event("reaction_added")
    def handle_reaction_added(event, client, logger):
        """리액션 추가 이벤트 처리 (예: 이모지로 작업 트리거)"""
        reaction = event["reaction"]
        item = event["item"]
        user_id = event["user"]

        logger.info(f"Reaction :{reaction}: added by {user_id}")

        # :white_check_mark: 리액션으로 작업 완료 처리
        if reaction == "white_check_mark":
            client.chat_postMessage(
                channel=item["channel"],
                thread_ts=item["ts"],
                text=f"<@{user_id}>님이 이 작업을 완료 처리했습니다.",
            )

        # :eyes: 리액션으로 작업 확인 처리
        elif reaction == "eyes":
            client.chat_postMessage(
                channel=item["channel"],
                thread_ts=item["ts"],
                text=f"<@{user_id}>님이 이 내용을 확인 중입니다.",
            )

    # --- 앱 홈 탭 ---
    @app.event("app_home_opened")
    def handle_app_home_opened(client, event, logger):
        """앱 홈 탭 열릴 때 대시보드 표시"""
        user_id = event["user"]
        now = datetime.now().strftime("%Y-%m-%d %H:%M")

        try:
            client.views_publish(
                user_id=user_id,
                view={
                    "type": "home",
                    "blocks": [
                        {
                            "type": "header",
                            "text": {
                                "type": "plain_text",
                                "text": "Bot Dashboard",
                            },
                        },
                        {
                            "type": "section",
                            "text": {
                                "type": "mrkdwn",
                                "text": (
                                    "*사용 가능한 기능:*\n"
                                    "- `/task` : 작업 생성 및 관리\n"
                                    "- `/status` : 서비스 상태 확인\n"
                                    "- `/oncall` : 온콜 담당자 조회\n"
                                    "- DM : 자유 질의응답"
                                ),
                            },
                        },
                        {"type": "divider"},
                        {
                            "type": "context",
                            "elements": [
                                {
                                    "type": "mrkdwn",
                                    "text": f"마지막 업데이트: {now}",
                                }
                            ],
                        },
                    ],
                },
            )
        except Exception as e:
            logger.error(f"Failed to publish home tab: {e}")

# handlers/commands.py
import json
from datetime import datetime


def register_command_handlers(app):

    @app.command("/task")
    def handle_task_command(ack, body, client, logger):
        """작업 생성 모달을 여는 슬래시 커맨드"""
        # 반드시 3초 내에 ack() 호출 필수!
        ack()

        try:
            client.views_open(
                trigger_id=body["trigger_id"],
                view={
                    "type": "modal",
                    "callback_id": "task_create_modal",
                    "title": {"type": "plain_text", "text": "작업 생성"},
                    "submit": {"type": "plain_text", "text": "생성"},
                    "close": {"type": "plain_text", "text": "취소"},
                    "blocks": [
                        {
                            "type": "input",
                            "block_id": "title_block",
                            "element": {
                                "type": "plain_text_input",
                                "action_id": "title_input",
                                "placeholder": {
                                    "type": "plain_text",
                                    "text": "작업 제목을 입력하세요",
                                },
                            },
                            "label": {"type": "plain_text", "text": "제목"},
                        },
                        {
                            "type": "input",
                            "block_id": "priority_block",
                            "element": {
                                "type": "static_select",
                                "action_id": "priority_select",
                                "options": [
                                    {
                                        "text": {"type": "plain_text", "text": "P1 - 긴급"},
                                        "value": "P1",
                                    },
                                    {
                                        "text": {"type": "plain_text", "text": "P2 - 높음"},
                                        "value": "P2",
                                    },
                                    {
                                        "text": {"type": "plain_text", "text": "P3 - 보통"},
                                        "value": "P3",
                                    },
                                    {
                                        "text": {"type": "plain_text", "text": "P4 - 낮음"},
                                        "value": "P4",
                                    },
                                ],
                            },
                            "label": {"type": "plain_text", "text": "우선순위"},
                        },
                        {
                            "type": "input",
                            "block_id": "assignee_block",
                            "element": {
                                "type": "users_select",
                                "action_id": "assignee_select",
                                "placeholder": {
                                    "type": "plain_text",
                                    "text": "담당자 선택",
                                },
                            },
                            "label": {"type": "plain_text", "text": "담당자"},
                        },
                        {
                            "type": "input",
                            "block_id": "desc_block",
                            "element": {
                                "type": "plain_text_input",
                                "action_id": "desc_input",
                                "multiline": True,
                                "placeholder": {
                                    "type": "plain_text",
                                    "text": "작업 내용을 상세히 기술하세요",
                                },
                            },
                            "label": {"type": "plain_text", "text": "설명"},
                            "optional": True,
                        },
                    ],
                },
            )
        except Exception as e:
            logger.error(f"Failed to open modal: {e}")

    @app.command("/status")
    def handle_status_command(ack, say, command, logger):
        """서비스 상태를 조회하는 커맨드"""
        ack()

        now = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
        say(
            blocks=[
                {
                    "type": "header",
                    "text": {"type": "plain_text", "text": "Service Status Dashboard"},
                },
                {
                    "type": "section",
                    "fields": [
                        {"type": "mrkdwn", "text": "*API Server*\nHealthy (v2.4.1)"},
                        {"type": "mrkdwn", "text": "*Web Frontend*\nHealthy (v3.1.0)"},
                        {"type": "mrkdwn", "text": "*Worker*\nDegraded (v1.8.2)"},
                        {"type": "mrkdwn", "text": "*Database*\nHealthy (CPU 38%)"},
                    ],
                },
                {"type": "divider"},
                {
                    "type": "actions",
                    "elements": [
                        {
                            "type": "button",
                            "text": {"type": "plain_text", "text": "상세 보기"},
                            "action_id": "status_detail",
                            "value": "all",
                        },
                        {
                            "type": "button",
                            "text": {"type": "plain_text", "text": "새로고침"},
                            "action_id": "status_refresh",
                        },
                    ],
                },
                {
                    "type": "context",
                    "elements": [
                        {
                            "type": "mrkdwn",
                            "text": f"조회 시각: {now}",
                        }
                    ],
                },
            ],
        )

    @app.command("/oncall")
    def handle_oncall_command(ack, say, command, logger):
        """현재 온콜 담당자를 조회하는 커맨드"""
        ack()

        # 실제로는 PagerDuty, OpsGenie 등 외부 서비스 연동
        say(
            blocks=[
                {
                    "type": "section",
                    "text": {
                        "type": "mrkdwn",
                        "text": (
                            "*현재 온콜 담당자*\n\n"
                            "- Backend: <@U12345678>\n"
                            "- Frontend: <@U23456789>\n"
                            "- Infra: <@U34567890>\n\n"
                            "긴급 연락은 온콜 담당자에게 DM을 보내주세요."
                        ),
                    },
                }
            ],
        )

# handlers/modals.py
from datetime import datetime


def register_modal_handlers(app):

    @app.view("task_create_modal")
    def handle_task_modal_submission(ack, body, client, view, logger):
        """작업 생성 모달 제출 처리"""
        # 입력값 검증
        values = view["state"]["values"]
        title = values["title_block"]["title_input"]["value"]
        errors = {}

        if len(title) < 3:
            errors["title_block"] = "제목은 최소 3자 이상이어야 합니다."

        if errors:
            ack(response_action="errors", errors=errors)
            return

        ack()

        # 입력값 추출
        priority = values["priority_block"]["priority_select"]["selected_option"]["value"]
        assignee = values["assignee_block"]["assignee_select"]["selected_user"]
        description = values["desc_block"]["desc_input"].get("value", "설명 없음")
        creator = body["user"]["id"]

        # 알림 채널에 작업 생성 메시지 전송
        now = datetime.now().strftime("%Y-%m-%d %H:%M")

        client.chat_postMessage(
            channel="#tasks",
            blocks=[
                {
                    "type": "header",
                    "text": {"type": "plain_text", "text": "새 작업이 생성되었습니다"},
                },
                {
                    "type": "section",
                    "fields": [
                        {"type": "mrkdwn", "text": f"*제목:*\n{title}"},
                        {"type": "mrkdwn", "text": f"*우선순위:*\n{priority}"},
                        {"type": "mrkdwn", "text": f"*담당자:*\n<@{assignee}>"},
                        {"type": "mrkdwn", "text": f"*생성자:*\n<@{creator}>"},
                    ],
                },
                {
                    "type": "section",
                    "text": {"type": "mrkdwn", "text": f"*설명:*\n{description}"},
                },
                {"type": "divider"},
                {
                    "type": "actions",
                    "elements": [
                        {
                            "type": "button",
                            "text": {"type": "plain_text", "text": "작업 시작"},
                            "style": "primary",
                            "action_id": "task_start",
                            "value": title,
                        },
                        {
                            "type": "button",
                            "text": {"type": "plain_text", "text": "완료"},
                            "action_id": "task_complete",
                            "value": title,
                        },
                    ],
                },
                {
                    "type": "context",
                    "elements": [
                        {"type": "mrkdwn", "text": f"생성 시각: {now}"}
                    ],
                },
            ],
        )

        # 담당자에게 DM 알림
        client.chat_postMessage(
            channel=assignee,
            text=f"새 작업이 할당되었습니다: *{title}* (우선순위: {priority})\n생성자: <@{creator}>",
        )

# handlers/actions.py


def register_action_handlers(app):

    @app.action("task_start")
    def handle_task_start(ack, body, client, action, logger):
        """작업 시작 버튼 클릭 처리"""
        ack()
        user_id = body["user"]["id"]
        task_title = action["value"]

        # 원본 메시지 업데이트
        client.chat_update(
            channel=body["channel"]["id"],
            ts=body["message"]["ts"],
            blocks=[
                {
                    "type": "section",
                    "text": {
                        "type": "mrkdwn",
                        "text": (
                            f"*{task_title}*\n"
                            f"상태: 진행 중\n"
                            f"담당: <@{user_id}>"
                        ),
                    },
                },
                {
                    "type": "actions",
                    "elements": [
                        {
                            "type": "button",
                            "text": {"type": "plain_text", "text": "완료 처리"},
                            "style": "primary",
                            "action_id": "task_complete",
                            "value": task_title,
                        },
                    ],
                },
            ],
        )

    @app.action("task_complete")
    def handle_task_complete(ack, body, client, action, logger):
        """작업 완료 버튼 클릭 처리"""
        ack()
        user_id = body["user"]["id"]
        task_title = action["value"]

        client.chat_update(
            channel=body["channel"]["id"],
            ts=body["message"]["ts"],
            blocks=[
                {
                    "type": "section",
                    "text": {
                        "type": "mrkdwn",
                        "text": (
                            f"~{task_title}~\n"
                            f"상태: 완료\n"
                            f"완료자: <@{user_id}>"
                        ),
                    },
                },
            ],
        )

    @app.action("open_incident_modal")
    def handle_open_incident(ack, body, client, logger):
        """장애 보고 모달 열기"""
        ack()
        client.views_open(
            trigger_id=body["trigger_id"],
            view={
                "type": "modal",
                "callback_id": "incident_report_modal",
                "title": {"type": "plain_text", "text": "장애 보고"},
                "submit": {"type": "plain_text", "text": "보고"},
                "blocks": [
                    {
                        "type": "input",
                        "block_id": "severity_block",
                        "element": {
                            "type": "static_select",
                            "action_id": "severity_select",
                            "options": [
                                {
                                    "text": {"type": "plain_text", "text": "P1 - Critical"},
                                    "value": "P1",
                                },
                                {
                                    "text": {"type": "plain_text", "text": "P2 - Major"},
                                    "value": "P2",
                                },
                                {
                                    "text": {"type": "plain_text", "text": "P3 - Minor"},
                                    "value": "P3",
                                },
                            ],
                        },
                        "label": {"type": "plain_text", "text": "심각도"},
                    },
                    {
                        "type": "input",
                        "block_id": "incident_desc_block",
                        "element": {
                            "type": "plain_text_input",
                            "action_id": "incident_desc_input",
                            "multiline": True,
                            "placeholder": {
                                "type": "plain_text",
                                "text": "장애 상황을 상세히 기술하세요",
                            },
                        },
                        "label": {"type": "plain_text", "text": "상황 설명"},
                    },
                ],
            },
        )

    @app.action("status_refresh")
    def handle_status_refresh(ack, body, logger):
        """상태 새로고침 버튼"""
        ack()
        logger.info("Status refresh requested")

    @app.action("status_detail")
    def handle_status_detail(ack, body, logger):
        """상태 상세보기 버튼"""
        ack()
        logger.info("Status detail requested")

# Socket Mode (개발, 내부 도구)
from slack_bolt import App
from slack_bolt.adapter.socket_mode import SocketModeHandler

app = App(token=os.environ["SLACK_BOT_TOKEN"])
handler = SocketModeHandler(app, os.environ["SLACK_APP_TOKEN"])
handler.start()

# HTTP Mode (프로덕션, 외부 서비스)
from slack_bolt import App
from slack_bolt.adapter.flask import SlackRequestHandler
from flask import Flask, request

app = App(
    token=os.environ["SLACK_BOT_TOKEN"],
    signing_secret=os.environ["SLACK_SIGNING_SECRET"],
)
flask_app = Flask(__name__)
handler = SlackRequestHandler(app)

@flask_app.route("/slack/events", methods=["POST"])
def slack_events():
    return handler.handle(request)

@flask_app.route("/slack/commands", methods=["POST"])
def slack_commands():
    return handler.handle(request)

@flask_app.route("/slack/interactions", methods=["POST"])
def slack_interactions():
    return handler.handle(request)

if __name__ == "__main__":
    flask_app.run(port=3000)

FROM python:3.12-slim

WORKDIR /app

# 의존성 먼저 복사 (레이어 캐싱 활용)
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

# 애플리케이션 코드 복사
COPY . .

# 비루트 사용자로 실행
RUN adduser --disabled-password --gecos "" botuser
USER botuser

# 헬스체크 (Socket Mode에서는 별도 HTTP 서버 필요)
HEALTHCHECK --interval=30s --timeout=10s --retries=3 \
    CMD python -c "print('healthy')" || exit 1

CMD ["python", "app.py"]

# docker-compose.yml
services:
  slack-bot:
    build: .
    env_file: .env
    restart: unless-stopped
    deploy:
      resources:
        limits:
          memory: 256M
          cpus: '0.5'
    logging:
      driver: json-file
      options:
        max-size: '10m'
        max-file: '3'

# k8s/deployment.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: slack-bot
  labels:
    app: slack-bot
spec:
  replicas: 1 # Socket Mode는 단일 인스턴스 권장
  selector:
    matchLabels:
      app: slack-bot
  template:
    metadata:
      labels:
        app: slack-bot
    spec:
      containers:
        - name: slack-bot
          image: myregistry/slack-bot:latest
          resources:
            requests:
              memory: '128Mi'
              cpu: '100m'
            limits:
              memory: '256Mi'
              cpu: '500m'
          envFrom:
            - secretRef:
                name: slack-bot-secrets
          livenessProbe:
            exec:
              command:
                - python
                - -c
                - "print('alive')"
            initialDelaySeconds: 10
            periodSeconds: 30
          readinessProbe:
            exec:
              command:
                - python
                - -c
                - "print('ready')"
            initialDelaySeconds: 5
            periodSeconds: 10
      restartPolicy: Always
---
apiVersion: v1
kind: Secret
metadata:
  name: slack-bot-secrets
type: Opaque
stringData:
  SLACK_BOT_TOKEN: 'xoxb-your-bot-token'
  SLACK_APP_TOKEN: 'xapp-your-app-token'
  SLACK_SIGNING_SECRET: 'your-signing-secret'

# utils/rate_limiter.py
import time
import logging
from slack_sdk.errors import SlackApiError
from slack_sdk.http_retry.builtin_handlers import RateLimitErrorRetryHandler

logger = logging.getLogger(__name__)


def configure_rate_limit_handler(client):
    """WebClient에 레이트 리밋 핸들러 추가"""
    rate_limit_handler = RateLimitErrorRetryHandler(max_retry_count=3)
    client.retry_handlers.append(rate_limit_handler)
    return client


def safe_api_call(func, *args, max_retries=3, **kwargs):
    """레이트 리밋을 고려한 안전한 API 호출 래퍼"""
    for attempt in range(max_retries):
        try:
            return func(*args, **kwargs)
        except SlackApiError as e:
            if e.response.status_code == 429:
                retry_after = int(e.response.headers.get("Retry-After", 5))
                logger.warning(
                    f"Rate limited. Retrying after {retry_after}s "
                    f"(attempt {attempt + 1}/{max_retries})"
                )
                time.sleep(retry_after)
            else:
                logger.error(f"Slack API error: {e.response['error']}")
                raise
    raise Exception(f"Max retries ({max_retries}) exceeded for API call")


# 사용 예시
# result = safe_api_call(
#     client.chat_postMessage,
#     channel="#general",
#     text="Hello!"
# )

# 앱 수준 에러 핸들러
@app.error
def global_error_handler(error, body, logger):
    """앱 전체의 미처리 에러를 캐치"""
    logger.exception(f"Unhandled error: {error}")

    # 에러 유형별 분기 처리
    if isinstance(error, SlackApiError):
        error_code = error.response.get("error", "unknown_error")
        logger.error(f"Slack API Error: {error_code}")

        if error_code == "channel_not_found":
            logger.warning("Channel not found - check channel ID or bot permissions")
        elif error_code == "not_in_channel":
            logger.warning("Bot is not in the channel - invite the bot first")
        elif error_code == "token_revoked":
            logger.critical("Bot token has been revoked!")
    else:
        logger.error(f"Non-Slack error: {type(error).__name__}: {error}")