Micrometer Tracing Integration

// Gradle
implementation("codes.domix:fun-tracing:LATEST_VERSION")
// Micrometer Tracing — bring your own version (1.2.x – 1.6.x)
implementation("io.micrometer:micrometer-tracing:1.6.5")
// Add a bridge — OTel (recommended) or Brave:
implementation("io.micrometer:micrometer-tracing-bridge-otel:1.6.5")
// implementation("io.micrometer:micrometer-tracing-bridge-brave:1.6.5")

<!-- Maven -->
<dependency>
    <groupId>codes.domix</groupId>
    <artifactId>fun-tracing</artifactId>
    <version>LATEST_VERSION</version>
</dependency>
<!-- Micrometer Tracing — bring your own version (1.2.x – 1.6.x) -->
<dependency>
    <groupId>io.micrometer</groupId>
    <artifactId>micrometer-tracing</artifactId>
    <version>1.6.5</version>
</dependency>
<!-- Add a bridge — OTel (recommended) or Brave -->
<dependency>
    <groupId>io.micrometer</groupId>
    <artifactId>micrometer-tracing-bridge-otel</artifactId>
    <version>1.6.5</version>
</dependency>

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

DmxTraced.of("payment.charge")
    .tracer(tracer)
    .exceptionClassifier(cause -> cause instanceof IOException ? "io" : "other")
    .traceTry(() -> stripe.charge(amount));

import dmx.fun.Result;
import dmx.fun.Try;
import dmx.fun.tracing.DmxTracing;
import io.micrometer.tracing.Tracer;

// One-time setup — typically injected from the application context
DmxTracing dmx = DmxTracing.of(tracer);  // io.micrometer.tracing.Tracer

// Instrument a Try operation — name becomes the span name
Try<Response> result = dmx.traceTry("http.client.get",
    () -> httpClient.get(url)
);

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

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

import dmx.fun.Try;
import dmx.fun.Result;
import dmx.fun.tracing.DmxTraced;

// Chain span name → tracer → execute
Try<Receipt> result = DmxTraced.of("payment.charge")
    .tracer(tracer)
    .traceTry(() -> stripe.charge(amount));

// Same with Result
Result<User, Throwable> user = DmxTraced.of("db.user.find")
    .tracer(tracer)
    .traceResult(() -> userRepo.findById(id));

import dmx.fun.Result;
import dmx.fun.Try;
import dmx.fun.tracing.DmxTracing;
import io.micrometer.tracing.Tracer;

/**
 * An order service where each step — inventory reservation, payment charge,
 * and persistence — is wrapped in its own named span.
 *
 * After a request completes, the trace backend (Zipkin, Jaeger, etc.) shows
 * a timeline of child spans, each tagged with outcome=success|failure.
 * Failed steps also carry exception=<ClassName> and are marked as errors,
 * making the root cause visible at a glance without digging into logs.
 */
public class OrderService {

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

    public OrderService(Tracer tracer,
                        PaymentGateway paymentGateway,
                        InventoryClient inventoryClient,
                        OrderRepository orderRepository) {
        this.dmx               = DmxTracing.of(tracer);
        this.paymentGateway    = paymentGateway;
        this.inventoryClient   = inventoryClient;
        this.orderRepository   = orderRepository;
    }

    /**
     * Places an order: reserves inventory, charges payment, and persists.
     * Each step is a child span of the active trace context — no manual
     * Span.start() / Span.end() calls needed.
     */
    public Result<Order, String> placeOrder(PlaceOrderCommand cmd) {

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

        // 2. Charge payment — span: payment.charge
        Try<Receipt> receipt = dmx.traceTry("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 — span: order.place
        return dmx.traceResult("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.tracing.DmxTracing;
import org.springframework.stereotype.Service;

@Service
public class PaymentService {

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

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

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

dmx.fun.tracing.enabled=false   # disable DmxTracing auto-configuration

@Bean
DmxTracing dmxTracing(Tracer tracer) {
    return DmxTracing.of(tracer);  // or any custom Tracer
}

@Service
public class PaymentService {

    private final DmxTracing dmx;

    public PaymentService(Tracer tracer) {
        this.dmx = DmxTracing.of(tracer);
    }
}