Apply Code Coverage Badge

* rename .gitea to .github
* attempt to fix lint/test job
* attempt to fix coverage job

.gitea/workflows/job_lint.yml

@@ -1,29 +0,0 @@
-name: lint
-
-on:
-  pull_request:
-    types: [opened, reopened, synchronize]
-    branches:
-    - master
-    - v3
-    - v4
-
-jobs:
-  lint:
-    runs-on: ubuntu-latest
-    steps:
-    - name: checkout code
-      uses: actions/checkout@v4
-      with:
-        filter: 'blob:none'
-    - name: setup go
-      uses: actions/setup-go@v5
-      with:
-        cache-dependency-path: "**/*.sum"
-        go-version: 'stable' 
-    - name: setup deps
-      run: go get -v ./...
-    - name: run lint
-      uses: https://github.com/golangci/golangci-lint-action@v6
-      with:
-        version: 'latest'

.gitea/workflows/job_tests.yml

@@ -1,53 +0,0 @@
-name: test
-
-on:
-  pull_request:
-    types: [opened, reopened, synchronize]
-    branches:
-    - master
-    - v3
-    - v4
-  push:
-    branches:
-    - master
-    - v3
-    - v4
-
-jobs:
-  test:
-    runs-on: ubuntu-latest
-    steps:
-    - name: checkout code
-      uses: actions/checkout@v4
-      with:
-        filter: 'blob:none'
-    - name: checkout tests
-      uses: actions/checkout@v4
-      with:
-        ref: master
-        filter: 'blob:none'
-        repository: unistack-org/micro-tests
-        path: micro-tests
-    - name: setup go
-      uses: actions/setup-go@v5
-      with:
-        cache-dependency-path: "**/*.sum"
-        go-version: 'stable'
-    - name: setup go work
-      env:
-        GOWORK: /workspace/${{ github.repository_owner }}/go.work
-      run: |
-        go work init
-        go work use .
-        go work use micro-tests
-    - name: setup deps
-      env:
-        GOWORK: /workspace/${{ github.repository_owner }}/go.work
-      run: go get -v ./...
-    - name: run tests
-      env:
-        INTEGRATION_TESTS: yes
-        GOWORK: /workspace/${{ github.repository_owner }}/go.work
-      run: |
-        cd micro-tests
-        go test -mod readonly -v ./... || true

.github/workflows/job_coverage.yml

@@ -26,26 +26,26 @@ jobs:
 
     - name: test coverage
       run: |
-        go test -v -cover ./... -coverprofile coverage.out -coverpkg ./...
+        go test -v -cover ./... -covermode=count -coverprofile coverage.out -coverpkg ./...
         go tool cover -func coverage.out -o coverage.out
 
     - name: coverage badge
-      uses: tj-actions/coverage-badge-go@v1
+      uses: tj-actions/coverage-badge-go@v2
       with:
         green: 80
         filename: coverage.out
 
     - uses: stefanzweifel/git-auto-commit-action@v4
-      id: auto-commit-action
+      name: autocommit
       with:
         commit_message: Apply Code Coverage Badge
-        skip_fetch: true
-        skip_checkout: true
+        skip_fetch: false
+        skip_checkout: false
         file_pattern: ./README.md
 
-    - name: Push Changes
+    - name: push
       if: steps.auto-commit-action.outputs.changes_detected == 'true'
       uses: ad-m/github-push-action@master
       with:
         github_token: ${{ github.token }}
-        branch: ${{ github.ref }}
+        branch: ${{ github.ref }}

.github/workflows/job_lint.yml

@@ -0,0 +1,29 @@
+name: lint
+
+on:
+  pull_request:
+    types: [opened, reopened, synchronize]
+    branches:
+      - master
+      - v3
+      - v4
+
+jobs:
+  lint:
+    runs-on: ubuntu-latest
+    steps:
+      - name: checkout code
+        uses: actions/checkout@v4
+        with:
+          filter: 'blob:none'
+      - name: setup go
+        uses: actions/setup-go@v5
+        with:
+          cache-dependency-path: "**/*.sum"
+          go-version: 'stable'
+      - name: setup deps
+        run: go get -v ./...
+      - name: run lint
+        uses: golangci/golangci-lint-action@v6
+        with:
+          version: 'latest'

.github/workflows/job_tests.yml

@@ -0,0 +1,53 @@
+name: test
+
+on:
+  pull_request:
+    types: [opened, reopened, synchronize]
+    branches:
+      - master
+      - v3
+      - v4
+  push:
+    branches:
+      - master
+      - v3
+      - v4
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    steps:
+      - name: checkout code
+        uses: actions/checkout@v4
+        with:
+          filter: 'blob:none'
+      - name: checkout tests
+        uses: actions/checkout@v4
+        with:
+          ref: master
+          filter: 'blob:none'
+          repository: unistack-org/micro-tests
+          path: micro-tests
+      - name: setup go
+        uses: actions/setup-go@v5
+        with:
+          cache-dependency-path: "**/*.sum"
+          go-version: 'stable'
+      - name: setup go work
+        env:
+          GOWORK: ${{ github.workspace }}/go.work
+        run: |
+          go work init
+          go work use .
+          go work use micro-tests
+      - name: setup deps
+        env:
+          GOWORK: ${{ github.workspace }}/go.work
+        run: go get -v ./...
+      - name: run tests
+        env:
+          INTEGRATION_TESTS: yes
+          GOWORK: ${{ github.workspace }}/go.work
+        run: |
+          cd micro-tests
+          go test -mod readonly -v ./... || true

.golangci.yml

@@ -1,5 +1,5 @@
 run:
   concurrency: 8
-  deadline: 5m
+  timeout: 5m
   issues-exit-code: 1
   tests: true

README.md

@@ -1,40 +1,34 @@
-# Micro 
-![Coverage](https://img.shields.io/badge/Coverage-44.8%25-yellow)
+# Micro
+![Coverage](https://img.shields.io/badge/Coverage-44.6%25-yellow)
+[![License](https://img.shields.io/:license-apache-blue.svg)](https://opensource.org/licenses/Apache-2.0)
+[![Doc](https://img.shields.io/badge/go.dev-reference-007d9c?logo=go&logoColor=white&style=flat-square)](https://pkg.go.dev/go.unistack.org/micro/v3?tab=overview)
+[![Status](https://git.unistack.org/unistack-org/micro/actions/workflows/job_tests.yml/badge.svg?branch=v3)](https://git.unistack.org/unistack-org/micro/actions?query=workflow%3Abuild+branch%3Av3+event%3Apush)
+[![Lint](https://goreportcard.com/badge/go.unistack.org/micro/v3)](https://goreportcard.com/report/go.unistack.org/micro/v3)
 
 Micro is a standard library for microservices.
 
 ## Overview
 
-Micro provides the core requirements for distributed systems development including RPC and Event driven communication. 
+Micro provides the core requirements for distributed systems development including SYNC and ASYNC communication. 
 
 ## Features
 
-Micro abstracts away the details of distributed systems. Here are the main features.
-
-- **Authentication** - Auth is built in as a first class citizen. Authentication and authorization enable secure 
-zero trust networking by providing every service an identity and certificates. This additionally includes rule 
-based access control.
+Micro abstracts away the details of distributed systems. Main features:
 
 - **Dynamic Config** - Load and hot reload dynamic config from anywhere. The config interface provides a way to load application 
-level config from any source such as env vars, file, etcd. You can merge the sources and even define fallbacks.
+level config from any source such as env vars, cmdline, file, consul, vault, etc... You can merge the sources and even define fallbacks.
 
 - **Data Storage** - A simple data store interface to read, write and delete records. It includes support for memory, file and 
-CockroachDB by default. State and persistence becomes a core requirement beyond prototyping and Micro looks to build that into the framework.
+s3. State and persistence becomes a core requirement beyond prototyping and Micro looks to build that into the framework.
 
 - **Service Discovery** - Automatic service registration and name resolution. Service discovery is at the core of micro service 
-development. When service A needs to speak to service B it needs the location of that service.
-
-- **Load Balancing** - Client side load balancing built on service discovery. Once we have the addresses of any number of instances 
-of a service we now need a way to decide which node to route to. We use random hashed load balancing to provide even distribution 
-across the services and retry a different node if there's a problem. 
+development.
 
 - **Message Encoding** - Dynamic message encoding based on content-type. The client and server will use codecs along with content-type 
 to seamlessly encode and decode Go types for you. Any variety of messages could be encoded and sent from different clients. The client 
 and server handle this by default.
 
-- **Transport** - gRPC or http based request/response with support for bidirectional streaming. We provide an abstraction for synchronous communication. A request made to a service will be automatically resolved, load balanced, dialled and streamed.
-
-- **Async Messaging** - PubSub is built in as a first class citizen for asynchronous communication and event driven architectures.
+- **Async Messaging** - Pub/Sub is built in as a first class citizen for asynchronous communication and event driven architectures.
 Event notifications are a core pattern in micro service development.
 
 - **Synchronization** - Distributed systems are often built in an eventually consistent manner. Support for distributed locking and 
@@ -43,10 +37,6 @@ leadership are built in as a Sync interface. When using an eventually consistent
 - **Pluggable Interfaces** - Micro makes use of Go interfaces for each system abstraction. Because of this these interfaces 
 are pluggable and allows Micro to be runtime agnostic.
 
-## Getting Started
-
-To be created.
-
 ## License
 
 Micro is Apache 2.0 licensed.

SECURITY.md

@@ -1,15 +0,0 @@
-# Security Policy
-
-## Supported Versions
-
-Use this section to tell people about which versions of your project are
-currently being supported with security updates.
-
-| Version | Supported          |
-| ------- | ------------------ |
-| 3.7.x   | :white_check_mark: |
-| < 3.7.0 | :x:                |
-
-## Reporting a Vulnerability
-
-If you find any issue, please create github issue in this repo

client/noop.go

@@ -588,7 +588,6 @@ func (n *noopClient) publish(ctx context.Context, ps []Message, opts ...PublishO
 
 	for _, p := range ps {
 		md := metadata.Copy(omd)
-		md[metadata.HeaderContentType] = p.ContentType()
 		topic := p.Topic()
 		if len(exchange) > 0 {
 			topic = exchange
@@ -600,6 +599,8 @@ func (n *noopClient) publish(ctx context.Context, ps []Message, opts ...PublishO
 			md.Set(k, v)
 		}
 
+		md[metadata.HeaderContentType] = p.ContentType()
+
 		var body []byte
 
 		// passed in raw data

hooks/metadata/metadata.go

@@ -0,0 +1,76 @@
+package metadata
+
+import (
+	"context"
+
+	"go.unistack.org/micro/v3/client"
+	"go.unistack.org/micro/v3/metadata"
+	"go.unistack.org/micro/v3/server"
+)
+
+var DefaultMetadataKeys = []string{"x-request-id"}
+
+type hook struct {
+	keys []string
+}
+
+func NewHook(keys ...string) *hook {
+	return &hook{keys: keys}
+}
+
+func metadataCopy(ctx context.Context, keys []string) context.Context {
+	if keys == nil {
+		return ctx
+	}
+	if imd, iok := metadata.FromIncomingContext(ctx); iok && imd != nil {
+		omd, ook := metadata.FromOutgoingContext(ctx)
+		if !ook || omd == nil {
+			omd = metadata.New(len(keys))
+		}
+		for _, k := range keys {
+			if v, ok := imd.Get(k); ok && v != "" {
+				omd.Set(k, v)
+			}
+		}
+		if !ook {
+			ctx = metadata.NewOutgoingContext(ctx, omd)
+		}
+	}
+	return ctx
+}
+
+func (w *hook) ClientCall(next client.FuncCall) client.FuncCall {
+	return func(ctx context.Context, req client.Request, rsp interface{}, opts ...client.CallOption) error {
+		return next(metadataCopy(ctx, w.keys), req, rsp, opts...)
+	}
+}
+
+func (w *hook) ClientStream(next client.FuncStream) client.FuncStream {
+	return func(ctx context.Context, req client.Request, opts ...client.CallOption) (client.Stream, error) {
+		return next(metadataCopy(ctx, w.keys), req, opts...)
+	}
+}
+
+func (w *hook) ClientPublish(next client.FuncPublish) client.FuncPublish {
+	return func(ctx context.Context, msg client.Message, opts ...client.PublishOption) error {
+		return next(metadataCopy(ctx, w.keys), msg, opts...)
+	}
+}
+
+func (w *hook) ClientBatchPublish(next client.FuncBatchPublish) client.FuncBatchPublish {
+	return func(ctx context.Context, msgs []client.Message, opts ...client.PublishOption) error {
+		return next(metadataCopy(ctx, w.keys), msgs, opts...)
+	}
+}
+
+func (w *hook) ServerHandler(next server.FuncHandler) server.FuncHandler {
+	return func(ctx context.Context, req server.Request, rsp interface{}) error {
+		return next(metadataCopy(ctx, w.keys), req, rsp)
+	}
+}
+
+func (w *hook) ServerSubscriber(next server.FuncSubHandler) server.FuncSubHandler {
+	return func(ctx context.Context, msg server.Message) error {
+		return next(metadataCopy(ctx, w.keys), msg)
+	}
+}

hooks/recovery/recovery.go

@@ -0,0 +1,94 @@
+package recovery
+
+import (
+	"context"
+	"fmt"
+
+	"go.unistack.org/micro/v3/errors"
+	"go.unistack.org/micro/v3/server"
+)
+
+func NewOptions(opts ...Option) Options {
+	options := Options{
+		ServerHandlerFn:    DefaultServerHandlerFn,
+		ServerSubscriberFn: DefaultServerSubscriberFn,
+	}
+	for _, o := range opts {
+		o(&options)
+	}
+	return options
+}
+
+type Options struct {
+	ServerHandlerFn    func(context.Context, server.Request, interface{}, error) error
+	ServerSubscriberFn func(context.Context, server.Message, error) error
+}
+
+type Option func(*Options)
+
+func ServerHandlerFunc(fn func(context.Context, server.Request, interface{}, error) error) Option {
+	return func(o *Options) {
+		o.ServerHandlerFn = fn
+	}
+}
+
+func ServerSubscriberFunc(fn func(context.Context, server.Message, error) error) Option {
+	return func(o *Options) {
+		o.ServerSubscriberFn = fn
+	}
+}
+
+var (
+	DefaultServerHandlerFn = func(ctx context.Context, req server.Request, rsp interface{}, err error) error {
+		return errors.BadRequest("", "%v", err)
+	}
+	DefaultServerSubscriberFn = func(ctx context.Context, req server.Message, err error) error {
+		return errors.BadRequest("", "%v", err)
+	}
+)
+
+var Hook = NewHook()
+
+type hook struct {
+	opts Options
+}
+
+func NewHook(opts ...Option) *hook {
+	return &hook{opts: NewOptions(opts...)}
+}
+
+func (w *hook) ServerHandler(next server.FuncHandler) server.FuncHandler {
+	return func(ctx context.Context, req server.Request, rsp interface{}) (err error) {
+		defer func() {
+			r := recover()
+			switch verr := r.(type) {
+			case nil:
+				return
+			case error:
+				err = w.opts.ServerHandlerFn(ctx, req, rsp, verr)
+			default:
+				err = w.opts.ServerHandlerFn(ctx, req, rsp, fmt.Errorf("%v", r))
+			}
+		}()
+		err = next(ctx, req, rsp)
+		return err
+	}
+}
+
+func (w *hook) ServerSubscriber(next server.FuncSubHandler) server.FuncSubHandler {
+	return func(ctx context.Context, msg server.Message) (err error) {
+		defer func() {
+			r := recover()
+			switch verr := r.(type) {
+			case nil:
+				return
+			case error:
+				err = w.opts.ServerSubscriberFn(ctx, msg, verr)
+			default:
+				err = w.opts.ServerSubscriberFn(ctx, msg, fmt.Errorf("%v", r))
+			}
+		}()
+		err = next(ctx, msg)
+		return err
+	}
+}

hooks/requestid/requestid.go

@@ -0,0 +1,139 @@
+package requestid
+
+import (
+	"context"
+	"net/textproto"
+	
+	"go.unistack.org/micro/v3/client"
+	"go.unistack.org/micro/v3/metadata"
+	"go.unistack.org/micro/v3/server"
+	"go.unistack.org/micro/v3/util/id"
+)
+
+type XRequestIDKey struct{}
+
+// DefaultMetadataKey contains metadata key
+var DefaultMetadataKey = textproto.CanonicalMIMEHeaderKey("x-request-id")
+
+// DefaultMetadataFunc wil be used if user not provide own func to fill metadata
+var DefaultMetadataFunc = func(ctx context.Context) (context.Context, error) {
+	var xid string
+
+	cid, cok := ctx.Value(XRequestIDKey{}).(string)
+	if cok && cid != "" {
+		xid = cid
+	}
+
+	imd, iok := metadata.FromIncomingContext(ctx)
+	if !iok || imd == nil {
+		imd = metadata.New(1)
+		ctx = metadata.NewIncomingContext(ctx, imd)
+	}
+
+	omd, ook := metadata.FromOutgoingContext(ctx)
+	if !ook || omd == nil {
+		omd = metadata.New(1)
+		ctx = metadata.NewOutgoingContext(ctx, omd)
+	}
+
+	if xid == "" {
+		var id string
+		if id, iok = imd.Get(DefaultMetadataKey); iok && id != "" {
+			xid = id
+		}
+		if id, ook = omd.Get(DefaultMetadataKey); ook && id != "" {
+			xid = id
+		}
+	}
+
+	if xid == "" {
+		var err error
+		xid, err = id.New()
+		if err != nil {
+			return ctx, err
+		}
+	}
+
+	if !cok {
+		ctx = context.WithValue(ctx, XRequestIDKey{}, xid)
+	}
+
+	if !iok {
+		imd.Set(DefaultMetadataKey, xid)
+	}
+
+	if !ook {
+		omd.Set(DefaultMetadataKey, xid)
+	}
+
+	return ctx, nil
+}
+
+type hook struct{}
+
+func NewHook() *hook {
+	return &hook{}
+}
+
+func (w *hook) ServerSubscriber(next server.FuncSubHandler) server.FuncSubHandler {
+	return func(ctx context.Context, msg server.Message) error {
+		var err error
+		if xid, ok := msg.Header()[DefaultMetadataKey]; ok {
+			ctx = context.WithValue(ctx, XRequestIDKey{}, xid)
+		}
+		if ctx, err = DefaultMetadataFunc(ctx); err != nil {
+			return err
+		}
+		return next(ctx, msg)
+	}
+}
+
+func (w *hook) ServerHandler(next server.FuncHandler) server.FuncHandler {
+	return func(ctx context.Context, req server.Request, rsp interface{}) error {
+		var err error
+		if ctx, err = DefaultMetadataFunc(ctx); err != nil {
+			return err
+		}
+		return next(ctx, req, rsp)
+	}
+}
+
+func (w *hook) ClientBatchPublish(next client.FuncBatchPublish) client.FuncBatchPublish {
+	return func(ctx context.Context, msgs []client.Message, opts ...client.PublishOption) error {
+		var err error
+		if ctx, err = DefaultMetadataFunc(ctx); err != nil {
+			return err
+		}
+		return next(ctx, msgs, opts...)
+	}
+}
+
+func (w *hook) ClientPublish(next client.FuncPublish) client.FuncPublish {
+	return func(ctx context.Context, msg client.Message, opts ...client.PublishOption) error {
+		var err error
+		if ctx, err = DefaultMetadataFunc(ctx); err != nil {
+			return err
+		}
+		return next(ctx, msg, opts...)
+	}
+}
+
+func (w *hook) ClientCall(next client.FuncCall) client.FuncCall {
+	return func(ctx context.Context, req client.Request, rsp interface{}, opts ...client.CallOption) error {
+		var err error
+		if ctx, err = DefaultMetadataFunc(ctx); err != nil {
+			return err
+		}
+		return next(ctx, req, rsp, opts...)
+	}
+}
+
+func (w *hook) ClientStream(next client.FuncStream) client.FuncStream {
+	return func(ctx context.Context, req client.Request, opts ...client.CallOption) (client.Stream, error) {
+		var err error
+		if ctx, err = DefaultMetadataFunc(ctx); err != nil {
+			return nil, err
+		}
+		return next(ctx, req, opts...)
+	}
+}

hooks/requestid/requestid_test.go

@@ -0,0 +1,33 @@
+package requestid
+
+import (
+	"context"
+	"testing"
+
+	"go.unistack.org/micro/v3/metadata"
+)
+
+func TestDefaultMetadataFunc(t *testing.T) {
+	ctx := context.TODO()
+
+	nctx, err := DefaultMetadataFunc(ctx)
+	if err != nil {
+		t.Fatalf("%v", err)
+	}
+
+	imd, ok := metadata.FromIncomingContext(nctx)
+	if !ok {
+		t.Fatalf("md missing in incoming context")
+	}
+	omd, ok := metadata.FromOutgoingContext(nctx)
+	if !ok {
+		t.Fatalf("md missing in outgoing context")
+	}
+
+	_, iok := imd.Get(DefaultMetadataKey)
+	_, ook := omd.Get(DefaultMetadataKey)
+
+	if !iok || !ook {
+		t.Fatalf("missing metadata key value")
+	}
+}

hooks/validator/validator.go

@@ -0,0 +1,194 @@
+package validator
+
+import (
+	"context"
+
+	"go.unistack.org/micro/v3/client"
+	"go.unistack.org/micro/v3/errors"
+	"go.unistack.org/micro/v3/server"
+)
+
+var (
+	DefaultClientErrorFunc = func(req client.Request, rsp interface{}, err error) error {
+		if rsp != nil {
+			return errors.BadGateway(req.Service(), "%v", err)
+		}
+		return errors.BadRequest(req.Service(), "%v", err)
+	}
+
+	DefaultServerErrorFunc = func(req server.Request, rsp interface{}, err error) error {
+		if rsp != nil {
+			return errors.BadGateway(req.Service(), "%v", err)
+		}
+		return errors.BadRequest(req.Service(), "%v", err)
+	}
+
+	DefaultPublishErrorFunc = func(msg client.Message, err error) error {
+		return errors.BadRequest(msg.Topic(), "%v", err)
+	}
+
+	DefaultSubscribeErrorFunc = func(msg server.Message, err error) error {
+		return errors.BadRequest(msg.Topic(), "%v", err)
+	}
+)
+
+type (
+	ClientErrorFunc    func(client.Request, interface{}, error) error
+	ServerErrorFunc    func(server.Request, interface{}, error) error
+	PublishErrorFunc   func(client.Message, error) error
+	SubscribeErrorFunc func(server.Message, error) error
+)
+
+// Options struct holds wrapper options
+type Options struct {
+	ClientErrorFn          ClientErrorFunc
+	ServerErrorFn          ServerErrorFunc
+	PublishErrorFn         PublishErrorFunc
+	SubscribeErrorFn       SubscribeErrorFunc
+	ClientValidateResponse bool
+	ServerValidateResponse bool
+}
+
+// Option func signature
+type Option func(*Options)
+
+func ClientValidateResponse(b bool) Option {
+	return func(o *Options) {
+		o.ClientValidateResponse = b
+	}
+}
+
+func ServerValidateResponse(b bool) Option {
+	return func(o *Options) {
+		o.ClientValidateResponse = b
+	}
+}
+
+func ClientReqErrorFn(fn ClientErrorFunc) Option {
+	return func(o *Options) {
+		o.ClientErrorFn = fn
+	}
+}
+
+func ServerErrorFn(fn ServerErrorFunc) Option {
+	return func(o *Options) {
+		o.ServerErrorFn = fn
+	}
+}
+
+func PublishErrorFn(fn PublishErrorFunc) Option {
+	return func(o *Options) {
+		o.PublishErrorFn = fn
+	}
+}
+
+func SubscribeErrorFn(fn SubscribeErrorFunc) Option {
+	return func(o *Options) {
+		o.SubscribeErrorFn = fn
+	}
+}
+
+func NewOptions(opts ...Option) Options {
+	options := Options{
+		ClientErrorFn:    DefaultClientErrorFunc,
+		ServerErrorFn:    DefaultServerErrorFunc,
+		PublishErrorFn:   DefaultPublishErrorFunc,
+		SubscribeErrorFn: DefaultSubscribeErrorFunc,
+	}
+	for _, o := range opts {
+		o(&options)
+	}
+	return options
+}
+
+func NewHook(opts ...Option) *hook {
+	return &hook{opts: NewOptions(opts...)}
+}
+
+type validator interface {
+	Validate() error
+}
+
+type hook struct {
+	opts Options
+}
+
+func (w *hook) ClientCall(next client.FuncCall) client.FuncCall {
+	return func(ctx context.Context, req client.Request, rsp interface{}, opts ...client.CallOption) error {
+		if v, ok := req.Body().(validator); ok {
+			if err := v.Validate(); err != nil {
+				return w.opts.ClientErrorFn(req, nil, err)
+			}
+		}
+		err := next(ctx, req, rsp, opts...)
+		if v, ok := rsp.(validator); ok && w.opts.ClientValidateResponse {
+			if verr := v.Validate(); verr != nil {
+				return w.opts.ClientErrorFn(req, rsp, verr)
+			}
+		}
+		return err
+	}
+}
+
+func (w *hook) ClientStream(next client.FuncStream) client.FuncStream {
+	return func(ctx context.Context, req client.Request, opts ...client.CallOption) (client.Stream, error) {
+		if v, ok := req.Body().(validator); ok {
+			if err := v.Validate(); err != nil {
+				return nil, w.opts.ClientErrorFn(req, nil, err)
+			}
+		}
+		return next(ctx, req, opts...)
+	}
+}
+
+func (w *hook) ClientPublish(next client.FuncPublish) client.FuncPublish {
+	return func(ctx context.Context, msg client.Message, opts ...client.PublishOption) error {
+		if v, ok := msg.Payload().(validator); ok {
+			if err := v.Validate(); err != nil {
+				return w.opts.PublishErrorFn(msg, err)
+			}
+		}
+		return next(ctx, msg, opts...)
+	}
+}
+
+func (w *hook) ClientBatchPublish(next client.FuncBatchPublish) client.FuncBatchPublish {
+	return func(ctx context.Context, msgs []client.Message, opts ...client.PublishOption) error {
+		for _, msg := range msgs {
+			if v, ok := msg.Payload().(validator); ok {
+				if err := v.Validate(); err != nil {
+					return w.opts.PublishErrorFn(msg, err)
+				}
+			}
+		}
+		return next(ctx, msgs, opts...)
+	}
+}
+
+func (w *hook) ServerHandler(next server.FuncHandler) server.FuncHandler {
+	return func(ctx context.Context, req server.Request, rsp interface{}) error {
+		if v, ok := req.Body().(validator); ok {
+			if err := v.Validate(); err != nil {
+				return w.opts.ServerErrorFn(req, nil, err)
+			}
+		}
+		err := next(ctx, req, rsp)
+		if v, ok := rsp.(validator); ok && w.opts.ServerValidateResponse {
+			if verr := v.Validate(); verr != nil {
+				return w.opts.ServerErrorFn(req, rsp, verr)
+			}
+		}
+		return err
+	}
+}
+
+func (w *hook) ServerSubscriber(next server.FuncSubHandler) server.FuncSubHandler {
+	return func(ctx context.Context, msg server.Message) error {
+		if v, ok := msg.Body().(validator); ok {
+			if err := v.Validate(); err != nil {
+				return w.opts.SubscribeErrorFn(msg, err)
+			}
+		}
+		return next(ctx, msg)
+	}
+}

logger/options.go

@@ -99,6 +99,7 @@ func WithAddFields(fields ...interface{}) Option {
 					iv, iok := o.Fields[i].(string)
 					jv, jok := fields[j].(string)
 					if iok && jok && iv == jv {
+						o.Fields[i+1] = fields[j+1]
 						fields = slices.Delete(fields, j, j+2)
 					}
 				}

logger/slog/slog.go

@@ -278,7 +278,7 @@ func (s *slogLogger) printLog(ctx context.Context, lvl logger.Level, msg string,
 		}
 	}
 
-	if (s.opts.AddStacktrace || lvl == logger.FatalLevel) || (s.opts.AddStacktrace && lvl == logger.ErrorLevel) {
+	if s.opts.AddStacktrace && (lvl == logger.FatalLevel || lvl == logger.ErrorLevel) {
 		stackInfo := make([]byte, 1024*1024)
 		if stackSize := runtime.Stack(stackInfo, false); stackSize > 0 {
 			traceLines := reTrace.Split(string(stackInfo[:stackSize]), -1)

logger/slog/slog_test.go

@@ -14,13 +14,14 @@ import (
 	"github.com/google/uuid"
 	"go.unistack.org/micro/v3/logger"
 	"go.unistack.org/micro/v3/metadata"
+	"go.unistack.org/micro/v3/util/buffer"
 )
 
 // always first to have proper check
 func TestStacktrace(t *testing.T) {
 	ctx := context.TODO()
 	buf := bytes.NewBuffer(nil)
-	l := NewLogger(logger.WithLevel(logger.ErrorLevel), logger.WithOutput(buf),
+	l := NewLogger(logger.WithLevel(logger.DebugLevel), logger.WithOutput(buf),
 		WithHandlerFunc(slog.NewTextHandler),
 		logger.WithAddStacktrace(true),
 	)
@@ -30,11 +31,30 @@ func TestStacktrace(t *testing.T) {
 
 	l.Error(ctx, "msg1", errors.New("err"))
 
-	if !bytes.Contains(buf.Bytes(), []byte(`slog_test.go:31`)) {
+	if !bytes.Contains(buf.Bytes(), []byte(`slog_test.go:32`)) {
 		t.Fatalf("logger error not works, buf contains: %s", buf.Bytes())
 	}
 }
 
+func TestDelayedBuffer(t *testing.T) {
+	ctx := context.TODO()
+	buf := bytes.NewBuffer(nil)
+	dbuf := buffer.NewDelayedBuffer(100, 100*time.Millisecond, buf)
+	l := NewLogger(logger.WithLevel(logger.ErrorLevel), logger.WithOutput(dbuf),
+		WithHandlerFunc(slog.NewTextHandler),
+		logger.WithAddStacktrace(true),
+	)
+	if err := l.Init(logger.WithFields("key1", "val1")); err != nil {
+		t.Fatal(err)
+	}
+
+	l.Error(ctx, "msg1", errors.New("err"))
+	time.Sleep(120 * time.Millisecond)
+	if !bytes.Contains(buf.Bytes(), []byte(`key1=val1`)) {
+		t.Fatalf("logger delayed buffer not works, buf contains: %s", buf.Bytes())
+	}
+}
+
 func TestTime(t *testing.T) {
 	ctx := context.TODO()
 	buf := bytes.NewBuffer(nil)
@@ -104,7 +124,7 @@ func TestWithDedupKeysWithAddFields(t *testing.T) {
 
 	l.Info(ctx, "msg3")
 
-	if !bytes.Contains(buf.Bytes(), []byte(`msg=msg3 key1=val1 key2=val2`)) {
+	if !bytes.Contains(buf.Bytes(), []byte(`msg=msg3 key1=val4 key2=val3`)) {
 		t.Fatalf("logger error not works, buf contains: %s", buf.Bytes())
 	}
 }

register/memory/memory.go

@@ -149,7 +149,7 @@ func (m *memory) Register(_ context.Context, s *register.Service, opts ...regist
 			m.opts.Logger.Debug(m.opts.Context, fmt.Sprintf("Register added new service: %s, version: %s", s.Name, s.Version))
 		}
 		m.records[options.Namespace] = srvs
-		go m.sendEvent(&register.Result{Action: "create", Service: s})
+		go m.sendEvent(&register.Result{Action: register.EventCreate, Service: s})
 	}
 
 	var addedNodes bool
@@ -185,7 +185,7 @@ func (m *memory) Register(_ context.Context, s *register.Service, opts ...regist
 		if m.opts.Logger.V(logger.DebugLevel) {
 			m.opts.Logger.Debug(m.opts.Context, fmt.Sprintf("Register added new node to service: %s, version: %s", s.Name, s.Version))
 		}
-		go m.sendEvent(&register.Result{Action: "update", Service: s})
+		go m.sendEvent(&register.Result{Action: register.EventUpdate, Service: s})
 	} else {
 		// refresh TTL and timestamp
 		for _, n := range s.Nodes {
@@ -238,7 +238,7 @@ func (m *memory) Deregister(ctx context.Context, s *register.Service, opts ...re
 	// is cleanup
 	if len(version.Nodes) > 0 {
 		m.records[options.Namespace][s.Name][s.Version] = version
-		go m.sendEvent(&register.Result{Action: "update", Service: s})
+		go m.sendEvent(&register.Result{Action: register.EventUpdate, Service: s})
 		return nil
 	}
 
@@ -246,7 +246,7 @@ func (m *memory) Deregister(ctx context.Context, s *register.Service, opts ...re
 	// register and exit
 	if len(versions) == 1 {
 		delete(m.records[options.Namespace], s.Name)
-		go m.sendEvent(&register.Result{Action: "delete", Service: s})
+		go m.sendEvent(&register.Result{Action: register.EventDelete, Service: s})
 
 		if m.opts.Logger.V(logger.DebugLevel) {
 			m.opts.Logger.Debug(m.opts.Context, fmt.Sprintf("Register removed service: %s", s.Name))
@@ -256,7 +256,7 @@ func (m *memory) Deregister(ctx context.Context, s *register.Service, opts ...re
 
 	// there are other versions of the service running, so only remove this version of it
 	delete(m.records[options.Namespace][s.Name], s.Version)
-	go m.sendEvent(&register.Result{Action: "delete", Service: s})
+	go m.sendEvent(&register.Result{Action: register.EventDelete, Service: s})
 	if m.opts.Logger.V(logger.DebugLevel) {
 		m.opts.Logger.Debug(m.opts.Context, fmt.Sprintf("Register removed service: %s, version: %s", s.Name, s.Version))
 	}

register/watcher.go

@@ -15,31 +15,31 @@ type Watcher interface {
 // the watcher. Actions can be create, update, delete
 type Result struct {
 	// Service holds register service
-	Service *Service
+	Service *Service `json:"service,omitempty"`
 	// Action holds the action
-	Action string
+	Action EventType `json:"action,omitempty"`
 }
 
 // EventType defines register event type
 type EventType int
 
 const (
-	// Create is emitted when a new service is registered
-	Create EventType = iota
-	// Delete is emitted when an existing service is deregistered
-	Delete
-	// Update is emitted when an existing service is updated
-	Update
+	// EventCreate is emitted when a new service is registered
+	EventCreate EventType = iota
+	// EventDelete is emitted when an existing service is deregistered
+	EventDelete
+	// EventUpdate is emitted when an existing service is updated
+	EventUpdate
 )
 
 // String returns human readable event type
 func (t EventType) String() string {
 	switch t {
-	case Create:
+	case EventCreate:
 		return "create"
-	case Delete:
+	case EventDelete:
 		return "delete"
-	case Update:
+	case EventUpdate:
 		return "update"
 	default:
 		return "unknown"
@@ -49,11 +49,11 @@ func (t EventType) String() string {
 // Event is register event
 type Event struct {
 	// Timestamp is event timestamp
-	Timestamp time.Time
+	Timestamp time.Time `json:"timestamp,omitempty"`
 	// Service is register service
-	Service *Service
+	Service *Service `json:"service,omitempty"`
 	// ID is register id
-	ID string
+	ID string `json:"id,omitempty"`
 	// Type defines type of event
-	Type EventType
+	Type EventType `json:"type,omitempty"`
 }

service.go

@@ -104,6 +104,7 @@ type service struct {
 	done chan struct{}
 	opts Options
 	sync.RWMutex
+	stopped bool
 }
 
 // NewService creates and returns a new Service based on the packages within.
@@ -429,7 +430,7 @@ func (s *service) Stop() error {
 		}
 	}
 
-	close(s.done)
+	s.notifyShutdown()
 
 	return nil
 }
@@ -453,10 +454,23 @@ func (s *service) Run() error {
 		return err
 	}
 
-	// wait on context cancel
 	<-s.done
 
-	return s.Stop()
+	return nil
+}
+
+// notifyShutdown marks the service as stopped and closes the done channel.
+// It ensures the channel is closed only once, preventing multiple closures.
+func (s *service) notifyShutdown() {
+	s.Lock()
+	if s.stopped {
+		s.Unlock()
+		return
+	}
+	s.stopped = true
+	s.Unlock()
+
+	close(s.done)
 }
 
 type Namer interface {

service_test.go

@@ -4,7 +4,9 @@ import (
 	"context"
 	"reflect"
 	"testing"
+	"time"
 
+	"github.com/stretchr/testify/require"
 	"go.unistack.org/micro/v3/broker"
 	"go.unistack.org/micro/v3/client"
 	"go.unistack.org/micro/v3/config"
@@ -773,3 +775,41 @@ func Test_getNameIndex(t *testing.T) {
 	}
 }
 */
+
+func TestServiceShutdown(t *testing.T) {
+	defer func() {
+		if r := recover(); r != nil {
+			t.Fatalf("service shutdown failed: %v", r)
+		}
+	}()
+
+	s, ok := NewService().(*service)
+	require.NotNil(t, s)
+	require.True(t, ok)
+
+	require.NoError(t, s.Start())
+	require.False(t, s.stopped)
+
+	require.NoError(t, s.Stop())
+	require.True(t, s.stopped)
+}
+
+func TestServiceMultipleShutdowns(t *testing.T) {
+	defer func() {
+		if r := recover(); r != nil {
+			t.Fatalf("service shutdown failed: %v", r)
+		}
+	}()
+
+	s := NewService()
+
+	go func() {
+		time.Sleep(10 * time.Millisecond)
+		// first call
+		require.NoError(t, s.Stop())
+		// duplicate call
+		require.NoError(t, s.Stop())
+	}()
+
+	require.NoError(t, s.Run())
+}

tracer/memory/memory.go

@@ -89,6 +89,10 @@ func (s *Span) Tracer() tracer.Tracer {
 	return s.tracer
 }
 
+func (s *Span) IsRecording() bool {
+	return true
+}
+
 type Event struct {
 	name   string
 	labels []interface{}

tracer/noop.go

@@ -120,6 +120,10 @@ func (s *noopSpan) SetStatus(st SpanStatus, msg string) {
 	s.statusMsg = msg
 }
 
+func (s *noopSpan) IsRecording() bool {
+	return false
+}
+
 // NewTracer returns new memory tracer
 func NewTracer(opts ...Option) Tracer {
 	return &noopTracer{

tracer/tracer.go

@@ -78,4 +78,6 @@ type Span interface {
 	TraceID() string
 	// SpanID returns span id
 	SpanID() string
+	// IsRecording returns the recording state of the Span.
+	IsRecording() bool
 }

util/buf/buf.go

@@ -1,27 +0,0 @@
-package buf
-
-import (
-	"bytes"
-	"io"
-)
-
-var _ io.Closer = &Buffer{}
-
-// Buffer bytes.Buffer wrapper to satisfie io.Closer interface
-type Buffer struct {
-	*bytes.Buffer
-}
-
-// Close reset buffer contents
-func (b *Buffer) Close() error {
-	b.Buffer.Reset()
-	return nil
-}
-
-// New creates new buffer that satisfies Closer interface
-func New(b *bytes.Buffer) *Buffer {
-	if b == nil {
-		b = bytes.NewBuffer(nil)
-	}
-	return &Buffer{b}
-}

util/buffer/delayed_buffer.go

@@ -0,0 +1,85 @@
+package buffer
+
+import (
+	"io"
+	"sync"
+	"time"
+)
+
+var _ io.WriteCloser = (*DelayedBuffer)(nil)
+
+// DelayedBuffer is the buffer that holds items until either the buffer filled or a specified time limit is reached
+type DelayedBuffer struct {
+	mu        sync.Mutex
+	maxWait   time.Duration
+	flushTime time.Time
+	buffer    chan []byte
+	ticker    *time.Ticker
+	w         io.Writer
+	err       error
+}
+
+func NewDelayedBuffer(size int, maxWait time.Duration, w io.Writer) *DelayedBuffer {
+	b := &DelayedBuffer{
+		buffer:    make(chan []byte, size),
+		ticker:    time.NewTicker(maxWait),
+		w:         w,
+		flushTime: time.Now(),
+		maxWait:   maxWait,
+	}
+	b.loop()
+	return b
+}
+
+func (b *DelayedBuffer) loop() {
+	go func() {
+		for range b.ticker.C {
+			b.mu.Lock()
+			if time.Since(b.flushTime) > b.maxWait {
+				b.flush()
+			}
+			b.mu.Unlock()
+		}
+	}()
+}
+
+func (b *DelayedBuffer) flush() {
+	bufLen := len(b.buffer)
+	if bufLen > 0 {
+		tmp := make([][]byte, bufLen)
+		for i := 0; i < bufLen; i++ {
+			tmp[i] = <-b.buffer
+		}
+		for _, t := range tmp {
+			_, b.err = b.w.Write(t)
+		}
+		b.flushTime = time.Now()
+	}
+}
+
+func (b *DelayedBuffer) Put(items ...[]byte) {
+	b.mu.Lock()
+	for _, item := range items {
+		select {
+		case b.buffer <- item:
+		default:
+			b.flush()
+			b.buffer <- item
+		}
+	}
+	b.mu.Unlock()
+}
+
+func (b *DelayedBuffer) Close() error {
+	b.mu.Lock()
+	b.flush()
+	close(b.buffer)
+	b.ticker.Stop()
+	b.mu.Unlock()
+	return b.err
+}
+
+func (b *DelayedBuffer) Write(data []byte) (int, error) {
+	b.Put(data)
+	return len(data), b.err
+}

util/buffer/delayed_buffer_test.go

@@ -0,0 +1,22 @@
+package buffer
+
+import (
+	"bytes"
+	"testing"
+	"time"
+)
+
+func TestTimedBuffer(t *testing.T) {
+	buf := bytes.NewBuffer(nil)
+	b := NewDelayedBuffer(100, 300*time.Millisecond, buf)
+	for i := 0; i < 100; i++ {
+		_, _ = b.Write([]byte(`test`))
+	}
+	if buf.Len() != 0 {
+		t.Fatal("delayed write not worked")
+	}
+	time.Sleep(400 * time.Millisecond)
+	if buf.Len() == 0 {
+		t.Fatal("delayed write not worked")
+	}
+}

util/buffer/seeker_buffer.go

@@ -0,0 +1,78 @@
+package buffer
+
+import "io"
+
+var _ interface {
+	io.ReadCloser
+	io.ReadSeeker
+} = (*SeekerBuffer)(nil)
+
+// Buffer is a ReadWriteCloser that supports seeking. It's intended to
+// replicate the functionality of bytes.Buffer that I use in my projects.
+//
+// Note that the seeking is limited to the read marker; all writes are
+// append-only.
+type SeekerBuffer struct {
+	data []byte
+	pos  int64
+}
+
+func NewSeekerBuffer(data []byte) *SeekerBuffer {
+	return &SeekerBuffer{
+		data: data,
+	}
+}
+
+func (b *SeekerBuffer) Read(p []byte) (int, error) {
+	if b.pos >= int64(len(b.data)) {
+		return 0, io.EOF
+	}
+
+	n := copy(p, b.data[b.pos:])
+	b.pos += int64(n)
+	return n, nil
+}
+
+func (b *SeekerBuffer) Write(p []byte) (int, error) {
+	b.data = append(b.data, p...)
+	return len(p), nil
+}
+
+// Seek sets the read pointer to pos.
+func (b *SeekerBuffer) Seek(offset int64, whence int) (int64, error) {
+	switch whence {
+	case io.SeekStart:
+		b.pos = offset
+	case io.SeekEnd:
+		b.pos = int64(len(b.data)) + offset
+	case io.SeekCurrent:
+		b.pos += offset
+	}
+
+	return b.pos, nil
+}
+
+// Rewind resets the read pointer to 0.
+func (b *SeekerBuffer) Rewind() error {
+	if _, err := b.Seek(0, io.SeekStart); err != nil {
+		return err
+	}
+	return nil
+}
+
+// Close clears all the data out of the buffer and sets the read position to 0.
+func (b *SeekerBuffer) Close() error {
+	b.data = nil
+	b.pos = 0
+	return nil
+}
+
+// Len returns the length of data remaining to be read.
+func (b *SeekerBuffer) Len() int {
+	return len(b.data[b.pos:])
+}
+
+// Bytes returns the underlying bytes from the current position.
+func (b *SeekerBuffer) Bytes() []byte {
+	return b.data[b.pos:]
+}

util/buffer/seeker_buffer_test.go

@@ -0,0 +1,55 @@
+package buffer
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func noErrorT(t *testing.T, err error) {
+	if nil != err {
+		t.Fatalf("%s", err)
+	}
+}
+
+func boolT(t *testing.T, cond bool, s ...string) {
+	if !cond {
+		what := strings.Join(s, ", ")
+		if len(what) > 0 {
+			what = ": " + what
+		}
+		t.Fatalf("assert.Bool failed%s", what)
+	}
+}
+
+func TestSeeking(t *testing.T) {
+	partA := []byte("hello, ")
+	partB := []byte("world!")
+
+	buf := NewSeekerBuffer(partA)
+
+	boolT(t, buf.Len() == len(partA), fmt.Sprintf("on init: have length %d, want length %d", buf.Len(), len(partA)))
+
+	b := make([]byte, 32)
+
+	n, err := buf.Read(b)
+	noErrorT(t, err)
+	boolT(t, buf.Len() == 0, fmt.Sprintf("after reading 1: have length %d, want length 0", buf.Len()))
+	boolT(t, n == len(partA), fmt.Sprintf("after reading 2: have length %d, want length %d", n, len(partA)))
+
+	n, err = buf.Write(partB)
+	noErrorT(t, err)
+	boolT(t, n == len(partB), fmt.Sprintf("after writing: have length %d, want length %d", n, len(partB)))
+
+	n, err = buf.Read(b)
+	noErrorT(t, err)
+	boolT(t, buf.Len() == 0, fmt.Sprintf("after rereading 1: have length %d, want length 0", buf.Len()))
+	boolT(t, n == len(partB), fmt.Sprintf("after rereading 2: have length %d, want length %d", n, len(partB)))
+
+	partsLen := len(partA) + len(partB)
+	_ = buf.Rewind()
+	boolT(t, buf.Len() == partsLen, fmt.Sprintf("after rewinding: have length %d, want length %d", buf.Len(), partsLen))
+
+	buf.Close()
+	boolT(t, buf.Len() == 0, fmt.Sprintf("after closing, have length %d, want length 0", buf.Len()))
+}

util/time/duration_test.go

@@ -35,11 +35,11 @@ func TestUnmarshalYAML(t *testing.T) {
 		t.Fatalf("invalid duration %v != 10000000", v.TTL)
 	}
 
-	err = yaml.Unmarshal([]byte(`{"ttl":"1y"}`), v)
+	err = yaml.Unmarshal([]byte(`{"ttl":"1d"}`), v)
 	if err != nil {
 		t.Fatal(err)
-	} else if *(v.TTL) != 31622400000000000 {
-		t.Fatalf("invalid duration %v != 31622400000000000", v.TTL)
+	} else if *(v.TTL) != 86400000000000 {
+		t.Fatalf("invalid duration %v != 86400000000000", *v.TTL)
 	}
 }
 
@@ -68,11 +68,11 @@ func TestUnmarshalJSON(t *testing.T) {
 		t.Fatalf("invalid duration %v != 10000000", v.TTL)
 	}
 
-	err = json.Unmarshal([]byte(`{"ttl":"1y"}`), v)
+	err = json.Unmarshal([]byte(`{"ttl":"1d"}`), v)
 	if err != nil {
 		t.Fatal(err)
-	} else if v.TTL != 31622400000000000 {
-		t.Fatalf("invalid duration %v != 31622400000000000", v.TTL)
+	} else if v.TTL != 86400000000000 {
+		t.Fatalf("invalid duration %v != 86400000000000", v.TTL)
 	}
 }
 
@@ -87,11 +87,11 @@ func TestParseDuration(t *testing.T) {
 	if td.String() != "340h0m0s" {
 		t.Fatalf("ParseDuration 14d != 340h0m0s : %s", td.String())
 	}
-	td, err = ParseDuration("1y")
+	td, err = ParseDuration("1d")
 	if err != nil {
 		t.Fatalf("ParseDuration error: %v", err)
 	}
-	if td.String() != "8784h0m0s" {
-		t.Fatalf("ParseDuration 1y != 8784h0m0s : %s", td.String())
+	if td.String() != "24h0m0s" {
+		t.Fatalf("ParseDuration 1d != 24h0m0s : %s", td.String())
 	}
 }