One Graph.
Design, Run, and Observe
Your Distributed System.

// HTTP handler
func processOrderHandler(w http.ResponseWriter, r *http.Request) {
    var req ProcessOrderRequest
    if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
        http.Error(w, err.Error(), 400); return
    }
    ctx, cancel := context.WithTimeout(r.Context(), 30*time.Second)
    defer cancel()

    orderID := uuid.New().String()
    results := make(chan OrderItemResult, len(req.Items))
    errs    := make(chan error, len(req.Items))

    var wg sync.WaitGroup
    for _, item := range req.Items {
        wg.Add(1)
        go func(item OrderItem) {
            defer wg.Done()
            span, ctx := tracer.StartSpanFromContext(ctx, "inventory.check")
            defer span.Finish()
            conn, err := grpc.DialContext(ctx, cfg.InventoryAddr,
                grpc.WithInsecure(),
                grpc.WithUnaryInterceptor(otelgrpc.UnaryClientInterceptor()),
            )
            if err != nil { errs <- err; return }
            defer conn.Close()
            client := pb.NewInventoryClient(conn)
            res, err := client.ProcessOrderItem(ctx,
                &pb.ProcessOrderItemRequest{
                    Sku: item.SKU, Quantity: int32(item.Qty),
                })
            if err != nil { errs <- err; return }
            results <- OrderItemResult{SKU: item.SKU, Reserved: res.Reserved}
        }(item)
    }

    // deadline ticker
    softDeadline := time.NewTimer(cfg.SoftDeadlineDuration)
    defer softDeadline.Stop()

    var confirmed []OrderItemResult
    received := 0
    status := "CONFIRMED"
    for received < len(req.Items) {
        select {
        case r := <-results:
            confirmed = append(confirmed, r)
            if !r.Reserved { status = "PARTIALLY_CONFIRMED" }
            received++
        case err := <-errs:
            log.Error("item error", zap.Error(err))
            received++
        case <-softDeadline.C:
            status = "TIMED_OUT"; goto done
        case <-ctx.Done():
            status = "TIMED_OUT"; goto done
        }
    }
done:
    // metrics
    orderDuration.Observe(time.Since(start).Seconds())
    ordersTotal.With(prometheus.Labels{"status": status}).Inc()

    w.Header().Set("Content-Type", "application/json")
    json.NewEncoder(w).Encode(ProcessOrderResponse{
        OrderID: orderID, Status: status,
        ConfirmedItems: confirmed,
    })
}