.gitea/ISSUE_TEMPLATE/bug_report.md

@@ -1,18 +0,0 @@
----
-name: Bug report
-about: For reporting bugs in micro
-title: "[BUG]"
-labels: ''
-assignees: ''
-
----
-
-**Describe the bug**
-
-1. What are you trying to do?
-2. What did you expect to happen?
-3. What happens instead?
-
-**How to reproduce the bug:**
-
-If possible, please include a minimal code snippet here.

.gitea/ISSUE_TEMPLATE/feature-request---enhancement.md

@@ -1,17 +0,0 @@
----
-name: Feature request / Enhancement
-about: If you have a need not served by micro
-title: "[FEATURE]"
-labels: ''
-assignees: ''
-
----
-
-**Is your feature request related to a problem? Please describe.**
-A clear and concise description of what the problem is. Ex. I'm always frustrated when [...]
-
-**Describe the solution you'd like**
-A clear and concise description of what you want to happen.
-
-**Additional context**
-Add any other context or screenshots about the feature request here.

.gitea/ISSUE_TEMPLATE/question.md

@@ -1,8 +0,0 @@
----
-name: Question
-about: Ask a question about micro
-title: ''
-labels: ''
-assignees: ''
-
----

.gitea/autoapprove.yml

@@ -1,28 +0,0 @@
-name: "autoapprove"
-
-on:
-  pull_request_target:
-    types: [assigned, opened, synchronize, reopened]
-  workflow_run:
-    workflows: ["prbuild"]
-    types:
-      - completed
-
-permissions:
-  pull-requests: write
-  contents: write
-
-jobs:
-  autoapprove:
-    runs-on: ubuntu-latest
-    steps:
-      - name: approve
-        run: [ "curl -o tea https://dl.gitea.com/tea/main/tea-main-linux-amd64",
-               "chmod +x ./tea",
-               "./tea login add --name unistack --token ${{ secrets.GITHUB_TOKEN }} --url https://git.unistack.org",
-               "./tea pr --repo ${{ github.event.repository.name }}"
-        ]
-        if: github.actor == 'vtolstov'
-        id: approve
-        with:
-          github-token: ${{ secrets.GITHUB_TOKEN }}

.gitea/workflows/lint.yml

@@ -1,24 +0,0 @@
-name: lint
-on:
-  pull_request:
-    branches:
-    - master
-    - v3
-jobs:
-  lint:
-    name: lint
-    runs-on: ubuntu-latest
-    steps:
-    - name: setup-go
-      uses: actions/setup-go@v3
-      with:
-        go-version: 1.21
-    - name: checkout
-      uses: actions/checkout@v3
-    - name: deps
-      run: go get -v -d ./...
-    - name: lint
-      uses: https://github.com/golangci/golangci-lint-action@v3.4.0
-      continue-on-error: true
-      with:
-        version: v1.52

.gitea/workflows/pr.yml

@@ -1,23 +0,0 @@
-name: pr
-on:
-  pull_request:
-    branches:
-    - master
-    - v3
-jobs:
-  test:
-    name: test
-    runs-on: ubuntu-latest
-    steps:
-    - name: checkout
-      uses: actions/checkout@v3
-    - name: setup-go
-      uses: actions/setup-go@v3
-      with:
-        go-version: 1.21
-    - name: deps
-      run: go get -v -t -d ./...
-    - name: test
-      env:
-        INTEGRATION_TESTS: yes
-      run: go test -mod readonly -v ./...

.github.old/PULL_REQUEST_TEMPLATE.md

@@ -1,9 +0,0 @@
-## Pull Request template
-Please, go through these steps before clicking submit on this PR.
-
-1. Give a descriptive title to your PR.
-2. Provide a description of your changes.
-3. Make sure you have some relevant tests.
-4. Put `closes #XXXX` in your comment to auto-close the issue that your PR fixes (if applicable).
-
-**PLEASE REMOVE THIS TEMPLATE BEFORE SUBMITTING**

.github.old/workflows/autoapprove.yml

@@ -1,24 +0,0 @@
-name: "autoapprove"
-
-on:
-  pull_request_target:
-    types: [assigned, opened, synchronize, reopened]
-  workflow_run:
-    workflows: ["prbuild"]
-    types:
-      - completed
-
-permissions:
-  pull-requests: write
-  contents: write
-
-jobs:
-  autoapprove:
-    runs-on: ubuntu-latest
-    steps:
-      - name: approve
-        uses: hmarr/auto-approve-action@v3
-        if: github.actor == 'vtolstov' || github.actor == 'dependabot[bot]'
-        id: approve
-        with:
-          github-token: ${{ secrets.GITHUB_TOKEN }}

.github.old/workflows/automerge.yml

@@ -1,21 +0,0 @@
-name: "automerge"
-
-on:
-  pull_request_target:
-    types: [assigned, opened, synchronize, reopened]
-
-permissions:
-  pull-requests: write
-  contents: write
-
-jobs:
-  automerge:
-    runs-on: ubuntu-latest
-    if: github.actor == 'vtolstov'
-    steps:
-      - name: merge
-        id: merge
-        run: gh pr merge --auto --merge "$PR_URL"
-        env:
-          PR_URL: ${{github.event.pull_request.html_url}}
-          GITHUB_TOKEN: ${{secrets.TOKEN}}

.github.old/workflows/codecov.yml

@@ -1,39 +0,0 @@
-name: "codecov"
-
-on:
-  workflow_run:
-    workflows: ["build"]
-    types:
-      - completed
-  push:
-    branches: [ v3 ]
-  pull_request:
-    branches: [ v3 ]
-  schedule:
-    - cron: '34 1 * * 0'
-
-jobs:
-  codecov:
-    name: codecov
-    runs-on: ubuntu-latest
-    permissions:
-      actions: read
-      contents: read
-      security-events: write
-
-    strategy:
-      fail-fast: false
-      matrix:
-        language: [ 'go' ]
-
-    steps:
-    - name: checkout
-      uses: actions/checkout@v3
-    - name: setup
-      uses: actions/setup-go@v3
-      with:
-        go-version: 1.17
-    - name: Run coverage
-      run: go test -v -race -coverprofile=coverage.out -covermode=atomic ./...
-    - name: codecov
-      uses: codecov/codecov-action@v3.1.1

.github.old/workflows/pr.yml

@@ -1,40 +0,0 @@
-name: prbuild
-on:
-  pull_request:
-    branches:
-    - master
-    - v3
-jobs:
-  test:
-    name: test
-    runs-on: ubuntu-latest
-    steps:
-    - name: setup
-      uses: actions/setup-go@v3
-      with:
-        go-version: 1.17
-    - name: checkout
-      uses: actions/checkout@v3
-    - name: cache
-      uses: actions/cache@v3
-      with:
-        path: ~/go/pkg/mod
-        key: ${{ runner.os }}-go-${{ hashFiles('**/go.sum') }}
-        restore-keys: ${{ runner.os }}-go-
-    - name: deps
-      run: go get -v -t -d ./...
-    - name: test
-      env:
-        INTEGRATION_TESTS: yes
-      run: go test -mod readonly -v ./...
-  lint:
-    name: lint
-    runs-on: ubuntu-latest
-    steps:
-      - name: checkout
-        uses: actions/checkout@v3
-      - name: lint
-        uses: golangci/golangci-lint-action@v3.4.0
-        continue-on-error: true
-        with:
-          version: v1.30

.github/workflows/build.yml

@@ -10,35 +10,51 @@ jobs:
     runs-on: ubuntu-latest
     steps:
     - name: setup
-      uses: actions/setup-go@v3
+      uses: actions/setup-go@v2
       with:
-        go-version: 1.17
+        go-version: 1.16
-    - name: checkout
-      uses: actions/checkout@v3
     - name: cache
-      uses: actions/cache@v3
+      uses: actions/cache@v2
       with:
         path: ~/go/pkg/mod
         key: ${{ runner.os }}-go-${{ hashFiles('**/go.sum') }}
         restore-keys: ${{ runner.os }}-go-
-    - name: deps
+    - name: sdk checkout
+      uses: actions/checkout@v2
+    - name: sdk deps
       run: go get -v -t -d ./...
-    - name: test
+    - name: sdk test
       env:
         INTEGRATION_TESTS: yes
       run: go test -mod readonly -v ./...
+    - name: tests checkout
+      uses: actions/checkout@v2
+      with:
+        repository: unistack-org/micro-tests
+        ref: refs/heads/master
+        path: micro-tests
+        fetch-depth: 1
+    - name: tests deps
+      run: |
+        cd micro-tests
+        go mod edit -replace="github.com/unistack-org/micro/v3=../"
+        go get -v -t -d ./...
+    - name: tests test
+      env:
+        INTEGRATION_TESTS: yes
+      run: cd micro-tests && go test -mod readonly -v ./...
   lint:
     name: lint
     runs-on: ubuntu-latest
     steps:
       - name: checkout
-        uses: actions/checkout@v3
+        uses: actions/checkout@v2
       - name: lint
-        uses: golangci/golangci-lint-action@v3.4.0
+        uses: golangci/golangci-lint-action@v2
         continue-on-error: true
         with:
           # Required: the version of golangci-lint is required and must be specified without patch version: we always use the latest patch version.
-          version: v1.30
+          version: v1.39
           # Optional: working directory, useful for monorepos
           # working-directory: somedir
           # Optional: golangci-lint command line arguments.

.github/workflows/codeql-analysis.yml

@@ -43,14 +43,14 @@ jobs:
 
     steps:
     - name: checkout
-      uses: actions/checkout@v3
+      uses: actions/checkout@v2
     - name: setup
-      uses: actions/setup-go@v3
+      uses: actions/setup-go@v2
       with:
-        go-version: 1.17
+        go-version: 1.16
     # Initializes the CodeQL tools for scanning.
     - name: init
-      uses: github/codeql-action/init@v2
+      uses: github/codeql-action/init@v1
       with:
         languages: ${{ matrix.language }}
         # If you wish to specify custom queries, you can do so here or in a config file.
@@ -61,7 +61,7 @@ jobs:
     # Autobuild attempts to build any compiled languages  (C/C++, C#, or Java).
     # If this step fails, then you should remove it and run the build manually (see below)
     - name: autobuild
-      uses: github/codeql-action/autobuild@v2
+      uses: github/codeql-action/autobuild@v1
 
     # ℹ️ Command-line programs to run using the OS shell.
     # 📚 https://git.io/JvXDl
@@ -75,4 +75,4 @@ jobs:
     #   make release
 
     - name: analyze
-      uses: github/codeql-action/analyze@v2
+      uses: github/codeql-action/analyze@v1

.github/workflows/dependabot-automerge.yml

@@ -1,4 +1,4 @@
-name: "dependabot-automerge"
+name: "prautomerge"
 
 on:
   pull_request_target:
@@ -9,17 +9,21 @@ permissions:
   contents: write
 
 jobs:
-  automerge:
+  dependabot:
     runs-on: ubuntu-latest
-    if: github.actor == 'dependabot[bot]'
+    if: ${{ github.actor == 'dependabot[bot]' }}
     steps:
       - name: metadata
         id: metadata
-        uses: dependabot/fetch-metadata@v1.3.6
+        uses: dependabot/fetch-metadata@v1.1.1
         with:
           github-token: "${{ secrets.TOKEN }}"
+      - name: approve
+        run: gh pr review --approve "$PR_URL"
+        env:
+          PR_URL: ${{github.event.pull_request.html_url}}
+          GITHUB_TOKEN: ${{secrets.TOKEN}}
       - name: merge
-        id: merge
         if: ${{contains(steps.metadata.outputs.dependency-names, 'go.unistack.org')}}
         run: gh pr merge --auto --merge "$PR_URL"
         env:

.github/workflows/pr.yml

@@ -0,0 +1,63 @@
+name: prbuild
+on:
+  pull_request:
+    branches:
+    - master
+    - v3
+jobs:
+  test:
+    name: test
+    runs-on: ubuntu-latest
+    steps:
+    - name: setup
+      uses: actions/setup-go@v2
+      with:
+        go-version: 1.16
+    - name: cache
+      uses: actions/cache@v2
+      with:
+        path: ~/go/pkg
+        key: ${{ runner.os }}-go-${{ hashFiles('**/go.sum') }}
+        restore-keys: ${{ runner.os }}-go-
+    - name: sdk checkout
+      uses: actions/checkout@v2
+    - name: sdk deps
+      run: go get -v -t -d ./...
+    - name: sdk test
+      env:
+        INTEGRATION_TESTS: yes
+      run: go test -mod readonly -v ./...
+    - name: tests checkout
+      uses: actions/checkout@v2
+      with:
+        repository: unistack-org/micro-tests
+        ref: refs/heads/master
+        path: micro-tests
+        fetch-depth: 1
+    - name: tests deps
+      run: |
+        cd micro-tests
+        go mod edit -replace="github.com/unistack-org/micro/v3=../"
+        go get -v -t -d ./...
+    - name: tests test
+      env:
+        INTEGRATION_TESTS: yes
+      run: cd micro-tests && go test -mod readonly -v ./...
+  lint:
+    name: lint
+    runs-on: ubuntu-latest
+    steps:
+      - name: checkout
+        uses: actions/checkout@v2
+      - name: lint
+        uses: golangci/golangci-lint-action@v2
+        continue-on-error: true
+        with:
+          # Required: the version of golangci-lint is required and must be specified without patch version: we always use the latest patch version.
+          version: v1.39
+          # Optional: working directory, useful for monorepos
+          # working-directory: somedir
+          # Optional: golangci-lint command line arguments.
+          # args: --issues-exit-code=0
+          # Optional: show only new issues if it's a pull request. The default value is `false`.
+          # only-new-issues: true

.gitignore

@@ -1,8 +1,6 @@
 # Develop tools
 /.vscode/
 /.idea/
-.idea
-.vscode
 
 # Binaries for programs and plugins
 *.exe
@@ -15,7 +13,6 @@
 _obj
 _test
 _build
-.DS_Store
 
 # Architecture specific extensions/prefixes
 *.[568vq]

README.md

@@ -1,4 +1,4 @@
-# Micro [![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/github.com/unistack-org/micro/v3?tab=overview) [![Status](https://github.com/unistack-org/micro/workflows/build/badge.svg?branch=master)](https://github.com/unistack-org/micro/actions?query=workflow%3Abuild+branch%3Amaster+event%3Apush) [![Lint](https://goreportcard.com/badge/go.unistack.org/micro/v3)](https://goreportcard.com/report/go.unistack.org/micro/v3) [![Coverage](https://codecov.io/gh/unistack-org/micro/branch/v3/graph/badge.svg?token=OZPO2LP7VS)](https://codecov.io/gh/unistack-org/micro)
+# Micro [![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/github.com/unistack-org/micro/v3?tab=overview) [![Status](https://github.com/unistack-org/micro/workflows/build/badge.svg?branch=master)](https://github.com/unistack-org/micro/actions?query=workflow%3Abuild+branch%3Amaster+event%3Apush) [![Lint](https://goreportcard.com/report/go.unistack.org/micro/v3)](https://goreportcard.com/report/go.unistack.org/micro/v3) [![Slack](https://img.shields.io/static/v1?label=micro&message=slack&color=blueviolet)](https://unistack-org.slack.com/messages/default)
 
 Micro is a standard library for microservices.
 

api/api.go

@@ -0,0 +1,182 @@
+package api // import "go.unistack.org/micro/v3/api"
+
+import (
+	"errors"
+	"regexp"
+	"strings"
+
+	"go.unistack.org/micro/v3/metadata"
+	"go.unistack.org/micro/v3/register"
+	"go.unistack.org/micro/v3/server"
+)
+
+// nolint: revive
+// Api interface
+type Api interface {
+	// Initialise options
+	Init(...Option) error
+	// Get the options
+	Options() Options
+	// Register a http handler
+	Register(*Endpoint) error
+	// Register a route
+	Deregister(*Endpoint) error
+	// Implementation of api
+	String() string
+}
+
+// Options holds the options
+type Options struct{}
+
+// Option func signature
+type Option func(*Options) error
+
+// Endpoint is a mapping between an RPC method and HTTP endpoint
+type Endpoint struct {
+	// Name Greeter.Hello
+	Name string
+	// Desciption for endpoint
+	Description string
+	// Handler e.g rpc, proxy
+	Handler string
+	// Body destination
+	// "*" or "" - top level message value
+	// "string" - inner message value
+	Body string
+	// Host e.g example.com
+	Host []string
+	// Method e.g GET, POST
+	Method []string
+	// Path e.g /greeter. Expect POSIX regex
+	Path []string
+	// Stream flag
+	Stream bool
+}
+
+// Service represents an API service
+type Service struct {
+	// Name of service
+	Name string
+	// Endpoint for this service
+	Endpoint *Endpoint
+	// Services that provides service
+	Services []*register.Service
+}
+
+// Encode encodes an endpoint to endpoint metadata
+func Encode(e *Endpoint) map[string]string {
+	if e == nil {
+		return nil
+	}
+
+	// endpoint map
+	ep := make(map[string]string)
+
+	// set vals only if they exist
+	set := func(k, v string) {
+		if len(v) == 0 {
+			return
+		}
+		ep[k] = v
+	}
+
+	set("endpoint", e.Name)
+	set("description", e.Description)
+	set("handler", e.Handler)
+	set("method", strings.Join(e.Method, ","))
+	set("path", strings.Join(e.Path, ","))
+	set("host", strings.Join(e.Host, ","))
+	set("body", e.Body)
+
+	return ep
+}
+
+// Decode decodes endpoint metadata into an endpoint
+func Decode(e metadata.Metadata) *Endpoint {
+	if e == nil {
+		return nil
+	}
+
+	ep := &Endpoint{}
+	ep.Name, _ = e.Get("endpoint")
+	ep.Description, _ = e.Get("description")
+	epmethod, _ := e.Get("method")
+	ep.Method = []string{epmethod}
+	eppath, _ := e.Get("path")
+	ep.Path = []string{eppath}
+	ephost, _ := e.Get("host")
+	ep.Host = []string{ephost}
+	ep.Handler, _ = e.Get("handler")
+	ep.Body, _ = e.Get("body")
+
+	return ep
+}
+
+// Validate validates an endpoint to guarantee it won't blow up when being served
+func Validate(e *Endpoint) error {
+	if e == nil {
+		return errors.New("endpoint is nil")
+	}
+
+	if len(e.Name) == 0 {
+		return errors.New("name required")
+	}
+
+	for _, p := range e.Path {
+		ps := p[0]
+		pe := p[len(p)-1]
+
+		switch {
+		case ps == '^' && pe == '$':
+			if _, err := regexp.CompilePOSIX(p); err != nil {
+				return err
+			}
+		case ps == '^' && pe != '$':
+			return errors.New("invalid path")
+		case ps != '^' && pe == '$':
+			return errors.New("invalid path")
+		}
+	}
+
+	if len(e.Handler) == 0 {
+		return errors.New("invalid handler")
+	}
+
+	return nil
+}
+
+/*
+Design ideas
+
+// Gateway is an api gateway interface
+type Gateway interface {
+	// Register a http handler
+	Handle(pattern string, http.Handler)
+	// Register a route
+	RegisterRoute(r Route)
+	// Init initialises the command line.
+	// It also parses further options.
+	Init(...Option) error
+	// Run the gateway
+	Run() error
+}
+
+// NewGateway returns a new api gateway
+func NewGateway() Gateway {
+	return newGateway()
+}
+*/
+
+// WithEndpoint returns a server.HandlerOption with endpoint metadata set
+//
+// Usage:
+//
+// 	proto.RegisterHandler(service.Server(), new(Handler), api.WithEndpoint(
+//		&api.Endpoint{
+//			Name: "Greeter.Hello",
+//			Path: []string{"/greeter"},
+//		},
+//	))
+func WithEndpoint(e *Endpoint) server.HandlerOption {
+	return server.EndpointMetadata(e.Name, Encode(e))
+}

api/api_test.go

@@ -0,0 +1,152 @@
+package api
+
+import (
+	"strings"
+	"testing"
+)
+
+//nolint:gocyclo
+func TestEncoding(t *testing.T) {
+	testData := []*Endpoint{
+		nil,
+		{
+			Name:        "Foo.Bar",
+			Description: "A test endpoint",
+			Handler:     "meta",
+			Host:        []string{"foo.com"},
+			Method:      []string{"GET"},
+			Path:        []string{"/test"},
+		},
+	}
+
+	compare := func(expect, got []string) bool {
+		// no data to compare, return true
+		if len(expect) == 0 && len(got) == 0 {
+			return true
+		}
+		// no data expected but got some return false
+		if len(expect) == 0 && len(got) > 0 {
+			return false
+		}
+
+		// compare expected with what we got
+		for _, e := range expect {
+			var seen bool
+			for _, g := range got {
+				if e == g {
+					seen = true
+					break
+				}
+			}
+			if !seen {
+				return false
+			}
+		}
+
+		// we're done, return true
+		return true
+	}
+
+	for _, d := range testData {
+		// encode
+		e := Encode(d)
+		// decode
+		de := Decode(e)
+
+		// nil endpoint returns nil
+		if d == nil {
+			if e != nil {
+				t.Fatalf("expected nil got %v", e)
+			}
+			if de != nil {
+				t.Fatalf("expected nil got %v", de)
+			}
+
+			continue
+		}
+
+		// check encoded map
+		name := e["endpoint"]
+		desc := e["description"]
+		method := strings.Split(e["method"], ",")
+		path := strings.Split(e["path"], ",")
+		host := strings.Split(e["host"], ",")
+		handler := e["handler"]
+
+		if name != d.Name {
+			t.Fatalf("expected %v got %v", d.Name, name)
+		}
+		if desc != d.Description {
+			t.Fatalf("expected %v got %v", d.Description, desc)
+		}
+		if handler != d.Handler {
+			t.Fatalf("expected %v got %v", d.Handler, handler)
+		}
+		if ok := compare(d.Method, method); !ok {
+			t.Fatalf("expected %v got %v", d.Method, method)
+		}
+		if ok := compare(d.Path, path); !ok {
+			t.Fatalf("expected %v got %v", d.Path, path)
+		}
+		if ok := compare(d.Host, host); !ok {
+			t.Fatalf("expected %v got %v", d.Host, host)
+		}
+
+		if de.Name != d.Name {
+			t.Fatalf("expected %v got %v", d.Name, de.Name)
+		}
+		if de.Description != d.Description {
+			t.Fatalf("expected %v got %v", d.Description, de.Description)
+		}
+		if de.Handler != d.Handler {
+			t.Fatalf("expected %v got %v", d.Handler, de.Handler)
+		}
+		if ok := compare(d.Method, de.Method); !ok {
+			t.Fatalf("expected %v got %v", d.Method, de.Method)
+		}
+		if ok := compare(d.Path, de.Path); !ok {
+			t.Fatalf("expected %v got %v", d.Path, de.Path)
+		}
+		if ok := compare(d.Host, de.Host); !ok {
+			t.Fatalf("expected %v got %v", d.Host, de.Host)
+		}
+	}
+}
+
+func TestValidate(t *testing.T) {
+	epPcre := &Endpoint{
+		Name:        "Foo.Bar",
+		Description: "A test endpoint",
+		Handler:     "meta",
+		Host:        []string{"foo.com"},
+		Method:      []string{"GET"},
+		Path:        []string{"^/test/?$"},
+	}
+	if err := Validate(epPcre); err != nil {
+		t.Fatal(err)
+	}
+
+	epGpath := &Endpoint{
+		Name:        "Foo.Bar",
+		Description: "A test endpoint",
+		Handler:     "meta",
+		Host:        []string{"foo.com"},
+		Method:      []string{"GET"},
+		Path:        []string{"/test/{id}"},
+	}
+	if err := Validate(epGpath); err != nil {
+		t.Fatal(err)
+	}
+
+	epPcreInvalid := &Endpoint{
+		Name:        "Foo.Bar",
+		Description: "A test endpoint",
+		Handler:     "meta",
+		Host:        []string{"foo.com"},
+		Method:      []string{"GET"},
+		Path:        []string{"/test/?$"},
+	}
+	if err := Validate(epPcreInvalid); err == nil {
+		t.Fatalf("invalid pcre %v", epPcreInvalid.Path[0])
+	}
+}

api/handler/handler.go

@@ -0,0 +1,14 @@
+// Package handler provides http handlers
+package handler // import "go.unistack.org/micro/v3/api/handler"
+
+import (
+	"net/http"
+)
+
+// Handler represents a HTTP handler that manages a request
+type Handler interface {
+	// standard http handler
+	http.Handler
+	// name of handler
+	String() string
+}

api/handler/options.go

@@ -0,0 +1,70 @@
+package handler
+
+import (
+	"go.unistack.org/micro/v3/api/router"
+	"go.unistack.org/micro/v3/client"
+	"go.unistack.org/micro/v3/logger"
+)
+
+// DefaultMaxRecvSize specifies max recv size for handler
+var DefaultMaxRecvSize int64 = 1024 * 1024 * 100 // 10Mb
+
+// Options struct holds handler options
+type Options struct {
+	Router      router.Router
+	Client      client.Client
+	Logger      logger.Logger
+	Namespace   string
+	MaxRecvSize int64
+}
+
+// Option func signature
+type Option func(o *Options)
+
+// NewOptions creates new options struct and fills it
+func NewOptions(opts ...Option) Options {
+	options := Options{
+		Client:      client.DefaultClient,
+		Router:      router.DefaultRouter,
+		Logger:      logger.DefaultLogger,
+		MaxRecvSize: DefaultMaxRecvSize,
+	}
+	for _, o := range opts {
+		o(&options)
+	}
+
+	// set namespace if blank
+	if len(options.Namespace) == 0 {
+		WithNamespace("go.micro.api")(&options)
+	}
+
+	return options
+}
+
+// WithNamespace specifies the namespace for the handler
+func WithNamespace(s string) Option {
+	return func(o *Options) {
+		o.Namespace = s
+	}
+}
+
+// WithRouter specifies a router to be used by the handler
+func WithRouter(r router.Router) Option {
+	return func(o *Options) {
+		o.Router = r
+	}
+}
+
+// WithClient specifies client to be used by the handler
+func WithClient(c client.Client) Option {
+	return func(o *Options) {
+		o.Client = c
+	}
+}
+
+// WithMaxRecvSize specifies max body size
+func WithMaxRecvSize(size int64) Option {
+	return func(o *Options) {
+		o.MaxRecvSize = size
+	}
+}

api/resolver/grpc/grpc.go

@@ -0,0 +1,47 @@
+// Package grpc resolves a grpc service like /greeter.Say/Hello to greeter service
+package grpc // import "go.unistack.org/micro/v3/api/resolver/grpc"
+
+import (
+	"errors"
+	"net/http"
+	"strings"
+
+	"go.unistack.org/micro/v3/api/resolver"
+)
+
+// Resolver struct
+type Resolver struct {
+	opts resolver.Options
+}
+
+// Resolve func to resolve enndpoint
+func (r *Resolver) Resolve(req *http.Request, opts ...resolver.ResolveOption) (*resolver.Endpoint, error) {
+	// parse options
+	options := resolver.NewResolveOptions(opts...)
+
+	// /foo.Bar/Service
+	if req.URL.Path == "/" {
+		return nil, errors.New("unknown name")
+	}
+	// [foo.Bar, Service]
+	parts := strings.Split(req.URL.Path[1:], "/")
+	// [foo, Bar]
+	name := strings.Split(parts[0], ".")
+	// foo
+	return &resolver.Endpoint{
+		Name:   strings.Join(name[:len(name)-1], "."),
+		Host:   req.Host,
+		Method: req.Method,
+		Path:   req.URL.Path,
+		Domain: options.Domain,
+	}, nil
+}
+
+func (r *Resolver) String() string {
+	return "grpc"
+}
+
+// NewResolver is used to create new Resolver
+func NewResolver(opts ...resolver.Option) resolver.Resolver {
+	return &Resolver{opts: resolver.NewOptions(opts...)}
+}

api/resolver/host/host.go

@@ -0,0 +1,35 @@
+// Package host resolves using http host
+package host // import "go.unistack.org/micro/v3/api/resolver/host"
+
+import (
+	"net/http"
+
+	"go.unistack.org/micro/v3/api/resolver"
+)
+
+type hostResolver struct {
+	opts resolver.Options
+}
+
+// Resolve endpoint
+func (r *hostResolver) Resolve(req *http.Request, opts ...resolver.ResolveOption) (*resolver.Endpoint, error) {
+	// parse options
+	options := resolver.NewResolveOptions(opts...)
+
+	return &resolver.Endpoint{
+		Name:   req.Host,
+		Host:   req.Host,
+		Method: req.Method,
+		Path:   req.URL.Path,
+		Domain: options.Domain,
+	}, nil
+}
+
+func (r *hostResolver) String() string {
+	return "host"
+}
+
+// NewResolver creates new host api resolver
+func NewResolver(opts ...resolver.Option) resolver.Resolver {
+	return &hostResolver{opts: resolver.NewOptions(opts...)}
+}

api/resolver/options.go

@@ -0,0 +1,70 @@
+package resolver
+
+import (
+	"context"
+
+	"go.unistack.org/micro/v3/register"
+)
+
+// Options struct
+type Options struct {
+	// Context is for external defined options
+	Context context.Context
+	// Handler name
+	Handler string
+	// ServicePrefix is the prefix
+	ServicePrefix string
+}
+
+// Option func
+type Option func(o *Options)
+
+// WithHandler sets the handler being used
+func WithHandler(h string) Option {
+	return func(o *Options) {
+		o.Handler = h
+	}
+}
+
+// WithServicePrefix sets the ServicePrefix option
+func WithServicePrefix(p string) Option {
+	return func(o *Options) {
+		o.ServicePrefix = p
+	}
+}
+
+// NewOptions returns new initialised options
+func NewOptions(opts ...Option) Options {
+	options := Options{
+		Context: context.Background(),
+	}
+	for _, o := range opts {
+		o(&options)
+	}
+	return options
+}
+
+// ResolveOptions are used when resolving a request
+type ResolveOptions struct {
+	Domain string
+}
+
+// ResolveOption sets an option
+type ResolveOption func(*ResolveOptions)
+
+// Domain sets the resolve Domain option
+func Domain(n string) ResolveOption {
+	return func(o *ResolveOptions) {
+		o.Domain = n
+	}
+}
+
+// NewResolveOptions returns new initialised resolve options
+func NewResolveOptions(opts ...ResolveOption) ResolveOptions {
+	options := ResolveOptions{Domain: register.DefaultDomain}
+	for _, o := range opts {
+		o(&options)
+	}
+
+	return options
+}

api/resolver/path/path.go

@@ -0,0 +1,44 @@
+// Package path resolves using http path
+package path // import "go.unistack.org/micro/v3/api/resolver/path"
+
+import (
+	"net/http"
+	"strings"
+
+	"go.unistack.org/micro/v3/api/resolver"
+)
+
+// Resolver the path resolver
+type Resolver struct {
+	opts resolver.Options
+}
+
+// Resolve resolves endpoint
+func (r *Resolver) Resolve(req *http.Request, opts ...resolver.ResolveOption) (*resolver.Endpoint, error) {
+	// parse options
+	options := resolver.NewResolveOptions(opts...)
+
+	if req.URL.Path == "/" {
+		return nil, resolver.ErrNotFound
+	}
+
+	parts := strings.Split(req.URL.Path[1:], "/")
+
+	return &resolver.Endpoint{
+		Name:   r.opts.ServicePrefix + "." + parts[0],
+		Host:   req.Host,
+		Method: req.Method,
+		Path:   req.URL.Path,
+		Domain: options.Domain,
+	}, nil
+}
+
+// String retruns the string representation
+func (r *Resolver) String() string {
+	return "path"
+}
+
+// NewResolver returns new path resolver
+func NewResolver(opts ...resolver.Option) resolver.Resolver {
+	return &Resolver{opts: resolver.NewOptions(opts...)}
+}

api/resolver/resolver.go

@@ -0,0 +1,34 @@
+// Package resolver resolves a http request to an endpoint
+package resolver // import "go.unistack.org/micro/v3/api/resolver"
+
+import (
+	"errors"
+	"net/http"
+)
+
+var (
+	// ErrNotFound returned when endpoint is not found
+	ErrNotFound = errors.New("not found")
+	// ErrInvalidPath returned on invalid path
+	ErrInvalidPath = errors.New("invalid path")
+)
+
+// Resolver resolves requests to endpoints
+type Resolver interface {
+	Resolve(r *http.Request, opts ...ResolveOption) (*Endpoint, error)
+	String() string
+}
+
+// Endpoint is the endpoint for a http request
+type Endpoint struct {
+	// Endpoint name e.g greeter
+	Name string
+	// HTTP Host e.g example.com
+	Host string
+	// HTTP Methods e.g GET, POST
+	Method string
+	// HTTP Path e.g /greeter.
+	Path string
+	// Domain endpoint exists within
+	Domain string
+}

api/resolver/subdomain/subdomain.go

@@ -0,0 +1,90 @@
+// Package subdomain is a resolver which uses the subdomain to determine the domain to route to. It
+// offloads the endpoint resolution to a child resolver which is provided in New.
+package subdomain // import "go.unistack.org/micro/v3/api/resolver/subdomain"
+
+import (
+	"net"
+	"net/http"
+	"strings"
+
+	"go.unistack.org/micro/v3/api/resolver"
+	"go.unistack.org/micro/v3/logger"
+	"golang.org/x/net/publicsuffix"
+)
+
+// NewResolver creates new subdomain api resolver
+func NewResolver(parent resolver.Resolver, opts ...resolver.Option) resolver.Resolver {
+	options := resolver.NewOptions(opts...)
+	return &subdomainResolver{opts: options, Resolver: parent}
+}
+
+type subdomainResolver struct {
+	resolver.Resolver
+	opts resolver.Options
+}
+
+// Resolve resolve endpoint based on subdomain
+func (r *subdomainResolver) Resolve(req *http.Request, opts ...resolver.ResolveOption) (*resolver.Endpoint, error) {
+	if dom := r.Domain(req); len(dom) > 0 {
+		opts = append(opts, resolver.Domain(dom))
+	}
+
+	return r.Resolver.Resolve(req, opts...)
+}
+
+// Domain returns domain
+func (r *subdomainResolver) Domain(req *http.Request) string {
+	// determine the host, e.g. foobar.m3o.app
+	host := req.URL.Hostname()
+	if len(host) == 0 {
+		if h, _, err := net.SplitHostPort(req.Host); err == nil {
+			host = h // host does contain a port
+		} else if strings.Contains(err.Error(), "missing port in address") {
+			host = req.Host // host does not contain a port
+		}
+	}
+
+	// check for an ip address
+	if net.ParseIP(host) != nil {
+		return ""
+	}
+
+	// check for dev environment
+	if host == "localhost" || host == "127.0.0.1" {
+		return ""
+	}
+
+	// extract the top level domain plus one (e.g. 'myapp.com')
+	domain, err := publicsuffix.EffectiveTLDPlusOne(host)
+	if err != nil {
+		if logger.V(logger.DebugLevel) {
+			logger.Debug(r.opts.Context, "Unable to extract domain from %v", host)
+		}
+		return ""
+	}
+
+	// there was no subdomain
+	if host == domain {
+		return ""
+	}
+
+	// remove the domain from the host, leaving the subdomain, e.g. "staging.foo.myapp.com" => "staging.foo"
+	subdomain := strings.TrimSuffix(host, "."+domain)
+
+	// ignore the API subdomain
+	if subdomain == "api" {
+		return ""
+	}
+
+	// return the reversed subdomain as the namespace, e.g. "staging.foo" => "foo-staging"
+	comps := strings.Split(subdomain, ".")
+	for i := len(comps)/2 - 1; i >= 0; i-- {
+		opp := len(comps) - 1 - i
+		comps[i], comps[opp] = comps[opp], comps[i]
+	}
+	return strings.Join(comps, "-")
+}
+
+func (r *subdomainResolver) String() string {
+	return "subdomain"
+}

api/resolver/subdomain/subdomain_test.go

@@ -0,0 +1,73 @@
+package subdomain
+
+import (
+	"net/http"
+	"net/url"
+	"testing"
+
+	"go.unistack.org/micro/v3/api/resolver/vpath"
+)
+
+func TestResolve(t *testing.T) {
+	tt := []struct {
+		Name   string
+		Host   string
+		Result string
+	}{
+		{
+			Name:   "Top level domain",
+			Host:   "micro.mu",
+			Result: "micro",
+		},
+		{
+			Name:   "Effective top level domain",
+			Host:   "micro.com.au",
+			Result: "micro",
+		},
+		{
+			Name:   "Subdomain dev",
+			Host:   "dev.micro.mu",
+			Result: "dev",
+		},
+		{
+			Name:   "Subdomain foo",
+			Host:   "foo.micro.mu",
+			Result: "foo",
+		},
+		{
+			Name:   "Multi-level subdomain",
+			Host:   "staging.myapp.m3o.app",
+			Result: "myapp-staging",
+		},
+		{
+			Name:   "Dev host",
+			Host:   "127.0.0.1",
+			Result: "micro",
+		},
+		{
+			Name:   "Localhost",
+			Host:   "localhost",
+			Result: "micro",
+		},
+		{
+			Name:   "IP host",
+			Host:   "81.151.101.146",
+			Result: "micro",
+		},
+	}
+
+	for _, tc := range tt {
+		t.Run(tc.Name, func(t *testing.T) {
+			r := NewResolver(vpath.NewResolver())
+			result, err := r.Resolve(&http.Request{URL: &url.URL{Host: tc.Host, Path: "foo/bar"}})
+			if err != nil {
+				t.Fatal(err)
+			}
+			if result != nil {
+				if tc.Result != result.Domain {
+					t.Fatalf("Expected %v but got %v", tc.Result, result.Domain)
+				}
+			}
+		})
+	}
+}

api/resolver/vpath/vpath.go

@@ -0,0 +1,75 @@
+// Package vpath resolves using http path and recognised versioned urls
+package vpath // import "go.unistack.org/micro/v3/api/resolver/vpath"
+
+import (
+	"errors"
+	"net/http"
+	"regexp"
+	"strings"
+
+	"go.unistack.org/micro/v3/api/resolver"
+)
+
+// NewResolver creates new vpath api resolver
+func NewResolver(opts ...resolver.Option) resolver.Resolver {
+	return &vpathResolver{opts: resolver.NewOptions(opts...)}
+}
+
+type vpathResolver struct {
+	opts resolver.Options
+}
+
+var re = regexp.MustCompile("^v[0-9]+$")
+
+// Resolve endpoint
+func (r *vpathResolver) Resolve(req *http.Request, opts ...resolver.ResolveOption) (*resolver.Endpoint, error) {
+	if req.URL.Path == "/" {
+		return nil, errors.New("unknown name")
+	}
+
+	options := resolver.NewResolveOptions(opts...)
+
+	parts := strings.Split(req.URL.Path[1:], "/")
+	if len(parts) == 1 {
+		return &resolver.Endpoint{
+			Name:   r.withPrefix(parts...),
+			Host:   req.Host,
+			Method: req.Method,
+			Path:   req.URL.Path,
+			Domain: options.Domain,
+		}, nil
+	}
+
+	// /v1/foo
+	if re.MatchString(parts[0]) {
+		return &resolver.Endpoint{
+			Name:   r.withPrefix(parts[0:2]...),
+			Host:   req.Host,
+			Method: req.Method,
+			Path:   req.URL.Path,
+			Domain: options.Domain,
+		}, nil
+	}
+
+	return &resolver.Endpoint{
+		Name:   r.withPrefix(parts[0]),
+		Host:   req.Host,
+		Method: req.Method,
+		Path:   req.URL.Path,
+		Domain: options.Domain,
+	}, nil
+}
+
+func (r *vpathResolver) String() string {
+	return "vpath"
+}
+
+// withPrefix transforms "foo" into "go.micro.api.foo"
+func (r *vpathResolver) withPrefix(parts ...string) string {
+	p := r.opts.ServicePrefix
+	if len(p) > 0 {
+		parts = append([]string{p}, parts...)
+	}
+
+	return strings.Join(parts, ".")
+}

api/router/options.go

@@ -0,0 +1,75 @@
+package router
+
+import (
+	"context"
+
+	"go.unistack.org/micro/v3/api/resolver"
+	"go.unistack.org/micro/v3/api/resolver/vpath"
+	"go.unistack.org/micro/v3/logger"
+	"go.unistack.org/micro/v3/register"
+)
+
+// Options holds the options for api router
+type Options struct {
+	// Register for service lookup
+	Register register.Register
+	// Resolver to use
+	Resolver resolver.Resolver
+	// Logger micro logger
+	Logger logger.Logger
+	// Context is for external options
+	Context context.Context
+	// Handler name
+	Handler string
+}
+
+// Option func signature
+type Option func(o *Options)
+
+// NewOptions returns options struct filled by opts
+func NewOptions(opts ...Option) Options {
+	options := Options{
+		Context: context.Background(),
+		Handler: "meta",
+	}
+
+	for _, o := range opts {
+		o(&options)
+	}
+
+	if options.Resolver == nil {
+		options.Resolver = vpath.NewResolver(
+			resolver.WithHandler(options.Handler),
+		)
+	}
+
+	return options
+}
+
+// WithContext sets the context
+func WithContext(ctx context.Context) Option {
+	return func(o *Options) {
+		o.Context = ctx
+	}
+}
+
+// WithHandler sets the handler
+func WithHandler(h string) Option {
+	return func(o *Options) {
+		o.Handler = h
+	}
+}
+
+// WithRegister sets the register
+func WithRegister(r register.Register) Option {
+	return func(o *Options) {
+		o.Register = r
+	}
+}
+
+// WithResolver sets the resolver
+func WithResolver(r resolver.Resolver) Option {
+	return func(o *Options) {
+		o.Resolver = r
+	}
+}

api/router/router.go

@@ -0,0 +1,31 @@
+// Package router provides api service routing
+package router // import "go.unistack.org/micro/v3/api/router"
+
+import (
+	"net/http"
+
+	"go.unistack.org/micro/v3/api"
+)
+
+// DefaultRouter contains default router implementation
+var DefaultRouter Router
+
+// Router is used to determine an endpoint for a request
+type Router interface {
+	// Returns options
+	Options() Options
+	// Init initialize router
+	Init(...Option) error
+	// Stop the router
+	Close() error
+	// Endpoint returns an api.Service endpoint or an error if it does not exist
+	Endpoint(r *http.Request) (*api.Service, error)
+	// Register endpoint in router
+	Register(ep *api.Endpoint) error
+	// Deregister endpoint from router
+	Deregister(ep *api.Endpoint) error
+	// Route returns an api.Service route
+	Route(r *http.Request) (*api.Service, error)
+	// String representation of router
+	String() string
+}

auth/auth.go

@@ -0,0 +1,141 @@
+// Package auth provides authentication and authorization capability
+package auth // import "go.unistack.org/micro/v3/auth"
+
+import (
+	"context"
+	"errors"
+	"time"
+
+	"go.unistack.org/micro/v3/metadata"
+)
+
+const (
+	// BearerScheme used for Authorization header
+	BearerScheme = "Bearer "
+	// ScopePublic is the scope applied to a rule to allow access to the public
+	ScopePublic = ""
+	// ScopeAccount is the scope applied to a rule to limit to users with any valid account
+	ScopeAccount = "*"
+)
+
+var (
+	// DefaultAuth holds default auth implementation
+	DefaultAuth Auth = NewAuth()
+	// ErrInvalidToken is when the token provided is not valid
+	ErrInvalidToken = errors.New("invalid token provided")
+	// ErrForbidden is when a user does not have the necessary scope to access a resource
+	ErrForbidden = errors.New("resource forbidden")
+)
+
+// Auth provides authentication and authorization
+type Auth interface {
+	// Init the auth
+	Init(opts ...Option) error
+	// Options set for auth
+	Options() Options
+	// Generate a new account
+	Generate(id string, opts ...GenerateOption) (*Account, error)
+	// Verify an account has access to a resource using the rules
+	Verify(acc *Account, res *Resource, opts ...VerifyOption) error
+	// Inspect a token
+	Inspect(token string) (*Account, error)
+	// Token generated using refresh token or credentials
+	Token(opts ...TokenOption) (*Token, error)
+	// Grant access to a resource
+	Grant(rule *Rule) error
+	// Revoke access to a resource
+	Revoke(rule *Rule) error
+	// Rules returns all the rules used to verify requests
+	Rules(...RulesOption) ([]*Rule, error)
+	// String returns the name of the implementation
+	String() string
+}
+
+// Account provided by an auth provider
+type Account struct {
+	// Metadata any other associated metadata
+	Metadata metadata.Metadata `json:"metadata"`
+	// ID of the account e.g. email or id
+	ID string `json:"id"`
+	// Type of the account, e.g. service
+	Type string `json:"type"`
+	// Issuer of the account
+	Issuer string `json:"issuer"`
+	// Secret for the account, e.g. the password
+	Secret string `json:"secret"`
+	// Scopes the account has access to
+	Scopes []string `json:"scopes"`
+}
+
+// Token can be short or long lived
+type Token struct {
+	// Time of token creation
+	Created time.Time `json:"created"`
+	// Time of token expiry
+	Expiry time.Time `json:"expiry"`
+	// The token to be used for accessing resources
+	AccessToken string `json:"access_token"`
+	// RefreshToken to be used to generate a new token
+	RefreshToken string `json:"refresh_token"`
+}
+
+// Expired returns a boolean indicating if the token needs to be refreshed
+func (t *Token) Expired() bool {
+	return t.Expiry.Unix() < time.Now().Unix()
+}
+
+// Resource is an entity such as a user or
+type Resource struct {
+	// Name of the resource, e.g. go.micro.service.notes
+	Name string `json:"name"`
+	// Type of resource, e.g. service
+	Type string `json:"type"`
+	// Endpoint resource e.g NotesService.Create
+	Endpoint string `json:"endpoint"`
+}
+
+// Access defines the type of access a rule grants
+type Access int
+
+const (
+	// AccessGranted to a resource
+	AccessGranted Access = iota
+	// AccessDenied to a resource
+	AccessDenied
+)
+
+// Rule is used to verify access to a resource
+type Rule struct {
+	// Resource that rule belongs to
+	Resource *Resource
+	// ID of the rule
+	ID string
+	// Scope of the rule
+	Scope string
+	// Access flag allow/deny
+	Access Access
+	// Priority holds the rule priority
+	Priority int32
+}
+
+type accountKey struct{}
+
+// AccountFromContext gets the account from the context, which
+// is set by the auth wrapper at the start of a call. If the account
+// is not set, a nil account will be returned. The error is only returned
+// when there was a problem retrieving an account
+func AccountFromContext(ctx context.Context) (*Account, bool) {
+	if ctx == nil {
+		return nil, false
+	}
+	acc, ok := ctx.Value(accountKey{}).(*Account)
+	return acc, ok
+}
+
+// ContextWithAccount sets the account in the context
+func ContextWithAccount(ctx context.Context, account *Account) context.Context {
+	if ctx == nil {
+		ctx = context.Background()
+	}
+	return context.WithValue(ctx, accountKey{}, account)
+}

auth/noop.go

@@ -0,0 +1,79 @@
+package auth
+
+import (
+	"go.unistack.org/micro/v3/util/id"
+)
+
+type noopAuth struct {
+	opts Options
+}
+
+// String returns the name of the implementation
+func (n *noopAuth) String() string {
+	return "noop"
+}
+
+// Init the auth
+func (n *noopAuth) Init(opts ...Option) error {
+	for _, o := range opts {
+		o(&n.opts)
+	}
+	return nil
+}
+
+// Options set for auth
+func (n *noopAuth) Options() Options {
+	return n.opts
+}
+
+// Generate a new account
+func (n *noopAuth) Generate(id string, opts ...GenerateOption) (*Account, error) {
+	options := NewGenerateOptions(opts...)
+
+	return &Account{
+		ID:       id,
+		Secret:   options.Secret,
+		Metadata: options.Metadata,
+		Scopes:   options.Scopes,
+		Issuer:   n.Options().Issuer,
+	}, nil
+}
+
+// Grant access to a resource
+func (n *noopAuth) Grant(rule *Rule) error {
+	return nil
+}
+
+// Revoke access to a resource
+func (n *noopAuth) Revoke(rule *Rule) error {
+	return nil
+}
+
+// Rules used to verify requests
+func (n *noopAuth) Rules(opts ...RulesOption) ([]*Rule, error) {
+	return []*Rule{}, nil
+}
+
+// Verify an account has access to a resource
+func (n *noopAuth) Verify(acc *Account, res *Resource, opts ...VerifyOption) error {
+	return nil
+}
+
+// Inspect a token
+func (n *noopAuth) Inspect(token string) (*Account, error) {
+	id, err := id.New()
+	if err != nil {
+		return nil, err
+	}
+	return &Account{ID: id, Issuer: n.Options().Issuer}, nil
+}
+
+// Token generation using an account id and secret
+func (n *noopAuth) Token(opts ...TokenOption) (*Token, error) {
+	return &Token{}, nil
+}
+
+// NewAuth returns new noop auth
+func NewAuth(opts ...Option) Auth {
+	return &noopAuth{opts: NewOptions(opts...)}
+}

auth/options.go

@@ -0,0 +1,311 @@
+package auth
+
+import (
+	"context"
+	"time"
+
+	"go.unistack.org/micro/v3/logger"
+	"go.unistack.org/micro/v3/metadata"
+	"go.unistack.org/micro/v3/meter"
+	"go.unistack.org/micro/v3/store"
+	"go.unistack.org/micro/v3/tracer"
+)
+
+// NewOptions creates Options struct from slice of options
+func NewOptions(opts ...Option) Options {
+	options := Options{
+		Tracer: tracer.DefaultTracer,
+		Logger: logger.DefaultLogger,
+		Meter:  meter.DefaultMeter,
+	}
+	for _, o := range opts {
+		o(&options)
+	}
+	return options
+}
+
+// Options struct holds auth options
+type Options struct {
+	// Context holds the external options
+	Context context.Context
+	// Meter used for metrics
+	Meter meter.Meter
+	// Logger used for logging
+	Logger logger.Logger
+	// Tracer used for tracing
+	Tracer tracer.Tracer
+	// Store used for stre data
+	Store store.Store
+	// Token is the services token used to authenticate itself
+	Token *Token
+	// LoginURL is the relative url path where a user can login
+	LoginURL string
+	// PrivateKey for encoding JWTs
+	PrivateKey string
+	// PublicKey for decoding JWTs
+	PublicKey string
+	// Secret is used to authenticate the service
+	Secret string
+	// ID is the services auth ID
+	ID string
+	// Issuer of the service's account
+	Issuer string
+	// Name holds the auth name
+	Name string
+	// Addrs sets the addresses of auth
+	Addrs []string
+}
+
+// Option func
+type Option func(o *Options)
+
+// Addrs is the auth addresses to use
+func Addrs(addrs ...string) Option {
+	return func(o *Options) {
+		o.Addrs = addrs
+	}
+}
+
+// Name sets the name
+func Name(n string) Option {
+	return func(o *Options) {
+		o.Name = n
+	}
+}
+
+// Issuer of the services account
+func Issuer(i string) Option {
+	return func(o *Options) {
+		o.Issuer = i
+	}
+}
+
+// Store to back auth
+func Store(s store.Store) Option {
+	return func(o *Options) {
+		o.Store = s
+	}
+}
+
+// PublicKey is the JWT public key
+func PublicKey(key string) Option {
+	return func(o *Options) {
+		o.PublicKey = key
+	}
+}
+
+// PrivateKey is the JWT private key
+func PrivateKey(key string) Option {
+	return func(o *Options) {
+		o.PrivateKey = key
+	}
+}
+
+// Credentials sets the auth credentials
+func Credentials(id, secret string) Option {
+	return func(o *Options) {
+		o.ID = id
+		o.Secret = secret
+	}
+}
+
+// ClientToken sets the auth token to use when making requests
+func ClientToken(token *Token) Option {
+	return func(o *Options) {
+		o.Token = token
+	}
+}
+
+// LoginURL sets the auth LoginURL
+func LoginURL(url string) Option {
+	return func(o *Options) {
+		o.LoginURL = url
+	}
+}
+
+// GenerateOptions struct
+type GenerateOptions struct {
+	Metadata metadata.Metadata
+	Provider string
+	Type     string
+	Secret   string
+	Issuer   string
+	Scopes   []string
+}
+
+// GenerateOption func
+type GenerateOption func(o *GenerateOptions)
+
+// WithSecret for the generated account
+func WithSecret(s string) GenerateOption {
+	return func(o *GenerateOptions) {
+		o.Secret = s
+	}
+}
+
+// WithType for the generated account
+func WithType(t string) GenerateOption {
+	return func(o *GenerateOptions) {
+		o.Type = t
+	}
+}
+
+// WithMetadata for the generated account
+func WithMetadata(md metadata.Metadata) GenerateOption {
+	return func(o *GenerateOptions) {
+		o.Metadata = metadata.Copy(md)
+	}
+}
+
+// WithProvider for the generated account
+func WithProvider(p string) GenerateOption {
+	return func(o *GenerateOptions) {
+		o.Provider = p
+	}
+}
+
+// WithScopes for the generated account
+func WithScopes(s ...string) GenerateOption {
+	return func(o *GenerateOptions) {
+		o.Scopes = s
+	}
+}
+
+// WithIssuer for the generated account
+func WithIssuer(i string) GenerateOption {
+	return func(o *GenerateOptions) {
+		o.Issuer = i
+	}
+}
+
+// NewGenerateOptions from a slice of options
+func NewGenerateOptions(opts ...GenerateOption) GenerateOptions {
+	var options GenerateOptions
+	for _, o := range opts {
+		o(&options)
+	}
+	return options
+}
+
+// TokenOptions struct
+type TokenOptions struct {
+	ID           string
+	Secret       string
+	RefreshToken string
+	Issuer       string
+	Expiry       time.Duration
+}
+
+// TokenOption func
+type TokenOption func(o *TokenOptions)
+
+// WithExpiry for the token
+func WithExpiry(ex time.Duration) TokenOption {
+	return func(o *TokenOptions) {
+		o.Expiry = ex
+	}
+}
+
+// WithCredentials sets tye id and secret
+func WithCredentials(id, secret string) TokenOption {
+	return func(o *TokenOptions) {
+		o.ID = id
+		o.Secret = secret
+	}
+}
+
+// WithToken sets the refresh token
+func WithToken(rt string) TokenOption {
+	return func(o *TokenOptions) {
+		o.RefreshToken = rt
+	}
+}
+
+// WithTokenIssuer sets the token issuer option
+func WithTokenIssuer(iss string) TokenOption {
+	return func(o *TokenOptions) {
+		o.Issuer = iss
+	}
+}
+
+// NewTokenOptions from a slice of options
+func NewTokenOptions(opts ...TokenOption) TokenOptions {
+	var options TokenOptions
+	for _, o := range opts {
+		o(&options)
+	}
+
+	// set default expiry of token
+	if options.Expiry == 0 {
+		options.Expiry = time.Minute
+	}
+
+	return options
+}
+
+// VerifyOptions struct
+type VerifyOptions struct {
+	Context   context.Context
+	Namespace string
+}
+
+// VerifyOption func
+type VerifyOption func(o *VerifyOptions)
+
+// VerifyContext pass context to verify
+func VerifyContext(ctx context.Context) VerifyOption {
+	return func(o *VerifyOptions) {
+		o.Context = ctx
+	}
+}
+
+// VerifyNamespace sets thhe namespace for verify
+func VerifyNamespace(ns string) VerifyOption {
+	return func(o *VerifyOptions) {
+		o.Namespace = ns
+	}
+}
+
+// RulesOptions struct
+type RulesOptions struct {
+	Context   context.Context
+	Namespace string
+}
+
+// RulesOption func
+type RulesOption func(o *RulesOptions)
+
+// RulesContext pass rules context
+func RulesContext(ctx context.Context) RulesOption {
+	return func(o *RulesOptions) {
+		o.Context = ctx
+	}
+}
+
+// RulesNamespace sets the rule namespace
+func RulesNamespace(ns string) RulesOption {
+	return func(o *RulesOptions) {
+		o.Namespace = ns
+	}
+}
+
+// Logger sets the logger
+func Logger(l logger.Logger) Option {
+	return func(o *Options) {
+		o.Logger = l
+	}
+}
+
+// Meter sets the meter
+func Meter(m meter.Meter) Option {
+	return func(o *Options) {
+		o.Meter = m
+	}
+}
+
+// Tracer sets the meter
+func Tracer(t tracer.Tracer) Option {
+	return func(o *Options) {
+		o.Tracer = t
+	}
+}

auth/rules.go

@@ -0,0 +1,92 @@
+package auth
+
+import (
+	"fmt"
+	"sort"
+	"strings"
+)
+
+// VerifyAccess an account has access to a resource using the rules provided. If the account does not have
+// access an error will be returned. If there are no rules provided which match the resource, an error
+// will be returned
+//nolint:gocyclo
+func VerifyAccess(rules []*Rule, acc *Account, res *Resource) error {
+	// the rule is only to be applied if the type matches the resource or is catch-all (*)
+	validTypes := []string{"*", res.Type}
+
+	// the rule is only to be applied if the name matches the resource or is catch-all (*)
+	validNames := []string{"*", res.Name}
+
+	// rules can have wildcard excludes on endpoints since this can also be a path for web services,
+	// e.g. /foo/* would include /foo/bar. We also want to check for wildcards and the exact endpoint
+	validEndpoints := []string{"*", res.Endpoint}
+	if comps := strings.Split(res.Endpoint, "/"); len(comps) > 1 {
+		for i := 1; i < len(comps)+1; i++ {
+			wildcard := fmt.Sprintf("%v/*", strings.Join(comps[0:i], "/"))
+			validEndpoints = append(validEndpoints, wildcard)
+		}
+	}
+
+	// filter the rules to the ones which match the criteria above
+	filteredRules := make([]*Rule, 0)
+	for _, rule := range rules {
+		if !include(validTypes, rule.Resource.Type) {
+			continue
+		}
+		if !include(validNames, rule.Resource.Name) {
+			continue
+		}
+		if !include(validEndpoints, rule.Resource.Endpoint) {
+			continue
+		}
+		filteredRules = append(filteredRules, rule)
+	}
+
+	// sort the filtered rules by priority, highest to lowest
+	sort.SliceStable(filteredRules, func(i, j int) bool {
+		return filteredRules[i].Priority > filteredRules[j].Priority
+	})
+
+	// loop through the rules and check for a rule which applies to this account
+	for _, rule := range filteredRules {
+		// a blank scope indicates the rule applies to everyone, even nil accounts
+		if rule.Scope == ScopePublic && rule.Access == AccessDenied {
+			return ErrForbidden
+		} else if rule.Scope == ScopePublic && rule.Access == AccessGranted {
+			return nil
+		}
+
+		// all further checks require an account
+		if acc == nil {
+			continue
+		}
+
+		// this rule applies to any account
+		if rule.Scope == ScopeAccount && rule.Access == AccessDenied {
+			return ErrForbidden
+		} else if rule.Scope == ScopeAccount && rule.Access == AccessGranted {
+			return nil
+		}
+
+		// if the account has the necessary scope
+		if include(acc.Scopes, rule.Scope) && rule.Access == AccessDenied {
+			return ErrForbidden
+		} else if include(acc.Scopes, rule.Scope) && rule.Access == AccessGranted {
+			return nil
+		}
+	}
+
+	// if no rules matched then return forbidden
+	return ErrForbidden
+}
+
+// include is a helper function which checks to see if the slice contains the value. includes is
+// not case sensitive.
+func include(slice []string, val string) bool {
+	for _, s := range slice {
+		if strings.EqualFold(s, val) {
+			return true
+		}
+	}
+	return false
+}

auth/rules_test.go

@@ -0,0 +1,288 @@
+package auth
+
+import (
+	"testing"
+)
+
+func TestVerify(t *testing.T) {
+	srvResource := &Resource{
+		Type:     "service",
+		Name:     "go.micro.service.foo",
+		Endpoint: "Foo.Bar",
+	}
+
+	webResource := &Resource{
+		Type:     "service",
+		Name:     "go.micro.web.foo",
+		Endpoint: "/foo/bar",
+	}
+
+	catchallResource := &Resource{
+		Type:     "*",
+		Name:     "*",
+		Endpoint: "*",
+	}
+
+	tt := []struct {
+		Error    error
+		Account  *Account
+		Resource *Resource
+		Name     string
+		Rules    []*Rule
+	}{
+		{
+			Name:     "NoRules",
+			Rules:    []*Rule{},
+			Account:  nil,
+			Resource: srvResource,
+			Error:    ErrForbidden,
+		},
+		{
+			Name:     "CatchallPublicAccount",
+			Account:  &Account{},
+			Resource: srvResource,
+			Rules: []*Rule{
+				{
+					Scope:    "",
+					Resource: catchallResource,
+				},
+			},
+		},
+		{
+			Name:     "CatchallPublicNoAccount",
+			Resource: srvResource,
+			Rules: []*Rule{
+				{
+					Scope:    "",
+					Resource: catchallResource,
+				},
+			},
+		},
+		{
+			Name:     "CatchallPrivateAccount",
+			Account:  &Account{},
+			Resource: srvResource,
+			Rules: []*Rule{
+				{
+					Scope:    "*",
+					Resource: catchallResource,
+				},
+			},
+		},
+		{
+			Name:     "CatchallPrivateNoAccount",
+			Resource: srvResource,
+			Rules: []*Rule{
+				{
+					Scope:    "*",
+					Resource: catchallResource,
+				},
+			},
+			Error: ErrForbidden,
+		},
+		{
+			Name:     "CatchallServiceRuleMatch",
+			Resource: srvResource,
+			Account:  &Account{},
+			Rules: []*Rule{
+				{
+					Scope: "*",
+					Resource: &Resource{
+						Type:     srvResource.Type,
+						Name:     srvResource.Name,
+						Endpoint: "*",
+					},
+				},
+			},
+		},
+		{
+			Name:     "CatchallServiceRuleNoMatch",
+			Resource: srvResource,
+			Account:  &Account{},
+			Rules: []*Rule{
+				{
+					Scope: "*",
+					Resource: &Resource{
+						Type:     srvResource.Type,
+						Name:     "wrongname",
+						Endpoint: "*",
+					},
+				},
+			},
+			Error: ErrForbidden,
+		},
+		{
+			Name:     "ExactRuleValidScope",
+			Resource: srvResource,
+			Account: &Account{
+				Scopes: []string{"neededscope"},
+			},
+			Rules: []*Rule{
+				{
+					Scope:    "neededscope",
+					Resource: srvResource,
+				},
+			},
+		},
+		{
+			Name:     "ExactRuleInvalidScope",
+			Resource: srvResource,
+			Account: &Account{
+				Scopes: []string{"neededscope"},
+			},
+			Rules: []*Rule{
+				{
+					Scope:    "invalidscope",
+					Resource: srvResource,
+				},
+			},
+			Error: ErrForbidden,
+		},
+		{
+			Name:     "CatchallDenyWithAccount",
+			Resource: srvResource,
+			Account:  &Account{},
+			Rules: []*Rule{
+				{
+					Scope:    "*",
+					Resource: catchallResource,
+					Access:   AccessDenied,
+				},
+			},
+			Error: ErrForbidden,
+		},
+		{
+			Name:     "CatchallDenyWithNoAccount",
+			Resource: srvResource,
+			Account:  &Account{},
+			Rules: []*Rule{
+				{
+					Scope:    "*",
+					Resource: catchallResource,
+					Access:   AccessDenied,
+				},
+			},
+			Error: ErrForbidden,
+		},
+		{
+			Name:     "RulePriorityGrantFirst",
+			Resource: srvResource,
+			Account:  &Account{},
+			Rules: []*Rule{
+				{
+					Scope:    "*",
+					Resource: catchallResource,
+					Access:   AccessGranted,
+					Priority: 1,
+				},
+				{
+					Scope:    "*",
+					Resource: catchallResource,
+					Access:   AccessDenied,
+					Priority: 0,
+				},
+			},
+		},
+		{
+			Name:     "RulePriorityDenyFirst",
+			Resource: srvResource,
+			Account:  &Account{},
+			Rules: []*Rule{
+				{
+					Scope:    "*",
+					Resource: catchallResource,
+					Access:   AccessGranted,
+					Priority: 0,
+				},
+				{
+					Scope:    "*",
+					Resource: catchallResource,
+					Access:   AccessDenied,
+					Priority: 1,
+				},
+			},
+			Error: ErrForbidden,
+		},
+		{
+			Name:     "WebExactEndpointValid",
+			Resource: webResource,
+			Account:  &Account{},
+			Rules: []*Rule{
+				{
+					Scope:    "*",
+					Resource: webResource,
+				},
+			},
+		},
+		{
+			Name:     "WebExactEndpointInalid",
+			Resource: webResource,
+			Account:  &Account{},
+			Rules: []*Rule{
+				{
+					Scope: "*",
+					Resource: &Resource{
+						Type:     webResource.Type,
+						Name:     webResource.Name,
+						Endpoint: "invalidendpoint",
+					},
+				},
+			},
+			Error: ErrForbidden,
+		},
+		{
+			Name:     "WebWildcardEndpoint",
+			Resource: webResource,
+			Account:  &Account{},
+			Rules: []*Rule{
+				{
+					Scope: "*",
+					Resource: &Resource{
+						Type:     webResource.Type,
+						Name:     webResource.Name,
+						Endpoint: "*",
+					},
+				},
+			},
+		},
+		{
+			Name:     "WebWildcardPathEndpointValid",
+			Resource: webResource,
+			Account:  &Account{},
+			Rules: []*Rule{
+				{
+					Scope: "*",
+					Resource: &Resource{
+						Type:     webResource.Type,
+						Name:     webResource.Name,
+						Endpoint: "/foo/*",
+					},
+				},
+			},
+		},
+		{
+			Name:     "WebWildcardPathEndpointInvalid",
+			Resource: webResource,
+			Account:  &Account{},
+			Rules: []*Rule{
+				{
+					Scope: "*",
+					Resource: &Resource{
+						Type:     webResource.Type,
+						Name:     webResource.Name,
+						Endpoint: "/bar/*",
+					},
+				},
+			},
+			Error: ErrForbidden,
+		},
+	}
+
+	for _, tc := range tt {
+		t.Run(tc.Name, func(t *testing.T) {
+			if err := VerifyAccess(tc.Rules, tc.Account, tc.Resource); err != tc.Error {
+				t.Errorf("Expected %v but got %v", tc.Error, err)
+			}
+		})
+	}
+}

broker/broker.go

@@ -1,12 +1,10 @@
 // Package broker is an interface used for asynchronous messaging
-package broker
+package broker // import "go.unistack.org/micro/v3/broker"
 
 import (
 	"context"
 	"errors"
-	"time"
 
-	"go.unistack.org/micro/v3/codec"
 	"go.unistack.org/micro/v3/metadata"
 )
 
@@ -18,8 +16,6 @@ var (
 	ErrNotConnected = errors.New("broker not connected")
 	// ErrDisconnected returns when broker disconnected
 	ErrDisconnected = errors.New("broker disconnected")
-	// DefaultGracefulTimeout
-	DefaultGracefulTimeout = 5 * time.Second
 )
 
 // Broker is an interface used for asynchronous messaging.
@@ -48,24 +44,12 @@ type Broker interface {
 	String() string
 }
 
-type (
-	FuncPublish        func(ctx context.Context, topic string, msg *Message, opts ...PublishOption) error
-	HookPublish        func(next FuncPublish) FuncPublish
-	FuncBatchPublish   func(ctx context.Context, msgs []*Message, opts ...PublishOption) error
-	HookBatchPublish   func(next FuncBatchPublish) FuncBatchPublish
-	FuncSubscribe      func(ctx context.Context, topic string, h Handler, opts ...SubscribeOption) (Subscriber, error)
-	HookSubscribe      func(next FuncSubscribe) FuncSubscribe
-	FuncBatchSubscribe func(ctx context.Context, topic string, h BatchHandler, opts ...SubscribeOption) (Subscriber, error)
-	HookBatchSubscribe func(next FuncBatchSubscribe) FuncBatchSubscribe
-)
-
 // Handler is used to process messages via a subscription of a topic.
 type Handler func(Event) error
 
 // Events contains multiple events
 type Events []Event
 
-// Ack try to ack all events and return
 func (evs Events) Ack() error {
 	var err error
 	for _, ev := range evs {
@@ -76,7 +60,6 @@ func (evs Events) Ack() error {
 	return nil
 }
 
-// SetError sets error on event
 func (evs Events) SetError(err error) {
 	for _, ev := range evs {
 		ev.SetError(err)
@@ -88,8 +71,6 @@ type BatchHandler func(Events) error
 
 // Event is given to a subscription handler for processing
 type Event interface {
-	// Context return context.Context for event
-	Context() context.Context
 	// Topic returns event topic
 	Topic() string
 	// Message returns broker message
@@ -102,12 +83,33 @@ type Event interface {
 	SetError(err error)
 }
 
+// RawMessage is a raw encoded JSON value.
+// It implements Marshaler and Unmarshaler and can be used to delay decoding or precompute a encoding.
+type RawMessage []byte
+
+// MarshalJSON returns m as the JSON encoding of m.
+func (m *RawMessage) MarshalJSON() ([]byte, error) {
+	if m == nil {
+		return []byte("null"), nil
+	}
+	return *m, nil
+}
+
+// UnmarshalJSON sets *m to a copy of data.
+func (m *RawMessage) UnmarshalJSON(data []byte) error {
+	if m == nil {
+		return errors.New("RawMessage UnmarshalJSON on nil pointer")
+	}
+	*m = append((*m)[0:0], data...)
+	return nil
+}
+
 // Message is used to transfer data
 type Message struct {
 	// Header contains message metadata
 	Header metadata.Metadata
 	// Body contains message body
-	Body codec.RawMessage
+	Body RawMessage
 }
 
 // NewMessage create broker message with topic filled

broker/context_test.go

@@ -1,72 +0,0 @@
-package broker
-
-import (
-	"context"
-	"testing"
-)
-
-func TestFromContext(t *testing.T) {
-	ctx := context.WithValue(context.TODO(), brokerKey{}, NewBroker())
-	c, ok := FromContext(ctx)
-	if c == nil || !ok {
-		t.Fatal("FromContext not works")
-	}
-}
-
-func TestFromNilContext(t *testing.T) {
-	// nolint: staticcheck
-	c, ok := FromContext(nil)
-	if ok || c != nil {
-		t.Fatal("FromContext not works")
-	}
-}
-
-func TestNewContext(t *testing.T) {
-	ctx := NewContext(context.TODO(), NewBroker())
-	c, ok := FromContext(ctx)
-	if c == nil || !ok {
-		t.Fatal("NewContext not works")
-	}
-}
-
-func TestNewNilContext(t *testing.T) {
-	// nolint: staticcheck
-	ctx := NewContext(nil, NewBroker())
-	c, ok := FromContext(ctx)
-	if c == nil || !ok {
-		t.Fatal("NewContext not works")
-	}
-}
-
-func TestSetSubscribeOption(t *testing.T) {
-	type key struct{}
-	o := SetSubscribeOption(key{}, "test")
-	opts := &SubscribeOptions{}
-	o(opts)
-
-	if v, ok := opts.Context.Value(key{}).(string); !ok || v == "" {
-		t.Fatal("SetSubscribeOption not works")
-	}
-}
-
-func TestSetPublishOption(t *testing.T) {
-	type key struct{}
-	o := SetPublishOption(key{}, "test")
-	opts := &PublishOptions{}
-	o(opts)
-
-	if v, ok := opts.Context.Value(key{}).(string); !ok || v == "" {
-		t.Fatal("SetPublishOption not works")
-	}
-}
-
-func TestSetOption(t *testing.T) {
-	type key struct{}
-	o := SetOption(key{}, "test")
-	opts := &Options{}
-	o(opts)
-
-	if v, ok := opts.Context.Value(key{}).(string); !ok || v == "" {
-		t.Fatal("SetOption not works")
-	}
-}

broker/memory.go

@@ -4,10 +4,8 @@ import (
 	"context"
 	"sync"
 
-	"go.unistack.org/micro/v3/broker"
 	"go.unistack.org/micro/v3/logger"
 	"go.unistack.org/micro/v3/metadata"
-	"go.unistack.org/micro/v3/options"
 	maddr "go.unistack.org/micro/v3/util/addr"
 	"go.unistack.org/micro/v3/util/id"
 	mnet "go.unistack.org/micro/v3/util/net"
@@ -15,13 +13,9 @@ import (
 )
 
 type memoryBroker struct {
-	funcPublish        broker.FuncPublish
-	funcBatchPublish   broker.FuncBatchPublish
-	funcSubscribe      broker.FuncSubscribe
-	funcBatchSubscribe broker.FuncBatchSubscribe
 	subscribers map[string][]*memorySubscriber
 	addr        string
-	opts               broker.Options
+	opts        Options
 	sync.RWMutex
 	connected bool
 }
@@ -30,20 +24,20 @@ type memoryEvent struct {
 	err     error
 	message interface{}
 	topic   string
-	opts    broker.Options
+	opts    Options
 }
 
 type memorySubscriber struct {
 	ctx          context.Context
 	exit         chan bool
-	handler      broker.Handler
+	handler      Handler
-	batchhandler broker.BatchHandler
+	batchhandler BatchHandler
 	id           string
 	topic        string
-	opts         broker.SubscribeOptions
+	opts         SubscribeOptions
 }
 
-func (m *memoryBroker) Options() broker.Options {
+func (m *memoryBroker) Options() Options {
 	return m.opts
 }
 
@@ -52,12 +46,6 @@ func (m *memoryBroker) Address() string {
 }
 
 func (m *memoryBroker) Connect(ctx context.Context) error {
-	select {
-	case <-ctx.Done():
-		return ctx.Err()
-	default:
-	}
-
 	m.Lock()
 	defer m.Unlock()
 
@@ -82,12 +70,6 @@ func (m *memoryBroker) Connect(ctx context.Context) error {
 }
 
 func (m *memoryBroker) Disconnect(ctx context.Context) error {
-	select {
-	case <-ctx.Done():
-		return ctx.Err()
-	default:
-	}
-
 	m.Lock()
 	defer m.Unlock()
 
@@ -99,54 +81,27 @@ func (m *memoryBroker) Disconnect(ctx context.Context) error {
 	return nil
 }
 
-func (m *memoryBroker) Init(opts ...broker.Option) error {
+func (m *memoryBroker) Init(opts ...Option) error {
 	for _, o := range opts {
 		o(&m.opts)
 	}
-
-	m.funcPublish = m.fnPublish
-	m.funcBatchPublish = m.fnBatchPublish
-	m.funcSubscribe = m.fnSubscribe
-	m.funcBatchSubscribe = m.fnBatchSubscribe
-
-	m.opts.Hooks.EachNext(func(hook options.Hook) {
-		switch h := hook.(type) {
-		case broker.HookPublish:
-			m.funcPublish = h(m.funcPublish)
-		case broker.HookBatchPublish:
-			m.funcBatchPublish = h(m.funcBatchPublish)
-		case broker.HookSubscribe:
-			m.funcSubscribe = h(m.funcSubscribe)
-		case broker.HookBatchSubscribe:
-			m.funcBatchSubscribe = h(m.funcBatchSubscribe)
-		}
-	})
-
 	return nil
 }
 
-func (m *memoryBroker) Publish(ctx context.Context, topic string, msg *broker.Message, opts ...broker.PublishOption) error {
+func (m *memoryBroker) Publish(ctx context.Context, topic string, msg *Message, opts ...PublishOption) error {
-	return m.funcPublish(ctx, topic, msg, opts...)
-}
-
-func (m *memoryBroker) fnPublish(ctx context.Context, topic string, msg *broker.Message, opts ...broker.PublishOption) error {
 	msg.Header.Set(metadata.HeaderTopic, topic)
-	return m.publish(ctx, []*broker.Message{msg}, opts...)
+	return m.publish(ctx, []*Message{msg}, opts...)
 }
 
-func (m *memoryBroker) BatchPublish(ctx context.Context, msgs []*broker.Message, opts ...broker.PublishOption) error {
+func (m *memoryBroker) BatchPublish(ctx context.Context, msgs []*Message, opts ...PublishOption) error {
-	return m.funcBatchPublish(ctx, msgs, opts...)
-}
-
-func (m *memoryBroker) fnBatchPublish(ctx context.Context, msgs []*broker.Message, opts ...broker.PublishOption) error {
 	return m.publish(ctx, msgs, opts...)
 }
 
-func (m *memoryBroker) publish(ctx context.Context, msgs []*broker.Message, opts ...broker.PublishOption) error {
+func (m *memoryBroker) publish(ctx context.Context, msgs []*Message, opts ...PublishOption) error {
 	m.RLock()
 	if !m.connected {
 		m.RUnlock()
-		return broker.ErrNotConnected
+		return ErrNotConnected
 	}
 	m.RUnlock()
 
@@ -156,9 +111,9 @@ func (m *memoryBroker) publish(ctx context.Context, msgs []*broker.Message, opts
 	case <-ctx.Done():
 		return ctx.Err()
 	default:
-		options := broker.NewPublishOptions(opts...)
+		options := NewPublishOptions(opts...)
 
-		msgTopicMap := make(map[string]broker.Events)
+		msgTopicMap := make(map[string]Events)
 		for _, v := range msgs {
 			p := &memoryEvent{opts: m.opts}
 
@@ -206,7 +161,7 @@ func (m *memoryBroker) publish(ctx context.Context, msgs []*broker.Message, opts
 						}
 					} else if sub.opts.AutoAck {
 						if err = ms.Ack(); err != nil {
-							m.opts.Logger.Error(m.opts.Context, "broker ack error", err)
+							m.opts.Logger.Errorf(m.opts.Context, "ack failed: %v", err)
 						}
 					}
 					// single processing
@@ -217,11 +172,11 @@ func (m *memoryBroker) publish(ctx context.Context, msgs []*broker.Message, opts
 							if eh != nil {
 								_ = eh(p)
 							} else if m.opts.Logger.V(logger.ErrorLevel) {
-								m.opts.Logger.Error(m.opts.Context, "broker handler error", err)
+								m.opts.Logger.Error(m.opts.Context, err.Error())
 							}
 						} else if sub.opts.AutoAck {
 							if err = p.Ack(); err != nil {
-								m.opts.Logger.Error(m.opts.Context, "broker ack error", err)
+								m.opts.Logger.Errorf(m.opts.Context, "ack failed: %v", err)
 							}
 						}
 					}
@@ -233,15 +188,11 @@ func (m *memoryBroker) publish(ctx context.Context, msgs []*broker.Message, opts
 	return nil
 }
 
-func (m *memoryBroker) BatchSubscribe(ctx context.Context, topic string, handler broker.BatchHandler, opts ...broker.SubscribeOption) (broker.Subscriber, error) {
+func (m *memoryBroker) BatchSubscribe(ctx context.Context, topic string, handler BatchHandler, opts ...SubscribeOption) (Subscriber, error) {
-	return m.funcBatchSubscribe(ctx, topic, handler, opts...)
-}
-
-func (m *memoryBroker) fnBatchSubscribe(ctx context.Context, topic string, handler broker.BatchHandler, opts ...broker.SubscribeOption) (broker.Subscriber, error) {
 	m.RLock()
 	if !m.connected {
 		m.RUnlock()
-		return nil, broker.ErrNotConnected
+		return nil, ErrNotConnected
 	}
 	m.RUnlock()
 
@@ -250,7 +201,7 @@ func (m *memoryBroker) fnBatchSubscribe(ctx context.Context, topic string, handl
 		return nil, err
 	}
 
-	options := broker.NewSubscribeOptions(opts...)
+	options := NewSubscribeOptions(opts...)
 
 	sub := &memorySubscriber{
 		exit:         make(chan bool, 1),
@@ -282,15 +233,11 @@ func (m *memoryBroker) fnBatchSubscribe(ctx context.Context, topic string, handl
 	return sub, nil
 }
 
-func (m *memoryBroker) Subscribe(ctx context.Context, topic string, handler broker.Handler, opts ...broker.SubscribeOption) (broker.Subscriber, error) {
+func (m *memoryBroker) Subscribe(ctx context.Context, topic string, handler Handler, opts ...SubscribeOption) (Subscriber, error) {
-	return m.funcSubscribe(ctx, topic, handler, opts...)
-}
-
-func (m *memoryBroker) fnSubscribe(ctx context.Context, topic string, handler broker.Handler, opts ...broker.SubscribeOption) (broker.Subscriber, error) {
 	m.RLock()
 	if !m.connected {
 		m.RUnlock()
-		return nil, broker.ErrNotConnected
+		return nil, ErrNotConnected
 	}
 	m.RUnlock()
 
@@ -299,7 +246,7 @@ func (m *memoryBroker) fnSubscribe(ctx context.Context, topic string, handler br
 		return nil, err
 	}
 
-	options := broker.NewSubscribeOptions(opts...)
+	options := NewSubscribeOptions(opts...)
 
 	sub := &memorySubscriber{
 		exit:    make(chan bool, 1),
@@ -343,12 +290,12 @@ func (m *memoryEvent) Topic() string {
 	return m.topic
 }
 
-func (m *memoryEvent) Message() *broker.Message {
+func (m *memoryEvent) Message() *Message {
 	switch v := m.message.(type) {
-	case *broker.Message:
+	case *Message:
 		return v
 	case []byte:
-		msg := &broker.Message{}
+		msg := &Message{}
 		if err := m.opts.Codec.Unmarshal(v, msg); err != nil {
 			if m.opts.Logger.V(logger.ErrorLevel) {
 				m.opts.Logger.Error(m.opts.Context, "[memory]: failed to unmarshal: %v", err)
@@ -373,11 +320,7 @@ func (m *memoryEvent) SetError(err error) {
 	m.err = err
 }
 
-func (m *memoryEvent) Context() context.Context {
+func (m *memorySubscriber) Options() SubscribeOptions {
-	return m.opts.Context
-}
-
-func (m *memorySubscriber) Options() broker.SubscribeOptions {
 	return m.opts
 }
 
@@ -391,9 +334,9 @@ func (m *memorySubscriber) Unsubscribe(ctx context.Context) error {
 }
 
 // NewBroker return new memory broker
-func NewBroker(opts ...broker.Option) broker.Broker {
+func NewBroker(opts ...Option) Broker {
 	return &memoryBroker{
-		opts:        broker.NewOptions(opts...),
+		opts:        NewOptions(opts...),
 		subscribers: make(map[string][]*memorySubscriber),
 	}
 }

broker/memory_test.go

@@ -5,7 +5,6 @@ import (
 	"fmt"
 	"testing"
 
-	"go.unistack.org/micro/v3/broker"
 	"go.unistack.org/micro/v3/metadata"
 )
 
@@ -13,10 +12,6 @@ func TestMemoryBatchBroker(t *testing.T) {
 	b := NewBroker()
 	ctx := context.Background()
 
-	if err := b.Init(); err != nil {
-		t.Fatalf("Unexpected init error %v", err)
-	}
-
 	if err := b.Connect(ctx); err != nil {
 		t.Fatalf("Unexpected connect error %v", err)
 	}
@@ -24,7 +19,7 @@ func TestMemoryBatchBroker(t *testing.T) {
 	topic := "test"
 	count := 10
 
-	fn := func(evts broker.Events) error {
+	fn := func(evts Events) error {
 		return evts.Ack()
 	}
 
@@ -33,9 +28,9 @@ func TestMemoryBatchBroker(t *testing.T) {
 		t.Fatalf("Unexpected error subscribing %v", err)
 	}
 
-	msgs := make([]*broker.Message, 0, count)
+	msgs := make([]*Message, 0, count)
 	for i := 0; i < count; i++ {
-		message := &broker.Message{
+		message := &Message{
 			Header: map[string]string{
 				metadata.HeaderTopic: topic,
 				"foo":                "bar",
@@ -63,10 +58,6 @@ func TestMemoryBroker(t *testing.T) {
 	b := NewBroker()
 	ctx := context.Background()
 
-	if err := b.Init(); err != nil {
-		t.Fatalf("Unexpected init error %v", err)
-	}
-
 	if err := b.Connect(ctx); err != nil {
 		t.Fatalf("Unexpected connect error %v", err)
 	}
@@ -74,7 +65,7 @@ func TestMemoryBroker(t *testing.T) {
 	topic := "test"
 	count := 10
 
-	fn := func(p broker.Event) error {
+	fn := func(p Event) error {
 		return nil
 	}
 
@@ -83,9 +74,9 @@ func TestMemoryBroker(t *testing.T) {
 		t.Fatalf("Unexpected error subscribing %v", err)
 	}
 
-	msgs := make([]*broker.Message, 0, count)
+	msgs := make([]*Message, 0, count)
 	for i := 0; i < count; i++ {
-		message := &broker.Message{
+		message := &Message{
 			Header: map[string]string{
 				metadata.HeaderTopic: topic,
 				"foo":                "bar",

broker/noop.go

@@ -1,128 +0,0 @@
-package broker
-
-import (
-	"context"
-	"strings"
-
-	"go.unistack.org/micro/v3/options"
-)
-
-type NoopBroker struct {
-	funcPublish        FuncPublish
-	funcBatchPublish   FuncBatchPublish
-	funcSubscribe      FuncSubscribe
-	funcBatchSubscribe FuncBatchSubscribe
-	opts               Options
-}
-
-func NewBroker(opts ...Option) *NoopBroker {
-	b := &NoopBroker{opts: NewOptions(opts...)}
-	b.funcPublish = b.fnPublish
-	b.funcBatchPublish = b.fnBatchPublish
-	b.funcSubscribe = b.fnSubscribe
-	b.funcBatchSubscribe = b.fnBatchSubscribe
-
-	return b
-}
-
-func (b *NoopBroker) Name() string {
-	return b.opts.Name
-}
-
-func (b *NoopBroker) String() string {
-	return "noop"
-}
-
-func (b *NoopBroker) Options() Options {
-	return b.opts
-}
-
-func (b *NoopBroker) Init(opts ...Option) error {
-	for _, opt := range opts {
-		opt(&b.opts)
-	}
-
-	b.funcPublish = b.fnPublish
-	b.funcBatchPublish = b.fnBatchPublish
-	b.funcSubscribe = b.fnSubscribe
-	b.funcBatchSubscribe = b.fnBatchSubscribe
-
-	b.opts.Hooks.EachNext(func(hook options.Hook) {
-		switch h := hook.(type) {
-		case HookPublish:
-			b.funcPublish = h(b.funcPublish)
-		case HookBatchPublish:
-			b.funcBatchPublish = h(b.funcBatchPublish)
-		case HookSubscribe:
-			b.funcSubscribe = h(b.funcSubscribe)
-		case HookBatchSubscribe:
-			b.funcBatchSubscribe = h(b.funcBatchSubscribe)
-		}
-	})
-
-	return nil
-}
-
-func (b *NoopBroker) Connect(_ context.Context) error {
-	return nil
-}
-
-func (b *NoopBroker) Disconnect(_ context.Context) error {
-	return nil
-}
-
-func (b *NoopBroker) Address() string {
-	return strings.Join(b.opts.Addrs, ",")
-}
-
-func (b *NoopBroker) fnBatchPublish(_ context.Context, _ []*Message, _ ...PublishOption) error {
-	return nil
-}
-
-func (b *NoopBroker) BatchPublish(ctx context.Context, msgs []*Message, opts ...PublishOption) error {
-	return b.funcBatchPublish(ctx, msgs, opts...)
-}
-
-func (b *NoopBroker) fnPublish(_ context.Context, _ string, _ *Message, _ ...PublishOption) error {
-	return nil
-}
-
-func (b *NoopBroker) Publish(ctx context.Context, topic string, msg *Message, opts ...PublishOption) error {
-	return b.funcPublish(ctx, topic, msg, opts...)
-}
-
-type NoopSubscriber struct {
-	ctx          context.Context
-	topic        string
-	handler      Handler
-	batchHandler BatchHandler
-	opts         SubscribeOptions
-}
-
-func (b *NoopBroker) fnBatchSubscribe(ctx context.Context, topic string, handler BatchHandler, opts ...SubscribeOption) (Subscriber, error) {
-	return &NoopSubscriber{ctx: ctx, topic: topic, opts: NewSubscribeOptions(opts...), batchHandler: handler}, nil
-}
-
-func (b *NoopBroker) BatchSubscribe(ctx context.Context, topic string, handler BatchHandler, opts ...SubscribeOption) (Subscriber, error) {
-	return b.funcBatchSubscribe(ctx, topic, handler, opts...)
-}
-
-func (b *NoopBroker) fnSubscribe(ctx context.Context, topic string, handler Handler, opts ...SubscribeOption) (Subscriber, error) {
-	return &NoopSubscriber{ctx: ctx, topic: topic, opts: NewSubscribeOptions(opts...), handler: handler}, nil
-}
-
-func (b *NoopBroker) Subscribe(ctx context.Context, topic string, handler Handler, opts ...SubscribeOption) (Subscriber, error) {
-	return b.funcSubscribe(ctx, topic, handler, opts...)
-}
-
-func (s *NoopSubscriber) Options() SubscribeOptions {
-	return s.opts
-}
-
-func (s *NoopSubscriber) Topic() string {
-	return s.topic
-}
-
-func (s *NoopSubscriber) Unsubscribe(_ context.Context) error {
-	return nil
-}

broker/noop_test.go

@@ -1,35 +0,0 @@
-package broker
-
-import (
-	"context"
-	"testing"
-)
-
-type testHook struct {
-	f bool
-}
-
-func (t *testHook) Publish1(fn FuncPublish) FuncPublish {
-	return func(ctx context.Context, topic string, msg *Message, opts ...PublishOption) error {
-		t.f = true
-		return fn(ctx, topic, msg, opts...)
-	}
-}
-
-func TestNoopHook(t *testing.T) {
-	h := &testHook{}
-
-	b := NewBroker(Hooks(HookPublish(h.Publish1)))
-
-	if err := b.Init(); err != nil {
-		t.Fatal(err)
-	}
-
-	if err := b.Publish(context.TODO(), "", nil); err != nil {
-		t.Fatal(err)
-	}
-
-	if !h.f {
-		t.Fatal("hook not works")
-	}
-}

broker/options.go

@@ -8,9 +8,7 @@ import (
 	"go.unistack.org/micro/v3/codec"
 	"go.unistack.org/micro/v3/logger"
 	"go.unistack.org/micro/v3/meter"
-	"go.unistack.org/micro/v3/options"
 	"go.unistack.org/micro/v3/register"
-	"go.unistack.org/micro/v3/sync"
 	"go.unistack.org/micro/v3/tracer"
 )
 
@@ -38,13 +36,6 @@ type Options struct {
 	Name string
 	// Addrs holds the broker address
 	Addrs []string
-	// Wait waits for a collection of goroutines to finish
-	Wait *sync.WaitGroup
-	// GracefulTimeout contains time to wait to finish in flight requests
-	GracefulTimeout time.Duration
-	// Hooks can be run before broker Publish/BatchPublish and
-	// Subscribe/BatchSubscribe methods
-	Hooks options.Hooks
 }
 
 // NewOptions create new Options
@@ -56,7 +47,6 @@ func NewOptions(opts ...Option) Options {
 		Meter:    meter.DefaultMeter,
 		Codec:    codec.DefaultCodec,
 		Tracer:   tracer.DefaultTracer,
-		GracefulTimeout: DefaultGracefulTimeout,
 	}
 	for _, o := range opts {
 		o(&options)
@@ -234,13 +224,6 @@ func Name(n string) Option {
 	}
 }
 
-// Hooks sets hook runs before action
-func Hooks(h ...options.Hook) Option {
-	return func(o *Options) {
-		o.Hooks = append(o.Hooks, h...)
-	}
-}
-
 // SubscribeContext set context
 func SubscribeContext(ctx context.Context) SubscribeOption {
 	return func(o *SubscribeOptions) {

build/build.go

@@ -0,0 +1,32 @@
+// Package build is for building source into a package
+package build // import "go.unistack.org/micro/v3/build"
+
+// Build is an interface for building packages
+type Build interface {
+	// Package builds a package
+	Package(name string, src *Source) (*Package, error)
+	// Remove removes the package
+	Remove(*Package) error
+}
+
+// Source is the source of a build
+type Source struct {
+	// Path to the source if local
+	Path string
+	// Language is the language of code
+	Language string
+	// Location of the source
+	Repository string
+}
+
+// Package is packaged format for source
+type Package struct {
+	// Source of the package
+	Source *Source
+	// Name of the package
+	Name string
+	// Location of the package
+	Path string
+	// Type of package e.g tarball, binary, docker
+	Type string
+}

build/options.go

@@ -0,0 +1,17 @@
+package build
+
+// Options struct
+type Options struct {
+	// local path to download source
+	Path string
+}
+
+// Option func
+type Option func(o *Options)
+
+// Path is the Local path for repository
+func Path(p string) Option {
+	return func(o *Options) {
+		o.Path = p
+	}
+}

client/backoff.go

@@ -2,7 +2,6 @@ package client
 
 import (
 	"context"
-	"math"
 	"time"
 
 	"go.unistack.org/micro/v3/util/backoff"
@@ -11,20 +10,6 @@ import (
 // BackoffFunc is the backoff call func
 type BackoffFunc func(ctx context.Context, req Request, attempts int) (time.Duration, error)
 
-// BackoffExp using exponential backoff func
+func exponentialBackoff(ctx context.Context, req Request, attempts int) (time.Duration, error) {
-func BackoffExp(_ context.Context, _ Request, attempts int) (time.Duration, error) {
 	return backoff.Do(attempts), nil
 }
-
-// BackoffInterval specifies randomization interval for backoff func
-func BackoffInterval(min time.Duration, max time.Duration) BackoffFunc {
-	return func(_ context.Context, _ Request, attempts int) (time.Duration, error) {
-		td := time.Duration(math.Pow(float64(attempts), math.E)) * time.Millisecond * 100
-		if td < min {
-			return min, nil
-		} else if td > max {
-			return max, nil
-		}
-		return td, nil
-	}
-}

client/backoff_test.go

@@ -6,7 +6,7 @@ import (
 	"time"
 )
 
-func TestBackoffExp(t *testing.T) {
+func TestBackoff(t *testing.T) {
 	results := []time.Duration{
 		0 * time.Second,
 		100 * time.Millisecond,
@@ -22,7 +22,7 @@ func TestBackoffExp(t *testing.T) {
 	}
 
 	for i := 0; i < 5; i++ {
-		d, err := BackoffExp(context.TODO(), r, i)
+		d, err := exponentialBackoff(context.TODO(), r, i)
 		if err != nil {
 			t.Fatal(err)
 		}
@@ -32,25 +32,3 @@ func TestBackoffExp(t *testing.T) {
 		}
 	}
 }
-
-func TestBackoffInterval(t *testing.T) {
-	min := 100 * time.Millisecond
-	max := 300 * time.Millisecond
-
-	r := &testRequest{
-		service: "test",
-		method:  "test",
-	}
-
-	fn := BackoffInterval(min, max)
-	for i := 0; i < 5; i++ {
-		d, err := fn(context.TODO(), r, i)
-		if err != nil {
-			t.Fatal(err)
-		}
-
-		if d < min || d > max {
-			t.Fatalf("Expected %v < %v < %v", min, d, max)
-		}
-	}
-}

client/client.go

@@ -1,5 +1,5 @@
 // Package client is an interface for an RPC client
-package client
+package client // import "go.unistack.org/micro/v3/client"
 
 import (
 	"context"
@@ -11,11 +11,11 @@ import (
 
 var (
 	// DefaultClient is the global default client
-	DefaultClient = NewClient()
+	DefaultClient Client = NewClient()
 	// DefaultContentType is the default content-type if not specified
-	DefaultContentType = ""
+	DefaultContentType = "application/json"
-	// DefaultBackoff is the default backoff function for retries (minimum 10 millisecond and maximum 5 second)
+	// DefaultBackoff is the default backoff function for retries
-	DefaultBackoff = BackoffInterval(10*time.Millisecond, 5*time.Second)
+	DefaultBackoff = exponentialBackoff
 	// DefaultRetry is the default check-for-retry function for retries
 	DefaultRetry = RetryNever
 	// DefaultRetries is the default number of times a request is tried
@@ -44,17 +44,6 @@ type Client interface {
 	String() string
 }
 
-type (
-	FuncCall         func(ctx context.Context, req Request, rsp interface{}, opts ...CallOption) error
-	HookCall         func(next FuncCall) FuncCall
-	FuncStream       func(ctx context.Context, req Request, opts ...CallOption) (Stream, error)
-	HookStream       func(next FuncStream) FuncStream
-	FuncPublish      func(ctx context.Context, msg Message, opts ...PublishOption) error
-	HookPublish      func(next FuncPublish) FuncPublish
-	FuncBatchPublish func(ctx context.Context, msg []Message, opts ...PublishOption) error
-	HookBatchPublish func(next FuncBatchPublish) FuncBatchPublish
-)
-
 // Message is the interface for publishing asynchronously
 type Message interface {
 	Topic() string
@@ -85,7 +74,7 @@ type Request interface {
 type Response interface {
 	// Read the response
 	Codec() codec.Codec
-	// Header data
+	// read the header
 	Header() metadata.Metadata
 	// Read the undecoded response
 	Read() ([]byte, error)

client/context_test.go

@@ -1,73 +0,0 @@
-package client
-
-import (
-	"context"
-	"testing"
-)
-
-func TestFromContext(t *testing.T) {
-	ctx := context.WithValue(context.TODO(), clientKey{}, NewClient())
-
-	c, ok := FromContext(ctx)
-	if c == nil || !ok {
-		t.Fatal("FromContext not works")
-	}
-}
-
-func TestFromNilContext(t *testing.T) {
-	// nolint: staticcheck
-	c, ok := FromContext(nil)
-	if ok || c != nil {
-		t.Fatal("FromContext not works")
-	}
-}
-
-func TestNewContext(t *testing.T) {
-	ctx := NewContext(context.TODO(), NewClient())
-	c, ok := FromContext(ctx)
-	if c == nil || !ok {
-		t.Fatal("NewContext not works")
-	}
-}
-
-func TestNewNilContext(t *testing.T) {
-	// nolint: staticcheck
-	ctx := NewContext(nil, NewClient())
-	c, ok := FromContext(ctx)
-	if c == nil || !ok {
-		t.Fatal("NewContext not works")
-	}
-}
-
-func TestSetPublishOption(t *testing.T) {
-	type key struct{}
-	o := SetPublishOption(key{}, "test")
-	opts := &PublishOptions{}
-	o(opts)
-
-	if v, ok := opts.Context.Value(key{}).(string); !ok || v == "" {
-		t.Fatal("SetPublishOption not works")
-	}
-}
-
-func TestSetCallOption(t *testing.T) {
-	type key struct{}
-	o := SetCallOption(key{}, "test")
-	opts := &CallOptions{}
-	o(opts)
-
-	if v, ok := opts.Context.Value(key{}).(string); !ok || v == "" {
-		t.Fatal("SetCallOption not works")
-	}
-}
-
-func TestSetOption(t *testing.T) {
-	type key struct{}
-	o := SetOption(key{}, "test")
-	opts := &Options{}
-	o(opts)
-
-	if v, ok := opts.Context.Value(key{}).(string); !ok || v == "" {
-		t.Fatal("SetOption not works")
-	}
-}

client/noop.go

@@ -2,19 +2,11 @@ package client
 
 import (
 	"context"
-	"fmt"
-	"os"
-	"strconv"
-	"time"
 
 	"go.unistack.org/micro/v3/broker"
 	"go.unistack.org/micro/v3/codec"
 	"go.unistack.org/micro/v3/errors"
 	"go.unistack.org/micro/v3/metadata"
-	"go.unistack.org/micro/v3/options"
-	"go.unistack.org/micro/v3/selector"
-	"go.unistack.org/micro/v3/semconv"
-	"go.unistack.org/micro/v3/tracer"
 )
 
 // DefaultCodecs will be used to encode/decode data
@@ -23,10 +15,6 @@ var DefaultCodecs = map[string]codec.Codec{
 }
 
 type noopClient struct {
-	funcPublish      FuncPublish
-	funcBatchPublish FuncBatchPublish
-	funcCall         FuncCall
-	funcStream       FuncStream
 	opts Options
 }
 
@@ -48,14 +36,16 @@ type noopRequest struct {
 
 // NewClient returns new noop client
 func NewClient(opts ...Option) Client {
-	n := &noopClient{opts: NewOptions(opts...)}
+	nc := &noopClient{opts: NewOptions(opts...)}
+	// wrap in reverse
 
-	n.funcCall = n.fnCall
+	c := Client(nc)
-	n.funcStream = n.fnStream
-	n.funcPublish = n.fnPublish
-	n.funcBatchPublish = n.fnBatchPublish
 
-	return n
+	for i := len(nc.opts.Wrappers); i > 0; i-- {
+		c = nc.opts.Wrappers[i-1](c)
+	}
+
+	return c
 }
 
 func (n *noopClient) Name() string {
@@ -107,13 +97,10 @@ func (n *noopResponse) Read() ([]byte, error) {
 	return nil, nil
 }
 
-type noopStream struct {
+type noopStream struct{}
-	err error
-	ctx context.Context
-}
 
 func (n *noopStream) Context() context.Context {
-	return n.ctx
+	return context.Background()
 }
 
 func (n *noopStream) Request() Request {
@@ -141,21 +128,15 @@ func (n *noopStream) RecvMsg(interface{}) error {
 }
 
 func (n *noopStream) Error() error {
-	return n.err
+	return nil
 }
 
 func (n *noopStream) Close() error {
-	if sp, ok := tracer.SpanFromContext(n.ctx); ok && sp != nil {
+	return nil
-		if n.err != nil {
-			sp.SetStatus(tracer.SpanStatusError, n.err.Error())
-		}
-		sp.Finish()
-	}
-	return n.err
 }
 
 func (n *noopStream) CloseSend() error {
-	return n.err
+	return nil
 }
 
 func (n *noopMessage) Topic() string {
@@ -188,25 +169,6 @@ func (n *noopClient) Init(opts ...Option) error {
 	for _, o := range opts {
 		o(&n.opts)
 	}
-
-	n.funcCall = n.fnCall
-	n.funcStream = n.fnStream
-	n.funcPublish = n.fnPublish
-	n.funcBatchPublish = n.fnBatchPublish
-
-	n.opts.Hooks.EachNext(func(hook options.Hook) {
-		switch h := hook.(type) {
-		case HookCall:
-			n.funcCall = h(n.funcCall)
-		case HookStream:
-			n.funcStream = h(n.funcStream)
-		case HookPublish:
-			n.funcPublish = h(n.funcPublish)
-		case HookBatchPublish:
-			n.funcBatchPublish = h(n.funcBatchPublish)
-		}
-	})
-
 	return nil
 }
 
@@ -219,159 +181,9 @@ func (n *noopClient) String() string {
 }
 
 func (n *noopClient) Call(ctx context.Context, req Request, rsp interface{}, opts ...CallOption) error {
-	ts := time.Now()
-	n.opts.Meter.Counter(semconv.ClientRequestInflight, "endpoint", req.Endpoint()).Inc()
-	var sp tracer.Span
-	ctx, sp = n.opts.Tracer.Start(ctx, req.Endpoint()+" rpc-client",
-		tracer.WithSpanKind(tracer.SpanKindClient),
-		tracer.WithSpanLabels("endpoint", req.Endpoint()),
-	)
-	err := n.funcCall(ctx, req, rsp, opts...)
-	n.opts.Meter.Counter(semconv.ClientRequestInflight, "endpoint", req.Endpoint()).Dec()
-	te := time.Since(ts)
-	n.opts.Meter.Summary(semconv.ClientRequestLatencyMicroseconds, "endpoint", req.Endpoint()).Update(te.Seconds())
-	n.opts.Meter.Histogram(semconv.ClientRequestDurationSeconds, "endpoint", req.Endpoint()).Update(te.Seconds())
-
-	if me := errors.FromError(err); me == nil {
-		sp.Finish()
-		n.opts.Meter.Counter(semconv.ClientRequestTotal, "endpoint", req.Endpoint(), "status", "success", "code", strconv.Itoa(int(200))).Inc()
-	} else {
-		sp.SetStatus(tracer.SpanStatusError, err.Error())
-		n.opts.Meter.Counter(semconv.ClientRequestTotal, "endpoint", req.Endpoint(), "status", "failure", "code", strconv.Itoa(int(me.Code))).Inc()
-	}
-
-	return err
-}
-
-func (n *noopClient) fnCall(ctx context.Context, req Request, rsp interface{}, opts ...CallOption) error {
-	// make a copy of call opts
-	callOpts := n.opts.CallOptions
-	for _, opt := range opts {
-		opt(&callOpts)
-	}
-
-	// check if we already have a deadline
-	d, ok := ctx.Deadline()
-	if !ok {
-		var cancel context.CancelFunc
-		// no deadline so we create a new one
-		ctx, cancel = context.WithTimeout(ctx, callOpts.RequestTimeout)
-		defer cancel()
-	} else {
-		// got a deadline so no need to setup context
-		// but we need to set the timeout we pass along
-		opt := WithRequestTimeout(time.Until(d))
-		opt(&callOpts)
-	}
-
-	// should we noop right here?
-	select {
-	case <-ctx.Done():
-		return errors.New("go.micro.client", fmt.Sprintf("%v", ctx.Err()), 408)
-	default:
-	}
-
-	// make copy of call method
-	hcall := func(ctx context.Context, addr string, req Request, rsp interface{}, opts CallOptions) error {
 	return nil
 }
 
-	// use the router passed as a call option, or fallback to the rpc clients router
-	if callOpts.Router == nil {
-		callOpts.Router = n.opts.Router
-	}
-
-	if callOpts.Selector == nil {
-		callOpts.Selector = n.opts.Selector
-	}
-
-	// inject proxy address
-	// TODO: don't even bother using Lookup/Select in this case
-	if len(n.opts.Proxy) > 0 {
-		callOpts.Address = []string{n.opts.Proxy}
-	}
-
-	var next selector.Next
-
-	// return errors.New("go.micro.client", "request timeout", 408)
-	call := func(i int) error {
-		// call backoff first. Someone may want an initial start delay
-		t, err := callOpts.Backoff(ctx, req, i)
-		if err != nil {
-			return errors.InternalServerError("go.micro.client", err.Error())
-		}
-
-		// only sleep if greater than 0
-		if t.Seconds() > 0 {
-			time.Sleep(t)
-		}
-
-		if next == nil {
-			var routes []string
-			// lookup the route to send the reques to
-			// TODO apply any filtering here
-			routes, err = n.opts.Lookup(ctx, req, callOpts)
-			if err != nil {
-				return errors.InternalServerError("go.micro.client", err.Error())
-			}
-
-			// balance the list of nodes
-			next, err = callOpts.Selector.Select(routes)
-			if err != nil {
-				return err
-			}
-		}
-
-		node := next()
-
-		// make the call
-		err = hcall(ctx, node, req, rsp, callOpts)
-		// record the result of the call to inform future routing decisions
-		if verr := n.opts.Selector.Record(node, err); verr != nil {
-			return verr
-		}
-
-		// try and transform the error to a go-micro error
-		if verr, ok := err.(*errors.Error); ok {
-			return verr
-		}
-
-		return err
-	}
-
-	ch := make(chan error, callOpts.Retries)
-	var gerr error
-
-	for i := 0; i <= callOpts.Retries; i++ {
-		go func() {
-			ch <- call(i)
-		}()
-
-		select {
-		case <-ctx.Done():
-			return errors.New("go.micro.client", fmt.Sprintf("%v", ctx.Err()), 408)
-		case err := <-ch:
-			// if the call succeeded lets bail early
-			if err == nil {
-				return nil
-			}
-
-			retry, rerr := callOpts.Retry(ctx, req, i, err)
-			if rerr != nil {
-				return rerr
-			}
-
-			if !retry {
-				return err
-			}
-
-			gerr = err
-		}
-	}
-
-	return gerr
-}
-
 func (n *noopClient) NewRequest(service, endpoint string, req interface{}, opts ...RequestOption) Request {
 	return &noopRequest{service: service, endpoint: endpoint}
 }
@@ -382,187 +194,14 @@ func (n *noopClient) NewMessage(topic string, msg interface{}, opts ...MessageOp
 }
 
 func (n *noopClient) Stream(ctx context.Context, req Request, opts ...CallOption) (Stream, error) {
-	ts := time.Now()
+	return &noopStream{}, nil
-	n.opts.Meter.Counter(semconv.ClientRequestInflight, "endpoint", req.Endpoint()).Inc()
-	var sp tracer.Span
-	ctx, sp = n.opts.Tracer.Start(ctx, req.Endpoint()+" rpc-client",
-		tracer.WithSpanKind(tracer.SpanKindClient),
-		tracer.WithSpanLabels("endpoint", req.Endpoint()),
-	)
-	stream, err := n.funcStream(ctx, req, opts...)
-	n.opts.Meter.Counter(semconv.ClientRequestInflight, "endpoint", req.Endpoint()).Dec()
-	te := time.Since(ts)
-	n.opts.Meter.Summary(semconv.ClientRequestLatencyMicroseconds, "endpoint", req.Endpoint()).Update(te.Seconds())
-	n.opts.Meter.Histogram(semconv.ClientRequestDurationSeconds, "endpoint", req.Endpoint()).Update(te.Seconds())
-
-	if me := errors.FromError(err); me == nil {
-		sp.Finish()
-		n.opts.Meter.Counter(semconv.ClientRequestTotal, "endpoint", req.Endpoint(), "status", "success", "code", strconv.Itoa(int(200))).Inc()
-	} else {
-		sp.SetStatus(tracer.SpanStatusError, err.Error())
-		n.opts.Meter.Counter(semconv.ClientRequestTotal, "endpoint", req.Endpoint(), "status", "failure", "code", strconv.Itoa(int(me.Code))).Inc()
-	}
-
-	return stream, err
-}
-
-func (n *noopClient) fnStream(ctx context.Context, req Request, opts ...CallOption) (Stream, error) {
-	var err error
-
-	// make a copy of call opts
-	callOpts := n.opts.CallOptions
-	for _, o := range opts {
-		o(&callOpts)
-	}
-
-	// check if we already have a deadline
-	d, ok := ctx.Deadline()
-	if !ok && callOpts.StreamTimeout > time.Duration(0) {
-		var cancel context.CancelFunc
-		// no deadline so we create a new one
-		ctx, cancel = context.WithTimeout(ctx, callOpts.StreamTimeout)
-		defer cancel()
-	} else {
-		// got a deadline so no need to setup context
-		// but we need to set the timeout we pass along
-		o := WithStreamTimeout(time.Until(d))
-		o(&callOpts)
-	}
-
-	// should we noop right here?
-	select {
-	case <-ctx.Done():
-		return nil, errors.New("go.micro.client", fmt.Sprintf("%v", ctx.Err()), 408)
-	default:
-	}
-
-	/*
-		// make copy of call method
-		hstream := h.stream
-		// wrap the call in reverse
-		for i := len(callOpts.CallWrappers); i > 0; i-- {
-			hstream = callOpts.CallWrappers[i-1](hstream)
-		}
-	*/
-
-	// use the router passed as a call option, or fallback to the rpc clients router
-	if callOpts.Router == nil {
-		callOpts.Router = n.opts.Router
-	}
-
-	if callOpts.Selector == nil {
-		callOpts.Selector = n.opts.Selector
-	}
-
-	// inject proxy address
-	// TODO: don't even bother using Lookup/Select in this case
-	if len(n.opts.Proxy) > 0 {
-		callOpts.Address = []string{n.opts.Proxy}
-	}
-
-	var next selector.Next
-
-	call := func(i int) (Stream, error) {
-		// call backoff first. Someone may want an initial start delay
-		t, cerr := callOpts.Backoff(ctx, req, i)
-		if cerr != nil {
-			return nil, errors.InternalServerError("go.micro.client", cerr.Error())
-		}
-
-		// only sleep if greater than 0
-		if t.Seconds() > 0 {
-			time.Sleep(t)
-		}
-
-		if next == nil {
-			var routes []string
-			// lookup the route to send the reques to
-			// TODO apply any filtering here
-			routes, err = n.opts.Lookup(ctx, req, callOpts)
-			if err != nil {
-				return nil, errors.InternalServerError("go.micro.client", err.Error())
-			}
-
-			// balance the list of nodes
-			next, err = callOpts.Selector.Select(routes)
-			if err != nil {
-				return nil, err
-			}
-		}
-
-		node := next()
-
-		stream, cerr := n.stream(ctx, node, req, callOpts)
-
-		// record the result of the call to inform future routing decisions
-		if verr := n.opts.Selector.Record(node, cerr); verr != nil {
-			return nil, verr
-		}
-
-		// try and transform the error to a go-micro error
-		if verr, ok := cerr.(*errors.Error); ok {
-			return nil, verr
-		}
-
-		return stream, cerr
-	}
-
-	type response struct {
-		stream Stream
-		err    error
-	}
-
-	ch := make(chan response, callOpts.Retries)
-	var grr error
-
-	for i := 0; i <= callOpts.Retries; i++ {
-		go func() {
-			s, cerr := call(i)
-			ch <- response{s, cerr}
-		}()
-
-		select {
-		case <-ctx.Done():
-			return nil, errors.New("go.micro.client", fmt.Sprintf("%v", ctx.Err()), 408)
-		case rsp := <-ch:
-			// if the call succeeded lets bail early
-			if rsp.err == nil {
-				return rsp.stream, nil
-			}
-
-			retry, rerr := callOpts.Retry(ctx, req, i, err)
-			if rerr != nil {
-				return nil, rerr
-			}
-
-			if !retry {
-				return nil, rsp.err
-			}
-
-			grr = rsp.err
-		}
-	}
-
-	return nil, grr
-}
-
-func (n *noopClient) stream(ctx context.Context, addr string, req Request, opts CallOptions) (Stream, error) {
-	return &noopStream{ctx: ctx}, nil
 }
 
 func (n *noopClient) BatchPublish(ctx context.Context, ps []Message, opts ...PublishOption) error {
-	return n.funcBatchPublish(ctx, ps, opts...)
-}
-
-func (n *noopClient) fnBatchPublish(ctx context.Context, ps []Message, opts ...PublishOption) error {
 	return n.publish(ctx, ps, opts...)
 }
 
 func (n *noopClient) Publish(ctx context.Context, p Message, opts ...PublishOption) error {
-	return n.funcPublish(ctx, p, opts...)
-}
-
-func (n *noopClient) fnPublish(ctx context.Context, p Message, opts ...PublishOption) error {
 	return n.publish(ctx, []Message{p}, opts...)
 }
 
@@ -571,34 +210,21 @@ func (n *noopClient) publish(ctx context.Context, ps []Message, opts ...PublishO
 
 	msgs := make([]*broker.Message, 0, len(ps))
 
-	// get proxy
+	for _, p := range ps {
-	exchange := ""
+		md, ok := metadata.FromOutgoingContext(ctx)
-	if v, ok := os.LookupEnv("MICRO_PROXY"); ok {
+		if !ok {
-		exchange = v
+			md = metadata.New(0)
 		}
+		md[metadata.HeaderContentType] = p.ContentType()
+
+		topic := p.Topic()
+
 		// get the exchange
 		if len(options.Exchange) > 0 {
-		exchange = options.Exchange
+			topic = options.Exchange
 		}
 
-	omd, ok := metadata.FromOutgoingContext(ctx)
-	if !ok {
-		omd = metadata.New(0)
-	}
-
-	for _, p := range ps {
-		md := metadata.Copy(omd)
-		md[metadata.HeaderContentType] = p.ContentType()
-		topic := p.Topic()
-		if len(exchange) > 0 {
-			topic = exchange
-		}
 		md[metadata.HeaderTopic] = topic
-		iter := p.Metadata().Iterator()
-		var k, v string
-		for iter.Next(&k, &v) {
-			md.Set(k, v)
-		}
 
 		var body []byte
 
@@ -623,13 +249,6 @@ func (n *noopClient) publish(ctx context.Context, ps []Message, opts ...PublishO
 		msgs = append(msgs, &broker.Message{Header: md, Body: body})
 	}
 
-	if len(msgs) == 1 {
-		return n.opts.Broker.Publish(ctx, msgs[0].Header[metadata.HeaderTopic], msgs[0],
-			broker.PublishContext(options.Context),
-			broker.PublishBodyOnly(options.BodyOnly),
-		)
-	}
-
 	return n.opts.Broker.BatchPublish(ctx, msgs,
 		broker.PublishContext(options.Context),
 		broker.PublishBodyOnly(options.BodyOnly),

client/noop_test.go

@@ -1,35 +0,0 @@
-package client
-
-import (
-	"context"
-	"testing"
-)
-
-type testHook struct {
-	f bool
-}
-
-func (t *testHook) Publish(fn FuncPublish) FuncPublish {
-	return func(ctx context.Context, msg Message, opts ...PublishOption) error {
-		t.f = true
-		return fn(ctx, msg, opts...)
-	}
-}
-
-func TestNoopHook(t *testing.T) {
-	h := &testHook{}
-
-	c := NewClient(Hooks(HookPublish(h.Publish)))
-
-	if err := c.Init(); err != nil {
-		t.Fatal(err)
-	}
-
-	if err := c.Publish(context.TODO(), c.NewMessage("", nil, MessageContentType("application/octet-stream"))); err != nil {
-		t.Fatal(err)
-	}
-
-	if !h.f {
-		t.Fatal("hook not works")
-	}
-}

client/options.go

@@ -3,7 +3,6 @@ package client
 import (
 	"context"
 	"crypto/tls"
-	"net"
 	"time"
 
 	"go.unistack.org/micro/v3/broker"
@@ -12,7 +11,6 @@ import (
 	"go.unistack.org/micro/v3/metadata"
 	"go.unistack.org/micro/v3/meter"
 	"go.unistack.org/micro/v3/network/transport"
-	"go.unistack.org/micro/v3/options"
 	"go.unistack.org/micro/v3/register"
 	"go.unistack.org/micro/v3/router"
 	"go.unistack.org/micro/v3/selector"
@@ -58,11 +56,6 @@ type Options struct {
 	PoolSize int
 	// PoolTTL connection pool ttl
 	PoolTTL time.Duration
-	// ContextDialer used to connect
-	ContextDialer func(context.Context, string) (net.Conn, error)
-	// Hooks can be run before broker Publish/BatchPublish and
-	// Subscribe/BatchSubscribe methods
-	Hooks options.Hooks
 }
 
 // NewCallOptions creates new call options struct
@@ -96,27 +89,16 @@ type CallOptions struct {
 	Address []string
 	// SelectOptions selector options
 	SelectOptions []selector.SelectOption
+	// CallWrappers call wrappers
+	CallWrappers []CallWrapper
 	// StreamTimeout stream timeout
 	StreamTimeout time.Duration
 	// RequestTimeout request timeout
 	RequestTimeout time.Duration
-	// RequestMetadata holds additional metadata for call
-	RequestMetadata metadata.Metadata
-	// ResponseMetadata holds additional metadata from call
-	ResponseMetadata *metadata.Metadata
 	// DialTimeout dial timeout
 	DialTimeout time.Duration
 	// Retries specifies retries num
 	Retries int
-	// ContextDialer used to connect
-	ContextDialer func(context.Context, string) (net.Conn, error)
-}
-
-// ContextDialer pass ContextDialer to client
-func ContextDialer(fn func(context.Context, string) (net.Conn, error)) Option {
-	return func(o *Options) {
-		o.ContextDialer = fn
-	}
 }
 
 // Context pass context to client
@@ -187,7 +169,7 @@ func NewOptions(opts ...Option) Options {
 	options := Options{
 		Context:     context.Background(),
 		ContentType: DefaultContentType,
-		Codecs:      DefaultCodecs,
+		Codecs:      make(map[string]codec.Codec),
 		CallOptions: CallOptions{
 			Context:        context.Background(),
 			Backoff:        DefaultBackoff,
@@ -308,6 +290,20 @@ func Selector(s selector.Selector) Option {
 	}
 }
 
+// Wrap adds a wrapper to the list of options passed into the client
+func Wrap(w Wrapper) Option {
+	return func(o *Options) {
+		o.Wrappers = append(o.Wrappers, w)
+	}
+}
+
+// WrapCall adds a wrapper to the list of CallFunc wrappers
+func WrapCall(cw ...CallWrapper) Option {
+	return func(o *Options) {
+		o.CallOptions.CallWrappers = append(o.CallOptions.CallWrappers, cw...)
+	}
+}
+
 // Backoff is used to set the backoff function used when retrying Calls
 func Backoff(fn BackoffFunc) Option {
 	return func(o *Options) {
@@ -417,13 +413,6 @@ func PublishContext(ctx context.Context) PublishOption {
 	}
 }
 
-// WithContextDialer pass ContextDialer to client call
-func WithContextDialer(fn func(context.Context, string) (net.Conn, error)) CallOption {
-	return func(o *CallOptions) {
-		o.ContextDialer = fn
-	}
-}
-
 // WithContentType specifies call content type
 func WithContentType(ct string) CallOption {
 	return func(o *CallOptions) {
@@ -438,6 +427,13 @@ func WithAddress(a ...string) CallOption {
 	}
 }
 
+// WithCallWrapper is a CallOption which adds to the existing CallFunc wrappers
+func WithCallWrapper(cw ...CallWrapper) CallOption {
+	return func(o *CallOptions) {
+		o.CallWrappers = append(o.CallWrappers, cw...)
+	}
+}
+
 // WithBackoff is a CallOption which overrides that which
 // set in Options.CallOptions
 func WithBackoff(fn BackoffFunc) CallOption {
@@ -462,20 +458,6 @@ func WithRetries(i int) CallOption {
 	}
 }
 
-// WithResponseMetadata is a CallOption which adds metadata.Metadata to Options.CallOptions
-func WithResponseMetadata(md *metadata.Metadata) CallOption {
-	return func(o *CallOptions) {
-		o.ResponseMetadata = md
-	}
-}
-
-// WithRequestMetadata is a CallOption which adds metadata.Metadata to Options.CallOptions
-func WithRequestMetadata(md metadata.Metadata) CallOption {
-	return func(o *CallOptions) {
-		o.RequestMetadata = md
-	}
-}
-
 // WithRequestTimeout is a CallOption which overrides that which
 // set in Options.CallOptions
 func WithRequestTimeout(d time.Duration) CallOption {
@@ -572,10 +554,3 @@ func RequestContentType(ct string) RequestOption {
 		o.ContentType = ct
 	}
 }
-
-// Hooks sets hook runs before action
-func Hooks(h ...options.Hook) Option {
-	return func(o *Options) {
-		o.Hooks = append(o.Hooks, h...)
-	}
-}

client/retry.go

@@ -19,32 +19,18 @@ func RetryNever(ctx context.Context, req Request, retryCount int, err error) (bo
 	return false, nil
 }
 
-// RetryOnError retries a request on a 500 or 408 (timeout) error
+// RetryOnError retries a request on a 500 or timeout error
 func RetryOnError(_ context.Context, _ Request, _ int, err error) (bool, error) {
 	if err == nil {
 		return false, nil
 	}
+
 	me := errors.FromError(err)
 	switch me.Code {
 	// retry on timeout or internal server error
 	case 408, 500:
 		return true, nil
 	}
-	return false, nil
-}
 
-// RetryOnErrors retries a request on specified error codes
-func RetryOnErrors(codes ...int32) RetryFunc {
-	return func(_ context.Context, _ Request, _ int, err error) (bool, error) {
-		if err == nil {
 	return false, nil
 }
-		me := errors.FromError(err)
-		for _, code := range codes {
-			if me.Code == code {
-				return true, nil
-			}
-		}
-		return false, nil
-	}
-}

client/retry_test.go

@@ -1,70 +0,0 @@
-package client
-
-import (
-	"context"
-	"fmt"
-	"testing"
-
-	"go.unistack.org/micro/v3/errors"
-)
-
-func TestRetryAlways(t *testing.T) {
-	tests := []error{
-		nil,
-		errors.InternalServerError("test", "%s", "test"),
-		fmt.Errorf("test"),
-	}
-
-	for _, e := range tests {
-		ok, er := RetryAlways(context.TODO(), nil, 1, e)
-		if !ok || er != nil {
-			t.Fatal("RetryAlways not works properly")
-		}
-	}
-}
-
-func TestRetryNever(t *testing.T) {
-	tests := []error{
-		nil,
-		errors.InternalServerError("test", "%s", "test"),
-		fmt.Errorf("test"),
-	}
-
-	for _, e := range tests {
-		ok, er := RetryNever(context.TODO(), nil, 1, e)
-		if ok || er != nil {
-			t.Fatal("RetryNever not works properly")
-		}
-	}
-}
-
-func TestRetryOnError(t *testing.T) {
-	tests := []error{
-		fmt.Errorf("test"),
-		errors.NotFound("test", "%s", "test"),
-		errors.Timeout("test", "%s", "test"),
-	}
-
-	for i, e := range tests {
-		ok, er := RetryOnError(context.TODO(), nil, 1, e)
-		if i == 2 && (!ok || er != nil) {
-			t.Fatal("RetryOnError not works properly")
-		}
-	}
-}
-
-func TestRetryOnErrors(t *testing.T) {
-	tests := []error{
-		fmt.Errorf("test"),
-		errors.NotFound("test", "%s", "test"),
-		errors.Timeout("test", "%s", "test"),
-	}
-
-	fn := RetryOnErrors(404)
-	for i, e := range tests {
-		ok, er := fn(context.TODO(), nil, 1, e)
-		if i == 1 && (!ok || er != nil) {
-			t.Fatal("RetryOnErrors not works properly")
-		}
-	}
-}

cluster/cluster.go

@@ -1,41 +0,0 @@
-package cluster
-
-import (
-	"context"
-
-	"go.unistack.org/micro/v3/metadata"
-)
-
-// Message sent to member in cluster
-type Message interface {
-	// Header returns message headers
-	Header() metadata.Metadata
-	// Body returns broker message may be []byte slice or some go struct or interface
-	Body() interface{}
-}
-
-type Node interface {
-	// Name returns node name
-	Name() string
-	// Address returns node address
-	Address() string
-	// Metadata returns node metadata
-	Metadata() metadata.Metadata
-}
-
-// Cluster interface used for cluster communication across nodes
-type Cluster interface {
-	// Join is used to take an existing members and performing state sync
-	Join(ctx context.Context, addr ...string) error
-	// Leave broadcast a leave message and stop listeners
-	Leave(ctx context.Context) error
-	// Ping is used to probe live status of the node
-	Ping(ctx context.Context, node Node, payload []byte) error
-	// Members returns the cluster members
-	Members() ([]Node, error)
-	// Broadcast send message for all members in cluster, if filter is not nil, nodes may be filtered
-	// by key/value pairs
-	Broadcast(ctx context.Context, msg Message, filter ...string) error
-	// Unicast send message to single member in cluster
-	Unicast(ctx context.Context, node Node, msg Message) error
-}

codec/codec.go

@@ -1,8 +1,19 @@
 // Package codec is an interface for encoding messages
-package codec
+package codec // import "go.unistack.org/micro/v3/codec"
 
 import (
 	"errors"
+	"io"
+
+	"go.unistack.org/micro/v3/metadata"
+)
+
+// Message types
+const (
+	Error MessageType = iota
+	Request
+	Response
+	Event
 )
 
 var (
@@ -13,44 +24,63 @@ var (
 )
 
 var (
+	// DefaultMaxMsgSize specifies how much data codec can handle
+	DefaultMaxMsgSize = 1024 * 1024 * 4 // 4Mb
 	// DefaultCodec is the global default codec
-	DefaultCodec = NewCodec()
+	DefaultCodec Codec = NewCodec()
 	// DefaultTagName specifies struct tag name to control codec Marshal/Unmarshal
 	DefaultTagName = "codec"
 )
 
-// Codec encodes/decodes various types of messages.
+// MessageType specifies message type for codec
+type MessageType int
+
+// Codec encodes/decodes various types of messages used within micro.
+// ReadHeader and ReadBody are called in pairs to read requests/responses
+// from the connection. Close is called when finished with the
+// connection. ReadBody may be called with a nil argument to force the
+// body to be read and discarded.
 type Codec interface {
+	ReadHeader(r io.Reader, m *Message, mt MessageType) error
+	ReadBody(r io.Reader, v interface{}) error
+	Write(w io.Writer, m *Message, v interface{}) error
 	Marshal(v interface{}, opts ...Option) ([]byte, error)
 	Unmarshal(b []byte, v interface{}, opts ...Option) error
 	String() string
 }
 
-type CodecV2 interface {
+// Message represents detailed information about
-	Marshal(buf []byte, v interface{}, opts ...Option) ([]byte, error)
+// the communication, likely followed by the body.
-	Unmarshal(buf []byte, v interface{}, opts ...Option) error
+// In the case of an error, body may be nil.
-	String() string
+type Message struct {
+	Header   metadata.Metadata
+	Target   string
+	Method   string
+	Endpoint string
+	Error    string
+	ID       string
+	Body     []byte
+	Type     MessageType
 }
 
-// RawMessage is a raw encoded JSON value.
+// NewMessage creates new codec message
-// It implements Marshaler and Unmarshaler and can be used to delay decoding or precompute a encoding.
+func NewMessage(t MessageType) *Message {
-type RawMessage []byte
+	return &Message{Type: t, Header: metadata.New(0)}
-
-// MarshalJSON returns m as the JSON encoding of m.
-func (m *RawMessage) MarshalJSON() ([]byte, error) {
-	if m == nil {
-		return []byte("null"), nil
-	} else if len(*m) == 0 {
-		return []byte("null"), nil
-	}
-	return *m, nil
 }
 
-// UnmarshalJSON sets *m to a copy of data.
+// MarshalAppend calls codec.Marshal(v) and returns the data appended to buf.
-func (m *RawMessage) UnmarshalJSON(data []byte) error {
+// If codec implements MarshalAppend, that is called instead.
-	if m == nil {
+func MarshalAppend(buf []byte, c Codec, v interface{}, opts ...Option) ([]byte, error) {
-		return errors.New("RawMessage UnmarshalJSON on nil pointer")
+	if nc, ok := c.(interface {
+		MarshalAppend([]byte, interface{}, ...Option) ([]byte, error)
+	}); ok {
+		return nc.MarshalAppend(buf, v, opts...)
 	}
-	*m = append((*m)[0:0], data...)
+
-	return nil
+	mbuf, err := c.Marshal(v, opts...)
+	if err != nil {
+		return nil, err
+	}
+
+	return append(buf, mbuf...), nil
 }

codec/context_test.go

@@ -1,35 +0,0 @@
-package codec
-
-import (
-	"context"
-	"testing"
-)
-
-func TestFromContext(t *testing.T) {
-	ctx := context.WithValue(context.TODO(), codecKey{}, NewCodec())
-
-	c, ok := FromContext(ctx)
-	if c == nil || !ok {
-		t.Fatal("FromContext not works")
-	}
-}
-
-func TestNewContext(t *testing.T) {
-	ctx := NewContext(context.TODO(), NewCodec())
-
-	c, ok := FromContext(ctx)
-	if c == nil || !ok {
-		t.Fatal("NewContext not works")
-	}
-}
-
-func TestSetOption(t *testing.T) {
-	type key struct{}
-	o := SetOption(key{}, "test")
-	opts := &Options{}
-	o(opts)
-
-	if v, ok := opts.Context.Value(key{}).(string); !ok || v == "" {
-		t.Fatal("SetOption not works")
-	}
-}

codec/noop.go

@@ -2,14 +2,70 @@ package codec
 
 import (
 	"encoding/json"
-
+	"io"
-	codecpb "go.unistack.org/micro-proto/v3/codec"
 )
 
 type noopCodec struct {
 	opts Options
 }
 
+func (c *noopCodec) ReadHeader(conn io.Reader, m *Message, t MessageType) error {
+	return nil
+}
+
+func (c *noopCodec) ReadBody(conn io.Reader, b interface{}) error {
+	// read bytes
+	buf, err := io.ReadAll(conn)
+	if err != nil {
+		return err
+	}
+
+	if b == nil {
+		return nil
+	}
+
+	switch v := b.(type) {
+	case *string:
+		*v = string(buf)
+	case *[]byte:
+		*v = buf
+	case *Frame:
+		v.Data = buf
+	default:
+		return json.Unmarshal(buf, v)
+	}
+
+	return nil
+}
+
+func (c *noopCodec) Write(conn io.Writer, m *Message, b interface{}) error {
+	if b == nil {
+		return nil
+	}
+
+	var v []byte
+	switch vb := b.(type) {
+	case *Frame:
+		v = vb.Data
+	case string:
+		v = []byte(vb)
+	case *string:
+		v = []byte(*vb)
+	case *[]byte:
+		v = *vb
+	case []byte:
+		v = vb
+	default:
+		var err error
+		v, err = json.Marshal(vb)
+		if err != nil {
+			return err
+		}
+	}
+	_, err := conn.Write(v)
+	return err
+}
+
 func (c *noopCodec) String() string {
 	return "noop"
 }
@@ -35,8 +91,8 @@ func (c *noopCodec) Marshal(v interface{}, opts ...Option) ([]byte, error) {
 		return ve, nil
 	case *Frame:
 		return ve.Data, nil
-	case *codecpb.Frame:
+	case *Message:
-		return ve.Data, nil
+		return ve.Body, nil
 	}
 
 	return json.Marshal(v)
@@ -50,17 +106,14 @@ func (c *noopCodec) Unmarshal(d []byte, v interface{}, opts ...Option) error {
 	case *string:
 		*ve = string(d)
 		return nil
-	case []byte:
-		copy(ve, d)
-		return nil
 	case *[]byte:
 		*ve = d
 		return nil
 	case *Frame:
 		ve.Data = d
 		return nil
-	case *codecpb.Frame:
+	case *Message:
-		ve.Data = d
+		ve.Body = d
 		return nil
 	}
 

codec/noop_test.go

@@ -5,23 +5,9 @@ import (
 	"testing"
 )
 
-func TestNoopBytesPtr(t *testing.T) {
-	req := []byte("test req")
-	rsp := make([]byte, len(req))
-
-	nc := NewCodec()
-	if err := nc.Unmarshal(req, &rsp); err != nil {
-		t.Fatal(err)
-	}
-
-	if !bytes.Equal(req, rsp) {
-		t.Fatalf("req not eq rsp: %s != %s", req, rsp)
-	}
-}
-
 func TestNoopBytes(t *testing.T) {
 	req := []byte("test req")
-	var rsp []byte
+	rsp := make([]byte, len(req))
 
 	nc := NewCodec()
 	if err := nc.Unmarshal(req, &rsp); err != nil {

codec/options.go

@@ -23,8 +23,15 @@ type Options struct {
 	Context context.Context
 	// TagName specifies tag name in struct to control codec
 	TagName string
-	// Flatten specifies that struct must be analyzed for flatten tag
+	// MaxMsgSize specifies max messages size that reads by codec
-	Flatten bool
+	MaxMsgSize int
+}
+
+// MaxMsgSize sets the max message size
+func MaxMsgSize(n int) Option {
+	return func(o *Options) {
+		o.MaxMsgSize = n
+	}
 }
 
 // TagName sets the codec tag name in struct
@@ -34,13 +41,6 @@ func TagName(n string) Option {
 	}
 }
 
-// Flatten enables checking for flatten tag name
-func Flatten(b bool) Option {
-	return func(o *Options) {
-		o.Flatten = b
-	}
-}
-
 // Logger sets the logger
 func Logger(l logger.Logger) Option {
 	return func(o *Options) {
@@ -69,8 +69,8 @@ func NewOptions(opts ...Option) Options {
 		Logger:     logger.DefaultLogger,
 		Meter:      meter.DefaultMeter,
 		Tracer:     tracer.DefaultTracer,
+		MaxMsgSize: DefaultMaxMsgSize,
 		TagName:    DefaultTagName,
-		Flatten: false,
 	}
 
 	for _, o := range opts {

config/config.go

@@ -1,18 +1,12 @@
 // Package config is an interface for dynamic configuration.
-package config
+package config // import "go.unistack.org/micro/v3/config"
 
 import (
 	"context"
 	"errors"
-	"fmt"
-	"reflect"
 	"time"
 )
 
-type Validator interface {
-	Validate() error
-}
-
 // DefaultConfig default config
 var DefaultConfig Config = NewConfig()
 
@@ -51,13 +45,6 @@ type Config interface {
 	String() string
 }
 
-type (
-	FuncLoad func(ctx context.Context, opts ...LoadOption) error
-	HookLoad func(next FuncLoad) FuncLoad
-	FuncSave func(ctx context.Context, opts ...SaveOption) error
-	HookSave func(next FuncSave) FuncSave
-)
-
 // Watcher is the config watcher
 type Watcher interface {
 	// Next blocks until update happens or error returned
@@ -80,81 +67,11 @@ func Load(ctx context.Context, cs []Config, opts ...LoadOption) error {
 	return nil
 }
 
-// Validate runs Validate() error func for each struct field
-func Validate(ctx context.Context, cfg interface{}) error {
-	if cfg == nil {
-		return nil
-	}
-
-	if v, ok := cfg.(Validator); ok {
-		if err := v.Validate(); err != nil {
-			return err
-		}
-	}
-
-	sv := reflect.ValueOf(cfg)
-	if sv.Kind() == reflect.Ptr {
-		sv = sv.Elem()
-	}
-	if sv.Kind() != reflect.Struct {
-		return nil
-	}
-
-	typ := sv.Type()
-	for idx := 0; idx < typ.NumField(); idx++ {
-		fld := typ.Field(idx)
-		val := sv.Field(idx)
-		if !val.IsValid() || len(fld.PkgPath) != 0 {
-			continue
-		}
-
-		if v, ok := val.Interface().(Validator); ok {
-			if err := v.Validate(); err != nil {
-				return err
-			}
-		}
-
-		switch val.Kind() {
-		case reflect.Ptr:
-			if reflect.Indirect(val).Kind() == reflect.Struct {
-				if err := Validate(ctx, val.Interface()); err != nil {
-					return err
-				}
-			}
-		case reflect.Struct:
-			if err := Validate(ctx, val.Interface()); err != nil {
-				return err
-			}
-		}
-	}
-
-	return nil
-}
-
 var (
-	// DefaultBeforeLoad default func that runs before config Load
-	DefaultBeforeLoad = func(ctx context.Context, c Config) error {
-		for _, fn := range c.Options().BeforeLoad {
-			if fn == nil {
-				return nil
-			}
-			if err := fn(ctx, c); err != nil {
-				c.Options().Logger.Error(ctx, fmt.Sprintf("%s BeforeLoad error", c.String()), err)
-				if !c.Options().AllowFail {
-					return err
-				}
-			}
-		}
-		return nil
-	}
-	// DefaultAfterLoad default func that runs after config Load
 	DefaultAfterLoad = func(ctx context.Context, c Config) error {
 		for _, fn := range c.Options().AfterLoad {
-			if fn == nil {
-				return nil
-			}
 			if err := fn(ctx, c); err != nil {
-				c.Options().Logger.Error(ctx, fmt.Sprintf("%s AfterLoad error", c.String()), err)
+				c.Options().Logger.Errorf(ctx, "%s AfterLoad err: %v", c.String(), err)
 				if !c.Options().AllowFail {
 					return err
 				}
@@ -162,29 +79,11 @@ var (
 		}
 		return nil
 	}
-	// DefaultBeforeSave default func that runs befora config Save
+
-	DefaultBeforeSave = func(ctx context.Context, c Config) error {
-		for _, fn := range c.Options().BeforeSave {
-			if fn == nil {
-				return nil
-			}
-			if err := fn(ctx, c); err != nil {
-				c.Options().Logger.Error(ctx, fmt.Sprintf("%s BeforeSave error", c.String()), err)
-				if !c.Options().AllowFail {
-					return err
-				}
-			}
-		}
-		return nil
-	}
-	// DefaultAfterSave default func that runs after config Save
 	DefaultAfterSave = func(ctx context.Context, c Config) error {
 		for _, fn := range c.Options().AfterSave {
-			if fn == nil {
-				return nil
-			}
 			if err := fn(ctx, c); err != nil {
-				c.Options().Logger.Error(ctx, fmt.Sprintf("%s AfterSave error", c.String()), err)
+				c.Options().Logger.Errorf(ctx, "%s AfterSave err: %v", c.String(), err)
 				if !c.Options().AllowFail {
 					return err
 				}
@@ -192,14 +91,11 @@ var (
 		}
 		return nil
 	}
-	// DefaultBeforeInit default func that runs befora config Init
+
-	DefaultBeforeInit = func(ctx context.Context, c Config) error {
+	DefaultBeforeLoad = func(ctx context.Context, c Config) error {
-		for _, fn := range c.Options().BeforeInit {
+		for _, fn := range c.Options().BeforeLoad {
-			if fn == nil {
-				return nil
-			}
 			if err := fn(ctx, c); err != nil {
-				c.Options().Logger.Error(ctx, fmt.Sprintf("%s BeforeInit error", c.String()), err)
+				c.Options().Logger.Errorf(ctx, "%s BeforeLoad err: %v", c.String(), err)
 				if !c.Options().AllowFail {
 					return err
 				}
@@ -207,14 +103,11 @@ var (
 		}
 		return nil
 	}
-	// DefaultAfterInit default func that runs after config Init
+
-	DefaultAfterInit = func(ctx context.Context, c Config) error {
+	DefaultBeforeSave = func(ctx context.Context, c Config) error {
-		for _, fn := range c.Options().AfterSave {
+		for _, fn := range c.Options().BeforeSave {
-			if fn == nil {
-				return nil
-			}
 			if err := fn(ctx, c); err != nil {
-				c.Options().Logger.Error(ctx, fmt.Sprintf("%s AfterInit error", c.String(), err), err)
+				c.Options().Logger.Errorf(ctx, "%s BeforeSavec err: %v", c.String(), err)
 				if !c.Options().AllowFail {
 					return err
 				}

config/context_test.go

@@ -1,86 +0,0 @@
-package config
-
-import (
-	"context"
-	"testing"
-)
-
-func TestFromNilContext(t *testing.T) {
-	// nolint: staticcheck
-	c, ok := FromContext(nil)
-	if ok || c != nil {
-		t.Fatal("FromContext not works")
-	}
-}
-
-func TestNewNilContext(t *testing.T) {
-	// nolint: staticcheck
-	ctx := NewContext(nil, NewConfig())
-
-	c, ok := FromContext(ctx)
-	if c == nil || !ok {
-		t.Fatal("NewContext not works")
-	}
-}
-
-func TestFromContext(t *testing.T) {
-	ctx := context.WithValue(context.TODO(), configKey{}, NewConfig())
-
-	c, ok := FromContext(ctx)
-	if c == nil || !ok {
-		t.Fatal("FromContext not works")
-	}
-}
-
-func TestNewContext(t *testing.T) {
-	ctx := NewContext(context.TODO(), NewConfig())
-
-	c, ok := FromContext(ctx)
-	if c == nil || !ok {
-		t.Fatal("NewContext not works")
-	}
-}
-
-func TestSetOption(t *testing.T) {
-	type key struct{}
-	o := SetOption(key{}, "test")
-	opts := &Options{}
-	o(opts)
-
-	if v, ok := opts.Context.Value(key{}).(string); !ok || v == "" {
-		t.Fatal("SetOption not works")
-	}
-}
-
-func TestSetSaveOption(t *testing.T) {
-	type key struct{}
-	o := SetSaveOption(key{}, "test")
-	opts := &SaveOptions{}
-	o(opts)
-
-	if v, ok := opts.Context.Value(key{}).(string); !ok || v == "" {
-		t.Fatal("SetSaveOption not works")
-	}
-}
-
-func TestSetLoadOption(t *testing.T) {
-	type key struct{}
-	o := SetLoadOption(key{}, "test")
-	opts := &LoadOptions{}
-	o(opts)
-
-	if v, ok := opts.Context.Value(key{}).(string); !ok || v == "" {
-		t.Fatal("SetLoadOption not works")
-	}
-}
-
-func TestSetWatchOption(t *testing.T) {
-	type key struct{}
-	o := SetWatchOption(key{}, "test")
-	opts := &WatchOptions{}
-	o(opts)
-
-	if v, ok := opts.Context.Value(key{}).(string); !ok || v == "" {
-		t.Fatal("SetWatchOption not works")
-	}
-}

config/default.go

@@ -5,19 +5,12 @@ import (
 	"reflect"
 	"strconv"
 	"strings"
-	"time"
 
-	"dario.cat/mergo"
+	"github.com/imdario/mergo"
-	"github.com/google/uuid"
-	"go.unistack.org/micro/v3/options"
-	mid "go.unistack.org/micro/v3/util/id"
 	rutil "go.unistack.org/micro/v3/util/reflect"
-	mtime "go.unistack.org/micro/v3/util/time"
 )
 
 type defaultConfig struct {
-	funcLoad FuncLoad
-	funcSave FuncSave
 	opts Options
 }
 
@@ -29,42 +22,11 @@ func (c *defaultConfig) Init(opts ...Option) error {
 	for _, o := range opts {
 		o(&c.opts)
 	}
-
-	if err := DefaultBeforeInit(c.opts.Context, c); err != nil && !c.opts.AllowFail {
-		return err
-	}
-
-	c.funcLoad = c.fnLoad
-	c.funcSave = c.fnSave
-
-	c.opts.Hooks.EachNext(func(hook options.Hook) {
-		switch h := hook.(type) {
-		case HookLoad:
-			c.funcLoad = h(c.funcLoad)
-		case HookSave:
-			c.funcSave = h(c.funcSave)
-		}
-	})
-
-	if err := DefaultAfterInit(c.opts.Context, c); err != nil && !c.opts.AllowFail {
-		return err
-	}
-
 	return nil
 }
 
 func (c *defaultConfig) Load(ctx context.Context, opts ...LoadOption) error {
-	return c.funcLoad(ctx, opts...)
+	if err := DefaultBeforeLoad(ctx, c); err != nil {
-}
-
-func (c *defaultConfig) fnLoad(ctx context.Context, opts ...LoadOption) error {
-	var err error
-
-	if c.opts.SkipLoad != nil && c.opts.SkipLoad(ctx, c) {
-		return nil
-	}
-
-	if err = DefaultBeforeLoad(ctx, c); err != nil && !c.opts.AllowFail {
 		return err
 	}
 
@@ -87,20 +49,21 @@ func (c *defaultConfig) fnLoad(ctx context.Context, opts ...LoadOption) error {
 		if !c.opts.AllowFail {
 			return err
 		}
-		if err = DefaultAfterLoad(ctx, c); err != nil && !c.opts.AllowFail {
+		return DefaultAfterLoad(ctx, c)
-			return err
-		}
 	}
 
 	if err = fillValues(reflect.ValueOf(src), c.opts.StructTag); err == nil {
 		err = mergo.Merge(dst, src, mopts...)
 	}
 
-	if err != nil && !c.opts.AllowFail {
+	if err != nil {
+		c.opts.Logger.Errorf(ctx, "default load error: %v", err)
+		if !c.opts.AllowFail {
 			return err
 		}
+	}
 
-	if err := DefaultAfterLoad(ctx, c); err != nil && !c.opts.AllowFail {
+	if err := DefaultAfterLoad(ctx, c); err != nil {
 		return err
 	}
 
@@ -112,7 +75,6 @@ func fillValue(value reflect.Value, val string) error {
 	if !rutil.IsEmpty(value) {
 		return nil
 	}
-
 	switch value.Kind() {
 	case reflect.Map:
 		t := value.Type()
@@ -151,20 +113,6 @@ func fillValue(value reflect.Value, val string) error {
 		}
 		value.Set(reflect.ValueOf(v))
 	case reflect.String:
-		switch val {
-		case "micro:generate uuid":
-			uid, err := uuid.NewRandom()
-			if err != nil {
-				return err
-			}
-			val = uid.String()
-		case "micro:generate id":
-			uid, err := mid.New()
-			if err != nil {
-				return err
-			}
-			val = uid
-		}
 		value.Set(reflect.ValueOf(val))
 	case reflect.Float32:
 		v, err := strconv.ParseFloat(val, 32)
@@ -203,26 +151,11 @@ func fillValue(value reflect.Value, val string) error {
 		}
 		value.Set(reflect.ValueOf(int32(v)))
 	case reflect.Int64:
-		switch {
-		case value.Type().String() == "time.Duration" && value.Type().PkgPath() == "time":
-			v, err := time.ParseDuration(val)
-			if err != nil {
-				return err
-			}
-			value.Set(reflect.ValueOf(v))
-		case value.Type().String() == "time.Duration" && value.Type().PkgPath() == "go.unistack.org/micro/v3/util/time":
-			v, err := mtime.ParseDuration(val)
-			if err != nil {
-				return err
-			}
-			value.SetInt(int64(v))
-		default:
 		v, err := strconv.ParseInt(val, 10, 64)
 		if err != nil {
 			return err
 		}
 		value.Set(reflect.ValueOf(v))
-		}
 	case reflect.Uint:
 		v, err := strconv.ParseUint(val, 10, 0)
 		if err != nil {
@@ -254,7 +187,6 @@ func fillValue(value reflect.Value, val string) error {
 		}
 		value.Set(reflect.ValueOf(v))
 	}
-
 	return nil
 }
 
@@ -318,14 +250,6 @@ func fillValues(valueOf reflect.Value, tname string) error {
 }
 
 func (c *defaultConfig) Save(ctx context.Context, opts ...SaveOption) error {
-	return c.funcSave(ctx, opts...)
-}
-
-func (c *defaultConfig) fnSave(ctx context.Context, opts ...SaveOption) error {
-	if c.opts.SkipSave != nil && c.opts.SkipSave(ctx, c) {
-		return nil
-	}
-
 	if err := DefaultBeforeSave(ctx, c); err != nil {
 		return err
 	}
@@ -345,7 +269,7 @@ func (c *defaultConfig) Name() string {
 	return c.opts.Name
 }
 
-func (c *defaultConfig) Watch(_ context.Context, _ ...WatchOption) (Watcher, error) {
+func (c *defaultConfig) Watch(ctx context.Context, opts ...WatchOption) (Watcher, error) {
 	return nil, ErrWatcherNotImplemented
 }
 
@@ -355,9 +279,5 @@ func NewConfig(opts ...Option) Config {
 	if len(options.StructTag) == 0 {
 		options.StructTag = "default"
 	}
-	c := &defaultConfig{opts: options}
+	return &defaultConfig{opts: options}
-	c.funcLoad = c.fnLoad
-	c.funcSave = c.fnSave
-
-	return c
 }

config/default_test.go

@@ -4,87 +4,34 @@ import (
 	"context"
 	"fmt"
 	"testing"
-	"time"
 
 	"go.unistack.org/micro/v3/config"
-	mid "go.unistack.org/micro/v3/util/id"
-	mtime "go.unistack.org/micro/v3/util/time"
 )
 
-type cfg struct {
+type Cfg struct {
 	StringValue string `default:"string_value"`
 	IgnoreValue string `json:"-"`
-	StructValue    *cfgStructValue
+	StructValue struct {
-	IntValue       int             `default:"99"`
-	DurationValue  time.Duration   `default:"10s"`
-	MDurationValue mtime.Duration  `default:"10s"`
-	MapValue       map[string]bool `default:"key1=true,key2=false"`
-	UUIDValue      string          `default:"micro:generate uuid"`
-	IDValue        string          `default:"micro:generate id"`
-}
-
-type cfgStructValue struct {
 		StringValue string `default:"string_value"`
 	}
-
+	IntValue int `default:"99"`
-func (c *cfg) Validate() error {
-	if c.IntValue != 10 {
-		return fmt.Errorf("invalid IntValue %d != %d", 10, c.IntValue)
-	}
-	return nil
-}
-
-func (c *cfgStructValue) Validate() error {
-	if c.StringValue != "string_value" {
-		return fmt.Errorf("invalid StringValue %s != %s", "string_value", c.StringValue)
-	}
-	return nil
-}
-
-type testHook struct {
-	f bool
-}
-
-func (t *testHook) Load(fn config.FuncLoad) config.FuncLoad {
-	return func(ctx context.Context, opts ...config.LoadOption) error {
-		t.f = true
-		return fn(ctx, opts...)
-	}
-}
-
-func TestHook(t *testing.T) {
-	h := &testHook{}
-
-	c := config.NewConfig(config.Struct(h), config.Hooks(config.HookLoad(h.Load)))
-
-	if err := c.Init(); err != nil {
-		t.Fatal(err)
-	}
-
-	if err := c.Load(context.TODO()); err != nil {
-		t.Fatal(err)
-	}
-
-	if !h.f {
-		t.Fatal("hook not works")
-	}
 }
 
 func TestDefault(t *testing.T) {
 	ctx := context.Background()
-	conf := &cfg{IntValue: 10}
+	conf := &Cfg{IntValue: 10}
-	blfn := func(_ context.Context, c config.Config) error {
+	blfn := func(ctx context.Context, cfg config.Config) error {
-		nconf, ok := c.Options().Struct.(*cfg)
+		nconf, ok := cfg.Options().Struct.(*Cfg)
 		if !ok {
-			return fmt.Errorf("failed to get Struct from options: %v", c.Options())
+			return fmt.Errorf("failed to get Struct from options: %v", cfg.Options())
 		}
 		nconf.StringValue = "before_load"
 		return nil
 	}
-	alfn := func(_ context.Context, c config.Config) error {
+	alfn := func(ctx context.Context, cfg config.Config) error {
-		nconf, ok := c.Options().Struct.(*cfg)
+		nconf, ok := cfg.Options().Struct.(*Cfg)
 		if !ok {
-			return fmt.Errorf("failed to get Struct from options: %v", c.Options())
+			return fmt.Errorf("failed to get Struct from options: %v", cfg.Options())
 		}
 		nconf.StringValue = "after_load"
 		return nil
@@ -100,37 +47,6 @@ func TestDefault(t *testing.T) {
 	if conf.StringValue != "after_load" {
 		t.Fatal("AfterLoad option not working")
 	}
-	if len(conf.MapValue) != 2 {
-		t.Fatalf("map value invalid: %#+v\n", conf.MapValue)
-	}
-
-	if conf.UUIDValue == "" {
-		t.Fatalf("uuid value empty")
-	} else if len(conf.UUIDValue) != 36 {
-		t.Fatalf("uuid value invalid: %s", conf.UUIDValue)
-	}
-
-	if conf.IDValue == "" {
-		t.Fatalf("id value empty")
-	} else if len(conf.IDValue) != mid.DefaultSize {
-		t.Fatalf("id value invalid: %s", conf.IDValue)
-	}
 	_ = conf
 	// t.Logf("%#+v\n", conf)
 }
-
-func TestValidate(t *testing.T) {
-	ctx := context.Background()
-	conf := &cfg{IntValue: 10}
-	cfg := config.NewConfig(config.Struct(conf))
-	if err := cfg.Init(); err != nil {
-		t.Fatal(err)
-	}
-	if err := cfg.Load(ctx); err != nil {
-		t.Fatal(err)
-	}
-
-	if err := config.Validate(ctx, conf); err != nil {
-		t.Fatal(err)
-	}
-}

config/options.go

@@ -7,7 +7,6 @@ import (
 	"go.unistack.org/micro/v3/codec"
 	"go.unistack.org/micro/v3/logger"
 	"go.unistack.org/micro/v3/meter"
-	"go.unistack.org/micro/v3/options"
 	"go.unistack.org/micro/v3/tracer"
 )
 
@@ -29,26 +28,16 @@ type Options struct {
 	Name string
 	// StructTag name
 	StructTag string
-	// BeforeSave contains slice of funcs that runs before Save
+	// BeforeSave contains slice of funcs that runs before save
 	BeforeSave []func(context.Context, Config) error
-	// AfterSave contains slice of funcs that runs after Save
+	// AfterLoad contains slice of funcs that runs after load
-	AfterSave []func(context.Context, Config) error
-	// BeforeLoad contains slice of funcs that runs before Load
-	BeforeLoad []func(context.Context, Config) error
-	// AfterLoad contains slice of funcs that runs after Load
 	AfterLoad []func(context.Context, Config) error
-	// BeforeInit contains slice of funcs that runs before Init
+	// BeforeLoad contains slice of funcs that runs before load
-	BeforeInit []func(context.Context, Config) error
+	BeforeLoad []func(context.Context, Config) error
-	// AfterInit contains slice of funcs that runs after Init
+	// AfterSave contains slice of funcs that runs after save
-	AfterInit []func(context.Context, Config) error
+	AfterSave []func(context.Context, Config) error
 	// AllowFail flag to allow fail in config source
 	AllowFail bool
-	// SkipLoad runs only if condition returns true
-	SkipLoad func(context.Context, Config) bool
-	// SkipSave runs only if condition returns true
-	SkipSave func(context.Context, Config) bool
-	// Hooks can be run before/after config Save/Load
-	Hooks options.Hooks
 }
 
 // Option function signature
@@ -75,12 +64,11 @@ type LoadOption func(o *LoadOptions)
 // LoadOptions struct
 type LoadOptions struct {
 	Struct   interface{}
-	Context  context.Context
 	Override bool
 	Append   bool
+	Context  context.Context
 }
 
-// NewLoadOptions create LoadOptions struct with provided opts
 func NewLoadOptions(opts ...LoadOption) LoadOptions {
 	options := LoadOptions{}
 	for _, o := range opts {
@@ -142,20 +130,6 @@ func AllowFail(b bool) Option {
 	}
 }
 
-// BeforeInit run funcs before config Init
-func BeforeInit(fn ...func(context.Context, Config) error) Option {
-	return func(o *Options) {
-		o.BeforeInit = fn
-	}
-}
-
-// AfterInit run funcs after config Init
-func AfterInit(fn ...func(context.Context, Config) error) Option {
-	return func(o *Options) {
-		o.AfterInit = fn
-	}
-}
-
 // BeforeLoad run funcs before config load
 func BeforeLoad(fn ...func(context.Context, Config) error) Option {
 	return func(o *Options) {
@@ -247,10 +221,8 @@ type WatchOptions struct {
 	Coalesce bool
 }
 
-// WatchOption func signature
 type WatchOption func(*WatchOptions)
 
-// NewWatchOptions create WatchOptions struct with provided opts
 func NewWatchOptions(opts ...WatchOption) WatchOptions {
 	options := WatchOptions{
 		Context:     context.Background(),
@@ -291,10 +263,3 @@ func WatchStruct(src interface{}) WatchOption {
 		o.Struct = src
 	}
 }
-
-// Hooks sets hook runs before action
-func Hooks(h ...options.Hook) Option {
-	return func(o *Options) {
-		o.Hooks = append(o.Hooks, h...)
-	}
-}

context_test.go

@@ -1,24 +0,0 @@
-package micro
-
-import (
-	"context"
-	"testing"
-)
-
-func TestFromContext(t *testing.T) {
-	ctx := context.WithValue(context.TODO(), serviceKey{}, NewService())
-
-	c, ok := FromContext(ctx)
-	if c == nil || !ok {
-		t.Fatal("FromContext not works")
-	}
-}
-
-func TestNewContext(t *testing.T) {
-	ctx := NewContext(context.TODO(), NewService())
-
-	c, ok := FromContext(ctx)
-	if c == nil || !ok {
-		t.Fatal("NewContext not works")
-	}
-}

database/dsn.go

@@ -1,157 +0,0 @@
-package database
-
-import (
-	"crypto/tls"
-	"errors"
-	"fmt"
-	"net/url"
-	"strings"
-)
-
-var (
-	ErrInvalidDSNAddr      = errors.New("invalid dsn addr")
-	ErrInvalidDSNUnescaped = errors.New("dsn must be escaped")
-	ErrInvalidDSNNoSlash   = errors.New("dsn must contains slash")
-)
-
-type Config struct {
-	TLSConfig *tls.Config
-	Username  string
-	Password  string
-	Scheme    string
-	Host      string
-	Port      string
-	Database  string
-	Params    []string
-}
-
-func (cfg *Config) FormatDSN() string {
-	var s strings.Builder
-
-	if len(cfg.Scheme) > 0 {
-		s.WriteString(cfg.Scheme + "://")
-	}
-	// [username[:password]@]
-	if len(cfg.Username) > 0 {
-		s.WriteString(cfg.Username)
-		if len(cfg.Password) > 0 {
-			s.WriteByte(':')
-			s.WriteString(url.PathEscape(cfg.Password))
-		}
-		s.WriteByte('@')
-	}
-
-	// [host:port]
-	if len(cfg.Host) > 0 {
-		s.WriteString(cfg.Host)
-		if len(cfg.Port) > 0 {
-			s.WriteByte(':')
-			s.WriteString(cfg.Port)
-		}
-	}
-
-	// /dbname
-	s.WriteByte('/')
-	s.WriteString(url.PathEscape(cfg.Database))
-
-	for i := 0; i < len(cfg.Params); i += 2 {
-		if i == 0 {
-			s.WriteString("?")
-		} else {
-			s.WriteString("&")
-		}
-		s.WriteString(cfg.Params[i])
-		s.WriteString("=")
-		s.WriteString(cfg.Params[i+1])
-	}
-
-	return s.String()
-}
-
-func ParseDSN(dsn string) (*Config, error) {
-	cfg := &Config{}
-
-	// [user[:password]@][net[(addr)]]/dbname[?param1=value1&paramN=valueN]
-	// Find last '/' that goes before dbname
-	foundSlash := false
-	for i := len(dsn) - 1; i >= 0; i-- {
-		if dsn[i] == '/' {
-			foundSlash = true
-			var j, k int
-
-			// left part is empty if i <= 0
-			if i > 0 {
-				// Find the first ':' in dsn
-				for j = i; j >= 0; j-- {
-					if dsn[j] == ':' {
-						cfg.Scheme = dsn[0:j]
-					}
-				}
-
-				// [username[:password]@][host]
-				// Find the last '@' in dsn[:i]
-				for j = i; j >= 0; j-- {
-					if dsn[j] == '@' {
-						// username[:password]
-						// Find the second ':' in dsn[:j]
-						for k = 0; k < j; k++ {
-							if dsn[k] == ':' {
-								if cfg.Scheme == dsn[:k] {
-									continue
-								}
-								var err error
-								cfg.Password, err = url.PathUnescape(dsn[k+1 : j])
-								if err != nil {
-									return nil, err
-								}
-								break
-							}
-						}
-						cfg.Username = dsn[len(cfg.Scheme)+3 : k]
-						break
-					}
-				}
-
-				for k = j + 1; k < i; k++ {
-					if dsn[k] == ':' {
-						cfg.Host = dsn[j+1 : k]
-						cfg.Port = dsn[k+1 : i]
-						break
-					}
-				}
-
-			}
-
-			// dbname[?param1=value1&...&paramN=valueN]
-			// Find the first '?' in dsn[i+1:]
-			for j = i + 1; j < len(dsn); j++ {
-				if dsn[j] == '?' {
-					parts := strings.Split(dsn[j+1:], "&")
-					cfg.Params = make([]string, 0, len(parts)*2)
-					for _, p := range parts {
-						k, v, found := strings.Cut(p, "=")
-						if !found {
-							continue
-						}
-						cfg.Params = append(cfg.Params, k, v)
-					}
-
-					break
-				}
-			}
-			var err error
-			dbname := dsn[i+1 : j]
-			if cfg.Database, err = url.PathUnescape(dbname); err != nil {
-				return nil, fmt.Errorf("invalid dbname %q: %w", dbname, err)
-			}
-
-			break
-		}
-	}
-
-	if !foundSlash && len(dsn) > 0 {
-		return nil, ErrInvalidDSNNoSlash
-	}
-
-	return cfg, nil
-}

database/dsn_test.go

@@ -1,31 +0,0 @@
-package database
-
-import (
-	"net/url"
-	"testing"
-)
-
-func TestParseDSN(t *testing.T) {
-	cfg, err := ParseDSN("postgres://username:p@ssword#@host:12345/dbname?key1=val2&key2=val2")
-	if err != nil {
-		t.Fatal(err)
-	}
-	if cfg.Password != "p@ssword#" {
-		t.Fatalf("parsing error")
-	}
-}
-
-func TestFormatDSN(t *testing.T) {
-	src := "postgres://username:p@ssword#@host:12345/dbname?key1=val2&key2=val2"
-	cfg, err := ParseDSN(src)
-	if err != nil {
-		t.Fatal(err)
-	}
-	dst, err := url.PathUnescape(cfg.FormatDSN())
-	if err != nil {
-		t.Fatal(err)
-	}
-	if src != dst {
-		t.Fatalf("\n%s\n%s", src, dst)
-	}
-}

errors/errors.go

@@ -1,20 +1,13 @@
 // Package errors provides a way to return detailed information
 // for an RPC request error. The error is normally JSON encoded.
-package errors
+package errors // import "go.unistack.org/micro/v3/errors"
 
 import (
-	"bytes"
-	"context"
 	"encoding/json"
-	"errors"
 	"fmt"
-	"io"
 	"net/http"
 	"strconv"
 	"strings"
-
-	"google.golang.org/grpc/codes"
-	"google.golang.org/grpc/status"
 )
 
 var (
@@ -44,20 +37,6 @@ var (
 	ErrGatewayTimeout = &Error{Code: 504}
 )
 
-const ProblemContentType = "application/problem+json"
-
-type Problem struct {
-	Type     string `json:"type,omitempty"`
-	Title    string `json:"title,omitempty"`
-	Detail   string `json:"detail,omitempty"`
-	Instance string `json:"instance,omitempty"`
-	Errors   []struct {
-		Title  string `json:"title,omitempty"`
-		Detail string `json:"detail,omitempty"`
-	} `json:"errors,omitempty"`
-	Status int `json:"status,omitempty"`
-}
-
 // Error type
 type Error struct {
 	// ID holds error id or service, usually someting like my_service or id
@@ -253,33 +232,8 @@ func Equal(err1 error, err2 error) bool {
 	return true
 }
 
-// CodeIn return true if err has specified code
-func CodeIn(err interface{}, codes ...int32) bool {
-	var code int32
-	switch verr := err.(type) {
-	case *Error:
-		code = verr.Code
-	case int32:
-		code = verr
-	default:
-		return false
-	}
-
-	for _, check := range codes {
-		if code == check {
-			return true
-		}
-	}
-
-	return false
-}
-
 // FromError try to convert go error to *Error
 func FromError(err error) *Error {
-	if err == nil {
-		return nil
-	}
-
 	if verr, ok := err.(*Error); ok && verr != nil {
 		return verr
 	}
@@ -307,7 +261,7 @@ func (e *Error) Reset() {
 
 // String returns error as string
 func (e *Error) String() string {
-	return fmt.Sprintf(`{"id":"%s","detail":"%s","status":"%s","code":%d}`, addslashes(e.ID), addslashes(e.Detail), addslashes(e.Status), e.Code)
+	return fmt.Sprintf(`{"id":"%s","detail":"%s","status":"%s","code":%d}`, e.ID, e.Detail, e.Status, e.Code)
 }
 
 // Marshal returns error data
@@ -352,147 +306,3 @@ func (e *Error) Unmarshal(data []byte) error {
 	}
 	return nil
 }
-
-func addslashes(str string) string {
-	var buf bytes.Buffer
-	for _, char := range str {
-		switch char {
-		case '\'', '"', '\\':
-			buf.WriteRune('\\')
-		}
-		buf.WriteRune(char)
-	}
-	return buf.String()
-}
-
-type retryableError struct {
-	err error
-}
-
-// Retryable returns error that can be retried later
-func Retryable(err error) error {
-	return &retryableError{err: err}
-}
-
-type IsRetryableFunc func(error) bool
-
-var (
-	RetrayableOracleErrors = []IsRetryableFunc{
-		func(err error) bool {
-			errmsg := err.Error()
-			switch {
-			case strings.Contains(errmsg, `ORA-`):
-				return true
-			case strings.Contains(errmsg, `can not assign`):
-				return true
-			case strings.Contains(errmsg, `can't assign`):
-				return true
-			}
-			return false
-		},
-	}
-	RetrayablePostgresErrors = []IsRetryableFunc{
-		func(err error) bool {
-			errmsg := err.Error()
-			switch {
-			case strings.Contains(errmsg, `number of field descriptions must equal number of`):
-				return true
-			case strings.Contains(errmsg, `not a pointer`):
-				return true
-			case strings.Contains(errmsg, `values, but dst struct has only`):
-				return true
-			case strings.Contains(errmsg, `struct doesn't have corresponding row field`):
-				return true
-			case strings.Contains(errmsg, `cannot find field`):
-				return true
-			case strings.Contains(errmsg, `cannot scan`) || strings.Contains(errmsg, `cannot convert`):
-				return true
-			case strings.Contains(errmsg, `failed to connect to`):
-				return true
-			}
-			return false
-		},
-	}
-	RetryableMicroErrors = []IsRetryableFunc{
-		func(err error) bool {
-			switch verr := err.(type) {
-			case *Error:
-				switch verr.Code {
-				case 401, 403, 408, 500, 501, 502, 503, 504:
-					return true
-				default:
-					return false
-				}
-			case *retryableError:
-				return true
-			}
-			return false
-		},
-	}
-	RetryableGoErrors = []IsRetryableFunc{
-		func(err error) bool {
-			switch verr := err.(type) {
-			case interface{ SafeToRetry() bool }:
-				return verr.SafeToRetry()
-			case interface{ Timeout() bool }:
-				return verr.Timeout()
-			}
-			switch {
-			case errors.Is(err, io.EOF), errors.Is(err, io.ErrUnexpectedEOF):
-				return true
-			case errors.Is(err, context.DeadlineExceeded):
-				return true
-			case errors.Is(err, io.ErrClosedPipe), errors.Is(err, io.ErrShortBuffer), errors.Is(err, io.ErrShortWrite):
-				return true
-			}
-			return false
-		},
-	}
-	RetryableGrpcErrors = []IsRetryableFunc{
-		func(err error) bool {
-			st, ok := status.FromError(err)
-			if !ok {
-				return false
-			}
-			switch st.Code() {
-			case codes.Unavailable, codes.ResourceExhausted:
-				return true
-			case codes.DeadlineExceeded:
-				return true
-			case codes.Internal:
-				switch {
-				case strings.Contains(st.Message(), `transport: received the unexpected content-type "text/html; charset=UTF-8"`):
-					return true
-				case strings.Contains(st.Message(), io.ErrUnexpectedEOF.Error()):
-					return true
-				case strings.Contains(st.Message(), `stream terminated by RST_STREAM with error code: INTERNAL_ERROR`):
-					return true
-				}
-			}
-			return false
-		},
-	}
-)
-
-// Unwrap provides error wrapping
-func (e *retryableError) Unwrap() error {
-	return e.err
-}
-
-// Error returns the error string
-func (e *retryableError) Error() string {
-	if e.err == nil {
-		return ""
-	}
-	return e.err.Error()
-}
-
-// IsRetryable checks error for ability to retry later
-func IsRetryable(err error, fns ...IsRetryableFunc) bool {
-	for _, fn := range fns {
-		if ok := fn(err); ok {
-			return true
-		}
-	}
-	return false
-}

errors/errors_test.go

@@ -1,28 +1,12 @@
 package errors
 
 import (
-	"encoding/json"
 	er "errors"
 	"fmt"
 	"net/http"
 	"testing"
 )
 
-func TestIsRetrayable(t *testing.T) {
-	err := fmt.Errorf("ORA-")
-	if !IsRetryable(err, RetrayableOracleErrors...) {
-		t.Fatalf("IsRetrayable not works")
-	}
-}
-
-func TestMarshalJSON(t *testing.T) {
-	e := InternalServerError("id", "err: %v", fmt.Errorf("err: %v", `xxx: "UNIX_TIMESTAMP": invalid identifier`))
-	_, err := json.Marshal(e)
-	if err != nil {
-		t.Fatal(err)
-	}
-}
-
 func TestEmpty(t *testing.T) {
 	msg := "test"
 	var err *Error
@@ -103,19 +87,3 @@ func TestErrors(t *testing.T) {
 		}
 	}
 }
-
-func TestCodeIn(t *testing.T) {
-	err := InternalServerError("id", "%s", "msg")
-
-	if ok := CodeIn(err, 400, 500); !ok {
-		t.Fatalf("CodeIn not works: %v", err)
-	}
-
-	if ok := CodeIn(err.(*Error).Code, 500); !ok {
-		t.Fatalf("CodeIn not works: %v", err)
-	}
-
-	if ok := CodeIn(err, 100); ok {
-		t.Fatalf("CodeIn not works: %v", err)
-	}
-}

flow/context_test.go

@@ -1,53 +0,0 @@
-package flow
-
-import (
-	"context"
-	"testing"
-)
-
-func TestFromNilContext(t *testing.T) {
-	// nolint: staticcheck
-	c, ok := FromContext(nil)
-	if ok || c != nil {
-		t.Fatal("FromContext not works")
-	}
-}
-
-func TestNewNilContext(t *testing.T) {
-	// nolint: staticcheck
-	ctx := NewContext(nil, NewFlow())
-
-	c, ok := FromContext(ctx)
-	if c == nil || !ok {
-		t.Fatal("NewContext not works")
-	}
-}
-
-func TestFromContext(t *testing.T) {
-	ctx := context.WithValue(context.TODO(), flowKey{}, NewFlow())
-
-	c, ok := FromContext(ctx)
-	if c == nil || !ok {
-		t.Fatal("FromContext not works")
-	}
-}
-
-func TestNewContext(t *testing.T) {
-	ctx := NewContext(context.TODO(), NewFlow())
-
-	c, ok := FromContext(ctx)
-	if c == nil || !ok {
-		t.Fatal("NewContext not works")
-	}
-}
-
-func TestSetOption(t *testing.T) {
-	type key struct{}
-	o := SetOption(key{}, "test")
-	opts := &Options{}
-	o(opts)
-
-	if v, ok := opts.Context.Value(key{}).(string); !ok || v == "" {
-		t.Fatal("SetOption not works")
-	}
-}

flow/dag_test.go

@@ -7,56 +7,6 @@ import (
 	"github.com/silas/dag"
 )
 
-func TestDeps(t *testing.T) {
-	t.Skip()
-	d := &dag.AcyclicGraph{}
-
-	v0 := d.Add(&node{"v0"})
-	v1 := d.Add(&node{"v1"})
-	v2 := d.Add(&node{"v2"})
-	v3 := d.Add(&node{"v3"})
-	v4 := d.Add(&node{"v4"})
-
-	d.Connect(dag.BasicEdge(v0, v1))
-	d.Connect(dag.BasicEdge(v1, v2))
-	d.Connect(dag.BasicEdge(v2, v4))
-	d.Connect(dag.BasicEdge(v0, v3))
-	d.Connect(dag.BasicEdge(v3, v4))
-
-	if err := d.Validate(); err != nil {
-		t.Fatal(err)
-	}
-
-	d.TransitiveReduction()
-
-	var steps [][]string
-	fn := func(n dag.Vertex, idx int) error {
-		if idx == 0 {
-			steps = make([][]string, 1)
-			steps[0] = make([]string, 0, 1)
-		} else if idx >= len(steps) {
-			tsteps := make([][]string, idx+1)
-			copy(tsteps, steps)
-			steps = tsteps
-			steps[idx] = make([]string, 0, 1)
-		}
-		steps[idx] = append(steps[idx], fmt.Sprintf("%s", n))
-		return nil
-	}
-
-	start := &node{"v0"}
-	err := d.SortedDepthFirstWalk([]dag.Vertex{start}, fn)
-	checkErr(t, err)
-
-	for idx, steps := range steps {
-		fmt.Printf("level %d steps %#+v\n", idx, steps)
-	}
-
-	if len(steps[2]) != 1 {
-		t.Logf("invalid steps %#+v", steps[2])
-	}
-}
-
 func checkErr(t *testing.T, err error) {
 	if err != nil {
 		t.Fatal(err)

flow/default.go

@@ -3,6 +3,7 @@ package flow
 import (
 	"context"
 	"fmt"
+	"path/filepath"
 	"sync"
 
 	"github.com/silas/dag"
@@ -149,17 +150,17 @@ func (w *microWorkflow) getSteps(start string, reverse bool) ([][]Step, error) {
 }
 
 func (w *microWorkflow) Abort(ctx context.Context, id string) error {
-	workflowStore := store.NewNamespaceStore(w.opts.Store, "workflows"+w.opts.Store.Options().Separator+id)
+	workflowStore := store.NewNamespaceStore(w.opts.Store, filepath.Join("workflows", id))
 	return workflowStore.Write(ctx, "status", &codec.Frame{Data: []byte(StatusAborted.String())})
 }
 
 func (w *microWorkflow) Suspend(ctx context.Context, id string) error {
-	workflowStore := store.NewNamespaceStore(w.opts.Store, "workflows"+w.opts.Store.Options().Separator+id)
+	workflowStore := store.NewNamespaceStore(w.opts.Store, filepath.Join("workflows", id))
 	return workflowStore.Write(ctx, "status", &codec.Frame{Data: []byte(StatusSuspend.String())})
 }
 
 func (w *microWorkflow) Resume(ctx context.Context, id string) error {
-	workflowStore := store.NewNamespaceStore(w.opts.Store, "workflows"+w.opts.Store.Options().Separator+id)
+	workflowStore := store.NewNamespaceStore(w.opts.Store, filepath.Join("workflows", id))
 	return workflowStore.Write(ctx, "status", &codec.Frame{Data: []byte(StatusRunning.String())})
 }
 
@@ -180,15 +181,15 @@ func (w *microWorkflow) Execute(ctx context.Context, req *Message, opts ...Execu
 		return "", err
 	}
 
-	stepStore := store.NewNamespaceStore(w.opts.Store, "steps"+w.opts.Store.Options().Separator+eid)
+	stepStore := store.NewNamespaceStore(w.opts.Store, filepath.Join("steps", eid))
-	workflowStore := store.NewNamespaceStore(w.opts.Store, "workflows"+w.opts.Store.Options().Separator+eid)
+	workflowStore := store.NewNamespaceStore(w.opts.Store, filepath.Join("workflows", eid))
 
 	options := NewExecuteOptions(opts...)
 
 	steps, err := w.getSteps(options.Start, options.Reverse)
 	if err != nil {
 		if werr := workflowStore.Write(w.opts.Context, "status", &codec.Frame{Data: []byte(StatusPending.String())}); werr != nil {
-			w.opts.Logger.Error(w.opts.Context, "store write error", werr)
+			w.opts.Logger.Errorf(w.opts.Context, "store error: %v", werr)
 		}
 		return "", err
 	}
@@ -212,13 +213,13 @@ func (w *microWorkflow) Execute(ctx context.Context, req *Message, opts ...Execu
 	done := make(chan struct{})
 
 	if werr := workflowStore.Write(w.opts.Context, "status", &codec.Frame{Data: []byte(StatusRunning.String())}); werr != nil {
-		w.opts.Logger.Error(w.opts.Context, "store write error", werr)
+		w.opts.Logger.Errorf(w.opts.Context, "store error: %v", werr)
 		return eid, werr
 	}
 	for idx := range steps {
 		for nidx := range steps[idx] {
 			cstep := steps[idx][nidx]
-			if werr := stepStore.Write(ctx, cstep.ID()+w.opts.Store.Options().Separator+"status", &codec.Frame{Data: []byte(StatusPending.String())}); werr != nil {
+			if werr := stepStore.Write(ctx, filepath.Join(cstep.ID(), "status"), &codec.Frame{Data: []byte(StatusPending.String())}); werr != nil {
 				return eid, werr
 			}
 		}
@@ -237,7 +238,7 @@ func (w *microWorkflow) Execute(ctx context.Context, req *Message, opts ...Execu
 					return
 				}
 				if w.opts.Logger.V(logger.TraceLevel) {
-					w.opts.Logger.Trace(nctx, fmt.Sprintf("will be executed %v", steps[idx][nidx]))
+					w.opts.Logger.Tracef(nctx, "will be executed %v", steps[idx][nidx])
 				}
 				cstep := steps[idx][nidx]
 				// nolint: nestif
@@ -245,65 +246,65 @@ func (w *microWorkflow) Execute(ctx context.Context, req *Message, opts ...Execu
 					wg.Add(1)
 					go func(step Step) {
 						defer wg.Done()
-						if werr := stepStore.Write(ctx, step.ID()+w.opts.Store.Options().Separator+"req", req); werr != nil {
+						if werr := stepStore.Write(ctx, filepath.Join(step.ID(), "req"), req); werr != nil {
 							cherr <- werr
 							return
 						}
-						if werr := stepStore.Write(ctx, step.ID()+w.opts.Store.Options().Separator+"status", &codec.Frame{Data: []byte(StatusRunning.String())}); werr != nil {
+						if werr := stepStore.Write(ctx, filepath.Join(step.ID(), "status"), &codec.Frame{Data: []byte(StatusRunning.String())}); werr != nil {
 							cherr <- werr
 							return
 						}
 						rsp, serr := step.Execute(nctx, req, nopts...)
 						if serr != nil {
 							step.SetStatus(StatusFailure)
-							if werr := stepStore.Write(ctx, step.ID()+w.opts.Store.Options().Separator+"rsp", serr); werr != nil && w.opts.Logger.V(logger.ErrorLevel) {
+							if werr := stepStore.Write(ctx, filepath.Join(step.ID(), "rsp"), serr); werr != nil && w.opts.Logger.V(logger.ErrorLevel) {
-								w.opts.Logger.Error(ctx, "store write error", werr)
+								w.opts.Logger.Errorf(ctx, "store write error: %v", werr)
 							}
-							if werr := stepStore.Write(ctx, step.ID()+w.opts.Store.Options().Separator+"status", &codec.Frame{Data: []byte(StatusFailure.String())}); werr != nil && w.opts.Logger.V(logger.ErrorLevel) {
+							if werr := stepStore.Write(ctx, filepath.Join(step.ID(), "status"), &codec.Frame{Data: []byte(StatusFailure.String())}); werr != nil && w.opts.Logger.V(logger.ErrorLevel) {
-								w.opts.Logger.Error(ctx, "store write error", werr)
+								w.opts.Logger.Errorf(ctx, "store write error: %v", werr)
 							}
 							cherr <- serr
 							return
 						}
-						if werr := stepStore.Write(ctx, step.ID()+w.opts.Store.Options().Separator+"rsp", rsp); werr != nil {
+						if werr := stepStore.Write(ctx, filepath.Join(step.ID(), "rsp"), rsp); werr != nil {
-							w.opts.Logger.Error(ctx, "store write error", werr)
+							w.opts.Logger.Errorf(ctx, "store write error: %v", werr)
 							cherr <- werr
 							return
 						}
-						if werr := stepStore.Write(ctx, step.ID()+w.opts.Store.Options().Separator+"status", &codec.Frame{Data: []byte(StatusSuccess.String())}); werr != nil {
+						if werr := stepStore.Write(ctx, filepath.Join(step.ID(), "status"), &codec.Frame{Data: []byte(StatusSuccess.String())}); werr != nil {
-							w.opts.Logger.Error(ctx, "store write error", werr)
+							w.opts.Logger.Errorf(ctx, "store write error: %v", werr)
 							cherr <- werr
 							return
 						}
 					}(cstep)
 					wg.Wait()
 				} else {
-					if werr := stepStore.Write(ctx, cstep.ID()+w.opts.Store.Options().Separator+"req", req); werr != nil {
+					if werr := stepStore.Write(ctx, filepath.Join(cstep.ID(), "req"), req); werr != nil {
 						cherr <- werr
 						return
 					}
-					if werr := stepStore.Write(ctx, cstep.ID()+w.opts.Store.Options().Separator+"status", &codec.Frame{Data: []byte(StatusRunning.String())}); werr != nil {
+					if werr := stepStore.Write(ctx, filepath.Join(cstep.ID(), "status"), &codec.Frame{Data: []byte(StatusRunning.String())}); werr != nil {
 						cherr <- werr
 						return
 					}
 					rsp, serr := cstep.Execute(nctx, req, nopts...)
 					if serr != nil {
 						cstep.SetStatus(StatusFailure)
-						if werr := stepStore.Write(ctx, cstep.ID()+w.opts.Store.Options().Separator+"rsp", serr); werr != nil && w.opts.Logger.V(logger.ErrorLevel) {
+						if werr := stepStore.Write(ctx, filepath.Join(cstep.ID(), "rsp"), serr); werr != nil && w.opts.Logger.V(logger.ErrorLevel) {
-							w.opts.Logger.Error(ctx, "store write error", werr)
+							w.opts.Logger.Errorf(ctx, "store write error: %v", werr)
 						}
-						if werr := stepStore.Write(ctx, cstep.ID()+w.opts.Store.Options().Separator+"status", &codec.Frame{Data: []byte(StatusFailure.String())}); werr != nil && w.opts.Logger.V(logger.ErrorLevel) {
+						if werr := stepStore.Write(ctx, filepath.Join(cstep.ID(), "status"), &codec.Frame{Data: []byte(StatusFailure.String())}); werr != nil && w.opts.Logger.V(logger.ErrorLevel) {
-							w.opts.Logger.Error(ctx, "store write error", werr)
+							w.opts.Logger.Errorf(ctx, "store write error: %v", werr)
 						}
 						cherr <- serr
 						return
 					}
-					if werr := stepStore.Write(ctx, cstep.ID()+w.opts.Store.Options().Separator+"rsp", rsp); werr != nil {
+					if werr := stepStore.Write(ctx, filepath.Join(cstep.ID(), "rsp"), rsp); werr != nil {
-						w.opts.Logger.Error(ctx, "store write error", werr)
+						w.opts.Logger.Errorf(ctx, "store write error: %v", werr)
 						cherr <- werr
 						return
 					}
-					if werr := stepStore.Write(ctx, cstep.ID()+w.opts.Store.Options().Separator+"status", &codec.Frame{Data: []byte(StatusSuccess.String())}); werr != nil {
+					if werr := stepStore.Write(ctx, filepath.Join(cstep.ID(), "status"), &codec.Frame{Data: []byte(StatusSuccess.String())}); werr != nil {
 						cherr <- werr
 						return
 					}
@@ -317,7 +318,7 @@ func (w *microWorkflow) Execute(ctx context.Context, req *Message, opts ...Execu
 		return eid, nil
 	}
 
-	logger.DefaultLogger.Trace(ctx, "wait for finish or error")
+	logger.Tracef(ctx, "wait for finish or error")
 	select {
 	case <-nctx.Done():
 		err = nctx.Err()
@@ -333,15 +334,15 @@ func (w *microWorkflow) Execute(ctx context.Context, req *Message, opts ...Execu
 	switch {
 	case nctx.Err() != nil:
 		if werr := workflowStore.Write(w.opts.Context, "status", &codec.Frame{Data: []byte(StatusAborted.String())}); werr != nil {
-			w.opts.Logger.Error(w.opts.Context, "store write error", werr)
+			w.opts.Logger.Errorf(w.opts.Context, "store error: %v", werr)
 		}
 	case err == nil:
 		if werr := workflowStore.Write(w.opts.Context, "status", &codec.Frame{Data: []byte(StatusSuccess.String())}); werr != nil {
-			w.opts.Logger.Error(w.opts.Context, "store write error", werr)
+			w.opts.Logger.Errorf(w.opts.Context, "store error: %v", werr)
 		}
 	case err != nil:
 		if werr := workflowStore.Write(w.opts.Context, "status", &codec.Frame{Data: []byte(StatusFailure.String())}); werr != nil {
-			w.opts.Logger.Error(w.opts.Context, "store write error", werr)
+			w.opts.Logger.Errorf(w.opts.Context, "store error: %v", werr)
 		}
 	}
 

flow/flow.go

@@ -1,5 +1,5 @@
 // Package flow is an interface used for saga pattern microservice workflow
-package flow
+package flow // import "go.unistack.org/micro/v3/flow"
 
 import (
 	"context"
@@ -11,9 +11,7 @@ import (
 )
 
 var (
-	// ErrStepNotExists returns when step not found
 	ErrStepNotExists = errors.New("step not exists")
-	// ErrMissingClient returns when client.Client is missing
 	ErrMissingClient = errors.New("client not set")
 )
 
@@ -38,7 +36,6 @@ func (m *RawMessage) UnmarshalJSON(data []byte) error {
 	return nil
 }
 
-// Message used to transfer data between steps
 type Message struct {
 	Header metadata.Metadata
 	Body   RawMessage
@@ -70,7 +67,6 @@ type Step interface {
 	Response() *Message
 }
 
-// Status contains step current status
 type Status int
 
 func (status Status) String() string {
@@ -78,22 +74,15 @@ func (status Status) String() string {
 }
 
 const (
-	// StatusPending step waiting to start
 	StatusPending Status = iota
-	// StatusRunning step is running
 	StatusRunning
-	// StatusFailure step competed with error
 	StatusFailure
-	// StatusSuccess step completed without error
 	StatusSuccess
-	// StatusAborted step aborted while it running
 	StatusAborted
-	// StatusSuspend step suspended
 	StatusSuspend
 )
 
 var (
-	// StatusString contains map status => string
 	StatusString = map[Status]string{
 		StatusPending: "StatusPending",
 		StatusRunning: "StatusRunning",
@@ -102,7 +91,6 @@ var (
 		StatusAborted: "StatusAborted",
 		StatusSuspend: "StatusSuspend",
 	}
-	// StringStatus contains map string => status
 	StringStatus = map[string]Status{
 		"StatusPending": StatusPending,
 		"StatusRunning": StatusRunning,
@@ -156,7 +144,6 @@ var (
 	atomicSteps atomic.Value
 )
 
-// RegisterStep register own step with workflow
 func RegisterStep(step Step) {
 	flowMu.Lock()
 	steps, _ := atomicSteps.Load().([]Step)

flow/options.go

@@ -91,7 +91,7 @@ func Store(s store.Store) Option {
 	}
 }
 
-// WorkflowOption func signature
+// WorflowOption func signature
 type WorkflowOption func(*WorkflowOptions)
 
 // WorkflowOptions holds workflow options

fsm/default.go

@@ -1,126 +0,0 @@
-package fsm
-
-import (
-	"context"
-	"fmt"
-	"sync"
-)
-
-type state struct {
-	body interface{}
-	name string
-}
-
-var _ State = &state{}
-
-func (s *state) Name() string {
-	return s.name
-}
-
-func (s *state) Body() interface{} {
-	return s.body
-}
-
-// fsm is a finite state machine
-type fsm struct {
-	statesMap   map[string]StateFunc
-	current     string
-	statesOrder []string
-	opts        Options
-	mu          sync.Mutex
-}
-
-// NewFSM creates a new finite state machine having the specified initial state
-// with specified options
-func NewFSM(opts ...Option) *fsm {
-	return &fsm{
-		statesMap: map[string]StateFunc{},
-		opts:      NewOptions(opts...),
-	}
-}
-
-// Current returns the current state
-func (f *fsm) Current() string {
-	f.mu.Lock()
-	s := f.current
-	f.mu.Unlock()
-	return s
-}
-
-// Current returns the current state
-func (f *fsm) Reset() {
-	f.mu.Lock()
-	f.current = f.opts.Initial
-	f.mu.Unlock()
-}
-
-// State adds state to fsm
-func (f *fsm) State(state string, fn StateFunc) {
-	f.mu.Lock()
-	f.statesMap[state] = fn
-	f.statesOrder = append(f.statesOrder, state)
-	f.mu.Unlock()
-}
-
-// Start runs state machine with provided data
-func (f *fsm) Start(ctx context.Context, args interface{}, opts ...Option) (interface{}, error) {
-	var err error
-
-	f.mu.Lock()
-	options := f.opts
-
-	for _, opt := range opts {
-		opt(&options)
-	}
-
-	sopts := []StateOption{StateDryRun(options.DryRun)}
-
-	cstate := options.Initial
-	states := make(map[string]StateFunc, len(f.statesMap))
-	for k, v := range f.statesMap {
-		states[k] = v
-	}
-	f.current = cstate
-	f.mu.Unlock()
-
-	var s State
-	s = &state{name: cstate, body: args}
-	nstate := s.Name()
-
-	for {
-		select {
-		case <-ctx.Done():
-			return nil, ctx.Err()
-		default:
-			fn, ok := states[nstate]
-			if !ok {
-				return nil, fmt.Errorf(`state "%s" %w`, nstate, ErrInvalidState)
-			}
-			f.mu.Lock()
-			f.current = nstate
-			f.mu.Unlock()
-
-			// wrap the handler func
-			for i := len(options.Wrappers); i > 0; i-- {
-				fn = options.Wrappers[i-1](fn)
-			}
-
-			s, err = fn(ctx, s, sopts...)
-
-			switch {
-			case err != nil:
-				return s.Body(), err
-			case s.Name() == StateEnd:
-				return s.Body(), nil
-			case s.Name() == "":
-				for idx := range f.statesOrder {
-					if f.statesOrder[idx] == nstate && len(f.statesOrder) > idx+1 {
-						nstate = f.statesOrder[idx+1]
-					}
-				}
-			default:
-				nstate = s.Name()
-			}
-		}
-	}
-}

fsm/fsm.go

@@ -1,29 +0,0 @@
-package fsm
-
-import (
-	"context"
-	"errors"
-)
-
-var (
-	ErrInvalidState = errors.New("does not exists")
-	StateEnd        = "end"
-)
-
-type State interface {
-	Name() string
-	Body() interface{}
-}
-
-// StateWrapper wraps the StateFunc and returns the equivalent
-type StateWrapper func(StateFunc) StateFunc
-
-// StateFunc called on state transition and return next step and error
-type StateFunc func(ctx context.Context, state State, opts ...StateOption) (State, error)
-
-type FSM interface {
-	Start(context.Context, interface{}, ...Option) (interface{}, error)
-	Current() string
-	Reset()
-	State(string, StateFunc)
-}

fsm/fsm_test.go

@@ -1,72 +0,0 @@
-package fsm
-
-import (
-	"context"
-	"fmt"
-	"testing"
-
-	"go.unistack.org/micro/v3/logger"
-)
-
-func TestFSMStart(t *testing.T) {
-	ctx := context.TODO()
-
-	if err := logger.DefaultLogger.Init(); err != nil {
-		t.Fatal(err)
-	}
-
-	wrapper := func(next StateFunc) StateFunc {
-		return func(sctx context.Context, s State, opts ...StateOption) (State, error) {
-			sctx = logger.NewContext(sctx, logger.DefaultLogger.Fields("state", s.Name()))
-			return next(sctx, s, opts...)
-		}
-	}
-
-	f := NewFSM(InitialState("1"), WrapState(wrapper))
-	f1 := func(sctx context.Context, s State, opts ...StateOption) (State, error) {
-		_, ok := logger.FromContext(sctx)
-		if !ok {
-			t.Fatal("f1 context does not have logger")
-		}
-		args := s.Body().(map[string]interface{})
-		if v, ok := args["request"].(string); !ok || v == "" {
-			return nil, fmt.Errorf("empty request")
-		}
-		return &state{name: "", body: map[string]interface{}{"response": "state1"}}, nil
-	}
-	f2 := func(sctx context.Context, s State, opts ...StateOption) (State, error) {
-		_, ok := logger.FromContext(sctx)
-		if !ok {
-			t.Fatal("f2 context does not have logger")
-		}
-		args := s.Body().(map[string]interface{})
-		if v, ok := args["response"].(string); !ok || v == "" {
-			return nil, fmt.Errorf("empty response")
-		}
-		return &state{name: "", body: map[string]interface{}{"response": "state2"}}, nil
-	}
-	f3 := func(sctx context.Context, s State, opts ...StateOption) (State, error) {
-		_, ok := logger.FromContext(sctx)
-		if !ok {
-			t.Fatal("f3 context does not have logger")
-		}
-		args := s.Body().(map[string]interface{})
-		if v, ok := args["response"].(string); !ok || v == "" {
-			return nil, fmt.Errorf("empty response")
-		}
-		return &state{name: StateEnd, body: map[string]interface{}{"response": "state3"}}, nil
-	}
-	f.State("1", f1)
-	f.State("2", f2)
-	f.State("3", f3)
-	rsp, err := f.Start(ctx, map[string]interface{}{"request": "state"})
-	if err != nil {
-		t.Fatal(err)
-	}
-	args := rsp.(map[string]interface{})
-	if v, ok := args["response"].(string); !ok || v == "" {
-		t.Fatalf("nil rsp: %#+v", args)
-	} else if v != "state3" {
-		t.Fatalf("invalid rsp %#+v", args)
-	}
-}

fsm/options.go

@@ -1,52 +0,0 @@
-package fsm
-
-// Options struct holding fsm options
-type Options struct {
-	// Initial state
-	Initial string
-	// Wrappers runs before state
-	Wrappers []StateWrapper
-	// DryRun mode
-	DryRun bool
-}
-
-// Option func signature
-type Option func(*Options)
-
-// StateOptions holds state options
-type StateOptions struct {
-	DryRun bool
-}
-
-// StateDryRun says that state executes in dry run mode
-func StateDryRun(b bool) StateOption {
-	return func(o *StateOptions) {
-		o.DryRun = b
-	}
-}
-
-// StateOption func signature
-type StateOption func(*StateOptions)
-
-// InitialState sets init state for state machine
-func InitialState(initial string) Option {
-	return func(o *Options) {
-		o.Initial = initial
-	}
-}
-
-// WrapState adds a state Wrapper to a list of options passed into the fsm
-func WrapState(w StateWrapper) Option {
-	return func(o *Options) {
-		o.Wrappers = append(o.Wrappers, w)
-	}
-}
-
-// NewOptions returns new Options struct filled by passed Option
-func NewOptions(opts ...Option) Options {
-	options := Options{}
-	for _, o := range opts {
-		o(&options)
-	}
-	return options
-}

function.go

@@ -0,0 +1,101 @@
+//go:build ignore
+// +build ignore
+
+package micro
+
+import (
+	"context"
+	"time"
+
+	"go.unistack.org/micro/v3/server"
+)
+
+// Function is a one time executing Service
+type Function interface {
+	// Inherits Service interface
+	Service
+	// Done signals to complete execution
+	Done() error
+	// Handle registers an RPC handler
+	Handle(v interface{}) error
+	// Subscribe registers a subscriber
+	Subscribe(topic string, v interface{}) error
+}
+
+type function struct {
+	cancel context.CancelFunc
+	Service
+}
+
+// NewFunction returns a new Function for a one time executing Service
+func NewFunction(opts ...Option) Function {
+	return newFunction(opts...)
+}
+
+func fnHandlerWrapper(f Function) server.HandlerWrapper {
+	return func(h server.HandlerFunc) server.HandlerFunc {
+		return func(ctx context.Context, req server.Request, rsp interface{}) error {
+			defer f.Done()
+			return h(ctx, req, rsp)
+		}
+	}
+}
+
+func fnSubWrapper(f Function) server.SubscriberWrapper {
+	return func(s server.SubscriberFunc) server.SubscriberFunc {
+		return func(ctx context.Context, msg server.Message) error {
+			defer f.Done()
+			return s(ctx, msg)
+		}
+	}
+}
+
+func newFunction(opts ...Option) Function {
+	ctx, cancel := context.WithCancel(context.Background())
+
+	// force ttl/interval
+	fopts := []Option{
+		RegisterTTL(time.Minute),
+		RegisterInterval(time.Second * 30),
+	}
+
+	// prepend to opts
+	fopts = append(fopts, opts...)
+
+	// make context the last thing
+	fopts = append(fopts, Context(ctx))
+
+	service := &service{opts: NewOptions(fopts...)}
+
+	fn := &function{
+		cancel:  cancel,
+		Service: service,
+	}
+
+	service.Server().Init(
+		// ensure the service waits for requests to finish
+		server.Wait(nil),
+		// wrap handlers and subscribers to finish execution
+		server.WrapHandler(fnHandlerWrapper(fn)),
+		server.WrapSubscriber(fnSubWrapper(fn)),
+	)
+
+	return fn
+}
+
+func (f *function) Done() error {
+	f.cancel()
+	return nil
+}
+
+func (f *function) Handle(v interface{}) error {
+	return f.Service.Server().Handle(
+		f.Service.Server().NewHandler(v),
+	)
+}
+
+func (f *function) Subscribe(topic string, v interface{}) error {
+	return f.Service.Server().Subscribe(
+		f.Service.Server().NewSubscriber(topic, v),
+	)
+}

function_test.go

@@ -0,0 +1,67 @@
+//go:build ignore
+// +build ignore
+
+package micro
+
+/*
+import (
+	"context"
+	"sync"
+	"testing"
+
+	"go.unistack.org/micro/v3/register"
+)
+
+func TestFunction(t *testing.T) {
+	var wg sync.WaitGroup
+	wg.Add(1)
+
+	r := register.NewRegister()
+	ctx := context.TODO()
+	// create service
+	fn := NewFunction(
+		Register(r),
+		Name("test.function"),
+		AfterStart(func(ctx context.Context) error {
+			wg.Done()
+			return nil
+		}),
+	)
+
+	// we can't test fn.Init as it parses the command line
+	// fn.Init()
+
+	ch := make(chan error, 2)
+
+	go func() {
+		// run service
+		ch <- fn.Run()
+	}()
+
+	// wait for start
+	wg.Wait()
+
+	// test call debug
+	req := fn.Client().NewRequest(
+		"test.function",
+		"Debug.Health",
+		new(proto.HealthRequest),
+	)
+
+	rsp := new(proto.HealthResponse)
+
+	err := fn.Client().Call(context.TODO(), req, rsp)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	if rsp.Status != "ok" {
+		t.Fatalf("function response: %s", rsp.Status)
+	}
+
+	if err := <-ch; err != nil {
+		t.Fatal(err)
+	}
+}
+
+*/

go.mod

@@ -1,32 +1,14 @@
 module go.unistack.org/micro/v3
 
-go 1.22
+go 1.16
 
 require (
-	dario.cat/mergo v1.0.0
+	github.com/ef-ds/deque v1.0.4
-	github.com/DATA-DOG/go-sqlmock v1.5.0
+	github.com/golang-jwt/jwt/v4 v4.2.0
-	github.com/KimMachineGun/automemlimit v0.6.1
+	github.com/imdario/mergo v0.3.12
-	github.com/google/uuid v1.3.0
 	github.com/patrickmn/go-cache v2.1.0+incompatible
-	github.com/silas/dag v0.0.0-20220518035006-a7e85ada93c5
+	github.com/silas/dag v0.0.0-20211117232152-9d50aa809f35
-	go.uber.org/automaxprocs v1.6.0
+	go.unistack.org/micro-proto/v3 v3.1.1
-	go.unistack.org/micro-proto/v3 v3.4.1
+	golang.org/x/net v0.0.0-20210928044308-7d9f5e0b762b
-	golang.org/x/sync v0.3.0
+	golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1 // indirect
-	google.golang.org/grpc v1.57.0
-	google.golang.org/protobuf v1.33.0
-)
-
-require (
-	github.com/cilium/ebpf v0.9.1 // indirect
-	github.com/containerd/cgroups/v3 v3.0.1 // indirect
-	github.com/coreos/go-systemd/v22 v22.3.2 // indirect
-	github.com/docker/go-units v0.4.0 // indirect
-	github.com/godbus/dbus/v5 v5.0.4 // indirect
-	github.com/golang/protobuf v1.5.3 // indirect
-	github.com/opencontainers/runtime-spec v1.0.2 // indirect
-	github.com/pbnjay/memory v0.0.0-20210728143218-7b4eea64cf58 // indirect
-	github.com/sirupsen/logrus v1.8.1 // indirect
-	golang.org/x/net v0.14.0 // indirect
-	golang.org/x/sys v0.11.0 // indirect
-	google.golang.org/genproto/googleapis/rpc v0.0.0-20230526203410-71b5a4ffd15e // indirect
 )

go.sum

@@ -1,78 +1,31 @@
-dario.cat/mergo v1.0.0 h1:AGCNq9Evsj31mOgNPcLyXc+4PNABt905YmuqPYYpBWk=
+github.com/ef-ds/deque v1.0.4 h1:iFAZNmveMT9WERAkqLJ+oaABF9AcVQ5AjXem/hroniI=
-dario.cat/mergo v1.0.0/go.mod h1:uNxQE+84aUszobStD9th8a29P2fMDhsBdgRYvZOxGmk=
+github.com/ef-ds/deque v1.0.4/go.mod h1:gXDnTC3yqvBcHbq2lcExjtAcVrOnJCbMcZXmuj8Z4tg=
-github.com/DATA-DOG/go-sqlmock v1.5.0 h1:Shsta01QNfFxHCfpW6YH2STWB0MudeXXEWMr20OEh60=
+github.com/golang-jwt/jwt/v4 v4.2.0 h1:besgBTC8w8HjP6NzQdxwKH9Z5oQMZ24ThTrHp3cZ8eU=
-github.com/DATA-DOG/go-sqlmock v1.5.0/go.mod h1:f/Ixk793poVmq4qj/V1dPUg2JEAKC73Q5eFN3EC/SaM=
+github.com/golang-jwt/jwt/v4 v4.2.0/go.mod h1:/xlHOz8bRuivTWchD4jCa+NbatV+wEUSzwAxVc6locg=
-github.com/KimMachineGun/automemlimit v0.6.1 h1:ILa9j1onAAMadBsyyUJv5cack8Y1WT26yLj/V+ulKp8=
-github.com/KimMachineGun/automemlimit v0.6.1/go.mod h1:T7xYht7B8r6AG/AqFcUdc7fzd2bIdBKmepfP2S1svPY=
-github.com/cilium/ebpf v0.9.1 h1:64sn2K3UKw8NbP/blsixRpF3nXuyhz/VjRlRzvlBRu4=
-github.com/cilium/ebpf v0.9.1/go.mod h1:+OhNOIXx/Fnu1IE8bJz2dzOA+VSfyTfdNUVdlQnxUFY=
-github.com/containerd/cgroups/v3 v3.0.1 h1:4hfGvu8rfGIwVIDd+nLzn/B9ZXx4BcCjzt5ToenJRaE=
-github.com/containerd/cgroups/v3 v3.0.1/go.mod h1:/vtwk1VXrtoa5AaZLkypuOJgA/6DyPMZHJPGQNtlHnw=
-github.com/coreos/go-systemd/v22 v22.3.2 h1:D9/bQk5vlXQFZ6Kwuu6zaiXJ9oTPe68++AzAJc1DzSI=
-github.com/coreos/go-systemd/v22 v22.3.2/go.mod h1:Y58oyj3AT4RCenI/lSvhwexgC+NSVTIJ3seZv2GcEnc=
-github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
-github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
-github.com/docker/go-units v0.4.0 h1:3uh0PgVws3nIA0Q+MwDC8yjEPf9zjRfZZWXZYDct3Tw=
-github.com/docker/go-units v0.4.0/go.mod h1:fgPhTUdO+D/Jk86RDLlptpiXQzgHJF7gydDDbaIK4Dk=
-github.com/frankban/quicktest v1.14.0 h1:+cqqvzZV87b4adx/5ayVOaYZ2CrvM4ejQvUdBzPPUss=
-github.com/frankban/quicktest v1.14.0/go.mod h1:NeW+ay9A/U67EYXNFA1nPE8e/tnQv/09mUdL/ijj8og=
-github.com/godbus/dbus/v5 v5.0.4 h1:9349emZab16e7zQvpmsbtjc18ykshndd8y2PG3sgJbA=
-github.com/godbus/dbus/v5 v5.0.4/go.mod h1:xhWf0FNVPg57R7Z0UbKHbJfkEywrmjJnf7w5xrFpKfA=
 github.com/golang/protobuf v1.5.0/go.mod h1:FsONVRAS9T7sI+LIUmWTfcYkHO4aIWwzhcaSAoJOfIk=
-github.com/golang/protobuf v1.5.3 h1:KhyjKVUg7Usr/dYsdSqoFveMYd5ko72D+zANwlG1mmg=
+github.com/google/go-cmp v0.5.5 h1:Khx7svrCpmxxtHBq5j2mp/xVjsi8hQMfNLvJFAlrGgU=
-github.com/golang/protobuf v1.5.3/go.mod h1:XVQd3VNwM+JqD3oG2Ue2ip4fOMUkwXdXDdiuN0vRsmY=
 github.com/google/go-cmp v0.5.5/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
-github.com/google/go-cmp v0.5.9 h1:O2Tfq5qg4qc4AmwVlvv0oLiVAGB7enBSJ2x2DqQFi38=
+github.com/imdario/mergo v0.3.12 h1:b6R2BslTbIEToALKP7LxUvijTsNI9TAe80pLWN2g/HU=
-github.com/google/go-cmp v0.5.9/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY=
+github.com/imdario/mergo v0.3.12/go.mod h1:jmQim1M+e3UYxmgPu/WyfjB3N3VflVyUjjjwH0dnCYA=
-github.com/google/uuid v1.3.0 h1:t6JiXgmwXMjEs8VusXIJk2BXHsn+wx8BZdTaoZ5fu7I=
-github.com/google/uuid v1.3.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
-github.com/kr/pretty v0.3.0 h1:WgNl7dwNpEZ6jJ9k1snq4pZsg7DOEN8hP9Xw0Tsjwk0=
-github.com/kr/pretty v0.3.0/go.mod h1:640gp4NfQd8pI5XOwp5fnNeVWj67G7CFk/SaSQn7NBk=
-github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY=
-github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE=
-github.com/opencontainers/runtime-spec v1.0.2 h1:UfAcuLBJB9Coz72x1hgl8O5RVzTdNiaglX6v2DM6FI0=
-github.com/opencontainers/runtime-spec v1.0.2/go.mod h1:jwyrGlmzljRJv/Fgzds9SsS/C5hL+LL3ko9hs6T5lQ0=
 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/pbnjay/memory v0.0.0-20210728143218-7b4eea64cf58 h1:onHthvaw9LFnH4t2DcNVpwGmV9E1BkGknEliJkfwQj0=
+github.com/silas/dag v0.0.0-20211117232152-9d50aa809f35 h1:4mohWoM/UGg1BvFFiqSPRl5uwJY3rVV0HQX0ETqauqQ=
-github.com/pbnjay/memory v0.0.0-20210728143218-7b4eea64cf58/go.mod h1:DXv8WO4yhMYhSNPKjeNKa5WY9YCIEBRbNzFFPJbWO6Y=
+github.com/silas/dag v0.0.0-20211117232152-9d50aa809f35/go.mod h1:7RTUFBdIRC9nZ7/3RyRNH1bdqIShrDejd1YbLwgPS+I=
-github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
+go.unistack.org/micro-proto/v3 v3.1.1 h1:78qRmltwGek5kSQ9tNmDZ9TCRvZM7YDIOgzriKvabjA=
-github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
+go.unistack.org/micro-proto/v3 v3.1.1/go.mod h1:DpRhYCBXlmSJ/AAXTmntvlh7kQkYU6eFvlmYAx4BQS8=
-github.com/prashantv/gostub v1.1.0 h1:BTyx3RfQjRHnUWaGF9oQos79AlQ5k8WNktv7VGvVH4g=
+golang.org/x/net v0.0.0-20210928044308-7d9f5e0b762b h1:eB48h3HiRycXNy8E0Gf5e0hv7YT6Kt14L/D73G1fuwo=
-github.com/prashantv/gostub v1.1.0/go.mod h1:A5zLQHz7ieHGG7is6LLXLz7I8+3LZzsrV0P1IAHhP5U=
+golang.org/x/net v0.0.0-20210928044308-7d9f5e0b762b/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y=
-github.com/rogpeppe/go-internal v1.6.1 h1:/FiVV8dS/e+YqF2JvO3yXRFbBLTIuSDkuC7aBOAvL+k=
+golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-github.com/rogpeppe/go-internal v1.6.1/go.mod h1:xXDCJY+GAPziupqXw64V24skbSoqbTEfhy4qGm1nDQc=
+golang.org/x/sys v0.0.0-20210423082822-04245dca01da/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-github.com/silas/dag v0.0.0-20220518035006-a7e85ada93c5 h1:G/FZtUu7a6NTWl3KUHMV9jkLAh/Rvtf03NWMHaEDl+E=
+golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
-github.com/silas/dag v0.0.0-20220518035006-a7e85ada93c5/go.mod h1:7RTUFBdIRC9nZ7/3RyRNH1bdqIShrDejd1YbLwgPS+I=
+golang.org/x/text v0.3.6/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
-github.com/sirupsen/logrus v1.8.1 h1:dJKuHgqk1NNQlqoA6BTlM1Wf9DOH3NBjQyu0h9+AZZE=
+golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
-github.com/sirupsen/logrus v1.8.1/go.mod h1:yWOB1SBYBC5VeMP7gHvWumXLIWorT60ONWic61uBYv0=
-github.com/stretchr/testify v1.2.2/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs=
-github.com/stretchr/testify v1.8.0 h1:pSgiaMZlXftHpm5L7V1+rVB+AZJydKsMxsQBIJw4PKk=
-github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU=
-go.uber.org/automaxprocs v1.6.0 h1:O3y2/QNTOdbF+e/dpXNNW7Rx2hZ4sTIPyybbxyNqTUs=
-go.uber.org/automaxprocs v1.6.0/go.mod h1:ifeIMSnPZuznNm6jmdzmU3/bfk01Fe2fotchwEFJ8r8=
-go.uber.org/goleak v1.1.12 h1:gZAh5/EyT/HQwlpkCy6wTpqfH9H8Lz8zbm3dZh+OyzA=
-go.uber.org/goleak v1.1.12/go.mod h1:cwTWslyiVhfpKIDGSZEM2HlOvcqm+tG4zioyIeLoqMQ=
-go.unistack.org/micro-proto/v3 v3.4.1 h1:UTjLSRz2YZuaHk9iSlVqqsA50JQNAEK2ZFboGqtEa9Q=
-go.unistack.org/micro-proto/v3 v3.4.1/go.mod h1:okx/cnOhzuCX0ggl/vToatbCupi0O44diiiLLsZ93Zo=
-golang.org/x/net v0.14.0 h1:BONx9s002vGdD9umnlX1Po8vOZmrgH34qlHcD1MfK14=
-golang.org/x/net v0.14.0/go.mod h1:PpSgVXXLK0OxS0F31C1/tv6XNguvCrnXIDrFMspZIUI=
-golang.org/x/sync v0.3.0 h1:ftCYgMx6zT/asHUrPw8BLLscYtGznsLAnjq5RH9P66E=
-golang.org/x/sync v0.3.0/go.mod h1:FU7BRWz2tNW+3quACPkgCx/L+uEAv1htQ0V83Z9Rj+Y=
-golang.org/x/sys v0.0.0-20191026070338-33540a1f6037/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.11.0 h1:eG7RXZHdqOJ1i+0lgLgCpSXAp6M3LYlAo6osgSi0xOM=
-golang.org/x/sys v0.11.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/text v0.12.0 h1:k+n5B8goJNdU7hSvEtMUz3d1Q6D/XW4COJSJR6fN0mc=
-golang.org/x/text v0.12.0/go.mod h1:TvPlkZtksWOMsz7fbANvkp4WM8x/WCo/om8BMLbz+aE=
 golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
-google.golang.org/genproto/googleapis/rpc v0.0.0-20230526203410-71b5a4ffd15e h1:NumxXLPfHSndr3wBBdeKiVHjGVFzi9RX2HwwQke94iY=
+golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1 h1:go1bK/D/BFZV2I8cIQd1NKEZ+0owSTG1fDTci4IqFcE=
-google.golang.org/genproto/googleapis/rpc v0.0.0-20230526203410-71b5a4ffd15e/go.mod h1:66JfowdXAEgad5O9NnYcsNPLCPZJD++2L9X0PCMODrA=
+golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
-google.golang.org/grpc v1.57.0 h1:kfzNeI/klCGD2YPMUlaGNT3pxvYfga7smW3Vth8Zsiw=
-google.golang.org/grpc v1.57.0/go.mod h1:Sd+9RMTACXwmub0zcNY2c4arhtrbBYD1AUHI/dt16Mo=
 google.golang.org/protobuf v1.26.0-rc.1/go.mod h1:jlhhOSvTdKEhbULTjvd4ARK9grFBp09yW+WbY/TyQbw=
-google.golang.org/protobuf v1.26.0/go.mod h1:9q0QmTI4eRPtz6boOQmLYwt+qCgq0jsYwAQnmE0givc=
+google.golang.org/protobuf v1.27.1 h1:SnqbnDw1V7RiZcXPx5MEeqPv2s79L9i7BJUlG/+RurQ=
-google.golang.org/protobuf v1.33.0 h1:uNO2rsAINq/JlFpSdYEKIZ0uKD/R9cpdv0T+yoGwGmI=
+google.golang.org/protobuf v1.27.1/go.mod h1:9q0QmTI4eRPtz6boOQmLYwt+qCgq0jsYwAQnmE0givc=
-google.golang.org/protobuf v1.33.0/go.mod h1:c6P6GXX6sHbq/GpV6MGZEdwhWPcYBgnhAHhKbcUYpos=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
-gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
+gopkg.in/yaml.v2 v2.3.0 h1:clyUAQHOM3G0M3f5vQj7LuJrETvjVot3Z5el9nffUtU=
-gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
+gopkg.in/yaml.v2 v2.3.0/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=

logger/context.go

@@ -4,17 +4,6 @@ import "context"
 
 type loggerKey struct{}
 
-// MustContext returns logger from passed context or DefaultLogger if empty
-func MustContext(ctx context.Context) Logger {
-	if ctx == nil {
-		return DefaultLogger
-	}
-	if l, ok := ctx.Value(loggerKey{}).(Logger); ok && l != nil {
-		return l
-	}
-	return DefaultLogger
-}
-
 // FromContext returns logger from passed context
 func FromContext(ctx context.Context) (Logger, bool) {
 	if ctx == nil {

logger/context_test.go

@@ -1,53 +0,0 @@
-package logger
-
-import (
-	"context"
-	"testing"
-)
-
-func TestFromNilContext(t *testing.T) {
-	// nolint: staticcheck
-	c, ok := FromContext(nil)
-	if ok || c != nil {
-		t.Fatal("FromContext not works")
-	}
-}
-
-func TestNewNilContext(t *testing.T) {
-	// nolint: staticcheck
-	ctx := NewContext(nil, NewLogger())
-
-	c, ok := FromContext(ctx)
-	if c == nil || !ok {
-		t.Fatal("NewContext not works")
-	}
-}
-
-func TestFromContext(t *testing.T) {
-	ctx := context.WithValue(context.TODO(), loggerKey{}, NewLogger())
-
-	c, ok := FromContext(ctx)
-	if c == nil || !ok {
-		t.Fatal("FromContext not works")
-	}
-}
-
-func TestNewContext(t *testing.T) {
-	ctx := NewContext(context.TODO(), NewLogger())
-
-	c, ok := FromContext(ctx)
-	if c == nil || !ok {
-		t.Fatal("NewContext not works")
-	}
-}
-
-func TestSetOption(t *testing.T) {
-	type key struct{}
-	o := SetOption(key{}, "test")
-	opts := &Options{}
-	o(opts)
-
-	if v, ok := opts.Context.Value(key{}).(string); !ok || v == "" {
-		t.Fatal("SetOption not works")
-	}
-}

logger/default.go

@@ -0,0 +1,243 @@
+package logger
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"os"
+	"runtime"
+	"strings"
+	"sync"
+	"time"
+)
+
+type defaultLogger struct {
+	sync.RWMutex
+	enc      *json.Encoder
+	logFunc  LogFunc
+	logfFunc LogfFunc
+	opts     Options
+}
+
+// Init(opts...) should only overwrite provided options
+func (l *defaultLogger) Init(opts ...Option) error {
+	l.Lock()
+	for _, o := range opts {
+		o(&l.opts)
+	}
+	l.enc = json.NewEncoder(l.opts.Out)
+	// wrap the Log func
+	for i := len(l.opts.Wrappers); i > 0; i-- {
+		l.logFunc = l.opts.Wrappers[i-1].Log(l.logFunc)
+		l.logfFunc = l.opts.Wrappers[i-1].Logf(l.logfFunc)
+	}
+	l.Unlock()
+	return nil
+}
+
+func (l *defaultLogger) String() string {
+	return "micro"
+}
+
+func (l *defaultLogger) Clone(opts ...Option) Logger {
+	newopts := NewOptions(opts...)
+	oldopts := l.opts
+	for _, o := range opts {
+		o(&newopts)
+		o(&oldopts)
+	}
+
+	oldopts.Wrappers = newopts.Wrappers
+	l.Lock()
+	cl := &defaultLogger{opts: oldopts, logFunc: l.logFunc, logfFunc: l.logfFunc}
+	l.Unlock()
+
+	// wrap the Log func
+	for i := len(newopts.Wrappers); i > 0; i-- {
+		cl.logFunc = newopts.Wrappers[i-1].Log(cl.logFunc)
+		cl.logfFunc = newopts.Wrappers[i-1].Logf(cl.logfFunc)
+	}
+
+	return cl
+}
+
+func (l *defaultLogger) V(level Level) bool {
+	l.RLock()
+	ok := l.opts.Level.Enabled(level)
+	l.RUnlock()
+	return ok
+}
+
+func (l *defaultLogger) Level(level Level) {
+	l.Lock()
+	l.opts.Level = level
+	l.Unlock()
+}
+
+func (l *defaultLogger) Fields(fields ...interface{}) Logger {
+	nl := &defaultLogger{opts: l.opts, enc: l.enc}
+	if len(fields) == 0 {
+		return nl
+	} else if len(fields)%2 != 0 {
+		fields = fields[:len(fields)-1]
+	}
+	nl.logFunc = l.logFunc
+	nl.logfFunc = l.logfFunc
+	nl.opts.Fields = append(nl.opts.Fields, fields...)
+	return nl
+}
+
+func copyFields(src []interface{}) []interface{} {
+	dst := make([]interface{}, len(src))
+	copy(dst, src)
+	return dst
+}
+
+// logCallerfilePath returns a package/file:line description of the caller,
+// preserving only the leaf directory name and file name.
+func logCallerfilePath(loggingFilePath string) string {
+	// To make sure we trim the path correctly on Windows too, we
+	// counter-intuitively need to use '/' and *not* os.PathSeparator here,
+	// because the path given originates from Go stdlib, specifically
+	// runtime.Caller() which (as of Mar/17) returns forward slashes even on
+	// Windows.
+	//
+	// See https://github.com/golang/go/issues/3335
+	// and https://github.com/golang/go/issues/18151
+	//
+	// for discussion on the issue on Go side.
+	idx := strings.LastIndexByte(loggingFilePath, '/')
+	if idx == -1 {
+		return loggingFilePath
+	}
+	idx = strings.LastIndexByte(loggingFilePath[:idx], '/')
+	if idx == -1 {
+		return loggingFilePath
+	}
+	return loggingFilePath[idx+1:]
+}
+
+func (l *defaultLogger) Info(ctx context.Context, args ...interface{}) {
+	l.Log(ctx, InfoLevel, args...)
+}
+
+func (l *defaultLogger) Error(ctx context.Context, args ...interface{}) {
+	l.Log(ctx, ErrorLevel, args...)
+}
+
+func (l *defaultLogger) Debug(ctx context.Context, args ...interface{}) {
+	l.Log(ctx, DebugLevel, args...)
+}
+
+func (l *defaultLogger) Warn(ctx context.Context, args ...interface{}) {
+	l.Log(ctx, WarnLevel, args...)
+}
+
+func (l *defaultLogger) Trace(ctx context.Context, args ...interface{}) {
+	l.Log(ctx, TraceLevel, args...)
+}
+
+func (l *defaultLogger) Fatal(ctx context.Context, args ...interface{}) {
+	l.Log(ctx, FatalLevel, args...)
+	os.Exit(1)
+}
+
+func (l *defaultLogger) Infof(ctx context.Context, msg string, args ...interface{}) {
+	l.logfFunc(ctx, InfoLevel, msg, args...)
+}
+
+func (l *defaultLogger) Errorf(ctx context.Context, msg string, args ...interface{}) {
+	l.logfFunc(ctx, ErrorLevel, msg, args...)
+}
+
+func (l *defaultLogger) Debugf(ctx context.Context, msg string, args ...interface{}) {
+	l.logfFunc(ctx, DebugLevel, msg, args...)
+}
+
+func (l *defaultLogger) Warnf(ctx context.Context, msg string, args ...interface{}) {
+	l.logfFunc(ctx, WarnLevel, msg, args...)
+}
+
+func (l *defaultLogger) Tracef(ctx context.Context, msg string, args ...interface{}) {
+	l.logfFunc(ctx, TraceLevel, msg, args...)
+}
+
+func (l *defaultLogger) Fatalf(ctx context.Context, msg string, args ...interface{}) {
+	l.logfFunc(ctx, FatalLevel, msg, args...)
+	os.Exit(1)
+}
+
+func (l *defaultLogger) Log(ctx context.Context, level Level, args ...interface{}) {
+	if !l.V(level) {
+		return
+	}
+
+	l.RLock()
+	fields := copyFields(l.opts.Fields)
+	l.RUnlock()
+
+	fields = append(fields, "level", level.String())
+
+	if _, file, line, ok := runtime.Caller(l.opts.CallerSkipCount); ok {
+		fields = append(fields, "caller", fmt.Sprintf("%s:%d", logCallerfilePath(file), line))
+	}
+	fields = append(fields, "timestamp", time.Now().Format("2006-01-02 15:04:05"))
+
+	if len(args) > 0 {
+		fields = append(fields, "msg", fmt.Sprint(args...))
+	}
+
+	out := make(map[string]interface{}, len(fields)/2)
+	for i := 0; i < len(fields); i += 2 {
+		out[fields[i].(string)] = fields[i+1]
+	}
+	l.RLock()
+	_ = l.enc.Encode(out)
+	l.RUnlock()
+}
+
+func (l *defaultLogger) Logf(ctx context.Context, level Level, msg string, args ...interface{}) {
+	if !l.V(level) {
+		return
+	}
+
+	l.RLock()
+	fields := copyFields(l.opts.Fields)
+	l.RUnlock()
+
+	fields = append(fields, "level", level.String())
+
+	if _, file, line, ok := runtime.Caller(l.opts.CallerSkipCount); ok {
+		fields = append(fields, "caller", fmt.Sprintf("%s:%d", logCallerfilePath(file), line))
+	}
+
+	fields = append(fields, "timestamp", time.Now().Format("2006-01-02 15:04:05"))
+	if len(args) > 0 {
+		fields = append(fields, "msg", fmt.Sprintf(msg, args...))
+	} else if msg != "" {
+		fields = append(fields, "msg", msg)
+	}
+
+	out := make(map[string]interface{}, len(fields)/2)
+	for i := 0; i < len(fields); i += 2 {
+		out[fields[i].(string)] = fields[i+1]
+	}
+	l.RLock()
+	_ = l.enc.Encode(out)
+	l.RUnlock()
+}
+
+func (l *defaultLogger) Options() Options {
+	return l.opts
+}
+
+// NewLogger builds a new logger based on options
+func NewLogger(opts ...Option) Logger {
+	l := &defaultLogger{
+		opts: NewOptions(opts...),
+	}
+	l.logFunc = l.Log
+	l.logfFunc = l.Logf
+	l.enc = json.NewEncoder(l.opts.Out)
+	return l
+}

logger/logger.go

@@ -1,19 +1,18 @@
 // Package logger provides a log interface
-package logger
+package logger // import "go.unistack.org/micro/v3/logger"
 
 import (
 	"context"
+	"os"
 )
 
-type ContextAttrFunc func(ctx context.Context) []interface{}
-
-var DefaultContextAttrFuncs []ContextAttrFunc
-
 var (
 	// DefaultLogger variable
-	DefaultLogger Logger = NewLogger()
+	DefaultLogger Logger = NewLogger(WithLevel(ParseLevel(os.Getenv("MICRO_LOG_LEVEL"))))
 	// DefaultLevel used by logger
-	DefaultLevel = InfoLevel
+	DefaultLevel Level = InfoLevel
+	// DefaultCallerSkipCount used by logger
+	DefaultCallerSkipCount = 2
 )
 
 // Logger is a generic logging interface
@@ -31,24 +30,111 @@ type Logger interface {
 	// Fields set fields to always be logged with keyval pairs
 	Fields(fields ...interface{}) Logger
 	// Info level message
-	Info(ctx context.Context, msg string, args ...interface{})
+	Info(ctx context.Context, args ...interface{})
 	// Trace level message
-	Trace(ctx context.Context, msg string, args ...interface{})
+	Trace(ctx context.Context, args ...interface{})
 	// Debug level message
-	Debug(ctx context.Context, msg string, args ...interface{})
+	Debug(ctx context.Context, args ...interface{})
 	// Warn level message
-	Warn(ctx context.Context, msg string, args ...interface{})
+	Warn(ctx context.Context, args ...interface{})
 	// Error level message
-	Error(ctx context.Context, msg string, args ...interface{})
+	Error(ctx context.Context, args ...interface{})
 	// Fatal level message
-	Fatal(ctx context.Context, msg string, args ...interface{})
+	Fatal(ctx context.Context, args ...interface{})
+	// Infof level message
+	Infof(ctx context.Context, msg string, args ...interface{})
+	// Tracef level message
+	Tracef(ctx context.Context, msg string, args ...interface{})
+	// Debug level message
+	Debugf(ctx context.Context, msg string, args ...interface{})
+	// Warn level message
+	Warnf(ctx context.Context, msg string, args ...interface{})
+	// Error level message
+	Errorf(ctx context.Context, msg string, args ...interface{})
+	// Fatal level message
+	Fatalf(ctx context.Context, msg string, args ...interface{})
 	// Log logs message with needed level
-	Log(ctx context.Context, level Level, msg string, args ...interface{})
+	Log(ctx context.Context, level Level, args ...interface{})
-	// Name returns broker instance name
+	// Logf logs message with needed level
-	Name() string
+	Logf(ctx context.Context, level Level, msg string, args ...interface{})
-	// String returns the type of logger
+	// String returns the name of logger
 	String() string
 }
 
 // Field contains keyval pair
 type Field interface{}
+
+// Info writes msg to default logger on info level
+func Info(ctx context.Context, args ...interface{}) {
+	DefaultLogger.Info(ctx, args...)
+}
+
+// Error writes msg to default logger on error level
+func Error(ctx context.Context, args ...interface{}) {
+	DefaultLogger.Error(ctx, args...)
+}
+
+// Debug writes msg to default logger on debug level
+func Debug(ctx context.Context, args ...interface{}) {
+	DefaultLogger.Debug(ctx, args...)
+}
+
+// Warn writes msg to default logger on warn level
+func Warn(ctx context.Context, args ...interface{}) {
+	DefaultLogger.Warn(ctx, args...)
+}
+
+// Trace writes msg to default logger on trace level
+func Trace(ctx context.Context, args ...interface{}) {
+	DefaultLogger.Trace(ctx, args...)
+}
+
+// Fatal writes msg to default logger on fatal level
+func Fatal(ctx context.Context, args ...interface{}) {
+	DefaultLogger.Fatal(ctx, args...)
+}
+
+// Infof writes formatted msg to default logger on info level
+func Infof(ctx context.Context, msg string, args ...interface{}) {
+	DefaultLogger.Infof(ctx, msg, args...)
+}
+
+// Errorf writes formatted msg to default logger on error level
+func Errorf(ctx context.Context, msg string, args ...interface{}) {
+	DefaultLogger.Errorf(ctx, msg, args...)
+}
+
+// Debugf writes formatted msg to default logger on debug level
+func Debugf(ctx context.Context, msg string, args ...interface{}) {
+	DefaultLogger.Debugf(ctx, msg, args...)
+}
+
+// Warnf writes formatted msg to default logger on warn level
+func Warnf(ctx context.Context, msg string, args ...interface{}) {
+	DefaultLogger.Warnf(ctx, msg, args...)
+}
+
+// Tracef writes formatted msg to default logger on trace level
+func Tracef(ctx context.Context, msg string, args ...interface{}) {
+	DefaultLogger.Tracef(ctx, msg, args...)
+}
+
+// Fatalf writes formatted msg to default logger on fatal level
+func Fatalf(ctx context.Context, msg string, args ...interface{}) {
+	DefaultLogger.Fatalf(ctx, msg, args...)
+}
+
+// V returns true if passed level enabled in default logger
+func V(level Level) bool {
+	return DefaultLogger.V(level)
+}
+
+// Init initialize logger
+func Init(opts ...Option) error {
+	return DefaultLogger.Init(opts...)
+}
+
+// Fields create logger with specific fields
+func Fields(fields ...interface{}) Logger {
+	return DefaultLogger.Fields(fields...)
+}

logger/logger_test.go

@@ -0,0 +1,148 @@
+package logger
+
+import (
+	"bytes"
+	"context"
+	"log"
+	"testing"
+)
+
+func TestContext(t *testing.T) {
+	ctx := context.TODO()
+	buf := bytes.NewBuffer(nil)
+	l := NewLogger(WithLevel(TraceLevel), WithOutput(buf))
+	if err := l.Init(); err != nil {
+		t.Fatal(err)
+	}
+
+	nl, ok := FromContext(NewContext(ctx, l.Fields("key", "val")))
+	if !ok {
+		t.Fatal("context without logger")
+	}
+	nl.Info(ctx, "message")
+	if !bytes.Contains(buf.Bytes(), []byte(`"key":"val"`)) {
+		t.Fatalf("logger fields not works, buf contains: %s", buf.Bytes())
+	}
+}
+
+func TestFields(t *testing.T) {
+	ctx := context.TODO()
+	buf := bytes.NewBuffer(nil)
+	l := NewLogger(WithLevel(TraceLevel), WithOutput(buf))
+	if err := l.Init(); err != nil {
+		t.Fatal(err)
+	}
+	l.Fields("key", "val").Info(ctx, "message")
+	if !bytes.Contains(buf.Bytes(), []byte(`"key":"val"`)) {
+		t.Fatalf("logger fields not works, buf contains: %s", buf.Bytes())
+	}
+}
+
+func TestClone(t *testing.T) {
+	ctx := context.TODO()
+	buf := bytes.NewBuffer(nil)
+	l := NewLogger(WithLevel(TraceLevel), WithOutput(buf))
+	if err := l.Init(); err != nil {
+		t.Fatal(err)
+	}
+	nl := l.Clone(WithLevel(ErrorLevel))
+	if err := nl.Init(); err != nil {
+		t.Fatal(err)
+	}
+	nl.Info(ctx, "info message")
+	if len(buf.Bytes()) != 0 {
+		t.Fatal("message must not be logged")
+	}
+	l.Info(ctx, "info message")
+	if len(buf.Bytes()) == 0 {
+		t.Fatal("message must be logged")
+	}
+}
+
+func TestRedirectStdLogger(t *testing.T) {
+	buf := bytes.NewBuffer(nil)
+	l := NewLogger(WithLevel(TraceLevel), WithOutput(buf))
+	if err := l.Init(); err != nil {
+		t.Fatal(err)
+	}
+	fn := RedirectStdLogger(l, ErrorLevel)
+	defer fn()
+	log.Print("test")
+	if !bytes.Contains(buf.Bytes(), []byte(`"level":"error","msg":"test","timestamp"`)) {
+		t.Fatalf("logger error, buf %s", buf.Bytes())
+	}
+}
+
+func TestStdLogger(t *testing.T) {
+	buf := bytes.NewBuffer(nil)
+	l := NewLogger(WithLevel(TraceLevel), WithOutput(buf))
+	if err := l.Init(); err != nil {
+		t.Fatal(err)
+	}
+	lg := NewStdLogger(l, ErrorLevel)
+	lg.Print("test")
+	if !bytes.Contains(buf.Bytes(), []byte(`"level":"error","msg":"test","timestamp"`)) {
+		t.Fatalf("logger error, buf %s", buf.Bytes())
+	}
+}
+
+func TestLogger(t *testing.T) {
+	ctx := context.TODO()
+	buf := bytes.NewBuffer(nil)
+	l := NewLogger(WithLevel(TraceLevel), WithOutput(buf))
+	if err := l.Init(); err != nil {
+		t.Fatal(err)
+	}
+	l.Trace(ctx, "trace_msg1")
+	l.Warn(ctx, "warn_msg1")
+	l.Fields("error", "test").Info(ctx, "error message")
+	l.Warn(ctx, "first", " ", "second")
+	if !bytes.Contains(buf.Bytes(), []byte(`"level":"trace","msg":"trace_msg1"`)) {
+		t.Fatalf("logger error, buf %s", buf.Bytes())
+	}
+	if !bytes.Contains(buf.Bytes(), []byte(`"warn","msg":"warn_msg1"`)) {
+		t.Fatalf("logger error, buf %s", buf.Bytes())
+	}
+	if !bytes.Contains(buf.Bytes(), []byte(`"error":"test","level":"info","msg":"error message"`)) {
+		t.Fatalf("logger error, buf %s", buf.Bytes())
+	}
+	if !bytes.Contains(buf.Bytes(), []byte(`"level":"warn","msg":"first second"`)) {
+		t.Fatalf("logger error, buf %s", buf.Bytes())
+	}
+}
+
+func TestLoggerWrapper(t *testing.T) {
+	ctx := context.TODO()
+	buf := bytes.NewBuffer(nil)
+	l := NewLogger(WithLevel(TraceLevel), WithOutput(buf))
+	if err := l.Init(WrapLogger(NewOmitWrapper())); err != nil {
+		t.Fatal(err)
+	}
+	type secret struct {
+		Name  string
+		Passw string `logger:"omit"`
+	}
+	s := &secret{Name: "name", Passw: "secret"}
+	l.Errorf(ctx, "test %#+v", s)
+	if !bytes.Contains(buf.Bytes(), []byte(`logger.secret{Name:\"name\", Passw:\"\"}"`)) {
+		t.Fatalf("omit not works, struct: %v, output: %s", s, buf.Bytes())
+	}
+}
+
+func TestOmitLoggerWrapper(t *testing.T) {
+	ctx := context.TODO()
+	buf := bytes.NewBuffer(nil)
+	l := NewOmitLogger(NewLogger(WithLevel(TraceLevel), WithOutput(buf)))
+	if err := l.Init(); err != nil {
+		t.Fatal(err)
+	}
+	type secret struct {
+		Name  string
+		Passw string `logger:"omit"`
+	}
+	s := &secret{Name: "name", Passw: "secret"}
+	l.Errorf(ctx, "test %#+v", s)
+	if !bytes.Contains(buf.Bytes(), []byte(`logger.secret{Name:\"name\", Passw:\"\"}"`)) {
+		t.Fatalf("omit not works, struct: %v, output: %s", s, buf.Bytes())
+	}
+}

logger/noop.go

@@ -1,78 +0,0 @@
-package logger
-
-import (
-	"context"
-)
-
-const (
-	defaultCallerSkipCount = 2
-)
-
-type noopLogger struct {
-	opts Options
-}
-
-func NewLogger(opts ...Option) Logger {
-	options := NewOptions(opts...)
-	options.CallerSkipCount = defaultCallerSkipCount
-	return &noopLogger{opts: options}
-}
-
-func (l *noopLogger) V(_ Level) bool {
-	return false
-}
-
-func (l *noopLogger) Level(_ Level) {
-}
-
-func (l *noopLogger) Name() string {
-	return l.opts.Name
-}
-
-func (l *noopLogger) Init(opts ...Option) error {
-	for _, o := range opts {
-		o(&l.opts)
-	}
-	return nil
-}
-
-func (l *noopLogger) Clone(opts ...Option) Logger {
-	nl := &noopLogger{opts: l.opts}
-	for _, o := range opts {
-		o(&nl.opts)
-	}
-	return nl
-}
-
-func (l *noopLogger) Fields(_ ...interface{}) Logger {
-	return l
-}
-
-func (l *noopLogger) Options() Options {
-	return l.opts
-}
-
-func (l *noopLogger) String() string {
-	return "noop"
-}
-
-func (l *noopLogger) Log(ctx context.Context, lvl Level, msg string, attrs ...interface{}) {
-}
-
-func (l *noopLogger) Info(ctx context.Context, msg string, attrs ...interface{}) {
-}
-
-func (l *noopLogger) Debug(ctx context.Context, msg string, attrs ...interface{}) {
-}
-
-func (l *noopLogger) Error(ctx context.Context, msg string, attrs ...interface{}) {
-}
-
-func (l *noopLogger) Trace(ctx context.Context, msg string, attrs ...interface{}) {
-}
-
-func (l *noopLogger) Warn(ctx context.Context, msg string, attrs ...interface{}) {
-}
-
-func (l *noopLogger) Fatal(ctx context.Context, msg string, attrs ...interface{}) {
-}

logger/options.go

@@ -3,14 +3,10 @@ package logger
 import (
 	"context"
 	"io"
-	"log/slog"
 	"os"
-	"time"
-
-	"go.unistack.org/micro/v3/meter"
 )
 
-// Option func signature
+// Option func
 type Option func(*Options)
 
 // Options holds logger options
@@ -19,36 +15,16 @@ type Options struct {
 	Out io.Writer
 	// Context holds exernal options
 	Context context.Context
-	// Name holds the logger name
-	Name string
 	// Fields holds additional metadata
 	Fields []interface{}
-	// callerSkipCount number of frmaes to skip
+	// Name holds the logger name
-	CallerSkipCount int
+	Name string
-	// ContextAttrFuncs contains funcs that executed before log func on context
+	// Wrappers logger wrapper that called before actual Log/Logf function
-	ContextAttrFuncs []ContextAttrFunc
+	Wrappers []Wrapper
-	// TimeKey is the key used for the time of the log call
-	TimeKey string
-	// LevelKey is the key used for the level of the log call
-	LevelKey string
-	// ErroreKey is the key used for the error of the log call
-	ErrorKey string
-	// MessageKey is the key used for the message of the log call
-	MessageKey string
-	// SourceKey is the key used for the source file and line of the log call
-	SourceKey string
-	// StacktraceKey is the key used for the stacktrace
-	StacktraceKey string
-	// AddStacktrace controls writing of stacktaces on error
-	AddStacktrace bool
-	// AddSource enabled writing source file and position in log
-	AddSource bool
 	// The logging level the logger should log
 	Level Level
-	// TimeFunc used to obtain current time
+	// CallerSkipCount number of frmaes to skip
-	TimeFunc func() time.Time
+	CallerSkipCount int
-	// Meter used to count logs for specific level
-	Meter meter.Meter
 }
 
 // NewOptions creates new options struct
@@ -57,29 +33,15 @@ func NewOptions(opts ...Option) Options {
 		Level:           DefaultLevel,
 		Fields:          make([]interface{}, 0, 6),
 		Out:             os.Stderr,
+		CallerSkipCount: DefaultCallerSkipCount,
 		Context:         context.Background(),
-		ContextAttrFuncs: DefaultContextAttrFuncs,
-		AddSource:        true,
-		TimeFunc:         time.Now,
-		Meter:            meter.DefaultMeter,
 	}
-
-	WithMicroKeys()(&options)
-
 	for _, o := range opts {
 		o(&options)
 	}
-
 	return options
 }
 
-// WithContextAttrFuncs appends default funcs for the context attrs filler
-func WithContextAttrFuncs(fncs ...ContextAttrFunc) Option {
-	return func(o *Options) {
-		o.ContextAttrFuncs = append(o.ContextAttrFuncs, fncs...)
-	}
-}
-
 // WithFields set default fields for the logger
 func WithFields(fields ...interface{}) Option {
 	return func(o *Options) {
@@ -101,17 +63,10 @@ func WithOutput(out io.Writer) Option {
 	}
 }
 
-// WithAddStacktrace controls writing stacktrace on error
+// WithCallerSkipCount set frame count to skip
-func WithAddStacktrace(v bool) Option {
+func WithCallerSkipCount(c int) Option {
 	return func(o *Options) {
-		o.AddStacktrace = v
+		o.CallerSkipCount = c
-	}
-}
-
-// WithAddSource controls writing source file and pos in log
-func WithAddSource(v bool) Option {
-	return func(o *Options) {
-		o.AddSource = v
 	}
 }
 
@@ -129,69 +84,9 @@ func WithName(n string) Option {
 	}
 }
 
-// WithMeter sets the meter
+// WrapLogger adds a logger Wrapper to a list of options passed into the logger
-func WithMeter(m meter.Meter) Option {
+func WrapLogger(w Wrapper) Option {
 	return func(o *Options) {
-		o.Meter = m
+		o.Wrappers = append(o.Wrappers, w)
-	}
-}
-
-// WithTimeFunc sets the func to obtain current time
-func WithTimeFunc(fn func() time.Time) Option {
-	return func(o *Options) {
-		o.TimeFunc = fn
-	}
-}
-
-func WithZapKeys() Option {
-	return func(o *Options) {
-		o.TimeKey = "@timestamp"
-		o.LevelKey = "level"
-		o.MessageKey = "msg"
-		o.SourceKey = "caller"
-		o.StacktraceKey = "stacktrace"
-		o.ErrorKey = "error"
-	}
-}
-
-func WithZerologKeys() Option {
-	return func(o *Options) {
-		o.TimeKey = "time"
-		o.LevelKey = "level"
-		o.MessageKey = "message"
-		o.SourceKey = "caller"
-		o.StacktraceKey = "stacktrace"
-		o.ErrorKey = "error"
-	}
-}
-
-func WithSlogKeys() Option {
-	return func(o *Options) {
-		o.TimeKey = slog.TimeKey
-		o.LevelKey = slog.LevelKey
-		o.MessageKey = slog.MessageKey
-		o.SourceKey = slog.SourceKey
-		o.StacktraceKey = "stacktrace"
-		o.ErrorKey = "error"
-	}
-}
-
-func WithMicroKeys() Option {
-	return func(o *Options) {
-		o.TimeKey = "timestamp"
-		o.LevelKey = "level"
-		o.MessageKey = "msg"
-		o.SourceKey = "caller"
-		o.StacktraceKey = "stacktrace"
-		o.ErrorKey = "error"
-	}
-}
-
-// WithAddCallerSkipCount add skip count for copy logger
-func WithAddCallerSkipCount(n int) Option {
-	return func(o *Options) {
-		if n > 0 {
-			o.CallerSkipCount += n
-		}
 	}
 }

logger/slog/slog.go

@@ -1,332 +0,0 @@
-package slog
-
-import (
-	"context"
-	"log/slog"
-	"os"
-	"regexp"
-	"runtime"
-	"strconv"
-	"sync"
-	"sync/atomic"
-
-	"go.unistack.org/micro/v3/logger"
-	"go.unistack.org/micro/v3/semconv"
-	"go.unistack.org/micro/v3/tracer"
-)
-
-const (
-	badKey = "!BADKEY"
-	// defaultCallerSkipCount used by logger
-	defaultCallerSkipCount = 3
-)
-
-var reTrace = regexp.MustCompile(`.*/slog/logger\.go.*\n`)
-
-var (
-	traceValue = slog.StringValue("trace")
-	debugValue = slog.StringValue("debug")
-	infoValue  = slog.StringValue("info")
-	warnValue  = slog.StringValue("warn")
-	errorValue = slog.StringValue("error")
-	fatalValue = slog.StringValue("fatal")
-)
-
-type wrapper struct {
-	h     slog.Handler
-	level atomic.Int64
-}
-
-func (h *wrapper) Enabled(ctx context.Context, level slog.Level) bool {
-	return level >= slog.Level(int(h.level.Load()))
-}
-
-func (h *wrapper) Handle(ctx context.Context, rec slog.Record) error {
-	return h.h.Handle(ctx, rec)
-}
-
-func (h *wrapper) WithAttrs(attrs []slog.Attr) slog.Handler {
-	return h.WithAttrs(attrs)
-}
-
-func (h *wrapper) WithGroup(name string) slog.Handler {
-	return h.WithGroup(name)
-}
-
-func (s *slogLogger) renameAttr(_ []string, a slog.Attr) slog.Attr {
-	switch a.Key {
-	case slog.SourceKey:
-		source := a.Value.Any().(*slog.Source)
-		a.Value = slog.StringValue(source.File + ":" + strconv.Itoa(source.Line))
-		a.Key = s.opts.SourceKey
-	case slog.TimeKey:
-		a.Key = s.opts.TimeKey
-	case slog.MessageKey:
-		a.Key = s.opts.MessageKey
-	case slog.LevelKey:
-		level := a.Value.Any().(slog.Level)
-		lvl := slogToLoggerLevel(level)
-		a.Key = s.opts.LevelKey
-		switch {
-		case lvl < logger.DebugLevel:
-			a.Value = traceValue
-		case lvl < logger.InfoLevel:
-			a.Value = debugValue
-		case lvl < logger.WarnLevel:
-			a.Value = infoValue
-		case lvl < logger.ErrorLevel:
-			a.Value = warnValue
-		case lvl < logger.FatalLevel:
-			a.Value = errorValue
-		case lvl >= logger.FatalLevel:
-			a.Value = fatalValue
-		default:
-			a.Value = infoValue
-		}
-	}
-
-	return a
-}
-
-type slogLogger struct {
-	leveler *slog.LevelVar
-	handler *wrapper
-	opts    logger.Options
-	mu      sync.RWMutex
-}
-
-func (s *slogLogger) Clone(opts ...logger.Option) logger.Logger {
-	s.mu.RLock()
-	options := s.opts
-	s.mu.RUnlock()
-
-	for _, o := range opts {
-		o(&options)
-	}
-
-	if len(options.ContextAttrFuncs) == 0 {
-		options.ContextAttrFuncs = logger.DefaultContextAttrFuncs
-	}
-
-	attrs, _ := s.argsAttrs(options.Fields)
-	l := &slogLogger{
-		handler: &wrapper{h: s.handler.h.WithAttrs(attrs)},
-		opts:    options,
-	}
-	l.handler.level.Store(int64(loggerToSlogLevel(options.Level)))
-
-	return l
-}
-
-func (s *slogLogger) V(level logger.Level) bool {
-	s.mu.Lock()
-	v := s.opts.Level.Enabled(level)
-	s.mu.Unlock()
-	return v
-}
-
-func (s *slogLogger) Level(level logger.Level) {
-	s.mu.Lock()
-	s.opts.Level = level
-	s.handler.level.Store(int64(loggerToSlogLevel(level)))
-	s.mu.Unlock()
-}
-
-func (s *slogLogger) Options() logger.Options {
-	return s.opts
-}
-
-func (s *slogLogger) Fields(fields ...interface{}) logger.Logger {
-	s.mu.RLock()
-	options := s.opts
-	s.mu.RUnlock()
-
-	l := &slogLogger{opts: options}
-
-	if len(options.ContextAttrFuncs) == 0 {
-		options.ContextAttrFuncs = logger.DefaultContextAttrFuncs
-	}
-
-	attrs, _ := s.argsAttrs(fields)
-	l.handler = &wrapper{h: s.handler.h.WithAttrs(attrs)}
-	l.handler.level.Store(int64(loggerToSlogLevel(l.opts.Level)))
-
-	return l
-}
-
-func (s *slogLogger) Init(opts ...logger.Option) error {
-	s.mu.Lock()
-
-	for _, o := range opts {
-		o(&s.opts)
-	}
-
-	if len(s.opts.ContextAttrFuncs) == 0 {
-		s.opts.ContextAttrFuncs = logger.DefaultContextAttrFuncs
-	}
-
-	handleOpt := &slog.HandlerOptions{
-		ReplaceAttr: s.renameAttr,
-		Level:       loggerToSlogLevel(logger.TraceLevel),
-		AddSource:   s.opts.AddSource,
-	}
-
-	attrs, _ := s.argsAttrs(s.opts.Fields)
-	s.handler = &wrapper{h: slog.NewJSONHandler(s.opts.Out, handleOpt).WithAttrs(attrs)}
-	s.handler.level.Store(int64(loggerToSlogLevel(s.opts.Level)))
-	s.mu.Unlock()
-
-	return nil
-}
-
-func (s *slogLogger) Log(ctx context.Context, lvl logger.Level, msg string, attrs ...interface{}) {
-	s.printLog(ctx, lvl, msg, attrs...)
-}
-
-func (s *slogLogger) Info(ctx context.Context, msg string, attrs ...interface{}) {
-	s.printLog(ctx, logger.InfoLevel, msg, attrs...)
-}
-
-func (s *slogLogger) Debug(ctx context.Context, msg string, attrs ...interface{}) {
-	s.printLog(ctx, logger.DebugLevel, msg, attrs...)
-}
-
-func (s *slogLogger) Trace(ctx context.Context, msg string, attrs ...interface{}) {
-	s.printLog(ctx, logger.TraceLevel, msg, attrs...)
-}
-
-func (s *slogLogger) Error(ctx context.Context, msg string, attrs ...interface{}) {
-	s.printLog(ctx, logger.ErrorLevel, msg, attrs...)
-}
-
-func (s *slogLogger) Fatal(ctx context.Context, msg string, attrs ...interface{}) {
-	s.printLog(ctx, logger.FatalLevel, msg, attrs...)
-	os.Exit(1)
-}
-
-func (s *slogLogger) Warn(ctx context.Context, msg string, attrs ...interface{}) {
-	s.printLog(ctx, logger.WarnLevel, msg, attrs...)
-}
-
-func (s *slogLogger) Name() string {
-	return s.opts.Name
-}
-
-func (s *slogLogger) String() string {
-	return "slog"
-}
-
-func (s *slogLogger) printLog(ctx context.Context, lvl logger.Level, msg string, args ...interface{}) {
-	if !s.V(lvl) {
-		return
-	}
-	var argError error
-
-	s.opts.Meter.Counter(semconv.LoggerMessageTotal, "level", lvl.String()).Inc()
-
-	attrs, err := s.argsAttrs(args)
-	if err != nil {
-		argError = err
-	}
-	if argError != nil {
-		if span, ok := tracer.SpanFromContext(ctx); ok {
-			span.SetStatus(tracer.SpanStatusError, argError.Error())
-		}
-	}
-
-	for _, fn := range s.opts.ContextAttrFuncs {
-		ctxAttrs, err := s.argsAttrs(fn(ctx))
-		if err != nil {
-			argError = err
-		}
-		attrs = append(attrs, ctxAttrs...)
-	}
-	if argError != nil {
-		if span, ok := tracer.SpanFromContext(ctx); ok {
-			span.SetStatus(tracer.SpanStatusError, argError.Error())
-		}
-	}
-
-	if s.opts.AddStacktrace && lvl == logger.ErrorLevel {
-		stackInfo := make([]byte, 1024*1024)
-		if stackSize := runtime.Stack(stackInfo, false); stackSize > 0 {
-			traceLines := reTrace.Split(string(stackInfo[:stackSize]), -1)
-			if len(traceLines) != 0 {
-				attrs = append(attrs, slog.String(s.opts.StacktraceKey, traceLines[len(traceLines)-1]))
-			}
-		}
-	}
-
-	var pcs [1]uintptr
-	runtime.Callers(s.opts.CallerSkipCount, pcs[:]) // skip [Callers, printLog, LogLvlMethod]
-	r := slog.NewRecord(s.opts.TimeFunc(), loggerToSlogLevel(lvl), msg, pcs[0])
-	r.AddAttrs(attrs...)
-	_ = s.handler.Handle(ctx, r)
-}
-
-func NewLogger(opts ...logger.Option) logger.Logger {
-	s := &slogLogger{
-		opts: logger.NewOptions(opts...),
-	}
-	s.opts.CallerSkipCount = defaultCallerSkipCount
-
-	return s
-}
-
-func loggerToSlogLevel(level logger.Level) slog.Level {
-	switch level {
-	case logger.DebugLevel:
-		return slog.LevelDebug
-	case logger.WarnLevel:
-		return slog.LevelWarn
-	case logger.ErrorLevel:
-		return slog.LevelError
-	case logger.TraceLevel:
-		return slog.LevelDebug - 1
-	case logger.FatalLevel:
-		return slog.LevelError + 1
-	default:
-		return slog.LevelInfo
-	}
-}
-
-func slogToLoggerLevel(level slog.Level) logger.Level {
-	switch level {
-	case slog.LevelDebug:
-		return logger.DebugLevel
-	case slog.LevelWarn:
-		return logger.WarnLevel
-	case slog.LevelError:
-		return logger.ErrorLevel
-	case slog.LevelDebug - 1:
-		return logger.TraceLevel
-	case slog.LevelError + 1:
-		return logger.FatalLevel
-	default:
-		return logger.InfoLevel
-	}
-}
-
-func (s *slogLogger) argsAttrs(args []interface{}) ([]slog.Attr, error) {
-	attrs := make([]slog.Attr, 0, len(args))
-	var err error
-
-	for idx := 0; idx < len(args); idx++ {
-		switch arg := args[idx].(type) {
-		case slog.Attr:
-			attrs = append(attrs, arg)
-		case string:
-			if idx+1 < len(args) {
-				attrs = append(attrs, slog.Any(arg, args[idx+1]))
-				idx += 1
-			} else {
-				attrs = append(attrs, slog.String(badKey, arg))
-			}
-		case error:
-			attrs = append(attrs, slog.String(s.opts.ErrorKey, arg.Error()))
-			err = arg
-		}
-	}
-
-	return attrs, err
-}

logger/slog/slog_test.go

@@ -1,294 +0,0 @@
-package slog
-
-import (
-	"bytes"
-	"context"
-	"errors"
-	"fmt"
-	"log"
-	"strings"
-	"testing"
-
-	"github.com/google/uuid"
-	"go.unistack.org/micro/v3/metadata"
-
-	"go.unistack.org/micro/v3/logger"
-)
-
-func TestMultipleFieldsWithLevel(t *testing.T) {
-	ctx := context.TODO()
-	buf := bytes.NewBuffer(nil)
-	l := NewLogger(logger.WithLevel(logger.InfoLevel), logger.WithOutput(buf))
-	if err := l.Init(); err != nil {
-		t.Fatal(err)
-	}
-
-	l = l.Fields("key", "val")
-
-	l.Info(ctx, "msg1")
-	nl := l.Clone(logger.WithLevel(logger.DebugLevel))
-	nl.Debug(ctx, "msg2")
-	l.Debug(ctx, "msg3")
-	if !bytes.Contains(buf.Bytes(), []byte(`"key":"val"`)) {
-		t.Fatalf("logger error not works, buf contains: %s", buf.Bytes())
-	}
-	if !bytes.Contains(buf.Bytes(), []byte(`"msg1"`)) {
-		t.Fatalf("logger error not works, buf contains: %s", buf.Bytes())
-	}
-	if !bytes.Contains(buf.Bytes(), []byte(`"msg2"`)) {
-		t.Fatalf("logger error not works, buf contains: %s", buf.Bytes())
-	}
-	if bytes.Contains(buf.Bytes(), []byte(`"msg3"`)) {
-		t.Fatalf("logger error not works, buf contains: %s", buf.Bytes())
-	}
-}
-
-func TestMultipleFields(t *testing.T) {
-	ctx := context.TODO()
-	buf := bytes.NewBuffer(nil)
-	l := NewLogger(logger.WithLevel(logger.InfoLevel), logger.WithOutput(buf))
-	if err := l.Init(); err != nil {
-		t.Fatal(err)
-	}
-
-	l = l.Fields("key", "val")
-
-	l = l.Fields("key1", "val1")
-
-	l.Info(ctx, "msg")
-
-	if !bytes.Contains(buf.Bytes(), []byte(`"key":"val"`)) {
-		t.Fatalf("logger error not works, buf contains: %s", buf.Bytes())
-	}
-	if !bytes.Contains(buf.Bytes(), []byte(`"key1":"val1"`)) {
-		t.Fatalf("logger error not works, buf contains: %s", buf.Bytes())
-	}
-}
-
-func TestError(t *testing.T) {
-	ctx := context.TODO()
-	buf := bytes.NewBuffer(nil)
-	l := NewLogger(logger.WithLevel(logger.ErrorLevel), logger.WithOutput(buf), logger.WithAddStacktrace(true))
-	if err := l.Init(); err != nil {
-		t.Fatal(err)
-	}
-
-	l.Error(ctx, "message", fmt.Errorf("error message"))
-	if !bytes.Contains(buf.Bytes(), []byte(`"stacktrace":"`)) {
-		t.Fatalf("logger stacktrace not works, buf contains: %s", buf.Bytes())
-	}
-	if !bytes.Contains(buf.Bytes(), []byte(`"error":"`)) {
-		t.Fatalf("logger error not works, buf contains: %s", buf.Bytes())
-	}
-}
-
-func TestErrorf(t *testing.T) {
-	ctx := context.TODO()
-
-	buf := bytes.NewBuffer(nil)
-	l := NewLogger(logger.WithLevel(logger.ErrorLevel), logger.WithOutput(buf), logger.WithAddStacktrace(true))
-	if err := l.Init(logger.WithContextAttrFuncs(func(ctx context.Context) []interface{} {
-		return nil
-	})); err != nil {
-		t.Fatal(err)
-	}
-
-	l.Log(ctx, logger.ErrorLevel, "message", errors.New("error msg"))
-
-	l.Log(ctx, logger.ErrorLevel, "", errors.New("error msg"))
-	if !bytes.Contains(buf.Bytes(), []byte(`"error":"error msg"`)) {
-		t.Fatalf("logger error not works, buf contains: %s", buf.Bytes())
-	}
-
-	if !bytes.Contains(buf.Bytes(), []byte(`"stacktrace":"`)) {
-		t.Fatalf("logger stacktrace not works, buf contains: %s", buf.Bytes())
-	}
-	if !bytes.Contains(buf.Bytes(), []byte(`"error":"`)) {
-		t.Fatalf("logger error not works, buf contains: %s", buf.Bytes())
-	}
-}
-
-func TestContext(t *testing.T) {
-	ctx := context.TODO()
-	buf := bytes.NewBuffer(nil)
-	l := NewLogger(logger.WithLevel(logger.TraceLevel), logger.WithOutput(buf))
-	if err := l.Init(); err != nil {
-		t.Fatal(err)
-	}
-
-	nl, ok := logger.FromContext(logger.NewContext(ctx, l.Fields("key", "val")))
-	if !ok {
-		t.Fatal("context without logger")
-	}
-	nl.Info(ctx, "message")
-	if !bytes.Contains(buf.Bytes(), []byte(`"key":"val"`)) {
-		t.Fatalf("logger fields not works, buf contains: %s", buf.Bytes())
-	}
-}
-
-func TestFields(t *testing.T) {
-	ctx := context.TODO()
-	buf := bytes.NewBuffer(nil)
-	l := NewLogger(logger.WithLevel(logger.TraceLevel), logger.WithOutput(buf))
-	if err := l.Init(); err != nil {
-		t.Fatal(err)
-	}
-
-	nl := l.Fields("key", "val")
-
-	nl.Info(ctx, "message")
-	if !bytes.Contains(buf.Bytes(), []byte(`"key":"val"`)) {
-		t.Fatalf("logger fields not works, buf contains: %s", buf.Bytes())
-	}
-}
-
-func TestFromContextWithFields(t *testing.T) {
-	ctx := context.TODO()
-	buf := bytes.NewBuffer(nil)
-	var ok bool
-	l := NewLogger(logger.WithLevel(logger.TraceLevel), logger.WithOutput(buf))
-	if err := l.Init(); err != nil {
-		t.Fatal(err)
-	}
-	nl := l.Fields("key", "val")
-
-	ctx = logger.NewContext(ctx, nl)
-
-	l, ok = logger.FromContext(ctx)
-	if !ok {
-		t.Fatalf("context does not have logger")
-	}
-
-	l.Info(ctx, "message")
-	if !bytes.Contains(buf.Bytes(), []byte(`"key":"val"`)) {
-		t.Fatalf("logger fields not works, buf contains: %s", buf.Bytes())
-	}
-
-	l.Info(ctx, "test", "uncorrected number attributes")
-	if !bytes.Contains(buf.Bytes(), []byte(`"!BADKEY":"uncorrected number attributes"`)) {
-		t.Fatalf("logger fields not works, buf contains: %s", buf.Bytes())
-	}
-}
-
-func TestClone(t *testing.T) {
-	ctx := context.TODO()
-	buf := bytes.NewBuffer(nil)
-	l := NewLogger(logger.WithLevel(logger.TraceLevel), logger.WithOutput(buf))
-	if err := l.Init(); err != nil {
-		t.Fatal(err)
-	}
-	nl := l.Clone(logger.WithLevel(logger.ErrorLevel))
-	if err := nl.Init(); err != nil {
-		t.Fatal(err)
-	}
-	nl.Info(ctx, "info message")
-	if len(buf.Bytes()) != 0 {
-		t.Fatal("message must not be logged")
-	}
-	l.Info(ctx, "info message")
-	if len(buf.Bytes()) == 0 {
-		t.Fatal("message must be logged")
-	}
-}
-
-func TestRedirectStdLogger(t *testing.T) {
-	buf := bytes.NewBuffer(nil)
-	l := NewLogger(logger.WithLevel(logger.ErrorLevel), logger.WithOutput(buf))
-	if err := l.Init(); err != nil {
-		t.Fatal(err)
-	}
-	fn := logger.RedirectStdLogger(l, logger.ErrorLevel)
-	defer fn()
-	log.Print("test")
-	if !(bytes.Contains(buf.Bytes(), []byte(`"level":"error"`)) && bytes.Contains(buf.Bytes(), []byte(`"msg":"test"`))) {
-		t.Fatalf("logger error, buf %s", buf.Bytes())
-	}
-}
-
-func TestStdLogger(t *testing.T) {
-	buf := bytes.NewBuffer(nil)
-	l := NewLogger(logger.WithLevel(logger.TraceLevel), logger.WithOutput(buf))
-	if err := l.Init(); err != nil {
-		t.Fatal(err)
-	}
-	lg := logger.NewStdLogger(l, logger.ErrorLevel)
-	lg.Print("test")
-	if !(bytes.Contains(buf.Bytes(), []byte(`"level":"error"`)) && bytes.Contains(buf.Bytes(), []byte(`"msg":"test"`))) {
-		t.Fatalf("logger error, buf %s", buf.Bytes())
-	}
-}
-
-func TestLogger(t *testing.T) {
-	ctx := context.TODO()
-	buf := bytes.NewBuffer(nil)
-	l := NewLogger(logger.WithLevel(logger.TraceLevel), logger.WithOutput(buf))
-	if err := l.Init(); err != nil {
-		t.Fatal(err)
-	}
-	l.Trace(ctx, "trace_msg1")
-	l.Warn(ctx, "warn_msg1")
-	l.Fields("error", "test").Info(ctx, "error message")
-	l.Warn(ctx, "first second")
-
-	if !(bytes.Contains(buf.Bytes(), []byte(`"level":"trace"`)) && bytes.Contains(buf.Bytes(), []byte(`"msg":"trace_msg1"`))) {
-		t.Fatalf("logger tracer, buf %s", buf.Bytes())
-	}
-	if !(bytes.Contains(buf.Bytes(), []byte(`"level":"warn"`)) && bytes.Contains(buf.Bytes(), []byte(`"msg":"warn_msg1"`))) {
-		t.Fatalf("logger warn, buf %s", buf.Bytes())
-	}
-	if !(bytes.Contains(buf.Bytes(), []byte(`"level":"info"`)) && bytes.Contains(buf.Bytes(), []byte(`"msg":"error message","error":"test"`))) {
-		t.Fatalf("logger info, buf %s", buf.Bytes())
-	}
-	if !(bytes.Contains(buf.Bytes(), []byte(`"level":"warn"`)) && bytes.Contains(buf.Bytes(), []byte(`"msg":"first second"`))) {
-		t.Fatalf("logger warn, buf %s", buf.Bytes())
-	}
-}
-
-func Test_WithContextAttrFunc(t *testing.T) {
-	loggerContextAttrFuncs := []logger.ContextAttrFunc{
-		func(ctx context.Context) []interface{} {
-			md, ok := metadata.FromIncomingContext(ctx)
-			if !ok {
-				return nil
-			}
-			attrs := make([]interface{}, 0, 10)
-			for k, v := range md {
-				switch k {
-				case "X-Request-Id", "Phone", "External-Id", "Source-Service", "X-App-Install-Id", "Client-Id", "Client-Ip":
-					attrs = append(attrs, strings.ToLower(k), v)
-				}
-			}
-			return attrs
-		},
-	}
-
-	logger.DefaultContextAttrFuncs = append(logger.DefaultContextAttrFuncs, loggerContextAttrFuncs...)
-
-	ctx := context.TODO()
-	ctx = metadata.AppendIncomingContext(ctx, "X-Request-Id", uuid.New().String(),
-		"Source-Service", "Test-System")
-
-	buf := bytes.NewBuffer(nil)
-	l := NewLogger(logger.WithLevel(logger.TraceLevel), logger.WithOutput(buf))
-	if err := l.Init(); err != nil {
-		t.Fatal(err)
-	}
-
-	l.Info(ctx, "test message")
-	if !(bytes.Contains(buf.Bytes(), []byte(`"level":"info"`)) && bytes.Contains(buf.Bytes(), []byte(`"msg":"test message"`))) {
-		t.Fatalf("logger info, buf %s", buf.Bytes())
-	}
-	if !(bytes.Contains(buf.Bytes(), []byte(`"x-request-id":"`))) {
-		t.Fatalf("logger info, buf %s", buf.Bytes())
-	}
-	if !(bytes.Contains(buf.Bytes(), []byte(`"source-service":"Test-System"`))) {
-		t.Fatalf("logger info, buf %s", buf.Bytes())
-	}
-	buf.Reset()
-	imd, _ := metadata.FromIncomingContext(ctx)
-	l.Info(ctx, "test message1")
-	imd.Set("Source-Service", "Test-System2")
-	l.Info(ctx, "test message2")
-
-	// t.Logf("xxx %s", buf.Bytes())
-}

logger/unwrap/unwrap.go

@@ -1,681 +0,0 @@
-package unwrap
-
-import (
-	"bytes"
-	"fmt"
-	"io"
-	"reflect"
-	"strconv"
-	"strings"
-
-	"go.unistack.org/micro/v3/codec"
-)
-
-const sf = "0-+# "
-
-var hexDigits = "0123456789abcdef"
-
-var (
-	panicBytes         = []byte("(PANIC=")
-	plusBytes          = []byte("+")
-	iBytes             = []byte("i")
-	trueBytes          = []byte("true")
-	falseBytes         = []byte("false")
-	interfaceBytes     = []byte("(interface {})")
-	openBraceBytes     = []byte("{")
-	closeBraceBytes    = []byte("}")
-	asteriskBytes      = []byte("*")
-	ampBytes           = []byte("&")
-	colonBytes         = []byte(":")
-	openParenBytes     = []byte("(")
-	closeParenBytes    = []byte(")")
-	spaceBytes         = []byte(" ")
-	commaBytes         = []byte(",")
-	pointerChainBytes  = []byte("->")
-	nilAngleBytes      = []byte("<nil>")
-	circularShortBytes = []byte("<shown>")
-	invalidAngleBytes  = []byte("<invalid>")
-	filteredBytes      = []byte("<filtered>")
-	openBracketBytes   = []byte("[")
-	closeBracketBytes  = []byte("]")
-	percentBytes       = []byte("%")
-	precisionBytes     = []byte(".")
-	openAngleBytes     = []byte("<")
-	closeAngleBytes    = []byte(">")
-	openMapBytes       = []byte("{")
-	closeMapBytes      = []byte("}")
-)
-
-type protoMessage interface {
-	Reset()
-	ProtoMessage()
-}
-
-type Wrapper struct {
-	val              interface{}
-	s                fmt.State
-	pointers         map[uintptr]int
-	opts             *Options
-	depth            int
-	ignoreNextType   bool
-	takeMap          map[int]bool
-	protoWrapperType bool
-	sqlWrapperType   bool
-}
-
-// Options struct
-type Options struct {
-	Codec   codec.Codec
-	Indent  string
-	Methods bool
-	Tagged  bool
-}
-
-// NewOptions creates new Options struct via provided args
-func NewOptions(opts ...Option) Options {
-	options := Options{
-		Indent:  " ",
-		Methods: false,
-	}
-	for _, o := range opts {
-		o(&options)
-	}
-	return options
-}
-
-// Option func signature
-type Option func(*Options)
-
-// Indent option specify indent level
-func Indent(f string) Option {
-	return func(o *Options) {
-		o.Indent = f
-	}
-}
-
-// Methods option toggles fmt.Stringer methods
-func Methods(b bool) Option {
-	return func(o *Options) {
-		o.Methods = b
-	}
-}
-
-// Codec option automatic marshal arg via specified codec and write it to log
-func Codec(c codec.Codec) Option {
-	return func(o *Options) {
-		o.Codec = c
-	}
-}
-
-// Tagged option toggles output only logger:"take" fields
-func Tagged(b bool) Option {
-	return func(o *Options) {
-		o.Tagged = b
-	}
-}
-
-func Unwrap(val interface{}, opts ...Option) *Wrapper {
-	options := NewOptions(opts...)
-	return &Wrapper{val: val, opts: &options, pointers: make(map[uintptr]int), takeMap: make(map[int]bool)}
-}
-
-func (w *Wrapper) unpackValue(v reflect.Value) reflect.Value {
-	if v.Kind() == reflect.Interface {
-		w.ignoreNextType = false
-		if !v.IsNil() {
-			v = v.Elem()
-		}
-	}
-	return v
-}
-
-// formatPtr handles formatting of pointers by indirecting them as necessary.
-func (w *Wrapper) formatPtr(v reflect.Value) {
-	// Display nil if top level pointer is nil.
-	showTypes := w.s.Flag('#')
-	if v.IsNil() && (!showTypes || w.ignoreNextType) {
-		_, _ = w.s.Write(nilAngleBytes)
-		return
-	}
-
-	// Remove pointers at or below the current depth from map used to detect
-	// circular refs.
-	for k, depth := range w.pointers {
-		if depth >= w.depth {
-			delete(w.pointers, k)
-		}
-	}
-
-	// Keep list of all dereferenced pointers to possibly show later.
-	pointerChain := make([]uintptr, 0)
-
-	// Figure out how many levels of indirection there are by derferencing
-	// pointers and unpacking interfaces down the chain while detecting circular
-	// references.
-	nilFound := false
-	cycleFound := false
-	indirects := 0
-	ve := v
-	for ve.Kind() == reflect.Ptr {
-		if ve.IsNil() {
-			nilFound = true
-			break
-		}
-		indirects++
-		addr := ve.Pointer()
-		pointerChain = append(pointerChain, addr)
-		if pd, ok := w.pointers[addr]; ok && pd < w.depth {
-			cycleFound = true
-			indirects--
-			break
-		}
-		w.pointers[addr] = w.depth
-
-		ve = ve.Elem()
-		if ve.Kind() == reflect.Interface {
-			if ve.IsNil() {
-				nilFound = true
-				break
-			}
-			ve = ve.Elem()
-		}
-	}
-
-	// Display type or indirection level depending on flags.
-	if showTypes && !w.ignoreNextType {
-		if w.depth > 0 {
-			_, _ = w.s.Write(openParenBytes)
-		}
-		if w.depth > 0 {
-			_, _ = w.s.Write(bytes.Repeat(asteriskBytes, indirects))
-		} else {
-			_, _ = w.s.Write(bytes.Repeat(ampBytes, indirects))
-		}
-		_, _ = w.s.Write([]byte(ve.Type().String()))
-		if w.depth > 0 {
-			_, _ = w.s.Write(closeParenBytes)
-		}
-	} else {
-		if nilFound || cycleFound {
-			indirects += strings.Count(ve.Type().String(), "*")
-		}
-		_, _ = w.s.Write(openAngleBytes)
-		_, _ = w.s.Write([]byte(strings.Repeat("*", indirects)))
-		_, _ = w.s.Write(closeAngleBytes)
-	}
-
-	// Display pointer information depending on flags.
-	if w.s.Flag('+') && (len(pointerChain) > 0) {
-		_, _ = w.s.Write(openParenBytes)
-		for i, addr := range pointerChain {
-			if i > 0 {
-				_, _ = w.s.Write(pointerChainBytes)
-			}
-			getHexPtr(w.s, addr)
-		}
-		_, _ = w.s.Write(closeParenBytes)
-	}
-
-	// Display dereferenced value.
-	switch {
-	case nilFound:
-		_, _ = w.s.Write(nilAngleBytes)
-	case cycleFound:
-		_, _ = w.s.Write(circularShortBytes)
-	default:
-		w.ignoreNextType = true
-		w.format(ve)
-	}
-}
-
-// format is the main workhorse for providing the Formatter interface.  It
-// uses the passed reflect value to figure out what kind of object we are
-// dealing with and formats it appropriately.  It is a recursive function,
-// however circular data structures are detected and handled properly.
-func (w *Wrapper) format(v reflect.Value) {
-	if w.opts.Codec != nil {
-		buf, err := w.opts.Codec.Marshal(v.Interface())
-		if err != nil {
-			_, _ = w.s.Write(invalidAngleBytes)
-			return
-		}
-		_, _ = w.s.Write(buf)
-		return
-	}
-
-	// Handle invalid reflect values immediately.
-	kind := v.Kind()
-	if kind == reflect.Invalid {
-		_, _ = w.s.Write(invalidAngleBytes)
-		return
-	}
-
-	// Handle pointers specially.
-	switch kind {
-	case reflect.Ptr:
-		if !v.IsZero() {
-			if strings.HasPrefix(reflect.Indirect(v).Type().String(), "wrapperspb.") {
-				w.protoWrapperType = true
-			} else if strings.HasPrefix(reflect.Indirect(v).Type().String(), "sql.Null") {
-				w.sqlWrapperType = true
-			} else if v.CanInterface() {
-				if _, ok := v.Interface().(protoMessage); ok {
-					w.protoWrapperType = true
-				}
-			}
-		}
-		w.formatPtr(v)
-		return
-	case reflect.Struct:
-		if !v.IsZero() {
-			if strings.HasPrefix(reflect.Indirect(v).Type().String(), "sql.Null") {
-				w.sqlWrapperType = true
-			}
-		}
-	}
-
-	// get type information unless already handled elsewhere.
-	if !w.ignoreNextType && w.s.Flag('#') {
-		if v.Type().Kind() != reflect.Map &&
-			v.Type().Kind() != reflect.String &&
-			v.Type().Kind() != reflect.Array &&
-			v.Type().Kind() != reflect.Slice {
-			_, _ = w.s.Write(openParenBytes)
-		}
-		if v.Kind() != reflect.String {
-			_, _ = w.s.Write([]byte(v.Type().String()))
-		}
-		if v.Type().Kind() != reflect.Map &&
-			v.Type().Kind() != reflect.String &&
-			v.Type().Kind() != reflect.Array &&
-			v.Type().Kind() != reflect.Slice {
-			_, _ = w.s.Write(closeParenBytes)
-		}
-	}
-	w.ignoreNextType = false
-
-	// Call Stringer/error interfaces if they exist and the handle methods
-	// flag is enabled.
-	if w.opts.Methods {
-		if (kind != reflect.Invalid) && (kind != reflect.Interface) {
-			if handled := handleMethods(w.opts, w.s, v); handled {
-				return
-			}
-		}
-	}
-
-	switch kind {
-	case reflect.Invalid:
-		_, _ = w.s.Write(invalidAngleBytes)
-	case reflect.Bool:
-		getBool(w.s, v.Bool())
-	case reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, reflect.Int:
-		getInt(w.s, v.Int(), 10)
-	case reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uint:
-		getUint(w.s, v.Uint(), 10)
-	case reflect.Float32:
-		getFloat(w.s, v.Float(), 32)
-	case reflect.Float64:
-		getFloat(w.s, v.Float(), 64)
-	case reflect.Complex64:
-		getComplex(w.s, v.Complex(), 32)
-	case reflect.Complex128:
-		getComplex(w.s, v.Complex(), 64)
-	case reflect.Slice:
-		if v.IsNil() {
-			_, _ = w.s.Write(nilAngleBytes)
-			break
-		}
-		fallthrough
-	case reflect.Array:
-		_, _ = w.s.Write(openBraceBytes)
-		w.depth++
-		numEntries := v.Len()
-		for i := 0; i < numEntries; i++ {
-			if i > 0 {
-				_, _ = w.s.Write(commaBytes)
-				_, _ = w.s.Write(spaceBytes)
-			}
-			w.ignoreNextType = true
-			w.format(w.unpackValue(v.Index(i)))
-		}
-		w.depth--
-		_, _ = w.s.Write(closeBraceBytes)
-	case reflect.String:
-		_, _ = w.s.Write([]byte(`"` + v.String() + `"`))
-	case reflect.Interface:
-		// The only time we should get here is for nil interfaces due to
-		// unpackValue calls.
-		if v.IsNil() {
-			_, _ = w.s.Write(nilAngleBytes)
-		}
-	case reflect.Ptr:
-		// Do nothing.  We should never get here since pointers have already
-		// been handled above.
-	case reflect.Map:
-		// nil maps should be indicated as different than empty maps
-		if v.IsNil() {
-			_, _ = w.s.Write(nilAngleBytes)
-			break
-		}
-		_, _ = w.s.Write(openMapBytes)
-		w.depth++
-		keys := v.MapKeys()
-		for i, key := range keys {
-			if i > 0 {
-				_, _ = w.s.Write(spaceBytes)
-			}
-			w.ignoreNextType = true
-			w.format(w.unpackValue(key))
-			_, _ = w.s.Write(colonBytes)
-			w.ignoreNextType = true
-			w.format(w.unpackValue(v.MapIndex(key)))
-		}
-		w.depth--
-		_, _ = w.s.Write(closeMapBytes)
-	case reflect.Struct:
-
-		numFields := v.NumField()
-		numWritten := 0
-		_, _ = w.s.Write(openBraceBytes)
-		w.depth++
-
-		vt := v.Type()
-		prevSkip := false
-
-		for i := 0; i < numFields; i++ {
-			switch vt.Field(i).Type.PkgPath() {
-			case "google.golang.org/protobuf/internal/impl", "google.golang.org/protobuf/internal/pragma":
-				w.protoWrapperType = true
-				prevSkip = true
-				continue
-			}
-			if w.protoWrapperType && !vt.Field(i).IsExported() {
-				prevSkip = true
-				continue
-			} else if w.sqlWrapperType && vt.Field(i).Name == "Valid" {
-				prevSkip = true
-				continue
-			}
-			if _, ok := vt.Field(i).Tag.Lookup("protobuf"); ok && !w.protoWrapperType {
-				w.protoWrapperType = true
-			}
-			sv, ok := vt.Field(i).Tag.Lookup("logger")
-			switch {
-			case ok:
-				switch sv {
-				case "omit":
-					prevSkip = true
-					continue
-				case "take":
-					break
-				}
-			case !ok && w.opts.Tagged:
-				// skip top level untagged
-				if w.depth == 1 {
-					prevSkip = true
-					continue
-				}
-				if tv, ok := w.takeMap[w.depth]; ok && !tv {
-					prevSkip = true
-					continue
-				}
-			}
-
-			if prevSkip {
-				prevSkip = false
-			}
-
-			if numWritten > 0 {
-				_, _ = w.s.Write(commaBytes)
-				_, _ = w.s.Write(spaceBytes)
-			}
-
-			vt := vt.Field(i)
-			if w.s.Flag('+') || w.s.Flag('#') {
-				_, _ = w.s.Write([]byte(vt.Name))
-				_, _ = w.s.Write(colonBytes)
-			}
-			w.format(w.unpackValue(v.Field(i)))
-			numWritten++
-		}
-		w.depth--
-
-		if numWritten == 0 && w.depth < 0 {
-			_, _ = w.s.Write(filteredBytes)
-		}
-		_, _ = w.s.Write(closeBraceBytes)
-	case reflect.Uintptr:
-		getHexPtr(w.s, uintptr(v.Uint()))
-	case reflect.UnsafePointer, reflect.Chan, reflect.Func:
-		getHexPtr(w.s, v.Pointer())
-	// There were not any other types at the time this code was written, but
-	// fall back to letting the default fmt package handle it if any get added.
-	default:
-		format := w.buildDefaultFormat()
-		if v.CanInterface() {
-			_, _ = fmt.Fprintf(w.s, format, v.Interface())
-		} else {
-			_, _ = fmt.Fprintf(w.s, format, v.String())
-		}
-	}
-}
-
-func (w *Wrapper) Format(s fmt.State, verb rune) {
-	w.s = s
-
-	// Use standard formatting for verbs that are not v.
-	if verb != 'v' {
-		format := w.constructOrigFormat(verb)
-		_, _ = fmt.Fprintf(s, format, w.val)
-		return
-	}
-
-	if w.val == nil {
-		if s.Flag('#') {
-			_, _ = s.Write(interfaceBytes)
-		}
-		_, _ = s.Write(nilAngleBytes)
-		return
-	}
-
-	if w.opts.Tagged {
-		w.buildTakeMap(reflect.ValueOf(w.val), 1)
-	}
-
-	w.format(reflect.ValueOf(w.val))
-}
-
-// handle special methods like error.Error() or fmt.Stringer interface
-func handleMethods(_ *Options, w io.Writer, v reflect.Value) (handled bool) {
-	if !v.CanInterface() {
-		// not our case
-		return false
-	}
-
-	if !v.CanAddr() {
-		// not our case
-		return false
-	}
-
-	if v.CanAddr() {
-		v = v.Addr()
-	}
-
-	// Is it an error or Stringer?
-	switch iface := v.Interface().(type) {
-	case error:
-		defer catchPanic(w, v)
-		_, _ = w.Write([]byte(iface.Error()))
-		return true
-	case fmt.Stringer:
-		defer catchPanic(w, v)
-		_, _ = w.Write([]byte(iface.String()))
-		return true
-	}
-
-	return false
-}
-
-// getBool outputs a boolean value as true or false to Writer w.
-func getBool(w io.Writer, val bool) {
-	if val {
-		_, _ = w.Write(trueBytes)
-	} else {
-		_, _ = w.Write(falseBytes)
-	}
-}
-
-// getInt outputs a signed integer value to Writer w.
-func getInt(w io.Writer, val int64, base int) {
-	_, _ = w.Write([]byte(strconv.FormatInt(val, base)))
-}
-
-// getUint outputs an unsigned integer value to Writer w.
-func getUint(w io.Writer, val uint64, base int) {
-	_, _ = w.Write([]byte(strconv.FormatUint(val, base)))
-}
-
-// getFloat outputs a floating point value using the specified precision,
-// which is expected to be 32 or 64bit, to Writer w.
-func getFloat(w io.Writer, val float64, precision int) {
-	_, _ = w.Write([]byte(strconv.FormatFloat(val, 'g', -1, precision)))
-}
-
-// getComplex outputs a complex value using the specified float precision
-// for the real and imaginary parts to Writer w.
-func getComplex(w io.Writer, c complex128, floatPrecision int) {
-	r := real(c)
-	_, _ = w.Write(openParenBytes)
-	_, _ = w.Write([]byte(strconv.FormatFloat(r, 'g', -1, floatPrecision)))
-	i := imag(c)
-	if i >= 0 {
-		_, _ = w.Write(plusBytes)
-	}
-	_, _ = w.Write([]byte(strconv.FormatFloat(i, 'g', -1, floatPrecision)))
-	_, _ = w.Write(iBytes)
-	_, _ = w.Write(closeParenBytes)
-}
-
-// getHexPtr outputs a uintptr formatted as hexadecimal with a leading '0x'
-// prefix to Writer w.
-func getHexPtr(w io.Writer, p uintptr) {
-	// Null pointer.
-	num := uint64(p)
-	if num == 0 {
-		_, _ = w.Write(nilAngleBytes)
-		return
-	}
-
-	// Max uint64 is 16 bytes in hex + 2 bytes for '0x' prefix
-	buf := make([]byte, 18)
-
-	// It's simpler to construct the hex string right to left.
-	base := uint64(16)
-	i := len(buf) - 1
-	for num >= base {
-		buf[i] = hexDigits[num%base]
-		num /= base
-		i--
-	}
-	buf[i] = hexDigits[num]
-
-	// Add '0x' prefix.
-	i--
-	buf[i] = 'x'
-	i--
-	buf[i] = '0'
-
-	// Strip unused leading bytes.
-	buf = buf[i:]
-	_, _ = w.Write(buf)
-}
-
-func catchPanic(w io.Writer, _ reflect.Value) {
-	if err := recover(); err != nil {
-		_, _ = w.Write(panicBytes)
-		_, _ = fmt.Fprintf(w, "%v", err)
-		_, _ = w.Write(closeParenBytes)
-	}
-}
-
-func (w *Wrapper) buildDefaultFormat() (format string) {
-	buf := bytes.NewBuffer(percentBytes)
-
-	for _, flag := range sf {
-		if w.s.Flag(int(flag)) {
-			_, _ = buf.WriteRune(flag)
-		}
-	}
-
-	_, _ = buf.WriteRune('v')
-
-	format = buf.String()
-	return format
-}
-
-func (w *Wrapper) constructOrigFormat(verb rune) string {
-	buf := bytes.NewBuffer(percentBytes)
-
-	for _, flag := range sf {
-		if w.s.Flag(int(flag)) {
-			_, _ = buf.WriteRune(flag)
-		}
-	}
-
-	if width, ok := w.s.Width(); ok {
-		_, _ = buf.WriteString(strconv.Itoa(width))
-	}
-
-	if precision, ok := w.s.Precision(); ok {
-		_, _ = buf.Write(precisionBytes)
-		_, _ = buf.WriteString(strconv.Itoa(precision))
-	}
-
-	_, _ = buf.WriteRune(verb)
-
-	return buf.String()
-}
-
-func (w *Wrapper) buildTakeMap(v reflect.Value, depth int) {
-	if !v.IsValid() || v.IsZero() {
-		return
-	}
-
-	switch v.Kind() {
-	case reflect.Slice, reflect.Array:
-		for i := 0; i < v.Len(); i++ {
-			w.buildTakeMap(v.Index(i), depth+1)
-		}
-		w.takeMap[depth] = true
-		return
-	case reflect.Struct:
-		break
-	case reflect.Ptr:
-		v = v.Elem()
-		if v.Kind() != reflect.Struct {
-			w.takeMap[depth] = true
-			return
-		}
-	default:
-		w.takeMap[depth] = true
-		return
-	}
-
-	vt := v.Type()
-
-	for i := 0; i < v.NumField(); i++ {
-		sv, ok := vt.Field(i).Tag.Lookup("logger")
-		if ok && sv == "take" {
-			w.takeMap[depth] = false
-		}
-		if v.Kind() == reflect.Struct ||
-			(v.Kind() == reflect.Ptr && v.Elem().Kind() == reflect.Struct) {
-			w.buildTakeMap(v.Field(i), depth+1)
-		}
-	}
-
-	if _, ok := w.takeMap[depth]; !ok {
-		w.takeMap[depth] = true
-	}
-}

logger/unwrap/unwrap_test.go

@@ -1,100 +0,0 @@
-package unwrap
-
-import (
-	"fmt"
-	"strings"
-	"testing"
-
-	"go.unistack.org/micro/v3/codec"
-)
-
-func TestUnwrap(t *testing.T) {
-	string1 := "string1"
-	string2 := "string2"
-
-	type val1 struct {
-		mp  map[string]string
-		val *val1
-		str *string
-		ar  []*string
-	}
-
-	v1 := &val1{ar: []*string{&string1, &string2}, str: &string1, val: &val1{str: &string2}, mp: map[string]string{"key": "val"}}
-
-	buf := fmt.Sprintf("%#v", Unwrap(v1))
-	if strings.Compare(buf, `&unwrap.val1{mp:map[string]string{"key":"val"}, val:(*unwrap.val1){mp:map[string]string<nil>, val:(*unwrap.val1)<nil>, str:(*string)"string2", ar:[]*string<nil>}, str:(*string)"string1", ar:[]*string{<*><shown>, <*>"string2"}}`) != 0 {
-		t.Fatalf("not proper written %s", buf)
-	}
-
-	type val2 struct {
-		mp  map[string]string
-		val *val2
-		str string
-		ar  []string
-	}
-
-	v2 := &val2{ar: []string{string1, string2}, str: string1, val: &val2{str: string2}, mp: map[string]string{"key": "val"}}
-	_ = v2
-	// t.Logf("output: %#v", v2)
-}
-
-func TestCodec(t *testing.T) {
-	type val struct {
-		MP  map[string]string `json:"mp"`
-		STR string            `json:"str"`
-		AR  []string          `json:"ar"`
-	}
-
-	v1 := &val{AR: []string{"string1", "string2"}, STR: "string", MP: map[string]string{"key": "val"}}
-
-	buf := fmt.Sprintf("%#v", Unwrap(v1, Codec(codec.NewCodec())))
-	if strings.Compare(buf, `{"mp":{"key":"val"},"str":"string","ar":["string1","string2"]}`) != 0 {
-		t.Fatalf("not proper written %s", buf)
-	}
-}
-
-func TestOmit(t *testing.T) {
-	type val struct {
-		Key1 string `logger:"omit"`
-		Key2 string `logger:"take"`
-		Key3 string
-	}
-	v1 := &val{Key1: "val1", Key2: "val2", Key3: "val3"}
-	buf := fmt.Sprintf("%#v", Unwrap(v1))
-	if strings.Compare(buf, `&unwrap.val{Key2:"val2", Key3:"val3"}`) != 0 {
-		t.Fatalf("not proper written %s", buf)
-	}
-}
-
-func TestTagged(t *testing.T) {
-	type val struct {
-		Key1 string `logger:"take"`
-		Key2 string
-	}
-
-	v1 := &val{Key1: "val1", Key2: "val2"}
-	buf := fmt.Sprintf("%#v", Unwrap(v1, Tagged(true)))
-	if strings.Compare(buf, `&unwrap.val{Key1:"val1"}`) != 0 {
-		t.Fatalf("not proper written %s", buf)
-	}
-}
-
-func TestTaggedNested(t *testing.T) {
-	type val struct {
-		key string `logger:"take"`
-		val string `logger:"omit"`
-		unk string
-	}
-	type str struct {
-		key string `logger:"omit"`
-		val *val   `logger:"take"`
-	}
-
-	var iface interface{}
-	v := &str{val: &val{key: "test", unk: "unk"}}
-	iface = v
-	buf := fmt.Sprintf("%#v", Unwrap(iface, Tagged(true)))
-	if strings.Compare(buf, `&unwrap.str{val:(*unwrap.val){key:"test"}}`) != 0 {
-		t.Fatalf("not proper written %s", buf)
-	}
-}

logger/wrapper.go

@@ -0,0 +1,166 @@
+package logger // import "go.unistack.org/micro/v3/logger/wrapper"
+
+import (
+	"context"
+	"reflect"
+
+	rutil "go.unistack.org/micro/v3/util/reflect"
+)
+
+// LogFunc function used for Log method
+type LogFunc func(ctx context.Context, level Level, args ...interface{})
+
+// LogfFunc function used for Logf method
+type LogfFunc func(ctx context.Context, level Level, msg string, args ...interface{})
+
+type Wrapper interface {
+	// Log logs message with needed level
+	Log(LogFunc) LogFunc
+	// Logf logs message with needed level
+	Logf(LogfFunc) LogfFunc
+}
+
+var _ Logger = &omitLogger{}
+
+type omitLogger struct {
+	l Logger
+}
+
+func NewOmitLogger(l Logger) Logger {
+	return &omitLogger{l: l}
+}
+
+func (w *omitLogger) Init(opts ...Option) error {
+	return w.l.Init(append(opts, WrapLogger(NewOmitWrapper()))...)
+}
+
+func (w *omitLogger) V(level Level) bool {
+	return w.l.V(level)
+}
+
+func (w *omitLogger) Level(level Level) {
+	w.l.Level(level)
+}
+
+func (w *omitLogger) Clone(opts ...Option) Logger {
+	return w.l.Clone(opts...)
+}
+
+func (w *omitLogger) Options() Options {
+	return w.l.Options()
+}
+
+func (w *omitLogger) Fields(fields ...interface{}) Logger {
+	return w.l.Fields(fields...)
+}
+
+func (w *omitLogger) Info(ctx context.Context, args ...interface{}) {
+	w.l.Info(ctx, args...)
+}
+
+func (w *omitLogger) Trace(ctx context.Context, args ...interface{}) {
+	w.l.Trace(ctx, args...)
+}
+
+func (w *omitLogger) Debug(ctx context.Context, args ...interface{}) {
+	w.l.Debug(ctx, args...)
+}
+
+func (w *omitLogger) Warn(ctx context.Context, args ...interface{}) {
+	w.l.Warn(ctx, args...)
+}
+
+func (w *omitLogger) Error(ctx context.Context, args ...interface{}) {
+	w.l.Error(ctx, args...)
+}
+
+func (w *omitLogger) Fatal(ctx context.Context, args ...interface{}) {
+	w.l.Fatal(ctx, args...)
+}
+
+func (w *omitLogger) Infof(ctx context.Context, msg string, args ...interface{}) {
+	w.l.Infof(ctx, msg, args...)
+}
+
+func (w *omitLogger) Tracef(ctx context.Context, msg string, args ...interface{}) {
+	w.l.Tracef(ctx, msg, args...)
+}
+
+func (w *omitLogger) Debugf(ctx context.Context, msg string, args ...interface{}) {
+	w.l.Debugf(ctx, msg, args...)
+}
+
+func (w *omitLogger) Warnf(ctx context.Context, msg string, args ...interface{}) {
+	w.l.Warnf(ctx, msg, args...)
+}
+
+func (w *omitLogger) Errorf(ctx context.Context, msg string, args ...interface{}) {
+	w.l.Errorf(ctx, msg, args...)
+}
+
+func (w *omitLogger) Fatalf(ctx context.Context, msg string, args ...interface{}) {
+	w.l.Fatalf(ctx, msg, args...)
+}
+
+func (w *omitLogger) Log(ctx context.Context, level Level, args ...interface{}) {
+	w.l.Log(ctx, level, args...)
+}
+
+func (w *omitLogger) Logf(ctx context.Context, level Level, msg string, args ...interface{}) {
+	w.l.Logf(ctx, level, msg, args...)
+}
+
+func (w *omitLogger) String() string {
+	return w.l.String()
+}
+
+type omitWrapper struct{}
+
+func NewOmitWrapper() Wrapper {
+	return &omitWrapper{}
+}
+
+func getArgs(args []interface{}) []interface{} {
+	nargs := make([]interface{}, 0, len(args))
+	var err error
+	for _, arg := range args {
+		val := reflect.ValueOf(arg)
+		if val.Kind() == reflect.Ptr {
+			val = val.Elem()
+		}
+		narg := arg
+		if val.Kind() != reflect.Struct {
+			nargs = append(nargs, narg)
+			continue
+		}
+
+		if narg, err = rutil.Zero(arg); err != nil {
+			nargs = append(nargs, narg)
+			continue
+		}
+
+		rutil.CopyDefaults(narg, arg)
+		if flds, ferr := rutil.StructFields(narg); ferr == nil {
+			for _, fld := range flds {
+				if tv, ok := fld.Field.Tag.Lookup("logger"); ok && tv == "omit" {
+					fld.Value.Set(reflect.Zero(fld.Value.Type()))
+				}
+			}
+		}
+
+		nargs = append(nargs, narg)
+	}
+	return nargs
+}
+
+func (w *omitWrapper) Log(fn LogFunc) LogFunc {
+	return func(ctx context.Context, level Level, args ...interface{}) {
+		fn(ctx, level, getArgs(args)...)
+	}
+}
+
+func (w *omitWrapper) Logf(fn LogfFunc) LogfFunc {
+	return func(ctx context.Context, level Level, msg string, args ...interface{}) {
+		fn(ctx, level, msg, getArgs(args)...)
+	}
+}