logger.go

package http2

import (
	"fmt"
	"os"
	"strings"
	"time"

	"github.com/rs/zerolog"
)

// logger là global logger instance cho HTTP/2 lib
var logger zerolog.Logger

func init() {
	setupLogger()
}

// setupLogger initializes zero log based on environment variables
func setupLogger() {
	// Get log level from environment variable
	logLevel := strings.ToLower(os.Getenv("DEBUG_HTTP2_LOG"))

	var level zerolog.Level
	switch logLevel {
	case "debug":
		level = zerolog.DebugLevel
	case "info":
		level = zerolog.InfoLevel
	case "warn", "warning":
		level = zerolog.WarnLevel
	case "error":
		level = zerolog.ErrorLevel
	case "fatal":
		level = zerolog.FatalLevel
	case "panic":
		level = zerolog.PanicLevel
	default:
		// If DEBUG_HTTP2_LOG is not set or invalid -> disable completely
		// level = zerolog.DebugLevel
		level = zerolog.Disabled
	}

	// Setup output format
	var output = zerolog.ConsoleWriter{
		Out:        os.Stdout,
		TimeFormat: time.RFC3339,
	}

	// Use pretty format for debug mode only
	if logLevel == "debug" {
		output.FormatLevel = func(i interface{}) string {
			return strings.ToUpper(fmt.Sprintf("| %-6s|", i))
		}
		output.FormatMessage = func(i interface{}) string {
			return fmt.Sprintf("*** %s ***", i)
		}
		output.FormatFieldName = func(i interface{}) string {
			return fmt.Sprintf("%s:", i)
		}
	}

	// Create logger with config
	logger = zerolog.New(output).
		Level(level).
		With().
		Timestamp().
		Str("component", "http2").
		Logger()

	// Log initialization if logging is enabled
	if level != zerolog.Disabled {
		logger.Info().
			Str("level", level.String()).
			Msg("HTTP/2 Logger initialized")
	}
}

// Helper methods để log các HTTP/2 specific events theo RFC 7540

// logConnection logs connection events (RFC 7540 Section 3)
func logConnection(event string, addr string, fields map[string]interface{}) {
	if logger.GetLevel() == zerolog.Disabled {
		return
	}

	logEvent := logger.Info().
		Str("event", "connection").
		Str("action", event).
		Str("address", addr)

	for key, value := range fields {
		logEvent = logEvent.Interface(key, value)
	}

	logEvent.Msg("HTTP/2 Connection Event")
}

// logStream logs stream events (RFC 7540 Section 5.1)
func logStream(streamID uint32, state string, event string, fields map[string]interface{}) {
	if logger.GetLevel() == zerolog.Disabled {
		return
	}

	logEvent := logger.Debug().
		Str("event", "stream").
		Uint32("stream_id", streamID).
		Str("state", state).
		Str("action", event)

	for key, value := range fields {
		logEvent = logEvent.Interface(key, value)
	}

	logEvent.Msg("HTTP/2 Stream Event")
}

// logFrame logs frame processing (RFC 7540 Section 4)
func logFrame(frameType string, streamID uint32, length int, flags string) {
	logger.Debug().
		Str("event", "frame").
		Str("type", frameType).
		Uint32("stream_id", streamID).
		Int("length", length).
		Str("flags", flags).
		Msg("HTTP/2 Frame")
}

// logFlowControl logs flow control events (RFC 7540 Section 5.2)
func logFlowControl(streamID uint32, windowSize int32, action string) {
	logger.Debug().
		Str("event", "flow_control").
		Uint32("stream_id", streamID).
		Int32("window_size", windowSize).
		Str("action", action).
		Msg("HTTP/2 Flow Control")
}

// logError logs errors with context
func logError(err error, context string, fields map[string]interface{}) {
	if logger.GetLevel() == zerolog.Disabled {
		return
	}

	logEvent := logger.Error().
		Err(err).
		Str("context", context)

	for key, value := range fields {
		logEvent = logEvent.Interface(key, value)
	}

	logEvent.Msg("HTTP/2 Error")
}

// logRequest logs HTTP request details (RFC 7540 Section 8.1)
func logRequest(method, path, authority string, headers map[string]string) {
	logger.Debug().
		Str("event", "request").
		Str("method", method).
		Str("path", path).
		Str("authority", authority).
		Interface("headers", headers).
		Msg("HTTP/2 Request")
}

// logResponse logs HTTP response details (RFC 7540 Section 8.1)
func logResponse(statusCode int, headers map[string]string, bodyLength int) {
	logger.Debug().
		Str("event", "response").
		Int("status_code", statusCode).
		Interface("headers", headers).
		Int("body_length", bodyLength).
		Msg("HTTP/2 Response")
}

// logHPACK logs header compression events (RFC 7540 Section 4.3)
func logHPACK(action string, originalSize, compressedSize int) {
	logger.Debug().
		Str("event", "hpack").
		Str("action", action).
		Int("original_size", originalSize).
		Int("compressed_size", compressedSize).
		Float64("compression_ratio", float64(compressedSize)/float64(originalSize)).
		Msg("HTTP/2 HPACK")
}

// logSettings logs settings frame processing (RFC 7540 Section 6.5)
func logSettings(settings map[string]interface{}, ack bool) {
	logger.Debug().
		Str("event", "settings").
		Interface("settings", settings).
		Bool("ack", ack).
		Msg("HTTP/2 Settings")
}