Core Components 🔥 - Logging - 《GoFrame v2.8 Documentation》

Introduction
Features
Singleton Object
Differences between glog.Print and g.Log().Print
Documentation

glog is a universal high-performance log management module that provides powerful and easy-to-use log management functions and is one of the core components of the GoFrame development framework.

Introduction

Usage:

import "github.com/gogf/gf/v2/os/glog"

API Documentation:

https://pkg.go.dev/github.com/gogf/gf/v2/os/glog

Brief Description:

The glog module has a fixed log file name format *.log, using .log as the fixed log file name suffix.
glog supports file output, log levels, log categorization, debug management, call tracing, chaining operations, rotation splitting, and many more rich features.
You can use the glog.New method to create glog.Logger objects for custom log printing, but it is recommended to use the default package methods provided by glog to print logs.
When using package methods to modify module configuration, note that any glog.Set* setting methods will take effect globally.
The default time format for log content is time [level] content newline, where time is accurate to the millisecond level, level is optionally output, content is the parameter input of the calling side, and newline is optionally output (some methods automatically add a newline character to the log content). Example log content: 2018-10-10 12:00:01.568 [ERRO] An error occurred.
Print*/Debug*/Info* methods output log content to the standard output (stdout), and to prevent the mixing of logs, Notice*/Warning*/Error*/Critical*/Panic*/Fatal* methods also output log content to the standard output (stdout).
The Panic* methods will trigger a panic error method after outputting log information.
The Fatal* methods will stop the process running after outputting log information and return a process status code of 1 (the normal program exit status code is 0).

Features

The glog component has the following notable features:

Easy to use, powerful functionality
Supports configuration management with a unified configuration component
Supports log levels
Supports color printing
Supports chaining operations
Supports specifying output log files/directories
Supports tracing
Supports asynchronous output
Supports stack printing
Supports debug information switch
Supports custom Writer output interface
Supports custom log Handler processing
Supports custom log CtxKeys keys
Supports JSON format printing
Supports Flags feature
Supports Rotate rotation splitting feature

Singleton Object

The log component supports the singleton pattern, using g.Log(singleton name) to obtain different singleton log management objects. The purpose of providing singleton objects is to allow different log management objects to be used for different business scenarios. It is recommended to use the g.Log() method to obtain singleton objects for logging operations. This method will automatically read the configuration file and initialize the singleton object, and this initialization operation will only be executed once.

Differences between `glog.Print` and `g.Log().Print`

glog is the package name of the log component, and g.Log() is a singleton object of a log component.
The g.Log() singleton object is maintained through the object management component g package. During object initialization, it will automatically read the log configuration. It is easy to use, and in most cases, it is recommended to use this method to use the log component.
glog is used in the form of an independent component, and by default, it directly outputs logs to the terminal. You can also set global configuration through configuration management methods or create independent log objects using New.

tip

User: Why are there two ways to print logs? Which method should I use?

Answer:

Since each component of the framework is decoupled, the framework can be used as an independent tool library. For example, if the project only needs to use the log component, you can directly use the methods of the glog package, without introducing other components. However, in project engineering use, the use of the tool library may be more cumbersome, often involving configuration and component initialization (in most cases, this will lead to secondary encapsulation). Therefore, the framework also provides a coupled package called the g package. This package loads some commonly used components by default. g.Log() is one of the log components, which will automatically read and initialize the configuration object according to engineering specifications, quickly initialize the log object and achieve singleton management, greatly simplifying the use of logs under engineering. For more introductions, please refer to: Objects