[🔥TroubleShooting - TicToc🔥] 사용자 로그인 기록 관리 어떻게 해야 할까‼️❓‼️❓

📌 프로젝트 소개

팀원 : 개인 프로젝트
기간 : 2025.01 ~ 진행 중
링크 : https://github.com/M-ung/TicToc_Server
서비스 내용 : 당신의 시간에 가치를 매기다, 시간 거래 경매 플랫폼

---

🔥TroubleShooting🔥

Problems

"TicToc" 서비스를 개발하면서 실제 배포를 목적으로 하기 때문에 서비스를 운영하는 입장에서 설계를 하게 됐다. 그래서 사용자 로그인 기록을 갖고 있는게 좋다고 판단하였기에 사용자 로그인 기록(UserLoginHistory) 테이블을 따로 생성했다.

로그인 기록은 사용자가 로그인 한 시점에 즉 JWT 토큰 발급 시점에 저장을 하도록 기능을 구현했다.

하지만 여기서 문제는 사용자 로그인 기록을 단순히 DB에 저장하기에는 한 사용자가 하루에 로그인을 10번만 해도 10개가 쌓이는 상황이 발생한다. 그렇지만 하루에 한 명만 접속할 일이 없다. 10명의 사용자가 10번 로그인을 하면 테이블에는 하루에만 100개가 넘게 쌓이게 된다.

---

How

그래서 위 문제를 해결하기 위해 단순히 DB에 계속 저장하기 보단 시간을 두고 특정 기간의 데이터를 지울 필요가 있다고 판단했다. 그래서 Spring Batch를 적용해 일주일마다 일주일 치 데이터를 지우는 설계를 하기로 했다.

하지만 단순히 또 데이터를 시간을 두고 지우기에는 서비스를 운영하는 입장에서 좋지 않은 방향일 수 있다. 그렇기 때문에 모든 로그인 기록을 저장할 공간이 필요했다. 그래서 DB가 아닌, UserLoginHistory.log라는 파일을 만들어 로그인 기록을 DB와 log 파일에 동시에 저장하기로 했다.

---

Process

Spring Batch 코드는 아래와 같다.

📍 UserLoginHistoryBatchScheduler.java

@Component
@RequiredArgsConstructor
public class UserLoginHistoryBatchScheduler {
    private final JobLauncher jobLauncher;
    private final Job userLoginHistoryJob;

    @Scheduled(cron = "0 0 0 * * SUN") 
    public void runBatchJob() throws JobExecutionException {
        JobParameters jobParameters = new JobParametersBuilder()
                .addLong("time", System.currentTimeMillis())
                .toJobParameters();
        jobLauncher.run(userLoginHistoryJob, jobParameters);
    }
}

📍 UserLoginHistoryBatchConfig.java

@Configuration
@RequiredArgsConstructor
public class UserLoginHistoryBatchConfig {
    private final JobRepository jobRepository;
    private final DataSource dataSource;
    private final PlatformTransactionManager transactionManager;

    @Bean
    public Job userLoginHistoryJob(Step step) {
        return new JobBuilder("userLoginHistoryJob", jobRepository)
                .start(step)
                .build();
    }

    @Bean
    public Step userLoginHistoryStep() {
        return new StepBuilder("userLoginHistoryStep", jobRepository)
                .<Long, Long>chunk(100, transactionManager)
                .reader(userLoginHistoryReader())
                .writer(userLoginHistoryItemWriter())
                .build();
    }

    @Bean
    public JdbcCursorItemReader<Long> userLoginHistoryReader() {
        LocalDateTime endDate = LocalDateTime.now();
        LocalDateTime startDate = endDate.minusDays(7);

        return new JdbcCursorItemReaderBuilder<Long>()
                .dataSource(dataSource)
                .name("userLoginHistoryReader")
                .sql("SELECT id FROM user_login_history WHERE login_at BETWEEN ? AND ?")
                .queryArguments(Timestamp.valueOf(startDate), Timestamp.valueOf(endDate))
                .rowMapper((rs, rowNum) -> rs.getLong("id"))
                .build();
    }

    @Bean
    public ItemWriter<Long> userLoginHistoryItemWriter() {
        return items -> {
            NamedParameterJdbcTemplate namedParameterJdbcTemplate = new NamedParameterJdbcTemplate(dataSource);
            if (items.isEmpty()) return;
            String sql = "DELETE FROM user_login_history WHERE id IN (:ids)";
            Map<String, Object> params = new HashMap<>();
            params.put("ids", items);
            namedParameterJdbcTemplate.update(sql, params);
        };
    }
}

Spring Batch 시나리오는 아래와 같다.

하지만 Spring Batch를 동작할 때 만약 Spring 서버가 다운되면 Spring Batch 또한 제때 동작을 제대로 수행하지 못 할 수 있다. 그렇기 때문에 Spring Batch를 동작할 서버와 API 서버를 분리해서 배포해야겠다는 생각을 했다.

다행히 우리 프로젝트는 멀티모듈로 구성되어 있기 때문에 분리하기 어렵지 않았다.

하지만 여기서 문제는 사용자 로그인 기록을 DB와 log 파일에 저장하는 로직을 Spring Batch 서버에서 관리하려고 했지만, API 서버와 Spring Batch 서버를 이어줄 "무언가" 가 필요했다.

처음에는 WebFlux를 적용해 관리하려 했지만, 사용자 로그인 기록은 순식간에 많은 요청이 들어올 수 있고 끊임없이 요청이 들어올 수 있기 때문에 대용량을 관리할 필요가 있었다.

그래서 "카프카" 를 적용해 보기로 했다.

카프카 코드는 아래와 같다.

📍 UserLoginHistoryEventProducer.java

@Slf4j
@Component
@RequiredArgsConstructor
public class UserLoginHistoryEventProducer {
    private final HttpServletRequest request;
    private final KafkaTemplate<String, UserLoginHistoryEvent> kafkaTemplate;

    @Async
    public void produce(Long userId) {
        try {
            UserLoginHistoryEvent event = UserLoginHistoryEvent.of(userId, getClientIp(), getUserAgent());
            log.info("[INFO] 토픽을 발행했습니다.: {}", event);
            kafkaTemplate.send("user-login-history-topic", event);
        } catch (Exception e) {
            throw new KafkaPublishException(ErrorCode.KAFKA_PUBLISH_ERROR);
        }
    }

    private String getClientIp() {
        var ip = request.getHeader(UserLoginHistoryConstants.X_FORWARDED_FOR);
        if (ip == null || ip.isEmpty() ||UserLoginHistoryConstants.UNKNOWN.equalsIgnoreCase(ip))
            ip = request.getRemoteAddr();
        return ip;
    }

    private String getUserAgent() {
        return request.getHeader(UserLoginHistoryConstants.USER_AGENT);
    }
}

📍 UserLoginHistoryEventConsumer.java

@Slf4j
@Component
@RequiredArgsConstructor
public class UserLoginHistoryEventConsumer {
    private final UserLoginHistoryRepository userLoginHistoryRepository;
    private final KafkaTemplate<String, UserLoginHistoryEvent> kafkaTemplate;
    private static final String LOG_FILE_PATH = "/var/log/tictoc/user_login_history.log";
    private static final String LOG_MESSAGE_FORMAT = "%s - Id: %d, UserId: %d, IPAddress: %s, Device: %s%n";

    @KafkaListener(
            topics = "user-login-history-topic",
            groupId = "${spring.kafka.consumer.group-id}",
            containerFactory = "kafkaListenerContainerFactory"
    )
    public void consume(UserLoginHistoryEvent event) {
        try {
            log.info("[INFO] 토픽을 소비했습니다.: {}", event);
            saveUserLoginHistory(UserLoginHistory.of(event.userId(), event.loginAt(), event.ipAddress(), event.device()));
        } catch (Exception e) {
            kafkaTemplate.send("user-login-history-topic.DLT", event);
            throw new KafkaConsumeException(KAFKA_CONSUME_ERROR, e);
        }
    }

    public void saveUserLoginHistory(UserLoginHistory loginHistory) {
        userLoginHistoryRepository.save(loginHistory);
        writeLogToFile(loginHistory);
    }

    private void writeLogToFile(UserLoginHistory loginHistory) {
        File logFile = ensureLogFileExists();
        synchronized (this) {
            try (BufferedWriter writer = new BufferedWriter(new FileWriter(logFile, true))) {
                writer.write(String.format(LOG_MESSAGE_FORMAT,
                        loginHistory.getLoginAt(), loginHistory.getId(), loginHistory.getUserId(), loginHistory.getIpAddress(), loginHistory.getDevice()));
            } catch (IOException e) {
                throw new LogFileWriteException(LOG_FILE_WRITE_ERROR, e);
            }
        }
    }

    private static File ensureLogFileExists() {
        File logFile = new File(LOG_FILE_PATH);
        File directory = logFile.getParentFile();
        if (!directory.exists() && directory.mkdirs()) {
            setFilePermissions(directory, "755");
        }
        if (!logFile.exists()) {
            try {
                if (logFile.createNewFile()) {
                    setFilePermissions(logFile, "666");
                }
            } catch (IOException e) {
                throw new LogFileWriteException(LOG_FILE_CREATION_ERROR, e);
            }
        }
        return logFile;
    }

    private static void setFilePermissions(File file, String permission) {
        try {
            Process process = new ProcessBuilder("chmod", permission, file.getAbsolutePath()).start();
            if (process.waitFor() == 0) {
                log.info("[INFO] chmod {} 권한 설정 완료: {}", permission, file.getAbsolutePath());
            } else {
                log.error("[ERROR] chmod {} 실패: {}", permission, file.getAbsolutePath());
            }
        } catch (Exception e) {
            log.error("[ERROR] chmod {} 실행 중 예외 발생: {}", permission, file.getAbsolutePath(), e);
        }
    }
}

위 구현 결과 시나리오는 아래와 같다.

1. 사용자가 로그인을 한다.
2. API 서버는 로그인 요청이 들어오면 JWT 토큰을 발급하고 발급과 동시에 카프카 서버에 사용자 로그인 기록 메세지를 전송한다.
3. Kafka는 메시지를 큐에 저장하여 Spring Batch 서버가 메시지를 처리할 수 있도록 한다.
4. Spring Batch 서버는 Kafka의 메시지를 이벤트 기반으로 실시간 수신한다.
5. Spring Batch 서버에서 받은 메시지를 기반으로 DB 저장 및 로그 파일에 기록한다.

---

Result

문제 해결로 아래와 같은 결과를 얻었다.
1. Kafka로 이벤트 비동기 처리 → 응답 속도 향상, DB 부하 감소.
2. Spring Batch 서버에서 주기적 DB 삭제 및 로그 파일 백업 → 데이터 유실 방지.
3. API 서버와 Batch 서버를 분리하여, 확장성과 유지보수 용이성 확보.

최종적인 아키텍처 흐름을 아래와 같다.

---

Thoughts

이번 경험을 통해 실제 운영 환경을 고려한 사용자 로그인 기록 저장 방식을 고민하며 여러 가지 문제를 해결해 나갈 수 있었다.

처음에는 단순히 DB에 로그인 기록을 저장하는 방식을 사용하려 했지만, 로그인 요청이 많아질수록 데이터가 기하급수적으로 증가하는 문제를 처음 마주했다.
이를 해결하기 위해 Spring Batch를 활용해 주기적 데이터 삭제를 적용하려 했지만, 로그인 기록을 모두 삭제하는 것은 운영적인 측면에서 문제될 것 같았다.

그래서 DB뿐만 아니라 로그 파일에도 저장하는 방식을 채택했다.
하지만 API 서버에서 직접 Spring Batch 서버로 데이터를 저장하려면 서버 간 통신 비용이 증가하고, 서버 장애 발생 시 데이터 유실 위험이 있었다.

이를 해결하기 위해 Kafka를 활용하여 API 서버와 Spring Batch 서버를 분리하였다.
Kafka를 도입함으로써 로그인 기록을 비동기적으로 처리할 수 있었으며, 데이터 유실을 방지할 수 있었다.

또 Spring Batch 서버가 API 서버와 별도로 운영되도록 구성하여, API 서버의 부하를 줄이고 안정적인 데이터 처리를 보장할 수 있도록 했다.

이번 경험에서 단순한 기능 구현이 아니라, 실제 서비스 운영을 고려한 아키텍처 설계의 중요성을 다시 한 번 느낄 수 있었다.

앞으로도 운영 측면에서 유지보수하기 좋은 설계를 고민하며 개발하는 개발자로 성장할 것이다.

---