Go语言企业级日志规范落地：Zap结构化日志+字段分级+采样策略+ELK索引模板（附Logrus迁移checklist）

第一章：Go语言企业级日志规范落地全景概览

企业级Go服务对日志的要求远超调试辅助——它需支撑可观测性体系建设、合规审计追踪、故障根因分析及跨团队协同排查。一个健壮的日志规范不是简单封装log.Printf，而是涵盖结构化输出、上下文传递、分级治理、采样控制、安全脱敏与统一接入等多维度实践。

日志核心设计原则

• 结构化优先：强制使用JSON格式，字段命名遵循snake_case约定（如request_id、http_status_code），避免自由文本解析困难；
• 上下文一致性：通过context.Context注入request_id、trace_id、user_id等关键标识，确保全链路日志可关联；
• 分级精准化：DEBUG仅用于开发环境本地诊断；INFO记录业务关键节点（如订单创建成功）；WARN表示可恢复异常（如第三方API降级）；ERROR必须附带堆栈与可操作建议；
• 零敏感信息泄露：自动过滤password、token、id_card等字段，禁止在日志中拼接原始用户输入。

标准化接入方式

推荐使用uber-go/zap作为基础日志库，并搭配zapcore.AddSync()对接企业日志平台（如ELK或Loki）：

import "go.uber.org/zap"

// 生产环境配置：结构化JSON + 错误堆栈 + 调用位置
cfg := zap.NewProductionConfig()
cfg.EncoderConfig.TimeKey = "timestamp"
cfg.EncoderConfig.EncodeTime = zapcore.ISO8601TimeEncoder
logger, _ := cfg.Build()
defer logger.Sync() // 确保日志刷盘

// 使用示例：自动携带request_id和trace_id
logger.Info("order processed",
    zap.String("request_id", "req-abc123"),
    zap.String("trace_id", "trace-def456"),
    zap.Int64("order_amount_cents", 9990),
    zap.String("currency", "CNY"))

关键治理项对照表

治理维度	合规要求	Go实现要点
日志留存	≥180天	依赖日志平台策略，应用层不管理轮转
敏感字段	全量脱敏	自定义zapcore.Encoder拦截关键词
性能影响		禁用Debug级日志于生产环境，启用异步写入
格式校验	JSON Schema验证	CI阶段集成jq校验日志输出样例

第二章：Zap结构化日志工程化实践

2.1 Zap核心架构解析与高性能日志写入原理

Zap 的高性能源于其零分配（zero-allocation）设计与结构化日志的分层抽象。

核心组件分工

• Logger：无锁、并发安全的入口，缓存字段与编码器配置
• Core：日志逻辑中枢，决定写入路径与格式化策略
• Encoder：支持 jsonEncoder/consoleEncoder，预分配缓冲区避免 GC
• WriteSyncer：封装底层 io.Writer，支持文件轮转与同步刷盘

日志写入流水线

// 示例：同步写入路径关键调用链
func (c *ioCore) Write(entry zapcore.Entry, fields []zapcore.Field) error {
    buf, err := c.enc.EncodeEntry(entry, fields) // 零拷贝序列化
    if err != nil {
        return err
    }
    _, err = c.ws.Write(buf.Bytes()) // 批量写入，非阻塞缓冲
    buf.Free() // 显式归还内存池
    return err
}

buf.Bytes() 返回内部切片视图，避免复制；buf.Free() 触发 sync.Pool 回收，降低 GC 压力。

性能对比（10k 日志/秒）

场景	Zap（JSON）	logrus（JSON）	stdlib
分配次数/条	0	~3	~5
耗时（ns）	240	1180	3900

graph TD
    A[Logger.Info] --> B[Core.CheckLevel]
    B --> C[Encoder.EncodeEntry]
    C --> D[WriteSyncer.Write]
    D --> E[fsync?]

2.2 结构化字段建模：业务上下文、请求链路与资源标识的Go struct映射实践

在微服务调用中，结构化字段需承载三重语义：业务意图（如 OrderType）、链路追踪（如 TraceID）和资源定位（如 ResourceKey）。直接使用 map[string]interface{} 削弱类型安全与可维护性。

核心 struct 设计原则

• 单一职责：每个 struct 仅表达一类上下文
• 嵌套组合：通过匿名字段复用通用元数据
• 零值友好：关键字段设为指针或带默认标签

示例：订单创建请求上下文

type OrderCreateContext struct {
    BizContext `json:",inline"` // 业务上下文（租户、渠道等）
    TraceInfo  `json:",inline"` // 请求链路（TraceID, SpanID, ParentSpanID）
    ResourceID string `json:"resource_id" validate:"required"` // 资源标识（全局唯一）
}

type BizContext struct {
    TenantID   string `json:"tenant_id"`
    Channel    string `json:"channel"`
    Locale     string `json:"locale"`
}

type TraceInfo struct {
    TraceID     string `json:"trace_id"`
    SpanID      string `json:"span_id"`
    ParentSpanID string `json:"parent_span_id"`
}

该设计将业务语义、分布式追踪与资源寻址解耦又聚合。json:",inline" 实现扁平化序列化，避免嵌套键（如 biz_context.tenant_id），同时保留结构可读性与 IDE 自动补全能力。ResourceID 作为顶层字段，强调其在路由与幂等性校验中的核心地位。

字段	类型	作用	是否必填
TenantID	string	多租户隔离	是
TraceID	string	全链路日志关联	是
ResourceID	string	幂等键 & 存储分片依据	是

graph TD
    A[HTTP Request] --> B[Bind OrderCreateContext]
    B --> C{Validate Required Fields}
    C -->|OK| D[Forward to Service]
    C -->|Fail| E[Return 400]

2.3 零分配日志构造：UnsafeString、预分配Buffer与sync.Pool在Zap Encoder中的实战优化

Zap 的高性能核心在于避免堆分配。其 Encoder 通过三重机制实现零分配日志序列化：

UnsafeString：字节切片到字符串的零拷贝转换

func unsafeString(b []byte) string {
    return *(*string)(unsafe.Pointer(&struct {
        data *byte
        len  int
    }{&b[0], len(b)}))
}

该转换绕过 runtime 字符串构造逻辑，不触发 GC；前提是 b 生命周期长于返回字符串，Zap 通过 sync.Pool 确保 b 复用安全。

预分配 Buffer + sync.Pool 协同

组件	作用	生命周期管理
bufferPool	复用 []byte 缓冲区	Get()/Put() 显式回收
encoder.buf	指向池中 buffer 的指针	仅在 encode 方法内有效

graph TD
    A[EncodeEntry] --> B[Get buffer from sync.Pool]
    B --> C[Write JSON fields directly to buf]
    C --> D[unsafeString(buf.Bytes())]
    D --> E[Return string to caller]
    E --> F[Put buffer back to pool]

关键路径全程无 new、无 append（预扩容）、无字符串拼接——这才是 Zap μs 级日志延迟的底层契约。

2.4 多输出目标协同：文件轮转+网络Hook+Stderr分级路由的Zap Core定制开发

Zap 的 Core 接口是日志分发的核心枢纽。我们通过组合 io.MultiWriter、自定义 WriteSyncer 与 LevelEnablerFunc，实现三路协同输出：

分级路由策略

• Error 级日志同步写入 stderr 并触发 Webhook
• Info 及以上写入按天轮转的文件（lumberjack.Logger）
• Debug 级仅存档，不推送网络端点

自定义 Core 实现

func NewMultiOutputCore() zapcore.Core {
  fileSyncer := zapcore.AddSync(&lumberjack.Logger{
    Filename:   "/var/log/app.log",
    MaxSize:    100, // MB
    MaxBackups: 7,
    MaxAge:     28,  // days
  })
  hookSyncer := &WebhookSyncer{URL: "https://log-hook.example.com"}
  stderrSyncer := zapcore.Lock(os.Stderr)

  return zapcore.NewTee(
    zapcore.NewCore(encoder, fileSyncer, zapcore.InfoLevel),
    zapcore.NewCore(encoder, hookSyncer, zapcore.ErrorLevel),
    zapcore.NewCore(encoder, stderrSyncer, func(lvl zapcore.Level) bool {
      return lvl >= zapcore.ErrorLevel
    }),
  )
}

该实现利用 zapcore.NewTee 并行分发日志；WebhookSyncer 需实现 Write 方法异步 POST；stderr 路由通过闭包函数动态启用，避免低级别日志污染终端。

输出目标	触发级别	同步性	持久化
文件轮转	Info+	同步	✅
Webhook	Error+	异步	❌
Stderr	Error+	同步	❌

graph TD
  A[Log Entry] --> B{Level Check}
  B -->|≥Error| C[Stderr]
  B -->|≥Error| D[Webhook]
  B -->|≥Info| E[Rotating File]

2.5 日志生命周期治理：从初始化配置到Shutdown优雅退出的Go Module级封装

核心设计原则

• 单例可配置：全局日志实例由 logrus 封装，支持运行时重载
• 资源自治：日志写入器（如 rotatelogs）与 sync.Once 配合确保初始化幂等
• 退出同步：通过 sync.WaitGroup 等待异步刷盘完成，避免 os.Exit 截断

初始化与优雅关闭示例

var (
    logger *logrus.Logger
    once   sync.Once
    wg     sync.WaitGroup
)

func Init(cfg LogConfig) {
    once.Do(func() {
        logger = logrus.New()
        logger.SetFormatter(&logrus.JSONFormatter{})
        logger.SetLevel(logrus.Level(cfg.Level))

        // 添加带缓冲的轮转文件写入器
        hook, _ := rotatelogs.New(
            cfg.Path+".%Y%m%d",
            rotatelogs.WithMaxAge(7*24*time.Hour),
            rotatelogs.WithRotationCount(30),
        )
        logger.AddHook(hook)
    })
}

func Shutdown() {
    wg.Add(1)
    go func() {
        defer wg.Done()
        logger.Out.(*rotatelogs.RotateLogs).Close() // 触发 flush & close
    }()
    wg.Wait()
}

逻辑分析：Init 使用 sync.Once 保证仅初始化一次；rotatelogs 的 WithMaxAge 控制日志保留时长，WithRotationCount 限制历史文件数量。Shutdown 中显式调用 Close() 触发底层 Flush()，确保缓冲日志落盘。

生命周期状态流转

graph TD
    A[New Logger] --> B[Configure Formatter/Level]
    B --> C[Attach Rotating Hook]
    C --> D[Accept Log Entries]
    D --> E[Shutdown: Close Hook]
    E --> F[Wait for Flush Completion]

阶段	关键动作	安全边界
初始化	Once.Do + Hook 注册	防止并发重复配置
运行中	异步写入 + 内存缓冲	降低主线程阻塞风险
退出前	hook.Close() + wg.Wait()	避免日志丢失或 panic

第三章：字段分级与语义化日志设计

3.1 四级字段分类法：Trace/Debug/Info/Warn/Error字段语义边界与Go标签驱动注入

日志级别不是粒度越细越好，而是需严格遵循语义契约。Trace用于链路追踪起点，Debug仅限开发调试，Info表征正常业务流转，Warn暗示潜在风险但不中断流程，Error则标识已发生的故障。

字段语义边界对照表

级别	触发场景	是否默认采集	可否结构化字段
Trace	RPC入口、Span ID生成点	否	是
Debug	内部状态快照（如缓存命中率）	否	是
Info	订单创建、支付成功	是	是
Warn	库存预占失败但降级成功	是	是
Error	DB连接超时、panic堆栈	是	必须含error字段

type OrderEvent struct {
    ID     string `json:"id" log:"info"`          // Info级必采字段
    Status string `json:"status" log:"warn,error"` // Warn/Error双级覆盖
    Err    error  `json:"err,omitempty" log:"error"` // Error级专属注入
}

该结构体通过log标签声明字段所属日志级别，运行时由logrus或zerolog的自定义Hook解析并路由至对应通道。log:"warn,error"表示该字段在Warn和Error日志中均被序列化，避免重复定义。

标签驱动注入流程

graph TD
    A[结构体实例] --> B{解析log标签}
    B --> C[按级别分组字段]
    C --> D[构建Level-Scoped Map]
    D --> E[注入到对应日志Entry]

3.2 上下文字段自动注入：基于context.Context与http.Request中间件的Go反射+interface{}安全序列化

核心设计原则

• 零侵入：不修改业务 handler 签名，仅依赖 http.Handler 接口；
• 类型安全：通过 interface{} 动态绑定 + 反射校验字段可导出性与标签；
• 上下文隔离：所有注入字段均挂载至 request.Context()，避免 request 对象污染。

安全序列化流程

func InjectContextFields(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        // 从 middleware 配置中提取需注入的结构体实例（如 AuthInfo、TraceID）
        ctx := r.Context()
        inj := &AuthInfo{UserID: "u-123", Role: "admin"}

        // 利用反射遍历字段，按 `ctx:"key"` 标签注入到 context
        v := reflect.ValueOf(inj).Elem()
        t := reflect.TypeOf(inj).Elem()
        for i := 0; i < v.NumField(); i++ {
            field := t.Field(i)
            if key := field.Tag.Get("ctx"); key != "" {
                ctx = context.WithValue(ctx, ctxKey(key), v.Field(i).Interface())
            }
        }

        next.ServeHTTP(w, r.WithContext(ctx))
    })
}

逻辑分析：该中间件在请求进入时，将标注 ctx:"user_id" 的字段值以 context.WithValue 方式注入。ctxKey 是自定义类型（非 string），防止 key 冲突；v.Field(i).Interface() 保证只传递可序列化的基础值或指针，规避 reflect.Value 泄露风险。

支持的字段标签对照表

字段类型	示例声明	注入 Key	是否支持嵌套
string	UserID stringctx:”user_id”` |“user_id”`	❌
int64	RequestID int64ctx:”req_id”` |“req_id”`	❌
time.Time	CreatedAt time.Timectx:”created_at”` |“created_at”| ✅（经fmt.String()` 序列化）

数据同步机制

graph TD
    A[HTTP Request] --> B[InjectContextFields Middleware]
    B --> C{反射解析 struct 标签}
    C --> D[context.WithValue 注入]
    D --> E[Handler 获取 ctx.Value]
    E --> F[类型断言安全解包]

3.3 敏感字段动态脱敏：基于正则规则与Go AST分析器的日志字段内容过滤器开发

设计目标

在日志采集链路中，需在不修改业务代码的前提下，自动识别并脱敏结构化日志中的敏感字段（如 id_card、phone、email），兼顾性能与可维护性。

核心架构

// LogFieldFilter 通过AST扫描+正则匹配双模态识别敏感字段
type LogFieldFilter struct {
    rules map[string]*regexp.Regexp // 字段名正则规则（如 `^id_card$|^phone.*`）
    ast   *ast.Package              // 编译期注入的AST快照，用于定位结构体定义
}

该结构体将运行时字段名匹配（轻量）与编译期结构体语义分析（精准）结合：rules 实现快速兜底，ast 支持嵌套字段路径推导（如 User.Profile.Phone）。

脱敏策略对照表

字段类型	正则模式	脱敏方式	示例输入	输出
手机号	\b1[3-9]\d{9}\b	138****1234	"13812345678"	"138****1234"
身份证	\b\d{17}[\dxX]\b	110101****12345678	"110101199003072318"	"110101****12345678"

AST分析流程

graph TD
    A[解析源码AST] --> B[提取所有struct定义]
    B --> C[递归遍历字段Tag]
    C --> D[匹配`json:"phone,omitempty"`等标签]
    D --> E[生成字段路径索引]

第四章：采样策略与ELK索引协同治理

4.1 动态采样算法实现：基于QPS阈值与错误率滑动窗口的Go rate.Limiter集成方案

核心设计思想

将请求速率（QPS）与错误率解耦监控，通过双滑动窗口协同决策：一个统计最近60秒请求数（qpsWindow），另一个记录同周期内失败响应（errWindow），动态计算采样率。

关键参数配置

• baseSampleRate: 基础采样率（默认 1.0）
• qpsThreshold: QPS 上限阈值（如 100）
• errorRateThreshold: 错误率熔断阈值（如 0.15）
• windowSize: 滑动窗口秒数（固定 60）

动态采样逻辑

func (d *DynamicSampler) ShouldSample() bool {
    qps := float64(d.qpsWindow.Sum()) / 60.0
    errRate := float64(d.errWindow.Sum()) / float64(d.qpsWindow.Sum()+1)

    if qps > d.qpsThreshold && errRate > d.errorRateThreshold {
        return rand.Float64() < math.Max(0.01, 1.0-qps/d.qpsThreshold)
    }
    return true // 默认全量采样
}

逻辑分析：当QPS超限且错误率超标时，按反比衰减采样率；分母加1避免除零；下限设为1%，保障可观测性。

决策流程图

graph TD
    A[开始] --> B{QPS > 阈值?}
    B -->|否| C[全量采样]
    B -->|是| D{错误率 > 阈值?}
    D -->|否| C
    D -->|是| E[按 1-QPS/阈值 动态降采样]
    E --> F[返回布尔结果]

性能对比（单位：μs/op）

方案	平均延迟	CPU开销	窗口更新成本
固定rate.Limiter	12.3	低	无
双窗口动态采样	48.7	中	每秒2次原子操作

4.2 分布式TraceID关联采样：OpenTelemetry SpanContext与Zap Fields双向绑定的Go SDK扩展

核心设计目标

实现跨组件调用链中 trace_id、span_id 与结构化日志字段的零拷贝同步，避免手动注入/提取。

双向绑定机制

• 自动从 context.Context 提取 SpanContext 并注入 zap.Fields
• 日志写入时反向将 zap.String("trace_id", ...) 注入当前 span 的 SetAttributes

关键代码实现

func ZapSpanHook() zapcore.Core {
    return zapcore.WrapCore(func(ctx context.Context, entry zapcore.Entry) *zapcore.Entry {
        if span := trace.SpanFromContext(ctx); span != nil {
            sc := span.SpanContext()
            entry = entry.With(
                zap.String("trace_id", sc.TraceID().String()),
                zap.String("span_id", sc.SpanID().String()),
                zap.Bool("trace_sampled", sc.IsSampled()),
            )
        }
        return &entry
    })
}

该 hook 在日志写入前动态注入 trace 上下文；sc.TraceID().String() 返回 32 字符十六进制字符串，sc.IsSampled() 对应 OpenTelemetry 采样决策结果。

支持的字段映射表

Zap Field	OTel Source	类型
trace_id	SpanContext.TraceID	string
span_id	SpanContext.SpanID	string
trace_flags	SpanContext.TraceFlags	uint8

graph TD
    A[HTTP Handler] --> B[StartSpan]
    B --> C[Context with Span]
    C --> D[Zap Logger with Hook]
    D --> E[Log Entry + Trace Fields]
    E --> F[Export to OTLP Collector]

4.3 ELK索引模板自动化生成：Go脚本驱动ES Index Template DSL定义与版本灰度发布机制

模板DSL抽象设计

采用Go结构体映射Elasticsearch Index Template DSL，支持动态字段策略、生命周期配置与多版本别名绑定：

type IndexTemplate struct {
    Name     string            `json:"name"`
    Pattern  []string          `json:"index_patterns"`
    Version  int               `json:"version"`
    Settings map[string]any    `json:"settings"`
    Mappings map[string]any    `json:"mappings"`
    Aliases  map[string]map[string]any `json:"aliases"`
}

该结构体直接序列化为ES v7+兼容的JSON模板；Version字段用于灰度路由判断，Aliases支持{"logs-v2": {"is_write_index": true}}语义。

灰度发布流程

通过template_version路由标签控制流量切分：

graph TD
    A[新模板v3生成] --> B{灰度比例=10%}
    B -->|true| C[写入v3索引+别名logs-write]
    B -->|false| D[继续写入v2索引]
    C & D --> E[查询聚合所有别名]

自动化执行链

• Go脚本校验DSL语法并注入环境变量（如cluster_env=prod）
• 调用ES API PUT /_index_template/logs-template-v3
• 原子性更新别名指向（logs-write → logs-v3）

阶段	检查项	工具
构建	字段类型一致性	go-jsonschema
部署	模板版本冲突	ES _cat/templates
回滚	别名恢复时效性	curl -X POST .../logs-write/_alias/logs-v2

4.4 日志爆炸防护：基于采样率反馈闭环的Go goroutine监控+自适应限流控制器

当高并发服务遭遇突发流量，未加节制的日志写入常引发I/O阻塞与goroutine堆积。传统固定采样率（如 log.WithField("sample_rate", 0.01)）无法应对动态负载变化。

核心设计：双环反馈控制

• 内环：实时采集 runtime.NumGoroutine() 与日志写入延迟（P99 > 50ms 触发预警）
• 外环：基于 PID 算法动态调节采样率 r ∈ [0.001, 0.1]

func updateSampleRate() {
  err := pidController.Update(
    float64(runtime.NumGoroutine()),
    targetGoroutines, // 设定阈值（如 800）
  )
  if err == nil {
    logSampler.SetRate(math.Max(0.001, math.Min(0.1, pidController.Output())))
  }
}

逻辑说明：pidController 每秒调用一次，输出为采样率增量；SetRate 原子更新全局采样器；边界截断确保日志仍具可观测性。

限流策略协同表

指标状态	采样率调整	goroutine 动作
P99延迟	+5%	允许新日志goroutine
P99延迟 > 100ms	-30%	拒绝非ERROR级日志协程

graph TD
  A[采集NumGoroutine/P99延迟] --> B{PID控制器}
  B --> C[计算新采样率r]
  C --> D[更新logSampler.rate]
  D --> E[日志写入协程按r概率执行]

第五章：Logrus迁移checklist与演进路线图

迁移前必备检查项

• 确认当前所有日志调用均通过 logrus.WithFields() 或 logrus.WithError() 显式构造上下文，避免直接使用全局 logrus 实例（如 logrus.Info()）；
• 审计代码中是否存在 logrus.SetOutput()、logrus.SetLevel() 等全局配置调用，需统一收口至初始化模块；
• 检查第三方库（如 gin-contrib/logger、gorm 日志适配器）是否兼容 Logrus v1.9+，特别注意 logrus.Entry 方法签名变更（例如 WithError(err) 返回新 Entry 而非链式修改原实例）；
• 验证结构化日志字段命名规范：禁止使用空格、点号或大驼峰（如 "user_id" ✅，"userId" ❌，"user.id" ❌），统一采用 snake_case 以适配 ELK 或 Loki 的字段解析逻辑。

兼容性风险高发场景

以下代码片段在迁移后将失效，必须重构：

// ❌ 错误示例：Logrus v1.8 之前允许的隐式字段继承
logrus.WithField("service", "api").Info("request start")
logrus.Info("request end") // 此处不会继承 service 字段

// ✅ 正确写法：显式传递 Entry 或使用 WithContext + context.WithValue
entry := logrus.WithField("service", "api")
entry.Info("request start")
entry.Info("request end")

分阶段迁移执行表

阶段	目标	关键动作	验证方式
Phase 0（冻结）	停止新增 logrus. 全局调用	在 CI 中添加 grep -r "logrus\." ./cmd/ ./internal/ --exclude-dir=vendor | grep -v "WithField\|WithError" 检查	扫描结果为零
Phase 1（封装）	将 logrus.Entry 封装为应用级 Logger 接口	定义 type Logger interface { Info(msg string, fields ...Field) } 并实现 wrapper	单元测试覆盖所有日志方法调用路径
Phase 2（替换）	替换 github.com/sirupsen/logrus 为 github.com/sirupsen/logrus/v2（如启用）	更新 go.mod 并修复 logrus.Formatter 接口变更（Format(*Entry) ([]byte, error) → Format(*Entry) (string, error)）	日志输出格式无乱码、时间戳精度保持毫秒级

生产环境灰度验证流程

graph TD
    A[上线新日志模块] --> B{日志采样率 1%}
    B -->|成功| C[对比旧日志字段完整性]
    B -->|失败| D[回滚至 v1.9.3 并记录 panic stack]
    C --> E[提升采样至 100%]
    E --> F[监控 Loki 查询延迟 & 字段提取成功率]
    F -->|>99.95%| G[全量发布]

字段标准化强制策略

在 NewLogger() 初始化时注入校验中间件：

func validateFields(entry *logrus.Entry) {
    for key := range entry.Data {
        if strings.ContainsAny(key, ". ") || !strings.EqualFold(key, strings.ToLower(key)) {
            panic(fmt.Sprintf("invalid log field: %s (must be lowercase snake_case)", key))
        }
    }
}

该策略已在支付核心服务落地，拦截 17 处历史遗留 UserID、http_status 等不合规字段。

运维协同事项

• 提前向 SRE 团队同步日志格式变更：level 字段值由 info 统一转为 INFO（大写），time 字段从 RFC3339Nano 改为 ISO8601 标准（2024-06-15T08:30:45.123Z）；
• 更新 Fluent Bit 配置文件中的 parser 规则，新增 Regex ^(?P<time>[^ ]+) (?P<level>[A-Z]+) (?P<msg>.*)$；
• 向 Grafana Loki 数据源注入 | json | line_format "{{.level}} {{.service}} {{.msg}}" 测试模板。