move memory implementations to core micro repo

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

.github/renovate.json

@@ -0,0 +1,19 @@
+{
+  "extends": [
+    "config:base"
+  ],
+  "packageRules": [
+    {
+      "matchUpdateTypes": ["minor", "patch", "pin", "digest"],
+      "automerge": true
+    },
+    {
+      "groupName": "all deps",
+      "separateMajorMinor": true,
+      "groupSlug": "all",
+      "packagePatterns": [
+        "*"
+      ]
+    }
+  ]
+}

.github/workflows/build.yml

@@ -9,7 +9,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
     - name: setup
-      uses: actions/setup-go@v1
+      uses: actions/setup-go@v2
       with:
         go-version: 1.15
     - name: cache
@@ -49,7 +49,7 @@ jobs:
       - name: checkout
         uses: actions/checkout@v2
       - name: lint
-        uses: golangci/golangci-lint-action@v1
+        uses: golangci/golangci-lint-action@v2
         continue-on-error: true
         with:
           # Required: the version of golangci-lint is required and must be specified without patch version: we always use the latest patch version.

.github/workflows/pr.yml

@@ -9,7 +9,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
     - name: setup
-      uses: actions/setup-go@v1
+      uses: actions/setup-go@v2
       with:
         go-version: 1.15
     - name: cache
@@ -49,7 +49,7 @@ jobs:
       - name: checkout
         uses: actions/checkout@v2
       - name: lint
-        uses: golangci/golangci-lint-action@v1
+        uses: golangci/golangci-lint-action@v2
         continue-on-error: true
         with:
           # Required: the version of golangci-lint is required and must be specified without patch version: we always use the latest patch version.

api/api.go

@@ -6,7 +6,7 @@ import (
 	"strings"
 
 	"github.com/unistack-org/micro/v3/metadata"
-	"github.com/unistack-org/micro/v3/registry"
+	"github.com/unistack-org/micro/v3/register"
 	"github.com/unistack-org/micro/v3/server"
 )
 
@@ -56,7 +56,7 @@ type Service struct {
 	// The endpoint for this service
 	Endpoint *Endpoint
 	// Versions of this service
-	Services []*registry.Service
+	Services []*register.Service
 }
 
 func strip(s string) string {
@@ -98,6 +98,7 @@ func Encode(e *Endpoint) map[string]string {
 	set("method", strings.Join(e.Method, ","))
 	set("path", strings.Join(e.Path, ","))
 	set("host", strings.Join(e.Host, ","))
+	set("body", e.Body)
 
 	return ep
 }
@@ -118,6 +119,7 @@ func Decode(e metadata.Metadata) *Endpoint {
 	ephost, _ := e.Get("host")
 	ep.Host = []string{ephost}
 	ep.Handler, _ = e.Get("handler")
+	ep.Body, _ = e.Get("body")
 
 	return ep
 }

api/handler/http/http.go

@@ -11,7 +11,7 @@ import (
 
 	"github.com/unistack-org/micro/v3/api"
 	"github.com/unistack-org/micro/v3/api/handler"
-	"github.com/unistack-org/micro/v3/registry"
+	"github.com/unistack-org/micro/v3/register"
 )
 
 const (
@@ -70,7 +70,7 @@ func (h *httpHandler) getService(r *http.Request) (string, error) {
 	}
 
 	// get the nodes for this service
-	nodes := make([]*registry.Node, 0, len(service.Services))
+	nodes := make([]*register.Node, 0, len(service.Services))
 	for _, srv := range service.Services {
 		nodes = append(nodes, srv.Nodes...)
 	}

api/handler/http/http_test.go

@@ -12,13 +12,13 @@ import (
 	"github.com/unistack-org/micro/v3/api/resolver"
 	"github.com/unistack-org/micro/v3/api/resolver/vpath"
 	"github.com/unistack-org/micro/v3/api/router"
-	regRouter "github.com/unistack-org/micro/v3/api/router/registry"
-	"github.com/unistack-org/micro/v3/registry"
-	"github.com/unistack-org/micro/v3/registry/memory"
+	regRouter "github.com/unistack-org/micro/v3/api/router/register"
+	"github.com/unistack-org/micro/v3/register"
+	"github.com/unistack-org/micro/v3/register/memory"
 )
 
 func testHttp(t *testing.T, path, service, ns string) {
-	r := memory.NewRegistry()
+	r := memory.NewRegister()
 
 	l, err := net.Listen("tcp", "127.0.0.1:0")
 	if err != nil {
@@ -26,9 +26,9 @@ func testHttp(t *testing.T, path, service, ns string) {
 	}
 	defer l.Close()
 
-	s := &registry.Service{
+	s := &register.Service{
 		Name: service,
-		Nodes: []*registry.Node{
+		Nodes: []*register.Node{
 			{
 				Id:      service + "-1",
 				Address: l.Addr().String(),
@@ -58,7 +58,7 @@ func testHttp(t *testing.T, path, service, ns string) {
 	// initialise the handler
 	rt := regRouter.NewRouter(
 		router.WithHandler("http"),
-		router.WithRegistry(r),
+		router.WithRegister(r),
 		router.WithResolver(vpath.NewResolver(
 			resolver.WithServicePrefix(ns),
 		)),

api/handler/web/web.go

@@ -14,7 +14,7 @@ import (
 
 	"github.com/unistack-org/micro/v3/api"
 	"github.com/unistack-org/micro/v3/api/handler"
-	"github.com/unistack-org/micro/v3/registry"
+	"github.com/unistack-org/micro/v3/register"
 )
 
 const (
@@ -72,7 +72,7 @@ func (wh *webHandler) getService(r *http.Request) (string, error) {
 	}
 
 	// get the nodes
-	nodes := make([]*registry.Node, 0, len(service.Services))
+	nodes := make([]*register.Node, 0, len(service.Services))
 	for _, srv := range service.Services {
 		nodes = append(nodes, srv.Nodes...)
 	}

api/resolver/options.go

@@ -3,7 +3,7 @@ package resolver
 import (
 	"context"
 
-	"github.com/unistack-org/micro/v3/registry"
+	"github.com/unistack-org/micro/v3/register"
 )
 
 // Options struct
@@ -58,7 +58,7 @@ func Domain(n string) ResolveOption {
 
 // NewResolveOptions returns new initialised resolve options
 func NewResolveOptions(opts ...ResolveOption) ResolveOptions {
-	options := ResolveOptions{Domain: registry.DefaultDomain}
+	options := ResolveOptions{Domain: register.DefaultDomain}
 	for _, o := range opts {
 		o(&options)
 	}

api/router/options.go

@@ -6,12 +6,12 @@ import (
 	"github.com/unistack-org/micro/v3/api/resolver"
 	"github.com/unistack-org/micro/v3/api/resolver/vpath"
 	"github.com/unistack-org/micro/v3/logger"
-	"github.com/unistack-org/micro/v3/registry"
+	"github.com/unistack-org/micro/v3/register"
 )
 
 type Options struct {
 	Handler  string
-	Registry registry.Registry
+	Register register.Register
 	Resolver resolver.Resolver
 	Logger   logger.Logger
 	Context  context.Context
@@ -52,10 +52,10 @@ func WithHandler(h string) Option {
 	}
 }
 
-// WithRegistry sets the registry
-func WithRegistry(r registry.Registry) Option {
+// WithRegister sets the register
+func WithRegister(r register.Register) Option {
 	return func(o *Options) {
-		o.Registry = r
+		o.Register = r
 	}
 }
 

api/server/acme/acme.go

@@ -1,29 +0,0 @@
-// Package acme abstracts away various ACME libraries
-package acme
-
-import (
-	"crypto/tls"
-	"errors"
-	"net"
-)
-
-var (
-	// ErrProviderNotImplemented can be returned when attempting to
-	// instantiate an unimplemented provider
-	ErrProviderNotImplemented = errors.New("Provider not implemented")
-)
-
-// Provider is a ACME provider interface
-type Provider interface {
-	Init(...Option) error
-	// Listen returns a new listener
-	Listen(...string) (net.Listener, error)
-	// TLSConfig returns a tls config
-	TLSConfig(...string) (*tls.Config, error)
-}
-
-// The Let's Encrypt ACME endpoints
-const (
-	LetsEncryptStagingCA    = "https://acme-staging-v02.api.letsencrypt.org/directory"
-	LetsEncryptProductionCA = "https://acme-v02.api.letsencrypt.org/directory"
-)

api/server/acme/autocert/autocert.go

@@ -1,53 +0,0 @@
-// Package autocert is the ACME provider from golang.org/x/crypto/acme/autocert
-// This provider does not take any config.
-package autocert
-
-import (
-	"crypto/tls"
-	"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 {
-	opts server.Options
-}
-
-func (a *autocertProvider) Init(opts ...acme.Option) error {
-	return nil
-}
-
-// Listen implements acme.Provider
-func (a *autocertProvider) Listen(hosts ...string) (net.Listener, error) {
-	return autocert.NewListener(hosts...), nil
-}
-
-// TLSConfig returns a new tls config
-func (a *autocertProvider) TLSConfig(hosts ...string) (*tls.Config, error) {
-	// create a new manager
-	m := &autocert.Manager{
-		Prompt: autocert.AcceptTOS,
-	}
-	if len(hosts) > 0 {
-		m.HostPolicy = autocert.HostWhitelist(hosts...)
-	}
-	dir := cacheDir()
-	if err := os.MkdirAll(dir, 0700); err != nil {
-		if logger.V(logger.InfoLevel) {
-			logger.Info(a.opts.Context, "warning: autocert not using a cache: %v", err)
-		}
-	} else {
-		m.Cache = autocert.DirCache(dir)
-	}
-	return m.TLSConfig(), nil
-}
-
-// New returns an autocert acme.Provider
-func NewProvider() acme.Provider {
-	return &autocertProvider{}
-}

api/server/acme/autocert/autocert_test.go

@@ -1,16 +0,0 @@
-package autocert
-
-import (
-	"testing"
-)
-
-func TestAutocert(t *testing.T) {
-	l := NewProvider()
-	if _, ok := l.(*autocertProvider); !ok {
-		t.Error("NewProvider() didn't return an autocertProvider")
-	}
-	// TODO: Travis CI doesn't let us bind :443
-	// if _, err := l.NewListener(); err != nil {
-	// 	t.Error(err.Error())
-	// }
-}

api/server/acme/autocert/cache.go

@@ -1,37 +0,0 @@
-package autocert
-
-import (
-	"os"
-	"path/filepath"
-	"runtime"
-)
-
-func homeDir() string {
-	if runtime.GOOS == "windows" {
-		return os.Getenv("HOMEDRIVE") + os.Getenv("HOMEPATH")
-	}
-	if h := os.Getenv("HOME"); h != "" {
-		return h
-	}
-	return "/"
-}
-
-func cacheDir() string {
-	const base = "golang-autocert"
-	switch runtime.GOOS {
-	case "darwin":
-		return filepath.Join(homeDir(), "Library", "Caches", base)
-	case "windows":
-		for _, ev := range []string{"APPDATA", "CSIDL_APPDATA", "TEMP", "TMP"} {
-			if v := os.Getenv(ev); v != "" {
-				return filepath.Join(v, base)
-			}
-		}
-		// Worst case:
-		return filepath.Join(homeDir(), base)
-	}
-	if xdg := os.Getenv("XDG_CACHE_HOME"); xdg != "" {
-		return filepath.Join(xdg, base)
-	}
-	return filepath.Join(homeDir(), ".cache", base)
-}

api/server/acme/certmagic/certmagic.go

@@ -1,71 +0,0 @@
-// Package certmagic is the ACME provider from github.com/caddyserver/certmagic
-package certmagic
-
-import (
-	"crypto/tls"
-	"fmt"
-	"math/rand"
-	"net"
-	"time"
-
-	"github.com/caddyserver/certmagic"
-	"github.com/unistack-org/micro/v3/api/server/acme"
-)
-
-type certmagicProvider struct {
-	opts acme.Options
-}
-
-// TODO: set self-contained options
-func (c *certmagicProvider) setup() {
-	certmagic.DefaultACME.CA = c.opts.CA
-	if c.opts.ChallengeProvider != nil {
-		// Enabling DNS Challenge disables the other challenges
-		certmagic.DefaultACME.DNSProvider = c.opts.ChallengeProvider
-	}
-	if c.opts.OnDemand {
-		certmagic.Default.OnDemand = new(certmagic.OnDemandConfig)
-	}
-	if c.opts.Cache != nil {
-		// already validated by new()
-		certmagic.Default.Storage = c.opts.Cache.(certmagic.Storage)
-	}
-	// If multiple instances of the provider are running, inject some
-	// randomness so they don't collide
-	// RenewalWindowRatio [0.33 - 0.50)
-	rand.Seed(time.Now().UnixNano())
-	randomRatio := float64(rand.Intn(17)+33) * 0.01
-	certmagic.Default.RenewalWindowRatio = randomRatio
-}
-
-func (c *certmagicProvider) Listen(hosts ...string) (net.Listener, error) {
-	c.setup()
-	return certmagic.Listen(hosts)
-}
-
-func (c *certmagicProvider) TLSConfig(hosts ...string) (*tls.Config, error) {
-	c.setup()
-	return certmagic.TLS(hosts)
-}
-
-func (p *certmagicProvider) Init(opts ...acme.Option) error {
-	if p.opts.Cache != nil {
-		if _, ok := p.opts.Cache.(certmagic.Storage); !ok {
-			return fmt.Errorf("ACME: cache provided doesn't implement certmagic's Storage interface")
-		}
-	}
-	return nil
-}
-
-// NewProvider returns a certmagic provider
-func NewProvider(options ...acme.Option) acme.Provider {
-	opts := acme.DefaultOptions()
-
-	for _, o := range options {
-		o(&opts)
-	}
-
-	return &certmagicProvider{
-		opts: opts,
-	}
-}

api/server/acme/certmagic/storage.go

@@ -1,138 +0,0 @@
-package certmagic
-
-import (
-	"bytes"
-	"encoding/gob"
-	"errors"
-	"path"
-	"strings"
-	"time"
-
-	"github.com/caddyserver/certmagic"
-	"github.com/unistack-org/micro/v3/store"
-	"github.com/unistack-org/micro/v3/sync"
-)
-
-// File represents a "File" that will be stored in store.Store - the contents and last modified time
-type File struct {
-	// last modified time
-	LastModified time.Time
-	// Contents
-	Contents []byte
-}
-
-// storage is an implementation of certmagic.Storage using micro's sync.Map and store.Store interfaces.
-// As certmagic storage expects a filesystem (with stat() abilities) we have to implement
-// the bare minimum of metadata.
-type storage struct {
-	lock  sync.Sync
-	store store.Store
-}
-
-func (s *storage) Lock(key string) error {
-	return s.lock.Lock(key, sync.LockTTL(10*time.Minute))
-}
-
-func (s *storage) Unlock(key string) error {
-	return s.lock.Unlock(key)
-}
-
-func (s *storage) Store(key string, value []byte) error {
-	f := File{
-		LastModified: time.Now(),
-		Contents:     value,
-	}
-	buf := &bytes.Buffer{}
-	e := gob.NewEncoder(buf)
-	if err := e.Encode(f); err != nil {
-		return err
-	}
-	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"))
-	}
-	var val []byte
-	err := s.store.Read(s.store.Options().Context, key, val)
-	if err != nil {
-		return nil, err
-	}
-	b := bytes.NewBuffer(val)
-	d := gob.NewDecoder(b)
-	var f File
-	err = d.Decode(&f)
-	if err != nil {
-		return nil, err
-	}
-	return f.Contents, nil
-}
-
-func (s *storage) Delete(key string) error {
-	return s.store.Delete(s.store.Options().Context, key)
-}
-
-func (s *storage) Exists(key string) bool {
-	if err := s.store.Read(s.store.Options().Context, key, nil); err != nil {
-		return false
-	}
-	return true
-}
-
-func (s *storage) List(prefix string, recursive bool) ([]string, error) {
-	keys, err := s.store.List(s.store.Options().Context)
-	if err != nil {
-		return nil, err
-	}
-
-	//nolint:prealloc
-	var results []string
-	for _, k := range keys {
-		if strings.HasPrefix(k, prefix) {
-			results = append(results, k)
-		}
-	}
-	if recursive {
-		return results, nil
-	}
-	keysMap := make(map[string]bool)
-	for _, key := range results {
-		dir := strings.Split(strings.TrimPrefix(key, prefix+"/"), "/")
-		keysMap[dir[0]] = true
-	}
-	results = make([]string, 0)
-	for k := range keysMap {
-		results = append(results, path.Join(prefix, k))
-	}
-	return results, nil
-}
-
-func (s *storage) Stat(key string) (certmagic.KeyInfo, error) {
-	var val []byte
-	err := s.store.Read(s.store.Options().Context, key, val)
-	if err != nil {
-		return certmagic.KeyInfo{}, err
-	}
-	b := bytes.NewBuffer(val)
-	d := gob.NewDecoder(b)
-	var f File
-	err = d.Decode(&f)
-	if err != nil {
-		return certmagic.KeyInfo{}, err
-	}
-	return certmagic.KeyInfo{
-		Key:        key,
-		Modified:   f.LastModified,
-		Size:       int64(len(f.Contents)),
-		IsTerminal: false,
-	}, nil
-}
-
-// 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,
-		store: store,
-	}
-}

api/server/acme/options.go

@@ -1,73 +0,0 @@
-package acme
-
-import "github.com/go-acme/lego/v3/challenge"
-
-// Option (or Options) are passed to New() to configure providers
-type Option func(o *Options)
-
-// Options represents various options you can present to ACME providers
-type Options struct {
-	// AcceptTLS must be set to true to indicate that you have read your
-	// provider's terms of service.
-	AcceptToS bool
-	// CA is the CA to use
-	CA string
-	// ChallengeProvider is a go-acme/lego challenge provider. Set this if you
-	// want to use DNS Challenges. Otherwise, tls-alpn-01 will be used
-	ChallengeProvider challenge.Provider
-	// Issue certificates for domains on demand. Otherwise, certs will be
-	// retrieved / issued on start-up.
-	OnDemand bool
-	// Cache is a storage interface. Most ACME libraries have an cache, but
-	// there's no defined interface, so if you consume this option
-	// sanity check it before using.
-	Cache interface{}
-}
-
-// AcceptToS indicates whether you accept your CA's terms of service
-func AcceptToS(b bool) Option {
-	return func(o *Options) {
-		o.AcceptToS = b
-	}
-}
-
-// CA sets the CA of an acme.Options
-func CA(CA string) Option {
-	return func(o *Options) {
-		o.CA = CA
-	}
-}
-
-// ChallengeProvider sets the Challenge provider of an acme.Options
-// if set, it enables the DNS challenge, otherwise tls-alpn-01 will be used.
-func ChallengeProvider(p challenge.Provider) Option {
-	return func(o *Options) {
-		o.ChallengeProvider = p
-	}
-}
-
-// OnDemand enables on-demand certificate issuance. Not recommended for use
-// with the DNS challenge, as the first connection may be very slow.
-func OnDemand(b bool) Option {
-	return func(o *Options) {
-		o.OnDemand = b
-	}
-}
-
-// Cache provides a cache / storage interface to the underlying ACME library
-// as there is no standard, this needs to be validated by the underlying
-// implementation
-func Cache(c interface{}) Option {
-	return func(o *Options) {
-		o.Cache = c
-	}
-}
-
-// DefaultOptions uses the Let's Encrypt Production CA, with DNS Challenge disabled.
-func DefaultOptions() Options {
-	return Options{
-		AcceptToS: true,
-		CA:        LetsEncryptProductionCA,
-		OnDemand:  true,
-	}
-}

api/server/cors/cors.go

@@ -1,44 +0,0 @@
-package cors
-
-import (
-	"net/http"
-)
-
-// CombinedCORSHandler wraps a server and provides CORS headers
-func CombinedCORSHandler(h http.Handler) http.Handler {
-	return corsHandler{h}
-}
-
-type corsHandler struct {
-	handler http.Handler
-}
-
-func (c corsHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
-	SetHeaders(w, r)
-
-	if r.Method == "OPTIONS" {
-		return
-	}
-
-	c.handler.ServeHTTP(w, r)
-}
-
-// SetHeaders sets the CORS headers
-func SetHeaders(w http.ResponseWriter, r *http.Request) {
-	set := func(w http.ResponseWriter, k, v string) {
-		if v := w.Header().Get(k); len(v) > 0 {
-			return
-		}
-		w.Header().Set(k, v)
-	}
-
-	if origin := r.Header.Get("Origin"); len(origin) > 0 {
-		set(w, "Access-Control-Allow-Origin", origin)
-	} else {
-		set(w, "Access-Control-Allow-Origin", "*")
-	}
-
-	set(w, "Access-Control-Allow-Credentials", "true")
-	set(w, "Access-Control-Allow-Methods", "POST, PATCH, GET, OPTIONS, PUT, DELETE")
-	set(w, "Access-Control-Allow-Headers", "Accept, Content-Type, Content-Length, Accept-Encoding, X-CSRF-Token, Authorization")
-}

api/server/http/http.go

@@ -1,110 +0,0 @@
-// Package http provides a http server with features; acme, cors, etc
-package http
-
-import (
-	"crypto/tls"
-	"net"
-	"net/http"
-	"sync"
-
-	"github.com/unistack-org/micro/v3/api/server"
-	"github.com/unistack-org/micro/v3/logger"
-)
-
-type httpServer struct {
-	mux  *http.ServeMux
-	opts server.Options
-
-	sync.RWMutex
-	address string
-	exit    chan chan error
-}
-
-func NewServer(address string, opts ...server.Option) server.Server {
-	return &httpServer{
-		opts:    server.NewOptions(opts...),
-		mux:     http.NewServeMux(),
-		address: address,
-		exit:    make(chan chan error),
-	}
-}
-
-func (s *httpServer) Address() string {
-	s.RLock()
-	defer s.RUnlock()
-	return s.address
-}
-
-func (s *httpServer) Init(opts ...server.Option) error {
-	for _, o := range opts {
-		o(&s.opts)
-	}
-	return nil
-}
-
-func (s *httpServer) Handle(path string, handler http.Handler) {
-	// TODO: move this stuff out to one place with ServeHTTP
-
-	// apply the wrappers, e.g. auth
-	for _, wrapper := range s.opts.Wrappers {
-		handler = wrapper(handler)
-	}
-
-	s.mux.Handle(path, handler)
-}
-
-func (s *httpServer) Start() error {
-	var l net.Listener
-	var err error
-
-	s.RLock()
-	config := s.opts
-	s.RUnlock()
-	if s.opts.EnableACME && s.opts.ACMEProvider != nil {
-		// should we check the address to make sure its using :443?
-		l, err = s.opts.ACMEProvider.Listen(s.opts.ACMEHosts...)
-	} else if s.opts.EnableTLS && s.opts.TLSConfig != nil {
-		l, err = tls.Listen("tcp", s.address, s.opts.TLSConfig)
-	} else {
-		// otherwise plain listen
-		l, err = net.Listen("tcp", s.address)
-	}
-	if err != nil {
-		return err
-	}
-
-	if config.Logger.V(logger.InfoLevel) {
-		config.Logger.Infof(s.opts.Context, "HTTP API Listening on %s", l.Addr().String())
-	}
-
-	s.Lock()
-	s.address = l.Addr().String()
-	s.Unlock()
-
-	go func() {
-		if err := http.Serve(l, s.mux); err != nil {
-			// temporary fix
-			if config.Logger.V(logger.ErrorLevel) {
-				config.Logger.Errorf(s.opts.Context, "serve err: %v", err)
-			}
-			s.Stop()
-		}
-	}()
-
-	go func() {
-		ch := <-s.exit
-		ch <- l.Close()
-	}()
-
-	return nil
-}
-
-func (s *httpServer) Stop() error {
-	ch := make(chan error)
-	s.exit <- ch
-	return <-ch
-}
-
-func (s *httpServer) String() string {
-	return "http"
-}

api/server/http/http_test.go

@@ -1,41 +0,0 @@
-package http
-
-import (
-	"fmt"
-	"io/ioutil"
-	"net/http"
-	"testing"
-)
-
-func TestHTTPServer(t *testing.T) {
-	testResponse := "hello world"
-
-	s := NewServer("localhost:0")
-
-	s.Handle("/", http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		fmt.Fprint(w, testResponse)
-	}))
-
-	if err := s.Start(); err != nil {
-		t.Fatal(err)
-	}
-
-	rsp, err := http.Get(fmt.Sprintf("http://%s/", s.Address()))
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer rsp.Body.Close()
-
-	b, err := ioutil.ReadAll(rsp.Body)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	if string(b) != testResponse {
-		t.Fatalf("Unexpected response, got %s, expected %s", string(b), testResponse)
-	}
-
-	if err := s.Stop(); err != nil {
-		t.Fatal(err)
-	}
-}

api/server/options.go

@@ -1,96 +0,0 @@
-package server
-
-import (
-	"context"
-	"crypto/tls"
-	"net/http"
-
-	"github.com/unistack-org/micro/v3/api/resolver"
-	"github.com/unistack-org/micro/v3/api/server/acme"
-	"github.com/unistack-org/micro/v3/logger"
-)
-
-// Option func
-type Option func(o *Options)
-
-// Options for api server
-type Options struct {
-	EnableACME   bool
-	EnableCORS   bool
-	ACMEProvider acme.Provider
-	EnableTLS    bool
-	ACMEHosts    []string
-	TLSConfig    *tls.Config
-	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,
-		Context: context.Background(),
-	}
-	for _, o := range opts {
-		o(&options)
-	}
-	return options
-}
-
-type Wrapper func(h http.Handler) http.Handler
-
-func WrapHandler(w ...Wrapper) Option {
-	return func(o *Options) {
-		o.Wrappers = append(o.Wrappers, w...)
-	}
-}
-
-func EnableCORS(b bool) Option {
-	return func(o *Options) {
-		o.EnableCORS = b
-	}
-}
-
-func EnableACME(b bool) Option {
-	return func(o *Options) {
-		o.EnableACME = b
-	}
-}
-
-func ACMEHosts(hosts ...string) Option {
-	return func(o *Options) {
-		o.ACMEHosts = hosts
-	}
-}
-
-func ACMEProvider(p acme.Provider) Option {
-	return func(o *Options) {
-		o.ACMEProvider = p
-	}
-}
-
-func EnableTLS(b bool) Option {
-	return func(o *Options) {
-		o.EnableTLS = b
-	}
-}
-
-func TLSConfig(t *tls.Config) Option {
-	return func(o *Options) {
-		o.TLSConfig = t
-	}
-}
-
-func Resolver(r resolver.Resolver) Option {
-	return func(o *Options) {
-		o.Resolver = r
-	}
-}
-
-func Logger(l logger.Logger) Option {
-	return func(o *Options) {
-		o.Logger = l
-	}
-}

api/server/server.go

@@ -1,15 +0,0 @@
-// Package server provides an API gateway server which handles inbound requests
-package server
-
-import (
-	"net/http"
-)
-
-// Server serves api requests
-type Server interface {
-	Address() string
-	Init(opts ...Option) error
-	Handle(path string, handler http.Handler)
-	Start() error
-	Stop() error
-}

auth/options.go

@@ -6,13 +6,17 @@ import (
 
 	"github.com/unistack-org/micro/v3/logger"
 	"github.com/unistack-org/micro/v3/metadata"
+	"github.com/unistack-org/micro/v3/meter"
 	"github.com/unistack-org/micro/v3/store"
+	"github.com/unistack-org/micro/v3/tracer"
 )
 
 // NewOptions creates Options struct from slice of options
 func NewOptions(opts ...Option) Options {
 	options := Options{
+		Tracer: tracer.DefaultTracer,
 		Logger: logger.DefaultLogger,
+		Meter:  meter.DefaultMeter,
 	}
 	for _, o := range opts {
 		o(&options)
@@ -21,6 +25,7 @@ func NewOptions(opts ...Option) Options {
 }
 
 type Options struct {
+	Name string
 	// Issuer of the service's account
 	Issuer string
 	// ID is the services auth ID
@@ -41,6 +46,10 @@ type Options struct {
 	Addrs []string
 	// Logger sets the logger
 	Logger logger.Logger
+	// Meter sets tht meter
+	Meter meter.Meter
+	// Tracer
+	Tracer tracer.Tracer
 	// Context to store other options
 	Context context.Context
 }
@@ -55,6 +64,13 @@ func Addrs(addrs ...string) Option {
 	}
 }
 
+// Name sets the name
+func Name(n string) Option {
+	return func(o *Options) {
+		o.Name = n
+	}
+}
+
 // Issuer of the services account
 func Issuer(i string) Option {
 	return func(o *Options) {
@@ -288,3 +304,17 @@ func Logger(l logger.Logger) Option {
 		o.Logger = l
 	}
 }
+
+// Meter sets the meter
+func Meter(m meter.Meter) Option {
+	return func(o *Options) {
+		o.Meter = m
+	}
+}
+
+// Tracer sets the meter
+func Tracer(t tracer.Tracer) Option {
+	return func(o *Options) {
+		o.Tracer = t
+	}
+}

broker/broker.go

@@ -14,6 +14,7 @@ var (
 
 // Broker is an interface used for asynchronous messaging.
 type Broker interface {
+	Name() string
 	Init(...Option) error
 	Options() Options
 	Address() string

broker/memory.go

@@ -0,0 +1,247 @@
+package broker
+
+import (
+	"context"
+	"errors"
+	"math/rand"
+	"sync"
+	"time"
+
+	"github.com/google/uuid"
+	"github.com/unistack-org/micro/v3/logger"
+	maddr "github.com/unistack-org/micro/v3/util/addr"
+	mnet "github.com/unistack-org/micro/v3/util/net"
+)
+
+type memoryBroker struct {
+	opts Options
+
+	addr string
+	sync.RWMutex
+	connected   bool
+	Subscribers map[string][]*memorySubscriber
+}
+
+type memoryEvent struct {
+	opts    Options
+	topic   string
+	err     error
+	message interface{}
+}
+
+type memorySubscriber struct {
+	id      string
+	topic   string
+	exit    chan bool
+	handler Handler
+	opts    SubscribeOptions
+	ctx     context.Context
+}
+
+func (m *memoryBroker) Options() Options {
+	return m.opts
+}
+
+func (m *memoryBroker) Address() string {
+	return m.addr
+}
+
+func (m *memoryBroker) Connect(ctx context.Context) error {
+	m.Lock()
+	defer m.Unlock()
+
+	if m.connected {
+		return nil
+	}
+
+	// use 127.0.0.1 to avoid scan of all network interfaces
+	addr, err := maddr.Extract("127.0.0.1")
+	if err != nil {
+		return err
+	}
+	i := rand.Intn(20000)
+	// set addr with port
+	addr = mnet.HostPort(addr, 10000+i)
+
+	m.addr = addr
+	m.connected = true
+
+	return nil
+}
+
+func (m *memoryBroker) Disconnect(ctx context.Context) error {
+	m.Lock()
+	defer m.Unlock()
+
+	if !m.connected {
+		return nil
+	}
+
+	m.connected = false
+
+	return nil
+}
+
+func (m *memoryBroker) Init(opts ...Option) error {
+	for _, o := range opts {
+		o(&m.opts)
+	}
+	return nil
+}
+
+func (m *memoryBroker) Publish(ctx context.Context, topic string, msg *Message, opts ...PublishOption) error {
+	m.RLock()
+	if !m.connected {
+		m.RUnlock()
+		return errors.New("not connected")
+	}
+
+	subs, ok := m.Subscribers[topic]
+	m.RUnlock()
+	if !ok {
+		return nil
+	}
+
+	var v interface{}
+	if m.opts.Codec != nil {
+		buf, err := m.opts.Codec.Marshal(msg)
+		if err != nil {
+			return err
+		}
+		v = buf
+	} else {
+		v = msg
+	}
+
+	p := &memoryEvent{
+		topic:   topic,
+		message: v,
+		opts:    m.opts,
+	}
+
+	eh := m.opts.ErrorHandler
+
+	for _, sub := range subs {
+		if err := sub.handler(p); err != nil {
+			p.err = err
+			if sub.opts.ErrorHandler != nil {
+				eh = sub.opts.ErrorHandler
+			}
+			if eh != nil {
+				eh(p)
+			} else {
+				if m.opts.Logger.V(logger.ErrorLevel) {
+					m.opts.Logger.Error(m.opts.Context, err.Error())
+				}
+			}
+			continue
+		}
+	}
+
+	return nil
+}
+
+func (m *memoryBroker) Subscribe(ctx context.Context, topic string, handler Handler, opts ...SubscribeOption) (Subscriber, error) {
+	m.RLock()
+	if !m.connected {
+		m.RUnlock()
+		return nil, errors.New("not connected")
+	}
+	m.RUnlock()
+
+	options := NewSubscribeOptions(opts...)
+
+	id, err := uuid.NewRandom()
+	if err != nil {
+		return nil, err
+	}
+
+	sub := &memorySubscriber{
+		exit:    make(chan bool, 1),
+		id:      id.String(),
+		topic:   topic,
+		handler: handler,
+		opts:    options,
+		ctx:     ctx,
+	}
+
+	m.Lock()
+	m.Subscribers[topic] = append(m.Subscribers[topic], sub)
+	m.Unlock()
+
+	go func() {
+		<-sub.exit
+		m.Lock()
+		var newSubscribers []*memorySubscriber
+		for _, sb := range m.Subscribers[topic] {
+			if sb.id == sub.id {
+				continue
+			}
+			newSubscribers = append(newSubscribers, sb)
+		}
+		m.Subscribers[topic] = newSubscribers
+		m.Unlock()
+	}()
+
+	return sub, nil
+}
+
+func (m *memoryBroker) String() string {
+	return "memory"
+}
+
+func (m *memoryBroker) Name() string {
+	return m.opts.Name
+}
+
+func (m *memoryEvent) Topic() string {
+	return m.topic
+}
+
+func (m *memoryEvent) Message() *Message {
+	switch v := m.message.(type) {
+	case *Message:
+		return v
+	case []byte:
+		msg := &Message{}
+		if err := m.opts.Codec.Unmarshal(v, msg); err != nil {
+			if m.opts.Logger.V(logger.ErrorLevel) {
+				m.opts.Logger.Error(m.opts.Context, "[memory]: failed to unmarshal: %v", err)
+			}
+			return nil
+		}
+		return msg
+	}
+
+	return nil
+}
+
+func (m *memoryEvent) Ack() error {
+	return nil
+}
+
+func (m *memoryEvent) Error() error {
+	return m.err
+}
+
+func (m *memorySubscriber) Options() SubscribeOptions {
+	return m.opts
+}
+
+func (m *memorySubscriber) Topic() string {
+	return m.topic
+}
+
+func (m *memorySubscriber) Unsubscribe(ctx context.Context) error {
+	m.exit <- true
+	return nil
+}
+
+func NewBroker(opts ...Option) Broker {
+	rand.Seed(time.Now().UnixNano())
+
+	return &memoryBroker{
+		opts:        NewOptions(opts...),
+		Subscribers: make(map[string][]*memorySubscriber),
+	}
+}

broker/memory_test.go

@@ -0,0 +1,50 @@
+package broker
+
+import (
+	"context"
+	"fmt"
+	"testing"
+)
+
+func TestMemoryBroker(t *testing.T) {
+	b := NewBroker()
+	ctx := context.Background()
+
+	if err := b.Connect(ctx); err != nil {
+		t.Fatalf("Unexpected connect error %v", err)
+	}
+
+	topic := "test"
+	count := 10
+
+	fn := func(p Event) error {
+		return nil
+	}
+
+	sub, err := b.Subscribe(ctx, topic, fn)
+	if err != nil {
+		t.Fatalf("Unexpected error subscribing %v", err)
+	}
+
+	for i := 0; i < count; i++ {
+		message := &Message{
+			Header: map[string]string{
+				"foo": "bar",
+				"id":  fmt.Sprintf("%d", i),
+			},
+			Body: []byte(`hello world`),
+		}
+
+		if err := b.Publish(ctx, topic, message); err != nil {
+			t.Fatalf("Unexpected error publishing %d", i)
+		}
+	}
+
+	if err := sub.Unsubscribe(ctx); err != nil {
+		t.Fatalf("Unexpected error unsubscribing from %s: %v", topic, err)
+	}
+
+	if err := b.Disconnect(ctx); err != nil {
+		t.Fatalf("Unexpected connect error %v", err)
+	}
+}

broker/noop.go

@@ -1,77 +0,0 @@
-package broker
-
-import "context"
-
-type noopBroker struct {
-	opts Options
-}
-
-type noopSubscriber struct {
-	topic string
-	opts  SubscribeOptions
-}
-
-// NewBroker returns new noop broker
-func NewBroker(opts ...Option) Broker {
-	return &noopBroker{opts: NewOptions(opts...)}
-}
-
-// Init initialize broker
-func (n *noopBroker) Init(opts ...Option) error {
-	for _, o := range opts {
-		o(&n.opts)
-	}
-
-	return nil
-}
-
-// Options returns broker Options
-func (n *noopBroker) Options() Options {
-	return n.opts
-}
-
-// Address returns broker address
-func (n *noopBroker) Address() string {
-	return ""
-}
-
-// Connect connects to broker
-func (n *noopBroker) Connect(ctx context.Context) error {
-	return nil
-}
-
-// Disconnect disconnects from broker
-func (n *noopBroker) Disconnect(ctx context.Context) error {
-	return nil
-}
-
-// Publish publishes message to broker
-func (n *noopBroker) Publish(ctx context.Context, topic string, m *Message, opts ...PublishOption) error {
-	return nil
-}
-
-// Subscribe subscribes to broker topic
-func (n *noopBroker) Subscribe(ctx context.Context, topic string, h Handler, opts ...SubscribeOption) (Subscriber, error) {
-	options := NewSubscribeOptions(opts...)
-	return &noopSubscriber{topic: topic, opts: options}, nil
-}
-
-// String return broker string representation
-func (n *noopBroker) String() string {
-	return "noop"
-}
-
-// Options returns subscriber options
-func (n *noopSubscriber) Options() SubscribeOptions {
-	return n.opts
-}
-
-// TOpic returns subscriber topic
-func (n *noopSubscriber) Topic() string {
-	return n.topic
-}
-
-// Unsubscribe unsbscribes from broker topic
-func (n *noopSubscriber) Unsubscribe(ctx context.Context) error {
-	return nil
-}

broker/options.go

@@ -6,36 +6,43 @@ import (
 
 	"github.com/unistack-org/micro/v3/codec"
 	"github.com/unistack-org/micro/v3/logger"
-	"github.com/unistack-org/micro/v3/registry"
+	"github.com/unistack-org/micro/v3/meter"
+	"github.com/unistack-org/micro/v3/register"
+	"github.com/unistack-org/micro/v3/tracer"
 )
 
 // Options struct
 type Options struct {
-	Addrs  []string
-	Secure bool
-
-	// Codec
-	Codec codec.Codec
-
-	// Logger the logger
-	Logger logger.Logger
-	// Handler executed when errors occur processing messages
+	Name string
+	// Addrs useed by broker
+	Addrs []string
+	// ErrorHandler executed when errors occur processing messages
 	ErrorHandler Handler
-
+	// Codec used to marshal/unmarshal messages
+	Codec codec.Codec
+	// Logger the used logger
+	Logger logger.Logger
+	// Meter the used for metrics
+	Meter meter.Meter
+	// Tracer used for trace
+	Tracer tracer.Tracer
+	// TLSConfig for secure communication
 	TLSConfig *tls.Config
-	// Registry used for clustering
-	Registry registry.Registry
-	// Other options for implementations of the interface
-	// can be stored in a context
+	// Register used for clustering
+	Register register.Register
+	// Context is used for non default options
 	Context context.Context
 }
 
 // NewOptions create new Options
 func NewOptions(opts ...Option) Options {
 	options := Options{
-		Registry: registry.DefaultRegistry,
+		Register: register.DefaultRegister,
 		Logger:   logger.DefaultLogger,
 		Context:  context.Background(),
+		Meter:    meter.DefaultMeter,
+		Codec:    codec.DefaultCodec,
+		Tracer:   tracer.DefaultTracer,
 	}
 	for _, o := range opts {
 		o(&options)
@@ -54,8 +61,7 @@ func Context(ctx context.Context) Option {
 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 for non default options
 	Context context.Context
 }
 
@@ -77,10 +83,10 @@ type SubscribeOptions struct {
 	// AutoAck ack messages if handler returns nil err
 	AutoAck bool
 
-	// Handler executed when errors occur processing messages
+	// ErrorHandler executed when errors occur processing messages
 	ErrorHandler Handler
 
-	// Subscribers with the same group name
+	// Group for subscriber, Subscribers with the same group name
 	// will create a shared subscription where each
 	// receives a subset of messages.
 	Group string
@@ -88,8 +94,7 @@ type SubscribeOptions struct {
 	// 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 is used for non default options
 	Context context.Context
 }
 
@@ -198,17 +203,10 @@ func SubscribeGroup(name string) SubscribeOption {
 	}
 }
 
-// Registry sets registry option
-func Registry(r registry.Registry) Option {
+// Register sets register option
+func Register(r register.Register) Option {
 	return func(o *Options) {
-		o.Registry = r
-	}
-}
-
-// Secure communication with the broker
-func Secure(b bool) Option {
-	return func(o *Options) {
-		o.Secure = b
+		o.Register = r
 	}
 }
 
@@ -226,6 +224,27 @@ func Logger(l logger.Logger) Option {
 	}
 }
 
+// Tracer to be used for tracing
+func Tracer(t tracer.Tracer) Option {
+	return func(o *Options) {
+		o.Tracer = t
+	}
+}
+
+// Meter sets the meter
+func Meter(m meter.Meter) Option {
+	return func(o *Options) {
+		o.Meter = m
+	}
+}
+
+// Name sets the name
+func Name(n string) Option {
+	return func(o *Options) {
+		o.Name = n
+	}
+}
+
 // SubscribeContext set context
 func SubscribeContext(ctx context.Context) SubscribeOption {
 	return func(o *SubscribeOptions) {

client/client.go

@@ -18,6 +18,7 @@ var (
 // It supports Request/Response via Transport and Publishing via the Broker.
 // It also supports bidirectional streaming of requests.
 type Client interface {
+	Name() string
 	Init(...Option) error
 	Options() Options
 	NewMessage(topic string, msg interface{}, opts ...MessageOption) Message

client/noop.go

@@ -46,7 +46,20 @@ type noopRequest struct {
 
 // NewClient returns new noop client
 func NewClient(opts ...Option) Client {
-	return &noopClient{opts: NewOptions(opts...)}
+	nc := &noopClient{opts: NewOptions(opts...)}
+	// wrap in reverse
+
+	c := Client(nc)
+
+	for i := len(nc.opts.Wrappers); i > 0; i-- {
+		c = nc.opts.Wrappers[i-1](c)
+	}
+
+	return c
+}
+
+func (n *noopClient) Name() string {
+	return n.opts.Name
 }
 
 func (n *noopRequest) Service() string {
@@ -183,7 +196,7 @@ func (n *noopClient) Publish(ctx context.Context, p Message, opts ...PublishOpti
 
 	options := NewPublishOptions(opts...)
 
-	md, ok := metadata.FromContext(ctx)
+	md, ok := metadata.FromOutgoingContext(ctx)
 	if !ok {
 		md = metadata.New(0)
 	}

client/options.go

@@ -7,15 +7,18 @@ import (
 	"github.com/unistack-org/micro/v3/broker"
 	"github.com/unistack-org/micro/v3/codec"
 	"github.com/unistack-org/micro/v3/logger"
+	"github.com/unistack-org/micro/v3/meter"
 	"github.com/unistack-org/micro/v3/network/transport"
-	"github.com/unistack-org/micro/v3/registry"
+	"github.com/unistack-org/micro/v3/register"
 	"github.com/unistack-org/micro/v3/router"
 	"github.com/unistack-org/micro/v3/selector"
 	"github.com/unistack-org/micro/v3/selector/random"
+	"github.com/unistack-org/micro/v3/tracer"
 )
 
 // Options holds client options
 type Options struct {
+	Name string
 	// Used to select codec
 	ContentType string
 	// Proxy address to send requests via
@@ -28,21 +31,21 @@ type Options struct {
 	Selector  selector.Selector
 	Transport transport.Transport
 	Logger    logger.Logger
+	Meter     meter.Meter
 	// Lookup used for looking up routes
 	Lookup LookupFunc
 
 	// Connection Pool
 	PoolSize int
 	PoolTTL  time.Duration
-
-	// Middleware for client
+	Tracer   tracer.Tracer
+	// Wrapper that used client
 	Wrappers []Wrapper
 
-	// Default Call Options
+	// CallOptions that used by default
 	CallOptions CallOptions
 
-	// Other options for implementations of the interface
-	// can be stored in a context
+	// Context is used for non default options
 	Context context.Context
 }
 
@@ -81,12 +84,9 @@ type CallOptions struct {
 	AuthToken bool
 	// Network to lookup the route within
 	Network string
-
 	// Middleware for low level call func
 	CallWrappers []CallWrapper
-
-	// Other options for implementations of the interface
-	// can be stored in a context
+	// Context is uded for non default options
 	Context context.Context
 }
 
@@ -142,7 +142,6 @@ func NewRequestOptions(opts ...RequestOption) RequestOptions {
 type RequestOptions struct {
 	ContentType string
 	Stream      bool
-
 	// Other options for implementations of the interface
 	// can be stored in a context
 	Context context.Context
@@ -167,6 +166,8 @@ func NewOptions(opts ...Option) Options {
 		Selector: random.NewSelector(),
 		Logger:   logger.DefaultLogger,
 		Broker:   broker.DefaultBroker,
+		Meter:    meter.DefaultMeter,
+		Tracer:   tracer.DefaultTracer,
 	}
 
 	for _, o := range opts {
@@ -183,6 +184,13 @@ func Broker(b broker.Broker) Option {
 	}
 }
 
+// Tracer to be used for tracing
+func Tracer(t tracer.Tracer) Option {
+	return func(o *Options) {
+		o.Tracer = t
+	}
+}
+
 // Logger to be used for log mesages
 func Logger(l logger.Logger) Option {
 	return func(o *Options) {
@@ -190,6 +198,13 @@ func Logger(l logger.Logger) Option {
 	}
 }
 
+// Meter to be used for metrics
+func Meter(m meter.Meter) Option {
+	return func(o *Options) {
+		o.Meter = m
+	}
+}
+
 // Codec to be used to encode/decode requests for a given content type
 func Codec(contentType string, c codec.Codec) Option {
 	return func(o *Options) {
@@ -232,11 +247,11 @@ func Transport(t transport.Transport) Option {
 	}
 }
 
-// Registry sets the routers registry
-func Registry(r registry.Registry) Option {
+// Register sets the routers register
+func Register(r register.Register) Option {
 	return func(o *Options) {
 		if o.Router != nil {
-			o.Router.Init(router.Registry(r))
+			o.Router.Init(router.Register(r))
 		}
 	}
 }
@@ -277,6 +292,13 @@ func Backoff(fn BackoffFunc) Option {
 	}
 }
 
+// Name sets the client name
+func Name(n string) Option {
+	return func(o *Options) {
+		o.Name = n
+	}
+}
+
 // Lookup sets the lookup function to use for resolving service names
 func Lookup(l LookupFunc) Option {
 	return func(o *Options) {

codec/codec.go

@@ -25,7 +25,7 @@ var (
 
 var (
 	// DefaultMaxMsgSize specifies how much data codec can handle
-	DefaultMaxMsgSize       = 1024 * 1024 * 4 // 4Mb
+	DefaultMaxMsgSize int   = 1024 * 1024 * 4 // 4Mb
 	DefaultCodec      Codec = NewCodec()
 )
 
@@ -62,21 +62,6 @@ type Message struct {
 	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

@@ -1,6 +1,7 @@
 package codec
 
 import (
+	"encoding/json"
 	"io"
 	"io/ioutil"
 )
@@ -40,7 +41,7 @@ func (c *noopCodec) ReadBody(conn io.Reader, b interface{}) error {
 	case *Frame:
 		v.Data = buf
 	default:
-		return ErrInvalidMessage
+		return json.Unmarshal(buf, v)
 	}
 
 	return nil
@@ -64,7 +65,11 @@ func (c *noopCodec) Write(conn io.Writer, m *Message, b interface{}) error {
 	case []byte:
 		v = vb
 	default:
-		return ErrInvalidMessage
+		var err error
+		v, err = json.Marshal(vb)
+		if err != nil {
+			return err
+		}
 	}
 	_, err := conn.Write(v)
 	return err
@@ -98,30 +103,34 @@ func (c *noopCodec) Marshal(v interface{}) ([]byte, error) {
 	case *Message:
 		return ve.Body, nil
 	}
-	return nil, ErrInvalidMessage
+
+	return json.Marshal(v)
 }
 
 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)
+		return nil
 	case *string:
 		*ve = string(d)
+		return nil
 	case []byte:
 		ve = d
+		return nil
 	case *[]byte:
 		*ve = d
+		return nil
 	case *Frame:
 		ve.Data = d
+		return nil
 	case *Message:
 		ve.Body = d
-	default:
-		err = ErrInvalidMessage
+		return nil
 	}
 
-	return err
+	return json.Unmarshal(d, v)
 }

codec/options.go

@@ -0,0 +1,61 @@
+package codec
+
+import (
+	"github.com/unistack-org/micro/v3/logger"
+	"github.com/unistack-org/micro/v3/meter"
+	"github.com/unistack-org/micro/v3/tracer"
+)
+
+// Option func
+type Option func(*Options)
+
+// Options contains codec options
+type Options struct {
+	MaxMsgSize int
+	Meter      meter.Meter
+	Logger     logger.Logger
+	Tracer     tracer.Tracer
+}
+
+// MaxMsgSize sets the max message size
+func MaxMsgSize(n int) Option {
+	return func(o *Options) {
+		o.MaxMsgSize = n
+	}
+}
+
+// Logger sets the logger
+func Logger(l logger.Logger) Option {
+	return func(o *Options) {
+		o.Logger = l
+	}
+}
+
+// Tracer to be used for tracing
+func Tracer(t tracer.Tracer) Option {
+	return func(o *Options) {
+		o.Tracer = t
+	}
+}
+
+// Meter sets the meter
+func Meter(m meter.Meter) Option {
+	return func(o *Options) {
+		o.Meter = m
+	}
+}
+
+func NewOptions(opts ...Option) Options {
+	options := Options{
+		Logger:     logger.DefaultLogger,
+		Meter:      meter.DefaultMeter,
+		Tracer:     tracer.DefaultTracer,
+		MaxMsgSize: DefaultMaxMsgSize,
+	}
+
+	for _, o := range opts {
+		o(&options)
+	}
+
+	return options
+}

config/config.go

@@ -22,6 +22,7 @@ var (
 
 // Config is an interface abstraction for dynamic configuration
 type Config interface {
+	Name() string
 	// Init the config
 	Init(opts ...Option) error
 	// Options in the config

config/default.go

@@ -6,6 +6,7 @@ import (
 	"strconv"
 	"strings"
 
+	"github.com/imdario/mergo"
 	rutil "github.com/unistack-org/micro/v3/util/reflect"
 )
 
@@ -31,9 +32,15 @@ func (c *defaultConfig) Load(ctx context.Context) error {
 		}
 	}
 
-	valueOf := reflect.ValueOf(c.opts.Struct)
+	src, err := rutil.Zero(c.opts.Struct)
+	if err == nil {
+		valueOf := reflect.ValueOf(src)
+		if err = c.fillValues(ctx, valueOf); err == nil {
+			err = mergo.Merge(c.opts.Struct, src, mergo.WithOverride, mergo.WithTypeCheck, mergo.WithAppendSlice)
+		}
+	}
 
-	if err := c.fillValues(ctx, valueOf); err != nil && !c.opts.AllowFail {
+	if err != nil && !c.opts.AllowFail {
 		return err
 	}
 
@@ -244,6 +251,10 @@ func (c *defaultConfig) String() string {
 	return "default"
 }
 
+func (c *defaultConfig) Name() string {
+	return c.opts.Name
+}
+
 func NewConfig(opts ...Option) Config {
 	options := NewOptions(opts...)
 	if len(options.StructTag) == 0 {

config/options.go

@@ -5,9 +5,12 @@ import (
 
 	"github.com/unistack-org/micro/v3/codec"
 	"github.com/unistack-org/micro/v3/logger"
+	"github.com/unistack-org/micro/v3/meter"
+	"github.com/unistack-org/micro/v3/tracer"
 )
 
 type Options struct {
+	Name       string
 	AllowFail  bool
 	BeforeLoad []func(context.Context, Config) error
 	AfterLoad  []func(context.Context, Config) error
@@ -15,13 +18,17 @@ type Options struct {
 	AfterSave  []func(context.Context, Config) error
 	// Struct that holds config data
 	Struct interface{}
-	// struct tag name
+	// StructTag name
 	StructTag string
-	// logger that will be used
+	// Logger that will be used
 	Logger logger.Logger
-	// codec that used for load/save
+	// Meter that will be used
+	Meter meter.Meter
+	// Tracer used for trace
+	Tracer tracer.Tracer
+	// Codec that used for load/save
 	Codec codec.Codec
-	// for alternative data
+	// Context for alternative data
 	Context context.Context
 }
 
@@ -30,6 +37,8 @@ type Option func(o *Options)
 func NewOptions(opts ...Option) Options {
 	options := Options{
 		Logger:  logger.DefaultLogger,
+		Meter:   meter.DefaultMeter,
+		Tracer:  tracer.DefaultTracer,
 		Context: context.Background(),
 	}
 	for _, o := range opts {
@@ -88,6 +97,13 @@ func Logger(l logger.Logger) Option {
 	}
 }
 
+// Tracer to be used for tracing
+func Tracer(t tracer.Tracer) Option {
+	return func(o *Options) {
+		o.Tracer = t
+	}
+}
+
 // Struct used as config
 func Struct(v interface{}) Option {
 	return func(o *Options) {
@@ -101,3 +117,10 @@ func StructTag(name string) Option {
 		o.StructTag = name
 	}
 }
+
+// Name sets the name
+func Name(n string) Option {
+	return func(o *Options) {
+		o.Name = n
+	}
+}

context.go

@@ -0,0 +1,22 @@
+package micro
+
+import "context"
+
+type serviceKey struct{}
+
+// 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)
+}

event.go

@@ -6,11 +6,22 @@ import (
 	"github.com/unistack-org/micro/v3/client"
 )
 
+// Event is used to publish messages to a topic
+type Event interface {
+	// Publish publishes a message to the event topic
+	Publish(ctx context.Context, msg interface{}, opts ...client.PublishOption) error
+}
+
 type event struct {
 	c     client.Client
 	topic string
 }
 
+// NewEvent creates a new event publisher
+func NewEvent(topic string, c client.Client) Event {
+	return &event{c, topic}
+}
+
 func (e *event) Publish(ctx context.Context, msg interface{}, opts ...client.PublishOption) error {
 	return e.c.Publish(ctx, e.c.NewMessage(e.topic, msg), opts...)
 }

events/events.go

@@ -1,49 +0,0 @@
-// Package events contains interfaces for managing events within distributed systems
-package events
-
-import (
-	"context"
-	"encoding/json"
-	"errors"
-	"time"
-
-	"github.com/unistack-org/micro/v3/metadata"
-)
-
-var (
-	// ErrMissingTopic is returned if a blank topic was provided to publish
-	ErrMissingTopic = errors.New("Missing topic")
-	// ErrEncodingMessage is returned from publish if there was an error encoding the message option
-	ErrEncodingMessage = errors.New("Error encoding message")
-)
-
-// Stream of events
-type Stream interface {
-	Publish(ctx context.Context, topic string, msg interface{}, opts ...PublishOption) error
-	Subscribe(ctx context.Context, topic string, opts ...SubscribeOption) (<-chan Event, error)
-}
-
-// Store of events
-type Store interface {
-	Read(ctx context.Context, opts ...ReadOption) ([]*Event, error)
-	Write(ctx context.Context, event *Event, opts ...WriteOption) error
-}
-
-// Event is the object returned by the broker when you subscribe to a topic
-type Event struct {
-	// ID to uniquely identify the event
-	ID string
-	// Topic of event, e.g. "registry.service.created"
-	Topic string
-	// Timestamp of the event
-	Timestamp time.Time
-	// Metadata contains the encoded event was indexed by
-	Metadata metadata.Metadata
-	// Payload contains the encoded message
-	Payload []byte
-}
-
-// Unmarshal the events message into an object
-func (e *Event) Unmarshal(v interface{}) error {
-	return json.Unmarshal(e.Payload, v)
-}

events/options.go

@@ -1,124 +0,0 @@
-package events
-
-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 metadata.Metadata
-	// Timestamp to set for the event, if the timestamp is a zero value, the current time will be used
-	Timestamp time.Time
-}
-
-// PublishOption sets attributes on PublishOptions
-type PublishOption func(o *PublishOptions)
-
-// WithMetadata sets the Metadata field on PublishOptions
-func WithMetadata(md metadata.Metadata) PublishOption {
-	return func(o *PublishOptions) {
-		o.Metadata = metadata.Copy(md)
-	}
-}
-
-// WithTimestamp sets the timestamp field on PublishOptions
-func WithTimestamp(t time.Time) PublishOption {
-	return func(o *PublishOptions) {
-		o.Timestamp = t
-	}
-}
-
-// SubscribeOptions contains all the options which can be provided when subscribing to a topic
-type SubscribeOptions struct {
-	// Queue is the name of the subscribers queue, if two subscribers have the same queue the message
-	// should only be published to one of them
-	Queue string
-	// StartAtTime is the time from which the messages should be consumed from. If not provided then
-	// the messages will be consumed starting from the moment the Subscription starts.
-	StartAtTime time.Time
-}
-
-// SubscribeOption sets attributes on SubscribeOptions
-type SubscribeOption func(o *SubscribeOptions)
-
-// WithQueue sets the Queue fielf on SubscribeOptions to the value provided
-func WithQueue(q string) SubscribeOption {
-	return func(o *SubscribeOptions) {
-		o.Queue = q
-	}
-}
-
-// WithStartAtTime sets the StartAtTime field on SubscribeOptions to the value provided
-func WithStartAtTime(t time.Time) SubscribeOption {
-	return func(o *SubscribeOptions) {
-		o.StartAtTime = t
-	}
-}
-
-// WriteOptions contains all the options which can be provided when writing an event to a store
-type WriteOptions struct {
-	// TTL is the duration the event should be recorded for, a zero value TTL indicates the event should
-	// be stored indefinitely
-	TTL time.Duration
-}
-
-// WriteOption sets attributes on WriteOptions
-type WriteOption func(o *WriteOptions)
-
-// WithTTL sets the TTL attribute on WriteOptions
-func WithTTL(d time.Duration) WriteOption {
-	return func(o *WriteOptions) {
-		o.TTL = d
-	}
-}
-
-// ReadOptions contains all the options which can be provided when reading events from a store
-type ReadOptions struct {
-	// Topic to read events from, if no topic is provided events from all topics will be returned
-	Topic string
-	// Query to filter the results using. The store will query the metadata provided when the event
-	// was written to the store
-	Query map[string]string
-	// Limit the number of results to return
-	Limit int
-	// Offset the results by this number, useful for paginated queries
-	Offset int
-}
-
-// ReadOption sets attributes on ReadOptions
-type ReadOption func(o *ReadOptions)
-
-// ReadTopic sets the topic attribute on ReadOptions
-func ReadTopic(t string) ReadOption {
-	return func(o *ReadOptions) {
-		o.Topic = t
-	}
-}
-
-// ReadFilter sets a key and value in the query
-func ReadFilter(key, value string) ReadOption {
-	return func(o *ReadOptions) {
-		if o.Query == nil {
-			o.Query = map[string]string{key: value}
-		} else {
-			o.Query[key] = value
-		}
-	}
-}
-
-// ReadLimit sets the limit attribute on ReadOptions
-func ReadLimit(l int) ReadOption {
-	return func(o *ReadOptions) {
-		o.Limit = 1
-	}
-}
-
-// ReadOffset sets the offset attribute on ReadOptions
-func ReadOffset(l int) ReadOption {
-	return func(o *ReadOptions) {
-		o.Offset = 1
-	}
-}

function.go

@@ -1,3 +1,5 @@
+// +build ignore
+
 package micro
 
 import (
@@ -7,11 +9,28 @@ import (
 	"github.com/unistack-org/micro/v3/server"
 )
 
+// Function is a one time executing Service
+type Function interface {
+	// Inherits Service interface
+	Service
+	// Done signals to complete execution
+	Done() error
+	// Handle registers an RPC handler
+	Handle(v interface{}) error
+	// Subscribe registers a subscriber
+	Subscribe(topic string, v interface{}) error
+}
+
 type function struct {
 	cancel context.CancelFunc
 	Service
 }
 
+// NewFunction returns a new Function for a one time executing Service
+func NewFunction(opts ...Option) Function {
+	return newFunction(opts...)
+}
+
 func fnHandlerWrapper(f Function) server.HandlerWrapper {
 	return func(h server.HandlerFunc) server.HandlerFunc {
 		return func(ctx context.Context, req server.Request, rsp interface{}) error {
@@ -45,7 +64,7 @@ func newFunction(opts ...Option) Function {
 	// make context the last thing
 	fopts = append(fopts, Context(ctx))
 
-	service := newService(fopts...)
+	service := &service{opts: NewOptions(opts...)}
 
 	fn := &function{
 		cancel:  cancel,

function_test.go

@@ -7,18 +7,18 @@ import (
 	"sync"
 	"testing"
 
-	rmemory "github.com/unistack-org/micro-registry-memory"
+	rmemory "github.com/unistack-org/micro-register-memory"
 )
 
 func TestFunction(t *testing.T) {
 	var wg sync.WaitGroup
 	wg.Add(1)
 
-	r := rmemory.NewRegistry()
+	r := rmemory.NewRegister()
 
 	// create service
 	fn := NewFunction(
-		Registry(r),
+		Register(r),
 		Name("test.function"),
 		AfterStart(func() error {
 			wg.Done()

go.mod

@@ -3,19 +3,21 @@ module github.com/unistack-org/micro/v3
 go 1.14
 
 require (
-	github.com/caddyserver/certmagic v0.12.0
+	github.com/davecgh/go-spew v1.1.1 // indirect
 	github.com/dgrijalva/jwt-go v3.2.0+incompatible
 	github.com/ef-ds/deque v1.0.4
-	github.com/go-acme/lego/v3 v3.9.0
 	github.com/golang/protobuf v1.4.3
-	github.com/google/uuid v1.1.5
+	github.com/google/uuid v1.2.0
+	github.com/imdario/mergo v0.3.11
 	github.com/kr/text v0.2.0 // indirect
-	github.com/miekg/dns v1.1.35
+	github.com/miekg/dns v1.1.38
 	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.7.0
-	golang.org/x/crypto v0.0.0-20201221181555-eec23a3978ad
-	golang.org/x/net v0.0.0-20201224014010-6772e930b67b
+	golang.org/x/crypto v0.0.0-20201221181555-eec23a3978ad // indirect
+	golang.org/x/net v0.0.0-20210119194325-5f4716e94777
+	golang.org/x/sync v0.0.0-20190911185100-cd5d95a43a6e // indirect
 	google.golang.org/protobuf v1.25.0
 	gopkg.in/check.v1 v1.0.0-20200227125254-8fa46927fb4f // indirect
 )

go.sum

@@ -1,120 +1,22 @@
 cloud.google.com/go v0.26.0/go.mod h1:aQUYkXzVsufM+DwF1aE+0xfcU+56JwCaLick0ClmMTw=
-cloud.google.com/go v0.34.0/go.mod h1:aQUYkXzVsufM+DwF1aE+0xfcU+56JwCaLick0ClmMTw=
-cloud.google.com/go v0.38.0/go.mod h1:990N+gfupTy94rShfmMCWGDn0LpTmnzTp2qbd1dvSRU=
-cloud.google.com/go v0.44.1/go.mod h1:iSa0KzasP4Uvy3f1mN/7PiObzGgflwredwwASm/v6AU=
-cloud.google.com/go v0.44.2/go.mod h1:60680Gw3Yr4ikxnPRS/oxxkBccT6SA1yMk63TGekxKY=
-cloud.google.com/go v0.45.1/go.mod h1:RpBamKRgapWJb87xiFSdk4g1CME7QZg3uwTez+TSTjc=
-cloud.google.com/go v0.46.3/go.mod h1:a6bKKbmY7er1mI7TEI4lsAkts/mkhTSZK8w33B4RAg0=
-cloud.google.com/go v0.50.0/go.mod h1:r9sluTvynVuxRIOHXQEHMFffphuXHOMZMycpNR5e6To=
-cloud.google.com/go v0.52.0/go.mod h1:pXajvRH/6o3+F9jDHZWQ5PbGhn+o8w9qiu/CffaVdO4=
-cloud.google.com/go v0.53.0/go.mod h1:fp/UouUEsRkN6ryDKNW/Upv/JBKnv6WDthjR6+vze6M=
-cloud.google.com/go v0.54.0/go.mod h1:1rq2OEkV3YMf6n/9ZvGWI3GWw0VoqH/1x2nd8Is/bPc=
-cloud.google.com/go/bigquery v1.0.1/go.mod h1:i/xbL2UlR5RvWAURpBYZTtm/cXjCha9lbfbpx4poX+o=
-cloud.google.com/go/bigquery v1.3.0/go.mod h1:PjpwJnslEMmckchkHFfq+HTD2DmtT67aNFKH1/VBDHE=
-cloud.google.com/go/bigquery v1.4.0/go.mod h1:S8dzgnTigyfTmLBfrtrhyYhwRxG72rYxvftPBK2Dvzc=
-cloud.google.com/go/datastore v1.0.0/go.mod h1:LXYbyblFSglQ5pkeyhO+Qmw7ukd3C+pD7TKLgZqpHYE=
-cloud.google.com/go/datastore v1.1.0/go.mod h1:umbIZjpQpHh4hmRpGhH4tLFup+FVzqBi1b3c64qFpCk=
-cloud.google.com/go/pubsub v1.0.1/go.mod h1:R0Gpsv3s54REJCy4fxDixWD93lHJMoZTyQ2kNxGRt3I=
-cloud.google.com/go/pubsub v1.1.0/go.mod h1:EwwdRX2sKPjnvnqCa270oGRyludottCI76h+R3AArQw=
-cloud.google.com/go/pubsub v1.2.0/go.mod h1:jhfEVHT8odbXTkndysNHCcx0awwzvfOlguIAii9o8iA=
-cloud.google.com/go/storage v1.0.0/go.mod h1:IhtSnM/ZTZV8YYJWCY8RULGVqBDmpoyjwiyrjsg+URw=
-cloud.google.com/go/storage v1.5.0/go.mod h1:tpKbwo567HUNpVclU5sGELwQWBDZ8gh0ZeosJ0Rtdos=
-cloud.google.com/go/storage v1.6.0/go.mod h1:N7U0C8pVQ/+NIKOBQyamJIeKQKkZ+mxpohlUTyfDhBk=
-contrib.go.opencensus.io/exporter/ocagent v0.4.12/go.mod h1:450APlNTSR6FrvC3CTRqYosuDstRB9un7SOx2k/9ckA=
-dmitri.shuralyov.com/gpu/mtl v0.0.0-20190408044501-666a987793e9/go.mod h1:H6x//7gZCb22OMCxBHrMx7a5I7Hp++hsVxbQ4BYO7hU=
-github.com/Azure/azure-sdk-for-go v32.4.0+incompatible/go.mod h1:9XXNKU+eRnpl9moKnB4QOLf1HestfXbmab5FXxiDBjc=
-github.com/Azure/go-autorest/autorest v0.1.0/go.mod h1:AKyIcETwSUFxIcs/Wnq/C+kwCtlEYGUVd7FPNb2slmg=
-github.com/Azure/go-autorest/autorest v0.5.0/go.mod h1:9HLKlQjVBH6U3oDfsXOeVc56THsLPw1L03yban4xThw=
-github.com/Azure/go-autorest/autorest/adal v0.1.0/go.mod h1:MeS4XhScH55IST095THyTxElntu7WqB7pNbZo8Q5G3E=
-github.com/Azure/go-autorest/autorest/adal v0.2.0/go.mod h1:MeS4XhScH55IST095THyTxElntu7WqB7pNbZo8Q5G3E=
-github.com/Azure/go-autorest/autorest/azure/auth v0.1.0/go.mod h1:Gf7/i2FUpyb/sGBLIFxTBzrNzBo7aPXXE3ZVeDRwdpM=
-github.com/Azure/go-autorest/autorest/azure/cli v0.1.0/go.mod h1:Dk8CUAt/b/PzkfeRsWzVG9Yj3ps8mS8ECztu43rdU8U=
-github.com/Azure/go-autorest/autorest/date v0.1.0/go.mod h1:plvfp3oPSKwf2DNjlBjWF/7vwR+cUD/ELuzDCXwHUVA=
-github.com/Azure/go-autorest/autorest/mocks v0.1.0/go.mod h1:OTyCOPRA2IgIlWxVYxBee2F5Gr4kF2zd2J5cFRaIDN0=
-github.com/Azure/go-autorest/autorest/to v0.2.0/go.mod h1:GunWKJp1AEqgMaGLV+iocmRAJWqST1wQYhyyjXJ3SJc=
-github.com/Azure/go-autorest/autorest/validation v0.1.0/go.mod h1:Ha3z/SqBeaalWQvokg3NZAlQTalVMtOIAs1aGK7G6u8=
-github.com/Azure/go-autorest/logger v0.1.0/go.mod h1:oExouG+K6PryycPJfVSxi/koC6LSNgds39diKLz7Vrc=
-github.com/Azure/go-autorest/tracing v0.1.0/go.mod h1:ROEEAFwXycQw7Sn3DXNtEedEvdeRAgDr0izn4z5Ij88=
 github.com/BurntSushi/toml v0.3.1 h1:WXkYYl6Yr3qBf1K79EBnL4mak0OimBfB0XUf9Vl28OQ=
 github.com/BurntSushi/toml v0.3.1/go.mod h1:xHWCNGjB5oqiDr8zfno3MHue2Ht5sIBksp03qcyfWMU=
-github.com/BurntSushi/xgb v0.0.0-20160522181843-27f122750802/go.mod h1:IVnqGOEym/WlBOVXweHU+Q+/VP0lqqI8lqeDx9IjBqo=
-github.com/OpenDNS/vegadns2client v0.0.0-20180418235048-a3fa4a771d87/go.mod h1:iGLljf5n9GjT6kc0HBvyI1nOKnGQbNB66VzSNbK5iks=
-github.com/Shopify/sarama v1.19.0/go.mod h1:FVkBWblsNy7DGZRfXLU0O9RCGt5g3g3yEuWXgklEdEo=
-github.com/Shopify/toxiproxy v2.1.4+incompatible/go.mod h1:OXgGpZ6Cli1/URJOF1DMxUHB2q5Ap20/P/eIdh4G0pI=
-github.com/akamai/AkamaiOPEN-edgegrid-golang v0.9.18/go.mod h1:L+HB2uBoDgi3+r1pJEJcbGwyyHhd2QXaGsKLbDwtm8Q=
-github.com/alecthomas/template v0.0.0-20160405071501-a0175ee3bccc/go.mod h1:LOuyumcjzFXgccqObfd/Ljyb9UuFJ6TxHnclSeseNhc=
-github.com/alecthomas/units v0.0.0-20151022065526-2efee857e7cf/go.mod h1:ybxpYRFXyAe+OPACYpWeL0wqObRcbAqCMya13uyzqw0=
-github.com/aliyun/alibaba-cloud-sdk-go v1.61.112/go.mod h1:pUKYbK5JQ+1Dfxk80P0qxGqe5dkxDoabbZS7zOcouyA=
-github.com/apache/thrift v0.12.0/go.mod h1:cp2SuWMxlEZw2r+iP2GNCdIi4C1qmUzdZFSVb+bacwQ=
-github.com/aws/aws-sdk-go v1.30.20/go.mod h1:5zCpMtNQVjRREroY7sYe8lOMRSxkhG6MZveU8YkpAk0=
-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/go.mod h1:G2ZrVWU2WbWT9wwq4/hrbKbnv/1ERSJQ0ibhJ6rlkpw=
-github.com/boombuler/barcode v1.0.1-0.20190219062509-6c824513bacc/go.mod h1:paBWMcWSl3LHKBqUq+rly7CNSldXjb2rDl3JlRe0mD8=
-github.com/caddyserver/certmagic v0.12.0 h1:1f7kxykaJkOVVpXJ8ZrC6RAO5F6+kKm9U7dBFbLNeug=
-github.com/caddyserver/certmagic v0.12.0/go.mod h1:tr26xh+9fY5dN0J6IPAlMj07qpog22PJKa7Nw7j835U=
-github.com/cenkalti/backoff/v4 v4.0.0 h1:6VeaLF9aI+MAUQ95106HwWzYZgJJpZ4stumjj6RFYAU=
-github.com/cenkalti/backoff/v4 v4.0.0/go.mod h1:eEew/i+1Q6OrCDZh3WiXYv3+nJwBASZ8Bog/87DQnVg=
-github.com/census-instrumentation/opencensus-proto v0.2.0/go.mod h1:f6KPmirojxKA12rnyqOA5BBL4O983OfeGPqjHWSTneU=
 github.com/census-instrumentation/opencensus-proto v0.2.1/go.mod h1:f6KPmirojxKA12rnyqOA5BBL4O983OfeGPqjHWSTneU=
-github.com/chzyer/logex v1.1.10/go.mod h1:+Ywpsq7O8HXn0nuIou7OrIPyXbp3wmkHB+jjWRnGsAI=
-github.com/chzyer/readline v0.0.0-20180603132655-2972be24d48e/go.mod h1:nSuG5e5PlCu98SY8svDHJxuZscDgtXS6KTTbou5AhLI=
-github.com/chzyer/test v0.0.0-20180213035817-a1ea475d72b1/go.mod h1:Q3SI9o4m/ZMnBNeIyt5eFwwo7qiLfzFZmjNmxjkiQlU=
 github.com/client9/misspell v0.3.4/go.mod h1:qj6jICC3Q7zFZvVWo7KLAzC3yx5G7kyvSDkc90ppPyw=
-github.com/cloudflare/cloudflare-go v0.10.2/go.mod h1:qhVI5MKwBGhdNU89ZRz2plgYutcJ5PCekLxXn56w6SY=
-github.com/cpu/goacmedns v0.0.2/go.mod h1:4MipLkI+qScwqtVxcNO6okBhbgRrr7/tKXUSgSL0teQ=
-github.com/cpuguy83/go-md2man/v2 v2.0.0-20190314233015-f79a8a8ca69d/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=
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/dgrijalva/jwt-go v3.2.0+incompatible h1:7qlOGliEKZXTDg6OTjfoBKDXWrumCAMpl/TFQ4/5kLM=
 github.com/dgrijalva/jwt-go v3.2.0+incompatible/go.mod h1:E3ru+11k8xSBh+hMPgOLZmtrrCbhqsmaPHjLKYnJCaQ=
-github.com/dimchansky/utfbom v1.1.0/go.mod h1:rO41eb7gLfo8SF1jd9F8HplJm1Fewwi4mQvIirEdv+8=
-github.com/dnaeon/go-vcr v0.0.0-20180814043457-aafff18a5cc2/go.mod h1:aBB1+wY4s93YsC3HHjMBMrwTj2R9FHDzUr9KyGc8n1E=
-github.com/dnsimple/dnsimple-go v0.60.0/go.mod h1:O5TJ0/U6r7AfT8niYNlmohpLbCSG+c71tQlGr9SeGrg=
-github.com/eapache/go-resiliency v1.1.0/go.mod h1:kFI+JgMyC7bLPUVY133qvEBtVayf5mFgVsvEsIPBvNs=
-github.com/eapache/go-xerial-snappy v0.0.0-20180814174437-776d5712da21/go.mod h1:+020luEh2TKB4/GOp8oxxtq0Daoen/Cii55CzbTV6DU=
-github.com/eapache/queue v1.1.0/go.mod h1:6eCeP0CKFpHLu8blIFXhExK/dRa7WDZfr6jVFPTqq+I=
 github.com/ef-ds/deque v1.0.4 h1:iFAZNmveMT9WERAkqLJ+oaABF9AcVQ5AjXem/hroniI=
 github.com/ef-ds/deque v1.0.4/go.mod h1:gXDnTC3yqvBcHbq2lcExjtAcVrOnJCbMcZXmuj8Z4tg=
 github.com/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/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/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=
-github.com/go-acme/lego/v3 v3.9.0 h1:Kyvg2GGqRJHfK2Stu57M45TDTx0y1bsxLH7lpeP3n0A=
-github.com/go-acme/lego/v3 v3.9.0/go.mod h1:va0cvQpxpJ3u2OA534L8TDn+lsr2oujLzPckLOLnUGQ=
-github.com/go-cmd/cmd v1.0.5/go.mod h1:y8q8qlK5wQibcw63djSl/ntiHUHXHGdCkPk0j4QeW4s=
-github.com/go-errors/errors v1.0.1/go.mod h1:f4zRHt4oKfwPJE5k8C9vpYG+aDHdBFUsgrm6/TyX73Q=
-github.com/go-gl/glfw v0.0.0-20190409004039-e6da0acd62b1/go.mod h1:vR7hzQXu2zJy9AVAgeJqvqgH9Q5CA+iKCZ2gyEVpxRU=
-github.com/go-gl/glfw/v3.3/glfw v0.0.0-20191125211704-12ad95a8df72/go.mod h1:tQ2UAYgL5IevRw8kRxooKSPJfGvJ9fJQFa0TUsXzTg8=
-github.com/go-gl/glfw/v3.3/glfw v0.0.0-20200222043503-6f7a984d4dc4/go.mod h1:tQ2UAYgL5IevRw8kRxooKSPJfGvJ9fJQFa0TUsXzTg8=
-github.com/go-kit/kit v0.8.0/go.mod h1:xBxKIO96dXMWWy0MnWVtmwkA9/13aqxPnvrjFYMA2as=
-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-sql-driver/mysql v1.5.0/go.mod h1:DCzpHaOWr8IXmIStZouvnhqoel9Qv2LBy8hT2VhHyBg=
-github.com/go-stack/stack v1.8.0/go.mod h1:v0f6uXyyMGvRgIKkXu+yp6POWl0qKG85gN/melR3HDY=
-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/go.mod h1:SBH7ygxi8pfUlaOkMMuAQtPIUF8ecWP5IEl/CR7VP2Q=
-github.com/golang/groupcache v0.0.0-20190702054246-869f871628b6/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc=
-github.com/golang/groupcache v0.0.0-20191227052852-215e87163ea7/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc=
-github.com/golang/groupcache v0.0.0-20200121045136-8c9f03a8e57e/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc=
 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/go.mod h1:sBzyDLLjw3U8JLTeZvSv8jJB+tU5PVekmnlKIyFUx0Y=
-github.com/golang/mock v1.4.0/go.mod h1:UOMv5ysSaYNkG+OFQykRIcU/QvvxJf3p21QfJ2Bt3cw=
-github.com/golang/mock v1.4.1/go.mod h1:UOMv5ysSaYNkG+OFQykRIcU/QvvxJf3p21QfJ2Bt3cw=
 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=
 github.com/golang/protobuf v1.3.2/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
-github.com/golang/protobuf v1.3.3/go.mod h1:vzj43D7+SQXF/4pzW/hwtAqwc6iTitCiVSaWz5lYuqw=
-github.com/golang/protobuf v1.3.4/go.mod h1:vzj43D7+SQXF/4pzW/hwtAqwc6iTitCiVSaWz5lYuqw=
 github.com/golang/protobuf v1.4.0-rc.1/go.mod h1:ceaxUfeHdC40wWswd/P6IGgMaK3YpKi5j83Wpe3EHw8=
 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=
@@ -123,402 +25,88 @@ github.com/golang/protobuf v1.4.0/go.mod h1:jodUvKwWbYaEsadDk5Fwe5c77LiNKVO9IDvq
 github.com/golang/protobuf v1.4.1/go.mod h1:U8fpvMrcmy5pZrNK1lt4xCsGvpyWQ/VVv6QDs8UjoX8=
 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/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/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/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/pprof v0.0.0-20191218002539-d4f498aebedc/go.mod h1:ZgVRPoUq/hfqzAqh7sHMqb3I9Rq5C59dIz2SbBwJ4eM=
-github.com/google/pprof v0.0.0-20200212024743-f11f1df84d12/go.mod h1:ZgVRPoUq/hfqzAqh7sHMqb3I9Rq5C59dIz2SbBwJ4eM=
-github.com/google/pprof v0.0.0-20200229191704-1ebb73c60ed3/go.mod h1:ZgVRPoUq/hfqzAqh7sHMqb3I9Rq5C59dIz2SbBwJ4eM=
-github.com/google/renameio v0.1.0/go.mod h1:KWCgfxg9yswjAJkECMjeO8J8rahYeXnNhOm40UhjYkI=
-github.com/google/uuid v1.1.1/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
-github.com/google/uuid v1.1.5 h1:kxhtnfFVi+rYdOALN0B3k9UT86zVJKfBimRaciULW4I=
-github.com/google/uuid v1.1.5/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
-github.com/googleapis/gax-go/v2 v2.0.4/go.mod h1:0Wqv26UfaUD9n4G6kQubkQ+KchISgw+vpHVxEJEs9eg=
-github.com/googleapis/gax-go/v2 v2.0.5/go.mod h1:DWXyrwAJ9X0FpwwEdw+IPEYBICEFu5mhpdKc/us6bOk=
-github.com/gophercloud/gophercloud v0.6.1-0.20191122030953-d8ac278c1c9d/go.mod h1:ozGNgr9KYOVATV5jsgHl/ceCDXGuguqOZAzoQ/2vcNM=
-github.com/gophercloud/gophercloud v0.7.0/go.mod h1:gmC5oQqMDOMO1t1gq5DquX/yAU808e/4mzjjDA76+Ss=
-github.com/gophercloud/utils v0.0.0-20200508015959-b0167b94122c/go.mod h1:ehWUbLQJPqS0Ep+CxeD559hsm9pthPXadJNKwZkp43w=
-github.com/gopherjs/gopherjs v0.0.0-20181017120253-0766667cb4d1/go.mod h1:wJfORRmW1u3UXTncJ5qlYoELFm8eSnnEO6hX4iZ3EWY=
-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/go.mod h1:vNeuVxBJEsws4ogUvrchl83t/GYV9WGTSLVdBhOQFDY=
-github.com/h2non/parth v0.0.0-20190131123155-b4df798d6542/go.mod h1:Ow0tF8D4Kplbc8s8sSb3V2oUCygFHVp8gC3Dn6U4MNI=
-github.com/hashicorp/go-cleanhttp v0.5.1/go.mod h1:JpRdi6/HCYpAwUzNwuwqhbovhLtngrth3wmdIIUrZ80=
-github.com/hashicorp/go-hclog v0.9.2/go.mod h1:5CU+agLiy3J7N7QjHK5d05KxGsuXiQLrjA0H7acj2lQ=
-github.com/hashicorp/go-retryablehttp v0.6.6/go.mod h1:vAew36LZh98gCBJNLH42IQ1ER/9wtLZZ8meHqQvEYWY=
-github.com/hashicorp/go-uuid v1.0.1/go.mod h1:6SBZvOh/SIDV7/2o3Jml5SYk/TvGqwFJ/bN7x4byOro=
-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/hpcloud/tail v1.0.0/go.mod h1:ab1qPbhIpdTxEkNHXyeSf5vhxWSCs/tWer42PpOxQnU=
-github.com/ianlancetaylor/demangle v0.0.0-20181102032728-5e5cf60278f6/go.mod h1:aSSvb/t6k1mPoxDqO4vJh6VOCGPwU4O0C2/Eqndh1Sc=
-github.com/iij/doapi v0.0.0-20190504054126-0bbf12d6d7df/go.mod h1:QMZY7/J/KSQEhKWFeDesPjMj+wCHReeknARU3wqlyN4=
-github.com/jmespath/go-jmespath v0.0.0-20180206201540-c2b33e8439af/go.mod h1:Nht3zPeWKUH0NzdCt2Blrr5ys8VGpn0CEB0cQHVjt7k=
-github.com/jmespath/go-jmespath v0.3.0/go.mod h1:9QtRXoHjLGCJ5IBSaohpXITPlowMeeYCZ7fLUTSywik=
-github.com/json-iterator/go v1.1.5/go.mod h1:+SdeFBvtyEkXs7REEP0seUULqWtbJapLOCVDaaPEHmU=
-github.com/json-iterator/go v1.1.6/go.mod h1:+SdeFBvtyEkXs7REEP0seUULqWtbJapLOCVDaaPEHmU=
-github.com/json-iterator/go v1.1.7/go.mod h1:KdQUCv79m/52Kvf8AW2vK1V8akMuk1QjK/uOdHXbAo4=
-github.com/jstemmer/go-junit-report v0.0.0-20190106144839-af01ea7f8024/go.mod h1:6v2b51hI/fHJwM22ozAgKL4VKDeJcHhJFhtBdhmNjmU=
-github.com/jstemmer/go-junit-report v0.9.1/go.mod h1:Brl9GWCQeLvo8nXZwPNNblvFj/XSXhF0NWZEnDohbsk=
-github.com/jtolds/gls v4.20.0+incompatible/go.mod h1:QJZ7F/aHp+rZTRtaJ1ow/lLfFfVYBRgL+9YlvaHOwJU=
-github.com/julienschmidt/httprouter v1.2.0/go.mod h1:SYymIcj16QtmaHHD7aYtjjsJG7VTCxuUUipMqKk8s4w=
-github.com/kisielk/gotool v1.0.0/go.mod h1:XhKaO+MFFWcvkIS/tQcRk01m1F5IRFswLeQ+oQHNcck=
-github.com/klauspost/cpuid v1.2.5 h1:VBd9MyVIiJHzzgnrLQG5Bcv75H4YaWrlKqWHjurxCGo=
-github.com/klauspost/cpuid v1.2.5/go.mod h1:bYW4mA6ZgKPob1/Dlai2LviZJO7KGI3uoWLd42rAQw4=
-github.com/kolo/xmlrpc v0.0.0-20200310150728-e0350524596b/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/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/google/uuid v1.2.0 h1:qJYtXnJRWmpe7m/3XlyhrsLrEURqHRM2kxzoxXqyUDs=
+github.com/google/uuid v1.2.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
+github.com/imdario/mergo v0.3.11 h1:3tnifQM4i+fbajXKBHXWEH+KvNHqojZ778UH75j3bGA=
+github.com/imdario/mergo v0.3.11/go.mod h1:jmQim1M+e3UYxmgPu/WyfjB3N3VflVyUjjjwH0dnCYA=
 github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ=
 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=
-github.com/labbsr0x/bindman-dns-webhook v1.0.2/go.mod h1:p6b+VCXIR8NYKpDr8/dg1HKfQoRHCdcsROXKvmoehKA=
-github.com/labbsr0x/goh v1.0.1/go.mod h1:8K2UhVoaWXcCU7Lxoa2omWnC8gyW8px7/lmO61c027w=
-github.com/libdns/libdns v0.1.0 h1:0ctCOrVJsVzj53mop1angHp/pE3hmAhP7KiHvR0HD04=
-github.com/libdns/libdns v0.1.0/go.mod h1:yQCXzk1lEZmmCPa857bnk4TsOiqYasqpyOEeSObbb40=
-github.com/linode/linodego v0.10.0/go.mod h1:cziNP7pbvE3mXIPneHj0oRY8L1WtGEIKlZ8LANE4eXA=
-github.com/liquidweb/liquidweb-go v1.6.0/go.mod h1:UDcVnAMDkZxpw4Y7NOHkqoeiGacVLEIG/i5J9cyixzQ=
-github.com/mattn/go-isatty v0.0.3/go.mod h1:M+lRXTBqGeGNdLjl/ufCoiOlB5xdOkqRJdNxMWT7Zi4=
-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/go.mod h1:D8He9yQNgCq6Z5Ld7szi9bcBfOoFv/3dc6xSMkL2PC0=
-github.com/mholt/acmez v0.1.1 h1:KQODCqk+hBn3O7qfCRPj6L96uG65T5BSS95FKNEqtdA=
-github.com/mholt/acmez v0.1.1/go.mod h1:8qnn8QA/Ewx8E3ZSsmscqsIjhhpxuy9vqdgbX2ceceM=
-github.com/miekg/dns v1.1.27/go.mod h1:KNUDUusw/aVsxyTYZM1oqvCicbwhgbNgztCETuNZ7xM=
-github.com/miekg/dns v1.1.30/go.mod h1:KNUDUusw/aVsxyTYZM1oqvCicbwhgbNgztCETuNZ7xM=
-github.com/miekg/dns v1.1.35 h1:oTfOaDH+mZkdcgdIjH6yBajRGtIwcwcaR+rt23ZSrJs=
-github.com/miekg/dns v1.1.35/go.mod h1:KNUDUusw/aVsxyTYZM1oqvCicbwhgbNgztCETuNZ7xM=
-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.3.1/go.mod h1:bFUtVrKA4DC2yAKiSyO/QUcy7e+RRV2QTWOzhPopBRo=
-github.com/modern-go/concurrent v0.0.0-20180228061459-e0a39a4cb421/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q=
-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/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=
-github.com/nbio/st v0.0.0-20140626010706-e9e8d9816f32/go.mod h1:9wM+0iRr9ahx58uYLpLIr5fm8diHn0JbqRycJi6w0Ms=
+github.com/miekg/dns v1.1.38 h1:MtIY+fmHUVVgv1AXzmKMWcwdCYxTRPG1EDjpqF4RCEw=
+github.com/miekg/dns v1.1.38/go.mod h1:KNUDUusw/aVsxyTYZM1oqvCicbwhgbNgztCETuNZ7xM=
 github.com/niemeyer/pretty v0.0.0-20200227124842-a10e7caefd8e h1:fD57ERR4JtEqsWbfPhv4DMiApHyliiK5xCTNVSPiaAs=
 github.com/niemeyer/pretty v0.0.0-20200227124842-a10e7caefd8e/go.mod h1:zD1mROLANZcx1PVRCS0qkT7pwLkGfwJo4zjcN/Tysno=
-github.com/nrdcg/auroradns v1.0.1/go.mod h1:y4pc0i9QXYlFCWrhWrUSIETnZgrf4KuwjDIWmmXo3JI=
-github.com/nrdcg/desec v0.5.0/go.mod h1:2ejvMazkav1VdDbv2HeQO7w+Ta1CGHqzQr27ZBYTuEQ=
-github.com/nrdcg/dnspod-go v0.4.0/go.mod h1:vZSoFSFeQVm2gWLMkyX61LZ8HI3BaqtHZWgPTGKr6KQ=
-github.com/nrdcg/goinwx v0.7.0/go.mod h1:4tKJOCi/1lTxuw9/yB2Ez0aojwtUCSkckjc22eALpqE=
-github.com/nrdcg/namesilo v0.2.1/go.mod h1:lwMvfQTyYq+BbjJd30ylEG4GPSS6PII0Tia4rRpRiyw=
-github.com/olekukonko/tablewriter v0.0.1/go.mod h1:vsDQFd/mU46D+Z4whnwzcISnGGzXWMclvtLoiIKAKIo=
-github.com/onsi/ginkgo v1.6.0/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE=
-github.com/onsi/ginkgo v1.7.0/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE=
-github.com/onsi/gomega v1.4.3/go.mod h1:ex+gbHU/CVuBBDIJjb2X0qEXbFg53c61hWP/1CpauHY=
-github.com/openzipkin/zipkin-go v0.1.6/go.mod h1:QgAqvLzwWbR/WpD4A3cGpPtJrZXNIiJc5AZX7/PBEpw=
-github.com/oracle/oci-go-sdk v7.0.0+incompatible/go.mod h1:VQb79nF8Z2cwLkLS35ukwStZIg5F66tcBccjip/j888=
-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/pquerna/otp v1.2.0/go.mod h1:dkJfzwRKNiegxyNb54X/3fLwhCynbMspSyWKnvi1AEg=
-github.com/prometheus/client_golang v0.9.1/go.mod h1:7SWBe2y4D6OKWSNQJUaRYU/AaXPKyh/dDVn+NZz0KFw=
-github.com/prometheus/client_golang v0.9.3-0.20190127221311-3c4408c8b829/go.mod h1:p2iRAGwDERtqlqzRXnrOVns+ignqQo//hLXqYxZYVNs=
-github.com/prometheus/client_golang v1.0.0/go.mod h1:db9x61etRT2tGnBNRi70OPL5FsnadC4Ky3P0J6CfImo=
-github.com/prometheus/client_golang v1.1.0/go.mod h1:I1FGZT9+L76gKKOs5djB6ezCbFQP1xR9D75/vuwEF3g=
-github.com/prometheus/client_model v0.0.0-20180712105110-5c3871d89910/go.mod h1:MbSGuTsp3dbXC40dX6PRTWyKYBIrTGTE9sqQNg2J8bo=
-github.com/prometheus/client_model v0.0.0-20190115171406-56726106282f/go.mod h1:MbSGuTsp3dbXC40dX6PRTWyKYBIrTGTE9sqQNg2J8bo=
-github.com/prometheus/client_model v0.0.0-20190129233127-fd36f4220a90/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA=
 github.com/prometheus/client_model v0.0.0-20190812154241-14fe0d1b01d4/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA=
-github.com/prometheus/common v0.2.0/go.mod h1:TNfzLD0ON7rHzMJeJkieUDPYmFC7Snx/y86RQel1bk4=
-github.com/prometheus/common v0.4.1/go.mod h1:TNfzLD0ON7rHzMJeJkieUDPYmFC7Snx/y86RQel1bk4=
-github.com/prometheus/common v0.6.0/go.mod h1:eBmuwkDJBwy6iBfxCBob6t6dR6ENT/y+J+Zk0j9GMYc=
-github.com/prometheus/procfs v0.0.0-20181005140218-185b4288413d/go.mod h1:c3At6R/oaqEKCNdg8wHV1ftS6bRYblBhIjjI8uT2IGk=
-github.com/prometheus/procfs v0.0.0-20190117184657-bf6a532e95b1/go.mod h1:c3At6R/oaqEKCNdg8wHV1ftS6bRYblBhIjjI8uT2IGk=
-github.com/prometheus/procfs v0.0.2/go.mod h1:TjEm7ze935MbeOT/UhFTIMYKhuLP4wbCsTZCD3I8kEA=
-github.com/prometheus/procfs v0.0.3/go.mod h1:4A/X28fw3Fc593LaREMrKMqOKvUAntwMDaekg4FpcdQ=
-github.com/rainycape/memcache v0.0.0-20150622160815-1031fa0ce2f2/go.mod h1:7tZKcyumwBO6qip7RNQ5r77yrssm9bfCowcLEBcU5IA=
-github.com/rcrowley/go-metrics v0.0.0-20181016184325-3113b8401b8a/go.mod h1:bCqnVzQkZxMG4s8nGwiZ5l3QUCyqpo9Y+/ZMZ9VjZe4=
-github.com/rogpeppe/fastuuid v0.0.0-20150106093220-6724a57986af/go.mod h1:XWv6SoW27p1b0cqNHllgS5HIMJraePCO15w5zCzIWYg=
-github.com/rogpeppe/go-internal v1.3.0/go.mod h1:M8bDsm7K2OlrFYOpmOWEs/qY81heoFRclV5y23lUDJ4=
-github.com/russross/blackfriday/v2 v2.0.1 h1:lPqVAte+HuHNfhJ/0LC98ESWRz8afy9tM/0RK8m9o+Q=
-github.com/russross/blackfriday/v2 v2.0.1/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM=
-github.com/sacloud/libsacloud v1.26.1/go.mod h1:79ZwATmHLIFZIMd7sxA3LwzVy/B77uj3LDoToVTxDoQ=
-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/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=
-github.com/smartystreets/goconvey v0.0.0-20190330032615-68dc04aab96a/go.mod h1:syvi0/a8iFYH4r/RixwvyeAJjdLS9QV7WQ/tjFTllLA=
-github.com/smartystreets/goconvey v1.6.4/go.mod h1:syvi0/a8iFYH4r/RixwvyeAJjdLS9QV7WQ/tjFTllLA=
 github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
-github.com/stretchr/objx v0.1.1 h1:2vfRuCMp5sSVIDSqO8oNnWJq7mPa6KVP3iPIwFBuy8A=
-github.com/stretchr/objx v0.1.1/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
-github.com/stretchr/testify v1.2.2/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs=
 github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
-github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4=
-github.com/stretchr/testify v1.5.1 h1:nOGnQDM7FYENwehXlg/kFVnos3rEvtKTjRvOWSzb6H4=
-github.com/stretchr/testify v1.5.1/go.mod h1:5W2xD1RspED5o8YsWQXVCued0rvSQ+mT+I5cxcmMvtA=
-github.com/stretchr/testify v1.6.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
 github.com/stretchr/testify v1.7.0 h1:nwc3DEeHmmLAfoZucVR881uASk0Mfjw8xYJ99tb5CcY=
 github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
-github.com/timewasted/linode v0.0.0-20160829202747-37e84520dcf7/go.mod h1:imsgLplxEC/etjIhdr3dNzV3JeT27LbVu5pYWm0JCBY=
-github.com/transip/gotransip/v6 v6.0.2/go.mod h1:pQZ36hWWRahCUXkFWlx9Hs711gLd8J4qdgLdRzmtY+g=
-github.com/uber-go/atomic v1.3.2/go.mod h1:/Ct5t2lcmbJ4OSe/waGBoaVvVqtO0bmtfVNex1PFV8g=
-github.com/urfave/cli v1.22.1/go.mod h1:Gos4lmkARVdJ6EkW0WaNv/tZAAMe9V7XWyB60NtXRu0=
-github.com/vultr/govultr v0.4.2/go.mod h1:TUuUizMOFc7z+PNMssb6iGjKjQfpw5arIaOLfocVudQ=
-github.com/xeipuuv/gojsonpointer v0.0.0-20180127040702-4e3ac2762d5f/go.mod h1:N2zxlSyiKSe5eX1tZViRH5QA0qijqEDrYZiPEAiq3wU=
-github.com/xeipuuv/gojsonreference v0.0.0-20180127040603-bd5ef7bd5415/go.mod h1:GwrjFmJcFw6At/Gs6z4yjiIwzuJ1/+UwLxMQDVQXShQ=
-github.com/xeipuuv/gojsonschema v1.2.0/go.mod h1:anYRn/JVcOK2ZgGU+IjEV4nwlhoK5sQluxsYJ78Id3Y=
-go.opencensus.io v0.20.1/go.mod h1:6WKK9ahsWS3RSO+PY9ZHZUfv2irvY6gN279GOPZjmmk=
-go.opencensus.io v0.20.2/go.mod h1:6WKK9ahsWS3RSO+PY9ZHZUfv2irvY6gN279GOPZjmmk=
-go.opencensus.io v0.21.0/go.mod h1:mSImk1erAIZhrmZN+AvHh14ztQfjbGwt4TtuofqLduU=
-go.opencensus.io v0.22.0/go.mod h1:+kGneAE2xo2IficOXnaByMWTGM9T73dGwxeWcUqIpI8=
-go.opencensus.io v0.22.2/go.mod h1:yxeiOL68Rb0Xd1ddK5vPZ/oVn4vY4Ynel7k9FzqtOIw=
-go.opencensus.io v0.22.3/go.mod h1:yxeiOL68Rb0Xd1ddK5vPZ/oVn4vY4Ynel7k9FzqtOIw=
-go.uber.org/atomic v1.3.2/go.mod h1:gD2HeocX3+yG+ygLZcrzQJaqmWj9AIm7n08wl/qW/PE=
-go.uber.org/atomic v1.6.0 h1:Ezj3JGmsOnG1MoRWQkPBsKLe9DwWD9QeXzTRzzldNVk=
-go.uber.org/atomic v1.6.0/go.mod h1:sABNBOSYdrvTF6hTgEIbc7YasKWGhgEQZyfxyTvoXHQ=
-go.uber.org/multierr v1.5.0 h1:KCa4XfM8CWFCpxXRGok+Q0SS/0XBhMDbHHGABQLvD2A=
-go.uber.org/multierr v1.5.0/go.mod h1:FeouvMocqHpRaaGuG9EjoKcStLC43Zu/fmqdUMPcKYU=
-go.uber.org/ratelimit v0.0.0-20180316092928-c15da0234277/go.mod h1:2X8KaoNd1J0lZV+PxJk/5+DGbO/tpwLR1m++a7FnB/Y=
-go.uber.org/tools v0.0.0-20190618225709-2cfd321de3ee h1:0mgffUl7nfd+FpvXMVz4IDEaUSmT1ysygQC7qYo7sG4=
-go.uber.org/tools v0.0.0-20190618225709-2cfd321de3ee/go.mod h1:vJERXedbb3MVM5f9Ejo0C68/HhF8uaILCdgjnY+goOA=
-go.uber.org/zap v1.15.0 h1:ZZCA22JRF2gQE5FoNmhmrf7jeJJ2uhqDUNRYKm8dvmM=
-go.uber.org/zap v1.15.0/go.mod h1:Mb2vm2krFEG5DV0W9qcHBYFtp/Wku1cvYaqPsS/WYfc=
-golang.org/x/crypto v0.0.0-20180621125126-a49355c7e3f8/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4=
-golang.org/x/crypto v0.0.0-20180904163835-0709b304e793/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4=
 golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
-golang.org/x/crypto v0.0.0-20190418165655-df01cb2cc480/go.mod h1:WFFai1msRO1wXaEeE5yQxYXgSfI8pQAWXbQop6sCtWE=
-golang.org/x/crypto v0.0.0-20190510104115-cbcb75029529/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
-golang.org/x/crypto v0.0.0-20190605123033-f99c8df09eb5/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
 golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
-golang.org/x/crypto v0.0.0-20191202143827-86a70503ff7e/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
-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-20200728195943-123391ffb6de/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
 golang.org/x/crypto v0.0.0-20201221181555-eec23a3978ad h1:DN0cp81fZ3njFcrLCytUHRSUkqBjfTo4Tx9RJTWs0EY=
 golang.org/x/crypto v0.0.0-20201221181555-eec23a3978ad/go.mod h1:jdWPYTVW3xRLrWPugEBEK3UY2ZEsg3UU495nc5E+M+I=
 golang.org/x/exp v0.0.0-20190121172915-509febef88a4/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA=
-golang.org/x/exp v0.0.0-20190306152737-a1d7652674e8/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA=
-golang.org/x/exp v0.0.0-20190510132918-efd6b22b2522/go.mod h1:ZjyILWgesfNpC6sMxTJOJm9Kp84zZh5NQWvqDGG3Qr8=
-golang.org/x/exp v0.0.0-20190829153037-c13cbed26979/go.mod h1:86+5VVa7VpoJ4kLfm080zCjGlMRFzhUhsZKEZO7MGek=
-golang.org/x/exp v0.0.0-20191030013958-a1ab85dbe136/go.mod h1:JXzH8nQsPlswgeRAPE3MuO9GYsAcnJvJ4vnMwN/5qkY=
-golang.org/x/exp v0.0.0-20191129062945-2f5052295587/go.mod h1:2RIsYlXP63K8oxa1u096TMicItID8zy7Y6sNkU49FU4=
-golang.org/x/exp v0.0.0-20191227195350-da58074b4299/go.mod h1:2RIsYlXP63K8oxa1u096TMicItID8zy7Y6sNkU49FU4=
-golang.org/x/exp v0.0.0-20200119233911-0405dc783f0a/go.mod h1:2RIsYlXP63K8oxa1u096TMicItID8zy7Y6sNkU49FU4=
-golang.org/x/exp v0.0.0-20200207192155-f17229e696bd/go.mod h1:J/WKrq2StrnmMY6+EHIKF9dgMWnmCNThgcyBT1FY9mM=
-golang.org/x/exp v0.0.0-20200224162631-6cc2880d07d6/go.mod h1:3jZMyOhIsHpP37uCMkUooju7aAi5cS1Q23tOzKc+0MU=
-golang.org/x/image v0.0.0-20190227222117-0694c2d4d067/go.mod h1:kZ7UVZpmo3dzQBMxlp+ypCbDeSB+sBbTgSJuh5dn5js=
-golang.org/x/image v0.0.0-20190802002840-cff245a6509b/go.mod h1:FeLwcggjj3mMvU+oOTbSwawSJRM1uh48EjtB4UJZlP0=
 golang.org/x/lint v0.0.0-20181026193005-c67002cb31c3/go.mod h1:UVdnD1Gm6xHRNCYTkRU2/jEulfH38KcIWyp/GAMgvoE=
 golang.org/x/lint v0.0.0-20190227174305-5b3e6a55c961/go.mod h1:wehouNa3lNwaWXcvxsM5YxQ5yQlVC4a0KAMCusXpPoU=
-golang.org/x/lint v0.0.0-20190301231843-5614ed5bae6f/go.mod h1:UVdnD1Gm6xHRNCYTkRU2/jEulfH38KcIWyp/GAMgvoE=
 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-20190930215403-16217165b5de/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc=
-golang.org/x/lint v0.0.0-20191125180803-fdd1cda4f05f/go.mod h1:5qLYkcX4OjUUV8bRuDixDT3tpyyb+LUpUlRWLxfhWrs=
-golang.org/x/lint v0.0.0-20200130185559-910be7a94367/go.mod h1:3xt1FjdF8hUf6vQPIChWIBhFzV8gjjsPE/fR3IyQdNY=
-golang.org/x/lint v0.0.0-20200302205851-738671d3881b h1:Wh+f8QHJXR411sJR8/vRBTZ7YapZaRvUcLFFJhusH0k=
-golang.org/x/lint v0.0.0-20200302205851-738671d3881b/go.mod h1:3xt1FjdF8hUf6vQPIChWIBhFzV8gjjsPE/fR3IyQdNY=
-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=
-golang.org/x/mod v0.0.0-20190513183733-4bf6d317e70e/go.mod h1:mXi4GBBbnImb6dmsKGUJ2LatrhH/nqhxcFungHvyanc=
-golang.org/x/mod v0.1.0/go.mod h1:0QHyrYULN0/3qlju5TqG8bIK38QM8yzMo5ekMj3DlcY=
 golang.org/x/mod v0.1.1-0.20191105210325-c90efee705ee/go.mod h1:QqPTAvyqsEbceGzBzNggFXnrqF1CaUcvgkdR5Ot7KZg=
-golang.org/x/mod v0.1.1-0.20191107180719-034126e5016b/go.mod h1:QqPTAvyqsEbceGzBzNggFXnrqF1CaUcvgkdR5Ot7KZg=
-golang.org/x/mod v0.2.0 h1:KU7oHjnv3XNWfa5COkzUifxZmxp1TyI7ImMXqFxLwvQ=
-golang.org/x/mod v0.2.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
-golang.org/x/net v0.0.0-20180611182652-db08ff08e862/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
 golang.org/x/net v0.0.0-20180724234803-3673e40ba225/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
 golang.org/x/net v0.0.0-20180826012351-8a410e7b638d/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
-golang.org/x/net v0.0.0-20180906233101-161cd47e91fd/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
-golang.org/x/net v0.0.0-20181114220301-adae6a3d119a/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
-golang.org/x/net v0.0.0-20181220203305-927f97764cc3/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
-golang.org/x/net v0.0.0-20190108225652-1e06a53dbb7e/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
-golang.org/x/net v0.0.0-20190125091013-d26f9f9a57f3/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
 golang.org/x/net v0.0.0-20190213061140-3a22650c66bd/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
 golang.org/x/net v0.0.0-20190311183353-d8887717615a/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
 golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
-golang.org/x/net v0.0.0-20190501004415-9ce7a6920f09/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
-golang.org/x/net v0.0.0-20190503192946-f4e77d36d62c/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
-golang.org/x/net v0.0.0-20190603091049-60506f45cf65/go.mod h1:HSz+uSET+XFnRR8LxR5pz3Of3rY3CfYBVs4xY44aLks=
-golang.org/x/net v0.0.0-20190613194153-d28f0bde5980/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
 golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
-golang.org/x/net v0.0.0-20190724013045-ca1201d0de80/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
 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-20191126235420-ef20fe5d7933/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
-golang.org/x/net v0.0.0-20191209160850-c0dbc17a3553/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
-golang.org/x/net v0.0.0-20200114155413-6afb5195e5aa/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
-golang.org/x/net v0.0.0-20200202094626-16171245cfb2/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
-golang.org/x/net v0.0.0-20200222125558-5a598a2470a0/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
-golang.org/x/net v0.0.0-20200226121028-0de0cce0169b/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
-golang.org/x/net v0.0.0-20200301022130-244492dfa37a/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
-golang.org/x/net v0.0.0-20200707034311-ab3426394381/go.mod h1:/O7V0waA8r7cgGh81Ro3o1hOxt32SMVPicZroKQ2sZA=
-golang.org/x/net v0.0.0-20201224014010-6772e930b67b h1:iFwSg7t5GZmB/Q5TjiEAsdoLDrdJRC1RiF2WhuV29Qw=
-golang.org/x/net v0.0.0-20201224014010-6772e930b67b/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg=
+golang.org/x/net v0.0.0-20210119194325-5f4716e94777 h1:003p0dJM77cxMSyCPFphvZf/Y5/NXf5fzg6ufd1/Oew=
+golang.org/x/net v0.0.0-20210119194325-5f4716e94777/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg=
 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/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw=
-golang.org/x/oauth2 v0.0.0-20191202225959-858c2ad4c8b6/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw=
-golang.org/x/oauth2 v0.0.0-20200107190931-bf48bf16ab8d/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=
-golang.org/x/sync v0.0.0-20181221193216-37e7f081c4d4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sync v0.0.0-20190227155943-e225da77a7e6/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sync v0.0.0-20190911185100-cd5d95a43a6e h1:vcxGaoTs7kV8m5Np9uUNQin4BrLOthgV7252N8V+FwY=
 golang.org/x/sync v0.0.0-20190911185100-cd5d95a43a6e/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sys v0.0.0-20180622082034-63fc586f45fe/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20180830151530-49385e6e1522/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
-golang.org/x/sys v0.0.0-20180905080454-ebe1bf3edb33/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
-golang.org/x/sys v0.0.0-20180909124046-d0be0721c37e/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
-golang.org/x/sys v0.0.0-20181107165924-66b7b1311ac8/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
-golang.org/x/sys v0.0.0-20181116152217-5ac8a444bdc5/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
-golang.org/x/sys v0.0.0-20181122145206-62eef0e2fa9b/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
-golang.org/x/sys v0.0.0-20190312061237-fead79001313/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20190403152447-81d4e9dc473e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20190422165155-953cdadca894/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20190502145724-3ef323f4f1fd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20190507160741-ecd444e8653b/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20190606165138-5da285871e9c/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20190624142023-c5567b49c5d0/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20190726091711-fc99dfbffb4e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20190801041406-cbf593c0f2f3/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20190924154521-2837fb4f24fe/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20191001151750-bb3f8db39f24/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20191026070338-33540a1f6037/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20191128015809-6d18c012aee9/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20191204072324-ce4227a45e2e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20191228213918-04cbcbbfeed8/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20200113162924-86b910548bc1/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20200122134326-e047566fdf82/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20200202164722-d101bd2416d5/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20200212091648-12a6c2dcc1e4/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20200223170610-d5e6a3e2c0ae/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20200302150141-5c8b2ff67527/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20200323222414-85ca7c5b95cd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20201119102817-f84b799fce68 h1:nxC68pudNYkKU6jWhgrqdreuFiOQWj1Fs7T3VrH4Pjw=
 golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/term v0.0.0-20201117132131-f5c789dd3221/go.mod h1:Nr5EML6q2oocZ2LXRh80K7BxOlk5/8JxuGnuhpl+muw=
 golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
-golang.org/x/text v0.0.0-20170915032832-14c0d48ead0c/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
 golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
-golang.org/x/text v0.3.1-0.20180807135948-17ff2d5776d2/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
-golang.org/x/text v0.3.2 h1:tW2bmiBqwgJj/UpqtC8EpXEZVYOwU0yG4iWbprSVAcs=
-golang.org/x/text v0.3.2/go.mod h1:bEr9sfX3Q8Zfm5fL9x+3itogRgK3+ptLWKqgva+5dAk=
 golang.org/x/text v0.3.3 h1:cokOdA+Jmi5PJGXLlLllQSgYigAEfHXJAERHVMaCc2k=
 golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
-golang.org/x/time v0.0.0-20181108054448-85acf8d2951c/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
-golang.org/x/time v0.0.0-20190308202827-9d24e82272b4/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
-golang.org/x/time v0.0.0-20190921001708-c4c64cad1fd0/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
-golang.org/x/time v0.0.0-20191024005414-555d28b269f0/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
-golang.org/x/time v0.0.0-20200630173020-3af7569d3a1e/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
-golang.org/x/tools v0.0.0-20180828015842-6cd1fcedba52/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
 golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
 golang.org/x/tools v0.0.0-20190114222345-bf090417da8b/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
 golang.org/x/tools v0.0.0-20190226205152-f727befe758c/go.mod h1:9Yl7xja0Znq3iFh3HoIrodX9oNMXvdceNzlUR8zjMvY=
 golang.org/x/tools v0.0.0-20190311212946-11955173bddd/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs=
-golang.org/x/tools v0.0.0-20190312151545-0bb0c0a6e846/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs=
-golang.org/x/tools v0.0.0-20190312170243-e65039ee4138/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs=
-golang.org/x/tools v0.0.0-20190328211700-ab21143f2384/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs=
-golang.org/x/tools v0.0.0-20190425150028-36563e24a262/go.mod h1:RgjU9mgBXZiqYHBnxXauZ1Gv1EHHAz9KjViQ78xBX0Q=
-golang.org/x/tools v0.0.0-20190506145303-2d16b83fe98c/go.mod h1:RgjU9mgBXZiqYHBnxXauZ1Gv1EHHAz9KjViQ78xBX0Q=
 golang.org/x/tools v0.0.0-20190524140312-2c0ae7006135/go.mod h1:RgjU9mgBXZiqYHBnxXauZ1Gv1EHHAz9KjViQ78xBX0Q=
-golang.org/x/tools v0.0.0-20190606124116-d0a3d012864b/go.mod h1:/rFqwRUd4F7ZHNgwSSTFct+R/Kf4OFW1sUzUTQQTgfc=
-golang.org/x/tools v0.0.0-20190621195816-6e04913cbbac/go.mod h1:/rFqwRUd4F7ZHNgwSSTFct+R/Kf4OFW1sUzUTQQTgfc=
-golang.org/x/tools v0.0.0-20190628153133-6cdbf07be9d0/go.mod h1:/rFqwRUd4F7ZHNgwSSTFct+R/Kf4OFW1sUzUTQQTgfc=
-golang.org/x/tools v0.0.0-20190816200558-6889da9d5479/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
-golang.org/x/tools v0.0.0-20190911174233-4f2ddba30aff/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
-golang.org/x/tools v0.0.0-20191012152004-8de300cfc20a/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
-golang.org/x/tools v0.0.0-20191029041327-9cc4af7d6b2c/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
-golang.org/x/tools v0.0.0-20191029190741-b9c20aec41a5/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
-golang.org/x/tools v0.0.0-20191113191852-77e3bb0ad9e7/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
-golang.org/x/tools v0.0.0-20191115202509-3a792d9c32b2/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
-golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/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-20191130070609-6e064ea0cf2d/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
-golang.org/x/tools v0.0.0-20191203134012-c197fd4bf371/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/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
-golang.org/x/tools v0.0.0-20191227053925-7b8e75db28f4/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
-golang.org/x/tools v0.0.0-20200117161641-43d50277825c/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
-golang.org/x/tools v0.0.0-20200122220014-bf1340f18c4a/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
-golang.org/x/tools v0.0.0-20200130002326-2f3ba24bd6e7/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
-golang.org/x/tools v0.0.0-20200204074204-1cc6d1ef6c74/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
-golang.org/x/tools v0.0.0-20200207183749-b753a1ba74fa/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
-golang.org/x/tools v0.0.0-20200212150539-ea181f53ac56/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
-golang.org/x/tools v0.0.0-20200224181240-023911ca70b2/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
-golang.org/x/tools v0.0.0-20200304193943-95d2e580d8eb h1:iKlO7ROJc6SttHKlxzwGytRtBUqX4VARrNTgP2YLX5M=
-golang.org/x/tools v0.0.0-20200304193943-95d2e580d8eb/go.mod h1:o4KQGtdN14AW+yjsvvwRTJJuXz8XRtIHtEnmAXLyFUw=
-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=
 golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543 h1:E7g+9GITq07hpfrRu66IVDexMakfv52eLZ2CXBWiKr4=
 golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
-google.golang.org/api v0.3.1/go.mod h1:6wY9I6uQWHQ8EM57III9mq/AjF+i8G65rmVagqKMtkk=
-google.golang.org/api v0.4.0/go.mod h1:8k5glujaEP+g9n7WNsDg8QP6cUVNI86fCNMcbazEtwE=
-google.golang.org/api v0.7.0/go.mod h1:WtwebWUNSVBH/HAw79HIFXZNqEvBhG+Ra+ax0hx3E3M=
-google.golang.org/api v0.8.0/go.mod h1:o4eAsZoiT+ibD93RtjEohWalFOjRDx6CVaqeizhEnKg=
-google.golang.org/api v0.9.0/go.mod h1:o4eAsZoiT+ibD93RtjEohWalFOjRDx6CVaqeizhEnKg=
-google.golang.org/api v0.13.0/go.mod h1:iLdEw5Ide6rF15KTC1Kkl0iskquN2gFfn9o9XIsbkAI=
-google.golang.org/api v0.14.0/go.mod h1:iLdEw5Ide6rF15KTC1Kkl0iskquN2gFfn9o9XIsbkAI=
-google.golang.org/api v0.15.0/go.mod h1:iLdEw5Ide6rF15KTC1Kkl0iskquN2gFfn9o9XIsbkAI=
-google.golang.org/api v0.17.0/go.mod h1:BwFmGc8tA3vsd7r/7kR8DY7iEEGSU04BFxCo5jP/sfE=
-google.golang.org/api v0.18.0/go.mod h1:BwFmGc8tA3vsd7r/7kR8DY7iEEGSU04BFxCo5jP/sfE=
-google.golang.org/api v0.20.0/go.mod h1:BwFmGc8tA3vsd7r/7kR8DY7iEEGSU04BFxCo5jP/sfE=
 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/go.mod h1:i06prIuMbXzDqacNJfV5OdTW448YApPu5ww/cMBSeb0=
-google.golang.org/appengine v1.6.5/go.mod h1:8WjMMxjGQR8xUklV/ARdw2HLXBOI7O7uCIDZVag1xfc=
 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=
-google.golang.org/genproto v0.0.0-20190418145605-e7d98fc518a7/go.mod h1:VzzqZJRnGkLBvHegQrXjBqPurQTc5/KpmUdxsrq26oE=
-google.golang.org/genproto v0.0.0-20190425155659-357c62f0e4bb/go.mod h1:VzzqZJRnGkLBvHegQrXjBqPurQTc5/KpmUdxsrq26oE=
-google.golang.org/genproto v0.0.0-20190502173448-54afdca5d873/go.mod h1:VzzqZJRnGkLBvHegQrXjBqPurQTc5/KpmUdxsrq26oE=
-google.golang.org/genproto v0.0.0-20190801165951-fa694d86fc64/go.mod h1:DMBHOl98Agz4BDEuKkezgsaosCRResVns1a3J2ZsMNc=
 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-20191108220845-16a3f7862a1a/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc=
-google.golang.org/genproto v0.0.0-20191115194625-c23dd37a84c9/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc=
-google.golang.org/genproto v0.0.0-20191216164720-4f79533eabd1/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc=
-google.golang.org/genproto v0.0.0-20191230161307-f3c370f40bfb/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc=
-google.golang.org/genproto v0.0.0-20200115191322-ca5a22157cba/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc=
-google.golang.org/genproto v0.0.0-20200122232147-0452cf42e150/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc=
-google.golang.org/genproto v0.0.0-20200204135345-fa8e72b47b90/go.mod h1:GmwEX6Z4W5gMy59cAlVYjN9JhxgbQH6Gn+gFDQe2lzA=
-google.golang.org/genproto v0.0.0-20200212174721-66ed5ce911ce/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c=
-google.golang.org/genproto v0.0.0-20200224152610-e50cd9704f63/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c=
-google.golang.org/genproto v0.0.0-20200305110556-506484158171/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c=
 google.golang.org/genproto v0.0.0-20200526211855-cb27e3aa2013/go.mod h1:NbSheEEYHJ7i3ixzK3sjbqSGDJWnxyFXZblF3eUsNvo=
-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.26.0/go.mod h1:qbnxyOmOxrQa7FizSgH+ReBfzJrCY1pSN7KXBS8abTk=
 google.golang.org/grpc v1.27.0/go.mod h1:qbnxyOmOxrQa7FizSgH+ReBfzJrCY1pSN7KXBS8abTk=
-google.golang.org/grpc v1.27.1/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=
 google.golang.org/protobuf v0.0.0-20200228230310-ab0ca4ff8a60/go.mod h1:cfTl7dwQJ+fmap5saPgwCLgHXTUD7jkjRqWcaiX5VyM=
@@ -529,38 +117,12 @@ google.golang.org/protobuf v1.23.0/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2
 google.golang.org/protobuf v1.23.1-0.20200526195155-81db48ad09cc/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU=
 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/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/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=
-gopkg.in/ini.v1 v1.51.1/go.mod h1:pNLf8WUiyNEtQjuu5G5vTm06TEv9tsIgeAvK8hOrP4k=
-gopkg.in/ns1/ns1-go.v2 v2.0.0-20190730140822-b51389932cbc/go.mod h1:VV+3haRsgDiVLxyifmMBrBIuCWFBPYKbRssXB9z67Hw=
-gopkg.in/resty.v1 v1.9.1/go.mod h1:vo52Hzryw9PnPHcJfPsBiFW62XhNx5OczbV9y+IMpgc=
-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/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=
-gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
-gopkg.in/yaml.v2 v2.2.4/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
-gopkg.in/yaml.v2 v2.2.7/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
-gopkg.in/yaml.v2 v2.2.8/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
+gopkg.in/yaml.v2 v2.3.0 h1:clyUAQHOM3G0M3f5vQj7LuJrETvjVot3Z5el9nffUtU=
+gopkg.in/yaml.v2 v2.3.0/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
 gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c h1:dUUwHk2QECo/6vqA44rthZ8ie2QXMNeKRTHCNY2nXvo=
 gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
-honnef.co/go/tools v0.0.0-20180728063816-88497007e858/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=
 honnef.co/go/tools v0.0.0-20190102054323-c2f93a96b099/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=
-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/go.mod h1:a3bituU0lyd329TUQxRnasdCoJDkEUEAqEt0JzvZhAg=
-honnef.co/go/tools v0.0.1-2020.1.3 h1:sXmLre5bzIR6ypkjXCDI3jHPssRhc8KD/Ome589sc3U=
-honnef.co/go/tools v0.0.1-2020.1.3/go.mod h1:X/FiERA/W4tHapMX5mGpAtMSVEeEUOyHaw9vFzvIQ3k=
-rsc.io/binaryregexp v0.2.0/go.mod h1:qTv7/COck+e2FymRvadv62gMdZztPaShugOCi3I+8D8=
-rsc.io/quote/v3 v3.1.0/go.mod h1:yEA65RcK8LyAZtP9Kv3t0HmxON59tX3rD+tICJqUlj0=
-rsc.io/sampler v1.3.0/go.mod h1:T1hPZKmBbMNahiBKFy5HrXp6adAjACjK9JXDnKaTXpA=

logger/options.go

@@ -11,6 +11,7 @@ type Option func(*Options)
 
 // Options holds logger options
 type Options struct {
+	Name string
 	// The logging level the logger should log at. default is `InfoLevel`
 	Level Level
 	// fields to always be logged
@@ -72,3 +73,10 @@ func WithContext(ctx context.Context) Option {
 		o.Context = ctx
 	}
 }
+
+// WithName sets the name
+func withName(n string) Option {
+	return func(o *Options) {
+		o.Name = n
+	}
+}

metadata/context.go

@@ -0,0 +1,108 @@
+// Package metadata is a way of defining message headers
+package metadata
+
+import (
+	"context"
+)
+
+type mdIncomingKey struct{}
+type mdOutgoingKey struct{}
+type mdKey struct{}
+
+// FromIncomingContext returns metadata from incoming ctx
+// returned metadata shoud not be modified or race condition happens
+func FromIncomingContext(ctx context.Context) (Metadata, bool) {
+	if ctx == nil {
+		return nil, false
+	}
+	md, ok := ctx.Value(mdIncomingKey{}).(*rawMetadata)
+	if !ok {
+		return nil, false
+	}
+	return md.md, ok
+}
+
+// FromOutgoingContext returns metadata from outgoing ctx
+// returned metadata shoud not be modified or race condition happens
+func FromOutgoingContext(ctx context.Context) (Metadata, bool) {
+	if ctx == nil {
+		return nil, false
+	}
+	md, ok := ctx.Value(mdOutgoingKey{}).(*rawMetadata)
+	if !ok {
+		return nil, false
+	}
+	return md.md, ok
+}
+
+// FromContext returns metadata from the given context
+// returned metadata shoud not be modified or race condition happens
+//
+// Deprecated: use FromIncomingContext or FromOutgoingContext
+func FromContext(ctx context.Context) (Metadata, bool) {
+	if ctx == nil {
+		return nil, false
+	}
+	md, ok := ctx.Value(mdKey{}).(*rawMetadata)
+	if !ok {
+		return nil, false
+	}
+	return md.md, ok
+}
+
+// NewContext creates a new context with the given metadata
+//
+// Deprecated: use NewIncomingContext or NewOutgoingContext
+func NewContext(ctx context.Context, md Metadata) context.Context {
+	if ctx == nil {
+		ctx = context.Background()
+	}
+	ctx = context.WithValue(ctx, mdKey{}, &rawMetadata{md})
+	ctx = context.WithValue(ctx, mdIncomingKey{}, &rawMetadata{})
+	ctx = context.WithValue(ctx, mdOutgoingKey{}, &rawMetadata{})
+	return ctx
+}
+
+// SetOutgoingContext modify outgoing context with given metadata
+func SetOutgoingContext(ctx context.Context, md Metadata) bool {
+	if ctx == nil {
+		return false
+	}
+	if omd, ok := ctx.Value(mdOutgoingKey{}).(*rawMetadata); ok {
+		omd.md = md
+		return true
+	}
+	return false
+}
+
+// SetIncomingContext modify incoming context with given metadata
+func SetIncomingContext(ctx context.Context, md Metadata) bool {
+	if ctx == nil {
+		return false
+	}
+	if omd, ok := ctx.Value(mdIncomingKey{}).(*rawMetadata); ok {
+		omd.md = md
+		return true
+	}
+	return false
+}
+
+// NewIncomingContext creates a new context with incoming metadata attached
+func NewIncomingContext(ctx context.Context, md Metadata) context.Context {
+	if ctx == nil {
+		ctx = context.Background()
+	}
+	ctx = context.WithValue(ctx, mdIncomingKey{}, &rawMetadata{md})
+	ctx = context.WithValue(ctx, mdOutgoingKey{}, &rawMetadata{})
+	return ctx
+}
+
+// NewOutgoingContext creates a new context with outcoming metadata attached
+func NewOutgoingContext(ctx context.Context, md Metadata) context.Context {
+	if ctx == nil {
+		ctx = context.Background()
+	}
+	ctx = context.WithValue(ctx, mdOutgoingKey{}, &rawMetadata{md})
+	ctx = context.WithValue(ctx, mdIncomingKey{}, &rawMetadata{})
+	return ctx
+}

metadata/metadata.go

@@ -2,22 +2,58 @@
 package metadata
 
 import (
-	"context"
 	"net/textproto"
+	"sort"
 )
 
-type metadataKey struct{}
+var (
+	// HeaderPrefix for all headers passed
+	HeaderPrefix = "Micro-"
+)
 
 // Metadata is our way of representing request headers internally.
 // They're used at the RPC level and translate back and forth
 // from Transport headers.
 type Metadata map[string]string
 
+type rawMetadata struct {
+	md Metadata
+}
+
 var (
-	// DefaultMetadataSize used when need to init new Metadata
-	DefaultMetadataSize = 6
+	// defaultMetadataSize used when need to init new Metadata
+	defaultMetadataSize = 2
 )
 
+type Iterator struct {
+	cur  int
+	cnt  int
+	keys []string
+	md   Metadata
+}
+
+func (iter *Iterator) Next(k, v *string) bool {
+	if iter.cur+1 > iter.cnt {
+		return false
+	}
+
+	*k = iter.keys[iter.cur]
+	*v = iter.md[*k]
+	iter.cur++
+	return true
+}
+
+// Iterate returns run user func with map key, val sorted by key
+func (md Metadata) Iterator() *Iterator {
+	iter := &Iterator{md: md, cnt: len(md)}
+	iter.keys = make([]string, 0, iter.cnt)
+	for k := range md {
+		iter.keys = append(iter.keys, k)
+	}
+	sort.Strings(iter.keys)
+	return iter
+}
+
 // Get returns value from metadata by key
 func (md Metadata) Get(key string) (string, bool) {
 	// fast path
@@ -37,12 +73,9 @@ func (md Metadata) Set(key, val string) {
 // Del is used to remove value from metadata
 func (md Metadata) Del(key string) {
 	// fast path
-	if _, ok := md[key]; ok {
-		delete(md, key)
-	} else {
-		// slow path
-		delete(md, textproto.CanonicalMIMEHeaderKey(key))
-	}
+	delete(md, key)
+	// slow path
+	delete(md, textproto.CanonicalMIMEHeaderKey(key))
 }
 
 // Copy makes a copy of the metadata
@@ -54,75 +87,18 @@ 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 {
-		md = New(0)
-	}
-	md.Del(key)
-	return context.WithValue(ctx, metadataKey{}, md)
-}
-
-// Set add key with val to metadata
-func Set(ctx context.Context, key, val string) context.Context {
-	md, ok := FromContext(ctx)
-	if !ok {
-		md = New(0)
-	}
-	md.Set(key, val)
-	return context.WithValue(ctx, metadataKey{}, md)
-}
-
-// Get returns a single value from metadata in the context
-func Get(ctx context.Context, key string) (string, bool) {
-	md, ok := FromContext(ctx)
-	if !ok {
-		return "", ok
-	}
-	return md.Get(key)
-}
-
-// FromContext returns metadata from the given context
-func FromContext(ctx context.Context) (Metadata, bool) {
-	if ctx == nil {
-		return nil, false
-	}
-	md, ok := ctx.Value(metadataKey{}).(Metadata)
-	if !ok {
-		return nil, ok
-	}
-	nmd := Copy(md)
-	return nmd, ok
-}
-
 // New return new sized metadata
 func New(size int) Metadata {
 	if size == 0 {
-		size = DefaultMetadataSize
+		size = defaultMetadataSize
 	}
 	return make(Metadata, size)
 }
 
-// NewContext creates a new context with the given metadata
-func NewContext(ctx context.Context, md Metadata) context.Context {
-	if ctx == nil {
-		ctx = context.Background()
-	}
-	return context.WithValue(ctx, metadataKey{}, Copy(md))
-}
-
-// MergeContext merges metadata to existing metadata, overwriting if specified
-func MergeContext(ctx context.Context, pmd Metadata, overwrite bool) context.Context {
-	if ctx == nil {
-		ctx = context.Background()
-	}
-	md, ok := FromContext(ctx)
-	if !ok {
-		return context.WithValue(ctx, metadataKey{}, Copy(pmd))
-	}
-	nmd := Copy(md)
-	for key, val := range pmd {
+// Merge merges metadata to existing metadata, overwriting if specified
+func Merge(omd Metadata, mmd Metadata, overwrite bool) Metadata {
+	nmd := Copy(omd)
+	for key, val := range mmd {
 		if _, ok := nmd[key]; ok && !overwrite {
 			// skip
 		} else if val != "" {
@@ -131,5 +107,5 @@ func MergeContext(ctx context.Context, pmd Metadata, overwrite bool) context.Con
 			nmd.Del(key)
 		}
 	}
-	return context.WithValue(ctx, metadataKey{}, nmd)
+	return nmd
 }

metadata/metadata_test.go

@@ -2,26 +2,78 @@ package metadata
 
 import (
 	"context"
-	"reflect"
+	"fmt"
 	"testing"
 )
 
+func testCtx(ctx context.Context) {
+	md := New(2)
+	md.Set("Key1", "Val1_new")
+	md.Set("Key3", "Val3")
+	SetOutgoingContext(ctx, md)
+}
+
+func TestPassing(t *testing.T) {
+	ctx := context.TODO()
+	md1 := New(2)
+	md1.Set("Key1", "Val1")
+	md1.Set("Key2", "Val2")
+
+	ctx = NewIncomingContext(ctx, md1)
+	testCtx(ctx)
+	md, ok := FromOutgoingContext(ctx)
+	if !ok {
+		t.Fatalf("missing metadata from outgoing context")
+	}
+	fmt.Printf("%#+v\n", md)
+}
+
+func TestMerge(t *testing.T) {
+	omd := Metadata{
+		"key1": "val1",
+	}
+	mmd := Metadata{
+		"key2": "val2",
+	}
+
+	nmd := Merge(omd, mmd, true)
+	if len(nmd) != 2 {
+		t.Fatalf("merge failed: %v", nmd)
+	}
+}
+
+func TestIterator(t *testing.T) {
+	md := Metadata{
+		"1Last":   "last",
+		"2First":  "first",
+		"3Second": "second",
+	}
+
+	iter := md.Iterator()
+	var k, v string
+
+	for iter.Next(&k, &v) {
+		//fmt.Printf("k: %s, v: %s\n", k, v)
+	}
+}
+
 func TestMedataCanonicalKey(t *testing.T) {
-	ctx := Set(context.TODO(), "x-request-id", "12345")
-	v, ok := Get(ctx, "x-request-id")
+	md := New(1)
+	md.Set("x-request-id", "12345")
+	v, ok := md.Get("x-request-id")
 	if !ok {
 		t.Fatalf("failed to get x-request-id")
 	} else if v != "12345" {
 		t.Fatalf("invalid metadata value: %s != %s", "12345", v)
 	}
 
-	v, ok = Get(ctx, "X-Request-Id")
+	v, ok = md.Get("X-Request-Id")
 	if !ok {
 		t.Fatalf("failed to get x-request-id")
 	} else if v != "12345" {
 		t.Fatalf("invalid metadata value: %s != %s", "12345", v)
 	}
-	v, ok = Get(ctx, "X-Request-ID")
+	v, ok = md.Get("X-Request-ID")
 	if !ok {
 		t.Fatalf("failed to get x-request-id")
 	} else if v != "12345" {
@@ -31,9 +83,11 @@ func TestMedataCanonicalKey(t *testing.T) {
 }
 
 func TestMetadataSet(t *testing.T) {
-	ctx := Set(context.TODO(), "Key", "val")
+	md := New(1)
 
-	val, ok := Get(ctx, "Key")
+	md.Set("Key", "val")
+
+	val, ok := md.Get("Key")
 	if !ok {
 		t.Fatal("key Key not found")
 	}
@@ -48,15 +102,8 @@ func TestMetadataDelete(t *testing.T) {
 		"Baz": "empty",
 	}
 
-	ctx := NewContext(context.TODO(), md)
-	ctx = Del(ctx, "Baz")
-
-	emd, ok := FromContext(ctx)
-	if !ok {
-		t.Fatal("key Key not found")
-	}
-
-	_, ok = emd["Baz"]
+	md.Del("Baz")
+	_, ok := md.Get("Baz")
 	if ok {
 		t.Fatal("key Baz not deleted")
 	}
@@ -107,42 +154,3 @@ func TestMetadataContext(t *testing.T) {
 		t.Errorf("Expected metadata length 1 got %d", i)
 	}
 }
-
-func TestMergeContext(t *testing.T) {
-	type args struct {
-		existing  Metadata
-		append    Metadata
-		overwrite bool
-	}
-	tests := []struct {
-		name string
-		args args
-		want Metadata
-	}{
-		{
-			name: "matching key, overwrite false",
-			args: args{
-				existing:  Metadata{"Foo": "bar", "Sumo": "demo"},
-				append:    Metadata{"Sumo": "demo2"},
-				overwrite: false,
-			},
-			want: Metadata{"Foo": "bar", "Sumo": "demo"},
-		},
-		{
-			name: "matching key, overwrite true",
-			args: args{
-				existing:  Metadata{"Foo": "bar", "Sumo": "demo"},
-				append:    Metadata{"Sumo": "demo2"},
-				overwrite: true,
-			},
-			want: Metadata{"Foo": "bar", "Sumo": "demo2"},
-		},
-	}
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			if got, _ := FromContext(MergeContext(NewContext(context.TODO(), tt.args.existing), tt.args.append, tt.args.overwrite)); !reflect.DeepEqual(got, tt.want) {
-				t.Errorf("MergeContext() = %v, want %v", got, tt.want)
-			}
-		})
-	}
-}

meter/README.md

@@ -1,22 +0,0 @@
-metrics
-=======
-
-The metrics package provides a simple metrics "Reporter" interface which allows the user to submit counters, gauges and timings (along with key/value tags).
-
-Implementations
----------------
-
-* Prometheus (pull): will be first
-* Prometheus (push): certainly achievable
-* InfluxDB: could quite easily be done
-* Telegraf: almost identical to the InfluxDB implementation
-* Micro: Could we provide metrics over Micro's server interface?
-
-
-Todo
-----
-
-* Include a handler middleware which uses the Reporter interface to generate per-request level metrics
-    - Throughput
-    - Errors
-    - Duration

meter/context.go

@@ -0,0 +1,34 @@
+package meter
+
+import (
+	"context"
+)
+
+type meterKey struct{}
+
+// FromContext get meter from context
+func FromContext(ctx context.Context) (Meter, bool) {
+	if ctx == nil {
+		return nil, false
+	}
+	c, ok := ctx.Value(meterKey{}).(Meter)
+	return c, ok
+}
+
+// NewContext put meter in context
+func NewContext(ctx context.Context, c Meter) context.Context {
+	if ctx == nil {
+		ctx = context.Background()
+	}
+	return context.WithValue(ctx, meterKey{}, 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)
+	}
+}

meter/meter.go

@@ -0,0 +1,127 @@
+// Package meter is for instrumentation
+package meter
+
+import (
+	"io"
+	"sort"
+	"time"
+)
+
+var (
+	// DefaultMeter is the default meter
+	DefaultMeter Meter = NewMeter()
+	// DefaultAddress data will be made available on this host:port
+	DefaultAddress = ":9090"
+	// DefaultPath the meter endpoint where the Meter data will be made available
+	DefaultPath = "/metrics"
+	// timingObjectives is the default spread of stats we maintain for timings / histograms:
+	//defaultTimingObjectives = map[float64]float64{0.0: 0, 0.5: 0.05, 0.75: 0.04, 0.90: 0.03, 0.95: 0.02, 0.98: 0.001, 1: 0}
+	// default metric prefix
+	DefaultMetricPrefix = "micro_"
+	// default label prefix
+	DefaultLabelPrefix = "micro_"
+)
+
+// Meter is an interface for collecting and instrumenting metrics
+type Meter interface {
+	Name() string
+	Init(...Option) error
+	Counter(string, ...Option) Counter
+	FloatCounter(string, ...Option) FloatCounter
+	Gauge(string, func() float64, ...Option) Gauge
+	Set(...Option) Meter
+	Histogram(string, ...Option) Histogram
+	Summary(string, ...Option) Summary
+	SummaryExt(string, time.Duration, []float64, ...Option) Summary
+	Write(io.Writer, bool) error
+	Options() Options
+	String() string
+}
+
+// Counter is a counter
+type Counter interface {
+	Add(int)
+	Dec()
+	Get() uint64
+	Inc()
+	Set(uint64)
+}
+
+// FloatCounter is a float64 counter
+type FloatCounter interface {
+	Add(float64)
+	Get() float64
+	Set(float64)
+	Sub(float64)
+}
+
+// Gauge is a float64 gauge
+type Gauge interface {
+	Get() float64
+}
+
+// Histogram is a histogram for non-negative values with automatically created buckets
+type Histogram interface {
+	Reset()
+	Update(float64)
+	UpdateDuration(time.Time)
+	// VisitNonZeroBuckets(f func(vmrange string, count uint64))
+}
+
+// Summary is the summary
+type Summary interface {
+	Update(float64)
+	UpdateDuration(time.Time)
+}
+
+type Labels struct {
+	keys []string
+	vals []string
+}
+
+func (ls Labels) Len() int {
+	return len(ls.keys)
+}
+
+func (ls Labels) Swap(i, j int) {
+	ls.keys[i], ls.keys[j] = ls.keys[j], ls.keys[i]
+	ls.vals[i], ls.vals[j] = ls.vals[j], ls.vals[i]
+}
+
+func (ls Labels) Less(i, j int) bool {
+	return ls.vals[i] < ls.vals[j]
+}
+
+func (ls Labels) Sort() {
+	sort.Sort(ls)
+}
+
+func (ls Labels) Append(nls Labels) Labels {
+	for n := range nls.keys {
+		ls.keys = append(ls.keys, nls.keys[n])
+		ls.vals = append(ls.vals, nls.vals[n])
+	}
+	return ls
+}
+
+type LabelIter struct {
+	labels Labels
+	cnt    int
+	cur    int
+}
+
+func (ls Labels) Iter() *LabelIter {
+	ls.Sort()
+	return &LabelIter{labels: ls, cnt: len(ls.keys)}
+}
+
+func (iter *LabelIter) Next(k, v *string) bool {
+	if iter.cur+1 > iter.cnt {
+		return false
+	}
+
+	*k = iter.labels.keys[iter.cur]
+	*v = iter.labels.vals[iter.cur]
+	iter.cur++
+	return true
+}

meter/meter_test.go

@@ -0,0 +1,63 @@
+package meter
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestNoopMeter(t *testing.T) {
+	meter := NewMeter(Path("/noop"))
+	assert.NotNil(t, meter)
+	assert.Equal(t, "/noop", meter.Options().Path)
+	assert.Implements(t, new(Meter), meter)
+
+	cnt := meter.Counter("counter", Label("server", "noop"))
+	cnt.Inc()
+
+}
+
+func TestLabels(t *testing.T) {
+	var ls Labels
+	ls.keys = []string{"type", "server"}
+	ls.vals = []string{"noop", "http"}
+
+	ls.Sort()
+
+	if ls.keys[0] != "server" || ls.vals[0] != "http" {
+		t.Fatalf("sort error: %v", ls)
+	}
+}
+
+func TestLabelsAppend(t *testing.T) {
+	var ls Labels
+	ls.keys = []string{"type", "server"}
+	ls.vals = []string{"noop", "http"}
+
+	var nls Labels
+	nls.keys = []string{"register"}
+	nls.vals = []string{"gossip"}
+	ls = ls.Append(nls)
+
+	ls.Sort()
+
+	if ls.keys[0] != "register" || ls.vals[0] != "gossip" {
+		t.Fatalf("append error: %v", ls)
+	}
+}
+
+func TestIterator(t *testing.T) {
+	var ls Labels
+	ls.keys = []string{"type", "server", "register"}
+	ls.vals = []string{"noop", "http", "gossip"}
+
+	iter := ls.Iter()
+	var k, v string
+	cnt := 0
+	for iter.Next(&k, &v) {
+		if cnt == 1 && (k != "server" || v != "http") {
+			t.Fatalf("iter error: %s != %s || %s != %s", k, "server", v, "http")
+		}
+		cnt++
+	}
+}

meter/noop.go

@@ -1,47 +1,162 @@
-package metrics
+package meter
 
 import (
+	"io"
 	"time"
-
-	"github.com/unistack-org/micro/v3/metadata"
 )
 
-// NoopReporter is an noop implementation of Reporter:
-type noopReporter struct {
-	opts Options
+// NoopMeter is an noop implementation of Meter
+type noopMeter struct {
+	opts   Options
+	labels Labels
 }
 
-// NewReporter returns a configured noop reporter:
-func NewReporter(opts ...Option) Reporter {
-	return &noopReporter{
-		opts: NewOptions(opts...),
-	}
+// NewMeter returns a configured noop reporter:
+func NewMeter(opts ...Option) Meter {
+	return &noopMeter{opts: NewOptions(opts...)}
+}
+
+func (r *noopMeter) Name() string {
+	return r.opts.Name
 }
 
 // Init initialize options
-func (r *noopReporter) Init(opts ...Option) error {
+func (r *noopMeter) 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 {
+// Counter implements the Meter interface
+func (r *noopMeter) Counter(name string, opts ...Option) Counter {
+	options := Options{}
+	for _, o := range opts {
+		o(&options)
+	}
+	return &noopCounter{labels: options.Labels}
+}
+
+// FloatCounter implements the Meter interface
+func (r *noopMeter) FloatCounter(name string, opts ...Option) FloatCounter {
+	return &noopFloatCounter{}
+}
+
+// Gauge implements the Meter interface
+func (r *noopMeter) Gauge(name string, f func() float64, opts ...Option) Gauge {
+	return &noopGauge{}
+}
+
+// Summary implements the Meter interface
+func (r *noopMeter) Summary(name string, opts ...Option) Summary {
+	return &noopSummary{}
+}
+
+// SummaryExt implements the Meter interface
+func (r *noopMeter) SummaryExt(name string, window time.Duration, quantiles []float64, opts ...Option) Summary {
+	return &noopSummary{}
+}
+
+// Histogram implements the Meter interface
+func (r *noopMeter) Histogram(name string, opts ...Option) Histogram {
+	return &noopHistogram{}
+}
+
+// Set implements the Meter interface
+func (r *noopMeter) Set(opts ...Option) Meter {
+	m := &noopMeter{opts: r.opts}
+
+	for _, o := range opts {
+		o(&m.opts)
+	}
+
+	return m
+}
+
+func (r *noopMeter) Write(w io.Writer, withProcessMetrics bool) 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 {
+// Options implements the Meter interface
+func (r *noopMeter) Options() Options {
 	return r.opts
 }
+
+// String implements the Meter interface
+func (r *noopMeter) String() string {
+	return "noop"
+}
+
+type noopCounter struct {
+	labels Labels
+}
+
+func (r *noopCounter) Add(int) {
+
+}
+
+func (r *noopCounter) Dec() {
+
+}
+
+func (r *noopCounter) Get() uint64 {
+	return 0
+}
+
+func (r *noopCounter) Inc() {
+
+}
+
+func (r *noopCounter) Set(uint64) {
+
+}
+
+type noopFloatCounter struct{}
+
+func (r *noopFloatCounter) Add(float64) {
+
+}
+
+func (r *noopFloatCounter) Get() float64 {
+	return 0
+}
+
+func (r *noopFloatCounter) Set(float64) {
+
+}
+
+func (r *noopFloatCounter) Sub(float64) {
+
+}
+
+type noopGauge struct{}
+
+func (r *noopGauge) Get() float64 {
+	return 0
+}
+
+type noopSummary struct{}
+
+func (r *noopSummary) Update(float64) {
+
+}
+
+func (r *noopSummary) UpdateDuration(time.Time) {
+
+}
+
+type noopHistogram struct{}
+
+func (r *noopHistogram) Reset() {
+
+}
+
+func (r *noopHistogram) Update(float64) {
+
+}
+
+func (r *noopHistogram) UpdateDuration(time.Time) {
+
+}
+
+//func (r *noopHistogram) VisitNonZeroBuckets(f func(vmrange string, count uint64)) {}

meter/options.go

@@ -1,19 +1,9 @@
-package metrics
+package meter
 
 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:
-	defaultPrometheusListenAddress = ":9000"
-	// This is the endpoint where the Prometheus metrics will be made available ("/metrics" is the default with Prometheus):
-	defaultPath = "/metrics"
-	// timingObjectives is the default spread of stats we maintain for timings / histograms:
-	defaultTimingObjectives = map[float64]float64{0.0: 0, 0.5: 0.05, 0.75: 0.04, 0.90: 0.03, 0.95: 0.02, 0.98: 0.001, 1: 0}
 )
 
 // Option powers the configuration for metrics implementations:
@@ -21,22 +11,26 @@ type Option func(*Options)
 
 // Options for metrics implementations:
 type Options struct {
-	Address          string
-	Path             string
-	DefaultTags      metadata.Metadata
-	TimingObjectives map[float64]float64
-	Logger           logger.Logger
-	Context          context.Context
+	Name    string
+	Address string
+	Path    string
+	Labels  Labels
+	//TimingObjectives map[float64]float64
+	Logger       logger.Logger
+	Context      context.Context
+	MetricPrefix string
+	LabelPrefix  string
 }
 
 // NewOptions prepares a set of options:
 func NewOptions(opt ...Option) Options {
 	opts := Options{
-		Address:          defaultPrometheusListenAddress,
-		DefaultTags:      metadata.New(2),
-		Path:             defaultPath,
-		TimingObjectives: defaultTimingObjectives,
-		Context:          context.Background(),
+		Address:      DefaultAddress,
+		Path:         DefaultPath,
+		Context:      context.Background(),
+		Logger:       logger.DefaultLogger,
+		MetricPrefix: DefaultMetricPrefix,
+		LabelPrefix:  DefaultLabelPrefix,
 	}
 
 	for _, o := range opt {
@@ -46,40 +40,44 @@ func NewOptions(opt ...Option) Options {
 	return opts
 }
 
-// Cntext sets the metrics context
+// Context sets the metrics context
 func Context(ctx context.Context) Option {
 	return func(o *Options) {
 		o.Context = ctx
 	}
 }
 
-// Path used to serve metrics over HTTP:
+// Path used to serve metrics over HTTP
 func Path(value string) Option {
 	return func(o *Options) {
 		o.Path = value
 	}
 }
 
-// Address is the listen address to serve metrics on:
+// Address is the listen address to serve metrics
 func Address(value string) Option {
 	return func(o *Options) {
 		o.Address = value
 	}
 }
 
-// DefaultTags will be added to every metric:
-func DefaultTags(md metadata.Metadata) Option {
+/*
+// Labels be added to every metric
+func Labels(labels []string) Option {
 	return func(o *Options) {
-		o.DefaultTags = metadata.Copy(md)
+		o.Labels = labels
 	}
 }
+*/
 
+/*
 // TimingObjectives defines the desired spread of statistics for histogram / timing metrics:
 func TimingObjectives(value map[float64]float64) Option {
 	return func(o *Options) {
 		o.TimingObjectives = value
 	}
 }
+*/
 
 // Logger sets the logger
 func Logger(l logger.Logger) Option {
@@ -87,3 +85,18 @@ func Logger(l logger.Logger) Option {
 		o.Logger = l
 	}
 }
+
+// Label sets the label
+func Label(key, val string) Option {
+	return func(o *Options) {
+		o.Labels.keys = append(o.Labels.keys, key)
+		o.Labels.vals = append(o.Labels.vals, val)
+	}
+}
+
+// Name sets the name
+func Name(n string) Option {
+	return func(o *Options) {
+		o.Name = n
+	}
+}

meter/reporter.go

@@ -1,21 +0,0 @@
-// Package metrics is for instrumentation and debugging
-package metrics
-
-import (
-	"time"
-
-	"github.com/unistack-org/micro/v3/metadata"
-)
-
-var (
-	DefaultReporter Reporter = NewReporter()
-)
-
-// Reporter is an interface for collecting and instrumenting metrics
-type Reporter interface {
-	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
-}

meter/reporter_test.go

@@ -1,17 +0,0 @@
-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)
-}

meter/wrapper/metrics_wrapper.go

@@ -1,50 +0,0 @@
-package wrapper
-
-import (
-	"context"
-	"time"
-
-	"github.com/unistack-org/micro/v3/metadata"
-	"github.com/unistack-org/micro/v3/meter"
-	"github.com/unistack-org/micro/v3/server"
-)
-
-// Wrapper provides a HandlerFunc for meter.Reporter implementations:
-type Wrapper struct {
-	reporter meter.Reporter
-}
-
-// New returns a *Wrapper configured with the given meter.Reporter:
-func New(reporter meter.Reporter) *Wrapper {
-	return &Wrapper{
-		reporter: reporter,
-	}
-}
-
-// HandlerFunc instruments handlers registered to a service:
-func (w *Wrapper) HandlerFunc(handlerFunction server.HandlerFunc) server.HandlerFunc {
-	return func(ctx context.Context, req server.Request, rsp interface{}) error {
-
-		// Build some tags to describe the call:
-		tags := metadata.New(2)
-		tags.Set("method", req.Method())
-
-		// Start the clock:
-		callTime := time.Now()
-
-		// Run the handlerFunction:
-		err := handlerFunction(ctx, req, rsp)
-
-		// Add a result tag:
-		if err != nil {
-			tags["status"] = "failure"
-		} else {
-			tags["status"] = "success"
-		}
-
-		// Instrument the result (if the DefaultClient has been configured):
-		w.reporter.Timing("service.handler", time.Since(callTime), tags)
-
-		return err
-	}
-}

meter/wrapper/wrapper.go

@@ -0,0 +1,232 @@
+// +build ignore
+
+package wrapper
+
+import (
+	"context"
+	"fmt"
+	"time"
+
+	"github.com/unistack-org/micro/v3/client"
+	"github.com/unistack-org/micro/v3/meter"
+	"github.com/unistack-org/micro/v3/server"
+)
+
+type Options struct {
+	Meter   meter.Meter
+	Name    string
+	Version string
+	ID      string
+}
+
+type Option func(*Options)
+
+func ServiceName(name string) Option {
+	return func(o *Options) {
+		o.Name = name
+	}
+}
+
+func ServiceVersion(version string) Option {
+	return func(o *Options) {
+		o.Version = version
+	}
+}
+
+func ServiceID(id string) Option {
+	return func(o *Options) {
+		o.ID = id
+	}
+}
+
+func Meter(m meter.Meter) Option {
+	return func(o *Options) {
+		o.Meter = m
+	}
+}
+
+type wrapper struct {
+	options  Options
+	callFunc client.CallFunc
+	client.Client
+}
+
+func NewClientWrapper(opts ...Option) client.Wrapper {
+	return func(c client.Client) client.Client {
+		handler := &wrapper{
+			labels: labels,
+			Client: c,
+		}
+
+		return handler
+	}
+}
+
+func NewCallWrapper(opts ...Option) client.CallWrapper {
+	labels := getLabels(opts...)
+
+	return func(fn client.CallFunc) client.CallFunc {
+		handler := &wrapper{
+			labels:   labels,
+			callFunc: fn,
+		}
+
+		return handler.CallFunc
+	}
+}
+
+func (w *wrapper) CallFunc(ctx context.Context, addr string, req client.Request, rsp interface{}, opts client.CallOptions) error {
+	endpoint := fmt.Sprintf("%s.%s", req.Service(), req.Endpoint())
+	wlabels := append(w.labels, fmt.Sprintf(`%sendpoint="%s"`, DefaultLabelPrefix, endpoint))
+
+	timeCounterSummary := metrics.GetOrCreateSummary(getName("client_request_latency_microseconds", wlabels))
+	timeCounterHistogram := metrics.GetOrCreateSummary(getName("client_request_duration_seconds", wlabels))
+
+	ts := time.Now()
+	err := w.callFunc(ctx, addr, req, rsp, opts)
+	te := time.Since(ts)
+
+	timeCounterSummary.Update(float64(te.Seconds()))
+	timeCounterHistogram.Update(te.Seconds())
+	if err == nil {
+		metrics.GetOrCreateCounter(getName("client_request_total", append(wlabels, fmt.Sprintf(`%sstatus="success"`, DefaultLabelPrefix)))).Inc()
+	} else {
+		metrics.GetOrCreateCounter(getName("client_request_total", append(wlabels, fmt.Sprintf(`%sstatus="failure"`, DefaultLabelPrefix)))).Inc()
+	}
+
+	return err
+}
+
+func (w *wrapper) Call(ctx context.Context, req client.Request, rsp interface{}, opts ...client.CallOption) error {
+	endpoint := fmt.Sprintf("%s.%s", req.Service(), req.Endpoint())
+	wlabels := append(w.labels, fmt.Sprintf(`%sendpoint="%s"`, DefaultLabelPrefix, endpoint))
+
+	timeCounterSummary := metrics.GetOrCreateSummary(getName("client_request_latency_microseconds", wlabels))
+	timeCounterHistogram := metrics.GetOrCreateSummary(getName("client_request_duration_seconds", wlabels))
+
+	ts := time.Now()
+	err := w.Client.Call(ctx, req, rsp, opts...)
+	te := time.Since(ts)
+
+	timeCounterSummary.Update(float64(te.Seconds()))
+	timeCounterHistogram.Update(te.Seconds())
+	if err == nil {
+		metrics.GetOrCreateCounter(getName("client_request_total", append(wlabels, fmt.Sprintf(`%sstatus="success"`, DefaultLabelPrefix)))).Inc()
+	} else {
+		metrics.GetOrCreateCounter(getName("client_request_total", append(wlabels, fmt.Sprintf(`%sstatus="failure"`, DefaultLabelPrefix)))).Inc()
+	}
+
+	return err
+}
+
+func (w *wrapper) Stream(ctx context.Context, req client.Request, opts ...client.CallOption) (client.Stream, error) {
+	endpoint := fmt.Sprintf("%s.%s", req.Service(), req.Endpoint())
+	wlabels := append(w.labels, fmt.Sprintf(`%sendpoint="%s"`, DefaultLabelPrefix, endpoint))
+
+	timeCounterSummary := metrics.GetOrCreateSummary(getName("client_request_latency_microseconds", wlabels))
+	timeCounterHistogram := metrics.GetOrCreateSummary(getName("client_request_duration_seconds", wlabels))
+
+	ts := time.Now()
+	stream, err := w.Client.Stream(ctx, req, opts...)
+	te := time.Since(ts)
+
+	timeCounterSummary.Update(float64(te.Seconds()))
+	timeCounterHistogram.Update(te.Seconds())
+	if err == nil {
+		metrics.GetOrCreateCounter(getName("client_request_total", append(wlabels, fmt.Sprintf(`%sstatus="success"`, DefaultLabelPrefix)))).Inc()
+	} else {
+		metrics.GetOrCreateCounter(getName("client_request_total", append(wlabels, fmt.Sprintf(`%sstatus="failure"`, DefaultLabelPrefix)))).Inc()
+	}
+
+	return stream, err
+}
+
+func (w *wrapper) Publish(ctx context.Context, p client.Message, opts ...client.PublishOption) error {
+	endpoint := p.Topic()
+	wlabels := append(w.labels, fmt.Sprintf(`%sendpoint="%s"`, DefaultLabelPrefix, endpoint))
+
+	timeCounterSummary := metrics.GetOrCreateSummary(getName("publish_message_latency_microseconds", wlabels))
+	timeCounterHistogram := metrics.GetOrCreateSummary(getName("publish_message_duration_seconds", wlabels))
+
+	ts := time.Now()
+	err := w.Client.Publish(ctx, p, opts...)
+	te := time.Since(ts)
+
+	timeCounterSummary.Update(float64(te.Seconds()))
+	timeCounterHistogram.Update(te.Seconds())
+	if err == nil {
+		metrics.GetOrCreateCounter(getName("publish_message_total", append(wlabels, fmt.Sprintf(`%sstatus="success"`, DefaultLabelPrefix)))).Inc()
+	} else {
+		metrics.GetOrCreateCounter(getName("publish_message_total", append(wlabels, fmt.Sprintf(`%sstatus="failure"`, DefaultLabelPrefix)))).Inc()
+	}
+
+	return err
+}
+
+func NewHandlerWrapper(opts ...Option) server.HandlerWrapper {
+	labels := getLabels(opts...)
+
+	handler := &wrapper{
+		labels: labels,
+	}
+
+	return handler.HandlerFunc
+}
+
+func (w *wrapper) HandlerFunc(fn server.HandlerFunc) server.HandlerFunc {
+	return func(ctx context.Context, req server.Request, rsp interface{}) error {
+		endpoint := req.Endpoint()
+		wlabels := append(w.labels, fmt.Sprintf(`%sendpoint="%s"`, DefaultLabelPrefix, endpoint))
+
+		timeCounterSummary := metrics.GetOrCreateSummary(getName("server_request_latency_microseconds", wlabels))
+		timeCounterHistogram := metrics.GetOrCreateSummary(getName("server_request_duration_seconds", wlabels))
+
+		ts := time.Now()
+		err := fn(ctx, req, rsp)
+		te := time.Since(ts)
+
+		timeCounterSummary.Update(float64(te.Seconds()))
+		timeCounterHistogram.Update(te.Seconds())
+		if err == nil {
+			metrics.GetOrCreateCounter(getName("server_request_total", append(wlabels, fmt.Sprintf(`%sstatus="success"`, DefaultLabelPrefix)))).Inc()
+		} else {
+			metrics.GetOrCreateCounter(getName("server_request_total", append(wlabels, fmt.Sprintf(`%sstatus="failure"`, DefaultLabelPrefix)))).Inc()
+		}
+
+		return err
+	}
+}
+
+func NewSubscriberWrapper(opts ...Option) server.SubscriberWrapper {
+	labels := getLabels(opts...)
+
+	handler := &wrapper{
+		labels: labels,
+	}
+
+	return handler.SubscriberFunc
+}
+
+func (w *wrapper) SubscriberFunc(fn server.SubscriberFunc) server.SubscriberFunc {
+	return func(ctx context.Context, msg server.Message) error {
+		endpoint := msg.Topic()
+		wlabels := append(w.labels, fmt.Sprintf(`%sendpoint="%s"`, DefaultLabelPrefix, endpoint))
+
+		timeCounterSummary := metrics.GetOrCreateSummary(getName("subscribe_message_latency_microseconds", wlabels))
+		timeCounterHistogram := metrics.GetOrCreateSummary(getName("subscribe_message_duration_seconds", wlabels))
+
+		ts := time.Now()
+		err := fn(ctx, msg)
+		te := time.Since(ts)
+
+		timeCounterSummary.Update(float64(te.Seconds()))
+		timeCounterHistogram.Update(te.Seconds())
+		if err == nil {
+			metrics.GetOrCreateCounter(getName("subscribe_message_total", append(wlabels, fmt.Sprintf(`%sstatus="success"`, DefaultLabelPrefix)))).Inc()
+		} else {
+			metrics.GetOrCreateCounter(getName("subscribe_message_total", append(wlabels, fmt.Sprintf(`%sstatus="failure"`, DefaultLabelPrefix)))).Inc()
+		}
+
+		return err
+	}
+}

micro.go

@@ -1,119 +0,0 @@
-// Package micro is a pluggable framework for microservices
-package micro
-
-import (
-	"context"
-
-	"github.com/unistack-org/micro/v3/broker"
-	"github.com/unistack-org/micro/v3/client"
-	"github.com/unistack-org/micro/v3/server"
-)
-
-type serviceKey struct{}
-
-// Service is an interface that wraps the lower level libraries
-// within micro. Its a convenience method for building
-// and initialising services.
-type Service interface {
-	// The service name
-	Name() string
-	// Init initialises options
-	Init(...Option) error
-	// Options returns the current options
-	Options() Options
-	// Client is used to call services
-	Client() client.Client
-	// Server is for handling requests and events
-	Server() server.Server
-	// Broker is for broker usage
-	Broker() broker.Broker
-	// Run the service
-	Run() error
-	// The service implementation
-	String() string
-}
-
-// Function is a one time executing Service
-type Function interface {
-	// Inherits Service interface
-	Service
-	// Done signals to complete execution
-	Done() error
-	// Handle registers an RPC handler
-	Handle(v interface{}) error
-	// Subscribe registers a subscriber
-	Subscribe(topic string, v interface{}) error
-}
-
-/*
-// Type Event is a future type for acting on asynchronous events
-type Event interface {
-	// Publish publishes a message to the event topic
-	Publish(ctx context.Context, msg interface{}, opts ...client.PublishOption) error
-	// Subscribe to the event
-	Subscribe(ctx context.Context, v in
-}
-
-// Resource is a future type for defining dependencies
-type Resource interface {
-	// Name of the resource
-	Name() string
-	// Type of resource
-	Type() string
-	// Method of creation
-	Create() error
-}
-*/
-
-// Event is used to publish messages to a topic
-type Event interface {
-	// Publish publishes a message to the event topic
-	Publish(ctx context.Context, msg interface{}, opts ...client.PublishOption) error
-}
-
-var (
-	// HeaderPrefix for all headers passed
-	HeaderPrefix = "Micro-"
-)
-
-// NewService creates and returns a new Service based on the packages within.
-func NewService(opts ...Option) Service {
-	return newService(opts...)
-}
-
-// 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)
-}
-
-// NewFunction returns a new Function for a one time executing Service
-func NewFunction(opts ...Option) Function {
-	return newFunction(opts...)
-}
-
-// NewEvent creates a new event publisher
-func NewEvent(topic string, c client.Client) Event {
-	return &event{c, topic}
-}
-
-// RegisterHandler is syntactic sugar for registering a handler
-func RegisterHandler(s server.Server, h interface{}, opts ...server.HandlerOption) error {
-	return s.Handle(s.NewHandler(h, opts...))
-}
-
-// RegisterSubscriber is syntactic sugar for registering a subscriber
-func RegisterSubscriber(topic string, s server.Server, h interface{}, opts ...server.SubscriberOption) error {
-	return s.Subscribe(s.NewSubscriber(topic, h, opts...))
-}

network/options.go

@@ -3,9 +3,11 @@ package network
 import (
 	"github.com/google/uuid"
 	"github.com/unistack-org/micro/v3/logger"
+	"github.com/unistack-org/micro/v3/meter"
 	"github.com/unistack-org/micro/v3/network/tunnel"
 	"github.com/unistack-org/micro/v3/proxy"
 	"github.com/unistack-org/micro/v3/router"
+	"github.com/unistack-org/micro/v3/tracer"
 )
 
 // Option func
@@ -31,6 +33,10 @@ type Options struct {
 	Proxy proxy.Proxy
 	// Logger
 	Logger logger.Logger
+	// Meter
+	Meter meter.Meter
+	// Tracer
+	Tracer tracer.Tracer
 }
 
 // Id sets the id of the network node
@@ -96,11 +102,34 @@ func Logger(l logger.Logger) Option {
 	}
 }
 
-// DefaultOptions returns network default options
-func DefaultOptions() Options {
-	return Options{
+// Meter sets the meter
+func Meter(m meter.Meter) Option {
+	return func(o *Options) {
+		o.Meter = m
+	}
+}
+
+// Tracer to be used for tracing
+func Tracer(t tracer.Tracer) Option {
+	return func(o *Options) {
+		o.Tracer = t
+	}
+}
+
+// NewOptions returns network default options
+func NewOptions(opts ...Option) Options {
+	options := Options{
 		Id:      uuid.New().String(),
 		Name:    "go.micro",
 		Address: ":0",
+		Logger:  logger.DefaultLogger,
+		Meter:   meter.DefaultMeter,
+		Tracer:  tracer.DefaultTracer,
 	}
+
+	for _, o := range opts {
+		o(&options)
+	}
+
+	return options
 }

network/transport/memory.go

@@ -0,0 +1,263 @@
+package transport
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"math/rand"
+	"net"
+	"sync"
+	"time"
+
+	maddr "github.com/unistack-org/micro/v3/util/addr"
+	mnet "github.com/unistack-org/micro/v3/util/net"
+)
+
+type memorySocket struct {
+	recv chan *Message
+	send chan *Message
+	// sock exit
+	exit chan bool
+	// listener exit
+	lexit chan bool
+
+	local  string
+	remote string
+
+	// for send/recv transport.Timeout
+	timeout time.Duration
+	ctx     context.Context
+	sync.RWMutex
+}
+
+type memoryClient struct {
+	*memorySocket
+	opts DialOptions
+}
+
+type memoryListener struct {
+	addr  string
+	exit  chan bool
+	conn  chan *memorySocket
+	lopts ListenOptions
+	topts Options
+	sync.RWMutex
+	ctx context.Context
+}
+
+type memoryTransport struct {
+	opts Options
+	sync.RWMutex
+	listeners map[string]*memoryListener
+}
+
+func (ms *memorySocket) Recv(m *Message) error {
+	ms.RLock()
+	defer ms.RUnlock()
+
+	ctx := ms.ctx
+	if ms.timeout > 0 {
+		var cancel context.CancelFunc
+		ctx, cancel = context.WithTimeout(ms.ctx, ms.timeout)
+		defer cancel()
+	}
+
+	select {
+	case <-ctx.Done():
+		return ctx.Err()
+	case <-ms.exit:
+		return errors.New("connection closed")
+	case <-ms.lexit:
+		return errors.New("server connection closed")
+	case cm := <-ms.recv:
+		*m = *cm
+	}
+	return nil
+}
+
+func (ms *memorySocket) Local() string {
+	return ms.local
+}
+
+func (ms *memorySocket) Remote() string {
+	return ms.remote
+}
+
+func (ms *memorySocket) Send(m *Message) error {
+	ms.RLock()
+	defer ms.RUnlock()
+
+	ctx := ms.ctx
+	if ms.timeout > 0 {
+		var cancel context.CancelFunc
+		ctx, cancel = context.WithTimeout(ms.ctx, ms.timeout)
+		defer cancel()
+	}
+
+	select {
+	case <-ctx.Done():
+		return ctx.Err()
+	case <-ms.exit:
+		return errors.New("connection closed")
+	case <-ms.lexit:
+		return errors.New("server connection closed")
+	case ms.send <- m:
+	}
+	return nil
+}
+
+func (ms *memorySocket) Close() error {
+	ms.Lock()
+	defer ms.Unlock()
+	select {
+	case <-ms.exit:
+		return nil
+	default:
+		close(ms.exit)
+	}
+	return nil
+}
+
+func (m *memoryListener) Addr() string {
+	return m.addr
+}
+
+func (m *memoryListener) Close() error {
+	m.Lock()
+	defer m.Unlock()
+	select {
+	case <-m.exit:
+		return nil
+	default:
+		close(m.exit)
+	}
+	return nil
+}
+
+func (m *memoryListener) Accept(fn func(Socket)) error {
+	for {
+		select {
+		case <-m.exit:
+			return nil
+		case c := <-m.conn:
+			go fn(&memorySocket{
+				lexit:   c.lexit,
+				exit:    c.exit,
+				send:    c.recv,
+				recv:    c.send,
+				local:   c.Remote(),
+				remote:  c.Local(),
+				timeout: m.topts.Timeout,
+				ctx:     m.topts.Context,
+			})
+		}
+	}
+}
+
+func (m *memoryTransport) Dial(ctx context.Context, addr string, opts ...DialOption) (Client, error) {
+	m.RLock()
+	defer m.RUnlock()
+
+	listener, ok := m.listeners[addr]
+	if !ok {
+		return nil, errors.New("could not dial " + addr)
+	}
+
+	options := NewDialOptions(opts...)
+
+	client := &memoryClient{
+		&memorySocket{
+			send:    make(chan *Message),
+			recv:    make(chan *Message),
+			exit:    make(chan bool),
+			lexit:   listener.exit,
+			local:   addr,
+			remote:  addr,
+			timeout: m.opts.Timeout,
+			ctx:     m.opts.Context,
+		},
+		options,
+	}
+
+	// pseudo connect
+	select {
+	case <-listener.exit:
+		return nil, errors.New("connection error")
+	case listener.conn <- client.memorySocket:
+	}
+
+	return client, nil
+}
+
+func (m *memoryTransport) Listen(ctx context.Context, addr string, opts ...ListenOption) (Listener, error) {
+	m.Lock()
+	defer m.Unlock()
+
+	options := NewListenOptions(opts...)
+
+	host, port, err := net.SplitHostPort(addr)
+	if err != nil {
+		return nil, err
+	}
+
+	addr, err = maddr.Extract(host)
+	if err != nil {
+		return nil, err
+	}
+
+	// if zero port then randomly assign one
+	if len(port) > 0 && port == "0" {
+		i := rand.Intn(20000)
+		port = fmt.Sprintf("%d", 10000+i)
+	}
+
+	// set addr with port
+	addr = mnet.HostPort(addr, port)
+
+	if _, ok := m.listeners[addr]; ok {
+		return nil, errors.New("already listening on " + addr)
+	}
+
+	listener := &memoryListener{
+		lopts: options,
+		topts: m.opts,
+		addr:  addr,
+		conn:  make(chan *memorySocket),
+		exit:  make(chan bool),
+		ctx:   m.opts.Context,
+	}
+
+	m.listeners[addr] = listener
+
+	return listener, nil
+}
+
+func (m *memoryTransport) Init(opts ...Option) error {
+	for _, o := range opts {
+		o(&m.opts)
+	}
+	return nil
+}
+
+func (m *memoryTransport) Options() Options {
+	return m.opts
+}
+
+func (m *memoryTransport) String() string {
+	return "memory"
+}
+
+func (m *memoryTransport) Name() string {
+	return m.opts.Name
+}
+
+func NewTransport(opts ...Option) Transport {
+	options := NewOptions(opts...)
+
+	rand.Seed(time.Now().UnixNano())
+
+	return &memoryTransport{
+		opts:      options,
+		listeners: make(map[string]*memoryListener),
+	}
+}

network/transport/memory_test.go

@@ -0,0 +1,93 @@
+package transport
+
+import (
+	"context"
+	"os"
+	"testing"
+)
+
+func TestMemoryTransport(t *testing.T) {
+	tr := NewTransport()
+	ctx := context.Background()
+	// bind / listen
+	l, err := tr.Listen(ctx, "127.0.0.1:8080")
+	if err != nil {
+		t.Fatalf("Unexpected error listening %v", err)
+	}
+	defer l.Close()
+
+	// accept
+	go func() {
+		if err := l.Accept(func(sock Socket) {
+			for {
+				var m Message
+				if err := sock.Recv(&m); err != nil {
+					return
+				}
+				if len(os.Getenv("INTEGRATION_TESTS")) == 0 {
+					t.Logf("Server Received %s", string(m.Body))
+				}
+				if err := sock.Send(&Message{
+					Body: []byte(`pong`),
+				}); err != nil {
+					return
+				}
+			}
+		}); err != nil {
+			t.Fatalf("Unexpected error accepting %v", err)
+		}
+	}()
+
+	// dial
+	c, err := tr.Dial(ctx, "127.0.0.1:8080")
+	if err != nil {
+		t.Fatalf("Unexpected error dialing %v", err)
+	}
+	defer c.Close()
+
+	// send <=> receive
+	for i := 0; i < 3; i++ {
+		if err := c.Send(&Message{
+			Body: []byte(`ping`),
+		}); err != nil {
+			return
+		}
+		var m Message
+		if err := c.Recv(&m); err != nil {
+			return
+		}
+		if len(os.Getenv("INTEGRATION_TESTS")) == 0 {
+			t.Logf("Client Received %s", string(m.Body))
+		}
+	}
+
+}
+
+func TestListener(t *testing.T) {
+	tr := NewTransport()
+	ctx := context.Background()
+	// bind / listen on random port
+	l, err := tr.Listen(ctx, ":0")
+	if err != nil {
+		t.Fatalf("Unexpected error listening %v", err)
+	}
+	defer l.Close()
+
+	// try again
+	l2, err := tr.Listen(ctx, ":0")
+	if err != nil {
+		t.Fatalf("Unexpected error listening %v", err)
+	}
+	defer l2.Close()
+
+	// now make sure it still fails
+	l3, err := tr.Listen(ctx, ":8080")
+	if err != nil {
+		t.Fatalf("Unexpected error listening %v", err)
+	}
+	defer l3.Close()
+
+	if _, err := tr.Listen(ctx, ":8080"); err == nil {
+		t.Fatal("Expected error binding to :8080 got nil")
+	}
+}

network/transport/noop.go

@@ -1,77 +0,0 @@
-package transport
-
-import "context"
-
-type noopTransport struct {
-	opts Options
-}
-
-// NewTransport creates new noop transport
-func NewTransport(opts ...Option) Transport {
-	return &noopTransport{opts: NewOptions(opts...)}
-}
-
-func (t *noopTransport) Init(opts ...Option) error {
-	for _, o := range opts {
-		o(&t.opts)
-	}
-	return nil
-}
-
-func (t *noopTransport) Options() Options {
-	return t.opts
-}
-
-func (t *noopTransport) Dial(ctx context.Context, addr string, opts ...DialOption) (Client, error) {
-	options := NewDialOptions(opts...)
-	return &noopClient{opts: options}, nil
-}
-
-func (t *noopTransport) Listen(ctx context.Context, addr string, opts ...ListenOption) (Listener, error) {
-	options := NewListenOptions(opts...)
-	return &noopListener{opts: options}, nil
-}
-
-func (t *noopTransport) String() string {
-	return "noop"
-}
-
-type noopClient struct {
-	opts DialOptions
-}
-
-func (c *noopClient) Close() error {
-	return nil
-}
-
-func (c *noopClient) Local() string {
-	return ""
-}
-
-func (c *noopClient) Remote() string {
-	return ""
-}
-
-func (c *noopClient) Recv(*Message) error {
-	return nil
-}
-
-func (c *noopClient) Send(*Message) error {
-	return nil
-}
-
-type noopListener struct {
-	opts ListenOptions
-}
-
-func (l *noopListener) Addr() string {
-	return ""
-}
-
-func (l *noopListener) Accept(fn func(Socket)) error {
-	return nil
-}
-
-func (l *noopListener) Close() error {
-	return nil
-}

network/transport/options.go

@@ -7,9 +7,12 @@ import (
 
 	"github.com/unistack-org/micro/v3/codec"
 	"github.com/unistack-org/micro/v3/logger"
+	"github.com/unistack-org/micro/v3/meter"
+	"github.com/unistack-org/micro/v3/tracer"
 )
 
 type Options struct {
+	Name string
 	// Addrs is the list of intermediary addresses to connect to
 	Addrs []string
 	// Codec is the codec interface to use where headers are not supported
@@ -26,6 +29,10 @@ type Options struct {
 	Timeout time.Duration
 	// Logger sets the logger
 	Logger logger.Logger
+	// Meter sets the meter
+	Meter meter.Meter
+	// Tracer
+	Tracer tracer.Tracer
 	// Other options for implementations of the interface
 	// can be stored in a context
 	Context context.Context
@@ -35,6 +42,8 @@ type Options struct {
 func NewOptions(opts ...Option) Options {
 	options := Options{
 		Logger:  logger.DefaultLogger,
+		Meter:   meter.DefaultMeter,
+		Tracer:  tracer.DefaultTracer,
 		Context: context.Background(),
 	}
 
@@ -112,6 +121,13 @@ func Logger(l logger.Logger) Option {
 	}
 }
 
+// Meter sets the meter
+func Meter(m meter.Meter) Option {
+	return func(o *Options) {
+		o.Meter = m
+	}
+}
+
 // Context sets the context
 func Context(ctx context.Context) Option {
 	return func(o *Options) {
@@ -134,14 +150,6 @@ func Timeout(t time.Duration) Option {
 	}
 }
 
-// Use secure communication. If TLSConfig is not specified we
-// use InsecureSkipVerify and generate a self signed cert
-func Secure(b bool) Option {
-	return func(o *Options) {
-		o.Secure = b
-	}
-}
-
 // TLSConfig to be used for the transport.
 func TLSConfig(t *tls.Config) Option {
 	return func(o *Options) {
@@ -162,3 +170,17 @@ func WithTimeout(d time.Duration) DialOption {
 		o.Timeout = d
 	}
 }
+
+// Tracer to be used for tracing
+func Tracer(t tracer.Tracer) Option {
+	return func(o *Options) {
+		o.Tracer = t
+	}
+}
+
+// Name sets the name
+func Name(n string) Option {
+	return func(o *Options) {
+		o.Name = n
+	}
+}

network/tunnel/broker/broker.go

@@ -41,6 +41,10 @@ func (t *tunBroker) Init(opts ...broker.Option) error {
 	return nil
 }
 
+func (t *tunBroker) Name() string {
+	return t.opts.Name
+}
+
 func (t *tunBroker) Options() broker.Options {
 	return t.opts
 }

network/tunnel/options.go

@@ -5,7 +5,9 @@ import (
 
 	"github.com/google/uuid"
 	"github.com/unistack-org/micro/v3/logger"
+	"github.com/unistack-org/micro/v3/meter"
 	"github.com/unistack-org/micro/v3/network/transport"
+	"github.com/unistack-org/micro/v3/tracer"
 )
 
 var (
@@ -20,6 +22,7 @@ type Option func(*Options)
 
 // Options provides network configuration options
 type Options struct {
+	Name string
 	// Id is tunnel id
 	Id string
 	// Address is tunnel address
@@ -32,6 +35,10 @@ type Options struct {
 	Transport transport.Transport
 	// Logger
 	Logger logger.Logger
+	// Meter
+	Meter meter.Meter
+	// Tracer
+	Tracer tracer.Tracer
 }
 
 // DialOption func
@@ -74,6 +81,13 @@ func Logger(l logger.Logger) Option {
 	}
 }
 
+// Meter sets the meter
+func Meter(m meter.Meter) Option {
+	return func(o *Options) {
+		o.Meter = m
+	}
+}
+
 // Address sets the tunnel address
 func Address(a string) Option {
 	return func(o *Options) {
@@ -152,9 +166,26 @@ func NewOptions(opts ...Option) Options {
 		Id:      uuid.New().String(),
 		Address: DefaultAddress,
 		Token:   DefaultToken,
+		Logger:  logger.DefaultLogger,
+		Meter:   meter.DefaultMeter,
+		Tracer:  tracer.DefaultTracer,
 	}
 	for _, o := range opts {
 		o(&options)
 	}
 	return options
 }
+
+// Tracer to be used for tracing
+func Tracer(t tracer.Tracer) Option {
+	return func(o *Options) {
+		o.Tracer = t
+	}
+}
+
+// Name sets the name
+func Name(n string) Option {
+	return func(o *Options) {
+		o.Name = n
+	}
+}

options.go

@@ -2,37 +2,44 @@ package micro
 
 import (
 	"context"
+	"fmt"
 	"time"
 
 	"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/metadata"
-	"github.com/unistack-org/micro/v3/registry"
+	"github.com/unistack-org/micro/v3/meter"
+	"github.com/unistack-org/micro/v3/register"
 	"github.com/unistack-org/micro/v3/router"
-	"github.com/unistack-org/micro/v3/runtime"
-	"github.com/unistack-org/micro/v3/selector"
 	"github.com/unistack-org/micro/v3/server"
 	"github.com/unistack-org/micro/v3/store"
 	"github.com/unistack-org/micro/v3/tracer"
+	//	"github.com/unistack-org/micro/v3/debug/profile"
+	//	"github.com/unistack-org/micro/v3/runtime"
 )
 
 // Options for micro service
 type Options struct {
-	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
+	Name     string
+	Version  string
+	Metadata metadata.Metadata
+
+	Auths     []auth.Auth
+	Brokers   []broker.Broker
+	Loggers   []logger.Logger
+	Meters    []meter.Meter
+	Configs   []config.Config
+	Clients   []client.Client
+	Servers   []server.Server
+	Stores    []store.Store
+	Registers []register.Register
+	Tracers   []tracer.Tracer
+	Routers   []router.Router
+	//	Runtime  runtime.Runtime
+	//	Profile  profile.Profile
 
 	// Before and After funcs
 	BeforeStart []func(context.Context) error
@@ -48,16 +55,18 @@ 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,
-		Configs:  []config.Config{config.DefaultConfig},
-		Store:    store.DefaultStore,
+		Context:   context.Background(),
+		Servers:   []server.Server{server.DefaultServer},
+		Clients:   []client.Client{client.DefaultClient},
+		Brokers:   []broker.Broker{broker.DefaultBroker},
+		Registers: []register.Register{register.DefaultRegister},
+		Routers:   []router.Router{router.DefaultRouter},
+		Auths:     []auth.Auth{auth.DefaultAuth},
+		Loggers:   []logger.Logger{logger.DefaultLogger},
+		Tracers:   []tracer.Tracer{tracer.DefaultTracer},
+		Meters:    []meter.Meter{meter.DefaultMeter},
+		Configs:   []config.Config{config.DefaultConfig},
+		Stores:    []store.Store{store.DefaultStore},
 		//Runtime   runtime.Runtime
 		//Profile   profile.Profile
 	}
@@ -70,264 +79,599 @@ func NewOptions(opts ...Option) Options {
 }
 
 // Option func
-type Option func(*Options)
+type Option func(*Options) error
 
-// Broker to be used for service
-func Broker(b broker.Broker) Option {
-	return func(o *Options) {
-		o.Broker = b
-		if o.Client != nil {
-			// Update Client and Server
-			o.Client.Init(client.Broker(b))
+// Broker to be used for client and server
+func Broker(b broker.Broker, opts ...BrokerOption) Option {
+	return func(o *Options) error {
+		var err error
+		bopts := brokerOptions{}
+		for _, opt := range opts {
+			opt(&bopts)
 		}
-		if o.Server != nil {
-			o.Server.Init(server.Broker(b))
+		all := false
+		if len(opts) == 0 {
+			all = true
 		}
+		for _, srv := range o.Servers {
+			for _, os := range bopts.servers {
+				if srv.Name() == os || all {
+					if err = srv.Init(server.Broker(b)); err != nil {
+						return err
+					}
+				}
+			}
+		}
+		for _, cli := range o.Clients {
+			for _, oc := range bopts.clients {
+				if cli.Name() == oc || all {
+					if err = cli.Init(client.Broker(b)); err != nil {
+						return err
+					}
+				}
+			}
+		}
+		return nil
+	}
+}
+
+type brokerOptions struct {
+	servers []string
+	clients []string
+}
+
+type BrokerOption func(*brokerOptions)
+
+func BrokerClient(n string) BrokerOption {
+	return func(o *brokerOptions) {
+		o.clients = append(o.clients, n)
+	}
+}
+
+func BrokerServer(n string) BrokerOption {
+	return func(o *brokerOptions) {
+		o.servers = append(o.servers, n)
 	}
 }
 
 // Client to be used for service
-func Client(c client.Client) Option {
-	return func(o *Options) {
-		o.Client = c
+func Client(c ...client.Client) Option {
+	return func(o *Options) error {
+		o.Clients = c
+		return nil
+	}
+}
+
+// Clients to be used for service
+func Clients(c ...client.Client) Option {
+	return func(o *Options) error {
+		o.Clients = c
+		return nil
 	}
 }
 
 // Context specifies a context for the service.
 // Can be used to signal shutdown of the service and for extra option values.
 func Context(ctx context.Context) Option {
-	return func(o *Options) {
+	return func(o *Options) error {
+		// TODO: Pass context to underline stuff ?
 		o.Context = ctx
+		return nil
 	}
 }
 
+/*
 // Profile to be used for debug profile
 func Profile(p profile.Profile) Option {
 	return func(o *Options) {
 		o.Profile = p
 	}
 }
+*/
 
 // Server to be used for service
-func Server(s server.Server) Option {
-	return func(o *Options) {
-		o.Server = s
+func Server(s ...server.Server) Option {
+	return func(o *Options) error {
+		o.Servers = s
+		return nil
+	}
+}
+
+// Servers to be used for service
+func Servers(s ...server.Server) Option {
+	return func(o *Options) error {
+		o.Servers = s
+		return nil
 	}
 }
 
 // Store sets the store to use
-func Store(s store.Store) Option {
-	return func(o *Options) {
-		o.Store = s
+func Store(s ...store.Store) Option {
+	return func(o *Options) error {
+		o.Stores = s
+		return nil
+	}
+}
+
+// Stores sets the store to use
+func Stores(s ...store.Store) Option {
+	return func(o *Options) error {
+		o.Stores = s
+		return nil
 	}
 }
 
 // Logger set the logger to use
-func Logger(l logger.Logger) Option {
-	return func(o *Options) {
-		o.Logger = l
+func Logger(l logger.Logger, opts ...LoggerOption) Option {
+	return func(o *Options) error {
+		var err error
+		lopts := loggerOptions{}
+		for _, opt := range opts {
+			opt(&lopts)
+		}
+		all := false
+		if len(opts) == 0 {
+			all = true
+		}
+		for _, srv := range o.Servers {
+			for _, os := range lopts.servers {
+				if srv.Name() == os || all {
+					if err = srv.Init(server.Logger(l)); err != nil {
+						return err
+					}
+				}
+			}
+		}
+		for _, cli := range o.Clients {
+			for _, oc := range lopts.clients {
+				if cli.Name() == oc || all {
+					if err = cli.Init(client.Logger(l)); err != nil {
+						return err
+					}
+				}
+			}
+		}
+		for _, brk := range o.Brokers {
+			for _, ob := range lopts.brokers {
+				if brk.Name() == ob || all {
+					if err = brk.Init(broker.Logger(l)); err != nil {
+						return err
+					}
+				}
+			}
+		}
+		for _, reg := range o.Registers {
+			for _, or := range lopts.registers {
+				if reg.Name() == or || all {
+					if err = reg.Init(register.Logger(l)); err != nil {
+						return err
+					}
+				}
+			}
+		}
+		for _, str := range o.Stores {
+			for _, or := range lopts.stores {
+				if str.Name() == or || all {
+					if err = str.Init(store.Logger(l)); err != nil {
+						return err
+					}
+				}
+			}
+		}
+		for _, mtr := range o.Meters {
+			for _, or := range lopts.meters {
+				if mtr.Name() == or || all {
+					if err = mtr.Init(meter.Logger(l)); err != nil {
+						return err
+					}
+				}
+			}
+		}
+		for _, trc := range o.Tracers {
+			for _, ot := range lopts.tracers {
+				if trc.Name() == ot || all {
+					if err = trc.Init(tracer.Logger(l)); err != nil {
+						return err
+					}
+				}
+			}
+		}
+
+		return nil
 	}
 }
 
-// Registry sets the registry for the service
+type LoggerOption func(*loggerOptions)
+
+type loggerOptions struct {
+	servers   []string
+	clients   []string
+	brokers   []string
+	registers []string
+	stores    []string
+	meters    []string
+	tracers   []string
+}
+
+/*
+func LoggerServer(n string) LoggerOption {
+
+}
+*/
+
+// Meter set the meter to use
+func Meter(m ...meter.Meter) Option {
+	return func(o *Options) error {
+		o.Meters = m
+		return nil
+	}
+}
+
+// Meters set the meter to use
+func Meters(m ...meter.Meter) Option {
+	return func(o *Options) error {
+		o.Meters = m
+		return nil
+	}
+}
+
+// Register sets the register for the service
 // and the underlying components
-func Registry(r registry.Registry) Option {
-	return func(o *Options) {
-		o.Registry = r
-		if o.Router != nil {
-			// Update router
-			o.Router.Init(router.Registry(r))
+func Register(r register.Register, opts ...RegisterOption) Option {
+	return func(o *Options) error {
+		var err error
+		ropts := registerOptions{}
+		for _, opt := range opts {
+			opt(&ropts)
 		}
-		if o.Server != nil {
-			// Update server
-			o.Server.Init(server.Registry(r))
+		all := false
+		if len(opts) == 0 {
+			all = true
 		}
-		if o.Broker != nil {
-			// Update Broker
-			o.Broker.Init(broker.Registry(r))
+		for _, rtr := range o.Routers {
+			for _, os := range ropts.routers {
+				if rtr.Name() == os || all {
+					if err = rtr.Init(router.Register(r)); err != nil {
+						return err
+					}
+				}
+			}
 		}
+		for _, srv := range o.Servers {
+			for _, os := range ropts.servers {
+				if srv.Name() == os || all {
+					if err = srv.Init(server.Register(r)); err != nil {
+						return err
+					}
+				}
+			}
+		}
+		for _, brk := range o.Brokers {
+			for _, os := range ropts.brokers {
+				if brk.Name() == os || all {
+					if err = brk.Init(broker.Register(r)); err != nil {
+						return err
+					}
+				}
+			}
+		}
+		return nil
 	}
 }
 
-// Tracer sets the tracer for the service
-func Tracer(t tracer.Tracer) Option {
-	return func(o *Options) {
-		if o.Server != nil {
-			//todo client trace
-			o.Server.Init(server.Tracer(t))
-		}
+type registerOptions struct {
+	routers []string
+	servers []string
+	brokers []string
+}
+
+type RegisterOption func(*registerOptions)
+
+func RegisterRouter(n string) RegisterOption {
+	return func(o *registerOptions) {
+		o.routers = append(o.routers, n)
 	}
 }
 
+func RegisterServer(n string) RegisterOption {
+	return func(o *registerOptions) {
+		o.servers = append(o.servers, n)
+	}
+}
+
+func RegisterBroker(n string) RegisterOption {
+	return func(o *registerOptions) {
+		o.brokers = append(o.brokers, n)
+	}
+}
+
+func Tracer(t tracer.Tracer, opts ...TracerOption) Option {
+	return func(o *Options) error {
+		var err error
+		topts := tracerOptions{}
+		for _, opt := range opts {
+			opt(&topts)
+		}
+		all := false
+		if len(opts) == 0 {
+			all = true
+		}
+		for _, srv := range o.Servers {
+			for _, os := range topts.servers {
+				if srv.Name() == os || all {
+					if err = srv.Init(server.Tracer(t)); err != nil {
+						return err
+					}
+				}
+			}
+		}
+		for _, cli := range o.Clients {
+			for _, os := range topts.clients {
+				if cli.Name() == os || all {
+					if err = cli.Init(client.Tracer(t)); err != nil {
+						return err
+					}
+				}
+			}
+		}
+		for _, str := range o.Stores {
+			for _, os := range topts.stores {
+				if str.Name() == os || all {
+					if err = str.Init(store.Tracer(t)); err != nil {
+						return err
+					}
+				}
+			}
+		}
+		for _, brk := range o.Brokers {
+			for _, os := range topts.brokers {
+				if brk.Name() == os || all {
+					if err = brk.Init(broker.Tracer(t)); err != nil {
+						return err
+					}
+				}
+			}
+		}
+		return nil
+	}
+}
+
+type tracerOptions struct {
+	clients []string
+	servers []string
+	brokers []string
+	stores  []string
+}
+
+type TracerOption func(*tracerOptions)
+
+func TracerClient(n string) TracerOption {
+	return func(o *tracerOptions) {
+		o.clients = append(o.clients, n)
+	}
+}
+
+func TracerServer(n string) TracerOption {
+	return func(o *tracerOptions) {
+		o.servers = append(o.servers, n)
+	}
+}
+
+func TracerBroker(n string) TracerOption {
+	return func(o *tracerOptions) {
+		o.brokers = append(o.brokers, n)
+	}
+}
+
+func TracerStore(n string) TracerOption {
+	return func(o *tracerOptions) {
+		o.stores = append(o.stores, n)
+	}
+}
+
+/*
 // Auth sets the auth for the service
 func Auth(a auth.Auth) Option {
-	return func(o *Options) {
+	return func(o *Options) error {
 		o.Auth = a
 		if o.Server != nil {
 			o.Server.Init(server.Auth(a))
 		}
+		return nil
+	}
+}
+*/
+
+// Config sets the config for the service
+func Config(c ...config.Config) Option {
+	return func(o *Options) error {
+		o.Configs = c
+		return nil
 	}
 }
 
 // Configs sets the configs for the service
 func Configs(c ...config.Config) Option {
-	return func(o *Options) {
+	return func(o *Options) error {
 		o.Configs = c
+		return nil
 	}
 }
 
+/*
 // Selector sets the selector for the service client
 func Selector(s selector.Selector) Option {
-	return func(o *Options) {
+	return func(o *Options) error {
 		if o.Client != nil {
 			o.Client.Init(client.Selector(s))
 		}
+		return nil
 	}
 }
-
+*/
+/*
 // Runtime sets the runtime
 func Runtime(r runtime.Runtime) Option {
 	return func(o *Options) {
 		o.Runtime = r
 	}
 }
+*/
 
 // Router sets the router
-func Router(r router.Router) Option {
-	return func(o *Options) {
-		o.Router = r
-		// Update client
-		if o.Client != nil {
-			o.Client.Init(client.Router(r))
+func Router(r router.Router, opts ...RouterOption) Option {
+	return func(o *Options) error {
+		var err error
+		ropts := routerOptions{}
+		for _, opt := range opts {
+			opt(&ropts)
 		}
+		all := false
+		if len(opts) == 0 {
+			all = true
+		}
+		for _, cli := range o.Clients {
+			for _, os := range ropts.clients {
+				if cli.Name() == os || all {
+					if err = cli.Init(client.Router(r)); err != nil {
+						return err
+					}
+				}
+			}
+		}
+		return nil
+	}
+}
+
+type routerOptions struct {
+	clients []string
+}
+
+type RouterOption func(*routerOptions)
+
+func RouterClient(n string) RouterOption {
+	return func(o *routerOptions) {
+		o.clients = append(o.clients, n)
 	}
 }
 
 // Address sets the address of the server
 func Address(addr string) Option {
-	return func(o *Options) {
-		if o.Server != nil {
-			o.Server.Init(server.Address(addr))
+	return func(o *Options) error {
+		switch len(o.Servers) {
+		case 0:
+			return fmt.Errorf("cant set address on nil server")
+		case 1:
+			break
+		default:
+			return fmt.Errorf("cant set same address for multiple servers")
 		}
+		return o.Servers[0].Init(server.Address(addr))
 	}
 }
 
 // Name of the service
 func Name(n string) Option {
-	return func(o *Options) {
-		if o.Server != nil {
-			o.Server.Init(server.Name(n))
-		}
+	return func(o *Options) error {
+		o.Name = n
+		return nil
 	}
 }
 
 // Version of the service
 func Version(v string) Option {
-	return func(o *Options) {
-		if o.Server != nil {
-			o.Server.Init(server.Version(v))
-		}
+	return func(o *Options) error {
+		o.Version = v
+		return nil
 	}
 }
 
 // Metadata associated with the service
 func Metadata(md metadata.Metadata) Option {
-	return func(o *Options) {
-		if o.Server != nil {
-			o.Server.Init(server.Metadata(md))
-		}
+	return func(o *Options) error {
+		o.Metadata = metadata.Copy(md)
+		return nil
 	}
 }
 
 // RegisterTTL specifies the TTL to use when registering the service
-func RegisterTTL(t time.Duration) Option {
-	return func(o *Options) {
-		if o.Server != nil {
-			o.Server.Init(server.RegisterTTL(t))
+func RegisterTTL(td time.Duration, opts ...RegisterOption) Option {
+	return func(o *Options) error {
+		var err error
+		ropts := registerOptions{}
+		for _, opt := range opts {
+			opt(&ropts)
 		}
+		all := false
+		if len(opts) == 0 {
+			all = true
+		}
+		for _, srv := range o.Servers {
+			for _, os := range ropts.servers {
+				if srv.Name() == os || all {
+					if err = srv.Init(server.RegisterTTL(td)); err != nil {
+						return err
+					}
+				}
+			}
+		}
+		return nil
 	}
 }
 
 // RegisterInterval specifies the interval on which to re-register
-func RegisterInterval(t time.Duration) Option {
-	return func(o *Options) {
-		if o.Server != nil {
-			o.Server.Init(server.RegisterInterval(t))
+func RegisterInterval(td time.Duration, opts ...RegisterOption) Option {
+	return func(o *Options) error {
+		var err error
+		ropts := registerOptions{}
+		for _, opt := range opts {
+			opt(&ropts)
 		}
-	}
-}
-
-// WrapClient is a convenience method for wrapping a Client with
-// some middleware component. A list of wrappers can be provided.
-// Wrappers are applied in reverse order so the last is executed first.
-func WrapClient(w ...client.Wrapper) Option {
-	return func(o *Options) {
-		// apply in reverse
-		for i := len(w); i > 0; i-- {
-			o.Client = w[i-1](o.Client)
+		all := false
+		if len(opts) == 0 {
+			all = true
 		}
-	}
-}
-
-// WrapCall is a convenience method for wrapping a Client CallFunc
-func WrapCall(w ...client.CallWrapper) Option {
-	return func(o *Options) {
-		o.Client.Init(client.WrapCall(w...))
-	}
-}
-
-// WrapHandler adds a handler Wrapper to a list of options passed into the server
-func WrapHandler(w ...server.HandlerWrapper) Option {
-	return func(o *Options) {
-		var wrappers []server.Option
-
-		for _, wrap := range w {
-			wrappers = append(wrappers, server.WrapHandler(wrap))
+		for _, srv := range o.Servers {
+			for _, os := range ropts.servers {
+				if srv.Name() == os || all {
+					if err = srv.Init(server.RegisterInterval(td)); err != nil {
+						return err
+					}
+				}
+			}
 		}
-
-		// Init once
-		o.Server.Init(wrappers...)
-	}
-}
-
-// WrapSubscriber adds a subscriber Wrapper to a list of options passed into the server
-func WrapSubscriber(w ...server.SubscriberWrapper) Option {
-	return func(o *Options) {
-		var wrappers []server.Option
-
-		for _, wrap := range w {
-			wrappers = append(wrappers, server.WrapSubscriber(wrap))
-		}
-
-		// Init once
-		o.Server.Init(wrappers...)
+		return nil
 	}
 }
 
 // BeforeStart run funcs before service starts
 func BeforeStart(fn func(context.Context) error) Option {
-	return func(o *Options) {
+	return func(o *Options) error {
 		o.BeforeStart = append(o.BeforeStart, fn)
+		return nil
 	}
 }
 
 // BeforeStop run funcs before service stops
 func BeforeStop(fn func(context.Context) error) Option {
-	return func(o *Options) {
+	return func(o *Options) error {
 		o.BeforeStop = append(o.BeforeStop, fn)
+		return nil
 	}
 }
 
 // AfterStart run funcs after service starts
 func AfterStart(fn func(context.Context) error) Option {
-	return func(o *Options) {
+	return func(o *Options) error {
 		o.AfterStart = append(o.AfterStart, fn)
+		return nil
 	}
 }
 
 // AfterStop run funcs after service stops
 func AfterStop(fn func(context.Context) error) Option {
-	return func(o *Options) {
+	return func(o *Options) error {
 		o.AfterStop = append(o.AfterStop, fn)
+		return nil
 	}
 }

proxy/options.go

@@ -4,7 +4,9 @@ package proxy
 import (
 	"github.com/unistack-org/micro/v3/client"
 	"github.com/unistack-org/micro/v3/logger"
+	"github.com/unistack-org/micro/v3/meter"
 	"github.com/unistack-org/micro/v3/router"
+	"github.com/unistack-org/micro/v3/tracer"
 )
 
 // Options for proxy
@@ -19,11 +21,29 @@ type Options struct {
 	Links map[string]client.Client
 	// Logger
 	Logger logger.Logger
+	// Meter
+	Meter meter.Meter
+	// Tracer
+	Tracer tracer.Tracer
 }
 
 // Option func signature
 type Option func(o *Options)
 
+func NewOptions(opts ...Option) Options {
+	options := Options{
+		Logger: logger.DefaultLogger,
+		Meter:  meter.DefaultMeter,
+		Tracer: tracer.DefaultTracer,
+	}
+
+	for _, o := range opts {
+		o(&options)
+	}
+
+	return options
+}
+
 // WithEndpoint sets a proxy endpoint
 func WithEndpoint(e string) Option {
 	return func(o *Options) {
@@ -52,6 +72,13 @@ func WithLogger(l logger.Logger) Option {
 	}
 }
 
+// WithMeter specifies the meter to use
+func WithMeter(m meter.Meter) Option {
+	return func(o *Options) {
+		o.Meter = m
+	}
+}
+
 // WithLink sets a link for outbound requests
 func WithLink(name string, c client.Client) Option {
 	return func(o *Options) {
@@ -61,3 +88,10 @@ func WithLink(name string, c client.Client) Option {
 		o.Links[name] = c
 	}
 }
+
+// Tracer to be used for tracing
+func Tracer(t tracer.Tracer) Option {
+	return func(o *Options) {
+		o.Tracer = t
+	}
+}

register/context.go

@@ -1,26 +1,26 @@
-package registry
+package register
 
 import (
 	"context"
 )
 
-type registryKey struct{}
+type registerKey struct{}
 
-// FromContext get registry from context
-func FromContext(ctx context.Context) (Registry, bool) {
+// FromContext get register from context
+func FromContext(ctx context.Context) (Register, bool) {
 	if ctx == nil {
 		return nil, false
 	}
-	c, ok := ctx.Value(registryKey{}).(Registry)
+	c, ok := ctx.Value(registerKey{}).(Register)
 	return c, ok
 }
 
-// NewContext put registry in context
-func NewContext(ctx context.Context, c Registry) context.Context {
+// NewContext put register in context
+func NewContext(ctx context.Context, c Register) context.Context {
 	if ctx == nil {
 		ctx = context.Background()
 	}
-	return context.WithValue(ctx, registryKey{}, c)
+	return context.WithValue(ctx, registerKey{}, c)
 }
 
 // SetOption returns a function to setup a context with given value

register/extractor.go

@@ -1,4 +1,4 @@
-package registry
+package register
 
 import (
 	"fmt"

register/extractor_test.go

@@ -1,4 +1,4 @@
-package registry
+package register
 
 import (
 	"context"

register/memory.go

@@ -0,0 +1,541 @@
+package register
+
+import (
+	"context"
+	"errors"
+	"sync"
+	"time"
+
+	"github.com/google/uuid"
+	"github.com/unistack-org/micro/v3/logger"
+)
+
+var (
+	sendEventTime = 10 * time.Millisecond
+	ttlPruneTime  = time.Second
+)
+
+type node struct {
+	*Node
+	TTL      time.Duration
+	LastSeen time.Time
+}
+
+type record struct {
+	Name      string
+	Version   string
+	Metadata  map[string]string
+	Nodes     map[string]*node
+	Endpoints []*Endpoint
+}
+
+type memory struct {
+	opts Options
+	// records is a KV map with domain name as the key and a services map as the value
+	records  map[string]services
+	watchers map[string]*watcher
+	sync.RWMutex
+}
+
+// services is a KV map with service name as the key and a map of records as the value
+type services map[string]map[string]*record
+
+// NewRegister returns an initialized in-memory register
+func NewRegister(opts ...Option) Register {
+	r := &memory{
+		opts:     NewOptions(opts...),
+		records:  make(map[string]services),
+		watchers: make(map[string]*watcher),
+	}
+
+	go r.ttlPrune()
+
+	return r
+}
+
+func (m *memory) ttlPrune() {
+	prune := time.NewTicker(ttlPruneTime)
+	defer prune.Stop()
+
+	for {
+		select {
+		case <-prune.C:
+			m.Lock()
+			for domain, services := range m.records {
+				for service, versions := range services {
+					for version, record := range versions {
+						for id, n := range record.Nodes {
+							if n.TTL != 0 && time.Since(n.LastSeen) > n.TTL {
+								if m.opts.Logger.V(logger.DebugLevel) {
+									m.opts.Logger.Debugf(m.opts.Context, "Register TTL expired for node %s of service %s", n.Id, service)
+								}
+								delete(m.records[domain][service][version].Nodes, id)
+							}
+						}
+					}
+				}
+			}
+			m.Unlock()
+		}
+	}
+}
+
+func (m *memory) sendEvent(r *Result) {
+	m.RLock()
+	watchers := make([]*watcher, 0, len(m.watchers))
+	for _, w := range m.watchers {
+		watchers = append(watchers, w)
+	}
+	m.RUnlock()
+
+	for _, w := range watchers {
+		select {
+		case <-w.exit:
+			m.Lock()
+			delete(m.watchers, w.id)
+			m.Unlock()
+		default:
+			select {
+			case w.res <- r:
+			case <-time.After(sendEventTime):
+			}
+		}
+	}
+}
+
+func (m *memory) Connect(ctx context.Context) error {
+	return nil
+}
+
+func (m *memory) Disconnect(ctx context.Context) error {
+	return nil
+}
+
+func (m *memory) Init(opts ...Option) error {
+	for _, o := range opts {
+		o(&m.opts)
+	}
+
+	// add services
+	m.Lock()
+	defer m.Unlock()
+
+	return nil
+}
+
+func (m *memory) Options() Options {
+	return m.opts
+}
+
+func (m *memory) Register(ctx context.Context, s *Service, opts ...RegisterOption) error {
+	m.Lock()
+	defer m.Unlock()
+
+	options := NewRegisterOptions(opts...)
+
+	// get the services for this domain from the register
+	srvs, ok := m.records[options.Domain]
+	if !ok {
+		srvs = make(services)
+	}
+
+	// domain is set in metadata so it can be passed to watchers
+	if s.Metadata == nil {
+		s.Metadata = map[string]string{"domain": options.Domain}
+	} else {
+		s.Metadata["domain"] = options.Domain
+	}
+
+	// ensure the service name exists
+	r := serviceToRecord(s, options.TTL)
+	if _, ok := srvs[s.Name]; !ok {
+		srvs[s.Name] = make(map[string]*record)
+	}
+
+	if _, ok := srvs[s.Name][s.Version]; !ok {
+		srvs[s.Name][s.Version] = r
+		if m.opts.Logger.V(logger.DebugLevel) {
+			m.opts.Logger.Debugf(m.opts.Context, "Register added new service: %s, version: %s", s.Name, s.Version)
+		}
+		m.records[options.Domain] = srvs
+		go m.sendEvent(&Result{Action: "create", Service: s})
+	}
+
+	var addedNodes bool
+
+	for _, n := range s.Nodes {
+		// check if already exists
+		if _, ok := srvs[s.Name][s.Version].Nodes[n.Id]; ok {
+			continue
+		}
+
+		metadata := make(map[string]string)
+
+		// make copy of metadata
+		for k, v := range n.Metadata {
+			metadata[k] = v
+		}
+
+		// set the domain
+		metadata["domain"] = options.Domain
+
+		// add the node
+		srvs[s.Name][s.Version].Nodes[n.Id] = &node{
+			Node: &Node{
+				Id:       n.Id,
+				Address:  n.Address,
+				Metadata: metadata,
+			},
+			TTL:      options.TTL,
+			LastSeen: time.Now(),
+		}
+
+		addedNodes = true
+	}
+
+	if addedNodes {
+		if m.opts.Logger.V(logger.DebugLevel) {
+			m.opts.Logger.Debugf(m.opts.Context, "Register added new node to service: %s, version: %s", s.Name, s.Version)
+		}
+		go m.sendEvent(&Result{Action: "update", Service: s})
+	} else {
+		// refresh TTL and timestamp
+		for _, n := range s.Nodes {
+			if m.opts.Logger.V(logger.DebugLevel) {
+				m.opts.Logger.Debugf(m.opts.Context, "Updated registration for service: %s, version: %s", s.Name, s.Version)
+			}
+			srvs[s.Name][s.Version].Nodes[n.Id].TTL = options.TTL
+			srvs[s.Name][s.Version].Nodes[n.Id].LastSeen = time.Now()
+		}
+	}
+
+	m.records[options.Domain] = srvs
+	return nil
+}
+
+func (m *memory) Deregister(ctx context.Context, s *Service, opts ...DeregisterOption) error {
+	m.Lock()
+	defer m.Unlock()
+
+	options := NewDeregisterOptions(opts...)
+
+	// domain is set in metadata so it can be passed to watchers
+	if s.Metadata == nil {
+		s.Metadata = map[string]string{"domain": options.Domain}
+	} else {
+		s.Metadata["domain"] = options.Domain
+	}
+
+	// if the domain doesn't exist, there is nothing to deregister
+	services, ok := m.records[options.Domain]
+	if !ok {
+		return nil
+	}
+
+	// if no services with this name and version exist, there is nothing to deregister
+	versions, ok := services[s.Name]
+	if !ok {
+		return nil
+	}
+
+	version, ok := versions[s.Version]
+	if !ok {
+		return nil
+	}
+
+	// deregister all of the service nodes from this version
+	for _, n := range s.Nodes {
+		if _, ok := version.Nodes[n.Id]; ok {
+			if m.opts.Logger.V(logger.DebugLevel) {
+				m.opts.Logger.Debugf(m.opts.Context, "Register removed node from service: %s, version: %s", s.Name, s.Version)
+			}
+			delete(version.Nodes, n.Id)
+		}
+	}
+
+	// if the nodes not empty, we replace the version in the store and exist, the rest of the logic
+	// is cleanup
+	if len(version.Nodes) > 0 {
+		m.records[options.Domain][s.Name][s.Version] = version
+		go m.sendEvent(&Result{Action: "update", Service: s})
+		return nil
+	}
+
+	// if this version was the only version of the service, we can remove the whole service from the
+	// register and exit
+	if len(versions) == 1 {
+		delete(m.records[options.Domain], s.Name)
+		go m.sendEvent(&Result{Action: "delete", Service: s})
+
+		if m.opts.Logger.V(logger.DebugLevel) {
+			m.opts.Logger.Debugf(m.opts.Context, "Register removed service: %s", s.Name)
+		}
+		return nil
+	}
+
+	// there are other versions of the service running, so only remove this version of it
+	delete(m.records[options.Domain][s.Name], s.Version)
+	go m.sendEvent(&Result{Action: "delete", Service: s})
+	if m.opts.Logger.V(logger.DebugLevel) {
+		m.opts.Logger.Debugf(m.opts.Context, "Register removed service: %s, version: %s", s.Name, s.Version)
+	}
+
+	return nil
+}
+
+func (m *memory) LookupService(ctx context.Context, name string, opts ...LookupOption) ([]*Service, error) {
+	options := NewLookupOptions(opts...)
+
+	// if it's a wildcard domain, return from all domains
+	if options.Domain == WildcardDomain {
+		m.RLock()
+		recs := m.records
+		m.RUnlock()
+
+		var services []*Service
+
+		for domain := range recs {
+			srvs, err := m.LookupService(ctx, name, append(opts, LookupDomain(domain))...)
+			if err == ErrNotFound {
+				continue
+			} else if err != nil {
+				return nil, err
+			}
+			services = append(services, srvs...)
+		}
+
+		if len(services) == 0 {
+			return nil, ErrNotFound
+		}
+		return services, nil
+	}
+
+	m.RLock()
+	defer m.RUnlock()
+
+	// check the domain exists
+	services, ok := m.records[options.Domain]
+	if !ok {
+		return nil, ErrNotFound
+	}
+
+	// check the service exists
+	versions, ok := services[name]
+	if !ok || len(versions) == 0 {
+		return nil, ErrNotFound
+	}
+
+	// serialize the response
+	result := make([]*Service, len(versions))
+
+	var i int
+
+	for _, r := range versions {
+		result[i] = recordToService(r, options.Domain)
+		i++
+	}
+
+	return result, nil
+}
+
+func (m *memory) ListServices(ctx context.Context, opts ...ListOption) ([]*Service, error) {
+	options := NewListOptions(opts...)
+
+	// if it's a wildcard domain, list from all domains
+	if options.Domain == WildcardDomain {
+		m.RLock()
+		recs := m.records
+		m.RUnlock()
+
+		var services []*Service
+
+		for domain := range recs {
+			srvs, err := m.ListServices(ctx, append(opts, ListDomain(domain))...)
+			if err != nil {
+				return nil, err
+			}
+			services = append(services, srvs...)
+		}
+
+		return services, nil
+	}
+
+	m.RLock()
+	defer m.RUnlock()
+
+	// ensure the domain exists
+	services, ok := m.records[options.Domain]
+	if !ok {
+		return make([]*Service, 0), nil
+	}
+
+	// serialize the result, each version counts as an individual service
+	var result []*Service
+
+	for domain, service := range services {
+		for _, version := range service {
+			result = append(result, recordToService(version, domain))
+		}
+	}
+
+	return result, nil
+}
+
+func (m *memory) Watch(ctx context.Context, opts ...WatchOption) (Watcher, error) {
+	wo := NewWatchOptions(opts...)
+
+	// construct the watcher
+	w := &watcher{
+		exit: make(chan bool),
+		res:  make(chan *Result),
+		id:   uuid.New().String(),
+		wo:   wo,
+	}
+
+	m.Lock()
+	m.watchers[w.id] = w
+	m.Unlock()
+
+	return w, nil
+}
+
+func (m *memory) Name() string {
+	return m.opts.Name
+}
+
+func (m *memory) String() string {
+	return "memory"
+}
+
+type watcher struct {
+	id   string
+	wo   WatchOptions
+	res  chan *Result
+	exit chan bool
+}
+
+func (m *watcher) Next() (*Result, error) {
+	for {
+		select {
+		case r := <-m.res:
+			if r.Service == nil {
+				continue
+			}
+
+			if len(m.wo.Service) > 0 && m.wo.Service != r.Service.Name {
+				continue
+			}
+
+			// extract domain from service metadata
+			var domain string
+			if r.Service.Metadata != nil && len(r.Service.Metadata["domain"]) > 0 {
+				domain = r.Service.Metadata["domain"]
+			} else {
+				domain = DefaultDomain
+			}
+
+			// only send the event if watching the wildcard or this specific domain
+			if m.wo.Domain == WildcardDomain || m.wo.Domain == domain {
+				return r, nil
+			}
+		case <-m.exit:
+			return nil, errors.New("watcher stopped")
+		}
+	}
+}
+
+func (m *watcher) Stop() {
+	select {
+	case <-m.exit:
+		return
+	default:
+		close(m.exit)
+	}
+}
+
+func serviceToRecord(s *Service, ttl time.Duration) *record {
+	metadata := make(map[string]string, len(s.Metadata))
+	for k, v := range s.Metadata {
+		metadata[k] = v
+	}
+
+	nodes := make(map[string]*node, len(s.Nodes))
+	for _, n := range s.Nodes {
+		nodes[n.Id] = &node{
+			Node:     n,
+			TTL:      ttl,
+			LastSeen: time.Now(),
+		}
+	}
+
+	endpoints := make([]*Endpoint, len(s.Endpoints))
+	for i, e := range s.Endpoints {
+		endpoints[i] = e
+	}
+
+	return &record{
+		Name:      s.Name,
+		Version:   s.Version,
+		Metadata:  metadata,
+		Nodes:     nodes,
+		Endpoints: endpoints,
+	}
+}
+
+func recordToService(r *record, domain string) *Service {
+	metadata := make(map[string]string, len(r.Metadata))
+	for k, v := range r.Metadata {
+		metadata[k] = v
+	}
+
+	// set the domain in metadata so it can be determined when a wildcard query is performed
+	metadata["domain"] = domain
+
+	endpoints := make([]*Endpoint, len(r.Endpoints))
+	for i, e := range r.Endpoints {
+		request := new(Value)
+		if e.Request != nil {
+			*request = *e.Request
+		}
+		response := new(Value)
+		if e.Response != nil {
+			*response = *e.Response
+		}
+
+		metadata := make(map[string]string, len(e.Metadata))
+		for k, v := range e.Metadata {
+			metadata[k] = v
+		}
+
+		endpoints[i] = &Endpoint{
+			Name:     e.Name,
+			Request:  request,
+			Response: response,
+			Metadata: metadata,
+		}
+	}
+
+	nodes := make([]*Node, len(r.Nodes))
+	i := 0
+	for _, n := range r.Nodes {
+		metadata := make(map[string]string, len(n.Metadata))
+		for k, v := range n.Metadata {
+			metadata[k] = v
+		}
+
+		nodes[i] = &Node{
+			Id:       n.Id,
+			Address:  n.Address,
+			Metadata: metadata,
+		}
+		i++
+	}
+
+	return &Service{
+		Name:      r.Name,
+		Version:   r.Version,
+		Metadata:  metadata,
+		Endpoints: endpoints,
+		Nodes:     nodes,
+	}
+}

register/memory_test.go

@@ -0,0 +1,313 @@
+package register
+
+import (
+	"context"
+	"fmt"
+	"os"
+	"testing"
+	"time"
+)
+
+var (
+	testData = map[string][]*Service{
+		"foo": {
+			{
+				Name:    "foo",
+				Version: "1.0.0",
+				Nodes: []*Node{
+					{
+						Id:      "foo-1.0.0-123",
+						Address: "localhost:9999",
+					},
+					{
+						Id:      "foo-1.0.0-321",
+						Address: "localhost:9999",
+					},
+				},
+			},
+			{
+				Name:    "foo",
+				Version: "1.0.1",
+				Nodes: []*Node{
+					{
+						Id:      "foo-1.0.1-321",
+						Address: "localhost:6666",
+					},
+				},
+			},
+			{
+				Name:    "foo",
+				Version: "1.0.3",
+				Nodes: []*Node{
+					{
+						Id:      "foo-1.0.3-345",
+						Address: "localhost:8888",
+					},
+				},
+			},
+		},
+		"bar": {
+			{
+				Name:    "bar",
+				Version: "default",
+				Nodes: []*Node{
+					{
+						Id:      "bar-1.0.0-123",
+						Address: "localhost:9999",
+					},
+					{
+						Id:      "bar-1.0.0-321",
+						Address: "localhost:9999",
+					},
+				},
+			},
+			{
+				Name:    "bar",
+				Version: "latest",
+				Nodes: []*Node{
+					{
+						Id:      "bar-1.0.1-321",
+						Address: "localhost:6666",
+					},
+				},
+			},
+		},
+	}
+)
+
+func TestMemoryRegistry(t *testing.T) {
+	ctx := context.TODO()
+	m := NewRegister()
+
+	fn := func(k string, v []*Service) {
+		services, err := m.LookupService(ctx, k)
+		if err != nil {
+			t.Errorf("Unexpected error getting service %s: %v", k, err)
+		}
+
+		if len(services) != len(v) {
+			t.Errorf("Expected %d services for %s, got %d", len(v), k, len(services))
+		}
+
+		for _, service := range v {
+			var seen bool
+			for _, s := range services {
+				if s.Version == service.Version {
+					seen = true
+					break
+				}
+			}
+			if !seen {
+				t.Errorf("expected to find version %s", service.Version)
+			}
+		}
+	}
+
+	// register data
+	for _, v := range testData {
+		serviceCount := 0
+		for _, service := range v {
+			if err := m.Register(ctx, service); err != nil {
+				t.Errorf("Unexpected register error: %v", err)
+			}
+			serviceCount++
+			// after the service has been registered we should be able to query it
+			services, err := m.LookupService(ctx, service.Name)
+			if err != nil {
+				t.Errorf("Unexpected error getting service %s: %v", service.Name, err)
+			}
+			if len(services) != serviceCount {
+				t.Errorf("Expected %d services for %s, got %d", serviceCount, service.Name, len(services))
+			}
+		}
+	}
+
+	// using test data
+	for k, v := range testData {
+		fn(k, v)
+	}
+
+	services, err := m.ListServices(ctx)
+	if err != nil {
+		t.Errorf("Unexpected error when listing services: %v", err)
+	}
+
+	totalServiceCount := 0
+	for _, testSvc := range testData {
+		for range testSvc {
+			totalServiceCount++
+		}
+	}
+
+	if len(services) != totalServiceCount {
+		t.Errorf("Expected total service count: %d, got: %d", totalServiceCount, len(services))
+	}
+
+	// deregister
+	for _, v := range testData {
+		for _, service := range v {
+			if err := m.Deregister(ctx, service); err != nil {
+				t.Errorf("Unexpected deregister error: %v", err)
+			}
+		}
+	}
+
+	// after all the service nodes have been deregistered we should not get any results
+	for _, v := range testData {
+		for _, service := range v {
+			services, err := m.LookupService(ctx, service.Name)
+			if err != ErrNotFound {
+				t.Errorf("Expected error: %v, got: %v", ErrNotFound, err)
+			}
+			if len(services) != 0 {
+				t.Errorf("Expected %d services for %s, got %d", 0, service.Name, len(services))
+			}
+		}
+	}
+}
+
+func TestMemoryRegistryTTL(t *testing.T) {
+	m := NewRegister()
+	ctx := context.TODO()
+
+	for _, v := range testData {
+		for _, service := range v {
+			if err := m.Register(ctx, service, RegisterTTL(time.Millisecond)); err != nil {
+				t.Fatal(err)
+			}
+		}
+	}
+
+	time.Sleep(ttlPruneTime * 2)
+
+	for name := range testData {
+		svcs, err := m.LookupService(ctx, name)
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		for _, svc := range svcs {
+			if len(svc.Nodes) > 0 {
+				t.Fatalf("Service %q still has nodes registered", name)
+			}
+		}
+	}
+}
+
+func TestMemoryRegistryTTLConcurrent(t *testing.T) {
+	concurrency := 1000
+	waitTime := ttlPruneTime * 2
+	m := NewRegister()
+	ctx := context.TODO()
+	for _, v := range testData {
+		for _, service := range v {
+			if err := m.Register(ctx, service, RegisterTTL(waitTime/2)); err != nil {
+				t.Fatal(err)
+			}
+		}
+	}
+
+	if len(os.Getenv("IN_TRAVIS_CI")) == 0 {
+		t.Logf("test will wait %v, then check TTL timeouts", waitTime)
+	}
+
+	errChan := make(chan error, concurrency)
+	syncChan := make(chan struct{})
+
+	for i := 0; i < concurrency; i++ {
+		go func() {
+			<-syncChan
+			for name := range testData {
+				svcs, err := m.LookupService(ctx, name)
+				if err != nil {
+					errChan <- err
+					return
+				}
+
+				for _, svc := range svcs {
+					if len(svc.Nodes) > 0 {
+						errChan <- fmt.Errorf("Service %q still has nodes registered", name)
+						return
+					}
+				}
+			}
+
+			errChan <- nil
+		}()
+	}
+
+	time.Sleep(waitTime)
+	close(syncChan)
+
+	for i := 0; i < concurrency; i++ {
+		if err := <-errChan; err != nil {
+			t.Fatal(err)
+		}
+	}
+}
+
+func TestMemoryWildcard(t *testing.T) {
+	m := NewRegister()
+	ctx := context.TODO()
+
+	testSrv := &Service{Name: "foo", Version: "1.0.0"}
+
+	if err := m.Register(ctx, testSrv, RegisterDomain("one")); err != nil {
+		t.Fatalf("Register err: %v", err)
+	}
+	if err := m.Register(ctx, testSrv, RegisterDomain("two")); err != nil {
+		t.Fatalf("Register err: %v", err)
+	}
+
+	if recs, err := m.ListServices(ctx, ListDomain("one")); err != nil {
+		t.Errorf("List err: %v", err)
+	} else if len(recs) != 1 {
+		t.Errorf("Expected 1 record, got %v", len(recs))
+	}
+
+	if recs, err := m.ListServices(ctx, ListDomain("*")); err != nil {
+		t.Errorf("List err: %v", err)
+	} else if len(recs) != 2 {
+		t.Errorf("Expected 2 records, got %v", len(recs))
+	}
+
+	if recs, err := m.LookupService(ctx, testSrv.Name, LookupDomain("one")); err != nil {
+		t.Errorf("Lookup err: %v", err)
+	} else if len(recs) != 1 {
+		t.Errorf("Expected 1 record, got %v", len(recs))
+	}
+
+	if recs, err := m.LookupService(ctx, testSrv.Name, LookupDomain("*")); err != nil {
+		t.Errorf("Lookup err: %v", err)
+	} else if len(recs) != 2 {
+		t.Errorf("Expected 2 records, got %v", len(recs))
+	}
+}
+
+func TestWatcher(t *testing.T) {
+	w := &watcher{
+		id:   "test",
+		res:  make(chan *Result),
+		exit: make(chan bool),
+		wo: WatchOptions{
+			Domain: WildcardDomain,
+		},
+	}
+
+	go func() {
+		w.res <- &Result{
+			Service: &Service{Name: "foo"},
+		}
+	}()
+
+	_, err := w.Next()
+	if err != nil {
+		t.Fatal("unexpected err", err)
+	}
+
+	w.Stop()
+
+	if _, err := w.Next(); err == nil {
+		t.Fatal("expected error on Next()")
+	}
+}

register/options.go

@@ -1,4 +1,4 @@
-package registry
+package register
 
 import (
 	"context"
@@ -6,16 +6,22 @@ import (
 	"time"
 
 	"github.com/unistack-org/micro/v3/logger"
+	"github.com/unistack-org/micro/v3/meter"
+	"github.com/unistack-org/micro/v3/tracer"
 )
 
 type Options struct {
+	Name      string
 	Addrs     []string
 	Timeout   time.Duration
-	Secure    bool
 	TLSConfig *tls.Config
 
-	// Logger imp
+	// Logger that will be used
 	Logger logger.Logger
+	// Meter that will be used
+	Meter meter.Meter
+	// Tracer
+	Tracer tracer.Tracer
 	// Other options for implementations of the interface
 	// can be stored in a context
 	Context context.Context
@@ -24,6 +30,8 @@ type Options struct {
 func NewOptions(opts ...Option) Options {
 	options := Options{
 		Logger:  logger.DefaultLogger,
+		Meter:   meter.DefaultMeter,
+		Tracer:  tracer.DefaultTracer,
 		Context: context.Background(),
 	}
 	for _, o := range opts {
@@ -95,14 +103,14 @@ func NewDeregisterOptions(opts ...DeregisterOption) DeregisterOptions {
 	return options
 }
 
-type GetOptions struct {
+type LookupOptions struct {
 	Context context.Context
 	// Domain to scope the request to
 	Domain string
 }
 
-func NewGetOptions(opts ...GetOption) GetOptions {
-	options := GetOptions{
+func NewLookupOptions(opts ...LookupOption) LookupOptions {
+	options := LookupOptions{
 		Domain:  DefaultDomain,
 		Context: context.Background(),
 	}
@@ -129,7 +137,7 @@ func NewListOptions(opts ...ListOption) ListOptions {
 	return options
 }
 
-// Addrs is the registry addresses to use
+// Addrs is the register addresses to use
 func Addrs(addrs ...string) Option {
 	return func(o *Options) {
 		o.Addrs = addrs
@@ -142,13 +150,6 @@ func Timeout(t time.Duration) Option {
 	}
 }
 
-// Secure communication with the registry
-func Secure(b bool) Option {
-	return func(o *Options) {
-		o.Secure = b
-	}
-}
-
 // Logger sets the logger
 func Logger(l logger.Logger) Option {
 	return func(o *Options) {
@@ -156,6 +157,20 @@ func Logger(l logger.Logger) Option {
 	}
 }
 
+// Meter sets the meter
+func Meter(m meter.Meter) Option {
+	return func(o *Options) {
+		o.Meter = m
+	}
+}
+
+// Tracer sets the tracer
+func Tracer(t tracer.Tracer) Option {
+	return func(o *Options) {
+		o.Tracer = t
+	}
+}
+
 // Context sets the context
 func Context(ctx context.Context) Option {
 	return func(o *Options) {
@@ -231,14 +246,14 @@ func DeregisterDomain(d string) DeregisterOption {
 	}
 }
 
-func GetContext(ctx context.Context) GetOption {
-	return func(o *GetOptions) {
+func LookupContext(ctx context.Context) LookupOption {
+	return func(o *LookupOptions) {
 		o.Context = ctx
 	}
 }
 
-func GetDomain(d string) GetOption {
-	return func(o *GetOptions) {
+func LookupDomain(d string) LookupOption {
+	return func(o *LookupOptions) {
 		o.Domain = d
 	}
 }
@@ -254,3 +269,10 @@ func ListDomain(d string) ListOption {
 		o.Domain = d
 	}
 }
+
+// Name sets the name
+func Name(n string) Option {
+	return func(o *Options) {
+		o.Name = n
+	}
+}

register/register.go

@@ -1,5 +1,5 @@
-// Package registry is an interface for service discovery
-package registry
+// Package register is an interface for service discovery
+package register
 
 import (
 	"context"
@@ -16,31 +16,32 @@ const (
 )
 
 var (
-	// DefaultRegistry is the global default registry
-	DefaultRegistry Registry = NewRegistry()
-	// ErrNotFound returned when GetService is called and no services found
+	// DefaultRegister is the global default register
+	DefaultRegister Register = NewRegister()
+	// ErrNotFound returned when LookupService is called and no services found
 	ErrNotFound = errors.New("service not found")
 	// ErrWatcherStopped returned when when watcher is stopped
 	ErrWatcherStopped = errors.New("watcher stopped")
 )
 
-// Registry provides an interface for service discovery
+// Register provides an interface for service discovery
 // and an abstraction over varying implementations
 // {consul, etcd, zookeeper, ...}
-type Registry interface {
+type Register interface {
+	Name() string
 	Init(...Option) error
 	Options() Options
 	Connect(context.Context) error
 	Disconnect(context.Context) error
 	Register(context.Context, *Service, ...RegisterOption) error
 	Deregister(context.Context, *Service, ...DeregisterOption) error
-	GetService(context.Context, string, ...GetOption) ([]*Service, error)
+	LookupService(context.Context, string, ...LookupOption) ([]*Service, error)
 	ListServices(context.Context, ...ListOption) ([]*Service, error)
 	Watch(context.Context, ...WatchOption) (Watcher, error)
 	String() string
 }
 
-// Service holds service registry info
+// Service holds service register info
 type Service struct {
 	Name      string            `json:"name"`
 	Version   string            `json:"version"`
@@ -49,14 +50,14 @@ type Service struct {
 	Nodes     []*Node           `json:"nodes"`
 }
 
-// Node holds node registry info
+// Node holds node register info
 type Node struct {
 	Id       string            `json:"id"`
 	Address  string            `json:"address"`
 	Metadata metadata.Metadata `json:"metadata"`
 }
 
-// Endpoint holds endpoint registry info
+// Endpoint holds endpoint register info
 type Endpoint struct {
 	Name     string            `json:"name"`
 	Request  *Value            `json:"request"`
@@ -83,8 +84,8 @@ type WatchOption func(*WatchOptions)
 // DeregisterOption option is used to deregister service
 type DeregisterOption func(*DeregisterOptions)
 
-// GetOption option is used to get service
-type GetOption func(*GetOptions)
+// LookupOption option is used to get service
+type LookupOption func(*LookupOptions)
 
 // ListOption option is used to list services
 type ListOption func(*ListOptions)

register/watcher.go

@@ -1,9 +1,9 @@
-package registry
+package register
 
 import "time"
 
 // Watcher is an interface that returns updates
-// about services within the registry.
+// about services within the register.
 type Watcher interface {
 	// Next is a blocking call
 	Next() (*Result, error)
@@ -17,7 +17,7 @@ type Result struct {
 	Service *Service
 }
 
-// EventType defines registry event type
+// EventType defines register event type
 type EventType int
 
 const (
@@ -43,14 +43,14 @@ func (t EventType) String() string {
 	}
 }
 
-// Event is registry event
+// Event is register event
 type Event struct {
-	// Id is registry id
+	// Id is register id
 	Id string
 	// Type defines type of event
 	Type EventType
 	// Timestamp is event timestamp
 	Timestamp time.Time
-	// Service is registry service
+	// Service is register service
 	Service *Service
 }

registry/noop.go

@@ -1,81 +0,0 @@
-package registry
-
-import (
-	"context"
-)
-
-type noopRegistry struct {
-	opts Options
-}
-
-// Init initialize registry
-func (n *noopRegistry) Init(opts ...Option) error {
-	for _, o := range opts {
-		o(&n.opts)
-	}
-	return nil
-}
-
-// Options returns options struct
-func (n *noopRegistry) Options() Options {
-	return n.opts
-}
-
-// Connect opens connection to registry
-func (n *noopRegistry) Connect(ctx context.Context) error {
-	return nil
-}
-
-// Disconnect close connection to registry
-func (n *noopRegistry) Disconnect(ctx context.Context) error {
-	return nil
-}
-
-// Register registers service
-func (n *noopRegistry) Register(ctx context.Context, svc *Service, opts ...RegisterOption) error {
-	return nil
-}
-
-// Deregister deregisters service
-func (n *noopRegistry) Deregister(ctx context.Context, svc *Service, opts ...DeregisterOption) error {
-	return nil
-}
-
-// GetService returns servive info
-func (n *noopRegistry) GetService(ctx context.Context, name string, opts ...GetOption) ([]*Service, error) {
-	return []*Service{}, nil
-}
-
-// ListServices listing services
-func (n *noopRegistry) ListServices(ctx context.Context, opts ...ListOption) ([]*Service, error) {
-	return []*Service{}, nil
-}
-
-// Watch is used to watch for service changes
-func (n *noopRegistry) Watch(ctx context.Context, opts ...WatchOption) (Watcher, error) {
-	return &noopWatcher{done: make(chan struct{}), opts: NewWatchOptions(opts...)}, nil
-}
-
-// String returns registry string representation
-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...)}
-}

resolver/registry/registry.go

@@ -1,22 +1,22 @@
-// Package registry resolves names using the micro registry
-package registry
+// Package register resolves names using the micro register
+package register
 
 import (
 	"context"
 
-	"github.com/unistack-org/micro/v3/registry"
+	"github.com/unistack-org/micro/v3/register"
 	"github.com/unistack-org/micro/v3/resolver"
 )
 
-// Resolver is a registry network resolver
+// Resolver is a register network resolver
 type Resolver struct {
-	// Registry is the registry to use otherwise we use the defaul
-	Registry registry.Registry
+	// Register is the register to use otherwise we use the defaul
+	Register register.Register
 }
 
 // Resolve assumes ID is a domain name e.g micro.mu
 func (r *Resolver) Resolve(name string) ([]*resolver.Record, error) {
-	services, err := r.Registry.GetService(context.TODO(), name)
+	services, err := r.Register.LookupService(context.TODO(), name)
 	if err != nil {
 		return nil, err
 	}

router/options.go

@@ -5,11 +5,12 @@ import (
 
 	"github.com/google/uuid"
 	"github.com/unistack-org/micro/v3/logger"
-	"github.com/unistack-org/micro/v3/registry"
+	"github.com/unistack-org/micro/v3/register"
 )
 
 // Options are router options
 type Options struct {
+	Name string
 	// Id is router id
 	Id string
 	// Address is router address
@@ -18,8 +19,8 @@ type Options struct {
 	Gateway string
 	// Network is network address
 	Network string
-	// Registry is the local registry
-	Registry registry.Registry
+	// Register is the local register
+	Register register.Register
 	// Precache routes
 	Precache bool
 	// Logger
@@ -63,10 +64,10 @@ func Logger(l logger.Logger) Option {
 	}
 }
 
-// Registry sets the local registry
-func Registry(r registry.Registry) Option {
+// Register sets the local register
+func Register(r register.Register) Option {
 	return func(o *Options) {
-		o.Registry = r
+		o.Register = r
 	}
 }
 
@@ -77,12 +78,19 @@ func Precache() Option {
 	}
 }
 
+// Name of the router
+func Name(n string) Option {
+	return func(o *Options) {
+		o.Name = n
+	}
+}
+
 // NewOptions returns router default options
 func NewOptions(opts ...Option) Options {
 	options := Options{
 		Id:       uuid.New().String(),
 		Network:  DefaultNetwork,
-		Registry: registry.DefaultRegistry,
+		Register: register.DefaultRegister,
 		Logger:   logger.DefaultLogger,
 		Context:  context.Background(),
 	}

router/router.go

@@ -18,6 +18,7 @@ var (
 
 // Router is an interface for a routing control plane
 type Router interface {
+	Name() string
 	// Init initializes the router with options
 	Init(...Option) error
 	// Options returns the router options

server/handler.go

@@ -3,13 +3,13 @@ package server
 import (
 	"reflect"
 
-	"github.com/unistack-org/micro/v3/registry"
+	"github.com/unistack-org/micro/v3/register"
 )
 
 type rpcHandler struct {
 	name      string
 	handler   interface{}
-	endpoints []*registry.Endpoint
+	endpoints []*register.Endpoint
 	opts      HandlerOptions
 }
 
@@ -20,10 +20,10 @@ func newRpcHandler(handler interface{}, opts ...HandlerOption) Handler {
 	hdlr := reflect.ValueOf(handler)
 	name := reflect.Indirect(hdlr).Type().Name()
 
-	var endpoints []*registry.Endpoint
+	var endpoints []*register.Endpoint
 
 	for m := 0; m < typ.NumMethod(); m++ {
-		if e := registry.ExtractEndpoint(typ.Method(m)); e != nil {
+		if e := register.ExtractEndpoint(typ.Method(m)); e != nil {
 			e.Name = name + "." + e.Name
 
 			for k, v := range options.Metadata[e.Name] {
@@ -50,7 +50,7 @@ func (r *rpcHandler) Handler() interface{} {
 	return r.handler
 }
 
-func (r *rpcHandler) Endpoints() []*registry.Endpoint {
+func (r *rpcHandler) Endpoints() []*register.Endpoint {
 	return r.endpoints
 }
 

server/noop.go

@@ -13,7 +13,7 @@ import (
 	"github.com/unistack-org/micro/v3/broker"
 	"github.com/unistack-org/micro/v3/codec"
 	"github.com/unistack-org/micro/v3/logger"
-	"github.com/unistack-org/micro/v3/registry"
+	"github.com/unistack-org/micro/v3/register"
 )
 
 var (
@@ -34,7 +34,7 @@ const (
 type noopServer struct {
 	h           Handler
 	opts        Options
-	rsvc        *registry.Service
+	rsvc        *register.Service
 	handlers    map[string]Handler
 	subscribers map[*subscriber][]broker.Subscriber
 	registered  bool
@@ -46,7 +46,17 @@ type noopServer struct {
 
 // NewServer returns new noop server
 func NewServer(opts ...Option) Server {
-	return &noopServer{opts: NewOptions(opts...)}
+	n := &noopServer{opts: NewOptions(opts...)}
+	if n.handlers == nil {
+		n.handlers = make(map[string]Handler)
+	}
+	if n.subscribers == nil {
+		n.subscribers = make(map[*subscriber][]broker.Subscriber)
+	}
+	if n.exit == nil {
+		n.exit = make(chan chan error)
+	}
+	return n
 }
 
 func (n *noopServer) newCodec(contentType string) (codec.Codec, error) {
@@ -64,6 +74,10 @@ func (n *noopServer) Handle(handler Handler) error {
 	return nil
 }
 
+func (n *noopServer) Name() string {
+	return n.opts.Name
+}
+
 func (n *noopServer) Subscribe(sb Subscriber) error {
 	sub, ok := sb.(*subscriber)
 	if !ok {
@@ -137,10 +151,10 @@ func (n *noopServer) Register() error {
 	}
 
 	var err error
-	var service *registry.Service
+	var service *register.Service
 	var cacheService bool
 
-	service, err = NewRegistryService(n)
+	service, err = NewRegisterService(n)
 	if err != nil {
 		return err
 	}
@@ -168,7 +182,7 @@ func (n *noopServer) Register() error {
 		return subscriberList[i].topic > subscriberList[j].topic
 	})
 
-	endpoints := make([]*registry.Endpoint, 0, len(handlerList)+len(subscriberList))
+	endpoints := make([]*register.Endpoint, 0, len(handlerList)+len(subscriberList))
 	for _, h := range handlerList {
 		endpoints = append(endpoints, n.handlers[h].Endpoints()...)
 	}
@@ -187,7 +201,7 @@ func (n *noopServer) Register() error {
 
 	if !registered {
 		if config.Logger.V(logger.InfoLevel) {
-			config.Logger.Infof(n.opts.Context, "registry [%s] Registering node: %s", config.Registry.String(), service.Nodes[0].Id)
+			config.Logger.Infof(n.opts.Context, "register [%s] Registering node: %s", config.Register.String(), service.Nodes[0].Id)
 		}
 	}
 
@@ -244,7 +258,7 @@ func (n *noopServer) Deregister() error {
 	config := n.opts
 	n.RUnlock()
 
-	service, err := NewRegistryService(n)
+	service, err := NewRegisterService(n)
 	if err != nil {
 		return err
 	}

server/options.go

@@ -12,8 +12,9 @@ import (
 	"github.com/unistack-org/micro/v3/codec"
 	"github.com/unistack-org/micro/v3/logger"
 	"github.com/unistack-org/micro/v3/metadata"
+	"github.com/unistack-org/micro/v3/meter"
 	"github.com/unistack-org/micro/v3/network/transport"
-	"github.com/unistack-org/micro/v3/registry"
+	"github.com/unistack-org/micro/v3/register"
 	"github.com/unistack-org/micro/v3/tracer"
 )
 
@@ -24,10 +25,11 @@ type Option func(*Options)
 type Options struct {
 	Codecs       map[string]codec.Codec
 	Broker       broker.Broker
-	Registry     registry.Registry
+	Register     register.Register
 	Tracer       tracer.Tracer
 	Auth         auth.Auth
 	Logger       logger.Logger
+	Meter        meter.Meter
 	Transport    transport.Transport
 	Metadata     metadata.Metadata
 	Name         string
@@ -78,9 +80,10 @@ func NewOptions(opts ...Option) Options {
 		RegisterTTL:      DefaultRegisterTTL,
 		RegisterCheck:    DefaultRegisterCheck,
 		Logger:           logger.DefaultLogger,
+		Meter:            meter.DefaultMeter,
 		Tracer:           tracer.DefaultTracer,
 		Broker:           broker.DefaultBroker,
-		Registry:         registry.DefaultRegistry,
+		Register:         register.DefaultRegister,
 		Transport:        transport.DefaultTransport,
 		Address:          DefaultAddress,
 		Name:             DefaultName,
@@ -117,6 +120,13 @@ func Logger(l logger.Logger) Option {
 	}
 }
 
+// Meter sets the meter option
+func Meter(m meter.Meter) Option {
+	return func(o *Options) {
+		o.Meter = m
+	}
+}
+
 // Id unique server id
 func Id(id string) Option {
 	return func(o *Options) {
@@ -168,10 +178,10 @@ func Context(ctx context.Context) Option {
 	}
 }
 
-// Registry used for discovery
-func Registry(r registry.Registry) Option {
+// Register used for discovery
+func Register(r register.Register) Option {
 	return func(o *Options) {
-		o.Registry = r
+		o.Register = r
 	}
 }
 
@@ -203,7 +213,7 @@ func Metadata(md metadata.Metadata) Option {
 	}
 }
 
-// RegisterCheck run func before registry service
+// RegisterCheck run func before register service
 func RegisterCheck(fn func(context.Context) error) Option {
 	return func(o *Options) {
 		o.RegisterCheck = fn
@@ -235,7 +245,6 @@ func TLSConfig(t *tls.Config) Option {
 
 		// set the transport tls
 		o.Transport.Init(
-			transport.Secure(true),
 			transport.TLSConfig(t),
 		)
 	}

server/registry.go

@@ -5,23 +5,23 @@ import (
 	"time"
 
 	"github.com/unistack-org/micro/v3/metadata"
-	"github.com/unistack-org/micro/v3/registry"
+	"github.com/unistack-org/micro/v3/register"
 	"github.com/unistack-org/micro/v3/util/addr"
 	"github.com/unistack-org/micro/v3/util/backoff"
 )
 
 var (
 	// DefaultRegisterFunc uses backoff to register service
-	DefaultRegisterFunc = func(svc *registry.Service, config Options) error {
+	DefaultRegisterFunc = func(svc *register.Service, config Options) error {
 		var err error
 
-		opts := []registry.RegisterOption{
-			registry.RegisterTTL(config.RegisterTTL),
-			registry.RegisterDomain(config.Namespace),
+		opts := []register.RegisterOption{
+			register.RegisterTTL(config.RegisterTTL),
+			register.RegisterDomain(config.Namespace),
 		}
 
 		for i := 0; i <= config.RegisterAttempts; i++ {
-			err = config.Registry.Register(config.Context, svc, opts...)
+			err = config.Register.Register(config.Context, svc, opts...)
 			if err == nil {
 				break
 			}
@@ -32,15 +32,15 @@ var (
 		return err
 	}
 	// DefaultDeregisterFunc uses backoff to deregister service
-	DefaultDeregisterFunc = func(svc *registry.Service, config Options) error {
+	DefaultDeregisterFunc = func(svc *register.Service, config Options) error {
 		var err error
 
-		opts := []registry.DeregisterOption{
-			registry.DeregisterDomain(config.Namespace),
+		opts := []register.DeregisterOption{
+			register.DeregisterDomain(config.Namespace),
 		}
 
 		for i := 0; i <= config.DeregisterAttempts; i++ {
-			err = config.Registry.Deregister(config.Context, svc, opts...)
+			err = config.Register.Deregister(config.Context, svc, opts...)
 			if err == nil {
 				break
 			}
@@ -52,8 +52,8 @@ var (
 	}
 )
 
-// NewRegistryService returns *registry.Service from Server
-func NewRegistryService(s Server) (*registry.Service, error) {
+// NewRegisterService returns *register.Service from Server
+func NewRegisterService(s Server) (*register.Service, error) {
 	opts := s.Options()
 
 	advt := opts.Address
@@ -71,7 +71,7 @@ func NewRegistryService(s Server) (*registry.Service, error) {
 		addr = host
 	}
 
-	node := &registry.Node{
+	node := &register.Node{
 		Id:      opts.Name + "-" + opts.Id,
 		Address: net.JoinHostPort(addr, port),
 	}
@@ -79,12 +79,12 @@ func NewRegistryService(s Server) (*registry.Service, error) {
 
 	node.Metadata["server"] = s.String()
 	node.Metadata["broker"] = opts.Broker.String()
-	node.Metadata["registry"] = opts.Registry.String()
+	node.Metadata["register"] = opts.Register.String()
 
-	return &registry.Service{
+	return &register.Service{
 		Name:     opts.Name,
 		Version:  opts.Version,
-		Nodes:    []*registry.Node{node},
+		Nodes:    []*register.Node{node},
 		Metadata: metadata.New(0),
 	}, nil
 }

server/server.go

@@ -8,7 +8,7 @@ import (
 	"github.com/google/uuid"
 	"github.com/unistack-org/micro/v3/codec"
 	"github.com/unistack-org/micro/v3/metadata"
-	"github.com/unistack-org/micro/v3/registry"
+	"github.com/unistack-org/micro/v3/register"
 )
 
 var (
@@ -29,7 +29,7 @@ var (
 	DefaultRegisterCheck = func(context.Context) error { return nil }
 	// DefaultRegisterInterval holds interval for register
 	DefaultRegisterInterval = time.Second * 30
-	// DefaultRegisterTTL holds registry record ttl, must be multiple of DefaultRegisterInterval
+	// DefaultRegisterTTL holds register record ttl, must be multiple of DefaultRegisterInterval
 	DefaultRegisterTTL = time.Second * 90
 	// DefaultNamespace will be used if no namespace passed
 	DefaultNamespace = "micro"
@@ -43,6 +43,8 @@ var (
 
 // Server is a simple micro server abstraction
 type Server interface {
+	// Name returns server name
+	Name() string
 	// Initialise options
 	Init(...Option) error
 	// Retrieve the options
@@ -147,7 +149,7 @@ type Stream interface {
 type Handler interface {
 	Name() string
 	Handler() interface{}
-	Endpoints() []*registry.Endpoint
+	Endpoints() []*register.Endpoint
 	Options() HandlerOptions
 }
 
@@ -157,6 +159,6 @@ type Handler interface {
 type Subscriber interface {
 	Topic() string
 	Subscriber() interface{}
-	Endpoints() []*registry.Endpoint
+	Endpoints() []*register.Endpoint
 	Options() SubscriberOptions
 }

server/subscriber.go

@@ -14,7 +14,7 @@ import (
 	"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/registry"
+	"github.com/unistack-org/micro/v3/register"
 )
 
 const (
@@ -39,7 +39,7 @@ type subscriber struct {
 	typ        reflect.Type
 	subscriber interface{}
 	handlers   []*handler
-	endpoints  []*registry.Endpoint
+	endpoints  []*register.Endpoint
 	opts       SubscriberOptions
 }
 
@@ -115,7 +115,7 @@ func ValidateSubscriber(sub Subscriber) error {
 }
 
 func newSubscriber(topic string, sub interface{}, opts ...SubscriberOption) Subscriber {
-	var endpoints []*registry.Endpoint
+	var endpoints []*register.Endpoint
 	var handlers []*handler
 
 	options := NewSubscriberOptions(opts...)
@@ -134,9 +134,9 @@ func newSubscriber(topic string, sub interface{}, opts ...SubscriberOption) Subs
 		}
 
 		handlers = append(handlers, h)
-		ep := &registry.Endpoint{
+		ep := &register.Endpoint{
 			Name:     "Func",
-			Request:  registry.ExtractSubValue(typ),
+			Request:  register.ExtractSubValue(typ),
 			Metadata: metadata.New(2),
 		}
 		ep.Metadata.Set("topic", topic)
@@ -161,9 +161,9 @@ func newSubscriber(topic string, sub interface{}, opts ...SubscriberOption) Subs
 			}
 
 			handlers = append(handlers, h)
-			ep := &registry.Endpoint{
+			ep := &register.Endpoint{
 				Name:     name + "." + method.Name,
-				Request:  registry.ExtractSubValue(method.Type),
+				Request:  register.ExtractSubValue(method.Type),
 				Metadata: metadata.New(2),
 			}
 			ep.Metadata.Set("topic", topic)
@@ -304,7 +304,7 @@ func (s *subscriber) Subscriber() interface{} {
 	return s.subscriber
 }
 
-func (s *subscriber) Endpoints() []*registry.Endpoint {
+func (s *subscriber) Endpoints() []*register.Endpoint {
 	return s.endpoints
 }
 

service.go

@@ -1,8 +1,8 @@
+// Package micro is a pluggable framework for microservices
 package micro
 
 import (
 	"fmt"
-	rtime "runtime"
 	"sync"
 
 	"github.com/unistack-org/micro/v3/auth"
@@ -10,31 +10,86 @@ import (
 	"github.com/unistack-org/micro/v3/client"
 	"github.com/unistack-org/micro/v3/config"
 	"github.com/unistack-org/micro/v3/logger"
-	"github.com/unistack-org/micro/v3/registry"
+	"github.com/unistack-org/micro/v3/meter"
+	"github.com/unistack-org/micro/v3/register"
 	"github.com/unistack-org/micro/v3/router"
 	"github.com/unistack-org/micro/v3/server"
 	"github.com/unistack-org/micro/v3/store"
+	"github.com/unistack-org/micro/v3/tracer"
 )
 
+// Service is an interface that wraps the lower level components.
+// Its works as container with building blocks for service.
+type Service interface {
+	// The service name
+	Name() string
+	// Init initialises options
+	Init(...Option) error
+	// Options returns the current options
+	Options() Options
+	// Auth is for handling auth
+	Auth(...string) auth.Auth
+	// Logger is for logs
+	Logger(...string) logger.Logger
+	// Config if for config
+	Config(...string) config.Config
+	// Client is for calling services
+	Client(...string) client.Client
+	// Broker is for sending and receiving events
+	Broker(...string) broker.Broker
+	// Server is for handling requests and events
+	Server(...string) server.Server
+	// Store is for key/val store
+	Store(...string) store.Store
+	// Register
+	Register(...string) register.Register
+	// Tracer
+	Tracer(...string) tracer.Tracer
+	// Router
+	Router(...string) router.Router
+	// Meter
+	Meter(...string) meter.Meter
+
+	// Runtime
+	// Runtime(string) (runtime.Runtime, bool)
+	// Profile
+	// Profile(string) (profile.Profile, bool)
+	// Run the service
+	Run() error
+	// The service implementation
+	String() string
+}
+
+// RegisterHandler is syntactic sugar for registering a handler
+func RegisterHandler(s server.Server, h interface{}, opts ...server.HandlerOption) error {
+	return s.Handle(s.NewHandler(h, opts...))
+}
+
+// RegisterSubscriber is syntactic sugar for registering a subscriber
+func RegisterSubscriber(topic string, s server.Server, h interface{}, opts ...server.SubscriberOption) error {
+	return s.Subscribe(s.NewSubscriber(topic, h, opts...))
+}
+
 type service struct {
 	opts Options
 	sync.RWMutex
 	//	once sync.Once
 }
 
-func newService(opts ...Option) Service {
-	service := &service{opts: NewOptions(opts...)}
-	return service
+// NewService creates and returns a new Service based on the packages within.
+func NewService(opts ...Option) Service {
+	return &service{opts: NewOptions(opts...)}
 }
 
 func (s *service) Name() string {
-	return s.opts.Server.Options().Name
+	return s.opts.Name
 }
 
 // Init initialises options. Additionally it calls cmd.Init
 // which parses command line flags. cmd.Init is only called
 // on first Init.
 func (s *service) Init(opts ...Option) error {
+	var err error
 	// process options
 	for _, o := range opts {
 		o(&s.opts)
@@ -45,60 +100,48 @@ func (s *service) Init(opts ...Option) error {
 			// skip config as the struct not passed
 			continue
 		}
-		if err := cfg.Init(config.Context(s.opts.Context)); err != nil {
+		if err = cfg.Init(config.Context(s.opts.Context)); err != nil {
 			return err
 		}
 
-		if err := cfg.Load(s.opts.Context); err != nil {
+		if err = cfg.Load(s.opts.Context); err != nil {
 			return err
 		}
 
 	}
 
-	if s.opts.Logger != nil {
-		if err := s.opts.Logger.Init(
-			logger.WithContext(s.opts.Context),
-		); err != nil {
+	for _, log := range s.opts.Loggers {
+		if err = log.Init(logger.WithContext(s.opts.Context)); err != nil {
 			return err
 		}
 	}
 
-	if s.opts.Registry != nil {
-		if err := s.opts.Registry.Init(
-			registry.Context(s.opts.Context),
-		); err != nil {
+	for _, reg := range s.opts.Registers {
+		if err = reg.Init(register.Context(s.opts.Context)); err != nil {
 			return err
 		}
 	}
 
-	if s.opts.Broker != nil {
-		if err := s.opts.Broker.Init(
-			broker.Context(s.opts.Context),
-		); err != nil {
+	for _, brk := range s.opts.Brokers {
+		if err = brk.Init(broker.Context(s.opts.Context)); err != nil {
 			return err
 		}
 	}
 
-	if s.opts.Store != nil {
-		if err := s.opts.Store.Init(
-			store.Context(s.opts.Context),
-		); err != nil {
+	for _, str := range s.opts.Stores {
+		if err = str.Init(store.Context(s.opts.Context)); err != nil {
 			return err
 		}
 	}
 
-	if s.opts.Server != nil {
-		if err := s.opts.Server.Init(
-			server.Context(s.opts.Context),
-		); err != nil {
+	for _, srv := range s.opts.Servers {
+		if err = srv.Init(server.Context(s.opts.Context)); err != nil {
 			return err
 		}
 	}
 
-	if s.opts.Client != nil {
-		if err := s.opts.Client.Init(
-			client.Context(s.opts.Context),
-		); err != nil {
+	for _, cli := range s.opts.Clients {
+		if err = cli.Init(client.Context(s.opts.Context)); err != nil {
 			return err
 		}
 	}
@@ -110,36 +153,93 @@ func (s *service) Options() Options {
 	return s.opts
 }
 
-func (s *service) Broker() broker.Broker {
-	return s.opts.Broker
+func (s *service) Broker(names ...string) broker.Broker {
+	idx := 0
+	if len(names) == 1 {
+		idx = getNameIndex(names[0], s.opts.Brokers)
+	}
+	return s.opts.Brokers[idx]
+
 }
 
-func (s *service) Client() client.Client {
-	return s.opts.Client
+func (s *service) Tracer(names ...string) tracer.Tracer {
+	idx := 0
+	if len(names) == 1 {
+		idx = getNameIndex(names[0], s.opts.Tracers)
+	}
+	return s.opts.Tracers[idx]
 }
 
-func (s *service) Server() server.Server {
-	return s.opts.Server
+func (s *service) Config(names ...string) config.Config {
+	idx := 0
+	if len(names) == 1 {
+		idx = getNameIndex(names[0], s.opts.Configs)
+	}
+	return s.opts.Configs[idx]
 }
 
-func (s *service) Store() store.Store {
-	return s.opts.Store
+func (s *service) Client(names ...string) client.Client {
+	idx := 0
+	if len(names) == 1 {
+		idx = getNameIndex(names[0], s.opts.Clients)
+	}
+	return s.opts.Clients[idx]
 }
 
-func (s *service) Registry() registry.Registry {
-	return s.opts.Registry
+func (s *service) Server(names ...string) server.Server {
+	idx := 0
+	if len(names) == 1 {
+		idx = getNameIndex(names[0], s.opts.Servers)
+	}
+	return s.opts.Servers[idx]
 }
 
-func (s *service) Logger() logger.Logger {
-	return s.opts.Logger
+func (s *service) Store(names ...string) store.Store {
+	idx := 0
+	if len(names) == 1 {
+		idx = getNameIndex(names[0], s.opts.Stores)
+	}
+	return s.opts.Stores[idx]
 }
 
-func (s *service) Auth() auth.Auth {
-	return s.opts.Auth
+func (s *service) Register(names ...string) register.Register {
+	idx := 0
+	if len(names) == 1 {
+		idx = getNameIndex(names[0], s.opts.Registers)
+	}
+	return s.opts.Registers[idx]
 }
 
-func (s *service) Router() router.Router {
-	return s.opts.Router
+func (s *service) Logger(names ...string) logger.Logger {
+	idx := 0
+	if len(names) == 1 {
+		idx = getNameIndex(names[0], s.opts.Loggers)
+	}
+	return s.opts.Loggers[idx]
+}
+
+func (s *service) Auth(names ...string) auth.Auth {
+	idx := 0
+	if len(names) == 1 {
+		idx = getNameIndex(names[0], s.opts.Auths)
+	}
+	return s.opts.Auths[idx]
+}
+
+func (s *service) Router(names ...string) router.Router {
+	idx := 0
+	if len(names) == 1 {
+		idx = getNameIndex(names[0], s.opts.Routers)
+	}
+	return s.opts.Routers[idx]
+}
+
+func (s *service) Meter(names ...string) meter.Meter {
+	idx := 0
+	if len(names) == 1 {
+		idx = getNameIndex(names[0], s.opts.Meters)
+	}
+	return s.opts.Meters[idx]
 }
 
 func (s *service) String() string {
@@ -153,8 +253,8 @@ func (s *service) Start() error {
 	config := s.opts
 	s.RUnlock()
 
-	if config.Logger.V(logger.InfoLevel) {
-		config.Logger.Infof(s.opts.Context, "starting [service] %s", s.Name())
+	if config.Loggers[0].V(logger.InfoLevel) {
+		config.Loggers[0].Infof(s.opts.Context, "starting [service] %s", s.Name())
 	}
 
 	for _, fn := range s.opts.BeforeStart {
@@ -169,35 +269,37 @@ func (s *service) Start() error {
 			continue
 		}
 
-		if err := cfg.Load(s.opts.Context); err != nil {
+		if err = cfg.Load(s.opts.Context); err != nil {
 			return err
 		}
 	}
 
-	if s.opts.Server == nil {
+	if len(s.opts.Servers) == 0 {
 		return fmt.Errorf("cant start nil server")
 	}
 
-	if s.opts.Registry != nil {
-		if err := s.opts.Registry.Connect(s.opts.Context); err != nil {
+	for _, reg := range s.opts.Registers {
+		if err = reg.Connect(s.opts.Context); err != nil {
 			return err
 		}
 	}
 
-	if s.opts.Broker != nil {
-		if err := s.opts.Broker.Connect(s.opts.Context); err != nil {
+	for _, brk := range s.opts.Brokers {
+		if err = brk.Connect(s.opts.Context); err != nil {
 			return err
 		}
 	}
 
-	if s.opts.Store != nil {
-		if err := s.opts.Store.Connect(s.opts.Context); err != nil {
+	for _, str := range s.opts.Stores {
+		if err = str.Connect(s.opts.Context); err != nil {
 			return err
 		}
 	}
 
-	if err = s.opts.Server.Start(); err != nil {
-		return err
+	for _, srv := range s.opts.Servers {
+		if err = srv.Start(); err != nil {
+			return err
+		}
 	}
 
 	for _, fn := range s.opts.AfterStart {
@@ -214,8 +316,8 @@ func (s *service) Stop() error {
 	config := s.opts
 	s.RUnlock()
 
-	if config.Logger.V(logger.InfoLevel) {
-		config.Logger.Infof(s.opts.Context, "stoppping [service] %s", s.Name())
+	if config.Loggers[0].V(logger.InfoLevel) {
+		config.Loggers[0].Infof(s.opts.Context, "stoppping [service] %s", s.Name())
 	}
 
 	var err error
@@ -225,8 +327,10 @@ func (s *service) Stop() error {
 		}
 	}
 
-	if err = s.opts.Server.Stop(); err != nil {
-		return err
+	for _, srv := range s.opts.Servers {
+		if err = srv.Stop(); err != nil {
+			return err
+		}
 	}
 
 	for _, fn := range s.opts.AfterStop {
@@ -235,20 +339,20 @@ func (s *service) Stop() error {
 		}
 	}
 
-	if s.opts.Registry != nil {
-		if err := s.opts.Registry.Disconnect(s.opts.Context); err != nil {
+	for _, reg := range s.opts.Registers {
+		if err = reg.Disconnect(s.opts.Context); err != nil {
 			return err
 		}
 	}
 
-	if s.opts.Broker != nil {
-		if err := s.opts.Broker.Disconnect(s.opts.Context); err != nil {
+	for _, brk := range s.opts.Brokers {
+		if err = brk.Disconnect(s.opts.Context); err != nil {
 			return err
 		}
 	}
 
-	if s.opts.Store != nil {
-		if err := s.opts.Store.Disconnect(s.opts.Context); err != nil {
+	for _, str := range s.opts.Stores {
+		if err = str.Disconnect(s.opts.Context); err != nil {
 			return err
 		}
 	}
@@ -258,18 +362,19 @@ func (s *service) Stop() error {
 
 func (s *service) Run() error {
 	// start the profiler
-	if s.opts.Profile != nil {
-		// to view mutex contention
-		rtime.SetMutexProfileFraction(5)
-		// to view blocking profile
-		rtime.SetBlockProfileRate(1)
+	/*
+		if s.opts.Profile != nil {
+			// to view mutex contention
+			rtime.SetMutexProfileFraction(5)
+			// to view blocking profile
+			rtime.SetBlockProfileRate(1)
 
-		if err := s.opts.Profile.Start(); err != nil {
-			return err
+			if err := s.opts.Profile.Start(); err != nil {
+				return err
+			}
+			defer s.opts.Profile.Stop()
 		}
-		defer s.opts.Profile.Stop()
-	}
-
+	*/
 	if err := s.Start(); err != nil {
 		return err
 	}
@@ -279,3 +384,16 @@ func (s *service) Run() error {
 
 	return s.Stop()
 }
+
+type nameIface interface {
+	Name() string
+}
+
+func getNameIndex(n string, ifaces ...interface{}) int {
+	for idx, iface := range ifaces {
+		if ifc, ok := iface.(nameIface); ok && ifc.Name() == n {
+			return idx
+		}
+	}
+	return 0
+}

store/context.go

@@ -32,3 +32,53 @@ func SetOption(k, v interface{}) Option {
 		o.Context = context.WithValue(o.Context, k, v)
 	}
 }
+
+// SetReadOption returns a function to setup a context with given value
+func SetReadOption(k, v interface{}) ReadOption {
+	return func(o *ReadOptions) {
+		if o.Context == nil {
+			o.Context = context.Background()
+		}
+		o.Context = context.WithValue(o.Context, k, v)
+	}
+}
+
+// SetWriteOption returns a function to setup a context with given value
+func SetWriteOption(k, v interface{}) WriteOption {
+	return func(o *WriteOptions) {
+		if o.Context == nil {
+			o.Context = context.Background()
+		}
+		o.Context = context.WithValue(o.Context, k, v)
+	}
+}
+
+// SetListOption returns a function to setup a context with given value
+func SetListOption(k, v interface{}) ListOption {
+	return func(o *ListOptions) {
+		if o.Context == nil {
+			o.Context = context.Background()
+		}
+		o.Context = context.WithValue(o.Context, k, v)
+	}
+}
+
+// SetDeleteOption returns a function to setup a context with given value
+func SetDeleteOption(k, v interface{}) DeleteOption {
+	return func(o *DeleteOptions) {
+		if o.Context == nil {
+			o.Context = context.Background()
+		}
+		o.Context = context.WithValue(o.Context, k, v)
+	}
+}
+
+// SetExistsOption returns a function to setup a context with given value
+func SetExistsOption(k, v interface{}) ExistsOption {
+	return func(o *ExistsOptions) {
+		if o.Context == nil {
+			o.Context = context.Background()
+		}
+		o.Context = context.WithValue(o.Context, k, v)
+	}
+}

store/memory.go

@@ -0,0 +1,199 @@
+package store
+
+import (
+	"context"
+	"path/filepath"
+	"sort"
+	"strings"
+	"time"
+
+	"github.com/patrickmn/go-cache"
+)
+
+// NewStore returns a memory store
+func NewStore(opts ...Option) Store {
+	return &memoryStore{
+		opts:  NewOptions(opts...),
+		store: cache.New(cache.NoExpiration, 5*time.Minute),
+	}
+}
+
+func (m *memoryStore) Connect(ctx context.Context) error {
+	return nil
+}
+
+func (m *memoryStore) Disconnect(ctx context.Context) error {
+	m.store.Flush()
+	return nil
+}
+
+type memoryStore struct {
+	opts  Options
+	store *cache.Cache
+}
+
+func (m *memoryStore) key(prefix, key string) string {
+	return filepath.Join(prefix, key)
+}
+
+func (m *memoryStore) prefix(database, table string) string {
+	if len(database) == 0 {
+		database = m.opts.Database
+	}
+	if len(table) == 0 {
+		table = m.opts.Table
+	}
+	return filepath.Join(database, table)
+}
+
+func (m *memoryStore) exists(prefix, key string) error {
+	key = m.key(prefix, key)
+
+	_, found := m.store.Get(key)
+	if !found {
+		return ErrNotFound
+	}
+
+	return nil
+}
+
+func (m *memoryStore) get(prefix, key string, val interface{}) error {
+	key = m.key(prefix, key)
+
+	r, found := m.store.Get(key)
+	if !found {
+		return ErrNotFound
+	}
+
+	buf, ok := r.([]byte)
+	if !ok {
+		return ErrNotFound
+	}
+
+	if err := m.opts.Codec.Unmarshal(buf, val); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func (m *memoryStore) delete(prefix, key string) {
+	key = m.key(prefix, key)
+	m.store.Delete(key)
+}
+
+func (m *memoryStore) list(prefix string, limit, offset uint) []string {
+	allItems := m.store.Items()
+	allKeys := make([]string, len(allItems))
+	i := 0
+
+	for k := range allItems {
+		if !strings.HasPrefix(k, prefix+"/") {
+			continue
+		}
+		allKeys[i] = strings.TrimPrefix(k, prefix+"/")
+		i++
+	}
+
+	if limit != 0 || offset != 0 {
+		sort.Slice(allKeys, func(i, j int) bool { return allKeys[i] < allKeys[j] })
+		sort.Slice(allKeys, func(i, j int) bool { return allKeys[i] < allKeys[j] })
+		end := len(allKeys)
+		if limit > 0 {
+			calcLimit := int(offset + limit)
+			if calcLimit < end {
+				end = calcLimit
+			}
+		}
+
+		if int(offset) >= end {
+			return nil
+		}
+		return allKeys[offset:end]
+	}
+
+	return allKeys
+}
+
+func (m *memoryStore) Init(opts ...Option) error {
+	for _, o := range opts {
+		o(&m.opts)
+	}
+	return nil
+}
+
+func (m *memoryStore) String() string {
+	return "memory"
+}
+
+func (m *memoryStore) Name() string {
+	return m.opts.Name
+}
+
+func (m *memoryStore) Exists(ctx context.Context, key string, opts ...ExistsOption) error {
+	prefix := m.prefix(m.opts.Database, m.opts.Table)
+	return m.exists(prefix, key)
+}
+
+func (m *memoryStore) Read(ctx context.Context, key string, val interface{}, opts ...ReadOption) error {
+	readOpts := NewReadOptions(opts...)
+	prefix := m.prefix(readOpts.Database, readOpts.Table)
+	return m.get(prefix, key, val)
+}
+
+func (m *memoryStore) Write(ctx context.Context, key string, val interface{}, opts ...WriteOption) error {
+	writeOpts := NewWriteOptions(opts...)
+
+	prefix := m.prefix(writeOpts.Database, writeOpts.Table)
+
+	key = m.key(prefix, key)
+
+	buf, err := m.opts.Codec.Marshal(val)
+	if err != nil {
+		return err
+	}
+
+	m.store.Set(key, buf, writeOpts.TTL)
+	return nil
+}
+
+func (m *memoryStore) Delete(ctx context.Context, key string, opts ...DeleteOption) error {
+	deleteOptions := NewDeleteOptions(opts...)
+
+	prefix := m.prefix(deleteOptions.Database, deleteOptions.Table)
+	m.delete(prefix, key)
+	return nil
+}
+
+func (m *memoryStore) Options() Options {
+	return m.opts
+}
+
+func (m *memoryStore) List(ctx context.Context, opts ...ListOption) ([]string, error) {
+	listOptions := NewListOptions(opts...)
+
+	prefix := m.prefix(listOptions.Database, listOptions.Table)
+	keys := m.list(prefix, listOptions.Limit, listOptions.Offset)
+
+	if len(listOptions.Prefix) > 0 {
+		var prefixKeys []string
+		for _, k := range keys {
+			if strings.HasPrefix(k, listOptions.Prefix) {
+				prefixKeys = append(prefixKeys, k)
+			}
+		}
+		keys = prefixKeys
+	}
+
+	if len(listOptions.Suffix) > 0 {
+		var suffixKeys []string
+		for _, k := range keys {
+			if strings.HasSuffix(k, listOptions.Suffix) {
+				suffixKeys = append(suffixKeys, k)
+			}
+		}
+		keys = suffixKeys
+	}
+
+	return keys, nil
+}

store/memory_test.go

@@ -0,0 +1,67 @@
+package store_test
+
+import (
+	"context"
+	"os"
+	"testing"
+	"time"
+
+	"github.com/unistack-org/micro/v3/store"
+)
+
+func TestMemoryReInit(t *testing.T) {
+	s := store.NewStore(store.Table("aaa"))
+	s.Init(store.Table(""))
+	if len(s.Options().Table) > 0 {
+		t.Error("Init didn't reinitialise the store")
+	}
+}
+
+func TestMemoryBasic(t *testing.T) {
+	s := store.NewStore()
+	s.Init()
+	basictest(s, t)
+}
+
+func TestMemoryPrefix(t *testing.T) {
+	s := store.NewStore()
+	s.Init(store.Table("some-prefix"))
+	basictest(s, t)
+}
+
+func TestMemoryNamespace(t *testing.T) {
+	s := store.NewStore()
+	s.Init(store.Database("some-namespace"))
+	basictest(s, t)
+}
+
+func TestMemoryNamespacePrefix(t *testing.T) {
+	s := store.NewStore()
+	s.Init(store.Table("some-prefix"), store.Database("some-namespace"))
+	basictest(s, t)
+}
+
+func basictest(s store.Store, t *testing.T) {
+	ctx := context.Background()
+	if len(os.Getenv("IN_TRAVIS_CI")) == 0 {
+		t.Logf("Testing store %s, with options %#+v\n", s.String(), s.Options())
+	}
+	// Read and Write an expiring Record
+	if err := s.Write(ctx, "Hello", "World", store.WriteTTL(time.Millisecond*100)); err != nil {
+		t.Error(err)
+	}
+	var val []byte
+	if err := s.Read(ctx, "Hello", &val); err != nil {
+		t.Error(err)
+	} else {
+		if string(val) != "World" {
+			t.Errorf("Expected %s, got %s", "World", val)
+		}
+	}
+	time.Sleep(time.Millisecond * 200)
+	if err := s.Read(ctx, "Hello", &val); err != store.ErrNotFound {
+		t.Errorf("Expected %# v, got %# v", store.ErrNotFound, err)
+	}
+
+	s.Disconnect(ctx) // reset the store
+}

store/noop.go

@@ -1,64 +0,0 @@
-package store
-
-import "context"
-
-type noopStore struct {
-	opts Options
-}
-
-func NewStore(opts ...Option) Store {
-	return &noopStore{opts: NewOptions(opts...)}
-}
-
-// Init initialize store
-func (n *noopStore) Init(opts ...Option) error {
-	for _, o := range opts {
-		o(&n.opts)
-	}
-	return nil
-}
-
-// Options returns Options struct
-func (n *noopStore) Options() Options {
-	return n.opts
-}
-
-// String returns string representation
-func (n *noopStore) String() string {
-	return "noop"
-}
-
-// Read reads store value by key
-func (n *noopStore) Exists(ctx context.Context, key string) error {
-	return ErrNotFound
-}
-
-// Read reads store value by key
-func (n *noopStore) Read(ctx context.Context, key string, val interface{}, opts ...ReadOption) error {
-	return ErrNotFound
-}
-
-// Write writes store record
-func (n *noopStore) Write(ctx context.Context, key string, val interface{}, opts ...WriteOption) error {
-	return nil
-}
-
-// Delete removes store value by key
-func (n *noopStore) Delete(ctx context.Context, key string, opts ...DeleteOption) error {
-	return nil
-}
-
-// List lists store
-func (n *noopStore) List(ctx context.Context, opts ...ListOption) ([]string, error) {
-	return []string{}, nil
-}
-
-// Connect connects to store
-func (n *noopStore) Connect(ctx context.Context) error {
-	return nil
-}
-
-// Disconnect disconnects from store
-func (n *noopStore) Disconnect(ctx context.Context) error {
-	return nil
-}

store/options.go

@@ -2,15 +2,19 @@ package store
 
 import (
 	"context"
+	"crypto/tls"
 	"time"
 
 	"github.com/unistack-org/micro/v3/codec"
 	"github.com/unistack-org/micro/v3/logger"
 	"github.com/unistack-org/micro/v3/metadata"
+	"github.com/unistack-org/micro/v3/meter"
+	"github.com/unistack-org/micro/v3/tracer"
 )
 
 // Options contains configuration for the Store
 type Options struct {
+	Name string
 	// Nodes contains the addresses or other connection information of the backing storage.
 	// For example, an etcd implementation would contain the nodes of the cluster.
 	// A SQL implementation could contain one or more connection strings.
@@ -23,6 +27,13 @@ type Options struct {
 	Codec codec.Codec
 	// Logger the logger
 	Logger logger.Logger
+	// Meter the meter
+	Meter meter.Meter
+	// Tracer the tacer
+	Tracer tracer.Tracer
+	// TLSConfig specifies tls.Config for secure
+	TLSConfig *tls.Config
+
 	// Context should contain all implementation specific options, using context.WithValue.
 	Context context.Context
 }
@@ -33,6 +44,8 @@ func NewOptions(opts ...Option) Options {
 		Logger:  logger.DefaultLogger,
 		Context: context.Background(),
 		Codec:   codec.DefaultCodec,
+		Tracer:  tracer.DefaultTracer,
+		Meter:   meter.DefaultMeter,
 	}
 	for _, o := range opts {
 		o(&options)
@@ -43,6 +56,13 @@ func NewOptions(opts ...Option) Options {
 // Option sets values in Options
 type Option func(o *Options)
 
+// TLSConfig specifies a *tls.Config
+func TLSConfig(t *tls.Config) Option {
+	return func(o *Options) {
+		o.TLSConfig = t
+	}
+}
+
 // Context pass context to store
 func Context(ctx context.Context) Option {
 	return func(o *Options) {
@@ -64,6 +84,27 @@ func Logger(l logger.Logger) Option {
 	}
 }
 
+// Meter sets the meter
+func Meter(m meter.Meter) Option {
+	return func(o *Options) {
+		o.Meter = m
+	}
+}
+
+// Name the name
+func Name(n string) Option {
+	return func(o *Options) {
+		o.Name = n
+	}
+}
+
+// Tracer sets the tracer
+func Tracer(t tracer.Tracer) Option {
+	return func(o *Options) {
+		o.Tracer = t
+	}
+}
+
 // Nodes contains the addresses or other connection information of the backing storage.
 // For example, an etcd implementation would contain the nodes of the cluster.
 // A SQL implementation could contain one or more connection strings.
@@ -98,8 +139,10 @@ func NewReadOptions(opts ...ReadOption) ReadOptions {
 
 // ReadOptions configures an individual Read operation
 type ReadOptions struct {
-	Database string
-	Table    string
+	Database  string
+	Table     string
+	Namespace string
+	Context   context.Context
 }
 
 // ReadOption sets values in ReadOptions
@@ -124,10 +167,12 @@ func NewWriteOptions(opts ...WriteOption) WriteOptions {
 
 // WriteOptions configures an individual Write operation
 type WriteOptions struct {
-	Database string
-	Table    string
-	TTL      time.Duration
-	Metadata metadata.Metadata
+	Database  string
+	Table     string
+	TTL       time.Duration
+	Metadata  metadata.Metadata
+	Namespace string
+	Context   context.Context
 }
 
 // WriteOption sets values in WriteOptions
@@ -166,7 +211,10 @@ func NewDeleteOptions(opts ...DeleteOption) DeleteOptions {
 
 // DeleteOptions configures an individual Delete operation
 type DeleteOptions struct {
-	Database, Table string
+	Database  string
+	Table     string
+	Namespace string
+	Context   context.Context
 }
 
 // DeleteOption sets values in DeleteOptions
@@ -200,7 +248,9 @@ type ListOptions struct {
 	// Limit limits the number of returned keys
 	Limit uint
 	// Offset when combined with Limit supports pagination
-	Offset uint
+	Offset    uint
+	Namespace string
+	Context   context.Context
 }
 
 // ListOption sets values in ListOptions
@@ -241,3 +291,20 @@ func ListOffset(o uint) ListOption {
 		l.Offset = o
 	}
 }
+
+type ExistsOption func(*ExistsOptions)
+
+type ExistsOptions struct {
+	Namespace string
+	Context   context.Context
+}
+
+func NewExistsOptions(opts ...ExistsOption) ExistsOptions {
+	options := ExistsOptions{
+		Context: context.Background(),
+	}
+	for _, o := range opts {
+		o(&options)
+	}
+	return options
+}

store/store.go

@@ -12,12 +12,15 @@ import (
 var (
 	// ErrNotFound is returned when a key doesn't exist
 	ErrNotFound = errors.New("not found")
+	// ErrInvalidKey is returned when a key has empty or have invalid format
+	ErrInvalidKey = errors.New("invalid key")
 	// DefaultStore is the global default store
 	DefaultStore Store = NewStore()
 )
 
 // Store is a data storage interface
 type Store interface {
+	Name() string
 	// Init initialises the store
 	Init(opts ...Option) error
 	// Connect is used when store needs to be connected
@@ -25,7 +28,7 @@ type Store interface {
 	// Options allows you to view the current options.
 	Options() Options
 	// Exists check that key exists in store
-	Exists(ctx context.Context, key string) error
+	Exists(ctx context.Context, key string, opts ...ExistsOption) error
 	// Read reads a single key name to provided value with optional ReadOptions
 	Read(ctx context.Context, key string, val interface{}, opts ...ReadOption) error
 	// Write writes a value to key name to the store with optional WriteOption

sync/memory.go

@@ -0,0 +1,199 @@
+package sync
+
+import (
+	gosync "sync"
+	"time"
+)
+
+type memorySync struct {
+	options Options
+
+	mtx   gosync.RWMutex
+	locks map[string]*memoryLock
+}
+
+type memoryLock struct {
+	id      string
+	time    time.Time
+	ttl     time.Duration
+	release chan bool
+}
+
+type memoryLeader struct {
+	opts   LeaderOptions
+	id     string
+	resign func(id string) error
+	status chan bool
+}
+
+func (m *memoryLeader) Resign() error {
+	return m.resign(m.id)
+}
+
+func (m *memoryLeader) Status() chan bool {
+	return m.status
+}
+
+func (m *memorySync) Leader(id string, opts ...LeaderOption) (Leader, error) {
+	var once gosync.Once
+	var options LeaderOptions
+	for _, o := range opts {
+		o(&options)
+	}
+
+	// acquire a lock for the id
+	if err := m.Lock(id); err != nil {
+		return nil, err
+	}
+
+	// return the leader
+	return &memoryLeader{
+		opts: options,
+		id:   id,
+		resign: func(id string) error {
+			once.Do(func() {
+				m.Unlock(id)
+			})
+			return nil
+		},
+		// TODO: signal when Unlock is called
+		status: make(chan bool, 1),
+	}, nil
+}
+
+func (m *memorySync) Init(opts ...Option) error {
+	for _, o := range opts {
+		o(&m.options)
+	}
+	return nil
+}
+
+func (m *memorySync) Options() Options {
+	return m.options
+}
+
+func (m *memorySync) Lock(id string, opts ...LockOption) error {
+	// lock our access
+	m.mtx.Lock()
+
+	var options LockOptions
+	for _, o := range opts {
+		o(&options)
+	}
+
+	lk, ok := m.locks[id]
+	if !ok {
+		m.locks[id] = &memoryLock{
+			id:      id,
+			time:    time.Now(),
+			ttl:     options.TTL,
+			release: make(chan bool),
+		}
+		// unlock
+		m.mtx.Unlock()
+		return nil
+	}
+
+	m.mtx.Unlock()
+
+	// set wait time
+	var wait <-chan time.Time
+	var ttl <-chan time.Time
+
+	// decide if we should wait
+	if options.Wait > time.Duration(0) {
+		wait = time.After(options.Wait)
+	}
+
+	// check the ttl of the lock
+	if lk.ttl > time.Duration(0) {
+		// time lived for the lock
+		live := time.Since(lk.time)
+
+		// set a timer for the leftover ttl
+		if live > lk.ttl {
+			// release the lock if it expired
+			_ = m.Unlock(id)
+		} else {
+			ttl = time.After(live)
+		}
+	}
+
+lockLoop:
+	for {
+		// wait for the lock to be released
+		select {
+		case <-lk.release:
+			m.mtx.Lock()
+
+			// someone locked before us
+			lk, ok = m.locks[id]
+			if ok {
+				m.mtx.Unlock()
+				continue
+			}
+
+			// got chance to lock
+			m.locks[id] = &memoryLock{
+				id:      id,
+				time:    time.Now(),
+				ttl:     options.TTL,
+				release: make(chan bool),
+			}
+
+			m.mtx.Unlock()
+
+			break lockLoop
+		case <-ttl:
+			// ttl exceeded
+			_ = m.Unlock(id)
+			// TODO: check the ttl again above
+			ttl = nil
+			// try acquire
+			continue
+		case <-wait:
+			return ErrLockTimeout
+		}
+	}
+
+	return nil
+}
+
+func (m *memorySync) Unlock(id string) error {
+	m.mtx.Lock()
+	defer m.mtx.Unlock()
+
+	lk, ok := m.locks[id]
+	// no lock exists
+	if !ok {
+		return nil
+	}
+
+	// delete the lock
+	delete(m.locks, id)
+
+	select {
+	case <-lk.release:
+		return nil
+	default:
+		close(lk.release)
+	}
+
+	return nil
+}
+
+func (m *memorySync) String() string {
+	return "memory"
+}
+
+func NewSync(opts ...Option) Sync {
+	var options Options
+	for _, o := range opts {
+		o(&options)
+	}
+
+	return &memorySync{
+		options: options,
+		locks:   make(map[string]*memoryLock),
+	}
+}

sync/options.go

@@ -4,16 +4,34 @@ import (
 	"time"
 
 	"github.com/unistack-org/micro/v3/logger"
+	"github.com/unistack-org/micro/v3/meter"
+	"github.com/unistack-org/micro/v3/tracer"
 )
 
 type Options struct {
 	Nodes  []string
 	Prefix string
 	Logger logger.Logger
+	Tracer tracer.Tracer
+	Meter  meter.Meter
 }
 
 type Option func(o *Options)
 
+func NewOptions(opts ...Option) Options {
+	options := Options{
+		Logger: logger.DefaultLogger,
+		Meter:  meter.DefaultMeter,
+		Tracer: tracer.DefaultTracer,
+	}
+
+	for _, o := range opts {
+		o(&options)
+	}
+
+	return options
+}
+
 type LeaderOptions struct{}
 
 type LeaderOption func(o *LeaderOptions)
@@ -32,6 +50,20 @@ func Logger(l logger.Logger) Option {
 	}
 }
 
+// Meter sets the logger
+func Meter(m meter.Meter) Option {
+	return func(o *Options) {
+		o.Meter = m
+	}
+}
+
+// Tracer sets the tracer
+func Tracer(t tracer.Tracer) Option {
+	return func(o *Options) {
+		o.Tracer = t
+	}
+}
+
 // Nodes sets the addresses to use
 func Nodes(a ...string) Option {
 	return func(o *Options) {

tracer/context.go

@@ -14,11 +14,12 @@ const (
 
 // FromContext returns a span from context
 func FromContext(ctx context.Context) (traceID string, parentSpanID string, isFound bool) {
-	if ctx == nil {
+	md, ok := metadata.FromIncomingContext(ctx)
+	if !ok {
 		return "", "", false
 	}
-	traceID, traceOk := metadata.Get(ctx, traceIDKey)
-	microID, microOk := metadata.Get(ctx, "Micro-Id")
+	traceID, traceOk := md.Get(traceIDKey)
+	microID, microOk := md.Get("Micro-Id")
 	if !traceOk && !microOk {
 		isFound = false
 		return
@@ -26,17 +27,17 @@ func FromContext(ctx context.Context) (traceID string, parentSpanID string, isFo
 	if !traceOk {
 		traceID = microID
 	}
-	parentSpanID, ok := metadata.Get(ctx, spanIDKey)
+	parentSpanID, ok = md.Get(spanIDKey)
 	return traceID, parentSpanID, ok
 }
 
 // NewContext saves the trace and span ids in the context
 func NewContext(ctx context.Context, traceID, parentSpanID string) context.Context {
-	if ctx == nil {
-		ctx = context.Background()
+	md, ok := metadata.FromContext(ctx)
+	if !ok {
+		md = metadata.New(2)
 	}
-	md := metadata.New(2)
 	md.Set(traceIDKey, traceID)
 	md.Set(spanIDKey, parentSpanID)
-	return metadata.MergeContext(ctx, md, true)
+	return metadata.NewContext(ctx, md)
 }

tracer/memory.go

@@ -0,0 +1,98 @@
+package tracer
+
+import (
+	"context"
+	"time"
+
+	"github.com/google/uuid"
+	"github.com/unistack-org/micro/v3/util/ring"
+)
+
+type tracer struct {
+	opts Options
+	// ring buffer of traces
+	buffer *ring.Buffer
+}
+
+func (t *tracer) Read(opts ...ReadOption) ([]*Span, error) {
+	var options ReadOptions
+	for _, o := range opts {
+		o(&options)
+	}
+
+	sp := t.buffer.Get(t.buffer.Size())
+
+	spans := make([]*Span, 0, len(sp))
+
+	for _, span := range sp {
+		val := span.Value.(*Span)
+		// skip if trace id is specified and doesn't match
+		if len(options.Trace) > 0 && val.Trace != options.Trace {
+			continue
+		}
+		spans = append(spans, val)
+	}
+
+	return spans, nil
+}
+
+func (t *tracer) Start(ctx context.Context, name string) (context.Context, *Span) {
+	span := &Span{
+		Name:     name,
+		Trace:    uuid.New().String(),
+		Id:       uuid.New().String(),
+		Started:  time.Now(),
+		Metadata: make(map[string]string),
+	}
+
+	// return span if no context
+	if ctx == nil {
+		return NewContext(context.Background(), span.Trace, span.Id), span
+	}
+	traceID, parentSpanID, ok := FromContext(ctx)
+	// If the trace can not be found in the header,
+	// that means this is where the trace is created.
+	if !ok {
+		return NewContext(ctx, span.Trace, span.Id), span
+	}
+
+	// set trace id
+	span.Trace = traceID
+	// set parent
+	span.Parent = parentSpanID
+
+	// return the span
+	return NewContext(ctx, span.Trace, span.Id), span
+}
+
+func (t *tracer) Finish(s *Span) error {
+	// set finished time
+	s.Duration = time.Since(s.Started)
+	// save the span
+	t.buffer.Put(s)
+
+	return nil
+}
+
+func (t *tracer) Init(opts ...Option) error {
+	for _, o := range opts {
+		o(&t.opts)
+	}
+	return nil
+}
+
+func (t *tracer) Lookup(ctx context.Context) (*Span, error) {
+	return nil, nil
+}
+
+func (t *tracer) Name() string {
+	return t.opts.Name
+}
+
+func NewTracer(opts ...Option) Tracer {
+	return &tracer{
+		opts: NewOptions(opts...),
+		// the last 256 requests
+		buffer: ring.New(256),
+	}
+}

tracer/noop.go

@@ -1,35 +0,0 @@
-package tracer
-
-import "context"
-
-type noopTracer struct {
-	opts Options
-}
-
-// Init initilize tracer
-func (n *noopTracer) Init(opts ...Option) error {
-	for _, o := range opts {
-		o(&n.opts)
-	}
-	return nil
-}
-
-// Start starts new span
-func (n *noopTracer) Start(ctx context.Context, name string) (context.Context, *Span) {
-	return nil, nil
-}
-
-// Finish finishes span
-func (n *noopTracer) Finish(*Span) error {
-	return nil
-}
-
-// Read reads span
-func (n *noopTracer) Read(...ReadOption) ([]*Span, error) {
-	return nil, nil
-}
-
-// NewTracer returns new noop tracer
-func NewTracer(opts ...Option) Tracer {
-	return &noopTracer{opts: NewOptions(opts...)}
-}

tracer/options.go

@@ -9,6 +9,7 @@ var (
 
 // Options struct
 type Options struct {
+	Name string
 	// Logger is the logger for messages
 	Logger logger.Logger
 	// Size is the size of ring buffer
@@ -52,3 +53,10 @@ func NewOptions(opts ...Option) Options {
 	}
 	return options
 }
+
+// Name sets the name
+func Name(n string) Option {
+	return func(o *Options) {
+		o.Name = n
+	}
+}

tracer/tracer.go

@@ -15,10 +15,14 @@ var (
 
 // Tracer is an interface for distributed tracing
 type Tracer interface {
+	Name() string
+	Init(...Option) error
 	// Start a trace
 	Start(ctx context.Context, name string) (context.Context, *Span)
 	// Finish the trace
 	Finish(*Span) error
+	// Lookup get span from context
+	Lookup(ctx context.Context) (*Span, error)
 	// Read the traces
 	Read(...ReadOption) ([]*Span, error)
 }