You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
316 lines
10 KiB
316 lines
10 KiB
package log_test
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"fmt"
|
|
"math"
|
|
"os"
|
|
"sync/atomic"
|
|
"time"
|
|
|
|
"gitoa.ru/go-4devs/log"
|
|
"gitoa.ru/go-4devs/log/entry"
|
|
"gitoa.ru/go-4devs/log/field"
|
|
"gitoa.ru/go-4devs/log/level"
|
|
)
|
|
|
|
var ctx = context.Background()
|
|
|
|
func setStdout() {
|
|
// set stout for example by default stderror
|
|
log.SetLogger(log.New(log.WithStdout()).With(log.WithLevel(log.KeyLevel, level.Debug)))
|
|
}
|
|
|
|
func ExampleNew() {
|
|
logger := log.New(log.WithStdout())
|
|
logger.Info(ctx, "same message")
|
|
// Output: msg="same message"
|
|
}
|
|
|
|
func ExampleInfo() {
|
|
setStdout()
|
|
log.Info(ctx, "same message")
|
|
// Output: msg="same message" level=info
|
|
}
|
|
|
|
func ExampleErrKV() {
|
|
setStdout()
|
|
log.ErrKVs(ctx, "same message", "key", "addition value")
|
|
// Output: msg="same message" key="addition value" level=error
|
|
}
|
|
|
|
func ExampleNew_errf() {
|
|
logger := log.New(log.WithStdout())
|
|
logger.Errf(ctx, "same message %d", 1)
|
|
// Output: msg="same message 1"
|
|
}
|
|
|
|
func ExampleNew_debugKV() {
|
|
logger := log.New(log.WithStdout()).With(log.WithLevel(log.KeyLevel, level.Debug))
|
|
logger.DebugKVs(ctx, "same message", "error", os.ErrNotExist)
|
|
// Output: msg="same message" error="file does not exist" level=debug
|
|
}
|
|
|
|
func ExampleNew_level() {
|
|
logger := log.New(log.WithStdout()).With(log.WithLevel(log.KeyLevel, level.Error))
|
|
logger.Err(ctx, "same error message")
|
|
// Output: msg="same error message" level=error
|
|
}
|
|
|
|
func ExampleNew_level_info() {
|
|
logger := log.New(log.WithStdout()).With(log.WithLevel(log.KeyLevel, level.Error))
|
|
logger.Info(ctx, "same message")
|
|
// Output:
|
|
}
|
|
|
|
type Obj struct {
|
|
Name string
|
|
IsEnable bool
|
|
}
|
|
|
|
var (
|
|
obj = Obj{
|
|
Name: "test obj",
|
|
}
|
|
|
|
str = "test str"
|
|
boolsVal = true
|
|
intVal = int(math.MaxInt)
|
|
int8Val = int8(math.MaxInt8)
|
|
int16Val = int16(math.MaxInt16)
|
|
int32Val = int32(math.MaxInt32)
|
|
int64Val = int64(math.MaxInt64)
|
|
|
|
uintVal = uint(math.MaxUint)
|
|
uint8Val = uint8(math.MaxUint8)
|
|
uint16Val = uint16(math.MaxInt16)
|
|
uint32Val = uint32(math.MaxInt32)
|
|
uint64Val = uint64(math.MaxInt64)
|
|
|
|
float32Val = float32(math.MaxFloat32)
|
|
float64Val = float64(math.MaxFloat64)
|
|
|
|
minute = time.Minute
|
|
timeVal = time.Unix(0, math.MaxInt32).In(time.UTC)
|
|
)
|
|
|
|
func ExampleNew_anyField() {
|
|
logger := log.New(log.WithStdout(), log.WithJSONFormat())
|
|
logger.InfoKV(ctx, "any info message",
|
|
field.Any("obj", Obj{Name: "obj name"}),
|
|
field.Any("obj", &obj),
|
|
field.Any("int", intVal),
|
|
field.Any("uint", uintVal),
|
|
field.Any("float", float64Val),
|
|
field.Any("time", timeVal),
|
|
field.Any("duration", time.Hour),
|
|
field.Any("error", errors.New("error")),
|
|
)
|
|
// Output:
|
|
// {"msg":"any info message","obj":{"Name":"obj name","IsEnable":false},"obj":{"Name":"test obj","IsEnable":false},"int":9223372036854775807,"uint":18446744073709551615,"float":1.7976931348623157e+308,"time":"1970-01-01T00:00:02Z","duration":"1h0m0s","error":"error"}
|
|
}
|
|
|
|
func ExampleNew_arrayField() {
|
|
logger := log.New(log.WithStdout(), log.WithJSONFormat())
|
|
logger.InfoKV(ctx, "array info message",
|
|
field.Strings("strings", "string", str),
|
|
field.Bools("bools", true, false),
|
|
field.Ints("ints", 42, 24),
|
|
field.Int8s("int8s", 42, 24),
|
|
field.Int16s("int16s", 42, 24),
|
|
field.Int32s("int32s", 42, 24),
|
|
field.Int64s("int64s", 42, 24),
|
|
field.Uint8s("uint8s", uint8Val, 0),
|
|
field.Uint16s("uint16s", 42, 24),
|
|
field.Uint32s("uint32s", 42, 24),
|
|
field.Uint64s("uint64s", 42, 24),
|
|
field.Float32s("float32s", 42, 24),
|
|
field.Float64s("float64s", 42, 24),
|
|
field.Complex64s("complex64s", 42, 24),
|
|
field.Complex128s("complex128s", 42, 24),
|
|
field.Durations("durations", time.Minute, time.Second),
|
|
field.Times("times", time.Unix(0, 42).In(time.UTC), time.Unix(0, 24).In(time.UTC)),
|
|
field.Errors("errors", errors.New("error"), errors.New("error2")),
|
|
)
|
|
// Output:
|
|
// {"msg":"array info message","strings":["string","test str"],"bools":[true,false],"ints":[42,24],"int8s":[42,24],"int16s":[42,24],"int32s":[42,24],"int64s":[42,24],"uint8s":[255,0],"uint16s":[42,24],"uint32s":[42,24],"uint64s":[42,24],"float32s":[42,24],"float64s":[42,24],"complex64s":["(42+0i)","(24+0i)"],"complex128s":["(42+0i)","(24+0i)"],"durations":["1m0s","1s"],"times":["1970-01-01T00:00:00Z","1970-01-01T00:00:00Z"],"errors":["error","error2"]}
|
|
}
|
|
|
|
func ExampleNew_pointerField() {
|
|
logger := log.New(log.WithStdout(), log.WithJSONFormat())
|
|
logger.InfoKV(ctx, "pointer info message",
|
|
field.Stringp("stringp", &str),
|
|
field.Stringp("stringp", nil),
|
|
field.Boolp("boolp", &boolsVal),
|
|
field.Boolp("boolp", nil),
|
|
field.Intp("intp", &intVal),
|
|
field.Intp("intp", nil),
|
|
field.Int8p("int8p", &int8Val),
|
|
field.Int8p("int8p", nil),
|
|
field.Int16p("int16p", &int16Val),
|
|
field.Int16p("int16p", nil),
|
|
field.Int32p("int32p", &int32Val),
|
|
field.Int32p("int32p", nil),
|
|
field.Int64p("int64p", &int64Val),
|
|
field.Int64p("int64p", nil),
|
|
field.Uintp("uintp", &uintVal),
|
|
field.Uintp("uintp", nil),
|
|
field.Uint8p("uint8p", &uint8Val),
|
|
field.Uint8p("uint8p", nil),
|
|
field.Uint16p("uint16p", &uint16Val),
|
|
field.Uint16p("uint16p", nil),
|
|
field.Uint32p("uint32p", &uint32Val),
|
|
field.Uint32p("uint32p", nil),
|
|
field.Uint64p("uint64p", &uint64Val),
|
|
field.Uint64p("uint64p", nil),
|
|
field.Float32p("float32p", &float32Val),
|
|
field.Float32p("float32p", nil),
|
|
field.Float64p("float64p", &float64Val),
|
|
field.Float64p("float64p", nil),
|
|
field.Durationp("durationp", &minute),
|
|
field.Durationp("durationp", nil),
|
|
field.Timep("timep", &timeVal),
|
|
field.Timep("timep", nil),
|
|
)
|
|
// Output:
|
|
// {"msg":"pointer info message","stringp":"test str","stringp":null,"boolp":true,"boolp":null,"intp":9223372036854775807,"intp":null,"int8p":127,"int8p":null,"int16p":32767,"int16p":null,"int32p":2147483647,"int32p":null,"int64p":9223372036854775807,"int64p":null,"uintp":18446744073709551615,"uintp":null,"uint8p":255,"uint8p":null,"uint16p":32767,"uint16p":null,"uint32p":2147483647,"uint32p":null,"uint64p":9223372036854775807,"uint64p":null,"float32p":3.4028235e+38,"float32p":null,"float64p":1.7976931348623157e+308,"float64p":null,"durationp":"1m0s","durationp":null,"timep":"1970-01-01T00:00:02Z","timep":null}
|
|
}
|
|
|
|
func ExampleNew_fields() {
|
|
logger := log.New(log.WithStdout(), log.WithJSONFormat())
|
|
logger.InfoKV(ctx, "info message",
|
|
field.String("string", str),
|
|
field.Bool("bool", true),
|
|
field.Int("int", 42),
|
|
field.Int8("int8", 42),
|
|
field.Int16("int16", 42),
|
|
field.Int32("int32", 42),
|
|
field.Int64("int64", 42),
|
|
field.Uint8("uint8", uint8Val),
|
|
field.Uint16("uint16", 42),
|
|
field.Uint32("uint32", 42),
|
|
field.Uint64("uint64", 42),
|
|
field.Float32("float32", 42),
|
|
field.Float64("float64", 42),
|
|
field.Complex64("complex16", 42),
|
|
field.Complex128("complex128", 42),
|
|
field.Duration("duration", time.Minute),
|
|
field.Time("time", timeVal),
|
|
field.FormatTime("format_time", time.UnixDate, timeVal),
|
|
field.Error("error", errors.New("error")),
|
|
)
|
|
// Output:
|
|
// {"msg":"info message","string":"test str","bool":true,"int":42,"int8":42,"int16":42,"int32":42,"int64":42,"uint8":255,"uint16":42,"uint32":42,"uint64":42,"float32":42,"float64":42,"complex16":"(42+0i)","complex128":"(42+0i)","duration":"1m0s","time":"1970-01-01T00:00:02Z","format_time":"Thu Jan 1 00:00:02 UTC 1970","error":"error"}
|
|
}
|
|
|
|
func ExampleNew_jsonFormat() {
|
|
logger := log.New(log.WithStdout(), log.WithJSONFormat()).
|
|
With(
|
|
log.WithLevel(log.KeyLevel, level.Debug),
|
|
log.GoVersion("go-version"),
|
|
)
|
|
logger.Err(ctx, "same error message")
|
|
logger.WarnKVs(ctx, "same warn message", "obj", Obj{Name: "obj name"})
|
|
// Output:
|
|
// {"msg":"same error message","level":"error","go-version":"go1.22.2"}
|
|
// {"msg":"same warn message","obj":{"Name":"obj name","IsEnable":false},"level":"warning","go-version":"go1.22.2"}
|
|
}
|
|
|
|
func ExampleNew_textEncoding() {
|
|
logger := log.New(log.WithStdout()).
|
|
With(
|
|
log.WithLevel(log.KeyLevel, level.Debug),
|
|
log.GoVersion("go-version"),
|
|
)
|
|
logger.Err(ctx, "same error message")
|
|
logger.InfoKVs(ctx, "same info message", "api-version", 0.1, "obj", Obj{Name: "text value", IsEnable: true})
|
|
|
|
// Output:
|
|
// msg="same error message" level=error go-version=go1.22.2
|
|
// msg="same info message" api-version=0.1 obj={Name:text value IsEnable:true} level=info go-version=go1.22.2
|
|
}
|
|
|
|
type ctxKey string
|
|
|
|
func (c ctxKey) String() string {
|
|
return string(c)
|
|
}
|
|
|
|
func levelInfo(ctx context.Context, entry *entry.Entry, handler log.Logger) (int, error) {
|
|
return handler(ctx, entry.Add(field.String(log.KeyLevel, entry.Level().String())))
|
|
}
|
|
|
|
func ExampleWith() {
|
|
var requestID ctxKey = "requestID"
|
|
vctx := context.WithValue(ctx, requestID, "6a5fa048-7181-11ea-bc55-0242ac130003")
|
|
|
|
logger := log.New(log.WithStdout()).With(
|
|
levelInfo,
|
|
log.WithContextValue(requestID),
|
|
log.KeyValue("api", "0.1.0"),
|
|
log.GoVersion("go"),
|
|
)
|
|
logger.Info(vctx, "same message")
|
|
// Output: msg="same message" level=info requestID=6a5fa048-7181-11ea-bc55-0242ac130003 api=0.1.0 go=go1.22.2
|
|
}
|
|
|
|
func ExampleLogger_Print() {
|
|
logger := log.New(log.WithStdout()).With(
|
|
levelInfo,
|
|
log.KeyValue("client", "http"),
|
|
log.KeyValue("api", "0.1.0"),
|
|
log.GoVersion("go"),
|
|
)
|
|
logger.Print("same message")
|
|
// Output: msg="same message" level=info client=http api=0.1.0 go=go1.22.2
|
|
}
|
|
|
|
func ExamplePrint() {
|
|
setStdout()
|
|
log.Print("same message")
|
|
// Output: msg="same message" level=info
|
|
}
|
|
|
|
func Example_fieldClosureFn() {
|
|
cnt := int32(0)
|
|
closure := field.ClosureFn(func() any {
|
|
d := fmt.Sprintf("additional error data: %d", cnt)
|
|
atomic.AddInt32(&cnt, 1)
|
|
|
|
return d
|
|
})
|
|
|
|
log := log.New(log.WithStdout()).With(log.WithLevel(log.KeyLevel, level.Info))
|
|
|
|
log.DebugKVs(ctx, "debug message", "data", closure)
|
|
log.ErrKVs(ctx, "error message", "err", closure)
|
|
log.WarnKVs(ctx, "warn message", "warn", closure)
|
|
|
|
// Output:
|
|
// msg="error message" err="additional error data: 0" level=error
|
|
// msg="warn message" warn="additional error data: 1" level=warning
|
|
}
|
|
|
|
func Example_withGroup() {
|
|
log := log.New(log.WithStdout()).With(
|
|
log.WithLevel(log.KeyLevel, level.Info),
|
|
)
|
|
|
|
log.ErrKVs(ctx, "error message",
|
|
field.Groups("grous_field",
|
|
field.Error("err", os.ErrDeadlineExceeded),
|
|
field.Bool("bool", false),
|
|
),
|
|
)
|
|
log.WarnKV(ctx, "error message", field.ValuerFn("valuer_field", func() any {
|
|
return field.Fields{
|
|
field.Int("int_value", math.MaxInt),
|
|
field.Uint8("uint8_value", math.MaxUint8),
|
|
}
|
|
}))
|
|
|
|
// Output:
|
|
// msg="error message" grous_field.err="i/o timeout" grous_field.bool=false level=error
|
|
// msg="error message" valuer_field.int_value=9223372036854775807 valuer_field.uint8_value=255 level=warning
|
|
}
|
|
|