simapi-cj/src/middlewares/SimApiRequestLogMiddleware.cj

/*
 * Copyright (c) 2025 SimcuTeam. All rights reserved.
 * 移植自 C# 项目 SimApi（E:\simcu\simapi-net），遵循 MIT 许可证。
 */

package simapi.middlewares

import std.collection.*
import std.io.*
import std.time.*
import soulsoft_web_http.*
import soulsoft_extensions_logging.*
import simapi_serialization.*
import simapi.communications.*
import simapi.configurations.*
import simapi.helpers.*

/**
 * 请求日志中间件：记录请求方法、URL、请求头、请求体、响应状态码、耗时与异常。
 * 对应 C# 的 SimApi.Middlewares.SimApiRequestLogMiddleware。
 *
 * 对齐说明：
 *   - 请求体按 JSON 字段级截断（对齐 C#：仅对超长字符串字段截断，保留结构）
 *   - 捕获下游异常并记录，随后重抛（对齐 C# ExceptionDispatchInfo + edi.Throw）
 *   - 响应体：soulsoft HttpResponse.body 只读不可替换（C# 用 MemoryStream 替换捕获），
 *     此处以 Content-Length 作为替代信息；ShowFullResponse 选项因此暂不生效
 */
public class SimApiRequestLogMiddleware <: IMiddleware {
    private let _options: SimApiOptions
    private let _logger: ILogger

    public init(options: SimApiOptions, loggerFactory: ILoggerFactory) {
        _options = options
        _logger = loggerFactory.createLogger("SimApi.RequestLog")
    }

    /**
     * 中间件入口（IMiddleware 风格，对齐 C# UseMiddleware<T> 的 InvokeAsync）。
     */
    public func invoke(context: HttpContext, next: RequestDelegate): Unit {
        let start = MonoTime.now()
        let fullUrl = context.request.getDisplayUrl()
        var sb = StringBuilder()

        sb.append("[${context.request.method}] ${fullUrl}\n")

        // 请求头
        if (_options.simApiRequestLogOptions.showFullHeader) {
            sb.append("*( RequestHeaders [Full] ) =>\n")
            sb.append(serializeHeaders(context))
        } else {
            sb.append("*( RequestHeaders ) =>\n")
            let token = context.request.headers.get("Token") ?? ""
            let queryId = context.request.headers.get("Query-Id") ?? ""
            sb.append("Token: ${token}  QueryId: ${queryId}\n")
        }

        // 请求体
        sb.append("*( RequestBody ) =>\n")
        sb.append(readRequestBody(context))

        // 调用下一级，捕获异常以便记录并重抛（对齐 C# ExceptionDispatchInfo）
        var exception: ?Exception = None
        try {
            next(context)
        } catch (ex: Exception) {
            exception = Some(ex)
        }

        // 响应信息
        let elapsed = MonoTime.now() - start
        let elapsedMs = elapsed / Duration.millisecond
        sb.append("*( Response [${context.response.statusCode}] ) => ${elapsedMs}ms")
        // 响应体捕获受 soulsoft 限制（body 只读不可替换），记录 Content-Length 作为替代
        if (let Some(len) <- context.response.contentLength) {
            sb.append("  (响应体长度: ${len})")
        }
        sb.append("\n")
        if (let Some(ex) <- exception) {
            sb.append("Exception: ${ex.toString()}\n")
        }

        _logger.info(sb.toString())

        // 重抛原异常（对齐 C# edi?.Throw()），由外层 ExceptionMiddleware 处理
        if (let Some(ex) <- exception) {
            throw ex
        }
    }

    private func serializeHeaders(context: HttpContext): String {
        var sb = StringBuilder()
        sb.append("{")
        var first = true
        for ((name, values) in context.request.headers) {
            if (!first) { sb.append(",") }
            sb.append("\"${SimApiUtil.escapeJson(name)}\":\"${SimApiUtil.escapeJson(joinValues(values))}\"")
            first = false
        }
        sb.append("}\n")
        sb.toString()
    }

    private func joinValues(values: Collection<String>): String {
        var sb = StringBuilder()
        var first = true
        for (v in values) {
            if (!first) { sb.append(",") }
            sb.append(v)
            first = false
        }
        sb.toString()
    }

    private func readRequestBody(context: HttpContext): String {
        try {
            context.request.enableBuffering()
            var buffer = Array<Byte>(4096, repeat: 0)
            var sb = StringBuilder()
            var read = context.request.body.read(buffer)
            while (read > 0) {
                sb.appendFromUtf8(buffer.slice(0, read))
                read = context.request.body.read(buffer)
            }
            let bodyText = sb.toString()
            // 重置流位置，供后续业务读取；同时缓存 body（流可能不可重读）
            if (let seekable: Seekable <- context.request.body) {
                seekable.seek(SeekPosition.Begin(0))
            }
            context.items["SimApi:BodyCache"] = bodyText
            return truncateBody(bodyText)
        } catch (_: Exception) {
            return "(读取请求体失败)\n"
        }
    }

    /// 请求体截断：JSON 字段级截断（对齐 C#：仅对超长字符串字段截断），非 JSON 则整串截断
    private func truncateBody(body: String): String {
        let maxLen = _options.simApiRequestLogOptions.requestStringLogLength
        if (maxLen <= 0) {
            return body + "\n"
        }
        try {
            // 用 simapi_serialization 解析为动态结构，仅截断超长字符串字段（保持结构）
            let map = JsonSerializer.Deserialize<HashMap<String, Any>>(body)
            var sb = StringBuilder()
            sb.append("{")
            var first = true
            for ((k, v) in map) {
                if (!first) { sb.append(",") }
                sb.append("\"${SimApiUtil.escapeJson(k)}\":")
                if (let s: String <- v) {
                    if (s.size > maxLen) {
                        sb.append("\"${SimApiUtil.escapeJson(s[0..maxLen])}...(${s.size})\"")
                    } else {
                        sb.append("\"${SimApiUtil.escapeJson(s)}\"")
                    }
                } else {
                    sb.append(SimApiUtil.json(Some(v)))
                }
                first = false
            }
            sb.append("}")
            return sb.toString() + "\n"
        } catch (_: Exception) {
        }
        // 非 JSON 或解析失败：整串按长度截断
        if (body.size <= maxLen) {
            return body + "\n"
        }
        return body[0..maxLen] + "...(${body.size})\n"
    }
}