알림 및 제어 루프를 위한 Discord 통합 패턴

[service] -> [alert router] -> [discord webhook] -> [channel]

[service] -> [queue topic] -> [alert dispatcher] -> [discord]
                                 |
                                 +-> [dead letter queue]

[alert] -> [discord message] -> [human reaction] -> [bot] -> [internal action API]

{
  "username": "alert-router",
  "content": "",
  "embeds": [
    {
      "title": "checkout error rate elevated",
      "description": "single message, structured fields",
      "fields": [
        { "name": "severity", "value": "warn", "inline": true },
        { "name": "context", "value": "service=checkout env=prod region=us-east", "inline": false },
        { "name": "action_hint", "value": "react with custom emoji thumbsup to trigger restart", "inline": false }
      ]
    }
  ],
  "allowed_mentions": { "parse": [] }
}

package main

import (
  "bytes"
  "encoding/json"
  "log"
  "net/http"
  "os"
  "strings"
  "sync"
  "time"

  "github.com/bwmarrin/discordgo"
)

type ActionRequest struct {
  AlertID   string `json:"alert_id"`
  MessageID string `json:"message_id"`
  UserID    string `json:"user_id"`
  Action    string `json:"action"`
}

var (
  targetMessageID string

  seenMu sync.Mutex
  seen   = map[string]time.Time{}
  ttl    = 10 * time.Minute
)

func main() {
  token := os.Getenv("DISCORD_BOT_TOKEN")
  channelID := os.Getenv("DISCORD_CHANNEL_ID")
  internalURL := os.Getenv("INTERNAL_API_URL")
  thumbsEmoji := os.Getenv("THUMBSUP_EMOJI") // custom guild emoji name:id, e.g. thumbsup:123456789012345678
  approverUsers := splitCSV(os.Getenv("APPROVER_USER_IDS")) // comma separated snowflake IDs

  if token == "" || channelID == "" || internalURL == "" {
    log.Fatal("Missing env vars DISCORD_BOT_TOKEN DISCORD_CHANNEL_ID INTERNAL_API_URL")
  }

  dg, err := discordgo.New("Bot " + token)
  if err != nil {
    log.Fatalf("discordgo.New failed: %v", err)
  }

  // Receive reaction events. Keep intents tight.
  dg.Identify.Intents = discordgo.IntentsGuildMessages | discordgo.IntentsGuildMessageReactions

  dg.AddHandlerOnce(func(s *discordgo.Session, r *discordgo.Ready) {
    msg, err := s.ChannelMessageSend(channelID, alertText())
    if err != nil {
      log.Printf("send alert failed: %v", err)
      return
    }
    targetMessageID = msg.ID
    log.Printf("posted alert message_id=%s", targetMessageID)

    // Optional convenience: pre-add the approval reaction so users can click it.
    // For custom emojis, Discord expects name:id. For unicode emojis, it is the glyph.
    // See Message Create and Create Reaction in Discord Message resource.
    if thumbsEmoji != "" {
      _ = s.MessageReactionAdd(channelID, targetMessageID, thumbsEmoji)
    }
  })

  dg.AddHandler(func(s *discordgo.Session, ev *discordgo.MessageReactionAdd) {
    if ev == nil || ev.MessageReaction == nil {
      return
    }

    // Only handle reactions for the message we just posted.
    if targetMessageID == "" || ev.MessageID != targetMessageID {
      return
    }

    // Ignore bot's own reactions.
    if s.State != nil && s.State.User != nil && ev.UserID == s.State.User.ID {
      return
    }

    // Match custom emoji name. If you use the standard emoji, Emoji.Name will be a unicode glyph.
    if ev.Emoji.Name != "thumbsup" {
      return
    }

    // Allowlist. Role based checks often pull in member state and sometimes privileged intents.
    if !isAllowlisted(ev.UserID, approverUsers) {
      log.Printf("deny approval user_id=%s", ev.UserID)
      return
    }

    // Dedupe approvals. In production, store this in Redis.
    key := ev.MessageID + ":" + ev.UserID + ":" + ev.Emoji.Name + ":approve"
    if !tryOnce(key) {
      return
    }

    req := ActionRequest{
      AlertID:   os.Getenv("ALERT_ID"),
      MessageID: ev.MessageID,
      UserID:    ev.UserID,
      Action:    "approve_restart",
    }

    if err := postJSON(internalURL, req); err != nil {
      log.Printf("action POST failed: %v", err)
      return
    }

    _, _ = s.ChannelMessageSend(channelID, "approval received, action triggered")
  })

  if err := dg.Open(); err != nil {
    log.Fatalf("dg.Open failed: %v", err)
  }
  defer dg.Close()

  log.Println("discord bot running")
  select {}
}

func alertText() string {
  return "[warn] checkout error rate elevated\n" +
    "context service=checkout env=prod\n" +
    "action_hint react with custom emoji thumbsup to trigger restart"
}

func splitCSV(s string) []string {
  if strings.TrimSpace(s) == "" {
    return nil
  }
  parts := strings.Split(s, ",")
  out := make([]string, 0, len(parts))
  for _, p := range parts {
    p = strings.TrimSpace(p)
    if p != "" {
      out = append(out, p)
    }
  }
  return out
}

func isAllowlisted(userID string, allow []string) bool {
  if len(allow) == 0 {
    return false
  }
  for _, a := range allow {
    if userID == a {
      return true
    }
  }
  return false
}

func tryOnce(key string) bool {
  now := time.Now()

  seenMu.Lock()
  defer seenMu.Unlock()

  // Lazy cleanup.
  for k, t := range seen {
    if now.Sub(t) > ttl {
      delete(seen, k)
    }
  }
  if _, ok := seen[key]; ok {
    return false
  }
  seen[key] = now
  return true
}

func postJSON(url string, body any) error {
  b, err := json.Marshal(body)
  if err != nil {
    return err
  }

  req, err := http.NewRequest(http.MethodPost, url, bytes.NewReader(b))
  if err != nil {
    return err
  }
  req.Header.Set("Content-Type", "application/json")

  c := &http.Client{Timeout: 5 * time.Second}
  res, err := c.Do(req)
  if err != nil {
    return err
  }
  defer res.Body.Close()

  if res.StatusCode < 200 || res.StatusCode >= 300 {
    return &httpError{code: res.StatusCode}
  }
  return nil
}

type httpError struct{ code int }

func (e *httpError) Error() string { return "http status " + http.StatusText(e.code) }

import os
import asyncio
import aiohttp
import discord
from typing import Set, Dict

DISCORD_BOT_TOKEN = os.environ["DISCORD_BOT_TOKEN"]
DISCORD_CHANNEL_ID = int(os.environ["DISCORD_CHANNEL_ID"])
INTERNAL_API_URL = os.environ["INTERNAL_API_URL"]

# Comma separated snowflake IDs of approvers
APPROVER_USER_IDS: Set[int] = set(
    int(x.strip()) for x in os.getenv("APPROVER_USER_IDS", "").split(",") if x.strip()
)

# In production, persist this in Redis or a database
_seen: Dict[str, float] = {}
_TTL_SECONDS = 600.0

intents = discord.Intents.default()
intents.guilds = True
intents.messages = True
intents.reactions = True

client = discord.Client(intents=intents)

target_message_id: int | None = None

def _try_once(key: str) -> bool:
    now = asyncio.get_event_loop().time()
    expired = [k for k, t in _seen.items() if (now - t) > _TTL_SECONDS]
    for k in expired:
        _seen.pop(k, None)

    if key in _seen:
        return False
    _seen[key] = now
    return True

async def _post_action(alert_id: str, message_id: int, user_id: int) -> None:
    payload = {
        "alert_id": alert_id,
        "message_id": str(message_id),
        "user_id": str(user_id),
        "action": "approve_restart",
    }
    async with aiohttp.ClientSession(timeout=aiohttp.ClientTimeout(total=5)) as session:
        async with session.post(INTERNAL_API_URL, json=payload) as resp:
            if resp.status < 200 or resp.status >= 300:
                body = await resp.text()
                raise RuntimeError(f"internal api http {resp.status} {body}")

@client.event
async def on_ready() -> None:
    global target_message_id

    ch = client.get_channel(DISCORD_CHANNEL_ID)
    if ch is None:
        raise RuntimeError("channel not found or missing permissions")

    msg = await ch.send(
        "[warn] checkout error rate elevated\\n"
        "context service=checkout env=prod\\n"
        "action_hint react with custom emoji thumbsup to trigger restart"
    )
    target_message_id = msg.id

    # Optional convenience: pre-add a custom emoji named thumbsup (server emoji).
    for e in client.emojis:
        if e.name == "thumbsup":
            try:
                await msg.add_reaction(e)
            except discord.HTTPException:
                pass
            break

    print(f"ready posted message_id={target_message_id}")

@client.event
async def on_raw_reaction_add(payload: discord.RawReactionActionEvent) -> None:
    global target_message_id

    if target_message_id is None:
        return
    if payload.message_id != target_message_id:
        return

    # Ignore the bot account itself
    if client.user and payload.user_id == client.user.id:
        return

    # Allowlist
    if payload.user_id not in APPROVER_USER_IDS:
        return

    # Match custom emoji name
    if payload.emoji.name != "thumbsup":
        return

    key = f"{payload.message_id}:{payload.user_id}:{payload.emoji.name}:approve"
    if not _try_once(key):
        return

    alert_id = os.getenv("ALERT_ID", "")
    try:
        await _post_action(alert_id, payload.message_id, payload.user_id)
    except Exception as exc:
        print(f"action failed {exc}")
        return

    ch = client.get_channel(payload.channel_id)
    if ch is not None:
        await ch.send("approval received, action triggered")

client.run(DISCORD_BOT_TOKEN)