Logger CLI

Below is a complete, working example of a command-line application written in Go. It utilizes the ZeroLog library to efficiently log messages at configurable severity levels directly to a local log file.

Go
package main

import (
	"flag"
	"fmt"
	"os"
	"strings"

	"github.com/rs/zerolog"
)

func main() {
	logLevelStr := flag.String("loglevel", "info", "Level of this log message: debug, info, warn, error, fatal")
	setLevelStr := flag.String("setlevel", "info", "Logging threshold: debug, info, warn, error, fatal")
	flag.Parse()

	args := flag.Args()
	if len(args) < 1 {
		fmt.Fprintln(os.Stderr, "Error: Please provide a log message.")
		os.Exit(1)
	}
	message := args[0]

	logLevel := parseLevel(*logLevelStr)
	setLevel := parseLevel(*setLevelStr)

	logFile, err := os.OpenFile("logger.log", os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0644)
	if err != nil {
		fmt.Fprintf(os.Stderr, "Error opening log file: %v\n", err)
		os.Exit(1)
	}
	defer logFile.Close()

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

	if logLevel < setLevel {
		fmt.Printf("Log message at level %s NOT logged (threshold: %s)\n", logLevel, setLevel)
		return
	}

	logWithLevel(logger, logLevel, message)
	fmt.Printf("Log message at level %s logged.\n", logLevel)
}

func parseLevel(levelStr string) zerolog.Level {
	levelStr = strings.ToLower(levelStr)
	level, err := zerolog.ParseLevel(levelStr)
	if err != nil {
		fmt.Fprintf(os.Stderr, "Invalid level '%s', defaulting to info\n", levelStr)
		return zerolog.InfoLevel
	}
	return level
}

func logWithLevel(logger zerolog.Logger, level zerolog.Level, msg string) {
	switch level {
	case zerolog.DebugLevel:
		logger.Debug().Msg(msg)
	case zerolog.InfoLevel:
		logger.Info().Msg(msg)
	case zerolog.WarnLevel:
		logger.Warn().Msg(msg)
	case zerolog.ErrorLevel:
		logger.Error().Msg(msg)
	case zerolog.FatalLevel:
		logger.Fatal().Msg(msg)
	default:
		logger.Info().Msg(msg)
	}
}
Expand

To compile and build the program:

Bash
vim main.go
go mod init logger
go mod tidy

go: finding module for package github.com/rs/zerolog
go: downloading github.com/rs/zerolog v1.34.0
go: found github.com/rs/zerolog in github.com/rs/zerolog v1.34.0
go: downloading github.com/mattn/go-colorable v0.1.13
go: downloading github.com/mattn/go-isatty v0.0.19
go: downloading golang.org/x/sys v0.12.0

go build -o logger

This CLI allows users to specify a logging threshold (setlevel) and log messages at a chosen severity (loglevel). If the message’s severity is equal to or higher than the configured threshold, the message is logged; otherwise, the message is skipped.


Note: This implementation uses Go’s default flag package, which strictly interprets the order of flags and arguments. For greater flexibility in argument ordering, consider using the pflag package instead.

Example scenarios for each log level:

Bash
./logger --loglevel=debug --setlevel=info "File opened"
Log message at level debug NOT logged (threshold: info)

./logger --loglevel=info --setlevel=debug "File opened"
Log message at level info logged.

./logger --loglevel=warn --setlevel=info "Disk usage high"
Log message at level warn logged.

./logger --loglevel=info --setlevel=warn "Routine check passed"
Log message at level info NOT logged (threshold: warn)

./logger --loglevel=error --setlevel=warn "Unable to connect to DB"
Log message at level error logged.

The resulting log entries in the local log file will appear as follows:

Bash
cat logger.log
{"level":"info","time":"2025-03-28T15:32:06-05:00","message":"File opened"}
{"level":"warn","time":"2025-03-28T15:32:49-05:00","message":"Disk usage high"}
{"level":"error","time":"2025-03-28T15:33:29-05:00","message":"Unable to connect to DB"}

cat logger.log | grep error
{"level":"error","time":"2025-03-28T15:33:29-05:00","message":"Unable to connect to DB"}