Debugging Guide¶

@Component
public class TraceIdFilter implements WebFilter {

    @Override
    public Mono<Void> filter(ServerWebExchange exchange, WebFilterChain chain) {
        String traceId = UUID.randomUUID().toString().substring(0, 8);

        return chain.filter(exchange)
            .contextWrite(Context.of("traceId", traceId))
            .doOnEach(ReactiveUtils.addToMDC("traceId", traceId));
    }
}

@Service
public class LoadBalancerService {
    private static final Logger log = LoggerFactory.getLogger(LoadBalancerService.class);

    public ServiceInstance selectInstance(String serviceType, String clientInfo) {
        log.debug("Selecting instance for service: {}, client: {}", serviceType, clientInfo);

        List<ServiceInstance> instances = getAvailableInstances(serviceType);
        log.debug("Available instances: {}", instances.size());

        ServiceInstance selected = loadBalancer.selectInstance(instances, clientInfo);
        log.info("Selected instance: {} for service: {}", 
                selected != null ? selected.getName() : "null", serviceType);

        return selected;
    }
}

@Component
public class ThreadMonitor {
    private static final Logger log = LoggerFactory.getLogger(ThreadMonitor.class);

    @Scheduled(fixedRate = 60000) // Check every minute
    public void monitorThreads() {
        ThreadMXBean threadBean = ManagementFactory.getThreadMXBean();

        long[] deadlockedThreads = threadBean.findDeadlockedThreads();
        if (deadlockedThreads != null) {
            log.error("Detected deadlocked threads: {}", Arrays.toString(deadlockedThreads));
        }

        int threadCount = threadBean.getThreadCount();
        int peakThreadCount = threadBean.getPeakThreadCount();

        log.debug("Current thread count: {}, Peak thread count: {}", threadCount, peakThreadCount);

        if (threadCount > 200) {
            log.warn("Too many threads: {}", threadCount);
        }
    }
}

@Component
public class PerformanceMonitor {
    private static final Logger log = LoggerFactory.getLogger(PerformanceMonitor.class);

    @Around("@annotation(Monitored)")
    public Object monitor(ProceedingJoinPoint joinPoint) throws Throwable {
        long startTime = System.currentTimeMillis();
        String methodName = joinPoint.getSignature().getName();

        try {
            Object result = joinPoint.proceed();
            long duration = System.currentTimeMillis() - startTime;

            if (duration > 1000) {
                log.warn("Method {} execution time too long: {}ms", methodName, duration);
            } else {
                log.debug("Method {} execution time: {}ms", methodName, duration);
            }

            return result;
        } catch (Exception e) {
            long duration = System.currentTimeMillis() - startTime;
            log.error("Method {} execution failed, duration: {}ms", methodName, duration, e);
            throw e;
        }
    }
}

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface Monitored {
}

@SpringBootApplication
public class ModelRouterApplication {

    public static void main(String[] args) {
        // Enable Reactor debugging
        Hooks.onOperatorDebug();

        SpringApplication.run(ModelRouterApplication.class, args);
    }
}

@Service
public class ChatService {
    private static final Logger log = LoggerFactory.getLogger(ChatService.class);

    public Mono<String> processChat(String request) {
        return Mono.fromCallable(() -> request)
            .doOnSubscribe(s -> log.debug("Starting chat request processing"))
            .doOnNext(req -> log.debug("Processing request: {}", req))
            .flatMap(this::callBackend)
            .doOnSuccess(response -> log.debug("Backend response: {}", response))
            .doOnError(error -> log.error("Processing failed", error))
            .doFinally(signal -> log.debug("Processing completed: {}", signal));
    }

    private Mono<String> callBackend(String request) {
        return webClient.post()
            .uri("/v1/chat/completions")
            .bodyValue(request)
            .retrieve()
            .bodyToMono(String.class)
            .timeout(Duration.ofSeconds(30))
            .onErrorMap(TimeoutException.class, 
                ex -> new ServiceException("Backend service timeout", ex));
    }
}

@Component
public class BackpressureMonitor {
    private static final Logger log = LoggerFactory.getLogger(BackpressureMonitor.class);

    public Flux<String> processStream(Flux<String> input) {
        return input
            .onBackpressureBuffer(1000, 
                dropped -> log.warn("Backpressure buffer full, dropped element: {}", dropped))
            .doOnRequest(n -> log.debug("Requested {} elements", n))
            .doOnCancel(() -> log.debug("Stream cancelled"))
            .map(this::processItem);
    }
}

@ConfigurationProperties(prefix = "model")
@Validated
@Data
public class ModelConfiguration {

    @PostConstruct
    public void validate() {
        log.info("Model configuration loaded: {}", this);

        if (services == null || services.isEmpty()) {
            throw new IllegalStateException("At least one service must be configured");
        }

        services.forEach((type, config) -> {
            if (config.getInstances() == null || config.getInstances().isEmpty()) {
                throw new IllegalStateException("Service " + type + " must have at least one instance");
            }
        });
    }
}

@Component
public class ConfigurationChangeListener {
    private static final Logger log = LoggerFactory.getLogger(ConfigurationChangeListener.class);

    @EventListener
    public void handleConfigurationChange(ConfigurationChangeEvent event) {
        log.info("Configuration changed: Type={}, Key={}, Old Value={}, New Value={}", 
                event.getType(), event.getKey(), event.getOldValue(), event.getNewValue());
    }
}

@Component
public class BackendHealthIndicator implements HealthIndicator {

    @Override
    public Health health() {
        try {
            // Check backend service health status
            boolean isHealthy = checkBackendHealth();

            if (isHealthy) {
                return Health.up()
                    .withDetail("backend", "All services are healthy")
                    .build();
            } else {
                return Health.down()
                    .withDetail("backend", "Some services are unhealthy")
                    .build();
            }
        } catch (Exception e) {
            return Health.down(e)
                .withDetail("error", e.getMessage())
                .build();
        }
    }
}

@Component
public class CustomMetrics {
    private final Counter requestCounter;
    private final Timer requestTimer;

    public CustomMetrics(MeterRegistry meterRegistry) {
        this.requestCounter = Counter.builder("jairouter.requests.custom")
            .description("Custom request counter")
            .register(meterRegistry);

        this.requestTimer = Timer.builder("jairouter.request.duration.custom")
            .description("Custom request duration")
            .register(meterRegistry);
    }

    public void recordRequest(String serviceType, Duration duration) {
        requestCounter.increment(Tags.of("service", serviceType));
        requestTimer.record(duration, Tags.of("service", serviceType));
    }
}