translated all logs to english

cmd/telesrv/log_encoder.go

@@ -0,0 +1,177 @@
+package main
+
+import (
+	"fmt"
+	"strings"
+	"time"
+
+	"go.uber.org/zap/buffer"
+	"go.uber.org/zap/zapcore"
+)
+
+var compactBufferPool = buffer.NewPool()
+
+// compactEncoder renders one readable line per entry: short time, level,
+// logger, message, then "key=value" pairs in call order — instead of zap's
+// stock console encoder, which appends fields as a raw JSON blob and makes
+// high-volume RPC logs unreadable at a glance. It writes fields straight
+// into a pooled buffer.Buffer (no map/interface{} boxing on the hot path),
+// so it stays close to the JSON/console encoders' cost.
+type compactEncoder struct {
+	cfg zapcore.EncoderConfig
+	buf *buffer.Buffer // accumulated fields from Logger.With(...)
+}
+
+func newCompactEncoder(cfg zapcore.EncoderConfig) *compactEncoder {
+	return &compactEncoder{cfg: cfg, buf: compactBufferPool.Get()}
+}
+
+func (e *compactEncoder) Clone() zapcore.Encoder {
+	clone := &compactEncoder{cfg: e.cfg, buf: compactBufferPool.Get()}
+	clone.buf.AppendString(e.buf.String())
+	return clone
+}
+
+func (e *compactEncoder) EncodeEntry(ent zapcore.Entry, fields []zapcore.Field) (*buffer.Buffer, error) {
+	line := compactBufferPool.Get()
+
+	line.AppendString(ent.Time.Format("15:04:05.000"))
+	line.AppendByte(' ')
+
+	lvl := ent.Level.CapitalString()
+	line.AppendString(lvl)
+	for i := len(lvl); i < 5; i++ {
+		line.AppendByte(' ')
+	}
+	line.AppendByte(' ')
+
+	if ent.LoggerName != "" {
+		line.AppendByte('[')
+		line.AppendString(ent.LoggerName)
+		line.AppendString("] ")
+	}
+	line.AppendString(ent.Message)
+
+	if e.buf.Len() > 0 {
+		line.AppendByte(' ')
+		line.AppendString(e.buf.String())
+	}
+
+	if len(fields) > 0 {
+		tmp := &compactEncoder{cfg: e.cfg, buf: compactBufferPool.Get()}
+		for _, f := range fields {
+			f.AddTo(tmp)
+		}
+		if tmp.buf.Len() > 0 {
+			line.AppendByte(' ')
+			line.AppendString(tmp.buf.String())
+		}
+		tmp.buf.Free()
+	}
+
+	if ent.Caller.Defined {
+		line.AppendString("  (")
+		line.AppendString(ent.Caller.TrimmedPath())
+		line.AppendByte(')')
+	}
+
+	if ent.Stack != "" {
+		line.AppendByte('\n')
+		line.AppendString(ent.Stack)
+	}
+
+	line.AppendByte('\n')
+	return line, nil
+}
+
+func (e *compactEncoder) addKey(key string) {
+	if e.buf.Len() > 0 {
+		e.buf.AppendByte(' ')
+	}
+	e.buf.AppendString(key)
+	e.buf.AppendByte('=')
+}
+
+// appendSafeString keeps "key=value value2" pairs unambiguous: values with
+// whitespace, '=' or '"' get quoted, everything else (the vast majority —
+// method names, hex ids, enum-ish strings) is written bare.
+func (e *compactEncoder) appendSafeString(s string) {
+	if s == "" || strings.ContainsAny(s, " \t\n=\"") {
+		e.buf.AppendByte('"')
+		e.buf.AppendString(strings.ReplaceAll(s, `"`, `\"`))
+		e.buf.AppendByte('"')
+		return
+	}
+	e.buf.AppendString(s)
+}
+
+func (e *compactEncoder) AddBool(key string, v bool)       { e.addKey(key); e.buf.AppendBool(v) }
+func (e *compactEncoder) AddInt64(key string, v int64)     { e.addKey(key); e.buf.AppendInt(v) }
+func (e *compactEncoder) AddInt(key string, v int)         { e.AddInt64(key, int64(v)) }
+func (e *compactEncoder) AddInt32(key string, v int32)     { e.AddInt64(key, int64(v)) }
+func (e *compactEncoder) AddInt16(key string, v int16)     { e.AddInt64(key, int64(v)) }
+func (e *compactEncoder) AddInt8(key string, v int8)       { e.AddInt64(key, int64(v)) }
+func (e *compactEncoder) AddUint64(key string, v uint64)   { e.addKey(key); e.buf.AppendUint(v) }
+func (e *compactEncoder) AddUint(key string, v uint)       { e.AddUint64(key, uint64(v)) }
+func (e *compactEncoder) AddUint32(key string, v uint32)   { e.AddUint64(key, uint64(v)) }
+func (e *compactEncoder) AddUint16(key string, v uint16)   { e.AddUint64(key, uint64(v)) }
+func (e *compactEncoder) AddUint8(key string, v uint8)     { e.AddUint64(key, uint64(v)) }
+func (e *compactEncoder) AddUintptr(key string, v uintptr) { e.AddUint64(key, uint64(v)) }
+func (e *compactEncoder) AddFloat64(key string, v float64) { e.addKey(key); e.buf.AppendFloat(v, 64) }
+func (e *compactEncoder) AddFloat32(key string, v float32) {
+	e.addKey(key)
+	e.buf.AppendFloat(float64(v), 32)
+}
+func (e *compactEncoder) AddDuration(key string, v time.Duration) {
+	e.addKey(key)
+	e.buf.AppendString(v.String())
+}
+func (e *compactEncoder) AddTime(key string, v time.Time) {
+	e.addKey(key)
+	e.buf.AppendTime(v, "15:04:05.000")
+}
+func (e *compactEncoder) AddString(key, v string) { e.addKey(key); e.appendSafeString(v) }
+func (e *compactEncoder) AddByteString(key string, v []byte) {
+	e.addKey(key)
+	e.appendSafeString(string(v))
+}
+func (e *compactEncoder) AddBinary(key string, v []byte) { e.addKey(key); fmt.Fprintf(e.buf, "%x", v) }
+func (e *compactEncoder) AddComplex128(key string, v complex128) {
+	e.addKey(key)
+	fmt.Fprintf(e.buf, "%v", v)
+}
+func (e *compactEncoder) AddComplex64(key string, v complex64) { e.AddComplex128(key, complex128(v)) }
+func (e *compactEncoder) AddReflected(key string, v interface{}) error {
+	e.addKey(key)
+	fmt.Fprintf(e.buf, "%v", v)
+	return nil
+}
+
+// OpenNamespace isn't used by any log call in this codebase today; nested
+// fields would just render as flat top-level keys, which is an acceptable
+// degradation for a format whose whole point is staying flat and scannable.
+func (e *compactEncoder) OpenNamespace(string) {}
+
+func (e *compactEncoder) AddArray(key string, m zapcore.ArrayMarshaler) error {
+	tmp := zapcore.NewMapObjectEncoder()
+	if err := tmp.AddArray("v", m); err != nil {
+		e.addKey(key)
+		e.buf.AppendString("!ERROR")
+		return err
+	}
+	e.addKey(key)
+	fmt.Fprintf(e.buf, "%v", tmp.Fields["v"])
+	return nil
+}
+
+func (e *compactEncoder) AddObject(key string, m zapcore.ObjectMarshaler) error {
+	tmp := zapcore.NewMapObjectEncoder()
+	if err := tmp.AddObject("v", m); err != nil {
+		e.addKey(key)
+		e.buf.AppendString("!ERROR")
+		return err
+	}
+	e.addKey(key)
+	fmt.Fprintf(e.buf, "%v", tmp.Fields["v"])
+	return nil
+}