【Go语言学习】——简易日志库

最新推荐文章于 2024-07-05 13:45:00 发布
最新推荐文章于 2024-07-05 13:45:00 发布
阅读量287 收藏 1
点赞数
文章标签： 学习 golang 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Kaychenl/article/details/125209739
版权

日志库

  • 需求分析

    1. 支持往不同的地方输出日志
    2. 日志分多种级别：Debug、Trace、Info、Warning、Error、Fatal
    3. 日志支持控制不同级别的日志开关，支撑开发和上线运行的不同期间支持不同类型的日志（如开发时支持所有日志，上线后只支持INFO级别及以下）
    4. 日志展示时间、行号、文件名、日志级别、 日志信息
    5. 日志文件要切割（按照文件大小/日期切割）,按照文件大小只需要每次切割前查看文件大小是否达到最大文件，按照日期则可以再结构体设置标志位记录上一次切割的小时数，每次判断当前的时间的小时数和之前的是否一致。

  • runtime.Caller

    调用runtime.Caller可以查看调用函数的文件地址，函数名，以及行号，注意参数中的数字表示向上返回多少级的意思

    package main

import (
	"fmt"
	"path"
	"runtime"
)

func f2() {
	//2表示向上返回两级，表示调用这个函数的函数，然后再向上找这个函数的调用函数
	pc, file, line, ok := runtime.Caller(2)
	if !ok {
		fmt.Println("runtime.Caller() failed")
		return
	}
	funcName := runtime.FuncForPC(pc).Name()
	fmt.Println(funcName)
	fmt.Println(file)
	fmt.Println(path.Base(file)) //只要当前文件的名字
	fmt.Println(line)
}
func f1() {
	//1表示向上返回一级，返回的是调用这个函数的函数的信息
	pc, file, line, ok := runtime.Caller(1)
	if !ok {
		fmt.Println("runtime.Caller() failed")
		return
	}
	funcName := runtime.FuncForPC(pc).Name()
	fmt.Println(funcName)
	fmt.Println(file)
	fmt.Println(path.Base(file)) //只要当前文件的名字
	fmt.Println(line)
	f2()
}

//runtime.Caller返回调用函数名，所在文件名以及行号，参数则是确认返回的是当前函数还是调用这个函数的函数
func main() {
	//0表示就是当前函数
	pc, file, line, ok := runtime.Caller(0)
	if !ok {
		fmt.Println("runtime.Caller() failed")
		return
	}
	funcName := runtime.FuncForPC(pc).Name()
	fmt.Println(funcName) //返回文件名.函数名
	fmt.Println(file)
	fmt.Println(path.Base(file)) //只要当前文件的名字
	fmt.Println(line)
	f1()
}

  • fileStat

    调用文件类型的Stat()可以查看当前的文件信息，如大小，名称等

    package main

import (
	"fmt"
	"os"
)

func main() {
	fileObj, err := os.Open("./main.go")
	if err != nil {
		fmt.Printf("open file failed err:%v", err)
		return
	}
	fileInfo, err := fileObj.Stat()
	if err != nil {
		fmt.Printf("get fileInfo failed err:%v", err)
		return
	}
	fmt.Printf("文件大小是：%dB\n", fileInfo.Size())
	fmt.Printf("文件名是：%s\n", fileInfo.Name())
}

  • 日志库公共插件

    建立接口，常量，级别设置，设置格式化输出内容

    package mylogger

import (
	"errors"
	"fmt"
	"path"
	"runtime"
	"strings"
)

type LogLevel uint16

type Logger interface {
	Debug(format string, a ...interface{})
	Trace(format string, a ...interface{})
	Info(format string, a ...interface{})
	Warning(format string, a ...interface{})
	Error(format string, a ...interface{})
	Fatal(format string, a ...interface{})
}

//设置日志级别
const (
	UNKNOWN LogLevel = iota
	DEBUG
	TRACE
	INFO
	WARNING
	ERROR
	FATAL
)

//将日志级别转换为内置的级别
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 getLogString(lv LogLevel) string {
	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 "UNKNOWN"
	}
}

func getInfo(skip int) (funcName, fileName string, lineNo int) {
	pc, file, lineNo, ok := runtime.Caller(skip)
	if !ok {
		fmt.Println("runtime.Caller() failed")
		return
	}
	funcName = runtime.FuncForPC(pc).Name()
	//只要函数名，不要上面的文件名
	funcName = strings.Split(funcName, ".")[1]
	fileName = path.Base(file)
	return
}

  • 日志库终端版

    package mylogger

import (
	"fmt"
	"time"
)

// 往终端写日志内容

//ConsoleLogger日志结构体

type ConsoleLogger struct {
	Level LogLevel
}

//Logger构造函数
func NewConsoleLog(levelStr string) ConsoleLogger {
	level, err := parseLogLevel(levelStr)
	if err != nil {
		panic(err)
	}
	return ConsoleLogger{
		Level: level,
	}
}

func (c ConsoleLogger) log(lv LogLevel, format string, a ...interface{}) {
	if c.enable(lv) {
		msg := fmt.Sprintf(format, a...)
		now := time.Now()
		funcName, fileName, lineNo := getInfo(3)
		fmt.Printf("[%s] [%s] [%s:%s:%d] %s\n", now.Format("2006-01-02 15:04:05"), getLogString(lv), fileName, funcName, lineNo, msg)
	}
}

func (c ConsoleLogger) enable(loglevel LogLevel) bool {
	return c.Level <= loglevel
}

func (c ConsoleLogger) Debug(format string, a ...interface{}) {
	c.log(DEBUG, format, a...)
}

func (c ConsoleLogger) Trace(format string, a ...interface{}) {
	c.log(TRACE, format, a...)
}
func (c ConsoleLogger) Info(format string, a ...interface{}) {
	c.log(INFO, format, a...)
}
func (c ConsoleLogger) Warning(format string, a ...interface{}) {
	c.log(WARNING, format, a...)
}
func (c ConsoleLogger) Error(format string, a ...interface{}) {
	c.log(ERROR, format, a...)
}
func (c ConsoleLogger) Fatal(format string, a ...interface{}) {
	c.log(FATAL, format, a...)
}

  • 日志库文件版

    支持按照文件大小/时间进行切割

    package mylogger

import (
	"fmt"
	"os"
	"path"
	"time"
)

// 往文件里面写日志

//日志文件结构体
type FileLogger struct {
	Level       LogLevel
	filePath    string //日志文件保存的路径
	fileName    string //日志文件保存的文件名
	fileObj     *os.File
	errFileObj  *os.File
	maxFileSize int64 //最大文件大小
	timeFlag    int   //日志时间标志
	timeErrFlag int   //错误日志时间标志
}

//FileLogger构造函数
func NewFileLogger(levelStr, fp, fn string, maxSize int64) *FileLogger {
	LogLevel, err := parseLogLevel(levelStr)
	if err != nil {
		panic(err)
	}
	tf := time.Now().Minute()
	tef := time.Now().Minute()
	fl := &FileLogger{
		Level:       LogLevel,
		filePath:    fp,
		fileName:    fn,
		maxFileSize: maxSize,
		timeFlag:    tf,
		timeErrFlag: tef,
	}
	//按照文件路径和文件名将文件打开
	err = fl.initFile()
	if err != nil {
		panic(err)
	}
	return fl
}

//根据指定的日志文件路径和文件名打开对应日志和错误日志
func (f *FileLogger) initFile() error {
	//将文件路径和文件名按照操作系统的格式进行拼接
	fullFileName := path.Join(f.filePath, f.fileName)
	//打开日志和日志错误文件
	fileObj, err := os.OpenFile(fullFileName, os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0644)
	if err != nil {
		fmt.Printf("open log file failed,err:%v\n", err)
		return err
	}
	errfileObj, err := os.OpenFile(fullFileName+".err", os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0644)
	if err != nil {
		fmt.Printf("open errlog file failed,err:%v\n", err)
		return err
	}
	f.fileObj = fileObj
	f.errFileObj = errfileObj
	return nil
}

func (f *FileLogger) Close() {
	f.fileObj.Close()
	f.errFileObj.Close()
}

//根据级别确定是否需要记录该日志
func (f *FileLogger) enable(loglevel LogLevel) bool {
	return f.Level <= loglevel
}

// 判断文件大小
// func (f *FileLogger) checkSize(file *os.File) bool {
// 	fileInfo, err := file.Stat()
// 	if err != nil {
// 		fmt.Printf("get file info failed,err:%v", err)
// 		return false
// 	}
// 	//返回当前文件大小和最大值的比较结果
// 	return fileInfo.Size() >= f.maxFileSize
// }

func (f *FileLogger) checkTime(t int) bool {
	nowMinute := time.Now().Minute()
	return nowMinute != t
}

//切割文件，文件达到最大后就重新生产新的文件
func (f *FileLogger) splitFile(file *os.File) (*os.File, error) {
	//获取旧文件信息和生成新文件信息
	nowStr := time.Now().Format("20060102150405000")
	fileInfo, err := file.Stat()
	if err != nil {
		fmt.Printf("get fileInfo failed,err:%v", err)
		return nil, err
	}
	//不能用fileLogger里的文件名，没有err
	//使用file查看文件名区分普通日志和错误日志
	logName := path.Join(f.filePath, fileInfo.Name())
	newLogName := fmt.Sprintf("%s.bak%s", logName, nowStr)
	// 1.关闭当前的日志文件，才能重命名
	file.Close()
	// 2.将已满的文件重新命名,添加上时间
	os.Rename(logName, newLogName)
	// 3.打开一个新的日志文件
	fileObj, err := os.OpenFile(logName, os.O_CREATE|os.O_APPEND|os.O_WRONLY, 0644)
	if err != nil {
		fmt.Printf("open new log file failed,err:%v", err)
		return nil, err
	}
	// 4.将新打开的日志文件对象赋值给 f.fileObj
	return fileObj, nil
}

//按照文件大写切割日志，每次记录日志之前都要判断下当前写的文件的大小
// func (f *FileLogger) log(lv LogLevel, format string, a ...interface{}) {
// 	if f.enable(lv) {
// 		msg := fmt.Sprintf(format, a...)
// 		now := time.Now()
// 		funcName, fileName, lineNo := getInfo(3)
// 		//根据文件大小判断结果确认是否切割文件
// 		if f.checkSize(f.fileObj) {
// 			newFile, err := f.splitFile(f.fileObj)
// 			if err != nil {
// 				return
// 			}
// 			f.fileObj = newFile
// 		}
// 		fmt.Fprintf(f.fileObj, "[%s] [%s] [%s:%s:%d] %s\n", now.Format("2006-01-02 15:04:05"), getLogString(lv), fileName, funcName, lineNo, msg)
// 		//记录日志等级大于Error级别，需要再err日志中再记录一遍
// 		if lv >= ERROR {
// 			if f.checkSize(f.errFileObj) {
// 				newFile, err := f.splitFile(f.errFileObj)
// 				if err != nil {
// 					return
// 				}
// 				f.errFileObj = newFile
// 			}
// 			fmt.Fprintf(f.errFileObj, "[%s] [%s] [%s:%s:%d] %s\n", now.Format("2006-01-02 15:04:05"), getLogString(lv), fileName, funcName, lineNo, msg)
// 		}

// 	}
// }

//按照时间切割日志，每次记录日志之前都要当前时间
func (f *FileLogger) log(lv LogLevel, format string, a ...interface{}) {
	if f.enable(lv) {
		msg := fmt.Sprintf(format, a...)
		now := time.Now()
		funcName, fileName, lineNo := getInfo(3)
		//根据时间判断结果确认是否切割文件
		if f.checkTime(f.timeFlag) {
			newFile, err := f.splitFile(f.fileObj)
			if err != nil {
				return
			}
			f.fileObj = newFile
			f.timeFlag = time.Now().Minute()
		}
		fmt.Fprintf(f.fileObj, "[%s] [%s] [%s:%s:%d] %s\n", now.Format("2006-01-02 15:04:05"), getLogString(lv), fileName, funcName, lineNo, msg)
		//记录日志等级大于Error级别，需要再err日志中再记录一遍
		if lv >= ERROR {
			if f.checkTime(f.timeErrFlag) {
				newFile, err := f.splitFile(f.errFileObj)
				if err != nil {
					return
				}
				f.errFileObj = newFile
				f.timeErrFlag = time.Now().Minute()
			}
			fmt.Fprintf(f.errFileObj, "[%s] [%s] [%s:%s:%d] %s\n", now.Format("2006-01-02 15:04:05"), getLogString(lv), fileName, funcName, lineNo, msg)
		}
	}
}

func (f *FileLogger) Debug(format string, a ...interface{}) {
	f.log(DEBUG, format, a...)
}

func (f *FileLogger) Trace(format string, a ...interface{}) {
	f.log(TRACE, format, a...)
}
func (f *FileLogger) Info(format string, a ...interface{}) {
	f.log(INFO, format, a...)
}
func (f *FileLogger) Warning(format string, a ...interface{}) {
	f.log(WARNING, format, a...)
}
func (f *FileLogger) Error(format string, a ...interface{}) {
	f.log(ERROR, format, a...)
}
func (f *FileLogger) Fatal(format string, a ...interface{}) {
	f.log(FATAL, format, a...)
}

  • 日志库主函数

    package main

import (
	"fmt"
	"os"
)

func main() {
	fileObj, err := os.Open("./main.go")
	if err != nil {
		fmt.Printf("open file failed err:%v", err)
		return
	}
	fileInfo, err := fileObj.Stat()
	if err != nil {
		fmt.Printf("get fileInfo failed err:%v", err)
		return
	}
	fmt.Printf("文件大小是：%dB\n", fileInfo.Size())
	fmt.Printf("文件名是：%s\n", fileInfo.Name())
}
KayCh
关注
Golang Log日志库
LU_ZHAO的博客
03-24 810
参考 Package log implements a simple logging package. It defines a type, Logger, with methods for formatting output. It also has a predefined ‘standard’ Logger accessible through helper functions Print...
Go语言Web编程怎么快速学习，Go语言有哪些优势，Go Web编程有哪些优秀书籍？
shirdon-廖显东的博客
04-26 830
1.Go语言之前编程的痛点 （1）为什么会设计Go语言？ 我们先来了解一下Go的作者和主要核心开发者们：Robert Griesemer, Rob Pike 和 Ken Thompson。设计Go语言是为了解决当时Google开发遇到的以下这些问题： 大量的C++代码，同时又引入了Java和Python； 成千上万的工程师； 数以万计行的代码； 分布式的编译系统； 数百万的服务器； 其主要有以下几个...
Go-log一个简单快速的Go日志库
08-14
log 一个简单快速的Go日志库
Golang - 日志库实战
yang_kaiyue的博客
06-24 627
日志库练习
简单日志库
hao931126的博客
12-18 254
源由这个就不再说了 过程一个类，或者工程总需要那么几个错误输出之类的东西，便于调试和排查问题。 从qqbot上对日志类有了一定的想法了。 需求分析1，最重要的是，输出日志。 重要性分级？ 模块信息 msg参数化 如不仅仅是"hello" 还可以"helle %d %s %f",xxx 2， 技术要点1，不定参数与格式化输出 va_start
基于go语言的日志库开发（源码）
qq_43514659的博客
10-24 290
只有源码，详解请看 《基于go的日志库开发详解》 mylogger.go package mylogger import ( "errors" "fmt" "path" "runtime" "strings" ) // LogLever 日志等级类型 type LogLever uint16 // 日志类型 等级变量 const ( UNKNOWN LogLever = iota DEBUG TRACE INFO WARNING ERROR FATAL ) // 将字符.
Go语言快速构建Web应用实战
"创建移动Web应用——Go语言版" 在《Creating Web Applications On the Go》这本书中，作者Frank Winchester引领读者从初学者到专家的旅程，揭示了Go语言进行Web编程的乐趣与简易性。通过采用实战训练营的方式，书...
基于cdp的简易数据采集工具.zip
01-03
《基于CDP的简易数据采集工具——Go语言实现解析》 在现代信息技术中，数据采集是数据分析的基础，它能够帮助我们获取有价值的信息，为决策提供支持。本文将深入探讨一个基于CDP（Continuous Data Protection，持续...
工作日志——k8s gitRepo volume
xts_huangxin的博客
05-25 3033
gitRepo volume可以理解为是emptyDir volume的一种实际应用，使用该volume的Pod可以在挂载目录访问指定的代码仓库。这里与大家分享一下gitRepo的使用。
Go-go-monitor采用Go编写的简单服务器监控
08-14
《Go-go-monitor：Go语言构建的简易服务器监控系统解析》 在现代的互联网环境中，服务器监控扮演着至关重要的角色，它能帮助我们实时了解服务器的运行状态，及时发现并解决问题，确保服务的稳定性和高可用性。Go-go...
Go最全Go日志库——logrus(1)，Golang开发指南
2401_84905102的博客
05-16 1126
通常，在一个应用中、或者应用的一部分中，始终附带一些固定的记录字段会很有帮助。比如在处理用户HTTP请求时，上下文中所有的日志都会有request_id。为了避免每次记录日志都要使用：我们可以创建一个logrus.Entry实例，为这个实例设置默认Fields，把logrus.Entry实例设置到记录器Logger，再记录日志时每次都会附带上这些默认的字段。logger.Info(“something happened on that request”) // 也会记录request_id。
go语言学习：简单的日志
qq_18115123的博客
08-29 179
123 package main import ( "fmt" "time" "os" ) func main(){ log("I'm %s.Today is %s\n","Herman","Wednesday") log("I'm %s.Today is %s\n","Jack","Friday"
不到130行代码打造一个简易的golang日志库
u013131603的博客
10-18 558
最近去一家大公司面试，一道有趣的面试题让我卡壳了。回去后，我思来想去，最后用不到130行代码，打造出了一个简易的golang日志库，完成了那个“缺憾”的梦。
go开发属于自己的日志库-日志库优化
weixin_34293059的博客
11-09 200
日志库基本上写完了，但是就完成了，还没有。目前来说，我们的文件写日志的方式采用同步方式，如果在大量日志写入的时候，同步写入的缺陷就暴露出来了。而且日志跟我们的业务逻辑也没有什么太大的关系，哪怕掉了几条也没什么影响，所以这里可以将同步写改为异步写。 这里采用go的channel进行异步写日志。 在业务调用写日志时，将日志数据写入channel中 起一个后台线程不断的从channel中取日志，然...
Go语言基础实战：日志库
wwxy1995的博客
07-09 183
重点: 如何异步写日志。 将日志数据放到管道里，开一个线程不断的从管道取数据写入到文件中。 日志的分片处理 定时将日志文件分开。
Go语言标准库之log和三方库zap
最新发布
Ricardo2的博客
07-05 1292
Go语言内置的log包实现了简单的日志服务。本包也提供了一个预定义的“标准”logger，可以通过调用函数Print系列、Fatal系列、和Panic系列来使用，比自行创建一个logger对象更容易使用。Fatal系列用于输出一条致命错误信息，并调用 os.Exit(1) 终止程序运行。这个函数会在打印完错误信息之后立即调用 os.Exit 退出程序。
一文搞懂 Go 1.21 的日志标准库 - slog
rubys007的博客
02-03 1495
定制默认Logger最直接的方法是利用方法，允许您用自定义的日志记录器替换默认的日志记录器。使用方法还会改变log包使用的默认log.Logger。这种行为允许利用旧log当您需要使用需要后者（例如）的 API 时，也可以使用方法将转换为log.Loggerlog/slogDEBUG(-4)INFO(0)WARN(4)和ERROR(8)。每个级别之间的间隔为 4，这是一个经过深思熟虑的设计决定，以适应具有自定义级别的日志方案。例如，您可以在INFO和WARN之间创建一个自定义级别，其值为1、2或3。
Golang基础之接口习题——李文周老师
qq_41580831的博客
01-30 996
面试题 注意：这是一道你需要回答**“能”或者“不能”**的题！ 首先请观察下面的这段代码，然后请回答这段代码能不能通过编译？ type People interface { Speak(string) string } type Student struct{} func (stu *Student) Speak(think string) (talk string) { if thin...
Go 语言 の 日志（读写文件和时间）
rush_peng的博客
04-11 478
文章目录go 对文件的操作对整个文件进行操作写数据操作 go 对文件的操作 对文件进行操作的时候，，如果是一行一行的读，建议使用 bufio 来实现。 如果只是读，可以只使用 Open 这个方法，如果要是写就不行了。 如果要写，使用 openfile 做个函数，使用指定的模式打开该文件。 package main import ( "bufio" "fmt" "io" "os" ) func main() { fileObej, err := os.Open("./test.go"
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值