debugger

package
v0.13.2 Latest Latest
Warning

This package is not in the latest version of its module.

Go to latest
Published: Nov 1, 2025 License: MIT Imports: 20 Imported by: 4

README

调试器组件 (Debugger Component)

概述

调试器组件是一个专为Gin框架设计的HTTP请求调试工具,用于解决Gin框架默认日志输出过多、并发请求下日志混杂的问题。该组件支持多种存储方式(文件、内存、数据库),提供完整的请求和响应信息记录、查询、搜索和详情查看功能。

功能特性

核心功能
  • ✅ 请求拦截: 自动拦截HTTP请求并记录完整的调试信息
  • ✅ 多存储支持: 支持文件、内存、数据库三种存储方式
  • ✅ 日志查询: 支持按时间、请求路径、状态码等条件过滤
  • ✅ 全文搜索: 支持关键词搜索请求头、响应头、请求体等内容
  • ✅ 详情查看: 显示完整的请求和响应信息,支持HTML和JSON格式
  • ✅ 统计信息: 提供请求统计、错误率、响应时间等分析数据
记录内容
  • 请求方法、URL、查询参数
  • 请求头和响应头
  • 请求体和响应体(支持JSON格式化)
  • 会话数据和错误信息
  • 客户端IP、User Agent、请求ID
  • 请求处理时间和状态码

快速开始

安装

确保项目已安装Gin框架:

go get -u github.com/gin-gonic/gin
基本使用
便捷构造函数(推荐)

我们提供了多种便捷构造函数,使用更加简单直观:

package main

import (
	"github.com/gin-gonic/gin"
	"github.com/jcbowen/jcbaseGo/component/debugger"
)

func main() {
	// 方式1:使用简单调试器(默认配置)
	dbg, err := debugger.NewSimpleDebugger()
	if err != nil {
		panic(err)
	}

	// 方式2:使用内存存储器(开发环境)
	dbg, err := debugger.NewWithMemoryStorage(1000)
	if err != nil {
		panic(err)
	}

	// 方式3:使用文件存储器(生产环境)
	dbg, err := debugger.NewWithFileStorage("/var/log/debug_logs", 5000)
	if err != nil {
		panic(err)
	}

	// 方式4:使用自定义存储器
	customStorage, _ := debugger.NewMemoryStorage(150)
	dbg, err := debugger.NewWithCustomStorage(customStorage)
	if err != nil {
		panic(err)
	}

	// 方式5:生产环境调试器
	dbg, err := debugger.NewProductionDebugger("/var/log/debug_logs")
	if err != nil {
		panic(err)
	}

	// 创建Gin路由
	router := gin.New()
	
	// 使用调试器中间件
	router.Use(dbg.Middleware())
	
	// 添加业务路由
	router.GET("/api/users", func(c *gin.Context) {
		c.JSON(200, gin.H{"message": "Hello World"})
	})
	
	router.Run(":8080")
}
详细使用指南
配置选项

调试器支持丰富的配置选项,推荐使用便捷构造函数:

便捷构造函数方式(推荐)
// 方式1:使用简单调试器(默认配置)
dbg, err := debugger.NewSimpleDebugger()

// 方式2:使用内存存储器(开发环境)
dbg, err := debugger.NewWithMemoryStorage(1000)

// 方式3:使用文件存储器(生产环境)
dbg, err := debugger.NewWithFileStorage("/var/log/debug_logs", 5000)

// 方式4:使用自定义存储器
customStorage, _ := debugger.NewMemoryStorage(150)
dbg, err := debugger.NewWithCustomStorage(customStorage)

// 方式5:生产环境配置
dbg, err := debugger.NewProductionDebugger("/var/log/debug_logs", 1000)

if err != nil {
	panic(err)
}

router.Use(dbg.Middleware())
手动配置方式(高级使用)
// 创建存储器实例
memoryStorage, _ := debugger.NewMemoryStorage(150)

// 创建调试器配置
config := &debugger.Config{
	Enabled:         true,                    // 是否启用调试器
	Storage:         memoryStorage,           // 必须传入实例化的存储器
	MaxBodySize:     1024,                    // 最大请求/响应体大小(KB),默认1MB
	RetentionPeriod: 7 * 24 * time.Hour,      // 日志保留期限,默认7天
	Level:           debugger.LevelDebug,     // 日志级别:LevelDebug/LevelInfo/LevelWarn/LevelError
	MaxRecords:      150,                     // 最大记录数量,默认150

	// 过滤配置
	SkipPaths:   []string{"/static", "/health"}, // 跳过的路径
	SkipMethods: []string{"OPTIONS"},              // 跳过的HTTP方法

	// 采样配置
	SampleRate: 1.0,                            // 采样率(0-1之间),默认1.0(记录所有请求)

	// 日志记录器配置(可选)
	Logger:  nil,                              // 日志记录器实例
}

// 使用自定义配置
dbg, err := debugger.New(config)
if err != nil {
	panic(err)
}

router.Use(dbg.Middleware())
日志级别说明
  • LevelDebug: 记录所有详细信息,包括请求体、响应体等(开发环境)
  • LevelInfo: 记录基本信息,包括请求头、响应头等(生产环境)
  • LevelWarn: 只记录警告级别的信息
  • LevelError: 只记录错误级别的信息

Logger功能使用

在控制器中使用Logger

debugger组件提供了Logger接口,可以在业务控制器中记录调试日志。通过GetLoggerFromContext函数可以从Gin上下文中获取Logger实例。

基本使用示例
package main

import (
	"net/http"
	"time"

	"github.com/gin-gonic/gin"
	"github.com/jcbowen/jcbaseGo/component/debugger"
)

func main() {
	r := gin.Default()

	// 创建调试器实例
	dbg, err := debugger.NewWithMemoryStorage(100)
	if err != nil {
		panic(err)
	}

	// 添加调试器中间件
	r.Use(dbg.Middleware())

	// 在控制器中使用Logger
	r.GET("/api/users", func(c *gin.Context) {
		// 从上下文中获取Logger实例
		logger := debugger.GetLoggerFromContext(c)

		// 记录不同级别的日志
		logger.Debug("开始处理用户列表请求", map[string]interface{}{
			"query_params": c.Request.URL.Query(),
			"page":         c.Query("page"),
			"limit":        c.Query("limit"),
		})

		// 模拟数据库查询
		time.Sleep(50 * time.Millisecond)

		logger.Info("用户列表查询成功", map[string]interface{}{
			"user_count": 3,
			"status_code": http.StatusOK,
		})

		c.JSON(http.StatusOK, gin.H{
			"users": []gin.H{
				{"id": 1, "name": "张三"},
				{"id": 2, "name": "李四"},
				{"id": 3, "name": "王五"},
			},
		})
	})

	r.Run(":8080")
}
Logger接口方法

Logger接口支持以下方法:

type Logger interface {
	// Debug 记录调试级别日志
	Debug(msg string, fields ...map[string]interface{})

	// Info 记录信息级别日志
	Info(msg string, fields ...map[string]interface{})

	// Warn 记录警告级别日志
	Warn(msg string, fields ...map[string]interface{})

	// Error 记录错误级别日志
	Error(msg string, fields ...map[string]interface{})

	// WithFields 创建带有字段的日志记录器
	WithFields(fields map[string]interface{}) Logger
}
使用WithFields添加结构化字段
// 在控制器中使用WithFields
r.GET("/api/users/:id", func(c *gin.Context) {
	userID := c.Param("id")

	// 使用WithFields创建带有用户ID的logger
	logger := debugger.GetLoggerFromContext(c).WithFields(map[string]interface{}{
		"user_id": userID,
		"endpoint": "/api/users/:id",
	})

	logger.Info("开始查询用户详情")

	// 模拟用户不存在的情况
	if userID == "999" {
		logger.Warn("用户不存在", map[string]interface{}{
			"reason": "数据库中未找到该用户",
		})
		c.JSON(http.StatusNotFound, gin.H{"error": "用户不存在"})
		return
	}

	logger.Info("用户详情查询成功")
	c.JSON(http.StatusOK, gin.H{"id": userID, "name": "示例用户"})
})
错误处理示例
r.GET("/api/error", func(c *gin.Context) {
	logger := debugger.GetLoggerFromContext(c)

	logger.Info("开始处理错误示例请求")

	// 模拟业务逻辑错误
	err := fmt.Errorf("数据库连接失败: 连接超时")

	logger.Error("业务处理失败", map[string]interface{}{
		"error":         err.Error(),
		"error_type":    "database_connection_timeout",
		"retry_count":   3,
		"last_attempt":  time.Now().Format(time.RFC3339),
	})

	c.JSON(http.StatusInternalServerError, gin.H{
		"error": "服务器内部错误",
		"details": "请稍后重试",
	})
})
查看完整示例

更多详细的使用示例,请查看:

  • example/debugger/logger_usage.go - 完整的Logger使用示例
  • example/debugger/basic_usage.go - 基础使用示例

高级功能

采样率配置

采样率可以控制记录日志的频率,避免在高并发场景下产生过多日志:

memoryStorage, _ := debugger.NewMemoryStorage(10000)
config := &debugger.Config{
    Enabled:    true,
    Storage:    memoryStorage,
    MaxRecords: 10000,
    Level:      debugger.LevelInfo,
    
    // 采样率配置:每10个请求记录1个(10%采样率)
    SampleRate: 0.1,
}

dbg, err := debugger.New(config)
if err != nil {
    panic(err)
}
过滤配置

可以配置请求过滤规则,避免记录某些不需要的请求:

memoryStorage, _ := debugger.NewMemoryStorage(10000)
config := &debugger.Config{
    Enabled:    true,
    Storage:    memoryStorage,
    MaxRecords: 10000,
    Level:      debugger.LevelInfo,
    
    // 过滤配置
    SkipPaths: []string{
        "/static/*",
        "/favicon.ico",
        "/robots.txt",
    },
    
    // 忽略特定HTTP方法
    SkipMethods: []string{"OPTIONS"},
    
    // 最大请求体大小(字节)
    MaxBodySize:     1024,        // 1MB(单位:KB)
}

dbg, err := debugger.New(config)
if err != nil {
    panic(err)
}
自定义存储

您可以实现自己的存储后端:

type CustomStorage struct {
    // 实现 Storage 接口
}

func (s *CustomStorage) Save(entry *LogEntry) error {
    // 自定义保存逻辑
}

func (s *CustomStorage) FindByID(id string) (*LogEntry, error) {
    // 自定义查询逻辑
}

// 实现其他接口方法...
查询和搜索功能
基本查询
// 通过调试器实例获取存储
storage := dbg.GetStorage()

// 查询最近的日志
logs, total, err := storage.FindAll(1, 10, nil)

// 按时间范围查询
startTime := time.Now().AddDate(0, 0, -7) // 一周前
endTime := time.Now()
filters := map[string]interface{}{
    "start_time": startTime,
    "end_time":   endTime,
}
result, total, err := storage.FindAll(1, 20, filters)

// 按方法查询
filters = map[string]interface{}{
    "method": "POST",
}
result, total, err := storage.FindAll(1, 10, filters)

// 按状态码查询
filters = map[string]interface{}{
    "status_code": 404,
}
result, total, err := storage.FindAll(1, 10, filters)

// 查询错误日志
filters = map[string]interface{}{
    "has_error": true,
}
result, total, err := storage.FindAll(1, 10, filters)
高级查询
// 使用查询选项
options := debugger.QueryOptions{
	Page:     1,
	PageSize: 20,
	Filters: map[string]interface{}{
		"method":      "POST",
		"status_code": 200,
		"url_contains": "/api",
		"has_error":   false,
	},
	SortBy:    "timestamp",
	SortOrder: "desc",
}

result, err := queryManager.Query(options)
全文搜索
// 搜索包含关键词的日志
result, total, err := storage.Search("用户", 1, 10)
Logger日志显示功能

debugger组件现在支持在详情页面中显示业务控制器中记录的logger日志。当您在控制器中使用GetLoggerFromContext记录日志时,这些日志会自动收集并在日志详情页面中显示。

功能特性
  • ✅ 自动收集: 在请求处理过程中自动收集logger日志
  • ✅ 级别区分: 支持Debug、Info、Warn、Error四种日志级别
  • ✅ 结构化字段: 显示日志的附加字段信息
  • ✅ 时间戳: 记录每条日志的精确时间戳
  • ✅ 响应式布局: 适配不同屏幕尺寸的显示
在详情页中查看Logger日志
  1. 访问调试器列表页面:http://localhost:8080/jcbase/debug/list
  2. 点击任意日志条目的"详情"按钮
  3. 在详情页面中查看"Logger日志"区域
示例效果

当您在控制器中记录如下日志:

logger := debugger.GetLoggerFromContext(c)
logger.Debug("开始处理请求", map[string]interface{}{
    "user_id": 123,
    "action": "create_user",
})
logger.Info("用户创建成功")
logger.Warn("密码强度较弱")
logger.Error("数据库连接失败", map[string]interface{}{
    "error": "connection timeout",
    "retry_count": 3,
})

在详情页面中,您将看到格式化的logger日志显示:

  • DEBUG 开始处理请求 (user_id: 123, action: create_user)
  • INFO 用户创建成功
  • WARN 密码强度较弱
  • ERROR 数据库连接失败 (error: connection timeout, retry_count: 3)
详情查看功能
// 创建详情查看器
detailViewer := debugger.NewDetailViewer(queryManager)

// 获取日志详情
detail, err := detailViewer.GetDetail("log_id")

// 获取HTML格式的详情
html, err := detailViewer.GetDetailHTML("log_id")

// 获取JSON格式的详情
jsonData, err := detailViewer.GetDetailJSON("log_id")

// 比较两个日志条目
comparison, err := detailViewer.CompareEntries("id1", "id2")
统计信息
// 获取统计信息
stats, err := queryManager.GetStats()

// 统计信息包含:
// - 存储统计(总数、错误率等)
// - 方法统计(各HTTP方法的请求数量)
// - 状态码统计(各状态码的分布)
// - 时间统计(今天、本周、本月的请求数量)
数据导出
// 导出为JSON格式
jsonData, err := queryManager.Export("json", options)

// 导出为CSV格式
csvData, err := queryManager.Export("csv", options)

Gin控制器使用指南

调试器组件提供了完整的Gin控制器,可以快速集成到现有的Gin应用中,提供Web管理界面。

基本使用
1. 使用默认路由配置
package main

import (
	"github.com/gin-gonic/gin"
	"github.com/jcbowen/jcbaseGo/component/debugger"
)

func main() {
	// 创建Gin引擎
	router := gin.Default()
	
	// 创建调试器实例(推荐使用便捷构造函数)
	dbg, err := debugger.NewWithMemoryStorage(1000)
	if err != nil {
		panic(err)
	}
	
	// 注册调试器路由(使用默认路径:/jcbase/debug)
	dbg.RegisterRoutes(router)
	
	// 添加业务路由
	router.GET("/api/users", func(c *gin.Context) {
		c.JSON(200, gin.H{"message": "Hello World"})
	})
	
	router.Run(":8080")
}
2. 使用自定义路由组
package main

import (
	"github.com/gin-gonic/gin"
	"github.com/jcbowen/jcbaseGo/component/debugger"
)

func main() {
	router := gin.Default()
	
	// 创建调试器实例
	dbg, err := debugger.NewWithMemoryStorage(1000)
	if err != nil {
		panic(err)
	}
	
	// 创建自定义路由组
	adminGroup := router.Group("/admin")
	adminGroup.Use(authMiddleware()) // 添加认证中间件
	
	// 注册调试器路由到自定义路由组
	dbg.RegisterRoutes(adminGroup)
	
	router.Run(":8080")
}
3. 高级配置
package main

import (
	"github.com/gin-gonic/gin"
	"github.com/jcbowen/jcbaseGo/component/debugger"
)

func main() {
	router := gin.Default()
	
	// 创建调试器实例
	dbg, err := debugger.NewWithMemoryStorage(1000)
	if err != nil {
		panic(err)
	}
	
	// 创建自定义控制器配置
	controllerConfig := &debugger.ControllerConfig{
		BasePath: "/custom/debug", // 自定义基础路径
		Title:    "调试管理界面",     // 自定义页面标题
		PageSize: 50,               // 自定义每页显示数量
	}
	
	// 创建自定义路由组
	adminGroup := router.Group("/admin")
	
	// 创建控制器实例
	controller := debugger.NewController(dbg, adminGroup, controllerConfig)
	
	// 控制器会自动注册路由到指定的路由组
	
	router.Run(":8080")
}
控制器功能

Gin控制器提供以下功能:

1. 日志列表页面
  • 路径:GET /jcbase/debug/
  • 功能:显示所有调试日志的列表,支持分页和搜索
2. 日志详情页面
  • 路径:GET /jcbase/debug/detail/:id
  • 功能:显示单个日志的详细信息,包括请求头、响应头、请求体等
3. 搜索功能
  • 路径:GET /jcbase/debug/list?q=关键词
  • 功能:在日志列表页面顶部提供搜索框,支持关键词搜索请求头、响应头、请求体等内容,搜索结果直接在列表页显示
4. API接口

控制器还提供对应的API接口,方便前端集成:

  • GET /jcbase/debug/api/logs - 获取日志列表(JSON格式)
  • GET /jcbase/debug/api/logs/:id - 获取日志详情(JSON格式)
  • GET /jcbase/debug/api/search - 搜索日志(JSON格式)
示例代码

项目提供了完整的示例代码,位于 example/debugger/ 目录下:

  • basic_usage.go - 基础使用示例,包含GIN框架集成和基本路由
  • file_storage.go - 文件存储使用示例,支持日志文件管理
  • controller_usage.go - 控制器使用示例,提供调试器Web界面
  • config_examples.go - 配置示例,包含6种不同的配置方式

运行示例代码:

cd example/debugger/
go run basic_usage.go

Web管理界面

调试器组件可以轻松集成到Web管理界面中:

日志列表接口
router.GET("/admin/debug/logs", func(c *gin.Context) {
	page := getIntParam(c, "page", 1)
	pageSize := getIntParam(c, "page_size", 20)
	
	options := debugger.QueryOptions{
		Page:     page,
		PageSize: pageSize,
		Filters:  buildFilters(c),
		SortBy:   c.DefaultQuery("sort_by", "timestamp"),
		SortOrder: c.DefaultQuery("sort_order", "desc"),
	}
	
	result, err := queryManager.Query(options)
	if err != nil {
		c.JSON(500, gin.H{"error": err.Error()})
		return
	}
	
	c.JSON(200, result)
})
日志详情接口
router.GET("/admin/debug/logs/:id", func(c *gin.Context) {
	id := c.Param("id")
	
	detail, err := detailViewer.GetDetail(id)
	if err != nil {
		c.JSON(404, gin.H{"error": "日志不存在"})
		return
	}
	
	c.JSON(200, detail)
})
统计信息接口
router.GET("/admin/debug/stats", func(c *gin.Context) {
	stats, err := queryManager.GetStats()
	if err != nil {
		c.JSON(500, gin.H{"error": err.Error()})
		return
	}
	
	c.JSON(200, stats)
})

存储方式比较

存储方式 创建方式 优点 缺点 适用场景
内存存储器 NewMemoryStorage(maxSize) 速度快,零配置 数据易丢失,重启后清空 开发环境,临时调试
文件存储器 NewFileStorage(path, maxSize) 数据持久化,易于备份 文件IO可能成为瓶颈 生产环境,中小规模应用
数据库存储器 NewDatabaseStorage(db, tableName) 查询性能好,支持复杂查询 需要数据库依赖 生产环境,大规模应用
存储创建示例
// 内存存储器(默认10000条记录)
memoryStorage, err := debugger.NewMemoryStorage()

// 内存存储器(自定义最大记录数)
memoryStorage, err := debugger.NewMemoryStorage(5000)

// 文件存储器(默认路径,默认10000条记录)
fileStorage, err := debugger.NewFileStorage("/var/log/debug_logs")

// 文件存储器(自定义最大记录数)
fileStorage, err := debugger.NewFileStorage("/var/log/debug_logs", 20000)

// 数据库存储器(需要GORM连接)
databaseStorage, err := debugger.NewDatabaseStorage(db, "debug_logs")

// 推荐使用便捷构造函数直接创建调试器
dbg, err := debugger.NewWithMemoryStorage(1000)  // 内存存储
dbg, err := debugger.NewWithFileStorage("/var/log/debug_logs", 5000)  // 文件存储
dbg, err := debugger.NewProductionDebugger("/var/log/debug_logs", 1000)  // 生产环境配置

性能优化建议

生产环境配置
  1. 使用LevelInfo级别: 避免记录请求体和响应体,减少存储空间
  2. 定期清理旧日志: 设置自动清理策略
  3. 使用数据库索引: 对常用查询字段创建索引
  4. 限制日志大小: 设置单个日志文件的最大大小
清理策略示例
// 定期清理7天前的日志
func cleanupOldLogs() {
	ticker := time.NewTicker(24 * time.Hour) // 每天执行一次
	defer ticker.Stop()
	
	for range ticker.C {
		sevenDaysAgo := time.Now().AddDate(0, 0, -7)
		err := queryManager.Cleanup(sevenDaysAgo)
		if err != nil {
			log.Printf("清理旧日志失败: %v", err)
		} else {
			log.Println("旧日志清理完成")
		}
	}
}

安全考虑

敏感数据处理
  1. 避免记录敏感信息: 在生产环境中使用LevelInfo级别
  2. 加密存储: 对敏感日志内容进行加密
  3. 访问控制: 对调试接口进行身份验证
生产环境安全配置
// 生产环境配置
config := debugger.Config{
	Enabled: true,
	Level:   debugger.LevelInfo, // 不记录请求体和响应体
}

// 保护调试接口
admin := router.Group("/admin")
admin.Use(authMiddleware()) // 添加认证中间件
admin.GET("/debug/logs", debugLogsHandler)

故障排除

常见问题
  1. 内存使用过高

    • 使用文件或数据库存储器替代内存存储器
    • 设置日志数量上限
    • 定期清理旧日志
  2. 存储性能问题

    • 对数据库字段添加索引
    • 使用更快的存储介质(SSD)
    • 考虑日志分片存储
  3. 日志丢失

    • 检查存储路径权限
    • 验证数据库连接
    • 添加错误重试机制

API参考

主要结构体
LogEntry
type LogEntry struct {
	ID              string            `json:"id"`          // 日志唯一标识
	Timestamp       time.Time         `json:"timestamp"`   // 请求时间戳
	Method          string            `json:"method"`      // HTTP方法
	URL             string            `json:"url"`         // 请求URL
	StatusCode      int               `json:"status_code"` // HTTP状态码
	Duration        time.Duration     `json:"duration"`    // 处理耗时
	ClientIP        string            `json:"client_ip"`   // 客户端IP
	UserAgent       string            `json:"user_agent"`  // 用户代理
	RequestID       string            `json:"request_id"`  // 请求ID(用于追踪)

	// 请求信息
	RequestHeaders map[string]string `json:"request_headers"` // 请求头
	QueryParams    map[string]string `json:"query_params"`    // 查询参数
	RequestBody    string            `json:"request_body"`    // 请求体内容

	// 响应信息
	ResponseHeaders map[string]string `json:"response_headers"` // 响应头
	ResponseBody    string            `json:"response_body"`    // 响应体内容

	// 会话数据(可选)
	SessionData map[string]interface{} `json:"session_data,omitempty"` // 会话数据

	// 错误信息
	Error string `json:"error,omitempty"` // 错误信息
}
Config
type Config struct {
	Enabled         bool          // 是否启用调试器
	Storage         Storage       // 存储器实例
	MaxBodySize     int64         // 最大请求/响应体大小(KB)
	RetentionPeriod time.Duration // 日志保留期限
	Level           LogLevel      // 日志级别
	MaxRecords      int           // 最大记录数量
	SkipPaths       []string      // 跳过的路径
	SkipMethods     []string      // 跳过的HTTP方法
	SampleRate      float64       // 采样率(0-1之间)
	Logger          Logger        // 日志记录器实例
}
主要接口
Storage接口
type Storage interface {
	Save(entry *LogEntry) error
	FindByID(id string) (*LogEntry, error)
	FindAll(page, pageSize int, filters map[string]interface{}) ([]*LogEntry, int, error)
	Search(keyword string, page, pageSize int) ([]*LogEntry, int, error)
	Cleanup(before time.Time) error
	GetStats() (map[string]interface{}, error)
	GetMethods() (map[string]int, error)
	GetStatusCodes() (map[int]int, error)
	Close() error
}
Logger接口
type Logger interface {
	Debug(args ...interface{})
	Debugf(format string, args ...interface{})
	Info(args ...interface{})
	Infof(format string, args ...interface{})
	Warn(args ...interface{})
	Warnf(format string, args ...interface{})
	Error(args ...interface{})
	Errorf(format string, args ...interface{})
}
便捷构造函数
// 便捷构造函数
func NewSimpleDebugger() (*Debugger, error)
func NewWithMemoryStorage(maxRecords int) (*Debugger, error)
func NewWithFileStorage(path string, maxRecords int) (*Debugger, error)
func NewWithCustomStorage(storage Storage) (*Debugger, error)
func NewProductionDebugger(path string, maxRecords int) (*Debugger, error)

// 存储器构造函数
func NewMemoryStorage(maxRecords int) (Storage, error)
func NewFileStorage(path string, maxRecords int) (Storage, error)
func NewDatabaseStorage(db *gorm.DB, tableName string) (Storage, error)

版本历史

  • v1.0.0: 初始版本,支持基本调试功能
  • 后续版本计划:支持更多存储后端、实时日志流、性能监控等

贡献指南

欢迎提交Issue和Pull Request来改进这个组件。

许可证

MIT License

Documentation

Index

Constants

View Source
const (
	LevelDebug = "debug" // 调试级别:记录所有详细信息
	LevelInfo  = "info"  // 信息级别:只记录基本信息
	LevelWarn  = "warn"  // 警告级别:记录警告信息
	LevelError = "error" // 错误级别:记录错误信息
)

日志级别常量

Variables

This section is empty.

Functions

func DetailedDebugLogger

func DetailedDebugLogger(storage Storage) gin.HandlerFunc

DetailedDebugLogger 详细的调试日志中间件 记录完整的请求和响应信息,适用于开发环境

func DisableMiddleware

func DisableMiddleware() gin.HandlerFunc

DisableMiddleware 禁用中间件的快捷方法 创建一个空中间件,不进行任何调试记录

func EnableMiddleware

func EnableMiddleware(storage Storage, config ...Config) gin.HandlerFunc

EnableMiddleware 启用中间件的快捷方法 创建一个已启用调试功能的中间件

func GenerateID

func GenerateID() string

GenerateID 生成唯一请求标识 使用纳秒时间戳和进程ID确保唯一性,经过SM4加密后输出,密文结果不包含=字符

func MiddlewareWithConfig

func MiddlewareWithConfig(storage Storage, config Config) gin.HandlerFunc

MiddlewareWithConfig 使用配置创建中间件 提供更灵活的配置选项

func RequestLogger

func RequestLogger(storage Storage) gin.HandlerFunc

RequestLogger 简化的请求日志中间件 只记录基本的请求信息,适用于生产环境

Types

type Config

type Config struct {
	Enabled         bool          `json:"enabled" default:"false"`         // 是否启用调试器
	MaxBodySize     int64         `json:"max_body_size" default:"1024"`    // 最大请求/响应体大小(KB),默认1MB
	RetentionPeriod time.Duration `json:"retention_period" default:"168h"` // 日志保留期限,默认7天
	Level           string        `json:"level" default:"debug"`           // 日志级别:debug/info
	MaxRecords      int           `json:"max_records" default:"150"`       // 最大记录数量,默认150条

	// 过滤配置
	SkipPaths   []string `json:"skip_paths" default:""`          // 跳过的路径(如静态文件:"/static/,/favicon.ico")
	SkipMethods []string `json:"skip_methods" default:"OPTIONS"` // 跳过的HTTP方法

	// 采样配置
	SampleRate float64 `json:"sample_rate" default:"1.0"` // 采样率(0-1之间),默认记录所有请求

	// 核心组件配置 - 必须传入实例化的存储器
	Storage Storage         `json:"-"` // 存储实现(必须传入实例化的存储器)
	Logger  LoggerInterface `json:"-"` // 日志记录器(推荐直接传入实例化的日志记录器)
}

Config 调试器配置结构

func DefaultConfig

func DefaultConfig() *Config

DefaultConfig 返回默认配置 使用helper.CheckAndSetDefault方法设置默认值,符合jcbaseGo规范

type Controller

type Controller struct {
	// contains filtered or unexported fields
}

Controller 调试器控制器结构

func NewController

func NewController(debugger *Debugger, router *gin.Engine, config *ControllerConfig) *Controller

NewController 创建新的调试器控制器

func (*Controller) GetBasePath

func (c *Controller) GetBasePath() string

GetBasePath 获取基础路径

func (*Controller) GetDebugger

func (c *Controller) GetDebugger() *Debugger

GetDebugger 获取调试器实例

func (*Controller) RegisterRoutes

func (c *Controller) RegisterRoutes(router *gin.Engine)

RegisterRoutes 手动注册路由到指定的Gin引擎 用于在初始化时没有传入路由组的情况

func (*Controller) SetBasePath

func (c *Controller) SetBasePath(path string)

SetBasePath 设置基础路径

type ControllerConfig

type ControllerConfig struct {
	BasePath string `json:"base_path" default:"/jcbase/debug"` // 基础路径,默认为 "/jcbase/debug"
	Title    string `json:"title" default:"调试器"`               // 页面标题,默认为 "调试器"
	PageSize int    `json:"page_size" default:"20"`            // 页面大小,默认为 20
}

ControllerConfig 控制器配置

type DatabaseStorage

type DatabaseStorage struct {
	// contains filtered or unexported fields
}

DatabaseStorage 数据库存储器实现 使用GORM将调试日志保存到数据库中

func NewDatabaseStorage

func NewDatabaseStorage(db *gorm.DB, maxSize int, tableName ...string) (*DatabaseStorage, error)

NewDatabaseStorage 创建新的数据库存储器 db: GORM数据库连接 maxSize: 最大存储条目数(0表示无限制) tableName: 数据表名(可选,默认为"debug_logs")

func (*DatabaseStorage) Cleanup

func (ds *DatabaseStorage) Cleanup(before time.Time) error

Cleanup 清理过期日志

func (*DatabaseStorage) Close

func (ds *DatabaseStorage) Close() error

Close 关闭数据库存储器

func (*DatabaseStorage) CreateIndexes

func (ds *DatabaseStorage) CreateIndexes() error

CreateIndexes 创建索引(优化查询性能)

func (*DatabaseStorage) FindAll

func (ds *DatabaseStorage) FindAll(page, pageSize int, filters map[string]interface{}) ([]*LogEntry, int, error)

FindAll 查找所有日志条目,支持分页和过滤

func (*DatabaseStorage) FindByID

func (ds *DatabaseStorage) FindByID(id string) (*LogEntry, error)

FindByID 根据ID查找日志条目

func (*DatabaseStorage) GetMethods

func (ds *DatabaseStorage) GetMethods() (map[string]int, error)

GetMethods 获取所有HTTP方法统计

func (*DatabaseStorage) GetStats

func (ds *DatabaseStorage) GetStats() (map[string]interface{}, error)

GetStats 获取存储统计信息

func (*DatabaseStorage) GetStatusCodes

func (ds *DatabaseStorage) GetStatusCodes() (map[int]int, error)

GetStatusCodes 获取所有状态码统计

func (*DatabaseStorage) Save

func (ds *DatabaseStorage) Save(entry *LogEntry) error

Save 保存日志条目到数据库

func (*DatabaseStorage) Search

func (ds *DatabaseStorage) Search(keyword string, page, pageSize int) ([]*LogEntry, int, error)

Search 搜索日志内容

type Debugger

type Debugger struct {
	// contains filtered or unexported fields
}

Debugger 调试器主结构

func New

func New(config *Config) (*Debugger, error)

New 创建新的调试器实例 config: 调试器配置,如果没有传入存储实例,将使用默认的内存存储

func NewProductionDebugger

func NewProductionDebugger(storagePath string) (*Debugger, error)

NewProductionDebugger 创建生产环境调试器实例 使用文件存储,适合生产环境

func NewSimpleDebugger

func NewSimpleDebugger() (*Debugger, error)

NewSimpleDebugger 创建简单的调试器实例 使用默认配置,适合快速开始

func NewWithCustomStorage

func NewWithCustomStorage(customStorage Storage) (*Debugger, error)

NewWithCustomStorage 创建使用自定义存储器的调试器 适用于需要自定义存储逻辑的场景

func NewWithFileStorage

func NewWithFileStorage(storagePath string, maxRecords int) (*Debugger, error)

NewWithFileStorage 创建使用文件存储器的调试器 适用于生产环境,日志会持久化到文件系统

func NewWithMemoryStorage

func NewWithMemoryStorage(maxRecords int) (*Debugger, error)

NewWithMemoryStorage 创建使用内存存储器的调试器 适用于开发和测试环境

func (*Debugger) GetConfig

func (d *Debugger) GetConfig() *Config

GetConfig 获取配置信息

func (*Debugger) GetController

func (d *Debugger) GetController() *Controller

GetController 获取控制器实例

func (*Debugger) GetLogger

func (d *Debugger) GetLogger() LoggerInterface

GetLogger 获取调试器的日志记录器 可以在控制器中通过此方法获取Logger实例来记录日志

func (*Debugger) GetLoggerWithFields

func (d *Debugger) GetLoggerWithFields(fields map[string]interface{}) LoggerInterface

GetLoggerWithFields 获取带有指定字段的日志记录器

func (*Debugger) GetStorage

func (d *Debugger) GetStorage() Storage

GetStorage 获取存储实例(用于外部访问)

func (*Debugger) Middleware

func (d *Debugger) Middleware() gin.HandlerFunc

Middleware 创建Gin中间件 用于拦截HTTP请求并记录调试信息

func (*Debugger) RegisterRoutes

func (d *Debugger) RegisterRoutes(router *gin.Engine)

RegisterRoutes 手动注册路由到指定的Gin引擎 只支持 *gin.Engine 类型,使用更简洁

func (*Debugger) SetSessionData

func (d *Debugger) SetSessionData(c *gin.Context, data map[string]interface{})

SetSessionData 设置会话数据(供外部调用)

func (*Debugger) WithController

func (d *Debugger) WithController(router *gin.Engine, config *ControllerConfig) *Debugger

WithController 为调试器添加控制器支持 router: Gin引擎,用于注册调试器页面路由 config: 控制器配置(可选)

type DefaultLogger

type DefaultLogger struct {
	// contains filtered or unexported fields
}

DefaultLogger 调试器内置的日志记录器实现(默认实现)

func (*DefaultLogger) ClearLogs

func (l *DefaultLogger) ClearLogs()

ClearLogs 清空收集的日志信息

func (*DefaultLogger) Debug

func (l *DefaultLogger) Debug(msg any, fields ...map[string]interface{})

Debug 记录调试级别日志

func (*DefaultLogger) Error

func (l *DefaultLogger) Error(msg any, fields ...map[string]interface{})

Error 记录错误级别日志

func (*DefaultLogger) GetLevel added in v0.13.2

func (l *DefaultLogger) GetLevel() string

GetLevel 获取当前日志记录器的日志级别

func (*DefaultLogger) GetLogs

func (l *DefaultLogger) GetLogs() []LoggerLog

GetLogs 获取收集的日志信息

func (*DefaultLogger) Info

func (l *DefaultLogger) Info(msg any, fields ...map[string]interface{})

Info 记录信息级别日志

func (*DefaultLogger) Warn

func (l *DefaultLogger) Warn(msg any, fields ...map[string]interface{})

Warn 记录警告级别日志

func (*DefaultLogger) WithFields

func (l *DefaultLogger) WithFields(fields map[string]interface{}) LoggerInterface

WithFields 创建带有字段的日志记录器

type DetailView

type DetailView struct {
	LogEntry *LogEntry `json:"log_entry"` // 原始日志条目

	// 格式化后的内容
	FormattedRequestHeaders  string `json:"formatted_request_headers"`  // 格式化请求头
	FormattedResponseHeaders string `json:"formatted_response_headers"` // 格式化响应头
	FormattedRequestBody     string `json:"formatted_request_body"`     // 格式化请求体
	FormattedResponseBody    string `json:"formatted_response_body"`    // 格式化响应体
	FormattedSessionData     string `json:"formatted_session_data"`     // 格式化会话数据
	FormattedQueryParams     string `json:"formatted_query_params"`     // 格式化查询参数

	// 统计信息
	RequestSize  int `json:"request_size"`  // 请求大小(字节)
	ResponseSize int `json:"response_size"` // 响应大小(字节)

	// 时间信息
	FormattedTimestamp string `json:"formatted_timestamp"` // 格式化时间戳
	FormattedDuration  string `json:"formatted_duration"`  // 格式化持续时间

	// 相关日志
	RelatedEntries []*LogEntry `json:"related_entries"` // 相关日志条目
}

DetailView 详情视图 包含日志条目的完整信息和格式化后的内容

type DetailViewer

type DetailViewer struct {
	// contains filtered or unexported fields
}

DetailViewer 日志详情查看器 提供丰富的日志详情展示功能,支持格式化显示请求和响应信息

func NewDetailViewer

func NewDetailViewer(queryManager *QueryManager) *DetailViewer

NewDetailViewer 创建新的详情查看器 queryManager: 查询管理器实例

func (*DetailViewer) CompareEntries

func (dv *DetailViewer) CompareEntries(id1, id2 string) (map[string]interface{}, error)

CompareEntries 比较两个日志条目

func (*DetailViewer) GetDetail

func (dv *DetailViewer) GetDetail(id string) (*DetailView, error)

GetDetail 获取日志详情 id: 日志条目ID

func (*DetailViewer) GetDetailHTML

func (dv *DetailViewer) GetDetailHTML(id string) (string, error)

GetDetailHTML 获取HTML格式的详情

func (*DetailViewer) GetDetailJSON

func (dv *DetailViewer) GetDetailJSON(id string) ([]byte, error)

GetDetailJSON 获取JSON格式的详情

type FileStorage

type FileStorage struct {
	// contains filtered or unexported fields
}

FileStorage 文件存储器实现 将调试日志保存到文件系统中

func NewFileStorage

func NewFileStorage(basePath string, maxSize int) (*FileStorage, error)

NewFileStorage 创建新的文件存储器 basePath: 文件存储的基础路径 maxSize: 最大存储条目数(0表示无限制)

func (*FileStorage) Cleanup

func (fs *FileStorage) Cleanup(before time.Time) error

Cleanup 清理过期日志

func (*FileStorage) Close

func (fs *FileStorage) Close() error

Close 关闭文件存储器(文件存储不需要特殊关闭操作)

func (*FileStorage) ExportAll

func (fs *FileStorage) ExportAll(outputPath string) error

ExportAll 导出所有日志到单个文件

func (*FileStorage) FindAll

func (fs *FileStorage) FindAll(page, pageSize int, filters map[string]interface{}) ([]*LogEntry, int, error)

FindAll 查找所有日志条目,支持分页和过滤

func (*FileStorage) FindByID

func (fs *FileStorage) FindByID(id string) (*LogEntry, error)

FindByID 根据ID查找日志条目

func (*FileStorage) GetMethods

func (fs *FileStorage) GetMethods() (map[string]int, error)

GetMethods 获取HTTP方法统计

func (*FileStorage) GetStats

func (fs *FileStorage) GetStats() (map[string]interface{}, error)

GetStats 获取存储统计信息

func (*FileStorage) GetStatusCodes

func (fs *FileStorage) GetStatusCodes() (map[int]int, error)

GetStatusCodes 获取状态码统计

func (*FileStorage) ImportFromFile

func (fs *FileStorage) ImportFromFile(filePath string) error

ImportFromFile 从文件导入日志

func (*FileStorage) Save

func (fs *FileStorage) Save(entry *LogEntry) error

Save 保存日志条目到文件 每个日志条目保存为一个独立的JSON文件

func (*FileStorage) Search

func (fs *FileStorage) Search(keyword string, page, pageSize int) ([]*LogEntry, int, error)

Search 搜索日志内容

type LogEntry

type LogEntry struct {
	ID         string        `json:"id"`          // 日志唯一标识
	Timestamp  time.Time     `json:"timestamp"`   // 请求时间戳
	Method     string        `json:"method"`      // HTTP方法
	URL        string        `json:"url"`         // 请求URL
	StatusCode int           `json:"status_code"` // HTTP状态码
	Duration   time.Duration `json:"duration"`    // 处理耗时
	ClientIP   string        `json:"client_ip"`   // 客户端IP
	UserAgent  string        `json:"user_agent"`  // 用户代理
	RequestID  string        `json:"request_id"`  // 请求ID(用于追踪)

	// 请求信息
	RequestHeaders map[string]string `json:"request_headers"` // 请求头
	QueryParams    map[string]string `json:"query_params"`    // 查询参数
	RequestBody    string            `json:"request_body"`    // 请求体内容

	// 响应信息
	ResponseHeaders map[string]string `json:"response_headers"` // 响应头
	ResponseBody    string            `json:"response_body"`    // 响应体内容

	// 会话数据(可选)
	SessionData map[string]interface{} `json:"session_data,omitempty"` // 会话数据

	// 错误信息
	Error string `json:"error,omitempty"` // 错误信息

	// Logger日志信息(新增)
	LoggerLogs []LoggerLog `json:"logger_logs,omitempty"` // 通过logger记录的日志

	// 存储大小(计算字段,不持久化到存储)
	StorageSize string `json:"storage_size,omitempty"` // 存储大小(格式化显示)
}

LogEntry 调试日志条目结构 用于记录单个HTTP请求的完整调试信息

func (*LogEntry) CalculateStorageSize

func (e *LogEntry) CalculateStorageSize() string

CalculateStorageSize 计算日志条目的存储大小并格式化显示 计算内容包括:基本字段、请求体、响应体、请求头、响应头、查询参数、会话数据等 与总存储计算逻辑保持一致

func (*LogEntry) JSONString

func (e *LogEntry) JSONString() string

JSONString 返回日志条目的JSON字符串表示

func (*LogEntry) Summary

func (e *LogEntry) Summary() string

Summary 返回日志条目的摘要信息

type LogEntryModel

type LogEntryModel struct {
	ID         string    `gorm:"column:id;type:VARCHAR(64);primaryKey" json:"id"`
	Timestamp  time.Time `gorm:"column:timestamp;type:DATETIME;index" json:"timestamp"`
	Method     string    `gorm:"column:method;type:VARCHAR(10);index" json:"method"`
	URL        string    `gorm:"column:url;type:TEXT" json:"url"`
	StatusCode int       `gorm:"column:status_code;type:INT;index" json:"status_code"`
	Duration   int64     `gorm:"column:duration;type:BIGINT" json:"duration"` // 存储纳秒数
	ClientIP   string    `gorm:"column:client_ip;type:VARCHAR(45)" json:"client_ip"`
	UserAgent  string    `gorm:"column:user_agent;type:TEXT" json:"user_agent"`
	RequestID  string    `gorm:"column:request_id;type:VARCHAR(64);index" json:"request_id"`

	// JSON格式存储的字段
	RequestHeaders  string `gorm:"column:request_headers;type:JSON" json:"request_headers"`
	QueryParams     string `gorm:"column:query_params;type:JSON" json:"query_params"`
	RequestBody     string `gorm:"column:request_body;type:LONGTEXT" json:"request_body"`
	ResponseHeaders string `gorm:"column:response_headers;type:JSON" json:"response_headers"`
	ResponseBody    string `gorm:"column:response_body;type:LONGTEXT" json:"response_body"`
	SessionData     string `gorm:"column:session_data;type:JSON" json:"session_data"`
	Error           string `gorm:"column:error;type:TEXT" json:"error"`

	// 索引字段
	URLHash string `gorm:"column:url_hash;type:VARCHAR(32);index" json:"url_hash"` // URL的MD5哈希,用于快速搜索
}

LogEntryModel 数据库模型结构 对应数据库中的日志条目表

func (LogEntryModel) TableName

func (LogEntryModel) TableName() string

TableName 实现自定义表名

type LoggerInterface

type LoggerInterface interface {
	// Debug 记录调试级别日志
	Debug(msg any, fields ...map[string]interface{})

	// Info 记录信息级别日志
	Info(msg any, fields ...map[string]interface{})

	// Warn 记录警告级别日志
	Warn(msg any, fields ...map[string]interface{})

	// Error 记录错误级别日志
	Error(msg any, fields ...map[string]interface{})

	// WithFields 创建带有字段的日志记录器
	WithFields(fields map[string]interface{}) LoggerInterface

	// GetLevel 获取当前日志记录器的日志级别
	GetLevel() string
}

LoggerInterface 日志记录器接口 支持不同级别的日志记录,可以在控制器中直接使用

func GetLoggerFromContext

func GetLoggerFromContext(c *gin.Context) LoggerInterface

GetLoggerFromContext 从Gin上下文中获取Logger实例 控制器可以通过此函数获取Logger来记录日志

type LoggerLog

type LoggerLog struct {
	Timestamp time.Time              `json:"timestamp"` // 日志时间戳
	Level     string                 `json:"level"`     // 日志级别:debug/info/warn/error
	Message   string                 `json:"message"`   // 日志消息
	Fields    map[string]interface{} `json:"fields"`    // 日志附加字段
}

LoggerLog 记录通过logger打印的日志信息

type MemoryStorage

type MemoryStorage struct {
	// contains filtered or unexported fields
}

MemoryStorage 内存存储器实现 将调试日志保存在内存中,适合开发环境使用

func NewMemoryStorage

func NewMemoryStorage(maxSize ...int) (*MemoryStorage, error)

NewMemoryStorage 创建新的内存存储器 maxSize: 最大存储条目数(0表示无限制)

func (*MemoryStorage) Cleanup

func (ms *MemoryStorage) Cleanup(before time.Time) error

Cleanup 清理过期日志

func (*MemoryStorage) Clear

func (ms *MemoryStorage) Clear() error

Clear 清空所有日志条目

func (*MemoryStorage) Close

func (ms *MemoryStorage) Close() error

Close 关闭内存存储器

func (*MemoryStorage) ExportAll

func (ms *MemoryStorage) ExportAll() ([]*LogEntry, error)

ExportAll 导出所有日志到内存(返回副本)

func (*MemoryStorage) FindAll

func (ms *MemoryStorage) FindAll(page, pageSize int, filters map[string]interface{}) ([]*LogEntry, int, error)

FindAll 查找所有日志条目,支持分页和过滤

func (*MemoryStorage) FindByID

func (ms *MemoryStorage) FindByID(id string) (*LogEntry, error)

FindByID 根据ID查找日志条目

func (*MemoryStorage) GetByTimeRange

func (ms *MemoryStorage) GetByTimeRange(startTime, endTime time.Time) ([]*LogEntry, error)

GetByTimeRange 根据时间范围获取日志条目

func (*MemoryStorage) GetMethods

func (ms *MemoryStorage) GetMethods() (map[string]int, error)

GetMethods 获取所有HTTP方法统计

func (*MemoryStorage) GetRecent

func (ms *MemoryStorage) GetRecent(count int) ([]*LogEntry, error)

GetRecent 获取最近的日志条目

func (*MemoryStorage) GetStats

func (ms *MemoryStorage) GetStats() (map[string]interface{}, error)

GetStats 获取存储统计信息

func (*MemoryStorage) GetStatusCodes

func (ms *MemoryStorage) GetStatusCodes() (map[int]int, error)

GetStatusCodes 获取所有状态码统计

func (*MemoryStorage) ImportEntries

func (ms *MemoryStorage) ImportEntries(entries []*LogEntry) error

ImportEntries 导入日志条目

func (*MemoryStorage) Save

func (ms *MemoryStorage) Save(entry *LogEntry) error

Save 保存日志条目到内存

func (*MemoryStorage) Search

func (ms *MemoryStorage) Search(keyword string, page, pageSize int) ([]*LogEntry, int, error)

Search 搜索日志内容

type Middleware

type Middleware struct {
	// contains filtered or unexported fields
}

Middleware Gin中间件,用于拦截请求并记录调试信息 该中间件会捕获请求和响应的所有关键信息,包括请求头、请求体、响应头、响应体等

func NewMiddleware

func NewMiddleware(debugger *Debugger) *Middleware

NewMiddleware 创建新的中间件实例 debugger: 调试器实例,用于存储日志

func (*Middleware) Handler

func (m *Middleware) Handler() gin.HandlerFunc

Handler 中间件处理函数 实现gin.HandlerFunc接口,用于拦截HTTP请求

type Pagination

type Pagination struct {
	Page       int  // 当前页码
	PageSize   int  // 每页大小
	Total      int  // 总记录数
	TotalPages int  // 总页数
	HasPrev    bool // 是否有上一页
	HasNext    bool // 是否有下一页
	PrevPage   int  // 上一页页码
	NextPage   int  // 下一页页码
}

Pagination 分页信息

type QueryManager

type QueryManager struct {
	// contains filtered or unexported fields
}

QueryManager 日志查询管理器 提供丰富的查询和过滤功能,支持多种查询条件组合

func NewQueryManager

func NewQueryManager(storage Storage) *QueryManager

NewQueryManager 创建新的查询管理器 storage: 存储接口实例

func (*QueryManager) Cleanup

func (qm *QueryManager) Cleanup(before time.Time) error

Cleanup 清理过期日志 before: 清理此时间之前的日志

func (*QueryManager) Export

func (qm *QueryManager) Export(format string, options QueryOptions) ([]byte, error)

Export 导出日志数据 format: 导出格式(json, csv等)

func (*QueryManager) GetByID

func (qm *QueryManager) GetByID(id string) (*LogEntry, error)

GetByID 根据ID获取日志条目

func (*QueryManager) GetByMethod

func (qm *QueryManager) GetByMethod(method string, page, pageSize int) (*QueryResult, error)

GetByMethod 根据HTTP方法查询日志

func (*QueryManager) GetByStatusCode

func (qm *QueryManager) GetByStatusCode(statusCode int, page, pageSize int) (*QueryResult, error)

GetByStatusCode 根据状态码查询日志

func (*QueryManager) GetByTimeRange

func (qm *QueryManager) GetByTimeRange(startTime, endTime time.Time, page, pageSize int) (*QueryResult, error)

GetByTimeRange 根据时间范围查询日志 startTime: 开始时间 endTime: 结束时间

func (*QueryManager) GetByURL

func (qm *QueryManager) GetByURL(urlPattern string, page, pageSize int) (*QueryResult, error)

GetByURL 根据URL查询日志(模糊匹配)

func (*QueryManager) GetErrors

func (qm *QueryManager) GetErrors(page, pageSize int) (*QueryResult, error)

GetErrors 获取包含错误的日志

func (*QueryManager) GetFilterOptions

func (qm *QueryManager) GetFilterOptions() map[string]interface{}

GetFilterOptions 获取可用的过滤选项

func (*QueryManager) GetRecent

func (qm *QueryManager) GetRecent(limit int) ([]*LogEntry, error)

GetRecent 获取最近的日志条目 limit: 限制返回的条目数量

func (*QueryManager) GetSlowRequests

func (qm *QueryManager) GetSlowRequests(threshold time.Duration, page, pageSize int) (*QueryResult, error)

GetSlowRequests 获取慢请求日志 threshold: 慢请求阈值

func (*QueryManager) GetStats

func (qm *QueryManager) GetStats() (map[string]interface{}, error)

GetStats 获取统计信息

func (*QueryManager) Query

func (qm *QueryManager) Query(options QueryOptions) (*QueryResult, error)

Query 执行查询 根据查询选项获取日志条目

func (*QueryManager) Search

func (qm *QueryManager) Search(keyword string, page, pageSize int) (*QueryResult, error)

Search 执行搜索 根据关键词搜索日志内容

type QueryOptions

type QueryOptions struct {
	Page      int                    `json:"page"`       // 页码,从1开始
	PageSize  int                    `json:"page_size"`  // 每页大小
	Filters   map[string]interface{} `json:"filters"`    // 过滤条件
	SortBy    string                 `json:"sort_by"`    // 排序字段
	SortOrder string                 `json:"sort_order"` // 排序方向:asc/desc
}

QueryOptions 查询选项 定义查询的各种过滤条件和分页参数

type QueryResult

type QueryResult struct {
	Entries    []*LogEntry `json:"entries"`     // 日志条目列表
	Total      int         `json:"total"`       // 总记录数
	Page       int         `json:"page"`        // 当前页码
	PageSize   int         `json:"page_size"`   // 每页大小
	TotalPages int         `json:"total_pages"` // 总页数
}

QueryResult 查询结果 包含查询到的日志条目和分页信息

type Storage

type Storage interface {
	// Save 保存日志条目
	Save(entry *LogEntry) error

	// FindByID 根据ID查找日志条目
	FindByID(id string) (*LogEntry, error)

	// FindAll 查找所有日志条目,支持分页和过滤
	FindAll(page, pageSize int, filters map[string]interface{}) ([]*LogEntry, int, error)

	// Search 搜索日志内容
	Search(keyword string, page, pageSize int) ([]*LogEntry, int, error)

	// Cleanup 清理过期日志
	Cleanup(before time.Time) error

	// GetStats 获取统计信息
	GetStats() (map[string]interface{}, error)

	// GetMethods 获取HTTP方法统计
	GetMethods() (map[string]int, error)

	// GetStatusCodes 获取状态码统计
	GetStatusCodes() (map[int]int, error)

	// Close 关闭存储
	Close() error
}

Storage 存储接口定义 支持多种存储方式:文件、内存、数据库

type TemplateData

type TemplateData struct {
	Title      string
	BasePath   string
	Entries    []*LogEntry
	Entry      *LogEntry
	Pagination *Pagination
	Filters    map[string]string
	Keyword    string
	Stats      map[string]interface{}
}

TemplateData 模板数据

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL