SangBeom-Hahn
diff --git a/‎backend/.gitignore‎
Lines changed: 1 addition & 0 deletions b/‎backend/.gitignore‎
Lines changed: 1 addition & 0 deletions
diff --git a/‎backend/build.gradle‎
Lines changed: 11 additions & 1 deletion b/‎backend/build.gradle‎
Lines changed: 11 additions & 1 deletion
diff --git a/‎backend/src/main/java/com/sketch2fashion/backend/config/JobConfig.java‎
Lines changed: 45 additions & 2 deletions b/‎backend/src/main/java/com/sketch2fashion/backend/config/JobConfig.java‎
Lines changed: 45 additions & 2 deletions
diff --git a/‎backend/src/main/java/com/sketch2fashion/backend/config/RedisConfig.java‎
Lines changed: 7 additions & 6 deletions b/‎backend/src/main/java/com/sketch2fashion/backend/config/RedisConfig.java‎
Lines changed: 7 additions & 6 deletions
diff --git a/‎backend/src/main/java/com/sketch2fashion/backend/config/WebConfig.java‎
Lines changed: 22 additions & 0 deletions b/‎backend/src/main/java/com/sketch2fashion/backend/config/WebConfig.java‎
Lines changed: 22 additions & 0 deletions
diff --git a/‎backend/src/main/java/com/sketch2fashion/backend/config/logging/LoggingAspect.java‎
Lines changed: 64 additions & 0 deletions b/‎backend/src/main/java/com/sketch2fashion/backend/config/logging/LoggingAspect.java‎
Lines changed: 64 additions & 0 deletions
diff --git a/‎backend/src/main/java/com/sketch2fashion/backend/config/logging/LoggingStatus.java‎
Lines changed: 37 additions & 0 deletions b/‎backend/src/main/java/com/sketch2fashion/backend/config/logging/LoggingStatus.java‎
Lines changed: 37 additions & 0 deletions
diff --git a/‎backend/src/main/java/com/sketch2fashion/backend/config/logging/LoggingStatusManager.java‎
Lines changed: 60 additions & 0 deletions b/‎backend/src/main/java/com/sketch2fashion/backend/config/logging/LoggingStatusManager.java‎
Lines changed: 60 additions & 0 deletions
@@ -23,6 +23,7 @@ bin/
 *.iml
 *.ipr
 out/
+logs/
 !**/src/main/**/out/
 !**/src/test/**/out/
 
 
@@ -18,6 +18,9 @@ configurations {
 	compileOnly {
 		extendsFrom annotationProcessor
 	}
+	all {
+		exclude group: 'org.springframework.boot', module: 'spring-boot-starter-logging'
+	}
 	asciidoctorExt
 }
 
@@ -66,9 +69,16 @@ dependencies {
 	// http
 	implementation 'org.apache.httpcomponents:httpclient:4.5.13'
 
-	// RestDocs
+	// restdocs
 	asciidoctorExt 'org.springframework.restdocs:spring-restdocs-asciidoctor'
 	testImplementation 'org.springframework.restdocs:spring-restdocs-mockmvc'
+
+	// logging
+	implementation 'org.springframework.boot:spring-boot-starter-log4j2'
+	implementation 'com.fasterxml.jackson.dataformat:jackson-dataformat-yaml'
+
+	// slack
+	implementation("com.slack.api:slack-api-client:1.45.2")
 }
 
 tasks.named('test') {
 
@@ -5,26 +5,54 @@
 import com.sketch2fashion.backend.service.dto.MessageResponseDto;
 import com.sketch2fashion.backend.support.ClothesModelHttpCaller;
 import com.sketch2fashion.backend.support.consume.ClothesJobConsumerListener;
+import com.sketch2fashion.backend.support.publish.MessagePublisher;
+import org.springframework.beans.factory.annotation.Qualifier;
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
+import org.springframework.data.redis.RedisSystemException;
 import org.springframework.data.redis.connection.RedisConnectionFactory;
+import org.springframework.data.redis.connection.stream.Consumer;
 import org.springframework.data.redis.connection.stream.ObjectRecord;
 import org.springframework.data.redis.connection.stream.ReadOffset;
 import org.springframework.data.redis.connection.stream.StreamOffset;
+import org.springframework.data.redis.core.RedisTemplate;
 import org.springframework.data.redis.core.convert.MappingRedisConverter;
 import org.springframework.data.redis.core.convert.RedisConverter;
 import org.springframework.data.redis.core.mapping.RedisMappingContext;
 import org.springframework.data.redis.hash.ObjectHashMapper;
 import org.springframework.data.redis.serializer.StringRedisSerializer;
 import org.springframework.data.redis.stream.StreamMessageListenerContainer;
 
+import java.time.Duration;
 import java.util.Collections;
+import java.util.concurrent.Executor;
+import java.util.concurrent.LinkedBlockingDeque;
+import java.util.concurrent.ThreadPoolExecutor;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicInteger;
 
 import static com.sketch2fashion.backend.support.publish.Type.CLOTHES;
+import static com.sketch2fashion.backend.utils.SketchConstants.MODEL_RUN_CONSUMER_GROUP;
+import static com.sketch2fashion.backend.utils.SketchConstants.MODEL_RUN_CONSUMER_NAME;
 
 @Configuration
 public class JobConfig {
 
+    private static final int PROCESSORS = Runtime.getRuntime().availableProcessors();
+
+    @Bean
+    public Executor dataRedisStreamExecutor() {
+        AtomicInteger index = new AtomicInteger(1);
+        ThreadPoolExecutor executor = new ThreadPoolExecutor(PROCESSORS, PROCESSORS, 0, TimeUnit.SECONDS,
+                new LinkedBlockingDeque<>(), r -> {
+            Thread thread = new Thread(r);
+            thread.setName("dataRedisConsumer-executor" + index.getAndIncrement());
+            thread.setDaemon(true);
+            return thread;
+        });
+        return executor;
+    }
+
     @Bean
     RedisMappingContext redisMappingContext() {
         final RedisMappingContext ctx = new RedisMappingContext();
@@ -42,21 +70,32 @@ ObjectHashMapper hashMapper(RedisConverter converter) {
         return new ObjectHashMapper(converter);
     }
 
+
     @Bean(initMethod = "start", destroyMethod = "stop")
     public StreamMessageListenerContainer<String, ObjectRecord<String, MessageResponseDto>> streamMessageListenerContainer(
+            Executor dataRedisStreamExecutor,
             RedisConnectionFactory redisConnectionFactory,
             ObjectHashMapper hashMapper,
             ClothesModelHttpCaller clothesModelHttpCaller,
             ObjectMapper objectMapper,
-            ResultService resultService
+            ResultService resultService,
+            @Qualifier("streamRedisTemplate") RedisTemplate<String, Object> redisStreamTemplate
     ) {
+        try {
+            redisStreamTemplate.opsForStream().createGroup(CLOTHES.toString(), MODEL_RUN_CONSUMER_GROUP);
+        } catch (RedisSystemException redisSystemException) {
+            // ignore
+        }
+
         final StreamMessageListenerContainer.StreamMessageListenerContainerOptions<String, ObjectRecord<String, MessageResponseDto>> options =
                 StreamMessageListenerContainer.StreamMessageListenerContainerOptions
                 .builder()
                 .batchSize(1)
+                .executor(dataRedisStreamExecutor)
                 .keySerializer(new StringRedisSerializer())
                 .hashValueSerializer(new StringRedisSerializer())
                 .hashValueSerializer(new StringRedisSerializer())
+                        .pollTimeout(Duration.ofSeconds(1))
                 .objectMapper(hashMapper)
                 .targetType(MessageResponseDto.class)
                 .build();
@@ -67,9 +106,13 @@ public StreamMessageListenerContainer<String, ObjectRecord<String, MessageRespon
         final StreamMessageListenerContainer.StreamReadRequest<String> streamReadRequest =
                 StreamMessageListenerContainer.StreamReadRequest
                         .builder(StreamOffset.create(CLOTHES.toString(), ReadOffset.lastConsumed()))
+                        .consumer(Consumer.from(MODEL_RUN_CONSUMER_GROUP, MODEL_RUN_CONSUMER_NAME))
+                        .autoAcknowledge(false)
+                        .cancelOnError(throwable -> false)
                         .build();
 
-        clothesMessageListenerContainer.register(streamReadRequest, new ClothesJobConsumerListener(clothesModelHttpCaller, objectMapper, resultService));
+        clothesMessageListenerContainer.register(streamReadRequest, new ClothesJobConsumerListener(clothesModelHttpCaller, objectMapper, resultService, redisStreamTemplate));
+
         return clothesMessageListenerContainer;
     }
 }
@@ -1,6 +1,7 @@
 package com.sketch2fashion.backend.config;
 
 import com.sketch2fashion.backend.service.dto.ResultResponseDto;
+import org.springframework.beans.factory.annotation.Qualifier;
 import org.springframework.beans.factory.annotation.Value;
 import org.springframework.cache.annotation.EnableCaching;
 import org.springframework.context.annotation.Bean;
@@ -31,14 +32,14 @@ public RedisConnectionFactory redisConnectionFactory() {
     }
 
     @Bean
-    public Jackson2JsonRedisSerializer<ResultResponseDto> jsonRedisSerializer() {
-        return new Jackson2JsonRedisSerializer<>(ResultResponseDto.class);
+    public Jackson2JsonRedisSerializer<Object> jsonRedisSerializer() {
+        return new Jackson2JsonRedisSerializer<>(Object.class);
     }
 
     @Bean
     public RedisCacheManager cacheManager(
             RedisConnectionFactory redisConnectionFactory,
-            Jackson2JsonRedisSerializer<ResultResponseDto> jsonRedisSerializer
+            Jackson2JsonRedisSerializer<Object> jsonRedisSerializer
     ) {
         final RedisCacheConfiguration configuration = RedisCacheConfiguration.defaultCacheConfig()
                 .disableCachingNullValues()
@@ -52,11 +53,11 @@ public RedisCacheManager cacheManager(
     }
 
     @Bean
-    public RedisTemplate<String, ResultResponseDto> redisTemplate(
+    public RedisTemplate<String, Object> redisTemplate(
             RedisConnectionFactory redisConnectionFactory,
-            Jackson2JsonRedisSerializer<ResultResponseDto> jsonRedisSerializer
+            Jackson2JsonRedisSerializer<Object> jsonRedisSerializer
     ) {
-        final RedisTemplate<String, ResultResponseDto> redisTemplate = new RedisTemplate<>();
+        final RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
 
         redisTemplate.setConnectionFactory(redisConnectionFactory);
         redisTemplate.setKeySerializer(new StringRedisSerializer());
 
@@ -0,0 +1,22 @@
+package com.sketch2fashion.backend.config;
+
+import com.sketch2fashion.backend.controller.history.HistoryInterceptor;
+import lombok.RequiredArgsConstructor;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
+import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
+
+@Configuration
+@RequiredArgsConstructor
+public class WebConfig implements WebMvcConfigurer {
+
+    private final HistoryInterceptor historyInterceptor;
+
+    @Override
+    public void addInterceptors(InterceptorRegistry registry) {
+        registry.addInterceptor(historyInterceptor)
+                .order(1)
+                .addPathPatterns("/**")
+                .excludePathPatterns("/css/**", "/*.ico", "/error");
+    }
+}
@@ -0,0 +1,64 @@
+package com.sketch2fashion.backend.config.logging;
+
+import jakarta.servlet.http.HttpServletRequest;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.aspectj.lang.ProceedingJoinPoint;
+import org.aspectj.lang.annotation.Around;
+import org.aspectj.lang.annotation.Aspect;
+import org.aspectj.lang.annotation.Pointcut;
+import org.springframework.stereotype.Component;
+import org.springframework.web.context.request.RequestContextHolder;
+import org.springframework.web.context.request.ServletRequestAttributes;
+
+@Slf4j
+@Aspect
+@Component
+@RequiredArgsConstructor
+public class LoggingAspect {
+
+    private final LoggingTracer loggingTracer;
+    private final LoggingStatusManager loggingStatusManager;
+
+    @Pointcut("execution(public * com.sketch2fashion.backend..*(..)) "
+            + "&& !execution(public * com.sketch2fashion.backend.config.logging..*(..))")
+    private void allComponents() {
+    }
+
+    @Pointcut("execution(public * com.sketch2fashion.backend.controller..*Controller.*(..))")
+    private void allController() {
+    }
+
+    @Around("allComponents()")
+    public Object doLogTrace(final ProceedingJoinPoint joinPoint) throws Throwable {
+        final String message = joinPoint.getSignature().toShortString();
+        final Object[] args = joinPoint.getArgs();
+        try {
+            loggingTracer.begin(message, args);
+            final Object result = joinPoint.proceed();
+            loggingTracer.end(message);
+            return result;
+        } catch (final Exception e) {
+            loggingTracer.exception(message, e);
+            throw e;
+        }
+    }
+
+    @Around("allController()")
+    public Object doLogRequest(final ProceedingJoinPoint joinPoint) throws Throwable {
+        loggingStatusManager.syncStatus();
+        final String taskId = loggingStatusManager.getTaskId();
+        final HttpServletRequest request = ((ServletRequestAttributes) RequestContextHolder.currentRequestAttributes())
+                .getRequest();
+        final String method = request.getMethod();
+        final String requestURI = request.getRequestURI();
+        final Object[] args = joinPoint.getArgs();
+        log.info("[{}] {} {} args={}", taskId, method, requestURI, args);
+
+        try {
+            return joinPoint.proceed();
+        } finally {
+            loggingStatusManager.release();
+        }
+    }
+}
@@ -0,0 +1,37 @@
+package com.sketch2fashion.backend.config.logging;
+
+public class LoggingStatus {
+
+    private final String taskId;
+    private final long startTimeMillis;
+    private int depthLevel = 0;
+
+    public LoggingStatus(final String taskId, final long startTimeMillis) {
+        this.taskId = taskId;
+        this.startTimeMillis = startTimeMillis;
+    }
+
+    public void enterDepth() {
+        depthLevel++;
+    }
+
+    public void comeOutDepth() {
+        depthLevel--;
+    }
+
+    public boolean isEndDepth() {
+        return depthLevel == 0;
+    }
+
+    public String getTaskId() {
+        return taskId;
+    }
+
+    public long getStartTimeMillis() {
+        return startTimeMillis;
+    }
+
+    public int getDepthLevel() {
+        return depthLevel;
+    }
+}
@@ -0,0 +1,60 @@
+package com.sketch2fashion.backend.config.logging;
+
+import org.springframework.stereotype.Component;
+
+import java.util.UUID;
+
+@Component
+public class LoggingStatusManager {
+
+    private final ThreadLocal<LoggingStatus> statusContainer =
+            new ThreadLocal<>();
+
+    public void syncStatus() {
+        final LoggingStatus status = statusContainer.get();
+        if (status != null) {
+            status.enterDepth();
+            return;
+        }
+        final LoggingStatus firstLoggingStatus = createLoggingStatus();
+        statusContainer.set(firstLoggingStatus);
+    }
+
+    private LoggingStatus createLoggingStatus() {
+        final String traceId = UUID.randomUUID().toString();
+        final long startTimeMillis = System.currentTimeMillis();
+        return new LoggingStatus(traceId, startTimeMillis);
+    }
+
+    public String getTaskId() {
+        final LoggingStatus status = getExistLoggingStatus();
+        return status.getTaskId();
+    }
+
+    public long getStartTimeMillis() {
+        final LoggingStatus status = getExistLoggingStatus();
+        return status.getStartTimeMillis();
+    }
+
+    public int getDepthLevel() {
+        final LoggingStatus status = getExistLoggingStatus();
+        return status.getDepthLevel();
+    }
+
+    public void release() {
+        final LoggingStatus status = getExistLoggingStatus();
+        if (status.isEndDepth()) {
+            statusContainer.remove();
+            return;
+        }
+        status.comeOutDepth();
+    }
+
+    private LoggingStatus getExistLoggingStatus() {
+        final LoggingStatus status = statusContainer.get();
+        if (status == null) {
+            throw new IllegalStateException();
+        }
+        return status;
+    }
+}