Logrus是否支持基于包名配置日志级别？Go语言同类日志功能替代方案咨询

Great question—this is such a handy feature for large, complex apps, so let’s break down what’s available in Go’s logging ecosystem.

Does Logrus support package-based log level configuration? #

Short answer: No, Logrus doesn’t have native support for this out of the box, unlike Java’s logging frameworks that let you map levels directly to package names via config files.

That said, you can simulate this behavior manually by creating a dedicated Logrus logger instance for each package, then setting levels for each instance at startup (based on your config). Here’s a quick example:

In the foo/bar/baz package:

package baz

import "github.com/sirupsen/logrus"

// Package-specific logger instance
var logger = logrus.New()

func init() {
    // Load your config (e.g., from a YAML/JSON file or env vars)
    // For demonstration, we'll hardcode the level here
    level, _ := logrus.ParseLevel("debug")
    logger.SetLevel(level)
}

// Example usage in the package
func DoSomething() {
    logger.Debug("Debug message from foo.bar.baz (visible)")
    logger.Info("Info message from foo.bar.baz")
}

In the foo/bar package:

package bar

import "github.com/sirupsen/logrus"

var logger = logrus.New()

func init() {
    level, _ := logrus.ParseLevel("info")
    logger.SetLevel(level)
}

func DoAnotherThing() {
    logger.Debug("This debug message will be suppressed")
    logger.Info("Info message from foo.bar (visible)")
}

This works, but it’s more manual than the Java approach—you’ll need to handle loading config values and applying them to each package’s logger explicitly.

Go logging libraries with native package-based level support #

If you want a more streamlined, native solution, these popular libraries have you covered:

1. Zap (Uber’s logging library) #

Zap is a high-performance structured logging library that supports package-based log level configuration via its config system. You can define levels per package in a JSON/YAML config, then load it at startup.

Example JSON config snippet:

{
  "level": "info",
  "loggerLevel": {
    "foo.bar": "info",
    "foo.bar.baz": "debug"
  },
  "encoding": "console",
  "outputPaths": ["stdout"]
}

To use this, load the config and create loggers tied to package names:

package main

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

func main() {
    // Load config from file
    cfg, err := zap.LoadConfig("zap-config.json")
    if err != nil {
        panic(err)
    }

    // Build the root logger
    logger, err := cfg.Build()
    if err != nil {
        panic(err)
    }
    defer logger.Sync()

    // Get package-specific loggers by name
    fooBarLogger := logger.Named("foo.bar")
    fooBarBazLogger := logger.Named("foo.bar.baz")

    fooBarLogger.Info("Visible info message from foo.bar")
    fooBarLogger.Debug("Suppressed debug message from foo.bar")

    fooBarBazLogger.Debug("Visible debug message from foo.bar.baz")
}

Zap automatically applies the level from the config to each named logger, matching the package path pattern.

2. log15 #

log15 is another popular structured logging library that supports namespace-based level filtering—you can use package names as namespaces to achieve the same effect.

Example implementation:

package main

import "github.com/inconshreveable/log15"

func main() {
    // Root logger with info-level filtering
    rootHandler := log15.LvlFilterHandler(log15.LvlInfo, log15.StdoutHandler)
    root := log15.New()
    root.SetHandler(rootHandler)

    // foo.bar logger (inherits root level unless overridden)
    fooBarLogger := root.New("ns", "foo.bar")

    // foo.bar.baz logger with debug-level filtering
    fooBarBazHandler := log15.LvlFilterHandler(log15.LvlDebug, log15.StdoutHandler)
    fooBarBazLogger := root.New("ns", "foo.bar.baz")
    fooBarBazLogger.SetHandler(fooBarBazHandler)

    fooBarLogger.Info("Info message from foo.bar (visible)")
    fooBarLogger.Debug("This debug message is hidden")

    fooBarBazLogger.Debug("Debug message from foo.bar.baz (visible)")
}

log15’s namespace system lets you granularly control levels for different parts of your application, including package-based grouping.

内容的提问来源于stack exchange，提问作者d80tb7