Microservice Architecture #

// pkg/httpclient/client.go — reusable HTTP client dengan timeout dan retry
package httpclient

import (
	"context"
	"encoding/json"
	"fmt"
	"net/http"
	"time"
)

// Config mengonfigurasi behavior HTTP client
type Config struct {
	BaseURL    string
	Timeout    time.Duration
	MaxRetries int
	RetryDelay time.Duration
}

// Client adalah HTTP client yang opinionated untuk inter-service communication
type Client struct {
	config Config
	http   *http.Client
}

func New(config Config) *Client {
	if config.Timeout == 0 {
		config.Timeout = 5 * time.Second
	}
	if config.MaxRetries == 0 {
		config.MaxRetries = 3
	}
	if config.RetryDelay == 0 {
		config.RetryDelay = 100 * time.Millisecond
	}

	return &Client{
		config: config,
		http:   &http.Client{Timeout: config.Timeout},
	}
}

// Get melakukan HTTP GET dengan retry otomatis untuk transient error
func (c *Client) Get(ctx context.Context, path string, result interface{}) error {
	url := c.config.BaseURL + path
	var lastErr error

	for attempt := 0; attempt <= c.config.MaxRetries; attempt++ {
		if attempt > 0 {
			select {
			case <-ctx.Done():
				return ctx.Err()
			case <-time.After(c.config.RetryDelay * time.Duration(attempt)):
			}
		}

		req, err := http.NewRequestWithContext(ctx, http.MethodGet, url, nil)
		if err != nil {
			return fmt.Errorf("gagal membuat request: %w", err)
		}

		// Propagasi trace ID untuk distributed tracing
		if traceID := ctx.Value("trace_id"); traceID != nil {
			req.Header.Set("X-Trace-ID", fmt.Sprint(traceID))
		}

		resp, err := c.http.Do(req)
		if err != nil {
			lastErr = err
			continue // retry
		}
		defer resp.Body.Close()

		// Jangan retry untuk client error (4xx)
		if resp.StatusCode >= 400 && resp.StatusCode < 500 {
			return fmt.Errorf("client error %d dari %s", resp.StatusCode, url)
		}

		// Retry untuk server error (5xx)
		if resp.StatusCode >= 500 {
			lastErr = fmt.Errorf("server error %d dari %s", resp.StatusCode, url)
			continue
		}

		if result != nil {
			if err := json.NewDecoder(resp.Body).Decode(result); err != nil {
				return fmt.Errorf("gagal decode response: %w", err)
			}
		}
		return nil
	}

	return fmt.Errorf("setelah %d percobaan: %w", c.config.MaxRetries, lastErr)
}

// internal/order/user_client.go — client untuk User Service
package order

import (
	"context"
	"fmt"

	"myapp/pkg/httpclient"
)

// UserServiceClient adalah client untuk berkomunikasi dengan User Service
type UserServiceClient struct {
	client *httpclient.Client
}

func NewUserServiceClient(baseURL string) *UserServiceClient {
	return &UserServiceClient{
		client: httpclient.New(httpclient.Config{
			BaseURL:    baseURL,
			Timeout:    3 * time.Second,
			MaxRetries: 2,
		}),
	}
}

type userResponse struct {
	ID       string `json:"id"`
	FullName string `json:"full_name"`
	IsActive bool   `json:"is_active"`
}

// ValidateUserActive memanggil User Service untuk memvalidasi user
func (c *UserServiceClient) ValidateUserActive(ctx context.Context, userID string) error {
	var user userResponse
	if err := c.client.Get(ctx, fmt.Sprintf("/users/%s", userID), &user); err != nil {
		return fmt.Errorf("gagal validasi user: %w", err)
	}
	if !user.IsActive {
		return fmt.Errorf("user %s tidak aktif", userID)
	}
	return nil
}

// pkg/circuitbreaker/breaker.go
package circuitbreaker

import (
	"errors"
	"sync"
	"time"
)

type State int

const (
	StateClosed   State = iota // Normal: request diizinkan
	StateOpen                  // Terbuka: request ditolak langsung
	StateHalfOpen              // Setengah terbuka: satu request percobaan
)

var ErrCircuitOpen = errors.New("circuit breaker terbuka — service tidak tersedia")

type Breaker struct {
	mu           sync.Mutex
	state        State
	failures     int
	maxFailures  int
	successCount int
	lastFailure  time.Time
	openDuration time.Duration
}

func New(maxFailures int, openDuration time.Duration) *Breaker {
	return &Breaker{
		maxFailures:  maxFailures,
		openDuration: openDuration,
	}
}

// Execute menjalankan fn melalui circuit breaker
func (b *Breaker) Execute(fn func() error) error {
	b.mu.Lock()
	state := b.currentState()
	b.mu.Unlock()

	if state == StateOpen {
		return ErrCircuitOpen // ✓ fail fast — tidak mencoba sama sekali
	}

	err := fn()

	b.mu.Lock()
	defer b.mu.Unlock()

	if err != nil {
		b.recordFailure()
	} else {
		b.recordSuccess()
	}
	return err
}

func (b *Breaker) currentState() State {
	if b.state == StateOpen {
		if time.Since(b.lastFailure) > b.openDuration {
			b.state = StateHalfOpen
			b.successCount = 0
		}
	}
	return b.state
}

func (b *Breaker) recordFailure() {
	b.failures++
	b.lastFailure = time.Now()
	if b.failures >= b.maxFailures {
		b.state = StateOpen
	}
}

func (b *Breaker) recordSuccess() {
	b.failures = 0
	if b.state == StateHalfOpen {
		b.successCount++
		if b.successCount >= 2 {
			b.state = StateClosed // ✓ pulih kembali
		}
	}
}

// internal/order/handler.go — structured logging dengan trace ID
package order

import (
	"encoding/json"
	"log/slog"
	"net/http"
	"time"

	"github.com/google/uuid"
)

// Middleware untuk inject trace ID dan structured logging
func TracingMiddleware(next http.Handler) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		// Generate atau propagasi trace ID
		traceID := r.Header.Get("X-Trace-ID")
		if traceID == "" {
			traceID = uuid.New().String()
		}

		// Inject ke context untuk dipropagasi ke downstream calls
		ctx := context.WithValue(r.Context(), "trace_id", traceID)

		// Set di response header
		w.Header().Set("X-Trace-ID", traceID)

		start := time.Now()
		rw := &responseWriter{ResponseWriter: w, statusCode: http.StatusOK}

		next.ServeHTTP(rw, r.WithContext(ctx))

		// Structured log setiap request
		slog.InfoContext(ctx, "request completed",
			"trace_id", traceID,
			"method", r.Method,
			"path", r.URL.Path,
			"status", rw.statusCode,
			"duration_ms", time.Since(start).Milliseconds(),
			"service", "order-service",
		)
	})
}

type responseWriter struct {
	http.ResponseWriter
	statusCode int
}

func (rw *responseWriter) WriteHeader(code int) {
	rw.statusCode = code
	rw.ResponseWriter.WriteHeader(code)
}

// Handler dengan structured logging
func (h *Handler) CreateOrder(w http.ResponseWriter, r *http.Request) {
	traceID := r.Context().Value("trace_id")

	var req CreateOrderRequest
	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
		slog.WarnContext(r.Context(), "invalid request body",
			"trace_id", traceID,
			"error", err.Error(),
		)
		http.Error(w, "request tidak valid", http.StatusBadRequest)
		return
	}

	slog.InfoContext(r.Context(), "creating order",
		"trace_id", traceID,
		"customer_id", req.CustomerID,
		"item_count", len(req.Items),
	)

	output, err := h.service.CreateOrder(r.Context(), req.toInput())
	if err != nil {
		slog.ErrorContext(r.Context(), "failed to create order",
			"trace_id", traceID,
			"customer_id", req.CustomerID,
			"error", err.Error(),
		)
		http.Error(w, err.Error(), http.StatusUnprocessableEntity)
		return
	}

	slog.InfoContext(r.Context(), "order created successfully",
		"trace_id", traceID,
		"order_id", output.OrderID,
	)

	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(http.StatusCreated)
	json.NewEncoder(w).Encode(output)
}

// internal/order/saga_handler.go — menangani hasil dari service lain
package order

import (
	"context"
	"log/slog"

	"myapp/internal/shared/eventbus"
)

// PaymentFailedEvent diterima dari Payment Service
type PaymentFailedEvent struct {
	OrderID string
	Reason  string
}

func (e PaymentFailedEvent) EventName() string { return "payment.failed" }

// SagaHandler menangani compensating transactions
type SagaHandler struct {
	repo     Repository
	eventBus *eventbus.EventBus
}

// HandlePaymentFailed adalah compensating transaction untuk order
func (h *SagaHandler) HandlePaymentFailed(ctx context.Context, event eventbus.Event) error {
	e, ok := event.(PaymentFailedEvent)
	if !ok {
		return nil
	}

	slog.InfoContext(ctx, "payment failed, cancelling order",
		"order_id", e.OrderID,
		"reason", e.Reason,
	)

	order, err := h.repo.FindByID(ctx, e.OrderID)
	if err != nil {
		return err
	}

	// Compensating transaction: batalkan order
	if err := order.Cancel("payment failed: " + e.Reason); err != nil {
		return err
	}

	if err := h.repo.Save(ctx, order); err != nil {
		return err
	}

	// Publikasikan event kompensasi
	return h.eventBus.Publish(ctx, OrderCancelledEvent{
		OrderID: e.OrderID,
		Reason:  "payment failed",
	})
}

// ✗ Shared database antar service — distributed monolith
// Order Service langsung query ke database User Service
func (r *OrderRepo) GetOrderWithUser(ctx context.Context, orderID string) (*OrderWithUser, error) {
	// ✗ JOIN ke database service lain — coupling yang paling berbahaya
	return r.db.QueryContext(ctx, `
		SELECT o.id, u.full_name
		FROM order_db.orders o
		JOIN user_db.users u ON u.id = o.customer_id
		WHERE o.id = $1
	`, orderID)
}

// ✓ Setiap service hanya akses database-nya sendiri
// Data dari service lain diambil via API call
func (s *OrderService) GetOrderWithUser(ctx context.Context, orderID string) (*OrderDisplay, error) {
	order, err := s.repo.FindByID(ctx, orderID)
	if err != nil {
		return nil, err
	}

	// Ambil nama user dari User Service via HTTP
	user, err := s.userClient.GetUser(ctx, order.CustomerID)
	if err != nil {
		// Graceful degradation: tampilkan order meski user tidak tersedia
		return &OrderDisplay{OrderID: orderID, CustomerName: "Unknown"}, nil
	}

	return &OrderDisplay{OrderID: orderID, CustomerName: user.FullName}, nil
}

// ✗ Synchronous chain yang terlalu panjang — cascade failure
// Order → Inventory → Warehouse → Supplier (semua sync)
func (s *OrderService) CreateOrder(ctx context.Context, req CreateOrderInput) error {
	// ✗ 4 hop sync — jika Supplier lambat, seluruh order creation lambat
	inventory := s.inventoryClient.CheckStock(ctx, req.Items)
	warehouse := s.warehouseClient.Reserve(ctx, inventory)
	supplier := s.supplierClient.Confirm(ctx, warehouse)
	_ = supplier
	return s.repo.Save(ctx, buildOrder(req))
}

// ✓ Hanya validasi kritis yang sync, sisanya async via event
func (s *OrderService) CreateOrder(ctx context.Context, req CreateOrderInput) error {
	// ✓ Hanya validasi user yang sync (butuh response langsung)
	if err := s.userClient.ValidateActive(ctx, req.CustomerID); err != nil {
		return err
	}

	order := buildOrder(req)
	if err := s.repo.Save(ctx, order); err != nil {
		return err
	}

	// ✓ Sisanya async — Inventory, Warehouse, Supplier akan merespons via event
	return s.eventBus.Publish(ctx, OrderCreatedEvent{OrderID: order.ID, Items: req.Items})
}

// ✗ Tidak ada timeout pada inter-service call — goroutine menunggu selamanya
func (s *Service) getUser(ctx context.Context, id string) (*User, error) {
	resp, err := http.Get("http://user-service/users/" + id) // ✗ no timeout!
	// ...
}

// ✓ Selalu gunakan context dengan timeout
func (s *Service) getUser(ctx context.Context, id string) (*User, error) {
	ctx, cancel := context.WithTimeout(ctx, 2*time.Second) // ✓ bounded timeout
	defer cancel()
	return s.userClient.Get(ctx, id)
}