feat: 이력서 크롤링 실패 슬랙봇 알림

Dockerfile

@@ -1,4 +1,4 @@
-FROM openjdk:21-slim AS builder
+FROM openjdk:21-jdk-slim AS builder
 WORKDIR /app
 RUN apt-get update && apt-get install -y findutils wget
 COPY ./techeerzip/ /app/
@@ -8,7 +8,7 @@ RUN ./gradlew clean spotlessApply bootJar --no-daemon -x test
 # OpenTelemetry Java Agent 다운로드
 RUN wget https://github.com/open-telemetry/opentelemetry-java-instrumentation/releases/download/v2.5.0/opentelemetry-javaagent.jar
 
-FROM openjdk:21-slim
+FROM openjdk:21-jre-slim
 RUN apt-get update \
  && apt-get install -y --no-install-recommends ffmpeg \
  && rm -rf /var/lib/apt/lists/*

techeerzip/src/main/java/backend/techeerzip/domain/resume/alert/ResumeAlertNotifier.java

@@ -0,0 +1,55 @@
+package backend.techeerzip.domain.resume.alert;
+
+import org.springframework.context.ApplicationEventPublisher;
+import org.springframework.data.redis.core.RedisTemplate;
+import org.springframework.stereotype.Component;
+
+import backend.techeerzip.infra.slack.event.SlackEvent;
+import backend.techeerzip.infra.slack.util.SlackChannelType;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+
+@Slf4j
+@Component
+@RequiredArgsConstructor
+public class ResumeAlertNotifier {
+    private static final String ALERT_SENT_KEY_PREFIX = "resume_alert_sent:";
+
+    private final ApplicationEventPublisher eventPublisher;
+    private final RedisTemplate<String, String> redisTemplate;
+
+    public void notify(
+            String reason, String stage, String taskId, Long userId, Long resumeId, String detail) {
+        if (resumeId == null) {
+            log.warn("resumeId가 null이어서 알림 발송 불가 - taskId: {}", taskId);
+            return;
+        }
+
+        final String alertKey = ALERT_SENT_KEY_PREFIX + resumeId;
+
+        Boolean alreadySent = redisTemplate.hasKey(alertKey);
+        if (Boolean.TRUE.equals(alreadySent)) {
+            log.debug("이미 알림이 발송된 이력서 - resumeId: {}, taskId: {}", resumeId, taskId);
+            return;
+        }
+
+        final String message =
+                String.format(
+                        "❗️ 이력서 크롤링 실패\n- reason: %s\n- stage: %s\n- taskId: %s\n- userId: %s\n- resumeId: %s\n- detail: %s",
+                        reason,
+                        stage,
+                        taskId,
+                        String.valueOf(userId),
+                        String.valueOf(resumeId),
+                        detail != null ? detail : "-");
+
+        eventPublisher.publishEvent(
+                SlackEvent.Channel.builder()
+                        .channelType(SlackChannelType.RESUME)
+                        .message(message)
+                        .build());
+
+        redisTemplate.opsForValue().set(alertKey, "sent");
+        log.info("이력서 실패 알림 발송 완료 - resumeId: {}, taskId: {}", resumeId, taskId);
+    }
+}

techeerzip/src/main/java/backend/techeerzip/domain/resume/event/ResumeStackExtractionSaveListener.java

@@ -7,6 +7,10 @@
 import org.springframework.scheduling.annotation.Async;
 import org.springframework.stereotype.Component;
 
+import backend.techeerzip.domain.resume.alert.ResumeAlertNotifier;
+import backend.techeerzip.domain.resume.monitoring.ResumeMetricsRecorder;
+import backend.techeerzip.domain.resume.support.ResumeFailureClassifier;
+import backend.techeerzip.domain.resume.support.ResumeTaskContextExtractor;
 import backend.techeerzip.domain.user.service.UserService;
 import backend.techeerzip.infra.redis.RedisTaskProcessedEvent;
 import lombok.RequiredArgsConstructor;
@@ -20,6 +24,8 @@ public class ResumeStackExtractionSaveListener {
 
     private final UserService userService;
     private final ApplicationEventPublisher eventPublisher;
+    private final ResumeAlertNotifier alertNotifier;
+    private final ResumeMetricsRecorder metricsRecorder;
 
     @Async("defaultExecutor")
     @EventListener
@@ -30,10 +36,41 @@ public void handleResumeStackSaveProcess(ResumeStackExtractionSaveEvent event) {
                 event.getUserId(),
                 CONTEXT);
         try {
+            // 총 시도 계측
+            metricsRecorder.markTotal();
+
+            // 다운로드 실패, 파싱/모델 오류 분류 및 알림
+            Optional<ResumeFailureClassifier.FailureInfo> classified =
+                    ResumeFailureClassifier.classify(event.getResultData());
+            if (classified.isPresent()) {
+                final String stage = classified.get().stage();
+                final String reason = classified.get().reason();
+                final Long resumeId = ResumeTaskContextExtractor.extractResumeId(event.getTaskId());
+                metricsRecorder.markFail(reason, stage);
+                alertNotifier.notify(
+                        reason,
+                        stage,
+                        event.getTaskId(),
+                        event.getUserId(),
+                        resumeId,
+                        "classified-by-result");
+                return;
+            }
+
             final Optional<ResumeStackExtractionResponse> response =
                     ResumeStackMapper.toExtractionResponse(
                             event.getUserId(), event.getResultData());
             if (response.isEmpty()) {
+                final Long resumeId = ResumeTaskContextExtractor.extractResumeId(event.getTaskId());
+                final String reason = "result_json_invalid";
+                metricsRecorder.markFail(reason, "map_result");
+                alertNotifier.notify(
+                        reason,
+                        "map_result",
+                        event.getTaskId(),
+                        event.getUserId(),
+                        resumeId,
+                        "json-parse-failed");
                 return;
             }
             userService.updateTechStack(response.get());

techeerzip/src/main/java/backend/techeerzip/domain/resume/monitoring/ResumeMetricsRecorder.java

@@ -0,0 +1,25 @@
+package backend.techeerzip.domain.resume.monitoring;
+
+import org.springframework.stereotype.Component;
+
+import io.micrometer.core.instrument.Counter;
+import io.micrometer.core.instrument.MeterRegistry;
+import lombok.RequiredArgsConstructor;
+
+@Component
+@RequiredArgsConstructor
+public class ResumeMetricsRecorder {
+    private final MeterRegistry meterRegistry;
+
+    public void markTotal() {
+        Counter.builder("resume_extraction_total").register(meterRegistry).increment();
+    }
+
+    public void markFail(String reason, String stage) {
+        Counter.builder("resume_extraction_fail_total")
+                .tag("reason", reason)
+                .tag("stage", stage)
+                .register(meterRegistry)
+                .increment();
+    }
+}

techeerzip/src/main/java/backend/techeerzip/domain/resume/scheduler/ResumeTaskWatchdog.java

@@ -0,0 +1,105 @@
+package backend.techeerzip.domain.resume.scheduler;
+
+import java.time.Duration;
+import java.time.Instant;
+import java.util.Map;
+import java.util.Set;
+
+import org.springframework.data.redis.core.RedisTemplate;
+import org.springframework.scheduling.annotation.Scheduled;
+import org.springframework.stereotype.Component;
+
+import backend.techeerzip.domain.resume.alert.ResumeAlertNotifier;
+import backend.techeerzip.domain.resume.monitoring.ResumeMetricsRecorder;
+import backend.techeerzip.domain.resume.support.ResumeTaskContextExtractor;
+import backend.techeerzip.infra.redis.RedisTaskReader;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+
+@Slf4j
+@Component
+@RequiredArgsConstructor
+public class ResumeTaskWatchdog {
+    private final RedisTemplate<String, String> redisTemplate;
+    private final RedisTaskReader redisTaskReader;
+    private final ResumeAlertNotifier alertNotifier;
+    private final ResumeMetricsRecorder metrics;
+
+    private static final Duration TIMEOUT = Duration.ofMinutes(20);
+
+    @Scheduled(fixedRate = 60_000)
+    public void checkTimeouts() {
+        try {
+            // "resume_extraction-<userId>-<resumeId>" 형식
+            final Set<String> taskIds = redisTemplate.keys("resume_extraction-*");
+            if (taskIds == null || taskIds.isEmpty()) {
+                return;
+            }
+            final Instant now = Instant.now();
+
+            for (String taskId : taskIds) {
+                try {
+                    final Map<String, Object> details = redisTaskReader.read(taskId);
+                    final Long userId = parseLong(details.get("userId"));
+                    final Long resumeId = ResumeTaskContextExtractor.extractResumeId(taskId);
+
+                    final Instant createdAt = parseInstant(details.get("createdAt"));
+                    final String status = String.valueOf(details.getOrDefault("status", ""));
+                    final boolean processed =
+                            "PROCESSED".equalsIgnoreCase(status)
+                                    || "COMPLETED".equalsIgnoreCase(status);
+                    final boolean hasResult = details.containsKey("result");
+
+                    if (createdAt != null && !processed && createdAt.isBefore(now.minus(TIMEOUT))) {
+                        metrics.markFail("worker_timeout", "worker_execute");
+                        alertNotifier.notify(
+                                "worker_timeout",
+                                "worker_execute",
+                                taskId,
+                                userId,
+                                resumeId,
+                                "no-completion-within-20m");
+                        continue;
+                    }
+
+                    if (processed && !hasResult) {
+                        metrics.markFail("result_missing", "worker_execute");
+                        alertNotifier.notify(
+                                "result_missing",
+                                "worker_execute",
+                                taskId,
+                                userId,
+                                resumeId,
+                                "processed-without-result");
+                    }
+                } catch (Exception e) {
+                    log.warn(
+                            "Watchdog inspection failed - taskId: {}, err: {}",
+                            taskId,
+                            e.getMessage());
+                }
+            }
+        } catch (Exception e) {
+            log.warn("Watchdog scan failed - err: {}", e.getMessage());
+        }
+    }
+
+    private static Long parseLong(Object v) {
+        try {
+            if (v == null) return null;
+            return Long.parseLong(String.valueOf(v));
+        } catch (Exception e) {
+            return null;
+        }
+    }
+
+    private static Instant parseInstant(Object v) {
+        try {
+            if (v == null) return null;
+            long epochMillis = Long.parseLong(String.valueOf(v));
+            return Instant.ofEpochMilli(epochMillis);
+        } catch (Exception e) {
+            return null;
+        }
+    }
+}

techeerzip/src/main/java/backend/techeerzip/domain/resume/support/ResumeFailureClassifier.java

@@ -0,0 +1,46 @@
+package backend.techeerzip.domain.resume.support;
+
+import java.util.Optional;
+
+import com.fasterxml.jackson.databind.JsonNode;
+import com.fasterxml.jackson.databind.ObjectMapper;
+
+public class ResumeFailureClassifier {
+    private static final ObjectMapper mapper = new ObjectMapper();
+
+    public static Optional<FailureInfo> classify(String resultJson) {
+        try {
+            final JsonNode root = mapper.readTree(resultJson);
+            final String errorCode =
+                    getFirstNonNullText(root, "errorCode", "error", "code", "status");
+            if (errorCode == null) return Optional.empty();
+
+            if (match(errorCode, "download_failed", "unauthorized_url", "not_found")) {
+                return Optional.of(new FailureInfo("worker_download", errorCode));
+            }
+            if (match(errorCode, "parsing_failed", "ocr_failed", "model_error")) {
+                return Optional.of(new FailureInfo("worker_parse", errorCode));
+            }
+            return Optional.empty();
+        } catch (Exception e) {
+            return Optional.empty();
+        }
+    }
+
+    private static boolean match(String code, String... candidates) {
+        for (String c : candidates) if (c.equalsIgnoreCase(code)) return true;
+        return false;
+    }
+
+    private static String getFirstNonNullText(JsonNode node, String... keys) {
+        for (String k : keys) {
+            if (node.has(k) && !node.get(k).isNull()) {
+                final String v = node.get(k).asText(null);
+                if (v != null && !v.isBlank()) return v;
+            }
+        }
+        return null;
+    }
+
+    public record FailureInfo(String stage, String reason) {}
+}

techeerzip/src/main/java/backend/techeerzip/domain/resume/support/ResumeTaskContextExtractor.java

@@ -0,0 +1,11 @@
+package backend.techeerzip.domain.resume.support;
+
+import backend.techeerzip.domain.task.dto.TaskIdInfo;
+import backend.techeerzip.domain.task.util.TaskIdHandler;
+
+public class ResumeTaskContextExtractor {
+    public static Long extractResumeId(String taskId) {
+        final TaskIdInfo info = TaskIdHandler.extractTaskId(taskId);
+        return info.getDomainId();
+    }
+}

techeerzip/src/main/java/backend/techeerzip/infra/slack/config/SlackProperties.java

@@ -21,6 +21,7 @@ public class SlackProperties {
     @NotBlank private final String todayCsId;
     @NotBlank private final String blogChallengeId;
     @NotBlank private final String emergencyAlertId;
+    @NotBlank private final String resumeId;
 
     @ConstructorBinding
     public SlackProperties(
@@ -31,7 +32,8 @@ public SlackProperties(
             String messageUrl,
             String todayCsId,
             String blogChallengeId,
-            String emergencyAlertId) {
+            String emergencyAlertId,
+            String resumeId) {
         this.environment = environment;
         this.channelUrl = channelUrl;
         this.dmUrl = dmUrl;
@@ -40,5 +42,6 @@ public SlackProperties(
         this.todayCsId = todayCsId;
         this.blogChallengeId = blogChallengeId;
         this.emergencyAlertId = emergencyAlertId;
+        this.resumeId = resumeId;
     }
 }

techeerzip/src/main/java/backend/techeerzip/infra/slack/util/SlackChannelType.java

@@ -7,7 +7,8 @@
 public enum SlackChannelType {
     TBC(SlackProperties::getBlogChallengeId),
     TC(SlackProperties::getTodayCsId),
-    EA(SlackProperties::getEmergencyAlertId);
+    EA(SlackProperties::getEmergencyAlertId),
+    RESUME(SlackProperties::getResumeId);
 
     private final Function<SlackProperties, String> channelIdExtractor;
 

techeerzip/src/main/resources/application.properties

@@ -69,7 +69,7 @@ springdoc.swagger-ui.tryItOutEnabled=true
 swagger.username=${SWAGGER_USER}
 swagger.password=${SWAGGER_PASSWORD}
 
-https.server.url=${HTTPS_SERVER_URL}
+https.server.url=${HTTPS_SERVER_URL} 
 staging.server.url=${STAGING_SERVER_URL}
 x.api.key=${X_API_KEY}
 
@@ -83,6 +83,7 @@ slack.message-url=${SLACKBOT_MESSAGE_URL}
 slack.today-cs-id=${SLACK_CHANNEL_TODAY_CS_ID}
 slack.blog-challenge-id=${SLACK_CHANNEL_BLOG_CHALLENGE_ID}
 slack.emergency-alert-id=${SLACK_CHANNEL_EMERGENCY_ALERT_ID}
+slack.resume-id=${SLACK_CHANNEL_RESUME_ID}
 
 # Flyway ??
 spring.flyway.enabled=true