log

package main

import (
	"context"

	"gitoa.ru/go-4devs/log"
)

var ctx = context.Background()

func main() {
	logger := log.New(log.WithStdout())
	logger.Info(ctx, "same message")
}

Output:

msg="same message"

package main

import (
	"context"
	"errors"
	"math"
	"time"

	"gitoa.ru/go-4devs/log"
	"gitoa.ru/go-4devs/log/field"
)

var ctx = context.Background()

type Obj struct {
	Name     string
	IsEnable bool
}

var (
	obj = Obj{
		Name: "test obj",
	}

	intVal = int(math.MaxInt)

	uintVal = uint(math.MaxUint)

	float64Val = float64(math.MaxFloat64)

	timeVal = time.Unix(0, math.MaxInt32).In(time.UTC)
)

func main() {
	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"}

package main

import (
	"context"
	"errors"
	"math"
	"time"

	"gitoa.ru/go-4devs/log"
	"gitoa.ru/go-4devs/log/field"
)

var ctx = context.Background()

type Obj struct {
	Name     string
	IsEnable bool
}

var (
	str = "test str"

	uint8Val = uint8(math.MaxUint8)
)

func main() {
	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"]}

package main

import (
	"context"
	"os"

	"gitoa.ru/go-4devs/log"
	"gitoa.ru/go-4devs/log/level"
)

var ctx = context.Background()

func main() {
	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

package main

import (
	"context"

	"gitoa.ru/go-4devs/log"
)

var ctx = context.Background()

func main() {
	logger := log.New(log.WithStdout())
	logger.Errf(ctx, "same message %d", 1)
}

Output:

msg="same message 1"

package main

import (
	"context"
	"errors"
	"math"
	"time"

	"gitoa.ru/go-4devs/log"
	"gitoa.ru/go-4devs/log/field"
)

var ctx = context.Background()

type Obj struct {
	Name     string
	IsEnable bool
}

var (
	str = "test str"

	uint8Val = uint8(math.MaxUint8)

	timeVal = time.Unix(0, math.MaxInt32).In(time.UTC)
)

func main() {
	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"}

package main

import (
	"context"

	"gitoa.ru/go-4devs/log"
	"gitoa.ru/go-4devs/log/level"
)

var ctx = context.Background()

type Obj struct {
	Name     string
	IsEnable bool
}

func main() {
	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"}

package main

import (
	"context"

	"gitoa.ru/go-4devs/log"
	"gitoa.ru/go-4devs/log/level"
)

var ctx = context.Background()

func main() {
	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

package main

import (
	"context"

	"gitoa.ru/go-4devs/log"
	"gitoa.ru/go-4devs/log/level"
)

var ctx = context.Background()

func main() {
	logger := log.New(log.WithStdout()).With(log.WithLevel(log.KeyLevel, level.Error))
	logger.Info(ctx, "same message")
}

Output:

package main

import (
	"context"
	"math"
	"time"

	"gitoa.ru/go-4devs/log"
	"gitoa.ru/go-4devs/log/field"
)

var ctx = context.Background()

type Obj struct {
	Name     string
	IsEnable bool
}

var (
	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 main() {
	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}

package main

import (
	"context"

	"gitoa.ru/go-4devs/log"
	"gitoa.ru/go-4devs/log/level"
)

var ctx = context.Background()

type Obj struct {
	Name     string
	IsEnable bool
}

func main() {
	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

logger := log.New(log.WithStdout()).With(
	log.WithLevel(log.KeyLevel, level.Debug),
	log.WithSource(3, filepath.Base),
)
logger.Err(ctx, "same error message")
logger.InfoKVs(ctx, "same info message", "api-version", 0.1)
_, _ = logger.Write([]byte("same write message"))

Output:

msg="same error message" level=error source=logger_example_caller_test.go:15
msg="same info message" api-version=0.1 level=info source=logger_example_caller_test.go:16
msg="same write message" level=info source=logger_example_caller_test.go:17

package main

import (
	"context"

	"gitoa.ru/go-4devs/log"
	"gitoa.ru/go-4devs/log/entry"
	"gitoa.ru/go-4devs/log/field"
)

var ctx = context.Background()

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 main() {
	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

package main

import (
	"context"
	"path/filepath"

	"gitoa.ru/go-4devs/log"
)

func main() {
	ctx := context.Background()
	logger := log.New(log.WithStdout()).With(log.WithSource(1, filepath.Base))

	logger.Debug(ctx, "debug message")
}

Output:

msg="debug message" source=source_example_test.go:14

package main

import (
	"context"
	"path/filepath"

	"gitoa.ru/go-4devs/log"
)

func main() {
	ctx := context.Background()
	logger := log.New(log.WithStdout(), log.WithJSONFormat()).With(log.WithSource(2, filepath.Base))

	logger.Debug(ctx, "debug message")
}

Output:

{"msg":"debug message","source":{"file":"source_example_test.go","line":23,"func":"log_test.ExampleWithSource_json"}}