project/
 ├── cmd/
 │   └── main.go
 ├── middleware/
 │   └── request_context.go
 ├── handler/
 │   └── user_handler.go
 ├── service/
 │   └── user_service.go
 ├── repository/
 │   └── user_repository.go
 ├── Dockerfile
 ├── docker-compose.yml
 ├── nginx.conf
 ├── go.mod
 └── go.sum

http {
  server {
    listen 80;

    location / {
      # ถ้ามี X-Request-ID แล้ว ให้ใช้ของเดิม
      # ถ้าไม่มี ให้ generate ใหม่จาก $request_id ของ NGINX
      proxy_set_header X-Request-ID $request_id;

      proxy_pass http://backend;
    }
  }

  # ตั้ง backend upstream
  upstream backend {
    server app:3000;
  }
}

// ctxkey/ctxkey.go
package ctxkey

type key int

const (
	Logger key = iota
	RequestID
)

// logger/logger.go
package logger

import (
	"context"
	"demo-logger/ctxkey"

	"go.uber.org/zap"
)

var baseLogger *zap.Logger

func InitLogger() {
	l, _ := zap.NewProduction()
	baseLogger = l.With(zap.String("app_name", "demo-logger"))
}

func Default() *zap.Logger {
	return baseLogger
}

func Logger(ctx context.Context) *zap.Logger {
	log, ok := ctx.Value(ctxkey.Logger).(*zap.Logger)
	if ok {
		return log
	}
	return baseLogger
}

// middleware/request_context.go
package middleware

import (
	"context"
	"demo-logger/ctxkey"
	"demo-logger/logger"

	"github.com/gofiber/fiber/v2"
	"github.com/google/uuid"
	"go.uber.org/zap"
)

func RequestContext() fiber.Handler {
	return func(c *fiber.Ctx) error {
		reqID := c.Get("X-Request-ID")
		if reqID == "" {
			reqID = uuid.New().String()
		}

		// Bind Request ID ลง Response Header
		c.Set("X-Request-ID", reqID)

		// สร้าง child logger
		reqLogger := logger.Default().With(zap.String("request_id", reqID))

		// สร้าง Context ใหม่
		ctx := context.WithValue(c.Context(), ctxkey.RequestID, reqID)
		ctx = context.WithValue(ctx, ctxkey.Logger, reqLogger)

		// แทน Context เดิม
		c.SetUserContext(ctx)

		return c.Next()
	}
}

// handler/user_handler.go
package handler

import (
	"demo-logger/logger"
	"demo-logger/service"

	"github.com/gofiber/fiber/v2"
	"go.uber.org/zap"
)

type UserHandler struct {
	svc *service.UserService
}

func NewUserHandler(svc *service.UserService) *UserHandler {
	return &UserHandler{svc: svc}
}

func (h *UserHandler) GetUser(c *fiber.Ctx) error {
	userID := c.Params("id")

  // ใช้ UserContext() เพราะใส่ logger ไว้ที่นี่
	user, err := h.svc.GetUser(c.UserContext(), userID)
	if err != nil {
		// ดึง logger จาก context
		logger.FromContext(c.UserContext()).Error("failed to get user")
		return c.Status(fiber.StatusInternalServerError).SendString("error")
	}

  // ดึง logger จาก context
	logger.FromContext(c.UserContext()).Info("success get user", zap.String("user_id", userID))

	return c.JSON(user)
}

// service/user_service.go
package service

import (
	"context"
	"demo-logger/logger"
	"demo-logger/repository"

	"go.uber.org/zap"
)

type UserService struct {
	repo *repository.UserRepository
}

func NewUserService(repo *repository.UserRepository) *UserService {
	return &UserService{repo: repo}
}

func (s *UserService) GetUser(ctx context.Context, userID string) (any, error) {
  // ดึง logger จาก context
	logger.FromContext(ctx).Info("calling repo", zap.String("user_id", userID))

	return s.repo.FindByID(ctx, userID)
}

// repository/user_repository.go
package repository

import (
	"context"
	"demo-logger/logger"

	"go.uber.org/zap"
)

type UserRepository struct {
	// DB connection
}

func NewUserRepository() *UserRepository {
	return &UserRepository{}
}

func (r *UserRepository) FindByID(ctx context.Context, userID string) (any, error) {
  // ดึง logger จาก context
	logger.FromContext(ctx).Info("querying database", zap.String("user_id", userID))

	// สมมติคืน mock user
	return map[string]string{"id": userID, "name": "ball"}, nil
}

// cmd/main.go
package main

import (
	"demo-logger/handler"
	"demo-logger/logger"
	"demo-logger/middleware"
	"demo-logger/repository"
	"demo-logger/service"

	"github.com/gofiber/fiber/v2"
)

func main() {
	logger.InitLogger()

	app := fiber.New()
	app.Use(middleware.RequestContext())

	repo := repository.NewUserRepository()
	svc := service.NewUserService(repo)
	hdl := handler.NewUserHandler(svc)

	app.Get("/user/:id", hdl.GetUser)

	app.Listen(":3000")
}

# ---------- STAGE 1: Build ----------
FROM golang:1.24 AS builder

# Set working dir
WORKDIR /app

# Copy go.mod and go.sum first for caching dependencies
COPY go.mod go.sum ./

# Download dependencies
RUN go mod download

# Copy the source code
COPY . .

# Build binary - youสามารถเปลี่ยนชื่อได้ตามต้องการ
RUN CGO_ENABLED=0 GOOS=linux GOARCH=amd64 go build -o app ./cmd/main.go

# ---------- STAGE 2: Run ----------
FROM alpine:latest

# ทำให้ binary ทำงานได้ (สำหรับบาง lib เช่น timezone)
RUN apk --no-cache add ca-certificates

# Set working dir
WORKDIR /root/

# Copy binary จาก builder stage
COPY --from=builder /app/app .

# Expose port (ถ้ามี)
EXPOSE 3000

# Command to run
CMD ["./app"]

services:
  nginx:
    image: nginx:latest
    container_name: nginx-proxy
    ports:
      - '80:80'
    volumes:
      - ./nginx.conf:/etc/nginx/nginx.conf:ro
    depends_on:
      - app

  app:
    build: .
    container_name: backend-app

docker compose up -d --build

backend-app  | {"level":"info","ts":1751602673.5724216,"caller":"service/user_service.go:20","msg":"calling repo","app_name":"demo-logger","request_id":"29988fdef291b7afaadaa872cea0d5ba","user_id":"1"}
backend-app  | {"level":"info","ts":1751602673.5769289,"caller":"repository/user_repository.go:19","msg":"querying database","app_name":"demo-logger","request_id":"29988fdef291b7afaadaa872cea0d5ba","user_id":"1"}
backend-app  | {"level":"info","ts":1751602673.5770924,"caller":"handler/user_handler.go:28","msg":"success get user","app_name":"demo-logger","request_id":"29988fdef291b7afaadaa872cea0d5ba","user_id":"1"}