json_sync.go

package logger

import (
	"encoding/json"
	"errors"
	"fmt"
	"log"
	"os"
	"strings"
	"time"
)

// LogLevel represents the minimum log severity threshold
type LogLevel int

const (
	LevelDebug LogLevel = iota // 0
	LevelInfo                  // 1
	LevelWarn                  // 2
	LevelError                 // 3
	LevelFatal                 // 4
)

// RedactConfig defines field redaction rules and censor replacement string
type RedactConfig struct {
	Paths  []string `json:"paths"`
	Censor string   `json:"censor"`
}

// DefaultRedactConfig returns default redaction settings for sensitive fields
func DefaultRedactConfig() *RedactConfig {
	return &RedactConfig{
		Paths: []string{
			"password",
			"card",
			"token",
			"refresh_token",
			"*.password",
			"*.card",
			"*.token",
			"req.headers.authorization",
		},
		Censor: "[Redacted]",
	}
}

// JSONConfig holds the base metadata configuration for JSON log entries
type JSONConfig struct {
	DeviceID    string
	AppVersion  string
	Service     string
	LogLevel    LogLevel // LevelDebug, LevelInfo, LevelWarn, LevelError, LevelFatal
	PrettyPrint bool
	Redact      *RedactConfig
}

// LogEntry defines the JSON structure for log outputs
type LogEntry struct {
	Timestamp  string `json:"timestamp"`
	Level      string `json:"level"`
	DeviceID   string `json:"device_id,omitempty"`
	AppVersion string `json:"app_version,omitempty"`
	TraceID    string `json:"trace_id,omitempty"`
	Service    string `json:"service,omitempty"`
	Msg        string `json:"msg"`
	Data       any    `json:"data,omitempty"`
}

type redactor struct {
	paths  []string
	censor string
}

func newRedactor(paths []string, censor string) *redactor {
	if censor == "" {
		censor = "[Redacted]"
	}
	return &redactor{
		paths:  paths,
		censor: censor,
	}
}

func (r *redactor) shouldRedact(key string, fullPath string) bool {
	keyLower := strings.ToLower(key)
	fullPathLower := strings.ToLower(fullPath)

	for _, p := range r.paths {
		pLower := strings.ToLower(strings.TrimSpace(p))
		if pLower == "" {
			continue
		}

		if strings.HasPrefix(pLower, "*.") {
			target := pLower[2:]
			if keyLower == target || strings.HasSuffix(fullPathLower, "."+target) {
				return true
			}
		} else if strings.Contains(pLower, ".") {
			if fullPathLower == pLower {
				return true
			}
		} else {
			if keyLower == pLower || fullPathLower == pLower {
				return true
			}
		}
	}
	return false
}

func redactAny(val any, currentPath string, r *redactor) any {
	if val == nil || r == nil {
		return val
	}

	switch v := val.(type) {
	case map[string]any:
		newMap := make(map[string]any, len(v))
		for k, item := range v {
			itemPath := k
			if currentPath != "" {
				itemPath = currentPath + "." + k
			}
			if r.shouldRedact(k, itemPath) {
				newMap[k] = r.censor
			} else {
				newMap[k] = redactAny(item, itemPath, r)
			}
		}
		return newMap
	case []any:
		newSlice := make([]any, len(v))
		for i, item := range v {
			newSlice[i] = redactAny(item, currentPath, r)
		}
		return newSlice
	default:
		return val
	}
}

func normalizeData(data any) any {
	if data == nil {
		return nil
	}
	switch data.(type) {
	case map[string]any, []any, string, int, int64, float64, bool:
		return data
	default:
		b, err := json.Marshal(data)
		if err != nil {
			return data
		}
		var out any
		if err := json.Unmarshal(b, &out); err != nil {
			return data
		}
		return out
	}
}

// RedactData applies field redaction rules to data payloads
func RedactData(data any, config *RedactConfig) any {
	if data == nil || config == nil || len(config.Paths) == 0 {
		return data
	}

	censor := config.Censor
	if censor == "" {
		censor = "[Redacted]"
	}

	r := newRedactor(config.Paths, censor)
	normalized := normalizeData(data)
	return redactAny(normalized, "", r)
}

// JSONLogEntry represents an active JSON log entry allowing .TraceID() and .Data() chaining
type JSONLogEntry struct {
	logger  *LoggerSyncJSON
	entry   LogEntry
	enabled bool
}

// TraceID updates the trace_id of the log entry
func (e *JSONLogEntry) TraceID(traceID string) *JSONLogEntry {
	if !e.enabled {
		return e
	}
	e.entry.TraceID = traceID
	e.logger.printEntry(e.entry)
	return e
}

// Data updates the data payload of the log entry
func (e *JSONLogEntry) Data(data any) *JSONLogEntry {
	if !e.enabled {
		return e
	}
	e.entry.Data = data
	e.logger.printEntry(e.entry)
	return e
}

// LoggerSyncJSON handles synchronous JSON logging
type LoggerSyncJSON struct {
	config          JSONConfig
	writeFileEnable bool
	objectName      string
	file            *os.File
	fileName        string
	path            string
}

// NewSyncJSON creates a new synchronous JSON logger instance
func NewSyncJSON(config JSONConfig) *LoggerSyncJSON {
	logger := &LoggerSyncJSON{
		config:          config,
		writeFileEnable: false,
	}
	log.SetOutput(os.Stdout)
	log.SetFlags(0)
	return logger
}

func (l *LoggerSyncJSON) baseEntry(level string, msg string) LogEntry {
	return LogEntry{
		Timestamp:  time.Now().Format("2006-01-02T15:04:05.000Z07:00"),
		Level:      level,
		DeviceID:   l.config.DeviceID,
		AppVersion: l.config.AppVersion,
		Service:    l.config.Service,
		Msg:        msg,
	}
}

func (l *LoggerSyncJSON) shouldLog(level LogLevel) bool {
	return level >= l.config.LogLevel
}

func (l *LoggerSyncJSON) printEntry(entry LogEntry) {
	if l.config.Redact != nil {
		entry.Data = RedactData(entry.Data, l.config.Redact)
	}

	var bytes []byte
	var err error
	if l.config.PrettyPrint {
		bytes, err = json.MarshalIndent(entry, "", "    ")
	} else {
		bytes, err = json.Marshal(entry)
	}

	var formattedMsg string
	if err != nil {
		formattedMsg = fmt.Sprintf(`{"timestamp":"%s","level":"ERROR","msg":"failed to marshal log entry: %v"}`,
			time.Now().Format("2006-01-02T15:04:05.000Z07:00"), err)
	} else {
		formattedMsg = string(bytes)
	}

	if l.writeFileEnable && l.file != nil {
		l.file.WriteString(formattedMsg + "\n")
	}

	log.Println(formattedMsg)
}

func (l *LoggerSyncJSON) createEntry(level string, levelVal LogLevel, msg string) *JSONLogEntry {
	if !l.shouldLog(levelVal) {
		return &JSONLogEntry{
			logger:  l,
			enabled: false,
		}
	}
	entry := l.baseEntry(level, msg)
	l.printEntry(entry)
	return &JSONLogEntry{
		logger:  l,
		entry:   entry,
		enabled: true,
	}
}

// Logging methods
func (l *LoggerSyncJSON) Debug(a ...any) *JSONLogEntry {
	return l.createEntry("DEBUG", LevelDebug, fmt.Sprint(a...))
}

func (l *LoggerSyncJSON) Debugf(format string, a ...any) *JSONLogEntry {
	return l.createEntry("DEBUG", LevelDebug, fmt.Sprintf(format, a...))
}

func (l *LoggerSyncJSON) Info(a ...any) *JSONLogEntry {
	return l.createEntry("INFO", LevelInfo, fmt.Sprint(a...))
}

func (l *LoggerSyncJSON) Infof(format string, a ...any) *JSONLogEntry {
	return l.createEntry("INFO", LevelInfo, fmt.Sprintf(format, a...))
}

func (l *LoggerSyncJSON) Warn(a ...any) *JSONLogEntry {
	return l.createEntry("WARN", LevelWarn, fmt.Sprint(a...))
}

func (l *LoggerSyncJSON) Warnf(format string, a ...any) *JSONLogEntry {
	return l.createEntry("WARN", LevelWarn, fmt.Sprintf(format, a...))
}

func (l *LoggerSyncJSON) Error(a ...any) *JSONLogEntry {
	return l.createEntry("ERROR", LevelError, fmt.Sprint(a...))
}

func (l *LoggerSyncJSON) Errorf(format string, a ...any) *JSONLogEntry {
	return l.createEntry("ERROR", LevelError, fmt.Sprintf(format, a...))
}

func (l *LoggerSyncJSON) Panic(a ...any) {
	msg := fmt.Sprint(a...)
	if l.shouldLog(LevelError) {
		entry := l.baseEntry("PANIC", msg)
		l.printEntry(entry)
	}
	panic(msg)
}

func (l *LoggerSyncJSON) Panicf(format string, a ...any) {
	msg := fmt.Sprintf(format, a...)
	if l.shouldLog(LevelError) {
		entry := l.baseEntry("PANIC", msg)
		l.printEntry(entry)
	}
	panic(msg)
}

func (l *LoggerSyncJSON) Fatal(a ...any) {
	msg := fmt.Sprint(a...)
	if l.shouldLog(LevelFatal) {
		entry := l.baseEntry("FATAL", msg)
		l.printEntry(entry)
	}
	os.Exit(1)
}

func (l *LoggerSyncJSON) Fatalf(format string, a ...any) {
	msg := fmt.Sprintf(format, a...)
	if l.shouldLog(LevelFatal) {
		entry := l.baseEntry("FATAL", msg)
		l.printEntry(entry)
	}
	os.Exit(1)
}

// File persistence and rotation
func (l *LoggerSyncJSON) SetWriteFilesEnable(path string, objectName string) {
	l.objectName = objectName
	l.path = newFolderPath(path)
	l.fileName = fileNameGenerator(l.objectName)
	l.file = createAndAppendObject(l.fileName, path)
	l.writeFileEnable = true
}

func (l *LoggerSyncJSON) ChangeFileRoutine(hour int, minute int) error {
	if !l.writeFileEnable {
		return errors.New("set write files enable first")
	}
	go func() {
		for range time.Tick(1 * time.Minute) {
			hours, minutes, _ := time.Now().Clock()
			if hours == hour && minutes == minute {
				if l.file != nil {
					l.file.Close()
				}
				l.fileName = fileNameGenerator(l.objectName)
				l.file = createAndAppendObject(l.fileName, l.path)
			}
		}
	}()
	return nil
}