Go zerolog setup with pgx

9:08PM TRC Query args=[] commandTag="DELETE 0" duration=4.653 pid=123 sql="-- name: CleanupExpiredTokens :exec\nDELETE\nFROM refresh_tokens\nWHERE expires_at < CURRENT_TIMESTAMP\n   OR revoked_at IS NOT NULL\n"

go get -u github.com/rs/zerolog/log
go get github.com/jackc/pgx/v5

package logger

import (
    "fmt"
    "os"
    "path/filepath"

    "github.com/rs/zerolog"
)

func New(isDebug bool, logPath string) (*zerolog.Logger, error) {
    logLevel := zerolog.InfoLevel
    if isDebug {
        logLevel = zerolog.TraceLevel
    }

    if err := os.MkdirAll(filepath.Dir(logPath), 0755); err != nil {
        return nil, fmt.Errorf("create log directory: %w", err)
    }

    runLogFile, err := os.OpenFile(
        logPath,
        os.O_APPEND|os.O_CREATE|os.O_WRONLY,
        0664,
    )
    if err != nil {
        return nil, fmt.Errorf("open log file: %w", err)
    }

    zerolog.SetGlobalLevel(logLevel)
    multi := zerolog.MultiLevelWriter(zerolog.ConsoleWriter{Out: os.Stdout}, runLogFile)
    logger := zerolog.New(multi).With().Timestamp().Logger()

    return &logger, nil
}

type Logger interface {
    Log(ctx context.Context, level LogLevel, msg string, data map[string]any)
}

// /github.com/jackc/pgx/[email protected]/tracelog/tracelog.go:135
type TraceLog struct {
    Logger   Logger
    LogLevel LogLevel

    Config           *TraceLogConfig
    ensureConfigOnce sync.Once
}

package logger

import (
    "context"

    "github.com/jackc/pgx/v5/tracelog"
    "github.com/rs/zerolog"
)

type zerologPgxLogger struct {
    logger zerolog.Logger
}

func (l zerologPgxLogger) Log(ctx context.Context, level tracelog.LogLevel, msg string, data map[string]interface{}) {
    logEvent := l.logger.With().Fields(data).Logger()
    zerologLevel := l.logger.GetLevel()
    if zerologLevel == zerolog.TraceLevel {
        level = tracelog.LogLevelTrace
    }

    switch level {
    case tracelog.LogLevelTrace:
        logEvent.Trace().Msg(msg)
    case tracelog.LogLevelDebug:
        logEvent.Debug().Msg(msg)
    case tracelog.LogLevelInfo:
        logEvent.Info().Msg(msg)
    case tracelog.LogLevelWarn:
        logEvent.Warn().Msg(msg)
    case tracelog.LogLevelError:
        logEvent.Error().Msg(msg)
    default:
        logEvent.Info().Msg(msg)
    }
}

func NewTraceLogger(zeroLog zerolog.Logger, isDebug bool) *tracelog.TraceLog {
    logLevel := tracelog.LogLevelInfo
    if isDebug {
        logLevel = tracelog.LogLevelTrace
    }

    return &tracelog.TraceLog{
        Logger:   zerologPgxLogger{logger: zeroLog},
        LogLevel: logLevel,
        Config: &tracelog.TraceLogConfig{
            TimeKey: "duration",
        },
    }
}

// QueryTracer traces Query, QueryRow, and Exec.
type QueryTracer interface {
    // TraceQueryStart is called at the beginning of Query, QueryRow, and Exec calls. The returned context is used for the
    // rest of the call and will be passed to TraceQueryEnd.
    TraceQueryStart(ctx context.Context, conn *Conn, data TraceQueryStartData) context.Context

    TraceQueryEnd(ctx context.Context, conn *Conn, data TraceQueryEndData)
}

package logger

import (
    "context"

    "github.com/jackc/pgx/v5"
)

type MultiQueryTracer struct {
    Tracers []pgx.QueryTracer
}

func (m *MultiQueryTracer) TraceQueryStart(ctx context.Context, conn *pgx.Conn, data pgx.TraceQueryStartData) context.Context {
    for _, t := range m.Tracers {
        ctx = t.TraceQueryStart(ctx, conn, data)
    }

    return ctx
}

func (m *MultiQueryTracer) TraceQueryEnd(ctx context.Context, conn *pgx.Conn, data pgx.TraceQueryEndData) {
    for _, t := range m.Tracers {
        t.TraceQueryEnd(ctx, conn, data)
    }
}

func main() {
    // prepare everything
    l, _ := logger.New(conf.Server.Debug, "logs/app.log")
    traceLogger := logger.NewTraceLogger(*l, conf.Server.Debug)
    m := logger.MultiQueryTracer{
        Tracers: []pgx.QueryTracer{
            // open telemetry tracer: https://github.com/exaring/otelpgx
            otelpgx.NewTracer(),
            // logger
            traceLogger,
        },
    }

    l.Info().Msg("Initializing database connection")
    dbString := fmt.Sprintf(fmtDBString, conf.DB.Host, conf.DB.Username, conf.DB.Password, conf.DB.DBName, conf.DB.Port)
    l.Info().
        Str("host", conf.DB.Host).
        Int("port", conf.DB.Port).
        Str("database", conf.DB.DBName).
        Msg("Connecting to database")

    dbConfig, err := pgxpool.ParseConfig(dbString)
    if err != nil {
        l.Fatal().
            Err(err).
            Msg("Failed to parse database config")
        return
    }
    dbConfig.ConnConfig.Tracer = &m

    pool, err := pgxpool.NewWithConfig(
        ctx,
        dbConfig,
    )
    if err != nil {
        l.Fatal().
            Err(err).
            Msg("Failed to create database connection pool")
        return
    }
    defer pool.Close()
    l.Info().Msg("Database connection established successfully")
}