chore: coding style (#3960)

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>

.codecov.yml

@@ -1,3 +1,7 @@
+coverage:
+  status:
+    patch: true
+    project: false # disabled because project coverage is not stable
 comment:
   layout: "flags, files"
   behavior: once

.dockerignore

@@ -1 +1,7 @@
 **/.git
+.dockerignore
+Dockerfile
+goctl
+Makefile
+readme.md
+readme-cn.md

.github/dependabot.yml

@@ -5,6 +5,14 @@
 
 version: 2
 updates:
+  - package-ecosystem: "docker" # Update image tags in Dockerfile
+    directory: "/"
+    schedule:
+      interval: "weekly"
+  - package-ecosystem: "github-actions" # Update GitHub Actions
+    directory: "/"
+    schedule:
+      interval: "weekly"
   - package-ecosystem: "gomod" # See documentation for possible values
     directory: "/" # Location of package manifests
     schedule:

.github/workflows/codeql-analysis.yml

@@ -35,11 +35,11 @@ jobs:
 
     steps:
     - name: Checkout repository
-      uses: actions/checkout@v3
+      uses: actions/checkout@v4
 
     # Initializes the CodeQL tools for scanning.
     - name: Initialize CodeQL
-      uses: github/codeql-action/init@v2
+      uses: github/codeql-action/init@v3
       with:
         languages: ${{ matrix.language }}
         # If you wish to specify custom queries, you can do so here or in a config file.
@@ -50,7 +50,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@v3
 
     # ℹ️ Command-line programs to run using the OS shell.
     # 📚 https://git.io/JvXDl
@@ -64,4 +64,4 @@ jobs:
     #   make release
 
     - name: Perform CodeQL Analysis
-      uses: github/codeql-action/analyze@v2
+      uses: github/codeql-action/analyze@v3

.github/workflows/go.yml

@@ -12,12 +12,12 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Check out code into the Go module directory
-        uses: actions/checkout@v3
+        uses: actions/checkout@v4
 
       - name: Set up Go 1.x
-        uses: actions/setup-go@v3
+        uses: actions/setup-go@v5
         with:
-          go-version: 1.18
+          go-version: '1.19'
           check-latest: true
           cache: true
         id: go
@@ -40,20 +40,20 @@ jobs:
         run: go test -race -coverprofile=coverage.txt -covermode=atomic ./...
 
       - name: Codecov
-        uses: codecov/codecov-action@v3
+        uses: codecov/codecov-action@v4
 
   test-win:
     name: Windows
     runs-on: windows-latest
     steps:
       - name: Checkout codebase
-        uses: actions/checkout@v3
+        uses: actions/checkout@v4
 
       - name: Set up Go 1.x
-        uses: actions/setup-go@v3
+        uses: actions/setup-go@v5
         with:
-          # use 1.18 to guarantee Go 1.18 compatibility
-          go-version: 1.18
+          # use 1.19 to guarantee Go 1.19 compatibility
+          go-version: '1.19'
           check-latest: true
           cache: true
 

.github/workflows/issues.yml

@@ -7,7 +7,7 @@ jobs:
   close-issues:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/stale@v6
+      - uses: actions/stale@v9
         with:
           days-before-issue-stale: 365
           days-before-issue-close: 90

.github/workflows/release.yaml

@@ -16,13 +16,13 @@ jobs:
           - goarch: "386"
             goos: darwin
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
       - uses: zeromicro/go-zero-release-action@master
         with:
           github_token: ${{ secrets.GITHUB_TOKEN }}
           goos: ${{ matrix.goos }}
           goarch: ${{ matrix.goarch }}
-          goversion: "https://dl.google.com/go/go1.18.10.linux-amd64.tar.gz"
+          goversion: "https://dl.google.com/go/go1.19.13.linux-amd64.tar.gz"
           project_path: "tools/goctl"
           binary_name: "goctl"
           extra_files: tools/goctl/readme.md tools/goctl/readme-cn.md

.github/workflows/reviewdog.yml

@@ -5,7 +5,7 @@ jobs:
     name: runner / staticcheck
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
       - uses: reviewdog/action-staticcheck@v1
         with:
           github_token: ${{ secrets.github_token }}

CONTRIBUTING.md

@@ -1,102 +1,76 @@
-# Contributing
+# 🚀 Contributing to go-zero
 
-Welcome to go-zero!
+Welcome to the go-zero community! We're thrilled to have you here. Contributing to our project is a fantastic way to be a part of the go-zero journey. Let's make this guide exciting and fun!
 
--   [Before you get started](#before-you-get-started)
-    -   [Code of Conduct](#code-of-conduct)
-    -   [Community Expectations](#community-expectations)
--   [Getting started](#getting-started)
--   [Your First Contribution](#your-first-contribution)
-    -   [Find something to work on](#find-something-to-work-on)
-        -   [Find a good first topic](#find-a-good-first-topic)
-        -   [Work on an Issue](#work-on-an-issue)
-        -   [File an Issue](#file-an-issue)
--   [Contributor Workflow](#contributor-workflow)
-    -   [Creating Pull Requests](#creating-pull-requests)
-    -   [Code Review](#code-review)
-    -   [Testing](#testing)
+## 📜 Before You Dive In
 
-# Before you get started
+### 🤝 Code of Conduct
 
-## Code of Conduct
+Let's start on the right foot. Please take a moment to read and embrace our [Code of Conduct](/code-of-conduct.md). We're all about creating a welcoming and respectful environment.
 
-Please make sure to read and observe our [Code of Conduct](/code-of-conduct.md).
+### 🌟 Community Expectations
 
-## Community Expectations
+At go-zero, we're like a close-knit family, and we believe in creating a healthy, friendly, and productive atmosphere. It's all about sharing knowledge and building amazing things together.
 
-go-zero is a community project driven by its community which strives to promote a healthy, friendly and productive environment.
-go-zero is a web and rpc framework written in Go. It's born to ensure the stability of the busy sites with resilient design. Builtin goctl greatly improves the development productivity.
+## 🚀 Getting Started
 
-# Getting started
+Get your adventure rolling! Here's how to begin:
 
-- Fork the repository on GitHub.
-- Make your changes on your fork repository.
-- Submit a PR.
+1. 🍴 **Fork the Repository**: Head over to the GitHub repository and fork it to your own space.
 
+2. 🛠️ **Make Your Magic**: Work your magic in your forked repository. Create new features, squash bugs, or improve documentation - it's your world to conquer!
 
-# Your First Contribution
+3. 🚀 **Submit a PR (Pull Request)**: When you're ready to unveil your creation, submit a Pull Request. We can't wait to see your awesome work!
 
-We will help you to contribute in different areas like filing issues, developing features, fixing critical bugs and
-getting your work reviewed and merged.
+## 🌟 Your First Contribution
 
-If you have questions about the development process,
-feel free to [file an issue](https://github.com/zeromicro/go-zero/issues/new/choose).
+We're here to guide you on your quest to become a go-zero contributor. Whether you want to file issues, develop features, or tame some critical bugs, we've got you covered.
 
-## Find something to work on
+If you have questions or need guidance at any stage, don't hesitate to [open an issue](https://github.com/zeromicro/go-zero/issues/new/choose).
 
-We are always in need of help, be it fixing documentation, reporting bugs or writing some code.
-Look at places where you feel best coding practices aren't followed, code refactoring is needed or tests are missing.
-Here is how you get started.
+## 🔍 Find Something to Work On
 
-### Find a good first topic
+Ready to dive into the action? There are several ways to contribute:
 
-[go-zero](https://github.com/zeromicro/go-zero) has beginner-friendly issues that provide a good first issue.
-For example, [go-zero](https://github.com/zeromicro/go-zero) has
-[help wanted](https://github.com/zeromicro/go-zero/issues?q=is%3Aopen+is%3Aissue+label%3A%22help+wanted%22) and
-[good first issue](https://github.com/zeromicro/go-zero/issues?q=is%3Aopen+is%3Aissue+label%3A%22good+first+issue%22)
-labels for issues that should not need deep knowledge of the system.
-We can help new contributors who wish to work on such issues.
+### 💼 Find a Good First Topic
 
-Another good way to contribute is to find a documentation improvement, such as a missing/broken link.
-Please see [Contributing](#contributing) below for the workflow.
+Discover easy-entry issues labeled as [help wanted](https://github.com/zeromicro/go-zero/issues?q=is%3Aopen+is%3Aissue+label%3A%22help+wanted%22) or [good first issue](https://github.com/zeromicro/go-zero/issues?q=is%3Aopen+is%3Aissue+label%3A%22good+first+issue%22). These issues are perfect for newcomers and don't require deep knowledge of the system. We're here to assist you with these tasks.
 
-#### Work on an issue
+### 🪄 Work on an Issue
 
-When you are willing to take on an issue, just reply on the issue. The maintainer will assign it to you.
+Once you've picked an issue that excites you, let us know by commenting on it. Our maintainers will assign it to you, and you can embark on your mission!
 
-### File an Issue
+### 📢 File an Issue
 
-While we encourage everyone to contribute code, it is also appreciated when someone reports an issue.
+Reporting an issue is just as valuable as code contributions. If you discover a problem, don't hesitate to [open an issue](https://github.com/zeromicro/go-zero/issues/new/choose). Be sure to follow our guidelines when submitting an issue.
 
-Please follow the prompted submission guidelines while opening an issue.
+## 🎯 Contributor Workflow
 
-# Contributor Workflow
+Here's a rough guide to your contributor journey:
 
-Please do not ever hesitate to ask a question or send a pull request.
+1. 🌱 Create a New Branch: Start by creating a topic branch, usually based on the 'master' branch. This is where your contribution will grow.
 
-This is a rough outline of what a contributor's workflow looks like:
+2. 💡 Make Commits: Commit your work in logical units. Each commit should tell a story.
 
-- Create a topic branch from where to base the contribution. This is usually master.
-- Make commits of logical units.
-- Push changes in a topic branch to a personal fork of the repository.
-- Submit a pull request to [go-zero](https://github.com/zeromicro/go-zero).
+3. 🚀 Push Changes: Push the changes in your topic branch to your personal fork of the repository.
 
-## Creating Pull Requests
+4. 📦 Submit a Pull Request: When your creation is complete, submit a Pull Request to the [go-zero repository](https://github.com/zeromicro/go-zero).
 
-Pull requests are often called simply "PR".
-go-zero generally follows the standard [github pull request](https://help.github.com/articles/about-pull-requests/) process.
-To submit a proposed change, please develop the code/fix and add new test cases.
-After that, run these local verifications before submitting pull request to predict the pass or
-fail of continuous integration.
+## 🌠 Creating Pull Requests
 
-* Format the code with `gofmt`
-* Run the test with data race enabled `go test -race ./...`
+Pull Requests (PRs) are your way of making a grand entrance with your contribution. Here's how to do it:
 
-## Code Review
+- 💼 Format Your Code: Ensure your code is beautifully formatted with `gofmt`.
+- 🏃 Run Tests: Verify that your changes pass all the tests, including data race tests. Run `go test -race ./...` for the ultimate validation.
 
-To make it easier for your PR to receive reviews, consider the reviewers will need you to:
+## 👁️‍🗨️ Code Review
 
-* follow [good coding guidelines](https://github.com/golang/go/wiki/CodeReviewComments).
-* write [good commit messages](https://chris.beams.io/posts/git-commit/).
-* break large changes into a logical series of smaller patches which individually make easily understandable changes, and in aggregate solve a broader issue.
+Getting your PR reviewed is the final step before your contribution becomes part of go-zero's magical world. To make the process smooth, keep these things in mind:
 
+- 🧙‍♀️ Follow Good Coding Practices: Stick to [good coding guidelines](https://github.com/golang/go/wiki/CodeReviewComments).
+- 📝 Write Awesome Commit Messages: Craft [impressive commit messages](https://chris.beams.io/posts/git-commit/) - they're like spells in the wizard's book!
+- 🔍 Break It Down: For larger changes, consider breaking them into a series of smaller, logical patches. Each patch should make an understandable and meaningful improvement.
+
+Congratulations on your contribution journey! We're thrilled to have you as part of our go-zero community. Let's make amazing things together! 🌟
+
+Now, go out there and start your adventure! If you have any more magical ideas to enhance this guide, please share them. 🔥

code-of-conduct.md

@@ -1,76 +1,127 @@
+
 # Contributor Covenant Code of Conduct
 
 ## Our Pledge
 
-In the interest of fostering an open and welcoming environment, we as
-contributors and maintainers pledge to make participation in our project and
-our community a harassment-free experience for everyone, regardless of age, body
-size, disability, ethnicity, sex characteristics, gender identity and expression,
-level of experience, education, socio-economic status, nationality, personal
-appearance, race, religion, or sexual identity and orientation.
+We as members, contributors, and leaders pledge to make participation in our
+community a harassment-free experience for everyone, regardless of age, body
+size, visible or invisible disability, ethnicity, sex characteristics, gender
+identity and expression, level of experience, education, socio-economic status,
+nationality, personal appearance, race, caste, color, religion, or sexual
+identity and orientation.
+
+We pledge to act and interact in ways that contribute to an open, welcoming,
+diverse, inclusive, and healthy community.
 
 ## Our Standards
 
-Examples of behavior that contributes to creating a positive environment
-include:
+Examples of behavior that contributes to a positive environment for our
+community include:
 
-* Using welcoming and inclusive language
-* Being respectful of differing viewpoints and experiences
-* Gracefully accepting constructive criticism
-* Focusing on what is best for the community
-* Showing empathy towards other community members
+* Demonstrating empathy and kindness toward other people
+* Being respectful of differing opinions, viewpoints, and experiences
+* Giving and gracefully accepting constructive feedback
+* Accepting responsibility and apologizing to those affected by our mistakes,
+  and learning from the experience
+* Focusing on what is best not just for us as individuals, but for the overall
+  community
 
-Examples of unacceptable behavior by participants include:
+Examples of unacceptable behavior include:
 
-* The use of sexualized language or imagery and unwelcome sexual attention or
-  advances
-* Trolling, insulting/derogatory comments, and personal or political attacks
+* The use of sexualized language or imagery, and sexual attention or advances of
+  any kind
+* Trolling, insulting or derogatory comments, and personal or political attacks
 * Public or private harassment
-* Publishing others' private information, such as a physical or electronic
-  address, without explicit permission
+* Publishing others' private information, such as a physical or email address,
+  without their explicit permission
 * Other conduct which could reasonably be considered inappropriate in a
   professional setting
 
-## Our Responsibilities
+## Enforcement Responsibilities
 
-Project maintainers are responsible for clarifying the standards of acceptable
-behavior and are expected to take appropriate and fair corrective action in
-response to any instances of unacceptable behavior.
+Community leaders are responsible for clarifying and enforcing our standards of
+acceptable behavior and will take appropriate and fair corrective action in
+response to any behavior that they deem inappropriate, threatening, offensive,
+or harmful.
 
-Project maintainers have the right and responsibility to remove, edit, or
-reject comments, commits, code, wiki edits, issues, and other contributions
-that are not aligned to this Code of Conduct, or to ban temporarily or
-permanently any contributor for other behaviors that they deem inappropriate,
-threatening, offensive, or harmful.
+Community leaders have the right and responsibility to remove, edit, or reject
+comments, commits, code, wiki edits, issues, and other contributions that are
+not aligned to this Code of Conduct, and will communicate reasons for moderation
+decisions when appropriate.
 
 ## Scope
 
-This Code of Conduct applies within all project spaces, and it also applies when
-an individual is representing the project or its community in public spaces.
-Examples of representing a project or community include using an official
-project e-mail address, posting via an official social media account, or acting
-as an appointed representative at an online or offline event. Representation of
-a project may be further defined and clarified by project maintainers.
+This Code of Conduct applies within all community spaces, and also applies when
+an individual is officially representing the community in public spaces.
+Examples of representing our community include using an official e-mail address,
+posting via an official social media account, or acting as an appointed
+representative at an online or offline event.
 
 ## Enforcement
 
 Instances of abusive, harassing, or otherwise unacceptable behavior may be
-reported by contacting the project team at [INSERT EMAIL ADDRESS]. All
-complaints will be reviewed and investigated and will result in a response that
-is deemed necessary and appropriate to the circumstances. The project team is
-obligated to maintain confidentiality with regard to the reporter of an incident.
-Further details of specific enforcement policies may be posted separately.
+reported to the community leaders responsible for enforcement at
+[INSERT CONTACT METHOD].
+All complaints will be reviewed and investigated promptly and fairly.
 
-Project maintainers who do not follow or enforce the Code of Conduct in good
-faith may face temporary or permanent repercussions as determined by other
-members of the project's leadership.
+All community leaders are obligated to respect the privacy and security of the
+reporter of any incident.
+
+## Enforcement Guidelines
+
+Community leaders will follow these Community Impact Guidelines in determining
+the consequences for any action they deem in violation of this Code of Conduct:
+
+### 1. Correction
+
+**Community Impact**: Use of inappropriate language or other behavior deemed
+unprofessional or unwelcome in the community.
+
+**Consequence**: A private, written warning from community leaders, providing
+clarity around the nature of the violation and an explanation of why the
+behavior was inappropriate. A public apology may be requested.
+
+### 2. Warning
+
+**Community Impact**: A violation through a single incident or series of
+actions.
+
+**Consequence**: A warning with consequences for continued behavior. No
+interaction with the people involved, including unsolicited interaction with
+those enforcing the Code of Conduct, for a specified period of time. This
+includes avoiding interactions in community spaces as well as external channels
+like social media. Violating these terms may lead to a temporary or permanent
+ban.
+
+### 3. Temporary Ban
+
+**Community Impact**: A serious violation of community standards, including
+sustained inappropriate behavior.
+
+**Consequence**: A temporary ban from any sort of interaction or public
+communication with the community for a specified period of time. No public or
+private interaction with the people involved, including unsolicited interaction
+with those enforcing the Code of Conduct, is allowed during this period.
+Violating these terms may lead to a permanent ban.
+
+### 4. Permanent Ban
+
+**Community Impact**: Demonstrating a pattern of violation of community
+standards, including sustained inappropriate behavior, harassment of an
+individual, or aggression toward or disparagement of classes of individuals.
+
+**Consequence**: A permanent ban from any sort of public interaction within the
+community.
 
 ## Attribution
 
-This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4,
-available at https://www.contributor-covenant.org/version/1/4/code-of-conduct.html
+This Code of Conduct is adapted from the [Contributor Covenant][homepage],
+version 2.1, available at
+[https://www.contributor-covenant.org/version/2/1/code_of_conduct.html][v2.1].
 
-[homepage]: https://www.contributor-covenant.org
+Community Impact Guidelines were inspired by
+[Mozilla's code of conduct enforcement ladder][Mozilla CoC].
 
-For answers to common questions about this code of conduct, see
-https://www.contributor-covenant.org/faq
+For answers to common questions about this code of conduct, see the FAQ at
+[https://www.contributor-covenant.org/faq][FAQ]. Translations are available at
+[https://www.contributor-covenant.org/translations][translations].

core/breaker/breaker.go

@@ -46,23 +46,26 @@ type (
 		// DoWithAcceptable returns an error instantly if the Breaker rejects the request.
 		// If a panic occurs in the request, the Breaker handles it as an error
 		// and causes the same panic again.
-		// acceptable checks if it's a successful call, even if the err is not nil.
+		// acceptable checks if it's a successful call, even if the error is not nil.
 		DoWithAcceptable(req func() error, acceptable Acceptable) error
 
 		// DoWithFallback runs the given request if the Breaker accepts it.
 		// DoWithFallback runs the fallback if the Breaker rejects the request.
 		// If a panic occurs in the request, the Breaker handles it as an error
 		// and causes the same panic again.
-		DoWithFallback(req func() error, fallback func(err error) error) error
+		DoWithFallback(req func() error, fallback Fallback) error
 
 		// DoWithFallbackAcceptable runs the given request if the Breaker accepts it.
 		// DoWithFallbackAcceptable runs the fallback if the Breaker rejects the request.
 		// If a panic occurs in the request, the Breaker handles it as an error
 		// and causes the same panic again.
-		// acceptable checks if it's a successful call, even if the err is not nil.
-		DoWithFallbackAcceptable(req func() error, fallback func(err error) error, acceptable Acceptable) error
+		// acceptable checks if it's a successful call, even if the error is not nil.
+		DoWithFallbackAcceptable(req func() error, fallback Fallback, acceptable Acceptable) error
 	}
 
+	// Fallback is the func to be called if the request is rejected.
+	Fallback func(err error) error
+
 	// Option defines the method to customize a Breaker.
 	Option func(breaker *circuitBreaker)
 
@@ -86,12 +89,12 @@ type (
 
 	internalThrottle interface {
 		allow() (internalPromise, error)
-		doReq(req func() error, fallback func(err error) error, acceptable Acceptable) error
+		doReq(req func() error, fallback Fallback, acceptable Acceptable) error
 	}
 
 	throttle interface {
 		allow() (Promise, error)
-		doReq(req func() error, fallback func(err error) error, acceptable Acceptable) error
+		doReq(req func() error, fallback Fallback, acceptable Acceptable) error
 	}
 )
 
@@ -122,11 +125,11 @@ func (cb *circuitBreaker) DoWithAcceptable(req func() error, acceptable Acceptab
 	return cb.throttle.doReq(req, nil, acceptable)
 }
 
-func (cb *circuitBreaker) DoWithFallback(req func() error, fallback func(err error) error) error {
+func (cb *circuitBreaker) DoWithFallback(req func() error, fallback Fallback) error {
 	return cb.throttle.doReq(req, fallback, defaultAcceptable)
 }
 
-func (cb *circuitBreaker) DoWithFallbackAcceptable(req func() error, fallback func(err error) error,
+func (cb *circuitBreaker) DoWithFallbackAcceptable(req func() error, fallback Fallback,
 	acceptable Acceptable) error {
 	return cb.throttle.doReq(req, fallback, acceptable)
 }
@@ -168,7 +171,7 @@ func (lt loggedThrottle) allow() (Promise, error) {
 	}, lt.logError(err)
 }
 
-func (lt loggedThrottle) doReq(req func() error, fallback func(err error) error, acceptable Acceptable) error {
+func (lt loggedThrottle) doReq(req func() error, fallback Fallback, acceptable Acceptable) error {
 	return lt.logError(lt.internalThrottle.doReq(req, fallback, func(err error) bool {
 		accept := acceptable(err)
 		if !accept && err != nil {
@@ -179,7 +182,7 @@ func (lt loggedThrottle) doReq(req func() error, fallback func(err error) error,
 }
 
 func (lt loggedThrottle) logError(err error) error {
-	if err == ErrServiceUnavailable {
+	if errors.Is(err, ErrServiceUnavailable) {
 		// if circuit open, not possible to have empty error window
 		stat.Report(fmt.Sprintf(
 			"proc(%s/%d), callee: %s, breaker is open and requests dropped\nlast errors:\n%s",

core/breaker/breakers.go

@@ -22,14 +22,14 @@ func DoWithAcceptable(name string, req func() error, acceptable Acceptable) erro
 }
 
 // DoWithFallback calls Breaker.DoWithFallback on the Breaker with given name.
-func DoWithFallback(name string, req func() error, fallback func(err error) error) error {
+func DoWithFallback(name string, req func() error, fallback Fallback) error {
 	return do(name, func(b Breaker) error {
 		return b.DoWithFallback(req, fallback)
 	})
 }
 
 // DoWithFallbackAcceptable calls Breaker.DoWithFallbackAcceptable on the Breaker with given name.
-func DoWithFallbackAcceptable(name string, req func() error, fallback func(err error) error,
+func DoWithFallbackAcceptable(name string, req func() error, fallback Fallback,
 	acceptable Acceptable) error {
 	return do(name, func(b Breaker) error {
 		return b.DoWithFallbackAcceptable(req, fallback, acceptable)
@@ -59,7 +59,7 @@ func GetBreaker(name string) Breaker {
 // NoBreakerFor disables the circuit breaker for the given name.
 func NoBreakerFor(name string) {
 	lock.Lock()
-	breakers[name] = newNoOpBreaker()
+	breakers[name] = NopBreaker()
 	lock.Unlock()
 }
 

core/breaker/breakers_test.go

@@ -30,7 +30,7 @@ func TestBreakersDoWithAcceptable(t *testing.T) {
 		assert.Equal(t, errDummy, GetBreaker("anyone").DoWithAcceptable(func() error {
 			return errDummy
 		}, func(err error) bool {
-			return err == nil || err == errDummy
+			return err == nil || errors.Is(err, errDummy)
 		}))
 	}
 	verify(t, func() bool {
@@ -45,12 +45,12 @@ func TestBreakersDoWithAcceptable(t *testing.T) {
 		}, func(err error) bool {
 			return err == nil
 		})
-		assert.True(t, err == errDummy || err == ErrServiceUnavailable)
+		assert.True(t, errors.Is(err, errDummy) || errors.Is(err, ErrServiceUnavailable))
 	}
 	verify(t, func() bool {
-		return ErrServiceUnavailable == Do("another", func() error {
+		return errors.Is(Do("another", func() error {
 			return nil
-		})
+		}), ErrServiceUnavailable)
 	})
 }
 
@@ -75,12 +75,12 @@ func TestBreakersFallback(t *testing.T) {
 		}, func(err error) error {
 			return nil
 		})
-		assert.True(t, err == nil || err == errDummy)
+		assert.True(t, err == nil || errors.Is(err, errDummy))
 	}
 	verify(t, func() bool {
-		return ErrServiceUnavailable == Do("fallback", func() error {
+		return errors.Is(Do("fallback", func() error {
 			return nil
-		})
+		}), ErrServiceUnavailable)
 	})
 }
 
@@ -94,12 +94,12 @@ func TestBreakersAcceptableFallback(t *testing.T) {
 		}, func(err error) bool {
 			return err == nil
 		})
-		assert.True(t, err == nil || err == errDummy)
+		assert.True(t, err == nil || errors.Is(err, errDummy))
 	}
 	verify(t, func() bool {
-		return ErrServiceUnavailable == Do("acceptablefallback", func() error {
+		return errors.Is(Do("acceptablefallback", func() error {
 			return nil
-		})
+		}), ErrServiceUnavailable)
 	})
 }
 

core/breaker/googlebreaker.go

@@ -1,7 +1,6 @@
 package breaker
 
 import (
-	"math"
 	"time"
 
 	"github.com/zeromicro/go-zero/core/collection"
@@ -38,7 +37,8 @@ func (b *googleBreaker) accept() error {
 	accepts, total := b.history()
 	weightedAccepts := b.k * float64(accepts)
 	// https://landing.google.com/sre/sre-book/chapters/handling-overload/#eq2101
-	dropRatio := math.Max(0, (float64(total-protection)-weightedAccepts)/float64(total+1))
+	// for better performance, no need to care about negative ratio
+	dropRatio := (float64(total-protection) - weightedAccepts) / float64(total+1)
 	if dropRatio <= 0 {
 		return nil
 	}
@@ -60,8 +60,9 @@ func (b *googleBreaker) allow() (internalPromise, error) {
 	}, nil
 }
 
-func (b *googleBreaker) doReq(req func() error, fallback func(err error) error, acceptable Acceptable) error {
+func (b *googleBreaker) doReq(req func() error, fallback Fallback, acceptable Acceptable) error {
 	if err := b.accept(); err != nil {
+		b.markFailure()
 		if fallback != nil {
 			return fallback(err)
 		}
@@ -69,18 +70,19 @@ func (b *googleBreaker) doReq(req func() error, fallback func(err error) error,
 		return err
 	}
 
+	var success bool
 	defer func() {
-		if e := recover(); e != nil {
+		// if req() panic, success is false, mark as failure
+		if success {
+			b.markSuccess()
+		} else {
 			b.markFailure()
-			panic(e)
 		}
 	}()
 
 	err := req()
 	if acceptable(err) {
-		b.markSuccess()
-	} else {
-		b.markFailure()
+		success = true
 	}
 
 	return err

core/breaker/googlebreaker_test.go

@@ -95,7 +95,7 @@ func TestGoogleBreakerAcceptable(t *testing.T) {
 	assert.Equal(t, errAcceptable, b.doReq(func() error {
 		return errAcceptable
 	}, nil, func(err error) bool {
-		return err == errAcceptable
+		return errors.Is(err, errAcceptable)
 	}))
 }
 
@@ -105,7 +105,7 @@ func TestGoogleBreakerNotAcceptable(t *testing.T) {
 	assert.Equal(t, errAcceptable, b.doReq(func() error {
 		return errAcceptable
 	}, nil, func(err error) bool {
-		return err != errAcceptable
+		return !errors.Is(err, errAcceptable)
 	}))
 }
 
@@ -206,7 +206,7 @@ func BenchmarkGoogleBreakerAllow(b *testing.B) {
 	breaker := getGoogleBreaker()
 	b.ResetTimer()
 	for i := 0; i <= b.N; i++ {
-		breaker.accept()
+		_ = breaker.accept()
 		if i%2 == 0 {
 			breaker.markSuccess()
 		} else {
@@ -215,6 +215,16 @@ func BenchmarkGoogleBreakerAllow(b *testing.B) {
 	}
 }
 
+func BenchmarkGoogleBreakerDoReq(b *testing.B) {
+	breaker := getGoogleBreaker()
+	b.ResetTimer()
+	for i := 0; i <= b.N; i++ {
+		_ = breaker.doReq(func() error {
+			return nil
+		}, nil, defaultAcceptable)
+	}
+}
+
 func markSuccess(b *googleBreaker, count int) {
 	for i := 0; i < count; i++ {
 		p, err := b.allow()

core/breaker/nopbreaker.go

@@ -1,35 +1,35 @@
 package breaker
 
-const noOpBreakerName = "nopBreaker"
+const nopBreakerName = "nopBreaker"
 
-type noOpBreaker struct{}
+type nopBreaker struct{}
 
-func newNoOpBreaker() Breaker {
-	return noOpBreaker{}
+// NopBreaker returns a breaker that never trigger breaker circuit.
+func NopBreaker() Breaker {
+	return nopBreaker{}
 }
 
-func (b noOpBreaker) Name() string {
-	return noOpBreakerName
+func (b nopBreaker) Name() string {
+	return nopBreakerName
 }
 
-func (b noOpBreaker) Allow() (Promise, error) {
+func (b nopBreaker) Allow() (Promise, error) {
 	return nopPromise{}, nil
 }
 
-func (b noOpBreaker) Do(req func() error) error {
+func (b nopBreaker) Do(req func() error) error {
 	return req()
 }
 
-func (b noOpBreaker) DoWithAcceptable(req func() error, _ Acceptable) error {
+func (b nopBreaker) DoWithAcceptable(req func() error, _ Acceptable) error {
 	return req()
 }
 
-func (b noOpBreaker) DoWithFallback(req func() error, _ func(err error) error) error {
+func (b nopBreaker) DoWithFallback(req func() error, _ Fallback) error {
 	return req()
 }
 
-func (b noOpBreaker) DoWithFallbackAcceptable(req func() error, _ func(err error) error,
-	_ Acceptable) error {
+func (b nopBreaker) DoWithFallbackAcceptable(req func() error, _ Fallback, _ Acceptable) error {
 	return req()
 }
 

core/breaker/nopbreaker_test.go

@@ -8,8 +8,8 @@ import (
 )
 
 func TestNopBreaker(t *testing.T) {
-	b := newNoOpBreaker()
-	assert.Equal(t, noOpBreakerName, b.Name())
+	b := NopBreaker()
+	assert.Equal(t, nopBreakerName, b.Name())
 	p, err := b.Allow()
 	assert.Nil(t, err)
 	p.Accept()

core/collection/ring.go

@@ -25,8 +25,14 @@ func (r *Ring) Add(v any) {
 	r.lock.Lock()
 	defer r.lock.Unlock()
 
-	r.elements[r.index%len(r.elements)] = v
+	rlen := len(r.elements)
+	r.elements[r.index%rlen] = v
 	r.index++
+
+	// prevent ring index overflow
+	if r.index >= rlen<<1 {
+		r.index -= rlen
+	}
 }
 
 // Take takes all items from r.
@@ -36,16 +42,18 @@ func (r *Ring) Take() []any {
 
 	var size int
 	var start int
-	if r.index > len(r.elements) {
-		size = len(r.elements)
-		start = r.index % len(r.elements)
+	rlen := len(r.elements)
+
+	if r.index > rlen {
+		size = rlen
+		start = r.index % rlen
 	} else {
 		size = r.index
 	}
 
 	elements := make([]any, size)
 	for i := 0; i < size; i++ {
-		elements[i] = r.elements[(start+i)%len(r.elements)]
+		elements[i] = r.elements[(start+i)%rlen]
 	}
 
 	return elements

core/collection/safemap.go

@@ -29,6 +29,8 @@ func NewSafeMap() *SafeMap {
 // Del deletes the value with the given key from m.
 func (m *SafeMap) Del(key any) {
 	m.lock.Lock()
+	defer m.lock.Unlock()
+
 	if _, ok := m.dirtyOld[key]; ok {
 		delete(m.dirtyOld, key)
 		m.deletionOld++
@@ -52,7 +54,6 @@ func (m *SafeMap) Del(key any) {
 		m.dirtyNew = make(map[any]any)
 		m.deletionNew = 0
 	}
-	m.lock.Unlock()
 }
 
 // Get gets the value with the given key from m.
@@ -89,6 +90,8 @@ func (m *SafeMap) Range(f func(key, val any) bool) {
 // Set sets the value into m with the given key.
 func (m *SafeMap) Set(key, value any) {
 	m.lock.Lock()
+	defer m.lock.Unlock()
+
 	if m.deletionOld <= maxDeletion {
 		if _, ok := m.dirtyNew[key]; ok {
 			delete(m.dirtyNew, key)
@@ -102,7 +105,6 @@ func (m *SafeMap) Set(key, value any) {
 		}
 		m.dirtyNew[key] = value
 	}
-	m.lock.Unlock()
 }
 
 // Size returns the size of m.

core/collection/safemap_test.go

@@ -147,3 +147,65 @@ func TestSafeMap_Range(t *testing.T) {
 	assert.Equal(t, m.dirtyNew, newMap.dirtyNew)
 	assert.Equal(t, m.dirtyOld, newMap.dirtyOld)
 }
+
+func TestSetManyTimes(t *testing.T) {
+	const iteration = maxDeletion * 2
+	m := NewSafeMap()
+	for i := 0; i < iteration; i++ {
+		m.Set(i, i)
+		if i%3 == 0 {
+			m.Del(i / 2)
+		}
+	}
+	var count int
+	m.Range(func(k, v any) bool {
+		count++
+		return count < maxDeletion/2
+	})
+	assert.Equal(t, maxDeletion/2, count)
+	for i := 0; i < iteration; i++ {
+		m.Set(i, i)
+		if i%3 == 0 {
+			m.Del(i / 2)
+		}
+	}
+	for i := 0; i < iteration; i++ {
+		m.Set(i, i)
+		if i%3 == 0 {
+			m.Del(i / 2)
+		}
+	}
+	for i := 0; i < iteration; i++ {
+		m.Set(i, i)
+		if i%3 == 0 {
+			m.Del(i / 2)
+		}
+	}
+
+	count = 0
+	m.Range(func(k, v any) bool {
+		count++
+		return count < maxDeletion
+	})
+	assert.Equal(t, maxDeletion, count)
+}
+
+func TestSetManyTimesNew(t *testing.T) {
+	m := NewSafeMap()
+	for i := 0; i < maxDeletion*3; i++ {
+		m.Set(i, i)
+	}
+	for i := 0; i < maxDeletion*2; i++ {
+		m.Del(i)
+	}
+	for i := 0; i < maxDeletion*3; i++ {
+		m.Set(i+maxDeletion*3, i+maxDeletion*3)
+	}
+	for i := 0; i < maxDeletion*2; i++ {
+		m.Del(i + maxDeletion*2)
+	}
+	for i := 0; i < maxDeletion-copyThreshold+1; i++ {
+		m.Del(i + maxDeletion*2)
+	}
+	assert.Equal(t, 0, len(m.dirtyNew))
+}

core/conf/readme.md

@@ -12,7 +12,7 @@ type RestfulConf struct {
 	MaxConns     int           `json:",default=10000"`
 	MaxBytes     int64         `json:",default=1048576"`
 	Timeout      time.Duration `json:",default=3s"`
-	CpuThreshold int64         `json:",default=900,range=[0:1000]"`
+	CpuThreshold int64         `json:",default=900,range=[0:1000)"`
 }
 ```
 

core/discov/internal/registry.go

@@ -2,6 +2,7 @@ package internal
 
 import (
 	"context"
+	"errors"
 	"fmt"
 	"io"
 	"sort"
@@ -14,6 +15,7 @@ import (
 	"github.com/zeromicro/go-zero/core/logx"
 	"github.com/zeromicro/go-zero/core/syncx"
 	"github.com/zeromicro/go-zero/core/threading"
+	"go.etcd.io/etcd/api/v3/v3rpc/rpctypes"
 	clientv3 "go.etcd.io/etcd/client/v3"
 )
 
@@ -22,6 +24,7 @@ var (
 		clusters: make(map[string]*cluster),
 	}
 	connManager = syncx.NewResourceManager()
+	errClosed   = errors.New("etcd monitor chan has been closed")
 )
 
 // A Registry is a registry that manages the etcd client connections.
@@ -288,40 +291,47 @@ func (c *cluster) reload(cli EtcdClient) {
 
 func (c *cluster) watch(cli EtcdClient, key string, rev int64) {
 	for {
-		if c.watchStream(cli, key, rev) {
+		err := c.watchStream(cli, key, rev)
+		if err == nil {
 			return
 		}
+
+		if rev != 0 && errors.Is(err, rpctypes.ErrCompacted) {
+			logx.Errorf("etcd watch stream has been compacted, try to reload, rev %d", rev)
+			rev = c.load(cli, key)
+		}
+
+		// log the error and retry
+		logx.Error(err)
 	}
 }
 
-func (c *cluster) watchStream(cli EtcdClient, key string, rev int64) bool {
+func (c *cluster) watchStream(cli EtcdClient, key string, rev int64) error {
 	var rch clientv3.WatchChan
 	if rev != 0 {
-		rch = cli.Watch(clientv3.WithRequireLeader(c.context(cli)), makeKeyPrefix(key), clientv3.WithPrefix(),
-			clientv3.WithRev(rev+1))
+		rch = cli.Watch(clientv3.WithRequireLeader(c.context(cli)), makeKeyPrefix(key),
+			clientv3.WithPrefix(), clientv3.WithRev(rev+1))
 	} else {
-		rch = cli.Watch(clientv3.WithRequireLeader(c.context(cli)), makeKeyPrefix(key), clientv3.WithPrefix())
+		rch = cli.Watch(clientv3.WithRequireLeader(c.context(cli)), makeKeyPrefix(key),
+			clientv3.WithPrefix())
 	}
 
 	for {
 		select {
 		case wresp, ok := <-rch:
 			if !ok {
-				logx.Error("etcd monitor chan has been closed")
-				return false
+				return errClosed
 			}
 			if wresp.Canceled {
-				logx.Errorf("etcd monitor chan has been canceled, error: %v", wresp.Err())
-				return false
+				return fmt.Errorf("etcd monitor chan has been canceled, error: %w", wresp.Err())
 			}
 			if wresp.Err() != nil {
-				logx.Error(fmt.Sprintf("etcd monitor chan error: %v", wresp.Err()))
-				return false
+				return fmt.Errorf("etcd monitor chan error: %w", wresp.Err())
 			}
 
 			c.handleWatchEvents(key, wresp.Events)
 		case <-c.done:
-			return true
+			return nil
 		}
 	}
 }

core/errorx/batcherror.go

@@ -1,11 +1,15 @@
 package errorx
 
-import "bytes"
+import (
+	"bytes"
+	"sync"
+)
 
 type (
 	// A BatchError is an error that can hold multiple errors.
 	BatchError struct {
 		errs errorArray
+		lock sync.Mutex
 	}
 
 	errorArray []error
@@ -13,6 +17,9 @@ type (
 
 // Add adds errs to be, nil errors are ignored.
 func (be *BatchError) Add(errs ...error) {
+	be.lock.Lock()
+	defer be.lock.Unlock()
+
 	for _, err := range errs {
 		if err != nil {
 			be.errs = append(be.errs, err)
@@ -22,6 +29,9 @@ func (be *BatchError) Add(errs ...error) {
 
 // Err returns an error that represents all errors.
 func (be *BatchError) Err() error {
+	be.lock.Lock()
+	defer be.lock.Unlock()
+
 	switch len(be.errs) {
 	case 0:
 		return nil
@@ -34,6 +44,9 @@ func (be *BatchError) Err() error {
 
 // NotNil checks if any error inside.
 func (be *BatchError) NotNil() bool {
+	be.lock.Lock()
+	defer be.lock.Unlock()
+
 	return len(be.errs) > 0
 }
 

core/errorx/batcherror_test.go

@@ -3,6 +3,7 @@ package errorx
 import (
 	"errors"
 	"fmt"
+	"sync"
 	"testing"
 
 	"github.com/stretchr/testify/assert"
@@ -33,7 +34,7 @@ func TestBatchErrorNilFromFunc(t *testing.T) {
 func TestBatchErrorOneError(t *testing.T) {
 	var batch BatchError
 	batch.Add(errors.New(err1))
-	assert.NotNil(t, batch)
+	assert.NotNil(t, batch.Err())
 	assert.Equal(t, err1, batch.Err().Error())
 	assert.True(t, batch.NotNil())
 }
@@ -42,7 +43,26 @@ func TestBatchErrorWithErrors(t *testing.T) {
 	var batch BatchError
 	batch.Add(errors.New(err1))
 	batch.Add(errors.New(err2))
-	assert.NotNil(t, batch)
+	assert.NotNil(t, batch.Err())
 	assert.Equal(t, fmt.Sprintf("%s\n%s", err1, err2), batch.Err().Error())
 	assert.True(t, batch.NotNil())
 }
+
+func TestBatchErrorConcurrentAdd(t *testing.T) {
+	const count = 10000
+	var batch BatchError
+	var wg sync.WaitGroup
+
+	wg.Add(count)
+	for i := 0; i < count; i++ {
+		go func() {
+			defer wg.Done()
+			batch.Add(errors.New(err1))
+		}()
+	}
+	wg.Wait()
+
+	assert.NotNil(t, batch.Err())
+	assert.Equal(t, count, len(batch.errs))
+	assert.True(t, batch.NotNil())
+}

core/fx/retry.go

@@ -10,16 +10,15 @@ import (
 
 const defaultRetryTimes = 3
 
-var errTimeout = errors.New("retry timeout")
-
 type (
 	// RetryOption defines the method to customize DoWithRetry.
 	RetryOption func(*retryOptions)
 
 	retryOptions struct {
-		times    int
-		interval time.Duration
-		timeout  time.Duration
+		times        int
+		interval     time.Duration
+		timeout      time.Duration
+		ignoreErrors []error
 	}
 )
 
@@ -28,7 +27,7 @@ type (
 // and performs modification operations, it is best to lock them,
 // otherwise there may be data race issues
 func DoWithRetry(fn func() error, opts ...RetryOption) error {
-	return retry(func(errChan chan error, retryCount int) {
+	return retry(context.Background(), func(errChan chan error, retryCount int) {
 		errChan <- fn()
 	}, opts...)
 }
@@ -40,12 +39,12 @@ func DoWithRetry(fn func() error, opts ...RetryOption) error {
 // otherwise there may be data race issues
 func DoWithRetryCtx(ctx context.Context, fn func(ctx context.Context, retryCount int) error,
 	opts ...RetryOption) error {
-	return retry(func(errChan chan error, retryCount int) {
+	return retry(ctx, func(errChan chan error, retryCount int) {
 		errChan <- fn(ctx, retryCount)
 	}, opts...)
 }
 
-func retry(fn func(errChan chan error, retryCount int), opts ...RetryOption) error {
+func retry(ctx context.Context, fn func(errChan chan error, retryCount int), opts ...RetryOption) error {
 	options := newRetryOptions()
 	for _, opt := range opts {
 		opt(options)
@@ -53,7 +52,6 @@ func retry(fn func(errChan chan error, retryCount int), opts ...RetryOption) err
 
 	var berr errorx.BatchError
 	var cancelFunc context.CancelFunc
-	ctx := context.Background()
 	if options.timeout > 0 {
 		ctx, cancelFunc = context.WithTimeout(ctx, options.timeout)
 		defer cancelFunc()
@@ -66,19 +64,24 @@ func retry(fn func(errChan chan error, retryCount int), opts ...RetryOption) err
 		select {
 		case err := <-errChan:
 			if err != nil {
+				for _, ignoreErr := range options.ignoreErrors {
+					if errors.Is(err, ignoreErr) {
+						return nil
+					}
+				}
 				berr.Add(err)
 			} else {
 				return nil
 			}
 		case <-ctx.Done():
-			berr.Add(errTimeout)
+			berr.Add(ctx.Err())
 			return berr.Err()
 		}
 
 		if options.interval > 0 {
 			select {
 			case <-ctx.Done():
-				berr.Add(errTimeout)
+				berr.Add(ctx.Err())
 				return berr.Err()
 			case <-time.After(options.interval):
 			}
@@ -88,19 +91,28 @@ func retry(fn func(errChan chan error, retryCount int), opts ...RetryOption) err
 	return berr.Err()
 }
 
-// WithRetry customize a DoWithRetry call with given retry times.
-func WithRetry(times int) RetryOption {
+// WithIgnoreErrors Ignore the specified errors
+func WithIgnoreErrors(ignoreErrors []error) RetryOption {
 	return func(options *retryOptions) {
-		options.times = times
+		options.ignoreErrors = ignoreErrors
 	}
 }
 
+// WithInterval customizes a DoWithRetry call with given interval.
 func WithInterval(interval time.Duration) RetryOption {
 	return func(options *retryOptions) {
 		options.interval = interval
 	}
 }
 
+// WithRetry customizes a DoWithRetry call with given retry times.
+func WithRetry(times int) RetryOption {
+	return func(options *retryOptions) {
+		options.times = times
+	}
+}
+
+// WithTimeout customizes a DoWithRetry call with given timeout.
 func WithTimeout(timeout time.Duration) RetryOption {
 	return func(options *retryOptions) {
 		options.timeout = timeout

core/fx/retry_test.go

@@ -97,20 +97,70 @@ func TestRetryWithInterval(t *testing.T) {
 
 }
 
-func TestRetryCtx(t *testing.T) {
-	assert.NotNil(t, DoWithRetryCtx(context.Background(), func(ctx context.Context, retryCount int) error {
-		if retryCount == 0 {
-			return errors.New("any")
-		}
-		time.Sleep(time.Millisecond * 150)
-		return nil
-	}, WithTimeout(time.Millisecond*250), WithInterval(time.Millisecond*150)))
+func TestRetryWithWithIgnoreErrors(t *testing.T) {
+	ignoreErr1 := errors.New("ignore error1")
+	ignoreErr2 := errors.New("ignore error2")
+	ignoreErrs := []error{ignoreErr1, ignoreErr2}
 
-	assert.NotNil(t, DoWithRetryCtx(context.Background(), func(ctx context.Context, retryCount int) error {
-		if retryCount == 1 {
-			return nil
-		}
-		time.Sleep(time.Millisecond * 150)
-		return errors.New("any ")
-	}, WithTimeout(time.Millisecond*250), WithInterval(time.Millisecond*150)))
+	assert.Nil(t, DoWithRetry(func() error {
+		return ignoreErr1
+	}, WithIgnoreErrors(ignoreErrs)))
+
+	assert.Nil(t, DoWithRetry(func() error {
+		return ignoreErr2
+	}, WithIgnoreErrors(ignoreErrs)))
+
+	assert.NotNil(t, DoWithRetry(func() error {
+		return errors.New("any")
+	}))
+}
+
+func TestRetryCtx(t *testing.T) {
+	t.Run("with timeout", func(t *testing.T) {
+		assert.NotNil(t, DoWithRetryCtx(context.Background(), func(ctx context.Context, retryCount int) error {
+			if retryCount == 0 {
+				return errors.New("any")
+			}
+			time.Sleep(time.Millisecond * 150)
+			return nil
+		}, WithTimeout(time.Millisecond*250), WithInterval(time.Millisecond*150)))
+
+		assert.NotNil(t, DoWithRetryCtx(context.Background(), func(ctx context.Context, retryCount int) error {
+			if retryCount == 1 {
+				return nil
+			}
+			time.Sleep(time.Millisecond * 150)
+			return errors.New("any ")
+		}, WithTimeout(time.Millisecond*250), WithInterval(time.Millisecond*150)))
+	})
+
+	t.Run("with deadline exceeded", func(t *testing.T) {
+		ctx, cancel := context.WithDeadline(context.Background(), time.Now().Add(time.Millisecond*250))
+		defer cancel()
+
+		var times int
+		assert.Error(t, DoWithRetryCtx(ctx, func(ctx context.Context, retryCount int) error {
+			times++
+			time.Sleep(time.Millisecond * 150)
+			return errors.New("any")
+		}, WithInterval(time.Millisecond*150)))
+		assert.Equal(t, 1, times)
+	})
+
+	t.Run("with deadline not exceeded", func(t *testing.T) {
+		ctx, cancel := context.WithDeadline(context.Background(), time.Now().Add(time.Millisecond*250))
+		defer cancel()
+
+		var times int
+		assert.NoError(t, DoWithRetryCtx(ctx, func(ctx context.Context, retryCount int) error {
+			times++
+			if times == defaultRetryTimes {
+				return nil
+			}
+
+			time.Sleep(time.Millisecond * 50)
+			return errors.New("any")
+		}))
+		assert.Equal(t, defaultRetryTimes, times)
+	})
 }

core/iox/bufferpool.go

@@ -32,6 +32,10 @@ func (bp *BufferPool) Get() *bytes.Buffer {
 
 // Put returns buf into bp.
 func (bp *BufferPool) Put(buf *bytes.Buffer) {
+	if buf == nil {
+		return
+	}
+
 	if buf.Cap() < bp.capability {
 		bp.pool.Put(buf)
 	}

core/iox/bufferpool_test.go

@@ -13,3 +13,26 @@ func TestBufferPool(t *testing.T) {
 	pool.Put(bytes.NewBuffer(make([]byte, 0, 2*capacity)))
 	assert.True(t, pool.Get().Cap() <= capacity)
 }
+
+func TestBufferPool_Put(t *testing.T) {
+	t.Run("with nil buf", func(t *testing.T) {
+		pool := NewBufferPool(1024)
+		pool.Put(nil)
+		val := pool.Get()
+		assert.IsType(t, new(bytes.Buffer), val)
+	})
+
+	t.Run("with less-cap buf", func(t *testing.T) {
+		pool := NewBufferPool(1024)
+		pool.Put(bytes.NewBuffer(make([]byte, 0, 512)))
+		val := pool.Get()
+		assert.IsType(t, new(bytes.Buffer), val)
+	})
+
+	t.Run("with more-cap buf", func(t *testing.T) {
+		pool := NewBufferPool(1024)
+		pool.Put(bytes.NewBuffer(make([]byte, 0, 1024<<1)))
+		val := pool.Get()
+		assert.IsType(t, new(bytes.Buffer), val)
+	})
+}

core/iox/nopcloser_test.go

@@ -0,0 +1,12 @@
+package iox
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestNopCloser(t *testing.T) {
+	closer := NopCloser(nil)
+	assert.NoError(t, closer.Close())
+}

core/iox/read.go

@@ -35,6 +35,16 @@ func KeepSpace() TextReadOption {
 	}
 }
 
+// LimitDupReadCloser returns two io.ReadCloser that read from the first will be written to the second.
+// But the second io.ReadCloser is limited to up to n bytes.
+// The first returned reader needs to be read first, because the content
+// read from it will be written to the underlying buffer of the second reader.
+func LimitDupReadCloser(reader io.ReadCloser, n int64) (io.ReadCloser, io.ReadCloser) {
+	var buf bytes.Buffer
+	tee := LimitTeeReader(reader, &buf, n)
+	return io.NopCloser(tee), io.NopCloser(&buf)
+}
+
 // ReadBytes reads exactly the bytes with the length of len(buf)
 func ReadBytes(reader io.Reader, buf []byte) error {
 	var got int

core/iox/read_test.go

@@ -51,6 +51,11 @@ b`,
 	}
 }
 
+func TestReadTextError(t *testing.T) {
+	_, err := ReadText("not-exist")
+	assert.NotNil(t, err)
+}
+
 func TestReadTextLines(t *testing.T) {
 	text := `1
 
@@ -94,6 +99,11 @@ func TestReadTextLines(t *testing.T) {
 	}
 }
 
+func TestReadTextLinesError(t *testing.T) {
+	_, err := ReadTextLines("not-exist")
+	assert.NotNil(t, err)
+}
+
 func TestDupReadCloser(t *testing.T) {
 	input := "hello"
 	reader := io.NopCloser(bytes.NewBufferString(input))
@@ -108,6 +118,29 @@ func TestDupReadCloser(t *testing.T) {
 	verify(r2)
 }
 
+func TestLimitDupReadCloser(t *testing.T) {
+	input := "hello world"
+	limitBytes := int64(4)
+	reader := io.NopCloser(bytes.NewBufferString(input))
+	r1, r2 := LimitDupReadCloser(reader, limitBytes)
+	verify := func(r io.Reader) {
+		output, err := io.ReadAll(r)
+		assert.Nil(t, err)
+		assert.Equal(t, input, string(output))
+	}
+	verifyLimit := func(r io.Reader, limit int64) {
+		output, err := io.ReadAll(r)
+		if limit < int64(len(input)) {
+			input = input[:limit]
+		}
+		assert.Nil(t, err)
+		assert.Equal(t, input, string(output))
+	}
+
+	verify(r1)
+	verifyLimit(r2, limitBytes)
+}
+
 func TestReadBytes(t *testing.T) {
 	reader := io.NopCloser(bytes.NewBufferString("helloworld"))
 	buf := make([]byte, 5)

core/iox/tee.go

@@ -0,0 +1,35 @@
+package iox
+
+import "io"
+
+// LimitTeeReader returns a Reader that writes up to n bytes to w what it reads from r.
+// First n bytes reads from r performed through it are matched with
+// corresponding writes to w. There is no internal buffering -
+// the write must complete before the first n bytes read completes.
+// Any error encountered while writing is reported as a read error.
+func LimitTeeReader(r io.Reader, w io.Writer, n int64) io.Reader {
+	return &limitTeeReader{r, w, n}
+}
+
+type limitTeeReader struct {
+	r io.Reader
+	w io.Writer
+	n int64 // limit bytes remaining
+}
+
+func (t *limitTeeReader) Read(p []byte) (n int, err error) {
+	n, err = t.r.Read(p)
+	if n > 0 && t.n > 0 {
+		limit := int64(n)
+		if limit > t.n {
+			limit = t.n
+		}
+		if n, err := t.w.Write(p[:limit]); err != nil {
+			return n, err
+		}
+
+		t.n -= limit
+	}
+
+	return
+}

core/iox/tee_test.go

@@ -0,0 +1,40 @@
+package iox
+
+import (
+	"bytes"
+	"io"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestLimitTeeReader(t *testing.T) {
+	limit := int64(4)
+	src := []byte("hello, world")
+	dst := make([]byte, len(src))
+	rb := bytes.NewBuffer(src)
+	wb := new(bytes.Buffer)
+	r := LimitTeeReader(rb, wb, limit)
+	if n, err := io.ReadFull(r, dst); err != nil || n != len(src) {
+		t.Fatalf("ReadFull(r, dst) = %d, %v; want %d, nil", n, err, len(src))
+	}
+	if !bytes.Equal(dst, src) {
+		t.Errorf("bytes read = %q want %q", dst, src)
+	}
+	if !bytes.Equal(wb.Bytes(), src[:limit]) {
+		t.Errorf("bytes written = %q want %q", wb.Bytes(), src)
+	}
+
+	n, err := r.Read(dst)
+	assert.Equal(t, 0, n)
+	assert.Equal(t, io.EOF, err)
+
+	rb = bytes.NewBuffer(src)
+	pr, pw := io.Pipe()
+	if assert.NoError(t, pr.Close()) {
+		r = LimitTeeReader(rb, pw, limit)
+		n, err := io.ReadFull(r, dst)
+		assert.Equal(t, 0, n)
+		assert.Equal(t, io.ErrClosedPipe, err)
+	}
+}

core/iox/textfile.go

@@ -2,6 +2,7 @@ package iox
 
 import (
 	"bytes"
+	"errors"
 	"io"
 	"os"
 )
@@ -26,7 +27,7 @@ func CountLines(file string) (int, error) {
 		count += bytes.Count(buf[:c], lineSep)
 
 		switch {
-		case err == io.EOF:
+		case errors.Is(err, io.EOF):
 			if noEol {
 				count++
 			}

core/iox/textfile_test.go

@@ -24,3 +24,8 @@ func TestCountLines(t *testing.T) {
 	assert.Nil(t, err)
 	assert.Equal(t, 4, lines)
 }
+
+func TestCountLinesError(t *testing.T) {
+	_, err := CountLines("not-exist")
+	assert.NotNil(t, err)
+}

core/iox/textlinescanner_test.go

@@ -3,6 +3,7 @@ package iox
 import (
 	"strings"
 	"testing"
+	"testing/iotest"
 
 	"github.com/stretchr/testify/assert"
 )
@@ -22,3 +23,10 @@ func TestScanner(t *testing.T) {
 	}
 	assert.EqualValues(t, []string{"1", "2", "3", "4"}, lines)
 }
+
+func TestBadScanner(t *testing.T) {
+	scanner := NewTextLineScanner(iotest.ErrReader(iotest.ErrTimeout))
+	assert.False(t, scanner.Scan())
+	_, err := scanner.Line()
+	assert.ErrorIs(t, err, iotest.ErrTimeout)
+}

core/load/adaptiveshedder.go

@@ -9,6 +9,7 @@ import (
 
 	"github.com/zeromicro/go-zero/core/collection"
 	"github.com/zeromicro/go-zero/core/logx"
+	"github.com/zeromicro/go-zero/core/mathx"
 	"github.com/zeromicro/go-zero/core/stat"
 	"github.com/zeromicro/go-zero/core/syncx"
 	"github.com/zeromicro/go-zero/core/timex"
@@ -21,8 +22,11 @@ const (
 	defaultCpuThreshold = 900
 	defaultMinRt        = float64(time.Second / time.Millisecond)
 	// moving average hyperparameter beta for calculating requests on the fly
-	flyingBeta      = 0.9
-	coolOffDuration = time.Second
+	flyingBeta               = 0.9
+	coolOffDuration          = time.Second
+	cpuMax                   = 1000 // millicpu
+	millisecondsPerSecond    = 1000
+	overloadFactorLowerBound = 0.1
 )
 
 var (
@@ -66,7 +70,7 @@ type (
 
 	adaptiveShedder struct {
 		cpuThreshold    int64
-		windows         int64
+		windowScale     float64
 		flying          int64
 		avgFlying       float64
 		avgFlyingLock   syncx.SpinLock
@@ -105,7 +109,7 @@ func NewAdaptiveShedder(opts ...ShedderOption) Shedder {
 	bucketDuration := options.window / time.Duration(options.buckets)
 	return &adaptiveShedder{
 		cpuThreshold:    options.cpuThreshold,
-		windows:         int64(time.Second / bucketDuration),
+		windowScale:     float64(time.Second) / float64(bucketDuration) / millisecondsPerSecond,
 		overloadTime:    syncx.NewAtomicDuration(),
 		droppedRecently: syncx.NewAtomicBool(),
 		passCounter: collection.NewRollingWindow(options.buckets, bucketDuration,
@@ -136,7 +140,7 @@ func (as *adaptiveShedder) addFlying(delta int64) {
 	// update avgFlying when the request is finished.
 	// this strategy makes avgFlying have a little bit lag against flying, and smoother.
 	// when the flying requests increase rapidly, avgFlying increase slower, accept more requests.
-	// when the flying requests drop rapidly, avgFlying drop slower, accept less requests.
+	// when the flying requests drop rapidly, avgFlying drop slower, accept fewer requests.
 	// it makes the service to serve as more requests as possible.
 	if delta < 0 {
 		as.avgFlyingLock.Lock()
@@ -149,16 +153,17 @@ func (as *adaptiveShedder) highThru() bool {
 	as.avgFlyingLock.Lock()
 	avgFlying := as.avgFlying
 	as.avgFlyingLock.Unlock()
-	maxFlight := as.maxFlight()
-	return int64(avgFlying) > maxFlight && atomic.LoadInt64(&as.flying) > maxFlight
+	maxFlight := as.maxFlight() * as.overloadFactor()
+	return avgFlying > maxFlight && float64(atomic.LoadInt64(&as.flying)) > maxFlight
 }
 
-func (as *adaptiveShedder) maxFlight() int64 {
+func (as *adaptiveShedder) maxFlight() float64 {
 	// windows = buckets per second
 	// maxQPS = maxPASS * windows
 	// minRT = min average response time in milliseconds
-	// maxQPS * minRT / milliseconds_per_second
-	return int64(math.Max(1, float64(as.maxPass()*as.windows)*(as.minRt()/1e3)))
+	// allowedFlying = maxQPS * minRT / milliseconds_per_second
+	maxFlight := float64(as.maxPass()) * as.minRt() * as.windowScale
+	return mathx.AtLeast(maxFlight, 1)
 }
 
 func (as *adaptiveShedder) maxPass() int64 {
@@ -174,6 +179,8 @@ func (as *adaptiveShedder) maxPass() int64 {
 }
 
 func (as *adaptiveShedder) minRt() float64 {
+	// if no requests in previous windows, return defaultMinRt,
+	// its a reasonable large value to avoid dropping requests.
 	result := defaultMinRt
 
 	as.rtCounter.Reduce(func(b *collection.Bucket) {
@@ -190,6 +197,13 @@ func (as *adaptiveShedder) minRt() float64 {
 	return result
 }
 
+func (as *adaptiveShedder) overloadFactor() float64 {
+	// as.cpuThreshold must be less than cpuMax
+	factor := (cpuMax - float64(stat.CpuUsage())) / (cpuMax - float64(as.cpuThreshold))
+	// at least accept 10% of acceptable requests even cpu is highly overloaded.
+	return mathx.Between(factor, overloadFactorLowerBound, 1)
+}
+
 func (as *adaptiveShedder) shouldDrop() bool {
 	if as.systemOverloaded() || as.stillHot() {
 		if as.highThru() {

core/load/adaptiveshedder_test.go

@@ -19,6 +19,7 @@ import (
 const (
 	buckets        = 10
 	bucketDuration = time.Millisecond * 50
+	windowFactor   = 0.01
 )
 
 func init() {
@@ -114,10 +115,10 @@ func TestAdaptiveShedderMaxFlight(t *testing.T) {
 	shedder := &adaptiveShedder{
 		passCounter:     passCounter,
 		rtCounter:       rtCounter,
-		windows:         buckets,
+		windowScale:     windowFactor,
 		droppedRecently: syncx.NewAtomicBool(),
 	}
-	assert.Equal(t, int64(54), shedder.maxFlight())
+	assert.Equal(t, float64(54), shedder.maxFlight())
 }
 
 func TestAdaptiveShedderShouldDrop(t *testing.T) {
@@ -136,7 +137,7 @@ func TestAdaptiveShedderShouldDrop(t *testing.T) {
 	shedder := &adaptiveShedder{
 		passCounter:     passCounter,
 		rtCounter:       rtCounter,
-		windows:         buckets,
+		windowScale:     windowFactor,
 		overloadTime:    syncx.NewAtomicDuration(),
 		droppedRecently: syncx.NewAtomicBool(),
 	}
@@ -149,7 +150,8 @@ func TestAdaptiveShedderShouldDrop(t *testing.T) {
 
 	// cpu >=  800, inflight > maxPass
 	shedder.avgFlying = 80
-	shedder.flying = 50
+	// because of the overloadFactor, so we need to make sure maxFlight is greater than flying
+	shedder.flying = int64(shedder.maxFlight()*shedder.overloadFactor()) - 5
 	assert.False(t, shedder.shouldDrop())
 
 	// cpu >=  800, inflight > maxPass
@@ -190,7 +192,7 @@ func TestAdaptiveShedderStillHot(t *testing.T) {
 	shedder := &adaptiveShedder{
 		passCounter:     passCounter,
 		rtCounter:       rtCounter,
-		windows:         buckets,
+		windowScale:     windowFactor,
 		overloadTime:    syncx.NewAtomicDuration(),
 		droppedRecently: syncx.ForAtomicBool(true),
 	}
@@ -239,6 +241,30 @@ func BenchmarkAdaptiveShedder_Allow(b *testing.B) {
 	b.Run("low load", bench)
 }
 
+func BenchmarkMaxFlight(b *testing.B) {
+	passCounter := newRollingWindow()
+	rtCounter := newRollingWindow()
+	for i := 0; i < 10; i++ {
+		if i > 0 {
+			time.Sleep(bucketDuration)
+		}
+		passCounter.Add(float64((i + 1) * 100))
+		for j := i*10 + 1; j <= i*10+10; j++ {
+			rtCounter.Add(float64(j))
+		}
+	}
+	shedder := &adaptiveShedder{
+		passCounter:     passCounter,
+		rtCounter:       rtCounter,
+		windowScale:     windowFactor,
+		droppedRecently: syncx.NewAtomicBool(),
+	}
+
+	for i := 0; i < b.N; i++ {
+		_ = shedder.maxFlight()
+	}
+}
+
 func newRollingWindow() *collection.RollingWindow {
 	return collection.NewRollingWindow(buckets, bucketDuration, collection.IgnoreCurrentBucket())
 }

core/logx/logs.go

@@ -17,14 +17,13 @@ import (
 const callerDepth = 4
 
 var (
-	timeFormat = "2006-01-02T15:04:05.000Z07:00"
-	logLevel   uint32
+	timeFormat        = "2006-01-02T15:04:05.000Z07:00"
 	encoding   uint32 = jsonEncodingType
 	// maxContentLength is used to truncate the log content, 0 for not truncating.
 	maxContentLength uint32
 	// use uint32 for atomic operations
-	disableLog  uint32
 	disableStat uint32
+	logLevel    uint32
 	options     logOptions
 	writer      = new(atomicWriter)
 	setupOnce   sync.Once
@@ -96,7 +95,7 @@ func Debugw(msg string, fields ...LogField) {
 
 // Disable disables the logging.
 func Disable() {
-	atomic.StoreUint32(&disableLog, 1)
+	atomic.StoreUint32(&logLevel, disableLevel)
 	writer.Store(nopWriter{})
 }
 
@@ -250,7 +249,7 @@ func SetLevel(level uint32) {
 
 // SetWriter sets the logging writer. It can be used to customize the logging.
 func SetWriter(w Writer) {
-	if atomic.LoadUint32(&disableLog) == 0 {
+	if atomic.LoadUint32(&logLevel) != disableLevel {
 		writer.Store(w)
 	}
 }

core/logx/logs_test.go

@@ -666,6 +666,7 @@ func TestDisable(t *testing.T) {
 	WithMaxSize(1024)(&opt)
 	assert.Nil(t, Close())
 	assert.Nil(t, Close())
+	assert.Equal(t, uint32(disableLevel), atomic.LoadUint32(&logLevel))
 }
 
 func TestDisableStat(t *testing.T) {
@@ -680,7 +681,7 @@ func TestDisableStat(t *testing.T) {
 }
 
 func TestSetWriter(t *testing.T) {
-	atomic.StoreUint32(&disableLog, 0)
+	atomic.StoreUint32(&logLevel, 0)
 	Reset()
 	SetWriter(nopWriter{})
 	assert.NotNil(t, writer.Load())

core/logx/readme.md

@@ -40,7 +40,7 @@ type LogConf struct {
 - `Compress`: whether or not to compress log files, only works with `file` mode.
 - `KeepDays`: how many days that the log files are kept, after the given days, the outdated files will be deleted automatically. It has no effect on `console` mode.
 - `StackCooldownMillis`: how many milliseconds to rewrite stacktrace again. It’s used to avoid stacktrace flooding.
-- `MaxBackups`: represents how many backup log files will be kept. 0 means all files will be kept forever. Only take effect when `Rotation` is `size`. NOTE: the level of option `KeepDays` will be higher. Even thougth `MaxBackups` sets 0, log files will still be removed if the `KeepDays` limitation is reached.
+- `MaxBackups`: represents how many backup log files will be kept. 0 means all files will be kept forever. Only take effect when `Rotation` is `size`. NOTE: the level of option `KeepDays` will be higher. Even though `MaxBackups` sets 0, log files will still be removed if the `KeepDays` limitation is reached.
 - `MaxSize`: represents how much space the writing log file takes up. 0 means no limit. The unit is `MB`. Only take effect when `Rotation` is `size`.
 - `Rotation`: represents the type of log rotation rule. Default is `daily`.
   - `daily` rotate the logs by day.

core/logx/richlogger.go

@@ -41,67 +41,99 @@ type richLogger struct {
 }
 
 func (l *richLogger) Debug(v ...any) {
-	l.debug(fmt.Sprint(v...))
+	if shallLog(DebugLevel) {
+		l.debug(fmt.Sprint(v...))
+	}
 }
 
 func (l *richLogger) Debugf(format string, v ...any) {
-	l.debug(fmt.Sprintf(format, v...))
+	if shallLog(DebugLevel) {
+		l.debug(fmt.Sprintf(format, v...))
+	}
 }
 
 func (l *richLogger) Debugv(v any) {
-	l.debug(v)
+	if shallLog(DebugLevel) {
+		l.debug(v)
+	}
 }
 
 func (l *richLogger) Debugw(msg string, fields ...LogField) {
-	l.debug(msg, fields...)
+	if shallLog(DebugLevel) {
+		l.debug(msg, fields...)
+	}
 }
 
 func (l *richLogger) Error(v ...any) {
-	l.err(fmt.Sprint(v...))
+	if shallLog(ErrorLevel) {
+		l.err(fmt.Sprint(v...))
+	}
 }
 
 func (l *richLogger) Errorf(format string, v ...any) {
-	l.err(fmt.Sprintf(format, v...))
+	if shallLog(ErrorLevel) {
+		l.err(fmt.Sprintf(format, v...))
+	}
 }
 
 func (l *richLogger) Errorv(v any) {
-	l.err(v)
+	if shallLog(ErrorLevel) {
+		l.err(v)
+	}
 }
 
 func (l *richLogger) Errorw(msg string, fields ...LogField) {
-	l.err(msg, fields...)
+	if shallLog(ErrorLevel) {
+		l.err(msg, fields...)
+	}
 }
 
 func (l *richLogger) Info(v ...any) {
-	l.info(fmt.Sprint(v...))
+	if shallLog(InfoLevel) {
+		l.info(fmt.Sprint(v...))
+	}
 }
 
 func (l *richLogger) Infof(format string, v ...any) {
-	l.info(fmt.Sprintf(format, v...))
+	if shallLog(InfoLevel) {
+		l.info(fmt.Sprintf(format, v...))
+	}
 }
 
 func (l *richLogger) Infov(v any) {
-	l.info(v)
+	if shallLog(InfoLevel) {
+		l.info(v)
+	}
 }
 
 func (l *richLogger) Infow(msg string, fields ...LogField) {
-	l.info(msg, fields...)
+	if shallLog(InfoLevel) {
+		l.info(msg, fields...)
+	}
 }
 
 func (l *richLogger) Slow(v ...any) {
-	l.slow(fmt.Sprint(v...))
+	if shallLog(ErrorLevel) {
+		l.slow(fmt.Sprint(v...))
+	}
 }
 
 func (l *richLogger) Slowf(format string, v ...any) {
-	l.slow(fmt.Sprintf(format, v...))
+	if shallLog(ErrorLevel) {
+		l.slow(fmt.Sprintf(format, v...))
+	}
 }
 
 func (l *richLogger) Slowv(v any) {
-	l.slow(v)
+	if shallLog(ErrorLevel) {
+		l.slow(v)
+	}
 }
 
 func (l *richLogger) Sloww(msg string, fields ...LogField) {
-	l.slow(msg, fields...)
+	if shallLog(ErrorLevel) {
+		l.slow(msg, fields...)
+	}
 }
 
 func (l *richLogger) WithCallerSkip(skip int) Logger {

core/logx/rotatelogger.go

@@ -298,6 +298,7 @@ func (l *RotateLogger) initialize() error {
 		if l.fp, err = os.OpenFile(l.filename, os.O_APPEND|os.O_WRONLY, defaultFileMode); err != nil {
 			return err
 		}
+
 		l.currentSize = fileInfo.Size()
 	}
 
@@ -381,7 +382,15 @@ func (l *RotateLogger) startWorker() {
 			case event := <-l.channel:
 				l.write(event)
 			case <-l.done:
-				return
+				// avoid losing logs before closing.
+				for {
+					select {
+					case event := <-l.channel:
+						l.write(event)
+					default:
+						return
+					}
+				}
 			}
 		}
 	}()

core/logx/rotatelogger_test.go

@@ -206,6 +206,27 @@ func TestRotateLoggerClose(t *testing.T) {
 		_, err := logger.Write([]byte("foo"))
 		assert.ErrorIs(t, err, ErrLogFileClosed)
 	})
+
+	t.Run("close without losing logs", func(t *testing.T) {
+		text := "foo"
+		filename, err := fs.TempFilenameWithText(text)
+		assert.Nil(t, err)
+		if len(filename) > 0 {
+			defer os.Remove(filename)
+		}
+		logger, err := NewLogger(filename, new(DailyRotateRule), false)
+		assert.Nil(t, err)
+		msg := []byte("foo")
+		n := 100
+		for i := 0; i < n; i++ {
+			_, err = logger.Write(msg)
+			assert.Nil(t, err)
+		}
+		assert.Nil(t, logger.Close())
+		bs, err := os.ReadFile(filename)
+		assert.Nil(t, err)
+		assert.Equal(t, len(msg)*n+len(text), len(bs))
+	})
 }
 
 func TestRotateLoggerGetBackupFilename(t *testing.T) {
@@ -496,6 +517,21 @@ func TestGzipFile(t *testing.T) {
 	})
 }
 
+func TestRotateLogger_WithExistingFile(t *testing.T) {
+	const body = "foo"
+	filename, err := fs.TempFilenameWithText(body)
+	assert.Nil(t, err)
+	if len(filename) > 0 {
+		defer os.Remove(filename)
+	}
+
+	rule := NewSizeLimitRotateRule(filename, "-", 1, 100, 3, false)
+	logger, err := NewLogger(filename, rule, false)
+	assert.Nil(t, err)
+	assert.Equal(t, int64(len(body)), logger.currentSize)
+	assert.Nil(t, logger.Close())
+}
+
 func BenchmarkRotateLogger(b *testing.B) {
 	filename := "./test.log"
 	filename2 := "./test2.log"

core/logx/vars.go

@@ -15,6 +15,8 @@ const (
 	ErrorLevel
 	// SevereLevel only log severe messages
 	SevereLevel
+	// disableLevel doesn't log any messages
+	disableLevel = 0xff
 )
 
 const (

core/logx/writer.go

@@ -7,6 +7,7 @@ import (
 	"io"
 	"log"
 	"path"
+	"runtime/debug"
 	"sync"
 	"sync/atomic"
 
@@ -332,11 +333,13 @@ func wrapLevelWithColor(level string) string {
 
 func writeJson(writer io.Writer, info any) {
 	if content, err := json.Marshal(info); err != nil {
-		log.Println(err.Error())
+		log.Printf("err: %s\n\n%s", err.Error(), debug.Stack())
 	} else if writer == nil {
 		log.Println(string(content))
 	} else {
-		writer.Write(append(content, '\n'))
+		if _, err := writer.Write(append(content, '\n')); err != nil {
+			log.Println(err.Error())
+		}
 	}
 }
 
@@ -384,7 +387,7 @@ func writePlainValue(writer io.Writer, level string, val any, fields ...string)
 	buf.WriteString(level)
 	buf.WriteByte(plainEncodingSep)
 	if err := json.NewEncoder(&buf).Encode(val); err != nil {
-		log.Println(err.Error())
+		log.Printf("err: %s\n\n%s", err.Error(), debug.Stack())
 		return
 	}
 

core/logx/writer_test.go

@@ -126,9 +126,23 @@ func TestWriteJson(t *testing.T) {
 	log.SetOutput(&buf)
 	writeJson(nil, "foo")
 	assert.Contains(t, buf.String(), "foo")
+
+	buf.Reset()
+	writeJson(hardToWriteWriter{}, "foo")
+	assert.Contains(t, buf.String(), "write error")
+
 	buf.Reset()
 	writeJson(nil, make(chan int))
 	assert.Contains(t, buf.String(), "unsupported type")
+
+	buf.Reset()
+	type C struct {
+		RC func()
+	}
+	writeJson(nil, C{
+		RC: func() {},
+	})
+	assert.Contains(t, buf.String(), "runtime/debug.Stack")
 }
 
 func TestWritePlainAny(t *testing.T) {
@@ -165,6 +179,14 @@ func TestWritePlainAny(t *testing.T) {
 	writePlainAny(hardToWriteWriter{}, levelFatal, "foo")
 	assert.Contains(t, buf.String(), "write error")
 
+	buf.Reset()
+	type C struct {
+		RC func()
+	}
+	writePlainAny(nil, levelError, C{
+		RC: func() {},
+	})
+	assert.Contains(t, buf.String(), "runtime/debug.Stack")
 }
 
 func TestLogWithLimitContentLength(t *testing.T) {

core/mapping/unmarshaler.go

@@ -18,8 +18,10 @@ import (
 )
 
 const (
-	defaultKeyName = "key"
-	delimiter      = '.'
+	defaultKeyName   = "key"
+	delimiter        = '.'
+	ignoreKey        = "-"
+	numberTypeString = "number"
 )
 
 var (
@@ -49,6 +51,7 @@ type (
 	unmarshalOptions struct {
 		fillDefault  bool
 		fromString   bool
+		opaqueKeys   bool
 		canonicalKey func(key string) string
 	}
 )
@@ -72,7 +75,11 @@ func UnmarshalKey(m map[string]any, v any) error {
 }
 
 // Unmarshal unmarshals m into v.
-func (u *Unmarshaler) Unmarshal(i any, v any) error {
+func (u *Unmarshaler) Unmarshal(i, v any) error {
+	return u.unmarshal(i, v, "")
+}
+
+func (u *Unmarshaler) unmarshal(i, v any, fullName string) error {
 	valueType := reflect.TypeOf(v)
 	if valueType.Kind() != reflect.Ptr {
 		return errValueNotSettable
@@ -85,13 +92,13 @@ func (u *Unmarshaler) Unmarshal(i any, v any) error {
 			return errTypeMismatch
 		}
 
-		return u.UnmarshalValuer(mapValuer(iv), v)
+		return u.unmarshalValuer(mapValuer(iv), v, fullName)
 	case []any:
 		if elemType.Kind() != reflect.Slice {
 			return errTypeMismatch
 		}
 
-		return u.fillSlice(elemType, reflect.ValueOf(v).Elem(), iv)
+		return u.fillSlice(elemType, reflect.ValueOf(v).Elem(), iv, fullName)
 	default:
 		return errUnsupportedType
 	}
@@ -99,17 +106,21 @@ func (u *Unmarshaler) Unmarshal(i any, v any) error {
 
 // UnmarshalValuer unmarshals m into v.
 func (u *Unmarshaler) UnmarshalValuer(m Valuer, v any) error {
-	return u.unmarshalWithFullName(simpleValuer{current: m}, v, "")
+	return u.unmarshalValuer(simpleValuer{current: m}, v, "")
 }
 
-func (u *Unmarshaler) fillMap(fieldType reflect.Type, value reflect.Value, mapValue any) error {
+func (u *Unmarshaler) unmarshalValuer(m Valuer, v any, fullName string) error {
+	return u.unmarshalWithFullName(simpleValuer{current: m}, v, fullName)
+}
+
+func (u *Unmarshaler) fillMap(fieldType reflect.Type, value reflect.Value, mapValue any, fullName string) error {
 	if !value.CanSet() {
 		return errValueNotSettable
 	}
 
 	fieldKeyType := fieldType.Key()
 	fieldElemType := fieldType.Elem()
-	targetValue, err := u.generateMap(fieldKeyType, fieldElemType, mapValue)
+	targetValue, err := u.generateMap(fieldKeyType, fieldElemType, mapValue, fullName)
 	if err != nil {
 		return err
 	}
@@ -143,14 +154,14 @@ func (u *Unmarshaler) fillMapFromString(value reflect.Value, mapValue any) error
 	return nil
 }
 
-func (u *Unmarshaler) fillSlice(fieldType reflect.Type, value reflect.Value, mapValue any) error {
+func (u *Unmarshaler) fillSlice(fieldType reflect.Type, value reflect.Value, mapValue any, fullName string) error {
 	if !value.CanSet() {
 		return errValueNotSettable
 	}
 
 	refValue := reflect.ValueOf(mapValue)
 	if refValue.Kind() != reflect.Slice {
-		return errTypeMismatch
+		return newTypeMismatchErrorWithHint(fullName, reflect.Slice.String(), refValue.Type().String())
 	}
 	if refValue.IsNil() {
 		return nil
@@ -173,6 +184,8 @@ func (u *Unmarshaler) fillSlice(fieldType reflect.Type, value reflect.Value, map
 		}
 
 		valid = true
+		sliceFullName := fmt.Sprintf("%s[%d]", fullName, i)
+
 		switch dereffedBaseKind {
 		case reflect.Struct:
 			target := reflect.New(dereffedBaseType)
@@ -181,17 +194,17 @@ func (u *Unmarshaler) fillSlice(fieldType reflect.Type, value reflect.Value, map
 				return errTypeMismatch
 			}
 
-			if err := u.Unmarshal(val, target.Interface()); err != nil {
+			if err := u.unmarshal(val, target.Interface(), sliceFullName); err != nil {
 				return err
 			}
 
 			SetValue(fieldType.Elem(), conv.Index(i), target.Elem())
 		case reflect.Slice:
-			if err := u.fillSlice(dereffedBaseType, conv.Index(i), ithValue); err != nil {
+			if err := u.fillSlice(dereffedBaseType, conv.Index(i), ithValue, sliceFullName); err != nil {
 				return err
 			}
 		default:
-			if err := u.fillSliceValue(conv, i, dereffedBaseKind, ithValue); err != nil {
+			if err := u.fillSliceValue(conv, i, dereffedBaseKind, ithValue, sliceFullName); err != nil {
 				return err
 			}
 		}
@@ -205,16 +218,16 @@ func (u *Unmarshaler) fillSlice(fieldType reflect.Type, value reflect.Value, map
 }
 
 func (u *Unmarshaler) fillSliceFromString(fieldType reflect.Type, value reflect.Value,
-	mapValue any) error {
+	mapValue any, fullName string) error {
 	var slice []any
 	switch v := mapValue.(type) {
 	case fmt.Stringer:
 		if err := jsonx.UnmarshalFromString(v.String(), &slice); err != nil {
-			return err
+			return fmt.Errorf("fullName: `%s`, error: `%w`", fullName, err)
 		}
 	case string:
 		if err := jsonx.UnmarshalFromString(v, &slice); err != nil {
-			return err
+			return fmt.Errorf("fullName: `%s`, error: `%w`", fullName, err)
 		}
 	default:
 		return errUnsupportedType
@@ -225,7 +238,7 @@ func (u *Unmarshaler) fillSliceFromString(fieldType reflect.Type, value reflect.
 	conv := reflect.MakeSlice(reflect.SliceOf(baseFieldType), len(slice), cap(slice))
 
 	for i := 0; i < len(slice); i++ {
-		if err := u.fillSliceValue(conv, i, baseFieldKind, slice[i]); err != nil {
+		if err := u.fillSliceValue(conv, i, baseFieldKind, slice[i], fullName); err != nil {
 			return err
 		}
 	}
@@ -235,7 +248,11 @@ func (u *Unmarshaler) fillSliceFromString(fieldType reflect.Type, value reflect.
 }
 
 func (u *Unmarshaler) fillSliceValue(slice reflect.Value, index int,
-	baseKind reflect.Kind, value any) error {
+	baseKind reflect.Kind, value any, fullName string) error {
+	if value == nil {
+		return errNilSliceElement
+	}
+
 	ithVal := slice.Index(index)
 	switch v := value.(type) {
 	case fmt.Stringer:
@@ -243,7 +260,7 @@ func (u *Unmarshaler) fillSliceValue(slice reflect.Value, index int,
 	case string:
 		return setValueFromString(baseKind, ithVal, v)
 	case map[string]any:
-		return u.fillMap(ithVal.Type(), ithVal, value)
+		return u.fillMap(ithVal.Type(), ithVal, value, fullName)
 	default:
 		// don't need to consider the difference between int, int8, int16, int32, int64,
 		// uint, uint8, uint16, uint32, uint64, because they're handled as json.Number.
@@ -269,7 +286,7 @@ func (u *Unmarshaler) fillSliceValue(slice reflect.Value, index int,
 }
 
 func (u *Unmarshaler) fillSliceWithDefault(derefedType reflect.Type, value reflect.Value,
-	defaultValue string) error {
+	defaultValue, fullName string) error {
 	baseFieldType := Deref(derefedType.Elem())
 	baseFieldKind := baseFieldType.Kind()
 	defaultCacheLock.Lock()
@@ -287,10 +304,10 @@ func (u *Unmarshaler) fillSliceWithDefault(derefedType reflect.Type, value refle
 		defaultCacheLock.Unlock()
 	}
 
-	return u.fillSlice(derefedType, value, slice)
+	return u.fillSlice(derefedType, value, slice, fullName)
 }
 
-func (u *Unmarshaler) generateMap(keyType, elemType reflect.Type, mapValue any) (reflect.Value, error) {
+func (u *Unmarshaler) generateMap(keyType, elemType reflect.Type, mapValue any, fullName string) (reflect.Value, error) {
 	mapType := reflect.MapOf(keyType, elemType)
 	valueType := reflect.TypeOf(mapValue)
 	if mapType == valueType {
@@ -309,11 +326,12 @@ func (u *Unmarshaler) generateMap(keyType, elemType reflect.Type, mapValue any)
 	for _, key := range refValue.MapKeys() {
 		keythValue := refValue.MapIndex(key)
 		keythData := keythValue.Interface()
+		mapFullName := fmt.Sprintf("%s[%s]", fullName, key.String())
 
 		switch dereffedElemKind {
 		case reflect.Slice:
 			target := reflect.New(dereffedElemType)
-			if err := u.fillSlice(elemType, target.Elem(), keythData); err != nil {
+			if err := u.fillSlice(elemType, target.Elem(), keythData, mapFullName); err != nil {
 				return emptyValue, err
 			}
 
@@ -325,7 +343,7 @@ func (u *Unmarshaler) generateMap(keyType, elemType reflect.Type, mapValue any)
 			}
 
 			target := reflect.New(dereffedElemType)
-			if err := u.Unmarshal(keythMap, target.Interface()); err != nil {
+			if err := u.unmarshal(keythMap, target.Interface(), mapFullName); err != nil {
 				return emptyValue, err
 			}
 
@@ -336,7 +354,7 @@ func (u *Unmarshaler) generateMap(keyType, elemType reflect.Type, mapValue any)
 				return emptyValue, errTypeMismatch
 			}
 
-			innerValue, err := u.generateMap(elemType.Key(), elemType.Elem(), keythMap)
+			innerValue, err := u.generateMap(elemType.Key(), elemType.Elem(), keythMap, mapFullName)
 			if err != nil {
 				return emptyValue, err
 			}
@@ -410,6 +428,10 @@ func (u *Unmarshaler) parseOptionsWithContext(field reflect.StructField, m Value
 		}
 	}
 
+	if u.opts.fillDefault {
+		return key, &options.fieldOptionsWithContext, nil
+	}
+
 	optsWithContext, err := options.toOptionsWithContext(key, m, fullName)
 	if err != nil {
 		return "", nil, err
@@ -425,6 +447,10 @@ func (u *Unmarshaler) processAnonymousField(field reflect.StructField, value ref
 		return err
 	}
 
+	if key == ignoreKey {
+		return nil
+	}
+
 	if options.optional() {
 		return u.processAnonymousFieldOptional(field, value, key, m, fullName)
 	}
@@ -483,7 +509,7 @@ func (u *Unmarshaler) processAnonymousStructFieldOptional(fieldType reflect.Type
 			return err
 		}
 
-		_, hasValue := getValue(m, fieldKey)
+		_, hasValue := getValue(m, fieldKey, u.opts.opaqueKeys)
 		if hasValue {
 			if !filled {
 				filled = true
@@ -541,13 +567,13 @@ func (u *Unmarshaler) processFieldNotFromString(fieldType reflect.Type, value re
 			parent:  vp.parent,
 		}, fullName)
 	case typeKind == reflect.Slice && valueKind == reflect.Slice:
-		return u.fillSlice(fieldType, value, mapValue)
+		return u.fillSlice(fieldType, value, mapValue, fullName)
 	case valueKind == reflect.Map && typeKind == reflect.Map:
-		return u.fillMap(fieldType, value, mapValue)
+		return u.fillMap(fieldType, value, mapValue, fullName)
 	case valueKind == reflect.String && typeKind == reflect.Map:
 		return u.fillMapFromString(value, mapValue)
 	case valueKind == reflect.String && typeKind == reflect.Slice:
-		return u.fillSliceFromString(fieldType, value, mapValue)
+		return u.fillSliceFromString(fieldType, value, mapValue, fullName)
 	case valueKind == reflect.String && derefedFieldType == durationType:
 		return fillDurationValue(fieldType, value, mapValue.(string))
 	default:
@@ -592,25 +618,28 @@ func (u *Unmarshaler) processFieldPrimitiveWithJSONNumber(fieldType reflect.Type
 	target := reflect.New(Deref(fieldType)).Elem()
 
 	switch typeKind {
-	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
-		iValue, err := v.Int64()
+	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64,
+		reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
+		if err := setValueFromString(typeKind, target, v.String()); err != nil {
+			return err
+		}
+	case reflect.Float32:
+		fValue, err := v.Float64()
 		if err != nil {
 			return err
 		}
 
-		target.SetInt(iValue)
-	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
-		iValue, err := v.Int64()
-		if err != nil {
-			return err
+		// if value is a pointer, we need to check overflow with the pointer's value.
+		derefedValue := value
+		for derefedValue.Type().Kind() == reflect.Ptr {
+			derefedValue = derefedValue.Elem()
+		}
+		if derefedValue.CanFloat() && derefedValue.OverflowFloat(fValue) {
+			return fmt.Errorf("parsing %q as float32: value out of range", v.String())
 		}
 
-		if iValue < 0 {
-			return fmt.Errorf("unmarshal %q with bad value %q", fullName, v.String())
-		}
-
-		target.SetUint(uint64(iValue))
-	case reflect.Float32, reflect.Float64:
+		target.SetFloat(fValue)
+	case reflect.Float64:
 		fValue, err := v.Float64()
 		if err != nil {
 			return err
@@ -618,7 +647,7 @@ func (u *Unmarshaler) processFieldPrimitiveWithJSONNumber(fieldType reflect.Type
 
 		target.SetFloat(fValue)
 	default:
-		return newTypeMismatchErrorWithHint(fullName, typeKind.String(), value.Type().String())
+		return newTypeMismatchErrorWithHint(fullName, typeKind.String(), numberTypeString)
 	}
 
 	SetValue(fieldType, value, target)
@@ -712,6 +741,10 @@ func (u *Unmarshaler) processNamedField(field reflect.StructField, value reflect
 		return err
 	}
 
+	if key == ignoreKey {
+		return nil
+	}
+
 	fullName = join(fullName, key)
 	if opts != nil && len(opts.EnvVar) > 0 {
 		envVal := proc.Env(opts.EnvVar)
@@ -726,7 +759,7 @@ func (u *Unmarshaler) processNamedField(field reflect.StructField, value reflect
 	}
 
 	valuer := createValuer(m, opts)
-	mapValue, hasValue := getValue(valuer, canonicalKey)
+	mapValue, hasValue := getValue(valuer, canonicalKey, u.opts.opaqueKeys)
 
 	// When fillDefault is used, m is a null value, hasValue must be false, all priority judgments fillDefault.
 	if u.opts.fillDefault {
@@ -819,7 +852,7 @@ func (u *Unmarshaler) processNamedFieldWithoutValue(fieldType reflect.Type, valu
 
 		switch fieldKind {
 		case reflect.Array, reflect.Slice:
-			return u.fillSliceWithDefault(derefedType, value, defaultValue)
+			return u.fillSliceWithDefault(derefedType, value, defaultValue, fullName)
 		default:
 			return setValueFromString(fieldKind, value, defaultValue)
 		}
@@ -867,7 +900,7 @@ func (u *Unmarshaler) processNamedFieldWithoutValue(fieldType reflect.Type, valu
 
 func (u *Unmarshaler) unmarshalWithFullName(m valuerWithParent, v any, fullName string) error {
 	rv := reflect.ValueOf(v)
-	if err := ValidatePtr(&rv); err != nil {
+	if err := ValidatePtr(rv); err != nil {
 		return err
 	}
 
@@ -889,11 +922,6 @@ func (u *Unmarshaler) unmarshalWithFullName(m valuerWithParent, v any, fullName
 		typeField := baseType.Field(i)
 		valueField := valElem.Field(i)
 		if err := u.processField(typeField, valueField, m, fullName); err != nil {
-			if len(fullName) > 0 {
-				err = fmt.Errorf("%w, fullName: %s, field: %s, type: %s",
-					err, fullName, typeField.Name, valueField.Type().Name())
-			}
-
 			return err
 		}
 	}
@@ -922,6 +950,14 @@ func WithDefault() UnmarshalOption {
 	}
 }
 
+// WithOpaqueKeys customizes an Unmarshaler with opaque keys.
+// Opaque keys are keys that are not processed by the unmarshaler.
+func WithOpaqueKeys() UnmarshalOption {
+	return func(opt *unmarshalOptions) {
+		opt.opaqueKeys = true
+	}
+}
+
 func createValuer(v valuerWithParent, opts *fieldOptionsWithContext) valuerWithParent {
 	if opts.inherit() {
 		return recursiveValuer{
@@ -999,8 +1035,8 @@ func fillWithSameType(fieldType reflect.Type, value reflect.Value, mapValue any,
 }
 
 // getValue gets the value for the specific key, the key can be in the format of parentKey.childKey
-func getValue(m valuerWithParent, key string) (any, bool) {
-	keys := readKeys(key)
+func getValue(m valuerWithParent, key string, opaque bool) (any, bool) {
+	keys := readKeys(key, opaque)
 	return getValueWithChainedKeys(m, keys)
 }
 
@@ -1059,7 +1095,11 @@ func newTypeMismatchErrorWithHint(name, expectType, actualType string) error {
 		name, expectType, actualType)
 }
 
-func readKeys(key string) []string {
+func readKeys(key string, opaque bool) []string {
+	if opaque {
+		return []string{key}
+	}
+
 	cacheKeysLock.Lock()
 	keys, ok := cacheKeys[key]
 	cacheKeysLock.Unlock()

core/mapping/utils.go

@@ -30,11 +30,13 @@ const (
 	leftSquareBracket  = '['
 	rightSquareBracket = ']'
 	segmentSeparator   = ','
+	intSize            = 32 << (^uint(0) >> 63) // 32 or 64
 )
 
 var (
 	errUnsupportedType  = errors.New("unsupported type on setting field value")
 	errNumberRange      = errors.New("wrong number range setting")
+	errNilSliceElement  = errors.New("null element for slice")
 	optionsCache        = make(map[string]optionsCacheValue)
 	cacheLock           sync.RWMutex
 	structRequiredCache = make(map[reflect.Type]requiredCacheValue)
@@ -79,7 +81,7 @@ func SetMapIndexValue(tp reflect.Type, value, key, target reflect.Value) {
 }
 
 // ValidatePtr validates v if it's a valid pointer.
-func ValidatePtr(v *reflect.Value) error {
+func ValidatePtr(v reflect.Value) error {
 	// sequence is very important, IsNil must be called after checking Kind() with reflect.Ptr,
 	// panic otherwise
 	if !v.IsValid() || v.Kind() != reflect.Ptr || v.IsNil() {
@@ -100,27 +102,30 @@ func convertTypeFromString(kind reflect.Kind, str string) (any, error) {
 		default:
 			return false, errTypeMismatch
 		}
-	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
-		intValue, err := strconv.ParseInt(str, 10, 64)
-		if err != nil {
-			return 0, fmt.Errorf("the value %q cannot parsed as int", str)
-		}
-
-		return intValue, nil
-	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
-		uintValue, err := strconv.ParseUint(str, 10, 64)
-		if err != nil {
-			return 0, fmt.Errorf("the value %q cannot parsed as uint", str)
-		}
-
-		return uintValue, nil
-	case reflect.Float32, reflect.Float64:
-		floatValue, err := strconv.ParseFloat(str, 64)
-		if err != nil {
-			return 0, fmt.Errorf("the value %q cannot parsed as float", str)
-		}
-
-		return floatValue, nil
+	case reflect.Int:
+		return strconv.ParseInt(str, 10, intSize)
+	case reflect.Int8:
+		return strconv.ParseInt(str, 10, 8)
+	case reflect.Int16:
+		return strconv.ParseInt(str, 10, 16)
+	case reflect.Int32:
+		return strconv.ParseInt(str, 10, 32)
+	case reflect.Int64:
+		return strconv.ParseInt(str, 10, 64)
+	case reflect.Uint:
+		return strconv.ParseUint(str, 10, intSize)
+	case reflect.Uint8:
+		return strconv.ParseUint(str, 10, 8)
+	case reflect.Uint16:
+		return strconv.ParseUint(str, 10, 16)
+	case reflect.Uint32:
+		return strconv.ParseUint(str, 10, 32)
+	case reflect.Uint64:
+		return strconv.ParseUint(str, 10, 64)
+	case reflect.Float32:
+		return strconv.ParseFloat(str, 32)
+	case reflect.Float64:
+		return strconv.ParseFloat(str, 64)
 	case reflect.String:
 		return str, nil
 	default:
@@ -486,19 +491,22 @@ func setMatchedPrimitiveValue(kind reflect.Kind, value reflect.Value, v any) err
 	switch kind {
 	case reflect.Bool:
 		value.SetBool(v.(bool))
+		return nil
 	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
 		value.SetInt(v.(int64))
+		return nil
 	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
 		value.SetUint(v.(uint64))
+		return nil
 	case reflect.Float32, reflect.Float64:
 		value.SetFloat(v.(float64))
+		return nil
 	case reflect.String:
 		value.SetString(v.(string))
+		return nil
 	default:
 		return errUnsupportedType
 	}
-
-	return nil
 }
 
 func setValueFromString(kind reflect.Kind, value reflect.Value, str string) error {
@@ -575,7 +583,8 @@ func usingDifferentKeys(key string, field reflect.StructField) bool {
 	return false
 }
 
-func validateAndSetValue(kind reflect.Kind, value reflect.Value, str string, opts *fieldOptionsWithContext) error {
+func validateAndSetValue(kind reflect.Kind, value reflect.Value, str string,
+	opts *fieldOptionsWithContext) error {
 	if !value.CanSet() {
 		return errValueNotSettable
 	}

core/mapping/utils_test.go

@@ -218,25 +218,25 @@ func TestParseSegments(t *testing.T) {
 func TestValidatePtrWithNonPtr(t *testing.T) {
 	var foo string
 	rve := reflect.ValueOf(foo)
-	assert.NotNil(t, ValidatePtr(&rve))
+	assert.NotNil(t, ValidatePtr(rve))
 }
 
 func TestValidatePtrWithPtr(t *testing.T) {
 	var foo string
 	rve := reflect.ValueOf(&foo)
-	assert.Nil(t, ValidatePtr(&rve))
+	assert.Nil(t, ValidatePtr(rve))
 }
 
 func TestValidatePtrWithNilPtr(t *testing.T) {
 	var foo *string
 	rve := reflect.ValueOf(foo)
-	assert.NotNil(t, ValidatePtr(&rve))
+	assert.NotNil(t, ValidatePtr(rve))
 }
 
 func TestValidatePtrWithZeroValue(t *testing.T) {
 	var s string
 	e := reflect.Zero(reflect.TypeOf(s))
-	assert.NotNil(t, ValidatePtr(&e))
+	assert.NotNil(t, ValidatePtr(e))
 }
 
 func TestSetValueNotSettable(t *testing.T) {

core/mapping/yamlunmarshaler_test.go

@@ -1011,6 +1011,15 @@ func TestUnmarshalYamlMapRune(t *testing.T) {
 	assert.Equal(t, rune(3), v.Machine["node3"])
 }
 
+func TestUnmarshalYamlStringOfInt(t *testing.T) {
+	text := `password: 123456`
+	var v struct {
+		Password string `json:"password"`
+	}
+	reader := strings.NewReader(text)
+	assert.Error(t, UnmarshalYamlReader(reader, &v))
+}
+
 func TestUnmarshalYamlBadInput(t *testing.T) {
 	var v struct {
 		Any string

core/mathx/entropy_test.go

@@ -15,3 +15,17 @@ func TestCalcEntropy(t *testing.T) {
 	}
 	assert.True(t, CalcEntropy(m) > .99)
 }
+
+func TestCalcEmptyEntropy(t *testing.T) {
+	m := make(map[any]int)
+	assert.Equal(t, float64(1), CalcEntropy(m))
+}
+
+func TestCalcDiffEntropy(t *testing.T) {
+	const total = 1000
+	m := make(map[any]int, total)
+	for i := 0; i < total; i++ {
+		m[i] = i
+	}
+	assert.True(t, CalcEntropy(m) < .99)
+}

core/mathx/range.go

@@ -0,0 +1,34 @@
+package mathx
+
+type numerical interface {
+	~int | ~int8 | ~int16 | ~int32 | ~int64 |
+		~uint | ~uint8 | ~uint16 | ~uint32 | ~uint64 |
+		~float32 | ~float64
+}
+
+// AtLeast returns the greater of x or lower.
+func AtLeast[T numerical](x, lower T) T {
+	if x < lower {
+		return lower
+	}
+	return x
+}
+
+// AtMost returns the smaller of x or upper.
+func AtMost[T numerical](x, upper T) T {
+	if x > upper {
+		return upper
+	}
+	return x
+}
+
+// Between returns the value of x clamped to the range [lower, upper].
+func Between[T numerical](x, lower, upper T) T {
+	if x < lower {
+		return lower
+	}
+	if x > upper {
+		return upper
+	}
+	return x
+}

core/mathx/range_test.go

@@ -0,0 +1,513 @@
+package mathx
+
+import "testing"
+
+func TestAtLeast(t *testing.T) {
+	t.Run("test int", func(t *testing.T) {
+		if got := AtLeast(10, 5); got != 10 {
+			t.Errorf("AtLeast() = %v, want 10", got)
+		}
+		if got := AtLeast(3, 5); got != 5 {
+			t.Errorf("AtLeast() = %v, want 5", got)
+		}
+		if got := AtLeast(5, 5); got != 5 {
+			t.Errorf("AtLeast() = %v, want 5", got)
+		}
+	})
+
+	t.Run("test int8", func(t *testing.T) {
+		if got := AtLeast(int8(10), int8(5)); got != 10 {
+			t.Errorf("AtLeast() = %v, want 10", got)
+		}
+		if got := AtLeast(int8(3), int8(5)); got != 5 {
+			t.Errorf("AtLeast() = %v, want 5", got)
+		}
+		if got := AtLeast(int8(5), int8(5)); got != 5 {
+			t.Errorf("AtLeast() = %v, want 5", got)
+		}
+	})
+
+	t.Run("test int16", func(t *testing.T) {
+		if got := AtLeast(int16(10), int16(5)); got != 10 {
+			t.Errorf("AtLeast() = %v, want 10", got)
+		}
+		if got := AtLeast(int16(3), int16(5)); got != 5 {
+			t.Errorf("AtLeast() = %v, want 5", got)
+		}
+		if got := AtLeast(int16(5), int16(5)); got != 5 {
+			t.Errorf("AtLeast() = %v, want 5", got)
+		}
+	})
+
+	t.Run("test int32", func(t *testing.T) {
+		if got := AtLeast(int32(10), int32(5)); got != 10 {
+			t.Errorf("AtLeast() = %v, want 10", got)
+		}
+		if got := AtLeast(int32(3), int32(5)); got != 5 {
+			t.Errorf("AtLeast() = %v, want 5", got)
+		}
+		if got := AtLeast(int32(5), int32(5)); got != 5 {
+			t.Errorf("AtLeast() = %v, want 5", got)
+		}
+	})
+
+	t.Run("test int64", func(t *testing.T) {
+		if got := AtLeast(int64(10), int64(5)); got != 10 {
+			t.Errorf("AtLeast() = %v, want 10", got)
+		}
+		if got := AtLeast(int64(3), int64(5)); got != 5 {
+			t.Errorf("AtLeast() = %v, want 5", got)
+		}
+		if got := AtLeast(int64(5), int64(5)); got != 5 {
+			t.Errorf("AtLeast() = %v, want 5", got)
+		}
+	})
+
+	t.Run("test uint", func(t *testing.T) {
+		if got := AtLeast(uint(10), uint(5)); got != 10 {
+			t.Errorf("AtLeast() = %v, want 10", got)
+		}
+		if got := AtLeast(uint(3), uint(5)); got != 5 {
+			t.Errorf("AtLeast() = %v, want 5", got)
+		}
+		if got := AtLeast(uint(5), uint(5)); got != 5 {
+			t.Errorf("AtLeast() = %v, want 5", got)
+		}
+	})
+
+	t.Run("test uint8", func(t *testing.T) {
+		if got := AtLeast(uint8(10), uint8(5)); got != 10 {
+			t.Errorf("AtLeast() = %v, want 10", got)
+		}
+		if got := AtLeast(uint8(3), uint8(5)); got != 5 {
+			t.Errorf("AtLeast() = %v, want 5", got)
+		}
+		if got := AtLeast(uint8(5), uint8(5)); got != 5 {
+			t.Errorf("AtLeast() = %v, want 5", got)
+		}
+	})
+
+	t.Run("test uint16", func(t *testing.T) {
+		if got := AtLeast(uint16(10), uint16(5)); got != 10 {
+			t.Errorf("AtLeast() = %v, want 10", got)
+		}
+		if got := AtLeast(uint16(3), uint16(5)); got != 5 {
+			t.Errorf("AtLeast() = %v, want 5", got)
+		}
+		if got := AtLeast(uint16(5), uint16(5)); got != 5 {
+			t.Errorf("AtLeast() = %v, want 5", got)
+		}
+	})
+
+	t.Run("test uint32", func(t *testing.T) {
+		if got := AtLeast(uint32(10), uint32(5)); got != 10 {
+			t.Errorf("AtLeast() = %v, want 10", got)
+		}
+		if got := AtLeast(uint32(3), uint32(5)); got != 5 {
+			t.Errorf("AtLeast() = %v, want 5", got)
+		}
+		if got := AtLeast(uint32(5), uint32(5)); got != 5 {
+			t.Errorf("AtLeast() = %v, want 5", got)
+		}
+	})
+
+	t.Run("test uint64", func(t *testing.T) {
+		if got := AtLeast(uint64(10), uint64(5)); got != 10 {
+			t.Errorf("AtLeast() = %v, want 10", got)
+		}
+		if got := AtLeast(uint64(3), uint64(5)); got != 5 {
+			t.Errorf("AtLeast() = %v, want 5", got)
+		}
+		if got := AtLeast(uint64(5), uint64(5)); got != 5 {
+			t.Errorf("AtLeast() = %v, want 5", got)
+		}
+	})
+
+	t.Run("test float32", func(t *testing.T) {
+		if got := AtLeast(float32(10.0), float32(5.0)); got != 10.0 {
+			t.Errorf("AtLeast() = %v, want 10.0", got)
+		}
+		if got := AtLeast(float32(3.0), float32(5.0)); got != 5.0 {
+			t.Errorf("AtLeast() = %v, want 5.0", got)
+		}
+		if got := AtLeast(float32(5.0), float32(5.0)); got != 5.0 {
+			t.Errorf("AtLeast() = %v, want 5.0", got)
+		}
+	})
+
+	t.Run("test float64", func(t *testing.T) {
+		if got := AtLeast(10.0, 5.0); got != 10.0 {
+			t.Errorf("AtLeast() = %v, want 10.0", got)
+		}
+		if got := AtLeast(3.0, 5.0); got != 5.0 {
+			t.Errorf("AtLeast() = %v, want 5.0", got)
+		}
+		if got := AtLeast(5.0, 5.0); got != 5.0 {
+			t.Errorf("AtLeast() = %v, want 5.0", got)
+		}
+	})
+}
+
+func TestAtMost(t *testing.T) {
+	t.Run("test int", func(t *testing.T) {
+		if got := AtMost(10, 5); got != 5 {
+			t.Errorf("AtMost() = %v, want 5", got)
+		}
+		if got := AtMost(3, 5); got != 3 {
+			t.Errorf("AtMost() = %v, want 3", got)
+		}
+		if got := AtMost(5, 5); got != 5 {
+			t.Errorf("AtMost() = %v, want 5", got)
+		}
+	})
+
+	t.Run("test int8", func(t *testing.T) {
+		if got := AtMost(int8(10), int8(5)); got != 5 {
+			t.Errorf("AtMost() = %v, want 5", got)
+		}
+		if got := AtMost(int8(3), int8(5)); got != 3 {
+			t.Errorf("AtMost() = %v, want 3", got)
+		}
+		if got := AtMost(int8(5), int8(5)); got != 5 {
+			t.Errorf("AtMost() = %v, want 5", got)
+		}
+	})
+
+	t.Run("test int16", func(t *testing.T) {
+		if got := AtMost(int16(10), int16(5)); got != 5 {
+			t.Errorf("AtMost() = %v, want 5", got)
+		}
+		if got := AtMost(int16(3), int16(5)); got != 3 {
+			t.Errorf("AtMost() = %v, want 3", got)
+		}
+		if got := AtMost(int16(5), int16(5)); got != 5 {
+			t.Errorf("AtMost() = %v, want 5", got)
+		}
+	})
+
+	t.Run("test int32", func(t *testing.T) {
+		if got := AtMost(int32(10), int32(5)); got != 5 {
+			t.Errorf("AtMost() = %v, want 5", got)
+		}
+		if got := AtMost(int32(3), int32(5)); got != 3 {
+			t.Errorf("AtMost() = %v, want 3", got)
+		}
+		if got := AtMost(int32(5), int32(5)); got != 5 {
+			t.Errorf("AtMost() = %v, want 5", got)
+		}
+	})
+
+	t.Run("test int64", func(t *testing.T) {
+		if got := AtMost(int64(10), int64(5)); got != 5 {
+			t.Errorf("AtMost() = %v, want 5", got)
+		}
+		if got := AtMost(int64(3), int64(5)); got != 3 {
+			t.Errorf("AtMost() = %v, want 3", got)
+		}
+		if got := AtMost(int64(5), int64(5)); got != 5 {
+			t.Errorf("AtMost() = %v, want 5", got)
+		}
+	})
+
+	t.Run("test uint", func(t *testing.T) {
+		if got := AtMost(uint(10), uint(5)); got != 5 {
+			t.Errorf("AtMost() = %v, want 5", got)
+		}
+		if got := AtMost(uint(3), uint(5)); got != 3 {
+			t.Errorf("AtMost() = %v, want 3", got)
+		}
+		if got := AtMost(uint(5), uint(5)); got != 5 {
+			t.Errorf("AtMost() = %v, want 5", got)
+		}
+	})
+
+	t.Run("test uint8", func(t *testing.T) {
+		if got := AtMost(uint8(10), uint8(5)); got != 5 {
+			t.Errorf("AtMost() = %v, want 5", got)
+		}
+		if got := AtMost(uint8(3), uint8(5)); got != 3 {
+			t.Errorf("AtMost() = %v, want 3", got)
+		}
+		if got := AtMost(uint8(5), uint8(5)); got != 5 {
+			t.Errorf("AtMost() = %v, want 5", got)
+		}
+	})
+
+	t.Run("test uint16", func(t *testing.T) {
+		if got := AtMost(uint16(10), uint16(5)); got != 5 {
+			t.Errorf("AtMost() = %v, want 5", got)
+		}
+		if got := AtMost(uint16(3), uint16(5)); got != 3 {
+			t.Errorf("AtMost() = %v, want 3", got)
+		}
+		if got := AtMost(uint16(5), uint16(5)); got != 5 {
+			t.Errorf("AtMost() = %v, want 5", got)
+		}
+	})
+
+	t.Run("test uint32", func(t *testing.T) {
+		if got := AtMost(uint32(10), uint32(5)); got != 5 {
+			t.Errorf("AtMost() = %v, want 5", got)
+		}
+		if got := AtMost(uint32(3), uint32(5)); got != 3 {
+			t.Errorf("AtMost() = %v, want 3", got)
+		}
+		if got := AtMost(uint32(5), uint32(5)); got != 5 {
+			t.Errorf("AtMost() = %v, want 5", got)
+		}
+	})
+
+	t.Run("test uint64", func(t *testing.T) {
+		if got := AtMost(uint64(10), uint64(5)); got != 5 {
+			t.Errorf("AtMost() = %v, want 5", got)
+		}
+		if got := AtMost(uint64(3), uint64(5)); got != 3 {
+			t.Errorf("AtMost() = %v, want 3", got)
+		}
+		if got := AtMost(uint64(5), uint64(5)); got != 5 {
+			t.Errorf("AtMost() = %v, want 5", got)
+		}
+	})
+
+	t.Run("test float32", func(t *testing.T) {
+		if got := AtMost(float32(10.0), float32(5.0)); got != 5.0 {
+			t.Errorf("AtMost() = %v, want 5.0", got)
+		}
+		if got := AtMost(float32(3.0), float32(5.0)); got != 3.0 {
+			t.Errorf("AtMost() = %v, want 3.0", got)
+		}
+		if got := AtMost(float32(5.0), float32(5.0)); got != 5.0 {
+			t.Errorf("AtMost() = %v, want 5.0", got)
+		}
+	})
+
+	t.Run("test float64", func(t *testing.T) {
+		if got := AtMost(10.0, 5.0); got != 5.0 {
+			t.Errorf("AtMost() = %v, want 5.0", got)
+		}
+		if got := AtMost(3.0, 5.0); got != 3.0 {
+			t.Errorf("AtMost() = %v, want 3.0", got)
+		}
+		if got := AtMost(5.0, 5.0); got != 5.0 {
+			t.Errorf("AtMost() = %v, want 5.0", got)
+		}
+	})
+}
+
+func TestBetween(t *testing.T) {
+	t.Run("test int", func(t *testing.T) {
+		if got := Between(10, 5, 15); got != 10 {
+			t.Errorf("Between() = %v, want 10", got)
+		}
+		if got := Between(3, 5, 15); got != 5 {
+			t.Errorf("Between() = %v, want 5", got)
+		}
+		if got := Between(20, 5, 15); got != 15 {
+			t.Errorf("Between() = %v, want 15", got)
+		}
+		if got := Between(5, 5, 15); got != 5 {
+			t.Errorf("Between() = %v, want 5", got)
+		}
+		if got := Between(15, 5, 15); got != 15 {
+			t.Errorf("Between() = %v, want 15", got)
+		}
+	})
+
+	t.Run("test int8", func(t *testing.T) {
+		if got := Between(int8(10), int8(5), int8(15)); got != 10 {
+			t.Errorf("Between() = %v, want 10", got)
+		}
+		if got := Between(int8(3), int8(5), int8(15)); got != 5 {
+			t.Errorf("Between() = %v, want 5", got)
+		}
+		if got := Between(int8(20), int8(5), int8(15)); got != 15 {
+			t.Errorf("Between() = %v, want 15", got)
+		}
+		if got := Between(int8(5), int8(5), int8(15)); got != 5 {
+			t.Errorf("Between() = %v, want 5", got)
+		}
+		if got := Between(int8(15), int8(5), int8(15)); got != 15 {
+			t.Errorf("Between() = %v, want 15", got)
+		}
+	})
+
+	t.Run("test int16", func(t *testing.T) {
+		if got := Between(int16(10), int16(5), int16(15)); got != 10 {
+			t.Errorf("Between() = %v, want 10", got)
+		}
+		if got := Between(int16(3), int16(5), int16(15)); got != 5 {
+			t.Errorf("Between() = %v, want 5", got)
+		}
+		if got := Between(int16(20), int16(5), int16(15)); got != 15 {
+			t.Errorf("Between() = %v, want 15", got)
+		}
+		if got := Between(int16(5), int16(5), int16(15)); got != 5 {
+			t.Errorf("Between() = %v, want 5", got)
+		}
+		if got := Between(int16(15), int16(5), int16(15)); got != 15 {
+			t.Errorf("Between() = %v, want 15", got)
+		}
+	})
+
+	t.Run("test int32", func(t *testing.T) {
+		if got := Between(int32(10), int32(5), int32(15)); got != 10 {
+			t.Errorf("Between() = %v, want 10", got)
+		}
+		if got := Between(int32(3), int32(5), int32(15)); got != 5 {
+			t.Errorf("Between() = %v, want 5", got)
+		}
+		if got := Between(int32(20), int32(5), int32(15)); got != 15 {
+			t.Errorf("Between() = %v, want 15", got)
+		}
+		if got := Between(int32(5), int32(5), int32(15)); got != 5 {
+			t.Errorf("Between() = %v, want 5", got)
+		}
+		if got := Between(int32(15), int32(5), int32(15)); got != 15 {
+			t.Errorf("Between() = %v, want 15", got)
+		}
+	})
+
+	t.Run("test int64", func(t *testing.T) {
+		if got := Between(int64(10), int64(5), int64(15)); got != 10 {
+			t.Errorf("Between() = %v, want 10", got)
+		}
+		if got := Between(int64(3), int64(5), int64(15)); got != 5 {
+			t.Errorf("Between() = %v, want 5", got)
+		}
+		if got := Between(int64(20), int64(5), int64(15)); got != 15 {
+			t.Errorf("Between() = %v, want 15", got)
+		}
+		if got := Between(int64(5), int64(5), int64(15)); got != 5 {
+			t.Errorf("Between() = %v, want 5", got)
+		}
+		if got := Between(int64(15), int64(5), int64(15)); got != 15 {
+			t.Errorf("Between() = %v, want 15", got)
+		}
+	})
+
+	t.Run("test uint", func(t *testing.T) {
+		if got := Between(uint(10), uint(5), uint(15)); got != 10 {
+			t.Errorf("Between() = %v, want 10", got)
+		}
+		if got := Between(uint(3), uint(5), uint(15)); got != 5 {
+			t.Errorf("Between() = %v, want 5", got)
+		}
+		if got := Between(uint(20), uint(5), uint(15)); got != 15 {
+			t.Errorf("Between() = %v, want 15", got)
+		}
+		if got := Between(uint(5), uint(5), uint(15)); got != 5 {
+			t.Errorf("Between() = %v, want 5", got)
+		}
+		if got := Between(uint(15), uint(5), uint(15)); got != 15 {
+			t.Errorf("Between() = %v, want 15", got)
+		}
+	})
+
+	t.Run("test uint8", func(t *testing.T) {
+		if got := Between(uint8(10), uint8(5), uint8(15)); got != 10 {
+			t.Errorf("Between() = %v, want 10", got)
+		}
+		if got := Between(uint8(3), uint8(5), uint8(15)); got != 5 {
+			t.Errorf("Between() = %v, want 5", got)
+		}
+		if got := Between(uint8(20), uint8(5), uint8(15)); got != 15 {
+			t.Errorf("Between() = %v, want 15", got)
+		}
+		if got := Between(uint8(5), uint8(5), uint8(15)); got != 5 {
+			t.Errorf("Between() = %v, want 5", got)
+		}
+		if got := Between(uint8(15), uint8(5), uint8(15)); got != 15 {
+			t.Errorf("Between() = %v, want 15", got)
+		}
+	})
+
+	t.Run("test uint16", func(t *testing.T) {
+		if got := Between(uint16(10), uint16(5), uint16(15)); got != 10 {
+			t.Errorf("Between() = %v, want 10", got)
+		}
+		if got := Between(uint16(3), uint16(5), uint16(15)); got != 5 {
+			t.Errorf("Between() = %v, want 5", got)
+		}
+		if got := Between(uint16(20), uint16(5), uint16(15)); got != 15 {
+			t.Errorf("Between() = %v, want 15", got)
+		}
+		if got := Between(uint16(5), uint16(5), uint16(15)); got != 5 {
+			t.Errorf("Between() = %v, want 5", got)
+		}
+		if got := Between(uint16(15), uint16(5), uint16(15)); got != 15 {
+			t.Errorf("Between() = %v, want 15", got)
+		}
+	})
+
+	t.Run("test uint32", func(t *testing.T) {
+		if got := Between(uint32(10), uint32(5), uint32(15)); got != 10 {
+			t.Errorf("Between() = %v, want 10", got)
+		}
+		if got := Between(uint32(3), uint32(5), uint32(15)); got != 5 {
+			t.Errorf("Between() = %v, want 5", got)
+		}
+		if got := Between(uint32(20), uint32(5), uint32(15)); got != 15 {
+			t.Errorf("Between() = %v, want 15", got)
+		}
+		if got := Between(uint32(5), uint32(5), uint32(15)); got != 5 {
+			t.Errorf("Between() = %v, want 5", got)
+		}
+		if got := Between(uint32(15), uint32(5), uint32(15)); got != 15 {
+			t.Errorf("Between() = %v, want 15", got)
+		}
+	})
+
+	t.Run("test uint64", func(t *testing.T) {
+		if got := Between(uint64(10), uint64(5), uint64(15)); got != 10 {
+			t.Errorf("Between() = %v, want 10", got)
+		}
+		if got := Between(uint64(3), uint64(5), uint64(15)); got != 5 {
+			t.Errorf("Between() = %v, want 5", got)
+		}
+		if got := Between(uint64(20), uint64(5), uint64(15)); got != 15 {
+			t.Errorf("Between() = %v, want 15", got)
+		}
+		if got := Between(uint64(5), uint64(5), uint64(15)); got != 5 {
+			t.Errorf("Between() = %v, want 5", got)
+		}
+		if got := Between(uint64(15), uint64(5), uint64(15)); got != 15 {
+			t.Errorf("Between() = %v, want 15", got)
+		}
+	})
+
+	t.Run("test float32", func(t *testing.T) {
+		if got := Between(float32(10.0), float32(5.0), float32(15.0)); got != 10.0 {
+			t.Errorf("Between() = %v, want 10.0", got)
+		}
+		if got := Between(float32(3.0), float32(5.0), float32(15.0)); got != 5.0 {
+			t.Errorf("Between() = %v, want 5.0", got)
+		}
+		if got := Between(float32(20.0), float32(5.0), float32(15.0)); got != 15.0 {
+			t.Errorf("Between() = %v, want 15.0", got)
+		}
+		if got := Between(float32(5.0), float32(5.0), float32(15.0)); got != 5.0 {
+			t.Errorf("Between() = %v, want 5.0", got)
+		}
+		if got := Between(float32(15.0), float32(5.0), float32(15.0)); got != 15.0 {
+			t.Errorf("Between() = %v, want 15.0", got)
+		}
+	})
+
+	t.Run("test float64", func(t *testing.T) {
+		if got := Between(10.0, 5.0, 15.0); got != 10.0 {
+			t.Errorf("Between() = %v, want 10.0", got)
+		}
+		if got := Between(3.0, 5.0, 15.0); got != 5.0 {
+			t.Errorf("Between() = %v, want 5.0", got)
+		}
+		if got := Between(20.0, 5.0, 15.0); got != 15.0 {
+			t.Errorf("Between() = %v, want 15.0", got)
+		}
+		if got := Between(5.0, 5.0, 15.0); got != 5.0 {
+			t.Errorf("Between() = %v, want 5.0", got)
+		}
+		if got := Between(15.0, 5.0, 15.0); got != 15.0 {
+			t.Errorf("Between() = %v, want 15.0", got)
+		}
+	})
+}

core/metric/counter.go

@@ -3,7 +3,6 @@ package metric
 import (
 	prom "github.com/prometheus/client_golang/prometheus"
 	"github.com/zeromicro/go-zero/core/proc"
-	"github.com/zeromicro/go-zero/core/prometheus"
 )
 
 type (
@@ -47,20 +46,16 @@ func NewCounterVec(cfg *CounterVecOpts) CounterVec {
 	return cv
 }
 
-func (cv *promCounterVec) Inc(labels ...string) {
-	if !prometheus.Enabled() {
-		return
-	}
-
-	cv.counter.WithLabelValues(labels...).Inc()
+func (cv *promCounterVec) Add(v float64, labels ...string) {
+	update(func() {
+		cv.counter.WithLabelValues(labels...).Add(v)
+	})
 }
 
-func (cv *promCounterVec) Add(v float64, labels ...string) {
-	if !prometheus.Enabled() {
-		return
-	}
-
-	cv.counter.WithLabelValues(labels...).Add(v)
+func (cv *promCounterVec) Inc(labels ...string) {
+	update(func() {
+		cv.counter.WithLabelValues(labels...).Inc()
+	})
 }
 
 func (cv *promCounterVec) close() bool {

core/metric/gauge.go

@@ -3,7 +3,6 @@ package metric
 import (
 	prom "github.com/prometheus/client_golang/prometheus"
 	"github.com/zeromicro/go-zero/core/proc"
-	"github.com/zeromicro/go-zero/core/prometheus"
 )
 
 type (
@@ -16,8 +15,12 @@ type (
 		Set(v float64, labels ...string)
 		// Inc increments labels.
 		Inc(labels ...string)
+		// Dec decrements labels.
+		Dec(labels ...string)
 		// Add adds v to labels.
 		Add(v float64, labels ...string)
+		// Sub subtracts v to labels.
+		Sub(v float64, labels ...string)
 		close() bool
 	}
 
@@ -32,13 +35,12 @@ func NewGaugeVec(cfg *GaugeVecOpts) GaugeVec {
 		return nil
 	}
 
-	vec := prom.NewGaugeVec(
-		prom.GaugeOpts{
-			Namespace: cfg.Namespace,
-			Subsystem: cfg.Subsystem,
-			Name:      cfg.Name,
-			Help:      cfg.Help,
-		}, cfg.Labels)
+	vec := prom.NewGaugeVec(prom.GaugeOpts{
+		Namespace: cfg.Namespace,
+		Subsystem: cfg.Subsystem,
+		Name:      cfg.Name,
+		Help:      cfg.Help,
+	}, cfg.Labels)
 	prom.MustRegister(vec)
 	gv := &promGaugeVec{
 		gauge: vec,
@@ -50,28 +52,34 @@ func NewGaugeVec(cfg *GaugeVecOpts) GaugeVec {
 	return gv
 }
 
-func (gv *promGaugeVec) Inc(labels ...string) {
-	if !prometheus.Enabled() {
-		return
-	}
-
-	gv.gauge.WithLabelValues(labels...).Inc()
+func (gv *promGaugeVec) Add(v float64, labels ...string) {
+	update(func() {
+		gv.gauge.WithLabelValues(labels...).Add(v)
+	})
 }
 
-func (gv *promGaugeVec) Add(v float64, labels ...string) {
-	if !prometheus.Enabled() {
-		return
-	}
+func (gv *promGaugeVec) Dec(labels ...string) {
+	update(func() {
+		gv.gauge.WithLabelValues(labels...).Dec()
+	})
+}
 
-	gv.gauge.WithLabelValues(labels...).Add(v)
+func (gv *promGaugeVec) Inc(labels ...string) {
+	update(func() {
+		gv.gauge.WithLabelValues(labels...).Inc()
+	})
 }
 
 func (gv *promGaugeVec) Set(v float64, labels ...string) {
-	if !prometheus.Enabled() {
-		return
-	}
+	update(func() {
+		gv.gauge.WithLabelValues(labels...).Set(v)
+	})
+}
 
-	gv.gauge.WithLabelValues(labels...).Set(v)
+func (gv *promGaugeVec) Sub(v float64, labels ...string) {
+	update(func() {
+		gv.gauge.WithLabelValues(labels...).Sub(v)
+	})
 }
 
 func (gv *promGaugeVec) close() bool {

core/metric/gauge_test.go

@@ -40,6 +40,23 @@ func TestGaugeInc(t *testing.T) {
 	assert.Equal(t, float64(2), r)
 }
 
+func TestGaugeDec(t *testing.T) {
+	startAgent()
+	gaugeVec := NewGaugeVec(&GaugeVecOpts{
+		Namespace: "rpc_client",
+		Subsystem: "requests",
+		Name:      "duration_ms",
+		Help:      "rpc server requests duration(ms).",
+		Labels:    []string{"path"},
+	})
+	defer gaugeVec.close()
+	gv, _ := gaugeVec.(*promGaugeVec)
+	gv.Dec("/users")
+	gv.Dec("/users")
+	r := testutil.ToFloat64(gv.gauge)
+	assert.Equal(t, float64(-2), r)
+}
+
 func TestGaugeAdd(t *testing.T) {
 	startAgent()
 	gaugeVec := NewGaugeVec(&GaugeVecOpts{
@@ -57,6 +74,23 @@ func TestGaugeAdd(t *testing.T) {
 	assert.Equal(t, float64(20), r)
 }
 
+func TestGaugeSub(t *testing.T) {
+	startAgent()
+	gaugeVec := NewGaugeVec(&GaugeVecOpts{
+		Namespace: "rpc_client",
+		Subsystem: "request",
+		Name:      "duration_ms",
+		Help:      "rpc server requests duration(ms).",
+		Labels:    []string{"path"},
+	})
+	defer gaugeVec.close()
+	gv, _ := gaugeVec.(*promGaugeVec)
+	gv.Sub(-100, "/classroom")
+	gv.Sub(30, "/classroom")
+	r := testutil.ToFloat64(gv.gauge)
+	assert.Equal(t, float64(70), r)
+}
+
 func TestGaugeSet(t *testing.T) {
 	startAgent()
 	gaugeVec := NewGaugeVec(&GaugeVecOpts{

core/metric/histogram.go

@@ -3,24 +3,26 @@ package metric
 import (
 	prom "github.com/prometheus/client_golang/prometheus"
 	"github.com/zeromicro/go-zero/core/proc"
-	"github.com/zeromicro/go-zero/core/prometheus"
 )
 
 type (
 	// A HistogramVecOpts is a histogram vector options.
 	HistogramVecOpts struct {
-		Namespace string
-		Subsystem string
-		Name      string
-		Help      string
-		Labels    []string
-		Buckets   []float64
+		Namespace   string
+		Subsystem   string
+		Name        string
+		Help        string
+		Labels      []string
+		Buckets     []float64
+		ConstLabels map[string]string
 	}
 
 	// A HistogramVec interface represents a histogram vector.
 	HistogramVec interface {
 		// Observe adds observation v to labels.
 		Observe(v int64, labels ...string)
+		// ObserveFloat allow to observe float64 values.
+		ObserveFloat(v float64, labels ...string)
 		close() bool
 	}
 
@@ -36,11 +38,12 @@ func NewHistogramVec(cfg *HistogramVecOpts) HistogramVec {
 	}
 
 	vec := prom.NewHistogramVec(prom.HistogramOpts{
-		Namespace: cfg.Namespace,
-		Subsystem: cfg.Subsystem,
-		Name:      cfg.Name,
-		Help:      cfg.Help,
-		Buckets:   cfg.Buckets,
+		Namespace:   cfg.Namespace,
+		Subsystem:   cfg.Subsystem,
+		Name:        cfg.Name,
+		Help:        cfg.Help,
+		Buckets:     cfg.Buckets,
+		ConstLabels: cfg.ConstLabels,
 	}, cfg.Labels)
 	prom.MustRegister(vec)
 	hv := &promHistogramVec{
@@ -54,11 +57,15 @@ func NewHistogramVec(cfg *HistogramVecOpts) HistogramVec {
 }
 
 func (hv *promHistogramVec) Observe(v int64, labels ...string) {
-	if !prometheus.Enabled() {
-		return
-	}
+	update(func() {
+		hv.histogram.WithLabelValues(labels...).Observe(float64(v))
+	})
+}
 
-	hv.histogram.WithLabelValues(labels...).Observe(float64(v))
+func (hv *promHistogramVec) ObserveFloat(v float64, labels ...string) {
+	update(func() {
+		hv.histogram.WithLabelValues(labels...).Observe(v)
+	})
 }
 
 func (hv *promHistogramVec) close() bool {

core/metric/histogram_test.go

@@ -6,7 +6,6 @@ import (
 
 	"github.com/prometheus/client_golang/prometheus/testutil"
 	"github.com/stretchr/testify/assert"
-	"github.com/zeromicro/go-zero/core/proc"
 )
 
 func TestNewHistogramVec(t *testing.T) {
@@ -15,7 +14,7 @@ func TestNewHistogramVec(t *testing.T) {
 		Help:    "rpc server requests duration(ms).",
 		Buckets: []float64{1, 2, 3},
 	})
-	defer histogramVec.close()
+	defer histogramVec.(*promHistogramVec).close()
 	histogramVecNil := NewHistogramVec(nil)
 	assert.NotNil(t, histogramVec)
 	assert.Nil(t, histogramVecNil)
@@ -29,9 +28,10 @@ func TestHistogramObserve(t *testing.T) {
 		Buckets: []float64{1, 2, 3},
 		Labels:  []string{"method"},
 	})
-	defer histogramVec.close()
+	defer histogramVec.(*promHistogramVec).close()
 	hv, _ := histogramVec.(*promHistogramVec)
 	hv.Observe(2, "/Users")
+	hv.ObserveFloat(1.1, "/Users")
 
 	metadata := `
 		# HELP counts rpc server requests duration(ms).
@@ -39,15 +39,13 @@ func TestHistogramObserve(t *testing.T) {
 `
 	val := `
 		counts_bucket{method="/Users",le="1"} 0
-		counts_bucket{method="/Users",le="2"} 1
-		counts_bucket{method="/Users",le="3"} 1
-		counts_bucket{method="/Users",le="+Inf"} 1
-		counts_sum{method="/Users"} 2
-        counts_count{method="/Users"} 1
+		counts_bucket{method="/Users",le="2"} 2
+		counts_bucket{method="/Users",le="3"} 2
+		counts_bucket{method="/Users",le="+Inf"} 2
+		counts_sum{method="/Users"} 3.1
+        counts_count{method="/Users"} 2
 `
 
 	err := testutil.CollectAndCompare(hv.histogram, strings.NewReader(metadata+val))
 	assert.Nil(t, err)
-
-	proc.Shutdown()
 }

core/metric/metric.go

@@ -1,5 +1,7 @@
 package metric
 
+import "github.com/zeromicro/go-zero/core/prometheus"
+
 // A VectorOpts is a general configuration.
 type VectorOpts struct {
 	Namespace string
@@ -8,3 +10,11 @@ type VectorOpts struct {
 	Help      string
 	Labels    []string
 }
+
+func update(fn func()) {
+	if !prometheus.Enabled() {
+		return
+	}
+
+	fn()
+}

core/metric/summary.go

@@ -0,0 +1,62 @@
+package metric
+
+import (
+	prom "github.com/prometheus/client_golang/prometheus"
+	"github.com/zeromicro/go-zero/core/proc"
+)
+
+type (
+	// A SummaryVecOpts is a summary vector options
+	SummaryVecOpts struct {
+		VecOpt     VectorOpts
+		Objectives map[float64]float64
+	}
+
+	// A SummaryVec interface represents a summary vector.
+	SummaryVec interface {
+		// Observe adds observation v to labels.
+		Observe(v float64, labels ...string)
+		close() bool
+	}
+
+	promSummaryVec struct {
+		summary *prom.SummaryVec
+	}
+)
+
+// NewSummaryVec return a SummaryVec
+func NewSummaryVec(cfg *SummaryVecOpts) SummaryVec {
+	if cfg == nil {
+		return nil
+	}
+
+	vec := prom.NewSummaryVec(
+		prom.SummaryOpts{
+			Namespace:  cfg.VecOpt.Namespace,
+			Subsystem:  cfg.VecOpt.Subsystem,
+			Name:       cfg.VecOpt.Name,
+			Help:       cfg.VecOpt.Help,
+			Objectives: cfg.Objectives,
+		},
+		cfg.VecOpt.Labels,
+	)
+	prom.MustRegister(vec)
+	sv := &promSummaryVec{
+		summary: vec,
+	}
+	proc.AddShutdownListener(func() {
+		sv.close()
+	})
+
+	return sv
+}
+
+func (sv *promSummaryVec) Observe(v float64, labels ...string) {
+	update(func() {
+		sv.summary.WithLabelValues(labels...).Observe(v)
+	})
+}
+
+func (sv *promSummaryVec) close() bool {
+	return prom.Unregister(sv.summary)
+}

core/metric/summary_test.go

@@ -0,0 +1,68 @@
+package metric
+
+import (
+	"strings"
+	"testing"
+
+	"github.com/prometheus/client_golang/prometheus/testutil"
+	"github.com/stretchr/testify/assert"
+	"github.com/zeromicro/go-zero/core/proc"
+)
+
+func TestNewSummaryVec(t *testing.T) {
+	summaryVec := NewSummaryVec(&SummaryVecOpts{
+		VecOpt: VectorOpts{
+			Namespace: "http_server",
+			Subsystem: "requests",
+			Name:      "duration_quantiles",
+			Help:      "rpc client requests duration(ms) φ quantiles ",
+			Labels:    []string{"method"},
+		},
+		Objectives: map[float64]float64{
+			0.5: 0.01,
+			0.9: 0.01,
+		},
+	})
+	defer summaryVec.close()
+	summaryVecNil := NewSummaryVec(nil)
+	assert.NotNil(t, summaryVec)
+	assert.Nil(t, summaryVecNil)
+}
+
+func TestSummaryObserve(t *testing.T) {
+	startAgent()
+	summaryVec := NewSummaryVec(&SummaryVecOpts{
+		VecOpt: VectorOpts{
+			Namespace: "http_server",
+			Subsystem: "requests",
+			Name:      "duration_quantiles",
+			Help:      "rpc client requests duration(ms) φ quantiles ",
+			Labels:    []string{"method"},
+		},
+		Objectives: map[float64]float64{
+			0.3: 0.01,
+			0.6: 0.01,
+			1:   0.01,
+		},
+	})
+	defer summaryVec.close()
+	sv := summaryVec.(*promSummaryVec)
+	sv.Observe(100, "GET")
+	sv.Observe(200, "GET")
+	sv.Observe(300, "GET")
+	metadata := `
+		# HELP http_server_requests_duration_quantiles rpc client requests duration(ms) φ quantiles 
+		# TYPE http_server_requests_duration_quantiles summary
+`
+	val := `
+		http_server_requests_duration_quantiles{method="GET",quantile="0.3"} 100
+		http_server_requests_duration_quantiles{method="GET",quantile="0.6"} 200
+		http_server_requests_duration_quantiles{method="GET",quantile="1"} 300
+		http_server_requests_duration_quantiles_sum{method="GET"} 600
+		http_server_requests_duration_quantiles_count{method="GET"} 3
+`
+
+	err := testutil.CollectAndCompare(sv.summary, strings.NewReader(metadata+val))
+	assert.Nil(t, err)
+	proc.Shutdown()
+}

core/mr/mapreduce_fuzz_test.go

@@ -13,7 +13,7 @@ import (
 )
 
 func FuzzMapReduce(f *testing.F) {
-	rand.Seed(time.Now().UnixNano())
+	rand.NewSource(time.Now().UnixNano())
 
 	f.Add(int64(10), runtime.NumCPU())
 	f.Fuzz(func(t *testing.T, n int64, workers int) {

core/mr/mapreduce_fuzzcase_test.go

@@ -20,7 +20,7 @@ import (
 // If Fuzz stuck, we don't know why, because it only returns hung or unexpected,
 // so we need to simulate the fuzz test in test mode.
 func TestMapReduceRandom(t *testing.T) {
-	rand.Seed(time.Now().UnixNano())
+	rand.NewSource(time.Now().UnixNano())
 
 	const (
 		times  = 10000

core/proc/shutdown.go

@@ -52,10 +52,10 @@ func WrapUp() {
 	wrapUpListeners.notifyListeners()
 }
 
-func gracefulStop(signals chan os.Signal) {
+func gracefulStop(signals chan os.Signal, sig syscall.Signal) {
 	signal.Stop(signals)
 
-	logx.Info("Got signal SIGTERM, shutting down...")
+	logx.Infof("Got signal %d, shutting down...", sig)
 	go wrapUpListeners.notifyListeners()
 
 	time.Sleep(wrapUpTime)
@@ -63,7 +63,7 @@ func gracefulStop(signals chan os.Signal) {
 
 	time.Sleep(delayTimeBeforeForceQuit - wrapUpTime)
 	logx.Infof("Still alive after %v, going to force kill the process...", delayTimeBeforeForceQuit)
-	syscall.Kill(syscall.Getpid(), syscall.SIGTERM)
+	_ = syscall.Kill(syscall.Getpid(), sig)
 }
 
 type listenerManager struct {
@@ -96,4 +96,6 @@ func (lm *listenerManager) notifyListeners() {
 		group.RunSafe(listener)
 	}
 	group.Wait()
+
+	lm.listeners = nil
 }

core/proc/shutdown_test.go

@@ -28,3 +28,33 @@ func TestShutdown(t *testing.T) {
 	called()
 	assert.Equal(t, 3, val)
 }
+
+func TestNotifyMoreThanOnce(t *testing.T) {
+	ch := make(chan struct{}, 1)
+
+	go func() {
+		var val int
+		called := AddWrapUpListener(func() {
+			val++
+		})
+		WrapUp()
+		WrapUp()
+		called()
+		assert.Equal(t, 1, val)
+
+		called = AddShutdownListener(func() {
+			val += 2
+		})
+		Shutdown()
+		Shutdown()
+		called()
+		assert.Equal(t, 3, val)
+		ch <- struct{}{}
+	}()
+
+	select {
+	case <-ch:
+	case <-time.After(time.Second):
+		t.Fatal("timeout, check error logs")
+	}
+}

core/proc/signals.go

@@ -6,21 +6,23 @@ import (
 	"os"
 	"os/signal"
 	"syscall"
+	"time"
 
 	"github.com/zeromicro/go-zero/core/logx"
 )
 
-const timeFormat = "0102150405"
+const (
+	profileDuration = time.Minute
+	timeFormat      = "0102150405"
+)
 
 var done = make(chan struct{})
 
 func init() {
 	go func() {
-		var profiler Stopper
-
 		// https://golang.org/pkg/os/signal/#Notify
 		signals := make(chan os.Signal, 1)
-		signal.Notify(signals, syscall.SIGUSR1, syscall.SIGUSR2, syscall.SIGTERM)
+		signal.Notify(signals, syscall.SIGUSR1, syscall.SIGUSR2, syscall.SIGTERM, syscall.SIGINT)
 
 		for {
 			v := <-signals
@@ -28,21 +30,14 @@ func init() {
 			case syscall.SIGUSR1:
 				dumpGoroutines(fileCreator{})
 			case syscall.SIGUSR2:
-				if profiler == nil {
-					profiler = StartProfile()
-				} else {
-					profiler.Stop()
-					profiler = nil
-				}
+				profiler := StartProfile()
+				time.AfterFunc(profileDuration, profiler.Stop)
 			case syscall.SIGTERM:
-				select {
-				case <-done:
-					// already closed
-				default:
-					close(done)
-				}
-
-				gracefulStop(signals)
+				stopOnSignal()
+				gracefulStop(signals, syscall.SIGTERM)
+			case syscall.SIGINT:
+				stopOnSignal()
+				gracefulStop(signals, syscall.SIGINT)
 			default:
 				logx.Error("Got unregistered signal:", v)
 			}
@@ -54,3 +49,12 @@ func init() {
 func Done() <-chan struct{} {
 	return done
 }
+
+func stopOnSignal() {
+	select {
+	case <-done:
+		// already closed
+	default:
+		close(done)
+	}
+}

core/search/tree.go

@@ -69,10 +69,10 @@ func (t *Tree) Add(route string, item any) error {
 	}
 
 	err := add(t.root, route[1:], item)
-	switch err {
-	case errDupItem:
+	switch {
+	case errors.Is(err, errDupItem):
 		return duplicatedItem(route)
-	case errDupSlash:
+	case errors.Is(err, errDupSlash):
 		return duplicatedSlash(route)
 	default:
 		return err

core/service/serviceconf.go

@@ -23,17 +23,22 @@ const (
 	ProMode = "pro"
 )
 
-// A ServiceConf is a service config.
-type ServiceConf struct {
-	Name       string
-	Log        logx.LogConf
-	Mode       string `json:",default=pro,options=dev|test|rt|pre|pro"`
-	MetricsUrl string `json:",optional"`
-	// Deprecated: please use DevServer
-	Prometheus prometheus.Config `json:",optional"`
-	Telemetry  trace.Config      `json:",optional"`
-	DevServer  devserver.Config  `json:",optional"`
-}
+type (
+	// DevServerConfig is type alias for devserver.Config
+	DevServerConfig = devserver.Config
+
+	// A ServiceConf is a service config.
+	ServiceConf struct {
+		Name       string
+		Log        logx.LogConf
+		Mode       string `json:",default=pro,options=dev|test|rt|pre|pro"`
+		MetricsUrl string `json:",optional"`
+		// Deprecated: please use DevServer
+		Prometheus prometheus.Config `json:",optional"`
+		Telemetry  trace.Config      `json:",optional"`
+		DevServer  DevServerConfig   `json:",optional"`
+	}
+)
 
 // MustSetUp sets up the service, exits on error.
 func (sc ServiceConf) MustSetUp() {

core/service/serviceconf_test.go

@@ -5,6 +5,7 @@ import (
 
 	"github.com/stretchr/testify/assert"
 	"github.com/zeromicro/go-zero/core/logx"
+	"github.com/zeromicro/go-zero/internal/devserver"
 )
 
 func TestServiceConf(t *testing.T) {
@@ -14,6 +15,10 @@ func TestServiceConf(t *testing.T) {
 			Mode: "console",
 		},
 		Mode: "dev",
+		DevServer: devserver.Config{
+			Port:       6470,
+			HealthPath: "/healthz",
+		},
 	}
 	c.MustSetUp()
 }

core/service/servicegroup.go

@@ -1,8 +1,7 @@
 package service
 
 import (
-	"log"
-
+	"github.com/zeromicro/go-zero/core/logx"
 	"github.com/zeromicro/go-zero/core/proc"
 	"github.com/zeromicro/go-zero/core/syncx"
 	"github.com/zeromicro/go-zero/core/threading"
@@ -51,7 +50,7 @@ func (sg *ServiceGroup) Add(service Service) {
 // Also, quitting this method will close the logx output.
 func (sg *ServiceGroup) Start() {
 	proc.AddShutdownListener(func() {
-		log.Println("Shutting down...")
+		logx.Info("Shutting down services in group")
 		sg.stopOnce()
 	})
 

core/stat/internal/cgroup_linux.go

@@ -2,6 +2,7 @@ package internal
 
 import (
 	"bufio"
+	"errors"
 	"fmt"
 	"math"
 	"os"
@@ -18,6 +19,7 @@ import (
 
 const (
 	cgroupDir   = "/sys/fs/cgroup"
+	cpuMaxFile  = cgroupDir + "/cpu.max"
 	cpuStatFile = cgroupDir + "/cpu.stat"
 	cpusetFile  = cgroupDir + "/cpuset.cpus.effective"
 )
@@ -30,10 +32,9 @@ var (
 )
 
 type cgroup interface {
-	cpuQuotaUs() (int64, error)
-	cpuPeriodUs() (uint64, error)
-	cpus() ([]uint64, error)
-	usageAllCpus() (uint64, error)
+	cpuQuota() (float64, error)
+	cpuUsage() (uint64, error)
+	effectiveCpus() (int, error)
 }
 
 func currentCgroup() (cgroup, error) {
@@ -48,13 +49,22 @@ type cgroupV1 struct {
 	cgroups map[string]string
 }
 
-func (c *cgroupV1) cpuQuotaUs() (int64, error) {
-	data, err := iox.ReadText(path.Join(c.cgroups["cpu"], "cpu.cfs_quota_us"))
+func (c *cgroupV1) cpuQuota() (float64, error) {
+	quotaUs, err := c.cpuQuotaUs()
 	if err != nil {
 		return 0, err
 	}
 
-	return strconv.ParseInt(data, 10, 64)
+	if quotaUs == -1 {
+		return -1, nil
+	}
+
+	periodUs, err := c.cpuPeriodUs()
+	if err != nil {
+		return 0, err
+	}
+
+	return float64(quotaUs) / float64(periodUs), nil
 }
 
 func (c *cgroupV1) cpuPeriodUs() (uint64, error) {
@@ -66,16 +76,16 @@ func (c *cgroupV1) cpuPeriodUs() (uint64, error) {
 	return parseUint(data)
 }
 
-func (c *cgroupV1) cpus() ([]uint64, error) {
-	data, err := iox.ReadText(path.Join(c.cgroups["cpuset"], "cpuset.cpus"))
+func (c *cgroupV1) cpuQuotaUs() (int64, error) {
+	data, err := iox.ReadText(path.Join(c.cgroups["cpu"], "cpu.cfs_quota_us"))
 	if err != nil {
-		return nil, err
+		return 0, err
 	}
 
-	return parseUints(data)
+	return strconv.ParseInt(data, 10, 64)
 }
 
-func (c *cgroupV1) usageAllCpus() (uint64, error) {
+func (c *cgroupV1) cpuUsage() (uint64, error) {
 	data, err := iox.ReadText(path.Join(c.cgroups["cpuacct"], "cpuacct.usage"))
 	if err != nil {
 		return 0, err
@@ -84,38 +94,53 @@ func (c *cgroupV1) usageAllCpus() (uint64, error) {
 	return parseUint(data)
 }
 
+func (c *cgroupV1) effectiveCpus() (int, error) {
+	data, err := iox.ReadText(path.Join(c.cgroups["cpuset"], "cpuset.cpus"))
+	if err != nil {
+		return 0, err
+	}
+
+	cpus, err := parseUints(data)
+	if err != nil {
+		return 0, err
+	}
+
+	return len(cpus), nil
+}
+
 type cgroupV2 struct {
 	cgroups map[string]string
 }
 
-func (c *cgroupV2) cpuQuotaUs() (int64, error) {
-	data, err := iox.ReadText(path.Join(cgroupDir, "cpu.cfs_quota_us"))
+func (c *cgroupV2) cpuQuota() (float64, error) {
+	data, err := iox.ReadText(cpuMaxFile)
 	if err != nil {
 		return 0, err
 	}
 
-	return strconv.ParseInt(data, 10, 64)
-}
+	fields := strings.Fields(data)
+	if len(fields) != 2 {
+		return 0, fmt.Errorf("cgroup: bad /sys/fs/cgroup/cpu.max file: %s", data)
+	}
 
-func (c *cgroupV2) cpuPeriodUs() (uint64, error) {
-	data, err := iox.ReadText(path.Join(cgroupDir, "cpu.cfs_period_us"))
+	if fields[0] == "max" {
+		return -1, nil
+	}
+
+	quotaUs, err := strconv.ParseInt(fields[0], 10, 64)
 	if err != nil {
 		return 0, err
 	}
 
-	return parseUint(data)
-}
-
-func (c *cgroupV2) cpus() ([]uint64, error) {
-	data, err := iox.ReadText(cpusetFile)
+	periodUs, err := strconv.ParseUint(fields[1], 10, 64)
 	if err != nil {
-		return nil, err
+		return 0, err
 	}
 
-	return parseUints(data)
+	return float64(quotaUs) / float64(periodUs), nil
 }
 
-func (c *cgroupV2) usageAllCpus() (uint64, error) {
+func (c *cgroupV2) cpuUsage() (uint64, error) {
 	usec, err := parseUint(c.cgroups["usage_usec"])
 	if err != nil {
 		return 0, err
@@ -124,6 +149,20 @@ func (c *cgroupV2) usageAllCpus() (uint64, error) {
 	return usec * uint64(time.Microsecond), nil
 }
 
+func (c *cgroupV2) effectiveCpus() (int, error) {
+	data, err := iox.ReadText(cpusetFile)
+	if err != nil {
+		return 0, err
+	}
+
+	cpus, err := parseUints(data)
+	if err != nil {
+		return 0, err
+	}
+
+	return len(cpus), nil
+}
+
 func currentCgroupV1() (cgroup, error) {
 	cgroupFile := fmt.Sprintf("/proc/%d/cgroup", os.Getpid())
 	lines, err := iox.ReadTextLines(cgroupFile, iox.WithoutBlank())
@@ -200,7 +239,7 @@ func isCgroup2UnifiedMode() bool {
 func parseUint(s string) (uint64, error) {
 	v, err := strconv.ParseInt(s, 10, 64)
 	if err != nil {
-		if err.(*strconv.NumError).Err == strconv.ErrRange {
+		if errors.Is(err, strconv.ErrRange) {
 			return 0, nil
 		}
 
@@ -225,21 +264,21 @@ func parseUints(val string) ([]uint64, error) {
 	for _, r := range cols {
 		if strings.Contains(r, "-") {
 			fields := strings.SplitN(r, "-", 2)
-			min, err := parseUint(fields[0])
+			minimum, err := parseUint(fields[0])
 			if err != nil {
 				return nil, fmt.Errorf("cgroup: bad int list format: %s", val)
 			}
 
-			max, err := parseUint(fields[1])
+			maximum, err := parseUint(fields[1])
 			if err != nil {
 				return nil, fmt.Errorf("cgroup: bad int list format: %s", val)
 			}
 
-			if max < min {
+			if maximum < minimum {
 				return nil, fmt.Errorf("cgroup: bad int list format: %s", val)
 			}
 
-			for i := min; i <= max; i++ {
+			for i := minimum; i <= maximum; i++ {
 				if _, ok := ints[i]; !ok {
 					ints[i] = lang.Placeholder
 					sets = append(sets, i)

core/stat/internal/cgroup_linux_test.go

@@ -12,18 +12,29 @@ func TestRunningInUserNS(t *testing.T) {
 	assert.False(t, runningInUserNS())
 }
 
-func TestCgroupV1(t *testing.T) {
-	if isCgroup2UnifiedMode() {
+func TestCgroups(t *testing.T) {
+	// test cgroup legacy(v1) & hybrid
+	if !isCgroup2UnifiedMode() {
 		cg, err := currentCgroupV1()
 		assert.NoError(t, err)
-		_, err = cg.cpus()
-		assert.Error(t, err)
-		_, err = cg.cpuPeriodUs()
-		assert.Error(t, err)
-		_, err = cg.cpuQuotaUs()
-		assert.Error(t, err)
-		_, err = cg.usageAllCpus()
+		_, err = cg.effectiveCpus()
+		assert.NoError(t, err)
+		_, err = cg.cpuQuota()
+		assert.NoError(t, err)
+		_, err = cg.cpuUsage()
+		assert.NoError(t, err)
+	}
+
+	// test cgroup v2
+	if isCgroup2UnifiedMode() {
+		cg, err := currentCgroupV2()
+		assert.NoError(t, err)
+		_, err = cg.effectiveCpus()
+		assert.NoError(t, err)
+		_, err = cg.cpuQuota()
 		assert.Error(t, err)
+		_, err = cg.cpuUsage()
+		assert.NoError(t, err)
 	}
 }
 

core/stat/internal/cpu_linux.go

@@ -14,60 +14,28 @@ import (
 const (
 	cpuTicks  = 100
 	cpuFields = 8
+	cpuMax    = 1000
+	statFile  = "/proc/stat"
 )
 
 var (
 	preSystem uint64
 	preTotal  uint64
-	quota     float64
+	limit     float64
 	cores     uint64
+	noCgroup  bool
 	initOnce  sync.Once
 )
 
-// if /proc not present, ignore the cpu calculation, like wsl linux
-func initialize() {
-	cpus, err := cpuSets()
-	if err != nil {
-		logx.Error(err)
-		return
-	}
-
-	cores = uint64(len(cpus))
-	quota = float64(len(cpus))
-	cq, err := cpuQuota()
-	if err == nil {
-		if cq != -1 {
-			period, err := cpuPeriod()
-			if err != nil {
-				logx.Error(err)
-				return
-			}
-
-			limit := float64(cq) / float64(period)
-			if limit < quota {
-				quota = limit
-			}
-		}
-	}
-
-	preSystem, err = systemCpuUsage()
-	if err != nil {
-		logx.Error(err)
-		return
-	}
-
-	preTotal, err = totalCpuUsage()
-	if err != nil {
-		logx.Error(err)
-		return
-	}
-}
-
 // RefreshCpu refreshes cpu usage and returns.
 func RefreshCpu() uint64 {
-	initOnce.Do(initialize)
+	initializeOnce()
 
-	total, err := totalCpuUsage()
+	if noCgroup {
+		return 0
+	}
+
+	total, err := cpuUsage()
 	if err != nil {
 		return 0
 	}
@@ -81,7 +49,10 @@ func RefreshCpu() uint64 {
 	cpuDelta := total - preTotal
 	systemDelta := system - preSystem
 	if cpuDelta > 0 && systemDelta > 0 {
-		usage = uint64(float64(cpuDelta*cores*1e3) / (float64(systemDelta) * quota))
+		usage = uint64(float64(cpuDelta*cores*cpuMax) / (float64(systemDelta) * limit))
+		if usage > cpuMax {
+			usage = cpuMax
+		}
 	}
 	preSystem = system
 	preTotal = total
@@ -89,35 +60,76 @@ func RefreshCpu() uint64 {
 	return usage
 }
 
-func cpuQuota() (int64, error) {
+func cpuQuota() (float64, error) {
 	cg, err := currentCgroup()
 	if err != nil {
 		return 0, err
 	}
 
-	return cg.cpuQuotaUs()
+	return cg.cpuQuota()
 }
 
-func cpuPeriod() (uint64, error) {
+func cpuUsage() (uint64, error) {
 	cg, err := currentCgroup()
 	if err != nil {
 		return 0, err
 	}
 
-	return cg.cpuPeriodUs()
+	return cg.cpuUsage()
 }
 
-func cpuSets() ([]uint64, error) {
+func effectiveCpus() (int, error) {
 	cg, err := currentCgroup()
 	if err != nil {
-		return nil, err
+		return 0, err
 	}
 
-	return cg.cpus()
+	return cg.effectiveCpus()
+}
+
+// if /proc not present, ignore the cpu calculation, like wsl linux
+func initialize() error {
+	cpus, err := effectiveCpus()
+	if err != nil {
+		return err
+	}
+
+	cores = uint64(cpus)
+	limit = float64(cpus)
+	quota, err := cpuQuota()
+	if err == nil && quota > 0 {
+		if quota < limit {
+			limit = quota
+		}
+	}
+
+	preSystem, err = systemCpuUsage()
+	if err != nil {
+		return err
+	}
+
+	preTotal, err = cpuUsage()
+	return err
+}
+
+func initializeOnce() {
+	initOnce.Do(func() {
+		defer func() {
+			if p := recover(); p != nil {
+				noCgroup = true
+				logx.Error(p)
+			}
+		}()
+
+		if err := initialize(); err != nil {
+			noCgroup = true
+			logx.Error(err)
+		}
+	})
 }
 
 func systemCpuUsage() (uint64, error) {
-	lines, err := iox.ReadTextLines("/proc/stat", iox.WithoutBlank())
+	lines, err := iox.ReadTextLines(statFile, iox.WithoutBlank())
 	if err != nil {
 		return 0, err
 	}
@@ -145,12 +157,3 @@ func systemCpuUsage() (uint64, error) {
 
 	return 0, errors.New("bad stats format")
 }
-
-func totalCpuUsage() (usage uint64, err error) {
-	var cg cgroup
-	if cg, err = currentCgroup(); err != nil {
-		return
-	}
-
-	return cg.usageAllCpus()
-}

core/stat/metrics_test.go

@@ -1,11 +1,13 @@
 package stat
 
 import (
+	"errors"
 	"strconv"
 	"testing"
 	"time"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/zeromicro/go-zero/core/logx/logtest"
 )
 
 func TestMetrics(t *testing.T) {
@@ -30,6 +32,34 @@ func TestMetrics(t *testing.T) {
 	}
 }
 
+func TestTopDurationWithEmpty(t *testing.T) {
+	assert.Equal(t, float32(0), getTopDuration(nil))
+	assert.Equal(t, float32(0), getTopDuration([]Task{}))
+}
+
+func TestLogAndReport(t *testing.T) {
+	buf := logtest.NewCollector(t)
+	old := logEnabled.True()
+	logEnabled.Set(true)
+	t.Cleanup(func() {
+		logEnabled.Set(old)
+	})
+
+	log(&StatReport{})
+	assert.NotEmpty(t, buf.String())
+
+	writerLock.Lock()
+	writer := reportWriter
+	writerLock.Unlock()
+	buf = logtest.NewCollector(t)
+	t.Cleanup(func() {
+		SetReportWriter(writer)
+	})
+	SetReportWriter(&badWriter{})
+	writeReport(&StatReport{})
+	assert.NotEmpty(t, buf.String())
+}
+
 type mockedWriter struct {
 	report *StatReport
 }
@@ -38,3 +68,9 @@ func (m *mockedWriter) Write(report *StatReport) error {
 	m.report = report
 	return nil
 }
+
+type badWriter struct{}
+
+func (b *badWriter) Write(report *StatReport) error {
+	return errors.New("bad")
+}

core/stores/builder/builder.go

@@ -9,7 +9,7 @@ import (
 const dbTag = "db"
 
 // RawFieldNames converts golang struct field into slice string.
-func RawFieldNames(in any, postgresSql ...bool) []string {
+func RawFieldNames(in any, postgreSql ...bool) []string {
 	out := make([]string, 0)
 	v := reflect.ValueOf(in)
 	if v.Kind() == reflect.Ptr {
@@ -17,8 +17,8 @@ func RawFieldNames(in any, postgresSql ...bool) []string {
 	}
 
 	var pg bool
-	if len(postgresSql) > 0 {
-		pg = postgresSql[0]
+	if len(postgreSql) > 0 {
+		pg = postgreSql[0]
 	}
 
 	// we only accept structs

core/stores/cache/cachenode.go

@@ -96,7 +96,7 @@ func (c cacheNode) Get(key string, val any) error {
 // GetCtx gets the cache with key and fills into v.
 func (c cacheNode) GetCtx(ctx context.Context, key string, val any) error {
 	err := c.doGetCache(ctx, key, val)
-	if err == errPlaceholder {
+	if errors.Is(err, errPlaceholder) {
 		return c.errNotFound
 	}
 
@@ -210,16 +210,16 @@ func (c cacheNode) doTake(ctx context.Context, v any, key string,
 	logger := logx.WithContext(ctx)
 	val, fresh, err := c.barrier.DoEx(key, func() (any, error) {
 		if err := c.doGetCache(ctx, key, v); err != nil {
-			if err == errPlaceholder {
+			if errors.Is(err, errPlaceholder) {
 				return nil, c.errNotFound
-			} else if err != c.errNotFound {
+			} else if !errors.Is(err, c.errNotFound) {
 				// why we just return the error instead of query from db,
 				// because we don't allow the disaster pass to the dbs.
 				// fail fast, in case we bring down the dbs.
 				return nil, err
 			}
 
-			if err = query(v); err == c.errNotFound {
+			if err = query(v); errors.Is(err, c.errNotFound) {
 				if err = c.setCacheWithNotFound(ctx, key); err != nil {
 					logger.Error(err)
 				}

core/stores/mon/bulkinserter_test.go

@@ -11,8 +11,6 @@ import (
 
 func TestBulkInserter(t *testing.T) {
 	mt := mtest.New(t, mtest.NewOptions().ClientType(mtest.Mock))
-	defer mt.Close()
-
 	mt.Run("test", func(mt *mtest.T) {
 		mt.AddMockResponses(mtest.CreateSuccessResponse(bson.D{{Key: "ok", Value: 1}}...))
 		bulk, err := NewBulkInserter(createModel(mt).Collection)

core/stores/mon/clientmanager_test.go

@@ -9,8 +9,6 @@ import (
 
 func TestClientManger_getClient(t *testing.T) {
 	mt := mtest.New(t, mtest.NewOptions().ClientType(mtest.Mock))
-	defer mt.Close()
-
 	mt.Run("test", func(mt *mtest.T) {
 		Inject(mtest.ClusterURI(), mt.Client)
 		cli, err := getClient(mtest.ClusterURI())

core/stores/mon/collection.go

@@ -2,11 +2,10 @@ package mon
 
 import (
 	"context"
-	"encoding/json"
+	"errors"
 	"time"
 
 	"github.com/zeromicro/go-zero/core/breaker"
-	"github.com/zeromicro/go-zero/core/logx"
 	"github.com/zeromicro/go-zero/core/timex"
 	"go.mongodb.org/mongo-driver/mongo"
 	mopt "go.mongodb.org/mongo-driver/mongo/options"
@@ -502,45 +501,11 @@ func (c *decoratedCollection) UpdateOne(ctx context.Context, filter, update any,
 
 func (c *decoratedCollection) logDuration(ctx context.Context, method string,
 	startTime time.Duration, err error, docs ...any) {
-	duration := timex.Since(startTime)
-	logger := logx.WithContext(ctx).WithDuration(duration)
-
-	content, jerr := json.Marshal(docs)
-	// jerr should not be non-nil, but we don't care much on this,
-	// if non-nil, we just log without docs.
-	if jerr != nil {
-		if err != nil {
-			if duration > slowThreshold.Load() {
-				logger.Slowf("[MONGO] mongo(%s) - slowcall - %s - fail(%s)", c.name, method, err.Error())
-			} else {
-				logger.Infof("mongo(%s) - %s - fail(%s)", c.name, method, err.Error())
-			}
-		} else {
-			if duration > slowThreshold.Load() {
-				logger.Slowf("[MONGO] mongo(%s) - slowcall - %s - ok", c.name, method)
-			} else {
-				logger.Infof("mongo(%s) - %s - ok", c.name, method)
-			}
-		}
-	} else if err != nil {
-		if duration > slowThreshold.Load() {
-			logger.Slowf("[MONGO] mongo(%s) - slowcall - %s - fail(%s) - %s",
-				c.name, method, err.Error(), string(content))
-		} else {
-			logger.Infof("mongo(%s) - %s - fail(%s) - %s",
-				c.name, method, err.Error(), string(content))
-		}
-	} else {
-		if duration > slowThreshold.Load() {
-			logger.Slowf("[MONGO] mongo(%s) - slowcall - %s - ok - %s",
-				c.name, method, string(content))
-		} else {
-			logger.Infof("mongo(%s) - %s - ok - %s", c.name, method, string(content))
-		}
-	}
+	logDurationWithDocs(ctx, c.name, method, startTime, err, docs...)
 }
 
-func (c *decoratedCollection) logDurationSimple(ctx context.Context, method string, startTime time.Duration, err error) {
+func (c *decoratedCollection) logDurationSimple(ctx context.Context, method string,
+	startTime time.Duration, err error) {
 	logDuration(ctx, c.name, method, startTime, err)
 }
 
@@ -562,11 +527,19 @@ func (p keepablePromise) keep(err error) error {
 }
 
 func acceptable(err error) bool {
-	return err == nil || err == mongo.ErrNoDocuments || err == mongo.ErrNilValue ||
-		err == mongo.ErrNilDocument || err == mongo.ErrNilCursor || err == mongo.ErrEmptySlice ||
+	return err == nil ||
+		errors.Is(err, mongo.ErrNoDocuments) ||
+		errors.Is(err, mongo.ErrNilValue) ||
+		errors.Is(err, mongo.ErrNilDocument) ||
+		errors.Is(err, mongo.ErrNilCursor) ||
+		errors.Is(err, mongo.ErrEmptySlice) ||
 		// session errors
-		err == session.ErrSessionEnded || err == session.ErrNoTransactStarted ||
-		err == session.ErrTransactInProgress || err == session.ErrAbortAfterCommit ||
-		err == session.ErrAbortTwice || err == session.ErrCommitAfterAbort ||
-		err == session.ErrUnackWCUnsupported || err == session.ErrSnapshotTransaction
+		errors.Is(err, session.ErrSessionEnded) ||
+		errors.Is(err, session.ErrNoTransactStarted) ||
+		errors.Is(err, session.ErrTransactInProgress) ||
+		errors.Is(err, session.ErrAbortAfterCommit) ||
+		errors.Is(err, session.ErrAbortTwice) ||
+		errors.Is(err, session.ErrCommitAfterAbort) ||
+		errors.Is(err, session.ErrUnackWCUnsupported) ||
+		errors.Is(err, session.ErrSnapshotTransaction)
 }

core/stores/mon/collection_test.go

@@ -68,7 +68,6 @@ func TestKeepPromise_keep(t *testing.T) {
 
 func TestNewCollection(t *testing.T) {
 	mt := mtest.New(t, mtest.NewOptions().ClientType(mtest.Mock))
-	defer mt.Close()
 	mt.Run("test", func(mt *mtest.T) {
 		coll := mt.Coll
 		assert.NotNil(t, coll)
@@ -79,7 +78,6 @@ func TestNewCollection(t *testing.T) {
 
 func TestCollection_Aggregate(t *testing.T) {
 	mt := mtest.New(t, mtest.NewOptions().ClientType(mtest.Mock))
-	defer mt.Close()
 	mt.Run("test", func(mt *mtest.T) {
 		coll := mt.Coll
 		assert.NotNil(t, coll)
@@ -96,8 +94,6 @@ func TestCollection_Aggregate(t *testing.T) {
 
 func TestCollection_BulkWrite(t *testing.T) {
 	mt := mtest.New(t, mtest.NewOptions().ClientType(mtest.Mock))
-	defer mt.Close()
-
 	mt.Run("test", func(mt *mtest.T) {
 		c := decoratedCollection{
 			Collection: mt.Coll,
@@ -119,8 +115,6 @@ func TestCollection_BulkWrite(t *testing.T) {
 
 func TestCollection_CountDocuments(t *testing.T) {
 	mt := mtest.New(t, mtest.NewOptions().ClientType(mtest.Mock))
-	defer mt.Close()
-
 	mt.Run("test", func(mt *mtest.T) {
 		c := decoratedCollection{
 			Collection: mt.Coll,
@@ -145,8 +139,6 @@ func TestCollection_CountDocuments(t *testing.T) {
 
 func TestDecoratedCollection_DeleteMany(t *testing.T) {
 	mt := mtest.New(t, mtest.NewOptions().ClientType(mtest.Mock))
-	defer mt.Close()
-
 	mt.Run("test", func(mt *mtest.T) {
 		c := decoratedCollection{
 			Collection: mt.Coll,
@@ -165,8 +157,6 @@ func TestDecoratedCollection_DeleteMany(t *testing.T) {
 
 func TestCollection_Distinct(t *testing.T) {
 	mt := mtest.New(t, mtest.NewOptions().ClientType(mtest.Mock))
-	defer mt.Close()
-
 	mt.Run("test", func(mt *mtest.T) {
 		c := decoratedCollection{
 			Collection: mt.Coll,
@@ -185,8 +175,6 @@ func TestCollection_Distinct(t *testing.T) {
 
 func TestCollection_EstimatedDocumentCount(t *testing.T) {
 	mt := mtest.New(t, mtest.NewOptions().ClientType(mtest.Mock))
-	defer mt.Close()
-
 	mt.Run("test", func(mt *mtest.T) {
 		c := decoratedCollection{
 			Collection: mt.Coll,
@@ -205,8 +193,6 @@ func TestCollection_EstimatedDocumentCount(t *testing.T) {
 
 func TestCollection_Find(t *testing.T) {
 	mt := mtest.New(t, mtest.NewOptions().ClientType(mtest.Mock))
-	defer mt.Close()
-
 	mt.Run("test", func(mt *mtest.T) {
 		c := decoratedCollection{
 			Collection: mt.Coll,
@@ -253,8 +239,6 @@ func TestCollection_Find(t *testing.T) {
 
 func TestCollection_FindOne(t *testing.T) {
 	mt := mtest.New(t, mtest.NewOptions().ClientType(mtest.Mock))
-	defer mt.Close()
-
 	mt.Run("test", func(mt *mtest.T) {
 		c := decoratedCollection{
 			Collection: mt.Coll,
@@ -297,8 +281,6 @@ func TestCollection_FindOne(t *testing.T) {
 
 func TestCollection_FindOneAndDelete(t *testing.T) {
 	mt := mtest.New(t, mtest.NewOptions().ClientType(mtest.Mock))
-	defer mt.Close()
-
 	mt.Run("test", func(mt *mtest.T) {
 		c := decoratedCollection{
 			Collection: mt.Coll,
@@ -328,8 +310,6 @@ func TestCollection_FindOneAndDelete(t *testing.T) {
 
 func TestCollection_FindOneAndReplace(t *testing.T) {
 	mt := mtest.New(t, mtest.NewOptions().ClientType(mtest.Mock))
-	defer mt.Close()
-
 	mt.Run("test", func(mt *mtest.T) {
 		c := decoratedCollection{
 			Collection: mt.Coll,
@@ -360,8 +340,6 @@ func TestCollection_FindOneAndReplace(t *testing.T) {
 
 func TestCollection_FindOneAndUpdate(t *testing.T) {
 	mt := mtest.New(t, mtest.NewOptions().ClientType(mtest.Mock))
-	defer mt.Close()
-
 	mt.Run("test", func(mt *mtest.T) {
 		c := decoratedCollection{
 			Collection: mt.Coll,
@@ -393,8 +371,6 @@ func TestCollection_FindOneAndUpdate(t *testing.T) {
 
 func TestCollection_InsertOne(t *testing.T) {
 	mt := mtest.New(t, mtest.NewOptions().ClientType(mtest.Mock))
-	defer mt.Close()
-
 	mt.Run("test", func(mt *mtest.T) {
 		c := decoratedCollection{
 			Collection: mt.Coll,
@@ -413,8 +389,6 @@ func TestCollection_InsertOne(t *testing.T) {
 
 func TestCollection_InsertMany(t *testing.T) {
 	mt := mtest.New(t, mtest.NewOptions().ClientType(mtest.Mock))
-	defer mt.Close()
-
 	mt.Run("test", func(mt *mtest.T) {
 		c := decoratedCollection{
 			Collection: mt.Coll,
@@ -437,8 +411,6 @@ func TestCollection_InsertMany(t *testing.T) {
 
 func TestCollection_DeleteOne(t *testing.T) {
 	mt := mtest.New(t, mtest.NewOptions().ClientType(mtest.Mock))
-	defer mt.Close()
-
 	mt.Run("test", func(mt *mtest.T) {
 		c := decoratedCollection{
 			Collection: mt.Coll,
@@ -457,8 +429,6 @@ func TestCollection_DeleteOne(t *testing.T) {
 
 func TestCollection_DeleteMany(t *testing.T) {
 	mt := mtest.New(t, mtest.NewOptions().ClientType(mtest.Mock))
-	defer mt.Close()
-
 	mt.Run("test", func(mt *mtest.T) {
 		c := decoratedCollection{
 			Collection: mt.Coll,
@@ -477,8 +447,6 @@ func TestCollection_DeleteMany(t *testing.T) {
 
 func TestCollection_ReplaceOne(t *testing.T) {
 	mt := mtest.New(t, mtest.NewOptions().ClientType(mtest.Mock))
-	defer mt.Close()
-
 	mt.Run("test", func(mt *mtest.T) {
 		c := decoratedCollection{
 			Collection: mt.Coll,
@@ -500,8 +468,6 @@ func TestCollection_ReplaceOne(t *testing.T) {
 
 func TestCollection_UpdateOne(t *testing.T) {
 	mt := mtest.New(t, mtest.NewOptions().ClientType(mtest.Mock))
-	defer mt.Close()
-
 	mt.Run("test", func(mt *mtest.T) {
 		c := decoratedCollection{
 			Collection: mt.Coll,
@@ -522,8 +488,6 @@ func TestCollection_UpdateOne(t *testing.T) {
 
 func TestCollection_UpdateByID(t *testing.T) {
 	mt := mtest.New(t, mtest.NewOptions().ClientType(mtest.Mock))
-	defer mt.Close()
-
 	mt.Run("test", func(mt *mtest.T) {
 		c := decoratedCollection{
 			Collection: mt.Coll,
@@ -544,8 +508,6 @@ func TestCollection_UpdateByID(t *testing.T) {
 
 func TestCollection_UpdateMany(t *testing.T) {
 	mt := mtest.New(t, mtest.NewOptions().ClientType(mtest.Mock))
-	defer mt.Close()
-
 	mt.Run("test", func(mt *mtest.T) {
 		c := decoratedCollection{
 			Collection: mt.Coll,
@@ -566,7 +528,6 @@ func TestCollection_UpdateMany(t *testing.T) {
 
 func TestDecoratedCollection_LogDuration(t *testing.T) {
 	mt := mtest.New(t, mtest.NewOptions().ClientType(mtest.Mock))
-	defer mt.Close()
 	c := decoratedCollection{
 		Collection: mt.Coll,
 		brk:        breaker.NewBreaker(),
@@ -599,13 +560,11 @@ func TestDecoratedCollection_LogDuration(t *testing.T) {
 		errors.New("bar"), make(chan int))
 	assert.Contains(t, buf.String(), "foo")
 	assert.Contains(t, buf.String(), "bar")
-	assert.Contains(t, buf.String(), "slowcall")
 
 	buf.Reset()
 	c.logDuration(context.Background(), "foo", timex.Now()-slowThreshold.Load()*2,
 		errors.New("bar"))
 	assert.Contains(t, buf.String(), "foo")
-	assert.Contains(t, buf.String(), "slowcall")
 
 	buf.Reset()
 	c.logDuration(context.Background(), "foo", timex.Now()-slowThreshold.Load()*2, nil)
@@ -644,11 +603,11 @@ func (d *dropBreaker) DoWithAcceptable(_ func() error, _ breaker.Acceptable) err
 	return errDummy
 }
 
-func (d *dropBreaker) DoWithFallback(_ func() error, _ func(err error) error) error {
+func (d *dropBreaker) DoWithFallback(_ func() error, _ breaker.Fallback) error {
 	return nil
 }
 
-func (d *dropBreaker) DoWithFallbackAcceptable(_ func() error, _ func(err error) error,
+func (d *dropBreaker) DoWithFallbackAcceptable(_ func() error, _ breaker.Fallback,
 	_ breaker.Acceptable) error {
 	return nil
 }

core/stores/mon/model_test.go

@@ -12,8 +12,6 @@ import (
 
 func TestModel_StartSession(t *testing.T) {
 	mt := mtest.New(t, mtest.NewOptions().ClientType(mtest.Mock))
-	defer mt.Close()
-
 	mt.Run("test", func(mt *mtest.T) {
 		m := createModel(mt)
 		sess, err := m.StartSession()
@@ -34,8 +32,6 @@ func TestModel_StartSession(t *testing.T) {
 
 func TestModel_Aggregate(t *testing.T) {
 	mt := mtest.New(t, mtest.NewOptions().ClientType(mtest.Mock))
-	defer mt.Close()
-
 	mt.Run("test", func(mt *mtest.T) {
 		m := createModel(mt)
 		find := mtest.CreateCursorResponse(
@@ -71,8 +67,6 @@ func TestModel_Aggregate(t *testing.T) {
 
 func TestModel_DeleteMany(t *testing.T) {
 	mt := mtest.New(t, mtest.NewOptions().ClientType(mtest.Mock))
-	defer mt.Close()
-
 	mt.Run("test", func(mt *mtest.T) {
 		m := createModel(mt)
 		mt.AddMockResponses(mtest.CreateSuccessResponse(bson.D{{Key: "n", Value: 1}}...))
@@ -88,8 +82,6 @@ func TestModel_DeleteMany(t *testing.T) {
 
 func TestModel_DeleteOne(t *testing.T) {
 	mt := mtest.New(t, mtest.NewOptions().ClientType(mtest.Mock))
-	defer mt.Close()
-
 	mt.Run("test", func(mt *mtest.T) {
 		m := createModel(mt)
 		mt.AddMockResponses(mtest.CreateSuccessResponse(bson.D{{Key: "n", Value: 1}}...))
@@ -105,8 +97,6 @@ func TestModel_DeleteOne(t *testing.T) {
 
 func TestModel_Find(t *testing.T) {
 	mt := mtest.New(t, mtest.NewOptions().ClientType(mtest.Mock))
-	defer mt.Close()
-
 	mt.Run("test", func(mt *mtest.T) {
 		m := createModel(mt)
 		find := mtest.CreateCursorResponse(
@@ -142,8 +132,6 @@ func TestModel_Find(t *testing.T) {
 
 func TestModel_FindOne(t *testing.T) {
 	mt := mtest.New(t, mtest.NewOptions().ClientType(mtest.Mock))
-	defer mt.Close()
-
 	mt.Run("test", func(mt *mtest.T) {
 		m := createModel(mt)
 		find := mtest.CreateCursorResponse(
@@ -170,8 +158,6 @@ func TestModel_FindOne(t *testing.T) {
 
 func TestModel_FindOneAndDelete(t *testing.T) {
 	mt := mtest.New(t, mtest.NewOptions().ClientType(mtest.Mock))
-	defer mt.Close()
-
 	mt.Run("test", func(mt *mtest.T) {
 		m := createModel(mt)
 		mt.AddMockResponses(mtest.CreateSuccessResponse(bson.D{
@@ -189,8 +175,6 @@ func TestModel_FindOneAndDelete(t *testing.T) {
 
 func TestModel_FindOneAndReplace(t *testing.T) {
 	mt := mtest.New(t, mtest.NewOptions().ClientType(mtest.Mock))
-	defer mt.Close()
-
 	mt.Run("test", func(mt *mtest.T) {
 		m := createModel(mt)
 		mt.AddMockResponses(mtest.CreateSuccessResponse(bson.D{
@@ -212,8 +196,6 @@ func TestModel_FindOneAndReplace(t *testing.T) {
 
 func TestModel_FindOneAndUpdate(t *testing.T) {
 	mt := mtest.New(t, mtest.NewOptions().ClientType(mtest.Mock))
-	defer mt.Close()
-
 	mt.Run("test", func(mt *mtest.T) {
 		m := createModel(mt)
 		mt.AddMockResponses(mtest.CreateSuccessResponse(bson.D{

core/stores/mon/options.go

@@ -1,37 +1,74 @@
 package mon
 
 import (
+	"reflect"
 	"time"
 
 	"github.com/zeromicro/go-zero/core/syncx"
+	"go.mongodb.org/mongo-driver/bson"
+	"go.mongodb.org/mongo-driver/bson/bsoncodec"
 	mopt "go.mongodb.org/mongo-driver/mongo/options"
 )
 
 const defaultTimeout = time.Second * 3
 
-var slowThreshold = syncx.ForAtomicDuration(defaultSlowThreshold)
+var (
+	slowThreshold = syncx.ForAtomicDuration(defaultSlowThreshold)
+	logMon        = syncx.ForAtomicBool(true)
+	logSlowMon    = syncx.ForAtomicBool(true)
+)
 
 type (
-	options = mopt.ClientOptions
-
 	// Option defines the method to customize a mongo model.
 	Option func(opts *options)
+
+	// TypeCodec is a struct that stores specific type Encoder/Decoder.
+	TypeCodec struct {
+		ValueType reflect.Type
+		Encoder   bsoncodec.ValueEncoder
+		Decoder   bsoncodec.ValueDecoder
+	}
+
+	options = mopt.ClientOptions
 )
 
+// DisableLog disables logging of mongo commands, includes info and slow logs.
+func DisableLog() {
+	logMon.Set(false)
+	logSlowMon.Set(false)
+}
+
+// DisableInfoLog disables info logging of mongo commands, but keeps slow logs.
+func DisableInfoLog() {
+	logMon.Set(false)
+}
+
 // SetSlowThreshold sets the slow threshold.
 func SetSlowThreshold(threshold time.Duration) {
 	slowThreshold.Set(threshold)
 }
 
-func defaultTimeoutOption() Option {
-	return func(opts *options) {
-		opts.SetTimeout(defaultTimeout)
-	}
-}
-
 // WithTimeout set the mon client operation timeout.
 func WithTimeout(timeout time.Duration) Option {
 	return func(opts *options) {
 		opts.SetTimeout(timeout)
 	}
 }
+
+// WithTypeCodec registers TypeCodecs to convert custom types.
+func WithTypeCodec(typeCodecs ...TypeCodec) Option {
+	return func(opts *options) {
+		registry := bson.NewRegistry()
+		for _, v := range typeCodecs {
+			registry.RegisterTypeEncoder(v.ValueType, v.Encoder)
+			registry.RegisterTypeDecoder(v.ValueType, v.Decoder)
+		}
+		opts.SetRegistry(registry)
+	}
+}
+
+func defaultTimeoutOption() Option {
+	return func(opts *options) {
+		opts.SetTimeout(defaultTimeout)
+	}
+}

core/stores/mon/options_test.go

@@ -1,10 +1,14 @@
 package mon
 
 import (
+	"fmt"
+	"reflect"
 	"testing"
 	"time"
 
 	"github.com/stretchr/testify/assert"
+	"go.mongodb.org/mongo-driver/bson/bsoncodec"
+	"go.mongodb.org/mongo-driver/bson/bsonrw"
 	mopt "go.mongodb.org/mongo-driver/mongo/options"
 )
 
@@ -25,3 +29,82 @@ func TestWithTimeout(t *testing.T) {
 	WithTimeout(time.Second)(opts)
 	assert.Equal(t, time.Second, *opts.Timeout)
 }
+
+func TestDisableLog(t *testing.T) {
+	assert.True(t, logMon.True())
+	assert.True(t, logSlowMon.True())
+	defer func() {
+		logMon.Set(true)
+		logSlowMon.Set(true)
+	}()
+
+	DisableLog()
+	assert.False(t, logMon.True())
+	assert.False(t, logSlowMon.True())
+}
+
+func TestDisableInfoLog(t *testing.T) {
+	assert.True(t, logMon.True())
+	assert.True(t, logSlowMon.True())
+	defer func() {
+		logMon.Set(true)
+		logSlowMon.Set(true)
+	}()
+
+	DisableInfoLog()
+	assert.False(t, logMon.True())
+	assert.True(t, logSlowMon.True())
+}
+
+func TestWithRegistryForTimestampRegisterType(t *testing.T) {
+	opts := mopt.Client()
+
+	// mongoDateTimeEncoder allow user convert time.Time to primitive.DateTime.
+	var mongoDateTimeEncoder bsoncodec.ValueEncoderFunc = func(ect bsoncodec.EncodeContext, w bsonrw.ValueWriter, value reflect.Value) error {
+		// Use reflect, determine if it can be converted to time.Time.
+		dec, ok := value.Interface().(time.Time)
+		if !ok {
+			return fmt.Errorf("value %v to encode is not of type time.Time", value)
+		}
+		return w.WriteDateTime(dec.Unix())
+	}
+
+	// mongoDateTimeEncoder allow user convert primitive.DateTime to time.Time.
+	var mongoDateTimeDecoder bsoncodec.ValueDecoderFunc = func(ect bsoncodec.DecodeContext, r bsonrw.ValueReader, value reflect.Value) error {
+		primTime, err := r.ReadDateTime()
+		if err != nil {
+			return fmt.Errorf("error reading primitive.DateTime from ValueReader: %v", err)
+		}
+		value.Set(reflect.ValueOf(time.Unix(primTime, 0)))
+		return nil
+	}
+
+	codecs := []TypeCodec{
+		{
+			ValueType: reflect.TypeOf(time.Time{}),
+			Encoder:   mongoDateTimeEncoder,
+			Decoder:   mongoDateTimeDecoder,
+		},
+	}
+	WithTypeCodec(codecs...)(opts)
+
+	for _, v := range codecs {
+		// Validate Encoder
+		enc, err := opts.Registry.LookupEncoder(v.ValueType)
+		if err != nil {
+			t.Fatal(err)
+		}
+		if assert.ObjectsAreEqual(v.Encoder, enc) {
+			t.Errorf("Encoder got from Registry: %v, but want: %v", enc, v.Encoder)
+		}
+
+		// Validate Decoder
+		dec, err := opts.Registry.LookupDecoder(v.ValueType)
+		if err != nil {
+			t.Fatal(err)
+		}
+		if assert.ObjectsAreEqual(v.Decoder, dec) {
+			t.Errorf("Decoder got from Registry: %v, but want: %v", dec, v.Decoder)
+		}
+	}
+}

core/stores/mon/trace.go

@@ -2,6 +2,7 @@ package mon
 
 import (
 	"context"
+	"errors"
 
 	"github.com/zeromicro/go-zero/core/trace"
 	"go.mongodb.org/mongo-driver/mongo"
@@ -23,8 +24,8 @@ func startSpan(ctx context.Context, cmd string) (context.Context, oteltrace.Span
 func endSpan(span oteltrace.Span, err error) {
 	defer span.End()
 
-	if err == nil || err == mongo.ErrNoDocuments ||
-		err == mongo.ErrNilValue || err == mongo.ErrNilDocument {
+	if err == nil || errors.Is(err, mongo.ErrNoDocuments) ||
+		errors.Is(err, mongo.ErrNilValue) || errors.Is(err, mongo.ErrNilDocument) {
 		span.SetStatus(codes.Ok, "")
 		return
 	}

core/stores/mon/util.go

@@ -2,6 +2,7 @@ package mon
 
 import (
 	"context"
+	"encoding/json"
 	"strings"
 	"time"
 
@@ -20,8 +21,41 @@ func logDuration(ctx context.Context, name, method string, startTime time.Durati
 	duration := timex.Since(startTime)
 	logger := logx.WithContext(ctx).WithDuration(duration)
 	if err != nil {
-		logger.Infof("mongo(%s) - %s - fail(%s)", name, method, err.Error())
-	} else {
+		logger.Errorf("mongo(%s) - %s - fail(%s)", name, method, err.Error())
+		return
+	}
+
+	if logSlowMon.True() && duration > slowThreshold.Load() {
+		logger.Slowf("[MONGO] mongo(%s) - slowcall - %s - ok", name, method)
+	} else if logMon.True() {
 		logger.Infof("mongo(%s) - %s - ok", name, method)
 	}
 }
+
+func logDurationWithDocs(ctx context.Context, name, method string, startTime time.Duration,
+	err error, docs ...any) {
+	duration := timex.Since(startTime)
+	logger := logx.WithContext(ctx).WithDuration(duration)
+
+	content, jerr := json.Marshal(docs)
+	// jerr should not be non-nil, but we don't care much on this,
+	// if non-nil, we just log without docs.
+	if jerr != nil {
+		if err != nil {
+			logger.Errorf("mongo(%s) - %s - fail(%s)", name, method, err.Error())
+		} else if logSlowMon.True() && duration > slowThreshold.Load() {
+			logger.Slowf("[MONGO] mongo(%s) - slowcall - %s - ok", name, method)
+		} else if logMon.True() {
+			logger.Infof("mongo(%s) - %s - ok", name, method)
+		}
+		return
+	}
+
+	if err != nil {
+		logger.Errorf("mongo(%s) - %s - fail(%s) - %s", name, method, err.Error(), string(content))
+	} else if logSlowMon.True() && duration > slowThreshold.Load() {
+		logger.Slowf("[MONGO] mongo(%s) - slowcall - %s - ok - %s", name, method, string(content))
+	} else if logMon.True() {
+		logger.Infof("mongo(%s) - %s - ok - %s", name, method, string(content))
+	}
+}

core/stores/mon/util_test.go

@@ -4,10 +4,10 @@ import (
 	"context"
 	"errors"
 	"testing"
-	"time"
 
 	"github.com/stretchr/testify/assert"
 	"github.com/zeromicro/go-zero/core/logx/logtest"
+	"github.com/zeromicro/go-zero/core/timex"
 )
 
 func TestFormatAddrs(t *testing.T) {
@@ -42,13 +42,148 @@ func Test_logDuration(t *testing.T) {
 	buf := logtest.NewCollector(t)
 
 	buf.Reset()
-	logDuration(context.Background(), "foo", "bar", time.Millisecond, nil)
+	logDuration(context.Background(), "foo", "bar", timex.Now()-slowThreshold.Load()*2, nil)
+	assert.Contains(t, buf.String(), "foo")
+	assert.Contains(t, buf.String(), "bar")
+	assert.Contains(t, buf.String(), "slow")
+
+	buf.Reset()
+	logDuration(context.Background(), "foo", "bar", timex.Now(), nil)
 	assert.Contains(t, buf.String(), "foo")
 	assert.Contains(t, buf.String(), "bar")
 
 	buf.Reset()
-	logDuration(context.Background(), "foo", "bar", time.Millisecond, errors.New("bar"))
+	logDuration(context.Background(), "foo", "bar", timex.Now(), errors.New("bar"))
+	assert.Contains(t, buf.String(), "foo")
+	assert.Contains(t, buf.String(), "bar")
+	assert.Contains(t, buf.String(), "fail")
+
+	defer func() {
+		logMon.Set(true)
+		logSlowMon.Set(true)
+	}()
+
+	buf.Reset()
+	DisableInfoLog()
+	logDuration(context.Background(), "foo", "bar", timex.Now(), nil)
+	assert.Empty(t, buf.String())
+
+	buf.Reset()
+	logDuration(context.Background(), "foo", "bar", timex.Now()-slowThreshold.Load()*2, nil)
+	assert.Contains(t, buf.String(), "foo")
+	assert.Contains(t, buf.String(), "bar")
+	assert.Contains(t, buf.String(), "slow")
+
+	buf.Reset()
+	DisableLog()
+	logDuration(context.Background(), "foo", "bar", timex.Now(), nil)
+	assert.Empty(t, buf.String())
+
+	buf.Reset()
+	logDuration(context.Background(), "foo", "bar", timex.Now()-slowThreshold.Load()*2, nil)
+	assert.Empty(t, buf.String())
+
+	buf.Reset()
+	logDuration(context.Background(), "foo", "bar", timex.Now(), errors.New("bar"))
 	assert.Contains(t, buf.String(), "foo")
 	assert.Contains(t, buf.String(), "bar")
 	assert.Contains(t, buf.String(), "fail")
 }
+
+func Test_logDurationWithDoc(t *testing.T) {
+	buf := logtest.NewCollector(t)
+	buf.Reset()
+
+	logDurationWithDocs(context.Background(), "foo", "bar", timex.Now()-slowThreshold.Load()*2, nil, make(chan int))
+	assert.Contains(t, buf.String(), "foo")
+	assert.Contains(t, buf.String(), "bar")
+	assert.Contains(t, buf.String(), "slow")
+
+	buf.Reset()
+	logDurationWithDocs(context.Background(), "foo", "bar", timex.Now()-slowThreshold.Load()*2, nil, "{'json': ''}")
+	assert.Contains(t, buf.String(), "foo")
+	assert.Contains(t, buf.String(), "bar")
+	assert.Contains(t, buf.String(), "slow")
+	assert.Contains(t, buf.String(), "json")
+
+	buf.Reset()
+	logDurationWithDocs(context.Background(), "foo", "bar", timex.Now(), nil, make(chan int))
+	assert.Contains(t, buf.String(), "foo")
+	assert.Contains(t, buf.String(), "bar")
+
+	buf.Reset()
+	logDurationWithDocs(context.Background(), "foo", "bar", timex.Now(), nil, "{'json': ''}")
+	assert.Contains(t, buf.String(), "foo")
+	assert.Contains(t, buf.String(), "bar")
+	assert.Contains(t, buf.String(), "json")
+
+	buf.Reset()
+	logDurationWithDocs(context.Background(), "foo", "bar", timex.Now(), errors.New("bar"), make(chan int))
+	assert.Contains(t, buf.String(), "foo")
+	assert.Contains(t, buf.String(), "bar")
+	assert.Contains(t, buf.String(), "fail")
+
+	buf.Reset()
+	logDurationWithDocs(context.Background(), "foo", "bar", timex.Now(), errors.New("bar"), "{'json': ''}")
+	assert.Contains(t, buf.String(), "foo")
+	assert.Contains(t, buf.String(), "bar")
+	assert.Contains(t, buf.String(), "fail")
+	assert.Contains(t, buf.String(), "json")
+
+	defer func() {
+		logMon.Set(true)
+		logSlowMon.Set(true)
+	}()
+
+	buf.Reset()
+	DisableInfoLog()
+	logDurationWithDocs(context.Background(), "foo", "bar", timex.Now(), nil, make(chan int))
+	assert.Empty(t, buf.String())
+
+	buf.Reset()
+	logDurationWithDocs(context.Background(), "foo", "bar", timex.Now(), nil, "{'json': ''}")
+	assert.Empty(t, buf.String())
+
+	buf.Reset()
+	logDurationWithDocs(context.Background(), "foo", "bar", timex.Now()-slowThreshold.Load()*2, nil, make(chan int))
+	assert.Contains(t, buf.String(), "foo")
+	assert.Contains(t, buf.String(), "bar")
+	assert.Contains(t, buf.String(), "slow")
+
+	buf.Reset()
+	logDurationWithDocs(context.Background(), "foo", "bar", timex.Now()-slowThreshold.Load()*2, nil, "{'json': ''}")
+	assert.Contains(t, buf.String(), "foo")
+	assert.Contains(t, buf.String(), "bar")
+	assert.Contains(t, buf.String(), "slow")
+	assert.Contains(t, buf.String(), "json")
+
+	buf.Reset()
+	DisableLog()
+	logDurationWithDocs(context.Background(), "foo", "bar", timex.Now(), nil, make(chan int))
+	assert.Empty(t, buf.String())
+
+	buf.Reset()
+	logDurationWithDocs(context.Background(), "foo", "bar", timex.Now(), nil, "{'json': ''}")
+	assert.Empty(t, buf.String())
+
+	buf.Reset()
+	logDurationWithDocs(context.Background(), "foo", "bar", timex.Now()-slowThreshold.Load()*2, nil, make(chan int))
+	assert.Empty(t, buf.String())
+
+	buf.Reset()
+	logDurationWithDocs(context.Background(), "foo", "bar", timex.Now()-slowThreshold.Load()*2, nil, "{'json': ''}")
+	assert.Empty(t, buf.String())
+
+	buf.Reset()
+	logDurationWithDocs(context.Background(), "foo", "bar", timex.Now(), errors.New("bar"), make(chan int))
+	assert.Contains(t, buf.String(), "foo")
+	assert.Contains(t, buf.String(), "bar")
+	assert.Contains(t, buf.String(), "fail")
+
+	buf.Reset()
+	logDurationWithDocs(context.Background(), "foo", "bar", timex.Now(), errors.New("bar"), "{'json': ''}")
+	assert.Contains(t, buf.String(), "foo")
+	assert.Contains(t, buf.String(), "bar")
+	assert.Contains(t, buf.String(), "fail")
+	assert.Contains(t, buf.String(), "json")
+}

core/stores/monc/cachedmodel_test.go

@@ -17,8 +17,6 @@ import (
 
 func TestNewModel(t *testing.T) {
 	mt := mtest.New(t, mtest.NewOptions().ClientType(mtest.Mock))
-	defer mt.Close()
-
 	mt.Run("test", func(mt *mtest.T) {
 		_, err := newModel("foo", mt.DB.Name(), mt.Coll.Name(), nil)
 		assert.NotNil(mt, err)
@@ -27,8 +25,6 @@ func TestNewModel(t *testing.T) {
 
 func TestModel_DelCache(t *testing.T) {
 	mt := mtest.New(t, mtest.NewOptions().ClientType(mtest.Mock))
-	defer mt.Close()
-
 	mt.Run("test", func(mt *mtest.T) {
 		m := createModel(t, mt)
 		assert.Nil(t, m.cache.Set("foo", "bar"))
@@ -42,8 +38,6 @@ func TestModel_DelCache(t *testing.T) {
 
 func TestModel_DeleteOne(t *testing.T) {
 	mt := mtest.New(t, mtest.NewOptions().ClientType(mtest.Mock))
-	defer mt.Close()
-
 	mt.Run("test", func(mt *mtest.T) {
 		mt.AddMockResponses(mtest.CreateSuccessResponse(bson.D{{Key: "n", Value: 1}}...))
 		m := createModel(t, mt)
@@ -65,8 +59,6 @@ func TestModel_DeleteOne(t *testing.T) {
 
 func TestModel_DeleteOneNoCache(t *testing.T) {
 	mt := mtest.New(t, mtest.NewOptions().ClientType(mtest.Mock))
-	defer mt.Close()
-
 	mt.Run("test", func(mt *mtest.T) {
 		mt.AddMockResponses(mtest.CreateSuccessResponse(bson.D{{Key: "n", Value: 1}}...))
 		m := createModel(t, mt)
@@ -81,8 +73,6 @@ func TestModel_DeleteOneNoCache(t *testing.T) {
 
 func TestModel_FindOne(t *testing.T) {
 	mt := mtest.New(t, mtest.NewOptions().ClientType(mtest.Mock))
-	defer mt.Close()
-
 	mt.Run("test", func(mt *mtest.T) {
 		resp := mtest.CreateCursorResponse(
 			1,
@@ -104,8 +94,6 @@ func TestModel_FindOne(t *testing.T) {
 
 func TestModel_FindOneNoCache(t *testing.T) {
 	mt := mtest.New(t, mtest.NewOptions().ClientType(mtest.Mock))
-	defer mt.Close()
-
 	mt.Run("test", func(mt *mtest.T) {
 		resp := mtest.CreateCursorResponse(
 			1,
@@ -126,8 +114,6 @@ func TestModel_FindOneNoCache(t *testing.T) {
 
 func TestModel_FindOneAndDelete(t *testing.T) {
 	mt := mtest.New(t, mtest.NewOptions().ClientType(mtest.Mock))
-	defer mt.Close()
-
 	mt.Run("test", func(mt *mtest.T) {
 		mt.AddMockResponses(mtest.CreateSuccessResponse(bson.D{
 			{Key: "value", Value: bson.D{{Key: "foo", Value: "bar"}}},
@@ -152,8 +138,6 @@ func TestModel_FindOneAndDelete(t *testing.T) {
 
 func TestModel_FindOneAndDeleteNoCache(t *testing.T) {
 	mt := mtest.New(t, mtest.NewOptions().ClientType(mtest.Mock))
-	defer mt.Close()
-
 	mt.Run("test", func(mt *mtest.T) {
 		mt.AddMockResponses(mtest.CreateSuccessResponse(bson.D{
 			{Key: "value", Value: bson.D{{Key: "foo", Value: "bar"}}},
@@ -169,8 +153,6 @@ func TestModel_FindOneAndDeleteNoCache(t *testing.T) {
 
 func TestModel_FindOneAndReplace(t *testing.T) {
 	mt := mtest.New(t, mtest.NewOptions().ClientType(mtest.Mock))
-	defer mt.Close()
-
 	mt.Run("test", func(mt *mtest.T) {
 		mt.AddMockResponses(mtest.CreateSuccessResponse(bson.D{
 			{Key: "value", Value: bson.D{{Key: "foo", Value: "bar"}}},
@@ -201,8 +183,6 @@ func TestModel_FindOneAndReplace(t *testing.T) {
 
 func TestModel_FindOneAndReplaceNoCache(t *testing.T) {
 	mt := mtest.New(t, mtest.NewOptions().ClientType(mtest.Mock))
-	defer mt.Close()
-
 	mt.Run("test", func(mt *mtest.T) {
 		mt.AddMockResponses(mtest.CreateSuccessResponse(bson.D{
 			{Key: "value", Value: bson.D{{Key: "foo", Value: "bar"}}},
@@ -220,8 +200,6 @@ func TestModel_FindOneAndReplaceNoCache(t *testing.T) {
 
 func TestModel_FindOneAndUpdate(t *testing.T) {
 	mt := mtest.New(t, mtest.NewOptions().ClientType(mtest.Mock))
-	defer mt.Close()
-
 	mt.Run("test", func(mt *mtest.T) {
 		mt.AddMockResponses(mtest.CreateSuccessResponse(bson.D{
 			{Key: "value", Value: bson.D{{Key: "foo", Value: "bar"}}},
@@ -252,8 +230,6 @@ func TestModel_FindOneAndUpdate(t *testing.T) {
 
 func TestModel_FindOneAndUpdateNoCache(t *testing.T) {
 	mt := mtest.New(t, mtest.NewOptions().ClientType(mtest.Mock))
-	defer mt.Close()
-
 	mt.Run("test", func(mt *mtest.T) {
 		mt.AddMockResponses(mtest.CreateSuccessResponse(bson.D{
 			{Key: "value", Value: bson.D{{Key: "foo", Value: "bar"}}},
@@ -271,8 +247,6 @@ func TestModel_FindOneAndUpdateNoCache(t *testing.T) {
 
 func TestModel_GetCache(t *testing.T) {
 	mt := mtest.New(t, mtest.NewOptions().ClientType(mtest.Mock))
-	defer mt.Close()
-
 	mt.Run("test", func(mt *mtest.T) {
 		m := createModel(t, mt)
 		assert.NotNil(t, m.cache)
@@ -285,8 +259,6 @@ func TestModel_GetCache(t *testing.T) {
 
 func TestModel_InsertOne(t *testing.T) {
 	mt := mtest.New(t, mtest.NewOptions().ClientType(mtest.Mock))
-	defer mt.Close()
-
 	mt.Run("test", func(mt *mtest.T) {
 		mt.AddMockResponses(mtest.CreateSuccessResponse(bson.D{
 			{Key: "value", Value: bson.D{{Key: "foo", Value: "bar"}}},
@@ -318,8 +290,6 @@ func TestModel_InsertOne(t *testing.T) {
 
 func TestModel_InsertOneNoCache(t *testing.T) {
 	mt := mtest.New(t, mtest.NewOptions().ClientType(mtest.Mock))
-	defer mt.Close()
-
 	mt.Run("test", func(mt *mtest.T) {
 		mt.AddMockResponses(mtest.CreateSuccessResponse(bson.D{
 			{Key: "value", Value: bson.D{{Key: "foo", Value: "bar"}}},
@@ -335,8 +305,6 @@ func TestModel_InsertOneNoCache(t *testing.T) {
 
 func TestModel_ReplaceOne(t *testing.T) {
 	mt := mtest.New(t, mtest.NewOptions().ClientType(mtest.Mock))
-	defer mt.Close()
-
 	mt.Run("test", func(mt *mtest.T) {
 		mt.AddMockResponses(mtest.CreateSuccessResponse(bson.D{
 			{Key: "value", Value: bson.D{{Key: "foo", Value: "bar"}}},
@@ -368,8 +336,6 @@ func TestModel_ReplaceOne(t *testing.T) {
 
 func TestModel_ReplaceOneNoCache(t *testing.T) {
 	mt := mtest.New(t, mtest.NewOptions().ClientType(mtest.Mock))
-	defer mt.Close()
-
 	mt.Run("test", func(mt *mtest.T) {
 		mt.AddMockResponses(mtest.CreateSuccessResponse(bson.D{
 			{Key: "value", Value: bson.D{{Key: "foo", Value: "bar"}}},
@@ -385,8 +351,6 @@ func TestModel_ReplaceOneNoCache(t *testing.T) {
 
 func TestModel_SetCache(t *testing.T) {
 	mt := mtest.New(t, mtest.NewOptions().ClientType(mtest.Mock))
-	defer mt.Close()
-
 	mt.Run("test", func(mt *mtest.T) {
 		m := createModel(t, mt)
 		assert.Nil(t, m.SetCache("foo", "bar"))
@@ -398,8 +362,6 @@ func TestModel_SetCache(t *testing.T) {
 
 func TestModel_UpdateByID(t *testing.T) {
 	mt := mtest.New(t, mtest.NewOptions().ClientType(mtest.Mock))
-	defer mt.Close()
-
 	mt.Run("test", func(mt *mtest.T) {
 		mt.AddMockResponses(mtest.CreateSuccessResponse(bson.D{
 			{Key: "value", Value: bson.D{{Key: "foo", Value: "bar"}}},
@@ -431,8 +393,6 @@ func TestModel_UpdateByID(t *testing.T) {
 
 func TestModel_UpdateByIDNoCache(t *testing.T) {
 	mt := mtest.New(t, mtest.NewOptions().ClientType(mtest.Mock))
-	defer mt.Close()
-
 	mt.Run("test", func(mt *mtest.T) {
 		mt.AddMockResponses(mtest.CreateSuccessResponse(bson.D{
 			{Key: "value", Value: bson.D{{Key: "foo", Value: "bar"}}},
@@ -448,8 +408,6 @@ func TestModel_UpdateByIDNoCache(t *testing.T) {
 
 func TestModel_UpdateMany(t *testing.T) {
 	mt := mtest.New(t, mtest.NewOptions().ClientType(mtest.Mock))
-	defer mt.Close()
-
 	mt.Run("test", func(mt *mtest.T) {
 		mt.AddMockResponses(mtest.CreateSuccessResponse(bson.D{
 			{Key: "value", Value: bson.D{{Key: "foo", Value: "bar"}}},
@@ -483,8 +441,6 @@ func TestModel_UpdateMany(t *testing.T) {
 
 func TestModel_UpdateManyNoCache(t *testing.T) {
 	mt := mtest.New(t, mtest.NewOptions().ClientType(mtest.Mock))
-	defer mt.Close()
-
 	mt.Run("test", func(mt *mtest.T) {
 		mt.AddMockResponses(mtest.CreateSuccessResponse(bson.D{
 			{Key: "value", Value: bson.D{{Key: "foo", Value: "bar"}}},
@@ -500,8 +456,6 @@ func TestModel_UpdateManyNoCache(t *testing.T) {
 
 func TestModel_UpdateOne(t *testing.T) {
 	mt := mtest.New(t, mtest.NewOptions().ClientType(mtest.Mock))
-	defer mt.Close()
-
 	mt.Run("test", func(mt *mtest.T) {
 		mt.AddMockResponses(mtest.CreateSuccessResponse(bson.D{
 			{Key: "value", Value: bson.D{{Key: "foo", Value: "bar"}}},
@@ -533,8 +487,6 @@ func TestModel_UpdateOne(t *testing.T) {
 
 func TestModel_UpdateOneNoCache(t *testing.T) {
 	mt := mtest.New(t, mtest.NewOptions().ClientType(mtest.Mock))
-	defer mt.Close()
-
 	mt.Run("test", func(mt *mtest.T) {
 		mt.AddMockResponses(mtest.CreateSuccessResponse(bson.D{
 			{Key: "value", Value: bson.D{{Key: "foo", Value: "bar"}}},

core/stores/redis/hook.go

@@ -2,14 +2,14 @@ package redis
 
 import (
 	"context"
+	"errors"
 	"io"
 	"net"
 	"strings"
 	"time"
 
-	red "github.com/go-redis/redis/v8"
+	red "github.com/redis/go-redis/v9"
 	"github.com/zeromicro/go-zero/core/breaker"
-	"github.com/zeromicro/go-zero/core/errorx"
 	"github.com/zeromicro/go-zero/core/logx"
 	"github.com/zeromicro/go-zero/core/mapping"
 	"github.com/zeromicro/go-zero/core/timex"
@@ -23,111 +23,84 @@ import (
 const spanName = "redis"
 
 var (
-	startTimeKey          = contextKey("startTime")
 	durationHook          = hook{}
 	redisCmdsAttributeKey = attribute.Key("redis.cmds")
 )
 
-type (
-	contextKey string
-	hook       struct{}
-)
+type hook struct{}
 
-func (h hook) BeforeProcess(ctx context.Context, cmd red.Cmder) (context.Context, error) {
-	return h.startSpan(context.WithValue(ctx, startTimeKey, timex.Now()), cmd), nil
+func (h hook) DialHook(next red.DialHook) red.DialHook {
+	return next
 }
 
-func (h hook) AfterProcess(ctx context.Context, cmd red.Cmder) error {
-	err := cmd.Err()
-	h.endSpan(ctx, err)
+func (h hook) ProcessHook(next red.ProcessHook) red.ProcessHook {
+	return func(ctx context.Context, cmd red.Cmder) error {
+		start := timex.Now()
+		ctx, endSpan := h.startSpan(ctx, cmd)
 
-	val := ctx.Value(startTimeKey)
-	if val == nil {
-		return nil
-	}
+		err := next(ctx, cmd)
 
-	start, ok := val.(time.Duration)
-	if !ok {
-		return nil
-	}
+		endSpan(err)
+		duration := timex.Since(start)
 
-	duration := timex.Since(start)
-	if duration > slowThreshold.Load() {
-		logDuration(ctx, []red.Cmder{cmd}, duration)
-	}
-
-	metricReqDur.Observe(duration.Milliseconds(), cmd.Name())
-	if msg := formatError(err); len(msg) > 0 {
-		metricReqErr.Inc(cmd.Name(), msg)
-	}
-
-	return nil
-}
-
-func (h hook) BeforeProcessPipeline(ctx context.Context, cmds []red.Cmder) (context.Context, error) {
-	if len(cmds) == 0 {
-		return ctx, nil
-	}
-
-	return h.startSpan(context.WithValue(ctx, startTimeKey, timex.Now()), cmds...), nil
-}
-
-func (h hook) AfterProcessPipeline(ctx context.Context, cmds []red.Cmder) error {
-	if len(cmds) == 0 {
-		return nil
-	}
-
-	batchError := errorx.BatchError{}
-	for _, cmd := range cmds {
-		err := cmd.Err()
-		if err == nil {
-			continue
+		if duration > slowThreshold.Load() {
+			logDuration(ctx, []red.Cmder{cmd}, duration)
+			metricSlowCount.Inc(cmd.Name())
 		}
 
-		batchError.Add(err)
-	}
-	h.endSpan(ctx, batchError.Err())
+		metricReqDur.Observe(duration.Milliseconds(), cmd.Name())
+		if msg := formatError(err); len(msg) > 0 {
+			metricReqErr.Inc(cmd.Name(), msg)
+		}
 
-	val := ctx.Value(startTimeKey)
-	if val == nil {
-		return nil
+		return err
 	}
+}
 
-	start, ok := val.(time.Duration)
-	if !ok {
-		return nil
+func (h hook) ProcessPipelineHook(next red.ProcessPipelineHook) red.ProcessPipelineHook {
+	return func(ctx context.Context, cmds []red.Cmder) error {
+		if len(cmds) == 0 {
+			return next(ctx, cmds)
+		}
+
+		start := timex.Now()
+		ctx, endSpan := h.startSpan(ctx, cmds...)
+
+		err := next(ctx, cmds)
+
+		endSpan(err)
+		duration := timex.Since(start)
+		if duration > slowThreshold.Load()*time.Duration(len(cmds)) {
+			logDuration(ctx, cmds, duration)
+		}
+
+		metricReqDur.Observe(duration.Milliseconds(), "Pipeline")
+		if msg := formatError(err); len(msg) > 0 {
+			metricReqErr.Inc("Pipeline", msg)
+		}
+
+		return err
 	}
-
-	duration := timex.Since(start)
-	if duration > slowThreshold.Load()*time.Duration(len(cmds)) {
-		logDuration(ctx, cmds, duration)
-	}
-
-	metricReqDur.Observe(duration.Milliseconds(), "Pipeline")
-	if msg := formatError(batchError.Err()); len(msg) > 0 {
-		metricReqErr.Inc("Pipeline", msg)
-	}
-
-	return nil
 }
 
 func formatError(err error) string {
-	if err == nil || err == red.Nil {
+	if err == nil || errors.Is(err, red.Nil) {
 		return ""
 	}
 
-	opErr, ok := err.(*net.OpError)
+	var opErr *net.OpError
+	ok := errors.As(err, &opErr)
 	if ok && opErr.Timeout() {
 		return "timeout"
 	}
 
-	switch err {
-	case io.EOF:
+	switch {
+	case err == io.EOF:
 		return "eof"
-	case context.DeadlineExceeded:
+	case errors.Is(err, context.DeadlineExceeded):
 		return "context deadline"
-	case breaker.ErrServiceUnavailable:
-		return "breaker"
+	case errors.Is(err, breaker.ErrServiceUnavailable):
+		return "breaker open"
 	default:
 		return "unexpected error"
 	}
@@ -151,7 +124,7 @@ func logDuration(ctx context.Context, cmds []red.Cmder, duration time.Duration)
 	logx.WithContext(ctx).WithDuration(duration).Slowf("[REDIS] slowcall on executing: %s", buf.String())
 }
 
-func (h hook) startSpan(ctx context.Context, cmds ...red.Cmder) context.Context {
+func (h hook) startSpan(ctx context.Context, cmds ...red.Cmder) (context.Context, func(err error)) {
 	tracer := trace.TracerFromContext(ctx)
 
 	ctx, span := tracer.Start(ctx,
@@ -165,18 +138,15 @@ func (h hook) startSpan(ctx context.Context, cmds ...red.Cmder) context.Context
 	}
 	span.SetAttributes(redisCmdsAttributeKey.StringSlice(cmdStrs))
 
-	return ctx
-}
+	return ctx, func(err error) {
+		defer span.End()
 
-func (h hook) endSpan(ctx context.Context, err error) {
-	span := oteltrace.SpanFromContext(ctx)
-	defer span.End()
+		if err == nil || errors.Is(err, red.Nil) {
+			span.SetStatus(codes.Ok, "")
+			return
+		}
 
-	if err == nil || err == red.Nil {
-		span.SetStatus(codes.Ok, "")
-		return
+		span.SetStatus(codes.Error, err.Error())
+		span.RecordError(err)
 	}
-
-	span.SetStatus(codes.Error, err.Error())
-	span.RecordError(err)
 }

core/stores/redis/hook_test.go

@@ -4,168 +4,103 @@ import (
 	"context"
 	"errors"
 	"io"
-	"log"
 	"net"
 	"strings"
 	"testing"
 	"time"
 
-	red "github.com/go-redis/redis/v8"
+	red "github.com/redis/go-redis/v9"
 	"github.com/stretchr/testify/assert"
 	"github.com/zeromicro/go-zero/core/breaker"
 	"github.com/zeromicro/go-zero/core/logx/logtest"
-	ztrace "github.com/zeromicro/go-zero/core/trace"
+	"github.com/zeromicro/go-zero/core/trace/tracetest"
 	tracesdk "go.opentelemetry.io/otel/trace"
 )
 
 func TestHookProcessCase1(t *testing.T) {
-	ztrace.StartAgent(ztrace.Config{
-		Name:     "go-zero-test",
-		Endpoint: "http://localhost:14268/api/traces",
-		Batcher:  "jaeger",
-		Sampler:  1.0,
-	})
-	defer ztrace.StopAgent()
+	tracetest.NewInMemoryExporter(t)
+	w := logtest.NewCollector(t)
 
-	writer := log.Writer()
-	var buf strings.Builder
-	log.SetOutput(&buf)
-	defer log.SetOutput(writer)
-
-	ctx, err := durationHook.BeforeProcess(context.Background(), red.NewCmd(context.Background()))
+	err := durationHook.ProcessHook(func(ctx context.Context, cmd red.Cmder) error {
+		assert.Equal(t, "redis", tracesdk.SpanFromContext(ctx).(interface{ Name() string }).Name())
+		return nil
+	})(context.Background(), red.NewCmd(context.Background()))
 	if err != nil {
 		t.Fatal(err)
 	}
 
-	assert.Nil(t, durationHook.AfterProcess(ctx, red.NewCmd(context.Background())))
-	assert.False(t, strings.Contains(buf.String(), "slow"))
-	assert.Equal(t, "redis", tracesdk.SpanFromContext(ctx).(interface{ Name() string }).Name())
+	assert.False(t, strings.Contains(w.String(), "slow"))
 }
 
 func TestHookProcessCase2(t *testing.T) {
-	ztrace.StartAgent(ztrace.Config{
-		Name:     "go-zero-test",
-		Endpoint: "http://localhost:14268/api/traces",
-		Batcher:  "jaeger",
-		Sampler:  1.0,
-	})
-	defer ztrace.StopAgent()
-
+	tracetest.NewInMemoryExporter(t)
 	w := logtest.NewCollector(t)
 
-	ctx, err := durationHook.BeforeProcess(context.Background(), red.NewCmd(context.Background()))
+	err := durationHook.ProcessHook(func(ctx context.Context, cmd red.Cmder) error {
+		assert.Equal(t, "redis", tracesdk.SpanFromContext(ctx).(interface{ Name() string }).Name())
+		time.Sleep(slowThreshold.Load() + time.Millisecond)
+		return nil
+	})(context.Background(), red.NewCmd(context.Background()))
 	if err != nil {
 		t.Fatal(err)
 	}
-	assert.Equal(t, "redis", tracesdk.SpanFromContext(ctx).(interface{ Name() string }).Name())
 
-	time.Sleep(slowThreshold.Load() + time.Millisecond)
-
-	assert.Nil(t, durationHook.AfterProcess(ctx, red.NewCmd(context.Background(), "foo", "bar")))
 	assert.True(t, strings.Contains(w.String(), "slow"))
 	assert.True(t, strings.Contains(w.String(), "trace"))
 	assert.True(t, strings.Contains(w.String(), "span"))
 }
 
-func TestHookProcessCase3(t *testing.T) {
-	writer := log.Writer()
-	var buf strings.Builder
-	log.SetOutput(&buf)
-	defer log.SetOutput(writer)
-
-	assert.Nil(t, durationHook.AfterProcess(context.Background(), red.NewCmd(context.Background())))
-	assert.True(t, buf.Len() == 0)
-}
-
-func TestHookProcessCase4(t *testing.T) {
-	writer := log.Writer()
-	var buf strings.Builder
-	log.SetOutput(&buf)
-	defer log.SetOutput(writer)
-
-	ctx := context.WithValue(context.Background(), startTimeKey, "foo")
-	assert.Nil(t, durationHook.AfterProcess(ctx, red.NewCmd(context.Background())))
-	assert.True(t, buf.Len() == 0)
-}
-
 func TestHookProcessPipelineCase1(t *testing.T) {
-	writer := log.Writer()
-	var buf strings.Builder
-	log.SetOutput(&buf)
-	defer log.SetOutput(writer)
+	tracetest.NewInMemoryExporter(t)
+	w := logtest.NewCollector(t)
 
-	_, err := durationHook.BeforeProcessPipeline(context.Background(), []red.Cmder{})
+	err := durationHook.ProcessPipelineHook(func(ctx context.Context, cmds []red.Cmder) error {
+		return nil
+	})(context.Background(), nil)
 	assert.NoError(t, err)
-	ctx, err := durationHook.BeforeProcessPipeline(context.Background(), []red.Cmder{
+
+	err = durationHook.ProcessPipelineHook(func(ctx context.Context, cmds []red.Cmder) error {
+		assert.Equal(t, "redis", tracesdk.SpanFromContext(ctx).(interface{ Name() string }).Name())
+		return nil
+	})(context.Background(), []red.Cmder{
 		red.NewCmd(context.Background()),
 	})
 	assert.NoError(t, err)
-	assert.Equal(t, "redis", tracesdk.SpanFromContext(ctx).(interface{ Name() string }).Name())
 
-	assert.NoError(t, durationHook.AfterProcessPipeline(ctx, []red.Cmder{}))
-	assert.NoError(t, durationHook.AfterProcessPipeline(ctx, []red.Cmder{
-		red.NewCmd(context.Background()),
-	}))
-	assert.False(t, strings.Contains(buf.String(), "slow"))
+	assert.False(t, strings.Contains(w.String(), "slow"))
 }
 
 func TestHookProcessPipelineCase2(t *testing.T) {
-	ztrace.StartAgent(ztrace.Config{
-		Name:     "go-zero-test",
-		Endpoint: "http://localhost:14268/api/traces",
-		Batcher:  "jaeger",
-		Sampler:  1.0,
-	})
-	defer ztrace.StopAgent()
-
+	tracetest.NewInMemoryExporter(t)
 	w := logtest.NewCollector(t)
 
-	ctx, err := durationHook.BeforeProcessPipeline(context.Background(), []red.Cmder{
+	err := durationHook.ProcessPipelineHook(func(ctx context.Context, cmds []red.Cmder) error {
+		assert.Equal(t, "redis", tracesdk.SpanFromContext(ctx).(interface{ Name() string }).Name())
+		time.Sleep(slowThreshold.Load() + time.Millisecond)
+		return nil
+	})(context.Background(), []red.Cmder{
 		red.NewCmd(context.Background()),
 	})
 	assert.NoError(t, err)
-	assert.Equal(t, "redis", tracesdk.SpanFromContext(ctx).(interface{ Name() string }).Name())
 
-	time.Sleep(slowThreshold.Load() + time.Millisecond)
-
-	assert.Nil(t, durationHook.AfterProcessPipeline(ctx, []red.Cmder{
-		red.NewCmd(context.Background(), "foo", "bar"),
-	}))
 	assert.True(t, strings.Contains(w.String(), "slow"))
 	assert.True(t, strings.Contains(w.String(), "trace"))
 	assert.True(t, strings.Contains(w.String(), "span"))
 }
 
 func TestHookProcessPipelineCase3(t *testing.T) {
-	w := logtest.NewCollector(t)
+	te := tracetest.NewInMemoryExporter(t)
 
-	assert.Nil(t, durationHook.AfterProcessPipeline(context.Background(), []red.Cmder{
+	err := durationHook.ProcessPipelineHook(func(ctx context.Context, cmds []red.Cmder) error {
+		assert.Equal(t, "redis", tracesdk.SpanFromContext(ctx).(interface{ Name() string }).Name())
+		return assert.AnError
+	})(context.Background(), []red.Cmder{
 		red.NewCmd(context.Background()),
-	}))
-	assert.True(t, len(w.String()) == 0)
-}
-
-func TestHookProcessPipelineCase4(t *testing.T) {
-	w := logtest.NewCollector(t)
-
-	ctx := context.WithValue(context.Background(), startTimeKey, "foo")
-	assert.Nil(t, durationHook.AfterProcessPipeline(ctx, []red.Cmder{
-		red.NewCmd(context.Background()),
-	}))
-	assert.True(t, len(w.String()) == 0)
-}
-
-func TestHookProcessPipelineCase5(t *testing.T) {
-	writer := log.Writer()
-	var buf strings.Builder
-	log.SetOutput(&buf)
-	defer log.SetOutput(writer)
-
-	ctx := context.WithValue(context.Background(), startTimeKey, "foo")
-	assert.Nil(t, durationHook.AfterProcessPipeline(ctx, []red.Cmder{
-		red.NewCmd(context.Background()),
-	}))
-	assert.True(t, buf.Len() == 0)
+	})
+	assert.ErrorIs(t, err, assert.AnError)
+	traceLogs := te.GetSpans().Snapshots()[0]
+	assert.Equal(t, "redis", traceLogs.Name())
+	assert.Equal(t, assert.AnError.Error(), traceLogs.Events()[0].Attributes[1].Value.AsString(), "trace should record error")
 }
 
 func TestLogDuration(t *testing.T) {
@@ -203,7 +138,7 @@ func TestFormatError(t *testing.T) {
 	assert.Equal(t, "context deadline", formatError(context.DeadlineExceeded))
 
 	// Test case: err is breaker.ErrServiceUnavailable
-	assert.Equal(t, "breaker", formatError(breaker.ErrServiceUnavailable))
+	assert.Equal(t, "breaker open", formatError(breaker.ErrServiceUnavailable))
 
 	// Test case: err is unknown
 	assert.Equal(t, "unexpected error", formatError(errors.New("some error")))

core/stores/redis/metrics.go

@@ -1,6 +1,12 @@
 package redis
 
-import "github.com/zeromicro/go-zero/core/metric"
+import (
+	"sync"
+
+	"github.com/prometheus/client_golang/prometheus"
+	red "github.com/redis/go-redis/v9"
+	"github.com/zeromicro/go-zero/core/metric"
+)
 
 const namespace = "redis_client"
 
@@ -11,7 +17,7 @@ var (
 		Name:      "duration_ms",
 		Help:      "redis client requests duration(ms).",
 		Labels:    []string{"command"},
-		Buckets:   []float64{5, 10, 25, 50, 100, 250, 500, 1000, 2500},
+		Buckets:   []float64{0.25, 0.5, 1, 1.5, 2, 3, 5, 10, 25, 50, 100, 250, 500, 1000, 2000, 5000, 10000, 15000},
 	})
 	metricReqErr = metric.NewCounterVec(&metric.CounterVecOpts{
 		Namespace: namespace,
@@ -20,4 +26,162 @@ var (
 		Help:      "redis client requests error count.",
 		Labels:    []string{"command", "error"},
 	})
+	metricSlowCount = metric.NewCounterVec(&metric.CounterVecOpts{
+		Namespace: namespace,
+		Subsystem: "requests",
+		Name:      "slow_total",
+		Help:      "redis client requests slow count.",
+		Labels:    []string{"command"},
+	})
+
+	connLabels                         = []string{"key", "client_type"}
+	connCollector                      = newCollector()
+	_             prometheus.Collector = (*collector)(nil)
 )
+
+type (
+	statGetter struct {
+		clientType string
+		key        string
+		poolSize   int
+		poolStats  func() *red.PoolStats
+	}
+
+	// collector collects statistics from a redis client.
+	// It implements the prometheus.Collector interface.
+	collector struct {
+		hitDesc     *prometheus.Desc
+		missDesc    *prometheus.Desc
+		timeoutDesc *prometheus.Desc
+		totalDesc   *prometheus.Desc
+		idleDesc    *prometheus.Desc
+		staleDesc   *prometheus.Desc
+		maxDesc     *prometheus.Desc
+
+		clients []*statGetter
+		lock    sync.Mutex
+	}
+)
+
+func newCollector() *collector {
+	c := &collector{
+		hitDesc: prometheus.NewDesc(
+			prometheus.BuildFQName(namespace, "", "pool_hit_total"),
+			"Number of times a connection was found in the pool",
+			connLabels, nil,
+		),
+		missDesc: prometheus.NewDesc(
+			prometheus.BuildFQName(namespace, "", "pool_miss_total"),
+			"Number of times a connection was not found in the pool",
+			connLabels, nil,
+		),
+		timeoutDesc: prometheus.NewDesc(
+			prometheus.BuildFQName(namespace, "", "pool_timeout_total"),
+			"Number of times a timeout occurred when looking for a connection in the pool",
+			connLabels, nil,
+		),
+		totalDesc: prometheus.NewDesc(
+			prometheus.BuildFQName(namespace, "", "pool_conn_total_current"),
+			"Current number of connections in the pool",
+			connLabels, nil,
+		),
+		idleDesc: prometheus.NewDesc(
+			prometheus.BuildFQName(namespace, "", "pool_conn_idle_current"),
+			"Current number of idle connections in the pool",
+			connLabels, nil,
+		),
+		staleDesc: prometheus.NewDesc(
+			prometheus.BuildFQName(namespace, "", "pool_conn_stale_total"),
+			"Number of times a connection was removed from the pool because it was stale",
+			connLabels, nil,
+		),
+		maxDesc: prometheus.NewDesc(
+			prometheus.BuildFQName(namespace, "", "pool_conn_max"),
+			"Max number of connections in the pool",
+			connLabels, nil,
+		),
+	}
+
+	prometheus.MustRegister(c)
+
+	return c
+}
+
+// Describe implements the prometheus.Collector interface.
+func (s *collector) Describe(descs chan<- *prometheus.Desc) {
+	descs <- s.hitDesc
+	descs <- s.missDesc
+	descs <- s.timeoutDesc
+	descs <- s.totalDesc
+	descs <- s.idleDesc
+	descs <- s.staleDesc
+	descs <- s.maxDesc
+}
+
+// Collect implements the prometheus.Collector interface.
+func (s *collector) Collect(metrics chan<- prometheus.Metric) {
+	s.lock.Lock()
+	defer s.lock.Unlock()
+
+	for _, client := range s.clients {
+		key, clientType := client.key, client.clientType
+		stats := client.poolStats()
+
+		metrics <- prometheus.MustNewConstMetric(
+			s.hitDesc,
+			prometheus.CounterValue,
+			float64(stats.Hits),
+			key,
+			clientType,
+		)
+		metrics <- prometheus.MustNewConstMetric(
+			s.missDesc,
+			prometheus.CounterValue,
+			float64(stats.Misses),
+			key,
+			clientType,
+		)
+		metrics <- prometheus.MustNewConstMetric(
+			s.timeoutDesc,
+			prometheus.CounterValue,
+			float64(stats.Timeouts),
+			key,
+			clientType,
+		)
+		metrics <- prometheus.MustNewConstMetric(
+			s.totalDesc,
+			prometheus.GaugeValue,
+			float64(stats.TotalConns),
+			key,
+			clientType,
+		)
+		metrics <- prometheus.MustNewConstMetric(
+			s.idleDesc,
+			prometheus.GaugeValue,
+			float64(stats.IdleConns),
+			key,
+			clientType,
+		)
+		metrics <- prometheus.MustNewConstMetric(
+			s.staleDesc,
+			prometheus.CounterValue,
+			float64(stats.StaleConns),
+			key,
+			clientType,
+		)
+		metrics <- prometheus.MustNewConstMetric(
+			s.maxDesc,
+			prometheus.CounterValue,
+			float64(client.poolSize),
+			key,
+			clientType,
+		)
+	}
+}
+
+func (s *collector) registerClient(client *statGetter) {
+	s.lock.Lock()
+	defer s.lock.Unlock()
+
+	s.clients = append(s.clients, client)
+}

core/stores/redis/metrics_test.go

@@ -0,0 +1,130 @@
+package redis
+
+import (
+	"io"
+	"net/http"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/prometheus/client_golang/prometheus"
+	"github.com/prometheus/client_golang/prometheus/testutil"
+	red "github.com/redis/go-redis/v9"
+	"github.com/stretchr/testify/assert"
+	"github.com/zeromicro/go-zero/core/conf"
+	"github.com/zeromicro/go-zero/internal/devserver"
+)
+
+func TestRedisMetric(t *testing.T) {
+	cfg := devserver.Config{}
+	_ = conf.FillDefault(&cfg)
+	server := devserver.NewServer(cfg)
+	server.StartAsync()
+	time.Sleep(time.Second)
+
+	metricReqDur.Observe(8, "test-cmd")
+	metricReqErr.Inc("test-cmd", "internal-error")
+	metricSlowCount.Inc("test-cmd")
+
+	url := "http://127.0.0.1:6060/metrics"
+	resp, err := http.Get(url)
+	assert.Nil(t, err)
+	defer resp.Body.Close()
+	s, err := io.ReadAll(resp.Body)
+	assert.Nil(t, err)
+	content := string(s)
+	assert.Contains(t, content, "redis_client_requests_duration_ms_sum{command=\"test-cmd\"} 8\n")
+	assert.Contains(t, content, "redis_client_requests_duration_ms_count{command=\"test-cmd\"} 1\n")
+	assert.Contains(t, content, "redis_client_requests_error_total{command=\"test-cmd\",error=\"internal-error\"} 1\n")
+	assert.Contains(t, content, "redis_client_requests_slow_total{command=\"test-cmd\"} 1\n")
+}
+
+func Test_newCollector(t *testing.T) {
+	prometheus.Unregister(connCollector)
+	c := newCollector()
+	c.registerClient(&statGetter{
+		clientType: "node",
+		key:        "test1",
+		poolSize:   10,
+		poolStats: func() *red.PoolStats {
+			return &red.PoolStats{
+				Hits:       10000,
+				Misses:     10,
+				Timeouts:   5,
+				TotalConns: 100,
+				IdleConns:  20,
+				StaleConns: 1,
+			}
+		},
+	})
+	c.registerClient(&statGetter{
+		clientType: "node",
+		key:        "test2",
+		poolSize:   11,
+		poolStats: func() *red.PoolStats {
+			return &red.PoolStats{
+				Hits:       10001,
+				Misses:     11,
+				Timeouts:   6,
+				TotalConns: 101,
+				IdleConns:  21,
+				StaleConns: 2,
+			}
+		},
+	})
+	c.registerClient(&statGetter{
+		clientType: "cluster",
+		key:        "test3",
+		poolSize:   5,
+		poolStats: func() *red.PoolStats {
+			return &red.PoolStats{
+				Hits:       20000,
+				Misses:     20,
+				Timeouts:   10,
+				TotalConns: 200,
+				IdleConns:  40,
+				StaleConns: 2,
+			}
+		},
+	})
+	val := `
+		# HELP redis_client_pool_conn_idle_current Current number of idle connections in the pool
+		# TYPE redis_client_pool_conn_idle_current gauge
+		redis_client_pool_conn_idle_current{client_type="cluster",key="test3"} 40
+		redis_client_pool_conn_idle_current{client_type="node",key="test1"} 20
+		redis_client_pool_conn_idle_current{client_type="node",key="test2"} 21
+	 	# HELP redis_client_pool_conn_max Max number of connections in the pool
+	 	# TYPE redis_client_pool_conn_max counter
+		redis_client_pool_conn_max{client_type="cluster",key="test3"} 5
+	 	redis_client_pool_conn_max{client_type="node",key="test1"} 10
+		redis_client_pool_conn_max{client_type="node",key="test2"} 11
+	 	# HELP redis_client_pool_conn_stale_total Number of times a connection was removed from the pool because it was stale
+	 	# TYPE redis_client_pool_conn_stale_total counter
+		redis_client_pool_conn_stale_total{client_type="cluster",key="test3"} 2
+	 	redis_client_pool_conn_stale_total{client_type="node",key="test1"} 1
+		redis_client_pool_conn_stale_total{client_type="node",key="test2"} 2
+	 	# HELP redis_client_pool_conn_total_current Current number of connections in the pool
+	 	# TYPE redis_client_pool_conn_total_current gauge
+		redis_client_pool_conn_total_current{client_type="cluster",key="test3"} 200
+	 	redis_client_pool_conn_total_current{client_type="node",key="test1"} 100
+		redis_client_pool_conn_total_current{client_type="node",key="test2"} 101
+	 	# HELP redis_client_pool_hit_total Number of times a connection was found in the pool
+	 	# TYPE redis_client_pool_hit_total counter
+		redis_client_pool_hit_total{client_type="cluster",key="test3"} 20000
+	 	redis_client_pool_hit_total{client_type="node",key="test1"} 10000
+		redis_client_pool_hit_total{client_type="node",key="test2"} 10001
+	 	# HELP redis_client_pool_miss_total Number of times a connection was not found in the pool
+	 	# TYPE redis_client_pool_miss_total counter
+		redis_client_pool_miss_total{client_type="cluster",key="test3"} 20
+	 	redis_client_pool_miss_total{client_type="node",key="test1"} 10
+		redis_client_pool_miss_total{client_type="node",key="test2"} 11
+	 	# HELP redis_client_pool_timeout_total Number of times a timeout occurred when looking for a connection in the pool
+	 	# TYPE redis_client_pool_timeout_total counter
+		redis_client_pool_timeout_total{client_type="cluster",key="test3"} 10
+	 	redis_client_pool_timeout_total{client_type="node",key="test1"} 5
+		redis_client_pool_timeout_total{client_type="node",key="test2"} 6
+`
+
+	err := testutil.CollectAndCompare(c, strings.NewReader(val))
+	assert.NoError(t, err)
+}

core/stores/redis/redis.go

@@ -7,7 +7,7 @@ import (
 	"strconv"
 	"time"
 
-	red "github.com/go-redis/redis/v8"
+	red "github.com/redis/go-redis/v9"
 	"github.com/zeromicro/go-zero/core/breaker"
 	"github.com/zeromicro/go-zero/core/errorx"
 	"github.com/zeromicro/go-zero/core/logx"
@@ -64,6 +64,7 @@ type (
 	// RedisNode interface represents a redis node.
 	RedisNode interface {
 		red.Cmdable
+		red.BitMapCmdable
 	}
 
 	// GeoLocation is used with GeoAdd to add geospatial location.
@@ -467,6 +468,28 @@ func (s *Redis) ExistsCtx(ctx context.Context, key string) (val bool, err error)
 	return
 }
 
+// ExistsMany is the implementation of redis exists command.
+// checks the existence of multiple keys in Redis using the EXISTS command.
+func (s *Redis) ExistsMany(keys ...string) (int64, error) {
+	return s.ExistsManyCtx(context.Background(), keys...)
+}
+
+// ExistsManyCtx is the implementation of redis exists command.
+// checks the existence of multiple keys in Redis using the EXISTS command.
+func (s *Redis) ExistsManyCtx(ctx context.Context, keys ...string) (val int64, err error) {
+	err = s.brk.DoWithAcceptable(func() error {
+		conn, err := getRedis(s)
+		if err != nil {
+			return err
+		}
+
+		val, err = conn.Exists(ctx, keys...).Result()
+		return err
+	}, acceptable)
+
+	return
+}
+
 // Expire is the implementation of redis expire command.
 func (s *Redis) Expire(key string, seconds int) error {
 	return s.ExpireCtx(context.Background(), key, seconds)
@@ -515,13 +538,8 @@ func (s *Redis) GeoAddCtx(ctx context.Context, key string, geoLocation ...*GeoLo
 			return err
 		}
 
-		v, err := conn.GeoAdd(ctx, key, geoLocation...).Result()
-		if err != nil {
-			return err
-		}
-
-		val = v
-		return nil
+		val, err = conn.GeoAdd(ctx, key, geoLocation...).Result()
+		return err
 	}, acceptable)
 
 	return
@@ -541,13 +559,8 @@ func (s *Redis) GeoDistCtx(ctx context.Context, key, member1, member2, unit stri
 			return err
 		}
 
-		v, err := conn.GeoDist(ctx, key, member1, member2, unit).Result()
-		if err != nil {
-			return err
-		}
-
-		val = v
-		return nil
+		val, err = conn.GeoDist(ctx, key, member1, member2, unit).Result()
+		return err
 	}, acceptable)
 
 	return
@@ -567,13 +580,8 @@ func (s *Redis) GeoHashCtx(ctx context.Context, key string, members ...string) (
 			return err
 		}
 
-		v, err := conn.GeoHash(ctx, key, members...).Result()
-		if err != nil {
-			return err
-		}
-
-		val = v
-		return nil
+		val, err = conn.GeoHash(ctx, key, members...).Result()
+		return err
 	}, acceptable)
 
 	return
@@ -594,13 +602,8 @@ func (s *Redis) GeoRadiusCtx(ctx context.Context, key string, longitude, latitud
 			return err
 		}
 
-		v, err := conn.GeoRadius(ctx, key, longitude, latitude, query).Result()
-		if err != nil {
-			return err
-		}
-
-		val = v
-		return nil
+		val, err = conn.GeoRadius(ctx, key, longitude, latitude, query).Result()
+		return err
 	}, acceptable)
 
 	return
@@ -620,13 +623,8 @@ func (s *Redis) GeoRadiusByMemberCtx(ctx context.Context, key, member string,
 			return err
 		}
 
-		v, err := conn.GeoRadiusByMember(ctx, key, member, query).Result()
-		if err != nil {
-			return err
-		}
-
-		val = v
-		return nil
+		val, err = conn.GeoRadiusByMember(ctx, key, member, query).Result()
+		return err
 	}, acceptable)
 
 	return
@@ -646,13 +644,8 @@ func (s *Redis) GeoPosCtx(ctx context.Context, key string, members ...string) (
 			return err
 		}
 
-		v, err := conn.GeoPos(ctx, key, members...).Result()
-		if err != nil {
-			return err
-		}
-
-		val = v
-		return nil
+		val, err = conn.GeoPos(ctx, key, members...).Result()
+		return err
 	}, acceptable)
 
 	return
@@ -671,7 +664,7 @@ func (s *Redis) GetCtx(ctx context.Context, key string) (val string, err error)
 			return err
 		}
 
-		if val, err = conn.Get(ctx, key).Result(); err == red.Nil {
+		if val, err = conn.Get(ctx, key).Result(); errors.Is(err, red.Nil) {
 			return nil
 		} else if err != nil {
 			return err
@@ -721,7 +714,7 @@ func (s *Redis) GetSetCtx(ctx context.Context, key, value string) (val string, e
 			return err
 		}
 
-		if val, err = conn.GetSet(ctx, key, value).Result(); err == red.Nil {
+		if val, err = conn.GetSet(ctx, key, value).Result(); errors.Is(err, red.Nil) {
 			return nil
 		}
 
@@ -847,17 +840,16 @@ func (s *Redis) HincrbyFloat(key, field string, increment float64) (float64, err
 }
 
 // HincrbyFloatCtx is the implementation of redis hincrbyfloat command.
-func (s *Redis) HincrbyFloatCtx(ctx context.Context, key, field string, increment float64) (val float64, err error) {
+func (s *Redis) HincrbyFloatCtx(ctx context.Context, key, field string, increment float64) (
+	val float64, err error) {
 	err = s.brk.DoWithAcceptable(func() error {
 		conn, err := getRedis(s)
 		if err != nil {
 			return err
 		}
+
 		val, err = conn.HIncrByFloat(ctx, key, field, increment).Result()
-		if err != nil {
-			return err
-		}
-		return nil
+		return err
 	}, acceptable)
 
 	return
@@ -1311,6 +1303,26 @@ func (s *Redis) MgetCtx(ctx context.Context, keys ...string) (val []string, err
 	return
 }
 
+// Mset is the implementation of redis mset command.
+func (s *Redis) Mset(fieldsAndValues ...any) (string, error) {
+	return s.MsetCtx(context.Background(), fieldsAndValues...)
+}
+
+// MsetCtx is the implementation of redis mset command.
+func (s *Redis) MsetCtx(ctx context.Context, fieldsAndValues ...any) (val string, err error) {
+	err = s.brk.DoWithAcceptable(func() error {
+		conn, err := getRedis(s)
+		if err != nil {
+			return err
+		}
+
+		val, err = conn.MSet(ctx, fieldsAndValues...).Result()
+		return err
+	}, acceptable)
+
+	return
+}
+
 // Persist is the implementation of redis persist command.
 func (s *Redis) Persist(key string) (bool, error) {
 	return s.PersistCtx(context.Background(), key)
@@ -1993,7 +2005,14 @@ func (s *Redis) TtlCtx(ctx context.Context, key string) (val int, err error) {
 			return err
 		}
 
-		val = int(duration / time.Second)
+		if duration >= 0 {
+			val = int(duration / time.Second)
+		} else {
+			// -2 means key does not exist
+			// -1 means key exists but has no expire
+			val = int(duration)
+		}
+
 		return nil
 	}, acceptable)
 
@@ -2025,7 +2044,47 @@ func (s *Redis) ZaddFloatCtx(ctx context.Context, key string, score float64, val
 			return err
 		}
 
-		v, err := conn.ZAdd(ctx, key, &red.Z{
+		v, err := conn.ZAdd(ctx, key, red.Z{
+			Score:  score,
+			Member: value,
+		}).Result()
+		if err != nil {
+			return err
+		}
+
+		val = v == 1
+		return nil
+	}, acceptable)
+
+	return
+}
+
+// Zaddnx is the implementation of redis zadd nx command.
+func (s *Redis) Zaddnx(key string, score int64, value string) (val bool, err error) {
+	return s.ZaddnxCtx(context.Background(), key, score, value)
+}
+
+// ZaddnxCtx is the implementation of redis zadd nx command.
+func (s *Redis) ZaddnxCtx(ctx context.Context, key string, score int64, value string) (
+	val bool, err error) {
+	return s.ZaddnxFloatCtx(ctx, key, float64(score), value)
+}
+
+// ZaddnxFloat is the implementation of redis zaddnx command.
+func (s *Redis) ZaddnxFloat(key string, score float64, value string) (bool, error) {
+	return s.ZaddFloatCtx(context.Background(), key, score, value)
+}
+
+// ZaddnxFloatCtx is the implementation of redis zaddnx command.
+func (s *Redis) ZaddnxFloatCtx(ctx context.Context, key string, score float64, value string) (
+	val bool, err error) {
+	err = s.brk.DoWithAcceptable(func() error {
+		conn, err := getRedis(s)
+		if err != nil {
+			return err
+		}
+
+		v, err := conn.ZAddNX(ctx, key, red.Z{
 			Score:  score,
 			Member: value,
 		}).Result()
@@ -2053,19 +2112,14 @@ func (s *Redis) ZaddsCtx(ctx context.Context, key string, ps ...Pair) (val int64
 			return err
 		}
 
-		var zs []*red.Z
+		var zs []red.Z
 		for _, p := range ps {
-			z := &red.Z{Score: float64(p.Score), Member: p.Key}
+			z := red.Z{Score: float64(p.Score), Member: p.Key}
 			zs = append(zs, z)
 		}
 
-		v, err := conn.ZAdd(ctx, key, zs...).Result()
-		if err != nil {
-			return err
-		}
-
-		val = v
-		return nil
+		val, err = conn.ZAdd(ctx, key, zs...).Result()
+		return err
 	}, acceptable)
 
 	return
@@ -2185,6 +2239,7 @@ func (s *Redis) ZscoreByFloatCtx(ctx context.Context, key, value string) (val fl
 		if err != nil {
 			return err
 		}
+
 		val, err = conn.ZScore(ctx, key, value).Result()
 		return err
 	}, acceptable)
@@ -2849,7 +2904,7 @@ func withHook(hook red.Hook) Option {
 }
 
 func acceptable(err error) bool {
-	return err == nil || err == red.Nil || err == context.Canceled
+	return err == nil || errors.Is(err, red.Nil) || errors.Is(err, context.Canceled)
 }
 
 func getRedis(r *Redis) (RedisNode, error) {

core/stores/redis/redisblockingnode.go

@@ -3,7 +3,7 @@ package redis
 import (
 	"fmt"
 
-	red "github.com/go-redis/redis/v8"
+	red "github.com/redis/go-redis/v9"
 	"github.com/zeromicro/go-zero/core/logx"
 )
 

core/stores/redis/redisclientmanager.go

@@ -3,8 +3,9 @@ package redis
 import (
 	"crypto/tls"
 	"io"
+	"runtime"
 
-	red "github.com/go-redis/redis/v8"
+	red "github.com/redis/go-redis/v9"
 	"github.com/zeromicro/go-zero/core/syncx"
 )
 
@@ -14,7 +15,11 @@ const (
 	idleConns       = 8
 )
 
-var clientManager = syncx.NewResourceManager()
+var (
+	clientManager = syncx.NewResourceManager()
+	// nodePoolSize is default pool size for node type of redis.
+	nodePoolSize = 10 * runtime.GOMAXPROCS(0)
+)
 
 func getClient(r *Redis) (*red.Client, error) {
 	val, err := clientManager.GetResource(r.Addr, func() (io.Closer, error) {
@@ -37,6 +42,15 @@ func getClient(r *Redis) (*red.Client, error) {
 			store.AddHook(hook)
 		}
 
+		connCollector.registerClient(&statGetter{
+			clientType: NodeType,
+			key:        r.Addr,
+			poolSize:   nodePoolSize,
+			poolStats: func() *red.PoolStats {
+				return store.PoolStats()
+			},
+		})
+
 		return store, nil
 	})
 	if err != nil {

core/stores/redis/redisclustermanager.go

@@ -3,15 +3,20 @@ package redis
 import (
 	"crypto/tls"
 	"io"
+	"runtime"
 	"strings"
 
-	red "github.com/go-redis/redis/v8"
+	red "github.com/redis/go-redis/v9"
 	"github.com/zeromicro/go-zero/core/syncx"
 )
 
 const addrSep = ","
 
-var clusterManager = syncx.NewResourceManager()
+var (
+	clusterManager = syncx.NewResourceManager()
+	// clusterPoolSize is default pool size for cluster type of redis.
+	clusterPoolSize = 5 * runtime.GOMAXPROCS(0)
+)
 
 func getCluster(r *Redis) (*red.ClusterClient, error) {
 	val, err := clusterManager.GetResource(r.Addr, func() (io.Closer, error) {
@@ -33,6 +38,15 @@ func getCluster(r *Redis) (*red.ClusterClient, error) {
 			store.AddHook(hook)
 		}
 
+		connCollector.registerClient(&statGetter{
+			clientType: ClusterType,
+			key:        r.Addr,
+			poolSize:   clusterPoolSize,
+			poolStats: func() *red.PoolStats {
+				return store.PoolStats()
+			},
+		})
+
 		return store, nil
 	})
 	if err != nil {

core/stores/redis/redisclustermanager_test.go

@@ -3,6 +3,8 @@ package redis
 import (
 	"testing"
 
+	"github.com/alicebob/miniredis/v2"
+	red "github.com/redis/go-redis/v9"
 	"github.com/stretchr/testify/assert"
 )
 
@@ -41,3 +43,17 @@ func TestSplitClusterAddrs(t *testing.T) {
 		})
 	}
 }
+
+func TestGetCluster(t *testing.T) {
+	r := miniredis.RunT(t)
+	defer r.Close()
+	c, err := getCluster(&Redis{
+		Addr:  r.Addr(),
+		Type:  ClusterType,
+		tls:   true,
+		hooks: []red.Hook{durationHook},
+	})
+	if assert.NoError(t, err) {
+		assert.NotNil(t, c)
+	}
+}