update random string seed + extend log context method

osspkg · Mar 27, 2023 · 50c5216 · 50c5216
1 parent 7c6992e
commit 50c5216
Show file tree

Hide file tree

Showing 8 changed files with 127 additions and 19 deletions.
diff --git a/log/common.go b/log/common.go
@@ -36,6 +36,8 @@ type Writer interface {
 }
 
 type WriterContext interface {
+	WithError(key string, err error) Writer
+	WithField(key string, value interface{}) Writer
 	WithFields(Fields) Writer
 	Writer
 }

diff --git a/log/default.go b/log/default.go
@@ -58,3 +58,13 @@ func Fatalf(format string, args ...interface{}) {
 func WithFields(v Fields) Writer {
 	return std.WithFields(v)
 }
+
+// WithError setter context to log message
+func WithError(key string, err error) Writer {
+	return std.WithError(key, err)
+}
+
+// WithField setter context to log message
+func WithField(key string, value interface{}) Writer {
+	return std.WithField(key, value)
+}
diff --git a/log/entity.go b/log/entity.go
@@ -22,6 +22,28 @@ func (e *entity) Reset() {
 	e.ctx = Fields{}
 }
 
+func (e *entity) WithError(key string, err error) Writer {
+	if err != nil {
+		e.ctx[key] = err.Error()
+	} else {
+		e.ctx[key] = nil
+	}
+	return e
+}
+
+func (e *entity) WithField(key string, value interface{}) Writer {
+	ref := reflect.TypeOf(value)
+	if ref != nil {
+		switch ref.Kind() {
+		case reflect.Chan, reflect.Func, reflect.Interface, reflect.Ptr, reflect.Struct:
+			e.ctx[key] = fmt.Sprintf("unsupported field value: %#v", value)
+			return e
+		}
+	}
+	e.ctx[key] = value
+	return e
+}
+
 func (e *entity) WithFields(fields Fields) Writer {
 	for key, value := range fields {
 		ref := reflect.TypeOf(value)

diff --git a/log/logger.go b/log/logger.go
@@ -145,3 +145,13 @@ func (l *log) Fatalf(format string, args ...interface{}) {
 func (l *log) WithFields(v Fields) Writer {
 	return l.getEntity().WithFields(v)
 }
+
+// WithError setter context to log message
+func (l *log) WithError(key string, err error) Writer {
+	return l.getEntity().WithError(key, err)
+}
+
+// WithField setter context to log message
+func (l *log) WithField(key string, value interface{}) Writer {
+	return l.getEntity().WithField(key, value)
+}
diff --git a/log/logger_test.go b/log/logger_test.go
@@ -1,6 +1,7 @@
 package log_test
 
 import (
+	"fmt"
 	"io"
 	"os"
 	"sync"
@@ -25,14 +26,23 @@ func TestUnit_New(t *testing.T) {
 	go log.Warnf("async %d", 2)
 	go log.Errorf("async %d", 3)
 	go log.Debugf("async %d", 4)
+
 	log.Infof("sync %d", 1)
 	log.Warnf("sync %d", 2)
 	log.Errorf("sync %d", 3)
 	log.Debugf("sync %d", 4)
+
 	log.WithFields(log.Fields{"ip": "0.0.0.0"}).Infof("context1")
 	log.WithFields(log.Fields{"nil": nil}).Infof("context2")
 	log.WithFields(log.Fields{"func": func() {}}).Infof("context3")
 
+	log.WithField("ip", "0.0.0.0").Infof("context4")
+	log.WithField("nil", nil).Infof("context5")
+	log.WithField("func", func() {}).Infof("context6")
+
+	log.WithError("err", nil).Infof("context7")
+	log.WithError("err", fmt.Errorf("er1")).Infof("context8")
+
 	<-time.After(time.Second * 1)
 	log.Close()
 
@@ -52,6 +62,11 @@ func TestUnit_New(t *testing.T) {
 	require.Contains(t, sdata, `"msg":"context1","ctx":{"ip":"0.0.0.0"}`)
 	require.Contains(t, sdata, `"msg":"context2","ctx":{"nil":null}`)
 	require.Contains(t, sdata, `"msg":"context3","ctx":{"func":"unsupported field value: (func())`)
+	require.Contains(t, sdata, `"msg":"context4","ctx":{"ip":"0.0.0.0"}`)
+	require.Contains(t, sdata, `"msg":"context5","ctx":{"nil":null}`)
+	require.Contains(t, sdata, `"msg":"context6","ctx":{"func":"unsupported field value: (func())`)
+	require.Contains(t, sdata, `"msg":"context7","ctx":{"err":null}`)
+	require.Contains(t, sdata, `"msg":"context8","ctx":{"err":"er1"}`)
 }
 
 func BenchmarkNew(b *testing.B) {
@@ -67,6 +82,8 @@ func BenchmarkNew(b *testing.B) {
 		wg.Add(1)
 		for p.Next() {
 			ll.WithFields(log.Fields{"a": "b"}).Infof("hello")
+			ll.WithField("a", "b").Infof("hello")
+			ll.WithError("a", fmt.Errorf("b")).Infof("hello")
 		}
 		wg.Done()
 	})

diff --git a/orm/plugins/devnull.go b/orm/plugins/devnull.go
@@ -17,15 +17,15 @@ func (devNullMetric) ExecutionTime(_ string, call func()) { call() }
 
 type devNullLogger struct{}
 
-func (devNullLogger) SetOutput(io.Writer)           {}
-func (devNullLogger) Fatalf(string, ...interface{}) {}
-func (devNullLogger) Errorf(string, ...interface{}) {}
-func (devNullLogger) Warnf(string, ...interface{})  {}
-func (devNullLogger) Infof(string, ...interface{})  {}
-func (devNullLogger) Debugf(string, ...interface{}) {}
-func (devNullLogger) SetLevel(v uint32)             {}
-func (devNullLogger) Close()                        {}
-func (devNullLogger) GetLevel() uint32              { return 0 }
-func (v devNullLogger) WithFields(_ log.Fields) log.Writer {
-	return v
-}
+func (devNullLogger) SetOutput(io.Writer)                            {}
+func (devNullLogger) Fatalf(string, ...interface{})                  {}
+func (devNullLogger) Errorf(string, ...interface{})                  {}
+func (devNullLogger) Warnf(string, ...interface{})                   {}
+func (devNullLogger) Infof(string, ...interface{})                   {}
+func (devNullLogger) Debugf(string, ...interface{})                  {}
+func (devNullLogger) SetLevel(v uint32)                              {}
+func (devNullLogger) Close()                                         {}
+func (devNullLogger) GetLevel() uint32                               { return 0 }
+func (v devNullLogger) WithFields(_ log.Fields) log.Writer           { return v }
+func (v devNullLogger) WithField(_ string, _ interface{}) log.Writer { return v }
+func (v devNullLogger) WithError(_ string, _ error) log.Writer       { return v }
diff --git a/random/random.go b/random/random.go
@@ -10,17 +10,30 @@ func init() {
 }
 
 var (
-	digest = []byte("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789")
+	digest = []byte("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789-+=~*@#$%&?!<>")
 )
 
-func Bytes(n int) []byte {
+func BytesOf(n int, src []byte) []byte {
+	tmp := make([]byte, len(src))
+	copy(tmp, src)
+	rand.Shuffle(len(tmp), func(i, j int) {
+		tmp[i], tmp[j] = tmp[j], tmp[i]
+	})
 	b := make([]byte, n)
 	for i := range b {
-		b[i] = digest[rand.Intn(len(digest))]
+		b[i] = tmp[rand.Intn(len(tmp))]
 	}
 	return b
 }
 
+func StringOf(n int, src string) string {
+	return string(BytesOf(n, []byte(src)))
+}
+
+func Bytes(n int) []byte {
+	return BytesOf(n, digest)
+}
+
 func String(n int) string {
 	return string(Bytes(n))
 }
diff --git a/random/random_test.go b/random/random_test.go
@@ -2,19 +2,53 @@ package random_test
 
 import (
 	"bytes"
+	"fmt"
 	"testing"
 
 	"github.com/deweppro/go-sdk/random"
 )
 
 func TestUnit_Bytes(t *testing.T) {
-	r1 := random.Bytes(5)
-	r2 := random.Bytes(5)
+	max := 10
+	r1 := random.Bytes(max)
+	r2 := random.Bytes(max)
 
-	if len(r1) != 5 || len(r2) != 5 {
-		t.Errorf("invalid len, is not 5")
+	fmt.Println(string(r1), string(r2))
+
+	if len(r1) != max || len(r2) != max {
+		t.Errorf("invalid len, is not %d", max)
 	}
 	if bytes.Equal(r1, r2) {
 		t.Errorf("result is not random")
 	}
 }
+
+func TestUnit_BytesOf(t *testing.T) {
+	max := 10
+	src := []byte("1234567890")
+	r1 := random.BytesOf(max, src)
+	r2 := random.BytesOf(max, src)
+
+	fmt.Println(string(r1), string(r2))
+
+	if len(r1) != max || len(r2) != max {
+		t.Errorf("invalid len, is not %d", max)
+	}
+	if bytes.Equal(r1, r2) {
+		t.Errorf("result is not random")
+	}
+}
+
+func Benchmark_Bytes64(b *testing.B) {
+	b.ReportAllocs()
+	for i := 0; i < b.N; i++ {
+		random.Bytes(64)
+	}
+}
+
+func Benchmark_Bytes256(b *testing.B) {
+	b.ReportAllocs()
+	for i := 0; i < b.N; i++ {
+		random.Bytes(256)
+	}
+}