// Before: Fragile, blocking distributed calls
@Transactional
public void processOrder(CreateOrderCommand command) {
    Order order = orderService.createOrder(command);
    paymentService.processPayment(order.getPaymentInfo()); // Blocks thread
    inventoryService.reserveItems(order.getItems());       // Can fail silently
    // No compensation logic, manual cleanup required
}

// After: Resilient saga with automatic compensation
@WorkflowMethod
public void processOrderSaga(CreateOrderCommand command) {
    Saga saga = new Saga(new SagaOptions.Builder().build());
    
    try {
        OrderCreatedEvent order = saga.addCompensation(
            () -> orderService.cancelOrder(command.getOrderId()),
            () -> orderService.createOrder(command)
        );
        
        PaymentProcessedEvent payment = saga.addCompensation(
            () -> paymentService.refundPayment(order.getPaymentId()),
            () -> paymentService.processPayment(order.getPaymentInfo())
        );
        
        saga.addCompensation(
            () -> inventoryService.releaseItems(order.getItems()),
            () -> inventoryService.reserveItems(order.getItems())
        );
        
    } catch (Exception e) {
        saga.compensate(); // Automatic rollback
        throw e;
    }
}

// Automatic correlation across all services
@KafkaListener(topics = "ordering.order.created.v1")
public void handleOrderCreated(OrderCreatedEvent event) {
    MDC.put("trace_id", event.getTraceId());
    MDC.put("idempotency_key", event.getIdempotencyKey());
    log.info("Processing order: {}", event.getOrderId());
    // All downstream calls automatically inherit trace context
}

// Resilient payment flow with automatic retries and compensation
@Component
public class PaymentSagaOrchestrator {
    
    @WorkflowMethod
    public PaymentResult processPayment(ProcessPaymentCommand command) {
        var options = ActivityOptions.newBuilder()
            .setRetryOptions(RetryOptions.newBuilder()
                .setInitialInterval(Duration.ofSeconds(1))
                .setMaximumAttempts(5)
                .setBackoffCoefficient(2.0)
                .build())
            .setStartToCloseTimeout(Duration.ofMinutes(2))
            .build();
            
        var activities = Workflow.newActivityStub(PaymentActivities.class, options);
        
        // Each step automatically retries with exponential backoff
        var preAuth = activities.preAuthorizePayment(command);
        var charge = activities.capturePayment(preAuth.getAuthId());
        var notification = activities.sendPaymentConfirmation(charge);
        
        return PaymentResult.success(charge.getTransactionId());
    }
}

// Outbox pattern ensuring exactly-once delivery
@Transactional
public void createOrder(CreateOrderCommand command) {
    // Single transaction for consistency
    Order order = orderRepository.save(new Order(command));
    
    // Outbox entry ensures event delivery even if Kafka is down
    outboxRepository.save(OutboxEntry.builder()
        .aggregateId(order.getId())
        .eventType("OrderCreatedEvent")
        .payload(orderMapper.toEvent(order))
        .build());
        
    // Separate process (Debezium CDC) publishes to Kafka
    // Guaranteed delivery, zero message loss
}

// Choreographed saga using domain events
@EventHandler
public class InventoryService {
    
    @KafkaListener(topics = "ordering.order.created.v1")
    @Retryable(value = {OptimisticLockingFailureException.class})
    public void handleOrderCreated(OrderCreatedEvent event) {
        try {
            reserveInventory(event.getItems(), event.getOrderId());
            publishEvent(InventoryReservedEvent.from(event));
        } catch (InsufficientInventoryException e) {
            publishEvent(InventoryReservationFailedEvent.from(event, e));
            // Order service receives failure event and cancels order
        }
    }
}

# Cursor will automatically suggest saga patterns
# when you type: "create order processing workflow"

# Example transformation:
# 1. Highlight your existing @Transactional method
# 2. Ask Cursor: "Convert this to a resilient saga pattern"
# 3. Cursor generates complete saga implementation with compensation

// Cursor auto-generates this boilerplate
@Configuration
public class ObservabilityConfig {
    
    @Bean
    public TraceIdGenerator traceIdGenerator() {
        return () -> UUID.randomUUID().toString();
    }
    
    @Bean
    public MeterRegistry meterRegistry() {
        return new PrometheusMeterRegistry(PrometheusConfig.DEFAULT);
    }
}

// Cursor suggests Resilience4j patterns automatically
@Component
public class PaymentServiceClient {
    
    @CircuitBreaker(name = "payment-service", fallbackMethod = "fallbackPayment")
    @Retry(name = "payment-service")
    @TimeLimiter(name = "payment-service")
    public CompletableFuture<PaymentResult> processPayment(PaymentRequest request) {
        return restTemplate.postForObject("/payments", request, PaymentResult.class);
    }
}

// Cursor generates complete test infrastructure
@SpringBootTest
@Testcontainers
class DistributedTransactionIntegrationTest {
    
    @Container
    static PostgreSQLContainer<?> postgres = new PostgreSQLContainer<>("postgres:15");
    
    @Container
    static KafkaContainer kafka = new KafkaContainer(DockerImageName.parse("confluentinc/cp-kafka:7.4.0"));
    
    @Test
    void shouldHandlePaymentFailureWithCompensation() {
        // Test complete saga failure and recovery
        // Cursor auto-generates failure scenarios
    }
}