package main

import (
	"fmt"
	"os"

	"go.uber.org/zap"
	"go.uber.org/zap/zapcore"
)

func main() {
	// Forge a custom Zap configuration for production
	// This ensures logs are structured JSON and written to stdout
	config := zap.Config{
		Level:       zap.NewAtomicLevelAt(zap.InfoLevel),
		Encoding:    "json",
		OutputPaths: []string{"stdout"},
		ErrorOutputPaths: []string{"stderr"},
		EncoderConfig: zapcore.EncoderConfig{
			MessageKey: "message",
			LevelKey:   "level",
			TimeKey:    "time",
			// Format the timestamp as ISO8601 for consistent parsing
			EncodeTime: zapcore.ISO8601TimeEncoder,
			// Encode levels as uppercase text (e.g., "INFO", "ERROR")
			EncodeLevel: zapcore.CapitalLevelEncoder,
			// Add a caller key to log the file and line number
			CallerKey: "caller",
			EncodeCaller: zapcore.ShortCallerEncoder,
		},
	}

	// Build the logger from the configuration. Handle any potential errors during logger creation.
	logger, err := config.Build()
	if err != nil {
		fmt.Printf("Failed to build Zap logger: %v\n", err)
		os.Exit(1)
	}
	defer logger.Sync() // Ensure all buffered log entries are flushed before exiting

	// Use logger.Named to add a component name, enriching context
	appLogger := logger.Named("myapp")

	// Activate logging with various levels and structured fields
	appLogger.Info("Application started successfully",
		zap.String("version", "1.0.0"),
		zap.Int("port", 8080),
	)

	requestID := "req-abc-123"
	userID := "user-456"
	transactionID := "tx-789"

	// Log an event within a specific request context
	appLogger.Debug("Processing user request",
		zap.String("request_id", requestID),
		zap.String("user_id", userID),
	)

	// Simulate an error condition and log it with relevant context
	err = fmt.Errorf("failed to connect to database: connection refused")
	appLogger.Error("Database operation failed",
		zap.Error(err),
		zap.String("request_id", requestID),
		zap.String("transaction_id", transactionID),
		zap.String("component", "database_service"),
	)

	// Log a warning about a deprecated feature being used
	appLogger.Warn("Deprecated API endpoint accessed",
		zap.String("endpoint", "/api/v1/legacy"),
		zap.String("client_ip", "192.168.1.100"),
	)

	// Log a fatal error that would typically cause application shutdown
	// appLogger.Fatal("Critical unrecoverable error, exiting", zap.Error(fmt.Errorf("out of memory")))
}

package main

import (
	"os"
	"time"

	"github.com/rs/zerolog"
	"github.com/rs/zerolog/log"
)

func main() {
	// Engineer Zerolog for development-friendly output initially
	// This console writer makes logs human-readable in a terminal
	// In production, we would use a simple os.Stdout for JSON output
	// log.Logger = log.Output(zerolog.ConsoleWriter{Out: os.Stderr, TimeFormat: time.RFC3339})

	// For production, use direct os.Stdout/Stderr to output pure JSON
	log.Logger = zerolog.New(os.Stderr).With().Timestamp().Caller().Logger()

	// Activate logging with various levels and structured fields
	log.Info().
		Str("version", "1.1.0").
		Int("uptime_seconds", 3600).
		Msg("Service initialized")

	requestID := "req-def-456"
	userID := "user-789"
	operation := "data_fetch"

	// Create a sub-logger for a specific request context
	requestLogger := log.With().
		Str("request_id", requestID).
		Str("user_id", userID).
		Logger()

	requestLogger.Debug().
		Str("operation", operation).
		Msg("Starting data retrieval for user")

	// Simulate an error condition and log it
	err := "network timeout: 10.0.0.5 is unreachable"
	requestLogger.Error().
		Err(fmt.Errorf(err)). // Zerolog expects an error interface
		Str("component", "api_gateway").
		Int("status_code", 504).
		Dur("duration_ms", 2500*time.Millisecond). // Log duration directly
		Msg("External service call failed")

	// Log a warning for resource exhaustion
	log.Warn().
		Str("resource", "database_pool").
		Int("current_connections", 95).
		Int("max_connections", 100).
		Msg("Database connection pool nearing capacity")

	// Example of setting a global level (can be done via environment variable too)
	zerolog.SetGlobalLevel(zerolog.DebugLevel)

	log.Debug().Msg("This debug message is now visible")

	// If we wanted to set a specific time format globally for all logs (e.g., for compatibility)
	// zerolog.TimeFieldFormat = zerolog.TimestampFormat

	// Example of chaining context directly onto an event
	log.Info().
		Str("event", "user_login").
		Str("username", "johndoe").		
		Bool("success", true).
		IPAddr("ip_address", net.ParseIP("203.0.113.42")).
		Msg("User authenticated")
}

package main

import (
	"context"
	"fmt"
	"os"
	"sync"
	"time"

	"go.uber.org/zap"
	"go.uber.org/zap/zapcore"
	"github.com/rs/zerolog"
	"github.com/rs/zerolog/log"
)

// Define a custom context key to store the logger
type loggerCtxKey struct{}

// NewContextLogger engineers a new context with the provided logger
func NewContextLogger(ctx context.Context, logger *zap.Logger) context.Context {
	return context.WithValue(ctx, loggerCtxKey{}, logger)
}

// FromContextLogger extracts the logger from the context, or returns a default no-op logger
func FromContextLogger(ctx context.Context) *zap.Logger {
	if logger, ok := ctx.Value(loggerCtxKey{}).(*zap.Logger); ok {
		return logger
	}
	// Return a no-op logger if none is found to prevent panics
	return zap.NewNop()
}

// Zerolog approach for context-aware logging
type zerologCtxKey struct{}

// NewZerologContext engineers a new context with the provided zerolog.Logger
func NewZerologContext(ctx context.Context, logger zerolog.Logger) context.Context {
	return context.WithValue(ctx, zerologCtxKey{}, logger)
}

// ZerologFromContext extracts the zerolog.Logger from the context, or returns a global logger
func ZerologFromContext(ctx context.Context) zerolog.Logger {
	if logger, ok := ctx.Value(zerologCtxKey{}).(zerolog.Logger); ok {
		return logger
	}
	return log.Logger // Fallback to global logger
}

func processRequestZap(ctx context.Context, requestID string) error {
	logger := FromContextLogger(ctx).With(zap.String("request_id", requestID))
	logger.Info("Starting request processing")

	// Simulate some work
	time.Sleep(50 * time.Millisecond)

	// Simulate an error deep within the logic
	err := fmt.Errorf("invalid input parameter: 'name' is empty")
	logger.Error("Request processing failed", zap.Error(err), zap.String("step", "validation"))
	return err
}

func processRequestZerolog(ctx context.Context, requestID string) error {
	logger := ZerologFromContext(ctx).With().Str("request_id", requestID).Logger()
	logger.Info().Msg("Starting request processing")

	// Simulate some work
	time.Sleep(50 * time.Millisecond)

	// Simulate an error deep within the logic
	err := fmt.Errorf("database connection error: timeout")
	logger.Error().Err(err).Str("step", "database_write").Msg("Request processing failed")
	return err
}

func main() {
	// 1. Zap Setup (similar to previous example, using a dev-friendly setup for stdout here)
	prodConfig := zap.NewProductionConfig()
	prodConfig.EncoderConfig.EncodeTime = zapcore.ISO8601TimeEncoder
	prodConfig.OutputPaths = []string{"stdout"}
	prodConfig.ErrorOutputPaths = []string{"stderr"}
	zapLogger, err := prodConfig.Build()
	if err != nil {
		fmt.Printf("Failed to build Zap logger: %v\n", err)
		os.Exit(1)
	}
	defer zapLogger.Sync()

	// 2. Zerolog Setup (production-ready JSON to stderr)
	zerolog.TimeFieldFormat = zerolog.TimestampFormat
	zerolog.SetGlobalLevel(zerolog.InfoLevel)
	zerologLogger := zerolog.New(os.Stderr).With().Timestamp().Logger()
	log.Logger = zerologLogger // Set as global default for convenience

	fmt.Println("--- Zap Contextual Logging Example ---")
	// Create a root context and attach the Zap logger
	ctxZap := NewContextLogger(context.Background(), zapLogger)

	// Process a request with Zap, passing the context
	_ = processRequestZap(ctxZap, "REQ-ZAP-001")

	fmt.Println("\n--- Zerolog Contextual Logging Example ---")
	// Create a root context and attach the Zerolog logger
	ctxZerolog := NewZerologContext(context.Background(), zerologLogger)

	// Process a request with Zerolog, passing the context
	_ = processRequestZerolog(ctxZerolog, "REQ-ZERO-002")

	// We can also use Zap's SugaredLogger for less verbose calls, sacrificing minimal performance for ergonomics
	sugaredLogger := zapLogger.Sugar()
	sugaredLogger.Infow("Application shutdown", "duration", "10s", "status", "graceful")
}