Logging with Context

Structured logging with context in Go can significantly improve traceability and make debugging easier by providing additional metadata with each log entry. The log package in the Go standard library is basic; for more advanced logging needs, the logrus library is widely used.

Using Logrus with Context

Logrus is a popular logging library that allows structured logging, including context data.

Setting Up Logrus

To use Logrus for structured logging with context, first install the package:

go get github.com/sirupsen/logrus

Here is a simple example:

package main

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

func main() {
	log := logrus.WithFields(logrus.Fields{
		"app": "example",
		"env": "production",
	})

	// Create a context with a correlation ID.
	ctx := context.WithValue(context.Background(), "correlation_id", "12345")
	logWithContext(ctx, log)
}

func logWithContext(ctx context.Context, baseLog *logrus.Entry) {
	correlationID := ctx.Value("correlation_id")

	log := baseLog.WithFields(logrus.Fields{
		"correlation_id": correlationID,
	})

	log.Info("Starting processing")
	// Simulate processing.
	log.WithField("step", "load data").Info("Loading data")
	log.WithField("step", "process data").Info("Processing data")
	log.Info("Processing completed")
}

Using Context in HTTP Handlers

Logrus can easily be integrated into HTTP handlers to log requests along with context data:

package main

import (
	"context"
	"net/http"
	"github.com/sirupsen/logrus"
)

func main() {
	http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
		// Extract or generate a request ID for tracing.
		requestID := r.Header.Get("X-Request-ID")
		if requestID == "" {
			requestID = "default-id"
		}

		// Attach the request ID to context.
		ctx := context.WithValue(r.Context(), "request_id", requestID)

		log := logrus.WithFields(logrus.Fields{
			"request_id": requestID,
			"path":       r.URL.Path,
			"method":     r.Method,
		})

		handleRequest(ctx, log, w, r)
	})

	http.ListenAndServe(":8080", nil)
}

func handleRequest(ctx context.Context, log *logrus.Entry, w http.ResponseWriter, r *http.Request) {
	log.Info("Handling request")
	// Simulate processing.
	w.Write([]byte("Request handled"))
	log.Info("Request processed")
}

Best Practices

• Use structural logging to include metadata, which aids in debugging and tracing.
• Attach unique identifiers (e.g., request ID, user ID) to logs using context.
• Keep log output consistent and meaningful by following a logging format across your application.
• Centralize logging setup to easily adjust configurations and logging levels as needed.

Common Pitfalls

• Failing to propagate the context through the application functions and layers might lose critical tracing information.
• Overloading context with excessive data can lead to performance issues.
• Logging sensitive information without appropriate care can lead to security risks.

Performance Tips

• Use asynchronous logging if supported by the library to reduce performance overhead by avoiding I/O blocking operations.
• Consider the verbosity level of the logs, adjusting logging level during development and production to avoid unnecessary performance overhead.
• Regularly rotate and archive logs to prevent log files from becoming too large, which can negatively impact performance.