841 lines
22 KiB
Go
841 lines
22 KiB
Go
package main
|
||
|
||
import "C"
|
||
import (
|
||
"encoding/json"
|
||
"fmt"
|
||
"log"
|
||
"os"
|
||
"path/filepath"
|
||
"runtime"
|
||
"syscall"
|
||
"time"
|
||
"unsafe"
|
||
|
||
"golang.org/x/sys/windows"
|
||
)
|
||
|
||
// LoggerWrapper 封装DLL调用
|
||
type LoggerWrapper struct {
|
||
dllHandle windows.Handle
|
||
createLogger uintptr
|
||
createContext uintptr
|
||
logInfo uintptr
|
||
logError uintptr
|
||
logWarning uintptr
|
||
logSuccess uintptr
|
||
freeString uintptr
|
||
closeAllLoggers uintptr
|
||
// cui
|
||
getLogs uintptr
|
||
getLogFiles uintptr
|
||
}
|
||
|
||
// 全局变量来跟踪创建的logger数量
|
||
var (
|
||
createdLoggers []string
|
||
loggerCount int
|
||
)
|
||
|
||
func NewLoggerWrapper(dllPath string) (*LoggerWrapper, error) {
|
||
if _, err := os.Stat(dllPath); os.IsNotExist(err) {
|
||
return nil, fmt.Errorf("DLL文件不存在: %s", dllPath)
|
||
}
|
||
|
||
dllHandle, err := windows.LoadLibrary(dllPath)
|
||
if err != nil {
|
||
return nil, fmt.Errorf("加载DLL失败: %v", err)
|
||
}
|
||
|
||
wrapper := &LoggerWrapper{
|
||
dllHandle: dllHandle,
|
||
}
|
||
|
||
if err := wrapper.loadFunctions(); err != nil {
|
||
windows.FreeLibrary(dllHandle)
|
||
return nil, err
|
||
}
|
||
return wrapper, nil
|
||
}
|
||
|
||
func (lw *LoggerWrapper) loadFunctions() error {
|
||
var err error
|
||
|
||
lw.createLogger, err = windows.GetProcAddress(lw.dllHandle, "CreateLogger")
|
||
if err != nil {
|
||
return err
|
||
}
|
||
|
||
lw.createContext, err = windows.GetProcAddress(lw.dllHandle, "CreateContextWithTaskType")
|
||
if err != nil {
|
||
return err
|
||
}
|
||
|
||
lw.logInfo, err = windows.GetProcAddress(lw.dllHandle, "LogInfo")
|
||
if err != nil {
|
||
return err
|
||
}
|
||
|
||
lw.logError, err = windows.GetProcAddress(lw.dllHandle, "LogError")
|
||
if err != nil {
|
||
return err
|
||
}
|
||
|
||
lw.logWarning, err = windows.GetProcAddress(lw.dllHandle, "LogWarning")
|
||
if err != nil {
|
||
return err
|
||
}
|
||
|
||
lw.logSuccess, err = windows.GetProcAddress(lw.dllHandle, "LogSuccess")
|
||
if err != nil {
|
||
return err
|
||
}
|
||
|
||
lw.freeString, err = windows.GetProcAddress(lw.dllHandle, "FreeString")
|
||
if err != nil {
|
||
return err
|
||
}
|
||
|
||
lw.closeAllLoggers, err = windows.GetProcAddress(lw.dllHandle, "CloseAllLoggers")
|
||
if err != nil {
|
||
return err
|
||
}
|
||
|
||
// cui
|
||
lw.getLogs, err = windows.GetProcAddress(lw.dllHandle, "GetLogs")
|
||
if err != nil {
|
||
return err
|
||
}
|
||
|
||
// cui
|
||
lw.getLogFiles, err = windows.GetProcAddress(lw.dllHandle, "GetLogFiles")
|
||
if err != nil {
|
||
return err
|
||
}
|
||
|
||
return nil
|
||
}
|
||
|
||
func (lw *LoggerWrapper) CreateLogger(configJSON string) (string, error) {
|
||
configCStr, err := syscall.BytePtrFromString(configJSON)
|
||
if err != nil {
|
||
return "", err
|
||
}
|
||
|
||
resultPtr, _, err := syscall.SyscallN(lw.createLogger, uintptr(unsafe.Pointer(configCStr)))
|
||
|
||
if err != syscall.Errno(0) {
|
||
return "", fmt.Errorf("CreateLogger调用失败: %v", err)
|
||
}
|
||
|
||
if resultPtr == 0 {
|
||
return "", fmt.Errorf("CreateLogger返回空指针")
|
||
}
|
||
|
||
result := readNullTerminatedString(resultPtr)
|
||
lw.FreeStringByPtr(resultPtr)
|
||
|
||
// 记录创建的logger
|
||
createdLoggers = append(createdLoggers, result)
|
||
loggerCount++
|
||
|
||
return result, nil
|
||
}
|
||
|
||
func (lw *LoggerWrapper) CreateContextWithTaskType(loggerHandle, taskType string) (string, error) {
|
||
loggerHandleCStr, err := syscall.BytePtrFromString(loggerHandle)
|
||
if err != nil {
|
||
return "", err
|
||
}
|
||
|
||
taskTypeCStr, err := syscall.BytePtrFromString(taskType)
|
||
if err != nil {
|
||
return "", err
|
||
}
|
||
|
||
resultPtr, _, err := syscall.SyscallN(
|
||
lw.createContext,
|
||
uintptr(unsafe.Pointer(loggerHandleCStr)),
|
||
uintptr(unsafe.Pointer(taskTypeCStr)),
|
||
)
|
||
|
||
if err != syscall.Errno(0) {
|
||
return "", fmt.Errorf("CreateContextWithTaskType调用失败: %v", err)
|
||
}
|
||
|
||
if resultPtr == 0 {
|
||
return "", fmt.Errorf("CreateContextWithTaskType返回空指针")
|
||
}
|
||
|
||
result := readNullTerminatedString(resultPtr)
|
||
lw.FreeStringByPtr(resultPtr)
|
||
return result, nil
|
||
}
|
||
|
||
func (lw *LoggerWrapper) LogInfo(ctxHandle, message string) error {
|
||
return lw.logMessage(ctxHandle, message, lw.logInfo)
|
||
}
|
||
|
||
func (lw *LoggerWrapper) LogError(ctxHandle, message string) error {
|
||
return lw.logMessage(ctxHandle, message, lw.logError)
|
||
}
|
||
|
||
func (lw *LoggerWrapper) LogWarning(ctxHandle, message string) error {
|
||
return lw.logMessage(ctxHandle, message, lw.logWarning)
|
||
}
|
||
|
||
func (lw *LoggerWrapper) LogSuccess(ctxHandle, message string) error {
|
||
return lw.logMessage(ctxHandle, message, lw.logSuccess)
|
||
}
|
||
|
||
func (lw *LoggerWrapper) logMessage(ctxHandle, message string, logFunc uintptr) error {
|
||
ctxHandleCStr, err := syscall.BytePtrFromString(ctxHandle)
|
||
if err != nil {
|
||
return err
|
||
}
|
||
|
||
messageCStr, err := syscall.BytePtrFromString(message)
|
||
if err != nil {
|
||
return err
|
||
}
|
||
|
||
_, _, err = syscall.SyscallN(
|
||
logFunc,
|
||
uintptr(unsafe.Pointer(ctxHandleCStr)),
|
||
uintptr(unsafe.Pointer(messageCStr)),
|
||
)
|
||
|
||
if err != syscall.Errno(0) {
|
||
return fmt.Errorf("日志记录失败: %v", err)
|
||
}
|
||
|
||
return nil
|
||
}
|
||
|
||
// cui
|
||
func (lw *LoggerWrapper) GetLogs(loggerHandle, configJSON string) (string, error) {
|
||
loggerHandleCStr, err := syscall.BytePtrFromString(loggerHandle)
|
||
if err != nil {
|
||
return "", err
|
||
}
|
||
|
||
configCStr, err := syscall.BytePtrFromString(configJSON)
|
||
if err != nil {
|
||
return "", err
|
||
}
|
||
|
||
resultPtr, _, err := syscall.SyscallN(
|
||
lw.getLogs,
|
||
uintptr(unsafe.Pointer(loggerHandleCStr)),
|
||
uintptr(unsafe.Pointer(configCStr)),
|
||
)
|
||
|
||
if err != syscall.Errno(0) {
|
||
return "", fmt.Errorf("GetLogs调用失败: %v", err)
|
||
}
|
||
|
||
if resultPtr == 0 {
|
||
return "", fmt.Errorf("GetLogs返回空指针")
|
||
}
|
||
|
||
result := ptrToString(resultPtr)
|
||
lw.FreeStringByPtr(resultPtr)
|
||
return result, nil
|
||
}
|
||
|
||
// cui
|
||
func (lw *LoggerWrapper) GetLogFiles(loggerHandle string) (string, error) {
|
||
loggerHandleCStr, err := syscall.BytePtrFromString(loggerHandle)
|
||
if err != nil {
|
||
return "", err
|
||
}
|
||
|
||
resultPtr, _, err := syscall.SyscallN(
|
||
lw.getLogFiles,
|
||
uintptr(unsafe.Pointer(loggerHandleCStr)),
|
||
)
|
||
|
||
if err != syscall.Errno(0) {
|
||
return "", fmt.Errorf("GetLogFiles调用失败: %v", err)
|
||
}
|
||
|
||
if resultPtr == 0 {
|
||
return "", fmt.Errorf("GetLogFiles返回空指针")
|
||
}
|
||
|
||
result := ptrToString(resultPtr)
|
||
lw.FreeStringByPtr(resultPtr)
|
||
return result, nil
|
||
}
|
||
|
||
func ptrToString(ptr uintptr) string {
|
||
if ptr == 0 {
|
||
return ""
|
||
}
|
||
// 先找到字符串长度
|
||
var length int
|
||
for {
|
||
b := *(*byte)(unsafe.Pointer(ptr + uintptr(length)))
|
||
if b == 0 {
|
||
break
|
||
}
|
||
length++
|
||
if length > 64*1024 { // 64KB限制
|
||
break
|
||
}
|
||
}
|
||
if length == 0 {
|
||
return ""
|
||
}
|
||
// 创建适当大小的切片
|
||
data := make([]byte, length)
|
||
for i := 0; i < length; i++ {
|
||
data[i] = *(*byte)(unsafe.Pointer(ptr + uintptr(i)))
|
||
}
|
||
return string(data)
|
||
}
|
||
|
||
func (lw *LoggerWrapper) FreeStringByPtr(ptr uintptr) {
|
||
if ptr != 0 {
|
||
syscall.SyscallN(lw.freeString, ptr)
|
||
}
|
||
}
|
||
|
||
func (lw *LoggerWrapper) CloseAllLoggers() (string, error) {
|
||
resultPtr, _, err := syscall.SyscallN(lw.closeAllLoggers)
|
||
if err != syscall.Errno(0) {
|
||
return "", fmt.Errorf("CloseAllLoggers调用失败: %v", err)
|
||
}
|
||
|
||
if resultPtr == 0 {
|
||
return "", fmt.Errorf("CloseAllLoggers返回空指针")
|
||
}
|
||
|
||
result := readNullTerminatedString(resultPtr)
|
||
lw.FreeStringByPtr(resultPtr)
|
||
return result, nil
|
||
}
|
||
|
||
func readNullTerminatedString(ptr uintptr) string {
|
||
if ptr == 0 {
|
||
return ""
|
||
}
|
||
|
||
var bytes []byte
|
||
for i := 0; i < 256; i++ {
|
||
b := *(*byte)(unsafe.Pointer(ptr + uintptr(i)))
|
||
if b == 0 {
|
||
break
|
||
}
|
||
bytes = append(bytes, b)
|
||
}
|
||
return string(bytes)
|
||
}
|
||
|
||
func (lw *LoggerWrapper) Close() error {
|
||
return windows.FreeLibrary(lw.dllHandle)
|
||
}
|
||
|
||
func checkError(result string) error {
|
||
if len(result) >= 6 && result[:6] == "错误:" {
|
||
return fmt.Errorf(result)
|
||
}
|
||
return nil
|
||
}
|
||
|
||
// 监控内存
|
||
func monitorResources() {
|
||
var m runtime.MemStats
|
||
runtime.ReadMemStats(&m)
|
||
fmt.Printf("📊 内存使用: Alloc=%.2fMB, TotalAlloc=%.2fMB, Sys=%.2fMB, NumGC=%d, Goroutines=%d\n",
|
||
float64(m.Alloc)/1024/1024,
|
||
float64(m.TotalAlloc)/1024/1024,
|
||
float64(m.Sys)/1024/1024,
|
||
m.NumGC,
|
||
runtime.NumGoroutine())
|
||
}
|
||
|
||
// 测试日志读取功能 cui
|
||
func testLogReadingFunctions(wrapper *LoggerWrapper) {
|
||
fmt.Println("\n📖 ========== 开始日志读取功能测试 ==========")
|
||
|
||
// 创建测试logger
|
||
config := `{
|
||
"log_dir": "./test_logs_reading",
|
||
"level": 1,
|
||
"split_type": 1,
|
||
"max_size": 1048576,
|
||
"max_count": 5,
|
||
"enable_caller": true,
|
||
"default_task_type": "reading_test"
|
||
}`
|
||
|
||
loggerHandle, err := wrapper.CreateLogger(config)
|
||
if err != nil {
|
||
log.Printf("创建测试logger失败: %v", err)
|
||
return
|
||
}
|
||
fmt.Printf("✅ 创建测试logger: %s\n", loggerHandle)
|
||
|
||
// 创建不同任务类型的上下文
|
||
taskTypes := []string{"task_a", "task_b", "task_c"}
|
||
ctxHandles := make(map[string]string)
|
||
|
||
for _, taskType := range taskTypes {
|
||
ctxHandle, err := wrapper.CreateContextWithTaskType(loggerHandle, taskType)
|
||
if err != nil {
|
||
log.Printf("创建上下文失败: %v", err)
|
||
continue
|
||
}
|
||
ctxHandles[taskType] = ctxHandle
|
||
fmt.Printf("✅ 创建上下文: %s -> %s\n", taskType, ctxHandle)
|
||
}
|
||
|
||
// 记录测试日志
|
||
fmt.Println("\n📝 记录测试日志数据...")
|
||
messages := []struct {
|
||
level string
|
||
message string
|
||
task string
|
||
}{
|
||
{"INFO", "这是INFO级别的测试消息", "task_a"},
|
||
{"ERROR", "这是ERROR级别的错误消息", "task_b"},
|
||
{"WARNING", "这是WARNING级别的警告消息", "task_c"},
|
||
{"SUCCESS", "这是SUCCESS级别的成功消息", "task_a"},
|
||
{"INFO", "另一条INFO消息", "task_b"},
|
||
}
|
||
|
||
for i, msg := range messages {
|
||
var err error
|
||
switch msg.level {
|
||
case "INFO":
|
||
err = wrapper.LogInfo(ctxHandles[msg.task], fmt.Sprintf("%s - 序号: %d", msg.message, i))
|
||
case "ERROR":
|
||
err = wrapper.LogError(ctxHandles[msg.task], fmt.Sprintf("%s - 序号: %d", msg.message, i))
|
||
case "WARNING":
|
||
err = wrapper.LogWarning(ctxHandles[msg.task], fmt.Sprintf("%s - 序号: %d", msg.message, i))
|
||
case "SUCCESS":
|
||
err = wrapper.LogSuccess(ctxHandles[msg.task], fmt.Sprintf("%s - 序号: %d", msg.message, i))
|
||
}
|
||
if err != nil {
|
||
log.Printf("记录日志失败: %v", err)
|
||
} else {
|
||
fmt.Printf("✅ 记录%s日志: %s\n", msg.level, msg.message)
|
||
}
|
||
}
|
||
|
||
// 等待一下确保日志写入完成
|
||
time.Sleep(100 * time.Millisecond)
|
||
|
||
// 测试1: 获取日志文件列表
|
||
fmt.Println("\n📁 测试1: 获取日志文件列表")
|
||
filesResult, err := wrapper.GetLogFiles(loggerHandle)
|
||
if err != nil {
|
||
log.Printf("获取日志文件列表失败: %v", err)
|
||
} else {
|
||
fmt.Printf("✅ 获取日志文件列表成功:\n%s\n", formatJSON(filesResult))
|
||
}
|
||
|
||
// 测试2: 获取所有日志
|
||
fmt.Println("\n📄 测试2: 获取所有日志")
|
||
allLogsConfig := `{
|
||
"level": -1,
|
||
"max_entries": 50
|
||
}`
|
||
allLogsResult, err := wrapper.GetLogs(loggerHandle, allLogsConfig)
|
||
if err != nil {
|
||
log.Printf("获取所有日志失败: %v", err)
|
||
} else {
|
||
fmt.Printf("✅ 获取所有日志成功:\n%s\n", formatJSON(allLogsResult))
|
||
}
|
||
|
||
// 测试3: 按级别过滤日志
|
||
fmt.Println("\n🔍 测试3: 按级别过滤日志(INFO)")
|
||
infoLogsConfig := `{
|
||
"level": 1,
|
||
"max_entries": 10
|
||
}`
|
||
infoLogsResult, err := wrapper.GetLogs(loggerHandle, infoLogsConfig)
|
||
if err != nil {
|
||
log.Printf("获取INFO日志失败: %v", err)
|
||
} else {
|
||
fmt.Printf("✅ 获取INFO日志成功:\n%s\n", formatJSON(infoLogsResult))
|
||
}
|
||
|
||
// 测试4: 按任务类型过滤日志
|
||
fmt.Println("\n🔍 测试4: 按任务类型过滤日志(task_a)")
|
||
taskALogsConfig := `{
|
||
"level": -1,
|
||
"task_type": "task_a",
|
||
"max_entries": 10
|
||
}`
|
||
taskALogsResult, err := wrapper.GetLogs(loggerHandle, taskALogsConfig)
|
||
if err != nil {
|
||
log.Printf("获取task_a日志失败: %v", err)
|
||
} else {
|
||
fmt.Printf("✅ 获取task_a日志成功:\n%s\n", formatJSON(taskALogsResult))
|
||
}
|
||
|
||
// 测试5: 限制返回条目数
|
||
fmt.Println("\n🔍 测试5: 限制返回条目数(2条)")
|
||
limitedLogsConfig := `{
|
||
"level": -1,
|
||
"max_entries": 2
|
||
}`
|
||
limitedLogsResult, err := wrapper.GetLogs(loggerHandle, limitedLogsConfig)
|
||
if err != nil {
|
||
log.Printf("获取限制条目日志失败: %v", err)
|
||
} else {
|
||
fmt.Printf("✅ 获取限制条目日志成功:\n%s\n", formatJSON(limitedLogsResult))
|
||
}
|
||
|
||
// 测试6: 组合条件查询
|
||
fmt.Println("\n🔍 测试6: 组合条件查询(ERROR级别 + task_b)")
|
||
combinedConfig := `{
|
||
"level": 3,
|
||
"task_type": "task_b",
|
||
"max_entries": 10
|
||
}`
|
||
combinedResult, err := wrapper.GetLogs(loggerHandle, combinedConfig)
|
||
if err != nil {
|
||
log.Printf("组合条件查询失败: %v", err)
|
||
} else {
|
||
fmt.Printf("✅ 组合条件查询成功:\n%s\n", formatJSON(combinedResult))
|
||
}
|
||
|
||
// 测试7: 组合条件查询
|
||
fmt.Println("\n🔍 测试7: 组合条件查询(task_b)")
|
||
combinedTimeConfig := `{
|
||
"level": -1,
|
||
"task_type": "task_b",
|
||
"start_time": "2025-11-25 15:03:31",
|
||
"end_time": "2025-11-25 15:04:31",
|
||
"max_entries": 10
|
||
}`
|
||
combinedTimeResult, err := wrapper.GetLogs(loggerHandle, combinedTimeConfig)
|
||
if err != nil {
|
||
log.Printf("组合条件查询失败: %v", err)
|
||
} else {
|
||
fmt.Printf("✅ 组合条件查询成功:\n%s\n", formatJSON(combinedTimeResult))
|
||
}
|
||
|
||
// 解析并分析结果
|
||
fmt.Println("\n📊 日志读取功能测试分析:")
|
||
analyzeLogReadingResults(allLogsResult)
|
||
|
||
fmt.Println("✅ 日志读取功能测试完成")
|
||
}
|
||
|
||
// 分析日志读取结果 cui
|
||
func analyzeLogReadingResults(logsResult string) {
|
||
var result map[string]interface{}
|
||
if err := json.Unmarshal([]byte(logsResult), &result); err != nil {
|
||
log.Printf("解析日志结果失败: %v", err)
|
||
return
|
||
}
|
||
|
||
if errorMsg, exists := result["error"]; exists {
|
||
fmt.Printf("❌ 错误: %v\n", errorMsg)
|
||
return
|
||
}
|
||
|
||
count, _ := result["count"].(float64)
|
||
entries, _ := result["entries"].([]interface{})
|
||
|
||
fmt.Printf(" 总日志条目数: %.0f\n", count)
|
||
|
||
// 统计各级别日志数量
|
||
levelCount := make(map[string]int)
|
||
taskCount := make(map[string]int)
|
||
|
||
for _, entry := range entries {
|
||
if entryMap, ok := entry.(map[string]interface{}); ok {
|
||
level, _ := entryMap["level"].(string)
|
||
taskType, _ := entryMap["task_type"].(string)
|
||
levelCount[level]++
|
||
taskCount[taskType]++
|
||
}
|
||
}
|
||
|
||
fmt.Println(" 日志级别分布:")
|
||
for level, count := range levelCount {
|
||
fmt.Printf(" - %s: %d条\n", level, count)
|
||
}
|
||
|
||
fmt.Println(" 任务类型分布:")
|
||
for taskType, count := range taskCount {
|
||
fmt.Printf(" - %s: %d条\n", taskType, count)
|
||
}
|
||
}
|
||
|
||
// 格式化JSON输出 cui
|
||
func formatJSON(jsonStr string) string {
|
||
var result map[string]interface{}
|
||
if err := json.Unmarshal([]byte(jsonStr), &result); err != nil {
|
||
return jsonStr // 返回原始字符串如果解析失败
|
||
}
|
||
|
||
formatted, err := json.MarshalIndent(result, " ", " ")
|
||
if err != nil {
|
||
return jsonStr
|
||
}
|
||
return string(formatted)
|
||
}
|
||
|
||
// 测试资源回收的核心函数
|
||
func testResourceCleanup(wrapper *LoggerWrapper) {
|
||
fmt.Println("🧪 开始资源回收验证测试")
|
||
|
||
// 测试配置
|
||
config := `{
|
||
"log_dir": "./resource_cleanup_test",
|
||
"level": 1,
|
||
"split_type": 1,
|
||
"max_size": 1048576,
|
||
"max_count": 3,
|
||
"enable_caller": false,
|
||
"default_task_type": "cleanup_test"
|
||
}`
|
||
|
||
// 阶段1: 创建多个logger并记录初始状态
|
||
fmt.Println("\n📝 阶段1: 创建测试logger")
|
||
activeLoggers := make([]string, 0)
|
||
idleLoggers := make([]string, 0)
|
||
|
||
// 创建6个logger，3个活跃，3个闲置
|
||
for i := 0; i < 6; i++ {
|
||
loggerHandle, err := wrapper.CreateLogger(config)
|
||
if err != nil {
|
||
log.Printf("创建logger %d 失败: %v", i, err)
|
||
continue
|
||
}
|
||
|
||
if i < 3 {
|
||
activeLoggers = append(activeLoggers, loggerHandle)
|
||
fmt.Printf("✅ 创建活跃logger %d: %s\n", i, loggerHandle)
|
||
} else {
|
||
idleLoggers = append(idleLoggers, loggerHandle)
|
||
fmt.Printf("✅ 创建闲置logger %d: %s\n", i, loggerHandle)
|
||
}
|
||
}
|
||
|
||
fmt.Printf("\n📊 创建统计: 活跃logger=%d, 闲置logger=%d, 总计=%d\n",
|
||
len(activeLoggers), len(idleLoggers), len(activeLoggers)+len(idleLoggers))
|
||
|
||
// 阶段2: 使用活跃logger，让闲置logger保持不使用状态
|
||
fmt.Println("\n📝 阶段2: 使用活跃logger")
|
||
for i, loggerHandle := range activeLoggers {
|
||
ctxHandle, err := wrapper.CreateContextWithTaskType(loggerHandle, fmt.Sprintf("active_task_%d", i))
|
||
if err != nil {
|
||
log.Printf("创建上下文失败: %v", err)
|
||
continue
|
||
}
|
||
|
||
// 记录多条日志确保活跃状态
|
||
for j := 0; j < 5; j++ {
|
||
message := fmt.Sprintf("活跃logger %d - 消息 %d - 时间: %s", i, j, time.Now().Format("15:04:05"))
|
||
err = wrapper.LogInfo(ctxHandle, message)
|
||
if err != nil {
|
||
log.Printf("记录日志失败: %v", err)
|
||
}
|
||
}
|
||
fmt.Printf("✅ 活跃logger %d 已使用: %s\n", i, loggerHandle)
|
||
}
|
||
|
||
// 记录当前资源状态
|
||
fmt.Println("\n📊 资源使用前状态:")
|
||
monitorResources()
|
||
|
||
// 阶段3: 模拟时间流逝并验证资源回收
|
||
fmt.Println("\n⏰ 阶段3: 模拟时间流逝等待资源回收")
|
||
fmt.Println(" 自动清理机制: 每30分钟运行一次，清理2小时未使用的资源")
|
||
fmt.Println(" 由于测试时间限制，我们将观察资源使用模式...")
|
||
|
||
// 多次采样资源使用情况来观察趋势
|
||
fmt.Println("\n📈 资源使用趋势观察:")
|
||
initialMemory := getMemoryUsage()
|
||
|
||
for i := 0; i < 3; i++ {
|
||
fmt.Printf("\n 采样 %d:\n", i+1)
|
||
monitorResources()
|
||
|
||
// 继续使用活跃logger以保持其活跃状态
|
||
for _, loggerHandle := range activeLoggers {
|
||
ctxHandle, err := wrapper.CreateContextWithTaskType(loggerHandle, "keep_alive")
|
||
if err == nil {
|
||
wrapper.LogInfo(ctxHandle, fmt.Sprintf("保持活跃 - 采样 %d", i+1))
|
||
}
|
||
}
|
||
|
||
time.Sleep(2 * time.Second)
|
||
}
|
||
|
||
finalMemory := getMemoryUsage()
|
||
memoryChange := finalMemory - initialMemory
|
||
|
||
fmt.Printf("\n📊 内存变化: %.2fMB\n", memoryChange)
|
||
|
||
// 阶段4: 验证闲置logger的状态
|
||
fmt.Println("\n🔍 阶段4: 验证闲置logger状态")
|
||
stillWorkingCount := 0
|
||
for i, loggerHandle := range idleLoggers {
|
||
ctxHandle, err := wrapper.CreateContextWithTaskType(loggerHandle, "test_after_idle")
|
||
if err != nil {
|
||
fmt.Printf("❌ 闲置logger %d 可能已被回收: %s -> %v\n", i, loggerHandle, err)
|
||
} else {
|
||
// 尝试记录日志
|
||
err = wrapper.LogInfo(ctxHandle, "测试闲置logger是否仍然工作")
|
||
if err != nil {
|
||
fmt.Printf("❌ 闲置logger %d 记录日志失败: %s -> %v\n", i, loggerHandle, err)
|
||
} else {
|
||
fmt.Printf("✅ 闲置logger %d 仍然工作: %s\n", i, loggerHandle)
|
||
stillWorkingCount++
|
||
}
|
||
}
|
||
}
|
||
|
||
// 阶段5: 验证活跃logger的状态
|
||
fmt.Println("\n🔍 阶段5: 验证活跃logger状态")
|
||
activeWorkingCount := 0
|
||
for i, loggerHandle := range activeLoggers {
|
||
ctxHandle, err := wrapper.CreateContextWithTaskType(loggerHandle, "test_active")
|
||
if err != nil {
|
||
fmt.Printf("❌ 活跃logger %d 异常: %s -> %v\n", i, loggerHandle, err)
|
||
} else {
|
||
err = wrapper.LogInfo(ctxHandle, "测试活跃logger是否正常工作")
|
||
if err != nil {
|
||
fmt.Printf("❌ 活跃logger %d 记录日志失败: %s -> %v\n", i, loggerHandle, err)
|
||
} else {
|
||
fmt.Printf("✅ 活跃logger %d 正常工作: %s\n", i, loggerHandle)
|
||
activeWorkingCount++
|
||
}
|
||
}
|
||
}
|
||
|
||
// 阶段6: 分析测试结果
|
||
fmt.Println("\n📋 阶段6: 资源回收测试结果分析")
|
||
fmt.Printf(" 初始创建: %d 个logger\n", len(activeLoggers)+len(idleLoggers))
|
||
fmt.Printf(" 活跃logger正常: %d/%d\n", activeWorkingCount, len(activeLoggers))
|
||
fmt.Printf(" 闲置logger仍然工作: %d/%d\n", stillWorkingCount, len(idleLoggers))
|
||
fmt.Printf(" 内存变化: %.2fMB\n", memoryChange)
|
||
|
||
// 资源回收效果评估
|
||
if stillWorkingCount < len(idleLoggers) {
|
||
fmt.Println("🎯 资源回收效果: ✅ 检测到可能的资源回收")
|
||
fmt.Println(" 说明: 部分闲置logger无法使用，可能已被自动清理机制回收")
|
||
} else {
|
||
fmt.Println("🎯 资源回收效果: ⚠️ 未检测到明显的资源回收")
|
||
fmt.Println(" 说明: 所有logger仍然可用，可能因为:")
|
||
fmt.Println(" - 测试时间不足以触发自动清理")
|
||
fmt.Println(" - 自动清理机制配置时间较长")
|
||
fmt.Println(" - 所有logger仍被认定为活跃状态")
|
||
}
|
||
|
||
// 阶段7: 显式清理
|
||
fmt.Println("\n🧹 阶段7: 显式清理所有资源")
|
||
result, err := wrapper.CloseAllLoggers()
|
||
if err != nil {
|
||
log.Printf("关闭所有logger失败: %v", err)
|
||
} else {
|
||
fmt.Printf("✅ %s\n", result)
|
||
}
|
||
|
||
// 最终资源状态
|
||
fmt.Println("\n📊 最终资源状态:")
|
||
monitorResources()
|
||
|
||
fmt.Println("🧪 资源回收验证测试完成")
|
||
}
|
||
|
||
func getMemoryUsage() float64 {
|
||
var m runtime.MemStats
|
||
runtime.ReadMemStats(&m)
|
||
return float64(m.Alloc) / 1024 / 1024
|
||
}
|
||
|
||
// 文件系统资源检查
|
||
func checkFileSystemResources() {
|
||
fmt.Println("\n📁 文件系统资源检查:")
|
||
|
||
// 检查日志目录
|
||
dirs := []string{"./resource_cleanup_test", "./test_logs"}
|
||
for _, dir := range dirs {
|
||
if _, err := os.Stat(dir); !os.IsNotExist(err) {
|
||
files, _ := filepath.Glob(filepath.Join(dir, "*", "*.log"))
|
||
fmt.Printf(" 目录 %s: %d 个日志文件\n", dir, len(files))
|
||
|
||
// 显示文件详情
|
||
for _, file := range files {
|
||
info, err := os.Stat(file)
|
||
if err == nil {
|
||
fmt.Printf(" - %s (大小: %.2fKB, 修改时间: %s)\n",
|
||
filepath.Base(file),
|
||
float64(info.Size())/1024,
|
||
info.ModTime().Format("15:04:05"))
|
||
}
|
||
}
|
||
} else {
|
||
fmt.Printf(" 目录 %s: 不存在\n", dir)
|
||
}
|
||
}
|
||
}
|
||
|
||
func main() {
|
||
config := `{
|
||
"log_dir": "./test_logs_reading",
|
||
"level": 1,
|
||
"split_type": 1,
|
||
"max_size": 1048576,
|
||
"max_count": 5,
|
||
"enable_caller": true,
|
||
"default_task_type": "reading_test"
|
||
}`
|
||
var configs Config
|
||
err2 := json.Unmarshal([]byte(config), &configs)
|
||
if err2 != nil {
|
||
fmt.Println(err2)
|
||
}
|
||
logger, err := NewLogger(configs)
|
||
if err != nil {
|
||
fmt.Println(err)
|
||
}
|
||
fmt.Println(logger)
|
||
|
||
fmt.Println("🚀 开始资源回收验证测试")
|
||
|
||
// 确定DLL路径
|
||
dllPath := "logger.dll"
|
||
if _, err := os.Stat(dllPath); os.IsNotExist(err) {
|
||
log.Fatalf("DLL文件不存在: %s", dllPath)
|
||
}
|
||
|
||
// 创建包装器
|
||
wrapper, err := NewLoggerWrapper(dllPath)
|
||
if err != nil {
|
||
log.Fatalf("创建日志包装器失败: %v", err)
|
||
}
|
||
defer wrapper.Close()
|
||
|
||
fmt.Println("✅ DLL加载成功")
|
||
|
||
// 初始资源状态
|
||
fmt.Println("\n📈 初始资源状态:")
|
||
monitorResources()
|
||
|
||
// 运行日志读取功能测试
|
||
testLogReadingFunctions(wrapper)
|
||
|
||
// 运行资源回收测试
|
||
testResourceCleanup(wrapper)
|
||
|
||
// 检查文件系统资源
|
||
checkFileSystemResources()
|
||
|
||
fmt.Println("\n🎉 资源回收验证完成!")
|
||
fmt.Println("\n💡 测试说明:")
|
||
fmt.Println(" - 本测试创建了活跃和闲置的logger来模拟真实使用场景")
|
||
fmt.Println(" - 通过观察闲置logger的可用性来验证自动回收机制")
|
||
fmt.Println(" - 内存使用趋势可以帮助识别资源泄漏")
|
||
fmt.Println(" - 实际自动清理需要较长时间(2小时未使用)")
|
||
}
|