一、标准库log介绍
- go语言内置的log包实现了简单的日志服务。
1、使用logger
- log包定义了logger类型，该类型提供了一些格式化输出的方法。
- log包也提供了一个预定义的“标准”logger，可以通过调用函数print系列(print|printf|println）、fatal系列（fatal|fatalf|fatalln）、和panic系列（panic|panicf|panicln）来使用，比自行创建一个logger对象更容易使用。
logger会打印每条日志信息的日期、时间，默认输出到系统的标准错误。
fatal系列函数会在写入日志信息后调用os.exit(1)。
panic系列函数会在写入日志信息后panic。
示例：
// 直接调用print来输出日志到终端
func main() {
log.println("这是一条很普通的日志。")
v := "很普通的"
log.printf("这是一条%s日志。\n", v)
log.fatalln("这是一条会触发fatal的日志。")
log.panicln("这是一条会触发panic的日志。")
}
2、配置logger
2.1、标准logger的配置
- 默认情况下的logger只会提供日志的时间信息，但是很多情况下我们希望得到更多信息，比如记录该日志的文件名和行号等。
- log标准库中为我们提供了定制这些设置的方法。log标准库中的flags函数会返回标准logger的输出配置，而setflags函数用来设置标准logger的输出配置。
二、自定义日志库
1、需要满足的需求
1、支持网不同地方输出日志
2、日志要支持开关控制
3、完整的日志要包含时间、行号、文件名、日志级别、日志信息
4、日志文件要能切割
5、日志级别
- debug
- trace
- info
- warning
- error
- fatal
2、了解下runtime包
- runtime.caller() 方法，会返回函数调用的信息，在()内传入int类型数据，代表调用的层数（0代表第一层被调用，1代表第二层，一次类推）。runtime.caller()返回如下四个参数:
pc: 记录了调用的函数消息，如函数名等
file: 调用的文件名
line: 行数
ok: 返回的bool值
// 获取代码行号
func getinfo(n int) {
/*
runtime.caller()返回四个参数:
pc: 记录了调用的函数消息，如函数名等
file: 调用的文件名
line: 行数
ok: 返回的bool值
*/
pc, file, line, ok := runtime.caller(n)
if !ok {
fmt.printf("runtime.caller() failed\n")
return
}
fmt.println(pc) // 用于调用函数消息
funcname := runtime.funcforpc(pc).name() // 利用 runtime.funcforpc()方法，参数pc序号，可以调出函数名
fmt.println(funcname)
fmt.println(file) // 打印出执行的文件的绝对路径
fmt.println(path.base(file)) // path.base()方法可以获取传入的绝对路径的最后一个文件名称
fmt.println(line) // 打印出执行的行号
}
func main() {
getinfo(0)
}
3、自定义日志库
1、在 e:\goproject\src\gitee.com 项目目录下，新建 mylogger 包目录，存放日志库代码
在mylogger包目录下console.go文件中，放将日志输出到终端的代码
# e:\goproject\src\gitee.com\mylogger\console.go
package mylogger
import (
"fmt"
"strings"
"time"
)
// 终端输出的日志内容
// logger 日志结构体
type consolelogger struct {
level loglevel
}
// 构造函数
func newlog(levelstr string) consolelogger {
level, err := parseloglevel(levelstr)
if err != nil {
panic(err)
}
return consolelogger{
level: level,
}
}
// 定义日志等级比较
func (c consolelogger) enable(level loglevel) bool {
return c.level <= level
}
// 定义一个日志打印方法
func (c consolelogger) outlog(lv loglevel, format string, a ...interface{}) {
level := parseloglevelstr(lv)
if c.enable(lv) {
msg := fmt.sprintf(format, a...) // 支持格式化操作，a...表示对接收的接口进行展开
level = strings.toupper(level)
filename, funcname, linenu := getinfo(3)
fmt.printf("[%s] [%s] [filename:%s linenum:%d:%s] %s\n", time.now().format("2006-01-02 15:04:05"), level, filename, linenu, funcname, msg)
}
}
// debug日志
func (c consolelogger) debug(msg string, a ...interface{}) {
c.outlog(debug, msg, a...)
}
// info日志
func (c consolelogger) info(msg string, a ...interface{}) {
c.outlog(info, msg, a...)
}
// warning日志
func (c consolelogger) warning(msg string, a ...interface{}) {
c.outlog(warning, msg, a...)
}
// error日志
func (c consolelogger) error(msg string, a ...interface{}) {
c.outlog(error, msg, a...)
}
// fatal日志
func (c consolelogger) fatal(msg string, a ...interface{}) {
c.outlog(fatal, msg, a...)
}
在mylogger包目录下logfile.go文件中，放将日志输出到文件的代码
# e:\goproject\src\gitee.com\mylogger\logfile.go
package mylogger
// 向文件中写日志的相关操作
import (
"fmt"
"os"
"path"
"strings"
"time"
)
// logger 日志结构体
type filelogger struct {
level loglevel
logpath string // 日志文件目录
filename string // 日志文件名称
maxfilesize int64 // 日志文件大小
fileobj *os.file
errfileobj *os.file
}
// 构造函数
func newfilelog(levelstr, fp, fn string, maxsize int64) *filelogger {
level, err := parseloglevel(levelstr)
if err != nil {
panic(err)
}
f1 := &filelogger{
level: level,
logpath: fp,
filename: fn,
maxfilesize: maxsize,
}
err = f1.initfile()
if err != nil {
panic(err)
}
return f1
}
// 定义文件初始化方法，打开文件
func (f *filelogger) initfile() error {
// 打开文件
fullpath := path.join(f.logpath, f.filename)
fileobj, err := os.openfile(fullpath, os.o_create|os.o_append|os.o_wronly, 0644)
if err != nil {
fmt.printf("open logfile failed,err:%v", err)
return err
}
// 打开错误日志文件
errfileobj, err := os.openfile("error-"+fullpath, os.o_create|os.o_append|os.o_wronly, 0644)
if err != nil {
fmt.printf("open errorlogfile failed,err:%v", err)
return err
}
// 将文件句柄赋值给结构体中的元素
f.fileobj = fileobj
f.errfileobj = errfileobj
return nil
}
// 关闭文件方法
func (f *filelogger) closefile() {
f.fileobj.close()
f.errfileobj.close()
}
// 定义日志等级比较
func (f *filelogger) enable(level loglevel) bool {
return f.level <= level
}
// 定义检查日志大小进行切割的方法
func (f *filelogger) checklogsize(file *os.file) bool { // 利用os.open()方法打开的文件句柄类型都是 *os.file 这种指针类型
fileinfo, err := file.stat()
if err != nil {
fmt.printf("get file info failed,err:%v\n", err)
return false
// panic(err)
}
if fileinfo.size() > f.maxfilesize {
return true
}
return false
}
func (f *filelogger) cutfile(file *os.file) (*os.file, error) {
// 获取当前文件名
fileinfo, err := file.stat()
if err != nil {
fmt.printf("get file info failed,err:%v\n", err)
return nil, err
}
append := "_" + time.now().format("2006-01-02-15-04-05") + ".log" // 时间戳后缀
filename := fileinfo.name()
newfilename := filename + append
oldpath := path.join(f.logpath, filename) // 日志文件的全路径
newpath := path.join(f.logpath, newfilename)
// 关闭当前文件句柄
file.close()
// 进行更名备份
os.rename(oldpath, newpath)
// 再打开一个文件
fileobj, err := os.openfile(oldpath, os.o_create|os.o_append|os.o_wronly, 0644)
if err != nil {
fmt.printf("open logfile failed,err:%v\n", err)
return nil, err
}
return fileobj, nil
}
// 定义一个日志输出的方法
func (f *filelogger) outlog(lv loglevel, format string, a ...interface{}) {
level := parseloglevelstr(lv)
if f.enable(lv) {
msg := fmt.sprintf(format, a...) // 支持格式化操作，a...表示对接收的接口进行展开
level = strings.toupper(level)
filename, funcname, linenu := getinfo(3)
// 判断日志是否需要切割
if f.checklogsize(f.fileobj) {
fileobj, err := f.cutfile(f.fileobj)
if err != nil {
fmt.printf("log cut failed,err:%v\n", err)
}
f.fileobj = fileobj
}
// 将日志记录在日志文件中
fmt.fprintf(f.fileobj, "[%s] [%s] [filename:%s linenum:%d:%s] %s\n", time.now().format("2006-01-02 15:04:05"), level, filename, linenu, funcname, msg)
if lv >= error {
// 判断错误日志是否需要切割
if f.checklogsize(f.errfileobj) {
fileobj, err := f.cutfile(f.errfileobj)
if err != nil {
fmt.printf("log cut failed,err:%v\n", err)
}
f.errfileobj = fileobj
}
// 将日志等级大于error的在错误日志中再记录一遍
fmt.fprintf(f.errfileobj, "[%s] [%s] [filename:%s linenum:%d:%s] %s\n", time.now().format("2006-01-02 15:04:05"), level, filename, linenu, funcname, msg)
}
}
}
// debug日志
func (f *filelogger) debug(msg string, a ...interface{}) {
f.outlog(debug, msg, a...)
}
// info日志
func (f *filelogger) info(msg string, a ...interface{}) {
f.outlog(info, msg, a...)
}
// warning日志
func (f *filelogger) warning(msg string, a ...interface{}) {
f.outlog(warning, msg, a...)
}
// error日志
func (f *filelogger) error(msg string, a ...interface{}) {
f.outlog(error, msg, a...)
}
// fatal日志
func (f *filelogger) fatal(msg string, a ...interface{}) {
f.outlog(fatal, msg, a...)
}
在mylogger包目录下创建mylogger.go文件，放包内共用的代码
# e:\goproject\src\gitee.com\mylogger\mylogger.go
package mylogger
import (
"errors"
"fmt"
"path"
"runtime"
"strings"
)
// 设置日志级别
type loglevel uint16
const (
unknown loglevel = iota
debug
trace
info
warning
error
fatal
)
// 解析日志等级，将字符串解析成int
func parseloglevel(s string) (loglevel, error) {
s = strings.tolower(s) // 将字符串全部转为小写
switch s {
case "debug":
return debug, nil
case "trace":
return trace, nil
case "info":
return info, nil
case "warning":
return warning, nil
case "error":
return error, nil
case "fatal":
return fatal, nil
default:
err := errors.new("无效日志等级")
return unknown, err
}
}
// 将日志等级解析成字符串
func parseloglevelstr(lv loglevel) (s string) {
s = strings.tolower(s) // 将字符串全部转为小写
switch lv {
case debug:
return "debug"
case trace:
return "trace"
case info:
return "info"
case warning:
return "warning"
case error:
return "error"
case fatal:
return "fatal"
default:
return "debug"
}
}
// 获取代码行号
func getinfo(n int) (filename, funcname string, line int) {
/*
runtime.caller()返回四个参数:
pc: 记录了调用的函数消息，如函数名等
file: 调用的文件名
line: 行数
ok: 返回的bool值
*/
pc, file, line, ok := runtime.caller(n)
if !ok {
fmt.printf("runtime.caller() failed\n")
return
}
filename = path.base(file)
funcname = runtime.funcforpc(pc).name()
return filename, funcname, line
}
2、调用日志库代码测试
需要注意，导入mylogger包，是从$gopath路径开始的（即从src目录开始的相对路径）
# e:\goproject\src\gitee.com\ltp\logging
package main
import (
"time"
mylogger "gitee.com/mylogger"
)
func main() {
id := 10
name := "小明"
flogger := mylogger.newfilelog("info", "./", "app.log", 1024)
for {
flogger.warning("这是个warning日志")
flogger.error("这是个error日志,id:%d name:%s", id, name)
time.sleep(2 * time.second)
}
}
到此这篇关于go log日志库的文章就介绍到这了,更多相关go log日志库内容请搜索www.887551.com以前的文章或继续浏览下面的相关文章希望大家以后多多支持www.887551.com！
黄山市民网：https://www.huangshanshimin.com/
