Spring Cloud микросервисы: обнаружение и отслеживание

@SpringBootApplication
@EnableEurekaServer
public class EurekaServerApplication {
    public static void main(String[] args) {
        SpringApplication.run(EurekaServerApplication.class, args);
    }
}

@Configuration
public class LoadBalancerConfig {
    @Bean
    public ServiceInstanceListSupplier discoveryClientServiceInstanceListSupplier(
            DiscoveryClient discoveryClient) {
        return new DiscoveryClientServiceInstanceListSupplier(discoveryClient);
    }
}

@SpringBootApplication
@EnableDiscoveryClient
public class MyServiceApplication {
    public static void main(String[] args) {
        SpringApplication.run(MyServiceApplication.class, args);
    }
}

INFO 14828 --- [main] c.n.d.s.r.DiscoveryClient: Initializing Eureka in region us-east-1
INFO 14828 --- [main] c.n.d.s.r.DiscoveryClient: Registering service instance payment-service/192.168.1.5:payment-service:8080 with eureka

@Configuration
public class RestTemplateConfig {
    @Bean
    @LoadBalanced
    public RestTemplate restTemplate() {
        return new RestTemplate();
    }
}

@Service
public class OrderService {
    private final RestTemplate restTemplate;
    
    public OrderService(RestTemplate restTemplate) {
        this.restTemplate = restTemplate;
    }
    
    public PaymentResponse processPayment(Long orderId, BigDecimal amount) {
        PaymentRequest request = new PaymentRequest(orderId, amount);
        // payment-service - это имя сервиса в Eureka
        return restTemplate.postForObject("http://payment-service/api/payments", request, PaymentResponse.class);
    }
}

@Configuration
public class WebClientConfig {
    @Bean
    @LoadBalanced
    public WebClient.Builder webClientBuilder() {
        return WebClient.builder();
    }
}

@Service
public class ReactiveOrderService {
    private final WebClient.Builder webClientBuilder;
    
    public ReactiveOrderService(WebClient.Builder webClientBuilder) {
        this.webClientBuilder = webClientBuilder;
    }
    
    public Mono<PaymentResponse> processPayment(Long orderId, BigDecimal amount) {
        PaymentRequest request = new PaymentRequest(orderId, amount);
        
        return webClientBuilder.build()
            .post()
            .uri("http://payment-service/api/payments")
            .bodyValue(request)
            .retrieve()
            .bodyToMono(PaymentResponse.class);
    }
}

@SpringBootApplication
@EnableFeignClients
public class OrderServiceApplication {
    public static void main(String[] args) {
        SpringApplication.run(OrderServiceApplication.class, args);
    }
}

@FeignClient(name = "payment-service")
public interface PaymentClient {
    @PostMapping("/api/payments")
    PaymentResponse processPayment(@RequestBody PaymentRequest request);
}

@Service
public class OrderService {
    private final PaymentClient paymentClient;
    
    public OrderService(PaymentClient paymentClient) {
        this.paymentClient = paymentClient;
    }
    
    public PaymentResponse processPayment(Long orderId, BigDecimal amount) {
        PaymentRequest request = new PaymentRequest(orderId, amount);
        return paymentClient.processPayment(request);
    }
}

@FeignClient(
    name = "payment-service",
    fallback = PaymentClientFallback.class,
    configuration = PaymentClientConfig.class
)
public interface PaymentClient {
    @PostMapping("/api/payments")
    PaymentResponse processPayment(@RequestBody PaymentRequest request);
}
 
@Component
class PaymentClientFallback implements PaymentClient {
    @Override
    public PaymentResponse processPayment(PaymentRequest request) {
        // Возвращает результат по умолчанию или выбрасывает ошибку
        return new PaymentResponse(request.getOrderId(), PaymentStatus.FAILED, "Service unavailable");
    }
}
 
@Configuration
class PaymentClientConfig {
    @Bean
    public Request.Options options() {
        // Таймауты для подключения и чтения в миллисекундах
        return new Request.Options(2000, 5000);
    }
}

@Configuration
public class CustomLoadBalancerConfig {
    @Bean
    ReactorLoadBalancer<ServiceInstance> randomLoadBalancer(Environment environment,
            LoadBalancerClientFactory clientFactory) {
        String serviceName = environment.getProperty("loadbalanced.service.name");
        return new RandomLoadBalancer(clientFactory
                .getLazyProvider(serviceName, ServiceInstanceListSupplier.class),
                serviceName);
    }
}

@Configuration
@LoadBalancerClient(name = "payment-service", configuration = CustomLoadBalancerConfig.class)
public class LoadBalancerConfiguration {
}

public class HeaderBasedLoadBalancer implements ReactorServiceInstanceLoadBalancer {
    private final ObjectProvider<ServiceInstanceListSupplier> serviceInstanceListSupplierProvider;
    private final String serviceId;
 
    public HeaderBasedLoadBalancer(ObjectProvider<ServiceInstanceListSupplier> serviceInstanceListSupplierProvider,
                              String serviceId) {
        this.serviceInstanceListSupplierProvider = serviceInstanceListSupplierProvider;
        this.serviceId = serviceId;
    }
 
    @Override
    public Mono<Response<ServiceInstance>> choose(Request request) {
        // Извлекаем заголовок из контекста запроса
        String targetDataCenter = ServerWebExchangeUtils.getContext(request).map(ctx -> 
            ctx.getExchange().getRequest().getHeaders().getFirst("X-Target-DataCenter")).orElse(null);
        
        ServiceInstanceListSupplier supplier = serviceInstanceListSupplierProvider.getIfAvailable();
        return supplier.get().next().map(instances -> {
            // Фильтруем экземпляры по метаданным
            List<ServiceInstance> filteredInstances = instances.stream()
                .filter(instance -> targetDataCenter == null || 
                       targetDataCenter.equals(instance.getMetadata().get("datacenter")))
                .collect(Collectors.toList());
            
            // Если нет подходящих, используем все доступные
            if (filteredInstances.isEmpty()) {
                filteredInstances = instances;
            }
            
            // Выбираем случайный экземпляр из отфильтрованных
            ServiceInstance instance = filteredInstances.isEmpty() ? null : 
                filteredInstances.get(new Random().nextInt(filteredInstances.size()));
                
            return new DefaultResponse(instance);
        });
    }
}

2023-08-15 14:23:07.782 INFO [order-service,5fe3d8f9c83da3ee,cbe8ef14e68a8304] 12232 --- [nio-8080-exec-3] c.e.o.controller.OrderController        : Processing order for customer: 42

@Component
public class CustomTagsContributor implements TracingHandlerInterceptor.TagsContributor {
    @Override
    public Map<String, String> requestTags(HttpServletRequest request) {
        Map<String, String> tags = new HashMap<>();
        tags.put("customerType", request.getHeader("X-Customer-Type"));
        return tags;
    }
 
    @Override
    public Map<String, String> responseTags(HttpServletResponse response) {
        Map<String, String> tags = new HashMap<>();
        tags.put("httpStatus", String.valueOf(response.getStatus()));
        return tags;
    }
}

@Service
public class OrderProcessingService {
    private final Tracer tracer;
    
    public OrderProcessingService(Tracer tracer) {
        this.tracer = tracer;
    }
    
    public void processOrder(Order order) {
        Span paymentSpan = tracer.nextSpan().name("payment-processing").start();
        try (SpanInScope ws = tracer.withSpan(paymentSpan.start())) {
            // Логика обработки платежа
            paymentSpan.tag("orderId", order.getId().toString());
            paymentSpan.tag("amount", order.getTotalAmount().toString());
        } finally {
            paymentSpan.finish();
        }
        
        // Остальная логика обработки заказа
    }
}

@Component
class CustomSampler implements Sampler {
    @Override
    public boolean isSampled(Span.SpanBuilder spanBuilder) {
        // Решение о сэмплировании на основе контекста
        String path = MDC.get("http.path");
        if (path != null && path.startsWith("/api/critical")) {
            return true;  // Всегда трассировать критически важные запросы
        }
        return Math.random() < 0.1;  // Для остальных - 10% вероятность
    }
}

@Component
public class TraceContextPropagatingMdcFilter extends OncePerRequestFilter {
  @Override
  protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, 
                               FilterChain filterChain) throws IOException, ServletException {
      boolean isErrorContext = false;
      try {
          filterChain.doFilter(request, response);
      } catch (Exception e) {
          isErrorContext = true;
          throw e;
      } finally {
          // Увеличиваем уровень логирования для запросов с ошибками
          if (isErrorContext || response.getStatus() >= 400) {
              MDC.put("logLevel", "TRACE");
          }
      }
  }
}

@Bean
SpanAdjuster customSanitizer() {
    return span -> {
        // Маскируем персональные данные в тегах
        span.tags().forEach((key, value) -> {
            if (key.equals("user.email") && value != null) {
                span.tag(key, value.toString().replaceAll("(.*)@.*", "$1@***"));
            }
        });
        return span;
    };
}

@SpringBootApplication
@EnableDiscoveryClient
public class ApiGatewayApplication {
  public static void main(String[] args) {
      SpringApplication.run(ApiGatewayApplication.class, args);
  }
}

@Service
public class OrderProcessingService {
  private final PaymentClient paymentClient;
  
  @CircuitBreaker(name = "paymentService", fallbackMethod = "processPaymentFallback")
  @Retry(name = "paymentService", fallbackMethod = "processPaymentFallback")
  @Bulkhead(name = "paymentService", fallbackMethod = "processPaymentFallback")
  public PaymentResponse processPayment(Long orderId, BigDecimal amount) {
      return paymentClient.processPayment(new PaymentRequest(orderId, amount));
  }
  
  public PaymentResponse processPaymentFallback(Long orderId, BigDecimal amount, Exception e) {
      log.error("Failed to process payment for order: {}, amount: {}", orderId, amount, e);
      // Сохраняем запрос оплаты в очередь для последующей обработки
      paymentQueueService.queuePayment(orderId, amount);
      return new PaymentResponse(orderId, PaymentStatus.PENDING, "Payment queued for processing");
  }
}

@Service
public class OrderCompletionService {
  private final StreamBridge streamBridge;
  
  public void completeOrder(Order order) {
      // Бизнес-логика обработки заказа
      
      // Публикация события о завершении заказа
      DeliveryRequestEvent event = new DeliveryRequestEvent(order.getId(), order.getDeliveryAddress());
      streamBridge.send("delivery-requests", event);
  }
}

@Bean
public Consumer<DeliveryRequestEvent> processDeliveryRequests() {
  return event -> {
      log.info("Processing delivery request for order: {}", event.getOrderId());
      // Логика организации доставки
  }
}