goproxy/examples/plugin/plugins/logger/logger_plugin.go

package main

import (
	"context"
	"fmt"
	"log"
	"os"
	"path/filepath"
	"time"

	"github.com/darkit/goproxy/examples/plugin"
)

// LoggerPlugin 日志插件
// 提供文件日志和控制台日志功能
type LoggerPlugin struct {
	plugin.Plugin                             // 嵌入接口，确保类型检查
	name                string                // 插件名称
	version             string                // 插件版本
	description         string                // 插件描述
	author              string                // 插件作者
	pluginType          plugin.PluginType     // 插件类型
	enabled             bool                  // 是否启用
	logFile             *os.File              // 日志文件
	logger              *log.Logger           // 日志记录器
	config              map[string]interface{} // 配置
}

// Plugin 导出的插件变量
// 注意：变量名必须是Plugin，大小写敏感
var Plugin = &LoggerPlugin{
	name:        "LoggerPlugin",
	version:     "1.0.0",
	description: "简单的日志记录插件",
	author:      "开发者",
	pluginType:  plugin.PluginTypeUtils, // 明确指定为工具类插件
	enabled:     true,
}

// Name 返回插件名称
func (p *LoggerPlugin) Name() string {
	return p.name
}

// Version 返回插件版本
func (p *LoggerPlugin) Version() string {
	return p.version
}

// Description 返回插件描述
func (p *LoggerPlugin) Description() string {
	return p.description
}

// Author 返回插件作者
func (p *LoggerPlugin) Author() string {
	return p.author
}

// Type 返回插件类型
func (p *LoggerPlugin) Type() plugin.PluginType {
	return p.pluginType
}

// IsEnabled 返回插件是否启用
func (p *LoggerPlugin) IsEnabled() bool {
	return p.enabled
}

// SetEnabled 设置插件启用状态
func (p *LoggerPlugin) SetEnabled(enabled bool) {
	p.enabled = enabled
}

// GetOperationInfo 获取操作的参数信息
func (p *LoggerPlugin) GetOperationInfo(operation string) (map[string]interface{}, error) {
	return map[string]interface{}{}, nil
}

// GetAllOperations 获取所有操作及其参数信息
func (p *LoggerPlugin) GetAllOperations() map[string]map[string]interface{} {
	return map[string]map[string]interface{}{}
}

// Init 初始化插件
func (p *LoggerPlugin) Init(ctx context.Context, config map[string]interface{}) error {
	p.config = config

	// 获取日志文件路径
	logPath, ok := config["log_path"].(string)
	if !ok {
		// 使用默认路径
		logPath = "logs"
	}

	// 确保日志目录存在
	if err := os.MkdirAll(logPath, 0o755); err != nil {
		return fmt.Errorf("创建日志目录失败: %v", err)
	}

	// 创建日志文件
	logFilePath := filepath.Join(logPath, fmt.Sprintf("app_%s.log", time.Now().Format("2006-01-02")))
	logFile, err := os.OpenFile(logFilePath, os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0o644)
	if err != nil {
		return fmt.Errorf("打开日志文件失败: %v", err)
	}

	p.logFile = logFile
	p.logger = log.New(logFile, "[LoggerPlugin] ", log.LstdFlags)

	p.logger.Println("日志插件初始化完成")
	fmt.Printf("日志插件初始化完成，日志文件: %s，插件类型: %s\n", logFilePath, p.Type())

	return nil
}

// Start 启动插件
func (p *LoggerPlugin) Start(ctx context.Context) error {
	if p.logger == nil {
		return fmt.Errorf("插件未初始化")
	}

	p.logger.Println("日志插件已启动")
	fmt.Println("日志插件已启动")
	return nil
}

// Stop 停止插件
func (p *LoggerPlugin) Stop(ctx context.Context) error {
	if p.logger != nil {
		p.logger.Println("日志插件正在停止")
	}

	if p.logFile != nil {
		if err := p.logFile.Close(); err != nil {
			return fmt.Errorf("关闭日志文件失败: %v", err)
		}
	}

	fmt.Println("日志插件已停止")
	return nil
}

// Execute 执行插件功能
func (p *LoggerPlugin) Execute(ctx context.Context, action string, params map[string]interface{}) (interface{}, error) {
	switch action {
	case "log":
		// 需要参数: level, message
		level, ok := params["level"].(string)
		if !ok {
			return nil, fmt.Errorf("缺少必需参数: level")
		}
		message, ok := params["message"].(string)
		if !ok {
			return nil, fmt.Errorf("缺少必需参数: message")
		}
		p.Log(level, message)
		return true, nil

	case "info":
		// 需要参数: message
		message, ok := params["message"].(string)
		if !ok {
			return nil, fmt.Errorf("缺少必需参数: message")
		}
		p.Info(message)
		return true, nil

	case "warn":
		// 需要参数: message
		message, ok := params["message"].(string)
		if !ok {
			return nil, fmt.Errorf("缺少必需参数: message")
		}
		p.Warn(message)
		return true, nil

	case "error":
		// 需要参数: message
		message, ok := params["message"].(string)
		if !ok {
			return nil, fmt.Errorf("缺少必需参数: message")
		}
		p.Error(message)
		return true, nil

	case "getLoggerStatus":
		// 不需要参数
		status := map[string]interface{}{
			"initialized": p.logger != nil,
			"config":      p.config,
		}
		return status, nil

	default:
		return nil, fmt.Errorf("未知的操作: %s", action)
	}
}

// Log 记录日志
func (p *LoggerPlugin) Log(level, message string) {
	if p.logger == nil {
		fmt.Printf("[%s] %s\n", level, message)
		return
	}

	logMsg := fmt.Sprintf("[%s] %s", level, message)
	p.logger.Println(logMsg)

	// 如果配置了同时输出到控制台
	if consoleOutput, ok := p.config["console_output"].(bool); ok && consoleOutput {
		fmt.Println(logMsg)
	}
}

// Info 记录信息日志
func (p *LoggerPlugin) Info(message string) {
	p.Log("INFO", message)
}

// Warn 记录警告日志
func (p *LoggerPlugin) Warn(message string) {
	p.Log("WARN", message)
}

// Error 记录错误日志
func (p *LoggerPlugin) Error(message string) {
	p.Log("ERROR", message)
}

// main 函数是必须的，但不会被调用
func main() {
	// 不会被执行，仅用于编译插件
}