Micrometer Integration

// Gradle
implementation("codes.domix:fun-micrometer:LATEST_VERSION")
// Micrometer — bring your own version (1.5.x – 1.16.x)
implementation("io.micrometer:micrometer-core:1.16.5")
// Add your Micrometer backend, e.g. Prometheus:
// implementation("io.micrometer:micrometer-registry-prometheus:1.16.5")

<!-- Maven -->
<dependency>
    <groupId>codes.domix</groupId>
    <artifactId>fun-micrometer</artifactId>
    <version>LATEST_VERSION</version>
</dependency>
<!-- Micrometer — bring your own version (1.5.x – 1.16.x) -->
<dependency>
    <groupId>io.micrometer</groupId>
    <artifactId>micrometer-core</artifactId>
    <version>1.16.5</version>
</dependency>

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

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

import dmx.fun.Result;
import dmx.fun.Try;
import dmx.fun.micrometer.DmxMicrometer;
import io.micrometer.core.instrument.MeterRegistry;
import io.micrometer.core.instrument.Tags;

// One-time setup — typically injected or obtained from the application context
DmxMicrometer dmx = DmxMicrometer.of(registry);

// Instrument a Try operation — name + tags identify the metric
Try<Response> result = dmx.recordTry(
    "http.client.get",
    Tags.of("endpoint", "/users"),
    () -> httpClient.get(url)
);

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

// Instrument a Result operation
Result<User, Throwable> user = dmx.recordResult(
    "db.user.find",
    Tags.of("table", "users"),
    () -> userRepo.findById(id)
);

import dmx.fun.Try;
import dmx.fun.Result;
import dmx.fun.micrometer.DmxMetered;
import io.micrometer.core.instrument.Tags;

// Chain name → tags → registry → execute
Try<Receipt> result = DmxMetered.of("payment.charge")
    .tags(Tags.of("provider", "stripe", "currency", "USD"))
    .registry(registry)
    .recordTry(() -> stripe.charge(amount));

// Same with Result
Result<User, Throwable> user = DmxMetered.of("db.user.find")
    .tags(Tags.of("table", "users"))
    .registry(registry)
    .recordResult(() -> userRepo.findById(id));

import dmx.fun.Option;
import dmx.fun.Result;
import dmx.fun.Try;
import dmx.fun.micrometer.DmxMicrometer;
import io.micrometer.core.instrument.MeterRegistry;
import io.micrometer.core.instrument.Tags;

/**
 * An order service that automatically records metrics for every Try/Result
 * operation without scattering manual counter.increment() calls throughout
 * the business logic.
 *
 * After startup, the following metrics appear in your Micrometer backend
 * (e.g. Prometheus /actuator/prometheus):
 *
 *   order_place_count{outcome="success",...}
 *   order_place_count{outcome="failure",...}
 *   order_place_duration_seconds_count{outcome="success",...}
 *   order_place_duration_seconds_sum{outcome="success",...}
 *   order_place_failure_total{exception="PaymentException",...}
 *
 *   inventory_reserve_count{outcome="success",...}
 *   ...
 */
public class OrderService {

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

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

    /**
     * Places an order: reserves inventory, charges payment, and persists.
     * Each step is instrumented independently so failures are traceable
     * to the exact service call — no wrapping try/catch needed.
     * Keep metric tags bounded: put customerId/orderId in logs or traces,
     * not in Micrometer tags.
     */
    public Result<Order, String> placeOrder(PlaceOrderCommand cmd) {
        Tags orderTags = Tags.of("channel", cmd.channel(), "region", cmd.region());

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

        // 2. Charge payment — metrics: payment.charge.count / duration / failure
        Try<Receipt> receipt = dmx.recordTry(
            "payment.charge",
            orderTags.and("provider", cmd.paymentProvider()),
            () -> paymentGateway.charge(cmd.amount(), cmd.paymentToken())
        );
        if (receipt.isFailure()) {
            inventoryClient.release(reservation.get());
            return Result.err("Payment failed: " + receipt.getCause().getMessage());
        }

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

    /**
     * Looks up an order by ID. Missing orders are modelled as Option.none()
     * rather than a failure — the metric still records outcome=success.
     */
    public Option<Order> findOrder(String orderId) {
        return dmx.recordTry(
            "order.find",
            Tags.of("lookup", "by-id", "channel", "api"),
            () -> orderRepository.findById(orderId)
        )
        .toOption()
        .flatMap(Option::fromOptional);
    }
}