在 Golang 高效的多包最佳实践中使用记录器/配置

Question

我有以下项目结构：myGithubProject/     |---- cmd       |----- command         |----- hello.go     |---- internal         |----- template            |----- template.go         |----- log           |----- logger.go     main.go和log处于template同一级别（在内部包下） 在logger.go我使用logrus一些配置作为记录器时，我想使用包logger.go 内的对象template。我应该如何以干净的方式做到这一点？import logger目前我在我的文件中使用它template.go，在包下，internal我有6更多packages需要这个的东西logger。他们每个人都依赖于它。（在log包装上），有没有很好的去处理它？更新：如果我有更多需要传递的东西（比如记录器），这里的方法/模式是什么？也许使用dependency injection？interface？其他清洁方法...我需要一些最佳实践的完整示例，我如何在文件logger内部hello.go以及template.go.这是我的项目cliProject/main.gopackage mainimport (    "cliProject/cmd"    "cliProject/internal/logs")func main() {    cmd.Execute()    logs.Logger.Error("starting")}**cliProject/cmd/root.go**package cmdimport (    "fmt"    "github.com/spf13/cobra")var rootCmd = &cobra.Command{    Use:   "cliProject",    Short: "A brief description of your application",}func Execute() {    if err := rootCmd.Execute(); err != nil {        fmt.Println(err)    }}**cliProject/cmd/serve.go**package cmdimport (    "cliProject/internal/logs"    "fmt"    "github.com/spf13/cobra")// serveCmd represents the serve commandvar serveCmd = &cobra.Command{    Use:   "serve",    Short: "A brief description of your command",    Run: func(cmd *cobra.Command, args []string) {        fmt.Println("serve called")        startServe()        stoppingServe()    },}func init() {    rootCmd.AddCommand(serveCmd)    serveCmd.Flags().BoolP("toggle", "t", false, "Help message for toggle")}func startServe() {    logs.Logger.Error("starting from function serve")}func stoppingServe() {    logs.Logger.Error("stoping from function serve")}**cliProject/cmd/start.go**package cmdimport (    "cliProject/internal/logs"    "github.com/spf13/cobra")这是它的样子

Answer 1

在内部包下，我还有 6 个需要这个记录器的包。他们每个人都依赖于它。（在日志包上），去处理它有什么好处吗？

一个好的一般原则是尊重应用程序的选择（是否记录或不记录）而不是设置策略。

1. 让目录中的 Go pkgsinternal成为支持包

• 只会error在出现问题时返回

• 不会记录（控制台或其他方式）

• 惯于panic

2. 让您的应用程序（您cmd目录中的包）决定在发生错误时的适当行为（日志/正常关闭/恢复到 100% 完整性）

这将通过仅在特定层进行日志记录来简化开发。注意：记得给应用程序提供足够的上下文来确定操作

内部/流程/process.go

package process

import (

    "errors"

)

var (

    ErrNotFound = errors.New("Not Found")

    ErrConnFail = errors.New("Connection Failed")

)

// function Process is a dummy function that returns error for certain arguments received

func Process(i int) error {

    switch i {

    case 6:

        return ErrNotFound

    case 7:

        return ErrConnFail

    default:

        return nil

    }

}

cmd/servi/main.go

package main

import (

    "log"

    p "../../internal/process"

)

func main() {

    // sample: generic logging on any failure

    err := p.Process(6)

    if err != nil {

        log.Println("FAIL", err)

    }

    // sample: this application decides how to handle error based on context

    err = p.Process(7)

    if err != nil {

        switch err {

        case p.ErrNotFound:

            log.Println("DOESN'T EXIST. TRY ANOTHER")

        case p.ErrConnFail:

            log.Println("UNABLE TO CONNECT; WILL RETRY LATER")

        }

    }

}

如果我有更多需要传递的东西（比如记录器），这里的方法/模式是什么

依赖注入始终是一个不错的首选。仅当最简单的实施方式不够时才考虑其他方式。

下面的代码使用依赖注入和一流的函数传递将template和打包在一起。logger

内部/日志/logger.go

package logger

import (

    "github.com/sirupsen/logrus"

    "github.com/x-cray/logrus-prefixed-formatter"

    "os"

)

var Logger *logrus.Logger

func NewLogger() *logrus.Logger {

    var level logrus.Level

    level = LogLevel("info")

    logger := &logrus.Logger{

        Out:   os.Stdout,

        Level: level,

        Formatter: &prefixed.TextFormatter{

            DisableColors:   true,

            TimestampFormat: "2009-06-03 11:04:075",

        },

    }

    Logger = logger

    return Logger

}

func LogLevel(lvl string) logrus.Level {

    switch lvl {

    case "info":

        return logrus.InfoLevel

    case "error":

        return logrus.ErrorLevel

    default:

        panic("Not supported")

    }

}

内部/模板/template.go

package template

import (

    "fmt"

    "github.com/sirupsen/logrus"

)

type Template struct {

    Name   string

    logger *logrus.Logger

}

// factory function New accepts a logging function and some data

func New(logger *logrus.Logger, data string) *Template {

    return &Template{data, logger}

}

// dummy function DoSomething should do something and log using the given logger

func (t *Template) DoSomething() {

    t.logger.Info(fmt.Sprintf("%s, %s", t.Name, "did something"))

}

命令/servi2/main.go

package main

import (

    "../../internal/logs"

    "../../internal/template"

)

func main() {

    // wire our template and logger together

    loggingFunc := logger.NewLogger()

    t := template.New(loggingFunc, "Penguin Template")

    // use the stuff we've set up

    t.DoSomething()

}

希望这可以帮助。干杯，

Answer 2

有几种可能性，每种可能性都有自己的权衡。

1. 显式传递依赖项

2. 传入具有所有依赖项的上下文

3. 将结构用于方法的上下文

4. 使用全局包并导入

它们在不同的情况下都有自己的位置，并且都有不同的权衡：

1. 这非常清楚，但可能会变得非常混乱，并使您的函数因大量依赖而变得混乱。如果那是你的事，它使测试很容易模拟。

2. 这是我最不喜欢的选项，因为它一开始很诱人，但很快就变成了一个混合了许多不相关问题的上帝对象。避免。

3. 这在许多情况下非常有用，例如许多人以这种方式访问数据库。如果需要，也很容易模拟。这允许您设置/共享依赖项而无需在使用时更改代码 - 基本上以比传入显式参数更简洁的方式反转控制。

4. 这具有清晰性和正交性的优点。它将要求您为测试与生产添加单独的设置，在使用之前将包初始化为正确的状态。由于这个原因，有些人不喜欢它。

只要使用非常简单的签名，我更喜欢将包全局方法用于日志记录之类的东西。我不倾向于测试日志输出，或者经常更改记录器。考虑你真正需要从日志中得到什么，以及是否最好只使用内置的日志包，也许可以尝试其中一种方法，看看哪种方法适合你。

为简洁起见，伪代码示例：

// 1. Pass in dependencies explicitly

func MyFunc(log LoggerInterface, param, param)

// 2. Pass in a context with all dependencies

func MyFunc(c *ContextInterface, param, param)

// 3. Use a struct for context to methods

func (controller *MyController) MyFunc(param, param) {

   controller.Logger.Printf("myfunc: doing foo:%s to bar:%s",foo, bar) 

}

// 4. Use a package global and import

package log 

var DefaultLogger PrintfLogger

func Printf(format, args) {DefaultLogger.Printf(format, args)}

// usage: 

import "xxx/log"

log.Printf("myfunc: doing foo:%s to bar:%s",foo, bar) 

我更喜欢这个选项 4 用于日志记录和配置，甚至数据库访问，因为它是明确的、灵活的，并且允许轻松切换另一个记录器——只需更改导入，无需更改接口。不过，最佳计算取决于具体情况——如果您正在编写一个广泛使用的库，您可能更愿意允许在结构级别设置记录器。

我通常需要在应用程序启动时使用显式设置进行设置，并且始终避免使用 init 函数，因为它们令人困惑且难以测试。

Answer 3

我总是明确地将 a 传递*logrus.Logger给需要它的函数（或偶尔是对象）。这避免了奇怪的依赖循环，明确表明日志记录是这个函数所做的事情的一部分，并且更容易在别处重用该函数或模块。初始日志对象是在我的主函数中创建和配置的（可能在一些命令行参数处理之后）。