CODEWITHSUNDEEP
gozerolog
leonardo watch
leonardo watch

Reputation: 53

Differentiating Error Level Log Output in Terminal and Hook Zerolog go

I'm currently working with the zerolog library in my Go application, and I'm facing a requirement where I need to differentiate the output of log messages based on their log level:

I want log messages of ERROR level to be displayed only in the terminal/console. All log messages, regardless of their level (DEBUG, INFO, WARNING, ERROR), should be sent to a hook for further processing. This is my Code :

func InitLogger(ctx context.Context, cfg *config, mc *mongo.Client) *zerolog.Logger {
    once.Do(func() {
        var multi zerolog.LevelWriter

        consoleWriter := zerolog.ConsoleWriter{Out: os.Stdout, NoColor: true, TimeFormat: time.RFC3339}

        multi = zerolog.MultiLevelWriter(consoleWriter)

        logger := zerolog.New(multi).Level(zerolog.TraceLevel).With().Timestamp().Logger()

        logger = logger.Hook(&ZerologHook{
            mClient:     mc,
        })

        zLog = &logger

    })

    return zLog
}


type ZerologHook struct {
    mClient     *mongo.Client
}

func (zh *ZerologHook) Run(e *zerolog.Event, level zerolog.Level, message string) {

    wg.Add(1)
    go func() {
    
        logData := LogData{}

        _ = zh.sendLogToMongoDB(e.GetCtx(), message, logData)

        wg.Done()
    }()
}

Is there a way to configure zerolog such that ERROR level log messages are shown only in the terminal while still allowing all log messages to be sent to the hook for further processing?

Upvotes: 1

Views: 301

Answers (1)

leonardo watch
leonardo watch

Reputation: 53

I managed to resolve the issue I was having with sending log levels to mongoDB while only displaying error logs on the terminal. If anyone else is facing a similar hope this code will help.

func ConsoleWriter() zerolog.ConsoleWriter {
    consoleWriter := zerolog.ConsoleWriter{Out: os.Stdout, NoColor: true, TimeFormat: time.RFC3339}

    return consoleWriter
}

func InitLogger(ctx context.Context, mc *mongo.Client, productType int) *zerolog.Logger {
    once.Do(func() {
        var multi zerolog.LevelWriter

        multi = zerolog.MultiLevelWriter(ZerologOut{
            mClient:     mc,
        })

        
        logger := zerolog.New(multi).With().Timestamp().Logger()

        zLog = &logger

    })
    return zLog
}


type ZerologOut struct {
    mClient     *mongo.Client
}


func (zo ZerologOut) Write(p []byte) (n int, err error) {
    return os.Stdout.Write(p)
}


func (zo ZerologOut) WriteLevel(level zerolog.Level, p []byte) (n int, err error) {

    message := string(p)

    logData := LogData{}

    err = zo.sendLogToMongoDB(context.Background(), message, logData)
    if err != nil {
        return 0, err
    }

    if level == zerolog.ErrorLevel {
        return ConsoleWriter().Write(p)
    }

    return len(p), nil
}

Upvotes: 0

Related Questions