goproxy/examples/plugin/plugins/defaultlogger/default_logger_plugin.go

package main

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

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

// DefaultLoggerPlugin 默认日志插件
// 提供文件日志和控制台日志功能，使用默认插件类型
type DefaultLoggerPlugin 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，大小写敏感
// 这个插件使用默认的通用插件类型（PluginTypeGeneral）
var Plugin = &DefaultLoggerPlugin{
	name:        "DefaultLoggerPlugin",
	version:     "1.0.0",
	description: "使用默认通用类型的日志记录插件",
	author:      "开发者",
	pluginType:  plugin.PluginTypeGeneral, // 使用通用插件类型
	enabled:     true,
}

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

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

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

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

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

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

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

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

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

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

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

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

	// 创建日志文件
	logFilePath := filepath.Join(logPath, fmt.Sprintf("default_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, "[DefaultLoggerPlugin] ", log.LstdFlags)

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

	return nil
}

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

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

// Stop 停止插件
func (p *DefaultLoggerPlugin) 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
}

// Log 记录日志
func (p *DefaultLoggerPlugin) Log(level, message string) {
	if p.logger == nil {
		fmt.Printf("[DEFAULT][%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 *DefaultLoggerPlugin) Info(message string) {
	p.Log("INFO", message)
}

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

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

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