Logging Levels and Configuration

Logging is a crucial part of application development and maintenance. Go provides several libraries for logging, including the standard log package and popular third-party libraries like logrus and zap. This guide covers how to use different logging levels and configure them to enhance your application's logging system.

Basic Logging with log

The standard log package in Go provides basic logging functionality. Here's an example of setting up different logging levels and using them:

package main

import (
	"log"
	"os"
)

var (
	InfoLogger  *log.Logger
	WarnLogger  *log.Logger
	ErrorLogger *log.Logger
)

func init() {
	file, err := os.OpenFile("app.log", os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0666)
	if err != nil {
		log.Fatal(err)
	}

	InfoLogger = log.New(file, "INFO: ", log.Ldate|log.Ltime|log.Lshortfile)
	WarnLogger = log.New(file, "WARN: ", log.Ldate|log.Ltime|log.Lshortfile)
	ErrorLogger = log.New(file, "ERROR: ", log.Ldate|log.Ltime|log.Lshortfile)
}

func main() {
	InfoLogger.Println("This is informational log")
	WarnLogger.Println("This is a warning log")
	ErrorLogger.Println("This is an error log")
}

Advanced Logging with logrus

logrus is a popular structured logger in Go. It provides more features compared to the standard log package. Here’s how you set it up with different log levels:

package main

import (
	log "github.com/sirupsen/logrus"
)

func init() {
	log.SetFormatter(&log.TextFormatter{
		FullTimestamp: true,
	})
	log.SetLevel(log.InfoLevel)
	log.SetOutput(os.Stdout)
}

func main() {
	log.Info("This is an info message")
	log.Warn("This is a warning message")
	log.Error("This is an error message")
}

High-Performance Logging with zap

zap is a fast, structured logging library that provides both a low-level barebones logger and a higher-level sugared logger. Here is an example of configuring zap:

package main

import (
	"go.uber.org/zap"
)

func main() {
	logger, _ := zap.NewProduction()
	defer logger.Sync()

	sugar := logger.Sugar()
	sugar.Infow("logged with zap",
		"level", "info",
		"example", "zap logging",
	)
	sugar.Warnw("This is a warning log",
		"example", "warning",
	)
	sugar.Errorw("An error occurred",
		"example", "error",
	)
}

Best Practices

• Choose the Right Library: Use logrus for flexible, feature-rich logging, or zap if performance is a priority.
• Use Structured Logging: Prefer structured logging (key-value pairs) for better organization and retrieval in log processing systems.
• Configurable Logging Levels: Allow dynamic configuration of logging levels to control verbosity without recompiling the application.

Common Pitfalls

• Ignoring Log Output Location: Always specify the correct log output (file, stdout, etc.) to avoid missing log messages.
• Overly Verbose Logging: Avoid logging excessively at higher levels (info, debug) which can obscure critical errors.
• Lack of Contextual Information: Ensure logs provide enough context to assist debugging, typically by including relevant request or environment data.

Performance Tips

• Manage Log Rotation: Implement log rotation to prevent enormous log files from degrading performance.
• Use Efficient Formats: Leverage efficient log formats like JSON offered by libraries like zap for high-volume logging.
• Minimize Blocking: In case of heavy logging, consider logging asynchronously or using batch logging to reduce application blocking.