metrics: add context option

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

api/api.go

@@ -5,6 +5,7 @@ import (
 	"regexp"
 	"strings"
 
+	"github.com/unistack-org/micro/v3/metadata"
 	"github.com/unistack-org/micro/v3/registry"
 	"github.com/unistack-org/micro/v3/server"
 )
@@ -102,19 +103,23 @@ func Encode(e *Endpoint) map[string]string {
 }
 
 // Decode decodes endpoint metadata into an endpoint
-func Decode(e map[string]string) *Endpoint {
+func Decode(e metadata.Metadata) *Endpoint {
 	if e == nil {
 		return nil
 	}
 
-	return &Endpoint{
-		Name:        e["endpoint"],
-		Description: e["description"],
-		Method:      slice(e["method"]),
-		Path:        slice(e["path"]),
-		Host:        slice(e["host"]),
-		Handler:     e["handler"],
-	}
+	ep := &Endpoint{}
+	ep.Name, _ = e.Get("endpoint")
+	ep.Description, _ = e.Get("description")
+	epmethod, _ := e.Get("method")
+	ep.Method = []string{epmethod}
+	eppath, _ := e.Get("path")
+	ep.Path = []string{eppath}
+	ephost, _ := e.Get("host")
+	ep.Host = []string{ephost}
+	ep.Handler, _ = e.Get("handler")
+
+	return ep
 }
 
 // Validate validates an endpoint to guarantee it won't blow up when being served

api/handler/rpc/rpc.go

@@ -1,495 +0,0 @@
-// Package rpc is a go-micro rpc handler.
-package rpc
-
-import (
-	"encoding/json"
-	"io"
-	"net/http"
-	"strconv"
-	"strings"
-
-	jsonpatch "github.com/evanphx/json-patch/v5"
-	"github.com/oxtoacart/bpool"
-	jsonrpc "github.com/unistack-org/micro-codec-jsonrpc"
-	protorpc "github.com/unistack-org/micro-codec-protorpc"
-	"github.com/unistack-org/micro/v3/api"
-	"github.com/unistack-org/micro/v3/api/handler"
-	"github.com/unistack-org/micro/v3/api/internal/proto"
-	"github.com/unistack-org/micro/v3/client"
-	"github.com/unistack-org/micro/v3/codec"
-	"github.com/unistack-org/micro/v3/errors"
-	"github.com/unistack-org/micro/v3/logger"
-	"github.com/unistack-org/micro/v3/metadata"
-	"github.com/unistack-org/micro/v3/util/ctx"
-	"github.com/unistack-org/micro/v3/util/qson"
-	"github.com/unistack-org/micro/v3/util/router"
-)
-
-const (
-	Handler = "rpc"
-)
-
-var (
-	// supported json codecs
-	jsonCodecs = []string{
-		"application/grpc+json",
-		"application/json",
-		"application/json-rpc",
-	}
-
-	// support proto codecs
-	protoCodecs = []string{
-		"application/grpc",
-		"application/grpc+proto",
-		"application/proto",
-		"application/protobuf",
-		"application/proto-rpc",
-		"application/octet-stream",
-	}
-
-	bufferPool = bpool.NewSizedBufferPool(1024, 8)
-)
-
-type rpcHandler struct {
-	opts handler.Options
-	s    *api.Service
-}
-
-type buffer struct {
-	io.ReadCloser
-}
-
-func (b *buffer) Write(_ []byte) (int, error) {
-	return 0, nil
-}
-
-func (h *rpcHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
-	bsize := handler.DefaultMaxRecvSize
-	if h.opts.MaxRecvSize > 0 {
-		bsize = h.opts.MaxRecvSize
-	}
-
-	r.Body = http.MaxBytesReader(w, r.Body, bsize)
-
-	defer r.Body.Close()
-	var service *api.Service
-
-	if h.s != nil {
-		// we were given the service
-		service = h.s
-	} else if h.opts.Router != nil {
-		// try get service from router
-		s, err := h.opts.Router.Route(r)
-		if err != nil {
-			writeError(w, r, errors.InternalServerError("go.micro.api", err.Error()))
-			return
-		}
-		service = s
-	} else {
-		// we have no way of routing the request
-		writeError(w, r, errors.InternalServerError("go.micro.api", "no route found"))
-		return
-	}
-
-	ct := r.Header.Get("Content-Type")
-
-	// Strip charset from Content-Type (like `application/json; charset=UTF-8`)
-	if idx := strings.IndexRune(ct, ';'); idx >= 0 {
-		ct = ct[:idx]
-	}
-
-	// micro client
-	c := h.opts.Client
-
-	// create context
-	cx := ctx.FromRequest(r)
-
-	// set merged context to request
-	*r = *r.Clone(cx)
-	// if stream we currently only support json
-	if isStream(r, service) {
-		serveWebsocket(cx, w, r, service, c)
-		return
-	}
-
-	// create custom router
-	callOpt := client.WithRouter(router.New(service.Services))
-
-	// walk the standard call path
-	// get payload
-	br, err := requestPayload(r)
-	if err != nil {
-		writeError(w, r, err)
-		return
-	}
-
-	var rsp []byte
-
-	switch {
-	// proto codecs
-	case hasCodec(ct, protoCodecs):
-		request := &proto.Message{}
-		// if the extracted payload isn't empty lets use it
-		if len(br) > 0 {
-			request = proto.NewMessage(br)
-		}
-
-		// create request/response
-		response := &proto.Message{}
-
-		req := c.NewRequest(
-			service.Name,
-			service.Endpoint.Name,
-			request,
-			client.WithContentType(ct),
-		)
-
-		// make the call
-		if err := c.Call(cx, req, response, callOpt); err != nil {
-			writeError(w, r, err)
-			return
-		}
-
-		// marshall response
-		rsp, err = response.Marshal()
-		if err != nil {
-			writeError(w, r, err)
-			return
-		}
-
-	default:
-		// if json codec is not present set to json
-		if !hasCodec(ct, jsonCodecs) {
-			ct = "application/json"
-		}
-
-		// default to trying json
-		var request json.RawMessage
-		// if the extracted payload isn't empty lets use it
-		if len(br) > 0 {
-			request = json.RawMessage(br)
-		}
-
-		// create request/response
-		var response json.RawMessage
-
-		req := c.NewRequest(
-			service.Name,
-			service.Endpoint.Name,
-			&request,
-			client.WithContentType(ct),
-		)
-		// make the call
-		if err := c.Call(cx, req, &response, callOpt); err != nil {
-			writeError(w, r, err)
-			return
-		}
-
-		// marshall response
-		rsp, err = response.MarshalJSON()
-		if err != nil {
-			writeError(w, r, err)
-			return
-		}
-	}
-
-	// write the response
-	writeResponse(w, r, rsp)
-}
-
-func (rh *rpcHandler) String() string {
-	return "rpc"
-}
-
-func hasCodec(ct string, codecs []string) bool {
-	for _, codec := range codecs {
-		if ct == codec {
-			return true
-		}
-	}
-	return false
-}
-
-// requestPayload takes a *http.Request.
-// If the request is a GET the query string parameters are extracted and marshaled to JSON and the raw bytes are returned.
-// If the request method is a POST the request body is read and returned
-func requestPayload(r *http.Request) ([]byte, error) {
-	var err error
-
-	// we have to decode json-rpc and proto-rpc because we suck
-	// well actually because there's no proxy codec right now
-
-	ct := r.Header.Get("Content-Type")
-	switch {
-	case strings.Contains(ct, "application/json-rpc"):
-		msg := codec.Message{
-			Type:   codec.Request,
-			Header: metadata.New(0),
-		}
-		c := jsonrpc.NewCodec(&buffer{r.Body})
-		if err = c.ReadHeader(&msg, codec.Request); err != nil {
-			return nil, err
-		}
-		var raw json.RawMessage
-		if err = c.ReadBody(&raw); err != nil {
-			return nil, err
-		}
-		return ([]byte)(raw), nil
-	case strings.Contains(ct, "application/proto-rpc"), strings.Contains(ct, "application/octet-stream"):
-		msg := codec.Message{
-			Type:   codec.Request,
-			Header: metadata.New(0),
-		}
-		c := protorpc.NewCodec(&buffer{r.Body})
-		if err = c.ReadHeader(&msg, codec.Request); err != nil {
-			return nil, err
-		}
-		var raw proto.Message
-		if err = c.ReadBody(&raw); err != nil {
-			return nil, err
-		}
-		return raw.Marshal()
-	case strings.Contains(ct, "application/www-x-form-urlencoded"):
-		if err = r.ParseForm(); err != nil {
-			return nil, err
-		}
-
-		// generate a new set of values from the form
-		vals := make(map[string]string, len(r.Form))
-		for k, v := range r.Form {
-			vals[k] = strings.Join(v, ",")
-		}
-
-		// marshal
-		return json.Marshal(vals)
-		// TODO: application/grpc
-	}
-
-	// otherwise as per usual
-	ctx := r.Context()
-	// dont user metadata.FromContext as it mangles names
-	md, ok := metadata.FromContext(ctx)
-	if !ok {
-		md = metadata.New(0)
-	}
-
-	// allocate maximum
-	matches := make(map[string]interface{}, len(md))
-	bodydst := ""
-
-	// get fields from url path
-	for k, v := range md {
-		k = strings.ToLower(k)
-		// filter own keys
-		if strings.HasPrefix(k, "x-api-field-") {
-			matches[strings.TrimPrefix(k, "x-api-field-")] = v
-			delete(md, k)
-		} else if k == "x-api-body" {
-			bodydst = v
-			delete(md, k)
-		}
-	}
-
-	// map of all fields
-	req := make(map[string]interface{}, len(md))
-
-	// get fields from url values
-	if len(r.URL.RawQuery) > 0 {
-		umd := make(map[string]interface{})
-		err = qson.Unmarshal(&umd, r.URL.RawQuery)
-		if err != nil {
-			return nil, err
-		}
-		for k, v := range umd {
-			matches[k] = v
-		}
-	}
-
-	// restore context without fields
-	*r = *r.Clone(metadata.NewContext(ctx, md))
-
-	for k, v := range matches {
-		ps := strings.Split(k, ".")
-		if len(ps) == 1 {
-			req[k] = v
-			continue
-		}
-		em := make(map[string]interface{})
-		em[ps[len(ps)-1]] = v
-		for i := len(ps) - 2; i > 0; i-- {
-			nm := make(map[string]interface{})
-			nm[ps[i]] = em
-			em = nm
-		}
-		if vm, ok := req[ps[0]]; ok {
-			// nested map
-			nm := vm.(map[string]interface{})
-			for vk, vv := range em {
-				nm[vk] = vv
-			}
-			req[ps[0]] = nm
-		} else {
-			req[ps[0]] = em
-		}
-	}
-	pathbuf := []byte("{}")
-	if len(req) > 0 {
-		pathbuf, err = json.Marshal(req)
-		if err != nil {
-			return nil, err
-		}
-	}
-
-	urlbuf := []byte("{}")
-	out, err := jsonpatch.MergeMergePatches(urlbuf, pathbuf)
-	if err != nil {
-		return nil, err
-	}
-
-	switch r.Method {
-	case "GET":
-		// empty response
-		if strings.Contains(ct, "application/json") && string(out) == "{}" {
-			return out, nil
-		} else if string(out) == "{}" && !strings.Contains(ct, "application/json") {
-			return []byte{}, nil
-		}
-		return out, nil
-	case "PATCH", "POST", "PUT", "DELETE":
-		bodybuf := []byte("{}")
-		buf := bufferPool.Get()
-		defer bufferPool.Put(buf)
-		if _, err := buf.ReadFrom(r.Body); err != nil {
-			return nil, err
-		}
-		if b := buf.Bytes(); len(b) > 0 {
-			bodybuf = b
-		}
-		if bodydst == "" || bodydst == "*" {
-			if out, err = jsonpatch.MergeMergePatches(out, bodybuf); err == nil {
-				return out, nil
-			}
-		}
-		var jsonbody map[string]interface{}
-		if json.Valid(bodybuf) {
-			if err = json.Unmarshal(bodybuf, &jsonbody); err != nil {
-				return nil, err
-			}
-		}
-		dstmap := make(map[string]interface{})
-		ps := strings.Split(bodydst, ".")
-		if len(ps) == 1 {
-			if jsonbody != nil {
-				dstmap[ps[0]] = jsonbody
-			} else {
-				// old unexpected behaviour
-				dstmap[ps[0]] = bodybuf
-			}
-		} else {
-			em := make(map[string]interface{})
-			if jsonbody != nil {
-				em[ps[len(ps)-1]] = jsonbody
-			} else {
-				// old unexpected behaviour
-				em[ps[len(ps)-1]] = bodybuf
-			}
-			for i := len(ps) - 2; i > 0; i-- {
-				nm := make(map[string]interface{})
-				nm[ps[i]] = em
-				em = nm
-			}
-			dstmap[ps[0]] = em
-		}
-
-		bodyout, err := json.Marshal(dstmap)
-		if err != nil {
-			return nil, err
-		}
-
-		if out, err = jsonpatch.MergeMergePatches(out, bodyout); err == nil {
-			return out, nil
-		}
-
-		//fallback to previous unknown behaviour
-		return bodybuf, nil
-
-	}
-
-	return []byte{}, nil
-}
-
-func writeError(w http.ResponseWriter, r *http.Request, err error) {
-	ce := errors.Parse(err.Error())
-
-	switch ce.Code {
-	case 0:
-		// assuming it's totally screwed
-		ce.Code = 500
-		ce.Id = "go.micro.api"
-		ce.Status = http.StatusText(500)
-		ce.Detail = "error during request: " + ce.Detail
-		w.WriteHeader(500)
-	default:
-		w.WriteHeader(int(ce.Code))
-	}
-
-	// response content type
-	w.Header().Set("Content-Type", "application/json")
-
-	// Set trailers
-	if strings.Contains(r.Header.Get("Content-Type"), "application/grpc") {
-		w.Header().Set("Trailer", "grpc-status")
-		w.Header().Set("Trailer", "grpc-message")
-		w.Header().Set("grpc-status", "13")
-		w.Header().Set("grpc-message", ce.Detail)
-	}
-
-	_, werr := w.Write([]byte(ce.Error()))
-	if werr != nil {
-		if logger.V(logger.ErrorLevel) {
-			logger.Error(werr.Error())
-		}
-	}
-}
-
-func writeResponse(w http.ResponseWriter, r *http.Request, rsp []byte) {
-	w.Header().Set("Content-Type", r.Header.Get("Content-Type"))
-	w.Header().Set("Content-Length", strconv.Itoa(len(rsp)))
-
-	// Set trailers
-	if strings.Contains(r.Header.Get("Content-Type"), "application/grpc") {
-		w.Header().Set("Trailer", "grpc-status")
-		w.Header().Set("Trailer", "grpc-message")
-		w.Header().Set("grpc-status", "0")
-		w.Header().Set("grpc-message", "")
-	}
-
-	// write 204 status if rsp is nil
-	if len(rsp) == 0 {
-		w.WriteHeader(http.StatusNoContent)
-	}
-
-	// write response
-	_, err := w.Write(rsp)
-	if err != nil {
-		if logger.V(logger.ErrorLevel) {
-			logger.Error(err.Error())
-		}
-	}
-
-}
-
-func NewHandler(opts ...handler.Option) handler.Handler {
-	options := handler.NewOptions(opts...)
-	return &rpcHandler{
-		opts: options,
-	}
-}
-
-func WithService(s *api.Service, opts ...handler.Option) handler.Handler {
-	options := handler.NewOptions(opts...)
-	return &rpcHandler{
-		opts: options,
-		s:    s,
-	}
-}

api/handler/rpc/rpc_test.go

@@ -1,112 +0,0 @@
-package rpc
-
-import (
-	"bytes"
-	"net/http"
-	"testing"
-
-	go_api "github.com/unistack-org/micro/v3/api/proto"
-	jsonpb "google.golang.org/protobuf/encoding/protojson"
-	"google.golang.org/protobuf/proto"
-)
-
-func TestRequestPayloadFromRequest(t *testing.T) {
-
-	// our test event so that we can validate serialising / deserializing of true protos works
-	protoEvent := go_api.Event{
-		Name: "Test",
-	}
-
-	protoBytes, err := proto.Marshal(&protoEvent)
-	if err != nil {
-		t.Fatal("Failed to marshal proto", err)
-	}
-
-	jsonBytes, err := jsonpb.Marshal(&protoEvent)
-	if err != nil {
-		t.Fatal("Failed to marshal proto to JSON ", err)
-	}
-
-	jsonUrlBytes := []byte(`{"key1":"val1","key2":"val2","name":"Test"}`)
-
-	t.Run("extracting a json from a POST request with url params", func(t *testing.T) {
-		r, err := http.NewRequest("POST", "http://localhost/my/path?key1=val1&key2=val2", bytes.NewReader(jsonBytes))
-		if err != nil {
-			t.Fatalf("Failed to created http.Request: %v", err)
-		}
-
-		extByte, err := requestPayload(r)
-		if err != nil {
-			t.Fatalf("Failed to extract payload from request: %v", err)
-		}
-		if string(extByte) != string(jsonUrlBytes) {
-			t.Fatalf("Expected %v and %v to match", string(extByte), jsonUrlBytes)
-		}
-	})
-
-	t.Run("extracting a proto from a POST request", func(t *testing.T) {
-		r, err := http.NewRequest("POST", "http://localhost/my/path", bytes.NewReader(protoBytes))
-		if err != nil {
-			t.Fatalf("Failed to created http.Request: %v", err)
-		}
-
-		extByte, err := requestPayload(r)
-		if err != nil {
-			t.Fatalf("Failed to extract payload from request: %v", err)
-		}
-		if string(extByte) != string(protoBytes) {
-			t.Fatalf("Expected %v and %v to match", string(extByte), string(protoBytes))
-		}
-	})
-
-	t.Run("extracting JSON from a POST request", func(t *testing.T) {
-		r, err := http.NewRequest("POST", "http://localhost/my/path", bytes.NewReader(jsonBytes))
-		if err != nil {
-			t.Fatalf("Failed to created http.Request: %v", err)
-		}
-
-		extByte, err := requestPayload(r)
-		if err != nil {
-			t.Fatalf("Failed to extract payload from request: %v", err)
-		}
-		if string(extByte) != string(jsonBytes) {
-			t.Fatalf("Expected %v and %v to match", string(extByte), string(jsonBytes))
-		}
-	})
-
-	t.Run("extracting params from a GET request", func(t *testing.T) {
-
-		r, err := http.NewRequest("GET", "http://localhost/my/path", nil)
-		if err != nil {
-			t.Fatalf("Failed to created http.Request: %v", err)
-		}
-
-		q := r.URL.Query()
-		q.Add("name", "Test")
-		r.URL.RawQuery = q.Encode()
-
-		extByte, err := requestPayload(r)
-		if err != nil {
-			t.Fatalf("Failed to extract payload from request: %v", err)
-		}
-		if string(extByte) != string(jsonBytes) {
-			t.Fatalf("Expected %v and %v to match", string(extByte), string(jsonBytes))
-		}
-	})
-
-	t.Run("GET request with no params", func(t *testing.T) {
-
-		r, err := http.NewRequest("GET", "http://localhost/my/path", nil)
-		if err != nil {
-			t.Fatalf("Failed to created http.Request: %v", err)
-		}
-
-		extByte, err := requestPayload(r)
-		if err != nil {
-			t.Fatalf("Failed to extract payload from request: %v", err)
-		}
-		if string(extByte) != "" {
-			t.Fatalf("Expected %v and %v to match", string(extByte), "")
-		}
-	})
-}

api/handler/rpc/stream.go

@@ -1,263 +0,0 @@
-package rpc
-
-import (
-	"bytes"
-	"context"
-	"encoding/json"
-	"io"
-	"net/http"
-	"strings"
-	"time"
-
-	"github.com/gobwas/httphead"
-	"github.com/gobwas/ws"
-	"github.com/gobwas/ws/wsutil"
-	raw "github.com/unistack-org/micro-codec-bytes"
-	"github.com/unistack-org/micro/v3/api"
-	"github.com/unistack-org/micro/v3/client"
-	"github.com/unistack-org/micro/v3/logger"
-	"github.com/unistack-org/micro/v3/util/router"
-)
-
-// serveWebsocket will stream rpc back over websockets assuming json
-func serveWebsocket(ctx context.Context, w http.ResponseWriter, r *http.Request, service *api.Service, c client.Client) {
-	var op ws.OpCode
-
-	ct := r.Header.Get("Content-Type")
-	// Strip charset from Content-Type (like `application/json; charset=UTF-8`)
-	if idx := strings.IndexRune(ct, ';'); idx >= 0 {
-		ct = ct[:idx]
-	}
-
-	// check proto from request
-	switch ct {
-	case "application/json":
-		op = ws.OpText
-	default:
-		op = ws.OpBinary
-	}
-
-	hdr := make(http.Header)
-	if proto, ok := r.Header["Sec-WebSocket-Protocol"]; ok {
-		for _, p := range proto {
-			switch p {
-			case "binary":
-				hdr["Sec-WebSocket-Protocol"] = []string{"binary"}
-				op = ws.OpBinary
-			default:
-				op = ws.OpBinary
-			}
-		}
-	}
-	payload, err := requestPayload(r)
-	if err != nil {
-		if logger.V(logger.ErrorLevel) {
-			logger.Error(err.Error())
-		}
-		return
-	}
-
-	upgrader := ws.HTTPUpgrader{Timeout: 5 * time.Second,
-		Protocol: func(proto string) bool {
-			if strings.Contains(proto, "binary") {
-				return true
-			}
-			// fallback to support all protocols now
-			return true
-		},
-		Extension: func(httphead.Option) bool {
-			// disable extensions for compatibility
-			return false
-		},
-		Header: hdr,
-	}
-
-	conn, rw, _, err := upgrader.Upgrade(r, w)
-	if err != nil {
-		if logger.V(logger.ErrorLevel) {
-			logger.Error(err.Error())
-		}
-		return
-	}
-
-	defer func() {
-		if err := conn.Close(); err != nil {
-			if logger.V(logger.ErrorLevel) {
-				logger.Error(err.Error())
-			}
-			return
-		}
-	}()
-
-	var request interface{}
-	if !bytes.Equal(payload, []byte(`{}`)) {
-		switch ct {
-		case "application/json", "":
-			m := json.RawMessage(payload)
-			request = &m
-		default:
-			request = &raw.Frame{Data: payload}
-		}
-	}
-
-	// we always need to set content type for message
-	if ct == "" {
-		ct = "application/json"
-	}
-	req := c.NewRequest(
-		service.Name,
-		service.Endpoint.Name,
-		request,
-		client.WithContentType(ct),
-		client.StreamingRequest(),
-	)
-
-	// create custom router
-	callOpt := client.WithRouter(router.New(service.Services))
-
-	// create a new stream
-	stream, err := c.Stream(ctx, req, callOpt)
-	if err != nil {
-		if logger.V(logger.ErrorLevel) {
-			logger.Error(err.Error())
-		}
-		return
-	}
-
-	if request != nil {
-		if err = stream.Send(request); err != nil {
-			if logger.V(logger.ErrorLevel) {
-				logger.Error(err.Error())
-			}
-			return
-		}
-	}
-
-	go writeLoop(rw, stream)
-
-	rsp := stream.Response()
-
-	// receive from stream and send to client
-	for {
-		select {
-		case <-ctx.Done():
-			return
-		case <-stream.Context().Done():
-			return
-		default:
-			// read backend response body
-			buf, err := rsp.Read()
-			if err != nil {
-				// wants to avoid import  grpc/status.Status
-				if strings.Contains(err.Error(), "context canceled") {
-					return
-				}
-				if logger.V(logger.ErrorLevel) {
-					logger.Error(err.Error())
-				}
-				return
-			}
-
-			// write the response
-			if err := wsutil.WriteServerMessage(rw, op, buf); err != nil {
-				if logger.V(logger.ErrorLevel) {
-					logger.Error(err.Error())
-				}
-				return
-			}
-			if err = rw.Flush(); err != nil {
-				if logger.V(logger.ErrorLevel) {
-					logger.Error(err.Error())
-				}
-				return
-			}
-		}
-	}
-}
-
-// writeLoop
-func writeLoop(rw io.ReadWriter, stream client.Stream) {
-	// close stream when done
-	defer stream.Close()
-
-	for {
-		select {
-		case <-stream.Context().Done():
-			return
-		default:
-			buf, op, err := wsutil.ReadClientData(rw)
-			if err != nil {
-				if wserr, ok := err.(wsutil.ClosedError); ok {
-					switch wserr.Code {
-					case ws.StatusGoingAway:
-						// this happens when user leave the page
-						return
-					case ws.StatusNormalClosure, ws.StatusNoStatusRcvd:
-						// this happens when user close ws connection, or we don't get any status
-						return
-					}
-				}
-				if logger.V(logger.ErrorLevel) {
-					logger.Error(err.Error())
-				}
-				return
-			}
-			switch op {
-			default:
-				// not relevant
-				continue
-			case ws.OpText, ws.OpBinary:
-				break
-			}
-			// send to backend
-			// default to trying json
-			// if the extracted payload isn't empty lets use it
-			request := &raw.Frame{Data: buf}
-			if err := stream.Send(request); err != nil {
-				if logger.V(logger.ErrorLevel) {
-					logger.Error(err.Error())
-				}
-				return
-			}
-		}
-	}
-}
-
-func isStream(r *http.Request, srv *api.Service) bool {
-	// check if it's a web socket
-	if !isWebSocket(r) {
-		return false
-	}
-	// check if the endpoint supports streaming
-	for _, service := range srv.Services {
-		for _, ep := range service.Endpoints {
-			// skip if it doesn't match the name
-			if ep.Name != srv.Endpoint.Name {
-				continue
-			}
-			// matched if the name
-			if v := ep.Metadata["stream"]; v == "true" {
-				return true
-			}
-		}
-	}
-	return false
-}
-
-func isWebSocket(r *http.Request) bool {
-	contains := func(key, val string) bool {
-		vv := strings.Split(r.Header.Get(key), ",")
-		for _, v := range vv {
-			if val == strings.ToLower(strings.TrimSpace(v)) {
-				return true
-			}
-		}
-		return false
-	}
-
-	if contains("Connection", "upgrade") && contains("Upgrade", "websocket") {
-		return true
-	}
-
-	return false
-}

api/resolver/options.go

@@ -1,6 +1,8 @@
 package resolver
 
 import (
+	"context"
+
 	"github.com/unistack-org/micro/v3/registry"
 )
 
@@ -8,6 +10,7 @@ import (
 type Options struct {
 	Handler       string
 	ServicePrefix string
+	Context       context.Context
 }
 
 // Option func
@@ -29,7 +32,9 @@ func WithServicePrefix(p string) Option {
 
 // NewOptions returns new initialised options
 func NewOptions(opts ...Option) Options {
-	options := Options{}
+	options := Options{
+		Context: context.Background(),
+	}
 	for _, o := range opts {
 		o(&options)
 	}

api/resolver/subdomain/subdomain.go

@@ -55,7 +55,7 @@ func (r *Resolver) Domain(req *http.Request) string {
 	domain, err := publicsuffix.EffectiveTLDPlusOne(host)
 	if err != nil {
 		if logger.V(logger.DebugLevel) {
-			logger.Debug("Unable to extract domain from %v", host)
+			logger.Debug(r.opts.Context, "Unable to extract domain from %v", host)
 		}
 		return ""
 	}

api/router/router.go

@@ -11,6 +11,8 @@ import (
 type Router interface {
 	// Returns options
 	Options() Options
+	// Init initialize router
+	Init(...Option) error
 	// Stop the router
 	Close() error
 	// Endpoint returns an api.Service endpoint or an error if it does not exist
@@ -21,4 +23,6 @@ type Router interface {
 	Deregister(ep *api.Endpoint) error
 	// Route returns an api.Service route
 	Route(r *http.Request) (*api.Service, error)
+	// String represenation of router
+	String() string
 }

api/server/acme/autocert/autocert.go

@@ -7,13 +7,16 @@ import (
 	"net"
 	"os"
 
+	"github.com/unistack-org/micro/v3/api/server"
 	"github.com/unistack-org/micro/v3/api/server/acme"
 	"github.com/unistack-org/micro/v3/logger"
 	"golang.org/x/crypto/acme/autocert"
 )
 
 // autoCertACME is the ACME provider from golang.org/x/crypto/acme/autocert
-type autocertProvider struct{}
+type autocertProvider struct {
+	opts server.Options
+}
 
 func (a *autocertProvider) Init(opts ...acme.Option) error {
 	return nil
@@ -36,7 +39,7 @@ func (a *autocertProvider) TLSConfig(hosts ...string) (*tls.Config, error) {
 	dir := cacheDir()
 	if err := os.MkdirAll(dir, 0700); err != nil {
 		if logger.V(logger.InfoLevel) {
-			logger.Info("warning: autocert not using a cache: %v", err)
+			logger.Info(a.opts.Context, "warning: autocert not using a cache: %v", err)
 		}
 	} else {
 		m.Cache = autocert.DirCache(dir)

api/server/acme/certmagic/storage.go

@@ -4,7 +4,6 @@ import (
 	"bytes"
 	"encoding/gob"
 	"errors"
-	"fmt"
 	"path"
 	"strings"
 	"time"
@@ -48,25 +47,19 @@ func (s *storage) Store(key string, value []byte) error {
 	if err := e.Encode(f); err != nil {
 		return err
 	}
-	r := &store.Record{
-		Key:   key,
-		Value: buf.Bytes(),
-	}
-	return s.store.Write(s.store.Options().Context, r)
+	return s.store.Write(s.store.Options().Context, key, buf.Bytes())
 }
 
 func (s *storage) Load(key string) ([]byte, error) {
 	if !s.Exists(key) {
 		return nil, certmagic.ErrNotExist(errors.New(key + " doesn't exist"))
 	}
-	records, err := s.store.Read(s.store.Options().Context, key)
+	var val []byte
+	err := s.store.Read(s.store.Options().Context, key, val)
 	if err != nil {
 		return nil, err
 	}
-	if len(records) != 1 {
-		return nil, fmt.Errorf("ACME Storage: multiple records matched key %s", key)
-	}
-	b := bytes.NewBuffer(records[0].Value)
+	b := bytes.NewBuffer(val)
 	d := gob.NewDecoder(b)
 	var f File
 	err = d.Decode(&f)
@@ -81,7 +74,7 @@ func (s *storage) Delete(key string) error {
 }
 
 func (s *storage) Exists(key string) bool {
-	if _, err := s.store.Read(s.store.Options().Context, key); err != nil {
+	if err := s.store.Read(s.store.Options().Context, key, nil); err != nil {
 		return false
 	}
 	return true
@@ -116,14 +109,12 @@ func (s *storage) List(prefix string, recursive bool) ([]string, error) {
 }
 
 func (s *storage) Stat(key string) (certmagic.KeyInfo, error) {
-	records, err := s.store.Read(s.store.Options().Context, key)
+	var val []byte
+	err := s.store.Read(s.store.Options().Context, key, val)
 	if err != nil {
 		return certmagic.KeyInfo{}, err
 	}
-	if len(records) != 1 {
-		return certmagic.KeyInfo{}, fmt.Errorf("ACME Storage: multiple records matched key %s", key)
-	}
-	b := bytes.NewBuffer(records[0].Value)
+	b := bytes.NewBuffer(val)
 	d := gob.NewDecoder(b)
 	var f File
 	err = d.Decode(&f)
@@ -138,7 +129,7 @@ func (s *storage) Stat(key string) (certmagic.KeyInfo, error) {
 	}, nil
 }
 
-// NewStorage returns a certmagic.Storage backed by a go-micro/lock and go-micro/store
+// NewStorage returns a certmagic.Storage backed by a micro/lock and micro/store
 func NewStorage(lock sync.Sync, store store.Store) certmagic.Storage {
 	return &storage{
 		lock:  lock,

api/server/http/http.go

@@ -74,7 +74,7 @@ func (s *httpServer) Start() error {
 	}
 
 	if config.Logger.V(logger.InfoLevel) {
-		config.Logger.Info("HTTP API Listening on %s", l.Addr().String())
+		config.Logger.Infof(s.opts.Context, "HTTP API Listening on %s", l.Addr().String())
 	}
 
 	s.Lock()
@@ -85,7 +85,7 @@ func (s *httpServer) Start() error {
 		if err := http.Serve(l, s.mux); err != nil {
 			// temporary fix
 			if config.Logger.V(logger.ErrorLevel) {
-				config.Logger.Error("serve err: %v", err)
+				config.Logger.Errorf(s.opts.Context, "serve err: %v", err)
 			}
 			s.Stop()
 		}

api/server/options.go

@@ -1,6 +1,7 @@
 package server
 
 import (
+	"context"
 	"crypto/tls"
 	"net/http"
 
@@ -23,12 +24,14 @@ type Options struct {
 	Resolver     resolver.Resolver
 	Wrappers     []Wrapper
 	Logger       logger.Logger
+	Context      context.Context
 }
 
 // NewOptions returns new Options
 func NewOptions(opts ...Option) Options {
 	options := Options{
-		Logger: logger.DefaultLogger,
+		Logger:  logger.DefaultLogger,
+		Context: context.Background(),
 	}
 	for _, o := range opts {
 		o(&options)

auth/auth.go

@@ -5,6 +5,8 @@ import (
 	"context"
 	"errors"
 	"time"
+
+	"github.com/unistack-org/micro/v3/metadata"
 )
 
 const (
@@ -17,7 +19,7 @@ const (
 )
 
 var (
-	DefaultAuth Auth = &NoopAuth{opts: NewOptions()}
+	DefaultAuth Auth = NewAuth()
 	// ErrInvalidToken is when the token provided is not valid
 	ErrInvalidToken = errors.New("invalid token provided")
 	// ErrForbidden is when a user does not have the necessary scope to access a resource
@@ -57,7 +59,7 @@ type Account struct {
 	// Issuer of the account
 	Issuer string `json:"issuer"`
 	// Any other associated metadata
-	Metadata map[string]string `json:"metadata"`
+	Metadata metadata.Metadata `json:"metadata"`
 	// Scopes the account has access to
 	Scopes []string `json:"scopes"`
 	// Secret for the account, e.g. the password
@@ -124,11 +126,17 @@ type accountKey struct{}
 // is not set, a nil account will be returned. The error is only returned
 // when there was a problem retrieving an account
 func AccountFromContext(ctx context.Context) (*Account, bool) {
+	if ctx == nil {
+		return nil, false
+	}
 	acc, ok := ctx.Value(accountKey{}).(*Account)
 	return acc, ok
 }
 
 // ContextWithAccount sets the account in the context
 func ContextWithAccount(ctx context.Context, account *Account) context.Context {
+	if ctx == nil {
+		ctx = context.Background()
+	}
 	return context.WithValue(ctx, accountKey{}, account)
 }

auth/noop.go

@@ -4,29 +4,29 @@ import (
 	"github.com/google/uuid"
 )
 
-type NoopAuth struct {
+type noopAuth struct {
 	opts Options
 }
 
 // String returns the name of the implementation
-func (n *NoopAuth) String() string {
+func (n *noopAuth) String() string {
 	return "noop"
 }
 
 // Init the auth
-func (n *NoopAuth) Init(opts ...Option) {
+func (n *noopAuth) Init(opts ...Option) {
 	for _, o := range opts {
 		o(&n.opts)
 	}
 }
 
 // Options set for auth
-func (n *NoopAuth) Options() Options {
+func (n *noopAuth) Options() Options {
 	return n.opts
 }
 
 // Generate a new account
-func (n *NoopAuth) Generate(id string, opts ...GenerateOption) (*Account, error) {
+func (n *noopAuth) Generate(id string, opts ...GenerateOption) (*Account, error) {
 	options := NewGenerateOptions(opts...)
 
 	return &Account{
@@ -39,27 +39,27 @@ func (n *NoopAuth) Generate(id string, opts ...GenerateOption) (*Account, error)
 }
 
 // Grant access to a resource
-func (n *NoopAuth) Grant(rule *Rule) error {
+func (n *noopAuth) Grant(rule *Rule) error {
 	return nil
 }
 
 // Revoke access to a resource
-func (n *NoopAuth) Revoke(rule *Rule) error {
+func (n *noopAuth) Revoke(rule *Rule) error {
 	return nil
 }
 
 // Rules used to verify requests
-func (n *NoopAuth) Rules(opts ...RulesOption) ([]*Rule, error) {
+func (n *noopAuth) Rules(opts ...RulesOption) ([]*Rule, error) {
 	return []*Rule{}, nil
 }
 
 // Verify an account has access to a resource
-func (n *NoopAuth) Verify(acc *Account, res *Resource, opts ...VerifyOption) error {
+func (n *noopAuth) Verify(acc *Account, res *Resource, opts ...VerifyOption) error {
 	return nil
 }
 
 // Inspect a token
-func (n *NoopAuth) Inspect(token string) (*Account, error) {
+func (n *noopAuth) Inspect(token string) (*Account, error) {
 	uid, err := uuid.NewRandom()
 	if err != nil {
 		return nil, err
@@ -68,6 +68,11 @@ func (n *NoopAuth) Inspect(token string) (*Account, error) {
 }
 
 // Token generation using an account id and secret
-func (n *NoopAuth) Token(opts ...TokenOption) (*Token, error) {
+func (n *noopAuth) Token(opts ...TokenOption) (*Token, error) {
 	return &Token{}, nil
 }
+
+// NewAuth returns new noop auth
+func NewAuth(opts ...Option) Auth {
+	return &noopAuth{opts: NewOptions(opts...)}
+}

auth/options.go

@@ -5,11 +5,15 @@ import (
 	"time"
 
 	"github.com/unistack-org/micro/v3/logger"
+	"github.com/unistack-org/micro/v3/metadata"
 	"github.com/unistack-org/micro/v3/store"
 )
 
+// NewOptions creates Options struct from slice of options
 func NewOptions(opts ...Option) Options {
-	var options Options
+	options := Options{
+		Logger: logger.DefaultLogger,
+	}
 	for _, o := range opts {
 		o(&options)
 	}
@@ -41,6 +45,7 @@ type Options struct {
 	Context context.Context
 }
 
+// Option func
 type Option func(o *Options)
 
 // Addrs is the auth addresses to use
@@ -100,9 +105,10 @@ func LoginURL(url string) Option {
 	}
 }
 
+// GenerateOptions struct
 type GenerateOptions struct {
 	// Metadata associated with the account
-	Metadata map[string]string
+	Metadata metadata.Metadata
 	// Scopes the account has access too
 	Scopes []string
 	// Provider of the account, e.g. oauth
@@ -115,6 +121,7 @@ type GenerateOptions struct {
 	Issuer string
 }
 
+// GenerateOption func
 type GenerateOption func(o *GenerateOptions)
 
 // WithSecret for the generated account
@@ -132,9 +139,9 @@ func WithType(t string) GenerateOption {
 }
 
 // WithMetadata for the generated account
-func WithMetadata(md map[string]string) GenerateOption {
+func WithMetadata(md metadata.Metadata) GenerateOption {
 	return func(o *GenerateOptions) {
-		o.Metadata = md
+		o.Metadata = metadata.Copy(md)
 	}
 }
 
@@ -168,6 +175,7 @@ func NewGenerateOptions(opts ...GenerateOption) GenerateOptions {
 	return options
 }
 
+// TokenOptions struct
 type TokenOptions struct {
 	// ID for the account
 	ID string
@@ -181,6 +189,7 @@ type TokenOptions struct {
 	Issuer string
 }
 
+// TokenOption func
 type TokenOption func(o *TokenOptions)
 
 // WithExpiry for the token
@@ -190,6 +199,7 @@ func WithExpiry(ex time.Duration) TokenOption {
 	}
 }
 
+// WithCredentials sets tye id and secret
 func WithCredentials(id, secret string) TokenOption {
 	return func(o *TokenOptions) {
 		o.ID = id
@@ -197,12 +207,14 @@ func WithCredentials(id, secret string) TokenOption {
 	}
 }
 
+// WithToken sets the refresh token
 func WithToken(rt string) TokenOption {
 	return func(o *TokenOptions) {
 		o.RefreshToken = rt
 	}
 }
 
+// WithTokenIssuer sets the token issuer option
 func WithTokenIssuer(iss string) TokenOption {
 	return func(o *TokenOptions) {
 		o.Issuer = iss
@@ -224,39 +236,55 @@ func NewTokenOptions(opts ...TokenOption) TokenOptions {
 	return options
 }
 
+// VerifyOptions struct
 type VerifyOptions struct {
 	Context   context.Context
 	Namespace string
 }
 
+// VerifyOption func
 type VerifyOption func(o *VerifyOptions)
 
+// VerifyContext pass context to verify
 func VerifyContext(ctx context.Context) VerifyOption {
 	return func(o *VerifyOptions) {
 		o.Context = ctx
 	}
 }
+
+// VerifyNamespace sets thhe namespace for verify
 func VerifyNamespace(ns string) VerifyOption {
 	return func(o *VerifyOptions) {
 		o.Namespace = ns
 	}
 }
 
+// RulesOptions struct
 type RulesOptions struct {
 	Context   context.Context
 	Namespace string
 }
 
+// RulesOption func
 type RulesOption func(o *RulesOptions)
 
+// RulesContext pass rules context
 func RulesContext(ctx context.Context) RulesOption {
 	return func(o *RulesOptions) {
 		o.Context = ctx
 	}
 }
 
+// RulesNamespace sets the rule namespace
 func RulesNamespace(ns string) RulesOption {
 	return func(o *RulesOptions) {
 		o.Namespace = ns
 	}
 }
+
+// Logger sets the logger
+func Logger(l logger.Logger) Option {
+	return func(o *Options) {
+		o.Logger = l
+	}
+}

broker/broker.go

@@ -1,9 +1,14 @@
 // Package broker is an interface used for asynchronous messaging
 package broker
 
-import "context"
+import (
+	"context"
+
+	"github.com/unistack-org/micro/v3/metadata"
+)
 
 var (
+	// DefaultBroker default broker
 	DefaultBroker Broker = NewBroker()
 )
 
@@ -32,7 +37,7 @@ type Event interface {
 
 // Message is used to transfer data
 type Message struct {
-	Header map[string]string // contains message metadata
+	Header metadata.Metadata // contains message metadata
 	Body   []byte            // contains message body
 }
 

broker/context.go

@@ -6,12 +6,20 @@ import (
 
 type brokerKey struct{}
 
+// FromContext returns broker from passed context
 func FromContext(ctx context.Context) (Broker, bool) {
+	if ctx == nil {
+		return nil, false
+	}
 	c, ok := ctx.Value(brokerKey{}).(Broker)
 	return c, ok
 }
 
+// NewContext savess broker in context
 func NewContext(ctx context.Context, s Broker) context.Context {
+	if ctx == nil {
+		ctx = context.Background()
+	}
 	return context.WithValue(ctx, brokerKey{}, s)
 }
 

broker/options.go

@@ -13,9 +13,11 @@ import (
 type Options struct {
 	Addrs  []string
 	Secure bool
-	Codec  codec.Marshaler
 
-	// Logger
+	// Codec
+	Codec codec.Codec
+
+	// Logger the logger
 	Logger logger.Logger
 	// Handler executed when errors occur processing messages
 	ErrorHandler Handler
@@ -50,6 +52,8 @@ func Context(ctx context.Context) Option {
 
 // PublishOptions struct
 type PublishOptions struct {
+	// BodyOnly says that only body of the message must be published
+	BodyOnly bool
 	// Other options for implementations of the interface
 	// can be stored in a context
 	Context context.Context
@@ -81,6 +85,9 @@ type SubscribeOptions struct {
 	// receives a subset of messages.
 	Group string
 
+	// BodyOnly says that consumed only body of the message
+	BodyOnly bool
+
 	// Other options for implementations of the interface
 	// can be stored in a context
 	Context context.Context
@@ -92,6 +99,13 @@ type Option func(*Options)
 // PublishOption func
 type PublishOption func(*PublishOptions)
 
+// PublishBodyOnly publish only body of the message
+func PublishBodyOnly(b bool) PublishOption {
+	return func(o *PublishOptions) {
+		o.BodyOnly = b
+	}
+}
+
 // PublishContext sets the context
 func PublishContext(ctx context.Context) PublishOption {
 	return func(o *PublishOptions) {
@@ -125,7 +139,7 @@ func Addrs(addrs ...string) Option {
 
 // Codec sets the codec used for encoding/decoding used where
 // a broker does not support headers
-func Codec(c codec.Marshaler) Option {
+func Codec(c codec.Codec) Option {
 	return func(o *Options) {
 		o.Codec = c
 	}
@@ -146,6 +160,13 @@ func SubscribeAutoAck(b bool) SubscribeOption {
 	}
 }
 
+// SubscribeBodyOnly consumes only body of the message
+func SubscribeBodyOnly(b bool) SubscribeOption {
+	return func(o *SubscribeOptions) {
+		o.BodyOnly = b
+	}
+}
+
 // ErrorHandler will catch all broker errors that cant be handled
 // in normal way, for example Codec errors
 func ErrorHandler(h Handler) Option {
@@ -162,7 +183,8 @@ func SubscribeErrorHandler(h Handler) SubscribeOption {
 	}
 }
 
-// Queue sets the subscribers sueue
+// Queue sets the subscribers queue
+// Deprecated
 func Queue(name string) SubscribeOption {
 	return func(o *SubscribeOptions) {
 		o.Group = name

client/client.go

@@ -6,6 +6,7 @@ import (
 	"time"
 
 	"github.com/unistack-org/micro/v3/codec"
+	"github.com/unistack-org/micro/v3/metadata"
 )
 
 var (
@@ -47,7 +48,7 @@ type Request interface {
 	// The unencoded request body
 	Body() interface{}
 	// Write to the encoded request writer. This is nil before a call is made
-	Codec() codec.Writer
+	Codec() codec.Codec
 	// indicates whether the request will be a streaming one rather than unary
 	Stream() bool
 }
@@ -55,9 +56,9 @@ type Request interface {
 // Response is the response received from a service
 type Response interface {
 	// Read the response
-	Codec() codec.Reader
+	Codec() codec.Codec
 	// read the header
-	Header() map[string]string
+	Header() metadata.Metadata
 	// Read the undecoded response
 	Read() ([]byte, error)
 }
@@ -99,9 +100,9 @@ var (
 	// DefaultBackoff is the default backoff function for retries
 	DefaultBackoff = exponentialBackoff
 	// DefaultRetry is the default check-for-retry function for retries
-	DefaultRetry = RetryOnError
+	DefaultRetry = RetryNever
 	// DefaultRetries is the default number of times a request is tried
-	DefaultRetries = 1
+	DefaultRetries = 0
 	// DefaultRequestTimeout is the default request timeout
 	DefaultRequestTimeout = time.Second * 5
 	// DefaultPoolSize sets the connection pool size

client/client_call_options.go

@@ -0,0 +1,23 @@
+package client
+
+import (
+	"context"
+)
+
+type clientCallOptions struct {
+	Client
+	opts []CallOption
+}
+
+func (s *clientCallOptions) Call(ctx context.Context, req Request, rsp interface{}, opts ...CallOption) error {
+	return s.Client.Call(ctx, req, rsp, append(s.opts, opts...)...)
+}
+
+func (s *clientCallOptions) Stream(ctx context.Context, req Request, opts ...CallOption) (Stream, error) {
+	return s.Client.Stream(ctx, req, append(s.opts, opts...)...)
+}
+
+// NewClientCallOptions add CallOption to every call
+func NewClientCallOptions(c Client, opts ...CallOption) Client {
+	return &clientCallOptions{c, opts}
+}

client/context.go

@@ -6,12 +6,20 @@ import (
 
 type clientKey struct{}
 
+// FromContext get client from context
 func FromContext(ctx context.Context) (Client, bool) {
+	if ctx == nil {
+		return nil, false
+	}
 	c, ok := ctx.Value(clientKey{}).(Client)
 	return c, ok
 }
 
+// NewContext put client in context
 func NewContext(ctx context.Context, c Client) context.Context {
+	if ctx == nil {
+		ctx = context.Background()
+	}
 	return context.WithValue(ctx, clientKey{}, c)
 }
 

client/lookup.go

@@ -18,6 +18,10 @@ func LookupRoute(ctx context.Context, req Request, opts CallOptions) ([]string,
 		return opts.Address, nil
 	}
 
+	if opts.Router == nil {
+		return nil, router.ErrRouteNotFound
+	}
+
 	// construct the router query
 	query := []router.QueryOption{router.QueryService(req.Service())}
 

client/noop.go

@@ -3,14 +3,27 @@ package client
 import (
 	"context"
 
-	raw "github.com/unistack-org/micro-codec-bytes"
-	json "github.com/unistack-org/micro-codec-json"
 	"github.com/unistack-org/micro/v3/broker"
 	"github.com/unistack-org/micro/v3/codec"
 	"github.com/unistack-org/micro/v3/errors"
 	"github.com/unistack-org/micro/v3/metadata"
 )
 
+var (
+	// DefaultCodecs will be used to encode/decode data
+	DefaultCodecs = map[string]codec.Codec{
+		//"application/json":         cjson.NewCodec,
+		//"application/json-rpc":     cjsonrpc.NewCodec,
+		//"application/protobuf":     cproto.NewCodec,
+		//"application/proto-rpc":    cprotorpc.NewCodec,
+		"application/octet-stream": codec.NewCodec(),
+	}
+)
+
+const (
+	defaultContentType = "application/json"
+)
+
 type noopClient struct {
 	opts Options
 }
@@ -27,7 +40,7 @@ type noopRequest struct {
 	endpoint    string
 	contentType string
 	body        interface{}
-	codec       codec.Writer
+	codec       codec.Codec
 	stream      bool
 }
 
@@ -56,7 +69,7 @@ func (n *noopRequest) Body() interface{} {
 	return n.body
 }
 
-func (n *noopRequest) Codec() codec.Writer {
+func (n *noopRequest) Codec() codec.Codec {
 	return n.codec
 }
 
@@ -65,15 +78,15 @@ func (n *noopRequest) Stream() bool {
 }
 
 type noopResponse struct {
-	codec  codec.Reader
-	header map[string]string
+	codec  codec.Codec
+	header metadata.Metadata
 }
 
-func (n *noopResponse) Codec() codec.Reader {
+func (n *noopResponse) Codec() codec.Codec {
 	return n.codec
 }
 
-func (n *noopResponse) Header() map[string]string {
+func (n *noopResponse) Header() metadata.Metadata {
 	return n.header
 }
 
@@ -123,6 +136,16 @@ func (n *noopMessage) ContentType() string {
 	return n.opts.ContentType
 }
 
+func (n *noopClient) newCodec(contentType string) (codec.Codec, error) {
+	if cf, ok := n.opts.Codecs[contentType]; ok {
+		return cf, nil
+	}
+	if cf, ok := DefaultCodecs[contentType]; ok {
+		return cf, nil
+	}
+	return nil, codec.ErrUnknownContentType
+}
+
 func (n *noopClient) Init(opts ...Option) error {
 	for _, o := range opts {
 		o(&n.opts)
@@ -168,21 +191,15 @@ func (n *noopClient) Publish(ctx context.Context, p Message, opts ...PublishOpti
 	md["Micro-Topic"] = p.Topic()
 
 	// passed in raw data
-	if d, ok := p.Payload().(*raw.Frame); ok {
+	if d, ok := p.Payload().(*codec.Frame); ok {
 		body = d.Data
 	} else {
-		cf := n.opts.Broker.Options().Codec
-		if cf == nil {
-			cf = json.Marshaler{}
+		// use codec for payload
+		cf, err := n.newCodec(p.ContentType())
+		if err != nil {
+			return errors.InternalServerError("go.micro.client", err.Error())
 		}
 
-		/*
-			// use codec for payload
-			cf, err := n.opts.Codecs[p.ContentType()]
-			if err != nil {
-				return errors.InternalServerError("go.micro.client", err.Error())
-			}
-		*/
 		// set the body
 		b, err := cf.Marshal(p.Payload())
 		if err != nil {

client/options.go

@@ -14,6 +14,7 @@ import (
 	"github.com/unistack-org/micro/v3/selector/random"
 )
 
+// Options holds client options
 type Options struct {
 	// Used to select codec
 	ContentType string
@@ -22,7 +23,7 @@ type Options struct {
 
 	// Plugged interfaces
 	Broker    broker.Broker
-	Codecs    map[string]codec.NewCodec
+	Codecs    map[string]codec.Codec
 	Router    router.Router
 	Selector  selector.Selector
 	Transport transport.Transport
@@ -45,6 +46,7 @@ type Options struct {
 	Context context.Context
 }
 
+// NewCallOptions creates new call options struct
 func NewCallOptions(opts ...CallOption) CallOptions {
 	options := CallOptions{}
 	for _, o := range opts {
@@ -53,6 +55,7 @@ func NewCallOptions(opts ...CallOption) CallOptions {
 	return options
 }
 
+// CallOptions holds client call options
 type CallOptions struct {
 	// Address of remote hosts
 	Address []string
@@ -87,12 +90,14 @@ type CallOptions struct {
 	Context context.Context
 }
 
+// Context pass context to client
 func Context(ctx context.Context) Option {
 	return func(o *Options) {
 		o.Context = ctx
 	}
 }
 
+// NewPublishOptions create new PublishOptions struct from option
 func NewPublishOptions(opts ...PublishOption) PublishOptions {
 	options := PublishOptions{}
 	for _, o := range opts {
@@ -101,6 +106,7 @@ func NewPublishOptions(opts ...PublishOption) PublishOptions {
 	return options
 }
 
+// PublishOptions holds publish options
 type PublishOptions struct {
 	// Exchange is the routing exchange for the message
 	Exchange string
@@ -109,6 +115,7 @@ type PublishOptions struct {
 	Context context.Context
 }
 
+// NewMessageOptions creates message options struct
 func NewMessageOptions(opts ...MessageOption) MessageOptions {
 	options := MessageOptions{}
 	for _, o := range opts {
@@ -117,10 +124,12 @@ func NewMessageOptions(opts ...MessageOption) MessageOptions {
 	return options
 }
 
+// MessageOptions holds client message options
 type MessageOptions struct {
 	ContentType string
 }
 
+// NewRequestOptions creates new RequestOptions struct
 func NewRequestOptions(opts ...RequestOption) RequestOptions {
 	options := RequestOptions{}
 	for _, o := range opts {
@@ -129,6 +138,7 @@ func NewRequestOptions(opts ...RequestOption) RequestOptions {
 	return options
 }
 
+// RequestOptions holds client request options
 type RequestOptions struct {
 	ContentType string
 	Stream      bool
@@ -138,11 +148,12 @@ type RequestOptions struct {
 	Context context.Context
 }
 
+// NewOptions creates new options struct
 func NewOptions(opts ...Option) Options {
 	options := Options{
 		Context:     context.Background(),
-		ContentType: "application/protobuf",
-		Codecs:      make(map[string]codec.NewCodec),
+		ContentType: "application/json",
+		Codecs:      make(map[string]codec.Codec),
 		CallOptions: CallOptions{
 			Backoff:        DefaultBackoff,
 			Retry:          DefaultRetry,
@@ -172,6 +183,7 @@ func Broker(b broker.Broker) Option {
 	}
 }
 
+// Logger to be used for log mesages
 func Logger(l logger.Logger) Option {
 	return func(o *Options) {
 		o.Logger = l
@@ -179,7 +191,7 @@ func Logger(l logger.Logger) Option {
 }
 
 // Codec to be used to encode/decode requests for a given content type
-func Codec(contentType string, c codec.NewCodec) Option {
+func Codec(contentType string, c codec.Codec) Option {
 	return func(o *Options) {
 		o.Codecs[contentType] = c
 	}
@@ -272,7 +284,7 @@ func Lookup(l LookupFunc) Option {
 	}
 }
 
-// Number of retries when making the request.
+// Retries sets the retry count when making the request.
 // Should this be a Call Option?
 func Retries(i int) Option {
 	return func(o *Options) {
@@ -287,7 +299,7 @@ func Retry(fn RetryFunc) Option {
 	}
 }
 
-// The request timeout.
+// RequestTimeout is the request timeout.
 // Should this be a Call Option?
 func RequestTimeout(d time.Duration) Option {
 	return func(o *Options) {
@@ -422,6 +434,7 @@ func WithSelectOptions(sops ...selector.SelectOption) CallOption {
 	}
 }
 
+// WithMessageContentType sets the message content type
 func WithMessageContentType(ct string) MessageOption {
 	return func(o *MessageOptions) {
 		o.ContentType = ct
@@ -430,12 +443,14 @@ func WithMessageContentType(ct string) MessageOption {
 
 // Request Options
 
+// WithContentType specifies request content type
 func WithContentType(ct string) RequestOption {
 	return func(o *RequestOptions) {
 		o.ContentType = ct
 	}
 }
 
+// StreamingRequest specifies that request is streaming
 func StreamingRequest() RequestOption {
 	return func(o *RequestOptions) {
 		o.Stream = true

client/retry.go

@@ -14,22 +14,23 @@ func RetryAlways(ctx context.Context, req Request, retryCount int, err error) (b
 	return true, nil
 }
 
+// RetryNever never retry on error
+func RetryNever(ctx context.Context, req Request, retryCount int, err error) (bool, error) {
+	return false, nil
+}
+
 // RetryOnError retries a request on a 500 or timeout error
 func RetryOnError(ctx context.Context, req Request, retryCount int, err error) (bool, error) {
 	if err == nil {
 		return false, nil
 	}
 
-	e := errors.Parse(err.Error())
-	if e == nil {
-		return false, nil
-	}
-
-	switch e.Code {
+	me := errors.FromError(err)
+	switch me.Code {
 	// retry on timeout or internal server error
 	case 408, 500:
 		return true, nil
-	default:
-		return false, nil
 	}
+
+	return false, nil
 }

client/test_request.go

@@ -34,7 +34,7 @@ func (r *testRequest) Body() interface{} {
 	return r.body
 }
 
-func (r *testRequest) Codec() codec.Writer {
+func (r *testRequest) Codec() codec.Codec {
 	return r.codec
 }
 

cmd/protoc-gen-micro/.gitignore

@@ -1,33 +0,0 @@
-# Compiled Object files, Static and Dynamic libs (Shared Objects)
-*.o
-*.a
-*.so
-
-# Folders
-_obj
-_test
-_build
-
-# Architecture specific extensions/prefixes
-*.[568vq]
-[568vq].out
-
-*.cgo1.go
-*.cgo2.c
-_cgo_defun.c
-_cgo_gotypes.go
-_cgo_export.*
-
-_testmain.go
-
-*.exe
-*.test
-*.prof
-
-# ignore go build and test outputs
-coverage.txt
-coverage.out
-
-# ignore locally built binaries
-protoc-gen-micro
-dist

cmd/protoc-gen-micro/README.md

@@ -1,138 +0,0 @@
-# protoc-gen-micro
-
-This is protobuf code generation for micro. We use protoc-gen-micro to reduce boilerplate code.
-
-## Install
-
-```
-go get github.com/micro/micro/v3/cmd/protoc-gen-micro@master
-```
-
-Also required: 
-
-- [protoc](https://github.com/google/protobuf)
-- [protoc-gen-go](https://github.com/golang/protobuf)
-
-## Usage
-
-Define your service as `greeter.proto`
-
-```
-syntax = "proto3";
-
-service Greeter {
-	rpc Hello(Request) returns (Response) {}
-}
-
-message Request {
-	string name = 1;
-}
-
-message Response {
-	string msg = 1;
-}
-```
-
-Generate the code
-
-```
-protoc --proto_path=$GOPATH/src:. --micro_out=. --go_out=. greeter.proto
-```
-
-Your output result should be:
-
-```
-./
-    greeter.proto	# original protobuf file
-    greeter.pb.go	# auto-generated by protoc-gen-go
-    greeter.micro.go	# auto-generated by protoc-gen-micro
-```
-
-The micro generated code includes clients and handlers which reduce boiler plate code
-
-### Server
-
-Register the handler with your micro server
-
-```go
-type Greeter struct{}
-
-func (g *Greeter) Hello(ctx context.Context, req *proto.Request, rsp *proto.Response) error {
-	rsp.Msg = "Hello " + req.Name
-	return nil
-}
-
-proto.RegisterGreeterHandler(service.Server(), &Greeter{})
-```
-
-### Client
-
-Create a service client with your micro client
-
-```go
-client := proto.NewGreeterService("greeter", service.Client())
-```
-
-### Errors
-
-If you see an error about `protoc-gen-micro` not being found or executable, it's likely your environment may not be configured correctly. If you've already installed `protoc`, `protoc-gen-go`, and `protoc-gen-micro` ensure you've included `$GOPATH/bin` in your `PATH`.
-
-Alternative specify the Go plugin paths as arguments to the `protoc` command
-
-```
-protoc --plugin=protoc-gen-go=$GOPATH/bin/protoc-gen-go --plugin=protoc-gen-micro=$GOPATH/bin/protoc-gen-micro --proto_path=$GOPATH/src:. --micro_out=. --go_out=. greeter.proto
-```
-
-### Endpoint
-
-Add a micro API endpoint which routes directly to an RPC method
-
-Usage:
-
-1. Clone `github.com/googleapis/googleapis` to use this feature as it requires http annotations.
-2. The protoc command must include `-I$GOPATH/src/github.com/googleapis/googleapis` for the annotations import.
-
-```diff
-syntax = "proto3";
-
-import "google/api/annotations.proto";
-
-service Greeter {
-	rpc Hello(Request) returns (Response) {
-		option (google.api.http) = { post: "/hello"; body: "*"; };
-	}
-}
-
-message Request {
-	string name = 1;
-}
-
-message Response {
-	string msg = 1;
-}
-```
-
-The proto generates a `RegisterGreeterHandler` function with a [api.Endpoint](https://godoc.org/github.com/micro/go-micro/api#Endpoint). 
-
-```diff
-func RegisterGreeterHandler(s server.Server, hdlr GreeterHandler, opts ...server.HandlerOption) error {
-	type greeter interface {
-		Hello(ctx context.Context, in *Request, out *Response) error
-	}
-	type Greeter struct {
-		greeter
-	}
-	h := &greeterHandler{hdlr}
-	opts = append(opts, api.WithEndpoint(&api.Endpoint{
-		Name:    "Greeter.Hello",
-		Path:    []string{"/hello"},
-		Method:  []string{"POST"},
-		Handler: "rpc",
-	}))
-	return s.Handle(s.NewHandler(&Greeter{h}, opts...))
-}
-```
-
-## LICENSE
-
-protoc-gen-micro is a liberal reuse of protoc-gen-go hence we maintain the original license 

cmd/protoc-gen-micro/generator/Makefile

@@ -1,40 +0,0 @@
-# Go support for Protocol Buffers - Google's data interchange format
-#
-# Copyright 2010 The Go Authors.  All rights reserved.
-# https://github.com/golang/protobuf
-#
-# Redistribution and use in source and binary forms, with or without
-# modification, are permitted provided that the following conditions are
-# met:
-#
-#     * Redistributions of source code must retain the above copyright
-# notice, this list of conditions and the following disclaimer.
-#     * Redistributions in binary form must reproduce the above
-# copyright notice, this list of conditions and the following disclaimer
-# in the documentation and/or other materials provided with the
-# distribution.
-#     * Neither the name of Google Inc. nor the names of its
-# contributors may be used to endorse or promote products derived from
-# this software without specific prior written permission.
-#
-# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-include $(GOROOT)/src/Make.inc
-
-TARG=github.com/golang/protobuf/compiler/generator
-GOFILES=\
-	generator.go\
-
-DEPS=../descriptor ../plugin ../../proto
-
-include $(GOROOT)/src/Make.pkg

cmd/protoc-gen-micro/generator/name_test.go

@@ -1,135 +0,0 @@
-// Go support for Protocol Buffers - Google's data interchange format
-//
-// Copyright 2013 The Go Authors.  All rights reserved.
-// https://github.com/golang/protobuf
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-package generator
-
-import (
-	"testing"
-
-	"github.com/golang/protobuf/protoc-gen-go/descriptor"
-)
-
-func TestCamelCase(t *testing.T) {
-	tests := []struct {
-		in, want string
-	}{
-		{"one", "One"},
-		{"one_two", "OneTwo"},
-		{"_my_field_name_2", "XMyFieldName_2"},
-		{"Something_Capped", "Something_Capped"},
-		{"my_Name", "My_Name"},
-		{"OneTwo", "OneTwo"},
-		{"_", "X"},
-		{"_a_", "XA_"},
-	}
-	for _, tc := range tests {
-		if got := CamelCase(tc.in); got != tc.want {
-			t.Errorf("CamelCase(%q) = %q, want %q", tc.in, got, tc.want)
-		}
-	}
-}
-
-func TestGoPackageOption(t *testing.T) {
-	tests := []struct {
-		in      string
-		impPath GoImportPath
-		pkg     GoPackageName
-		ok      bool
-	}{
-		{"", "", "", false},
-		{"foo", "", "foo", true},
-		{"github.com/golang/bar", "github.com/golang/bar", "bar", true},
-		{"github.com/golang/bar;baz", "github.com/golang/bar", "baz", true},
-		{"github.com/golang/string", "github.com/golang/string", "string", true},
-	}
-	for _, tc := range tests {
-		d := &FileDescriptor{
-			FileDescriptorProto: &descriptor.FileDescriptorProto{
-				Options: &descriptor.FileOptions{
-					GoPackage: &tc.in,
-				},
-			},
-		}
-		impPath, pkg, ok := d.goPackageOption()
-		if impPath != tc.impPath || pkg != tc.pkg || ok != tc.ok {
-			t.Errorf("go_package = %q => (%q, %q, %t), want (%q, %q, %t)", tc.in,
-				impPath, pkg, ok, tc.impPath, tc.pkg, tc.ok)
-		}
-	}
-}
-
-func TestPackageNames(t *testing.T) {
-	g := New()
-	g.packageNames = make(map[GoImportPath]GoPackageName)
-	g.usedPackageNames = make(map[GoPackageName]bool)
-	for _, test := range []struct {
-		importPath GoImportPath
-		want       GoPackageName
-	}{
-		{"github.com/golang/foo", "foo"},
-		{"github.com/golang/second/package/named/foo", "foo1"},
-		{"github.com/golang/third/package/named/foo", "foo2"},
-		{"github.com/golang/conflicts/with/predeclared/ident/string", "string1"},
-	} {
-		if got := g.GoPackageName(test.importPath); got != test.want {
-			t.Errorf("GoPackageName(%v) = %v, want %v", test.importPath, got, test.want)
-		}
-	}
-}
-
-func TestUnescape(t *testing.T) {
-	tests := []struct {
-		in  string
-		out string
-	}{
-		// successful cases, including all kinds of escapes
-		{"", ""},
-		{"foo bar baz frob nitz", "foo bar baz frob nitz"},
-		{`\000\001\002\003\004\005\006\007`, string([]byte{0, 1, 2, 3, 4, 5, 6, 7})},
-		{`\a\b\f\n\r\t\v\\\?\'\"`, string([]byte{'\a', '\b', '\f', '\n', '\r', '\t', '\v', '\\', '?', '\'', '"'})},
-		{`\x10\x20\x30\x40\x50\x60\x70\x80`, string([]byte{16, 32, 48, 64, 80, 96, 112, 128})},
-		// variable length octal escapes
-		{`\0\018\222\377\3\04\005\6\07`, string([]byte{0, 1, '8', 0222, 255, 3, 4, 5, 6, 7})},
-		// malformed escape sequences left as is
-		{"foo \\g bar", "foo \\g bar"},
-		{"foo \\xg0 bar", "foo \\xg0 bar"},
-		{"\\", "\\"},
-		{"\\x", "\\x"},
-		{"\\xf", "\\xf"},
-		{"\\777", "\\777"}, // overflows byte
-	}
-	for _, tc := range tests {
-		s := unescape(tc.in)
-		if s != tc.out {
-			t.Errorf("doUnescape(%q) = %q; should have been %q", tc.in, s, tc.out)
-		}
-	}
-}

cmd/protoc-gen-micro/main.go

@@ -1,99 +0,0 @@
-// Go support for Protocol Buffers - Google's data interchange format
-//
-// Copyright 2010 The Go Authors.  All rights reserved.
-// https://github.com/golang/protobuf
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-// protoc-gen-micro is a plugin for the Google protocol buffer compiler to generate
-// Go code.  Run it by building this program and putting it in your path with
-// the name
-// 	protoc-gen-micro
-// That word 'micro' at the end becomes part of the option string set for the
-// protocol compiler, so once the protocol compiler (protoc) is installed
-// you can run
-// 	protoc --micro_out=output_directory --go_out=output_directory input_directory/file.proto
-// to generate go-micro code for the protocol defined by file.proto.
-// With that input, the output will be written to
-// 	output_directory/file.micro.go
-//
-// The generated code is documented in the package comment for
-// the library.
-//
-// See the README and documentation for protocol buffers to learn more:
-// 	https://developers.google.com/protocol-buffers/
-package main
-
-import (
-	"io/ioutil"
-	"os"
-
-	"github.com/golang/protobuf/proto"
-	"github.com/unistack-org/micro/v3/cmd/protoc-gen-micro/generator"
-	_ "github.com/unistack-org/micro/v3/cmd/protoc-gen-micro/plugin/micro"
-)
-
-func main() {
-	// Begin by allocating a generator. The request and response structures are stored there
-	// so we can do error handling easily - the response structure contains the field to
-	// report failure.
-	g := generator.New()
-
-	data, err := ioutil.ReadAll(os.Stdin)
-	if err != nil {
-		g.Error(err, "reading input")
-	}
-
-	if err := proto.Unmarshal(data, g.Request); err != nil {
-		g.Error(err, "parsing input proto")
-	}
-
-	if len(g.Request.FileToGenerate) == 0 {
-		g.Fail("no files to generate")
-	}
-
-	g.CommandLineParameters(g.Request.GetParameter())
-
-	// Create a wrapped version of the Descriptors and EnumDescriptors that
-	// point to the file that defines them.
-	g.WrapTypes()
-
-	g.SetPackageNames()
-	g.BuildTypeNameMap()
-
-	g.GenerateAllFiles()
-
-	// Send back the results.
-	data, err = proto.Marshal(g.Response)
-	if err != nil {
-		g.Error(err, "failed to marshal output proto")
-	}
-	_, err = os.Stdout.Write(data)
-	if err != nil {
-		g.Error(err, "failed to write output proto")
-	}
-}

cmd/protoc-gen-micro/plugin/micro/micro.go

@@ -1,583 +0,0 @@
-package micro
-
-import (
-	"fmt"
-	"path"
-	"strconv"
-	"strings"
-
-	"github.com/golang/protobuf/proto"
-	pb "github.com/golang/protobuf/protoc-gen-go/descriptor"
-	"github.com/unistack-org/micro/v3/cmd/protoc-gen-micro/generator"
-	options "google.golang.org/genproto/googleapis/api/annotations"
-)
-
-// Paths for packages used by code generated in this file,
-// relative to the import_prefix of the generator.Generator.
-const (
-	apiPkgPath     = "github.com/unistack-org/micro/v3/api"
-	contextPkgPath = "context"
-	clientPkgPath  = "github.com/unistack-org/micro/v3/client"
-	serverPkgPath  = "github.com/unistack-org/micro/v3/server"
-)
-
-func init() {
-	generator.RegisterPlugin(new(micro))
-}
-
-// micro is an implementation of the Go protocol buffer compiler's
-// plugin architecture.  It generates bindings for go-micro support.
-type micro struct {
-	gen *generator.Generator
-}
-
-// Name returns the name of this plugin, "micro".
-func (g *micro) Name() string {
-	return "micro"
-}
-
-// The names for packages imported in the generated code.
-// They may vary from the final path component of the import path
-// if the name is used by other packages.
-var (
-	apiPkg     string
-	contextPkg string
-	clientPkg  string
-	serverPkg  string
-	pkgImports map[generator.GoPackageName]bool
-)
-
-// Init initializes the plugin.
-func (g *micro) Init(gen *generator.Generator) {
-	g.gen = gen
-	apiPkg = generator.RegisterUniquePackageName("api", nil)
-	contextPkg = generator.RegisterUniquePackageName("context", nil)
-	clientPkg = generator.RegisterUniquePackageName("client", nil)
-	serverPkg = generator.RegisterUniquePackageName("server", nil)
-}
-
-// Given a type name defined in a .proto, return its object.
-// Also record that we're using it, to guarantee the associated import.
-func (g *micro) objectNamed(name string) generator.Object {
-	g.gen.RecordTypeUse(name)
-	return g.gen.ObjectNamed(name)
-}
-
-// Given a type name defined in a .proto, return its name as we will print it.
-func (g *micro) typeName(str string) string {
-	return g.gen.TypeName(g.objectNamed(str))
-}
-
-// P forwards to g.gen.P.
-func (g *micro) P(args ...interface{}) { g.gen.P(args...) }
-
-// Generate generates code for the services in the given file.
-func (g *micro) Generate(file *generator.FileDescriptor) {
-	if len(file.FileDescriptorProto.Service) == 0 {
-		return
-	}
-	g.P("// Reference imports to suppress errors if they are not otherwise used.")
-	g.P("var _ ", apiPkg, ".Endpoint")
-	g.P("var _ ", contextPkg, ".Context")
-	g.P("var _ ", clientPkg, ".Option")
-	g.P("var _ ", serverPkg, ".Option")
-	g.P()
-
-	for i, service := range file.FileDescriptorProto.Service {
-		g.generateService(file, service, i)
-	}
-}
-
-// GenerateImports generates the import declaration for this file.
-func (g *micro) GenerateImports(file *generator.FileDescriptor, imports map[generator.GoImportPath]generator.GoPackageName) {
-	if len(file.FileDescriptorProto.Service) == 0 {
-		return
-	}
-	g.P("import (")
-	g.P(apiPkg, " ", strconv.Quote(path.Join(g.gen.ImportPrefix, apiPkgPath)))
-	g.P(contextPkg, " ", strconv.Quote(path.Join(g.gen.ImportPrefix, contextPkgPath)))
-	g.P(clientPkg, " ", strconv.Quote(path.Join(g.gen.ImportPrefix, clientPkgPath)))
-	g.P(serverPkg, " ", strconv.Quote(path.Join(g.gen.ImportPrefix, serverPkgPath)))
-	g.P(")")
-	g.P()
-
-	// We need to keep track of imported packages to make sure we don't produce
-	// a name collision when generating types.
-	pkgImports = make(map[generator.GoPackageName]bool)
-	for _, name := range imports {
-		pkgImports[name] = true
-	}
-}
-
-// reservedClientName records whether a client name is reserved on the client side.
-var reservedClientName = map[string]bool{
-	// TODO: do we need any in go-micro?
-}
-
-func unexport(s string) string {
-	if len(s) == 0 {
-		return ""
-	}
-	name := strings.ToLower(s[:1]) + s[1:]
-	if pkgImports[generator.GoPackageName(name)] {
-		return name + "_"
-	}
-	return name
-}
-
-// generateService generates all the code for the named service.
-func (g *micro) generateService(file *generator.FileDescriptor, service *pb.ServiceDescriptorProto, index int) {
-	path := fmt.Sprintf("6,%d", index) // 6 means service.
-
-	origServName := service.GetName()
-	serviceName := strings.ToLower(service.GetName())
-	if pkg := file.GetPackage(); pkg != "" {
-		serviceName = pkg
-	}
-	servName := generator.CamelCase(origServName)
-	servAlias := servName + "Service"
-
-	// strip suffix
-	if strings.HasSuffix(servAlias, "ServiceService") {
-		servAlias = strings.TrimSuffix(servAlias, "Service")
-	}
-
-	g.P()
-	g.P("// Api Endpoints for ", servName, " service")
-	g.P()
-
-	g.P("func New", servName, "Endpoints () []*", apiPkg, ".Endpoint {")
-	g.P("return []*", apiPkg, ".Endpoint{")
-	for _, method := range service.Method {
-		if method.Options != nil && proto.HasExtension(method.Options, options.E_Http) {
-			g.P("&", apiPkg, ".Endpoint{")
-			g.generateEndpoint(servName, method)
-			g.P("},")
-		}
-	}
-	g.P("}")
-	g.P("}")
-	g.P()
-
-	g.P()
-	g.P("// Client API for ", servName, " service")
-	g.P()
-
-	// Client interface.
-	g.P("type ", servAlias, " interface {")
-	for i, method := range service.Method {
-		g.gen.PrintComments(fmt.Sprintf("%s,2,%d", path, i)) // 2 means method in a service.
-		g.P(g.generateClientSignature(servName, method))
-	}
-	g.P("}")
-	g.P()
-
-	// Client structure.
-	g.P("type ", unexport(servAlias), " struct {")
-	g.P("c ", clientPkg, ".Client")
-	g.P("name string")
-	g.P("}")
-	g.P()
-
-	// NewClient factory.
-	g.P("func New", servAlias, " (name string, c ", clientPkg, ".Client) ", servAlias, " {")
-	/*
-		g.P("if c == nil {")
-		g.P("c = ", clientPkg, ".NewClient()")
-		g.P("}")
-		g.P("if len(name) == 0 {")
-		g.P(`name = "`, serviceName, `"`)
-		g.P("}")
-	*/
-	g.P("return &", unexport(servAlias), "{")
-	g.P("c: c,")
-	g.P("name: name,")
-	g.P("}")
-	g.P("}")
-	g.P()
-	var methodIndex, streamIndex int
-	serviceDescVar := "_" + servName + "_serviceDesc"
-	// Client method implementations.
-	for _, method := range service.Method {
-		var descExpr string
-		if !method.GetServerStreaming() {
-			// Unary RPC method
-			descExpr = fmt.Sprintf("&%s.Methods[%d]", serviceDescVar, methodIndex)
-			methodIndex++
-		} else {
-			// Streaming RPC method
-			descExpr = fmt.Sprintf("&%s.Streams[%d]", serviceDescVar, streamIndex)
-			streamIndex++
-		}
-		g.generateClientMethod(serviceName, servName, serviceDescVar, method, descExpr)
-	}
-
-	g.P("// Server API for ", servName, " service")
-	g.P()
-
-	// Server interface.
-	serverType := servName + "Handler"
-	g.P("type ", serverType, " interface {")
-	for i, method := range service.Method {
-		g.gen.PrintComments(fmt.Sprintf("%s,2,%d", path, i)) // 2 means method in a service.
-		g.P(g.generateServerSignature(servName, method))
-	}
-	g.P("}")
-	g.P()
-
-	// Server registration.
-	g.P("func Register", servName, "Handler(s ", serverPkg, ".Server, hdlr ", serverType, ", opts ...", serverPkg, ".HandlerOption) error {")
-	g.P("type ", unexport(servName), " interface {")
-
-	// generate interface methods
-	for _, method := range service.Method {
-		methName := generator.CamelCase(method.GetName())
-		inType := g.typeName(method.GetInputType())
-		outType := g.typeName(method.GetOutputType())
-
-		if !method.GetServerStreaming() && !method.GetClientStreaming() {
-			g.P(methName, "(ctx ", contextPkg, ".Context, req *", inType, ", rsp *", outType, ") error")
-			continue
-		}
-		g.P(methName, "(ctx ", contextPkg, ".Context, stream server.Stream) error")
-	}
-	g.P("}")
-	g.P("type ", servName, " struct {")
-	g.P(unexport(servName))
-	g.P("}")
-	g.P("h := &", unexport(servName), "Handler{hdlr}")
-	for _, method := range service.Method {
-		if method.Options != nil && proto.HasExtension(method.Options, options.E_Http) {
-			g.P("opts = append(opts, ", apiPkg, ".WithEndpoint(&", apiPkg, ".Endpoint{")
-			g.generateEndpoint(servName, method)
-			g.P("}))")
-		}
-	}
-	g.P("return s.Handle(s.NewHandler(&", servName, "{h}, opts...))")
-	g.P("}")
-	g.P()
-
-	g.P("type ", unexport(servName), "Handler struct {")
-	g.P(serverType)
-	g.P("}")
-
-	// Server handler implementations.
-	var handlerNames []string
-	for _, method := range service.Method {
-		hname := g.generateServerMethod(servName, method)
-		handlerNames = append(handlerNames, hname)
-	}
-}
-
-// generateEndpoint creates the api endpoint
-func (g *micro) generateEndpoint(servName string, method *pb.MethodDescriptorProto) {
-	if method.Options == nil || !proto.HasExtension(method.Options, options.E_Http) {
-		return
-	}
-	// http rules
-	r, err := proto.GetExtension(method.Options, options.E_Http)
-	if err != nil {
-		return
-	}
-	rule := r.(*options.HttpRule)
-	var meth string
-	var path string
-	switch {
-	case len(rule.GetDelete()) > 0:
-		meth = "DELETE"
-		path = rule.GetDelete()
-	case len(rule.GetGet()) > 0:
-		meth = "GET"
-		path = rule.GetGet()
-	case len(rule.GetPatch()) > 0:
-		meth = "PATCH"
-		path = rule.GetPatch()
-	case len(rule.GetPost()) > 0:
-		meth = "POST"
-		path = rule.GetPost()
-	case len(rule.GetPut()) > 0:
-		meth = "PUT"
-		path = rule.GetPut()
-	}
-	if len(meth) == 0 || len(path) == 0 {
-		return
-	}
-	// TODO: process additional bindings
-	g.P("Name:", fmt.Sprintf(`"%s.%s",`, servName, method.GetName()))
-	g.P("Path:", fmt.Sprintf(`[]string{"%s"},`, path))
-	g.P("Method:", fmt.Sprintf(`[]string{"%s"},`, meth))
-	if len(rule.GetGet()) == 0 {
-		g.P("Body:", fmt.Sprintf(`"%s",`, rule.GetBody()))
-	}
-	if method.GetServerStreaming() || method.GetClientStreaming() {
-		g.P("Stream: true,")
-	}
-	g.P(`Handler: "rpc",`)
-}
-
-// generateClientSignature returns the client-side signature for a method.
-func (g *micro) generateClientSignature(servName string, method *pb.MethodDescriptorProto) string {
-	origMethName := method.GetName()
-	methName := generator.CamelCase(origMethName)
-	if reservedClientName[methName] {
-		methName += "_"
-	}
-	reqArg := ", req *" + g.typeName(method.GetInputType())
-	if method.GetClientStreaming() {
-		reqArg = ""
-	}
-	respName := "*" + g.typeName(method.GetOutputType())
-	if method.GetServerStreaming() || method.GetClientStreaming() {
-		respName = servName + "_" + generator.CamelCase(origMethName) + "Service"
-	}
-
-	return fmt.Sprintf("%s(ctx %s.Context%s, opts ...%s.CallOption) (%s, error)", methName, contextPkg, reqArg, clientPkg, respName)
-}
-
-func (g *micro) generateClientMethod(reqServ, servName, serviceDescVar string, method *pb.MethodDescriptorProto, descExpr string) {
-	methName := generator.CamelCase(method.GetName())
-	reqMethod := fmt.Sprintf("%s.%s", servName, methName)
-	inType := g.typeName(method.GetInputType())
-	outType := g.typeName(method.GetOutputType())
-
-	servAlias := servName + "Service"
-
-	// strip suffix
-	if strings.HasSuffix(servAlias, "ServiceService") {
-		servAlias = strings.TrimSuffix(servAlias, "Service")
-	}
-
-	g.P("func (c *", unexport(servAlias), ") ", g.generateClientSignature(servName, method), "{")
-	if !method.GetServerStreaming() && !method.GetClientStreaming() {
-		g.P("rsp := &", outType, "{}")
-		// TODO: Pass descExpr to Invoke.
-		g.P(`err := c.c.Call(ctx, c.c.NewRequest(c.name, "`, reqMethod, `", req), rsp, opts...)`)
-		g.P("if err != nil { return nil, err }")
-		g.P("return rsp, nil")
-		g.P("}")
-		g.P()
-		return
-	}
-	streamType := unexport(servAlias) + methName
-	g.P(`stream, err := c.c.Stream(ctx, c.c.NewRequest(c.name, "`, reqMethod, `", &`, inType, `{}), opts...)`)
-	g.P("if err != nil { return nil, err }")
-
-	if !method.GetClientStreaming() {
-		g.P("if err := stream.Send(req); err != nil { return nil, err }")
-	}
-
-	g.P("return &", streamType, "{stream}, nil")
-	g.P("}")
-	g.P()
-
-	genSend := method.GetClientStreaming()
-	genRecv := method.GetServerStreaming()
-
-	// Stream auxiliary types and methods.
-	g.P("type ", servName, "_", methName, "Service interface {")
-	g.P("Context() context.Context")
-	g.P("SendMsg(interface{}) error")
-	g.P("RecvMsg(interface{}) error")
-
-	if genSend && !genRecv {
-		// client streaming, the server will send a response upon close
-		g.P("CloseAndRecv() (*", outType, ", error)")
-	}
-	g.P("Close() error")
-
-	if genSend {
-		g.P("Send(*", inType, ") error")
-	}
-	if genRecv {
-		g.P("Recv() (*", outType, ", error)")
-	}
-	g.P("}")
-	g.P()
-
-	g.P("type ", streamType, " struct {")
-	g.P("stream ", clientPkg, ".Stream")
-	g.P("}")
-	g.P()
-
-	if genSend && !genRecv {
-		// client streaming, the server will send a response upon close
-		g.P("func (x *", streamType, ") CloseAndRecv() (*", outType, ", error) {")
-		g.P("if err := x.stream.Close(); err != nil {")
-		g.P("return nil, err")
-		g.P("}")
-		g.P("r := new(", outType, ")")
-		g.P("err := x.RecvMsg(r)")
-		g.P("return r, err")
-		g.P("}")
-		g.P()
-	}
-	g.P("func (x *", streamType, ") Close() error {")
-	g.P("return x.stream.Close()")
-	g.P("}")
-	g.P()
-
-	g.P("func (x *", streamType, ") Context() context.Context {")
-	g.P("return x.stream.Context()")
-	g.P("}")
-	g.P()
-
-	g.P("func (x *", streamType, ") SendMsg(m interface{}) error {")
-	g.P("return x.stream.Send(m)")
-	g.P("}")
-	g.P()
-
-	g.P("func (x *", streamType, ") RecvMsg(m interface{}) error {")
-	g.P("return x.stream.Recv(m)")
-	g.P("}")
-	g.P()
-
-	if genSend {
-		g.P("func (x *", streamType, ") Send(m *", inType, ") error {")
-		g.P("return x.stream.Send(m)")
-		g.P("}")
-		g.P()
-
-	}
-
-	if genRecv {
-		g.P("func (x *", streamType, ") Recv() (*", outType, ", error) {")
-		g.P("m := &", outType, "{}")
-		g.P("err := x.stream.Recv(m)")
-		g.P("if err != nil {")
-		g.P("return nil, err")
-		g.P("}")
-		g.P("return m, nil")
-		g.P("}")
-		g.P()
-	}
-}
-
-// generateServerSignature returns the server-side signature for a method.
-func (g *micro) generateServerSignature(servName string, method *pb.MethodDescriptorProto) string {
-	origMethName := method.GetName()
-	methName := generator.CamelCase(origMethName)
-	if reservedClientName[methName] {
-		methName += "_"
-	}
-
-	var reqArgs []string
-	ret := "error"
-	reqArgs = append(reqArgs, contextPkg+".Context")
-
-	if !method.GetClientStreaming() {
-		reqArgs = append(reqArgs, "*"+g.typeName(method.GetInputType()))
-	}
-	if method.GetServerStreaming() || method.GetClientStreaming() {
-		reqArgs = append(reqArgs, servName+"_"+generator.CamelCase(origMethName)+"Stream")
-	}
-	if !method.GetClientStreaming() && !method.GetServerStreaming() {
-		reqArgs = append(reqArgs, "*"+g.typeName(method.GetOutputType()))
-	}
-	return methName + "(" + strings.Join(reqArgs, ", ") + ") " + ret
-}
-
-func (g *micro) generateServerMethod(servName string, method *pb.MethodDescriptorProto) string {
-	methName := generator.CamelCase(method.GetName())
-	hname := fmt.Sprintf("_%s_%s_Handler", servName, methName)
-	serveType := servName + "Handler"
-	inType := g.typeName(method.GetInputType())
-	outType := g.typeName(method.GetOutputType())
-
-	if !method.GetServerStreaming() && !method.GetClientStreaming() {
-		g.P("func (h *", unexport(servName), "Handler) ", methName, "(ctx ", contextPkg, ".Context, req *", inType, ", rsp *", outType, ") error {")
-		g.P("return h.", serveType, ".", methName, "(ctx, req, rsp)")
-		g.P("}")
-		g.P()
-		return hname
-	}
-	streamType := unexport(servName) + methName + "Stream"
-	g.P("func (h *", unexport(servName), "Handler) ", methName, "(ctx ", contextPkg, ".Context, stream server.Stream) error {")
-	if !method.GetClientStreaming() {
-		g.P("m := &", inType, "{}")
-		g.P("if err := stream.Recv(m); err != nil { return err }")
-		g.P("return h.", serveType, ".", methName, "(ctx, m, &", streamType, "{stream})")
-	} else {
-		g.P("return h.", serveType, ".", methName, "(ctx, &", streamType, "{stream})")
-	}
-	g.P("}")
-	g.P()
-
-	genSend := method.GetServerStreaming()
-	genRecv := method.GetClientStreaming()
-
-	// Stream auxiliary types and methods.
-	g.P("type ", servName, "_", methName, "Stream interface {")
-	g.P("Context() context.Context")
-	g.P("SendMsg(interface{}) error")
-	g.P("RecvMsg(interface{}) error")
-	if !genSend {
-		// client streaming, the server will send a response upon close
-		g.P("SendAndClose(*", outType, ")  error")
-	}
-	g.P("Close() error")
-
-	if genSend {
-		g.P("Send(*", outType, ") error")
-	}
-
-	if genRecv {
-		g.P("Recv() (*", inType, ", error)")
-	}
-
-	g.P("}")
-	g.P()
-
-	g.P("type ", streamType, " struct {")
-	g.P("stream ", serverPkg, ".Stream")
-	g.P("}")
-	g.P()
-
-	if !genSend {
-		// client streaming, the server will send a response upon close
-		g.P("func (x *", streamType, ") SendAndClose(in *", outType, ") error {")
-		g.P("if err := x.SendMsg(in); err != nil {")
-		g.P("return err")
-		g.P("}")
-		g.P("return x.stream.Close()")
-		g.P("}")
-		g.P()
-	}
-	// other types of rpc don't send a response when the stream closes
-	g.P("func (x *", streamType, ") Close() error {")
-	g.P("return x.stream.Close()")
-	g.P("}")
-	g.P()
-
-	g.P("func (x *", streamType, ") Context() context.Context {")
-	g.P("return x.stream.Context()")
-	g.P("}")
-	g.P()
-
-	g.P("func (x *", streamType, ") SendMsg(m interface{}) error {")
-	g.P("return x.stream.Send(m)")
-	g.P("}")
-	g.P()
-
-	g.P("func (x *", streamType, ") RecvMsg(m interface{}) error {")
-	g.P("return x.stream.Recv(m)")
-	g.P("}")
-	g.P()
-
-	if genSend {
-		g.P("func (x *", streamType, ") Send(m *", outType, ") error {")
-		g.P("return x.stream.Send(m)")
-		g.P("}")
-		g.P()
-	}
-
-	if genRecv {
-		g.P("func (x *", streamType, ") Recv() (*", inType, ", error) {")
-		g.P("m := &", inType, "{}")
-		g.P("if err := x.stream.Recv(m); err != nil { return nil, err }")
-		g.P("return m, nil")
-		g.P("}")
-		g.P()
-	}
-
-	return hname
-}

codec/codec.go

@@ -4,9 +4,12 @@ package codec
 import (
 	"errors"
 	"io"
+
+	"github.com/unistack-org/micro/v3/metadata"
 )
 
 const (
+	// Message types
 	Error MessageType = iota
 	Request
 	Response
@@ -16,40 +19,28 @@ const (
 var (
 	// ErrInvalidMessage returned when invalid messge passed to codec
 	ErrInvalidMessage = errors.New("invalid message")
+	// ErrUnknownContentType returned when content-type is unknown
+	ErrUnknownContentType = errors.New("unknown content-type")
+)
+
+var (
+	// DefaultMaxMsgSize specifies how much data codec can handle
+	DefaultMaxMsgSize       = 1024 * 1024 * 4 // 4Mb
+	DefaultCodec      Codec = NewCodec()
 )
 
 // MessageType
 type MessageType int
 
-// NewCodec takes in a connection/buffer and returns a new Codec
-type NewCodec func(io.ReadWriteCloser) Codec
-
-// Codec encodes/decodes various types of messages used within go-micro.
+// Codec encodes/decodes various types of messages used within micro.
 // ReadHeader and ReadBody are called in pairs to read requests/responses
 // from the connection. Close is called when finished with the
 // connection. ReadBody may be called with a nil argument to force the
 // body to be read and discarded.
 type Codec interface {
-	Reader
-	Writer
-	Close() error
-	String() string
-}
-
-// Reader interface
-type Reader interface {
-	ReadHeader(*Message, MessageType) error
-	ReadBody(interface{}) error
-}
-
-// Writer interface
-type Writer interface {
-	Write(*Message, interface{}) error
-}
-
-// Marshaler is a simple encoding interface used for the broker/transport
-// where headers are not supported by the underlying implementation.
-type Marshaler interface {
+	ReadHeader(io.Reader, *Message, MessageType) error
+	ReadBody(io.Reader, interface{}) error
+	Write(io.Writer, *Message, interface{}) error
 	Marshal(interface{}) ([]byte, error)
 	Unmarshal([]byte, interface{}) error
 	String() string
@@ -67,6 +58,26 @@ type Message struct {
 	Error    string
 
 	// The values read from the socket
-	Header map[string]string
+	Header metadata.Metadata
 	Body   []byte
 }
+
+// Option func
+type Option func(*Options)
+
+// Options contains codec options
+type Options struct {
+	MaxMsgSize int64
+}
+
+// MaxMsgSize sets the max message size
+func MaxMsgSize(n int64) Option {
+	return func(o *Options) {
+		o.MaxMsgSize = n
+	}
+}
+
+// NewMessage creates new codec message
+func NewMessage(t MessageType) *Message {
+	return &Message{Type: t, Header: metadata.New(0)}
+}

codec/noop.go

@@ -0,0 +1,127 @@
+package codec
+
+import (
+	"io"
+	"io/ioutil"
+)
+
+type noopCodec struct {
+}
+
+// Frame gives us the ability to define raw data to send over the pipes
+type Frame struct {
+	Data []byte
+}
+
+func (c *noopCodec) ReadHeader(conn io.Reader, m *Message, t MessageType) error {
+	return nil
+}
+
+func (c *noopCodec) ReadBody(conn io.Reader, b interface{}) error {
+	// read bytes
+	buf, err := ioutil.ReadAll(conn)
+	if err != nil {
+		return err
+	}
+
+	if b == nil {
+		return nil
+	}
+
+	switch v := b.(type) {
+	case string:
+		v = string(buf)
+	case *string:
+		*v = string(buf)
+	case []byte:
+		v = buf
+	case *[]byte:
+		*v = buf
+	case *Frame:
+		v.Data = buf
+	default:
+		return ErrInvalidMessage
+	}
+
+	return nil
+}
+
+func (c *noopCodec) Write(conn io.Writer, m *Message, b interface{}) error {
+	if b == nil {
+		return nil
+	}
+
+	var v []byte
+	switch vb := b.(type) {
+	case *Frame:
+		v = vb.Data
+	case string:
+		v = []byte(vb)
+	case *string:
+		v = []byte(*vb)
+	case *[]byte:
+		v = *vb
+	case []byte:
+		v = vb
+	default:
+		return ErrInvalidMessage
+	}
+	_, err := conn.Write(v)
+	return err
+}
+
+func (c *noopCodec) String() string {
+	return "noop"
+}
+
+// NewCodec returns new noop codec
+func NewCodec() Codec {
+	return &noopCodec{}
+}
+
+func (c *noopCodec) Marshal(v interface{}) ([]byte, error) {
+	if v == nil {
+		return nil, nil
+	}
+
+	switch ve := v.(type) {
+	case string:
+		return []byte(ve), nil
+	case *string:
+		return []byte(*ve), nil
+	case *[]byte:
+		return *ve, nil
+	case []byte:
+		return ve, nil
+	case *Frame:
+		return ve.Data, nil
+	case *Message:
+		return ve.Body, nil
+	}
+	return nil, ErrInvalidMessage
+}
+
+func (c *noopCodec) Unmarshal(d []byte, v interface{}) error {
+	var err error
+	if v == nil {
+		return nil
+	}
+	switch ve := v.(type) {
+	case string:
+		ve = string(d)
+	case *string:
+		*ve = string(d)
+	case []byte:
+		ve = d
+	case *[]byte:
+		*ve = d
+	case *Frame:
+		ve.Data = d
+	case *Message:
+		ve.Body = d
+	default:
+		err = ErrInvalidMessage
+	}
+
+	return err
+}

config/config.go

@@ -3,52 +3,54 @@ package config
 
 import (
 	"context"
-
-	"github.com/unistack-org/micro/v3/config/loader"
-	"github.com/unistack-org/micro/v3/config/reader"
-	"github.com/unistack-org/micro/v3/config/source"
+	"errors"
 )
 
 var (
-	DefaultConfig Config
+	// DefaultConfig default config
+	DefaultConfig Config = NewConfig()
+)
+
+var (
+	// ErrCodecMissing is returned when codec needed and not specified
+	ErrCodecMissing = errors.New("codec missing")
+	// ErrInvalidStruct is returned when the target struct is invalid
+	ErrInvalidStruct = errors.New("invalid struct specified")
+	// ErrWatcherStopped is returned when source watcher has been stopped
+	ErrWatcherStopped = errors.New("watcher stopped")
 )
 
 // Config is an interface abstraction for dynamic configuration
 type Config interface {
-	// provide the reader.Values interface
-	reader.Values
 	// Init the config
 	Init(opts ...Option) error
 	// Options in the config
 	Options() Options
-	// Stop the config loader/watcher
-	Close() error
-	// Load config sources
-	Load(source ...source.Source) error
-	// Force a source changeset sync
-	Sync() error
+	// Load config from sources
+	Load(context.Context) error
+	// Save config to sources
+	Save(context.Context) error
 	// Watch a value for changes
-	Watch(path ...string) (Watcher, error)
+	//	Watch(interface{}) (Watcher, error)
+	String() string
 }
 
 // Watcher is the config watcher
-type Watcher interface {
-	Next() (reader.Value, error)
-	Stop() error
-}
-
-type Options struct {
-	Loader loader.Loader
-	Reader reader.Reader
-	Source []source.Source
-
-	// for alternative data
-	Context context.Context
-}
-
-type Option func(o *Options)
-
-// NewConfig returns new config
-func NewConfig(opts ...Option) (Config, error) {
-	return newConfig(opts...)
+//type Watcher interface {
+//	Next() (, error)
+//	Stop() error
+//}
+
+// Load loads config from config sources
+func Load(ctx context.Context, cs ...Config) error {
+	var err error
+	for _, c := range cs {
+		if err = c.Init(); err != nil {
+			return err
+		}
+		if err = c.Load(ctx); err != nil {
+			return err
+		}
+	}
+	return nil
 }

config/context.go

@@ -0,0 +1,32 @@
+package config
+
+import (
+	"context"
+)
+
+type configKey struct{}
+
+func FromContext(ctx context.Context) (Config, bool) {
+	if ctx == nil {
+		return nil, false
+	}
+	c, ok := ctx.Value(configKey{}).(Config)
+	return c, ok
+}
+
+func NewContext(ctx context.Context, c Config) context.Context {
+	if ctx == nil {
+		ctx = context.Background()
+	}
+	return context.WithValue(ctx, configKey{}, c)
+}
+
+// SetOption returns a function to setup a context with given value
+func SetOption(k, v interface{}) Option {
+	return func(o *Options) {
+		if o.Context == nil {
+			o.Context = context.Background()
+		}
+		o.Context = context.WithValue(o.Context, k, v)
+	}
+}

config/default.go

@@ -1,294 +1,251 @@
 package config
 
 import (
-	"bytes"
-	"fmt"
-	"sync"
-	"time"
-
-	"github.com/unistack-org/micro/v3/config/loader"
-	"github.com/unistack-org/micro/v3/config/reader"
-	"github.com/unistack-org/micro/v3/config/source"
+	"context"
+	"reflect"
+	"strconv"
+	"strings"
 )
 
-type config struct {
-	exit chan bool
+type defaultConfig struct {
 	opts Options
-
-	sync.RWMutex
-	// the current snapshot
-	snap *loader.Snapshot
-	// the current values
-	vals reader.Values
 }
 
-type watcher struct {
-	lw    loader.Watcher
-	rd    reader.Reader
-	path  []string
-	value reader.Value
-}
-
-func newConfig(opts ...Option) (Config, error) {
-	var c config
-
-	if err := c.Init(opts...); err != nil {
-		return nil, err
-	}
-
-	go c.run()
-	return &c, nil
-}
-
-func (c *config) Init(opts ...Option) error {
-	c.opts = Options{}
-	c.exit = make(chan bool)
-	for _, o := range opts {
-		o(&c.opts)
-	}
-
-	err := c.opts.Loader.Load(c.opts.Source...)
-	if err != nil {
-		return err
-	}
-
-	c.snap, err = c.opts.Loader.Snapshot()
-	if err != nil {
-		return err
-	}
-
-	c.vals, err = c.opts.Reader.Values(c.snap.ChangeSet)
-	if err != nil {
-		return err
-	}
-
-	return nil
-}
-
-func (c *config) Options() Options {
+func (c *defaultConfig) Options() Options {
 	return c.opts
 }
 
-func (c *config) run() {
-	watch := func(w loader.Watcher) error {
-		for {
-			// get changeset
-			snap, err := w.Next()
-			if err != nil {
+func (c *defaultConfig) Init(opts ...Option) error {
+	for _, o := range opts {
+		o(&c.opts)
+	}
+	return nil
+}
+
+func (c *defaultConfig) Load(ctx context.Context) error {
+	for _, fn := range c.opts.BeforeLoad {
+		if err := fn(ctx, c); err != nil && !c.opts.AllowFail {
+			return err
+		}
+	}
+
+	valueOf := reflect.ValueOf(c.opts.Struct)
+
+	if err := c.fillValues(ctx, valueOf); err != nil && !c.opts.AllowFail {
+		return err
+	}
+
+	for _, fn := range c.opts.AfterLoad {
+		if err := fn(ctx, c); err != nil && !c.opts.AllowFail {
+			return err
+		}
+	}
+
+	return nil
+}
+
+func (c *defaultConfig) fillValue(ctx context.Context, value reflect.Value, val string) error {
+	if !IsEmpty(value) {
+		return nil
+	}
+	switch value.Kind() {
+	case reflect.Map:
+		t := value.Type()
+		nvals := strings.FieldsFunc(val, func(c rune) bool { return c == ',' || c == ';' })
+		if value.IsNil() {
+			value.Set(reflect.MakeMapWithSize(t, len(nvals)))
+		}
+		kt := t.Key()
+		et := t.Elem()
+		for _, nval := range nvals {
+			kv := strings.FieldsFunc(nval, func(c rune) bool { return c == '=' })
+			mkey := reflect.Indirect(reflect.New(kt))
+			mval := reflect.Indirect(reflect.New(et))
+			if err := c.fillValue(ctx, mkey, kv[0]); err != nil {
 				return err
 			}
-
-			c.Lock()
-
-			if c.snap != nil && c.snap.Version >= snap.Version {
-				c.Unlock()
-				continue
+			if err := c.fillValue(ctx, mval, kv[1]); err != nil {
+				return err
 			}
-
-			// save
-			c.snap = snap
-
-			// set values
-			c.vals, _ = c.opts.Reader.Values(snap.ChangeSet)
-
-			c.Unlock()
+			value.SetMapIndex(mkey, mval)
 		}
+	case reflect.Slice, reflect.Array:
+		nvals := strings.FieldsFunc(val, func(c rune) bool { return c == ',' || c == ';' })
+		value.Set(reflect.MakeSlice(reflect.SliceOf(value.Type().Elem()), len(nvals), len(nvals)))
+		for idx, nval := range nvals {
+			nvalue := reflect.Indirect(reflect.New(value.Type().Elem()))
+			if err := c.fillValue(ctx, nvalue, nval); err != nil {
+				return err
+			}
+			value.Index(idx).Set(nvalue)
+		}
+	case reflect.Bool:
+		v, err := strconv.ParseBool(val)
+		if err != nil {
+			return err
+		}
+		value.Set(reflect.ValueOf(v))
+	case reflect.String:
+		value.Set(reflect.ValueOf(val))
+	case reflect.Float32:
+		v, err := strconv.ParseFloat(val, 32)
+		if err != nil {
+			return err
+		}
+		value.Set(reflect.ValueOf(float32(v)))
+	case reflect.Float64:
+		v, err := strconv.ParseFloat(val, 64)
+		if err != nil {
+			return err
+		}
+		value.Set(reflect.ValueOf(float64(v)))
+	case reflect.Int:
+		v, err := strconv.ParseInt(val, 10, 0)
+		if err != nil {
+			return err
+		}
+		value.Set(reflect.ValueOf(int(v)))
+	case reflect.Int8:
+		v, err := strconv.ParseInt(val, 10, 8)
+		if err != nil {
+			return err
+		}
+		value.Set(reflect.ValueOf(v))
+	case reflect.Int16:
+		v, err := strconv.ParseInt(val, 10, 16)
+		if err != nil {
+			return err
+		}
+		value.Set(reflect.ValueOf(int16(v)))
+	case reflect.Int32:
+		v, err := strconv.ParseInt(val, 10, 32)
+		if err != nil {
+			return err
+		}
+		value.Set(reflect.ValueOf(int32(v)))
+	case reflect.Int64:
+		v, err := strconv.ParseInt(val, 10, 64)
+		if err != nil {
+			return err
+		}
+		value.Set(reflect.ValueOf(int64(v)))
+	case reflect.Uint:
+		v, err := strconv.ParseUint(val, 10, 0)
+		if err != nil {
+			return err
+		}
+		value.Set(reflect.ValueOf(uint(v)))
+	case reflect.Uint8:
+		v, err := strconv.ParseUint(val, 10, 8)
+		if err != nil {
+			return err
+		}
+		value.Set(reflect.ValueOf(uint8(v)))
+	case reflect.Uint16:
+		v, err := strconv.ParseUint(val, 10, 16)
+		if err != nil {
+			return err
+		}
+		value.Set(reflect.ValueOf(uint16(v)))
+	case reflect.Uint32:
+		v, err := strconv.ParseUint(val, 10, 32)
+		if err != nil {
+			return err
+		}
+		value.Set(reflect.ValueOf(uint32(v)))
+	case reflect.Uint64:
+		v, err := strconv.ParseUint(val, 10, 64)
+		if err != nil {
+			return err
+		}
+		value.Set(reflect.ValueOf(uint64(v)))
+	}
+	return nil
+}
+
+func (c *defaultConfig) fillValues(ctx context.Context, valueOf reflect.Value) error {
+	var values reflect.Value
+
+	if valueOf.Kind() == reflect.Ptr {
+		values = valueOf.Elem()
+	} else {
+		values = valueOf
 	}
 
-	for {
-		w, err := c.opts.Loader.Watch()
-		if err != nil {
-			time.Sleep(time.Second)
+	if values.Kind() == reflect.Invalid {
+		return ErrInvalidStruct
+	}
+
+	fields := values.Type()
+
+	for idx := 0; idx < fields.NumField(); idx++ {
+		field := fields.Field(idx)
+		value := values.Field(idx)
+		if !value.CanSet() {
+			continue
+		}
+		if len(field.PkgPath) != 0 {
+			continue
+		}
+		switch value.Kind() {
+		case reflect.Struct:
+			value.Set(reflect.Indirect(reflect.New(value.Type())))
+			if err := c.fillValues(ctx, value); err != nil {
+				return err
+			}
+			continue
+		case reflect.Ptr:
+			if value.IsNil() {
+				if value.Type().Elem().Kind() != reflect.Struct {
+					// nil pointer to a non-struct: leave it alone
+					break
+				}
+				// nil pointer to struct: create a zero instance
+				value.Set(reflect.New(value.Type().Elem()))
+			}
+			value = value.Elem()
+			if err := c.fillValues(ctx, value); err != nil {
+				return err
+			}
+			continue
+		}
+		tag, ok := field.Tag.Lookup(c.opts.StructTag)
+		if !ok {
 			continue
 		}
 
-		done := make(chan bool)
-
-		// the stop watch func
-		go func() {
-			select {
-			case <-done:
-			case <-c.exit:
-			}
-			w.Stop()
-		}()
-
-		// block watch
-		if err := watch(w); err != nil {
-			// do something better
-			time.Sleep(time.Second)
+		if err := c.fillValue(ctx, value, tag); err != nil {
+			return err
 		}
-
-		// close done chan
-		close(done)
-
-		// if the config is closed exit
-		select {
-		case <-c.exit:
-			return
-		default:
-		}
-	}
-}
-
-func (c *config) Map() map[string]interface{} {
-	c.RLock()
-	defer c.RUnlock()
-	return c.vals.Map()
-}
-
-func (c *config) Scan(v interface{}) error {
-	c.RLock()
-	defer c.RUnlock()
-	return c.vals.Scan(v)
-}
-
-// sync loads all the sources, calls the parser and updates the config
-func (c *config) Sync() error {
-	if err := c.opts.Loader.Sync(); err != nil {
-		return err
-	}
-
-	snap, err := c.opts.Loader.Snapshot()
-	if err != nil {
-		return err
-	}
-
-	c.Lock()
-	defer c.Unlock()
-
-	c.snap = snap
-	vals, err := c.opts.Reader.Values(snap.ChangeSet)
-	if err != nil {
-		return err
-	}
-	c.vals = vals
-
-	return nil
-}
-
-func (c *config) Close() error {
-	select {
-	case <-c.exit:
-		return nil
-	default:
-		close(c.exit)
-	}
-	return nil
-}
-
-func (c *config) Get(path ...string) (reader.Value, error) {
-	c.RLock()
-	defer c.RUnlock()
-
-	// did sync actually work?
-	if c.vals != nil {
-		return c.vals.Get(path...)
-	}
-
-	// no value
-	return nil, fmt.Errorf("no value")
-}
-
-func (c *config) Set(val interface{}, path ...string) error {
-	c.Lock()
-	defer c.Unlock()
-
-	if c.vals != nil {
-		c.vals.Set(val, path...)
-	}
-	return nil
-}
-
-func (c *config) Del(path ...string) error {
-	c.Lock()
-	defer c.Unlock()
-
-	if c.vals != nil {
-		c.vals.Del(path...)
 	}
 
 	return nil
 }
 
-func (c *config) Bytes() []byte {
-	c.RLock()
-	defer c.RUnlock()
-
-	if c.vals == nil {
-		return []byte{}
+func (c *defaultConfig) Save(ctx context.Context) error {
+	for _, fn := range c.opts.BeforeSave {
+		if err := fn(ctx, c); err != nil && !c.opts.AllowFail {
+			return err
+		}
 	}
 
-	return c.vals.Bytes()
-}
-
-func (c *config) Load(sources ...source.Source) error {
-	if err := c.opts.Loader.Load(sources...); err != nil {
-		return err
+	for _, fn := range c.opts.AfterSave {
+		if err := fn(ctx, c); err != nil && !c.opts.AllowFail {
+			return err
+		}
 	}
 
-	snap, err := c.opts.Loader.Snapshot()
-	if err != nil {
-		return err
-	}
-
-	c.Lock()
-	defer c.Unlock()
-
-	c.snap = snap
-	vals, err := c.opts.Reader.Values(snap.ChangeSet)
-	if err != nil {
-		return err
-	}
-	c.vals = vals
-
 	return nil
 }
 
-func (c *config) Watch(path ...string) (Watcher, error) {
-	value, err := c.Get(path...)
-	if err != nil {
-		return nil, err
+func (c *defaultConfig) String() string {
+	return "default"
+}
+
+func NewConfig(opts ...Option) Config {
+	options := NewOptions(opts...)
+	if len(options.StructTag) == 0 {
+		options.StructTag = "default"
 	}
-
-	w, err := c.opts.Loader.Watch(path...)
-	if err != nil {
-		return nil, err
-	}
-
-	return &watcher{
-		lw:    w,
-		rd:    c.opts.Reader,
-		path:  path,
-		value: value,
-	}, nil
-}
-
-func (c *config) String() string {
-	return "config"
-}
-
-func (w *watcher) Next() (reader.Value, error) {
-	for {
-		s, err := w.lw.Next()
-		if err != nil {
-			return nil, err
-		}
-
-		// only process changes
-		if bytes.Equal(w.value.Bytes(), s.ChangeSet.Data) {
-			continue
-		}
-
-		v, err := w.rd.Values(s.ChangeSet)
-		if err != nil {
-			return nil, err
-		}
-
-		return v.Get()
-	}
-}
-
-func (w *watcher) Stop() error {
-	return w.lw.Stop()
+	return &defaultConfig{opts: options}
 }

config/default_test.go

@@ -1,168 +1,52 @@
-// +build ignore
-
-package config
+package config_test
 
 import (
+	"context"
 	"fmt"
-	"os"
-	"path/filepath"
-	"runtime"
-	"strings"
 	"testing"
-	"time"
 
-	"github.com/unistack-org/micro/v3/config/source"
-	"github.com/unistack-org/micro/v3/config/source/env"
-	"github.com/unistack-org/micro/v3/config/source/file"
-	"github.com/unistack-org/micro/v3/config/source/memory"
+	"github.com/unistack-org/micro/v3/config"
 )
 
-func createFileForIssue18(t *testing.T, content string) *os.File {
-	data := []byte(content)
-	path := filepath.Join(os.TempDir(), fmt.Sprintf("file.%d", time.Now().UnixNano()))
-	fh, err := os.Create(path)
-	if err != nil {
-		t.Error(err)
-	}
-	_, err = fh.Write(data)
-	if err != nil {
-		t.Error(err)
-	}
-
-	return fh
-}
-
-func createFileForTest(t *testing.T) *os.File {
-	data := []byte(`{"foo": "bar"}`)
-	path := filepath.Join(os.TempDir(), fmt.Sprintf("file.%d", time.Now().UnixNano()))
-	fh, err := os.Create(path)
-	if err != nil {
-		t.Error(err)
-	}
-	_, err = fh.Write(data)
-	if err != nil {
-		t.Error(err)
-	}
-
-	return fh
-}
-
-func TestConfigLoadWithGoodFile(t *testing.T) {
-	fh := createFileForTest(t)
-	path := fh.Name()
-	defer func() {
-		fh.Close()
-		os.Remove(path)
-	}()
-
-	// Create new config
-	conf, err := NewConfig()
-	if err != nil {
-		t.Fatalf("Expected no error but got %v", err)
-	}
-	// Load file source
-	if err := conf.Load(file.NewSource(
-		file.WithPath(path),
-	)); err != nil {
-		t.Fatalf("Expected no error but got %v", err)
+type Cfg struct {
+	StringValue string `default:"string_value"`
+	IntValue    int    `default:"99"`
+	IgnoreValue string `json:"-"`
+	StructValue struct {
+		StringValue string `default:"string_value"`
 	}
 }
 
-func TestConfigLoadWithInvalidFile(t *testing.T) {
-	fh := createFileForTest(t)
-	path := fh.Name()
-	defer func() {
-		fh.Close()
-		os.Remove(path)
-	}()
+func TestDefault(t *testing.T) {
+	ctx := context.Background()
+	conf := &Cfg{IntValue: 10}
+	blfn := func(ctx context.Context, cfg config.Config) error {
+		conf, ok := cfg.Options().Struct.(*Cfg)
+		if !ok {
+			return fmt.Errorf("failed to get Struct from options: %v", cfg.Options())
+		}
+		conf.StringValue = "before_load"
+		return nil
+	}
+	alfn := func(ctx context.Context, cfg config.Config) error {
+		conf, ok := cfg.Options().Struct.(*Cfg)
+		if !ok {
+			return fmt.Errorf("failed to get Struct from options: %v", cfg.Options())
+		}
+		conf.StringValue = "after_load"
+		return nil
+	}
 
-	// Create new config
-	conf, err := NewConfig()
-	if err != nil {
-		t.Fatalf("Expected no error but got %v", err)
+	cfg := config.NewConfig(config.Struct(conf), config.BeforeLoad(blfn), config.AfterLoad(alfn))
+	if err := cfg.Init(); err != nil {
+		t.Fatal(err)
+	}
+	if err := cfg.Load(ctx); err != nil {
+		t.Fatal(err)
+	}
+	if conf.StringValue != "after_load" {
+		t.Fatal("AfterLoad option not working")
 	}
-	// Load file source
-	err = conf.Load(file.NewSource(
-		file.WithPath(path),
-		file.WithPath("/i/do/not/exists.json"),
-	))
 
-	if err == nil {
-		t.Fatal("Expected error but none !")
-	}
-	if !strings.Contains(fmt.Sprintf("%v", err), "/i/do/not/exists.json") {
-		t.Fatalf("Expected error to contain the unexisting file but got %v", err)
-	}
-}
-
-func TestConfigMerge(t *testing.T) {
-	fh := createFileForIssue18(t, `{
-  "amqp": {
-    "host": "rabbit.platform",
-    "port": 80
-  },
-  "handler": {
-    "exchange": "springCloudBus"
-  }
-}`)
-	path := fh.Name()
-	defer func() {
-		fh.Close()
-		os.Remove(path)
-	}()
-	os.Setenv("AMQP_HOST", "rabbit.testing.com")
-
-	conf, err := NewConfig()
-	if err != nil {
-		t.Fatalf("Expected no error but got %v", err)
-	}
-	if err := conf.Load(
-		file.NewSource(
-			file.WithPath(path),
-		),
-		env.NewSource(),
-	); err != nil {
-		t.Fatalf("Expected no error but got %v", err)
-	}
-
-	actualHost := conf.Get("amqp", "host").String("backup")
-	if actualHost != "rabbit.testing.com" {
-		t.Fatalf("Expected %v but got %v",
-			"rabbit.testing.com",
-			actualHost)
-	}
-}
-
-func equalS(t *testing.T, actual, expect string) {
-	if actual != expect {
-		t.Errorf("Expected %s but got %s", actual, expect)
-	}
-}
-
-func TestConfigWatcherDirtyOverrite(t *testing.T) {
-	n := runtime.GOMAXPROCS(0)
-	defer runtime.GOMAXPROCS(n)
-
-	runtime.GOMAXPROCS(1)
-
-	l := 100
-
-	ss := make([]source.Source, l)
-
-	for i := 0; i < l; i++ {
-		ss[i] = memory.NewSource(memory.WithJSON([]byte(fmt.Sprintf(`{"key%d": "val%d"}`, i, i))))
-	}
-
-	conf, _ := NewConfig()
-
-	for _, s := range ss {
-		_ = conf.Load(s)
-	}
-	runtime.Gosched()
-
-	for i := range ss {
-		k := fmt.Sprintf("key%d", i)
-		v := fmt.Sprintf("val%d", i)
-		equalS(t, conf.Get(k).String(""), v)
-	}
+	t.Logf("%#+v\n", conf)
 }

config/encoder/encoder.go

@@ -1,8 +0,0 @@
-// Package encoder handles source encoding formats
-package encoder
-
-type Encoder interface {
-	Encode(interface{}) ([]byte, error)
-	Decode([]byte, interface{}) error
-	String() string
-}

config/encoder/hcl/hcl.go

@@ -1,26 +0,0 @@
-package hcl
-
-import (
-	"encoding/json"
-
-	"github.com/hashicorp/hcl"
-	"github.com/unistack-org/micro/v3/config/encoder"
-)
-
-type hclEncoder struct{}
-
-func (h hclEncoder) Encode(v interface{}) ([]byte, error) {
-	return json.Marshal(v)
-}
-
-func (h hclEncoder) Decode(d []byte, v interface{}) error {
-	return hcl.Unmarshal(d, v)
-}
-
-func (h hclEncoder) String() string {
-	return "hcl"
-}
-
-func NewEncoder() encoder.Encoder {
-	return hclEncoder{}
-}

config/encoder/json/json.go

@@ -1,25 +0,0 @@
-package json
-
-import (
-	"encoding/json"
-
-	"github.com/unistack-org/micro/v3/config/encoder"
-)
-
-type jsonEncoder struct{}
-
-func (j jsonEncoder) Encode(v interface{}) ([]byte, error) {
-	return json.Marshal(v)
-}
-
-func (j jsonEncoder) Decode(d []byte, v interface{}) error {
-	return json.Unmarshal(d, v)
-}
-
-func (j jsonEncoder) String() string {
-	return "json"
-}
-
-func NewEncoder() encoder.Encoder {
-	return jsonEncoder{}
-}

config/encoder/toml/toml.go

@@ -1,32 +0,0 @@
-package toml
-
-import (
-	"bytes"
-
-	"github.com/BurntSushi/toml"
-	"github.com/unistack-org/micro/v3/config/encoder"
-)
-
-type tomlEncoder struct{}
-
-func (t tomlEncoder) Encode(v interface{}) ([]byte, error) {
-	b := bytes.NewBuffer(nil)
-	defer b.Reset()
-	err := toml.NewEncoder(b).Encode(v)
-	if err != nil {
-		return nil, err
-	}
-	return b.Bytes(), nil
-}
-
-func (t tomlEncoder) Decode(d []byte, v interface{}) error {
-	return toml.Unmarshal(d, v)
-}
-
-func (t tomlEncoder) String() string {
-	return "toml"
-}
-
-func NewEncoder() encoder.Encoder {
-	return tomlEncoder{}
-}

config/encoder/xml/xml.go

@@ -1,25 +0,0 @@
-package xml
-
-import (
-	"encoding/xml"
-
-	"github.com/unistack-org/micro/v3/config/encoder"
-)
-
-type xmlEncoder struct{}
-
-func (x xmlEncoder) Encode(v interface{}) ([]byte, error) {
-	return xml.Marshal(v)
-}
-
-func (x xmlEncoder) Decode(d []byte, v interface{}) error {
-	return xml.Unmarshal(d, v)
-}
-
-func (x xmlEncoder) String() string {
-	return "xml"
-}
-
-func NewEncoder() encoder.Encoder {
-	return xmlEncoder{}
-}

config/encoder/yaml/yaml.go

@@ -1,24 +0,0 @@
-package yaml
-
-import (
-	"github.com/ghodss/yaml"
-	"github.com/unistack-org/micro/v3/config/encoder"
-)
-
-type yamlEncoder struct{}
-
-func (y yamlEncoder) Encode(v interface{}) ([]byte, error) {
-	return yaml.Marshal(v)
-}
-
-func (y yamlEncoder) Decode(d []byte, v interface{}) error {
-	return yaml.Unmarshal(d, v)
-}
-
-func (y yamlEncoder) String() string {
-	return "yaml"
-}
-
-func NewEncoder() encoder.Encoder {
-	return yamlEncoder{}
-}

config/loader/loader.go

@@ -1,63 +0,0 @@
-// package loader manages loading from multiple sources
-package loader
-
-import (
-	"context"
-
-	"github.com/unistack-org/micro/v3/config/reader"
-	"github.com/unistack-org/micro/v3/config/source"
-)
-
-// Loader manages loading sources
-type Loader interface {
-	// Stop the loader
-	Close() error
-	// Load the sources
-	Load(...source.Source) error
-	// A Snapshot of loaded config
-	Snapshot() (*Snapshot, error)
-	// Force sync of sources
-	Sync() error
-	// Watch for changes
-	Watch(...string) (Watcher, error)
-	// Name of loader
-	String() string
-}
-
-// Watcher lets you watch sources and returns a merged ChangeSet
-type Watcher interface {
-	// First call to next may return the current Snapshot
-	// If you are watching a path then only the data from
-	// that path is returned.
-	Next() (*Snapshot, error)
-	// Stop watching for changes
-	Stop() error
-}
-
-// Snapshot is a merged ChangeSet
-type Snapshot struct {
-	// The merged ChangeSet
-	ChangeSet *source.ChangeSet
-	// Deterministic and comparable version of the snapshot
-	Version string
-}
-
-type Options struct {
-	Reader reader.Reader
-	Source []source.Source
-
-	// for alternative data
-	Context context.Context
-}
-
-type Option func(o *Options)
-
-// Copy snapshot
-func Copy(s *Snapshot) *Snapshot {
-	cs := *(s.ChangeSet)
-
-	return &Snapshot{
-		ChangeSet: &cs,
-		Version:   s.Version,
-	}
-}

config/options.go

@@ -1,28 +1,103 @@
 package config
 
 import (
-	"github.com/unistack-org/micro/v3/config/loader"
-	"github.com/unistack-org/micro/v3/config/reader"
-	"github.com/unistack-org/micro/v3/config/source"
+	"context"
+
+	"github.com/unistack-org/micro/v3/codec"
+	"github.com/unistack-org/micro/v3/logger"
 )
 
-// WithLoader sets the loader for manager config
-func WithLoader(l loader.Loader) Option {
+type Options struct {
+	AllowFail  bool
+	BeforeLoad []func(context.Context, Config) error
+	AfterLoad  []func(context.Context, Config) error
+	BeforeSave []func(context.Context, Config) error
+	AfterSave  []func(context.Context, Config) error
+	// Struct that holds config data
+	Struct interface{}
+	// struct tag name
+	StructTag string
+	// logger that will be used
+	Logger logger.Logger
+	// codec that used for load/save
+	Codec codec.Codec
+	// for alternative data
+	Context context.Context
+}
+
+type Option func(o *Options)
+
+func NewOptions(opts ...Option) Options {
+	options := Options{
+		Logger:  logger.DefaultLogger,
+		Context: context.Background(),
+	}
+	for _, o := range opts {
+		o(&options)
+	}
+
+	return options
+}
+
+func AllowFail(b bool) Option {
 	return func(o *Options) {
-		o.Loader = l
+		o.AllowFail = b
 	}
 }
 
-// WithSource appends a source to list of sources
-func WithSource(s source.Source) Option {
+func BeforeLoad(fn ...func(context.Context, Config) error) Option {
 	return func(o *Options) {
-		o.Source = append(o.Source, s)
+		o.BeforeLoad = fn
 	}
 }
 
-// WithReader sets the config reader
-func WithReader(r reader.Reader) Option {
+func AfterLoad(fn ...func(context.Context, Config) error) Option {
 	return func(o *Options) {
-		o.Reader = r
+		o.AfterLoad = fn
+	}
+}
+
+func BeforeSave(fn ...func(context.Context, Config) error) Option {
+	return func(o *Options) {
+		o.BeforeSave = fn
+	}
+}
+
+func AfterSave(fn ...func(context.Context, Config) error) Option {
+	return func(o *Options) {
+		o.AfterSave = fn
+	}
+}
+
+func Context(ctx context.Context) Option {
+	return func(o *Options) {
+		o.Context = ctx
+	}
+}
+
+// Codec sets the source codec
+func Codec(c codec.Codec) Option {
+	return func(o *Options) {
+		o.Codec = c
+	}
+}
+
+func Logger(l logger.Logger) Option {
+	return func(o *Options) {
+		o.Logger = l
+	}
+}
+
+// Struct used as config
+func Struct(v interface{}) Option {
+	return func(o *Options) {
+		o.Struct = v
+	}
+}
+
+// StructTag
+func StructTag(name string) Option {
+	return func(o *Options) {
+		o.StructTag = name
 	}
 }

config/reader/options.go

@@ -1,50 +0,0 @@
-package reader
-
-import (
-	"github.com/unistack-org/micro/v3/config/encoder"
-	"github.com/unistack-org/micro/v3/config/encoder/hcl"
-	"github.com/unistack-org/micro/v3/config/encoder/json"
-	"github.com/unistack-org/micro/v3/config/encoder/toml"
-	"github.com/unistack-org/micro/v3/config/encoder/xml"
-	"github.com/unistack-org/micro/v3/config/encoder/yaml"
-)
-
-type Options struct {
-	Encoding              map[string]encoder.Encoder
-	DisableReplaceEnvVars bool
-}
-
-type Option func(o *Options)
-
-func NewOptions(opts ...Option) Options {
-	options := Options{
-		Encoding: map[string]encoder.Encoder{
-			"json": json.NewEncoder(),
-			"yaml": yaml.NewEncoder(),
-			"toml": toml.NewEncoder(),
-			"xml":  xml.NewEncoder(),
-			"hcl":  hcl.NewEncoder(),
-			"yml":  yaml.NewEncoder(),
-		},
-	}
-	for _, o := range opts {
-		o(&options)
-	}
-	return options
-}
-
-func WithEncoder(e encoder.Encoder) Option {
-	return func(o *Options) {
-		if o.Encoding == nil {
-			o.Encoding = make(map[string]encoder.Encoder)
-		}
-		o.Encoding[e.String()] = e
-	}
-}
-
-// WithDisableReplaceEnvVars disables the environment variable interpolation preprocessor
-func WithDisableReplaceEnvVars() Option {
-	return func(o *Options) {
-		o.DisableReplaceEnvVars = true
-	}
-}

config/reader/preprocessor.go

@@ -1,23 +0,0 @@
-package reader
-
-import (
-	"os"
-	"regexp"
-)
-
-func ReplaceEnvVars(raw []byte) ([]byte, error) {
-	re := regexp.MustCompile(`\$\{([A-Za-z0-9_]+)\}`)
-	if re.Match(raw) {
-		dataS := string(raw)
-		res := re.ReplaceAllStringFunc(dataS, replaceEnvVars)
-		return []byte(res), nil
-	} else {
-		return raw, nil
-	}
-}
-
-func replaceEnvVars(element string) string {
-	v := element[2 : len(element)-1]
-	el := os.Getenv(v)
-	return el
-}

config/reader/preprocessor_test.go

@@ -1,73 +0,0 @@
-package reader
-
-import (
-	"os"
-	"strings"
-	"testing"
-)
-
-func TestReplaceEnvVars(t *testing.T) {
-	os.Setenv("myBar", "cat")
-	os.Setenv("MYBAR", "cat")
-	os.Setenv("my_Bar", "cat")
-	os.Setenv("myBar_", "cat")
-
-	testData := []struct {
-		expected string
-		data     []byte
-	}{
-		// Right use cases
-		{
-			`{"foo": "bar", "baz": {"bar": "cat"}}`,
-			[]byte(`{"foo": "bar", "baz": {"bar": "${myBar}"}}`),
-		},
-		{
-			`{"foo": "bar", "baz": {"bar": "cat"}}`,
-			[]byte(`{"foo": "bar", "baz": {"bar": "${MYBAR}"}}`),
-		},
-		{
-			`{"foo": "bar", "baz": {"bar": "cat"}}`,
-			[]byte(`{"foo": "bar", "baz": {"bar": "${my_Bar}"}}`),
-		},
-		{
-			`{"foo": "bar", "baz": {"bar": "cat"}}`,
-			[]byte(`{"foo": "bar", "baz": {"bar": "${myBar_}"}}`),
-		},
-		// Wrong use cases
-		{
-			`{"foo": "bar", "baz": {"bar": "${myBar-}"}}`,
-			[]byte(`{"foo": "bar", "baz": {"bar": "${myBar-}"}}`),
-		},
-		{
-			`{"foo": "bar", "baz": {"bar": "${}"}}`,
-			[]byte(`{"foo": "bar", "baz": {"bar": "${}"}}`),
-		},
-		{
-			`{"foo": "bar", "baz": {"bar": "$sss}"}}`,
-			[]byte(`{"foo": "bar", "baz": {"bar": "$sss}"}}`),
-		},
-		{
-			`{"foo": "bar", "baz": {"bar": "${sss"}}`,
-			[]byte(`{"foo": "bar", "baz": {"bar": "${sss"}}`),
-		},
-		{
-			`{"foo": "bar", "baz": {"bar": "{something}"}}`,
-			[]byte(`{"foo": "bar", "baz": {"bar": "{something}"}}`),
-		},
-		// Use cases without replace env vars
-		{
-			`{"foo": "bar", "baz": {"bar": "cat"}}`,
-			[]byte(`{"foo": "bar", "baz": {"bar": "cat"}}`),
-		},
-	}
-
-	for _, test := range testData {
-		res, err := ReplaceEnvVars(test.data)
-		if err != nil {
-			t.Fatal(err)
-		}
-		if strings.Compare(test.expected, string(res)) != 0 {
-			t.Fatalf("Expected %s got %s", test.expected, res)
-		}
-	}
-}

config/reader/reader.go

@@ -1,38 +0,0 @@
-// Package reader parses change sets and provides config values
-package reader
-
-import (
-	"time"
-
-	"github.com/unistack-org/micro/v3/config/source"
-)
-
-// Reader is an interface for merging changesets
-type Reader interface {
-	Merge(...*source.ChangeSet) (*source.ChangeSet, error)
-	Values(*source.ChangeSet) (Values, error)
-	String() string
-}
-
-// Values is returned by the reader
-type Values interface {
-	Bytes() []byte
-	Get(path ...string) (Value, error)
-	Set(val interface{}, path ...string) error
-	Del(path ...string) error
-	Map() map[string]interface{}
-	Scan(v interface{}) error
-}
-
-// Value represents a value of any type
-type Value interface {
-	Bool(def bool) bool
-	Int(def int) int
-	String(def string) string
-	Float64(def float64) float64
-	Duration(def time.Duration) time.Duration
-	StringSlice(def []string) []string
-	StringMap(def map[string]string) map[string]string
-	Scan(val interface{}) error
-	Bytes() []byte
-}

config/reflect.go

@@ -0,0 +1,46 @@
+package config
+
+import (
+	"reflect"
+)
+
+func IsEmpty(v reflect.Value) bool {
+	switch v.Kind() {
+	case reflect.Array, reflect.Map, reflect.Slice, reflect.String:
+		return v.Len() == 0
+	case reflect.Bool:
+		return !v.Bool()
+	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+		return v.Int() == 0
+	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
+		return v.Uint() == 0
+	case reflect.Float32, reflect.Float64:
+		return v.Float() == 0
+	case reflect.Interface, reflect.Ptr:
+		if v.IsNil() {
+			return true
+		}
+		return IsEmpty(v.Elem())
+	case reflect.Func:
+		return v.IsNil()
+	case reflect.Invalid:
+		return true
+	}
+	return false
+}
+
+func Zero(src interface{}) (interface{}, error) {
+	sv := reflect.ValueOf(src)
+
+	if sv.Kind() == reflect.Ptr {
+		sv = sv.Elem()
+	}
+
+	if sv.Kind() == reflect.Invalid {
+		return nil, ErrInvalidStruct
+	}
+
+	dst := reflect.New(sv.Type())
+
+	return dst.Interface(), nil
+}

config/reflect_test.go

@@ -0,0 +1,26 @@
+package config_test
+
+import (
+	"testing"
+
+	"github.com/unistack-org/micro/v3/config"
+)
+
+type Config struct {
+	Value     string
+	SubConfig *SubConfig
+	Config    *Config
+}
+
+type SubConfig struct {
+	Value string
+}
+
+func TestReflect(t *testing.T) {
+	cfg1 := &Config{Value: "cfg1", Config: &Config{Value: "cfg1_1"}, SubConfig: &SubConfig{Value: "cfg1"}}
+	cfg2, err := config.Zero(cfg1)
+	if err != nil {
+		t.Fatal(err)
+	}
+	t.Logf("dst: %#+v\n", cfg2)
+}

config/source/changeset.go

@@ -1,13 +0,0 @@
-package source
-
-import (
-	"crypto/md5"
-	"fmt"
-)
-
-// Sum returns the md5 checksum of the ChangeSet data
-func (c *ChangeSet) Sum() string {
-	h := md5.New()
-	h.Write(c.Data)
-	return fmt.Sprintf("%x", h.Sum(nil))
-}

config/source/noop.go

@@ -1,25 +0,0 @@
-package source
-
-import (
-	"errors"
-)
-
-type noopWatcher struct {
-	exit chan struct{}
-}
-
-func (w *noopWatcher) Next() (*ChangeSet, error) {
-	<-w.exit
-
-	return nil, errors.New("noopWatcher stopped")
-}
-
-func (w *noopWatcher) Stop() error {
-	close(w.exit)
-	return nil
-}
-
-// NewNoopWatcher returns a watcher that blocks on Next() until Stop() is called.
-func NewNoopWatcher() (Watcher, error) {
-	return &noopWatcher{exit: make(chan struct{})}, nil
-}

config/source/options.go

@@ -1,49 +0,0 @@
-package source
-
-import (
-	"context"
-
-	"github.com/unistack-org/micro/v3/client"
-	"github.com/unistack-org/micro/v3/config/encoder"
-	"github.com/unistack-org/micro/v3/config/encoder/json"
-)
-
-type Options struct {
-	// Encoder
-	Encoder encoder.Encoder
-
-	// for alternative data
-	Context context.Context
-
-	// Client to use for RPC
-	Client client.Client
-}
-
-type Option func(o *Options)
-
-func NewOptions(opts ...Option) Options {
-	options := Options{
-		Encoder: json.NewEncoder(),
-		Context: context.Background(),
-	}
-
-	for _, o := range opts {
-		o(&options)
-	}
-
-	return options
-}
-
-// WithEncoder sets the source encoder
-func WithEncoder(e encoder.Encoder) Option {
-	return func(o *Options) {
-		o.Encoder = e
-	}
-}
-
-// WithClient sets the source client
-func WithClient(c client.Client) Option {
-	return func(o *Options) {
-		o.Client = c
-	}
-}

config/source/source.go

@@ -1,35 +0,0 @@
-// Package source is the interface for sources
-package source
-
-import (
-	"errors"
-	"time"
-)
-
-var (
-	// ErrWatcherStopped is returned when source watcher has been stopped
-	ErrWatcherStopped = errors.New("watcher stopped")
-)
-
-// Source is the source from which config is loaded
-type Source interface {
-	Read() (*ChangeSet, error)
-	Write(*ChangeSet) error
-	Watch() (Watcher, error)
-	String() string
-}
-
-// ChangeSet represents a set of changes from a source
-type ChangeSet struct {
-	Data      []byte
-	Checksum  string
-	Format    string
-	Source    string
-	Timestamp time.Time
-}
-
-// Watcher watches a source for changes
-type Watcher interface {
-	Next() (*ChangeSet, error)
-	Stop() error
-}

config/value.go

@@ -1,49 +0,0 @@
-package config
-
-import (
-	"time"
-
-	"github.com/unistack-org/micro/v3/config/reader"
-)
-
-type value struct{}
-
-func newValue() reader.Value {
-	return new(value)
-}
-
-func (v *value) Bool(def bool) bool {
-	return false
-}
-
-func (v *value) Int(def int) int {
-	return 0
-}
-
-func (v *value) String(def string) string {
-	return ""
-}
-
-func (v *value) Float64(def float64) float64 {
-	return 0.0
-}
-
-func (v *value) Duration(def time.Duration) time.Duration {
-	return time.Duration(0)
-}
-
-func (v *value) StringSlice(def []string) []string {
-	return nil
-}
-
-func (v *value) StringMap(def map[string]string) map[string]string {
-	return map[string]string{}
-}
-
-func (v *value) Scan(val interface{}) error {
-	return nil
-}
-
-func (v *value) Bytes() []byte {
-	return nil
-}

debug/log/kubernetes/kubernetes.go

@@ -11,6 +11,7 @@ import (
 	"time"
 
 	"github.com/unistack-org/micro/v3/debug/log"
+	"github.com/unistack-org/micro/v3/metadata"
 	"github.com/unistack-org/micro/v3/util/kubernetes/client"
 )
 
@@ -89,7 +90,7 @@ func (k *klog) parse(line string) log.Record {
 	if err := json.Unmarshal([]byte(line), &record); err != nil {
 		record.Timestamp = time.Now().UTC()
 		record.Message = line
-		record.Metadata = make(map[string]string)
+		record.Metadata = metadata.New(1)
 	}
 
 	record.Metadata["service"] = k.Options.Name

debug/log/log.go

@@ -5,6 +5,8 @@ import (
 	"encoding/json"
 	"fmt"
 	"time"
+
+	"github.com/unistack-org/micro/v3/metadata"
 )
 
 var (
@@ -29,7 +31,7 @@ type Record struct {
 	// Timestamp of logged event
 	Timestamp time.Time `json:"timestamp"`
 	// Metadata to enrich log record
-	Metadata map[string]string `json:"metadata"`
+	Metadata metadata.Metadata `json:"metadata"`
 	// Value contains log entry
 	Message interface{} `json:"message"`
 }

errors/errors.go

@@ -9,18 +9,30 @@ import (
 )
 
 var (
-	ErrBadRequest          = &Error{Code: 400}
-	ErrUnauthorized        = &Error{Code: 401}
-	ErrForbidden           = &Error{Code: 403}
-	ErrNotFound            = &Error{Code: 404}
-	ErrMethodNotAllowed    = &Error{Code: 405}
-	ErrTimeout             = &Error{Code: 408}
-	ErrConflict            = &Error{Code: 409}
+	// ErrBadRequest
+	ErrBadRequest = &Error{Code: 400}
+	// ErrUnauthorized
+	ErrUnauthorized = &Error{Code: 401}
+	// ErrForbidden
+	ErrForbidden = &Error{Code: 403}
+	// ErrNotFound
+	ErrNotFound = &Error{Code: 404}
+	// ErrMethodNotAllowed
+	ErrMethodNotAllowed = &Error{Code: 405}
+	// ErrTimeout
+	ErrTimeout = &Error{Code: 408}
+	// ErrConflict
+	ErrConflict = &Error{Code: 409}
+	// ErrInternalServerError
 	ErrInternalServerError = &Error{Code: 500}
-	ErNotImplemented       = &Error{Code: 501}
-	ErrBadGateway          = &Error{Code: 502}
-	ErrServiceUnavailable  = &Error{Code: 503}
-	ErrGatewayTimeout      = &Error{Code: 504}
+	// ErNotImplemented
+	ErNotImplemented = &Error{Code: 501}
+	// ErrBadGateway
+	ErrBadGateway = &Error{Code: 502}
+	// ErrServiceUnavailable
+	ErrServiceUnavailable = &Error{Code: 503}
+	// ErrGatewayTimeout
+	ErrGatewayTimeout = &Error{Code: 504}
 )
 
 // Error tpye

events/events.go

@@ -6,6 +6,8 @@ import (
 	"encoding/json"
 	"errors"
 	"time"
+
+	"github.com/unistack-org/micro/v3/metadata"
 )
 
 var (
@@ -36,7 +38,7 @@ type Event struct {
 	// Timestamp of the event
 	Timestamp time.Time
 	// Metadata contains the encoded event was indexed by
-	Metadata map[string]string
+	Metadata metadata.Metadata
 	// Payload contains the encoded message
 	Payload []byte
 }

events/options.go

@@ -1,11 +1,15 @@
 package events
 
-import "time"
+import (
+	"time"
+
+	"github.com/unistack-org/micro/v3/metadata"
+)
 
 // PublishOptions contains all the options which can be provided when publishing an event
 type PublishOptions struct {
 	// Metadata contains any keys which can be used to query the data, for example a customer id
-	Metadata map[string]string
+	Metadata metadata.Metadata
 	// Timestamp to set for the event, if the timestamp is a zero value, the current time will be used
 	Timestamp time.Time
 }
@@ -14,9 +18,9 @@ type PublishOptions struct {
 type PublishOption func(o *PublishOptions)
 
 // WithMetadata sets the Metadata field on PublishOptions
-func WithMetadata(md map[string]string) PublishOption {
+func WithMetadata(md metadata.Metadata) PublishOption {
 	return func(o *PublishOptions) {
-		o.Metadata = md
+		o.Metadata = metadata.Copy(md)
 	}
 }
 

go.mod

@@ -3,31 +3,22 @@ module github.com/unistack-org/micro/v3
 go 1.14
 
 require (
-	github.com/BurntSushi/toml v0.3.1
 	github.com/caddyserver/certmagic v0.10.6
 	github.com/dgrijalva/jwt-go v3.2.0+incompatible
 	github.com/ef-ds/deque v1.0.4-0.20190904040645-54cb57c252a1
-	github.com/evanphx/json-patch/v5 v5.1.0
-	github.com/ghodss/yaml v1.0.0
 	github.com/go-acme/lego/v3 v3.4.0
-	github.com/gobwas/httphead v0.0.0-20180130184737-2c6c146eadee
-	github.com/gobwas/ws v1.0.3
 	github.com/golang/protobuf v1.4.3
 	github.com/google/uuid v1.1.2
-	github.com/hashicorp/hcl v1.0.0
-	github.com/micro/cli/v2 v2.1.2
+	github.com/kr/text v0.2.0 // indirect
 	github.com/miekg/dns v1.1.31
+	github.com/niemeyer/pretty v0.0.0-20200227124842-a10e7caefd8e // indirect
 	github.com/oxtoacart/bpool v0.0.0-20190530202638-03653db5a59c
-	github.com/patrickmn/go-cache v2.1.0+incompatible
 	github.com/stretchr/testify v1.5.1
-	github.com/unistack-org/micro-codec-bytes v0.0.0-20200828083432-4e49e953d844
-	github.com/unistack-org/micro-codec-json v0.0.0-20201102222734-a29c895ec05c
-	github.com/unistack-org/micro-codec-jsonrpc v0.0.0-20201102222451-ff6a69988bcd
-	github.com/unistack-org/micro-codec-proto v0.0.0-20201102222202-769c2d6a4b92
-	github.com/unistack-org/micro-codec-protorpc v0.0.0-20201102222610-3a343898c077
-	github.com/unistack-org/micro-config-cmd v0.0.0-20201028144621-5a55f1aad70a
 	golang.org/x/crypto v0.0.0-20200820211705-5c72a883971a
 	golang.org/x/net v0.0.0-20200904194848-62affa334b73
-	google.golang.org/genproto v0.0.0-20200904004341-0bd0a958aa1d
+	golang.org/x/sys v0.0.0-20200615200032-f1bc736245b1 // indirect
 	google.golang.org/protobuf v1.25.0
+	gopkg.in/check.v1 v1.0.0-20200227125254-8fa46927fb4f // indirect
+	gopkg.in/square/go-jose.v2 v2.4.1 // indirect
+	gopkg.in/yaml.v2 v2.3.0 // indirect
 )

go.sum

@@ -41,10 +41,7 @@ github.com/aws/aws-sdk-go v1.23.0/go.mod h1:KmX6BPdI08NWTb3/sm4ZGu5ShLoqVDhKgpiN
 github.com/baiyubin/aliyun-sts-go-sdk v0.0.0-20180326062324-cfa1a18b161f/go.mod h1:AuiFmCCPBSrqvVMvuqFuk0qogytodnVFVSN5CeJB8Gc=
 github.com/beorn7/perks v0.0.0-20180321164747-3a771d992973/go.mod h1:Dwedo/Wpr24TaqPxmxbtue+5NUziq4I4S80YR8gNf3Q=
 github.com/beorn7/perks v1.0.0/go.mod h1:KWe93zE9D1o94FZ5RNwFwVgaQK1VOXiVxmqh+CedLV8=
-github.com/beorn7/perks v1.0.1 h1:VlbKKnNfV8bJzeqoa4cOKqO6bYr3WgKZxO8Z16+hsOM=
 github.com/beorn7/perks v1.0.1/go.mod h1:G2ZrVWU2WbWT9wwq4/hrbKbnv/1ERSJQ0ibhJ6rlkpw=
-github.com/bradfitz/gomemcache v0.0.0-20190913173617-a41fca850d0b h1:L/QXpzIa3pOvUGt1D1lA5KjYhPBAN/3iWdP7xeFS9F0=
-github.com/bradfitz/gomemcache v0.0.0-20190913173617-a41fca850d0b/go.mod h1:H0wQNHz2YrLsuXOZozoeDmnHXkNCRmMW0gwFWDfEZDA=
 github.com/caddyserver/certmagic v0.10.6 h1:sCya6FmfaN74oZE46kqfaFOVoROD/mF36rTQfjN7TZc=
 github.com/caddyserver/certmagic v0.10.6/go.mod h1:Y8jcUBctgk/IhpAzlHKfimZNyXCkfGgRTC0orl8gROQ=
 github.com/cenkalti/backoff/v4 v4.0.0 h1:6VeaLF9aI+MAUQ95106HwWzYZgJJpZ4stumjj6RFYAU=
@@ -55,8 +52,6 @@ github.com/client9/misspell v0.3.4/go.mod h1:qj6jICC3Q7zFZvVWo7KLAzC3yx5G7kyvSDk
 github.com/cloudflare/cloudflare-go v0.10.2/go.mod h1:qhVI5MKwBGhdNU89ZRz2plgYutcJ5PCekLxXn56w6SY=
 github.com/cpu/goacmedns v0.0.1/go.mod h1:sesf/pNnCYwUevQEQfEwY0Y3DydlQWSGZbaMElOWxok=
 github.com/cpuguy83/go-md2man/v2 v2.0.0-20190314233015-f79a8a8ca69d/go.mod h1:maD7wRr/U5Z6m/iR4s+kqSMx2CaBsrgA7czyZG/E6dU=
-github.com/cpuguy83/go-md2man/v2 v2.0.0 h1:EoUDS0afbrsXAZ9YQ9jdu/mZ2sXgT1/2yyNng4PGlyM=
-github.com/cpuguy83/go-md2man/v2 v2.0.0/go.mod h1:maD7wRr/U5Z6m/iR4s+kqSMx2CaBsrgA7czyZG/E6dU=
 github.com/creack/pty v1.1.9/go.mod h1:oKZEueFk5CKHvIhNR5MUki03XCEU+Q6VDXinZuGJ33E=
 github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
@@ -73,13 +68,8 @@ github.com/ef-ds/deque v1.0.4-0.20190904040645-54cb57c252a1 h1:jFGzikHboUMRXmMBt
 github.com/ef-ds/deque v1.0.4-0.20190904040645-54cb57c252a1/go.mod h1:HvODWzv6Y6kBf3Ah2WzN1bHjDUezGLaAhwuWVwfpEJs=
 github.com/envoyproxy/go-control-plane v0.9.1-0.20191026205805-5f8ba28d4473/go.mod h1:YTl/9mNaCwkRvm6d1a2C3ymFceY/DCBVvsKhRF0iEA4=
 github.com/envoyproxy/protoc-gen-validate v0.1.0/go.mod h1:iSmxcyjqTsJpI2R4NaDN7+kN2VEUnK/pcBlmesArF7c=
-github.com/evanphx/json-patch/v5 v5.0.0 h1:dKTrUeykyQwKb/kx7Z+4ukDs6l+4L41HqG1XHnhX7WE=
-github.com/evanphx/json-patch/v5 v5.0.0/go.mod h1:G79N1coSVB93tBe7j6PhzjmR3/2VvlbKOFpnXhI9Bw4=
-github.com/evanphx/json-patch/v5 v5.1.0 h1:B0aXl1o/1cP8NbviYiBMkcHBtUjIJ1/Ccg6b+SwCLQg=
-github.com/evanphx/json-patch/v5 v5.1.0/go.mod h1:G79N1coSVB93tBe7j6PhzjmR3/2VvlbKOFpnXhI9Bw4=
 github.com/exoscale/egoscale v0.18.1/go.mod h1:Z7OOdzzTOz1Q1PjQXumlz9Wn/CddH0zSYdCF3rnBKXE=
 github.com/fatih/structs v1.1.0/go.mod h1:9NiDSp5zOcgEDl+j00MP/WkGVPOlPRLejGD8Ga6PJ7M=
-github.com/fsnotify/fsnotify v1.4.7 h1:IXs+QLmnXW2CcXuY+8Mzv/fWEsPGWxqefPtCP5CnV9I=
 github.com/fsnotify/fsnotify v1.4.7/go.mod h1:jwhsz4b93w/PPRr/qN1Yymfu8t87LnFCMoQvtojpjFo=
 github.com/ghodss/yaml v1.0.0 h1:wQHKEahhL6wmXdzwWG11gIVCkOv05bNOh+Rxn0yngAk=
 github.com/ghodss/yaml v1.0.0/go.mod h1:4dBDuWmgqj2HViK6kFavaiC9ZROes6MMH2rRYeMEF04=
@@ -93,21 +83,13 @@ github.com/go-kit/kit v0.8.0/go.mod h1:xBxKIO96dXMWWy0MnWVtmwkA9/13aqxPnvrjFYMA2
 github.com/go-logfmt/logfmt v0.3.0/go.mod h1:Qt1PoO58o5twSAckw1HlFXLmHsOX5/0LbT9GBnD5lWE=
 github.com/go-logfmt/logfmt v0.4.0/go.mod h1:3RMwSq7FuexP4Kalkev3ejPJsZTpXXBr9+V4qmtdjCk=
 github.com/go-stack/stack v1.8.0/go.mod h1:v0f6uXyyMGvRgIKkXu+yp6POWl0qKG85gN/melR3HDY=
-github.com/gobwas/httphead v0.0.0-20180130184737-2c6c146eadee h1:s+21KNqlpePfkah2I+gwHF8xmJWRjooY+5248k6m4A0=
-github.com/gobwas/httphead v0.0.0-20180130184737-2c6c146eadee/go.mod h1:L0fX3K22YWvt/FAX9NnzrNzcI4wNYi9Yku4O0LKYflo=
-github.com/gobwas/pool v0.2.1 h1:xfeeEhW7pwmX8nuLVlqbzVc7udMDrwetjEv+TZIz1og=
-github.com/gobwas/pool v0.2.1/go.mod h1:q8bcK0KcYlCgd9e7WYLm9LpyS+YeLd8JVDW6WezmKEw=
-github.com/gobwas/ws v1.0.3 h1:ZOigqf7iBxkA4jdQ3am7ATzdlOFp9YzA6NmuvEEZc9g=
-github.com/gobwas/ws v1.0.3/go.mod h1:szmBTxLgaFppYjEmNtny/v3w89xOydFnnZMcgRRu/EM=
 github.com/gofrs/uuid v3.2.0+incompatible/go.mod h1:b2aQJv3Z4Fp6yNu3cdSllBxTCLRxnplIgP/c0N/04lM=
 github.com/gogo/protobuf v1.1.1/go.mod h1:r8qH/GZQm5c6nD/R0oafs1akxWv10x8SbQlK7atdtwQ=
 github.com/gogo/protobuf v1.2.0/go.mod h1:r8qH/GZQm5c6nD/R0oafs1akxWv10x8SbQlK7atdtwQ=
 github.com/goji/httpauth v0.0.0-20160601135302-2da839ab0f4d/go.mod h1:nnjvkQ9ptGaCkuDUx6wNykzzlUixGxvkme+H/lnzb+A=
-github.com/golang/glog v0.0.0-20160126235308-23def4e6c14b h1:VKtxabqXZkF25pY9ekfRL6a582T4P37/31XEstQ5p58=
 github.com/golang/glog v0.0.0-20160126235308-23def4e6c14b/go.mod h1:SBH7ygxi8pfUlaOkMMuAQtPIUF8ecWP5IEl/CR7VP2Q=
 github.com/golang/mock v1.1.1/go.mod h1:oTYuIxOrZwtPieC+H1uAHpcLFnEyAGVDL/k47Jfbm0A=
 github.com/golang/mock v1.2.0/go.mod h1:oTYuIxOrZwtPieC+H1uAHpcLFnEyAGVDL/k47Jfbm0A=
-github.com/golang/mock v1.3.1 h1:qGJ6qTW+x6xX/my+8YUVl4WNpX9B7+/l2tRsHGZ7f2s=
 github.com/golang/mock v1.3.1/go.mod h1:sBzyDLLjw3U8JLTeZvSv8jJB+tU5PVekmnlKIyFUx0Y=
 github.com/golang/protobuf v1.2.0/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
 github.com/golang/protobuf v1.3.1/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
@@ -116,32 +98,25 @@ github.com/golang/protobuf v1.4.0-rc.1/go.mod h1:ceaxUfeHdC40wWswd/P6IGgMaK3YpKi
 github.com/golang/protobuf v1.4.0-rc.1.0.20200221234624-67d41d38c208/go.mod h1:xKAWHe0F5eneWXFV3EuXVDTCmh+JuBKY0li0aMyXATA=
 github.com/golang/protobuf v1.4.0-rc.2/go.mod h1:LlEzMj4AhA7rCAGe4KMBDvJI+AwstrUpVNzEA03Pprs=
 github.com/golang/protobuf v1.4.0-rc.4.0.20200313231945-b860323f09d0/go.mod h1:WU3c8KckQ9AFe+yFwt9sWVRKCVIyN9cPHBJSNnbL67w=
-github.com/golang/protobuf v1.4.0 h1:oOuy+ugB+P/kBdUnG5QaMXSIyJ1q38wWSojYCb3z5VQ=
 github.com/golang/protobuf v1.4.0/go.mod h1:jodUvKwWbYaEsadDk5Fwe5c77LiNKVO9IDvqG2KuDX0=
 github.com/golang/protobuf v1.4.1/go.mod h1:U8fpvMrcmy5pZrNK1lt4xCsGvpyWQ/VVv6QDs8UjoX8=
-github.com/golang/protobuf v1.4.2 h1:+Z5KGCizgyZCbGh1KZqA0fcLLkwbsjIzS4aV2v7wJX0=
-github.com/golang/protobuf v1.4.2/go.mod h1:oDoupMAO8OvCJWAcko0GGGIgR6R6ocIYbsSw735rRwI=
 github.com/golang/protobuf v1.4.3 h1:JjCZWpVbqXDqFVmTfYWEVTMIYrL/NPdPSCHPJ0T/raM=
 github.com/golang/protobuf v1.4.3/go.mod h1:oDoupMAO8OvCJWAcko0GGGIgR6R6ocIYbsSw735rRwI=
 github.com/golang/snappy v0.0.0-20180518054509-2e65f85255db/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q=
 github.com/google/btree v0.0.0-20180813153112-4030bb1f1f0c/go.mod h1:lNA+9X1NB3Zf8V7Ke586lFgjr2dZNuvo3lPJSGZ5JPQ=
-github.com/google/btree v1.0.0 h1:0udJVsspx3VBr5FwtLhQQtuAsVc79tTq0ocGIPAU6qo=
 github.com/google/btree v1.0.0/go.mod h1:lNA+9X1NB3Zf8V7Ke586lFgjr2dZNuvo3lPJSGZ5JPQ=
 github.com/google/go-cmp v0.2.0/go.mod h1:oXzfMopK8JAjlY9xF4vHSVASa0yLyX7SntLO5aqRK0M=
 github.com/google/go-cmp v0.3.0/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU=
 github.com/google/go-cmp v0.3.1/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU=
-github.com/google/go-cmp v0.4.0 h1:xsAVV57WRhGj6kEIi8ReJzQlHHqcBYCElAvkovg3B/4=
 github.com/google/go-cmp v0.4.0/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
 github.com/google/go-cmp v0.5.0 h1:/QaMHBdZ26BB3SSst0Iwl10Epc+xhTquomWX0oZEB6w=
 github.com/google/go-cmp v0.5.0/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
-github.com/google/go-querystring v1.0.0 h1:Xkwi/a1rcvNg1PPYe5vI8GbeBY/jrVuDX5ASuANWTrk=
 github.com/google/go-querystring v1.0.0/go.mod h1:odCYkC5MyYFN7vkCjXpyrEuKhc/BUO6wN/zVPAxq5ck=
 github.com/google/gofuzz v1.0.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg=
 github.com/google/martian v2.1.0+incompatible/go.mod h1:9I4somxYTbIHy5NJKHRl3wXiIaQGbYVAs8BPL6v8lEs=
 github.com/google/pprof v0.0.0-20181206194817-3ea8567a2e57/go.mod h1:zfwlbNMJ+OItoe0UupaVj+oy1omPYYDuagoSzA8v9mc=
 github.com/google/pprof v0.0.0-20190515194954-54271f7e092f/go.mod h1:zfwlbNMJ+OItoe0UupaVj+oy1omPYYDuagoSzA8v9mc=
 github.com/google/renameio v0.1.0/go.mod h1:KWCgfxg9yswjAJkECMjeO8J8rahYeXnNhOm40UhjYkI=
-github.com/google/uuid v1.1.1 h1:Gkbcsh/GbpXz7lPftLA3P6TYMwjCLYm83jiFQZF/3gY=
 github.com/google/uuid v1.1.1/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
 github.com/google/uuid v1.1.2 h1:EVhdT+1Kseyi1/pUmXKaFxYsDNy9RQYkMWRH68J/W7Y=
 github.com/google/uuid v1.1.2/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
@@ -152,19 +127,13 @@ github.com/gopherjs/gopherjs v0.0.0-20181017120253-0766667cb4d1/go.mod h1:wJfORR
 github.com/gorilla/context v1.1.1/go.mod h1:kBGZzfjB9CEq2AlWe17Uuf7NDRt0dE0s8S51q0aT7Yg=
 github.com/gorilla/mux v1.6.2/go.mod h1:1lud6UwP+6orDFRuTfBEV8e9/aOM/c4fVVCaMa2zaAs=
 github.com/gorilla/mux v1.7.3/go.mod h1:1lud6UwP+6orDFRuTfBEV8e9/aOM/c4fVVCaMa2zaAs=
-github.com/grpc-ecosystem/grpc-gateway v1.8.5 h1:2+KSC78XiO6Qy0hIjfc1OD9H+hsaJdJlb8Kqsd41CTE=
 github.com/grpc-ecosystem/grpc-gateway v1.8.5/go.mod h1:vNeuVxBJEsws4ogUvrchl83t/GYV9WGTSLVdBhOQFDY=
 github.com/h2non/parth v0.0.0-20190131123155-b4df798d6542/go.mod h1:Ow0tF8D4Kplbc8s8sSb3V2oUCygFHVp8gC3Dn6U4MNI=
 github.com/hashicorp/golang-lru v0.5.0/go.mod h1:/m3WP610KZHVQ1SGc6re/UDhFvYD7pJ4Ao+sR/qLZy8=
 github.com/hashicorp/golang-lru v0.5.1/go.mod h1:/m3WP610KZHVQ1SGc6re/UDhFvYD7pJ4Ao+sR/qLZy8=
-github.com/hashicorp/golang-lru v0.5.3 h1:YPkqC67at8FYaadspW/6uE0COsBxS2656RLEr8Bppgk=
 github.com/hashicorp/golang-lru v0.5.3/go.mod h1:iADmTwqILo4mZ8BN3D2Q6+9jd8WM5uGBxy+E8yxSoD4=
-github.com/hashicorp/hcl v1.0.0 h1:0Anlzjpi4vEasTeNFn2mLJgTSwt0+6sfsiTG8qcWGx4=
-github.com/hashicorp/hcl v1.0.0/go.mod h1:E5yfLk+7swimpb2L/Alb/PJmXilQ/rhwaUYs4T20WEQ=
-github.com/hpcloud/tail v1.0.0 h1:nfCOvKYfkgYP8hkirhJocXT2+zOD8yUNjXaWfTlyFKI=
 github.com/hpcloud/tail v1.0.0/go.mod h1:ab1qPbhIpdTxEkNHXyeSf5vhxWSCs/tWer42PpOxQnU=
 github.com/iij/doapi v0.0.0-20190504054126-0bbf12d6d7df/go.mod h1:QMZY7/J/KSQEhKWFeDesPjMj+wCHReeknARU3wqlyN4=
-github.com/jessevdk/go-flags v1.4.0/go.mod h1:4FA24M0QyGHXBuZZK/XkWh8h0e1EYbRYJSGM75WSRxI=
 github.com/jmespath/go-jmespath v0.0.0-20180206201540-c2b33e8439af/go.mod h1:Nht3zPeWKUH0NzdCt2Blrr5ys8VGpn0CEB0cQHVjt7k=
 github.com/json-iterator/go v1.1.5/go.mod h1:+SdeFBvtyEkXs7REEP0seUULqWtbJapLOCVDaaPEHmU=
 github.com/json-iterator/go v1.1.6/go.mod h1:+SdeFBvtyEkXs7REEP0seUULqWtbJapLOCVDaaPEHmU=
@@ -177,14 +146,10 @@ github.com/klauspost/cpuid v1.2.3 h1:CCtW0xUnWGVINKvE/WWOYKdsPV6mawAtvQuSl8guwQs
 github.com/klauspost/cpuid v1.2.3/go.mod h1:Pj4uuM528wm8OyEC2QMXAi2YiTZ96dNQPGgoMS4s3ek=
 github.com/kolo/xmlrpc v0.0.0-20190717152603-07c4ee3fd181/go.mod h1:o03bZfuBwAXHetKXuInt4S7omeXUu62/A845kiycsSQ=
 github.com/konsorten/go-windows-terminal-sequences v1.0.1/go.mod h1:T0+1ngSBFLxvqU3pZ+m/2kptfBszLMUkC4ZK/EgS/cQ=
-github.com/konsorten/go-windows-terminal-sequences v1.0.2 h1:DB17ag19krx9CFsz4o3enTrPXyIXCl+2iCXH/aMAp9s=
 github.com/konsorten/go-windows-terminal-sequences v1.0.2/go.mod h1:T0+1ngSBFLxvqU3pZ+m/2kptfBszLMUkC4ZK/EgS/cQ=
 github.com/kr/logfmt v0.0.0-20140226030751-b84e30acd515/go.mod h1:+0opPa2QZZtGFBFZlji/RkVcI2GknAs/DXo4wKdlNEc=
 github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo=
-github.com/kr/pretty v0.2.0 h1:s5hAObm+yFO5uHYt5dYjxi2rXrsnmRpJx4OYvIWUaQs=
-github.com/kr/pretty v0.2.0/go.mod h1:ipq/a2n7PKx3OHsz4KJII5eveXtPO4qwEXGdVfWzfnI=
 github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ=
-github.com/kr/text v0.1.0 h1:45sCR5RtlFHMR4UwH9sdQ5TC8v0qDQCHnXt+kaKSTVE=
 github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI=
 github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY=
 github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE=
@@ -196,24 +161,16 @@ github.com/mattn/go-isatty v0.0.3/go.mod h1:M+lRXTBqGeGNdLjl/ufCoiOlB5xdOkqRJdNx
 github.com/mattn/go-runewidth v0.0.2/go.mod h1:LwmH8dsx7+W8Uxz3IHJYH5QSwggIsqBzpuz5H//U1FU=
 github.com/mattn/go-runewidth v0.0.4/go.mod h1:LwmH8dsx7+W8Uxz3IHJYH5QSwggIsqBzpuz5H//U1FU=
 github.com/mattn/go-tty v0.0.0-20180219170247-931426f7535a/go.mod h1:XPvLUNfbS4fJH25nqRHfWLMa1ONC8Amw+mIA639KxkE=
-github.com/matttproud/golang_protobuf_extensions v1.0.1 h1:4hp9jkHxhMHkqkrB3Ix0jegS5sx/RkqARlsWZ6pIwiU=
 github.com/matttproud/golang_protobuf_extensions v1.0.1/go.mod h1:D8He9yQNgCq6Z5Ld7szi9bcBfOoFv/3dc6xSMkL2PC0=
-github.com/micro/cli/v2 v2.1.2 h1:43J1lChg/rZCC1rvdqZNFSQDrGT7qfMrtp6/ztpIkEM=
-github.com/micro/cli/v2 v2.1.2/go.mod h1:EguNh6DAoWKm9nmk+k/Rg0H3lQnDxqzu5x5srOtGtYg=
 github.com/miekg/dns v1.1.15/go.mod h1:W1PPwlIAgtquWBMBEV9nkV9Cazfe8ScdGz/Lj7v3Nrg=
-github.com/miekg/dns v1.1.27 h1:aEH/kqUzUxGJ/UHcEKdJY+ugH6WEzsEBBSPa8zuy1aM=
-github.com/miekg/dns v1.1.27/go.mod h1:KNUDUusw/aVsxyTYZM1oqvCicbwhgbNgztCETuNZ7xM=
 github.com/miekg/dns v1.1.31 h1:sJFOl9BgwbYAWOGEwr61FU28pqsBNdpRBnhGXtO06Oo=
 github.com/miekg/dns v1.1.31/go.mod h1:KNUDUusw/aVsxyTYZM1oqvCicbwhgbNgztCETuNZ7xM=
-github.com/mitchellh/go-homedir v1.1.0 h1:lukF9ziXFxDFPkA1vsr5zpc1XuPDn/wFntq5mG+4E0Y=
 github.com/mitchellh/go-homedir v1.1.0/go.mod h1:SfyaCUpYCn1Vlf4IUYiD9fPX4A5wJrkLzIz1N1q0pr0=
 github.com/mitchellh/go-vnc v0.0.0-20150629162542-723ed9867aed/go.mod h1:3rdaFaCv4AyBgu5ALFM0+tSuHrBh6v692nyQe3ikrq0=
 github.com/mitchellh/mapstructure v1.1.2/go.mod h1:FVVH3fgwuzCH5S8UJGiWEs2h04kUh9fWfEaFds41c1Y=
 github.com/modern-go/concurrent v0.0.0-20180228061459-e0a39a4cb421/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q=
-github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd h1:TRLaZ9cD/w8PVh93nsPXa1VrQ6jlwL5oN8l14QlcNfg=
 github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q=
 github.com/modern-go/reflect2 v0.0.0-20180701023420-4b7aa43c6742/go.mod h1:bx2lNnkwVCuqBIxFjflWJWanXIb3RllmbCylyMrvgv0=
-github.com/modern-go/reflect2 v1.0.1 h1:9f412s+6RmYXLWZSEzVVgPGK7C2PphHj5RJrvfx9AWI=
 github.com/modern-go/reflect2 v1.0.1/go.mod h1:bx2lNnkwVCuqBIxFjflWJWanXIb3RllmbCylyMrvgv0=
 github.com/mwitkow/go-conntrack v0.0.0-20161129095857-cc309e4a2223/go.mod h1:qRWi+5nqEBWmkhHvq77mSJWrCKwh8bxhgT7d/eI7P4U=
 github.com/namedotcom/go v0.0.0-20180403034216-08470befbe04/go.mod h1:5sN+Lt1CaY4wsPvgQH/jsuJi4XO2ssZbdsIizr4CVC8=
@@ -233,13 +190,9 @@ github.com/oracle/oci-go-sdk v7.0.0+incompatible/go.mod h1:VQb79nF8Z2cwLkLS35ukw
 github.com/ovh/go-ovh v0.0.0-20181109152953-ba5adb4cf014/go.mod h1:joRatxRJaZBsY3JAOEMcoOp05CnZzsx4scTxi95DHyQ=
 github.com/oxtoacart/bpool v0.0.0-20190530202638-03653db5a59c h1:rp5dCmg/yLR3mgFuSOe4oEnDDmGLROTvMragMUXpTQw=
 github.com/oxtoacart/bpool v0.0.0-20190530202638-03653db5a59c/go.mod h1:X07ZCGwUbLaax7L0S3Tw4hpejzu63ZrrQiUe6W0hcy0=
-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/pierrec/lz4 v2.0.5+incompatible/go.mod h1:pdkljMzZIN41W+lC3N2tnIh5sFi+IEE17M5jbnwPHcY=
 github.com/pkg/errors v0.8.0/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
 github.com/pkg/errors v0.8.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
-github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4=
-github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
 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/prometheus/client_golang v0.9.1/go.mod h1:7SWBe2y4D6OKWSNQJUaRYU/AaXPKyh/dDVn+NZz0KFw=
@@ -268,7 +221,6 @@ github.com/satori/go.uuid v1.2.0/go.mod h1:dA0hQrYB0VpLJoorglMZABFdXlWrHn1NEOzdh
 github.com/shurcooL/sanitized_anchor_name v1.0.0 h1:PdmoCO6wvbs+7yrJyMORt4/BmY5IYyJwS/kOiWx8mHo=
 github.com/shurcooL/sanitized_anchor_name v1.0.0/go.mod h1:1NzhyTcUVG4SuEtjjoZeVRXNmyL/1OwPU0+IJeTBvfc=
 github.com/sirupsen/logrus v1.2.0/go.mod h1:LxeOpSwHxABJmUn/MG1IvRgCAasNZTLOkJPxbbu5VWo=
-github.com/sirupsen/logrus v1.4.2 h1:SPIRibHv4MatM3XXNO2BJeFLZwZ2LvZgfQ5+UNI2im4=
 github.com/sirupsen/logrus v1.4.2/go.mod h1:tLMulIdttU9McNUspp0xgXVQah82FyeX6MwdIuYE2rE=
 github.com/skratchdot/open-golang v0.0.0-20160302144031-75fb7ed4208c/go.mod h1:sUM3LWHvSMaG192sy56D9F7CNvL7jUJVXoqM1QKLnog=
 github.com/smartystreets/assertions v0.0.0-20180927180507-b2de0cb4f26d/go.mod h1:OnSkiWE9lh6wB0YB77sQom3nweQdgAjqCqsofrRNTgc=
@@ -283,31 +235,6 @@ github.com/stretchr/testify v1.5.1/go.mod h1:5W2xD1RspED5o8YsWQXVCued0rvSQ+mT+I5
 github.com/timewasted/linode v0.0.0-20160829202747-37e84520dcf7/go.mod h1:imsgLplxEC/etjIhdr3dNzV3JeT27LbVu5pYWm0JCBY=
 github.com/transip/gotransip v0.0.0-20190812104329-6d8d9179b66f/go.mod h1:i0f4R4o2HM0m3DZYQWsj6/MEowD57VzoH0v3d7igeFY=
 github.com/uber-go/atomic v1.3.2/go.mod h1:/Ct5t2lcmbJ4OSe/waGBoaVvVqtO0bmtfVNex1PFV8g=
-github.com/unistack-org/micro-codec-bytes v0.0.0-20200827104921-3616a69473a6/go.mod h1:g5sOI8TWgGZiVHe8zoUPdtz7+0oLnqTnfBoai6Qb7jE=
-github.com/unistack-org/micro-codec-bytes v0.0.0-20200828083432-4e49e953d844 h1:5b1yuSllbsMm/9fUIlIXSr8DbsKT/sAKSCgOx6+SAfI=
-github.com/unistack-org/micro-codec-bytes v0.0.0-20200828083432-4e49e953d844/go.mod h1:g5sOI8TWgGZiVHe8zoUPdtz7+0oLnqTnfBoai6Qb7jE=
-github.com/unistack-org/micro-codec-json v0.0.0-20201102222734-a29c895ec05c h1:RtcNaK8rQSl7xAoy1W437dvZLCVjSC6e4JcolepSQs0=
-github.com/unistack-org/micro-codec-json v0.0.0-20201102222734-a29c895ec05c/go.mod h1:dG5aUyhBv+ebOl/UFW2Aj2GTfVxxXWi6AcynpePOAhQ=
-github.com/unistack-org/micro-codec-jsonrpc v0.0.0-20201102222451-ff6a69988bcd h1:qXSiEfVnCgrwTHYvAnEPSHEai3+5EUH9ZYovLpxGDwg=
-github.com/unistack-org/micro-codec-jsonrpc v0.0.0-20201102222451-ff6a69988bcd/go.mod h1:PFyvkGhavl+3tEPgOaLAhoJJX4/webVGW59BSOXDfNM=
-github.com/unistack-org/micro-codec-proto v0.0.0-20201102222202-769c2d6a4b92 h1:1rPDBu7Nwo3ZL6r6H5rj7qNchHSdBF4zcewAeTUEMC4=
-github.com/unistack-org/micro-codec-proto v0.0.0-20201102222202-769c2d6a4b92/go.mod h1:31JMo683bBQ+uN9YufpUU6ESHphyx3DFmTXEnjpJV9Y=
-github.com/unistack-org/micro-codec-protorpc v0.0.0-20201102222610-3a343898c077 h1:uK7owL8TPSwoQiDM1V/0swmgCEepSQKXoi8GEnGxtlU=
-github.com/unistack-org/micro-codec-protorpc v0.0.0-20201102222610-3a343898c077/go.mod h1:Ct4uAVZaDEyBZj9Q0poDkbzu6zKXUCcSqJkv/MWPpeI=
-github.com/unistack-org/micro-config-cmd v0.0.0-20200828075439-d859b9d7265b/go.mod h1:6pm1cadbwsFcEW1ZbV5Fp0i3goR3TNfROMNSPih3I8k=
-github.com/unistack-org/micro-config-cmd v0.0.0-20200909210346-ec89783dc46c h1:GbcjxyOyA9tnNoe4FcnzzLDa8JwEBnQKN/7Bhd8t47I=
-github.com/unistack-org/micro-config-cmd v0.0.0-20200909210346-ec89783dc46c/go.mod h1:6pm1cadbwsFcEW1ZbV5Fp0i3goR3TNfROMNSPih3I8k=
-github.com/unistack-org/micro-config-cmd v0.0.0-20200909210755-6e7e85eeab34 h1:VHc98t4SoiCF/jbkFu2e/j+IyJ/+MFQ1T+INNL7LubU=
-github.com/unistack-org/micro-config-cmd v0.0.0-20200909210755-6e7e85eeab34/go.mod h1:fT1gYn+TtfVZZ5tNx56bZIncJjmlji66g7GKdWua5hE=
-github.com/unistack-org/micro-config-cmd v0.0.0-20200920140133-0853deb2e5dc h1:hHAU3rgeiA0LaudfNdMLf9/jkOBeFxvJdnwXevviZF8=
-github.com/unistack-org/micro-config-cmd v0.0.0-20200920140133-0853deb2e5dc/go.mod h1:il8nz4ZEcX3Usyfrtwy+YtQcb7xSUSFJdSe8PBJ9gOA=
-github.com/unistack-org/micro-config-cmd v0.0.0-20201028144621-5a55f1aad70a h1:VjlqP1qZkjC0Chmx5MKFPIbtSCigeICFDf8vaLZGh9o=
-github.com/unistack-org/micro-config-cmd v0.0.0-20201028144621-5a55f1aad70a/go.mod h1:MzMg+qh1wORZwYtg5AVgFkNFrXVVbdPKW7s/Is+A994=
-github.com/unistack-org/micro/v3 v3.0.0-20200827083227-aa99378adc6e/go.mod h1:rPQbnry3nboAnMczj8B1Gzlcyv/HYoMZLgd3/3nttJ4=
-github.com/unistack-org/micro/v3 v3.0.0-gamma/go.mod h1:iEtpu3wTYCRs3pQ3VsFEO7JBO4lOMpkOwMyrpZyIDPo=
-github.com/unistack-org/micro/v3 v3.0.0-gamma.0.20200909210629-caec730248b1/go.mod h1:mmqHR9WelHUXqg2mELjsQ+FJHcWs6mNmXg+wEYO2T3c=
-github.com/unistack-org/micro/v3 v3.0.0-gamma.0.20200920135754-1cbd1d2bad83/go.mod h1:HUzMG4Mcy97958VxWTg8zuazZgwQ/aoLZ8wtBVONwRE=
-github.com/unistack-org/micro/v3 v3.0.0-gamma.0.20200922103357-4c4fa00a5d94/go.mod h1:aL+8VhSXpx0SuEeXPOWUo5BgS7kyvWYobeXFay90UUM=
 github.com/urfave/cli v1.22.1/go.mod h1:Gos4lmkARVdJ6EkW0WaNv/tZAAMe9V7XWyB60NtXRu0=
 github.com/vultr/govultr v0.1.4/go.mod h1:9H008Uxr/C4vFNGLqKx232C206GL0PBHzOP0809bGNA=
 github.com/xeipuuv/gojsonpointer v0.0.0-20180127040702-4e3ac2762d5f/go.mod h1:N2zxlSyiKSe5eX1tZViRH5QA0qijqEDrYZiPEAiq3wU=
@@ -329,8 +256,6 @@ golang.org/x/crypto v0.0.0-20190605123033-f99c8df09eb5/go.mod h1:yigFU9vqHzYiE8U
 golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
 golang.org/x/crypto v0.0.0-20200302210943-78000ba7a073/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
 golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
-golang.org/x/crypto v0.0.0-20200709230013-948cd5f35899 h1:DZhuSZLsGlFL4CmhA8BcRA0mnthyA/nZ00AqCUo7vHg=
-golang.org/x/crypto v0.0.0-20200709230013-948cd5f35899/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
 golang.org/x/crypto v0.0.0-20200820211705-5c72a883971a h1:vclmkQCjlDX5OydZ9wv8rBCcS0QyQY66Mpf/7BZbInM=
 golang.org/x/crypto v0.0.0-20200820211705-5c72a883971a/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
 golang.org/x/exp v0.0.0-20190121172915-509febef88a4/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA=
@@ -346,7 +271,6 @@ golang.org/x/lint v0.0.0-20190301231843-5614ed5bae6f/go.mod h1:UVdnD1Gm6xHRNCYTk
 golang.org/x/lint v0.0.0-20190313153728-d0100b6bd8b3/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc=
 golang.org/x/lint v0.0.0-20190409202823-959b441ac422/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc=
 golang.org/x/lint v0.0.0-20190909230951-414d861bb4ac/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc=
-golang.org/x/lint v0.0.0-20191125180803-fdd1cda4f05f h1:J5lckAjkw6qYlOZNj90mLYNTEKDvWeuc1yieZ8qUzUE=
 golang.org/x/lint v0.0.0-20191125180803-fdd1cda4f05f/go.mod h1:5qLYkcX4OjUUV8bRuDixDT3tpyyb+LUpUlRWLxfhWrs=
 golang.org/x/mobile v0.0.0-20190312151609-d3739f865fa6/go.mod h1:z+o9i4GpDbdi3rU15maQ/Ox0txvL9dWGYEHz965HBQE=
 golang.org/x/mobile v0.0.0-20190719004257-d2bd2a29d028/go.mod h1:E/iHnbuqvinMTCcRqshq8CkpyQDoeVncDDYHnLhea+o=
@@ -373,13 +297,10 @@ golang.org/x/net v0.0.0-20190724013045-ca1201d0de80/go.mod h1:z5CRVTTTmAJ677TzLL
 golang.org/x/net v0.0.0-20190923162816-aa69164e4478/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
 golang.org/x/net v0.0.0-20190930134127-c5a3c61f89f3/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
 golang.org/x/net v0.0.0-20191027093000-83d349e8ac1a/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
-golang.org/x/net v0.0.0-20200707034311-ab3426394381 h1:VXak5I6aEWmAXeQjA+QSZzlgNrpq9mjcfDemuexIKsU=
-golang.org/x/net v0.0.0-20200707034311-ab3426394381/go.mod h1:/O7V0waA8r7cgGh81Ro3o1hOxt32SMVPicZroKQ2sZA=
 golang.org/x/net v0.0.0-20200904194848-62affa334b73 h1:MXfv8rhZWmFeqX3GNZRsd6vOLoaCHjYEX3qkRo3YBUA=
 golang.org/x/net v0.0.0-20200904194848-62affa334b73/go.mod h1:/O7V0waA8r7cgGh81Ro3o1hOxt32SMVPicZroKQ2sZA=
 golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U=
 golang.org/x/oauth2 v0.0.0-20190226205417-e64efc72b421/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw=
-golang.org/x/oauth2 v0.0.0-20190604053449-0f29369cfe45 h1:SVwTIAaPC2U/AvvLNZ2a7OVsmBpC8L5BlwK1whH3hm0=
 golang.org/x/oauth2 v0.0.0-20190604053449-0f29369cfe45/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw=
 golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sync v0.0.0-20181108010431-42b317875d0f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
@@ -437,7 +358,6 @@ golang.org/x/tools v0.0.0-20190911174233-4f2ddba30aff/go.mod h1:b+2E5dAYhXwXZwtn
 golang.org/x/tools v0.0.0-20191012152004-8de300cfc20a/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
 golang.org/x/tools v0.0.0-20191125144606-a911d9008d1f/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
 golang.org/x/tools v0.0.0-20191216052735-49a3e744a425/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
-golang.org/x/tools v0.0.0-20191216173652-a0e659d51361 h1:RIIXAeV6GvDBuADKumTODatUqANFZ+5BPMnzsy4hulY=
 golang.org/x/tools v0.0.0-20191216173652-a0e659d51361/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
 golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
@@ -452,7 +372,6 @@ google.golang.org/api v0.14.0/go.mod h1:iLdEw5Ide6rF15KTC1Kkl0iskquN2gFfn9o9XIsb
 google.golang.org/appengine v1.1.0/go.mod h1:EbEs0AVv82hx2wNQdGPgUI5lhzA/G0D9YwlJXL52JkM=
 google.golang.org/appengine v1.4.0/go.mod h1:xpcJRLb0r/rnEns0DIKYYv+WjYCduHsrkT7/EB5XEv4=
 google.golang.org/appengine v1.5.0/go.mod h1:xpcJRLb0r/rnEns0DIKYYv+WjYCduHsrkT7/EB5XEv4=
-google.golang.org/appengine v1.6.1 h1:QzqyMA1tlu6CgqCDUtU9V+ZKhLFT2dkJuANu5QaxI3I=
 google.golang.org/appengine v1.6.1/go.mod h1:i06prIuMbXzDqacNJfV5OdTW448YApPu5ww/cMBSeb0=
 google.golang.org/genproto v0.0.0-20180817151627-c66870c02cf8/go.mod h1:JiN7NxoALGmiZfu7CAH4rXhgtRTLTxftemlI0sWmxmc=
 google.golang.org/genproto v0.0.0-20190307195333-5fe7a883aa19/go.mod h1:VzzqZJRnGkLBvHegQrXjBqPurQTc5/KpmUdxsrq26oE=
@@ -463,17 +382,13 @@ google.golang.org/genproto v0.0.0-20190801165951-fa694d86fc64/go.mod h1:DMBHOl98
 google.golang.org/genproto v0.0.0-20190819201941-24fa4b261c55/go.mod h1:DMBHOl98Agz4BDEuKkezgsaosCRResVns1a3J2ZsMNc=
 google.golang.org/genproto v0.0.0-20190911173649-1774047e7e51/go.mod h1:IbNlFCBrqXvoKpeg0TB2l7cyZUmoaFKYIwrEpbDKLA8=
 google.golang.org/genproto v0.0.0-20191216164720-4f79533eabd1/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc=
-google.golang.org/genproto v0.0.0-20200526211855-cb27e3aa2013 h1:+kGHl1aib/qcwaRi1CbqBZ1rk19r85MNUf8HaBghugY=
 google.golang.org/genproto v0.0.0-20200526211855-cb27e3aa2013/go.mod h1:NbSheEEYHJ7i3ixzK3sjbqSGDJWnxyFXZblF3eUsNvo=
-google.golang.org/genproto v0.0.0-20200904004341-0bd0a958aa1d h1:92D1fum1bJLKSdr11OJ+54YeCMCGYIygTA7R/YZxH5M=
-google.golang.org/genproto v0.0.0-20200904004341-0bd0a958aa1d/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no=
 google.golang.org/grpc v1.17.0/go.mod h1:6QZJwpn2B+Zp71q/5VxRsJ6NXXVCE5NRUHRo+f3cWCs=
 google.golang.org/grpc v1.19.0/go.mod h1:mqu4LbDTu4XGKhr4mRzUsmM4RtVoemTSY81AxZiDr8c=
 google.golang.org/grpc v1.19.1/go.mod h1:mqu4LbDTu4XGKhr4mRzUsmM4RtVoemTSY81AxZiDr8c=
 google.golang.org/grpc v1.20.1/go.mod h1:10oTOabMzJvdu6/UiuZezV6QK5dSlG84ov/aaiqXj38=
 google.golang.org/grpc v1.21.1/go.mod h1:oYelfM1adQP15Ek0mdvEgi9Df8B9CZIaU1084ijfRaM=
 google.golang.org/grpc v1.23.0/go.mod h1:Y5yQAOtifL1yxbo5wqy6BxZv8vAUGQwXBOALyacEbxg=
-google.golang.org/grpc v1.27.0 h1:rRYRFMVgRv6E0D70Skyfsr28tDXIuuPZyWGMPdMcnXg=
 google.golang.org/grpc v1.27.0/go.mod h1:qbnxyOmOxrQa7FizSgH+ReBfzJrCY1pSN7KXBS8abTk=
 google.golang.org/protobuf v0.0.0-20200109180630-ec00e32a8dfd/go.mod h1:DFci5gLYBciE7Vtevhsrf46CRTquxDuWsQurQQe4oz8=
 google.golang.org/protobuf v0.0.0-20200221191635-4d8936d0db64/go.mod h1:kwYJMbMJ01Woi6D6+Kah6886xMZcty6N08ah7+eCXa0=
@@ -483,18 +398,14 @@ google.golang.org/protobuf v1.21.0/go.mod h1:47Nbq4nVaFHyn7ilMalzfO3qCViNmqZ2kzi
 google.golang.org/protobuf v1.22.0/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU=
 google.golang.org/protobuf v1.23.0/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU=
 google.golang.org/protobuf v1.23.1-0.20200526195155-81db48ad09cc/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU=
-google.golang.org/protobuf v1.24.0/go.mod h1:r/3tXBNzIEhYS9I1OUVjXDlt8tc493IdKGjtUeSXeh4=
 google.golang.org/protobuf v1.25.0 h1:Ejskq+SyPohKW+1uil0JJMtmHCgJPJ/qWTxr8qp+R4c=
 google.golang.org/protobuf v1.25.0/go.mod h1:9JNX74DMeImyA3h4bdi1ymwjUzf21/xIlbajtzgsN7c=
 gopkg.in/alecthomas/kingpin.v2 v2.2.6/go.mod h1:FMv+mEhP44yOT+4EoQTLFTRgOQ1FBLkstjWtayDeSgw=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
-gopkg.in/check.v1 v1.0.0-20190902080502-41f04d3bba15 h1:YR8cESwS4TdDjEe65xsg0ogRM/Nc3DYOhEAlW+xobZo=
-gopkg.in/check.v1 v1.0.0-20190902080502-41f04d3bba15/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/check.v1 v1.0.0-20200227125254-8fa46927fb4f h1:BLraFXnmrev5lT+xlilqcH8XK9/i0At2xKjWk4p6zsU=
 gopkg.in/check.v1 v1.0.0-20200227125254-8fa46927fb4f/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/errgo.v2 v2.1.0/go.mod h1:hNsd1EY+bozCKY1Ytp96fpM3vjJbqLJn88ws8XvfDNI=
-gopkg.in/fsnotify.v1 v1.4.7 h1:xOHLXZwVvI9hhs+cLKq5+I5onOuwQLhQwiu63xxlHs4=
 gopkg.in/fsnotify.v1 v1.4.7/go.mod h1:Tz8NjZHkW78fSQdbUxIjBTcgA1z1m8ZHf0WmKUhAMys=
 gopkg.in/h2non/gock.v1 v1.0.15/go.mod h1:sX4zAkdYX1TRGJ2JY156cFspQn4yRWn6p9EMdODlynE=
 gopkg.in/ini.v1 v1.42.0/go.mod h1:pNLf8WUiyNEtQjuu5G5vTm06TEv9tsIgeAvK8hOrP4k=
@@ -505,7 +416,6 @@ gopkg.in/resty.v1 v1.12.0/go.mod h1:mDo4pnntr5jdWRML875a/NmxYqAlA73dVijT2AXvQQo=
 gopkg.in/square/go-jose.v2 v2.3.1/go.mod h1:M9dMgbHiYLoDGQrXy7OpJDJWiKiU//h+vD76mk0e1AI=
 gopkg.in/square/go-jose.v2 v2.4.1 h1:H0TmLt7/KmzlrDOpa1F+zr0Tk90PbJYBfsVUmRLrf9Y=
 gopkg.in/square/go-jose.v2 v2.4.1/go.mod h1:M9dMgbHiYLoDGQrXy7OpJDJWiKiU//h+vD76mk0e1AI=
-gopkg.in/tomb.v1 v1.0.0-20141024135613-dd632973f1e7 h1:uRGJdciOHaEIrze2W8Q3AKkepLTh2hOroT7a+7czfdQ=
 gopkg.in/tomb.v1 v1.0.0-20141024135613-dd632973f1e7/go.mod h1:dt/ZhP58zS4L8KSrWDmTeBkI65Dw0HsyUHuEVlX15mw=
 gopkg.in/yaml.v2 v2.0.0-20170812160011-eb3733d160e7/go.mod h1:JAlM8MvJe8wmxCU4Bli9HhUf9+ttbYbLASfIpnQbh74=
 gopkg.in/yaml.v2 v2.2.1/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
@@ -517,6 +427,5 @@ honnef.co/go/tools v0.0.0-20190102054323-c2f93a96b099/go.mod h1:rf3lG4BRIbNafJWh
 honnef.co/go/tools v0.0.0-20190106161140-3f1c8253044a/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=
 honnef.co/go/tools v0.0.0-20190418001031-e561f6794a2a/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=
 honnef.co/go/tools v0.0.0-20190523083050-ea95bdfd59fc/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=
-honnef.co/go/tools v0.0.1-2019.2.3 h1:3JgtbtFHMiCmsznwGVTUWbgGov+pVqnlf1dEJTNAXeM=
 honnef.co/go/tools v0.0.1-2019.2.3/go.mod h1:a3bituU0lyd329TUQxRnasdCoJDkEUEAqEt0JzvZhAg=
 rsc.io/binaryregexp v0.2.0/go.mod h1:qTv7/COck+e2FymRvadv62gMdZztPaShugOCi3I+8D8=

logger/context.go

@@ -6,11 +6,27 @@ type loggerKey struct{}
 
 // FromContext returns logger from passed context
 func FromContext(ctx context.Context) (Logger, bool) {
+	if ctx == nil {
+		return nil, false
+	}
 	l, ok := ctx.Value(loggerKey{}).(Logger)
 	return l, ok
 }
 
 // NewContext stores logger into passed context
 func NewContext(ctx context.Context, l Logger) context.Context {
+	if ctx == nil {
+		ctx = context.Background()
+	}
 	return context.WithValue(ctx, loggerKey{}, l)
 }
+
+// SetOption returns a function to setup a context with given value
+func SetOption(k, v interface{}) Option {
+	return func(o *Options) {
+		if o.Context == nil {
+			o.Context = context.Background()
+		}
+		o.Context = context.WithValue(o.Context, k, v)
+	}
+}

logger/level.go

@@ -4,6 +4,7 @@ import (
 	"fmt"
 )
 
+// Level means logger level
 type Level int8
 
 const (
@@ -11,17 +12,17 @@ const (
 	TraceLevel Level = iota - 2
 	// DebugLevel level. Usually only enabled when debugging. Very verbose logging.
 	DebugLevel
-	// InfoLevel is the default logging priority.
-	// General operational entries about what's going on inside the application.
+	// InfoLevel level. General operational entries about what's going on inside the application.
 	InfoLevel
 	// WarnLevel level. Non-critical entries that deserve eyes.
 	WarnLevel
-	// ErrorLevel level. Logs. Used for errors that should definitely be noted.
+	// ErrorLevel level. Used for errors that should definitely be noted.
 	ErrorLevel
 	// FatalLevel level. Logs and then calls `os.Exit(1)`. highest level of severity.
 	FatalLevel
 )
 
+// String returns logger level string representation
 func (l Level) String() string {
 	switch l {
 	case TraceLevel:

logger/logger.go

@@ -1,9 +1,13 @@
 // Package logger provides a log interface
 package logger
 
+import "context"
+
 var (
 	// DefaultLogger variable
 	DefaultLogger Logger = NewLogger()
+	// DefaultLogger level
+	DefaultLevel Level = InfoLevel
 )
 
 // Logger is a generic logging interface
@@ -17,81 +21,98 @@ type Logger interface {
 	// Fields set fields to always be logged
 	Fields(fields map[string]interface{}) Logger
 	// Info level message
-	Info(args ...interface{})
+	Info(ctx context.Context, args ...interface{})
 	// Trace level message
-	Trace(args ...interface{})
+	Trace(ctx context.Context, args ...interface{})
 	// Debug level message
-	Debug(args ...interface{})
+	Debug(ctx context.Context, args ...interface{})
 	// Warn level message
-	Warn(args ...interface{})
+	Warn(ctx context.Context, args ...interface{})
 	// Error level message
-	Error(args ...interface{})
+	Error(ctx context.Context, args ...interface{})
 	// Fatal level message
-	Fatal(args ...interface{})
+	Fatal(ctx context.Context, args ...interface{})
 	// Infof level message
-	Infof(msg string, args ...interface{})
+	Infof(ctx context.Context, msg string, args ...interface{})
 	// Tracef level message
-	Tracef(msg string, args ...interface{})
+	Tracef(ctx context.Context, msg string, args ...interface{})
 	// Debug level message
-	Debugf(msg string, args ...interface{})
+	Debugf(ctx context.Context, msg string, args ...interface{})
 	// Warn level message
-	Warnf(msg string, args ...interface{})
+	Warnf(ctx context.Context, msg string, args ...interface{})
 	// Error level message
-	Errorf(msg string, args ...interface{})
+	Errorf(ctx context.Context, msg string, args ...interface{})
 	// Fatal level message
-	Fatalf(msg string, args ...interface{})
+	Fatalf(ctx context.Context, msg string, args ...interface{})
+	// Log logs message with needed level
+	Log(ctx context.Context, level Level, args ...interface{})
+	// Logf logs message with needed level
+	Logf(ctx context.Context, level Level, msg string, args ...interface{})
 	// String returns the name of logger
 	String() string
 }
 
-func Info(args ...interface{}) {
-	DefaultLogger.Info(args...)
+// Info writes msg to default logger on info level
+func Info(ctx context.Context, args ...interface{}) {
+	DefaultLogger.Info(ctx, args...)
 }
 
-func Error(args ...interface{}) {
-	DefaultLogger.Error(args...)
+// Error writes msg to default logger on error level
+func Error(ctx context.Context, args ...interface{}) {
+	DefaultLogger.Error(ctx, args...)
 }
 
-func Debug(args ...interface{}) {
-	DefaultLogger.Debug(args...)
+// Debug writes msg to default logger on debug level
+func Debug(ctx context.Context, args ...interface{}) {
+	DefaultLogger.Debug(ctx, args...)
 }
 
-func Warn(args ...interface{}) {
-	DefaultLogger.Warn(args...)
+// Warn writes msg to default logger on warn level
+func Warn(ctx context.Context, args ...interface{}) {
+	DefaultLogger.Warn(ctx, args...)
 }
 
-func Trace(args ...interface{}) {
-	DefaultLogger.Trace(args...)
+// Trace writes msg to default logger on trace level
+func Trace(ctx context.Context, args ...interface{}) {
+	DefaultLogger.Trace(ctx, args...)
 }
 
-func Fatal(args ...interface{}) {
-	DefaultLogger.Fatal(args...)
+// Fatal writes msg to default logger on fatal level
+func Fatal(ctx context.Context, args ...interface{}) {
+	DefaultLogger.Fatal(ctx, args...)
 }
 
-func Infof(msg string, args ...interface{}) {
-	DefaultLogger.Infof(msg, args...)
+// Infof writes formatted msg to default logger on info level
+func Infof(ctx context.Context, msg string, args ...interface{}) {
+	DefaultLogger.Infof(ctx, msg, args...)
 }
 
-func Errorf(msg string, args ...interface{}) {
-	DefaultLogger.Errorf(msg, args...)
+// Errorf writes formatted msg to default logger on error level
+func Errorf(ctx context.Context, msg string, args ...interface{}) {
+	DefaultLogger.Errorf(ctx, msg, args...)
 }
 
-func Debugf(msg string, args ...interface{}) {
-	DefaultLogger.Debugf(msg, args...)
+// Debugf writes formatted msg to default logger on debug level
+func Debugf(ctx context.Context, msg string, args ...interface{}) {
+	DefaultLogger.Debugf(ctx, msg, args...)
 }
 
-func Warnf(msg string, args ...interface{}) {
-	DefaultLogger.Warnf(msg, args...)
+// Warnf writes formatted msg to default logger on warn level
+func Warnf(ctx context.Context, msg string, args ...interface{}) {
+	DefaultLogger.Warnf(ctx, msg, args...)
 }
 
-func Tracef(msg string, args ...interface{}) {
-	DefaultLogger.Tracef(msg, args...)
+// Tracef writes formatted msg to default logger on trace level
+func Tracef(ctx context.Context, msg string, args ...interface{}) {
+	DefaultLogger.Tracef(ctx, msg, args...)
 }
 
-func Fatalf(msg string, args ...interface{}) {
-	DefaultLogger.Fatalf(msg, args...)
+// Fatalf writes formatted msg to default logger on fatal level
+func Fatalf(ctx context.Context, msg string, args ...interface{}) {
+	DefaultLogger.Fatalf(ctx, msg, args...)
 }
 
+// V returns true if passed level enabled in default logger
 func V(level Level) bool {
 	return DefaultLogger.V(level)
 }

logger/logger_test.go

@@ -1,16 +1,18 @@
 package logger
 
 import (
+	"context"
 	"testing"
 )
 
 func TestLogger(t *testing.T) {
+	ctx := context.TODO()
 	l := NewLogger(WithLevel(TraceLevel))
 	if err := l.Init(); err != nil {
 		t.Fatal(err)
 	}
-	l.Trace("trace_msg1")
-	l.Warn("warn_msg1")
-	l.Fields(map[string]interface{}{"error": "test"}).Info("error message")
-	l.Warn("first", " ", "second")
+	l.Trace(ctx, "trace_msg1")
+	l.Warn(ctx, "warn_msg1")
+	l.Fields(map[string]interface{}{"error": "test"}).Info(ctx, "error message")
+	l.Warn(ctx, "first", " ", "second")
 }

logger/micro.go

@@ -1,6 +1,7 @@
 package logger
 
 import (
+	"context"
 	"encoding/json"
 	"fmt"
 	"os"
@@ -28,12 +29,11 @@ type defaultLogger struct {
 // Init(opts...) should only overwrite provided options
 func (l *defaultLogger) Init(opts ...Option) error {
 	l.Lock()
-	defer l.Unlock()
-
 	for _, o := range opts {
 		o(&l.opts)
 	}
 	l.enc = json.NewEncoder(l.opts.Out)
+	l.Unlock()
 	return nil
 }
 
@@ -42,7 +42,10 @@ func (l *defaultLogger) String() string {
 }
 
 func (l *defaultLogger) V(level Level) bool {
-	return l.opts.Level.Enabled(level)
+	l.RLock()
+	ok := l.opts.Level.Enabled(level)
+	l.RUnlock()
+	return ok
 }
 
 func (l *defaultLogger) Fields(fields map[string]interface{}) Logger {
@@ -84,57 +87,57 @@ func logCallerfilePath(loggingFilePath string) string {
 	return loggingFilePath[idx+1:]
 }
 
-func (l *defaultLogger) Info(args ...interface{}) {
-	l.log(InfoLevel, args...)
+func (l *defaultLogger) Info(ctx context.Context, args ...interface{}) {
+	l.Log(ctx, InfoLevel, args...)
 }
 
-func (l *defaultLogger) Error(args ...interface{}) {
-	l.log(ErrorLevel, args...)
+func (l *defaultLogger) Error(ctx context.Context, args ...interface{}) {
+	l.Log(ctx, ErrorLevel, args...)
 }
 
-func (l *defaultLogger) Debug(args ...interface{}) {
-	l.log(DebugLevel, args...)
+func (l *defaultLogger) Debug(ctx context.Context, args ...interface{}) {
+	l.Log(ctx, DebugLevel, args...)
 }
 
-func (l *defaultLogger) Warn(args ...interface{}) {
-	l.log(WarnLevel, args...)
+func (l *defaultLogger) Warn(ctx context.Context, args ...interface{}) {
+	l.Log(ctx, WarnLevel, args...)
 }
 
-func (l *defaultLogger) Trace(args ...interface{}) {
-	l.log(TraceLevel, args...)
+func (l *defaultLogger) Trace(ctx context.Context, args ...interface{}) {
+	l.Log(ctx, TraceLevel, args...)
 }
 
-func (l *defaultLogger) Fatal(args ...interface{}) {
-	l.log(FatalLevel, args...)
+func (l *defaultLogger) Fatal(ctx context.Context, args ...interface{}) {
+	l.Log(ctx, FatalLevel, args...)
 	os.Exit(1)
 }
 
-func (l *defaultLogger) Infof(msg string, args ...interface{}) {
-	l.logf(InfoLevel, msg, args...)
+func (l *defaultLogger) Infof(ctx context.Context, msg string, args ...interface{}) {
+	l.Logf(ctx, InfoLevel, msg, args...)
 }
 
-func (l *defaultLogger) Errorf(msg string, args ...interface{}) {
-	l.logf(ErrorLevel, msg, args...)
+func (l *defaultLogger) Errorf(ctx context.Context, msg string, args ...interface{}) {
+	l.Logf(ctx, ErrorLevel, msg, args...)
 }
 
-func (l *defaultLogger) Debugf(msg string, args ...interface{}) {
-	l.logf(DebugLevel, msg, args...)
+func (l *defaultLogger) Debugf(ctx context.Context, msg string, args ...interface{}) {
+	l.Logf(ctx, DebugLevel, msg, args...)
 }
 
-func (l *defaultLogger) Warnf(msg string, args ...interface{}) {
-	l.logf(WarnLevel, msg, args...)
+func (l *defaultLogger) Warnf(ctx context.Context, msg string, args ...interface{}) {
+	l.Logf(ctx, WarnLevel, msg, args...)
 }
 
-func (l *defaultLogger) Tracef(msg string, args ...interface{}) {
-	l.logf(TraceLevel, msg, args...)
+func (l *defaultLogger) Tracef(ctx context.Context, msg string, args ...interface{}) {
+	l.Logf(ctx, TraceLevel, msg, args...)
 }
 
-func (l *defaultLogger) Fatalf(msg string, args ...interface{}) {
-	l.logf(FatalLevel, msg, args...)
+func (l *defaultLogger) Fatalf(ctx context.Context, msg string, args ...interface{}) {
+	l.Logf(ctx, FatalLevel, msg, args...)
 	os.Exit(1)
 }
 
-func (l *defaultLogger) log(level Level, args ...interface{}) {
+func (l *defaultLogger) Log(ctx context.Context, level Level, args ...interface{}) {
 	if !l.V(level) {
 		return
 	}
@@ -157,7 +160,7 @@ func (l *defaultLogger) log(level Level, args ...interface{}) {
 	l.RUnlock()
 }
 
-func (l *defaultLogger) logf(level Level, msg string, args ...interface{}) {
+func (l *defaultLogger) Logf(ctx context.Context, level Level, msg string, args ...interface{}) {
 	if !l.V(level) {
 		return
 	}

logger/options.go

@@ -6,8 +6,10 @@ import (
 	"os"
 )
 
+// Option func
 type Option func(*Options)
 
+// Options holds logger options
 type Options struct {
 	// The logging level the logger should log at. default is `InfoLevel`
 	Level Level
@@ -21,12 +23,13 @@ type Options struct {
 	Context context.Context
 }
 
+// NewOptions creates new options struct
 func NewOptions(opts ...Option) Options {
 	options := Options{
-		Level:           InfoLevel,
+		Level:           DefaultLevel,
 		Fields:          make(map[string]interface{}),
 		Out:             os.Stderr,
-		CallerSkipCount: 2,
+		CallerSkipCount: 0,
 		Context:         context.Background(),
 	}
 	for _, o := range opts {
@@ -37,37 +40,35 @@ func NewOptions(opts ...Option) Options {
 
 // WithFields set default fields for the logger
 func WithFields(fields map[string]interface{}) Option {
-	return func(args *Options) {
-		args.Fields = fields
+	return func(o *Options) {
+		o.Fields = fields
 	}
 }
 
 // WithLevel set default level for the logger
 func WithLevel(level Level) Option {
-	return func(args *Options) {
-		args.Level = level
+	return func(o *Options) {
+		o.Level = level
 	}
 }
 
 // WithOutput set default output writer for the logger
 func WithOutput(out io.Writer) Option {
-	return func(args *Options) {
-		args.Out = out
+	return func(o *Options) {
+		o.Out = out
 	}
 }
 
 // WithCallerSkipCount set frame count to skip
 func WithCallerSkipCount(c int) Option {
-	return func(args *Options) {
-		args.CallerSkipCount = c
+	return func(o *Options) {
+		o.CallerSkipCount = c
 	}
 }
 
-func SetOption(k, v interface{}) Option {
+// WithContext set context
+func WithContext(ctx context.Context) Option {
 	return func(o *Options) {
-		if o.Context == nil {
-			o.Context = context.Background()
-		}
-		o.Context = context.WithValue(o.Context, k, v)
+		o.Context = ctx
 	}
 }

metadata/metadata.go

@@ -54,6 +54,7 @@ func Copy(md Metadata) Metadata {
 	return nmd
 }
 
+// Del deletes key from metadata
 func Del(ctx context.Context, key string) context.Context {
 	md, ok := FromContext(ctx)
 	if !ok {

metrics/noop.go

@@ -0,0 +1,47 @@
+package metrics
+
+import (
+	"time"
+
+	"github.com/unistack-org/micro/v3/metadata"
+)
+
+// NoopReporter is an noop implementation of Reporter:
+type noopReporter struct {
+	opts Options
+}
+
+// NewReporter returns a configured noop reporter:
+func NewReporter(opts ...Option) Reporter {
+	return &noopReporter{
+		opts: NewOptions(opts...),
+	}
+}
+
+// Init initialize options
+func (r *noopReporter) Init(opts ...Option) error {
+	for _, o := range opts {
+		o(&r.opts)
+	}
+	return nil
+}
+
+// Count implements the Reporter interface Count method:
+func (r *noopReporter) Count(metricName string, value int64, md metadata.Metadata) error {
+	return nil
+}
+
+// Gauge implements the Reporter interface Gauge method:
+func (r *noopReporter) Gauge(metricName string, value float64, md metadata.Metadata) error {
+	return nil
+}
+
+// Timing implements the Reporter interface Timing method:
+func (r *noopReporter) Timing(metricName string, value time.Duration, md metadata.Metadata) error {
+	return nil
+}
+
+// Options implements the Reporter interface Optios method:
+func (r *noopReporter) Options() Options {
+	return r.opts
+}

metrics/noop/reporter.go

@@ -1,37 +0,0 @@
-package noop
-
-import (
-	"time"
-
-	log "github.com/unistack-org/micro/v3/logger"
-	"github.com/unistack-org/micro/v3/metrics"
-)
-
-// Reporter is an implementation of metrics.Reporter:
-type Reporter struct {
-	options metrics.Options
-}
-
-// New returns a configured noop reporter:
-func New(opts ...metrics.Option) *Reporter {
-	log.Info("Metrics/NoOp - not doing anything")
-
-	return &Reporter{
-		options: metrics.NewOptions(opts...),
-	}
-}
-
-// Count implements the metrics.Reporter interface Count method:
-func (r *Reporter) Count(metricName string, value int64, tags metrics.Tags) error {
-	return nil
-}
-
-// Gauge implements the metrics.Reporter interface Gauge method:
-func (r *Reporter) Gauge(metricName string, value float64, tags metrics.Tags) error {
-	return nil
-}
-
-// Timing implements the metrics.Reporter interface Timing method:
-func (r *Reporter) Timing(metricName string, value time.Duration, tags metrics.Tags) error {
-	return nil
-}

metrics/noop/reporter_test.go

@@ -1,20 +0,0 @@
-package noop
-
-import (
-	"testing"
-
-	"github.com/unistack-org/micro/v3/metrics"
-
-	"github.com/stretchr/testify/assert"
-)
-
-func TestNoopReporter(t *testing.T) {
-
-	// Make a Reporter:
-	reporter := New(metrics.Path("/noop"))
-	assert.NotNil(t, reporter)
-	assert.Equal(t, "/noop", reporter.options.Path)
-
-	// Check that our implementation is valid:
-	assert.Implements(t, new(metrics.Reporter), reporter)
-}

metrics/options.go

@@ -1,6 +1,11 @@
 package metrics
 
-import "github.com/unistack-org/micro/v3/logger"
+import (
+	"context"
+
+	"github.com/unistack-org/micro/v3/logger"
+	"github.com/unistack-org/micro/v3/metadata"
+)
 
 var (
 	// The Prometheus metrics will be made available on this port:
@@ -18,18 +23,20 @@ type Option func(*Options)
 type Options struct {
 	Address          string
 	Path             string
-	DefaultTags      Tags
+	DefaultTags      metadata.Metadata
 	TimingObjectives map[float64]float64
 	Logger           logger.Logger
+	Context          context.Context
 }
 
 // NewOptions prepares a set of options:
 func NewOptions(opt ...Option) Options {
 	opts := Options{
 		Address:          defaultPrometheusListenAddress,
-		DefaultTags:      make(Tags),
+		DefaultTags:      metadata.New(2),
 		Path:             defaultPath,
 		TimingObjectives: defaultTimingObjectives,
+		Context:          context.Background(),
 	}
 
 	for _, o := range opt {
@@ -39,6 +46,13 @@ func NewOptions(opt ...Option) Options {
 	return opts
 }
 
+// Cntext sets the metrics context
+func Context(ctx context.Context) Option {
+	return func(o *Options) {
+		o.Context = ctx
+	}
+}
+
 // Path used to serve metrics over HTTP:
 func Path(value string) Option {
 	return func(o *Options) {
@@ -54,9 +68,9 @@ func Address(value string) Option {
 }
 
 // DefaultTags will be added to every metric:
-func DefaultTags(value Tags) Option {
+func DefaultTags(md metadata.Metadata) Option {
 	return func(o *Options) {
-		o.DefaultTags = value
+		o.DefaultTags = metadata.Copy(md)
 	}
 }
 

metrics/reporter.go

@@ -1,18 +1,21 @@
 // Package metrics is for instrumentation and debugging
 package metrics
 
-import "time"
+import (
+	"time"
 
-// Tags is a map of fields to add to a metric:
-type Tags map[string]string
+	"github.com/unistack-org/micro/v3/metadata"
+)
 
 var (
-	DefaultReporter Reporter
+	DefaultReporter Reporter = NewReporter()
 )
 
 // Reporter is an interface for collecting and instrumenting metrics
 type Reporter interface {
-	Count(id string, value int64, tags Tags) error
-	Gauge(id string, value float64, tags Tags) error
-	Timing(id string, value time.Duration, tags Tags) error
+	Init(...Option) error
+	Count(id string, value int64, md metadata.Metadata) error
+	Gauge(id string, value float64, md metadata.Metadata) error
+	Timing(id string, value time.Duration, md metadata.Metadata) error
+	Options() Options
 }

metrics/reporter_test.go

@@ -0,0 +1,17 @@
+package metrics
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestNoopReporter(t *testing.T) {
+	// Make a Reporter:
+	reporter := NewReporter(Path("/noop"))
+	assert.NotNil(t, reporter)
+	assert.Equal(t, "/noop", reporter.Options().Path)
+
+	// Check that our implementation is valid:
+	assert.Implements(t, new(Reporter), reporter)
+}

metrics/wrapper/metrics_wrapper.go

@@ -1,10 +1,10 @@
 package wrapper
 
 import (
+	"context"
 	"time"
 
-	"context"
-
+	"github.com/unistack-org/micro/v3/metadata"
 	"github.com/unistack-org/micro/v3/metrics"
 	"github.com/unistack-org/micro/v3/server"
 )
@@ -26,9 +26,8 @@ func (w *Wrapper) HandlerFunc(handlerFunction server.HandlerFunc) server.Handler
 	return func(ctx context.Context, req server.Request, rsp interface{}) error {
 
 		// Build some tags to describe the call:
-		tags := metrics.Tags{
-			"method": req.Method(),
-		}
+		tags := metadata.New(2)
+		tags.Set("method", req.Method())
 
 		// Start the clock:
 		callTime := time.Now()

micro.go

@@ -12,7 +12,7 @@ import (
 type serviceKey struct{}
 
 // Service is an interface that wraps the lower level libraries
-// within go-micro. Its a convenience method for building
+// within micro. Its a convenience method for building
 // and initialising services.
 type Service interface {
 	// The service name
@@ -83,12 +83,18 @@ func NewService(opts ...Option) Service {
 
 // FromContext retrieves a Service from the Context.
 func FromContext(ctx context.Context) (Service, bool) {
+	if ctx == nil {
+		return nil, false
+	}
 	s, ok := ctx.Value(serviceKey{}).(Service)
 	return s, ok
 }
 
 // NewContext returns a new Context with the Service embedded within it.
 func NewContext(ctx context.Context, s Service) context.Context {
+	if ctx == nil {
+		ctx = context.Background()
+	}
 	return context.WithValue(ctx, serviceKey{}, s)
 }
 

model/options.go

@@ -12,7 +12,7 @@ type Options struct {
 	// Database to write to
 	Database string
 	// for serialising
-	Codec codec.Marshaler
+	Codec codec.Codec
 	// for locking
 	Sync sync.Sync
 	// for storage

network/transport/context.go

@@ -0,0 +1,34 @@
+package transport
+
+import (
+	"context"
+)
+
+type transportKey struct{}
+
+// FromContext get transport from context
+func FromContext(ctx context.Context) (Transport, bool) {
+	if ctx == nil {
+		return nil, false
+	}
+	c, ok := ctx.Value(transportKey{}).(Transport)
+	return c, ok
+}
+
+// NewContext put transport in context
+func NewContext(ctx context.Context, c Transport) context.Context {
+	if ctx == nil {
+		ctx = context.Background()
+	}
+	return context.WithValue(ctx, transportKey{}, c)
+}
+
+// SetOption returns a function to setup a context with given value
+func SetOption(k, v interface{}) Option {
+	return func(o *Options) {
+		if o.Context == nil {
+			o.Context = context.Background()
+		}
+		o.Context = context.WithValue(o.Context, k, v)
+	}
+}

network/transport/noop.go

@@ -6,6 +6,7 @@ type noopTransport struct {
 	opts Options
 }
 
+// NewTransport creates new noop transport
 func NewTransport(opts ...Option) Transport {
 	return &noopTransport{opts: NewOptions(opts...)}
 }

network/transport/options.go

@@ -14,7 +14,7 @@ type Options struct {
 	Addrs []string
 	// Codec is the codec interface to use where headers are not supported
 	// by the transport and the entire payload must be encoded
-	Codec codec.Marshaler
+	Codec codec.Codec
 	// Secure tells the transport to secure the connection.
 	// In the case TLSConfig is not specified best effort self-signed
 	// certs should be used
@@ -24,7 +24,7 @@ type Options struct {
 	TLSConfig *tls.Config
 	// Timeout sets the timeout for Send/Recv
 	Timeout time.Duration
-	// Logger
+	// Logger sets the logger
 	Logger logger.Logger
 	// Other options for implementations of the interface
 	// can be stored in a context
@@ -121,7 +121,7 @@ func Context(ctx context.Context) Option {
 
 // Codec sets the codec used for encoding where the transport
 // does not support message headers
-func Codec(c codec.Marshaler) Option {
+func Codec(c codec.Codec) Option {
 	return func(o *Options) {
 		o.Codec = c
 	}

network/transport/transport.go

@@ -4,6 +4,8 @@ package transport
 import (
 	"context"
 	"time"
+
+	"github.com/unistack-org/micro/v3/metadata"
 )
 
 var (
@@ -26,7 +28,7 @@ type Transport interface {
 
 // Message is used to transfer data
 type Message struct {
-	Header map[string]string
+	Header metadata.Metadata
 	Body   []byte
 }
 

network/tunnel/broker/broker.go

@@ -113,11 +113,11 @@ func (t *tunSubscriber) run() {
 		m := new(transport.Message)
 		if err := c.Recv(m); err != nil {
 			if logger.V(logger.ErrorLevel) {
-				logger.Error(err.Error())
+				logger.Error(t.opts.Context, err.Error())
 			}
 			if err = c.Close(); err != nil {
 				if logger.V(logger.ErrorLevel) {
-					logger.Error(err.Error())
+					logger.Error(t.opts.Context, err.Error())
 				}
 			}
 			continue

network/tunnel/tunnel.go

@@ -46,7 +46,7 @@ var (
 // Mode of the session
 type Mode uint8
 
-// Tunnel creates a gre tunnel on top of the go-micro/transport.
+// Tunnel creates a gre tunnel on top of the micro/transport.
 // It establishes multiple streams using the Micro-Tunnel-Channel header
 // and Micro-Tunnel-Session header. The tunnel id is a hash of
 // the address being requested.

options.go

@@ -4,15 +4,13 @@ import (
 	"context"
 	"time"
 
-	"github.com/micro/cli/v2"
-	cmd "github.com/unistack-org/micro-config-cmd"
 	"github.com/unistack-org/micro/v3/auth"
 	"github.com/unistack-org/micro/v3/broker"
 	"github.com/unistack-org/micro/v3/client"
 	"github.com/unistack-org/micro/v3/config"
 	"github.com/unistack-org/micro/v3/debug/profile"
 	"github.com/unistack-org/micro/v3/logger"
-	"github.com/unistack-org/micro/v3/network/transport"
+	"github.com/unistack-org/micro/v3/metadata"
 	"github.com/unistack-org/micro/v3/registry"
 	"github.com/unistack-org/micro/v3/router"
 	"github.com/unistack-org/micro/v3/runtime"
@@ -24,25 +22,23 @@ import (
 
 // Options for micro service
 type Options struct {
-	Auth      auth.Auth
-	Broker    broker.Broker
-	Logger    logger.Logger
-	Cmd       cmd.Cmd
-	Config    config.Config
-	Client    client.Client
-	Server    server.Server
-	Store     store.Store
-	Registry  registry.Registry
-	Router    router.Router
-	Runtime   runtime.Runtime
-	Transport transport.Transport
-	Profile   profile.Profile
+	Auth     auth.Auth
+	Broker   broker.Broker
+	Logger   logger.Logger
+	Configs  []config.Config
+	Client   client.Client
+	Server   server.Server
+	Store    store.Store
+	Registry registry.Registry
+	Router   router.Router
+	Runtime  runtime.Runtime
+	Profile  profile.Profile
 
 	// Before and After funcs
-	BeforeStart []func() error
-	BeforeStop  []func() error
-	AfterStart  []func() error
-	AfterStop   []func() error
+	BeforeStart []func(context.Context) error
+	BeforeStop  []func(context.Context) error
+	AfterStart  []func(context.Context) error
+	AfterStop   []func(context.Context) error
 
 	// Other options for implementations of the interface
 	// can be stored in a context
@@ -52,17 +48,16 @@ type Options struct {
 // NewOptions returns new Options filled with defaults and overrided by provided opts
 func NewOptions(opts ...Option) Options {
 	options := Options{
-		Context:   context.Background(),
-		Server:    server.DefaultServer,
-		Client:    client.DefaultClient,
-		Broker:    broker.DefaultBroker,
-		Registry:  registry.DefaultRegistry,
-		Router:    router.DefaultRouter,
-		Auth:      auth.DefaultAuth,
-		Logger:    logger.DefaultLogger,
-		Config:    config.DefaultConfig,
-		Store:     store.DefaultStore,
-		Transport: transport.DefaultTransport,
+		Context:  context.Background(),
+		Server:   server.DefaultServer,
+		Client:   client.DefaultClient,
+		Broker:   broker.DefaultBroker,
+		Registry: registry.DefaultRegistry,
+		Router:   router.DefaultRouter,
+		Auth:     auth.DefaultAuth,
+		Logger:   logger.DefaultLogger,
+		Configs:  []config.Config{config.DefaultConfig},
+		Store:    store.DefaultStore,
 		//Runtime   runtime.Runtime
 		//Profile   profile.Profile
 	}
@@ -91,13 +86,6 @@ func Broker(b broker.Broker) Option {
 	}
 }
 
-// Cmd to be used for service
-func Cmd(c cmd.Cmd) Option {
-	return func(o *Options) {
-		o.Cmd = c
-	}
-}
-
 // Client to be used for service
 func Client(c client.Client) Option {
 	return func(o *Options) {
@@ -181,10 +169,10 @@ func Auth(a auth.Auth) Option {
 	}
 }
 
-// Config sets the config for the service
-func Config(c config.Config) Option {
+// Configs sets the configs for the service
+func Configs(c ...config.Config) Option {
 	return func(o *Options) {
-		o.Config = c
+		o.Configs = c
 	}
 }
 
@@ -197,21 +185,6 @@ func Selector(s selector.Selector) Option {
 	}
 }
 
-// Transport sets the transport for the service
-// and the underlying components
-func Transport(t transport.Transport) Option {
-	return func(o *Options) {
-		o.Transport = t
-		// Update Client and Server
-		if o.Client != nil {
-			o.Client.Init(client.Transport(t))
-		}
-		if o.Server != nil {
-			o.Server.Init(server.Transport(t))
-		}
-	}
-}
-
 // Runtime sets the runtime
 func Runtime(r runtime.Runtime) Option {
 	return func(o *Options) {
@@ -230,8 +203,6 @@ func Router(r router.Router) Option {
 	}
 }
 
-// Convenience options
-
 // Address sets the address of the server
 func Address(addr string) Option {
 	return func(o *Options) {
@@ -260,7 +231,7 @@ func Version(v string) Option {
 }
 
 // Metadata associated with the service
-func Metadata(md map[string]string) Option {
+func Metadata(md metadata.Metadata) Option {
 	return func(o *Options) {
 		if o.Server != nil {
 			o.Server.Init(server.Metadata(md))
@@ -268,24 +239,6 @@ func Metadata(md map[string]string) Option {
 	}
 }
 
-// Flags that can be passed to service
-func Flags(flags ...cli.Flag) Option {
-	return func(o *Options) {
-		if o.Cmd != nil {
-			o.Cmd.App().Flags = append(o.Cmd.App().Flags, flags...)
-		}
-	}
-}
-
-// Action can be used to parse user provided cli options
-func Action(a func(*cli.Context) error) Option {
-	return func(o *Options) {
-		if o.Cmd != nil {
-			o.Cmd.App().Action = a
-		}
-	}
-}
-
 // RegisterTTL specifies the TTL to use when registering the service
 func RegisterTTL(t time.Duration) Option {
 	return func(o *Options) {
@@ -351,31 +304,29 @@ func WrapSubscriber(w ...server.SubscriberWrapper) Option {
 	}
 }
 
-// Before and Afters
-
 // BeforeStart run funcs before service starts
-func BeforeStart(fn func() error) Option {
+func BeforeStart(fn func(context.Context) error) Option {
 	return func(o *Options) {
 		o.BeforeStart = append(o.BeforeStart, fn)
 	}
 }
 
 // BeforeStop run funcs before service stops
-func BeforeStop(fn func() error) Option {
+func BeforeStop(fn func(context.Context) error) Option {
 	return func(o *Options) {
 		o.BeforeStop = append(o.BeforeStop, fn)
 	}
 }
 
 // AfterStart run funcs after service starts
-func AfterStart(fn func() error) Option {
+func AfterStart(fn func(context.Context) error) Option {
 	return func(o *Options) {
 		o.AfterStart = append(o.AfterStart, fn)
 	}
 }
 
 // AfterStop run funcs after service stops
-func AfterStop(fn func() error) Option {
+func AfterStop(fn func(context.Context) error) Option {
 	return func(o *Options) {
 		o.AfterStop = append(o.AfterStop, fn)
 	}

proxy/options.go

@@ -1,4 +1,4 @@
-// Package proxy is a transparent proxy built on the go-micro/server
+// Package proxy is a transparent proxy built on the micro/server
 package proxy
 
 import (

proxy/proxy.go

@@ -1,4 +1,4 @@
-// Package proxy is a transparent proxy built on the go-micro/server
+// Package proxy is a transparent proxy built on the micro/server
 package proxy
 
 import (
@@ -7,7 +7,7 @@ import (
 	"github.com/unistack-org/micro/v3/server"
 )
 
-// Proxy can be used as a proxy server for go-micro services
+// Proxy can be used as a proxy server for micro services
 type Proxy interface {
 	// ProcessMessage handles inbound messages
 	ProcessMessage(context.Context, server.Message) error

registry/context.go

@@ -0,0 +1,34 @@
+package registry
+
+import (
+	"context"
+)
+
+type registryKey struct{}
+
+// FromContext get registry from context
+func FromContext(ctx context.Context) (Registry, bool) {
+	if ctx == nil {
+		return nil, false
+	}
+	c, ok := ctx.Value(registryKey{}).(Registry)
+	return c, ok
+}
+
+// NewContext put registry in context
+func NewContext(ctx context.Context, c Registry) context.Context {
+	if ctx == nil {
+		ctx = context.Background()
+	}
+	return context.WithValue(ctx, registryKey{}, c)
+}
+
+// SetOption returns a function to setup a context with given value
+func SetOption(k, v interface{}) Option {
+	return func(o *Options) {
+		if o.Context == nil {
+			o.Context = context.Background()
+		}
+		o.Context = context.WithValue(o.Context, k, v)
+	}
+}

registry/extractor.go

@@ -4,6 +4,8 @@ import (
 	"fmt"
 	"reflect"
 	"strings"
+	"unicode"
+	"unicode/utf8"
 
 	"github.com/unistack-org/micro/v3/metadata"
 )
@@ -21,6 +23,18 @@ func ExtractValue(v reflect.Type, d int) *Value {
 		v = v.Elem()
 	}
 
+	if len(v.Name()) == 0 {
+		return nil
+	}
+
+	// get the rune character
+	a, _ := utf8.DecodeRuneInString(string(v.Name()[0]))
+
+	// crude check for is unexported field
+	if unicode.IsLower(a) {
+		return nil
+	}
+
 	arg := &Value{
 		Name: v.Name(),
 		Type: v.Name(),
@@ -91,6 +105,9 @@ func ExtractEndpoint(method reflect.Method) *Endpoint {
 
 	request := ExtractValue(reqType, 0)
 	response := ExtractValue(rspType, 0)
+	if request == nil || response == nil {
+		return nil
+	}
 
 	ep := &Endpoint{
 		Name:     method.Name,
@@ -100,9 +117,7 @@ func ExtractEndpoint(method reflect.Method) *Endpoint {
 	}
 
 	if stream {
-		ep.Metadata = map[string]string{
-			"stream": fmt.Sprintf("%v", stream),
-		}
+		ep.Metadata.Set("stream", fmt.Sprintf("%v", stream))
 	}
 
 	return ep

registry/extractor_test.go

@@ -6,18 +6,18 @@ import (
 	"testing"
 )
 
-type testHandler struct{}
+type TestHandler struct{}
 
-type testRequest struct{}
+type TestRequest struct{}
 
-type testResponse struct{}
+type TestResponse struct{}
 
-func (t *testHandler) Test(ctx context.Context, req *testRequest, rsp *testResponse) error {
+func (t *TestHandler) Test(ctx context.Context, req *TestRequest, rsp *TestResponse) error {
 	return nil
 }
 
 func TestExtractEndpoint(t *testing.T) {
-	handler := &testHandler{}
+	handler := &TestHandler{}
 	typ := reflect.TypeOf(handler)
 
 	var endpoints []*Endpoint
@@ -29,35 +29,35 @@ func TestExtractEndpoint(t *testing.T) {
 	}
 
 	if i := len(endpoints); i != 1 {
-		t.Errorf("Expected 1 endpoint, have %d", i)
+		t.Fatalf("Expected 1 endpoint, have %d", i)
 	}
 
 	if endpoints[0].Name != "Test" {
-		t.Errorf("Expected handler Test, got %s", endpoints[0].Name)
+		t.Fatalf("Expected handler Test, got %s", endpoints[0].Name)
 	}
 
 	if endpoints[0].Request == nil {
-		t.Error("Expected non nil request")
+		t.Fatal("Expected non nil Request")
 	}
 
 	if endpoints[0].Response == nil {
-		t.Error("Expected non nil request")
+		t.Fatal("Expected non nil Request")
 	}
 
-	if endpoints[0].Request.Name != "testRequest" {
-		t.Errorf("Expected testRequest got %s", endpoints[0].Request.Name)
+	if endpoints[0].Request.Name != "TestRequest" {
+		t.Fatalf("Expected TestRequest got %s", endpoints[0].Request.Name)
 	}
 
-	if endpoints[0].Response.Name != "testResponse" {
-		t.Errorf("Expected testResponse got %s", endpoints[0].Response.Name)
+	if endpoints[0].Response.Name != "TestResponse" {
+		t.Fatalf("Expected TestResponse got %s", endpoints[0].Response.Name)
 	}
 
-	if endpoints[0].Request.Type != "testRequest" {
-		t.Errorf("Expected testRequest type got %s", endpoints[0].Request.Type)
+	if endpoints[0].Request.Type != "TestRequest" {
+		t.Fatalf("Expected TestRequest type got %s", endpoints[0].Request.Type)
 	}
 
-	if endpoints[0].Response.Type != "testResponse" {
-		t.Errorf("Expected testResponse type got %s", endpoints[0].Response.Type)
+	if endpoints[0].Response.Type != "TestResponse" {
+		t.Fatalf("Expected TestResponse type got %s", endpoints[0].Response.Type)
 	}
 
 }

registry/noop.go

@@ -2,7 +2,6 @@ package registry
 
 import (
 	"context"
-	"fmt"
 )
 
 type noopRegistry struct {
@@ -54,7 +53,7 @@ func (n *noopRegistry) ListServices(ctx context.Context, opts ...ListOption) ([]
 
 // Watch is used to watch for service changes
 func (n *noopRegistry) Watch(ctx context.Context, opts ...WatchOption) (Watcher, error) {
-	return nil, fmt.Errorf("not implemented")
+	return &noopWatcher{done: make(chan struct{}), opts: NewWatchOptions(opts...)}, nil
 }
 
 // String returns registry string representation
@@ -62,6 +61,20 @@ func (n *noopRegistry) String() string {
 	return "noop"
 }
 
+type noopWatcher struct {
+	opts WatchOptions
+	done chan struct{}
+}
+
+func (n *noopWatcher) Next() (*Result, error) {
+	<-n.done
+	return nil, ErrWatcherStopped
+}
+
+func (n *noopWatcher) Stop() {
+	close(n.done)
+}
+
 // NewRegistry returns a new noop registry
 func NewRegistry(opts ...Option) Registry {
 	return &noopRegistry{opts: NewOptions(opts...)}

registry/options.go

@@ -13,7 +13,9 @@ type Options struct {
 	Timeout   time.Duration
 	Secure    bool
 	TLSConfig *tls.Config
-	Logger    logger.Logger
+
+	// Logger imp
+	Logger logger.Logger
 	// Other options for implementations of the interface
 	// can be stored in a context
 	Context context.Context

registry/registry.go

@@ -4,6 +4,8 @@ package registry
 import (
 	"context"
 	"errors"
+
+	"github.com/unistack-org/micro/v3/metadata"
 )
 
 const (
@@ -22,7 +24,7 @@ var (
 	ErrWatcherStopped = errors.New("watcher stopped")
 )
 
-// The registry provides an interface for service discovery
+// Registry provides an interface for service discovery
 // and an abstraction over varying implementations
 // {consul, etcd, zookeeper, ...}
 type Registry interface {
@@ -42,7 +44,7 @@ type Registry interface {
 type Service struct {
 	Name      string            `json:"name"`
 	Version   string            `json:"version"`
-	Metadata  map[string]string `json:"metadata"`
+	Metadata  metadata.Metadata `json:"metadata"`
 	Endpoints []*Endpoint       `json:"endpoints"`
 	Nodes     []*Node           `json:"nodes"`
 }
@@ -51,7 +53,7 @@ type Service struct {
 type Node struct {
 	Id       string            `json:"id"`
 	Address  string            `json:"address"`
-	Metadata map[string]string `json:"metadata"`
+	Metadata metadata.Metadata `json:"metadata"`
 }
 
 // Endpoint holds endpoint registry info
@@ -59,10 +61,10 @@ type Endpoint struct {
 	Name     string            `json:"name"`
 	Request  *Value            `json:"request"`
 	Response *Value            `json:"response"`
-	Metadata map[string]string `json:"metadata"`
+	Metadata metadata.Metadata `json:"metadata"`
 }
 
-// Valud holds additional kv stuff
+// Value holds additional kv stuff
 type Value struct {
 	Name   string   `json:"name"`
 	Type   string   `json:"type"`

resolver/registry/registry.go

@@ -1,4 +1,4 @@
-// Package registry resolves names using the go-micro registry
+// Package registry resolves names using the micro registry
 package registry
 
 import (

router/route.go

@@ -2,6 +2,8 @@ package router
 
 import (
 	"hash/fnv"
+
+	"github.com/unistack-org/micro/v3/metadata"
 )
 
 var (
@@ -28,7 +30,7 @@ type Route struct {
 	// Metric is the route cost metric
 	Metric int64
 	// Metadata for the route
-	Metadata map[string]string
+	Metadata metadata.Metadata
 }
 
 // Hash returns route hash sum.

runtime/runtime.go

@@ -4,6 +4,8 @@ package runtime
 import (
 	"errors"
 	"time"
+
+	"github.com/unistack-org/micro/v3/metadata"
 )
 
 var (
@@ -43,7 +45,7 @@ type Logs interface {
 // Log is a log message
 type Log struct {
 	Message  string
-	Metadata map[string]string
+	Metadata metadata.Metadata
 }
 
 // Scheduler is a runtime service scheduler
@@ -103,7 +105,7 @@ type Service struct {
 	// url location of source
 	Source string
 	// Metadata stores metadata
-	Metadata map[string]string
+	Metadata metadata.Metadata
 }
 
 // Resources which are allocated to a serivce

selector/random/random.go

@@ -22,7 +22,7 @@ func (r *random) Select(routes []string, opts ...selector.SelectOption) (selecto
 		}
 
 		// select a random route from the slice
-		return routes[rand.Intn(len(routes)-1)]
+		return routes[rand.Intn(len(routes))]
 	}, nil
 }
 

selector/roundrobin/roundrobin.go

@@ -1,6 +1,8 @@
 package roundrobin
 
 import (
+	"math/rand"
+
 	"github.com/unistack-org/micro/v3/selector"
 )
 
@@ -17,7 +19,7 @@ func (r *roundrobin) Select(routes []string, opts ...selector.SelectOption) (sel
 		return nil, selector.ErrNoneAvailable
 	}
 
-	var i int
+	i := rand.Intn(len(routes))
 
 	return func() string {
 		route := routes[i%len(routes)]