client: allow to set content-type for call

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

client/options.go

@@ -2,6 +2,7 @@ package client
 
 import (
 	"context"
+	"crypto/tls"
 	"time"
 
 	"github.com/unistack-org/micro/v3/broker"
@@ -52,6 +53,8 @@ type Options struct {
 	PoolSize int
 	// PoolTTL connection pool ttl
 	PoolTTL time.Duration
+	// TLSConfig specifies tls.Config for secure connection
+	TLSConfig *tls.Config
 }
 
 // NewCallOptions creates new call options struct
@@ -77,6 +80,8 @@ type CallOptions struct {
 	Backoff BackoffFunc
 	// Network name
 	Network string
+	// Content-Type
+	ContentType string
 	// CallWrappers call wrappers
 	CallWrappers []CallWrapper
 	// SelectOptions selector options
@@ -167,14 +172,16 @@ func NewOptions(opts ...Option) Options {
 			RequestTimeout: DefaultRequestTimeout,
 			DialTimeout:    transport.DefaultDialTimeout,
 		},
-		Lookup:   LookupRoute,
-		PoolSize: DefaultPoolSize,
-		PoolTTL:  DefaultPoolTTL,
-		Selector: random.NewSelector(),
-		Logger:   logger.DefaultLogger,
-		Broker:   broker.DefaultBroker,
-		Meter:    meter.DefaultMeter,
-		Tracer:   tracer.DefaultTracer,
+		Lookup:    LookupRoute,
+		PoolSize:  DefaultPoolSize,
+		PoolTTL:   DefaultPoolTTL,
+		Selector:  random.NewSelector(),
+		Logger:    logger.DefaultLogger,
+		Broker:    broker.DefaultBroker,
+		Meter:     meter.DefaultMeter,
+		Tracer:    tracer.DefaultTracer,
+		Router:    router.DefaultRouter,
+		Transport: transport.DefaultTransport,
 	}
 
 	for _, o := range opts {
@@ -312,6 +319,22 @@ func Lookup(l LookupFunc) Option {
 	}
 }
 
+// TLSConfig specifies a *tls.Config
+func TLSConfig(t *tls.Config) Option {
+	return func(o *Options) {
+		// set the internal tls
+		o.TLSConfig = t
+
+		// set the default transport if one is not
+		// already set. Required for Init call below.
+
+		// set the transport tls
+		o.Transport.Init(
+			transport.TLSConfig(t),
+		)
+	}
+}
+
 // Retries sets the retry count when making the request.
 func Retries(i int) Option {
 	return func(o *Options) {
@@ -361,6 +384,13 @@ func PublishContext(ctx context.Context) PublishOption {
 	}
 }
 
+// WithContentType specifies call content type
+func WithContentType(ct string) CallOption {
+	return func(o *CallOptions) {
+		o.ContentType = ct
+	}
+}
+
 // WithAddress sets the remote addresses to use rather than using service discovery
 func WithAddress(a ...string) CallOption {
 	return func(o *CallOptions) {
@@ -465,16 +495,16 @@ func WithMessageContentType(ct string) MessageOption {
 	}
 }
 
-// WithContentType specifies request content type
-func WithContentType(ct string) RequestOption {
+// StreamingRequest specifies that request is streaming
+func StreamingRequest(b bool) RequestOption {
+	return func(o *RequestOptions) {
+		o.Stream = b
+	}
+}
+
+// RequestContentType specifies request content type
+func RequestContentType(ct string) RequestOption {
 	return func(o *RequestOptions) {
 		o.ContentType = ct
 	}
 }
-
-// StreamingRequest specifies that request is streaming
-func StreamingRequest() RequestOption {
-	return func(o *RequestOptions) {
-		o.Stream = true
-	}
-}

go.mod

@@ -9,5 +9,5 @@ require (
 	github.com/imdario/mergo v0.3.12
 	github.com/patrickmn/go-cache v2.1.0+incompatible
 	github.com/silas/dag v0.0.0-20210121180416-41cf55125c34
-	golang.org/x/net v0.0.0-20210316092652-d523dce5a7f4
+	golang.org/x/net v0.0.0-20210405180319-a5a99cb37ef4
 )

go.sum

@@ -10,10 +10,10 @@ github.com/patrickmn/go-cache v2.1.0+incompatible h1:HRMgzkcYKYpi3C8ajMPV8OFXaaR
 github.com/patrickmn/go-cache v2.1.0+incompatible/go.mod h1:3Qf8kWWT7OJRJbdiICTKqZju1ZixQ/KpMGzzAfe6+WQ=
 github.com/silas/dag v0.0.0-20210121180416-41cf55125c34 h1:vBfVmA5mZhsQa2jr1FOL9nfA37N/jnbBmi5XUfviVTI=
 github.com/silas/dag v0.0.0-20210121180416-41cf55125c34/go.mod h1:7RTUFBdIRC9nZ7/3RyRNH1bdqIShrDejd1YbLwgPS+I=
-golang.org/x/net v0.0.0-20210316092652-d523dce5a7f4 h1:b0LrWgu8+q7z4J+0Y3Umo5q1dL7NXBkKBWkaVkAq17E=
-golang.org/x/net v0.0.0-20210316092652-d523dce5a7f4/go.mod h1:RBQZq4jEuRlivfhVLdyRGr576XBO4/greRjx4P4O3yc=
+golang.org/x/net v0.0.0-20210405180319-a5a99cb37ef4 h1:4nGaVu0QrbjT/AK2PRLuQfQuh6DJve+pELhqTdAj3x0=
+golang.org/x/net v0.0.0-20210405180319-a5a99cb37ef4/go.mod h1:p54w0d4576C0XHj96bSt6lcn1PtDYWL6XObtHCRCNQM=
 golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20210315160823-c6e025ad8005/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20210330210617-4fbd30eecc44/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
 golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
 golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=

logger/wrapper/wrapper.go

@@ -3,6 +3,7 @@ package wrapper
 
 import (
 	"context"
+	"fmt"
 
 	"github.com/unistack-org/micro/v3/client"
 	"github.com/unistack-org/micro/v3/logger"
@@ -57,6 +58,8 @@ var (
 		}
 		return labels
 	}
+
+	DefaultSkipEndpoints = []string{"Meter.Metrics"}
 )
 
 type lWrapper struct {
@@ -94,6 +97,8 @@ type Options struct {
 	ServerHandlerObservers []ServerHandlerObserver
 	// ServerSubscriberObservers funcs
 	ServerSubscriberObservers []ServerSubscriberObserver
+	// SkipEndpoints
+	SkipEndpoints []string
 }
 
 // Option func signature
@@ -110,6 +115,7 @@ func NewOptions(opts ...Option) Options {
 		ClientCallFuncObservers:   []ClientCallFuncObserver{DefaultClientCallFuncObserver},
 		ServerHandlerObservers:    []ServerHandlerObserver{DefaultServerHandlerObserver},
 		ServerSubscriberObservers: []ServerSubscriberObserver{DefaultServerSubscriberObserver},
+		SkipEndpoints:             DefaultSkipEndpoints,
 	}
 
 	for _, o := range opts {
@@ -182,9 +188,23 @@ func WithServerSubscriberObservers(ob ...ServerSubscriberObserver) Option {
 	}
 }
 
+// SkipEndpoins
+func SkipEndpoints(eps ...string) Option {
+	return func(o *Options) {
+		o.SkipEndpoints = append(o.SkipEndpoints, eps...)
+	}
+}
+
 func (l *lWrapper) Call(ctx context.Context, req client.Request, rsp interface{}, opts ...client.CallOption) error {
 	err := l.Client.Call(ctx, req, rsp, opts...)
 
+	endpoint := fmt.Sprintf("%s.%s", req.Service(), req.Endpoint())
+	for _, ep := range l.opts.SkipEndpoints {
+		if ep == endpoint {
+			return err
+		}
+	}
+
 	if !l.opts.Enabled {
 		return err
 	}
@@ -205,6 +225,13 @@ func (l *lWrapper) Call(ctx context.Context, req client.Request, rsp interface{}
 func (l *lWrapper) Stream(ctx context.Context, req client.Request, opts ...client.CallOption) (client.Stream, error) {
 	stream, err := l.Client.Stream(ctx, req, opts...)
 
+	endpoint := fmt.Sprintf("%s.%s", req.Service(), req.Endpoint())
+	for _, ep := range l.opts.SkipEndpoints {
+		if ep == endpoint {
+			return stream, err
+		}
+	}
+
 	if !l.opts.Enabled {
 		return stream, err
 	}
@@ -225,6 +252,13 @@ func (l *lWrapper) Stream(ctx context.Context, req client.Request, opts ...clien
 func (l *lWrapper) Publish(ctx context.Context, msg client.Message, opts ...client.PublishOption) error {
 	err := l.Client.Publish(ctx, msg, opts...)
 
+	endpoint := msg.Topic()
+	for _, ep := range l.opts.SkipEndpoints {
+		if ep == endpoint {
+			return err
+		}
+	}
+
 	if !l.opts.Enabled {
 		return err
 	}
@@ -245,6 +279,13 @@ func (l *lWrapper) Publish(ctx context.Context, msg client.Message, opts ...clie
 func (l *lWrapper) ServerHandler(ctx context.Context, req server.Request, rsp interface{}) error {
 	err := l.serverHandler(ctx, req, rsp)
 
+	endpoint := req.Endpoint()
+	for _, ep := range l.opts.SkipEndpoints {
+		if ep == endpoint {
+			return err
+		}
+	}
+
 	if !l.opts.Enabled {
 		return err
 	}
@@ -265,6 +306,13 @@ func (l *lWrapper) ServerHandler(ctx context.Context, req server.Request, rsp in
 func (l *lWrapper) ServerSubscriber(ctx context.Context, msg server.Message) error {
 	err := l.serverSubscriber(ctx, msg)
 
+	endpoint := msg.Topic()
+	for _, ep := range l.opts.SkipEndpoints {
+		if ep == endpoint {
+			return err
+		}
+	}
+
 	if !l.opts.Enabled {
 		return err
 	}
@@ -309,6 +357,13 @@ func NewClientCallWrapper(opts ...Option) client.CallWrapper {
 func (l *lWrapper) ClientCallFunc(ctx context.Context, addr string, req client.Request, rsp interface{}, opts client.CallOptions) error {
 	err := l.clientCallFunc(ctx, addr, req, rsp, opts)
 
+	endpoint := fmt.Sprintf("%s.%s", req.Service(), req.Endpoint())
+	for _, ep := range l.opts.SkipEndpoints {
+		if ep == endpoint {
+			return err
+		}
+	}
+
 	if !l.opts.Enabled {
 		return err
 	}

meter/handler/handler.go

@@ -1,10 +1,11 @@
-package pb
+package handler
 
 import (
 	"bytes"
 	"context"
 
 	"github.com/unistack-org/micro/v3/codec"
+	"github.com/unistack-org/micro/v3/errors"
 	"github.com/unistack-org/micro/v3/meter"
 )
 
@@ -13,21 +14,53 @@ var (
 	_ MeterServer = &handler{}
 )
 
-type Empty struct{}
-
 type handler struct {
-	meter meter.Meter
-	opts  []meter.Option
+	opts Options
 }
 
-func NewHandler(meter meter.Meter, opts ...meter.Option) *handler {
-	return &handler{meter: meter, opts: opts}
+type Option func(*Options)
+
+type Options struct {
+	Meter        meter.Meter
+	MeterOptions []meter.Option
+	Name         string
 }
 
-func (h *handler) Metrics(ctx context.Context, req *Empty, rsp *codec.Frame) error {
+func Meter(m meter.Meter) Option {
+	return func(o *Options) {
+		o.Meter = m
+	}
+}
+
+func Name(name string) Option {
+	return func(o *Options) {
+		o.Name = name
+	}
+}
+
+func MeterOptions(opts ...meter.Option) Option {
+	return func(o *Options) {
+		o.MeterOptions = append(o.MeterOptions, opts...)
+	}
+}
+
+func NewOptions(opts ...Option) Options {
+	options := Options{Meter: meter.DefaultMeter}
+	for _, o := range opts {
+		o(&options)
+	}
+	return options
+}
+
+func NewHandler(opts ...Option) *handler {
+	options := NewOptions(opts...)
+	return &handler{opts: options}
+}
+
+func (h *handler) Metrics(ctx context.Context, req *codec.Frame, rsp *codec.Frame) error {
 	buf := bytes.NewBuffer(nil)
-	if err := h.meter.Write(buf, h.opts...); err != nil {
-		return err
+	if err := h.opts.Meter.Write(buf, h.opts.MeterOptions...); err != nil {
+		return errors.InternalServerError(h.opts.Name, "%v", err)
 	}
 
 	rsp.Data = buf.Bytes()

meter/handler/handler.proto

@@ -1,14 +1,14 @@
 syntax = "proto3";
 
-package meter;
-option go_package = "github.com/unistack-org/micro/v3/meter/handler;pb";
+package micro.meter.handler;
+option go_package = "github.com/unistack-org/micro/v3/meter/handler;handler";
 
 import "api/annotations.proto";
 import "openapiv2/annotations.proto";
 import "codec/frame.proto";
 
 service Meter {
-	rpc Metrics(Empty) returns (micro.codec.Frame) {
+	rpc Metrics(micro.codec.Frame) returns (micro.codec.Frame) {
 		option (micro.openapiv2.openapiv2_operation) = {
       operation_id: "Metrics";
         responses: {
@@ -17,7 +17,7 @@ service Meter {
             description: "Error response";
             schema: {
               json_schema: {
-                ref: "Empty";
+                ref: "micro.codec.Frame";
               }
             }
           }
@@ -26,5 +26,3 @@ service Meter {
 		option (micro.api.http) = { get: "/metrics"; };
   };
 };
-
-message Empty{};

meter/handler/handler_micro.pb.go

@@ -1,6 +1,6 @@
 // Code generated by protoc-gen-micro
 // source: handler.proto
-package pb
+package handler
 
 import (
 	context "context"
@@ -20,5 +20,5 @@ func NewMeterEndpoints() []*api.Endpoint {
 }
 
 type MeterServer interface {
-	Metrics(ctx context.Context, req *Empty, rsp *codec.Frame) error
+	Metrics(ctx context.Context, req *codec.Frame, rsp *codec.Frame) error
 }

meter/handler/handler_micro_http.pb.go

@@ -1,6 +1,6 @@
 // Code generated by protoc-gen-micro
 // source: handler.proto
-package pb
+package handler
 
 import (
 	context "context"
@@ -13,20 +13,21 @@ type meterServer struct {
 	MeterServer
 }
 
-func (h *meterServer) Metrics(ctx context.Context, req *Empty, rsp *codec.Frame) error {
+func (h *meterServer) Metrics(ctx context.Context, req *codec.Frame, rsp *codec.Frame) error {
 	return h.MeterServer.Metrics(ctx, req, rsp)
 }
 
 func RegisterMeterServer(s server.Server, sh MeterServer, opts ...server.HandlerOption) error {
 	type meter interface {
-		Metrics(ctx context.Context, req *Empty, rsp *codec.Frame) error
+		Metrics(ctx context.Context, req *codec.Frame, rsp *codec.Frame) error
 	}
 	type Meter struct {
 		meter
 	}
 	h := &meterServer{sh}
+	var nopts []server.HandlerOption
 	for _, endpoint := range NewMeterEndpoints() {
-		opts = append(opts, api.WithEndpoint(endpoint))
+		nopts = append(nopts, api.WithEndpoint(endpoint))
 	}
-	return s.Handle(s.NewHandler(&Meter{h}, opts...))
+	return s.Handle(s.NewHandler(&Meter{h}, append(nopts, opts...)...))
 }

meter/wrapper/wrapper.go

@@ -34,16 +34,18 @@ var (
 )
 
 type Options struct {
-	Meter meter.Meter
-	lopts []meter.Option
+	Meter         meter.Meter
+	lopts         []meter.Option
+	SkipEndpoints []string
 }
 
 type Option func(*Options)
 
 func NewOptions(opts ...Option) Options {
 	options := Options{
-		Meter: meter.DefaultMeter,
-		lopts: make([]meter.Option, 0, 5),
+		Meter:         meter.DefaultMeter,
+		lopts:         make([]meter.Option, 0, 5),
+		SkipEndpoints: DefaultSkipEndpoints,
 	}
 	for _, o := range opts {
 		o(&options)
@@ -75,6 +77,12 @@ func Meter(m meter.Meter) Option {
 	}
 }
 
+func SkipEndoints(eps ...string) Option {
+	return func(o *Options) {
+		o.SkipEndpoints = append(o.SkipEndpoints, eps...)
+	}
+}
+
 type wrapper struct {
 	client.Client
 	callFunc client.CallFunc
@@ -103,7 +111,7 @@ func NewCallWrapper(opts ...Option) client.CallWrapper {
 
 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())
-	for _, ep := range DefaultSkipEndpoints {
+	for _, ep := range w.opts.SkipEndpoints {
 		if ep == endpoint {
 			return w.callFunc(ctx, addr, req, rsp, opts)
 		}
@@ -130,7 +138,7 @@ func (w *wrapper) CallFunc(ctx context.Context, addr string, req client.Request,
 
 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())
-	for _, ep := range DefaultSkipEndpoints {
+	for _, ep := range w.opts.SkipEndpoints {
 		if ep == endpoint {
 			return w.Client.Call(ctx, req, rsp, opts...)
 		}
@@ -158,7 +166,7 @@ func (w *wrapper) Call(ctx context.Context, req client.Request, rsp interface{},
 
 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())
-	for _, ep := range DefaultSkipEndpoints {
+	for _, ep := range w.opts.SkipEndpoints {
 		if ep == endpoint {
 			return w.Client.Stream(ctx, req, opts...)
 		}
@@ -217,7 +225,7 @@ func NewHandlerWrapper(opts ...Option) server.HandlerWrapper {
 func (w *wrapper) HandlerFunc(fn server.HandlerFunc) server.HandlerFunc {
 	return func(ctx context.Context, req server.Request, rsp interface{}) error {
 		endpoint := req.Endpoint()
-		for _, ep := range DefaultSkipEndpoints {
+		for _, ep := range w.opts.SkipEndpoints {
 			if ep == endpoint {
 				return fn(ctx, req, rsp)
 			}

router/dns.go

@@ -0,0 +1,91 @@
+package router
+
+import (
+	"fmt"
+	"net"
+	"strconv"
+)
+
+// NewRouter returns an initialized dns router
+func NewRouter(opts ...Option) Router {
+	options := NewOptions(opts...)
+	return &dns{options}
+}
+
+type dns struct {
+	options Options
+}
+
+func (d *dns) Init(opts ...Option) error {
+	for _, o := range opts {
+		o(&d.options)
+	}
+	return nil
+}
+
+func (d *dns) Options() Options {
+	return d.options
+}
+
+func (d *dns) Table() Table {
+	return nil
+}
+
+func (d *dns) Close() error {
+	return nil
+}
+
+func (d *dns) Lookup(opts ...QueryOption) ([]Route, error) {
+	options := NewQuery(opts...)
+	// check to see if we have the port provided in the service, e.g. go-micro-srv-foo:8000
+	host, port, err := net.SplitHostPort(options.Service)
+	if err == nil {
+		// lookup the service using A records
+		ips, err := net.LookupHost(host)
+		if err != nil {
+			return nil, err
+		}
+
+		p, _ := strconv.Atoi(port)
+
+		// convert the ip addresses to routes
+		result := make([]Route, len(ips))
+		for i, ip := range ips {
+			result[i] = Route{
+				Service: options.Service,
+				Address: fmt.Sprintf("%s:%d", ip, uint16(p)),
+			}
+		}
+		return result, nil
+	}
+
+	// we didn't get the port so we'll lookup the service using SRV records. If we can't lookup the
+	// service using the SRV record, we return the error.
+	_, nodes, err := net.LookupSRV(options.Service, "tcp", d.options.Network)
+	if err != nil {
+		return nil, err
+	}
+
+	// convert the nodes (net services) to routes
+	result := make([]Route, len(nodes))
+	for i, n := range nodes {
+		result[i] = Route{
+			Service: options.Service,
+			Address: fmt.Sprintf("%s:%d", n.Target, n.Port),
+			Network: d.options.Network,
+		}
+	}
+	return result, nil
+}
+
+func (d *dns) Watch(opts ...WatchOption) (Watcher, error) {
+	return nil, nil
+}
+
+func (d *dns) Name() string {
+	return d.options.Name
+}
+
+func (d *dns) String() string {
+	return "dns"
+}

router/router.go

@@ -7,7 +7,7 @@ import (
 
 var (
 	// DefaultRouter is the global default router
-	DefaultRouter Router
+	DefaultRouter Router = NewRouter()
 	// DefaultNetwork is default micro network
 	DefaultNetwork = "micro"
 	// ErrRouteNotFound is returned when no route was found in the routing table

server/generate.go

@@ -0,0 +1,3 @@
+package server
+
+//go:generate protoc -I./health -I../ -I/home/vtolstov/.cache/go-path/pkg/mod/github.com/unistack-org/micro-proto@v0.0.1 --micro_out=components=micro|http|server,standalone=false,debug=true,paths=source_relative:./health health/health.proto

server/health/health.go

@@ -0,0 +1,87 @@
+package health
+
+import (
+	"context"
+
+	"github.com/unistack-org/micro/v3/codec"
+	"github.com/unistack-org/micro/v3/errors"
+	"github.com/unistack-org/micro/v3/server"
+)
+
+var (
+	// guard to fail early
+	_ HealthServer = &handler{}
+)
+
+type handler struct {
+	server server.Server
+	opts   Options
+}
+
+type CheckFunc func(context.Context) error
+
+type Option func(*Options)
+
+type Options struct {
+	LiveChecks  []CheckFunc
+	ReadyChecks []CheckFunc
+	Version     string
+	Name        string
+}
+
+func LiveChecks(fns ...CheckFunc) Option {
+	return func(o *Options) {
+		o.LiveChecks = append(o.LiveChecks, fns...)
+	}
+}
+
+func ReadyChecks(fns ...CheckFunc) Option {
+	return func(o *Options) {
+		o.ReadyChecks = append(o.ReadyChecks, fns...)
+	}
+}
+
+func Name(name string) Option {
+	return func(o *Options) {
+		o.Name = name
+	}
+}
+
+func Version(version string) Option {
+	return func(o *Options) {
+		o.Version = version
+	}
+}
+
+func NewHandler(opts ...Option) *handler {
+	options := Options{}
+	for _, o := range opts {
+		o(&options)
+	}
+	return &handler{opts: options}
+}
+
+func (h *handler) Live(ctx context.Context, req *codec.Frame, rsp *codec.Frame) error {
+	var err error
+	for _, fn := range h.opts.LiveChecks {
+		if err = fn(ctx); err != nil {
+			return errors.ServiceUnavailable(h.opts.Name, "%v", err)
+		}
+	}
+	return nil
+}
+
+func (h *handler) Ready(ctx context.Context, req *codec.Frame, rsp *codec.Frame) error {
+	var err error
+	for _, fn := range h.opts.ReadyChecks {
+		if err = fn(ctx); err != nil {
+			return errors.ServiceUnavailable(h.opts.Name, "%v", err)
+		}
+	}
+	return nil
+}
+
+func (h *handler) Version(ctx context.Context, req *codec.Frame, rsp *codec.Frame) error {
+	rsp.Data = []byte(h.opts.Version)
+	return nil
+}

server/health/health.proto

@@ -0,0 +1,62 @@
+syntax = "proto3";
+
+package micro.server.health;
+option go_package = "github.com/unistack-org/micro/v3/server/health;health";
+
+import "api/annotations.proto";
+import "openapiv2/annotations.proto";
+import "codec/frame.proto";
+
+service Health {
+	rpc Live(micro.codec.Frame) returns (micro.codec.Frame) {
+		option (micro.openapiv2.openapiv2_operation) = {
+      operation_id: "Live";
+        responses: {
+          key: "default";
+          value: {
+            description: "Error response";
+            schema: {
+              json_schema: {
+                ref: "micro.codec.Frame";
+              }
+            }
+          }
+        }
+    };
+		option (micro.api.http) = { get: "/live"; };
+  };
+	rpc Ready(micro.codec.Frame) returns (micro.codec.Frame) {
+		option (micro.openapiv2.openapiv2_operation) = {
+      operation_id: "Ready";
+        responses: {
+          key: "default";
+          value: {
+            description: "Error response";
+            schema: {
+              json_schema: {
+                ref: "micro.codec.Frame";
+              }
+            }
+          }
+        }
+    };
+		option (micro.api.http) = { get: "/ready"; };
+  };
+	rpc Version(micro.codec.Frame) returns (micro.codec.Frame) {
+		option (micro.openapiv2.openapiv2_operation) = {
+      operation_id: "Version";
+        responses: {
+          key: "default";
+          value: {
+            description: "Error response";
+            schema: {
+              json_schema: {
+                ref: "micro.codec.Frame";
+              }
+            }
+          }
+        }
+    };
+		option (micro.api.http) = { get: "/version"; };
+  };
+};

server/health/health_micro.pb.go

@@ -0,0 +1,38 @@
+// Code generated by protoc-gen-micro
+// source: health.proto
+package health
+
+import (
+	context "context"
+	api "github.com/unistack-org/micro/v3/api"
+	codec "github.com/unistack-org/micro/v3/codec"
+)
+
+func NewHealthEndpoints() []*api.Endpoint {
+	return []*api.Endpoint{
+		&api.Endpoint{
+			Name:    "Health.Live",
+			Path:    []string{"/live"},
+			Method:  []string{"GET"},
+			Handler: "rpc",
+		},
+		&api.Endpoint{
+			Name:    "Health.Ready",
+			Path:    []string{"/ready"},
+			Method:  []string{"GET"},
+			Handler: "rpc",
+		},
+		&api.Endpoint{
+			Name:    "Health.Version",
+			Path:    []string{"/version"},
+			Method:  []string{"GET"},
+			Handler: "rpc",
+		},
+	}
+}
+
+type HealthServer interface {
+	Live(ctx context.Context, req *codec.Frame, rsp *codec.Frame) error
+	Ready(ctx context.Context, req *codec.Frame, rsp *codec.Frame) error
+	Version(ctx context.Context, req *codec.Frame, rsp *codec.Frame) error
+}

server/health/health_micro_http.pb.go

@@ -0,0 +1,43 @@
+// Code generated by protoc-gen-micro
+// source: health.proto
+package health
+
+import (
+	context "context"
+	api "github.com/unistack-org/micro/v3/api"
+	codec "github.com/unistack-org/micro/v3/codec"
+	server "github.com/unistack-org/micro/v3/server"
+)
+
+type healthServer struct {
+	HealthServer
+}
+
+func (h *healthServer) Live(ctx context.Context, req *codec.Frame, rsp *codec.Frame) error {
+	return h.HealthServer.Live(ctx, req, rsp)
+}
+
+func (h *healthServer) Ready(ctx context.Context, req *codec.Frame, rsp *codec.Frame) error {
+	return h.HealthServer.Ready(ctx, req, rsp)
+}
+
+func (h *healthServer) Version(ctx context.Context, req *codec.Frame, rsp *codec.Frame) error {
+	return h.HealthServer.Version(ctx, req, rsp)
+}
+
+func RegisterHealthServer(s server.Server, sh HealthServer, opts ...server.HandlerOption) error {
+	type health interface {
+		Live(ctx context.Context, req *codec.Frame, rsp *codec.Frame) error
+		Ready(ctx context.Context, req *codec.Frame, rsp *codec.Frame) error
+		Version(ctx context.Context, req *codec.Frame, rsp *codec.Frame) error
+	}
+	type Health struct {
+		health
+	}
+	h := &healthServer{sh}
+	var nopts []server.HandlerOption
+	for _, endpoint := range NewHealthEndpoints() {
+		nopts = append(nopts, api.WithEndpoint(endpoint))
+	}
+	return s.Handle(s.NewHandler(&Health{h}, append(nopts, opts...)...))
+}

service.go

@@ -103,48 +103,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(cfg.Options().Context)); err != nil {
 			return err
 		}
 
-		if err = cfg.Load(s.opts.Context); err != nil {
+		if err = cfg.Load(cfg.Options().Context); err != nil {
 			return err
 		}
 
 	}
 
 	for _, log := range s.opts.Loggers {
-		if err = log.Init(logger.WithContext(s.opts.Context)); err != nil {
+		if err = log.Init(logger.WithContext(log.Options().Context)); err != nil {
 			return err
 		}
 	}
 
 	for _, reg := range s.opts.Registers {
-		if err = reg.Init(register.Context(s.opts.Context)); err != nil {
+		if err = reg.Init(register.Context(reg.Options().Context)); err != nil {
 			return err
 		}
 	}
 
 	for _, brk := range s.opts.Brokers {
-		if err = brk.Init(broker.Context(s.opts.Context)); err != nil {
+		if err = brk.Init(broker.Context(brk.Options().Context)); err != nil {
 			return err
 		}
 	}
 
 	for _, str := range s.opts.Stores {
-		if err = str.Init(store.Context(s.opts.Context)); err != nil {
+		if err = str.Init(store.Context(str.Options().Context)); err != nil {
 			return err
 		}
 	}
 
 	for _, srv := range s.opts.Servers {
-		if err = srv.Init(server.Context(s.opts.Context)); err != nil {
+		if err = srv.Init(server.Context(srv.Options().Context)); err != nil {
 			return err
 		}
 	}
 
 	for _, cli := range s.opts.Clients {
-		if err = cli.Init(client.Context(s.opts.Context)); err != nil {
+		if err = cli.Init(client.Context(cli.Options().Context)); err != nil {
 			return err
 		}
 	}

tracer/wrapper/wrapper.go

@@ -101,6 +101,8 @@ var (
 		}
 		sp.SetLabels(labels...)
 	}
+
+	DefaultSkipEndpoints = []string{"Meter.Metrics"}
 )
 
 type tWrapper struct {
@@ -134,6 +136,8 @@ type Options struct {
 	ServerHandlerObservers []ServerHandlerObserver
 	// ServerSubscriberObservers funcs
 	ServerSubscriberObservers []ServerSubscriberObserver
+	// SkipEndpoints
+	SkipEndpoints []string
 }
 
 // Option func signature
@@ -149,6 +153,7 @@ func NewOptions(opts ...Option) Options {
 		ClientCallFuncObservers:   []ClientCallFuncObserver{DefaultClientCallFuncObserver},
 		ServerHandlerObservers:    []ServerHandlerObserver{DefaultServerHandlerObserver},
 		ServerSubscriberObservers: []ServerSubscriberObserver{DefaultServerSubscriberObserver},
+		SkipEndpoints:             DefaultSkipEndpoints,
 	}
 
 	for _, o := range opts {
@@ -165,6 +170,13 @@ func WithTracer(t tracer.Tracer) Option {
 	}
 }
 
+// SkipEndponts
+func SkipEndpoins(eps ...string) Option {
+	return func(o *Options) {
+		o.SkipEndpoints = append(o.SkipEndpoints, eps...)
+	}
+}
+
 // WithClientCallObservers funcs
 func WithClientCallObservers(ob ...ClientCallObserver) Option {
 	return func(o *Options) {
@@ -208,6 +220,13 @@ func WithServerSubscriberObservers(ob ...ServerSubscriberObserver) Option {
 }
 
 func (ot *tWrapper) Call(ctx context.Context, req client.Request, rsp interface{}, opts ...client.CallOption) error {
+	endpoint := fmt.Sprintf("%s.%s", req.Service(), req.Endpoint())
+	for _, ep := range ot.opts.SkipEndpoints {
+		if ep == endpoint {
+			return ot.Client.Call(ctx, req, rsp, opts...)
+		}
+	}
+
 	sp := tracer.SpanFromContext(ctx)
 	defer sp.Finish()
 
@@ -221,6 +240,13 @@ func (ot *tWrapper) Call(ctx context.Context, req client.Request, rsp interface{
 }
 
 func (ot *tWrapper) Stream(ctx context.Context, req client.Request, opts ...client.CallOption) (client.Stream, error) {
+	endpoint := fmt.Sprintf("%s.%s", req.Service(), req.Endpoint())
+	for _, ep := range ot.opts.SkipEndpoints {
+		if ep == endpoint {
+			return ot.Client.Stream(ctx, req, opts...)
+		}
+	}
+
 	sp := tracer.SpanFromContext(ctx)
 	defer sp.Finish()
 
@@ -247,6 +273,13 @@ func (ot *tWrapper) Publish(ctx context.Context, msg client.Message, opts ...cli
 }
 
 func (ot *tWrapper) ServerHandler(ctx context.Context, req server.Request, rsp interface{}) error {
+	endpoint := req.Endpoint()
+	for _, ep := range ot.opts.SkipEndpoints {
+		if ep == endpoint {
+			return ot.serverHandler(ctx, req, rsp)
+		}
+	}
+
 	sp := tracer.SpanFromContext(ctx)
 	defer sp.Finish()
 
@@ -297,6 +330,13 @@ func NewClientCallWrapper(opts ...Option) client.CallWrapper {
 }
 
 func (ot *tWrapper) ClientCallFunc(ctx context.Context, addr string, req client.Request, rsp interface{}, opts client.CallOptions) error {
+	endpoint := fmt.Sprintf("%s.%s", req.Service(), req.Endpoint())
+	for _, ep := range ot.opts.SkipEndpoints {
+		if ep == endpoint {
+			return ot.ClientCallFunc(ctx, addr, req, rsp, opts)
+		}
+	}
+
 	sp := tracer.SpanFromContext(ctx)
 	defer sp.Finish()
 

util/reflect/reflect.go

@@ -173,6 +173,108 @@ func CopyFrom(a, b interface{}) {
 	}
 }
 
+func StructURLValues(src interface{}, pref string, tags []string) (url.Values, error) {
+	data := url.Values{}
+
+	sv := reflect.ValueOf(src)
+	if sv.Kind() == reflect.Ptr {
+		sv = sv.Elem()
+	}
+	if sv.Kind() != reflect.Struct {
+		return nil, ErrInvalidStruct
+	}
+
+	typ := sv.Type()
+	for idx := 0; idx < typ.NumField(); idx++ {
+		fld := typ.Field(idx)
+		val := sv.Field(idx)
+		if !val.CanSet() || len(fld.PkgPath) != 0 || !val.IsValid() {
+			continue
+		}
+
+		var t *tag
+		for _, tn := range tags {
+			ts, ok := fld.Tag.Lookup(tn)
+			if !ok {
+				continue
+			}
+
+			tp := strings.Split(ts, ",")
+			// special
+			switch tn {
+			case "protobuf": // special
+				t = &tag{key: tn, name: tp[3][5:], opts: append(tp[:3], tp[4:]...)}
+			default:
+				t = &tag{key: tn, name: tp[0], opts: tp[1:]}
+			}
+			if t.name != "" {
+				break
+			}
+		}
+
+		if t.name == "" {
+			// fallback to lowercase
+			t.name = strings.ToLower(fld.Name)
+		}
+		if pref != "" {
+			t.name = pref + "." + t.name
+		}
+
+		if !val.IsValid() || val.IsZero() {
+			continue
+		}
+
+		switch val.Kind() {
+		case reflect.Struct, reflect.Ptr:
+			if val.IsNil() {
+				continue
+			}
+			ndata, err := StructURLValues(val.Interface(), t.name, tags)
+			if err != nil {
+				return ndata, err
+			}
+			for k, v := range ndata {
+				data[k] = v
+			}
+		default:
+			switch val.Kind() {
+			case reflect.Slice:
+				for i := 0; i < val.Len(); i++ {
+					va := val.Index(i)
+					//if va.Type().Elem().Kind() != reflect.Ptr {
+					if va.Kind() != reflect.Ptr {
+						data.Set(t.name, fmt.Sprintf("%v", va.Interface()))
+						continue
+					}
+					switch va.Type().Elem().String() {
+					case "wrapperspb.BoolValue", "wrapperspb.BytesValue", "wrapperspb.StringValue":
+						if eva := reflect.Indirect(va).FieldByName("Value"); eva.IsValid() {
+							data.Add(t.name, fmt.Sprintf("%v", eva.Interface()))
+						}
+					case "wrapperspb.DoubleValue", "wrapperspb.FloatValue":
+						if eva := reflect.Indirect(va).FieldByName("Value"); eva.IsValid() {
+							data.Add(t.name, fmt.Sprintf("%v", eva.Interface()))
+						}
+					case "wrapperspb.Int32Value", "wrapperspb.Int64Value":
+						if eva := reflect.Indirect(va).FieldByName("Value"); eva.IsValid() {
+							data.Add(t.name, fmt.Sprintf("%v", eva.Interface()))
+						}
+					case "wrapperspb.UInt32Value", "wrapperspb.UInt64Value":
+						if eva := reflect.Indirect(va).FieldByName("Value"); eva.IsValid() {
+							data.Add(t.name, fmt.Sprintf("%v", eva.Interface()))
+						}
+					default:
+						data.Add(t.name, fmt.Sprintf("%v", val.Index(i).Interface()))
+					}
+				}
+			default:
+				data.Set(t.name, fmt.Sprintf("%v", val.Interface()))
+			}
+		}
+	}
+	return data, nil
+}
+
 // URLMap returns map of url query params
 func URLMap(query string) (map[string]interface{}, error) {
 	var (
@@ -363,7 +465,7 @@ func mergeSlice(va, vb reflect.Value) error {
 			}
 		}
 	default:
-		return fmt.Errorf("cant merge %v %s with %v %s", va, va.Kind(), vb, vb.Kind())
+		return fmt.Errorf("cant merge %v %s with %v %s", va.Type(), va.Kind(), vb.Type(), vb.Kind())
 	}
 	return nil
 }
@@ -624,3 +726,9 @@ func mergeSliceIface(a []interface{}, b []interface{}) []interface{} {
 	a = append(a, b...)
 	return a
 }
+
+type tag struct {
+	key  string
+	name string
+	opts []string
+}

util/reflect/reflect_test.go

@@ -5,6 +5,24 @@ import (
 	"testing"
 )
 
+func TestStructURLValues(t *testing.T) {
+	type Str struct {
+		Name string `json:"name"`
+		Args []int  `json:"args"`
+		Str  *Str   `json:"str"`
+	}
+
+	val := &Str{Name: "test_name", Args: []int{1, 2, 3}, Str: &Str{Name: "nested_name"}}
+	data, err := StructURLValues(val, "", []string{"json"})
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	if data.Get("name") != "test_name" {
+		t.Fatalf("invalid data: %v", data)
+	}
+}
+
 func TestURLSliceVars(t *testing.T) {
 	u, err := url.Parse("http://localhost/v1/test/call/my_name?key=arg1&key=arg2&key=arg3")
 	if err != nil {