WIP: logger/unwrap: add unwrap method #143
535
logger/unwrap/unwrap.go
Normal file
535
logger/unwrap/unwrap.go
Normal file
@@ -0,0 +1,535 @@
|
||||
package unwrap
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"fmt"
|
||||
"io"
|
||||
"reflect"
|
||||
"strconv"
|
||||
"strings"
|
||||
|
||||
"go.unistack.org/micro/v3/codec"
|
||||
)
|
||||
|
||||
const sf = "0-+# "
|
||||
|
||||
var hexDigits = "0123456789abcdef"
|
||||
|
||||
var (
|
||||
panicBytes = []byte("(PANIC=")
|
||||
plusBytes = []byte("+")
|
||||
iBytes = []byte("i")
|
||||
trueBytes = []byte("true")
|
||||
falseBytes = []byte("false")
|
||||
interfaceBytes = []byte("(interface {})")
|
||||
openBraceBytes = []byte("{")
|
||||
closeBraceBytes = []byte("}")
|
||||
asteriskBytes = []byte("*")
|
||||
ampBytes = []byte("&")
|
||||
colonBytes = []byte(":")
|
||||
openParenBytes = []byte("(")
|
||||
closeParenBytes = []byte(")")
|
||||
spaceBytes = []byte(" ")
|
||||
commaBytes = []byte(",")
|
||||
pointerChainBytes = []byte("->")
|
||||
nilAngleBytes = []byte("<nil>")
|
||||
circularShortBytes = []byte("<shown>")
|
||||
invalidAngleBytes = []byte("<invalid>")
|
||||
openBracketBytes = []byte("[")
|
||||
closeBracketBytes = []byte("]")
|
||||
percentBytes = []byte("%")
|
||||
precisionBytes = []byte(".")
|
||||
openAngleBytes = []byte("<")
|
||||
closeAngleBytes = []byte(">")
|
||||
openMapBytes = []byte("{")
|
||||
closeMapBytes = []byte("}")
|
||||
)
|
||||
|
||||
type unwrap struct {
|
||||
val interface{}
|
||||
s fmt.State
|
||||
depth int
|
||||
pointers map[uintptr]int
|
||||
opts *Options
|
||||
ignoreNextType bool
|
||||
}
|
||||
|
||||
type Options struct {
|
||||
Codec codec.Codec
|
||||
Indent string
|
||||
UnwrapMethods bool
|
||||
}
|
||||
|
||||
func NewOptions(opts ...Option) Options {
|
||||
options := Options{
|
||||
Indent: " ",
|
||||
UnwrapMethods: false,
|
||||
}
|
||||
for _, o := range opts {
|
||||
o(&options)
|
||||
}
|
||||
return options
|
||||
}
|
||||
|
||||
type Option func(*Options)
|
||||
|
||||
func UnwrapIndent(f string) Option {
|
||||
return func(o *Options) {
|
||||
o.Indent = f
|
||||
}
|
||||
}
|
||||
|
||||
func UnwrapMethods(b bool) Option {
|
||||
return func(o *Options) {
|
||||
o.UnwrapMethods = b
|
||||
}
|
||||
}
|
||||
|
||||
func UnwrapCodec(c codec.Codec) Option {
|
||||
return func(o *Options) {
|
||||
o.Codec = c
|
||||
}
|
||||
}
|
||||
|
||||
func Unwrap(val interface{}, opts ...Option) *unwrap {
|
||||
options := NewOptions(opts...)
|
||||
return &unwrap{val: val, opts: &options, pointers: make(map[uintptr]int)}
|
||||
}
|
||||
|
||||
func (f *unwrap) unpackValue(v reflect.Value) reflect.Value {
|
||||
if v.Kind() == reflect.Interface {
|
||||
f.ignoreNextType = false
|
||||
if !v.IsNil() {
|
||||
v = v.Elem()
|
||||
}
|
||||
}
|
||||
return v
|
||||
}
|
||||
|
||||
// formatPtr handles formatting of pointers by indirecting them as necessary.
|
||||
func (f *unwrap) formatPtr(v reflect.Value) {
|
||||
// Display nil if top level pointer is nil.
|
||||
showTypes := f.s.Flag('#')
|
||||
if v.IsNil() && (!showTypes || f.ignoreNextType) {
|
||||
_, _ = f.s.Write(nilAngleBytes)
|
||||
return
|
||||
}
|
||||
|
||||
// Remove pointers at or below the current depth from map used to detect
|
||||
// circular refs.
|
||||
for k, depth := range f.pointers {
|
||||
if depth >= f.depth {
|
||||
delete(f.pointers, k)
|
||||
}
|
||||
}
|
||||
|
||||
// Keep list of all dereferenced pointers to possibly show later.
|
||||
pointerChain := make([]uintptr, 0)
|
||||
|
||||
// Figure out how many levels of indirection there are by derferencing
|
||||
// pointers and unpacking interfaces down the chain while detecting circular
|
||||
// references.
|
||||
nilFound := false
|
||||
cycleFound := false
|
||||
indirects := 0
|
||||
ve := v
|
||||
for ve.Kind() == reflect.Ptr {
|
||||
if ve.IsNil() {
|
||||
nilFound = true
|
||||
break
|
||||
}
|
||||
indirects++
|
||||
addr := ve.Pointer()
|
||||
pointerChain = append(pointerChain, addr)
|
||||
if pd, ok := f.pointers[addr]; ok && pd < f.depth {
|
||||
cycleFound = true
|
||||
indirects--
|
||||
break
|
||||
}
|
||||
f.pointers[addr] = f.depth
|
||||
|
||||
ve = ve.Elem()
|
||||
if ve.Kind() == reflect.Interface {
|
||||
if ve.IsNil() {
|
||||
nilFound = true
|
||||
break
|
||||
}
|
||||
ve = ve.Elem()
|
||||
}
|
||||
}
|
||||
|
||||
// Display type or indirection level depending on flags.
|
||||
if showTypes && !f.ignoreNextType {
|
||||
if f.depth > 0 {
|
||||
_, _ = f.s.Write(openParenBytes)
|
||||
}
|
||||
if f.depth > 0 {
|
||||
_, _ = f.s.Write(bytes.Repeat(asteriskBytes, indirects))
|
||||
} else {
|
||||
_, _ = f.s.Write(bytes.Repeat(ampBytes, indirects))
|
||||
}
|
||||
|
||||
_, _ = f.s.Write([]byte(ve.Type().String()))
|
||||
|
||||
if f.depth > 0 {
|
||||
_, _ = f.s.Write(closeParenBytes)
|
||||
}
|
||||
} else {
|
||||
if nilFound || cycleFound {
|
||||
indirects += strings.Count(ve.Type().String(), "*")
|
||||
}
|
||||
_, _ = f.s.Write(openAngleBytes)
|
||||
_, _ = f.s.Write([]byte(strings.Repeat("*", indirects)))
|
||||
_, _ = f.s.Write(closeAngleBytes)
|
||||
}
|
||||
|
||||
// Display pointer information depending on flags.
|
||||
if f.s.Flag('+') && (len(pointerChain) > 0) {
|
||||
_, _ = f.s.Write(openParenBytes)
|
||||
for i, addr := range pointerChain {
|
||||
if i > 0 {
|
||||
_, _ = f.s.Write(pointerChainBytes)
|
||||
}
|
||||
getHexPtr(f.s, addr)
|
||||
}
|
||||
_, _ = f.s.Write(closeParenBytes)
|
||||
}
|
||||
|
||||
// Display dereferenced value.
|
||||
switch {
|
||||
case nilFound:
|
||||
_, _ = f.s.Write(nilAngleBytes)
|
||||
|
||||
case cycleFound:
|
||||
_, _ = f.s.Write(circularShortBytes)
|
||||
|
||||
default:
|
||||
f.ignoreNextType = true
|
||||
f.format(ve)
|
||||
}
|
||||
}
|
||||
|
||||
// format is the main workhorse for providing the Formatter interface. It
|
||||
// uses the passed reflect value to figure out what kind of object we are
|
||||
// dealing with and formats it appropriately. It is a recursive function,
|
||||
// however circular data structures are detected and handled properly.
|
||||
func (f *unwrap) format(v reflect.Value) {
|
||||
if f.opts.Codec != nil {
|
||||
buf, err := f.opts.Codec.Marshal(v.Interface())
|
||||
if err != nil {
|
||||
_, _ = f.s.Write(invalidAngleBytes)
|
||||
return
|
||||
}
|
||||
_, _ = f.s.Write(buf)
|
||||
return
|
||||
}
|
||||
// Handle invalid reflect values immediately.
|
||||
kind := v.Kind()
|
||||
if kind == reflect.Invalid {
|
||||
_, _ = f.s.Write(invalidAngleBytes)
|
||||
return
|
||||
}
|
||||
|
||||
// Handle pointers specially.
|
||||
if kind == reflect.Ptr {
|
||||
f.formatPtr(v)
|
||||
return
|
||||
}
|
||||
|
||||
// get type information unless already handled elsewhere.
|
||||
if !f.ignoreNextType && f.s.Flag('#') {
|
||||
if v.Type().Kind() != reflect.Map {
|
||||
_, _ = f.s.Write(openParenBytes)
|
||||
}
|
||||
_, _ = f.s.Write([]byte(v.Type().String()))
|
||||
if v.Type().Kind() != reflect.Map {
|
||||
_, _ = f.s.Write(closeParenBytes)
|
||||
}
|
||||
}
|
||||
f.ignoreNextType = false
|
||||
|
||||
// Call Stringer/error interfaces if they exist and the handle methods
|
||||
// flag is enabled.
|
||||
if !f.opts.UnwrapMethods {
|
||||
if (kind != reflect.Invalid) && (kind != reflect.Interface) {
|
||||
if handled := handleMethods(f.opts, f.s, v); handled {
|
||||
return
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
switch kind {
|
||||
case reflect.Invalid:
|
||||
_, _ = f.s.Write(invalidAngleBytes)
|
||||
case reflect.Bool:
|
||||
getBool(f.s, v.Bool())
|
||||
case reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, reflect.Int:
|
||||
getInt(f.s, v.Int(), 10)
|
||||
case reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uint:
|
||||
getUint(f.s, v.Uint(), 10)
|
||||
case reflect.Float32:
|
||||
getFloat(f.s, v.Float(), 32)
|
||||
case reflect.Float64:
|
||||
getFloat(f.s, v.Float(), 64)
|
||||
case reflect.Complex64:
|
||||
getComplex(f.s, v.Complex(), 32)
|
||||
case reflect.Complex128:
|
||||
getComplex(f.s, v.Complex(), 64)
|
||||
case reflect.Slice:
|
||||
if v.IsNil() {
|
||||
_, _ = f.s.Write(nilAngleBytes)
|
||||
break
|
||||
}
|
||||
fallthrough
|
||||
case reflect.Array:
|
||||
_, _ = f.s.Write(openBracketBytes)
|
||||
f.depth++
|
||||
numEntries := v.Len()
|
||||
for i := 0; i < numEntries; i++ {
|
||||
if i > 0 {
|
||||
_, _ = f.s.Write(spaceBytes)
|
||||
}
|
||||
f.ignoreNextType = true
|
||||
f.format(f.unpackValue(v.Index(i)))
|
||||
}
|
||||
f.depth--
|
||||
_, _ = f.s.Write(closeBracketBytes)
|
||||
case reflect.String:
|
||||
_, _ = f.s.Write([]byte(`"` + v.String() + `"`))
|
||||
case reflect.Interface:
|
||||
// The only time we should get here is for nil interfaces due to
|
||||
// unpackValue calls.
|
||||
if v.IsNil() {
|
||||
_, _ = f.s.Write(nilAngleBytes)
|
||||
}
|
||||
case reflect.Ptr:
|
||||
// Do nothing. We should never get here since pointers have already
|
||||
// been handled above.
|
||||
case reflect.Map:
|
||||
// nil maps should be indicated as different than empty maps
|
||||
if v.IsNil() {
|
||||
_, _ = f.s.Write(nilAngleBytes)
|
||||
break
|
||||
}
|
||||
_, _ = f.s.Write(openMapBytes)
|
||||
f.depth++
|
||||
keys := v.MapKeys()
|
||||
for i, key := range keys {
|
||||
if i > 0 {
|
||||
_, _ = f.s.Write(spaceBytes)
|
||||
}
|
||||
f.ignoreNextType = true
|
||||
f.format(f.unpackValue(key))
|
||||
_, _ = f.s.Write(colonBytes)
|
||||
f.ignoreNextType = true
|
||||
f.format(f.unpackValue(v.MapIndex(key)))
|
||||
}
|
||||
f.depth--
|
||||
_, _ = f.s.Write(closeMapBytes)
|
||||
case reflect.Struct:
|
||||
numFields := v.NumField()
|
||||
_, _ = f.s.Write(openBraceBytes)
|
||||
f.depth++
|
||||
vt := v.Type()
|
||||
for i := 0; i < numFields; i++ {
|
||||
if i > 0 {
|
||||
_, _ = f.s.Write(commaBytes)
|
||||
_, _ = f.s.Write(spaceBytes)
|
||||
}
|
||||
vtf := vt.Field(i)
|
||||
if f.s.Flag('+') || f.s.Flag('#') {
|
||||
_, _ = f.s.Write([]byte(vtf.Name))
|
||||
_, _ = f.s.Write(colonBytes)
|
||||
}
|
||||
f.format(f.unpackValue(v.Field(i)))
|
||||
}
|
||||
f.depth--
|
||||
_, _ = f.s.Write(closeBraceBytes)
|
||||
case reflect.Uintptr:
|
||||
getHexPtr(f.s, uintptr(v.Uint()))
|
||||
case reflect.UnsafePointer, reflect.Chan, reflect.Func:
|
||||
getHexPtr(f.s, v.Pointer())
|
||||
// There were not any other types at the time this code was written, but
|
||||
// fall back to letting the default fmt package handle it if any get added.
|
||||
default:
|
||||
format := f.buildDefaultFormat()
|
||||
if v.CanInterface() {
|
||||
_, _ = fmt.Fprintf(f.s, format, v.Interface())
|
||||
} else {
|
||||
_, _ = fmt.Fprintf(f.s, format, v.String())
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func (f *unwrap) Format(s fmt.State, verb rune) {
|
||||
f.s = s
|
||||
|
||||
// Use standard formatting for verbs that are not v.
|
||||
if verb != 'v' {
|
||||
format := f.constructOrigFormat(verb)
|
||||
_, _ = fmt.Fprintf(s, format, f.val)
|
||||
return
|
||||
}
|
||||
|
||||
if f.val == nil {
|
||||
if s.Flag('#') {
|
||||
_, _ = s.Write(interfaceBytes)
|
||||
}
|
||||
_, _ = s.Write(nilAngleBytes)
|
||||
return
|
||||
}
|
||||
|
||||
f.format(reflect.ValueOf(f.val))
|
||||
}
|
||||
|
||||
// handle special methods like error.Error() or fmt.Stringer interface
|
||||
func handleMethods(_ *Options, w io.Writer, v reflect.Value) (handled bool) {
|
||||
if !v.CanInterface() {
|
||||
// not our case
|
||||
return false
|
||||
}
|
||||
|
||||
if !v.CanAddr() {
|
||||
// not our case
|
||||
return false
|
||||
}
|
||||
|
||||
if v.CanAddr() {
|
||||
v = v.Addr()
|
||||
}
|
||||
|
||||
// Is it an error or Stringer?
|
||||
switch iface := v.Interface().(type) {
|
||||
case error:
|
||||
defer catchPanic(w, v)
|
||||
_, _ = w.Write([]byte(iface.Error()))
|
||||
return true
|
||||
case fmt.Stringer:
|
||||
defer catchPanic(w, v)
|
||||
_, _ = w.Write([]byte(iface.String()))
|
||||
return true
|
||||
}
|
||||
|
||||
return false
|
||||
}
|
||||
|
||||
// getBool outputs a boolean value as true or false to Writer w.
|
||||
func getBool(w io.Writer, val bool) {
|
||||
if val {
|
||||
_, _ = w.Write(trueBytes)
|
||||
} else {
|
||||
_, _ = w.Write(falseBytes)
|
||||
}
|
||||
}
|
||||
|
||||
// getInt outputs a signed integer value to Writer w.
|
||||
func getInt(w io.Writer, val int64, base int) {
|
||||
_, _ = w.Write([]byte(strconv.FormatInt(val, base)))
|
||||
}
|
||||
|
||||
// getUint outputs an unsigned integer value to Writer w.
|
||||
func getUint(w io.Writer, val uint64, base int) {
|
||||
_, _ = w.Write([]byte(strconv.FormatUint(val, base)))
|
||||
}
|
||||
|
||||
// getFloat outputs a floating point value using the specified precision,
|
||||
// which is expected to be 32 or 64bit, to Writer w.
|
||||
func getFloat(w io.Writer, val float64, precision int) {
|
||||
_, _ = w.Write([]byte(strconv.FormatFloat(val, 'g', -1, precision)))
|
||||
}
|
||||
|
||||
// getComplex outputs a complex value using the specified float precision
|
||||
// for the real and imaginary parts to Writer w.
|
||||
func getComplex(w io.Writer, c complex128, floatPrecision int) {
|
||||
r := real(c)
|
||||
_, _ = w.Write(openParenBytes)
|
||||
_, _ = w.Write([]byte(strconv.FormatFloat(r, 'g', -1, floatPrecision)))
|
||||
i := imag(c)
|
||||
if i >= 0 {
|
||||
_, _ = w.Write(plusBytes)
|
||||
}
|
||||
_, _ = w.Write([]byte(strconv.FormatFloat(i, 'g', -1, floatPrecision)))
|
||||
_, _ = w.Write(iBytes)
|
||||
_, _ = w.Write(closeParenBytes)
|
||||
}
|
||||
|
||||
// getHexPtr outputs a uintptr formatted as hexadecimal with a leading '0x'
|
||||
// prefix to Writer w.
|
||||
func getHexPtr(w io.Writer, p uintptr) {
|
||||
// Null pointer.
|
||||
num := uint64(p)
|
||||
if num == 0 {
|
||||
_, _ = w.Write(nilAngleBytes)
|
||||
return
|
||||
}
|
||||
|
||||
// Max uint64 is 16 bytes in hex + 2 bytes for '0x' prefix
|
||||
buf := make([]byte, 18)
|
||||
|
||||
// It's simpler to construct the hex string right to left.
|
||||
base := uint64(16)
|
||||
i := len(buf) - 1
|
||||
for num >= base {
|
||||
buf[i] = hexDigits[num%base]
|
||||
num /= base
|
||||
i--
|
||||
}
|
||||
buf[i] = hexDigits[num]
|
||||
|
||||
// Add '0x' prefix.
|
||||
i--
|
||||
buf[i] = 'x'
|
||||
i--
|
||||
buf[i] = '0'
|
||||
|
||||
// Strip unused leading bytes.
|
||||
buf = buf[i:]
|
||||
_, _ = w.Write(buf)
|
||||
}
|
||||
|
||||
func catchPanic(w io.Writer, _ reflect.Value) {
|
||||
if err := recover(); err != nil {
|
||||
_, _ = w.Write(panicBytes)
|
||||
_, _ = fmt.Fprintf(w, "%v", err)
|
||||
_, _ = w.Write(closeParenBytes)
|
||||
}
|
||||
}
|
||||
|
||||
func (f *unwrap) buildDefaultFormat() (format string) {
|
||||
buf := bytes.NewBuffer(percentBytes)
|
||||
|
||||
for _, flag := range sf {
|
||||
if f.s.Flag(int(flag)) {
|
||||
_, _ = buf.WriteRune(flag)
|
||||
}
|
||||
}
|
||||
|
||||
_, _ = buf.WriteRune('v')
|
||||
|
||||
format = buf.String()
|
||||
return format
|
||||
}
|
||||
|
||||
func (f *unwrap) constructOrigFormat(verb rune) (format string) {
|
||||
buf := bytes.NewBuffer(percentBytes)
|
||||
|
||||
for _, flag := range sf {
|
||||
if f.s.Flag(int(flag)) {
|
||||
_, _ = buf.WriteRune(flag)
|
||||
}
|
||||
}
|
||||
|
||||
if width, ok := f.s.Width(); ok {
|
||||
_, _ = buf.WriteString(strconv.Itoa(width))
|
||||
}
|
||||
|
||||
if precision, ok := f.s.Precision(); ok {
|
||||
_, _ = buf.Write(precisionBytes)
|
||||
_, _ = buf.WriteString(strconv.Itoa(precision))
|
||||
}
|
||||
|
||||
_, _ = buf.WriteRune(verb)
|
||||
|
||||
format = buf.String()
|
||||
return format
|
||||
}
|
||||
46
logger/unwrap/unwrap_test.go
Normal file
46
logger/unwrap/unwrap_test.go
Normal file
@@ -0,0 +1,46 @@
|
||||
package unwrap
|
||||
|
||||
import (
|
||||
"testing"
|
||||
|
||||
"go.unistack.org/micro/v3/codec"
|
||||
)
|
||||
|
||||
func TestUnwrap(t *testing.T) {
|
||||
string1 := "string1"
|
||||
string2 := "string2"
|
||||
|
||||
type val1 struct {
|
||||
mp map[string]string
|
||||
val *val1
|
||||
str *string
|
||||
ar []*string
|
||||
}
|
||||
|
||||
v1 := &val1{ar: []*string{&string1, &string2}, str: &string1, val: &val1{str: &string2}, mp: map[string]string{"key": "val"}}
|
||||
|
||||
t.Logf("output: %#v", Unwrap(v1))
|
||||
|
||||
type val2 struct {
|
||||
mp map[string]string
|
||||
val *val2
|
||||
str string
|
||||
ar []string
|
||||
}
|
||||
|
||||
v2 := &val2{ar: []string{string1, string2}, str: string1, val: &val2{str: string2}, mp: map[string]string{"key": "val"}}
|
||||
|
||||
t.Logf("output: %#v", v2)
|
||||
}
|
||||
|
||||
func TestUnwrapCodec(t *testing.T) {
|
||||
type val struct {
|
||||
MP map[string]string `json:"mp"`
|
||||
STR string `json:"str"`
|
||||
AR []string `json:"ar"`
|
||||
}
|
||||
|
||||
v1 := &val{AR: []string{"string1", "string2"}, STR: "string", MP: map[string]string{"key": "val"}}
|
||||
|
||||
t.Logf("output: %#v", Unwrap(v1, UnwrapCodec(codec.NewCodec())))
|
||||
}
|
||||
Reference in New Issue
Block a user