<火山程序 类型 = "通常" 版本 = 1 />

包 火山.程序

类 全部例程 <公开>
{
    方法 添加 <公开 静态>
    {
        例程.所有例程.加入成员 (新建对象 (日志))
        例程.所有例程.加入成员 (新建对象 (结构化日志))
        例程.所有例程.加入成员 (新建对象 (结构化日志替换属性))
        例程.所有例程.加入成员 (新建对象 (结构化日志动态级别))
        例程.所有例程.加入成员 (新建对象 (结构化值接口))
        例程.所有例程.加入成员 (新建对象 (日志切割案例))
    }
}

类 日志切割案例 <基础类 = 例程>
{
    方法 执行 <公开 @虚拟方法 = 可覆盖>
    {
        变量 切割 <类型 = 日志切割类 保存位置 = "logs/app.log" 最大文件尺寸 = 1 旧日志保留文件数量 = 10 旧日志保留最大天数 = 30 压缩旧日志 = 假 使用本地时间 = 真>
        变量 日志 <参考 类型 = 日志类>
        日志 = 日志类.创建 (切割, "火山:", 位或 (日志类.标志_消息前缀, 位或 (日志类.标志_时间, 日志类.标志_微秒)))
        计次循环 (10000)
        {
            日志.换行输出 (取循环索引 (), "这是一条日志信息，这是一条日志信息，这是一条日志信息，这是一条日志信息，这是一条日志信息。")
        }
        变量 切割2 <类型 = 日志切割类 保存位置 = "slogs/app.log" 最大文件尺寸 = 1 旧日志保留文件数量 = 10 旧日志保留最大天数 = 30 压缩旧日志 = 假 使用本地时间 = 真>
        变量 结构化日志 <参考 类型 = 结构化日志类>
        结构化日志 = 结构化日志类.创建 (结构化日志JSON处理程序.创建 (切割2, 空对象))
        结构化日志类.置默认日志 (结构化日志)
        计次循环 (10000)
        {
            结构化日志.输出错误 ("这是一条 错误 级别的日志", "错误", "示例错误")
            结构化日志.输出警告 ("这是一条 警告 级别的日志", "警告", "示例警告！")
            结构化日志.输出信息 ("这是一条 信息 级别的日志", "信息", "示例信息")
        }
    }

    方法 名称 <公开 类型 = 文本型 @虚拟方法 = 可覆盖>
    {
        返回 (取源类名 ())
    }
}

类 日志 <基础类 = 例程>
{
    方法 执行 <公开 折叠 @虚拟方法 = 可覆盖>
    {
        日志类.默认日志 ().输出 ("这是一行日志")
        日志类.默认日志 ().格式输出 ("这是另一行%s", "日志")
        变量 日志 <类型 = 日志类>
        日志 = 日志类.创建 (标准输出 ().写接口, "火山:", 位或 (日志类.标志_消息前缀, 位或 (日志类.标志_时间, 日志类.标志_微秒)))
        日志.换行输出 (123, "abc")
    }

    方法 名称 <公开 类型 = 文本型 @虚拟方法 = 可覆盖>
    {
        返回 (取源类名 ())
    }
}

类 结构化日志 <基础类 = 例程 折叠>
{
    方法 执行 <公开 @虚拟方法 = 可覆盖>
    {
        结构化日志类.默认日志 ().输出信息 ("这是一行信息日志", "a", 100, "b", "文本: abc")
        结构化日志类.默认日志 ().输出调试 ("这是一行日志", "a", 100, "b", "文本: abc")  // 这一行不会输出
        结构化日志类.置默认日志级别 (结构化日志类.级别_调试)
        结构化日志类.默认日志 ().输出调试 ("这是一行调试日志", "a", 100, "b", "文本: abc")
        结构化日志类.默认日志 ().输出信息 ("请求详情", 结构化日志属性类.创建组 ("req", 结构化日志属性类.从文本创建 ("method", "GET"), 结构化日志属性类.从文本创建 ("url", "voldp.com")), 结构化日志属性类.从整数创建 ("status", 200))
        变量 日志 <类型 = 结构化日志类>
        日志 = 结构化日志类.创建 (结构化日志JSON处理程序.创建 (标准输出 ().写接口, 空对象))
        日志.输出错误 ("这是一个错误", "路径", "a/b/c", "值", -1)
    }

    方法 名称 <公开 类型 = 文本型 @虚拟方法 = 可覆盖>
    {
        返回 (取源类名 ())
    }
}

类 结构化日志替换属性 <基础类 = 例程 折叠>
{
    方法 执行 <公开 @虚拟方法 = 可覆盖>
    {
        变量 日志 <类型 = 结构化日志类>
        变量 选项 <类型 = 结构化日志处理程序选项类>
        选项.置替换属性方法 (替换属性)
        日志 = 结构化日志类.创建 (结构化日志文本处理程序.创建 (标准输出 ().写接口, 选项))
        日志.输出错误 ("这是一个错误", "路径", "a/b/c", "值", -1)
    }

    方法 替换属性 <公开 静态 类型 = 结构化日志属性类>
    参数 组名 <类型 = "文本型[]">
    参数 原始属性 <类型 = 结构化日志属性类>
    {
        如果真 (原始属性.关键字 == 结构化日志属性类.关键字_级别)
        {
            如果 (原始属性.值.取 ().取 (结构化日志级别类) == 结构化日志类.级别_信息)
            {
                原始属性.值 = 结构化日志值类.从文本创建 ("信息")
            }
            否则 (原始属性.值.取 ().取 (结构化日志级别类, ) == 结构化日志类.级别_错误)
            {
                原始属性.值 = 结构化日志值类.从文本创建 ("错误")
                // 其他级别依次处理
            }
        }
        返回 (原始属性)
    }

    方法 名称 <公开 类型 = 文本型 @虚拟方法 = 可覆盖>
    {
        返回 (取源类名 ())
    }
}

类 结构化值接口 <基础类 = 例程 折叠>
{
    方法 执行 <公开 @虚拟方法 = 可覆盖>
    {
        结构化日志类.默认日志 ().输出信息 ("图书", "作者", 人员.创建 ("张", "三").值接口 ())
        变量 用户名 <类型 = 文本型>
        变量 密码 <类型 = 密钥>
        用户名 = "abc"
        密码 = 密钥.创建 ("1s23dS3#")
        结构化日志类.默认日志 ().输出信息 ("登录", "用户名", "abc", "密码", 密码.值接口 ())
    }

    方法 名称 <公开 类型 = 文本型 @虚拟方法 = 可覆盖>
    {
        返回 (取源类名 ())
    }
}

类 结构化日志动态级别 <基础类 = 例程>
{
    方法 执行 <公开 @虚拟方法 = 可覆盖>
    {
        变量 日志 <类型 = 结构化日志类>
        变量 级别 <类型 = 结构化日志级别值类>
        变量 选项 <类型 = 结构化日志处理程序选项类>
        选项.级别 = 级别
        日志 = 结构化日志类.创建 (结构化日志文本处理程序.创建 (标准输出 ().写接口, 选项))
        日志.输出调试文本 ("此选项不会被记录,因为默认级别为 信息")
        级别.置级别 (结构化日志类.级别_调试)
        日志.输出调试 ("这是一条日志", "参数", 123)
    }

    方法 名称 <公开 类型 = 文本型 @虚拟方法 = 可覆盖>
    {
        返回 (取源类名 ())
    }
}

类 人员
{
    变量 名 <类型 = 文本型>
    变量 姓 <类型 = 文本型>
    变量 转发器 <类型 = 结构化日志值接口转发器>

    方法 值接口 <公开 类型 = 结构化日志值接口>
    {
        返回 (转发器.结构化日志值接口)
    }

    方法 创建 <公开 静态 类型 = 人员>
    参数 姓参数 <类型 = 文本型>
    参数 名参数 <类型 = 文本型>
    {
        变量 返回值 <类型 = 人员>
        返回值.姓 = 姓参数
        返回值.名 = 名参数
        返回 (返回值)
    }

    方法 结构化日志值接口转发器_取值 <接收事件 类型 = 结构化日志值类>
    参数 来源对象 <类型 = 结构化日志值接口转发器>
    参数 标记值 <类型 = 整数>
    {
        返回 (结构化日志值类.从文本创建 (姓 + 名))
    }
}

类 密钥
{
    变量 文本 <公开 类型 = 文本型>
    变量 转发器 <类型 = 结构化日志值接口转发器>

    方法 值接口 <公开 类型 = 结构化日志值接口>
    {
        返回 (转发器.结构化日志值接口)
    }

    方法 创建 <公开 静态 类型 = 密钥>
    参数 参数 <类型 = 文本型>
    {
        变量 返回值 <类型 = 密钥>
        返回值.文本 = 参数
        返回 (返回值)
    }

    方法 结构化日志值接口转发器_取值 <接收事件 类型 = 结构化日志值类>
    参数 来源对象 <类型 = 结构化日志值接口转发器>
    参数 标记值 <类型 = 整数>
    {
        返回 (结构化日志值类.从文本创建 ("*"))
    }
}
