アラートと制御ループ向けの 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 エラー率の上昇",
      "description": "単一メッセージ、構造化されたフィールド",
      "fields": [
        { "name": "severity", "value": "warn", "inline": true },
        { "name": "context", "value": "service=checkout env=prod region=us-east", "inline": false },
        { "name": "action_hint", "value": "カスタム絵文字 thumbsup でリアクションしてリスタートをトリガー", "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") // カスタムギルド絵文字 name:id、例：thumbsup:123456789012345678
  approverUsers := splitCSV(os.Getenv("APPROVER_USER_IDS")) // カンマ区切りの snowflake ID

  if token == "" || channelID == "" || internalURL == "" {
    log.Fatal("環境変数 DISCORD_BOT_TOKEN DISCORD_CHANNEL_ID INTERNAL_API_URL が不足しています")
  }

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

  // リアクションイベントを受信します。インテントは厳密にします。
  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("アラート送信失敗：%v", err)
      return
    }
    targetMessageID = msg.ID
    log.Printf("アラート投稿 message_id=%s", targetMessageID)

    // オプションの利便性：承認リアクションを事前に追加して、ユーザーがクリックできるようにします。
    // カスタム絵文字の場合、Discord は name:id を期待します。Unicode 絵文字の場合、グリフそのものです。
    // Discord Message リソースの Message Create および Create Reaction を参照してください。
    if thumbsEmoji != "" {
      _ = s.MessageReactionAdd(channelID, targetMessageID, thumbsEmoji)
    }
  })

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

    // 先ほど投稿したメッセージのリアクションのみ処理します。
    if targetMessageID == "" || ev.MessageID != targetMessageID {
      return
    }

    // ボット自身のリアクションを無視します。
    if s.State != nil && s.State.User != nil && ev.UserID == s.State.User.ID {
      return
    }

    // カスタム絵文字名にマッチします。標準絵文字を使用する場合、Emoji.Name は Unicode グリフになります。
    if ev.Emoji.Name != "thumbsup" {
      return
    }

    // 許可リスト。ロールベースのチェックは、メンバー状態や特権インテントを必要とすることがあります。
    if !isAllowlisted(ev.UserID, approverUsers) {
      log.Printf("承認拒否 user_id=%s", ev.UserID)
      return
    }

    // 承認の重複排除。本番では 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("アクション POST 失敗：%v", err)
      return
    }

    _, _ = s.ChannelMessageSend(channelID, "承認を受け取り、アクションをトリガーしました")
  })

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

  log.Println("Discord ボット実行中")
  select {}
}

func alertText() string {
  return "[warn] checkout エラー率の上昇\n" +
    "context service=checkout env=prod\n" +
    "action_hint カスタム絵文字 thumbsup でリアクションしてリスタートをトリガー"
}

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

  // 遅延クリーンアップ。
  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"]

# 承認者のカンマ区切りの snowflake ID
APPROVER_USER_IDS: Set[int] = set(
    int(x.strip()) for x in os.getenv("APPROVER_USER_IDS", "").split(",") if x.strip()
)

# 本番では、これを Redis またはデータベースに永続化してください
_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("チャンネルが見つからない、または権限不足")

    msg = await ch.send(
        "[warn] checkout エラー率の上昇\\n"
        "context service=checkout env=prod\\n"
        "action_hint カスタム絵文字 thumbsup でリアクションしてリスタートをトリガー"
    )
    target_message_id = msg.id

    # オプションの利便性：thumbsup という名前のカスタム絵文字（サーバー絵文字）を事前に追加します。
    for e in client.emojis:
        if e.name == "thumbsup":
            try:
                await msg.add_reaction(e)
            except discord.HTTPException:
                pass
            break

    print(f"準備完了、投稿 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

    # ボットアカウント自身を無視
    if client.user and payload.user_id == client.user.id:
        return

    # 許可リスト
    if payload.user_id not in APPROVER_USER_IDS:
        return

    # カスタム絵文字名にマッチ
    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"アクション失敗 {exc}")
        return

    ch = client.get_channel(payload.channel_id)
    if ch is not None:
        await ch.send("承認を受け取り、アクションをトリガーしました")

client.run(DISCORD_BOT_TOKEN)