feature: 센트리 Slack 알림 기능 통합

Author: six-standard

src/controllers/slack.controller.ts

@@ -0,0 +1,165 @@
+import { NextFunction, Request, RequestHandler, Response } from 'express';
+import { SlackService } from '@/services/slack.service';
+import { SentryService } from '@/services/sentry.service';
+import logger from '@/configs/logger.config';
+import { PermissionCheckResponseDto, SlackSuccessResponseDto } from '@/types';
+import { SentryActionData, SentryApiAction } from '@/types/models/Sentry.type';
+import { getNewStatusFromAction } from '@/utils/sentry.util';
+
+export class SlackController {
+  constructor(
+    private slackService: SlackService,
+    private sentryService: SentryService,
+  ) {}
+
+  checkPermissions: RequestHandler = async (
+    req: Request,
+    res: Response<PermissionCheckResponseDto>,
+    next: NextFunction,
+  ): Promise<void> => {
+    try {
+      const permissions = await this.slackService.checkPermissions();
+      const response = new PermissionCheckResponseDto(true, 'Slack 권한 확인 완료', permissions, null);
+      res.status(200).json(response);
+    } catch (error) {
+      logger.error('Slack 권한 확인 실패:', error instanceof Error ? error.message : '알 수 없는 오류');
+      next(error);
+    }
+  };
+
+  testBot: RequestHandler = async (
+    req: Request,
+    res: Response<SlackSuccessResponseDto>,
+    next: NextFunction,
+  ): Promise<void> => {
+    try {
+      if (!this.slackService.hasBotToken() && !this.slackService.hasWebhookUrl()) {
+        const response = new SlackSuccessResponseDto(
+          false,
+          'SLACK_BOT_TOKEN 또는 SLACK_WEBHOOK_URL 환경 변수가 설정되지 않았습니다.',
+          {},
+          'MISSING_SLACK_CONFIG'
+        );
+        res.status(400).json(response);
+        return;
+      }
+
+      const testMessage = {
+        text: '🤖 봇 테스트 메시지입니다!',
+        attachments: [
+          {
+            color: 'good',
+            fields: [
+              {
+                title: '테스트 결과',
+                value: '✅ Slack 연동이 정상적으로 작동합니다.',
+                short: false,
+              },
+            ],
+            footer: `테스트 시간: ${new Date().toLocaleString('ko-KR', { timeZone: 'Asia/Seoul' })}`,
+          },
+        ],
+      };
+
+      await this.slackService.sendMessage(testMessage);
+      const response = new SlackSuccessResponseDto(true, '봇 테스트 메시지 전송 완료!', {}, null);
+      res.status(200).json(response);
+    } catch (error) {
+      logger.error('봇 테스트 실패:', error instanceof Error ? error.message : '알 수 없는 오류');
+      next(error);
+    }
+  };
+
+  handleInteractive: 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('Interactive 처리 실패:', error instanceof Error ? error.message : '알 수 없는 오류');
+      next(error);
+    }
+  };
+
+  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/controllers/webhook.controller.ts

@@ -0,0 +1,109 @@
+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 logger from '@/configs/logger.config';
+import { formatSentryIssueForSlack, createStatusUpdateMessage } from '@/utils/slack.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);
+    }
+  };
+
+  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());
+  }
+} 

src/routes/index.ts

@@ -4,6 +4,9 @@ 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';
+import SlackRouter from './slack.router';
+
 
 const router: Router = express.Router();
 
@@ -16,5 +19,8 @@ router.use('/', PostRouter);
 router.use('/', NotiRouter);
 router.use('/', LeaderboardRouter);
 router.use('/', TotalStatsRouter);
+router.use('/', WebhookRouter);
+router.use('/', SlackRouter);
+
 
 export default router;

src/routes/slack.router.ts

@@ -0,0 +1,90 @@
+import express, { Router } from 'express';
+import { SlackController } from '@/controllers/slack.controller';
+import { SentryService } from '@/services/sentry.service';
+import { SlackService } from '@/services/slack.service';
+
+const router: Router = express.Router();
+
+const slackService = new SlackService();
+const sentryService = new SentryService();
+const slackController = new SlackController(slackService, sentryService);
+
+/**
+ * @swagger
+ * /slack/check-permissions:
+ *   get:
+ *     summary: Slack 권한 확인
+ *     description: Slack Bot의 권한 상태를 확인합니다.
+ *     tags: [Slack]
+ *     responses:
+ *       200:
+ *         description: 권한 확인 성공
+ *         content:
+ *           application/json:
+ *             schema:
+ *               $ref: '#/components/schemas/PermissionCheckResponseDto'
+ *       400:
+ *         description: Bot Token 미설정
+ *       500:
+ *         description: 서버 오류
+ */
+router.get('/slack/check-permissions', slackController.checkPermissions);
+
+/**
+ * @swagger
+ * /slack/test-bot:
+ *   post:
+ *     summary: 봇 테스트
+ *     description: Slack Bot 테스트 메시지를 전송합니다.
+ *     tags: [Slack]
+ *     responses:
+ *       200:
+ *         description: 테스트 메시지 전송 성공
+ *         content:
+ *           application/json:
+ *             schema:
+ *               $ref: '#/components/schemas/SlackSuccessResponseDto'
+ *       400:
+ *         description: Slack 연동 미설정
+ *       500:
+ *         description: 서버 오류
+ */
+router.post('/slack/test-bot', slackController.testBot);
+
+/**
+ * @swagger
+ * /slack/interactive:
+ *   post:
+ *     summary: Slack Interactive Components 처리
+ *     description: Slack에서 전송되는 버튼 클릭 등의 상호작용을 처리합니다.
+ *     tags: [Slack]
+ *     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('/slack/interactive', slackController.handleInteractive);
+
+export default router;