Java日志体系

/**
 * 日志上下文类
 * 用于收集和管理整个请求生命周期中的日志信息
 * 支持泛型，可以处理不同类型的请求和响应对象
 */
@Data
public class LogInfo {
    // 日志字段常量，定义日志中各个字段的键名
    private String scene;             // 场景标识
    /**
     * 请求响应
     * request: 原始请求对象
     * response: 响应对象
     */
    private Object request;
    private Object response;
    private Map<String, Object> extraInfoMap;    // 扩展信息
}

/**
 * 场景枚举类
 * 定义系统中的各种业务场景
 */
@Getter
public enum LogScene {

    Scene1("Scene1"),
    Scene2("Scene2");

    private final String value;

    LogScene(String value) {
        this.value = value;
    }

    /**
     * 根据字符串值获取对应的枚举
     * @param value 场景值
     * @return 对应的枚举值，如果不存在则返回null
     */
    public static LogScene fromValue(String value) {
        if (value == null) {
            return null;
        }
        
        for (LogScene logScene : LogScene.values()) {
            if (logScene.getValue().equals(value)) {
                return logScene;
            }
        }
        return null;
    }
}

/**
 * 日志工具类
 * 提供将LogContext对象转换为标准日志格式并输出的功能
 * 使用@UtilityClass注解标记为工具类，所有方法都是静态的
 */
@UtilityClass
public class LogUtil {
    // 日志记录器，使用scribe作为日志名称，通常用于远程日志收集
    private static final Logger localLogger = LoggerFactory.getLogger(LogUtil.class);

    private static final Logger remoteLogger = LoggerFactory.getLogger("topic");

    // 日志字段常量，定义日志中各个字段的键名
    private static final String SCENE = "scene";             // 场景标识
    private static final String REQUEST = "request";         // 请求对象
    private static final String RESPONSE = "response";       // 响应对象
    private static final String EXTRA_INFO = "extraInfo";    // 扩展信息
    private static final String TIMESTAMP = "timestamp";     // 时间戳

    /**
     * 记录业务日志
     * 将LogContext对象中的信息格式化为JSON并输出到日志系统
     * @param logInfo 日志上下文对象，包含所有需要记录的信息
     */
    public static void logInfo(LogInfo logInfo) {
        if (Objects.isNull(logInfo)){
            return;
        }
        XMDLogFormat formatter = XMDLogFormat.build();

        try {
            // 使用ImmutableMap.Builder构建不可变Map
            ImmutableMap.Builder<String, Object> tags = buildBasicInfo(logInfo);
//            formatter.putTags(tags.build());
            formatter.putJson(JacksonUtils.toJson(tags.build()));
            String extraMessage = "";
            remoteLogger.info(formatter.message(extraMessage));
        } catch (Exception e) {
            // 记录日志过程中发生异常时，记录错误日志
            localLogger.error("记录业务日志异常", e);
        }
    }

    /**
     * 构建基础信息
     * 添加时间戳等基础字段到日志中
     *
     * @param logInfo 日志上下文对象
     */
    private static ImmutableMap.Builder<String, Object> buildBasicInfo(LogInfo logInfo) {
        ImmutableMap.Builder<String, Object> tags = ImmutableMap.builder();
        try {
            if (logInfo.getScene() != null) {
                tags.put(SCENE, logInfo.getScene());
            }
            // 将请求和响应对象转换为JSON字符串
            if (logInfo.getRequest() != null) {
                tags.put(REQUEST, JacksonUtils.toJson(logInfo.getRequest()));
            }
            if (logInfo.getResponse() != null) {
                tags.put(RESPONSE,  JacksonUtils.toJson(logInfo.getResponse()));
            }
            if (MapUtils.isNotEmpty(logInfo.getExtraInfoMap())) {
                tags.put(EXTRA_INFO,  JacksonUtils.toJson(logInfo.getExtraInfoMap()));
            }
            tags.put(TIMESTAMP, System.currentTimeMillis());
        } catch (Exception e) {
            localLogger.error(" build log info tag error", e);
        }
        return tags;
    }

}

@Configuration
public class ThreadConfig {

    private static final Logger LOGGER = LoggerFactory.getLogger(ThreadConfig.class);
   
    @Bean(name = "logThreadPool")
    public ThreadPool logThreadPool() {
        ThreadPool threadPool = new ThreadPool("logThreadPool", DefaultThreadPoolProperties
                .Setter()
                .withCoreSize(64)
                .withMaxSize(128)
                .withMaxQueueSize(1024)
                .withKeepAliveTimeMinutes(10)
                .withRejectHandler(new RejectedExecutionHandler() {
                    @Override
                    public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
                        LOGGER.error("logThreadPool reject");
                    }
                })
        );
        //warmup
        warmup(threadPool, 64);
        return threadPool;
    }

    private void warmup(ThreadPool threadPool, int coreSize) {
        if (coreSize <= 0 || threadPool == null) {
            return;
        }
        for (int i = 0; i < coreSize; i++) {
            threadPool.submit(()->{
                ThreadUtil.sleep(5);
            });
        }
    }
}

@Service
public class LogService {
    private static final Logger LOGGER = LoggerFactory.getLogger(LogService.class);

    @Data
    @AllArgsConstructor
    class LogMessage {
        private String role;
        private String content;
    }
    @Resource
    ThreadPool logThreadPool;


    /**
     * 记录模型调用信息
     *
     * @param ctx 代理上下文，包含请求和响应信息
     */
    public void logModelInfo(Context ctx) {
        try{
            LogInfo loginfo = build(ctx);
            // 提交日志记录任务
            logInfo(logInfo);
        } catch (Throwable t) {
            // 捕获所有可能的异常，包括Error
            LOGGER.error("Unexpected error in logModelInfo", t);
        }
    }


    /**
     * 记录代理信息
     *
     * @param request 代理请求
     * @param response 代理响应
     */
    public void logAgentInfo(Request request, Response response) {
        try {
            LogInfo loginfo = build(request,response);
            logInfo(logInfo);
        } catch (Throwable t) {
            // 捕获所有可能的异常，包括Error
            LOGGER.error("Unexpected error in logAgentInfo", t);
        }
    }

    /**
     * 将日志信息提交到线程池异步处理
     *
     * @param info 日志信息对象
     */
    private void logInfo(LogInfo info) {
        try {
            if (info == null) {
                LOGGER.warn("logModelInfo failed: LogInfo is null");
                return;
            }

            // 检查线程池是否可用
            if (logThreadPool != null) {
                try {
                    logThreadPool.submit(() -> {
                        try {
                            LogUtil.logInfo(info);
                        } catch (Exception e) {
                            LOGGER.error("Failed to log model info in thread pool task", e);
                        } catch (Throwable t) {
                            LOGGER.error("Unexpected error in thread pool log task", t);
                        }
                    });
                } catch (Exception e) {
                    LOGGER.error("Failed to submit log task to thread pool", e);
                    // 降级处理：直接记录日志
                    try {
                        LogUtil.logInfo(info);
                    } catch (Exception ex) {
                        LOGGER.error("Failed to log model info directly after thread pool failure", ex);
                    }
                }
            } else {
                LOGGER.warn("logThreadPool is null, logging synchronously");
                try {
                    LogUtil.logInfo(info);
                } catch (Exception e) {
                    LOGGER.error("Failed to log model info synchronously", e);
                }
            }
        } catch (Throwable t) {
            // 捕获所有可能的异常，包括Error
            LOGGER.error("Unexpected error in logModelInfo method", t);
            // 最后的尝试：直接记录日志
            try {
                LogUtil.logInfo(info);
            } catch (Exception e) {
                LOGGER.error("Final attempt to log info failed", e);
            }
        }
    }
}