meter/wrapper: add DefaultSkipEndpoints

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

auth/auth.go

@@ -30,7 +30,7 @@ var (
 // Auth provides authentication and authorization
 type Auth interface {
 	// Init the auth
-	Init(opts ...Option)
+	Init(opts ...Option) error
 	// Options set for auth
 	Options() Options
 	// Generate a new account

auth/noop.go

@@ -14,10 +14,11 @@ func (n *noopAuth) String() string {
 }
 
 // Init the auth
-func (n *noopAuth) Init(opts ...Option) {
+func (n *noopAuth) Init(opts ...Option) error {
 	for _, o := range opts {
 		o(&n.opts)
 	}
+	return nil
 }
 
 // Options set for auth

client/options.go

@@ -160,6 +160,7 @@ func NewOptions(opts ...Option) Options {
 		ContentType: DefaultContentType,
 		Codecs:      make(map[string]codec.Codec),
 		CallOptions: CallOptions{
+			Context:        context.Background(),
 			Backoff:        DefaultBackoff,
 			Retry:          DefaultRetry,
 			Retries:        DefaultRetries,

codec/frame.go

@@ -0,0 +1,6 @@
+package codec
+
+// Frame gives us the ability to define raw data to send over the pipes
+type Frame struct {
+	Data []byte
+}

codec/frame.proto

@@ -0,0 +1,28 @@
+// Copyright 2021 Unistack LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+syntax = "proto3";
+
+package micro.codec;
+
+option cc_enable_arenas = true;
+option go_package = "github.com/unistack-org/micro/v3/codec;codec";
+option java_multiple_files = true;
+option java_outer_classname = "MicroCodec";
+option java_package = "micro.codec";
+option objc_class_prefix = "MCODEC";
+
+message Frame {
+  bytes data = 1;
+}

codec/noop.go

@@ -8,11 +8,6 @@ import (
 type noopCodec struct {
 }
 
-// Frame gives us the ability to define raw data to send over the pipes
-type Frame struct {
-	Data []byte
-}
-
 func (c *noopCodec) ReadHeader(conn io.Reader, m *Message, t MessageType) error {
 	return nil
 }

go.mod

@@ -6,8 +6,8 @@ require (
 	github.com/dgrijalva/jwt-go v3.2.0+incompatible
 	github.com/ef-ds/deque v1.0.4
 	github.com/google/uuid v1.2.0
-	github.com/imdario/mergo v0.3.11
+	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-20210226172049-e18ecbb05110
+	golang.org/x/net v0.0.0-20210316092652-d523dce5a7f4
 )

go.sum

@@ -4,15 +4,16 @@ 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/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/imdario/mergo v0.3.12 h1:b6R2BslTbIEToALKP7LxUvijTsNI9TAe80pLWN2g/HU=
+github.com/imdario/mergo v0.3.12/go.mod h1:jmQim1M+e3UYxmgPu/WyfjB3N3VflVyUjjjwH0dnCYA=
 github.com/patrickmn/go-cache v2.1.0+incompatible h1:HRMgzkcYKYpi3C8ajMPV8OFXaaRUnok+kx1WdO15EQc=
 github.com/patrickmn/go-cache v2.1.0+incompatible/go.mod h1:3Qf8kWWT7OJRJbdiICTKqZju1ZixQ/KpMGzzAfe6+WQ=
 github.com/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-20210226172049-e18ecbb05110 h1:qWPm9rbaAMKs8Bq/9LRpbMqxWRVUAQwMI9fVrssnTfw=
-golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg=
+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/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/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=

meter/generate.go

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

meter/handler/handler.go

@@ -0,0 +1,36 @@
+package pb
+
+import (
+	"bytes"
+	"context"
+
+	"github.com/unistack-org/micro/v3/codec"
+	"github.com/unistack-org/micro/v3/meter"
+)
+
+var (
+	// guard to fail early
+	_ MeterServer = &handler{}
+)
+
+type Empty struct{}
+
+type handler struct {
+	meter meter.Meter
+	opts  []meter.Option
+}
+
+func NewHandler(meter meter.Meter, opts ...meter.Option) *handler {
+	return &handler{meter: meter, opts: opts}
+}
+
+func (h *handler) Metrics(ctx context.Context, req *Empty, rsp *codec.Frame) error {
+	buf := bytes.NewBuffer(nil)
+	if err := h.meter.Write(buf, h.opts...); err != nil {
+		return err
+	}
+
+	rsp.Data = buf.Bytes()
+
+	return nil
+}

meter/handler/handler.proto

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

meter/handler/handler_micro.pb.go

@@ -0,0 +1,24 @@
+// Code generated by protoc-gen-micro
+// source: handler.proto
+package pb
+
+import (
+	context "context"
+	api "github.com/unistack-org/micro/v3/api"
+	codec "github.com/unistack-org/micro/v3/codec"
+)
+
+func NewMeterEndpoints() []*api.Endpoint {
+	return []*api.Endpoint{
+		&api.Endpoint{
+			Name:    "Meter.Metrics",
+			Path:    []string{"/metrics"},
+			Method:  []string{"GET"},
+			Handler: "rpc",
+		},
+	}
+}
+
+type MeterServer interface {
+	Metrics(ctx context.Context, req *Empty, rsp *codec.Frame) error
+}

meter/handler/handler_micro_http.pb.go

@@ -0,0 +1,32 @@
+// Code generated by protoc-gen-micro
+// source: handler.proto
+package pb
+
+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 meterServer struct {
+	MeterServer
+}
+
+func (h *meterServer) Metrics(ctx context.Context, req *Empty, 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
+	}
+	type Meter struct {
+		meter
+	}
+	h := &meterServer{sh}
+	for _, endpoint := range NewMeterEndpoints() {
+		opts = append(opts, api.WithEndpoint(endpoint))
+	}
+	return s.Handle(s.NewHandler(&Meter{h}, opts...))
+}

meter/meter.go

@@ -3,6 +3,7 @@ package meter
 
 import (
 	"io"
+	"reflect"
 	"sort"
 	"time"
 )
@@ -76,66 +77,36 @@ type Summary interface {
 	UpdateDuration(time.Time)
 }
 
-// Labels holds the metrics labels with k, v
-type Labels struct {
-	keys []string
-	vals []string
+type byKey []string
+
+func (k byKey) Len() int           { return len(k) / 2 }
+func (k byKey) Less(i, j int) bool { return k[i*2] < k[j*2] }
+func (k byKey) Swap(i, j int) {
+	k[i*2], k[i*2+1], k[j*2], k[j*2+1] = k[j*2], k[j*2+1], k[i*2], k[i*2+1]
 }
 
-// Append adds labels to label set
-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])
+func Sort(slice *[]string) {
+	bk := byKey(*slice)
+	if bk.Len() <= 1 {
+		return
 	}
-	return ls
-}
-
-// Len returns number of labels
-func (ls Labels) Len() int {
-	return len(ls.keys)
-}
-
-type labels Labels
-
-func (ls labels) Len() int {
-	return len(ls.keys)
-}
-
-func (ls labels) Sort() {
-	sort.Sort(ls)
-}
-
-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.keys[i] < ls.keys[j]
-}
-
-// LabelIter holds the
-type LabelIter struct {
-	labels Labels
-	cnt    int
-	cur    int
-}
-
-// Iter returns labels iterator
-func (ls Labels) Iter() *LabelIter {
-	labels(ls).Sort()
-	return &LabelIter{labels: ls, cnt: len(ls.keys)}
-}
-
-// Next advance itarator to new pos
-func (iter *LabelIter) Next(k, v *string) bool {
-	if iter.cur+1 > iter.cnt {
-		return false
+	sort.Sort(bk)
+	v := reflect.ValueOf(slice).Elem()
+	cnt := 0
+	key := 0
+	val := 1
+	for key < v.Len() {
+		if len(bk) > key+2 && bk[key] == bk[key+2] {
+			key += 2
+			val += 2
+			continue
+		}
+		v.Index(cnt).Set(v.Index(key))
+		cnt++
+		v.Index(cnt).Set(v.Index(val))
+		cnt++
+		key += 2
+		val += 2
 	}
-
-	*k = iter.labels.keys[iter.cur]
-	*v = iter.labels.vals[iter.cur]
-	iter.cur++
-	return true
+	v.SetLen(cnt)
 }

meter/meter_test.go

@@ -10,46 +10,15 @@ func TestNoopMeter(t *testing.T) {
 		t.Fatalf("invalid options parsing: %v", m.Options())
 	}
 
-	cnt := m.Counter("counter", Label("server", "noop"))
+	cnt := m.Counter("counter", Labels("server", "noop"))
 	cnt.Inc()
 }
 
-func TestLabelsAppend(t *testing.T) {
-	var ls Labels
-	ls.keys = []string{"type", "server"}
-	ls.vals = []string{"noop", "http"}
+func TestLabelsSort(t *testing.T) {
+	ls := []string{"server", "http", "register", "mdns", "broker", "broker1", "broker", "broker2", "server", "tcp"}
+	Sort(&ls)
 
-	var nls Labels
-	nls.keys = []string{"register"}
-	nls.vals = []string{"gossip"}
-	ls = ls.Append(nls)
-
-	//ls.Sort()
-
-	if ls.keys[0] != "type" || ls.vals[0] != "noop" {
-		t.Fatalf("append error: %v", ls)
-	}
-}
-
-func TestIterator(t *testing.T) {
-	options := NewOptions(
-		Label("name", "svc1"),
-		Label("version", "0.0.1"),
-		Label("id", "12345"),
-		Label("type", "noop"),
-		Label("server", "http"),
-		Label("register", "gossip"),
-		Label("aa", "kk"),
-		Label("zz", "kk"),
-	)
-
-	iter := options.Labels.Iter()
-	var k, v string
-	cnt := 0
-	for iter.Next(&k, &v) {
-		if cnt == 4 && (k != "server" || v != "http") {
-			t.Fatalf("iter error: %s != %s || %s != %s", k, "server", v, "http")
-		}
-		cnt++
+	if ls[0] != "broker" || ls[1] != "broker2" {
+		t.Fatalf("sort error: %v", ls)
 	}
 }

meter/noop.go

@@ -107,7 +107,7 @@ func (r *noopMeter) String() string {
 }
 
 type noopCounter struct {
-	labels Labels
+	labels []string
 }
 
 func (r *noopCounter) Add(int) {
@@ -131,7 +131,7 @@ func (r *noopCounter) Set(uint64) {
 }
 
 type noopFloatCounter struct {
-	labels Labels
+	labels []string
 }
 
 func (r *noopFloatCounter) Add(float64) {
@@ -151,7 +151,7 @@ func (r *noopFloatCounter) Sub(float64) {
 }
 
 type noopGauge struct {
-	labels Labels
+	labels []string
 }
 
 func (r *noopGauge) Get() float64 {
@@ -159,7 +159,7 @@ func (r *noopGauge) Get() float64 {
 }
 
 type noopSummary struct {
-	labels Labels
+	labels []string
 }
 
 func (r *noopSummary) Update(float64) {
@@ -171,7 +171,7 @@ func (r *noopSummary) UpdateDuration(time.Time) {
 }
 
 type noopHistogram struct {
-	labels Labels
+	labels []string
 }
 
 func (r *noopHistogram) Reset() {

meter/options.go

@@ -26,7 +26,7 @@ type Options struct {
 	// LabelPrefix holds the prefix for all labels
 	LabelPrefix string
 	// Labels holds the default labels
-	Labels Labels
+	Labels []string
 	// WriteProcessMetrics flag to write process metrics
 	WriteProcessMetrics bool
 	// WriteFDMetrics flag to write fd metrics
@@ -88,11 +88,9 @@ func Logger(l logger.Logger) Option {
 	}
 }
 
-// Label sets the label
-func Label(key, val string) Option {
+func Labels(ls ...string) Option {
 	return func(o *Options) {
-		o.Labels.keys = append(o.Labels.keys, key)
-		o.Labels.vals = append(o.Labels.vals, val)
+		o.Labels = ls
 	}
 }
 

meter/wrapper/wrapper.go

@@ -28,6 +28,9 @@ var (
 	labelFailure  = "failure"
 	labelStatus   = "status"
 	labelEndpoint = "endpoint"
+
+	// DefaultSkipEndpoints contains list of endpoints that not evaluted by wrapper
+	DefaultSkipEndpoints = []string{"Meter.Metrics"}
 )
 
 type Options struct {
@@ -50,19 +53,19 @@ func NewOptions(opts ...Option) Options {
 
 func ServiceName(name string) Option {
 	return func(o *Options) {
-		o.lopts = append(o.lopts, meter.Label("name", name))
+		o.lopts = append(o.lopts, meter.Labels("name", name))
 	}
 }
 
 func ServiceVersion(version string) Option {
 	return func(o *Options) {
-		o.lopts = append(o.lopts, meter.Label("version", version))
+		o.lopts = append(o.lopts, meter.Labels("version", version))
 	}
 }
 
 func ServiceID(id string) Option {
 	return func(o *Options) {
-		o.lopts = append(o.lopts, meter.Label("id", id))
+		o.lopts = append(o.lopts, meter.Labels("id", id))
 	}
 }
 
@@ -100,21 +103,25 @@ 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 {
+		if ep == endpoint {
+			return w.callFunc(ctx, addr, req, rsp, opts)
+		}
+	}
 	ts := time.Now()
 	err := w.callFunc(ctx, addr, req, rsp, opts)
 	te := time.Since(ts)
 
 	lopts := w.opts.lopts
-	lopts = append(lopts, meter.Label(labelEndpoint, endpoint))
+	lopts = append(lopts, meter.Labels(labelEndpoint, endpoint))
 
 	w.opts.Meter.Summary(ClientRequestLatencyMicroseconds, lopts...).Update(float64(te.Seconds()))
 	w.opts.Meter.Histogram(ClientRequestDurationSeconds, lopts...).Update(float64(te.Seconds()))
 
 	if err == nil {
-		lopts = append(lopts, meter.Label(labelStatus, labelSuccess))
+		lopts = append(lopts, meter.Labels(labelStatus, labelSuccess))
 	} else {
-		lopts = append(lopts, meter.Label(labelStatus, labelFailure))
+		lopts = append(lopts, meter.Labels(labelStatus, labelFailure))
 	}
 	w.opts.Meter.Counter(ClientRequestTotal, lopts...).Inc()
 
@@ -123,21 +130,26 @@ 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 {
+		if ep == endpoint {
+			return w.Client.Call(ctx, req, rsp, opts...)
+		}
+	}
 
 	ts := time.Now()
 	err := w.Client.Call(ctx, req, rsp, opts...)
 	te := time.Since(ts)
 
 	lopts := w.opts.lopts
-	lopts = append(lopts, meter.Label(labelEndpoint, endpoint))
+	lopts = append(lopts, meter.Labels(labelEndpoint, endpoint))
 
 	w.opts.Meter.Summary(ClientRequestLatencyMicroseconds, lopts...).Update(float64(te.Seconds()))
 	w.opts.Meter.Histogram(ClientRequestDurationSeconds, lopts...).Update(float64(te.Seconds()))
 
 	if err == nil {
-		lopts = append(lopts, meter.Label(labelStatus, labelSuccess))
+		lopts = append(lopts, meter.Labels(labelStatus, labelSuccess))
 	} else {
-		lopts = append(lopts, meter.Label(labelStatus, labelFailure))
+		lopts = append(lopts, meter.Labels(labelStatus, labelFailure))
 	}
 	w.opts.Meter.Counter(ClientRequestTotal, lopts...).Inc()
 
@@ -146,21 +158,26 @@ 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 {
+		if ep == endpoint {
+			return w.Client.Stream(ctx, req, opts...)
+		}
+	}
 
 	ts := time.Now()
 	stream, err := w.Client.Stream(ctx, req, opts...)
 	te := time.Since(ts)
 
 	lopts := w.opts.lopts
-	lopts = append(lopts, meter.Label(labelEndpoint, endpoint))
+	lopts = append(lopts, meter.Labels(labelEndpoint, endpoint))
 
 	w.opts.Meter.Summary(ClientRequestLatencyMicroseconds, lopts...).Update(float64(te.Seconds()))
 	w.opts.Meter.Histogram(ClientRequestDurationSeconds, lopts...).Update(float64(te.Seconds()))
 
 	if err == nil {
-		lopts = append(lopts, meter.Label(labelStatus, labelSuccess))
+		lopts = append(lopts, meter.Labels(labelStatus, labelSuccess))
 	} else {
-		lopts = append(lopts, meter.Label(labelStatus, labelFailure))
+		lopts = append(lopts, meter.Labels(labelStatus, labelFailure))
 	}
 	w.opts.Meter.Counter(ClientRequestTotal, lopts...).Inc()
 
@@ -175,15 +192,15 @@ func (w *wrapper) Publish(ctx context.Context, p client.Message, opts ...client.
 	te := time.Since(ts)
 
 	lopts := w.opts.lopts
-	lopts = append(lopts, meter.Label(labelEndpoint, endpoint))
+	lopts = append(lopts, meter.Labels(labelEndpoint, endpoint))
 
 	w.opts.Meter.Summary(PublishMessageLatencyMicroseconds, lopts...).Update(float64(te.Seconds()))
 	w.opts.Meter.Histogram(PublishMessageDurationSeconds, lopts...).Update(float64(te.Seconds()))
 
 	if err == nil {
-		lopts = append(lopts, meter.Label(labelStatus, labelSuccess))
+		lopts = append(lopts, meter.Labels(labelStatus, labelSuccess))
 	} else {
-		lopts = append(lopts, meter.Label(labelStatus, labelFailure))
+		lopts = append(lopts, meter.Labels(labelStatus, labelFailure))
 	}
 	w.opts.Meter.Counter(PublishMessageTotal, lopts...).Inc()
 
@@ -200,21 +217,26 @@ 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 {
+			if ep == endpoint {
+				return fn(ctx, req, rsp)
+			}
+		}
 
 		ts := time.Now()
 		err := fn(ctx, req, rsp)
 		te := time.Since(ts)
 
 		lopts := w.opts.lopts
-		lopts = append(lopts, meter.Label(labelEndpoint, endpoint))
+		lopts = append(lopts, meter.Labels(labelEndpoint, endpoint))
 
 		w.opts.Meter.Summary(ServerRequestLatencyMicroseconds, lopts...).Update(float64(te.Seconds()))
 		w.opts.Meter.Histogram(ServerRequestDurationSeconds, lopts...).Update(float64(te.Seconds()))
 
 		if err == nil {
-			lopts = append(lopts, meter.Label(labelStatus, labelSuccess))
+			lopts = append(lopts, meter.Labels(labelStatus, labelSuccess))
 		} else {
-			lopts = append(lopts, meter.Label(labelStatus, labelFailure))
+			lopts = append(lopts, meter.Labels(labelStatus, labelFailure))
 		}
 		w.opts.Meter.Counter(ServerRequestTotal, lopts...).Inc()
 
@@ -238,15 +260,15 @@ func (w *wrapper) SubscriberFunc(fn server.SubscriberFunc) server.SubscriberFunc
 		te := time.Since(ts)
 
 		lopts := w.opts.lopts
-		lopts = append(lopts, meter.Label(labelEndpoint, endpoint))
+		lopts = append(lopts, meter.Labels(labelEndpoint, endpoint))
 
 		w.opts.Meter.Summary(SubscribeMessageLatencyMicroseconds, lopts...).Update(float64(te.Seconds()))
 		w.opts.Meter.Histogram(SubscribeMessageDurationSeconds, lopts...).Update(float64(te.Seconds()))
 
 		if err == nil {
-			lopts = append(lopts, meter.Label(labelStatus, labelSuccess))
+			lopts = append(lopts, meter.Labels(labelStatus, labelSuccess))
 		} else {
-			lopts = append(lopts, meter.Label(labelStatus, labelFailure))
+			lopts = append(lopts, meter.Labels(labelStatus, labelFailure))
 		}
 		w.opts.Meter.Counter(SubscribeMessageTotal, lopts...).Inc()
 

register/extractor.go

@@ -23,7 +23,8 @@ func ExtractValue(v reflect.Type, d int) *Value {
 		v = v.Elem()
 	}
 
-	if len(v.Name()) == 0 {
+	// slices and maps don't have a defined name
+	if (v.Kind() == reflect.Slice || v.Kind() == reflect.Map) || len(v.Name()) == 0 {
 		return nil
 	}
 
@@ -71,6 +72,16 @@ func ExtractValue(v reflect.Type, d int) *Value {
 			p = p.Elem()
 		}
 		arg.Type = "[]" + p.Name()
+	case reflect.Map:
+		p := v.Elem()
+		if p.Kind() == reflect.Ptr {
+			p = p.Elem()
+		}
+		key := v.Key()
+		if key.Kind() == reflect.Ptr {
+			key = key.Elem()
+		}
+		arg.Type = fmt.Sprintf("map[%s]%s", key.Name(), p.Name())
 	}
 
 	return arg

server/options.go

@@ -39,8 +39,12 @@ type Options struct {
 	Meter meter.Meter
 	// Transport holds the transport
 	Transport transport.Transport
-	// Router for requests
-	Router Router
+
+	/*
+		// Router for requests
+		Router Router
+	*/
+
 	// Listener may be passed if already created
 	Listener net.Listener
 	// Wait group
@@ -262,12 +266,14 @@ func TLSConfig(t *tls.Config) Option {
 	}
 }
 
+/*
 // WithRouter sets the request router
 func WithRouter(r Router) Option {
 	return func(o *Options) {
 		o.Router = r
 	}
 }
+*/
 
 // Wait tells the server to wait for requests to finish before exiting
 // If `wg` is nil, server only wait for completion of rpc handler.

server/server.go

@@ -65,6 +65,7 @@ type Server interface {
 	String() string
 }
 
+/*
 // Router handle serving messages
 type Router interface {
 	// ProcessMessage processes a message
@@ -72,6 +73,7 @@ type Router interface {
 	// ServeRequest processes a request to completion
 	ServeRequest(ctx context.Context, req Request, rsp Response) error
 }
+*/
 
 // Message is an async message interface
 type Message interface {

util/reflect/reflect.go

@@ -65,8 +65,24 @@ func IsEmpty(v reflect.Value) bool {
 		return v.IsNil()
 	case reflect.Invalid:
 		return true
+	case reflect.Struct:
+		var ok bool
+		for i := 0; i < v.NumField(); i++ {
+			ok = IsEmpty(v.FieldByIndex([]int{i}))
+			if !ok {
+				return false
+			}
+		}
+	default:
+		return false
 	}
-	return false
+	return true
+}
+
+// IsZero returns true if struct is zero (not have any defined values)
+func IsZero(src interface{}) bool {
+	v := reflect.ValueOf(src)
+	return IsEmpty(v)
 }
 
 // Zero creates new zero interface

util/reflect/reflect_test.go

@@ -43,3 +43,50 @@ func TestURLVars(t *testing.T) {
 	}
 	_ = mp
 }
+
+func TestIsZero(t *testing.T) {
+	testStr1 := struct {
+		Name   string
+		Value  string
+		Nested struct {
+			NestedName string
+		}
+	}{
+		Name:  "test_name",
+		Value: "test_value",
+	}
+	testStr1.Nested.NestedName = "nested_name"
+
+	if ok := IsZero(testStr1); ok {
+		t.Fatalf("zero ret on non zero struct: %#+v", testStr1)
+	}
+
+	testStr1.Name = ""
+	testStr1.Value = ""
+	testStr1.Nested.NestedName = ""
+	if ok := IsZero(testStr1); !ok {
+		t.Fatalf("non zero ret on zero struct: %#+v", testStr1)
+	}
+
+	type testStr3 struct {
+		Nested string
+	}
+	type testStr2 struct {
+		Name   string
+		Nested *testStr3
+	}
+	vtest := &testStr2{
+		Name:   "test_name",
+		Nested: &testStr3{Nested: "nested_name"},
+	}
+	if ok := IsZero(vtest); ok {
+		t.Fatalf("zero ret on non zero struct: %#+v", vtest)
+	}
+	vtest.Nested = nil
+	vtest.Name = ""
+	if ok := IsZero(vtest); !ok {
+		t.Fatalf("non zero ret on zero struct: %#+v", vtest)
+	}
+
+	//t.Logf("XX %#+v\n", ok)
+}