Observability ও Service Mesh

package main

import (
	"context"
	"encoding/json"
	"fmt"
	"log"
	"math/rand"
	"net/http"
	"os"
	"sort"
	"strings"
	"sync"
	"sync/atomic"
	"time"

	"github.com/google/uuid"
)

// --- Structured Logger ---
type Logger struct {
	service string
}

type LogEntry struct {
	Level     string                 `json:"level"`
	Msg       string                 `json:"msg"`
	Timestamp string                 `json:"timestamp"`
	Service   string                 `json:"service"`
	Fields    map[string]interface{} `json:"fields,omitempty"`
}

func NewLogger(service string) *Logger {
	return &Logger{service: service}
}

func (l *Logger) log(level, msg string, fields map[string]interface{}) {
	entry := LogEntry{
		Level:     level,
		Msg:       msg,
		Timestamp: time.Now().UTC().Format(time.RFC3339Nano),
		Service:   l.service,
		Fields:    fields,
	}
	data, _ := json.Marshal(entry)
	fmt.Fprintln(os.Stdout, string(data))
}

func (l *Logger) Info(msg string, fields map[string]interface{})  { l.log("info", msg, fields) }
func (l *Logger) Error(msg string, fields map[string]interface{}) { l.log("error", msg, fields) }
func (l *Logger) Warn(msg string, fields map[string]interface{})  { l.log("warn", msg, fields) }

func (l *Logger) With(fields map[string]interface{}) *ContextLogger {
	return &ContextLogger{parent: l, fields: fields}
}

type ContextLogger struct {
	parent *Logger
	fields map[string]interface{}
}

func (cl *ContextLogger) Info(msg string, extra map[string]interface{}) {
	merged := make(map[string]interface{})
	for k, v := range cl.fields {
		merged[k] = v
	}
	for k, v := range extra {
		merged[k] = v
	}
	cl.parent.Info(msg, merged)
}

func (cl *ContextLogger) Error(msg string, extra map[string]interface{}) {
	merged := make(map[string]interface{})
	for k, v := range cl.fields {
		merged[k] = v
	}
	for k, v := range extra {
		merged[k] = v
	}
	cl.parent.Error(msg, merged)
}

// --- Metrics ---
type Counter struct {
	name   string
	help   string
	mu     sync.Mutex
	values map[string]int64
}

func NewCounter(name, help string) *Counter {
	return &Counter{name: name, help: help, values: make(map[string]int64)}
}

func (c *Counter) Inc(labels map[string]string) {
	c.mu.Lock()
	defer c.mu.Unlock()
	key := labelKey(labels)
	c.values[key]++
}

func (c *Counter) Serialize() string {
	c.mu.Lock()
	defer c.mu.Unlock()
	var sb strings.Builder
	fmt.Fprintf(&sb, "# HELP %s %s\n# TYPE %s counter\n", c.name, c.help, c.name)
	for labels, value := range c.values {
		labelStr := ""
		if labels != "" {
			labelStr = "{" + labels + "}"
		}
		fmt.Fprintf(&sb, "%s%s %d\n", c.name, labelStr, value)
	}
	return sb.String()
}

type Histogram struct {
	name         string
	help         string
	mu           sync.Mutex
	observations map[string][]float64
	buckets      []float64
}

func NewHistogram(name, help string) *Histogram {
	return &Histogram{
		name: name, help: help,
		observations: make(map[string][]float64),
		buckets:      []float64{0.005, 0.01, 0.025, 0.05, 0.1, 0.25, 0.5, 1, 2.5, 5, 10},
	}
}

func (h *Histogram) Observe(labels map[string]string, value float64) {
	h.mu.Lock()
	defer h.mu.Unlock()
	key := labelKey(labels)
	h.observations[key] = append(h.observations[key], value)
}

func (h *Histogram) Serialize() string {
	h.mu.Lock()
	defer h.mu.Unlock()
	var sb strings.Builder
	fmt.Fprintf(&sb, "# HELP %s %s\n# TYPE %s histogram\n", h.name, h.help, h.name)
	for labels, values := range h.observations {
		sorted := make([]float64, len(values))
		copy(sorted, values)
		sort.Float64s(sorted)

		var sum float64
		for _, v := range values {
			sum += v
		}

		for _, bucket := range h.buckets {
			count := 0
			for _, v := range sorted {
				if v <= bucket {
					count++
				}
			}
			fmt.Fprintf(&sb, "%s_bucket{%sle=\"%g\"} %d\n", h.name, labels+",", bucket, count)
		}
		fmt.Fprintf(&sb, "%s_bucket{%sle=\"+Inf\"} %d\n", h.name, labels+",", len(values))
		fmt.Fprintf(&sb, "%s_sum{%s} %g\n", h.name, labels, sum)
		fmt.Fprintf(&sb, "%s_count{%s} %d\n", h.name, labels, len(values))
	}
	return sb.String()
}

func labelKey(labels map[string]string) string {
	keys := make([]string, 0, len(labels))
	for k := range labels {
		keys = append(keys, k)
	}
	sort.Strings(keys)
	parts := make([]string, 0, len(keys))
	for _, k := range keys {
		parts = append(parts, fmt.Sprintf(`%s="%s"`, k, labels[k]))
	}
	return strings.Join(parts, ",")
}

// --- Tracing ---
type Span struct {
	TraceID       string            `json:"traceId"`
	SpanID        string            `json:"spanId"`
	ParentSpanID  string            `json:"parentSpanId,omitempty"`
	OperationName string            `json:"operationName"`
	ServiceName   string            `json:"serviceName"`
	StartTime     time.Time         `json:"startTime"`
	Duration      time.Duration     `json:"duration,omitempty"`
	Status        string            `json:"status"`
	Attributes    map[string]string `json:"attributes"`
}

type Tracer struct {
	serviceName string
}

func NewTracer(service string) *Tracer {
	return &Tracer{serviceName: service}
}

func (t *Tracer) StartSpan(name string, parent *Span) *Span {
	traceID := uuid.New().String()[:16] + uuid.New().String()[:16]
	if parent != nil {
		traceID = parent.TraceID
	}
	parentID := ""
	if parent != nil {
		parentID = parent.SpanID
	}
	return &Span{
		TraceID: traceID, SpanID: uuid.New().String()[:16],
		ParentSpanID: parentID, OperationName: name,
		ServiceName: t.serviceName, StartTime: time.Now(),
		Status: "ok", Attributes: make(map[string]string),
	}
}

func (t *Tracer) EndSpan(span *Span) {
	span.Duration = time.Since(span.StartTime)
	data, _ := json.Marshal(map[string]interface{}{
		"type": "span", "traceId": span.TraceID, "spanId": span.SpanID,
		"operation": span.OperationName, "duration_ms": span.Duration.Milliseconds(),
		"status": span.Status, "attributes": span.Attributes,
	})
	fmt.Fprintln(os.Stdout, string(data))
}

// --- Middleware ---
var (
	logger               = NewLogger("api-gateway")
	tracer               = NewTracer("api-gateway")
	httpRequestsTotal    = NewCounter("http_requests_total", "Total HTTP requests")
	httpRequestDuration  = NewHistogram("http_request_duration_seconds", "Request duration")
	httpRequestsInFlight atomic.Int64
)

type contextKey string

func observabilityMiddleware(next http.Handler) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		requestID := r.Header.Get("X-Request-Id")
		if requestID == "" {
			requestID = uuid.New().String()
		}

		span := tracer.StartSpan(fmt.Sprintf("%s %s", r.Method, r.URL.Path), nil)
		if traceID := r.Header.Get("X-Trace-Id"); traceID != "" {
			span.TraceID = traceID
		}

		span.Attributes["http.method"] = r.Method
		span.Attributes["http.url"] = r.URL.Path

		reqLogger := logger.With(map[string]interface{}{
			"traceId": span.TraceID, "spanId": span.SpanID,
			"requestId": requestID, "method": r.Method, "path": r.URL.Path,
		})

		start := time.Now()
		httpRequestsInFlight.Add(1)
		reqLogger.Info("request_started", nil)

		// Wrap response writer to capture status code
		rw := &responseWriter{ResponseWriter: w, statusCode: 200}

		ctx := context.WithValue(r.Context(), contextKey("span"), span)
		ctx = context.WithValue(ctx, contextKey("requestId"), requestID)

		w.Header().Set("X-Trace-Id", span.TraceID)
		w.Header().Set("X-Request-Id", requestID)

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

		duration := time.Since(start).Seconds()
		httpRequestsInFlight.Add(-1)

		status := fmt.Sprintf("%d", rw.statusCode)
		httpRequestsTotal.Inc(map[string]string{"method": r.Method, "status": status, "path": r.URL.Path})
		httpRequestDuration.Observe(map[string]string{"method": r.Method, "path": r.URL.Path}, duration)

		span.Attributes["http.status_code"] = status
		if rw.statusCode >= 500 {
			span.Status = "error"
		}
		tracer.EndSpan(span)

		reqLogger.Info("request_completed", map[string]interface{}{
			"statusCode": rw.statusCode, "duration_ms": duration * 1000,
		})
	})
}

type responseWriter struct {
	http.ResponseWriter
	statusCode int
}

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

func main() {
	mux := http.NewServeMux()

	mux.HandleFunc("/metrics", func(w http.ResponseWriter, _ *http.Request) {
		w.Header().Set("Content-Type", "text/plain")
		fmt.Fprint(w, httpRequestsTotal.Serialize()+httpRequestDuration.Serialize())
	})

	mux.HandleFunc("/health", func(w http.ResponseWriter, _ *http.Request) {
		w.Write([]byte("ok"))
	})

	mux.HandleFunc("/api/users", func(w http.ResponseWriter, r *http.Request) {
		// Simulate DB query with child span
		parentSpan := r.Context().Value(contextKey("span")).(*Span)
		dbSpan := tracer.StartSpan("db.query", parentSpan)
		dbSpan.Attributes["db.system"] = "postgresql"
		time.Sleep(time.Duration(rand.Intn(50)) * time.Millisecond)
		tracer.EndSpan(dbSpan)

		w.Header().Set("Content-Type", "application/json")
		json.NewEncoder(w).Encode(map[string]string{"status": "ok"})
	})

	handler := observabilityMiddleware(mux)

	log.Println("Server with observability on :3000")
	log.Fatal(http.ListenAndServe(":3000", handler))
}