Golang Log

Golang Logging is a critical aspect of software development, providing insights into the behavior of applications and aiding in debugging and monitoring. In this post, we’ll explore the logging capabilities of Golang log, compare it with other logging libraries, and discuss best practices for using it in real-life projects.

Introduction to Golang Logging

Golang log is one of the standard libraries which provides basic logging capabilities. This library is straightforward to use and integrates seamlessly with Go applications. Its really crucial to decide which logging framework to use for your projects. There are various factors which we will discuss in detail to make it easy to choose the right one for your use case.

Why Use Logging?

• Debugging: Helps trace issues and understand application flow.
• Monitoring: Provides insights into application performance.
• Audit Trails: Keeps records of application activities for compliance and analysis.

Getting Started with Golang’s log Package

The Golang log package is simple yet powerful, offering basic logging functionalities such as printing messages, setting output destinations, and formatting logs.

Basic Usage

Here’s a simple example to get you started with the log package:

package main

import (
	"log"
	"os"
)

func main() {
	// Setting the output destination to a file
	file, err := os.OpenFile("app.log", os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0666)
	if err != nil {
		log.Fatalf("Failed to open log file: %v", err)
	}
	log.SetOutput(file)

	// Logging messages
	log.Println("This is a standard log message.")
	log.Printf("Formatted log message: %s", "Hello, Logger!")

	// Logging with different severity levels
	log.Fatal("This is a fatal log message, program will exit.")
	log.Panic("This is a panic log message, program will panic.")
}

Explanation of the Code

• Setting Output: The log.SetOutput() function directs log messages to a specified destination, such as a file.
• Logging Messages: log.Println() and log.Printf() are used for standard and formatted log messages.
• Severity Levels: log.Fatal() logs a message and then calls os.Exit(1), while log.Panic() logs a message and then calls panic().

Creating Custom Logger

Lets create a basic custom logger that defines different log levels (INFO, WARN, ERROR) with color-coded output:

package main

import (
    "fmt"
    "os"
    "time"
)

type LogLevel int

const (
    INFO LogLevel = iota
    WARN
    ERROR
)

type CustomLogger struct {
    level LogLevel
}

func (l *CustomLogger) log(level LogLevel, message string) {
    if level >= l.level {
        timestamp := time.Now().Format("2006-01-02 15:04:05")
        var levelString, color string
        
        switch level {
        case INFO:
            levelString = "INFO"
            color = "\033[32m" // Green
        case WARN:
            levelString = "WARN"
            color = "\033[33m" // Yellow
        case ERROR:
            levelString = "ERROR"
            color = "\033[31m" // Red
        }
        
        fmt.Fprintf(os.Stdout, "%s[%s] %s: %s\033[0m\n", color, timestamp, levelString, message)
    }
}

func (l *CustomLogger) Info(message string) {
    l.log(INFO, message)
}

func (l *CustomLogger) Warn(message string) {
    l.log(WARN, message)
}

func (l *CustomLogger) Error(message string) {
    l.log(ERROR, message)
}

func main() {
    logger := &CustomLogger{level: INFO}
    
    logger.Info("This is an informational message")
    logger.Warn("This is a warning message")
    logger.Error("This is an error message")
}

Expected Output:

[2024-08-22 12:00:00] INFO: This is an informational message
[2024-08-22 12:00:01] WARN: This is a warning message
[2024-08-22 12:00:02] ERROR: This is an error message

Each message will be in a different color: green for INFO, yellow for WARN, and red for ERROR.

• We define a LogLevel type and constants for different log levels (INFO, WARN, ERROR).
• The CustomLogger struct holds the current log level.
• The log method is the core of our logger:
  • It checks if the message’s level is high enough to be logged.
  • It formats the timestamp.
  • It sets the appropriate color and level string based on the log level.
  • It prints the formatted log message to stdout.
• We define convenience methods (Info, Warn, Error) that call the log method with the appropriate level.
• In the main function, we create a logger instance and use it to log messages at different levels.

Popular Third-Party Logging Libraries

1. Logrus

Logrus is a widely used structured logging library. By default, Logrus outputs logs in a text format that includes the timestamp, log level, message, and any additional fields. However, Logrus can be configured to output logs in JSON format if needed.

package main

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

func main() {
    log := logrus.New()
    log.SetFormatter(&logrus.JSONFormatter{})

    log.WithFields(logrus.Fields{
        "username": "john",
        "ip":       "192.168.1.1",
    }).Info("User logged in")
}

Expected Output:

{
    "level": "info",
    "msg": "User logged in",
    "time": "2024-08-22T12:00:00Z",
    "username": "john_doe",
    "ip": "192.168.1.1"
}

• logrus.New(): Initializes a new Logrus logger.
• log.SetFormatter(&logrus.JSONFormatter{}): Configures the Logrus logger to use the JSONFormatter, which outputs logs in JSON format.
• log.WithFields(): Adds structured fields to the log entry.
• Info("User logged in"): Logs an informational message.

2. slog (Go 1.21+)

Go 1.21 introduced the slog package for structured logging.

package main

import (
    "log/slog"
    "os"
)

func main() {
    logger := slog.New(slog.NewJSONHandler(os.Stdout, nil))
    logger.Info("User logged in", "username", "john", "ip", "192.168.1.1")
}

Expected Output:

{
    "level": "info",
    "msg": "User logged in",
    "username": "john",
    "ip": "192.168.1.1"
}

• slog.NewJSONHandler(os.Stdout, nil): Creates a new logger that outputs logs in JSON format to the standard output.
• logger.Info("User logged in", "username", "john", "ip", "192.168.1.1"): Logs an informational message with structured fields for username and ip

3. Zap

Zap is known for its high performance.

package main

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

func main() {
    logger, _ := zap.NewProduction()
    defer logger.Sync()
    sugar := logger.Sugar()
    sugar.Infow("User logged in",
        "username", "john",
        "ip", "192.168.1.1",
    )
}

Expected Output:

{
    "level": "info",
    "ts": 1692700800,
    "msg": "User logged in",
    "username": "john",
    "ip": "192.168.1.1"
}

Note: The timestamp (ts) will be a Unix timestamp and will vary based on the actual time of execution.

• zap.NewProduction(): Creates a production-ready logger with sensible defaults.
• defer logger.Sync(): Ensures any buffered log entries are flushed before the program exits.
• sugar.Infow(): Logs an informational message with structured fields using a “sugared” logger for a simpler API.

Comparison and Recommendations

1. Standard log package:
   • Pros: Simple, part of standard library
   • Cons: No log levels, no structured logging
   • Use case: Small scripts, basic applications
2. slog:
   • Pros: Structured logging, part of standard library (Go 1.21+)
   • Cons: Relatively new, may lack some advanced features
   • Use case: Modern Go applications needing structured logging
3. Logrus:
   • Pros: Easy to use, structured logging, widely adopted
   • Cons: No longer actively developed
   • Use case: Existing projects using Logrus
4. Zap:
   • Pros: High performance, structured logging, actively maintained
   • Cons: Slightly more complex API
   • Use case: High-performance applications, microservices

Best Practices

1. Use structured logging for easier parsing and analysis
2. Include relevant context in log messages (e.g., request IDs, user IDs)
3. Use appropriate log levels (debug, info, warn, error)
4. Avoid logging sensitive information
5. Consider using a centralized logging system for distributed applications

FAQs

What is Golang’s log package used for?

Golang’s log package is used for logging messages to standard output or a specified destination. It provides basic logging functionalities like printing messages and setting output destinations.

Can I use Golang’s log package for structured logging?

No, Golang’s log package does not support structured logging. For structured logging, consider using third-party libraries like Logrus or Zap.

How do I set the output destination for logs in Golang?

You can set the output destination using the log.SetOutput() function, which allows you to specify a file, standard output, or any other io.Writer.

Is Golang’s log package suitable for production use?

While it can be used in production for simple applications, it lacks advanced features needed for complex applications. For production-grade logging, consider using third-party libraries.

Conclusion

For new projects, consider using slog if you’re on Go 1.21 or later. It provides structured logging as part of the standard library. For high-performance requirements or more advanced features, Zap is an excellent choice. Logrus is still widely used but consider alternatives for new projects.

Remember to choose a logging library that fits your project’s needs in terms of performance, features, and ease of use. For more information on Golang’s log package, refer to the official Golang log documentation. Happy Coding!