Micrometer Observation Integration

// Gradle
implementation("codes.domix:fun-observation:LATEST_VERSION")
// Micrometer — bring your own version (1.10.x – 1.16.x)
implementation("io.micrometer:micrometer-core:1.16.5")
// Optional: add a tracing bridge to also get distributed tracing spans
// implementation("io.micrometer:micrometer-tracing-bridge-otel:1.6.5")

<!-- Maven -->
<dependency>
    <groupId>codes.domix</groupId>
    <artifactId>fun-observation</artifactId>
    <version>LATEST_VERSION</version>
</dependency>
<!-- Micrometer — bring your own version (1.10.x – 1.16.x) -->
<dependency>
    <groupId>io.micrometer</groupId>
    <artifactId>micrometer-core</artifactId>
    <version>1.16.5</version>
</dependency>
<!-- Optional: add a tracing bridge to also get distributed tracing spans -->
<!--
<dependency>
    <groupId>io.micrometer</groupId>
    <artifactId>micrometer-tracing-bridge-otel</artifactId>
    <version>1.6.5</version>
</dependency>
-->

DmxObservation dmx = DmxObservation.of(observationRegistry, cause ->
    switch (cause) {
        case IOException _           -> "io";
        case TimeoutException _      -> "timeout";
        case IllegalStateException _ -> "state";
        default                      -> "other";
    }
);

DmxObserved.of("payment.charge")
    .registry(observationRegistry)
    .exceptionClassifier(cause -> cause instanceof IOException ? "io" : "other")
    .observeTry(() -> stripe.charge(amount));

import dmx.fun.Result;
import dmx.fun.Try;
import dmx.fun.observation.DmxObservation;
import io.micrometer.observation.ObservationRegistry;

// One-time setup — typically injected from the application context
DmxObservation dmx = DmxObservation.of(observationRegistry);

// metrics + spans in one call — name becomes the observation name
Try<Response> result = dmx.observeTry("http.client.get",
    () -> httpClient.get(url)
);

result
    .onSuccess(r  -> render(r))
    .onFailure(ex -> renderError(ex));

// Same with Result
Result<User, Throwable> user = dmx.observeResult("db.user.find",
    () -> userRepo.findById(id)
);

import dmx.fun.Try;
import dmx.fun.Result;
import dmx.fun.observation.DmxObserved;

// Chain observation name → registry → execute
Try<Receipt> result = DmxObserved.of("payment.charge")
    .registry(observationRegistry)
    .observeTry(() -> stripe.charge(amount));

// Same with Result
Result<User, Throwable> user = DmxObserved.of("db.user.find")
    .registry(observationRegistry)
    .observeResult(() -> userRepo.findById(id));

import dmx.fun.Result;
import dmx.fun.Try;
import dmx.fun.observation.DmxObservation;
import io.micrometer.observation.ObservationRegistry;

/**
 * An order service where each step is wrapped in its own named Observation.
 *
 * With Spring Boot 3.0+ and a tracing bridge on the classpath, each call
 * automatically produces:
 *   - A timer: payment_charge_seconds_count{outcome="success"|"failure"}
 *   - A child span: "payment.charge" tagged outcome + exception on failure
 *
 * No manual counter.increment(), Span.start(), or stopwatch calls needed.
 */
public class OrderService {

    private final DmxObservation dmx;
    private final PaymentGateway paymentGateway;
    private final InventoryClient inventoryClient;
    private final OrderRepository orderRepository;

    public OrderService(ObservationRegistry registry,
                        PaymentGateway paymentGateway,
                        InventoryClient inventoryClient,
                        OrderRepository orderRepository) {
        this.dmx               = DmxObservation.of(registry);
        this.paymentGateway    = paymentGateway;
        this.inventoryClient   = inventoryClient;
        this.orderRepository   = orderRepository;
    }

    public Result<Order, String> placeOrder(PlaceOrderCommand cmd) {

        // 1. Reserve inventory — observation: inventory.reserve
        Try<Reservation> reservation = dmx.observeTry("inventory.reserve",
            () -> inventoryClient.reserve(cmd.items())
        );
        if (reservation.isFailure()) {
            return Result.err("Inventory unavailable: " + reservation.getCause().getMessage());
        }

        // 2. Charge payment — observation: payment.charge
        Try<Receipt> receipt = dmx.observeTry("payment.charge",
            () -> paymentGateway.charge(cmd.amount(), cmd.paymentToken())
        );
        if (receipt.isFailure()) {
            inventoryClient.release(reservation.get());
            return Result.err("Payment failed: " + receipt.getCause().getMessage());
        }

        // 3. Persist order — observation: order.place
        return dmx.observeResult("order.place",
            () -> orderRepository.save(Order.from(cmd, reservation.get(), receipt.get()))
        )
        .mapError(ex -> "Failed to persist order: " + ex.getMessage());
    }
}

import dmx.fun.Try;
import dmx.fun.observation.DmxObservation;
import org.springframework.stereotype.Service;

@Service
public class PaymentService {

    private final DmxObservation dmx;  // injected — auto-configured by fun-spring-boot

    public PaymentService(DmxObservation dmx) {
        this.dmx = dmx;
    }

    public Try<Receipt> charge(Amount amount, PaymentToken token) {
        return dmx.observeTry("payment.charge",
            () -> gateway.charge(amount, token)
        );
    }
}

dmx.fun.observation.enabled=false   # disable DmxObservation auto-configuration

@Bean
DmxObservation dmxObservation(ObservationRegistry registry) {
    // Supply an explicit classifier in production — see "Exception key cardinality" above.
    return DmxObservation.of(registry);
}

@Service
public class PaymentService {

    private final DmxObservation dmx;

    public PaymentService(ObservationRegistry registry) {
        // Supply an explicit classifier in production — see "Exception key cardinality" above.
        this.dmx = DmxObservation.of(registry);
    }
}