[25.06.25 / TASK-214] Feature - 센트리 슬랙 연동 및 API 통합

src/configs/db.config.ts

@@ -16,13 +16,17 @@ const poolConfig: pg.PoolConfig = {
   max: 10, // 최대 연결 수
   idleTimeoutMillis: 30000, // 연결 유휴 시간 (30초)
   connectionTimeoutMillis: 5000, // 연결 시간 초과 (5초)
+  ssl: false,
+  // ssl: {
+  //   rejectUnauthorized: false,
+  // },
 };
 
-if (process.env.NODE_ENV === 'production') {
-  poolConfig.ssl = {
-    rejectUnauthorized: false,
-  };
-}
+// if (process.env.NODE_ENV === 'production') {
+//   poolConfig.ssl = {
+//     rejectUnauthorized: false,
+//   };
+// }
 
 const pool = new Pool(poolConfig);
 

src/controllers/webhook.controller.ts

@@ -0,0 +1,204 @@
+import { NextFunction, Request, RequestHandler, Response } from 'express';
+import { SlackService } from '@/services/slack.service';
+import { SentryService } from '@/services/sentry.service';
+import { SentryWebhookData, SlackMessage } from '@/types';
+import { SentryActionData, SentryApiAction } from '@/types/models/Sentry.type';
+import logger from '@/configs/logger.config';
+import { formatSentryIssueForSlack, createStatusUpdateMessage } from '@/utils/slack.util';
+import { getNewStatusFromAction } from '@/utils/sentry.util';
+
+export class WebhookController {
+  constructor(
+    private slackService: SlackService,
+    private sentryService: SentryService,
+  ) {}
+
+  handleSentryWebhook: RequestHandler = async (
+    req: Request,
+    res: Response,
+    next: NextFunction,
+  ): Promise<void> => {
+    try {
+      const sentryData = req.body;
+
+      const slackMessage = await this.formatSentryDataForSlack(sentryData);
+
+      if (slackMessage === null) {
+        logger.info('기존 메시지 업데이트 완료, 새 메시지 전송 생략');
+        res.status(200).json({ message: 'Webhook processed successfully' });
+        return;
+      }
+
+      const issueId = sentryData.data?.issue?.id;
+      await this.slackService.sendMessage(slackMessage, issueId);
+
+      res.status(200).json({ message: 'Webhook processed successfully' });
+    } catch (error) {
+      logger.error('Sentry webhook 처리 실패:', error instanceof Error ? error.message : '알 수 없는 오류');
+      next(error);
+    }
+  };
+
+  handleSlackInteractive: RequestHandler = async (
+    req: Request,
+    res: Response,
+    next: NextFunction,
+  ): Promise<void> => {
+    try {
+      const payload = JSON.parse(req.body.payload);
+
+      if (payload.type === 'interactive_message' && payload.actions && payload.actions[0]) {
+        const action = payload.actions[0];
+
+        if (action.name === 'sentry_action') {
+          const [actionType, issueId, organizationSlug, projectSlug] = action.value.split(':');
+
+          const actionData: SentryActionData = {
+            action: actionType as SentryApiAction,
+            issueId,
+            organizationSlug,
+            projectSlug,
+          };
+
+          if (actionData.issueId && actionData.organizationSlug && actionData.projectSlug) {
+            logger.info('Processing Sentry action:', actionData);
+
+            const result = await this.sentryService.handleIssueAction(actionData);
+
+            if (result.success) {
+              const updatedMessage = this.createSuccessMessage(actionData, payload.original_message || {});
+              res.json(updatedMessage);
+            } else {
+              const errorMessage = this.createErrorMessage(result.error || 'Unknown error', payload.original_message || {});
+              res.json(errorMessage);
+            }
+            return;
+          }
+        }
+      }
+
+      res.json({ text: '❌ 잘못된 요청입니다.' });
+    } catch (error) {
+      logger.error('Slack Interactive 처리 실패:', error instanceof Error ? error.message : '알 수 없는 오류');
+      next(error);
+    }
+  };
+
+  private async formatSentryDataForSlack(sentryData: SentryWebhookData): Promise<SlackMessage | null> {
+    const { action, data } = sentryData;
+
+    if (action === 'resolved' || action === 'unresolved' || action === 'ignored') {
+      return await this.handleIssueStatusChange(sentryData);
+    }
+
+    if (action === 'created' && data.issue) {
+      return formatSentryIssueForSlack(sentryData, this.sentryService.hasSentryToken());
+    }
+
+    return {
+      text: `🔔 Sentry 이벤트: ${action || 'Unknown action'}`,
+      attachments: [
+        {
+          color: 'warning',
+          fields: [
+            {
+              title: '이벤트 타입',
+              value: action || 'Unknown',
+              short: true,
+            },
+          ],
+        },
+      ],
+    };
+  }
+
+  private async handleIssueStatusChange(sentryData: SentryWebhookData): Promise<SlackMessage | null> {
+    const { data } = sentryData;
+    const issue = data.issue;
+
+    if (!issue) {
+      logger.warn('이슈 정보가 없습니다:', sentryData);
+      return formatSentryIssueForSlack(sentryData, this.sentryService.hasSentryToken());
+    }
+
+    logger.info(`이슈 상태 변경 감지: ${issue.id} → ${sentryData.action}`);
+
+    const messageInfo = this.slackService.getMessageInfo(issue.id);
+
+    if (messageInfo) {
+      logger.info('기존 메시지 발견, 업데이트 시도');
+
+      try {
+        const updatedMessage = createStatusUpdateMessage(
+          sentryData, 
+          this.sentryService.hasSentryToken()
+        );
+
+        await this.slackService.updateMessage(
+          messageInfo.channel,
+          messageInfo.ts,
+          updatedMessage
+        );
+
+        logger.info('기존 메시지 업데이트 완료');
+        return null;
+
+      } catch (error) {
+        logger.error('메시지 업데이트 실패, 새 메시지로 전송:', error instanceof Error ? error.message : '알 수 없는 오류');
+
+      }
+    } else {
+      logger.info('기존 메시지 없음, 새 메시지 생성');
+    }
+
+    return formatSentryIssueForSlack(sentryData, this.sentryService.hasSentryToken());
+  }
+
+  private createSuccessMessage(actionData: SentryActionData, originalMessage: unknown): unknown {
+    const { action } = actionData;
+
+    const updatedMessage = JSON.parse(JSON.stringify(originalMessage));
+
+    if (updatedMessage.attachments && updatedMessage.attachments[0]) {
+      const newStatus = getNewStatusFromAction(action);
+      const statusColors = {
+        'resolved': 'good',
+        'ignored': 'warning',
+        'archived': '#808080',
+        'unresolved': 'danger',
+      };
+
+      updatedMessage.attachments[0].color = statusColors[newStatus as keyof typeof statusColors] || 'good';
+
+      const statusMapping = {
+        'resolved': 'RESOLVED',
+        'ignored': 'IGNORED',
+        'archived': 'ARCHIVED',
+        'unresolved': 'UNRESOLVED',
+      };
+
+      const statusText = statusMapping[newStatus as keyof typeof statusMapping] || newStatus.toUpperCase();
+      updatedMessage.attachments[0].footer = `✅ ${statusText} | 처리 완료: ${new Date().toLocaleString('ko-KR', { timeZone: 'Asia/Seoul' })}`;
+
+      delete updatedMessage.attachments[0].actions;
+    }
+
+    return updatedMessage;
+  }
+
+  private createErrorMessage(error: string, originalMessage: unknown): unknown {
+    const updatedMessage = JSON.parse(JSON.stringify(originalMessage));
+
+    if (updatedMessage.attachments && updatedMessage.attachments[0]) {
+      updatedMessage.attachments[0].fields.push({
+        title: '❌ 오류 발생',
+        value: error,
+        short: false,
+      });
+
+      updatedMessage.attachments[0].color = 'danger';
+    }
+
+    return updatedMessage;
+  }
+} 

src/routes/index.ts

@@ -4,6 +4,8 @@ import PostRouter from './post.router';
 import NotiRouter from './noti.router';
 import LeaderboardRouter from './leaderboard.router';
 import TotalStatsRouter from './totalStats.router';
+import WebhookRouter from './webhook.router';
+
 
 const router: Router = express.Router();
 
@@ -16,5 +18,6 @@ router.use('/', PostRouter);
 router.use('/', NotiRouter);
 router.use('/', LeaderboardRouter);
 router.use('/', TotalStatsRouter);
+router.use('/', WebhookRouter);
 
 export default router;

src/routes/webhook.router.ts

@@ -0,0 +1,94 @@
+import express, { Router } from 'express';
+import { WebhookController } from '@/controllers/webhook.controller';
+import { SentryService } from '@/services/sentry.service';
+import { SlackService } from '@/services/slack.service';
+
+const router: Router = express.Router();
+
+// 서비스 인스턴스 생성
+const sentryService = new SentryService();
+const slackService = new SlackService();
+
+// 컨트롤러 인스턴스 생성
+const webhookController = new WebhookController(slackService, sentryService);
+
+/**
+ * @swagger
+ * /webhook/sentry:
+ *   post:
+ *     summary: Sentry webhook 처리
+ *     description: Sentry에서 전송되는 webhook 이벤트를 처리합니다.
+ *     tags: [Webhook]
+ *     requestBody:
+ *       required: true
+ *       content:
+ *         application/json:
+ *           schema:
+ *             type: object
+ *             properties:
+ *               action:
+ *                 type: string
+ *                 description: Sentry 액션 타입
+ *                 enum: [created, resolved, unresolved, ignored]
+ *               data:
+ *                 type: object
+ *                 properties:
+ *                   issue:
+ *                     type: object
+ *                     description: Sentry 이슈 정보
+ *               actor:
+ *                 type: object
+ *                 description: 액션을 수행한 사용자 정보
+ *     responses:
+ *       200:
+ *         description: Webhook 처리 성공
+ *         content:
+ *           application/json:
+ *             schema:
+ *               type: object
+ *               properties:
+ *                 message:
+ *                   type: string
+ *                   example: "Webhook 처리 완료"
+ *       500:
+ *         description: 서버 오류
+ */
+router.post('/webhook/sentry', webhookController.handleSentryWebhook);
+
+/**
+ * @swagger
+ * /webhook/slack/interactive:
+ *   post:
+ *     summary: Slack Interactive Components 처리
+ *     description: Slack에서 전송되는 버튼 클릭 등의 상호작용을 처리합니다.
+ *     tags: [Webhook]
+ *     requestBody:
+ *       required: true
+ *       content:
+ *         application/x-www-form-urlencoded:
+ *           schema:
+ *             type: object
+ *             properties:
+ *               payload:
+ *                 type: string
+ *                 description: JSON 형태의 Slack payload (URL encoded)
+ *     responses:
+ *       200:
+ *         description: 상호작용 처리 성공
+ *         content:
+ *           application/json:
+ *             schema:
+ *               type: object
+ *               properties:
+ *                 text:
+ *                   type: string
+ *                   example: "버튼 클릭 처리 완료"
+ *                 response_type:
+ *                   type: string
+ *                   enum: [in_channel, ephemeral]
+ *       400:
+ *         description: 잘못된 요청
+ */
+router.post('/webhook/slack/interactive', webhookController.handleSlackInteractive);
+
+export default router;