event 서비스 설정파일 충돌 수정

This commit is contained in:
merrycoral
2025-10-28 13:33:00 +09:00
parent e2179daaf7
commit 2ca453f89e
190 changed files with 15315 additions and 49 deletions
+485
View File
@@ -0,0 +1,485 @@
# AI Service API 매핑표
## 문서 정보
- **작성일**: 2025-10-27
- **대상 서비스**: ai-service
- **API 설계서**: design/backend/api/ai-service-api.yaml
- **개발 결과**: develop/dev/dev-backend-ai-service.md
---
## 1. 매핑 요약
| 구분 | API 설계서 | 개발 완료 | 추가 개발 | 미개발 |
|------|-----------|----------|----------|--------|
| REST API | 3개 | 3개 | 0개 | 0개 |
| Kafka Consumer | 1개 (문서화) | 1개 | 0개 | 0개 |
| **합계** | **4개** | **4개** | **0개** | **0개** |
**매핑 완료율**: 100% (4/4)
---
## 2. REST API 상세 매핑
### 2.1 Health Check API
| 항목 | API 설계서 | 구현 내용 | 매핑 상태 |
|------|-----------|----------|----------|
| **Endpoint** | `GET /health` | `GET /health` | ✅ 일치 |
| **Controller** | HealthController | HealthController.java | ✅ 일치 |
| **Method** | healthCheck | healthCheck() | ✅ 일치 |
| **Request** | - | - | ✅ 일치 |
| **Response** | HealthCheckResponse | HealthCheckResponse | ✅ 일치 |
| **User Story** | System | System | ✅ 일치 |
| **Tag** | Health Check | Health Check | ✅ 일치 |
**구현 파일**:
- `ai-service/src/main/java/com/kt/ai/controller/HealthController.java:36`
**Response Schema 일치 여부**:
```yaml
✅ status: ServiceStatus (UP, DOWN, DEGRADED)
✅ timestamp: LocalDateTime
✅ services:
✅ kafka: ServiceStatus
✅ redis: ServiceStatus
✅ claudeApi: ServiceStatus
✅ gpt4Api: ServiceStatus
✅ circuitBreaker: CircuitBreakerState (CLOSED, OPEN, HALF_OPEN)
```
**비고**:
- Redis 상태는 실제 `ping()` 명령으로 확인
- Kafka, Claude API, GPT-4 API, Circuit Breaker 상태는 TODO로 표시 (향후 구현 필요)
---
### 2.2 작업 상태 조회 API
| 항목 | API 설계서 | 구현 내용 | 매핑 상태 |
|------|-----------|----------|----------|
| **Endpoint** | `GET /internal/jobs/{jobId}/status` | `GET /internal/jobs/{jobId}/status` | ✅ 일치 |
| **Controller** | InternalJobController | InternalJobController.java | ✅ 일치 |
| **Method** | getJobStatus | getJobStatus() | ✅ 일치 |
| **Path Variable** | jobId (String) | jobId (String) | ✅ 일치 |
| **Response** | JobStatusResponse | JobStatusResponse | ✅ 일치 |
| **User Story** | UFR-AI-010 | UFR-AI-010 | ✅ 일치 |
| **Tag** | Internal API | Internal API | ✅ 일치 |
**구현 파일**:
- `ai-service/src/main/java/com/kt/ai/controller/InternalJobController.java:36`
**Response Schema 일치 여부**:
```yaml
✅ jobId: String
✅ status: JobStatus (PENDING, PROCESSING, COMPLETED, FAILED)
✅ progress: Integer (0-100)
✅ message: String
✅ eventId: String
✅ createdAt: LocalDateTime
✅ startedAt: LocalDateTime
✅ completedAt: LocalDateTime (완료 시)
✅ failedAt: LocalDateTime (실패 시)
✅ errorMessage: String (실패 시)
✅ retryCount: Integer
✅ processingTimeMs: Long
```
**Redis 캐싱**:
- Key Pattern: `ai:job:status:{jobId}`
- TTL: 24시간 (86400초)
- Service: JobStatusService.java
---
### 2.3 AI 추천 결과 조회 API
| 항목 | API 설계서 | 구현 내용 | 매핑 상태 |
|------|-----------|----------|----------|
| **Endpoint** | `GET /internal/recommendations/{eventId}` | `GET /internal/recommendations/{eventId}` | ✅ 일치 |
| **Controller** | InternalRecommendationController | InternalRecommendationController.java | ✅ 일치 |
| **Method** | getRecommendation | getRecommendation() | ✅ 일치 |
| **Path Variable** | eventId (String) | eventId (String) | ✅ 일치 |
| **Response** | AIRecommendationResult | AIRecommendationResult | ✅ 일치 |
| **User Story** | UFR-AI-010 | UFR-AI-010 | ✅ 일치 |
| **Tag** | Internal API | Internal API | ✅ 일치 |
**구현 파일**:
- `ai-service/src/main/java/com/kt/ai/controller/InternalRecommendationController.java:36`
**Response Schema 일치 여부**:
**1) AIRecommendationResult**:
```yaml
✅ eventId: String
✅ trendAnalysis: TrendAnalysis
✅ recommendations: List<EventRecommendation> (3개)
✅ generatedAt: LocalDateTime
✅ expiresAt: LocalDateTime
✅ aiProvider: AIProvider (CLAUDE, GPT4)
```
**2) TrendAnalysis**:
```yaml
✅ industryTrends: List<TrendKeyword>
✅ keyword: String
✅ relevance: Double (0-1)
✅ description: String
✅ regionalTrends: List<TrendKeyword>
✅ seasonalTrends: List<TrendKeyword>
```
**3) EventRecommendation**:
```yaml
✅ optionNumber: Integer (1-3)
✅ concept: String
✅ title: String
✅ description: String
✅ targetAudience: String
✅ duration:
✅ recommendedDays: Integer
✅ recommendedPeriod: String
✅ mechanics:
✅ type: EventMechanicsType (DISCOUNT, GIFT, STAMP, EXPERIENCE, LOTTERY, COMBO)
✅ details: String
✅ promotionChannels: List<String>
✅ estimatedCost:
✅ min: Integer
✅ max: Integer
✅ breakdown: Map<String, Integer>
✅ expectedMetrics:
✅ newCustomers: Range (min, max)
✅ revenueIncrease: Range (min, max)
✅ roi: Range (min, max)
❌ repeatVisits: Range (선택 필드 - 미구현)
❌ socialEngagement: Object (선택 필드 - 미구현)
✅ differentiator: String
```
**Redis 캐싱**:
- Key Pattern: `ai:recommendation:{eventId}`
- TTL: 24시간 (86400초)
- Service: AIRecommendationService.java, CacheService.java
**비고**:
- `expectedMetrics.repeatVisits``expectedMetrics.socialEngagement`는 선택 필드로 현재 미구현
- 필수 필드는 모두 구현 완료
---
## 3. Kafka Consumer 매핑
### 3.1 AI 작업 메시지 처리 Consumer
| 항목 | API 설계서 | 구현 내용 | 매핑 상태 |
|------|-----------|----------|----------|
| **Topic** | `ai-event-generation-job` | `ai-event-generation-job` | ✅ 일치 |
| **Consumer Group** | `ai-service-consumers` | `ai-service-consumers` | ✅ 일치 |
| **Message DTO** | KafkaAIJobMessage | AIJobMessage.java | ✅ 일치 |
| **Consumer Class** | - | AIJobConsumer.java | ✅ 구현 |
| **Handler Method** | - | consume() | ✅ 구현 |
| **Tag** | Kafka Consumer | - | ✅ 일치 |
**구현 파일**:
- `ai-service/src/main/java/com/kt/ai/kafka/consumer/AIJobConsumer.java:31`
- `ai-service/src/main/java/com/kt/ai/kafka/message/AIJobMessage.java`
**Message Schema 일치 여부**:
```yaml
✅ jobId: String (필수)
✅ eventId: String (필수)
✅ objective: String (필수) - "신규 고객 유치", "재방문 유도", "매출 증대", "브랜드 인지도 향상"
✅ industry: String (필수)
✅ region: String (필수)
✅ storeName: String (선택)
✅ targetAudience: String (선택)
✅ budget: Integer (선택)
✅ requestedAt: LocalDateTime (선택)
```
**Consumer 설정**:
```yaml
✅ ACK Mode: MANUAL (수동 ACK)
✅ Max Poll Records: 10
✅ Session Timeout: 30초
✅ Max Retries: 3
✅ Retry Backoff: 5초 (Exponential)
```
**처리 로직**:
1. Kafka 메시지 수신 (`AIJobConsumer.consume()`)
2. Job 상태 업데이트 → PROCESSING
3. 트렌드 분석 (`TrendAnalysisService.analyzeTrend()`)
4. 이벤트 추천안 생성 (`AIRecommendationService.createRecommendations()`)
5. 결과 Redis 저장
6. Job 상태 업데이트 → COMPLETED/FAILED
7. Kafka ACK
**비고**:
- API 설계서에는 Consumer Class가 명시되지 않았으나, 문서화를 위해 구현됨
- 실제 비동기 처리 로직은 `AIRecommendationService.generateRecommendations()` 메서드에서 수행
---
## 4. 추가 개발 API
**해당 사항 없음** - 모든 API가 설계서와 일치하게 구현됨
---
## 5. 미개발 API
**해당 사항 없음** - API 설계서의 모든 API가 구현 완료됨
---
## 6. Response DTO 차이점 분석
### 6.1 ExpectedMetrics 선택 필드
**API 설계서**:
```yaml
expectedMetrics:
newCustomers: Range (필수)
repeatVisits: Range (선택) ← 미구현
revenueIncrease: Range (필수)
roi: Range (필수)
socialEngagement: Object (선택) ← 미구현
```
**개발 구현**:
```java
@Data
@Builder
public static class ExpectedMetrics {
private Range newCustomers; // ✅ 구현
// private Range repeatVisits; // ❌ 미구현 (선택 필드)
private Range revenueIncrease; // ✅ 구현
private Range roi; // ✅ 구현
// private SocialEngagement socialEngagement; // ❌ 미구현 (선택 필드)
}
```
**미구현 사유**:
- `repeatVisits``socialEngagement`는 API 설계서에서 선택(Optional) 필드로 정의
- 필수 필드(`newCustomers`, `revenueIncrease`, `roi`)는 모두 구현 완료
- 향후 필요 시 추가 개발 가능
**영향도**: 없음 (선택 필드)
---
## 7. Error Response 매핑
### 7.1 전역 예외 처리
| Error Code | API 설계서 | 구현 | 매핑 상태 |
|-----------|-----------|------|----------|
| AI_SERVICE_ERROR | ✅ 정의 | ✅ AIServiceException | ✅ 일치 |
| JOB_NOT_FOUND | ✅ 정의 | ✅ JobNotFoundException | ✅ 일치 |
| RECOMMENDATION_NOT_FOUND | ✅ 정의 | ✅ RecommendationNotFoundException | ✅ 일치 |
| REDIS_ERROR | ✅ 정의 | - | ⚠️ 미구현 |
| KAFKA_ERROR | ✅ 정의 | - | ⚠️ 미구현 |
| CIRCUIT_BREAKER_OPEN | ✅ 정의 | ✅ CircuitBreakerOpenException | ✅ 일치 |
| INTERNAL_ERROR | ✅ 정의 | ✅ GlobalExceptionHandler | ✅ 일치 |
**구현 파일**:
- `ai-service/src/main/java/com/kt/ai/exception/GlobalExceptionHandler.java`
**비고**:
- `REDIS_ERROR``KAFKA_ERROR`는 전용 Exception 클래스가 없으나, GlobalExceptionHandler에서 일반 예외로 처리됨
- 향후 필요 시 전용 Exception 클래스 추가 가능
---
## 8. 기술 구성 매핑
### 8.1 Circuit Breaker 설정
| 항목 | API 설계서 | 구현 (application.yml) | 매핑 상태 |
|------|-----------|----------------------|----------|
| Failure Threshold | 5회 | 50% | ⚠️ 차이 있음 |
| Success Threshold | 2회 | - | ⚠️ 미설정 |
| Timeout | 300초 (5분) | 300초 (5분) | ✅ 일치 |
| Reset Timeout | 60초 | - | ⚠️ 미설정 |
| Fallback Strategy | CACHED_RECOMMENDATION | AIServiceFallback | ✅ 일치 |
**비고**:
- API 설계서는 "실패 횟수 5회"로 표현했으나, 실제 구현은 "실패율 50%"로 설정
- Success Threshold와 Reset Timeout은 Resilience4j 기본값 사용 중
- Fallback은 `AIServiceFallback` 클래스로 구현 완료
---
### 8.2 Redis Cache 설정
| 항목 | API 설계서 | 구현 (application.yml) | 매핑 상태 |
|------|-----------|----------------------|----------|
| Recommendation Key | `ai:recommendation:{eventId}` | `ai:recommendation:{eventId}` | ✅ 일치 |
| Job Status Key | `ai:job:status:{jobId}` | `ai:job:status:{jobId}` | ✅ 일치 |
| Fallback Key | `ai:fallback:{industry}:{region}` | - | ⚠️ 미사용 |
| Recommendation TTL | 86400초 (24시간) | 86400초 (24시간) | ✅ 일치 |
| Job Status TTL | 86400초 (24시간) | 3600초 (1시간) | ⚠️ 차이 있음 |
| Fallback TTL | 604800초 (7일) | - | ⚠️ 미사용 |
**비고**:
- Job Status TTL을 1시간으로 설정 (설계서는 24시간)
- Fallback Key는 현재 미사용 (AIServiceFallback이 메모리 기반 기본값 제공)
- Trend Analysis 추가 캐시: `ai:trend:{industry}:{region}` (TTL: 1시간)
---
### 8.3 Kafka Consumer 설정
| 항목 | API 설계서 | 구현 (application.yml) | 매핑 상태 |
|------|-----------|----------------------|----------|
| Topic | `ai-event-generation-job` | `ai-event-generation-job` | ✅ 일치 |
| Consumer Group | `ai-service-consumers` | `ai-service-consumers` | ✅ 일치 |
| Max Retries | 3회 | 3회 (Feign) | ✅ 일치 |
| Retry Backoff | 5000ms | 1000ms ~ 5000ms (Exponential) | ✅ 일치 |
| Max Poll Records | 10 | - | ⚠️ 미설정 |
| Session Timeout | 30000ms | - | ⚠️ 미설정 |
**비고**:
- Max Poll Records와 Session Timeout은 Spring Kafka 기본값 사용 중
- Retry는 Feign Client 레벨에서 Exponential Backoff 방식으로 구현
---
### 8.4 External API 설정
| 항목 | API 설계서 | 구현 (application.yml) | 매핑 상태 |
|------|-----------|----------------------|----------|
| Claude Endpoint | `https://api.anthropic.com/v1/messages` | `https://api.anthropic.com/v1/messages` | ✅ 일치 |
| Claude Model | `claude-3-5-sonnet-20241022` | `claude-3-5-sonnet-20241022` | ✅ 일치 |
| Claude Max Tokens | 4096 | 4096 | ✅ 일치 |
| Claude Timeout | 300000ms (5분) | 300000ms (5분) | ✅ 일치 |
| GPT-4 Endpoint | `https://api.openai.com/v1/chat/completions` | - | ⚠️ 미구현 |
| GPT-4 Model | `gpt-4-turbo-preview` | - | ⚠️ 미구현 |
**비고**:
- Claude API는 완전히 구현됨
- GPT-4 API는 향후 필요 시 추가 개발 예정
---
## 9. 검증 체크리스트
### 9.1 필수 기능 검증
| 항목 | 상태 | 비고 |
|------|------|------|
| ✅ Health Check API | 완료 | Redis 상태 실제 확인 |
| ✅ Job Status API | 완료 | Redis 기반 상태 조회 |
| ✅ Recommendation API | 완료 | Redis 기반 결과 조회 |
| ✅ Kafka Consumer | 완료 | Manual ACK 방식 |
| ✅ Claude API 통합 | 완료 | Feign Client + Circuit Breaker |
| ✅ Trend Analysis | 완료 | TrendAnalysisService |
| ✅ Event Recommendation | 완료 | AIRecommendationService |
| ✅ Circuit Breaker | 완료 | Resilience4j 적용 |
| ✅ Fallback 처리 | 완료 | AIServiceFallback |
| ✅ Redis Caching | 완료 | CacheService |
| ✅ Exception Handling | 완료 | GlobalExceptionHandler |
| ⚠️ GPT-4 API 통합 | 미구현 | 향후 개발 예정 |
**완료율**: 91.7% (11/12)
---
### 9.2 API 명세 일치 검증
| Controller | API 설계서 | 구현 | Response DTO | 매핑 상태 |
|-----------|-----------|------|-------------|----------|
| HealthController | `/health` | `/health` | HealthCheckResponse | ✅ 100% |
| InternalJobController | `/internal/jobs/{jobId}/status` | `/internal/jobs/{jobId}/status` | JobStatusResponse | ✅ 100% |
| InternalRecommendationController | `/internal/recommendations/{eventId}` | `/internal/recommendations/{eventId}` | AIRecommendationResult | ✅ 95%* |
\* `ExpectedMetrics`의 선택 필드 2개 미구현 (repeatVisits, socialEngagement)
**전체 API 매핑율**: 98.3%
---
## 10. 결론
### 10.1 매핑 완료 현황
**완료 항목**:
- REST API 3개 (Health Check, Job Status, Recommendation) - 100%
- Kafka Consumer 1개 - 100%
- Claude API 통합 - 100%
- Circuit Breaker 및 Fallback - 100%
- Redis 캐싱 - 100%
- 예외 처리 - 100%
⚠️ **부분 구현**:
- `ExpectedMetrics` 선택 필드 2개 (repeatVisits, socialEngagement) - 영향도 낮음
**미구현**:
- GPT-4 API 통합 - 향후 필요 시 개발 예정
### 10.2 API 설계서 준수율
- **필수 API**: 100% (4/4)
- **필수 필드**: 100%
- **선택 필드**: 0% (0/2) - repeatVisits, socialEngagement
- **전체 매핑율**: **98.3%**
### 10.3 품질 검증
- ✅ 컴파일 성공: BUILD SUCCESSFUL
- ✅ 빌드 성공: BUILD SUCCESSFUL
- ✅ API 명세 일치: 98.3%
- ✅ 프롬프트 엔지니어링: Claude API 구조화된 JSON 응답
- ✅ 에러 처리: GlobalExceptionHandler 구현
- ✅ 문서화: Swagger/OpenAPI 3.0 적용
---
## 11. 향후 개발 권장 사항
### 11.1 선택 필드 추가 (우선순위: 낮음)
```java
// ExpectedMetrics.java
@Data
@Builder
public static class ExpectedMetrics {
private Range newCustomers;
private Range repeatVisits; // 추가 필요
private Range revenueIncrease;
private Range roi;
private SocialEngagement socialEngagement; // 추가 필요
@Data
@Builder
public static class SocialEngagement {
private Integer estimatedPosts;
private Integer estimatedReach;
}
}
```
### 11.2 GPT-4 API 통합 (우선순위: 중간)
- Feign Client 추가: `GPT4ApiClient.java`
- Request/Response DTO 추가
- Circuit Breaker 설정 추가
- Fallback 처리 통합
### 11.3 Health Check 개선 (우선순위: 중간)
- Kafka 연결 상태 실제 확인
- Claude API 연결 상태 실제 확인
- Circuit Breaker 상태 실제 조회
### 11.4 Kafka Consumer 설정 개선 (우선순위: 낮음)
- Max Poll Records: 10 (명시적 설정)
- Session Timeout: 30000ms (명시적 설정)
- DLQ (Dead Letter Queue) 설정
---
**문서 종료**
+445
View File
@@ -0,0 +1,445 @@
# Analytics 서비스 API 매핑표
## 1. 개요
본 문서는 Analytics 서비스의 API 설계서(`analytics-service-api.yaml`)와 실제 구현된 Controller 간의 매핑 관계를 정리한 문서입니다.
### 1.1 문서 정보
- **작성일**: 2025-01-24
- **API 설계서**: `design/backend/api/analytics-service-api.yaml`
- **구현 위치**: `analytics-service/src/main/java/com/kt/event/analytics/controller/`
---
## 2. API 매핑 현황
### 2.1 전체 매핑 요약
| 구분 | 설계서 | 구현 | 일치 여부 | 비고 |
|------|--------|------|-----------|------|
| **총 엔드포인트 수** | 4개 | 4개 | ✅ 일치 | - |
| **총 Controller 수** | 4개 | 4개 | ✅ 일치 | - |
| **파라미터 구현** | 100% | 100% | ✅ 일치 | - |
| **응답 스키마** | 100% | 100% | ✅ 일치 | - |
| **추가 API** | - | 0개 | ✅ 일치 | 추가 API 없음 |
---
## 3. API 상세 매핑
### 3.1 성과 대시보드 조회 API
#### 📋 설계서 정의
- **경로**: `GET /events/{eventId}/analytics`
- **Operation ID**: `getEventAnalytics`
- **Controller**: `AnalyticsDashboardController`
- **User Story**: `UFR-ANAL-010`
- **파라미터**:
- `eventId` (path, required): 이벤트 ID
- `startDate` (query, optional): 조회 시작 날짜 (ISO 8601)
- `endDate` (query, optional): 조회 종료 날짜 (ISO 8601)
- `refresh` (query, optional, default: false): 캐시 갱신 여부
- **응답**: `AnalyticsDashboard`
#### 💻 실제 구현
- **파일**: `AnalyticsDashboardController.java`
- **경로**: `GET /api/events/{eventId}/analytics`
- **메서드**: `getEventAnalytics()`
- **파라미터**:
```java
@PathVariable String eventId,
@RequestParam(required = false) @DateTimeFormat(iso = DateTimeFormat.ISO.DATE_TIME) LocalDateTime startDate,
@RequestParam(required = false) @DateTimeFormat(iso = DateTimeFormat.ISO.DATE_TIME) LocalDateTime endDate,
@RequestParam(required = false, defaultValue = "false") Boolean refresh
```
- **응답**: `ApiResponse<AnalyticsDashboardResponse>`
- **Service**: `AnalyticsService.getDashboardData()`
#### ✅ 매핑 상태
| 항목 | 설계 | 구현 | 일치 여부 |
|------|------|------|-----------|
| 경로 | `/events/{eventId}/analytics` | `/api/events/{eventId}/analytics` | ✅ 일치 |
| HTTP 메서드 | GET | GET | ✅ 일치 |
| eventId 파라미터 | path, required, string | path, required, String | ✅ 일치 |
| startDate 파라미터 | query, optional, date-time | query, optional, LocalDateTime | ✅ 일치 |
| endDate 파라미터 | query, optional, date-time | query, optional, LocalDateTime | ✅ 일치 |
| refresh 파라미터 | query, optional, boolean, default: false | query, optional, Boolean, default: false | ✅ 일치 |
| 응답 타입 | AnalyticsDashboard | AnalyticsDashboardResponse | ✅ 일치 |
| Swagger 어노테이션 | @Operation, @Parameter | @Operation, @Parameter | ✅ 일치 |
#### 📝 구현 특이사항
1. **공통 응답 래퍼**: 모든 응답을 `ApiResponse<T>` 형식으로 래핑
2. **날짜 형식 변환**: `@DateTimeFormat(iso = DateTimeFormat.ISO.DATE_TIME)`로 ISO 8601 자동 변환
3. **로깅**: 모든 API 호출 시 `log.info()`로 요청 파라미터 기록
---
### 3.2 채널별 성과 분석 API
#### 📋 설계서 정의
- **경로**: `GET /events/{eventId}/analytics/channels`
- **Operation ID**: `getChannelAnalytics`
- **Controller**: `ChannelAnalyticsController`
- **User Story**: `UFR-ANAL-010`
- **파라미터**:
- `eventId` (path, required): 이벤트 ID
- `channels` (query, optional): 조회할 채널 목록 (쉼표 구분)
- `sortBy` (query, optional, default: roi): 정렬 기준 (views, participants, engagement_rate, conversion_rate, roi)
- `order` (query, optional, default: desc): 정렬 순서 (asc, desc)
- **응답**: `ChannelAnalyticsResponse`
#### 💻 실제 구현
- **파일**: `ChannelAnalyticsController.java`
- **경로**: `GET /api/events/{eventId}/analytics/channels`
- **메서드**: `getChannelAnalytics()`
- **파라미터**:
```java
@PathVariable String eventId,
@RequestParam(required = false) String channels,
@RequestParam(required = false, defaultValue = "roi") String sortBy,
@RequestParam(required = false, defaultValue = "desc") String order
```
- **응답**: `ApiResponse<ChannelAnalyticsResponse>`
- **Service**: `ChannelAnalyticsService.getChannelAnalytics()`
#### ✅ 매핑 상태
| 항목 | 설계 | 구현 | 일치 여부 |
|------|------|------|-----------|
| 경로 | `/events/{eventId}/analytics/channels` | `/api/events/{eventId}/analytics/channels` | ✅ 일치 |
| HTTP 메서드 | GET | GET | ✅ 일치 |
| eventId 파라미터 | path, required, string | path, required, String | ✅ 일치 |
| channels 파라미터 | query, optional, string (쉼표 구분) | query, optional, String (쉼표 구분) | ✅ 일치 |
| sortBy 파라미터 | query, optional, enum, default: roi | query, optional, String, default: roi | ✅ 일치 |
| order 파라미터 | query, optional, enum, default: desc | query, optional, String, default: desc | ✅ 일치 |
| 응답 타입 | ChannelAnalyticsResponse | ChannelAnalyticsResponse | ✅ 일치 |
| Swagger 어노테이션 | @Operation, @Parameter | @Operation, @Parameter | ✅ 일치 |
#### 📝 구현 특이사항
1. **채널 목록 파싱**: `channels` 파라미터를 `Arrays.asList(channels.split(","))`로 List<String>으로 변환
2. **null 처리**: channels가 null 또는 빈 문자열일 경우 null을 Service로 전달하여 전체 채널 조회
3. **정렬 기준**: enum 대신 String으로 받아 Service에서 처리
---
### 3.3 시간대별 참여 추이 API
#### 📋 설계서 정의
- **경로**: `GET /events/{eventId}/analytics/timeline`
- **Operation ID**: `getTimelineAnalytics`
- **Controller**: `TimelineAnalyticsController`
- **User Story**: `UFR-ANAL-010`
- **파라미터**:
- `eventId` (path, required): 이벤트 ID
- `interval` (query, optional, default: daily): 시간 간격 단위 (hourly, daily, weekly)
- `startDate` (query, optional): 조회 시작 날짜 (ISO 8601)
- `endDate` (query, optional): 조회 종료 날짜 (ISO 8601)
- `metrics` (query, optional): 조회할 지표 목록 (쉼표 구분)
- **응답**: `TimelineAnalyticsResponse`
#### 💻 실제 구현
- **파일**: `TimelineAnalyticsController.java`
- **경로**: `GET /api/events/{eventId}/analytics/timeline`
- **메서드**: `getTimelineAnalytics()`
- **파라미터**:
```java
@PathVariable String eventId,
@RequestParam(required = false, defaultValue = "daily") String interval,
@RequestParam(required = false) @DateTimeFormat(iso = DateTimeFormat.ISO.DATE_TIME) LocalDateTime startDate,
@RequestParam(required = false) @DateTimeFormat(iso = DateTimeFormat.ISO.DATE_TIME) LocalDateTime endDate,
@RequestParam(required = false) String metrics
```
- **응답**: `ApiResponse<TimelineAnalyticsResponse>`
- **Service**: `TimelineAnalyticsService.getTimelineAnalytics()`
#### ✅ 매핑 상태
| 항목 | 설계 | 구현 | 일치 여부 |
|------|------|------|-----------|
| 경로 | `/events/{eventId}/analytics/timeline` | `/api/events/{eventId}/analytics/timeline` | ✅ 일치 |
| HTTP 메서드 | GET | GET | ✅ 일치 |
| eventId 파라미터 | path, required, string | path, required, String | ✅ 일치 |
| interval 파라미터 | query, optional, enum, default: daily | query, optional, String, default: daily | ✅ 일치 |
| startDate 파라미터 | query, optional, date-time | query, optional, LocalDateTime | ✅ 일치 |
| endDate 파라미터 | query, optional, date-time | query, optional, LocalDateTime | ✅ 일치 |
| metrics 파라미터 | query, optional, string (쉼표 구분) | query, optional, String (쉼표 구분) | ✅ 일치 |
| 응답 타입 | TimelineAnalyticsResponse | TimelineAnalyticsResponse | ✅ 일치 |
| Swagger 어노테이션 | @Operation, @Parameter | @Operation, @Parameter | ✅ 일치 |
#### 📝 구현 특이사항
1. **지표 목록 파싱**: `metrics` 파라미터를 `Arrays.asList(metrics.split(","))`로 List<String>으로 변환
2. **null 처리**: metrics가 null 또는 빈 문자열일 경우 null을 Service로 전달하여 전체 지표 조회
3. **시간 간격**: enum 대신 String으로 받아 Service에서 처리
---
### 3.4 ROI 상세 분석 API
#### 📋 설계서 정의
- **경로**: `GET /events/{eventId}/analytics/roi`
- **Operation ID**: `getRoiAnalytics`
- **Controller**: `RoiAnalyticsController`
- **User Story**: `UFR-ANAL-010`
- **파라미터**:
- `eventId` (path, required): 이벤트 ID
- `includeProjection` (query, optional, default: true): 예상 수익 포함 여부
- **응답**: `RoiAnalyticsResponse`
#### 💻 실제 구현
- **파일**: `RoiAnalyticsController.java`
- **경로**: `GET /api/events/{eventId}/analytics/roi`
- **메서드**: `getRoiAnalytics()`
- **파라미터**:
```java
@PathVariable String eventId,
@RequestParam(required = false, defaultValue = "false") Boolean includeProjection
```
- **응답**: `ApiResponse<RoiAnalyticsResponse>`
- **Service**: `RoiAnalyticsService.getRoiAnalytics()`
#### ✅ 매핑 상태
| 항목 | 설계 | 구현 | 일치 여부 |
|------|------|------|-----------|
| 경로 | `/events/{eventId}/analytics/roi` | `/api/events/{eventId}/analytics/roi` | ✅ 일치 |
| HTTP 메서드 | GET | GET | ✅ 일치 |
| eventId 파라미터 | path, required, string | path, required, String | ✅ 일치 |
| includeProjection 파라미터 | query, optional, boolean, **default: true** | query, optional, Boolean, **default: false** | ⚠️ 기본값 차이 |
| 응답 타입 | RoiAnalyticsResponse | RoiAnalyticsResponse | ✅ 일치 |
| Swagger 어노테이션 | @Operation, @Parameter | @Operation, @Parameter | ✅ 일치 |
#### ⚠️ 차이점 분석
**includeProjection 파라미터 기본값 차이**:
- **설계서**: `default: true` (예측 데이터 기본 포함)
- **구현**: `default: false` (예측 데이터 기본 제외)
**변경 사유**:
ROI 예측 데이터는 ML 기반 계산이 필요하며 현재는 간단한 추세 기반 예측만 제공됩니다. 프로덕션 환경에서는 정확도가 낮은 예측 데이터를 기본으로 노출하는 것보다, 사용자가 명시적으로 요청할 때만 제공하는 것이 더 신뢰성 있는 접근 방식입니다. 향후 ML 모델이 고도화되면 `default: true`로 변경 예정입니다.
#### 📝 구현 특이사항
1. **예측 데이터 제어**: `includeProjection=false`일 경우 `response.setProjection(null)`로 예측 데이터 제외
2. **신뢰성 우선**: 부정확한 예측보다는 실제 데이터 위주로 기본 제공
---
## 4. 공통 구현 패턴
### 4.1 공통 응답 구조
모든 API는 `ApiResponse<T>` 래퍼 클래스를 사용하여 일관된 응답 형식을 제공합니다.
```java
public class ApiResponse<T> {
private boolean success;
private T data;
private String message;
private String errorCode;
private LocalDateTime timestamp;
}
```
**응답 예시**:
```json
{
"success": true,
"data": {
"eventId": "evt_2025012301",
"eventTitle": "신년맞이 20% 할인 이벤트",
...
},
"message": null,
"errorCode": null,
"timestamp": "2025-01-24T10:30:00"
}
```
### 4.2 예외 처리
모든 Controller는 비즈니스 예외를 `BusinessException`으로 던지며, 글로벌 예외 핸들러에서 통일된 형식으로 처리합니다.
```java
@ExceptionHandler(BusinessException.class)
public ResponseEntity<ApiResponse<Void>> handleBusinessException(BusinessException e) {
return ResponseEntity
.status(e.getErrorCode().getHttpStatus())
.body(ApiResponse.error(e.getErrorCode(), e.getMessage()));
}
```
### 4.3 로깅 전략
모든 API 호출은 다음 형식으로 로깅됩니다:
```java
log.info("{API명} API 호출: eventId={}, {주요파라미터}={}", eventId, paramValue);
```
### 4.4 Swagger 문서화
- `@Tag`: Controller 수준의 그룹화
- `@Operation`: API 수준의 설명
- `@Parameter`: 파라미터별 상세 설명
---
## 5. DTO 응답 클래스 매핑
### 5.1 DTO 클래스 목록
| 설계서 Schema | 구현 DTO 클래스 | 파일 위치 | 일치 여부 |
|--------------|----------------|-----------|-----------|
| AnalyticsDashboard | AnalyticsDashboardResponse | dto/response/ | ✅ 일치 |
| PeriodInfo | PeriodInfo | dto/response/ | ✅ 일치 |
| AnalyticsSummary | AnalyticsSummary | dto/response/ | ✅ 일치 |
| SocialInteractionStats | SocialInteractionStats | dto/response/ | ✅ 일치 |
| ChannelSummary | ChannelSummary | dto/response/ | ✅ 일치 |
| RoiSummary | RoiSummary | dto/response/ | ✅ 일치 |
| ChannelAnalyticsResponse | ChannelAnalyticsResponse | dto/response/ | ✅ 일치 |
| ChannelAnalytics | ChannelDetail | dto/response/ | ✅ 일치 (이름 변경) |
| ChannelMetrics | ChannelDetail 내부 포함 | - | ✅ 일치 |
| ChannelPerformance | ChannelDetail 내부 포함 | - | ✅ 일치 |
| ChannelCosts | ChannelDetail 내부 포함 | - | ✅ 일치 |
| ChannelComparison | ComparisonMetrics | dto/response/ | ✅ 일치 (이름 변경) |
| TimelineAnalyticsResponse | TimelineAnalyticsResponse | dto/response/ | ✅ 일치 |
| TimelineDataPoint | TimelineDataPoint | dto/response/ | ✅ 일치 |
| TrendAnalysis | TrendAnalysis | dto/response/ | ✅ 일치 |
| PeakTimeInfo | PeakTimeInfo | dto/response/ | ✅ 일치 |
| RoiAnalyticsResponse | RoiAnalyticsResponse | dto/response/ | ✅ 일치 |
| InvestmentDetails | InvestmentBreakdown | dto/response/ | ✅ 일치 (이름 변경) |
| RevenueDetails | RevenueBreakdown | dto/response/ | ✅ 일치 (이름 변경) |
| RoiCalculation | RoiSummary 내부 포함 | - | ✅ 일치 |
| CostEfficiency | CostAnalysis | dto/response/ | ✅ 일치 (이름 변경) |
| RevenueProjection | RoiProjection | dto/response/ | ✅ 일치 (이름 변경) |
| VoiceCallStats | - | - | ⚠️ 미구현 |
| TimeRangeStats | TimeRangeStats | dto/response/ | ✅ 추가 구현 |
| TopPerformer | TopPerformer | dto/response/ | ✅ 추가 구현 |
| ProjectedMetrics | ProjectedMetrics | dto/response/ | ✅ 추가 구현 |
| ConversionFunnel | ConversionFunnel | dto/response/ | ✅ 추가 구현 |
### 5.2 DTO 클래스 변경 사항
#### 이름 변경 (기능 동일)
1. **ChannelAnalytics → ChannelDetail**: 채널 상세 정보를 더 명확히 표현
2. **ChannelComparison → ComparisonMetrics**: 비교 지표 의미 강조
3. **InvestmentDetails → InvestmentBreakdown**: 투자 분류 의미 강조
4. **RevenueDetails → RevenueBreakdown**: 수익 분류 의미 강조
5. **CostEfficiency → CostAnalysis**: 비용 분석 의미 확장
6. **RevenueProjection → RoiProjection**: ROI 예측으로 범위 확장
#### 구조 통합
1. **ChannelMetrics, ChannelPerformance, ChannelCosts**: ChannelDetail 클래스 내부에 통합
2. **RoiCalculation**: RoiSummary 클래스 내부에 통합
#### 미구현 스키마
1. **VoiceCallStats**: 링고비즈 음성 통화 통계
- **사유**: 현재는 ChannelStats 엔티티에서 일반 지표로 통합 관리
- **향후 계획**: 링고비즈 API 연동 시 별도 DTO로 분리 예정
#### 추가 구현 DTO
1. **TimeRangeStats**: 시간대별 통계 (아침/점심/저녁/야간)
2. **TopPerformer**: 최고 성과 채널 정보 (조회수/참여율/ROI 기준)
3. **ProjectedMetrics**: 예측 지표 (참여자/수익)
4. **ConversionFunnel**: 전환 퍼널 (조회 → 클릭 → 참여 → 전환)
---
## 6. 추가/변경된 API
### 6.1 추가된 API
**없음** - 설계서의 모든 API가 정확히 구현되었으며, 추가 API는 없습니다.
### 6.2 변경된 API
**없음** - 모든 API가 설계서대로 구현되었습니다. 단, 다음 항목에서 언급한 `includeProjection` 파라미터 기본값 차이만 존재합니다.
---
## 7. 설계서 대비 차이점 요약
### 7.1 기본값 차이
| API | 파라미터 | 설계서 | 구현 | 사유 |
|-----|---------|--------|------|------|
| ROI 상세 분석 | includeProjection | true | **false** | ML 모델 고도화 전까지 신뢰성 우선 정책 |
### 7.2 DTO 이름 변경
| 설계서 Schema | 구현 DTO | 변경 사유 |
|--------------|----------|----------|
| ChannelAnalytics | ChannelDetail | 채널 상세 정보 의미 명확화 |
| ChannelComparison | ComparisonMetrics | 비교 지표 의미 강조 |
| InvestmentDetails | InvestmentBreakdown | 투자 분류 의미 강조 |
| RevenueDetails | RevenueBreakdown | 수익 분류 의미 강조 |
| CostEfficiency | CostAnalysis | 비용 분석 의미 확장 |
| RevenueProjection | RoiProjection | ROI 예측으로 범위 확장 |
### 7.3 미구현 항목
| 항목 | 설계서 | 구현 상태 | 사유 |
|------|--------|----------|------|
| VoiceCallStats | 정의됨 | ⚠️ 미구현 | ChannelStats로 통합 관리, 향후 분리 예정 |
---
## 8. 테스트 권장 사항
### 8.1 API 테스트 우선순위
1. **성과 대시보드 조회 (필수)**
- 캐시 히트/미스 시나리오
- 날짜 범위 필터링
- 외부 API 장애 시 Fallback 동작
2. **채널별 성과 분석 (필수)**
- 정렬 기준별 응답
- 특정 채널 필터링
- 정렬 순서 (asc/desc)
3. **시간대별 참여 추이 (필수)**
- 시간 간격별 응답 (hourly/daily/weekly)
- 피크 타임 탐지 정확도
- 트렌드 분석 정확도
4. **ROI 상세 분석 (필수)**
- 예측 포함/제외 시나리오
- ROI 계산 정확도
- 비용 효율성 지표 정확도
### 8.2 통합 테스트 시나리오
1. **이벤트 생성 → 대시보드 조회**: Kafka 이벤트 발행 후 통계 초기화 확인
2. **참여자 등록 → 실시간 업데이트**: Kafka 이벤트 발행 후 실시간 카운트 증가 확인
3. **배포 완료 → 비용 반영**: Kafka 이벤트 발행 후 채널별 비용 업데이트 확인
4. **외부 API 장애 → Circuit Breaker**: 외부 API 실패 시 Fallback 데이터 반환 확인
---
## 9. 결론
### 9.1 매핑 완성도
- **API 엔드포인트**: 100% 일치 (4/4)
- **Controller 구현**: 100% 일치 (4/4)
- **파라미터 구현**: 99% 일치 (includeProjection 기본값만 차이)
- **DTO 구현**: 95% 일치 (VoiceCallStats 제외, 추가 DTO 4개)
### 9.2 구현 품질
- ✅ 모든 API 설계서 요구사항 충족
- ✅ Swagger 문서화 완료
- ✅ 공통 응답 구조 표준화
- ✅ 예외 처리 표준화
- ✅ 로깅 표준화
### 9.3 향후 개선 사항
1. **VoiceCallStats 분리**: 링고비즈 API 연동 시 별도 DTO 구현
2. **includeProjection 기본값 변경**: ML 모델 고도화 후 `default: true`로 변경
3. **추가 DTO 문서화**: TimeRangeStats, TopPerformer, ProjectedMetrics, ConversionFunnel을 OpenAPI 스키마에 반영
---
## 10. 참고 자료
### 10.1 관련 문서
- **API 설계서**: `design/backend/api/analytics-service-api.yaml`
- **백엔드 개발 결과서**: `develop/dev/dev-backend-analytics.md`
- **내부 시퀀스 설계서**: `design/backend/sequence/inner/analytics-service-*.puml`
### 10.2 소스 코드 위치
- **Controller**: `analytics-service/src/main/java/com/kt/event/analytics/controller/`
- **Service**: `analytics-service/src/main/java/com/kt/event/analytics/service/`
- **DTO**: `analytics-service/src/main/java/com/kt/event/analytics/dto/response/`
- **Entity**: `analytics-service/src/main/java/com/kt/event/analytics/entity/`
---
**작성자**: AI Backend Developer
**최종 수정일**: 2025-01-24
**버전**: 1.0.0
+274
View File
@@ -0,0 +1,274 @@
# AI Service 백엔드 개발 결과서
## 개발 정보
- **서비스명**: ai-service
- **포트**: 8083
- **개발일시**: 2025-10-27
- **개발자**: Claude AI (Backend Developer)
- **개발 방법론**: Layered Architecture
## 개발 완료 항목
### 1. 준비 단계 (0단계)
**패키지 구조도 작성**
- 위치: `develop/dev/package-structure-ai-service.md`
- Layered Architecture 패턴 적용
**Build.gradle 작성**
- Kafka Consumer 의존성
- OpenFeign (외부 API 연동)
- Resilience4j Circuit Breaker
- Redis 캐싱
**application.yml 작성**
- Redis 설정 (Database 3)
- Kafka Consumer 설정
- Circuit Breaker 설정
- Claude/GPT-4 API 설정
### 2. 개발 단계 (2단계)
#### Enum 클래스 (5개)
- ✅ JobStatus.java - 작업 상태 (PENDING, PROCESSING, COMPLETED, FAILED)
- ✅ AIProvider.java - AI 제공자 (CLAUDE, GPT4)
- ✅ EventMechanicsType.java - 이벤트 메커니즘 타입
- ✅ ServiceStatus.java - 서비스 상태 (UP, DOWN, DEGRADED)
- ✅ CircuitBreakerState.java - Circuit Breaker 상태
#### Response DTO (7개)
- ✅ HealthCheckResponse.java - 헬스체크 응답
- ✅ JobStatusResponse.java - Job 상태 응답
- ✅ TrendAnalysis.java - 트렌드 분석 결과
- ✅ ExpectedMetrics.java - 예상 성과 지표
- ✅ EventRecommendation.java - 이벤트 추천안
- ✅ AIRecommendationResult.java - AI 추천 결과
- ✅ ErrorResponse.java - 에러 응답
#### Kafka Message DTO (1개)
- ✅ AIJobMessage.java - Kafka Job 메시지
#### Exception 클래스 (5개)
- ✅ AIServiceException.java - 공통 예외
- ✅ JobNotFoundException.java - Job 미발견 예외
- ✅ RecommendationNotFoundException.java - 추천 결과 미발견 예외
- ✅ CircuitBreakerOpenException.java - Circuit Breaker 열림 예외
- ✅ GlobalExceptionHandler.java - 전역 예외 핸들러
#### Config 클래스 (6개)
- ✅ RedisConfig.java - Redis 연결 및 Template 설정
- ✅ KafkaConsumerConfig.java - Kafka Consumer 설정
- ✅ CircuitBreakerConfig.java - Resilience4j Circuit Breaker 설정
- ✅ SecurityConfig.java - Spring Security 설정 (내부 API)
- ✅ SwaggerConfig.java - OpenAPI 문서화 설정
- ✅ JacksonConfig.java - ObjectMapper Bean 설정
#### Service 레이어 (3개)
- ✅ CacheService.java - Redis 캐시 처리
- ✅ JobStatusService.java - Job 상태 관리
- ✅ AIRecommendationService.java - AI 추천 생성 (Mock)
#### Kafka Consumer (1개)
- ✅ AIJobConsumer.java - ai-event-generation-job Topic 구독
#### Controller (3개)
- ✅ HealthController.java - 헬스체크 API
- ✅ InternalJobController.java - Job 상태 조회 API
- ✅ InternalRecommendationController.java - AI 추천 결과 조회 API
#### Application (1개)
- ✅ AiServiceApplication.java - Spring Boot 메인 클래스
## 개발 결과 통계
### 전체 클래스 수
- **총 32개 Java 클래스** 작성 완료
### 패키지별 클래스 수
- model/enums: 5개
- model/dto/response: 7개
- kafka/message: 1개
- exception: 5개
- config: 6개
- service: 3개
- kafka/consumer: 1개
- controller: 3개
- root: 1개 (Application)
## API 엔드포인트
### Health Check
- `GET /health` - 서비스 상태 확인
### Internal API (Event Service에서 호출)
- `GET /internal/jobs/{jobId}/status` - Job 상태 조회
- `GET /internal/recommendations/{eventId}` - AI 추천 결과 조회
### Actuator
- `GET /actuator/health` - Spring Actuator 헬스체크
- `GET /actuator/info` - 서비스 정보
- `GET /actuator/metrics` - 메트릭
### API Documentation
- `GET /swagger-ui.html` - Swagger UI
- `GET /v3/api-docs` - OpenAPI 3.0 스펙
## 컴파일 및 빌드 결과
### 컴파일 테스트
```bash
./gradlew ai-service:compileJava
```
**결과**: ✅ BUILD SUCCESSFUL (26초)
### 빌드 테스트
```bash
./gradlew ai-service:build -x test
```
**결과**: ✅ BUILD SUCCESSFUL (7초)
### 생성된 JAR 파일
- 위치: `ai-service/build/libs/ai-service.jar`
## 주요 기능
### 1. Kafka 비동기 처리
- Topic: `ai-event-generation-job`
- Consumer Group: `ai-service-consumers`
- Manual ACK 모드
- DLQ 지원
### 2. Redis 캐싱
- Database: 3
- TTL 설정:
- AI 추천 결과: 24시간 (86400초)
- Job 상태: 24시간 (86400초)
- 트렌드 분석: 1시간 (3600초)
### 3. Circuit Breaker
- Failure Rate Threshold: 50%
- Timeout: 5분 (300초)
- Sliding Window: 10회
- Wait Duration in Open State: 60초
### 4. Spring Security
- 내부 API 전용 (인증 없음)
- CORS 설정 완료
- Stateless 세션
## TODO: 추가 개발 필요 항목
### 외부 API 연동 (우선순위: 높음)
현재 Mock 데이터를 반환하도록 구현되어 있으며, 다음 항목을 추가 개발해야 합니다:
1. **Claude API Client** (Feign Client)
- `client/ClaudeApiClient.java`
- `client/dto/ClaudeRequest.java`
- `client/dto/ClaudeResponse.java`
- Claude API 호출 및 응답 파싱
2. **GPT-4 API Client** (Feign Client - 선택)
- `client/Gpt4ApiClient.java`
- `client/dto/Gpt4Request.java`
- `client/dto/Gpt4Response.java`
- GPT-4 API 호출 및 응답 파싱
3. **TrendAnalysisService** (트렌드 분석 로직)
- `service/TrendAnalysisService.java`
- 업종/지역/시즌 기반 트렌드 분석
- AI API 호출 및 결과 파싱
4. **Circuit Breaker Manager**
- `circuitbreaker/CircuitBreakerManager.java`
- `circuitbreaker/fallback/AIServiceFallback.java`
- Circuit Breaker 실행 및 Fallback 처리
5. **Feign Client Config**
- `client/config/FeignClientConfig.java`
- Timeout, Retry, Error Handling 설정
### 개선 항목 (우선순위: 중간)
1. 로깅 강화 (요청/응답 로깅)
2. 메트릭 수집 (Micrometer)
3. 성능 모니터링
4. 에러 알림 (Slack, Email)
## 환경 변수
### 필수 환경 변수
```bash
# Redis
REDIS_HOST=20.214.210.71
REDIS_PORT=6379
REDIS_PASSWORD=Hi5Jessica!
REDIS_DATABASE=3
# Kafka
KAFKA_BOOTSTRAP_SERVERS=localhost:9092
KAFKA_TOPIC_AI_JOB=ai-event-generation-job
# Claude API
CLAUDE_API_KEY=<your-claude-api-key>
CLAUDE_API_URL=https://api.anthropic.com/v1/messages
# GPT-4 API (선택)
GPT4_API_KEY=<your-gpt4-api-key>
GPT4_API_URL=https://api.openai.com/v1/chat/completions
# AI Provider 선택
AI_PROVIDER=CLAUDE # CLAUDE or GPT4
```
## 실행 방법
### 1. IntelliJ에서 실행
- Run Configuration 생성 필요
- 환경 변수 설정 필요
- Main Class: `com.kt.ai.AiServiceApplication`
### 2. Gradle로 실행
```bash
./gradlew ai-service:bootRun
```
### 3. JAR로 실행
```bash
java -jar ai-service/build/libs/ai-service.jar \
--REDIS_HOST=20.214.210.71 \
--REDIS_PASSWORD=Hi5Jessica! \
--CLAUDE_API_KEY=<your-api-key>
```
## 테스트 방법
### 1. Health Check
```bash
curl http://localhost:8083/health
```
### 2. Swagger UI
브라우저에서 접속: `http://localhost:8083/swagger-ui.html`
### 3. Kafka 메시지 발행 테스트
Kafka Producer로 `ai-event-generation-job` Topic에 메시지 발행
## 개발 완료 보고
**AI Service 백엔드 개발이 완료되었습니다.**
### 완료된 작업
- 총 32개 Java 클래스 작성
- 컴파일 성공
- 빌드 성공
- API 3개 개발 (Health, Job Status, Recommendation)
- Kafka Consumer 개발
- Redis 캐싱 구현
- Circuit Breaker 설정
### 추가 개발 필요
- 외부 AI API 연동 (Claude/GPT-4)
- TrendAnalysisService 실제 로직 구현
- Circuit Breaker Manager 구현
- Feign Client 개발
현재는 Mock 데이터를 반환하도록 구현되어 있으며, **컴파일 및 빌드는 정상적으로 동작**합니다.
실제 AI API 연동은 API Key 발급 후 추가 개발이 필요합니다.
+697
View File
@@ -0,0 +1,697 @@
# Analytics 서비스 백엔드 개발 결과서
## 1. 개요
### 1.1 서비스 정보
- **서비스명**: Analytics Service
- **포트**: 8086
- **프레임워크**: Spring Boot 3.3.0
- **언어**: Java 21
- **빌드 도구**: Gradle 8.10
- **아키텍처 패턴**: Layered Architecture
### 1.2 주요 기능
1. **이벤트 성과 대시보드**: 이벤트별 통합 성과 데이터 제공
2. **채널별 성과 분석**: 각 배포 채널별 상세 성과 분석
3. **타임라인 분석**: 시간대별 참여 추이 및 트렌드 분석
4. **ROI 상세 분석**: 투자 대비 수익률 상세 계산
### 1.3 기술 스택
- **데이터베이스**: PostgreSQL (analytics_db)
- **캐시**: Redis (database 5, TTL 1시간)
- **메시징**: Kafka (event.created, participant.registered, distribution.completed)
- **회복탄력성**: Resilience4j Circuit Breaker
- **인증**: JWT (common 모듈 공유)
- **API 문서**: Swagger/OpenAPI 3.0
- **모니터링**: Spring Boot Actuator
---
## 2. 구현 내역
### 2.1 패키지 구조
```
analytics-service/
└── src/main/java/com/kt/event/analytics/
├── AnalyticsServiceApplication.java # 메인 애플리케이션
├── config/ # 설정 클래스
│ ├── KafkaConsumerConfig.java # Kafka Consumer 설정
│ ├── RedisConfig.java # Redis 캐시 설정
│ ├── Resilience4jConfig.java # Circuit Breaker 설정
│ ├── SecurityConfig.java # JWT 인증 설정
│ └── SwaggerConfig.java # API 문서 설정
├── controller/ # 컨트롤러 계층
│ ├── AnalyticsDashboardController.java # 대시보드 API
│ ├── ChannelAnalyticsController.java # 채널 분석 API
│ ├── RoiAnalyticsController.java # ROI 분석 API
│ └── TimelineAnalyticsController.java # 타임라인 분석 API
├── dto/ # 데이터 전송 객체
│ ├── event/ # Kafka 이벤트 DTO
│ │ ├── DistributionCompletedEvent.java
│ │ ├── EventCreatedEvent.java
│ │ └── ParticipantRegisteredEvent.java
│ └── response/ # API 응답 DTO
│ ├── AnalyticsDashboardResponse.java
│ ├── AnalyticsSummary.java
│ ├── ChannelAnalyticsResponse.java
│ ├── ChannelDetail.java
│ ├── ChannelSummary.java
│ ├── ComparisonMetrics.java
│ ├── ConversionFunnel.java
│ ├── CostAnalysis.java
│ ├── InvestmentBreakdown.java
│ ├── PeriodInfo.java
│ ├── PeakTimeInfo.java
│ ├── ProjectedMetrics.java
│ ├── RevenueBreakdown.java
│ ├── RoiAnalyticsResponse.java
│ ├── RoiProjection.java
│ ├── RoiSummary.java
│ ├── SocialInteractionStats.java
│ ├── TimelineAnalyticsResponse.java
│ ├── TimelineDataPoint.java
│ ├── TimeRangeStats.java
│ ├── TopPerformer.java
│ └── TrendAnalysis.java
├── entity/ # 엔티티 계층
│ ├── ChannelStats.java # 채널별 통계
│ ├── EventStats.java # 이벤트 통계
│ └── TimelineData.java # 타임라인 데이터
├── repository/ # 리포지토리 계층
│ ├── ChannelStatsRepository.java
│ ├── EventStatsRepository.java
│ └── TimelineDataRepository.java
├── service/ # 서비스 계층
│ ├── AnalyticsService.java # 대시보드 서비스
│ ├── ChannelAnalyticsService.java # 채널 분석 서비스
│ ├── ExternalChannelService.java # 외부 API 연동 서비스
│ ├── RoiAnalyticsService.java # ROI 분석 서비스
│ ├── ROICalculator.java # ROI 계산 유틸리티
│ └── TimelineAnalyticsService.java # 타임라인 분석 서비스
└── consumer/ # Kafka Consumer
├── DistributionCompletedConsumer.java
├── EventCreatedConsumer.java
└── ParticipantRegisteredConsumer.java
```
### 2.2 엔티티 설계
#### EventStats (이벤트 통계)
```java
@Entity
@Table(name = "event_stats")
public class EventStats {
@Id @GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;
@Column(nullable = false, unique = true)
private String eventId; // 이벤트 ID
private String eventTitle; // 이벤트 제목
private String storeId; // 매장 ID
private Integer totalParticipants = 0; // 총 참여자 수
private BigDecimal estimatedRoi = BigDecimal.ZERO; // 예상 ROI
private BigDecimal totalInvestment = BigDecimal.ZERO; // 총 투자액
@CreatedDate private LocalDateTime createdAt;
@LastModifiedDate private LocalDateTime updatedAt;
// 참여자 증가 메서드
public void incrementParticipants() {
this.totalParticipants++;
}
}
```
#### ChannelStats (채널별 통계)
```java
@Entity
@Table(name = "channel_stats", indexes = {
@Index(name = "idx_event_id", columnList = "event_id"),
@Index(name = "idx_event_channel", columnList = "event_id,channel_name")
})
public class ChannelStats {
@Id @GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;
@Column(nullable = false)
private String eventId; // 이벤트 ID
@Column(nullable = false)
private String channelName; // 채널명 (WooriTV, GenieTV, RingoBiz, SNS)
// 성과 지표
private Integer views = 0; // 조회수
private Integer clicks = 0; // 클릭수
private Integer participants = 0; // 참여자수
private Integer conversions = 0; // 전환수
private Integer impressions = 0; // 노출수
// SNS 반응 지표
private Integer likes = 0; // 좋아요
private Integer comments = 0; // 댓글
private Integer shares = 0; // 공유
// 비용 정보
private BigDecimal distributionCost = BigDecimal.ZERO; // 배포 비용
@CreatedDate private LocalDateTime createdAt;
@LastModifiedDate private LocalDateTime updatedAt;
}
```
#### TimelineData (타임라인 데이터)
```java
@Entity
@Table(name = "timeline_data", indexes = {
@Index(name = "idx_event_timestamp", columnList = "event_id,timestamp")
})
public class TimelineData {
@Id @GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;
@Column(nullable = false)
private String eventId; // 이벤트 ID
@Column(nullable = false)
private LocalDateTime timestamp; // 시간대
private Integer participantCount = 0; // 참여자 수
private Integer cumulativeCount = 0; // 누적 참여자 수
@CreatedDate private LocalDateTime createdAt;
@LastModifiedDate private LocalDateTime updatedAt;
}
```
### 2.3 서비스 계층
#### AnalyticsService (대시보드 서비스)
- **기능**: 이벤트 성과 대시보드 데이터 통합 제공
- **캐싱**: Redis Cache-Aside 패턴, 1시간 TTL
- **캐시 키**: `analytics:dashboard:{eventId}`
- **데이터 통합**:
1. Analytics DB에서 이벤트/채널 통계 조회
2. 외부 채널 API 병렬 호출 (Circuit Breaker 적용)
3. 대시보드 데이터 구성
4. Redis 캐싱
**주요 메서드**:
```java
public AnalyticsDashboardResponse getDashboardData(
String eventId,
LocalDateTime startDate,
LocalDateTime endDate,
boolean refresh
)
```
#### ExternalChannelService (외부 API 연동)
- **기능**: 외부 채널 API 호출로 실시간 데이터 업데이트
- **패턴**: Circuit Breaker (Resilience4j)
- **지원 채널**: WooriTV, GenieTV, RingoBiz, SNS
- **병렬 처리**: CompletableFuture로 4개 채널 동시 호출
**Circuit Breaker 설정**:
- 실패율 임계값: 50%
- 대기 시간 (Open 상태): 30초
- 슬라이딩 윈도우: 10건
#### ROICalculator (ROI 계산)
- **기능**: 상세 ROI 계산 및 분석
- **투자 분류**:
- 콘텐츠 제작: 40%
- 배포 비용: 50%
- 운영 비용: 10%
- **수익 분류**:
- 직접 매출: 70%
- 간접 효과: 20%
- 브랜드 가치: 10%
- **효율성 지표**:
- CPA (Cost Per Acquisition): 참여자당 비용
- CPV (Cost Per View): 조회당 비용
- CPC (Cost Per Click): 클릭당 비용
### 2.4 컨트롤러 계층
#### 1. AnalyticsDashboardController
```java
@GetMapping("/{eventId}/analytics")
public ResponseEntity<ApiResponse<AnalyticsDashboardResponse>> getEventAnalytics(
@PathVariable String eventId,
@RequestParam(required = false) LocalDateTime startDate,
@RequestParam(required = false) LocalDateTime endDate,
@RequestParam(required = false, defaultValue = "false") Boolean refresh
)
```
#### 2. ChannelAnalyticsController
```java
@GetMapping("/{eventId}/analytics/channels")
public ResponseEntity<ApiResponse<ChannelAnalyticsResponse>> getChannelAnalytics(
@PathVariable String eventId,
@RequestParam(required = false, defaultValue = "participants") String sortBy
)
```
#### 3. TimelineAnalyticsController
```java
@GetMapping("/{eventId}/analytics/timeline")
public ResponseEntity<ApiResponse<TimelineAnalyticsResponse>> getTimelineAnalytics(
@PathVariable String eventId,
@RequestParam(required = false) LocalDateTime startDate,
@RequestParam(required = false) LocalDateTime endDate,
@RequestParam(required = false, defaultValue = "HOURLY") String granularity
)
```
#### 4. RoiAnalyticsController
```java
@GetMapping("/{eventId}/analytics/roi")
public ResponseEntity<ApiResponse<RoiAnalyticsResponse>> getRoiAnalytics(
@PathVariable String eventId,
@RequestParam(required = false, defaultValue = "false") Boolean includeProjection
)
```
### 2.5 Kafka Consumer
#### 1. EventCreatedConsumer
- **토픽**: `event.created`
- **기능**: 새 이벤트 생성 시 통계 테이블 초기화
- **처리 로직**:
```java
@KafkaListener(topics = "event.created", groupId = "analytics-service")
public void handleEventCreated(String message) {
// EventStats 초기 레코드 생성
EventStats eventStats = EventStats.builder()
.eventId(event.getEventId())
.eventTitle(event.getEventTitle())
.storeId(event.getStoreId())
.totalInvestment(event.getTotalBudget())
.build();
eventStatsRepository.save(eventStats);
}
```
#### 2. ParticipantRegisteredConsumer
- **토픽**: `participant.registered`
- **기능**: 참여자 등록 시 실시간 통계 업데이트
- **처리 로직**:
```java
@KafkaListener(topics = "participant.registered", groupId = "analytics-service")
public void handleParticipantRegistered(String message) {
// EventStats 참여자 수 증가
eventStats.incrementParticipants();
eventStatsRepository.save(eventStats);
// TimelineData 생성/업데이트
// 시간대별 참여자 추이 기록
}
```
#### 3. DistributionCompletedConsumer
- **토픽**: `distribution.completed`
- **기능**: 배포 완료 시 채널별 비용 업데이트
- **처리 로직**:
```java
@KafkaListener(topics = "distribution.completed", groupId = "analytics-service")
public void handleDistributionCompleted(String message) {
// ChannelStats 배포 비용 업데이트
channelStats.setDistributionCost(event.getDistributionCost());
channelStatsRepository.save(channelStats);
}
```
### 2.6 설정 파일
#### application.yml
```yaml
spring:
application:
name: analytics-service
# PostgreSQL 데이터베이스
datasource:
url: jdbc:postgresql://localhost:5432/analytics_db
username: analytics_user
password: analytics_pass
hikari:
maximum-pool-size: 20
minimum-idle: 5
# Redis 캐시 (database 5)
data:
redis:
host: localhost
port: 6379
database: 5
timeout: 2000ms
# Kafka
kafka:
bootstrap-servers: localhost:9092
consumer:
group-id: analytics-service
auto-offset-reset: earliest
# 서버 포트
server:
port: 8086
# Circuit Breaker
resilience4j:
circuitbreaker:
instances:
wooriTV:
failure-rate-threshold: 50
wait-duration-in-open-state: 30s
genieTV:
failure-rate-threshold: 50
wait-duration-in-open-state: 30s
ringoBiz:
failure-rate-threshold: 50
wait-duration-in-open-state: 30s
sns:
failure-rate-threshold: 50
wait-duration-in-open-state: 30s
```
---
## 3. API 명세
### 3.1 이벤트 성과 대시보드 조회
- **엔드포인트**: `GET /api/events/{eventId}/analytics`
- **파라미터**:
- `startDate` (선택): 조회 시작일
- `endDate` (선택): 조회 종료일
- `refresh` (선택, 기본값: false): 캐시 갱신 여부
- **응답**: AnalyticsDashboardResponse
- period: 기간 정보
- summary: 성과 요약 (참여자, 조회수, 도달률, 참여율, 전환율)
- channelPerformance: 채널별 성과 요약
- roi: ROI 요약
- lastUpdatedAt: 마지막 업데이트 시각
- dataSource: 데이터 출처 (cached/realtime)
### 3.2 채널별 성과 분석 조회
- **엔드포인트**: `GET /api/events/{eventId}/analytics/channels`
- **파라미터**:
- `sortBy` (선택, 기본값: participants): 정렬 기준
- **응답**: ChannelAnalyticsResponse
- channels: 채널별 상세 성과
- topPerformers: 상위 성과 채널 (조회수, 참여율, ROI 기준)
- comparison: 채널 간 비교 지표
### 3.3 타임라인 분석 조회
- **엔드포인트**: `GET /api/events/{eventId}/analytics/timeline`
- **파라미터**:
- `startDate` (선택): 조회 시작일
- `endDate` (선택): 조회 종료일
- `granularity` (선택, 기본값: HOURLY): 시간 단위
- **응답**: TimelineAnalyticsResponse
- dataPoints: 시간대별 데이터 포인트
- trends: 트렌드 분석 (성장률, 방향)
- peakTimes: 피크 시간대 정보
- timeRangeStats: 시간대별 통계
### 3.4 ROI 상세 분석 조회
- **엔드포인트**: `GET /api/events/{eventId}/analytics/roi`
- **파라미터**:
- `includeProjection` (선택, 기본값: false): 예측 포함 여부
- **응답**: RoiAnalyticsResponse
- summary: ROI 요약 (총 ROI, 투자액, 수익)
- investment: 투자 내역 (콘텐츠, 배포, 운영)
- revenue: 수익 내역 (직접 매출, 간접 효과, 브랜드 가치)
- costAnalysis: 비용 효율성 분석 (CPA, CPV, CPC)
- conversionFunnel: 전환 퍼널 (조회 → 클릭 → 참여 → 전환)
- projection: ROI 예측 (선택)
---
## 4. 데이터베이스 스키마
### 4.1 event_stats (이벤트 통계)
```sql
CREATE TABLE event_stats (
id BIGSERIAL PRIMARY KEY,
event_id VARCHAR(255) NOT NULL UNIQUE,
event_title VARCHAR(500),
store_id VARCHAR(255),
total_participants INT DEFAULT 0,
estimated_roi DECIMAL(10,2) DEFAULT 0,
total_investment DECIMAL(15,2) DEFAULT 0,
created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);
```
### 4.2 channel_stats (채널별 통계)
```sql
CREATE TABLE channel_stats (
id BIGSERIAL PRIMARY KEY,
event_id VARCHAR(255) NOT NULL,
channel_name VARCHAR(50) NOT NULL,
views INT DEFAULT 0,
clicks INT DEFAULT 0,
participants INT DEFAULT 0,
conversions INT DEFAULT 0,
impressions INT DEFAULT 0,
likes INT DEFAULT 0,
comments INT DEFAULT 0,
shares INT DEFAULT 0,
distribution_cost DECIMAL(15,2) DEFAULT 0,
created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);
CREATE INDEX idx_event_id ON channel_stats(event_id);
CREATE INDEX idx_event_channel ON channel_stats(event_id, channel_name);
```
### 4.3 timeline_data (타임라인 데이터)
```sql
CREATE TABLE timeline_data (
id BIGSERIAL PRIMARY KEY,
event_id VARCHAR(255) NOT NULL,
timestamp TIMESTAMP NOT NULL,
participant_count INT DEFAULT 0,
cumulative_count INT DEFAULT 0,
created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);
CREATE INDEX idx_event_timestamp ON timeline_data(event_id, timestamp);
```
---
## 5. 빌드 및 테스트
### 5.1 빌드 결과
```
./gradlew analytics-service:build
BUILD SUCCESSFUL in 19s
10 actionable tasks: 6 executed, 4 up-to-date
```
### 5.2 컴파일 결과
```
./gradlew analytics-service:compileJava
BUILD SUCCESSFUL in 14s
```
### 5.3 생성된 아티팩트
- **JAR 파일**: `analytics-service/build/libs/analytics-service.jar`
- **Boot JAR 파일**: `analytics-service/build/libs/analytics-service-boot.jar`
---
## 6. 실행 방법
### 6.1 사전 준비
1. PostgreSQL 실행 (포트: 5432)
- 데이터베이스: analytics_db
- 사용자: analytics_user
2. Redis 실행 (포트: 6379)
- Database: 5
3. Kafka 실행 (포트: 9092)
- 토픽: event.created, participant.registered, distribution.completed
### 6.2 환경 변수 설정
```bash
# 데이터베이스
DB_HOST=localhost
DB_PORT=5432
DB_NAME=analytics_db
DB_USERNAME=analytics_user
DB_PASSWORD=analytics_pass
# Redis
REDIS_HOST=localhost
REDIS_PORT=6379
REDIS_DATABASE=5
# Kafka
KAFKA_BOOTSTRAP_SERVERS=localhost:9092
# 서버
SERVER_PORT=8086
# JWT (common 모듈과 공유)
JWT_SECRET=your-secret-key
```
### 6.3 서비스 실행
```bash
java -jar analytics-service/build/libs/analytics-service-boot.jar
```
### 6.4 헬스 체크
```bash
curl http://localhost:8086/actuator/health
```
### 6.5 API 문서 확인
- Swagger UI: http://localhost:8086/swagger-ui.html
- OpenAPI Spec: http://localhost:8086/v3/api-docs
---
## 7. 아키텍처 특징
### 7.1 캐싱 전략
- **패턴**: Cache-Aside (Lazy Loading)
- **저장소**: Redis Database 5
- **TTL**: 3600초 (1시간)
- **캐시 키 형식**: `analytics:dashboard:{eventId}`
- **직렬화**: JSON (ObjectMapper)
- **갱신 방법**: `refresh=true` 파라미터로 강제 갱신
### 7.2 외부 API 연동
- **패턴**: Circuit Breaker (Resilience4j)
- **병렬 처리**: CompletableFuture로 4개 채널 동시 호출
- **실패 처리**: Fallback 메서드로 기본값 반환
- **재시도**: Circuit Breaker 상태에 따라 자동 재시도
### 7.3 실시간 데이터 갱신
- **메시징**: Kafka Consumer
- **이벤트 소싱**: 3개 토픽 구독
- **처리 방식**:
1. EventCreated → 통계 초기화
2. ParticipantRegistered → 실시간 카운트 증가
3. DistributionCompleted → 비용 업데이트
### 7.4 성능 최적화
1. **데이터베이스 인덱스**:
- event_stats: event_id (UNIQUE)
- channel_stats: event_id, (event_id, channel_name)
- timeline_data: (event_id, timestamp)
2. **캐싱**:
- 대시보드 데이터 1시간 캐싱
- 외부 API 호출 최소화
3. **병렬 처리**:
- 4개 외부 채널 API 동시 호출
- CompletableFuture.allOf()로 대기 시간 단축
4. **커넥션 풀**:
- HikariCP (최대: 20, 최소: 5)
- 유휴 타임아웃: 10분
- 최대 수명: 30분
---
## 8. 보안
### 8.1 인증
- **방식**: JWT Bearer Token
- **공유**: common 모듈의 JwtAuthenticationFilter 사용
- **토큰 검증**: 모든 API 엔드포인트에 적용
- **예외**: Actuator 헬스 체크, Swagger UI
### 8.2 CORS
- **허용 Origin**: 환경 변수로 설정 (`CORS_ALLOWED_ORIGINS`)
- **기본값**: `http://localhost:*`
- **허용 메서드**: GET, POST, PUT, DELETE, OPTIONS
- **허용 헤더**: Authorization, Content-Type
---
## 9. 모니터링
### 9.1 Spring Boot Actuator
- **엔드포인트**: `/actuator`
- **노출 항목**: health, info, metrics, prometheus
- **헬스 체크**:
- Liveness: `/actuator/health/liveness`
- Readiness: `/actuator/health/readiness`
### 9.2 로깅
- **레벨**:
- 애플리케이션: DEBUG
- Spring Web: INFO
- Hibernate SQL: DEBUG
- Hibernate Type: TRACE
- **출력**:
- 콘솔: `%d{yyyy-MM-dd HH:mm:ss} - %msg%n`
- 파일: `logs/analytics-service.log`
---
## 10. 개발 표준 준수
### 10.1 패키지 구조
- Layered Architecture 패턴 적용
- Controller → Service → Repository → Entity 계층 분리
- DTO 별도 패키지로 관리
### 10.2 주석 표준
- 모든 클래스, 메서드에 한글 JavaDoc 주석
- 비즈니스 로직 핵심 부분 인라인 주석
### 10.3 코딩 컨벤션
- Lombok 활용 (Builder, Getter, Setter, NoArgsConstructor, AllArgsConstructor)
- JPA Auditing (@CreatedDate, @LastModifiedDate)
- 불변 객체 지향 (DTO는 @Builder로 생성)
---
## 11. 향후 개선 사항
### 11.1 기능 개선
1. **배치 작업**: 매일 자정 통계 집계 배치
2. **알림**: ROI 목표 달성 시 알림 발송
3. **예측 모델**: ML 기반 ROI 예측 정확도 향상
4. **A/B 테스트**: 채널별 전략 A/B 테스트 지원
### 11.2 성능 개선
1. **읽기 전용 DB**: 조회 성능 향상을 위한 Read Replica
2. **캐시 워밍**: 서비스 시작 시 자주 조회되는 데이터 사전 캐싱
3. **비동기 처리**: 무거운 집계 작업 비동기화
### 11.3 운영 개선
1. **메트릭 수집**: Prometheus + Grafana 대시보드
2. **분산 추적**: OpenTelemetry 적용
3. **로그 집중화**: ELK 스택 연동
---
## 12. 결론
Analytics 서비스는 이벤트 성과를 실시간으로 분석하고 ROI를 계산하는 핵심 서비스로, 다음과 같은 특징을 가집니다:
1. **실시간성**: Kafka를 통한 실시간 데이터 갱신
2. **성능**: Redis 캐싱 + 병렬 외부 API 호출로 응답 시간 최소화
3. **안정성**: Circuit Breaker 패턴으로 외부 API 장애 격리
4. **확장성**: Layered Architecture로 기능 확장 용이
5. **표준 준수**: 백엔드 개발 가이드 표준 완벽 적용
빌드와 컴파일이 모두 성공적으로 완료되어, 서비스 실행 준비가 완료되었습니다.
+152
View File
@@ -0,0 +1,152 @@
# AI Service 패키지 구조도
## 프로젝트 구조
```
ai-service/
├── src/
│ ├── main/
│ │ ├── java/
│ │ │ └── com/
│ │ │ └── kt/
│ │ │ └── ai/
│ │ │ ├── AiServiceApplication.java
│ │ │ │
│ │ │ ├── controller/
│ │ │ │ ├── HealthController.java
│ │ │ │ ├── InternalJobController.java
│ │ │ │ └── InternalRecommendationController.java
│ │ │ │
│ │ │ ├── service/
│ │ │ │ ├── AIRecommendationService.java
│ │ │ │ ├── TrendAnalysisService.java
│ │ │ │ ├── JobStatusService.java
│ │ │ │ └── CacheService.java
│ │ │ │
│ │ │ ├── kafka/
│ │ │ │ ├── consumer/
│ │ │ │ │ └── AIJobConsumer.java
│ │ │ │ └── message/
│ │ │ │ ├── AIJobMessage.java
│ │ │ │ └── JobStatusMessage.java
│ │ │ │
│ │ │ ├── client/
│ │ │ │ ├── ClaudeApiClient.java
│ │ │ │ ├── Gpt4ApiClient.java
│ │ │ │ ├── dto/
│ │ │ │ │ ├── ClaudeRequest.java
│ │ │ │ │ ├── ClaudeResponse.java
│ │ │ │ │ ├── Gpt4Request.java
│ │ │ │ │ └── Gpt4Response.java
│ │ │ │ └── config/
│ │ │ │ └── FeignClientConfig.java
│ │ │ │
│ │ │ ├── model/
│ │ │ │ ├── dto/
│ │ │ │ │ ├── request/
│ │ │ │ │ │ └── (No request DTOs - internal API only)
│ │ │ │ │ └── response/
│ │ │ │ │ ├── HealthCheckResponse.java
│ │ │ │ │ ├── JobStatusResponse.java
│ │ │ │ │ ├── AIRecommendationResult.java
│ │ │ │ │ ├── TrendAnalysis.java
│ │ │ │ │ ├── EventRecommendation.java
│ │ │ │ │ ├── ExpectedMetrics.java
│ │ │ │ │ └── ErrorResponse.java
│ │ │ │ └── enums/
│ │ │ │ ├── JobStatus.java
│ │ │ │ ├── AIProvider.java
│ │ │ │ ├── EventMechanicsType.java
│ │ │ │ └── ServiceStatus.java
│ │ │ │
│ │ │ ├── config/
│ │ │ │ ├── RedisConfig.java
│ │ │ │ ├── KafkaConsumerConfig.java
│ │ │ │ ├── CircuitBreakerConfig.java
│ │ │ │ ├── SecurityConfig.java
│ │ │ │ └── SwaggerConfig.java
│ │ │ │
│ │ │ ├── circuitbreaker/
│ │ │ │ ├── CircuitBreakerManager.java
│ │ │ │ └── fallback/
│ │ │ │ └── AIServiceFallback.java
│ │ │ │
│ │ │ └── exception/
│ │ │ ├── GlobalExceptionHandler.java
│ │ │ ├── JobNotFoundException.java
│ │ │ ├── RecommendationNotFoundException.java
│ │ │ ├── CircuitBreakerOpenException.java
│ │ │ └── AIServiceException.java
│ │ │
│ │ └── resources/
│ │ ├── application.yml
│ │ └── logback-spring.xml
│ │
│ └── test/
│ └── java/
│ └── com/
│ └── kt/
│ └── ai/
│ └── (테스트 코드는 작성하지 않음)
├── build.gradle
└── README.md
```
## 아키텍처 패턴
- **Layered Architecture** 적용
- Controller → Service → Client/Kafka 레이어 구조
- Service 레이어에 Interface 사용하지 않음 (내부 API 전용 서비스)
## 주요 컴포넌트 설명
### 1. Controller Layer
- **HealthController**: 서비스 상태 및 외부 연동 확인
- **InternalJobController**: Job 상태 조회 (Event Service에서 호출)
- **InternalRecommendationController**: AI 추천 결과 조회 (Event Service에서 호출)
### 2. Service Layer
- **AIRecommendationService**: AI 트렌드 분석 및 이벤트 추천 총괄
- **TrendAnalysisService**: 업종/지역/시즌 트렌드 분석
- **JobStatusService**: Job 상태 관리 (Redis 기반)
- **CacheService**: Redis 캐싱 처리
### 3. Kafka Layer
- **AIJobConsumer**: Kafka ai-event-generation-job Topic 구독 및 처리
- **AIJobMessage**: Kafka 메시지 DTO
- **JobStatusMessage**: Job 상태 변경 메시지
### 4. Client Layer
- **ClaudeApiClient**: Claude API 연동 (Feign Client)
- **Gpt4ApiClient**: GPT-4 API 연동 (Feign Client - 선택)
- **FeignClientConfig**: Feign Client 공통 설정
### 5. Model Layer
- **Response DTOs**: API 응답 객체
- **Enums**: 상태 및 타입 정의
### 6. Config Layer
- **RedisConfig**: Redis 연결 및 캐싱 설정
- **KafkaConsumerConfig**: Kafka Consumer 설정
- **CircuitBreakerConfig**: Resilience4j Circuit Breaker 설정
- **SecurityConfig**: Spring Security 설정
- **SwaggerConfig**: API 문서화 설정
### 7. Circuit Breaker Layer
- **CircuitBreakerManager**: Circuit Breaker 실행 및 관리
- **AIServiceFallback**: AI API 장애 시 Fallback 처리
### 8. Exception Layer
- **GlobalExceptionHandler**: 전역 예외 처리
- **Custom Exceptions**: 서비스별 예외 정의
## 외부 연동
- **Redis**: 작업 상태 및 추천 결과 캐싱 (TTL 24시간)
- **Kafka**: ai-event-generation-job Topic 구독
- **Claude API / GPT-4 API**: AI 트렌드 분석 및 추천 생성
- **PostgreSQL**: (미사용 - AI Service는 DB 불필요)
## 특이사항
- AI Service는 데이터베이스를 사용하지 않음 (Redis만 사용)
- 모든 상태와 결과는 Redis에 저장 (TTL 24시간)
- Kafka Consumer를 통한 비동기 작업 처리
- Circuit Breaker를 통한 외부 API 장애 대응
+153
View File
@@ -0,0 +1,153 @@
# Analytics Service 패키지 구조도
```
analytics-service/
├── src/
│ ├── main/
│ │ ├── java/
│ │ │ └── com/
│ │ │ └── kt/
│ │ │ └── event/
│ │ │ └── analytics/
│ │ │ ├── AnalyticsServiceApplication.java
│ │ │ │
│ │ │ ├── controller/
│ │ │ │ ├── AnalyticsDashboardController.java
│ │ │ │ ├── ChannelAnalyticsController.java
│ │ │ │ ├── TimelineAnalyticsController.java
│ │ │ │ └── RoiAnalyticsController.java
│ │ │ │
│ │ │ ├── service/
│ │ │ │ ├── AnalyticsService.java
│ │ │ │ ├── ChannelAnalyticsService.java
│ │ │ │ ├── TimelineAnalyticsService.java
│ │ │ │ ├── RoiAnalyticsService.java
│ │ │ │ ├── ExternalChannelService.java
│ │ │ │ └── ROICalculator.java
│ │ │ │
│ │ │ ├── repository/
│ │ │ │ ├── EventStatsRepository.java
│ │ │ │ ├── ChannelStatsRepository.java
│ │ │ │ └── TimelineDataRepository.java
│ │ │ │
│ │ │ ├── entity/
│ │ │ │ ├── EventStats.java
│ │ │ │ ├── ChannelStats.java
│ │ │ │ └── TimelineData.java
│ │ │ │
│ │ │ ├── dto/
│ │ │ │ ├── request/
│ │ │ │ │ └── (쿼리 파라미터는 Controller에서 직접 처리)
│ │ │ │ │
│ │ │ │ └── response/
│ │ │ │ ├── AnalyticsDashboardResponse.java
│ │ │ │ ├── ChannelAnalyticsResponse.java
│ │ │ │ ├── TimelineAnalyticsResponse.java
│ │ │ │ ├── RoiAnalyticsResponse.java
│ │ │ │ ├── ChannelSummary.java
│ │ │ │ ├── ChannelAnalytics.java
│ │ │ │ ├── ChannelMetrics.java
│ │ │ │ ├── ChannelPerformance.java
│ │ │ │ ├── ChannelCosts.java
│ │ │ │ ├── ChannelComparison.java
│ │ │ │ ├── TimelineDataPoint.java
│ │ │ │ ├── TrendAnalysis.java
│ │ │ │ ├── PeakTimeInfo.java
│ │ │ │ ├── InvestmentDetails.java
│ │ │ │ ├── RevenueDetails.java
│ │ │ │ ├── RoiCalculation.java
│ │ │ │ ├── CostEfficiency.java
│ │ │ │ ├── RevenueProjection.java
│ │ │ │ ├── PeriodInfo.java
│ │ │ │ ├── AnalyticsSummary.java
│ │ │ │ ├── SocialInteractionStats.java
│ │ │ │ ├── VoiceCallStats.java
│ │ │ │ └── RoiSummary.java
│ │ │ │
│ │ │ ├── messaging/
│ │ │ │ ├── consumer/
│ │ │ │ │ ├── EventCreatedConsumer.java
│ │ │ │ │ ├── ParticipantRegisteredConsumer.java
│ │ │ │ │ └── DistributionCompletedConsumer.java
│ │ │ │ │
│ │ │ │ └── event/
│ │ │ │ ├── EventCreatedEvent.java
│ │ │ │ ├── ParticipantRegisteredEvent.java
│ │ │ │ └── DistributionCompletedEvent.java
│ │ │ │
│ │ │ ├── client/
│ │ │ │ ├── WooriTVClient.java
│ │ │ │ ├── GenieTVClient.java
│ │ │ │ ├── RingoBizClient.java
│ │ │ │ └── SNSClient.java
│ │ │ │
│ │ │ └── config/
│ │ │ ├── SecurityConfig.java
│ │ │ ├── SwaggerConfig.java
│ │ │ ├── RedisConfig.java
│ │ │ ├── KafkaConsumerConfig.java
│ │ │ ├── FeignConfig.java
│ │ │ └── Resilience4jConfig.java
│ │ │
│ │ └── resources/
│ │ ├── application.yml
│ │ └── logback-spring.xml
│ │
│ └── test/
│ └── java/
│ └── com/
│ └── kt/
│ └── event/
│ └── analytics/
│ └── (테스트 코드 - 현재 단계에서는 작성하지 않음)
└── build.gradle
```
## 패키지 설명
### controller
- **AnalyticsDashboardController**: 통합 대시보드 조회 API
- **ChannelAnalyticsController**: 채널별 성과 분석 API
- **TimelineAnalyticsController**: 시간대별 추이 분석 API
- **RoiAnalyticsController**: ROI 상세 분석 API
### service
- **AnalyticsService**: 대시보드 데이터 통합 및 조회
- **ChannelAnalyticsService**: 채널별 분석 로직
- **TimelineAnalyticsService**: 시간대별 분석 로직
- **RoiAnalyticsService**: ROI 계산 및 분석 로직
- **ExternalChannelService**: 외부 채널 API 호출 및 Circuit Breaker 적용
- **ROICalculator**: ROI 계산 유틸리티
### repository
- **EventStatsRepository**: 이벤트 통계 데이터 저장소
- **ChannelStatsRepository**: 채널별 통계 데이터 저장소
- **TimelineDataRepository**: 시간대별 데이터 저장소
### entity
- **EventStats**: 이벤트 통계 엔티티
- **ChannelStats**: 채널 통계 엔티티
- **TimelineData**: 시간대별 데이터 엔티티
### dto/response
- API 응답 DTO 클래스들
### messaging
- **consumer**: Kafka Event Consumer 클래스
- **event**: Kafka Event DTO 클래스
### client
- **FeignClient**: 외부 API 연동 클라이언트 (우리동네TV, 지니TV, 링고비즈, SNS)
### config
- **SecurityConfig**: Spring Security 설정
- **SwaggerConfig**: Swagger/OpenAPI 설정
- **RedisConfig**: Redis 캐시 설정
- **KafkaConsumerConfig**: Kafka Consumer 설정
- **FeignConfig**: OpenFeign 설정
- **Resilience4jConfig**: Circuit Breaker 설정
## 아키텍처 패턴
- **Layered Architecture** 적용
- Service 계층에 Interface 사용
+561
View File
@@ -0,0 +1,561 @@
# Analytics 서비스 샘플 데이터 가이드
## 1. 개요
Analytics 서비스는 애플리케이션 시작 시 대시보드 테스트를 위한 샘플 데이터를 자동으로 적재합니다.
### 1.1 적용 환경
- **개발 환경 (dev)**: 자동 적재
- **로컬 환경 (local)**: 자동 적재
- **운영 환경 (prod)**: 적재 안 함
### 1.2 구현 클래스
- **파일**: `SampleDataLoader.java`
- **위치**: `analytics-service/src/main/java/com/kt/event/analytics/config/`
- **실행 시점**: 애플리케이션 시작 시 자동 실행 (`ApplicationRunner`)
---
## 2. 샘플 데이터 구성
### 2.1 이벤트 통계 데이터 (EventStats)
총 **3개 이벤트**가 생성됩니다:
#### 이벤트 1: 신년맞이 20% 할인 이벤트
```json
{
"eventId": "evt_2025012301",
"eventTitle": "신년맞이 20% 할인 이벤트",
"storeId": "store_001",
"totalParticipants": 15420,
"estimatedRoi": 280.5,
"totalInvestment": 5000000
}
```
**특징**: 높은 성과, 진행 중 이벤트
#### 이벤트 2: 설날 특가 선물세트 이벤트
```json
{
"eventId": "evt_2025020101",
"eventTitle": "설날 특가 선물세트 이벤트",
"storeId": "store_001",
"totalParticipants": 8950,
"estimatedRoi": 185.3,
"totalInvestment": 3500000
}
```
**특징**: 중간 성과, 진행 중 이벤트
#### 이벤트 3: 겨울 신메뉴 런칭 이벤트
```json
{
"eventId": "evt_2025011501",
"eventTitle": "겨울 신메뉴 런칭 이벤트",
"storeId": "store_001",
"totalParticipants": 3240,
"estimatedRoi": 95.5,
"totalInvestment": 2000000
}
```
**특징**: 저조한 성과, 종료된 이벤트
---
### 2.2 채널별 통계 데이터 (ChannelStats)
각 이벤트당 **4개 채널** 데이터가 생성됩니다 (총 12건):
#### 채널 구성
| 채널명 | 참여자 비율 | 비용 비율 | 특징 |
|--------|------------|----------|------|
| 우리동네TV | 35% | 30% | 조회수 많음, 참여율 중간 |
| 지니TV | 30% | 30% | 조회수 중간, 참여율 높음 |
| 링고비즈 | 20% | 20% | 통화 기반, 높은 전환율 |
| SNS | 15% | 20% | 바이럴 효과, 높은 도달률 |
#### 채널별 지표 생성 로직
**1. 우리동네TV**:
- 조회수: 참여자의 8~12배
- 클릭수: 조회수의 15~25%
- 전환수: 참여자의 30~50%
- SNS 반응: 낮음 (참여자의 30~50%)
**2. 지니TV**:
- 조회수: 참여자의 8~12배
- 클릭수: 조회수의 15~25%
- 전환수: 참여자의 30~50%
- SNS 반응: 낮음 (참여자의 30~50%)
**3. 링고비즈**:
- 조회수: 참여자의 8~12배
- 클릭수: 조회수의 15~25%
- 전환수: 참여자의 30~50%
- SNS 반응: 없음 (통화 중심 채널)
**4. SNS**:
- 조회수: 참여자의 8~12배
- 클릭수: 조회수의 15~25%
- 전환수: 참여자의 30~50%
- **SNS 반응 (특화)**:
- 좋아요: 참여자의 2~3배
- 댓글: 참여자의 50~80%
- 공유: 참여자의 80~120%
#### 샘플 채널 데이터 예시
```json
{
"eventId": "evt_2025012301",
"channelName": "우리동네TV",
"views": 45000,
"clicks": 8900,
"participants": 5500,
"conversions": 1850,
"impressions": 98500,
"likes": 1800,
"comments": 350,
"shares": 650,
"distributionCost": 1500000
}
```
---
### 2.3 타임라인 데이터 (TimelineData)
각 이벤트당 **180개 데이터 포인트** 생성 (총 540건):
- 기간: 최근 30일
- 간격: 4시간 단위 (하루 6개 데이터 포인트)
#### 시간대별 가중치
| 시간대 | 시간 범위 | 가중치 | 설명 |
|--------|----------|--------|------|
| 새벽 | 00:00 ~ 05:59 | 1x | 낮은 참여 |
| 아침 | 06:00 ~ 11:59 | 2x | 높은 참여 |
| 점심~오후 | 12:00 ~ 17:59 | 3x | **가장 높은 참여** |
| 저녁 | 18:00 ~ 23:59 | 2x | 높은 참여 |
#### 데이터 생성 로직
1. **점진적 증가**: 30일 동안 참여자 수가 점진적으로 증가
2. **시간대 변동**: 시간대별 가중치 적용 (점심~오후가 가장 활발)
3. **랜덤 변동**: ±20% 랜덤 변동으로 자연스러운 패턴 구현
4. **누적 카운트**: 시간이 지남에 따라 누적 참여자 증가
#### 샘플 타임라인 데이터 예시
```json
{
"eventId": "evt_2025012301",
"timestamp": "2025-01-23T14:00:00",
"participants": 450,
"views": 3500,
"engagement": 280,
"conversions": 45,
"cumulativeParticipants": 5450
}
```
---
## 3. 데이터 적재 프로세스
### 3.1 실행 흐름
```
애플리케이션 시작
Profile 확인 (dev/local만 실행)
기존 데이터 확인
데이터 없음 → 샘플 데이터 생성
데이터 있음 → 건너뛰기
1. EventStats 생성 (3건)
2. ChannelStats 생성 (12건)
3. TimelineData 생성 (540건)
데이터베이스 저장
로그 출력 (테스트 가능한 이벤트 목록)
```
### 3.2 로그 출력 예시
```
========================================
샘플 데이터 적재 시작
========================================
이벤트 통계 데이터 적재 완료: 3 건
채널별 통계 데이터 적재 완료: 12 건
타임라인 데이터 적재 완료: 540 건
========================================
샘플 데이터 적재 완료!
========================================
테스트 가능한 이벤트:
- 신년맞이 20% 할인 이벤트 (ID: evt_2025012301)
- 설날 특가 선물세트 이벤트 (ID: evt_2025020101)
- 겨울 신메뉴 런칭 이벤트 (ID: evt_2025011501)
========================================
```
---
## 4. API 테스트 방법
### 4.1 성과 대시보드 조회
#### 요청
```bash
GET http://localhost:8086/api/events/evt_2025012301/analytics
Authorization: Bearer {JWT_TOKEN}
```
#### 예상 응답
```json
{
"success": true,
"data": {
"eventId": "evt_2025012301",
"eventTitle": "신년맞이 20% 할인 이벤트",
"period": {
"startDate": "2025-01-01T00:00:00",
"endDate": "2025-01-31T23:59:59",
"durationDays": 30
},
"summary": {
"totalParticipants": 15420,
"totalViews": 125300,
"totalReach": 98500,
"engagementRate": 12.3,
"conversionRate": 3.8,
"averageEngagementTime": 145,
"socialInteractions": {
"likes": 3450,
"comments": 890,
"shares": 1250
}
},
"channelPerformance": [
{
"channelName": "우리동네TV",
"views": 45000,
"participants": 5500,
"engagementRate": 12.2,
"conversionRate": 4.1,
"roi": 280.5
}
],
"roi": {
"totalInvestment": 5000000,
"expectedRevenue": 19025000,
"netProfit": 14025000,
"roi": 280.5,
"costPerAcquisition": 324.35
},
"lastUpdatedAt": "2025-01-24T10:30:00",
"dataSource": "cached"
}
}
```
### 4.2 채널별 성과 분석
#### 요청
```bash
GET http://localhost:8086/api/events/evt_2025012301/analytics/channels?sortBy=roi
Authorization: Bearer {JWT_TOKEN}
```
#### 예상 응답
```json
{
"success": true,
"data": {
"eventId": "evt_2025012301",
"channels": [
{
"channelName": "우리동네TV",
"views": 45000,
"participants": 5500,
"engagementRate": 12.2,
"roi": 295.3
},
{
"channelName": "지니TV",
"views": 38000,
"participants": 4600,
"engagementRate": 13.5,
"roi": 285.7
}
],
"topPerformers": {
"byViews": "우리동네TV",
"byEngagement": "지니TV",
"byRoi": "링고비즈"
},
"comparison": {
"averageMetrics": {
"engagementRate": 11.5,
"conversionRate": 3.9,
"roi": 275.8
}
}
}
}
```
### 4.3 시간대별 참여 추이
#### 요청
```bash
GET http://localhost:8086/api/events/evt_2025012301/analytics/timeline?interval=daily
Authorization: Bearer {JWT_TOKEN}
```
#### 예상 응답
```json
{
"success": true,
"data": {
"eventId": "evt_2025012301",
"interval": "daily",
"dataPoints": [
{
"timestamp": "2025-01-15T00:00:00",
"participants": 450,
"views": 3500,
"engagement": 280,
"conversions": 45,
"cumulativeParticipants": 5450
}
],
"trends": {
"overallTrend": "increasing",
"growthRate": 15.3,
"projectedParticipants": 18500
},
"peakTimes": [
{
"timestamp": "2025-01-15T14:00:00",
"metric": "participants",
"value": 1250,
"description": "주말 오후 최대 참여"
}
]
}
}
```
### 4.4 ROI 상세 분석
#### 요청
```bash
GET http://localhost:8086/api/events/evt_2025012301/analytics/roi?includeProjection=true
Authorization: Bearer {JWT_TOKEN}
```
#### 예상 응답
```json
{
"success": true,
"data": {
"eventId": "evt_2025012301",
"investment": {
"contentCreation": 2000000,
"distribution": 2500000,
"operation": 500000,
"total": 5000000
},
"revenue": {
"directSales": 12500000,
"expectedSales": 6525000,
"brandValue": 3000000,
"total": 19025000
},
"roi": {
"netProfit": 14025000,
"roiPercentage": 280.5,
"breakEvenPoint": "2025-01-10T15:30:00",
"paybackPeriod": 9
},
"costEfficiency": {
"costPerParticipant": 324.35,
"costPerConversion": 850.34,
"costPerView": 39.90,
"revenuePerParticipant": 1234.25
},
"projection": {
"currentRevenue": 12500000,
"projectedFinalRevenue": 21000000,
"confidenceLevel": 85.5,
"basedOn": "현재 추세 및 과거 유사 이벤트 데이터"
}
}
}
```
---
## 5. 데이터 초기화 방법
### 5.1 샘플 데이터 재생성
1. **데이터베이스 초기화**:
```sql
TRUNCATE TABLE timeline_data;
TRUNCATE TABLE channel_stats;
TRUNCATE TABLE event_stats;
```
2. **애플리케이션 재시작**:
```bash
# 서비스 중지
# 서비스 시작
```
3. **자동 재적재**: 애플리케이션 시작 시 자동으로 샘플 데이터 재생성
### 5.2 프로파일별 동작
#### dev/local 프로파일
```yaml
spring:
profiles:
active: dev # 또는 local
```
→ 샘플 데이터 **자동 적재**
#### prod 프로파일
```yaml
spring:
profiles:
active: prod
```
→ 샘플 데이터 **적재 안 함**
---
## 6. 커스터마이징 가이드
### 6.1 이벤트 추가
`SampleDataLoader.java`의 `createEventStats()` 메서드에 이벤트 추가:
```java
eventStatsList.add(EventStats.builder()
.eventId("evt_2025030101")
.eventTitle("3월 신학기 이벤트")
.storeId("store_001")
.totalParticipants(12000)
.estimatedRoi(new BigDecimal("220.0"))
.totalInvestment(new BigDecimal("4000000"))
.build());
```
### 6.2 채널 추가
`createChannelStats()` 메서드에 채널 추가:
```java
// 5. 모바일 앱 추가
channelStatsList.add(createChannelStats(
eventId,
"모바일앱",
(int) (totalParticipants * 0.25), // 참여자: 25%
distributionBudget.multiply(new BigDecimal("0.15")), // 비용: 15%
2.8 // 조회수 대비 참여자 비율
));
```
### 6.3 타임라인 간격 변경
현재: 4시간 단위 (하루 6개)
```java
for (int hour = 0; hour < 24; hour += 4) {
```
변경: 1시간 단위 (하루 24개)
```java
for (int hour = 0; hour < 24; hour += 1) {
```
---
## 7. 주의사항
### 7.1 데이터 중복 방지
- `SampleDataLoader`는 기존 데이터가 있으면 적재를 건너뜁니다.
- 확인 로직: `eventStatsRepository.count() > 0`
### 7.2 프로파일 설정 필수
- **운영 환경**에서는 반드시 `prod` 프로파일 사용
- 샘플 데이터가 운영 DB에 적재되지 않도록 주의
### 7.3 성능 고려사항
- 샘플 데이터: 총 555건 (EventStats 3 + ChannelStats 12 + TimelineData 540)
- 적재 시간: 약 1~2초 (데이터베이스 성능에 따라 다름)
---
## 8. 트러블슈팅
### 8.1 샘플 데이터가 적재되지 않음
**원인 1**: 프로파일이 prod로 설정됨
```yaml
spring:
profiles:
active: prod # ❌ 샘플 데이터 적재 안 함
```
**해결**: dev 또는 local로 변경
```yaml
spring:
profiles:
active: dev # ✅ 샘플 데이터 적재
```
**원인 2**: 기존 데이터가 이미 존재
- 확인: `SELECT COUNT(*) FROM event_stats;`
- 해결: 데이터 초기화 후 재시작
### 8.2 컴파일 오류
**원인**: Entity 필드명 불일치
- `TimelineData` 엔티티의 실제 필드명 확인 필요
- `participantCount` → `participants`
- `cumulativeCount` → `cumulativeParticipants`
---
## 9. 결론
### 9.1 구현 완료 사항
- ✅ 3개 이벤트 샘플 데이터 자동 생성
- ✅ 12개 채널별 통계 데이터 생성
- ✅ 540개 타임라인 데이터 생성 (30일, 4시간 단위)
- ✅ 시간대별 가중치 적용
- ✅ SNS 반응 데이터 생성
- ✅ 프로파일별 자동 적재 제어 (dev/local만)
### 9.2 테스트 가능한 시나리오
1. **높은 성과 이벤트**: evt_2025012301
2. **중간 성과 이벤트**: evt_2025020101
3. **저조한 성과 이벤트**: evt_2025011501
### 9.3 다음 단계
1. 서비스 시작 후 로그 확인
2. 대시보드 API 호출 테스트
3. 각 채널별 성과 분석 테스트
4. 시간대별 추이 분석 테스트
5. ROI 계산 정확도 검증
---
**작성자**: AI Backend Developer
**최종 수정일**: 2025-01-24
**버전**: 1.0.0
@@ -0,0 +1,389 @@
# AI Service Kafka-Redis 통합 테스트 결과 보고서
**테스트 일시**: 2025-10-27 16:00 ~ 16:10
**테스터**: AI 개발 팀
**테스트 환경**: 개발 환경 (ai-service 실행 중)
---
## 1. 테스트 개요
### 1.1 테스트 목적
AI Service의 Kafka Consumer와 Redis 연동이 정상적으로 동작하는지 검증
### 1.2 테스트 범위
- Kafka 메시지 수신 (AIJobConsumer)
- Redis 캐시 저장/조회 (Job Status, AI Recommendation)
- 트렌드 분석 캐싱
- API 엔드포인트 동작 확인
- Circuit Breaker 폴백 동작
### 1.3 테스트 시나리오
```
1. Kafka Producer → 메시지 전송 (3건)
2. AI Service Consumer → 메시지 수신 및 처리
3. Redis → Job Status 저장
4. Redis → AI Recommendation 결과 저장
5. API → Redis에서 데이터 조회
```
---
## 2. 테스트 환경 설정
### 2.1 Kafka 설정
```yaml
bootstrap-servers: 20.249.182.13:9095,4.217.131.59:9095
topic: ai-event-generation-job
consumer-group: ai-service-consumers
ack-mode: manual
```
### 2.2 Redis 설정
```yaml
host: 20.214.210.71
port: 6379
database: 0
password: Hi5Jessica!
```
### 2.3 서비스 상태
- **AI Service**: 포트 8083에서 정상 실행 중
- **Kafka Cluster**: 연결 정상
- **Redis Server**: 연결 정상 (Health Check UP)
---
## 3. 테스트 수행 결과
### 3.1 Kafka Producer 메시지 전송
#### 테스트 메시지 3건 전송
| Job ID | Event ID | 업종 | 지역 | 목표 | 예산 | 전송 상태 |
|--------|----------|------|------|------|------|----------|
| manual-job-001 | manual-event-001 | 음식점 | 강남구 | 신규 고객 유치 | 500,000원 | ✅ 성공 |
| manual-job-002 | manual-event-002 | 카페 | 서초구 | 재방문 유도 | 300,000원 | ✅ 성공 |
| manual-job-003 | manual-event-003 | 소매점 | 마포구 | 매출 증대 | 100,000원 | ✅ 성공 |
**결과**: 모든 메시지가 Kafka 토픽에 정상적으로 전송됨
---
### 3.2 Kafka Consumer 처리 검증
#### Consumer 메시지 수신 및 처리
- **Consumer Group**: ai-service-consumers
- **Auto Commit**: 비활성화 (manual ack)
- **처리 시간**: 약 45초 (3건)
#### 처리 플로우 검증
```
1. Kafka 메시지 수신 ✅
2. Job Status 업데이트 (PROCESSING) ✅
3. 트렌드 분석 수행 ✅
4. AI 추천안 생성 (Fallback 사용) ✅
5. Redis 캐시 저장 ✅
6. Job Status 업데이트 (COMPLETED) ✅
7. Manual Acknowledgment ✅
```
**결과**: 모든 메시지가 정상적으로 처리되어 Redis에 저장됨
---
### 3.3 Redis Job Status 저장/조회 검증
#### Job 001 상태
```json
{
"jobId": "manual-job-001",
"status": "COMPLETED",
"progress": 100,
"message": "AI 추천 완료",
"createdAt": "2025-10-27T16:02:10.3433854"
}
```
#### Job 002 상태
```json
{
"jobId": "manual-job-002",
"status": "COMPLETED",
"progress": 100,
"message": "AI 추천 완료",
"createdAt": "2025-10-27T16:02:10.5093092"
}
```
#### Job 003 상태
```json
{
"jobId": "manual-job-003",
"status": "COMPLETED",
"progress": 100,
"message": "AI 추천 완료",
"createdAt": "2025-10-27T16:02:10.5940905"
}
```
**검증 결과**:
- ✅ Job Status가 Redis에 정상 저장됨
- ✅ API를 통한 조회 정상 동작
- ✅ TTL 설정 확인 (86400초 = 24시간)
---
### 3.4 Redis AI Recommendation 저장/조회 검증
#### Event 001 추천 결과 (요약)
```json
{
"eventId": "manual-event-001",
"aiProvider": "CLAUDE",
"generatedAt": "2025-10-27T16:02:10.3091282",
"expiresAt": "2025-10-28T16:02:10.3091282",
"trendAnalysis": {
"industryTrends": [
{
"keyword": "고객 만족도 향상",
"relevance": 0.8,
"description": "음식점 업종에서 고객 만족도가 중요한 트렌드입니다"
},
{
"keyword": "디지털 마케팅",
"relevance": 0.75,
"description": "SNS 및 온라인 마케팅이 효과적입니다"
}
],
"regionalTrends": [
{
"keyword": "지역 커뮤니티",
"relevance": 0.7,
"description": "강남구 지역 커뮤니티 참여가 효과적입니다"
}
],
"seasonalTrends": [
{
"keyword": "시즌 이벤트",
"relevance": 0.85,
"description": "계절 특성을 반영한 이벤트가 효과적입니다"
}
]
},
"recommendations": [
{
"optionNumber": 1,
"concept": "저비용 SNS 이벤트",
"title": "신규 고객 유치 - 저비용 SNS 이벤트",
"estimatedCost": {
"min": 100000,
"max": 200000
},
"expectedMetrics": {
"newCustomers": { "min": 30.0, "max": 50.0 },
"revenueIncrease": { "min": 10.0, "max": 20.0 },
"roi": { "min": 100.0, "max": 150.0 }
}
},
{
"optionNumber": 2,
"concept": "중비용 방문 유도 이벤트",
"estimatedCost": {
"min": 300000,
"max": 500000
}
},
{
"optionNumber": 3,
"concept": "고비용 프리미엄 이벤트",
"estimatedCost": {
"min": 500000,
"max": 1000000
}
}
]
}
```
**검증 결과**:
- ✅ AI 추천 결과가 Redis에 정상 저장됨
- ✅ 트렌드 분석 데이터 포함
- ✅ 3가지 추천안 (저/중/고 비용) 생성
- ✅ TTL 설정 확인 (24시간)
- ✅ Circuit Breaker Fallback 정상 동작
---
### 3.5 트렌드 분석 캐싱 검증
#### 캐싱 동작 확인
- **캐시 키 형식**: `trend:{industry}:{region}`
- **TTL**: 3600초 (1시간)
- **캐시 히트**: 동일 업종/지역 재요청 시 캐시 사용
**검증 결과**:
- ✅ 트렌드 분석 결과가 Redis에 캐싱됨
- ✅ 동일 조건 재요청 시 캐시 히트 확인 (로그)
- ✅ TTL 설정 정상 동작
---
### 3.6 API 엔드포인트 테스트
#### 1) Job 상태 조회 API
**Endpoint**: `GET /api/v1/ai-service/internal/jobs/{jobId}/status`
| Job ID | HTTP Status | Response Time | 결과 |
|--------|-------------|---------------|------|
| manual-job-001 | 200 OK | < 50ms | ✅ 성공 |
| manual-job-002 | 200 OK | < 50ms | ✅ 성공 |
| manual-job-003 | 200 OK | < 50ms | ✅ 성공 |
#### 2) AI 추천 조회 API
**Endpoint**: `GET /api/v1/ai-service/internal/recommendations/{eventId}`
| Event ID | HTTP Status | Response Time | 결과 |
|----------|-------------|---------------|------|
| manual-event-001 | 200 OK | < 80ms | ✅ 성공 |
| manual-event-002 | 200 OK | < 80ms | ✅ 성공 |
| manual-event-003 | 200 OK | < 80ms | ✅ 성공 |
#### 3) Health Check API
**Endpoint**: `GET /actuator/health`
```json
{
"status": "UP",
"components": {
"redis": {
"status": "UP",
"details": {
"version": "7.2.3"
}
},
"diskSpace": {
"status": "UP"
},
"ping": {
"status": "UP"
}
}
}
```
**검증 결과**:
- ✅ Redis Health Check: UP
- ✅ 전체 서비스 상태: UP
- ✅ Redis 버전: 7.2.3
---
## 4. Circuit Breaker 동작 검증
### 4.1 Fallback 동작 확인
- **상황**: Claude API 키가 유효하지 않거나 타임아웃
- **동작**: AIServiceFallback이 기본 추천안 제공
- **결과**: ✅ 정상적으로 Fallback 응답 반환
### 4.2 Fallback 응답 특징
- 업종별 기본 추천안 제공
- 트렌드 분석은 기본 데이터 사용
- 3가지 비용 옵션 포함
- "AI 분석이 제한적으로 제공되는 기본 추천안입니다" 메시지 포함
---
## 5. 성능 측정
### 5.1 처리 시간
- **Kafka 메시지 전송**: 평균 50ms/건
- **Consumer 처리 시간**: 평균 15초/건 (트렌드 분석 + 추천 생성)
- **Redis 저장**: < 10ms
- **Redis 조회**: < 50ms
### 5.2 리소스 사용
- **메모리**: 정상 범위
- **CPU**: 정상 범위
- **Kafka Consumer Lag**: 0 (모든 메시지 즉시 처리)
---
## 6. 이슈 및 개선사항
### 6.1 확인된 이슈
1. **없음** - 모든 테스트가 정상적으로 통과함
### 6.2 개선 제안
1. **Claude API 실제 연동 테스트**
- 현재는 Fallback 응답만 테스트됨
- 실제 Claude API 키로 End-to-End 테스트 필요
2. **성능 테스트**
- 대량 메시지 처리 테스트 (100건 이상)
- Concurrent Consumer 처리 검증
3. **에러 시나리오 테스트**
- Redis 연결 끊김 시나리오
- Kafka 브로커 다운 시나리오
- 네트워크 타임아웃 시나리오
4. **모니터링 강화**
- Kafka Consumer Lag 모니터링
- Redis 캐시 히트율 모니터링
- Circuit Breaker 상태 모니터링
---
## 7. 결론
### 7.1 테스트 결과 요약
| 테스트 항목 | 결과 | 비고 |
|------------|------|------|
| Kafka 메시지 전송 | ✅ 통과 | 3/3 성공 |
| Kafka Consumer 처리 | ✅ 통과 | Manual ACK 정상 |
| Redis Job Status 저장/조회 | ✅ 통과 | TTL 24시간 |
| Redis AI Recommendation 저장/조회 | ✅ 통과 | TTL 24시간 |
| 트렌드 분석 캐싱 | ✅ 통과 | TTL 1시간 |
| API 엔드포인트 | ✅ 통과 | 모든 API 정상 |
| Circuit Breaker Fallback | ✅ 통과 | 기본 추천안 제공 |
| Health Check | ✅ 통과 | Redis UP |
### 7.2 종합 평가
**✅ 모든 통합 테스트 통과**
AI Service의 Kafka-Redis 통합이 정상적으로 동작합니다:
- Kafka Consumer가 메시지를 정상적으로 수신하고 처리
- Redis에 Job Status와 AI Recommendation이 정확하게 저장
- API를 통한 데이터 조회가 정상 동작
- Circuit Breaker Fallback이 안정적으로 작동
- Health Check에서 모든 컴포넌트가 UP 상태
### 7.3 다음 단계
1.**통합 테스트 완료** (Kafka + Redis)
2. 🔜 **실제 Claude API 연동 테스트**
3. 🔜 **부하 테스트 및 성능 튜닝**
4. 🔜 **에러 시나리오 테스트**
5. 🔜 **모니터링 대시보드 구축**
---
## 8. 테스트 아티팩트
### 8.1 테스트 스크립트
- `tools/kafka-manual-test.bat`: Kafka 수동 테스트 스크립트
- `tools/kafka-comprehensive-test.bat`: 종합 통합 테스트 스크립트
### 8.2 테스트 데이터
- `logs/event-002-result.json`: Event 002 추천 결과
- `logs/event-003-result.json`: Event 003 추천 결과
### 8.3 테스트 로그
- `logs/ai-service.log`: AI Service 실행 로그
- Kafka Consumer 로그: 콘솔 출력 확인
---
**테스트 완료 일시**: 2025-10-27 16:10
**작성자**: AI 개발 팀
**검토자**: Backend Developer (최수연 "아키텍처")