ASSU-dev · 2ghrms · Sep 15, 2026 · Sep 5, 2026 · Sep 5, 2026 · Sep 6, 2026
diff --git a/manifest b/manifest
diff --git a/...in/java/com/assu/server/domain/certification/controller/GroupCertificationController.java b/...in/java/com/assu/server/domain/certification/controller/GroupCertificationController.java
@@ -14,6 +14,8 @@
 import com.assu.server.domain.certification.service.CertificationService;
 import com.assu.server.global.util.PrincipalDetails;
 
+import io.micrometer.core.instrument.MeterRegistry;
+import io.micrometer.core.instrument.Timer;
 import io.swagger.v3.oas.annotations.Operation;
 import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
@@ -26,6 +28,7 @@
 public class GroupCertificationController {
 
 	private final CertificationService certificationService;
+	private final MeterRegistry meterRegistry;
 
 	@MessageMapping("/certify")
 	@Operation(
@@ -44,15 +47,21 @@ public CertificationProgressResponseDTO certifyGroup(@Payload GroupSessionReques
 			UsernamePasswordAuthenticationToken auth = (UsernamePasswordAuthenticationToken)principal;
 			PrincipalDetails principalDetails = (PrincipalDetails)auth.getPrincipal();
 
+			Timer.Sample sample = Timer.start(meterRegistry);
 			try {
 				log.info("### SUCCESS ### 인증 요청 메시지 수신 - user: {}, adminId: {}, sessionId: {}",
 					principalDetails.getUsername(), dto.adminId(), dto.sessionId());
 
 				if (principalDetails != null) {
-					return certificationService.handleCertification(dto, principalDetails.getMember());
+					CertificationProgressResponseDTO result = certificationService.handleCertification(dto, principalDetails.getMember());
+					meterRegistry.counter("certification.group.result", "result", result.type()).increment();
+					return result;
 				}
 			} catch (Exception e) {
 				log.error("### ERROR ### 인증 처리 중 오류 발생: {}", e.getMessage(), e);
+				meterRegistry.counter("certification.group.result", "result", "failure").increment();
+			} finally {
+				sample.stop(meterRegistry.timer("certification.group.duration"));
 			}
 		}
 		return null;

diff --git a/src/main/java/com/assu/server/domain/chat/service/ChatServiceImpl.java b/src/main/java/com/assu/server/domain/chat/service/ChatServiceImpl.java
@@ -21,12 +21,16 @@
 import com.assu.server.global.exception.DatabaseException;
 import com.assu.server.global.exception.GeneralException;
 import com.assu.server.global.util.PresenceTracker;
+import io.micrometer.core.instrument.Counter;
+import io.micrometer.core.instrument.MeterRegistry;
 import jakarta.transaction.Transactional;
 import org.springframework.dao.DataIntegrityViolationException;
 import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.messaging.simp.SimpMessagingTemplate;
 import org.springframework.stereotype.Service;
+import org.springframework.transaction.support.TransactionSynchronization;
+import org.springframework.transaction.support.TransactionSynchronizationManager;
 
 import java.util.ArrayList;
 import java.util.List;
@@ -45,6 +49,7 @@ public class ChatServiceImpl implements ChatService {
     private final NotificationCommandService notificationCommandService;
     private final PresenceTracker presenceTracker;
     private final BlockRepository blockRepository;
+    private final MeterRegistry meterRegistry;
 
 
     @Override
@@ -115,6 +120,7 @@ public MessageHandlingResult handleMessage(ChatRequestDTO.ChatMessageRequestDTO
         // 3. 메시지 저장 (기존 로직)
         Message message = Message.toMessageEntity(request, room, sender, receiver, unreadForSender);
         Message saved = messageRepository.saveAndFlush(message);
+        incrementAfterCommit(meterRegistry.counter("chat.message.sent"));
         log.info("saved message id={}, roomId={}, senderId={}, receiverId={}",
                 saved.getId(), room.getId(), sender.getId(), receiver.getId());
 
@@ -255,4 +261,17 @@ public ChatResponseDTO.LeaveChattingRoomResponseDTO leaveChattingRoom(Long roomI
         }
         return new  ChatResponseDTO.LeaveChattingRoomResponseDTO(roomId, isLeftSuccessfully,isRoomDeleted);
     }
+
+    private void incrementAfterCommit(Counter counter) {
+        if (!TransactionSynchronizationManager.isSynchronizationActive()) {
+            counter.increment();
+            return;
+        }
+        TransactionSynchronizationManager.registerSynchronization(new TransactionSynchronization() {
+            @Override
+            public void afterCommit() {
+                counter.increment();
+            }
+        });
+    }
 }
diff --git a/src/main/java/com/assu/server/domain/notification/service/NotificationListener.java b/src/main/java/com/assu/server/domain/notification/service/NotificationListener.java
@@ -8,6 +8,7 @@
 import com.assu.server.domain.notification.dto.NotificationMessageDTO;
 import com.google.firebase.messaging.FirebaseMessagingException;
 import com.rabbitmq.client.Channel;
+import io.micrometer.core.instrument.MeterRegistry;
 import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.amqp.rabbit.annotation.RabbitListener;
@@ -28,6 +29,7 @@ public class NotificationListener {
     private final FcmClient fcmClient;
     private final OutboxStatusService outboxStatus;
     private final ApplicationEventPublisher eventPublisher;
+    private final MeterRegistry meterRegistry;
 
     @RabbitListener(queues = AmqpConfig.QUEUE, ackMode = "MANUAL")
     public void onMessage(@Payload NotificationMessageDTO notificationMessageDTO,
@@ -67,11 +69,17 @@ private void sendNotification(NotificationMessageDTO dto, Long outboxId)
 
         if (outboxId != null) outboxStatus.markSent(outboxId);
 
+        meterRegistry.counter("notification.fcm.send", "result", "success").increment(result.successCount());
+        if (result.failureCount() > 0) {
+            meterRegistry.counter("notification.fcm.send", "result", "failure").increment(result.failureCount());
+        }
+
         log.info("[Notify] sent outboxId={} memberId={} success={} fail={} invalidTokens={}",
                 outboxId, dto.receiverId(), result.successCount(), result.failureCount(), result.invalidTokens());
     }
 
     private void handleException(Exception e, Long outboxId, Long memberId) {
+        meterRegistry.counter("notification.fcm.send", "result", "exception").increment();
         if (outboxId != null) {
             outboxStatus.markFailed(outboxId);
 

diff --git a/src/main/java/com/assu/server/domain/notification/service/OutboxAfterCommitPublisher.java b/src/main/java/com/assu/server/domain/notification/service/OutboxAfterCommitPublisher.java
@@ -6,6 +6,7 @@
 import com.assu.server.domain.notification.event.NotificationFailedEvent;
 import com.assu.server.infra.messaging.AmqpConfig;
 import com.assu.server.infra.messaging.ConditionalOnRabbitEnabled;
+import io.micrometer.core.instrument.MeterRegistry;
 import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.amqp.rabbit.core.RabbitTemplate;
@@ -24,6 +25,7 @@ public class OutboxAfterCommitPublisher {
     private final RabbitTemplate rabbit;
     private final OutboxStatusService outboxStatus;
     private final ApplicationEventPublisher eventPublisher;
+    private final MeterRegistry meterRegistry;
 
     @TransactionalEventListener(phase = TransactionPhase.AFTER_COMMIT)
     public void onOutboxCreated(OutboxCreatedEvent e) {
@@ -44,8 +46,10 @@ public void onOutboxCreated(OutboxCreatedEvent e) {
             rabbit.convertAndSend(AmqpConfig.EXCHANGE, AmqpConfig.ROUTING_KEY, dto);
             log.info("[Outbox] Message sent to queue for outboxId={}", e.getOutboxId());
             outboxStatus.markDispatched(e.getOutboxId());
+            meterRegistry.counter("notification.outbox.publish", "result", "success").increment();
         } catch (Exception ex) {
             log.error("[Outbox] Failed to send message for outboxId={}", e.getOutboxId(), ex);
+            meterRegistry.counter("notification.outbox.publish", "result", "failure").increment();
             // 큐 전송 실패 시 재시도 이벤트 발행
             eventPublisher.publishEvent(new NotificationFailedEvent(e.getOutboxId(), 0));
         }

diff --git a/src/main/java/com/assu/server/domain/notification/service/OutboxRetryProcessor.java b/src/main/java/com/assu/server/domain/notification/service/OutboxRetryProcessor.java
@@ -4,6 +4,7 @@
 import com.assu.server.domain.notification.entity.OutboxCreatedEvent;
 import com.assu.server.domain.notification.event.NotificationFailedEvent;
 import com.assu.server.domain.notification.repository.NotificationOutboxRepository;
+import io.micrometer.core.instrument.MeterRegistry;
 import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.context.ApplicationEventPublisher;
@@ -19,9 +20,11 @@ public class OutboxRetryProcessor {
 
     private final NotificationOutboxRepository outboxRepository;
     private final ApplicationEventPublisher eventPublisher;
-
+    private final MeterRegistry meterRegistry;
+
     @Transactional(propagation = Propagation.REQUIRES_NEW)
     public void processRetry(NotificationOutbox outbox) {
+        meterRegistry.counter("notification.outbox.retry").increment();
         try {
             outbox.incrementRetryCount();
             outboxRepository.save(outbox);

diff --git a/src/main/java/com/assu/server/global/filter/RequestIdFilter.java b/src/main/java/com/assu/server/global/filter/RequestIdFilter.java
@@ -0,0 +1,38 @@
+package com.assu.server.global.filter;
+
+import jakarta.servlet.FilterChain;
+import jakarta.servlet.ServletException;
+import jakarta.servlet.http.HttpServletRequest;
+import jakarta.servlet.http.HttpServletResponse;
+import org.slf4j.MDC;
+import org.springframework.core.Ordered;
+import org.springframework.core.annotation.Order;
+import org.springframework.stereotype.Component;
+import org.springframework.web.filter.OncePerRequestFilter;
+
+import java.io.IOException;
+import java.util.UUID;
+
+@Component
+@Order(Ordered.HIGHEST_PRECEDENCE)
+public class RequestIdFilter extends OncePerRequestFilter {
+
+    public static final String REQUEST_ID_HEADER = "X-Request-Id";
+    public static final String MDC_KEY = "requestId";
+
+    @Override
+    protected void doFilterInternal(
+            HttpServletRequest request,
+            HttpServletResponse response,
+            FilterChain filterChain)
+            throws ServletException, IOException {
+        String requestId = UUID.randomUUID().toString();
+        MDC.put(MDC_KEY, requestId);
+        response.setHeader(REQUEST_ID_HEADER, requestId);
+        try {
+            filterChain.doFilter(request, response);
+        } finally {
+            MDC.remove(MDC_KEY);
+        }
+    }
+}
diff --git a/src/main/java/com/assu/server/global/util/PresenceTracker.java b/src/main/java/com/assu/server/global/util/PresenceTracker.java
@@ -1,5 +1,7 @@
 package com.assu.server.global.util;
 
+import io.micrometer.core.instrument.Gauge;
+import io.micrometer.core.instrument.MeterRegistry;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.context.event.EventListener;
 import org.springframework.messaging.simp.stomp.StompHeaderAccessor;
@@ -22,6 +24,11 @@ public class PresenceTracker {
     // "sessionId:subscriptionId" -> roomId: 특정 구독 해제 시 어느 방인지 추적
     private final Map<String, Long> subToRoom = new ConcurrentHashMap<>();
 
+    public PresenceTracker(MeterRegistry meterRegistry) {
+        Gauge.builder("chat.active.sessions", sessionToMember, Map::size)
+                .register(meterRegistry);
+    }
+
     private Long parseRoomId(String dest) { // "/sub/chat/26" -> 26
         if (dest == null) return null;
         String[] p = dest.split("/");

diff --git a/src/main/resources/application.yml b/src/main/resources/application.yml
@@ -47,6 +47,10 @@ spring:
 server:
   shutdown: graceful
 
+logging:
+  pattern:
+    console: "%clr(%d{yyyy-MM-dd'T'HH:mm:ss.SSSXXX}){faint} %clr(${LOG_LEVEL_PATTERN:-%5p}) %clr(${PID:- }){magenta} %clr(---){faint} %clr([%15.15t]){faint} %clr(%-40.40logger{39}){cyan} %clr(:){faint} [reqId=%X{requestId}] %m%n${LOG_EXCEPTION_CONVERSION_WORD:-%wEx}"
+
 management:
   endpoints:
     web:
@@ -56,3 +60,10 @@ management:
     health:
       probes:
         enabled: true
+  metrics:
+    tags:
+      application: ${spring.application.name}
+    distribution:
+      slo:
+        http.server.requests: 50ms,100ms,200ms,500ms,800ms,1s,2s,5s,10s,30s
+        certification.group.duration: 100ms,500ms,1s,3s,10s,30s
diff --git a/src/test/java/com/assu/server/domain/chat/service/ChatServiceImplTest.java b/src/test/java/com/assu/server/domain/chat/service/ChatServiceImplTest.java
@@ -10,14 +10,20 @@
 import java.util.List;
 import java.util.Optional;
 
+import io.micrometer.core.instrument.MeterRegistry;
+import io.micrometer.core.instrument.simple.SimpleMeterRegistry;
+
 import org.junit.jupiter.api.DisplayName;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.extension.ExtendWith;
 import org.mockito.ArgumentCaptor;
 import org.mockito.InjectMocks;
 import org.mockito.Mock;
+import org.mockito.Spy;
 import org.mockito.junit.jupiter.MockitoExtension;
 import org.springframework.messaging.simp.SimpMessagingTemplate;
+import org.springframework.transaction.support.TransactionSynchronization;
+import org.springframework.transaction.support.TransactionSynchronizationManager;
 
 import com.assu.server.domain.admin.entity.Admin;
 import com.assu.server.domain.admin.repository.AdminRepository;
@@ -78,6 +84,9 @@ class ChatServiceImplTest {
 	@Mock
 	private BlockRepository blockRepository;
 
+	@Spy
+	private MeterRegistry meterRegistry = new SimpleMeterRegistry();
+
 	private static final Long ADMIN_ID = 10L;
 	private static final Long PARTNER_ID = 20L;
 	private static final Long ROOM_ID = 1L;
@@ -260,6 +269,40 @@ void handleMessage_ReceiverInRoom_NoNotification() {
 		verify(messageRepository).saveAndFlush(captor.capture());
 		assertEquals(0, captor.getValue().getUnreadCount());
 		assertTrue(captor.getValue().isRead());
+		assertEquals(1.0, meterRegistry.counter("chat.message.sent").count());
+	}
+
+	@Test
+	@DisplayName("트랜잭션 동기화가 활성화되어 있으면 메시지 전송 카운터는 커밋 이후에 증가한다")
+	void handleMessage_WithTransactionSynchronization_IncrementsCounterAfterCommit() {
+		// 1. Given
+		ChatRequestDTO.ChatMessageRequestDTO request =
+			new ChatRequestDTO.ChatMessageRequestDTO(ROOM_ID, PARTNER_ID, ADMIN_ID, "안녕하세요");
+
+		ChattingRoom room = ChattingRoom.builder().id(ROOM_ID).build();
+		when(chatRepository.findById(ROOM_ID)).thenReturn(Optional.of(room));
+		Member sender = givenMember(PARTNER_ID);
+		Member receiver = givenMember(ADMIN_ID);
+		when(presenceTracker.isInRoom(ADMIN_ID, ROOM_ID)).thenReturn(true);
+
+		Message saved = Message.builder()
+			.id(100L).chattingRoom(room).sender(sender).receiver(receiver)
+			.message("안녕하세요").unreadCount(0).isRead(true).type(MessageType.TEXT)
+			.build();
+		when(messageRepository.saveAndFlush(any(Message.class))).thenReturn(saved);
+
+		TransactionSynchronizationManager.initSynchronization();
+		try {
+			// 2. When
+			chatService.handleMessage(request);
+
+			// 3. Then
+			assertEquals(0.0, meterRegistry.counter("chat.message.sent").count());
+			TransactionSynchronizationManager.getSynchronizations().forEach(TransactionSynchronization::afterCommit);
+			assertEquals(1.0, meterRegistry.counter("chat.message.sent").count());
+		} finally {
+			TransactionSynchronizationManager.clearSynchronization();
+		}
 	}
 
 	@Test