npm i prisma @prisma/client
npx prisma init
 
or
 
pnpm add prisma @prisma/client
pnpm dlx prisma init

datasource db {
  provider = "postgresql"
}
 
generator client {
  provider = "prisma-client-js"
}
 
enum IssueStatus {
  OPEN
  ACK
  FIXED
  IGNORED
}
 
model SentryIssue {
  id              String      @id
  project         String?
  environment     String?
  level           String?
  title           String?
  culprit         String?
  url             String?
 
  firstSeenAt     DateTime    @default(now())
  lastSeenAt      DateTime    @default(now())
  totalCount      Int         @default(0)
 
  windowStartAt   DateTime    @default(now())
  windowCount     Int         @default(0)
 
  status          IssueStatus @default(OPEN)
  lastNotifiedAt  DateTime?
 
  triageJson      Json?
  triageUpdatedAt DateTime?
 
  notifications   NotificationLog[]
  triageRuns      TriageRun[]
 
  @@index([lastSeenAt])
}
 
model NotificationLog {
  id        String   @id @default(cuid())
  issueId   String
  channel   String   // "slack"
  sentAt    DateTime @default(now())
  success   Boolean  @default(true)
  errorMsg  String?
 
  issue     SentryIssue @relation(fields: [issueId], references: [id], onDelete: Cascade)
 
  @@index([issueId, sentAt])
}
 
model TriageRun {
  id        String   @id @default(cuid())
  issueId   String
  provider  String   // "openai"
  model     String?
  createdAt DateTime @default(now())
  result    Json
 
  issue     SentryIssue @relation(fields: [issueId], references: [id], onDelete: Cascade)
 
  @@index([issueId, createdAt])
}

npx prisma migrate dev -n init
 
or
 
pnpm dlx prisma migrate dev -n init

// lib/prisma.ts
import { PrismaPg } from '@prisma/adapter-pg';
import { PrismaClient } from '@prisma/client';
import { Pool } from 'pg';
 
const globalForPrisma = globalThis as unknown as { prisma?: PrismaClient };
 
const pool = new Pool({ connectionString: process.env.DATABASE_URL });
const adapter = new PrismaPg(pool);
 
export const prisma =
  globalForPrisma.prisma ??
  new PrismaClient({
    adapter,
    log: ['error', 'warn'],
  });
 
if (process.env.NODE_ENV !== 'production') globalForPrisma.prisma = prisma;

// lib/slack.ts
type SlackTextObject = { type: 'mrkdwn'; text: string } | { type: 'plain_text'; text: string };
 
type SlackBlock =
  | { type: 'header'; text: { type: 'plain_text'; text: string } }
  | { type: 'section'; text: SlackTextObject }
  | { type: 'context'; elements: SlackTextObject[] }
  | { type: 'divider' };
 
export async function sendSlackWebhook(
  webhookUrl: string,
  payload: { text: string; blocks?: SlackBlock[] },
) {
  const res = await fetch(webhookUrl, {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify(payload),
  });
 
  if (!res.ok) {
    const text = await res.text().catch(() => '');
    throw new Error(`Slack webhook failed: ${res.status} ${text}`);
  }
}
 
export function buildSlackBlocks(input: {
  title: string;
  project?: string | null;
  environment?: string | null;
  level?: string | null;
  url?: string | null;
  windowMin: number;
  windowCount: number;
  totalCount: number;
  triage?: {
    severity?: string;
    summary?: string;
    likely_causes?: string[];
    next_actions?: string[];
  } | null;
}) {
  const severity = input.triage?.severity ?? 'P?';
  const header = `🚨 ${severity} | ${input.project ?? '-'} | ${input.environment ?? '-'} | level=${input.level ?? '-'}`;
 
  const blocks: SlackBlock[] = [
    { type: 'header', text: { type: 'plain_text', text: header } },
    { type: 'section', text: { type: 'mrkdwn', text: `*${input.title}*` } },
    {
      type: 'context',
      elements: [
        {
          type: 'mrkdwn',
          text: `최근 ${input.windowMin}분: *${input.windowCount}* / 누적: *${input.totalCount}*`,
        },
      ],
    },
  ];
 
  if (input.url) {
    blocks.push({
      type: 'section',
      text: { type: 'mrkdwn', text: `🔗 <${input.url}|Open in Sentry>` },
    });
  }
 
  if (input.triage?.summary) {
    blocks.push({ type: 'divider' });
    blocks.push({
      type: 'section',
      text: { type: 'mrkdwn', text: `*🧠 요약*\n${input.triage.summary}` },
    });
  }
 
  const causes = input.triage?.likely_causes ?? [];
  if (causes.length) {
    blocks.push({
      type: 'section',
      text: { type: 'mrkdwn', text: `*🔎 원인 후보*\n• ${causes.join('\n• ')}` },
    });
  }
 
  const actions = input.triage?.next_actions ?? [];
  if (actions.length) {
    blocks.push({
      type: 'section',
      text: { type: 'mrkdwn', text: `*✅ 다음 액션*\n• ${actions.join('\n• ')}` },
    });
  }
 
  return blocks;
}

export type TriageJson = {
  summary: string;
  likely_causes: string[];
  next_actions: string[];
  severity: 'P0' | 'P1' | 'P2' | 'P3';
  tags: string[];
};
 
function extractJson(text: string) {
  const s = text.trim();
  const start = s.indexOf('{');
  const end = s.lastIndexOf('}');
  if (start < 0 || end < 0) throw new Error(`LLM did not return JSON: ${s}`);
  return JSON.parse(s.slice(start, end + 1));
}
 
export async function triageWithOpenAI(input: {
  issue: {
    id: string;
    title?: string | null;
    level?: string | null;
    project?: string | null;
    environment?: string | null;
    url?: string | null;
    windowCount: number;
    totalCount: number;
  };
  payload: unknown;
}): Promise<TriageJson> {
  const apiKey = process.env.OPENAI_API_KEY;
  if (!apiKey) throw new Error('Missing OPENAI_API_KEY');
 
  const prompt = `
    너는 시니어 프론트엔드 엔지니어다.
    Sentry 이슈를 보고 팀이 바로 움직일 수 있도록 트리아지 JSON만 출력해라.
    
    규칙:
    - Root Level에 아래 키들이 바로 나와야 함 (wrapping 금지)
    - summary: 한글 요약 (한 문장)
    - likely_causes: 원인 추정 (배열, 최대 3개)
    - next_actions: 조치 사항 (배열, 3~7개)
    - severity: P0(치명적)~P3(사소함)
    - tags: 키워드 배열
    
    입력:
    project=${input.issue.project ?? ''}
    env=${input.issue.environment ?? ''}
    level=${input.issue.level ?? ''}
    title=${input.issue.title ?? ''}
    url=${input.issue.url ?? ''}
    recent_10m_count=${input.issue.windowCount}
    total_count=${input.issue.totalCount}
    
    payload(일부):
    ${JSON.stringify(input.payload).slice(0, 8000)}
    `.trim();
 
  const res = await fetch('https://api.openai.com/v1/chat/completions', {
    method: 'POST',
    headers: {
      Authorization: `Bearer ${apiKey}`,
      'Content-Type': 'application/json',
    },
    body: JSON.stringify({
      model: 'gpt-4o-mini',
      messages: [{ role: 'user', content: prompt }],
      response_format: { type: 'json_object' },
    }),
  });
 
  if (!res.ok) {
    const text = await res.text().catch(() => '');
    throw new Error(`OpenAI failed: ${res.status} ${text}`);
  }
 
  const data: unknown = await res.json();
  const d = data as { choices?: { message?: { content?: string } }[] };
  const text = d?.choices?.[0]?.message?.content ?? '';
 
  return extractJson(String(text));
}

export async function POST(req: Request) {
  // 1) Sentry 서명 검증
  const ok = verifySentrySignature(rawBody, sig, secret);
  if (!ok) return NextResponse.json({ message: 'Invalid signature' }, { status: 401 });
 
  // 2) 이슈 정보 추출
  const { issueId, title, level, project, environment, url } = extractSentryFields(body);
 
  // 3) DB 업데이트 + 10분 윈도우 집계
  const issue = await updateIssueWithWindow(issueId, now);
 
  // 4) 도배 방지: 10분에 1번만 알림
  if (!shouldNotify) return NextResponse.json({ ok: true, skipped: 'rate_limited' });
 
  // 5) 조건부 LLM 호출 + 24시간 TTL 캐시
  const triage = await getOrCreateTriage(issue, body);
 
  // 6) Slack 알림 전송
  await sendSlackNotification(issue, triage);
 
  return NextResponse.json({ ok: true });
}

const WINDOW_MS = 10 * 60 * 1000; // 10분
 
const windowExpired = now.getTime() - existing.windowStartAt.getTime() > WINDOW_MS;
 
await tx.sentryIssue.update({
  data: {
    totalCount: { increment: 1 }, // 누적 횟수
    windowStartAt: windowExpired ? now : existing.windowStartAt,
    windowCount: windowExpired ? 1 : { increment: 1 }, // 10분 윈도우 카운트
  },
});

const TRIAGE_TTL_MS = 24 * 60 * 60 * 1000; // 24시간
 
// TTL 만료 체크
const triageExpired =
  !issue.triageUpdatedAt ||
  now.getTime() - issue.triageUpdatedAt.getTime() > TRIAGE_TTL_MS;
 
// 호출 조건: 새 이슈 OR 급증 OR error/fatal
const isNew = issue.totalCount === 1;
const isSpike = issue.windowCount >= 5;
const isError = ['error', 'fatal'].includes(issue.level);
 
// 조건 충족 시에만 LLM 호출
if (!triage || triageExpired) && (isNew || isSpike || isError) {
  triage = await triageWithOpenAI({ issue, payload: body });
 
  // DB에 24시간 캐시
  await prisma.sentryIssue.update({
    data: {
      triageJson: triage,
      triageUpdatedAt: now  // TTL 시작 시점
    },
  });
}

Sentry Webhook
    ↓
[1] 서명 검증 (보안)
    ↓
[2] DB 업데이트
    - totalCount (누적)
    - windowCount (최근 10분)
    ↓
[3] 도배 방지 체크
    - 10분에 1번만 알림
    ↓
[4] LLM 트리아지 (조건부)
    - 새 이슈 OR 급증 OR error/fatal
    - 24시간 TTL 캐시
    ↓
[5] Slack 알림 전송