fix flow

Signed-off-by: Vasiliy Tolstov <v.tolstov@unistack.org>

auth/auth.go

@@ -55,7 +55,7 @@ type Auth interface {
 type Account struct {
 	// Metadata any other associated metadata
 	Metadata metadata.Metadata `json:"metadata"`
-	// ID of the account e.g. email or uuid
+	// ID of the account e.g. email or id
 	ID string `json:"id"`
 	// Type of the account, e.g. service
 	Type string `json:"type"`

auth/noop.go

@@ -1,7 +1,7 @@
 package auth
 
 import (
-	"github.com/google/uuid"
+	"github.com/unistack-org/micro/v3/util/id"
 )
 
 type noopAuth struct {
@@ -61,11 +61,11 @@ func (n *noopAuth) Verify(acc *Account, res *Resource, opts ...VerifyOption) err
 
 // Inspect a token
 func (n *noopAuth) Inspect(token string) (*Account, error) {
-	uid, err := uuid.NewRandom()
+	id, err := id.New()
 	if err != nil {
 		return nil, err
 	}
-	return &Account{ID: uid.String(), Issuer: n.Options().Issuer}, nil
+	return &Account{ID: id, Issuer: n.Options().Issuer}, nil
 }
 
 // Token generation using an account id and secret

broker/memory.go

@@ -4,10 +4,10 @@ import (
 	"context"
 	"sync"
 
-	"github.com/google/uuid"
 	"github.com/unistack-org/micro/v3/logger"
 	"github.com/unistack-org/micro/v3/metadata"
 	maddr "github.com/unistack-org/micro/v3/util/addr"
+	"github.com/unistack-org/micro/v3/util/id"
 	mnet "github.com/unistack-org/micro/v3/util/net"
 	"github.com/unistack-org/micro/v3/util/rand"
 )
@@ -224,7 +224,7 @@ func (m *memoryBroker) BatchSubscribe(ctx context.Context, topic string, handler
 	}
 	m.RUnlock()
 
-	id, err := uuid.NewRandom()
+	sid, err := id.New()
 	if err != nil {
 		return nil, err
 	}
@@ -233,7 +233,7 @@ func (m *memoryBroker) BatchSubscribe(ctx context.Context, topic string, handler
 
 	sub := &memorySubscriber{
 		exit:         make(chan bool, 1),
-		id:           id.String(),
+		id:           sid,
 		topic:        topic,
 		batchhandler: handler,
 		opts:         options,
@@ -269,7 +269,7 @@ func (m *memoryBroker) Subscribe(ctx context.Context, topic string, handler Hand
 	}
 	m.RUnlock()
 
-	id, err := uuid.NewRandom()
+	sid, err := id.New()
 	if err != nil {
 		return nil, err
 	}
@@ -278,7 +278,7 @@ func (m *memoryBroker) Subscribe(ctx context.Context, topic string, handler Hand
 
 	sub := &memorySubscriber{
 		exit:    make(chan bool, 1),
-		id:      id.String(),
+		id:      sid,
 		topic:   topic,
 		handler: handler,
 		opts:    options,

config/config.go

@@ -10,8 +10,11 @@ import (
 // DefaultConfig default config
 var DefaultConfig Config = NewConfig()
 
-// DefaultWatcherInterval default interval for poll changes
-var DefaultWatcherInterval = 5 * time.Second
+// DefaultWatcherMinInterval default min interval for poll changes
+var DefaultWatcherMinInterval = 5 * time.Second
+
+// DefaultWatcherMinInterval default max interval for poll changes
+var DefaultWatcherMaxInterval = 9 * time.Second
 
 var (
 	// ErrCodecMissing is returned when codec needed and not specified

config/default.go

@@ -2,10 +2,10 @@ package config
 
 import (
 	"context"
+	"fmt"
 	"reflect"
 	"strconv"
 	"strings"
-	"time"
 
 	"github.com/imdario/mergo"
 	rutil "github.com/unistack-org/micro/v3/util/reflect"
@@ -271,17 +271,7 @@ func (c *defaultConfig) Name() string {
 }
 
 func (c *defaultConfig) Watch(ctx context.Context, opts ...WatchOption) (Watcher, error) {
-	w := &defaultWatcher{
-		opts:  c.opts,
-		wopts: NewWatchOptions(opts...),
-		done:  make(chan bool),
-		vchan: make(chan map[string]interface{}),
-		echan: make(chan error),
-	}
-
-	go w.run()
-
-	return w, nil
+	return nil, fmt.Errorf("not implemented")
 }
 
 // NewConfig returns new default config source
@@ -292,73 +282,3 @@ func NewConfig(opts ...Option) Config {
 	}
 	return &defaultConfig{opts: options}
 }
-
-type defaultWatcher struct {
-	opts   Options
-	wopts  WatchOptions
-	done   chan bool
-	ticker *time.Ticker
-	vchan  chan map[string]interface{}
-	echan  chan error
-}
-
-func (w *defaultWatcher) run() {
-	ticker := time.NewTicker(w.wopts.Interval)
-	defer ticker.Stop()
-
-	src := w.opts.Struct
-	if w.wopts.Struct != nil {
-		src = w.wopts.Struct
-	}
-
-	for {
-		select {
-		case <-w.done:
-			return
-		case <-ticker.C:
-			dst, err := rutil.Zero(src)
-			if err == nil {
-				err = fillValues(reflect.ValueOf(dst), w.opts.StructTag)
-			}
-			if err != nil {
-				w.echan <- err
-				return
-			}
-			srcmp, err := rutil.StructFieldsMap(src)
-			if err != nil {
-				w.echan <- err
-				return
-			}
-			dstmp, err := rutil.StructFieldsMap(dst)
-			if err != nil {
-				w.echan <- err
-				return
-			}
-			for sk, sv := range srcmp {
-				if reflect.DeepEqual(dstmp[sk], sv) {
-					delete(dstmp, sk)
-				}
-			}
-			w.vchan <- dstmp
-			src = dst
-		}
-	}
-}
-
-func (w *defaultWatcher) Next() (map[string]interface{}, error) {
-	select {
-	case <-w.done:
-		break
-	case v, ok := <-w.vchan:
-		if !ok {
-			break
-		}
-		return v, nil
-	}
-	return nil, ErrWatcherStopped
-}
-
-func (w *defaultWatcher) Stop() error {
-	close(w.done)
-	return nil
-}

config/default_test.go

@@ -4,7 +4,6 @@ import (
 	"context"
 	"fmt"
 	"testing"
-	"time"
 
 	"github.com/unistack-org/micro/v3/config"
 )
@@ -18,57 +17,6 @@ type Cfg struct {
 	IntValue int `default:"99"`
 }
 
-func TestWatch(t *testing.T) {
-	ctx := context.Background()
-
-	conf := &Cfg{IntValue: 10}
-
-	cfg := config.NewConfig(config.Struct(conf))
-	if err := cfg.Init(); err != nil {
-		t.Fatal(err)
-	}
-	if err := cfg.Load(ctx); err != nil {
-		t.Fatal(err)
-	}
-
-	w, err := cfg.Watch(ctx, config.WatchInterval(500*time.Millisecond))
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	defer func() {
-		_ = w.Stop()
-	}()
-
-	done := make(chan struct{})
-
-	go func() {
-		for {
-			mp, err := w.Next()
-			if err != nil && err != config.ErrWatcherStopped {
-				t.Fatal(err)
-			} else if err == config.ErrWatcherStopped {
-				return
-			}
-			if len(mp) != 1 {
-				t.Fatal(fmt.Errorf("default watcher err: %v", mp))
-			}
-
-			v, ok := mp["IntValue"]
-			if !ok {
-				t.Fatal(fmt.Errorf("default watcher err: %v", v))
-			}
-			if nv, ok := v.(int); !ok || nv != 99 {
-				t.Fatal(fmt.Errorf("default watcher err: %v", v))
-			}
-			close(done)
-			return
-		}
-	}()
-
-	<-done
-}
-
 func TestDefault(t *testing.T) {
 	ctx := context.Background()
 	conf := &Cfg{IntValue: 10}

config/options.go

@@ -211,8 +211,10 @@ type WatchOptions struct {
 	Context context.Context
 	// Coalesce multiple events to one
 	Coalesce bool
-	// Interval to periodically pull changes if config source not supports async notify
-	Interval time.Duration
+	// MinInterval specifies the min time.Duration interval for poll changes
+	MinInterval time.Duration
+	// MaxInterval specifies the max time.Duration interval for poll changes
+	MaxInterval time.Duration
 	// Struct for filling
 	Struct interface{}
 }
@@ -221,8 +223,9 @@ type WatchOption func(*WatchOptions)
 
 func NewWatchOptions(opts ...WatchOption) WatchOptions {
 	options := WatchOptions{
-		Context:  context.Background(),
-		Interval: DefaultWatcherInterval,
+		Context:     context.Background(),
+		MinInterval: DefaultWatcherMinInterval,
+		MaxInterval: DefaultWatcherMaxInterval,
 	}
 	for _, o := range opts {
 		o(&options)
@@ -244,10 +247,11 @@ func WatchCoalesce(b bool) WatchOption {
 	}
 }
 
-// WatchInterval specifies time.Duration for pulling changes
-func WatchInterval(td time.Duration) WatchOption {
+// WatchInterval specifies min and max time.Duration for pulling changes
+func WatchInterval(min, max time.Duration) WatchOption {
 	return func(o *WatchOptions) {
-		o.Interval = td
+		o.MinInterval = min
+		o.MaxInterval = max
 	}
 }
 

errors/errors.go

@@ -37,7 +37,7 @@ var (
 
 // Error type
 type Error struct {
-	// Id holds error id or service, usually someting like my_service or uuid
+	// Id holds error id or service, usually someting like my_service or id
 	Id string
 	// Detail holds some useful details about error
 	Detail string

flow/default.go

@@ -6,13 +6,13 @@ import (
 	"path/filepath"
 	"sync"
 
-	"github.com/google/uuid"
 	"github.com/silas/dag"
 	"github.com/unistack-org/micro/v3/client"
 	"github.com/unistack-org/micro/v3/codec"
 	"github.com/unistack-org/micro/v3/logger"
 	"github.com/unistack-org/micro/v3/metadata"
 	"github.com/unistack-org/micro/v3/store"
+	"github.com/unistack-org/micro/v3/util/id"
 )
 
 type microFlow struct {
@@ -149,18 +149,18 @@ func (w *microWorkflow) getSteps(start string, reverse bool) ([][]Step, error) {
 	return steps, nil
 }
 
-func (w *microWorkflow) Abort(ctx context.Context, eid string) error {
-	workflowStore := store.NewNamespaceStore(w.opts.Store, filepath.Join("workflows", eid))
+func (w *microWorkflow) Abort(ctx context.Context, id string) error {
+	workflowStore := store.NewNamespaceStore(w.opts.Store, filepath.Join("workflows", id))
 	return workflowStore.Write(ctx, "status", &codec.Frame{Data: []byte(StatusAborted.String())})
 }
 
-func (w *microWorkflow) Suspend(ctx context.Context, eid string) error {
-	workflowStore := store.NewNamespaceStore(w.opts.Store, filepath.Join("workflows", eid))
+func (w *microWorkflow) Suspend(ctx context.Context, id string) error {
+	workflowStore := store.NewNamespaceStore(w.opts.Store, filepath.Join("workflows", id))
 	return workflowStore.Write(ctx, "status", &codec.Frame{Data: []byte(StatusSuspend.String())})
 }
 
-func (w *microWorkflow) Resume(ctx context.Context, eid string) error {
-	workflowStore := store.NewNamespaceStore(w.opts.Store, filepath.Join("workflows", eid))
+func (w *microWorkflow) Resume(ctx context.Context, id string) error {
+	workflowStore := store.NewNamespaceStore(w.opts.Store, filepath.Join("workflows", id))
 	return workflowStore.Write(ctx, "status", &codec.Frame{Data: []byte(StatusRunning.String())})
 }
 
@@ -176,11 +176,10 @@ func (w *microWorkflow) Execute(ctx context.Context, req *Message, opts ...Execu
 	}
 	w.Unlock()
 
-	uid, err := uuid.NewRandom()
+	eid, err := id.New()
 	if err != nil {
 		return "", err
 	}
-	eid := uid.String()
 
 	stepStore := store.NewNamespaceStore(w.opts.Store, filepath.Join("steps", eid))
 	workflowStore := store.NewNamespaceStore(w.opts.Store, filepath.Join("workflows", eid))
@@ -330,7 +329,7 @@ func (w *microWorkflow) Execute(ctx context.Context, req *Message, opts ...Execu
 		close(cherr)
 	case <-chstatus:
 		close(chstatus)
-		return uid.String(), nil
+		return eid, nil
 	}
 
 	switch {
@@ -351,7 +350,7 @@ func (w *microWorkflow) Execute(ctx context.Context, req *Message, opts ...Execu
 		break
 	}
 
-	return uid.String(), err
+	return eid, err
 }
 
 func NewFlow(opts ...Option) Flow {

flow/flow.go

@@ -116,11 +116,11 @@ type Workflow interface {
 	// Steps returns steps slice where parallel steps returned on the same level
 	Steps() ([][]Step, error)
 	// Suspend suspends execution
-	Suspend(ctx context.Context, eid string) error
+	Suspend(ctx context.Context, id string) error
 	// Resume resumes execution
-	Resume(ctx context.Context, eid string) error
+	Resume(ctx context.Context, id string) error
 	// Abort abort execution
-	Abort(ctx context.Context, eid string) error
+	Abort(ctx context.Context, id string) error
 }
 
 // Flow the base interface to interact with workflows

go.mod

@@ -4,10 +4,11 @@ go 1.16
 
 require (
 	github.com/ef-ds/deque v1.0.4
-	github.com/golang-jwt/jwt v3.2.1+incompatible
-	github.com/google/uuid v1.3.0
+	github.com/golang-jwt/jwt/v4 v4.0.0
 	github.com/imdario/mergo v0.3.12
 	github.com/patrickmn/go-cache v2.1.0+incompatible
 	github.com/silas/dag v0.0.0-20210121180416-41cf55125c34
+	github.com/stretchr/testify v1.7.0
+	github.com/unistack-org/micro-proto v0.0.5
 	golang.org/x/net v0.0.0-20210510120150-4163338589ed
 )

go.sum

@@ -1,15 +1,25 @@
+github.com/davecgh/go-spew v1.1.0 h1:ZDRjVQ15GmhC3fiQ8ni8+OwkZQO4DARzQgrnXU1Liz8=
+github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/ef-ds/deque v1.0.4 h1:iFAZNmveMT9WERAkqLJ+oaABF9AcVQ5AjXem/hroniI=
 github.com/ef-ds/deque v1.0.4/go.mod h1:gXDnTC3yqvBcHbq2lcExjtAcVrOnJCbMcZXmuj8Z4tg=
-github.com/golang-jwt/jwt v3.2.1+incompatible h1:73Z+4BJcrTC+KczS6WvTPvRGOp1WmfEP4Q1lOd9Z/+c=
-github.com/golang-jwt/jwt v3.2.1+incompatible/go.mod h1:8pz2t5EyA70fFQQSrl6XZXzqecmYZeUEB8OUGHkxJ+I=
-github.com/google/uuid v1.3.0 h1:t6JiXgmwXMjEs8VusXIJk2BXHsn+wx8BZdTaoZ5fu7I=
-github.com/google/uuid v1.3.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
+github.com/golang-jwt/jwt/v4 v4.0.0 h1:RAqyYixv1p7uEnocuy8P1nru5wprCh/MH2BIlW5z5/o=
+github.com/golang-jwt/jwt/v4 v4.0.0/go.mod h1:/xlHOz8bRuivTWchD4jCa+NbatV+wEUSzwAxVc6locg=
+github.com/golang/protobuf v1.5.0/go.mod h1:FsONVRAS9T7sI+LIUmWTfcYkHO4aIWwzhcaSAoJOfIk=
+github.com/google/go-cmp v0.5.5 h1:Khx7svrCpmxxtHBq5j2mp/xVjsi8hQMfNLvJFAlrGgU=
+github.com/google/go-cmp v0.5.5/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
 github.com/imdario/mergo v0.3.12 h1:b6R2BslTbIEToALKP7LxUvijTsNI9TAe80pLWN2g/HU=
 github.com/imdario/mergo v0.3.12/go.mod h1:jmQim1M+e3UYxmgPu/WyfjB3N3VflVyUjjjwH0dnCYA=
 github.com/patrickmn/go-cache v2.1.0+incompatible h1:HRMgzkcYKYpi3C8ajMPV8OFXaaRUnok+kx1WdO15EQc=
 github.com/patrickmn/go-cache v2.1.0+incompatible/go.mod h1:3Qf8kWWT7OJRJbdiICTKqZju1ZixQ/KpMGzzAfe6+WQ=
+github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
+github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
 github.com/silas/dag v0.0.0-20210121180416-41cf55125c34 h1:vBfVmA5mZhsQa2jr1FOL9nfA37N/jnbBmi5XUfviVTI=
 github.com/silas/dag v0.0.0-20210121180416-41cf55125c34/go.mod h1:7RTUFBdIRC9nZ7/3RyRNH1bdqIShrDejd1YbLwgPS+I=
+github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
+github.com/stretchr/testify v1.7.0 h1:nwc3DEeHmmLAfoZucVR881uASk0Mfjw8xYJ99tb5CcY=
+github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
+github.com/unistack-org/micro-proto v0.0.5 h1:DIC97Hufa2nGjuvTsfToD9laEOKddWMRTzeCfBwJ1j8=
+github.com/unistack-org/micro-proto v0.0.5/go.mod h1:EuI7UlfGXmT1hy6WacULib9LbNgRnDYQvTCFoLgKM2I=
 golang.org/x/net v0.0.0-20210510120150-4163338589ed h1:p9UgmWI9wKpfYmgaV/IZKGdXc5qEK45tDwwwDyjS26I=
 golang.org/x/net v0.0.0-20210510120150-4163338589ed/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y=
 golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
@@ -17,6 +27,14 @@ golang.org/x/sys v0.0.0-20210423082822-04245dca01da/go.mod h1:h1NjWce9XRLGQEsW7w
 golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
 golang.org/x/text v0.3.6/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
 golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
+golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543 h1:E7g+9GITq07hpfrRu66IVDexMakfv52eLZ2CXBWiKr4=
+golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
+google.golang.org/protobuf v1.26.0-rc.1/go.mod h1:jlhhOSvTdKEhbULTjvd4ARK9grFBp09yW+WbY/TyQbw=
+google.golang.org/protobuf v1.26.0 h1:bxAC2xTBsZGibn2RTntX0oH50xLsqy1OxA9tTL3p/lk=
+google.golang.org/protobuf v1.26.0/go.mod h1:9q0QmTI4eRPtz6boOQmLYwt+qCgq0jsYwAQnmE0givc=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/yaml.v2 v2.3.0 h1:clyUAQHOM3G0M3f5vQj7LuJrETvjVot3Z5el9nffUtU=
 gopkg.in/yaml.v2 v2.3.0/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
+gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c h1:dUUwHk2QECo/6vqA44rthZ8ie2QXMNeKRTHCNY2nXvo=
+gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=

logger/default.go

@@ -40,7 +40,6 @@ func (l *defaultLogger) Init(opts ...Option) error {
 		l.logFunc = l.opts.Wrappers[i-1].Log(l.logFunc)
 		l.logfFunc = l.opts.Wrappers[i-1].Logf(l.logfFunc)
 	}
-
 	l.Unlock()
 	return nil
 }
@@ -56,26 +55,20 @@ func (l *defaultLogger) V(level Level) bool {
 	return ok
 }
 
-func (l *defaultLogger) Fields(fields map[string]interface{}) Logger {
+func (l *defaultLogger) Fields(fields ...interface{}) Logger {
 	nl := &defaultLogger{opts: l.opts, enc: l.enc}
-	nl.opts.Fields = make(map[string]interface{}, len(l.opts.Fields)+len(fields))
-	l.RLock()
-	for k, v := range l.opts.Fields {
-		nl.opts.Fields[k] = v
-	}
-	l.RUnlock()
-
-	for k, v := range fields {
-		nl.opts.Fields[k] = v
+	if len(fields) == 0 {
+		return nl
+	} else if len(fields)%2 != 0 {
+		fields = fields[:len(fields)-1]
 	}
+	nl.opts.Fields = append(l.opts.Fields, fields...)
 	return nl
 }
 
-func copyFields(src map[string]interface{}) map[string]interface{} {
-	dst := make(map[string]interface{}, len(src))
-	for k, v := range src {
-		dst[k] = v
-	}
+func copyFields(src []interface{}) []interface{} {
+	dst := make([]interface{}, len(src))
+	copy(dst, src)
 	return dst
 }
 
@@ -162,19 +155,23 @@ func (l *defaultLogger) Log(ctx context.Context, level Level, args ...interface{
 	fields := copyFields(l.opts.Fields)
 	l.RUnlock()
 
-	fields["level"] = level.String()
+	fields = append(fields, "level", level.String())
 
 	if _, file, line, ok := runtime.Caller(l.opts.CallerSkipCount); ok {
-		fields["caller"] = fmt.Sprintf("%s:%d", logCallerfilePath(file), line)
+		fields = append(fields, "caller", fmt.Sprintf("%s:%d", logCallerfilePath(file), line))
 	}
+	fields = append(fields, "timestamp", time.Now().Format("2006-01-02 15:04:05"))
 
-	fields["timestamp"] = time.Now().Format("2006-01-02 15:04:05")
 	if len(args) > 0 {
-		fields["msg"] = fmt.Sprint(args...)
+		fields = append(fields, "msg", fmt.Sprint(args...))
 	}
 
+	out := make(map[string]interface{}, len(fields)/2)
+	for i := 0; i < len(fields); i += 2 {
+		out[fields[i].(string)] = fields[i+1]
+	}
 	l.RLock()
-	_ = l.enc.Encode(fields)
+	_ = l.enc.Encode(out)
 	l.RUnlock()
 }
 
@@ -187,30 +184,30 @@ func (l *defaultLogger) Logf(ctx context.Context, level Level, msg string, args
 	fields := copyFields(l.opts.Fields)
 	l.RUnlock()
 
-	fields["level"] = level.String()
+	fields = append(fields, "level", level.String())
 
 	if _, file, line, ok := runtime.Caller(l.opts.CallerSkipCount); ok {
-		fields["caller"] = fmt.Sprintf("%s:%d", logCallerfilePath(file), line)
+		fields = append(fields, "caller", fmt.Sprintf("%s:%d", logCallerfilePath(file), line))
 	}
 
-	fields["timestamp"] = time.Now().Format("2006-01-02 15:04:05")
+	fields = append(fields, "timestamp", time.Now().Format("2006-01-02 15:04:05"))
 	if len(args) > 0 {
-		fields["msg"] = fmt.Sprintf(msg, args...)
+		fields = append(fields, "msg", fmt.Sprintf(msg, args...))
 	} else if msg != "" {
-		fields["msg"] = msg
+		fields = append(fields, "msg", msg)
+	}
+
+	out := make(map[string]interface{}, len(fields)/2)
+	for i := 0; i < len(fields); i += 2 {
+		out[fields[i].(string)] = fields[i+1]
 	}
 	l.RLock()
-	_ = l.enc.Encode(fields)
+	_ = l.enc.Encode(out)
 	l.RUnlock()
 }
 
 func (l *defaultLogger) Options() Options {
-	// not guard against options Context values
-	l.RLock()
-	opts := l.opts
-	opts.Fields = copyFields(l.opts.Fields)
-	l.RUnlock()
-	return opts
+	return l.opts
 }
 
 // NewLogger builds a new logger based on options

logger/logger.go

@@ -20,8 +20,8 @@ type Logger interface {
 	V(level Level) bool
 	// The Logger options
 	Options() Options
-	// Fields set fields to always be logged
-	Fields(fields map[string]interface{}) Logger
+	// Fields set fields to always be logged with keyval pairs
+	Fields(fields ...interface{}) Logger
 	// Info level message
 	Info(ctx context.Context, args ...interface{})
 	// Trace level message
@@ -54,6 +54,9 @@ type Logger interface {
 	String() string
 }
 
+// Field contains keyval pair
+type Field interface{}
+
 // Info writes msg to default logger on info level
 func Info(ctx context.Context, args ...interface{}) {
 	DefaultLogger.Info(ctx, args...)
@@ -125,6 +128,6 @@ func Init(opts ...Option) error {
 }
 
 // Fields create logger with specific fields
-func Fields(fields map[string]interface{}) Logger {
-	return DefaultLogger.Fields(fields)
+func Fields(fields ...interface{}) Logger {
+	return DefaultLogger.Fields(fields...)
 }

logger/logger_test.go

@@ -3,9 +3,37 @@ package logger
 import (
 	"bytes"
 	"context"
+	"log"
 	"testing"
 )
 
+func TestRedirectStdLogger(t *testing.T) {
+	buf := bytes.NewBuffer(nil)
+	l := NewLogger(WithLevel(TraceLevel), WithOutput(buf))
+	if err := l.Init(); err != nil {
+		t.Fatal(err)
+	}
+	fn := RedirectStdLogger(l, ErrorLevel)
+	defer fn()
+	log.Print("test")
+	if !bytes.Contains(buf.Bytes(), []byte(`"level":"error","msg":"test","timestamp"`)) {
+		t.Fatalf("logger error, buf %s", buf.Bytes())
+	}
+}
+
+func TestStdLogger(t *testing.T) {
+	buf := bytes.NewBuffer(nil)
+	l := NewLogger(WithLevel(TraceLevel), WithOutput(buf))
+	if err := l.Init(); err != nil {
+		t.Fatal(err)
+	}
+	lg := NewStdLogger(l, ErrorLevel)
+	lg.Print("test")
+	if !bytes.Contains(buf.Bytes(), []byte(`"level":"error","msg":"test","timestamp"`)) {
+		t.Fatalf("logger error, buf %s", buf.Bytes())
+	}
+}
+
 func TestLogger(t *testing.T) {
 	ctx := context.TODO()
 	buf := bytes.NewBuffer(nil)
@@ -15,7 +43,7 @@ func TestLogger(t *testing.T) {
 	}
 	l.Trace(ctx, "trace_msg1")
 	l.Warn(ctx, "warn_msg1")
-	l.Fields(map[string]interface{}{"error": "test"}).Info(ctx, "error message")
+	l.Fields("error", "test").Info(ctx, "error message")
 	l.Warn(ctx, "first", " ", "second")
 	if !bytes.Contains(buf.Bytes(), []byte(`"level":"trace","msg":"trace_msg1"`)) {
 		t.Fatalf("logger error, buf %s", buf.Bytes())

logger/options.go

@@ -16,7 +16,7 @@ type Options struct {
 	// Context holds exernal options
 	Context context.Context
 	// Fields holds additional metadata
-	Fields map[string]interface{}
+	Fields []interface{}
 	// Name holds the logger name
 	Name string
 	// CallerSkipCount number of frmaes to skip
@@ -31,7 +31,7 @@ type Options struct {
 func NewOptions(opts ...Option) Options {
 	options := Options{
 		Level:           DefaultLevel,
-		Fields:          make(map[string]interface{}),
+		Fields:          make([]interface{}, 0, 6),
 		Out:             os.Stderr,
 		CallerSkipCount: DefaultCallerSkipCount,
 		Context:         context.Background(),
@@ -43,7 +43,7 @@ func NewOptions(opts ...Option) Options {
 }
 
 // WithFields set default fields for the logger
-func WithFields(fields map[string]interface{}) Option {
+func WithFields(fields ...interface{}) Option {
 	return func(o *Options) {
 		o.Fields = fields
 	}

logger/stdlogger.go

@@ -0,0 +1,35 @@
+package logger
+
+import (
+	"bytes"
+	"log"
+)
+
+type stdLogger struct {
+	l     Logger
+	level Level
+}
+
+func NewStdLogger(l Logger, level Level) *log.Logger {
+	return log.New(&stdLogger{l: l, level: level}, "" /* prefix */, 0 /* flags */)
+}
+
+func (sl *stdLogger) Write(p []byte) (int, error) {
+	p = bytes.TrimSpace(p)
+	sl.l.Log(sl.l.Options().Context, sl.level, string(p))
+	return len(p), nil
+}
+
+func RedirectStdLogger(l Logger, level Level) func() {
+	flags := log.Flags()
+	prefix := log.Prefix()
+	writer := log.Writer()
+	log.SetFlags(0)
+	log.SetPrefix("")
+	log.SetOutput(&stdLogger{l: l, level: level})
+	return func() {
+		log.SetFlags(flags)
+		log.SetPrefix(prefix)
+		log.SetOutput(writer)
+	}
+}

logger/wrapper.go

@@ -44,8 +44,8 @@ func (w *OmitLogger) Options() Options {
 	return w.l.Options()
 }
 
-func (w *OmitLogger) Fields(fields map[string]interface{}) Logger {
-	return w.l.Fields(fields)
+func (w *OmitLogger) Fields(fields ...interface{}) Logger {
+	return w.l.Fields(fields...)
 }
 
 func (w *OmitLogger) Info(ctx context.Context, args ...interface{}) {

meter/generate.go

@@ -1,3 +1,8 @@
 package meter
 
-//go:generate protoc -I./handler -I../ -I/home/vtolstov/.cache/go-path/pkg/mod/github.com/unistack-org/micro-proto@v0.0.1 --micro_out=components=micro|http|server,standalone=false,debug=true,paths=source_relative:./handler handler/handler.proto
+//go:generate sh -c "protoc -I./handler -I../ -I$(go list -f '{{ .Dir }}' -m github.com/unistack-org/micro-proto) --go-micro_out='components=micro|http|server',standalone=false,debug=true,paths=source_relative:./handler handler/handler.proto"
+
+import (
+	_ "github.com/unistack-org/micro-proto/api"
+	_ "github.com/unistack-org/micro-proto/openapiv2"
+)

meter/handler/handler.proto

@@ -11,17 +11,17 @@ service Meter {
 	rpc Metrics(micro.codec.Frame) returns (micro.codec.Frame) {
 		option (micro.openapiv2.openapiv2_operation) = {
       operation_id: "Metrics";
-        responses: {
-          key: "default";
+      responses: {
+        response_code: {
+          name: "default";
           value: {
-            description: "Error response";
-            schema: {
-              json_schema: {
-                ref: "micro.codec.Frame";
-              }
-            }
-          }
-        }
+            json_reference: {
+              description: "Error response";
+              _ref: "micro.codec.Frame";
+            };
+          };
+        };
+      };
     };
 		option (micro.api.http) = { get: "/metrics"; };
   };

meter/handler/handler_micro.pb.go

@@ -1,5 +1,7 @@
-// Code generated by protoc-gen-micro
+// Code generated by protoc-gen-go-micro. DO NOT EDIT.
+// protoc-gen-go-micro version: v3.4.2
 // source: handler.proto
+
 package handler
 
 import (
@@ -8,15 +10,21 @@ import (
 	codec "github.com/unistack-org/micro/v3/codec"
 )
 
-func NewMeterEndpoints() []*api.Endpoint {
-	return []*api.Endpoint{
-		&api.Endpoint{
+var (
+	MeterName = "Meter"
+
+	MeterEndpoints = []api.Endpoint{
+		api.Endpoint{
 			Name:    "Meter.Metrics",
 			Path:    []string{"/metrics"},
 			Method:  []string{"GET"},
 			Handler: "rpc",
 		},
 	}
+)
+
+func NewMeterEndpoints() []api.Endpoint {
+	return MeterEndpoints
 }
 
 type MeterServer interface {

meter/handler/handler_micro_http.pb.go

@@ -1,5 +1,7 @@
-// Code generated by protoc-gen-micro
+// Code generated by protoc-gen-go-micro. DO NOT EDIT.
+// protoc-gen-go-micro version: v3.4.2
 // source: handler.proto
+
 package handler
 
 import (
@@ -26,8 +28,8 @@ func RegisterMeterServer(s server.Server, sh MeterServer, opts ...server.Handler
 	}
 	h := &meterServer{sh}
 	var nopts []server.HandlerOption
-	for _, endpoint := range NewMeterEndpoints() {
-		nopts = append(nopts, api.WithEndpoint(endpoint))
+	for _, endpoint := range MeterEndpoints {
+		nopts = append(nopts, api.WithEndpoint(&endpoint))
 	}
 	return s.Handle(s.NewHandler(&Meter{h}, append(nopts, opts...)...))
 }

network/options.go

@@ -1,13 +1,13 @@
 package network
 
 import (
-	"github.com/google/uuid"
 	"github.com/unistack-org/micro/v3/logger"
 	"github.com/unistack-org/micro/v3/meter"
 	"github.com/unistack-org/micro/v3/network/tunnel"
 	"github.com/unistack-org/micro/v3/proxy"
 	"github.com/unistack-org/micro/v3/router"
 	"github.com/unistack-org/micro/v3/tracer"
+	"github.com/unistack-org/micro/v3/util/id"
 )
 
 // Option func
@@ -119,7 +119,7 @@ func Tracer(t tracer.Tracer) Option {
 // NewOptions returns network default options
 func NewOptions(opts ...Option) Options {
 	options := Options{
-		Id:      uuid.New().String(),
+		Id:      id.Must(),
 		Name:    "go.micro",
 		Address: ":0",
 		Logger:  logger.DefaultLogger,

network/tunnel/broker/broker.go

@@ -7,6 +7,7 @@ import (
 
 	"github.com/unistack-org/micro/v3/broker"
 	"github.com/unistack-org/micro/v3/logger"
+	"github.com/unistack-org/micro/v3/metadata"
 	"github.com/unistack-org/micro/v3/network/transport"
 	"github.com/unistack-org/micro/v3/network/tunnel"
 )

network/tunnel/options.go

@@ -3,11 +3,11 @@ package tunnel
 import (
 	"time"
 
-	"github.com/google/uuid"
 	"github.com/unistack-org/micro/v3/logger"
 	"github.com/unistack-org/micro/v3/meter"
 	"github.com/unistack-org/micro/v3/network/transport"
 	"github.com/unistack-org/micro/v3/tracer"
+	"github.com/unistack-org/micro/v3/util/id"
 )
 
 var (
@@ -164,7 +164,7 @@ func DialWait(b bool) DialOption {
 // NewOptions returns router default options with filled values
 func NewOptions(opts ...Option) Options {
 	options := Options{
-		ID:      uuid.New().String(),
+		ID:      id.Must(),
 		Address: DefaultAddress,
 		Token:   DefaultToken,
 		Logger:  logger.DefaultLogger,

register/memory.go

@@ -6,8 +6,8 @@ import (
 	"sync"
 	"time"
 
-	"github.com/google/uuid"
 	"github.com/unistack-org/micro/v3/logger"
+	"github.com/unistack-org/micro/v3/util/id"
 )
 
 var (
@@ -378,13 +378,16 @@ func (m *memory) ListServices(ctx context.Context, opts ...ListOption) ([]*Servi
 }
 
 func (m *memory) Watch(ctx context.Context, opts ...WatchOption) (Watcher, error) {
+	id, err := id.New()
+	if err != nil {
+		return nil, err
+	}
 	wo := NewWatchOptions(opts...)
-
 	// construct the watcher
 	w := &watcher{
 		exit: make(chan bool),
 		res:  make(chan *Result),
-		id:   uuid.New().String(),
+		id:   id,
 		wo:   wo,
 	}
 

router/options.go

@@ -3,9 +3,9 @@ package router
 import (
 	"context"
 
-	"github.com/google/uuid"
 	"github.com/unistack-org/micro/v3/logger"
 	"github.com/unistack-org/micro/v3/register"
+	"github.com/unistack-org/micro/v3/util/id"
 )
 
 // Options are router options
@@ -80,7 +80,7 @@ func Name(n string) Option {
 // NewOptions returns router default options
 func NewOptions(opts ...Option) Options {
 	options := Options{
-		Id:       uuid.New().String(),
+		Id:       id.Must(),
 		Network:  DefaultNetwork,
 		Register: register.DefaultRegister,
 		Logger:   logger.DefaultLogger,

server/generate.go

@@ -1,3 +1,8 @@
 package server
 
-//go:generate protoc -I./health -I../ -I/home/vtolstov/.cache/go-path/pkg/mod/github.com/unistack-org/micro-proto@v0.0.1 --micro_out=components=micro|http|server,standalone=false,debug=true,paths=source_relative:./health health/health.proto
+//go:generate sh -c "protoc -I./health -I../ -I$(go list -f '{{ .Dir }}' -m github.com/unistack-org/micro-proto) --go-micro_out='components=micro|http|server',standalone=false,debug=true,paths=source_relative:./health health/health.proto"
+
+import (
+	_ "github.com/unistack-org/micro-proto/api"
+	_ "github.com/unistack-org/micro-proto/openapiv2"
+)

server/health/health.proto

@@ -11,51 +11,51 @@ service Health {
 	rpc Live(micro.codec.Frame) returns (micro.codec.Frame) {
 		option (micro.openapiv2.openapiv2_operation) = {
       operation_id: "Live";
-        responses: {
-          key: "default";
+      responses: {
+        response_code: {
+          name: "default";
           value: {
-            description: "Error response";
-            schema: {
-              json_schema: {
-                ref: "micro.codec.Frame";
-              }
-            }
-          }
-        }
+            json_reference: {
+              description: "Error response";
+              _ref: "micro.codec.Frame";
+            };
+          };
+        };
+      };
     };
 		option (micro.api.http) = { get: "/live"; };
   };
 	rpc Ready(micro.codec.Frame) returns (micro.codec.Frame) {
 		option (micro.openapiv2.openapiv2_operation) = {
       operation_id: "Ready";
-        responses: {
-          key: "default";
+      responses: {
+        response_code: {
+          name: "default";
           value: {
-            description: "Error response";
-            schema: {
-              json_schema: {
-                ref: "micro.codec.Frame";
-              }
-            }
-          }
-        }
+            json_reference: {
+              description: "Error response";
+              _ref: "micro.codec.Frame";
+            };
+          };
+        };
+      };
     };
 		option (micro.api.http) = { get: "/ready"; };
   };
 	rpc Version(micro.codec.Frame) returns (micro.codec.Frame) {
 		option (micro.openapiv2.openapiv2_operation) = {
       operation_id: "Version";
-        responses: {
-          key: "default";
+      responses: {
+        response_code: {
+          name: "default";
           value: {
-            description: "Error response";
-            schema: {
-              json_schema: {
-                ref: "micro.codec.Frame";
-              }
-            }
-          }
-        }
+            json_reference: {
+              description: "Error response";
+              _ref: "micro.codec.Frame";
+            };
+          };
+        };
+      };
     };
 		option (micro.api.http) = { get: "/version"; };
   };

server/health/health_micro.pb.go

@@ -1,5 +1,7 @@
-// Code generated by protoc-gen-micro
+// Code generated by protoc-gen-go-micro. DO NOT EDIT.
+// protoc-gen-go-micro version: v3.4.2
 // source: health.proto
+
 package health
 
 import (
@@ -8,27 +10,33 @@ import (
 	codec "github.com/unistack-org/micro/v3/codec"
 )
 
-func NewHealthEndpoints() []*api.Endpoint {
-	return []*api.Endpoint{
-		&api.Endpoint{
+var (
+	HealthName = "Health"
+
+	HealthEndpoints = []api.Endpoint{
+		api.Endpoint{
 			Name:    "Health.Live",
 			Path:    []string{"/live"},
 			Method:  []string{"GET"},
 			Handler: "rpc",
 		},
-		&api.Endpoint{
+		api.Endpoint{
 			Name:    "Health.Ready",
 			Path:    []string{"/ready"},
 			Method:  []string{"GET"},
 			Handler: "rpc",
 		},
-		&api.Endpoint{
+		api.Endpoint{
 			Name:    "Health.Version",
 			Path:    []string{"/version"},
 			Method:  []string{"GET"},
 			Handler: "rpc",
 		},
 	}
+)
+
+func NewHealthEndpoints() []api.Endpoint {
+	return HealthEndpoints
 }
 
 type HealthServer interface {

server/health/health_micro_http.pb.go

@@ -1,5 +1,7 @@
-// Code generated by protoc-gen-micro
+// Code generated by protoc-gen-go-micro. DO NOT EDIT.
+// protoc-gen-go-micro version: v3.4.2
 // source: health.proto
+
 package health
 
 import (
@@ -36,8 +38,8 @@ func RegisterHealthServer(s server.Server, sh HealthServer, opts ...server.Handl
 	}
 	h := &healthServer{sh}
 	var nopts []server.HandlerOption
-	for _, endpoint := range NewHealthEndpoints() {
-		nopts = append(nopts, api.WithEndpoint(endpoint))
+	for _, endpoint := range HealthEndpoints {
+		nopts = append(nopts, api.WithEndpoint(&endpoint))
 	}
 	return s.Handle(s.NewHandler(&Health{h}, append(nopts, opts...)...))
 }

server/server.go

@@ -5,10 +5,10 @@ import (
 	"context"
 	"time"
 
-	"github.com/google/uuid"
 	"github.com/unistack-org/micro/v3/codec"
 	"github.com/unistack-org/micro/v3/metadata"
 	"github.com/unistack-org/micro/v3/register"
+	"github.com/unistack-org/micro/v3/util/id"
 )
 
 // DefaultServer default server
@@ -22,7 +22,7 @@ var (
 	// DefaultVersion will be used if no version passed
 	DefaultVersion = "latest"
 	// DefaultID will be used if no id passed
-	DefaultID = uuid.New().String()
+	DefaultID = id.Must()
 	// DefaultRegisterCheck holds func that run before register server
 	DefaultRegisterCheck = func(context.Context) error { return nil }
 	// DefaultRegisterInterval holds interval for register

util/auth/auth.go

@@ -4,9 +4,9 @@ import (
 	"context"
 	"time"
 
-	"github.com/google/uuid"
 	"github.com/unistack-org/micro/v3/auth"
 	"github.com/unistack-org/micro/v3/logger"
+	"github.com/unistack-org/micro/v3/util/id"
 )
 
 // Verify the auth credentials and refresh the auth token periodically
@@ -22,7 +22,11 @@ func Verify(a auth.Auth) error {
 			auth.WithScopes("service"),
 		}
 
-		acc, err := a.Generate(uuid.New().String(), opts...)
+		id, err := id.New()
+		if err != nil {
+			return err
+		}
+		acc, err := a.Generate(id, opts...)
 		if err != nil {
 			return err
 		}

util/id/LICENSE

@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright (c) 2018-2021 Matous Dzivjak <matousdzivjak@gmail.com>
+Copyright (c) 2021 Unistack LLC <v.tolstov@unistack.org>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

util/id/id.go

@@ -0,0 +1,108 @@
+package id
+
+import (
+	"crypto/rand"
+	"errors"
+	"math"
+)
+
+// DefaultAlphabet is the alphabet used for ID characters by default
+var DefaultAlphabet = []rune("6789BCDFGHJKLMNPQRTWbcdfghjkmnpqrtwz")
+
+// DefaultSize is the size used for ID by default
+var DefaultSize = 16
+
+// getMask generates bit mask used to obtain bits from the random bytes that are used to get index of random character
+// from the alphabet. Example: if the alphabet has 6 = (110)_2 characters it is sufficient to use mask 7 = (111)_2
+func getMask(alphabetSize int) int {
+	for i := 1; i <= 8; i++ {
+		mask := (2 << uint(i)) - 1
+		if mask >= alphabetSize-1 {
+			return mask
+		}
+	}
+	return 0
+}
+
+// New returns new id or error
+func New(opts ...Option) (string, error) {
+	options := NewOptions(opts...)
+
+	if len(options.Alphabet) == 0 || len(options.Alphabet) > 255 {
+		return "", errors.New("alphabet must not be empty and contain no more than 255 chars")
+	}
+	if options.Size <= 0 {
+		return "", errors.New("size must be positive integer")
+	}
+
+	chars := options.Alphabet
+
+	mask := getMask(len(chars))
+	// estimate how many random bytes we will need for the ID, we might actually need more but this is tradeoff
+	// between average case and worst case
+	ceilArg := 1.6 * float64(mask*options.Size) / float64(len(options.Alphabet))
+	step := int(math.Ceil(ceilArg))
+
+	id := make([]rune, options.Size)
+	bytes := make([]byte, step)
+	for j := 0; ; {
+		_, err := rand.Read(bytes)
+		if err != nil {
+			return "", err
+		}
+		for i := 0; i < step; i++ {
+			currByte := bytes[i] & byte(mask)
+			if currByte < byte(len(chars)) {
+				id[j] = chars[currByte]
+				j++
+				if j == options.Size {
+					return string(id[:options.Size]), nil
+				}
+			}
+		}
+	}
+}
+
+// Must is the same as New but panics on error
+func Must(opts ...Option) string {
+	id, err := New(opts...)
+	if err != nil {
+		panic(err)
+	}
+	return id
+}
+
+// Options contains id deneration options
+type Options struct {
+	Alphabet []rune
+	Size     int
+}
+
+// Option func signature
+type Option func(*Options)
+
+// Alphabet specifies alphabet to use
+func Alphabet(alphabet string) Option {
+	return func(o *Options) {
+		o.Alphabet = []rune(alphabet)
+	}
+}
+
+// Size specifies id size
+func Size(size int) Option {
+	return func(o *Options) {
+		o.Size = size
+	}
+}
+
+// NewOptions returns new Options struct filled by opts
+func NewOptions(opts ...Option) Options {
+	options := Options{
+		Alphabet: DefaultAlphabet,
+		Size:     DefaultSize,
+	}
+	for _, o := range opts {
+		o(&options)
+	}
+	return options
+}

util/id/id_internal_test.go

@@ -0,0 +1,41 @@
+package id
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/require"
+)
+
+func TestHasNoCollisions(t *testing.T) {
+	tries := 100_000
+	used := make(map[string]bool, tries)
+	for i := 0; i < tries; i++ {
+		id := Must()
+		require.False(t, used[id], "shouldn't return colliding IDs")
+		used[id] = true
+	}
+}
+
+func TestFlatDistribution(t *testing.T) {
+	tries := 100_000
+	alphabet := "abcdefghij"
+	size := 10
+	chars := make(map[rune]int)
+	for i := 0; i < tries; i++ {
+		id := Must(Alphabet(alphabet), Size(size))
+		for _, r := range id {
+			chars[r]++
+		}
+	}
+
+	for _, count := range chars {
+		require.InEpsilon(t, size*tries/len(alphabet), count, .01, "should have flat distribution")
+	}
+}
+
+// Benchmark id generator
+func BenchmarkNanoid(b *testing.B) {
+	for n := 0; n < b.N; n++ {
+		_, _ = New()
+	}
+}

util/id/id_test.go

@@ -0,0 +1,68 @@
+package id_test
+
+import (
+	"strings"
+	"testing"
+	"unicode/utf8"
+
+	"github.com/stretchr/testify/assert"
+	id "github.com/unistack-org/micro/v3/util/id"
+)
+
+func TestGenerate(t *testing.T) {
+	t.Run("short alphabet", func(t *testing.T) {
+		alphabet := ""
+		_, err := id.New(id.Alphabet(alphabet), id.Size(32))
+		assert.Error(t, err, "should return error if the alphabet is too small")
+	})
+
+	t.Run("long alphabet", func(t *testing.T) {
+		alphabet := strings.Repeat("a", 256)
+		_, err := id.New(id.Alphabet(alphabet), id.Size(32))
+		assert.Error(t, err, "should return error if the alphabet is too long")
+	})
+
+	t.Run("negative ID length", func(t *testing.T) {
+		_, err := id.New(id.Alphabet("abcdef"), id.Size(-1))
+		assert.Error(t, err, "should return error if the requested ID length is invalid")
+	})
+
+	t.Run("happy path", func(t *testing.T) {
+		alphabet := "abcdef"
+		id, err := id.New(id.Alphabet(alphabet), id.Size(6))
+		assert.NoError(t, err, "shouldn't return error")
+		assert.Len(t, id, 6, "should return ID of requested length")
+		for _, r := range id {
+			assert.True(t, strings.ContainsRune(alphabet, r), "should use given alphabet")
+		}
+	})
+
+	t.Run("works with unicode", func(t *testing.T) {
+		alphabet := "🚀💩🦄🤖"
+		id, err := id.New(id.Alphabet(alphabet), id.Size(6))
+		assert.NoError(t, err, "shouldn't return error")
+		assert.Equal(t, utf8.RuneCountInString(id), 6, "should return ID of requested length")
+		for _, r := range id {
+			assert.True(t, strings.ContainsRune(alphabet, r), "should use given alphabet")
+		}
+	})
+}
+
+func TestNew(t *testing.T) {
+	t.Run("negative ID length", func(t *testing.T) {
+		_, err := id.New(id.Size(-1))
+		assert.Error(t, err, "should return error if the requested ID length is invalid")
+	})
+
+	t.Run("happy path", func(t *testing.T) {
+		nid, err := id.New()
+		assert.NoError(t, err, "shouldn't return error")
+		assert.Len(t, nid, id.DefaultSize, "should return ID of default length")
+	})
+
+	t.Run("custom length", func(t *testing.T) {
+		id, err := id.New(id.Size(6))
+		assert.NoError(t, err, "shouldn't return error")
+		assert.Len(t, id, 6, "should return ID of requested length")
+	})
+}

util/jitter/random.go

@@ -7,8 +7,8 @@ import (
 	"github.com/unistack-org/micro/v3/util/rand"
 )
 
-// Do returns a random time to jitter with max cap specified
-func Do(d time.Duration) time.Duration {
+// Random returns a random time to jitter with max cap specified
+func Random(d time.Duration) time.Duration {
 	var rng rand.Rand
 	v := rng.Float64() * float64(d.Nanoseconds())
 	return time.Duration(v)

util/jitter/ticker.go

@@ -0,0 +1,65 @@
+package jitter
+
+import (
+	"time"
+
+	"github.com/unistack-org/micro/v3/util/rand"
+)
+
+// Ticker is similar to time.Ticker but ticks at random intervals between
+// the min and max duration values (stored internally as int64 nanosecond
+// counts).
+type Ticker struct {
+	C    chan time.Time
+	done chan chan struct{}
+	min  int64
+	max  int64
+	rng  rand.Rand
+}
+
+// NewTicker returns a pointer to an initialized instance of the Ticker.
+// Min and max are durations of the shortest and longest allowed
+// ticks. Ticker will run in a goroutine until explicitly stopped.
+func NewTicker(min, max time.Duration) *Ticker {
+	ticker := &Ticker{
+		C:    make(chan time.Time),
+		done: make(chan chan struct{}),
+		min:  min.Nanoseconds(),
+		max:  max.Nanoseconds(),
+	}
+	go ticker.run()
+	return ticker
+}
+
+// Stop terminates the ticker goroutine and closes the C channel.
+func (ticker *Ticker) Stop() {
+	c := make(chan struct{})
+	ticker.done <- c
+	<-c
+}
+
+func (ticker *Ticker) run() {
+	defer close(ticker.C)
+	t := time.NewTimer(ticker.nextInterval())
+	for {
+		// either a stop signal or a timeout
+		select {
+		case c := <-ticker.done:
+			t.Stop()
+			close(c)
+			return
+		case <-t.C:
+			select {
+			case ticker.C <- time.Now():
+				t.Stop()
+				t = time.NewTimer(ticker.nextInterval())
+			default:
+				// there could be noone receiving...
+			}
+		}
+	}
+}
+
+func (ticker *Ticker) nextInterval() time.Duration {
+	return time.Duration(ticker.rng.Int63n(ticker.max-ticker.min)+ticker.min) * time.Nanosecond
+}

util/pool/default.go

@@ -5,8 +5,8 @@ import (
 	"sync"
 	"time"
 
-	"github.com/google/uuid"
 	"github.com/unistack-org/micro/v3/network/transport"
+	"github.com/unistack-org/micro/v3/util/id"
 )
 
 type pool struct {
@@ -87,9 +87,13 @@ func (p *pool) Get(ctx context.Context, addr string, opts ...transport.DialOptio
 	if err != nil {
 		return nil, err
 	}
+	id, err := id.New()
+	if err != nil {
+		return nil, err
+	}
 	return &poolConn{
 		Client:  c,
-		id:      uuid.New().String(),
+		id:      id,
 		created: time.Now(),
 	}, nil
 }

util/ring/buffer.go

@@ -5,7 +5,7 @@ import (
 	"sync"
 	"time"
 
-	"github.com/google/uuid"
+	"github.com/unistack-org/micro/v3/util/id"
 )
 
 // Buffer is ring buffer
@@ -112,7 +112,7 @@ func (b *Buffer) Stream() (<-chan *Entry, chan bool) {
 	defer b.Unlock()
 
 	entries := make(chan *Entry, 128)
-	id := uuid.New().String()
+	id := id.Must()
 	stop := make(chan bool)
 
 	b.streams[id] = &Stream{

util/token/basic/basic.go

@@ -6,9 +6,9 @@ import (
 	"fmt"
 	"time"
 
-	"github.com/google/uuid"
 	"github.com/unistack-org/micro/v3/auth"
 	"github.com/unistack-org/micro/v3/store"
+	"github.com/unistack-org/micro/v3/util/id"
 	"github.com/unistack-org/micro/v3/util/token"
 )
 
@@ -44,7 +44,11 @@ func (b *Basic) Generate(acc *auth.Account, opts ...token.GenerateOption) (*toke
 	}
 
 	// write to the store
-	key := uuid.New().String()
+	key, err := id.New()
+	if err !=nil {
+		return nil, err
+	}
+	
 	err = b.store.Write(context.Background(), fmt.Sprintf("%v%v", StorePrefix, key), bytes, store.WriteTTL(options.Expiry))
 	if err != nil {
 		return nil, err

util/token/jwt/jwt.go

@@ -4,7 +4,7 @@ import (
 	"encoding/base64"
 	"time"
 
-	"github.com/golang-jwt/jwt"
+	"github.com/golang-jwt/jwt/v4"
 	"github.com/unistack-org/micro/v3/auth"
 	"github.com/unistack-org/micro/v3/metadata"
 	"github.com/unistack-org/micro/v3/util/token"