Merge bf3ab6608cb91028f0b350f410661d040e4af65e into 81dba468722f41347ed74ee66e9c1781d72f68a5

Bumps [github.com/go-playground/validator/v10](https://github.com/go-playground/validator) from 10.28.0 to 10.30.1.
- [Release notes](https://github.com/go-playground/validator/releases)
- [Commits](https://github.com/go-playground/validator/compare/v10.28.0...v10.30.1)

---
updated-dependencies:
- dependency-name: github.com/go-playground/validator/v10
  dependency-version: 10.30.1
  dependency-type: direct:production
  update-type: version-update:semver-minor
...

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

.github/workflows/gin.yml

@@ -26,14 +26,14 @@ jobs:
       - name: Setup golangci-lint
         uses: golangci/golangci-lint-action@v9
         with:
-          version: v2.6
+          version: v2.9
           args: --verbose
   test:
     needs: lint
     strategy:
       matrix:
         os: [ubuntu-latest, macos-latest]
-        go: ["1.24", "1.25"]
+        go: ["1.24", "1.25", "1.26"]
         test-tags:
           [
             "",

.github/workflows/trivy-scan.yml

@@ -9,7 +9,7 @@ on:
       - master
   schedule:
     # Run daily at 00:00 UTC
-    - cron: '0 0 * * *'
+    - cron: "0 0 * * *"
   workflow_dispatch: # Allow manual trigger
 
 permissions:
@@ -27,30 +27,30 @@ jobs:
           fetch-depth: 0
 
       - name: Run Trivy vulnerability scanner (source code)
-        uses: aquasecurity/trivy-action@0.34.0
+        uses: aquasecurity/trivy-action@0.34.1
         with:
-          scan-type: 'fs'
-          scan-ref: '.'
-          scanners: 'vuln,secret,misconfig'
-          format: 'sarif'
-          output: 'trivy-results.sarif'
-          severity: 'CRITICAL,HIGH,MEDIUM'
+          scan-type: "fs"
+          scan-ref: "."
+          scanners: "vuln,secret,misconfig"
+          format: "sarif"
+          output: "trivy-results.sarif"
+          severity: "CRITICAL,HIGH,MEDIUM"
           ignore-unfixed: true
 
       - name: Upload Trivy results to GitHub Security tab
         uses: github/codeql-action/upload-sarif@v4
         if: always()
         with:
-          sarif_file: 'trivy-results.sarif'
+          sarif_file: "trivy-results.sarif"
 
       - name: Run Trivy scanner (table output for logs)
-        uses: aquasecurity/trivy-action@0.34.0
+        uses: aquasecurity/trivy-action@0.34.1
         if: always()
         with:
-          scan-type: 'fs'
-          scan-ref: '.'
-          scanners: 'vuln,secret,misconfig'
-          format: 'table'
-          severity: 'CRITICAL,HIGH,MEDIUM'
+          scan-type: "fs"
+          scan-ref: "."
+          scanners: "vuln,secret,misconfig"
+          format: "table"
+          severity: "CRITICAL,HIGH,MEDIUM"
           ignore-unfixed: true
-          exit-code: '1'
+          exit-code: "1"

context.go

@@ -10,7 +10,6 @@ import (
 	"io"
 	"io/fs"
 	"log"
-	"maps"
 	"math"
 	"mime/multipart"
 	"net"
@@ -56,6 +55,42 @@ const ContextRequestKey ContextKeyType = 0
 // abortIndex represents a typical value used in abort functions.
 const abortIndex int8 = math.MaxInt8 >> 1
 
+// ContextKeys is a thread-safe key-value store wrapper around sync.Map
+// that provides compatibility with existing map[any]any API expectations
+type ContextKeys struct {
+	m sync.Map
+}
+
+// Store stores a value in the context keys
+func (ck *ContextKeys) Store(key, value any) {
+	ck.m.Store(key, value)
+}
+
+// Load retrieves a value from the context keys
+func (ck *ContextKeys) Load(key any) (value any, exists bool) {
+	return ck.m.Load(key)
+}
+
+// Delete removes a value from the context keys
+func (ck *ContextKeys) Delete(key any) {
+	ck.m.Delete(key)
+}
+
+// Range iterates over all key-value pairs in the context keys
+func (ck *ContextKeys) Range(f func(key, value any) bool) {
+	ck.m.Range(f)
+}
+
+// IsEmpty returns true if the context keys contain no values
+func (ck *ContextKeys) IsEmpty() bool {
+	empty := true
+	ck.m.Range(func(key, value any) bool {
+		empty = false
+		return false // Stop iteration on first item
+	})
+	return empty
+}
+
 // Context is the most important part of gin. It allows us to pass variables between middleware,
 // manage the flow, validate the JSON of a request and render a JSON response for example.
 type Context struct {
@@ -72,11 +107,9 @@ type Context struct {
 	params       *Params
 	skippedNodes *[]skippedNode
 
-	// This mutex protects Keys map.
-	mu sync.RWMutex
-
 	// Keys is a key/value pair exclusively for the context of each request.
-	Keys map[any]any
+	// Using ContextKeys wrapper around sync.Map for better concurrent performance.
+	Keys *ContextKeys
 
 	// Errors is a list of errors attached to all the handlers/middlewares who used this context.
 	Errors errorMsgs
@@ -107,7 +140,7 @@ func (c *Context) reset() {
 	c.index = -1
 
 	c.fullPath = ""
-	c.Keys = nil
+	c.Keys = nil  // Reset to nil for backward compatibility
 	c.Errors = c.Errors[:0]
 	c.Accepted = nil
 	c.queryCache = nil
@@ -132,10 +165,14 @@ func (c *Context) Copy() *Context {
 	cp.handlers = nil
 	cp.fullPath = c.fullPath
 
-	cKeys := c.Keys
-	c.mu.RLock()
-	cp.Keys = maps.Clone(cKeys)
-	c.mu.RUnlock()
+	// Copy ContextKeys contents if they exist
+	if c.Keys != nil {
+		cp.Keys = &ContextKeys{}
+		c.Keys.Range(func(key, value any) bool {
+			cp.Keys.Store(key, value)
+			return true
+		})
+	}
 
 	cParams := c.Params
 	cp.Params = make([]Param, len(cParams))
@@ -272,24 +309,22 @@ func (c *Context) Error(err error) *Error {
 /************************************/
 
 // Set is used to store a new key/value pair exclusively for this context.
-// It also lazy initializes c.Keys if it was not used previously.
+// Uses ContextKeys wrapper around sync.Map for better concurrent performance.
 func (c *Context) Set(key any, value any) {
-	c.mu.Lock()
-	defer c.mu.Unlock()
 	if c.Keys == nil {
-		c.Keys = make(map[any]any)
+		c.Keys = &ContextKeys{}
 	}
-
-	c.Keys[key] = value
+	c.Keys.Store(key, value)
 }
 
 // Get returns the value for the given key, ie: (value, true).
 // If the value does not exist it returns (nil, false)
+// Uses ContextKeys wrapper around sync.Map for better concurrent performance.
 func (c *Context) Get(key any) (value any, exists bool) {
-	c.mu.RLock()
-	defer c.mu.RUnlock()
-	value, exists = c.Keys[key]
-	return
+	if c.Keys == nil {
+		return nil, false
+	}
+	return c.Keys.Load(key)
 }
 
 // MustGet returns the value for the given key if it exists, otherwise it panics.
@@ -479,14 +514,27 @@ func (c *Context) GetStringMapStringSlice(key any) map[string][]string {
 
 // Delete deletes the key from the Context's Key map, if it exists.
 // This operation is safe to be used by concurrent go-routines
+// Uses ContextKeys wrapper around sync.Map for better concurrent performance.
 func (c *Context) Delete(key any) {
-	c.mu.Lock()
-	defer c.mu.Unlock()
 	if c.Keys != nil {
-		delete(c.Keys, key)
+		c.Keys.Delete(key)
 	}
 }
 
+// GetKeysAsMap returns a copy of the context keys as a regular map[any]any.
+// This is useful for compatibility with existing APIs that expect regular maps.
+// Note: This creates a snapshot of the keys at the time of calling.
+func (c *Context) GetKeysAsMap() map[any]any {
+	result := make(map[any]any)
+	if c.Keys != nil {
+		c.Keys.Range(func(key, value any) bool {
+			result[key] = value
+			return true
+		})
+	}
+	return result
+}
+
 /************************************/
 /************ INPUT DATA ************/
 /************************************/

context_test.go

@@ -684,7 +684,9 @@ func TestContextCopy(t *testing.T) {
 	assert.Equal(t, cp.engine, c.engine)
 	assert.Equal(t, cp.Params, c.Params)
 	cp.Set("foo", "notBar")
-	assert.NotEqual(t, cp.Keys["foo"], c.Keys["foo"])
+	cpFooValue, _ := cp.Get("foo")
+	cFooValue, _ := c.Get("foo")
+	assert.NotEqual(t, cpFooValue, cFooValue)
 	assert.Equal(t, cp.fullPath, c.fullPath)
 }
 

go.mod

@@ -7,7 +7,7 @@ toolchain go1.24.7
 require (
 	github.com/bytedance/sonic v1.15.0
 	github.com/gin-contrib/sse v1.1.0
-	github.com/go-playground/validator/v10 v10.28.0
+	github.com/go-playground/validator/v10 v10.30.1
 	github.com/goccy/go-json v0.10.5
 	github.com/goccy/go-yaml v1.19.2
 	github.com/json-iterator/go v1.1.12
@@ -29,7 +29,7 @@ require (
 	github.com/bytedance/sonic/loader v0.5.0 // indirect
 	github.com/cloudwego/base64x v0.1.6 // indirect
 	github.com/davecgh/go-spew v1.1.1 // indirect
-	github.com/gabriel-vasile/mimetype v1.4.10 // indirect
+	github.com/gabriel-vasile/mimetype v1.4.12 // indirect
 	github.com/go-playground/locales v0.14.1 // indirect
 	github.com/go-playground/universal-translator v0.18.1 // indirect
 	github.com/klauspost/cpuid/v2 v2.3.0 // indirect

go.sum

@@ -10,8 +10,8 @@ github.com/creack/pty v1.1.9/go.mod h1:oKZEueFk5CKHvIhNR5MUki03XCEU+Q6VDXinZuGJ3
 github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
-github.com/gabriel-vasile/mimetype v1.4.10 h1:zyueNbySn/z8mJZHLt6IPw0KoZsiQNszIpU+bX4+ZK0=
-github.com/gabriel-vasile/mimetype v1.4.10/go.mod h1:d+9Oxyo1wTzWdyVUPMmXFvp4F9tea18J8ufA774AB3s=
+github.com/gabriel-vasile/mimetype v1.4.12 h1:e9hWvmLYvtp846tLHam2o++qitpguFiYCKbn0w9jyqw=
+github.com/gabriel-vasile/mimetype v1.4.12/go.mod h1:d+9Oxyo1wTzWdyVUPMmXFvp4F9tea18J8ufA774AB3s=
 github.com/gin-contrib/sse v1.1.0 h1:n0w2GMuUpWDVp7qSpvze6fAu9iRxJY4Hmj6AmBOU05w=
 github.com/gin-contrib/sse v1.1.0/go.mod h1:hxRZ5gVpWMT7Z0B0gSNYqqsSCNIJMjzvm6fqCz9vjwM=
 github.com/go-playground/assert/v2 v2.2.0 h1:JvknZsQTYeFEAhQwI4qEt9cyV5ONwRHC+lYKSsYSR8s=
@@ -20,8 +20,8 @@ github.com/go-playground/locales v0.14.1 h1:EWaQ/wswjilfKLTECiXz7Rh+3BjFhfDFKv/o
 github.com/go-playground/locales v0.14.1/go.mod h1:hxrqLVvrK65+Rwrd5Fc6F2O76J/NuW9t0sjnWqG1slY=
 github.com/go-playground/universal-translator v0.18.1 h1:Bcnm0ZwsGyWbCzImXv+pAJnYK9S473LQFuzCbDbfSFY=
 github.com/go-playground/universal-translator v0.18.1/go.mod h1:xekY+UJKNuX9WP91TpwSH2VMlDf28Uj24BCp08ZFTUY=
-github.com/go-playground/validator/v10 v10.28.0 h1:Q7ibns33JjyW48gHkuFT91qX48KG0ktULL6FgHdG688=
-github.com/go-playground/validator/v10 v10.28.0/go.mod h1:GoI6I1SjPBh9p7ykNE/yj3fFYbyDOpwMn5KXd+m2hUU=
+github.com/go-playground/validator/v10 v10.30.1 h1:f3zDSN/zOma+w6+1Wswgd9fLkdwy06ntQJp0BBvFG0w=
+github.com/go-playground/validator/v10 v10.30.1/go.mod h1:oSuBIQzuJxL//3MelwSLD5hc2Tu889bF0Idm9Dg26cM=
 github.com/goccy/go-json v0.10.5 h1:Fq85nIqj+gXn/S5ahsiTlK3TmC85qgirsdTP/+DeaC4=
 github.com/goccy/go-json v0.10.5/go.mod h1:oq7eo15ShAhp70Anwd5lgX2pLfOS3QCiwU/PULtXL6M=
 github.com/goccy/go-yaml v1.19.2 h1:PmFC1S6h8ljIz6gMRBopkjP1TVT7xuwrButHID66PoM=

logger.go

@@ -284,7 +284,7 @@ func LoggerWithConfig(conf LoggerConfig) HandlerFunc {
 		param := LogFormatterParams{
 			Request: c.Request,
 			isTerm:  isTerm,
-			Keys:    c.Keys,
+			Keys:    c.GetKeysAsMap(),
 		}
 
 		// Stop timer

logger_test.go

@@ -207,7 +207,7 @@ func TestLoggerWithConfigFormatting(t *testing.T) {
 	router.GET("/example", func(c *Context) {
 		// set dummy ClientIP
 		c.Request.Header.Set("X-Forwarded-For", "20.20.20.20")
-		gotKeys = c.Keys
+		gotKeys = c.GetKeysAsMap()
 		time.Sleep(time.Millisecond)
 	})
 	PerformRequest(router, http.MethodGet, "/example?a=100")

tree.go

@@ -9,6 +9,7 @@ import (
 	"strings"
 	"unicode"
 	"unicode/utf8"
+	"unsafe"
 
 	"github.com/gin-gonic/gin/internal/bytesconv"
 )
@@ -59,11 +60,30 @@ func (trees methodTrees) get(method string) *node {
 }
 
 func longestCommonPrefix(a, b string) int {
+	// Use unsafe operations for better performance in this hot path
+	aBytes := ([]byte)(a)
+	bBytes := ([]byte)(b)
+
+	minLen := min(len(aBytes), len(bBytes))
+
+	// Use word-sized comparison for better performance on 64-bit systems
+	// Compare 8 bytes at a time when possible
+	wordSize := 8
 	i := 0
-	max_ := min(len(a), len(b))
-	for i < max_ && a[i] == b[i] {
+
+	// Word-by-word comparison for better performance
+	for i+wordSize <= minLen {
+		if *(*uint64)(unsafe.Pointer(&aBytes[i])) != *(*uint64)(unsafe.Pointer(&bBytes[i])) {
+			break
+		}
+		i += wordSize
+	}
+
+	// Byte-by-byte comparison for the remainder
+	for i < minLen && aBytes[i] == bBytes[i] {
 		i++
 	}
+
 	return i
 }
 
@@ -421,13 +441,18 @@ func (n *node) getValue(path string, params *Params, skippedNodes *[]skippedNode
 walk: // Outer loop for walking the tree
 	for {
 		prefix := n.path
-		if len(path) > len(prefix) {
-			if path[:len(prefix)] == prefix {
-				path = path[len(prefix):]
+		prefixLen := len(prefix)
+		if len(path) > prefixLen {
+			// Use bytes comparison for better performance
+			pathBytes := ([]byte)(path)
+			if string(pathBytes[:prefixLen]) == prefix {
+				path = path[prefixLen:]
 
 				// Try all the non-wildcard children first by matching the indices
-				idxc := path[0]
-				for i, c := range []byte(n.indices) {
+				pathBytes = ([]byte)(path)  // Update pathBytes after path change
+				idxc := pathBytes[0]
+				indicesBytes := ([]byte)(n.indices)
+				for i, c := range indicesBytes {
 					if c == idxc {
 						//  strings.HasPrefix(n.children[len(n.children)-1].path, ":") == n.wildChild
 						if n.wildChild {
@@ -460,7 +485,11 @@ walk: // Outer loop for walking the tree
 						for length := len(*skippedNodes); length > 0; length-- {
 							skippedNode := (*skippedNodes)[length-1]
 							*skippedNodes = (*skippedNodes)[:length-1]
-							if strings.HasSuffix(skippedNode.path, path) {
+							// Use more efficient suffix check
+							skippedPathBytes := ([]byte)(skippedNode.path)
+							pathBytes := ([]byte)(path)
+							if len(skippedPathBytes) >= len(pathBytes) &&
+							   string(skippedPathBytes[len(skippedPathBytes)-len(pathBytes):]) == path {
 								path = skippedNode.path
 								n = skippedNode.node
 								if value.params != nil {
@@ -489,8 +518,10 @@ walk: // Outer loop for walking the tree
 					// tree_test.go  line: 204
 
 					// Find param end (either '/' or path end)
+					// Use bytes operations for better performance
+					pathBytes := ([]byte)(path)
 					end := 0
-					for end < len(path) && path[end] != '/' {
+					for end < len(pathBytes) && pathBytes[end] != '/' {
 						end++
 					}
 
@@ -509,14 +540,17 @@ walk: // Outer loop for walking the tree
 						// Expand slice within preallocated capacity
 						i := len(*value.params)
 						*value.params = (*value.params)[:i+1]
+
+						// Use bytes slicing to avoid string allocation
 						val := path[:end]
-						if unescape {
+						if unescape && end > 0 {
+							// Only unescape if there are actually characters to unescape
 							if v, err := url.QueryUnescape(val); err == nil {
 								val = v
 							}
 						}
 						(*value.params)[i] = Param{
-							Key:   n.path[1:],
+							Key:   n.path[1:],  // Skip the ':' character
 							Value: val,
 						}
 					}
@@ -562,14 +596,16 @@ walk: // Outer loop for walking the tree
 						// Expand slice within preallocated capacity
 						i := len(*value.params)
 						*value.params = (*value.params)[:i+1]
+
 						val := path
-						if unescape {
+						if unescape && len(path) > 0 {
+							// Only attempt unescape if path is not empty
 							if v, err := url.QueryUnescape(path); err == nil {
 								val = v
 							}
 						}
 						(*value.params)[i] = Param{
-							Key:   n.path[2:],
+							Key:   n.path[2:],  // Skip the '*'
 							Value: val,
 						}
 					}
@@ -591,7 +627,11 @@ walk: // Outer loop for walking the tree
 				for length := len(*skippedNodes); length > 0; length-- {
 					skippedNode := (*skippedNodes)[length-1]
 					*skippedNodes = (*skippedNodes)[:length-1]
-					if strings.HasSuffix(skippedNode.path, path) {
+					// Use more efficient suffix check
+					skippedPathBytes := ([]byte)(skippedNode.path)
+					pathBytes := ([]byte)(path)
+					if len(skippedPathBytes) >= len(pathBytes) &&
+					   string(skippedPathBytes[len(skippedPathBytes)-len(pathBytes):]) == path {
 						path = skippedNode.path
 						n = skippedNode.node
 						if value.params != nil {
@@ -648,7 +688,11 @@ walk: // Outer loop for walking the tree
 			for length := len(*skippedNodes); length > 0; length-- {
 				skippedNode := (*skippedNodes)[length-1]
 				*skippedNodes = (*skippedNodes)[:length-1]
-				if strings.HasSuffix(skippedNode.path, path) {
+				// Use more efficient suffix check
+				skippedPathBytes := ([]byte)(skippedNode.path)
+				pathBytes := ([]byte)(path)
+				if len(skippedPathBytes) >= len(pathBytes) &&
+				   string(skippedPathBytes[len(skippedPathBytes)-len(pathBytes):]) == path {
 					path = skippedNode.path
 					n = skippedNode.node
 					if value.params != nil {