// Copilot completion — basic, correct
@FeignClient(name = "user-service", url = "${user-service.url}")
public interface UserServiceClient {

    @GetMapping("/users/{id}")
    UserDto getUserById(@PathVariable Long id);

    @PostMapping("/users")
    UserDto createUser(@RequestBody CreateUserRequest request);
}

// Claude generates the complete Feign client with Resilience4j circuit breaker
@FeignClient(
    name = "user-service",
    url = "${services.user-service.url}",
    fallbackFactory = UserServiceClient.UserServiceFallbackFactory.class
)
public interface UserServiceClient {

    @GetMapping("/users/{id}")
    UserDto getUserById(@PathVariable("id") Long id);

    @PostMapping("/users")
    UserDto createUser(@RequestBody CreateUserRequest request);

    @Component
    @Slf4j
    class UserServiceFallbackFactory implements FallbackFactory<UserServiceClient> {

        @Override
        public UserServiceClient create(Throwable cause) {
            log.error("UserService call failed, using fallback. Cause: {}", cause.getMessage());
            return new UserServiceClient() {

                @Override
                public UserDto getUserById(Long id) {
                    return UserDto.builder()
                        .id(id)
                        .name("Unknown User")
                        .status(UserStatus.UNAVAILABLE)
                        .build();
                }

                @Override
                public UserDto createUser(CreateUserRequest request) {
                    throw new ServiceUnavailableException("User service is currently unavailable");
                }
            };
        }
    }
}

// UserOrderController.java — reactive endpoint
@RestController
@RequestMapping("/api/v1/users")
@RequiredArgsConstructor
public class UserOrderController {

    private final UserWebClient userWebClient;
    private final OrderWebClient orderWebClient;

    @GetMapping("/{userId}/profile")
    public Mono<UserProfileDto> getUserProfile(@PathVariable Long userId) {
        // Fetch user and orders concurrently using Mono.zip
        return Mono.zip(
            userWebClient.getUser(userId)
                .onErrorResume(WebClientResponseException.NotFound.class,
                    ex -> Mono.error(new UserNotFoundException("User not found: " + userId))),
            orderWebClient.getOrdersByUserId(userId)
                .onErrorResume(ex -> {
                    log.warn("Failed to fetch orders for user {}: {}", userId, ex.getMessage());
                    return Mono.just(List.of()); // Degrade gracefully
                })
                .collectList()
        )
        .map(tuple -> UserProfileDto.builder()
            .user(tuple.getT1())
            .orders(tuple.getT2())
            .orderCount(tuple.getT2().size())
            .build()
        )
        .timeout(Duration.ofSeconds(5))
        .onErrorMap(TimeoutException.class,
            ex -> new GatewayTimeoutException("Profile fetch timed out"));
    }
}

// UserWebClient.java — Claude generates the WebClient wrapper too
@Component
public class UserWebClient {

    private final WebClient webClient;

    public UserWebClient(WebClient.Builder builder,
                         @Value("${services.user-service.url}") String baseUrl) {
        this.webClient = builder
            .baseUrl(baseUrl)
            .defaultHeader(HttpHeaders.CONTENT_TYPE, MediaType.APPLICATION_JSON_VALUE)
            .build();
    }

    public Mono<UserDto> getUser(Long userId) {
        return webClient.get()
            .uri("/users/{id}", userId)
            .retrieve()
            .onStatus(HttpStatusCode::is4xxClientError,
                resp -> resp.bodyToMono(ErrorResponse.class)
                    .flatMap(err -> Mono.error(new ClientException(err.getMessage()))))
            .bodyToMono(UserDto.class)
            .retryWhen(Retry.backoff(3, Duration.ofMillis(100))
                .filter(ex -> ex instanceof WebClientRequestException));
    }
}

// Custom span in a business method
@Service
@RequiredArgsConstructor
public class OrderService {

    private final Tracer tracer;
    private final UserServiceClient userServiceClient;

    public OrderDto processOrder(CreateOrderRequest request) {
        // Start a custom span for the business operation
        Span span = tracer.nextSpan()
            .name("order.process")
            .tag("order.user_id", String.valueOf(request.getUserId()))
            .start();

        try (Tracer.SpanInScope ws = tracer.withSpan(span)) {
            // Verify user — trace context propagates through Feign automatically
            UserDto user = userServiceClient.getUserById(request.getUserId());
            span.tag("order.user_status", user.getStatus().name());

            OrderEntity order = createOrderEntity(request, user);
            return orderRepository.save(order).toDto();

        } catch (Exception e) {
            span.error(e);
            throw e;
        } finally {
            span.end();
        }
    }
}