Skip to content

O
opkg
提交 d57375cc authored 作者: mooncake's avatar mooncake
浏览文件
操作

update

上级 54ae8fdb
隐藏空白字符变更
内嵌 并排
正在显示 包含 5803 行增加 和 19 行删除
gin/middleware/auth.go 0 → 100644
浏览文件 @ d57375cc
package middleware
import (
"github.com/gin-gonic/gin"
"gitlab.wanzhuangkj.com/tush/opkg/gin/response"
"gitlab.wanzhuangkj.com/tush/opkg/pkg/errcode"
"gitlab.wanzhuangkj.com/tush/opkg/pkg/jwt"
"gitlab.wanzhuangkj.com/tush/opkg/pkg/logger"
"gitlab.wanzhuangkj.com/tush/opkg/pkg/sf"
ctxutils "gitlab.wanzhuangkj.com/tush/opkg/xutils/ctxutils"
)
const (
// HeaderAuthorizationKey http header authorization key
HeaderAuthorizationKey = "Authorization"
)
type jwtOptions struct {
isSwitchHTTPCode bool
verify VerifyFn // verify function, only use in Auth
}
// JwtOption set the jwt options.
type JwtOption func(*jwtOptions)
func (o *jwtOptions) apply(opts ...JwtOption) {
for _, opt := range opts {
opt(o)
}
}
func defaultJwtOptions() *jwtOptions {
return &jwtOptions{
isSwitchHTTPCode: false,
verify: nil,
}
}
// WithSwitchHTTPCode switch to http code
func WithSwitchHTTPCode() JwtOption {
return func(o *jwtOptions) {
o.isSwitchHTTPCode = true
}
}
// WithVerify set verify function
func WithVerify(verify VerifyFn) JwtOption {
return func(o *jwtOptions) {
o.verify = verify
}
}
func responseUnauthorized(c *gin.Context, isSwitchHTTPCode bool) {
if isSwitchHTTPCode {
response.Out(c, errcode.Unauthorized)
} else {
response.ErrorE(c, errcode.Unauthorized)
}
}
// -------------------------------------------------------------------------------------------
// VerifyFn verify function, tokenTail10 is the last 10 characters of the token.
type VerifyFn func(claims *jwt.Claims, tokenTail10 string, c *gin.Context) error
// Auth authorization
func Auth(opts ...JwtOption) gin.HandlerFunc {
o := defaultJwtOptions()
o.apply(opts...)
return func(c *gin.Context) {
authorization := c.GetHeader(HeaderAuthorizationKey)
if authorization == "" || len(authorization) < 10 {
responseUnauthorized(c, o.isSwitchHTTPCode)
c.Abort()
return
}
token := authorization[7:] // remove Bearer prefix
claims, err := jwt.ParseToken(token)
if err != nil {
logger.Error("parseToken error", logger.Err(err), ctxutils.GinTraceIDField(c))
responseUnauthorized(c, o.isSwitchHTTPCode)
c.Abort()
return
}
if o.verify != nil {
tokenTail10 := token[len(token)-10:]
if err = o.verify(claims, tokenTail10, c); err != nil {
logger.Error("verify token error", logger.Err(err), logger.Any("claims", claims), ctxutils.GinTraceIDField(c))
responseUnauthorized(c, o.isSwitchHTTPCode)
c.Abort()
return
}
} else {
xsfID, _ := sf.ParseString(claims.UID)
c.Set(ctxutils.KeyUID, xsfID)
c.Set(ctxutils.KeyUName, claims.Name)
}
c.Next()
}
}
func URLFields() gin.HandlerFunc {
return func(c *gin.Context) {
params := c.Request.URL.Query()
for key, values := range params {
if len(values) > 0 {
c.Set(key, values[0])
}
}
}
}
type KV = map[string]interface{}
func HeaderFields(keys []string) gin.HandlerFunc {
return func(c *gin.Context) {
kv := KV{}
for _, key := range keys {
c.Set(key, c.Request.Header.Get(key))
kv[key] = c.Request.Header.Get(key)
}
logger.Info("[middleware][headerFields]header kvs", logger.Any("kv", kv), ctxutils.GinTraceIDField(c))
}
}
// -------------------------------------------------------------------------------------------
// VerifyCustomFn verify custom function, tokenTail10 is the last 10 characters of the token.
type VerifyCustomFn func(claims *jwt.CustomClaims, tokenTail10 string, c *gin.Context) error
// AuthCustom custom authentication
func AuthCustom(verify VerifyCustomFn, opts ...JwtOption) gin.HandlerFunc {
o := defaultJwtOptions()
o.apply(opts...)
return func(c *gin.Context) {
authorization := c.GetHeader(HeaderAuthorizationKey)
if authorization == "" || len(authorization) < 10 {
responseUnauthorized(c, o.isSwitchHTTPCode)
c.Abort()
return
}
token := authorization[7:] // remove Bearer prefix
claims, err := jwt.ParseCustomToken(token)
if err != nil {
logger.Error("parseToken error", logger.Err(err), ctxutils.GinTraceIDField(c))
responseUnauthorized(c, o.isSwitchHTTPCode)
c.Abort()
return
}
tokenTail10 := token[len(token)-10:]
if err = verify(claims, tokenTail10, c); err != nil {
logger.Error("verify token error", logger.Err(err), logger.Any("fields", claims.Fields), ctxutils.GinTraceIDField(c))
responseUnauthorized(c, o.isSwitchHTTPCode)
c.Abort()
return
}
c.Next()
}
}
gin/middleware/breaker.go 0 → 100644
浏览文件 @ d57375cc
package middleware
import (
"net/http"
"github.com/gin-gonic/gin"
"gitlab.wanzhuangkj.com/tush/opkg/gin/response"
"gitlab.wanzhuangkj.com/tush/opkg/pkg/container/group"
"gitlab.wanzhuangkj.com/tush/opkg/pkg/shield/circuitbreaker"
)
// ErrNotAllowed error not allowed.
var ErrNotAllowed = circuitbreaker.ErrNotAllowed
// CircuitBreakerOption set the circuit breaker circuitBreakerOptions.
type CircuitBreakerOption func(*circuitBreakerOptions)
type circuitBreakerOptions struct {
group *group.Group
// http code for circuit breaker, default already includes 500 and 503
validCodes map[int]struct{}
// degrade func
degradeHandler func(c *gin.Context)
}
func defaultCircuitBreakerOptions() *circuitBreakerOptions {
return &circuitBreakerOptions{
group: group.NewGroup(func() interface{} {
return circuitbreaker.NewBreaker()
}),
validCodes: map[int]struct{}{
http.StatusInternalServerError: {},
http.StatusServiceUnavailable: {},
},
}
}
func (o *circuitBreakerOptions) apply(opts ...CircuitBreakerOption) {
for _, opt := range opts {
opt(o)
}
}
// WithGroup with circuit breaker group.
// NOTE: implements generics circuitbreaker.CircuitBreaker
func WithGroup(g *group.Group) CircuitBreakerOption {
return func(o *circuitBreakerOptions) {
if g != nil {
o.group = g
}
}
}
// WithValidCode http code to mark failed
func WithValidCode(code ...int) CircuitBreakerOption {
return func(o *circuitBreakerOptions) {
for _, c := range code {
o.validCodes[c] = struct{}{}
}
}
}
// WithDegradeHandler set degrade handler function
func WithDegradeHandler(handler func(c *gin.Context)) CircuitBreakerOption {
return func(o *circuitBreakerOptions) {
o.degradeHandler = handler
}
}
// CircuitBreaker a circuit breaker middleware
func CircuitBreaker(opts ...CircuitBreakerOption) gin.HandlerFunc {
o := defaultCircuitBreakerOptions()
o.apply(opts...)
return func(c *gin.Context) {
breaker := o.group.Get(c.FullPath()).(circuitbreaker.CircuitBreaker)
if err := breaker.Allow(); err != nil {
// NOTE: when client reject request locally, keep adding counter let the drop ratio higher.
breaker.MarkFailed()
if o.degradeHandler != nil {
o.degradeHandler(c)
} else {
response.Output(c, http.StatusServiceUnavailable, err.Error())
}
c.Abort()
return
}
c.Next()
code := c.Writer.Status()
// NOTE: need to check internal and service unavailable error
_, isHit := o.validCodes[code]
if isHit {
breaker.MarkFailed()
} else {
breaker.MarkSuccess()
}
}
}
gin/middleware/cors.go 0 → 100644
浏览文件 @ d57375cc
package middleware
import (
"time"
"github.com/gin-contrib/cors"
"github.com/gin-gonic/gin"
)
type corsOptions struct {
allowOrigins []string
}
type CorsOption func(*corsOptions)
func defaultCorsOptions() *corsOptions {
return &corsOptions{
allowOrigins: []string{"*"},
}
}
func (o *corsOptions) apply(opts ...CorsOption) {
for _, opt := range opts {
opt(o)
}
}
func WithCorsOption(allowOrigins []string) CorsOption {
return func(o *corsOptions) {
o.allowOrigins = allowOrigins
}
}
// Cors cross domain
func Cors(opts ...CorsOption) gin.HandlerFunc {
o := defaultCorsOptions()
o.apply(opts...)
return cors.New(
cors.Config{
AllowOrigins: o.allowOrigins,
AllowMethods: []string{"GET", "POST", "PUT", "DELETE", "PATCH", "OPTIONS"},
AllowHeaders: []string{"Origin", "Authorization", "Content-Type", "Accept"},
ExposeHeaders: []string{"Content-Length", "text/plain", "Authorization", "Content-Type"},
AllowCredentials: true,
MaxAge: 12 * time.Hour,
},
)
}
// func CorsQT() gin.HandlerFunc {
// return cors.New(
// cors.Config{
// AllowOrigins: []string{"http://wanzhuangkj.com", "https://wanzhuangkj.com", "http://hzqitu.com", "https://hzqitu.com"},
// AllowMethods: []string{"GET", "POST", "PUT", "DELETE", "PATCH", "OPTIONS"},
// AllowHeaders: []string{"Origin", "Authorization", "Content-Type", "Accept"},
// ExposeHeaders: []string{"Content-Length", "text/plain", "Authorization", "Content-Type"},
// AllowCredentials: true,
// MaxAge: 12 * time.Hour,
// },
// )
// }
gin/middleware/logging.go 0 → 100644
浏览文件 @ d57375cc
package middleware
import (
"bytes"
"io"
"net/http"
"strings"
"time"
"gitlab.wanzhuangkj.com/tush/opkg/pkg/httpcli/entity"
ctxutils "gitlab.wanzhuangkj.com/tush/opkg/xutils/ctxutils"
"gitlab.wanzhuangkj.com/tush/opkg/pkg/ips"
"github.com/gin-gonic/gin"
"go.uber.org/zap"
)
var (
// Print body max length
defaultMaxLength = 300
defaultMediaMaxLength = 300
// default zap log
defaultLogger, _ = zap.NewProduction()
// Ignore route list
defaultIgnoreRoutes = map[string]struct{}{
"/ping": {},
"/pong": {},
"/health": {},
}
emptyBody = []byte("")
contentMark = []byte(" ...... ")
)
// Option set the gin logger options.
type Option func(*options)
func defaultOptions() *options {
return &options{
maxLength: defaultMaxLength,
mediaMaxLength: defaultMediaMaxLength,
log: defaultLogger,
ignoreRoutes: defaultIgnoreRoutes,
traceIDFrom: 0,
}
}
type options struct {
maxLength int
mediaMaxLength int
appName string
log *zap.Logger
ignoreRoutes map[string]struct{}
traceIDFrom int // 0: ignore, 1: from context, 2: from header
}
func (o *options) apply(opts ...Option) {
for _, opt := range opts {
opt(o)
}
}
// WithMaxLen logger content max length
func WithMaxLen(maxLen int) Option {
return func(o *options) {
if maxLen < len(contentMark) {
panic("maxLen should be greater than or equal to 8")
}
o.maxLength = maxLen
}
}
func WithMediaMaxLen(maxLen int) Option {
return func(o *options) {
if maxLen < len(contentMark) {
panic("mediaMaxLength should be greater than or equal to 8")
}
o.mediaMaxLength = maxLen
}
}
// WithLog set log
func WithLog(log *zap.Logger) Option {
return func(o *options) {
if log != nil {
o.log = log
}
}
}
func WithAppName(appName string) Option {
return func(o *options) {
o.appName = appName
}
}
// WithIgnoreRoutes no logger content routes
func WithIgnoreRoutes(routes ...string) Option {
return func(o *options) {
for _, route := range routes {
o.ignoreRoutes[route] = struct{}{}
}
}
}
// WithTraceIDFromContext name is field in context, default value is request_id
func WithTraceIDFromContext() Option {
return func(o *options) {
o.traceIDFrom = 1
}
}
// WithTraceIDFromHeader name is field in header, default value is X-Request-Id
func WithTraceIDFromHeader() Option {
return func(o *options) {
o.traceIDFrom = 2
}
}
// ------------------------------------------------------------------------------------------
type bodyLogWriter struct {
gin.ResponseWriter
body *bytes.Buffer
}
func (w bodyLogWriter) Write(b []byte) (int, error) {
w.body.Write(b)
return w.ResponseWriter.Write(b)
}
// If there is sensitive information in the body, you can use WithIgnoreRoutes set the route to ignore logging
func getResponseBody(buf *bytes.Buffer, maxLen int) []byte {
l := buf.Len()
if l == 0 {
return []byte("")
} else if l > maxLen {
l = maxLen
}
body := make([]byte, l)
n, _ := buf.Read(body)
if n == 0 {
return emptyBody
} else if n < maxLen {
if isLastByteNewline(body) {
return body[:n-1]
}
return body[:n]
}
return append(body[:maxLen-len(contentMark)], contentMark...)
}
func isLastByteNewline(data []byte) bool {
if len(data) == 0 {
return false
}
return data[len(data)-1] == '\n'
}
// If there is sensitive information in the body, you can use WithIgnoreRoutes set the route to ignore logging
func getRequestBody(buf *bytes.Buffer, maxLen int) []byte {
l := buf.Len()
if l == 0 {
return []byte("")
} else if l < maxLen {
return buf.Bytes()
}
body := make([]byte, maxLen)
copy(body, buf.Bytes())
return append(body[:maxLen-len(contentMark)], contentMark...)
}
// Logging print request and response info
func Logging(opts ...Option) gin.HandlerFunc {
o := defaultOptions()
o.apply(opts...)
return func(c *gin.Context) {
start := time.Now()
// ignore printing of the specified route
if _, ok := o.ignoreRoutes[c.Request.URL.Path]; ok {
c.Next()
return
}
// print input information before processing
buf := &bytes.Buffer{}
_, _ = buf.ReadFrom(c.Request.Body)
fields := []zap.Field{
zap.String("method", c.Request.Method),
zap.String("url", c.Request.URL.String()),
zap.Any("headers", c.Request.Header),
}
if c.Request.Method == http.MethodPost || c.Request.Method == http.MethodPut || c.Request.Method == http.MethodPatch || c.Request.Method == http.MethodDelete {
fields = append(fields,
zap.Int("size", buf.Len()),
zap.ByteString("body", getRequestBody(buf, o.maxLength)),
)
}
entity.SetCopyReq(c, buf)
c.Set(ctxutils.KeyAppName, o.appName)
reqID := ""
if o.traceIDFrom == 1 {
if v, isExist := c.Get(ctxutils.ContextTraceIDKey); isExist {
if requestID, ok := v.(string); ok {
reqID = requestID
fields = append(fields, zap.String(ctxutils.ContextTraceIDKey, reqID))
}
}
} else if o.traceIDFrom == 2 {
reqID = c.Request.Header.Get(ctxutils.HeaderXRequestIDKey)
fields = append(fields, zap.String(ctxutils.ContextTraceIDKey, reqID))
}
o.log.Info("[middleware][logging]<<<<<<<<<req", fields...)
c.Request.Body = io.NopCloser(buf)
//replace writer
newWriter := &bodyLogWriter{body: &bytes.Buffer{}, ResponseWriter: c.Writer}
c.Writer = newWriter
ip := ips.GetClientIP(c)
c.Set(ctxutils.KeyClientIP, ip)
// processing requests
c.Next()
rspBodyMax := c.GetInt(ctxutils.KeyRspBodyMax)
contentType := c.Writer.Header().Get("Content-Type")
isMedia := false
if strings.Contains(contentType, "image") {
isMedia = true
}
//print return message after processing
fields = []zap.Field{
zap.Int("code", c.Writer.Status()),
zap.String("cost", time.Since(start).String()),
zap.String("method", c.Request.Method),
zap.String("url", c.Request.URL.Path),
zap.String("client_ip", ip),
zap.Int("size", newWriter.body.Len()),
zap.Any("header", c.Writer.Header()),
}
if isMedia {
fields = append(fields, zap.ByteString("body", getResponseBody(newWriter.body, o.mediaMaxLength)))
} else {
if rspBodyMax > 0 {
fields = append(fields, zap.ByteString("body", getResponseBody(newWriter.body, rspBodyMax)))
} else {
fields = append(fields, zap.ByteString("body", getResponseBody(newWriter.body, o.maxLength)))
}
}
if reqID != "" {
fields = append(fields, zap.String(ctxutils.ContextTraceIDKey, reqID))
}
o.log.Info("[middleware][logging]>>>>>>>>>rsp", fields...)
}
}
// SimpleLog print response info
func SimpleLog(opts ...Option) gin.HandlerFunc {
o := defaultOptions()
o.apply(opts...)
return func(c *gin.Context) {
start := time.Now()
// ignore printing of the specified route
if _, ok := o.ignoreRoutes[c.Request.URL.Path]; ok {
c.Next()
return
}
reqID := ""
switch o.traceIDFrom {
case 1:
if v, isExist := c.Get(ctxutils.ContextTraceIDKey); isExist {
if requestID, ok := v.(string); ok {
reqID = requestID
}
}
case 2:
reqID = c.Request.Header.Get(ctxutils.HeaderXRequestIDKey)
}
// processing requests
c.Next()
// print return message after processing
fields := []zap.Field{
zap.Int("code", c.Writer.Status()),
zap.String("method", c.Request.Method),
zap.String("url", c.Request.URL.String()),
zap.String("cost", time.Since(start).String()),
zap.Int("size", c.Writer.Size()),
}
if reqID != "" {
fields = append(fields, zap.String(ctxutils.ContextTraceIDKey, reqID))
}
o.log.Info("[middleware][logging]]>>>>>>>>>rsp", fields...)
}
}
gin/middleware/metrics/gin_grafana.json 0 → 100644
浏览文件 @ d57375cc
{
"annotations": {
"list": [
{
"builtIn": 1,
"datasource": "-- Grafana --",
"enable": true,
"hide": true,
"iconColor": "rgba(0, 211, 255, 1)",
"name": "Annotations & Alerts",
"type": "dashboard"
}
]
},
"editable": true,
"gnetId": null,
"graphTooltip": 0,
"id": 26,
"iteration": 1670389325121,
"links": [],
"panels": [
{
"cacheTimeout": null,
"colorBackground": false,
"colorValue": true,
"colors": [
"#5794F2",
"#5794F2",
"#5794F2"
],
"datasource": "Prometheus",
"fieldConfig": {
"defaults": {
"custom": {}
},
"overrides": []
},
"format": "dateTimeAsSystem",
"gauge": {
"maxValue": 100,
"minValue": 0,
"show": false,
"thresholdLabels": false,
"thresholdMarkers": true
},
"gridPos": {
"h": 6,
"w": 6,
"x": 0,
"y": 0
},
"id": 14,
"interval": null,
"links": [],
"mappingType": 1,
"mappingTypes": [
{
"name": "value to text",
"value": 1
},
{
"name": "range to text",
"value": 2
}
],
"maxDataPoints": 100,
"nullPointMode": "connected",
"nullText": null,
"postfix": "",
"postfixFontSize": "50%",
"prefix": "",
"prefixFontSize": "50%",
"rangeMaps": [
{
"from": "null",
"text": "N/A",
"to": "null"
}
],
"sparkline": {
"fillColor": "rgba(31, 118, 189, 0.18)",
"full": false,
"lineColor": "rgb(31, 120, 193)",
"show": false
},
"tableColumn": "",
"targets": [
{
"expr": "(time() - 60*(gin_uptime{job=~\"$job\"})) * 1000",
"format": "time_series",
"interval": "",
"intervalFactor": 1,
"legendFormat": "",
"refId": "A"
}
],
"thresholds": "",
"timeFrom": null,
"timeShift": null,
"title": "Service last updated",
"type": "singlestat",
"valueFontSize": "110%",
"valueMaps": [
{
"op": "=",
"text": "N/A",
"value": "null"
}
],
"valueName": "current"
},
{
"aliasColors": {},
"bars": false,
"dashLength": 10,
"dashes": false,
"datasource": "Prometheus",
"decimals": null,
"fieldConfig": {
"defaults": {
"custom": {},
"links": []
},
"overrides": []
},
"fill": 1,
"fillGradient": 0,
"gridPos": {
"h": 12,
"w": 18,
"x": 6,
"y": 0
},
"hiddenSeries": false,
"id": 2,
"legend": {
"alignAsTable": true,
"avg": true,
"current": true,
"max": true,
"min": false,
"rightSide": false,
"show": true,
"total": false,
"values": true
},
"lines": true,
"linewidth": 2,
"links": [],
"nullPointMode": "null as zero",
"options": {
"alertThreshold": true
},
"percentage": false,
"pluginVersion": "7.4.3",
"pointradius": 2,
"points": false,
"renderer": "flot",
"seriesOverrides": [],
"spaceLength": 10,
"stack": false,
"steppedLine": false,
"targets": [
{
"expr": "rate(gin_http_request_count_total{job=~\"$job\", path=~\"$path\", method=~\"$method\", status=~\"$status\"}[$interval])",
"format": "time_series",
"interval": "",
"intervalFactor": 1,
"legendFormat": "{{ path }}-{{method}}-{{status}}",
"refId": "A"
}
],
"thresholds": [],
"timeFrom": null,
"timeRegions": [],
"timeShift": null,
"title": "Requests QPS",
"tooltip": {
"shared": true,
"sort": 0,
"value_type": "individual"
},
"type": "graph",
"xaxis": {
"buckets": null,
"mode": "time",
"name": null,
"show": true,
"values": []
},
"yaxes": [
{
"format": "short",
"label": null,
"logBase": 1,
"max": null,
"min": null,
"show": true
},
{
"format": "short",
"label": null,
"logBase": 1,
"max": null,
"min": null,
"show": true
}
],
"yaxis": {
"align": false,
"alignLevel": null
}
},
{
"cacheTimeout": null,
"colorBackground": false,
"colorValue": true,
"colors": [
"#299c46",
"#73BF69",
"#d44a3a"
],
"datasource": "Prometheus",
"fieldConfig": {
"defaults": {
"custom": {}
},
"overrides": []
},
"format": "m",
"gauge": {
"maxValue": 100,
"minValue": 0,
"show": false,
"thresholdLabels": false,
"thresholdMarkers": true
},
"gridPos": {
"h": 6,
"w": 6,
"x": 0,
"y": 6
},
"id": 12,
"interval": null,
"links": [],
"mappingType": 1,
"mappingTypes": [
{
"name": "value to text",
"value": 1
},
{
"name": "range to text",
"value": 2
}
],
"maxDataPoints": 100,
"nullPointMode": "connected",
"nullText": null,
"pluginVersion": "6.2.1",
"postfix": "",
"postfixFontSize": "50%",
"prefix": "",
"prefixFontSize": "50%",
"rangeMaps": [
{
"from": "null",
"text": "N/A",
"to": "null"
}
],
"sparkline": {
"fillColor": "rgba(31, 118, 189, 0.18)",
"full": false,
"lineColor": "rgb(31, 120, 193)",
"show": false
},
"tableColumn": "",
"targets": [
{
"expr": "gin_uptime{job=~\"$job\"}",
"format": "time_series",
"intervalFactor": 1,
"refId": "A"
}
],
"thresholds": "",
"timeFrom": null,
"timeShift": null,
"title": "Service Uptime",
"type": "singlestat",
"valueFontSize": "110%",
"valueMaps": [
{
"op": "=",
"text": "N/A",
"value": "null"
}
],
"valueName": "current"
},
{
"aliasColors": {},
"bars": false,
"dashLength": 10,
"dashes": false,
"datasource": "Prometheus",
"fieldConfig": {
"defaults": {
"custom": {},
"links": []
},
"overrides": []
},
"fill": 1,
"fillGradient": 0,
"gridPos": {
"h": 11,
"w": 12,
"x": 0,
"y": 12
},
"hiddenSeries": false,
"id": 4,
"legend": {
"alignAsTable": true,
"avg": true,
"current": true,
"max": true,
"min": false,
"show": true,
"total": false,
"values": true
},
"lines": true,
"linewidth": 2,
"links": [],
"nullPointMode": "null as zero",
"options": {
"alertThreshold": true
},
"percentage": false,
"pluginVersion": "7.4.3",
"pointradius": 2,
"points": false,
"renderer": "flot",
"seriesOverrides": [],
"spaceLength": 10,
"stack": false,
"steppedLine": false,
"targets": [
{
"expr": "rate(gin_http_request_size_bytes_sum{job=~\"$job\", path=~\"$path\", method=~\"$method\", status=~\"$status\"}[$interval])\n/\nrate(gin_http_request_size_bytes_count{job=~\"$job\", path=~\"$path\", method=~\"$method\", status=~\"$status\"}[$interval])",
"format": "time_series",
"interval": "",
"intervalFactor": 1,
"legendFormat": "{{ path }}-{{method}}-{{status}}",
"refId": "A"
}
],
"thresholds": [],
"timeFrom": null,
"timeRegions": [],
"timeShift": null,
"title": "Request size(bytes) per second",
"tooltip": {
"shared": true,
"sort": 0,
"value_type": "individual"
},
"type": "graph",
"xaxis": {
"buckets": null,
"mode": "time",
"name": null,
"show": true,
"values": []
},
"yaxes": [
{
"format": "bytes",
"label": null,
"logBase": 1,
"max": null,
"min": null,
"show": true
},
{
"format": "short",
"label": null,
"logBase": 1,
"max": null,
"min": null,
"show": true
}
],
"yaxis": {
"align": false,
"alignLevel": null
}
},
{
"aliasColors": {},
"bars": false,
"dashLength": 10,
"dashes": false,
"datasource": "Prometheus",
"description": "",
"fieldConfig": {
"defaults": {
"custom": {},
"links": []
},
"overrides": []
},
"fill": 1,
"fillGradient": 0,
"gridPos": {
"h": 11,
"w": 12,
"x": 12,
"y": 12
},
"hiddenSeries": false,
"id": 6,
"legend": {
"alignAsTable": true,
"avg": true,
"current": true,
"max": true,
"min": false,
"show": true,
"total": false,
"values": true
},
"lines": true,
"linewidth": 2,
"links": [],
"nullPointMode": "null as zero",
"options": {
"alertThreshold": true
},
"percentage": false,
"pluginVersion": "7.4.3",
"pointradius": 2,
"points": false,
"renderer": "flot",
"seriesOverrides": [],
"spaceLength": 10,
"stack": false,
"steppedLine": false,
"targets": [
{
"expr": "rate(gin_http_response_size_bytes_sum{job=~\"$job\", path=~\"$path\", method=~\"$method\", status=~\"$status\"}[$interval])\n/\nrate(gin_http_response_size_bytes_count{job=~\"$job\", path=~\"$path\", method=~\"$method\", status=~\"$status\"}[$interval])",
"format": "time_series",
"interval": "",
"intervalFactor": 1,
"legendFormat": "{{ path }}-{{method}}-{{status}}",
"refId": "A"
}
],
"thresholds": [],
"timeFrom": null,
"timeRegions": [],
"timeShift": null,
"title": "Response size(bytes) per second",
"tooltip": {
"shared": true,
"sort": 0,
"value_type": "individual"
},
"type": "graph",
"xaxis": {
"buckets": null,
"mode": "time",
"name": null,
"show": true,
"values": []
},
"yaxes": [
{
"format": "bytes",
"label": null,
"logBase": 1,
"max": null,
"min": null,
"show": true
},
{
"format": "short",
"label": null,
"logBase": 1,
"max": null,
"min": null,
"show": true
}
],
"yaxis": {
"align": false,
"alignLevel": null
}
},
{
"aliasColors": {},
"bars": false,
"dashLength": 10,
"dashes": false,
"datasource": "Prometheus",
"fieldConfig": {
"defaults": {
"custom": {},
"links": []
},
"overrides": []
},
"fill": 1,
"fillGradient": 0,
"gridPos": {
"h": 12,
"w": 12,
"x": 0,
"y": 23
},
"hiddenSeries": false,
"id": 10,
"legend": {
"avg": true,
"current": true,
"max": true,
"min": false,
"show": true,
"total": false,
"values": true
},
"lines": true,
"linewidth": 2,
"links": [],
"nullPointMode": "null as zero",
"options": {
"alertThreshold": true
},
"percentage": false,
"pluginVersion": "7.4.3",
"pointradius": 2,
"points": false,
"renderer": "flot",
"seriesOverrides": [],
"spaceLength": 10,
"stack": false,
"steppedLine": false,
"targets": [
{
"expr": "histogram_quantile($quantile, sum(rate(gin_http_request_duration_seconds_bucket{job=~\"$job\", path=~\"$path\", method=~\"$method\", status=~\"$status\"}[$interval])) by (le))",
"format": "time_series",
"interval": "",
"intervalFactor": 1,
"legendFormat": "{{ path }}",
"refId": "A"
}
],
"thresholds": [],
"timeFrom": null,
"timeRegions": [],
"timeShift": null,
"title": "Quantile of requests",
"tooltip": {
"shared": true,
"sort": 0,
"value_type": "individual"
},
"type": "graph",
"xaxis": {
"buckets": null,
"mode": "time",
"name": null,
"show": true,
"values": []
},
"yaxes": [
{
"format": "s",
"label": null,
"logBase": 1,
"max": null,
"min": null,
"show": true
},
{
"format": "short",
"label": null,
"logBase": 1,
"max": null,
"min": null,
"show": true
}
],
"yaxis": {
"align": false,
"alignLevel": null
}
},
{
"aliasColors": {},
"bars": false,
"dashLength": 10,
"dashes": false,
"datasource": "Prometheus",
"fieldConfig": {
"defaults": {
"custom": {},
"links": []
},
"overrides": []
},
"fill": 1,
"fillGradient": 0,
"gridPos": {
"h": 12,
"w": 12,
"x": 12,
"y": 23
},
"hiddenSeries": false,
"id": 8,
"legend": {
"alignAsTable": true,
"avg": true,
"current": true,
"max": true,
"min": false,
"show": true,
"total": false,
"values": true
},
"lines": true,
"linewidth": 2,
"links": [],
"nullPointMode": "null as zero",
"options": {
"alertThreshold": true
},
"percentage": false,
"pluginVersion": "7.4.3",
"pointradius": 2,
"points": false,
"renderer": "flot",
"seriesOverrides": [],
"spaceLength": 10,
"stack": false,
"steppedLine": false,
"targets": [
{
"expr": "rate(gin_http_request_duration_seconds_sum{job=~\"$job\", path=~\"$path\", method=~\"$method\", status=~\"$status\"}[$interval])\r\n/\r\nrate(gin_http_request_duration_seconds_count{job=~\"$job\", path=~\"$path\", method=~\"$method\", status=~\"$status\"}[$interval])",
"format": "time_series",
"interval": "",
"intervalFactor": 1,
"legendFormat": "{{ path }}-{{method}}-{{status}}",
"refId": "A"
}
],
"thresholds": [],
"timeFrom": null,
"timeRegions": [],
"timeShift": null,
"title": "Duration per request",
"tooltip": {
"shared": true,
"sort": 0,
"value_type": "individual"
},
"type": "graph",
"xaxis": {
"buckets": null,
"mode": "time",
"name": null,
"show": true,
"values": []
},
"yaxes": [
{
"format": "s",
"label": null,
"logBase": 1,
"max": null,
"min": null,
"show": true
},
{
"format": "short",
"label": null,
"logBase": 1,
"max": null,
"min": null,
"show": true
}
],
"yaxis": {
"align": false,
"alignLevel": null
}
}
],
"refresh": false,
"schemaVersion": 27,
"style": "dark",
"tags": [
"Service"
],
"templating": {
"list": [
{
"allValue": null,
"current": {
"selected": false,
"text": "edusys-http",
"value": "edusys-http"
},
"datasource": "Prometheus",
"definition": "label_values(gin_http_request_count_total, job)",
"description": null,
"error": null,
"hide": 0,
"includeAll": false,
"label": "Job",
"multi": false,
"name": "job",
"options": [],
"query": {
"query": "label_values(gin_http_request_count_total, job)",
"refId": "Prometheus-job-Variable-Query"
},
"refresh": 1,
"regex": "",
"skipUrlSync": false,
"sort": 0,
"tagValuesQuery": "",
"tags": [],
"tagsQuery": "",
"type": "query",
"useTags": false
},
{
"current": {
"selected": false,
"text": "Prometheus",
"value": "Prometheus"
},
"description": null,
"error": null,
"hide": 2,
"includeAll": false,
"label": null,
"multi": false,
"name": "datasource",
"options": [],
"query": "prometheus",
"refresh": 1,
"regex": "",
"skipUrlSync": false,
"type": "datasource"
},
{
"auto": false,
"auto_count": 30,
"auto_min": "10s",
"current": {
"selected": false,
"text": "1m",
"value": "1m"
},
"description": null,
"error": null,
"hide": 0,
"label": "Interval",
"name": "interval",
"options": [
{
"selected": true,
"text": "1m",
"value": "1m"
},
{
"selected": false,
"text": "10m",
"value": "10m"
},
{
"selected": false,
"text": "30m",
"value": "30m"
},
{
"selected": false,
"text": "1h",
"value": "1h"
},
{
"selected": false,
"text": "6h",
"value": "6h"
},
{
"selected": false,
"text": "12h",
"value": "12h"
},
{
"selected": false,
"text": "1d",
"value": "1d"
},
{
"selected": false,
"text": "7d",
"value": "7d"
},
{
"selected": false,
"text": "14d",
"value": "14d"
},
{
"selected": false,
"text": "30d",
"value": "30d"
}
],
"query": "1m,10m,30m,1h,6h,12h,1d,7d,14d,30d",
"refresh": 2,
"skipUrlSync": false,
"type": "interval"
},
{
"allValue": null,
"current": {
"selected": false,
"text": "All",
"value": "$__all"
},
"datasource": "Prometheus",
"definition": "label_values(gin_http_request_count_total{path!~\"/metrics\", status!=\"404\", job=~\"$job\"}, path)",
"description": null,
"error": null,
"hide": 0,
"includeAll": true,
"label": "Path",
"multi": false,
"name": "path",
"options": [],
"query": {
"query": "label_values(gin_http_request_count_total{path!~\"/metrics\", status!=\"404\", job=~\"$job\"}, path)",
"refId": "Prometheus-path-Variable-Query"
},
"refresh": 1,
"regex": "",
"skipUrlSync": false,
"sort": 0,
"tagValuesQuery": "",
"tags": [],
"tagsQuery": "",
"type": "query",
"useTags": false
},
{
"allValue": null,
"current": {
"selected": false,
"text": "GET",
"value": "GET"
},
"datasource": "Prometheus",
"definition": "label_values(gin_http_request_count_total, method)",
"description": null,
"error": null,
"hide": 0,
"includeAll": true,
"label": "Method",
"multi": false,
"name": "method",
"options": [],
"query": {
"query": "label_values(gin_http_request_count_total, method)",
"refId": "Prometheus-method-Variable-Query"
},
"refresh": 1,
"regex": "",
"skipUrlSync": false,
"sort": 0,
"tagValuesQuery": "",
"tags": [],
"tagsQuery": "",
"type": "query",
"useTags": false
},
{
"allValue": null,
"current": {
"selected": false,
"text": "200",
"value": "200"
},
"datasource": "Prometheus",
"definition": "label_values(gin_http_request_count_total, status)",
"description": null,
"error": null,
"hide": 0,
"includeAll": true,
"label": "Status",
"multi": false,
"name": "status",
"options": [],
"query": {
"query": "label_values(gin_http_request_count_total, status)",
"refId": "Prometheus-status-Variable-Query"
},
"refresh": 1,
"regex": "",
"skipUrlSync": false,
"sort": 0,
"tagValuesQuery": "",
"tags": [],
"tagsQuery": "",
"type": "query",
"useTags": false
},
{
"allValue": null,
"current": {
"tags": [],
"text": "0.95",
"value": "0.95"
},
"description": null,
"error": null,
"hide": 0,
"includeAll": false,
"label": "Quantile",
"multi": false,
"name": "quantile",
"options": [
{
"selected": true,
"text": "0.95",
"value": "0.95"
},
{
"selected": false,
"text": "0.75",
"value": "0.75"
},
{
"selected": false,
"text": "0.25",
"value": "0.25"
}
],
"query": "0.95,0.75,0.25",
"skipUrlSync": false,
"type": "custom"
}
]
},
"time": {
"from": "now-30m",
"to": "now"
},
"timepicker": {
"refresh_intervals": [
"10s",
"30s",
"1m",
"5m",
"15m",
"30m",
"1h",
"2h",
"1d"
],
"time_options": [
"5m",
"15m",
"1h",
"6h",
"12h",
"24h",
"2d",
"7d",
"30d"
]
},
"timezone": "browser",
"title": "Prometheus Gin",
"uid": "EyaoypOZz",
"version": 3
}
\ No newline at end of file
gin/middleware/metrics/metrics.go 0 → 100644
浏览文件 @ d57375cc
// Package metrics is gin metrics library, collect five metrics, "uptime", "http_request_count_total",
// "http_request_duration_seconds", "http_request_size_bytes", "http_response_size_bytes".
package metrics
import (
"net/http"
"strconv"
"time"
"github.com/gin-gonic/gin"
"github.com/prometheus/client_golang/prometheus"
"github.com/prometheus/client_golang/prometheus/promhttp"
)
var (
namespace = "gin"
labels = []string{"status", "path", "method"}
uptime = prometheus.NewCounterVec(
prometheus.CounterOpts{
Namespace: namespace,
Name: "uptime",
Help: "HTTP service uptime, updated every minute",
}, nil,
)
reqCount = prometheus.NewCounterVec(
prometheus.CounterOpts{
Namespace: namespace,
Name: "http_request_count_total",
Help: "Total number of HTTP requests made.",
}, labels,
)
reqDuration = prometheus.NewHistogramVec(
prometheus.HistogramOpts{
Namespace: namespace,
Name: "http_request_duration_seconds",
Help: "HTTP request latencies in seconds.",
}, labels,
)
reqSizeBytes = prometheus.NewSummaryVec(
prometheus.SummaryOpts{
Namespace: namespace,
Name: "http_request_size_bytes",
Help: "HTTP request sizes in bytes.",
}, labels,
)
respSizeBytes = prometheus.NewSummaryVec(
prometheus.SummaryOpts{
Namespace: namespace,
Name: "http_response_size_bytes",
Help: "HTTP response sizes in bytes.",
}, labels,
)
)
// init registers the prometheus metrics
func initPrometheus() {
prometheus.MustRegister(uptime, reqCount, reqDuration, reqSizeBytes, respSizeBytes)
go recordUptime()
}
// recordUptime increases service uptime per 1 minute.
func recordUptime() {
for range time.Tick(time.Minute) {
uptime.WithLabelValues().Inc()
}
}
// calcRequestSize returns the size of request object.
func calcRequestSize(r *http.Request) float64 {
size := 0
if r.URL != nil {
size = len(r.URL.String())
}
size += len(r.Method)
size += len(r.Proto)
for name, values := range r.Header {
size += len(name)
for _, value := range values {
size += len(value)
}
}
size += len(r.Host)
// r.Form and r.MultipartForm are assumed to be included in r.URL.
if r.ContentLength != -1 {
size += int(r.ContentLength)
}
return float64(size)
}
// ------------------------------------------------------------------------------------------
// metricsHandler wrappers the standard http.Handler to gin.HandlerFunc
func metricsHandler() gin.HandlerFunc {
return func(c *gin.Context) {
handler := promhttp.Handler()
handler.ServeHTTP(c.Writer, c.Request)
}
}
// Metrics returns a gin.HandlerFunc for exporting some Web metrics
func Metrics(r *gin.Engine, opts ...Option) gin.HandlerFunc {
o := defaultOptions()
o.apply(opts...)
// init prometheus
initPrometheus()
r.GET(o.metricsPath, metricsHandler())
return func(c *gin.Context) {
start := time.Now()
c.Next()
ok := o.isIgnoreCodeStatus(c.Writer.Status()) ||
o.isIgnorePath(c.Request.URL.Path) ||
o.checkIgnoreMethod(c.Request.Method)
if ok {
return
}
// no response content will return -1
respSize := c.Writer.Size()
if respSize < 0 {
respSize = 0
}
lvs := []string{strconv.Itoa(c.Writer.Status()), c.Request.URL.Path, c.Request.Method}
reqCount.WithLabelValues(lvs...).Inc()
reqDuration.WithLabelValues(lvs...).Observe(time.Since(start).Seconds())
reqSizeBytes.WithLabelValues(lvs...).Observe(calcRequestSize(c.Request))
respSizeBytes.WithLabelValues(lvs...).Observe(float64(respSize))
}
}
gin/middleware/metrics/option.go 0 → 100644
浏览文件 @ d57375cc
package metrics
import (
"strings"
)
// Option set the metrics options.
type Option func(*options)
type options struct {
metricsPath string
ignoreStatusCodes map[int]struct{}
ignoreRequestPaths map[string]struct{}
ignoreRequestMethods map[string]struct{}
}
// defaultOptions default value
func defaultOptions() *options {
return &options{
metricsPath: "/metrics",
ignoreStatusCodes: nil,
ignoreRequestPaths: nil,
ignoreRequestMethods: nil,
}
}
func (o *options) apply(opts ...Option) {
for _, opt := range opts {
opt(o)
}
}
// WithMetricsPath set metrics path
func WithMetricsPath(metricsPath string) Option {
return func(o *options) {
o.metricsPath = metricsPath
}
}
// WithIgnoreStatusCodes ignore status codes
func WithIgnoreStatusCodes(statusCodes ...int) Option {
return func(o *options) {
codeMaps := make(map[int]struct{}, len(statusCodes))
for _, code := range statusCodes {
codeMaps[code] = struct{}{}
}
o.ignoreStatusCodes = codeMaps
}
}
// WithIgnoreRequestPaths ignore request paths
func WithIgnoreRequestPaths(paths ...string) Option {
return func(o *options) {
pathMaps := make(map[string]struct{}, len(paths))
for _, path := range paths {
pathMaps[path] = struct{}{}
}
o.ignoreRequestPaths = pathMaps
}
}
// WithIgnoreRequestMethods ignore request methods
func WithIgnoreRequestMethods(methods ...string) Option {
return func(o *options) {
methodMaps := make(map[string]struct{}, len(methods))
for _, method := range methods {
methodMaps[strings.ToUpper(method)] = struct{}{}
}
o.ignoreRequestMethods = methodMaps
}
}
func (o *options) isIgnoreCodeStatus(statusCode int) bool {
if o.ignoreStatusCodes == nil {
return false
}
_, ok := o.ignoreStatusCodes[statusCode]
return ok
}
func (o *options) isIgnorePath(path string) bool {
if o.ignoreRequestPaths == nil {
return false
}
_, ok := o.ignoreRequestPaths[path]
return ok
}
func (o *options) checkIgnoreMethod(method string) bool {
if o.ignoreRequestMethods == nil {
return false
}
_, ok := o.ignoreRequestMethods[strings.ToUpper(method)]
return ok
}
gin/middleware/metrics_wz/metrics.go 0 → 100644
浏览文件 @ d57375cc
package metrics
import (
"os"
"time"
"github.com/gin-gonic/gin"
"github.com/prometheus/client_golang/prometheus"
"github.com/prometheus/client_golang/prometheus/promhttp"
"github.com/spf13/cast"
)
var (
// namespace = "xmall"
namespace = ""
// uptime = prometheus.NewCounterVec(
// prometheus.CounterOpts{
// Namespace: namespace,
// Name: "uptime",
// Help: "HTTP service uptime, updated every minute",
// }, nil,
// )
reqCount = prometheus.NewCounterVec(
prometheus.CounterOpts{
Namespace: namespace,
Name: "client_code_total",
Help: "Total number of HTTP requests made.",
}, []string{"kind", "operation", "code"},
)
reqDuration = prometheus.NewHistogramVec(prometheus.HistogramOpts{
Namespace: namespace,
Name: "server_requests_duration_sec",
Help: "Server requests duratio(sec).",
Buckets: []float64{0.005, 0.01, 0.025, 0.05, 0.1, 0.250, 0.5, 1},
}, []string{"kind", "operation"})
)
func init() {
if ns := os.Getenv("CONTAINER_NAMESPACE"); ns != "" {
namespace = ns
}
}
// init registers the prometheus metrics
func initPrometheus() {
// prometheus.MustRegister(uptime, reqCount, reqDuration)
prometheus.MustRegister(reqCount, reqDuration)
}
// recordUptime increases service uptime per 1 minute.
// func recordUptime() {
// for range time.Tick(time.Minute) {
// uptime.WithLabelValues().Inc()
// }
// }
// metricsHandler wrappers the standard http.Handler to gin.HandlerFunc
func metricsHandler() gin.HandlerFunc {
return func(c *gin.Context) {
handler := promhttp.Handler()
handler.ServeHTTP(c.Writer, c.Request)
}
}
// Metrics returns a gin.HandlerFunc for exporting some Web metrics
func Metrics(r *gin.Engine, opts ...Option) gin.HandlerFunc {
o := defaultOptions()
o.apply(opts...)
// init prometheus
initPrometheus()
r.GET(o.metricsPath, metricsHandler())
return func(c *gin.Context) {
start := time.Now()
c.Next()
ok := o.isIgnoreCodeStatus(c.Writer.Status()) ||
o.isIgnorePath(c.Request.URL.Path) ||
o.checkIgnoreMethod(c.Request.Method)
if ok {
return
}
reqCount.With(prometheus.Labels{
"kind": "http",
"operation": c.Request.Method + "." + c.Request.URL.Path,
"code": cast.ToString(c.Writer.Status()),
}).Inc()
reqDuration.With(prometheus.Labels{
"kind": "http",
"operation": c.Request.Method + "." + c.Request.URL.Path,
}).Observe(time.Since(start).Seconds())
}
}
gin/middleware/metrics_wz/option.go 0 → 100644
浏览文件 @ d57375cc
package metrics
import (
"strings"
)
// Option set the metrics options.
type Option func(*options)
type options struct {
metricsPath string
ignoreStatusCodes map[int]struct{}
ignoreRequestPaths map[string]struct{}
ignoreRequestMethods map[string]struct{}
}
// defaultOptions default value
func defaultOptions() *options {
return &options{
metricsPath: "/metrics",
ignoreStatusCodes: nil,
ignoreRequestPaths: nil,
ignoreRequestMethods: nil,
}
}
func (o *options) apply(opts ...Option) {
for _, opt := range opts {
opt(o)
}
}
// WithMetricsPath set metrics path
func WithMetricsPath(metricsPath string) Option {
return func(o *options) {
o.metricsPath = metricsPath
}
}
// WithIgnoreStatusCodes ignore status codes
func WithIgnoreStatusCodes(statusCodes ...int) Option {
return func(o *options) {
codeMaps := make(map[int]struct{}, len(statusCodes))
for _, code := range statusCodes {
codeMaps[code] = struct{}{}
}
o.ignoreStatusCodes = codeMaps
}
}
// WithIgnoreRequestPaths ignore request paths
func WithIgnoreRequestPaths(paths ...string) Option {
return func(o *options) {
pathMaps := make(map[string]struct{}, len(paths))
for _, path := range paths {
pathMaps[path] = struct{}{}
}
o.ignoreRequestPaths = pathMaps
}
}
// WithIgnoreRequestMethods ignore request methods
func WithIgnoreRequestMethods(methods ...string) Option {
return func(o *options) {
methodMaps := make(map[string]struct{}, len(methods))
for _, method := range methods {
methodMaps[strings.ToUpper(method)] = struct{}{}
}
o.ignoreRequestMethods = methodMaps
}
}
func (o *options) isIgnoreCodeStatus(statusCode int) bool {
if o.ignoreStatusCodes == nil {
return false
}
_, ok := o.ignoreStatusCodes[statusCode]
return ok
}
func (o *options) isIgnorePath(path string) bool {
if o.ignoreRequestPaths == nil {
return false
}
_, ok := o.ignoreRequestPaths[path]
return ok
}
func (o *options) checkIgnoreMethod(method string) bool {
if o.ignoreRequestMethods == nil {
return false
}
_, ok := o.ignoreRequestMethods[strings.ToUpper(method)]
return ok
}
gin/middleware/recovery.go 0 → 100644
浏览文件 @ d57375cc
package middleware
import (
"net/http"
ctxUtil "gitlab.wanzhuangkj.com/tush/opkg/xutils/ctxutils"
"github.com/gin-gonic/gin"
"go.uber.org/zap"
)
func CustomRecoveryWithLogger(logger *zap.Logger) gin.HandlerFunc {
return gin.CustomRecovery(func(c *gin.Context, err interface{}) {
logger.Error("Recovered from panic",
zap.String("path", c.Request.URL.Path),
zap.String("method", c.Request.Method),
zap.String("client_ip", c.ClientIP()),
zap.Any("error", err),
zap.Stack("stack"),
ctxUtil.GinTraceIDField(c),
)
c.AbortWithStatusJSON(http.StatusInternalServerError, gin.H{
"code": 500,
"message": "服务器内部错误",
})
})
}
gin/middleware/requstid.go 0 → 100644
浏览文件 @ d57375cc
package middleware
import (
"context"
"net/http"
"time"
"github.com/gin-gonic/gin"
"gitlab.wanzhuangkj.com/tush/opkg/pkg/sf"
ctxutils "gitlab.wanzhuangkj.com/tush/opkg/xutils/ctxutils"
"go.uber.org/zap"
)
// RequestIDOption set the request id options.
type RequestIDOption func(*requestIDOptions)
type requestIDOptions struct {
contextRequestIDKey string
headerXRequestIDKey string
appName string
}
func defaultRequestIDOptions() *requestIDOptions {
return &requestIDOptions{
contextRequestIDKey: ctxutils.ContextTraceIDKey,
headerXRequestIDKey: ctxutils.HeaderXRequestIDKey,
}
}
func (o *requestIDOptions) apply(opts ...RequestIDOption) {
for _, opt := range opts {
opt(o)
}
}
func (o *requestIDOptions) setRequestIDKey() {
if o.contextRequestIDKey != ctxutils.ContextTraceIDKey {
ctxutils.ContextTraceIDKey = o.contextRequestIDKey
}
if o.headerXRequestIDKey != ctxutils.HeaderXRequestIDKey {
ctxutils.HeaderXRequestIDKey = o.headerXRequestIDKey
}
}
// Withctx.ContextRequestIDKey set context request id key, minimum length of 4
func WithContextRequestIDKey(key string) RequestIDOption {
return func(o *requestIDOptions) {
if len(key) < 4 {
return
}
o.contextRequestIDKey = key
}
}
// WithHeaderRequestIDKey set header request id key, minimum length of 4
func WithHeaderRequestIDKey(key string) RequestIDOption {
return func(o *requestIDOptions) {
if len(key) < 4 {
return
}
o.headerXRequestIDKey = key
}
}
// CtxKeyString for context.WithValue key type
type CtxKeyString string
// RequestIDKey request_id
var RequestIDKey = CtxKeyString(ctxutils.ContextTraceIDKey)
// -------------------------------------------------------------------------------------------
// RequestID is an interceptor that injects a 'request id' into the context and request/response header of each request.
func RequestID(opts ...RequestIDOption) gin.HandlerFunc {
// customized request id key
o := defaultRequestIDOptions()
o.apply(opts...)
o.setRequestIDKey()
return func(c *gin.Context) {
requestID := c.Request.Header.Get(ctxutils.HeaderXRequestIDKey)
// Create request id
if requestID == "" {
requestID = sf.GenerateID().String()
c.Request.Header.Set(ctxutils.HeaderXRequestIDKey, requestID)
}
st := time.Now()
// Expose it for use in the application
c.Set(ctxutils.ContextTraceIDKey, requestID)
c.Set(ctxutils.KeyApiStartTime, st)
// Set X-Request-Id header
c.Writer.Header().Set(ctxutils.HeaderXRequestIDKey, requestID)
c.Next()
}
}
// HeaderRequestID get request id from the header
func HeaderRequestID(c *gin.Context) string {
return c.Request.Header.Get(ctxutils.HeaderXRequestIDKey)
}
// HeaderRequestIDField get request id field from header
func HeaderRequestIDField(c *gin.Context) zap.Field {
return zap.String(ctxutils.HeaderXRequestIDKey, HeaderRequestID(c))
}
// -------------------------------------------------------------------------------------------
// RequestHeaderKey request header key
var RequestHeaderKey = "request_header_key"
// AdaptCtx adapt context, if ctx is gin.Context, return gin.Context and context of the transformation
func AdaptCtx(ctx context.Context) (*gin.Context, context.Context) {
c, ok := ctx.(*gin.Context)
if ok {
ctx = ctxutils.WrapCtx(c)
}
return c, ctx
}
// GetFromCtx get value from context
func GetFromCtx(ctx context.Context, key string) interface{} {
return ctx.Value(key)
}
// GetFromHeader get value from header
func GetFromHeader(ctx context.Context, key string) string {
header, ok := ctx.Value(RequestHeaderKey).(http.Header)
if !ok {
return ""
}
return header.Get(key)
}
// GetFromHeaders get values from header
func GetFromHeaders(ctx context.Context, key string) []string {
header, ok := ctx.Value(RequestHeaderKey).(http.Header)
if !ok {
return []string{}
}
return header.Values(key)
}
gin/middleware/tracing.go 0 → 100644
浏览文件 @ d57375cc
package middleware
import (
"fmt"
"github.com/gin-gonic/gin"
otelcontrib "go.opentelemetry.io/contrib"
"go.opentelemetry.io/otel"
"go.opentelemetry.io/otel/attribute"
"go.opentelemetry.io/otel/propagation"
semconv "go.opentelemetry.io/otel/semconv/v1.12.0"
oteltrace "go.opentelemetry.io/otel/trace"
)
const (
tracerKey = "otel-tracer"
tracerName = "otelgin"
)
type traceConfig struct {
TracerProvider oteltrace.TracerProvider
Propagators propagation.TextMapPropagator
}
// TraceOption specifies instrumentation configuration options.
type TraceOption func(*traceConfig)
// WithPropagators specifies propagators to use for extracting
// information from the HTTP requests. If none are specified, global
// ones will be used.
func WithPropagators(propagators propagation.TextMapPropagator) TraceOption {
return func(cfg *traceConfig) {
cfg.Propagators = propagators
}
}
// WithTracerProvider specifies a tracer provider to use for creating a tracer.
// If none is specified, the global provider is used.
func WithTracerProvider(provider oteltrace.TracerProvider) TraceOption {
return func(cfg *traceConfig) {
cfg.TracerProvider = provider
}
}
// Tracing returns interceptor that will trace incoming requests.
// The service parameter should describe the name of the (virtual)
// server handling the request.
func Tracing(serviceName string, opts ...TraceOption) gin.HandlerFunc {
cfg := traceConfig{}
for _, opt := range opts {
opt(&cfg)
}
if cfg.TracerProvider == nil {
cfg.TracerProvider = otel.GetTracerProvider()
}
tracer := cfg.TracerProvider.Tracer(
tracerName,
oteltrace.WithInstrumentationVersion(otelcontrib.Version()),
)
if cfg.Propagators == nil {
cfg.Propagators = otel.GetTextMapPropagator()
}
return func(c *gin.Context) {
c.Set(tracerKey, tracer)
savedCtx := c.Request.Context()
defer func() {
c.Request = c.Request.WithContext(savedCtx)
}()
ctx := cfg.Propagators.Extract(savedCtx, propagation.HeaderCarrier(c.Request.Header))
route := c.FullPath()
tOpts := []oteltrace.SpanStartOption{
oteltrace.WithAttributes(semconv.NetAttributesFromHTTPRequest("tcp", c.Request)...),
oteltrace.WithAttributes(semconv.EndUserAttributesFromHTTPRequest(c.Request)...),
oteltrace.WithAttributes(semconv.HTTPServerAttributesFromHTTPRequest(serviceName, route, c.Request)...),
oteltrace.WithSpanKind(oteltrace.SpanKindServer),
}
spanName := route
if spanName == "" {
spanName = fmt.Sprintf("HTTP %s route not found", c.Request.Method)
}
ctx, span := tracer.Start(ctx, spanName, tOpts...)
defer span.End()
// pass the span through the request context
c.Request = c.Request.WithContext(ctx)
// serve the request to the next interceptor
c.Next()
status := c.Writer.Status()
attrs := semconv.HTTPAttributesFromHTTPStatusCode(status)
spanStatus, spanMessage := semconv.SpanStatusFromHTTPStatusCode(status)
span.SetAttributes(attrs...)
span.SetStatus(spanStatus, spanMessage)
if len(c.Errors) > 0 {
span.SetAttributes(attribute.String("gin.errors", c.Errors.String()))
}
}
}
gin/response/response.go 0 → 100644
浏览文件 @ d57375cc
// Package response provides wrapper gin returns json data in the same format.
package response
import (
"bytes"
"encoding/json"
"net/http"
"strconv"
"time"
"gitlab.wanzhuangkj.com/tush/opkg/pkg/httpcli/entity"
"gitlab.wanzhuangkj.com/tush/opkg/pkg/sgorm/query"
"gitlab.wanzhuangkj.com/tush/opkg/xutils/ctxutils"
"github.com/gin-gonic/gin"
"gitlab.wanzhuangkj.com/tush/opkg/pkg/errcode"
"gitlab.wanzhuangkj.com/tush/opkg/pkg/logger"
"gitlab.wanzhuangkj.com/tush/opkg/pkg/xerrors/xerror"
)
const CustomErrorCode = 0
type BasePageReply struct {
BaseListReply
Total int64 `json:"total" comment:"total" encomment:"total" form:"total" example:"2000"` // 总行数
PageSize int64 `json:"pageSize" comment:"pageSize" encomment:"pageSize" form:"pageSize" example:"1"` // 页大小
PageIndex int64 `json:"pageIndex" comment:"pageIndex" encomment:"pageIndex" form:"pageIndex" example:"1"` // 当前页码
PageTotal int64 `json:"pageTotal" comment:"pageTotal" encomment:"pageTotal" form:"pageTotal" example:"99"` // 总页数
}
type BasePageReply2 struct {
BaseListReply2
Total int64 `json:"total" comment:"total" encomment:"total" form:"total" example:"2000"` // 总行数
PageSize int64 `json:"pageSize" comment:"pageSize" encomment:"pageSize" form:"pageSize" example:"1"` // 页大小
PageIndex int64 `json:"pageIndex" comment:"pageIndex" encomment:"pageIndex" form:"pageIndex" example:"1"` // 当前页码
PageTotal int64 `json:"pageTotal" comment:"pageTotal" encomment:"pageTotal" form:"pageTotal" example:"99"` // 总页数
}
type BaseListReply struct {
List []any `json:"list" comment:"list" encomment:"list" form:"list"` //
}
type BaseListReply2 struct {
List any `json:"list" comment:"list" encomment:"list" form:"list"` //
}
type BaseReply struct {
Result
}
// Result output data format
type Result struct {
Code int `json:"code" form:"code" example:"1"`
Msg string `json:"message" form:"message" example:"OK"`
Data interface{} `json:"data"`
TimeStamp int64 `json:"timestamp" form:"data" example:"1718850053"`
TraceID string `json:"traceID" form:"traceID" example:"7f0000016673920576f0659c620086b0"`
}
func newResp(c *gin.Context, code int, msg string, data interface{}) *Result {
resp := &Result{
Code: code,
Msg: msg,
TimeStamp: time.Now().Unix(),
TraceID: ctxutils.GenerateTraceID(c),
}
// ensure that the data field is not nil on return, note that it is not nil when resp.data=[]interface {}, it is serialized to null
//if data == nil {
// resp.Data = &struct{}{}
//} else {
resp.Data = data
//}
// resp.Data = data
return resp
}
var jsonContentType = []string{"application/json; charset=utf-8"}
func writeContentType(w http.ResponseWriter, value []string) {
header := w.Header()
if val := header["Content-Type"]; len(val) == 0 {
header["Content-Type"] = value
}
}
func writeJSON(c *gin.Context, code int, res interface{}) {
c.Writer.WriteHeader(code)
writeContentType(c.Writer, jsonContentType)
if res != nil {
resBytes, _ := json.Marshal(res)
buf := bytes.NewBuffer(resBytes)
entity.SetCopyRsp(c, buf)
_, _ = c.Writer.Write(resBytes)
}
//err := json.NewEncoder(c.Writer).Encode(res)
//if err != nil {
// fmt.Printf("json encode error, err = %s\n", err.Error())
//}
}
func respJSONWithStatusCode(c *gin.Context, code int, msg string, data ...interface{}) {
var firstData interface{}
if len(data) > 0 {
firstData = data[0]
}
resp := newResp(c, code, msg, firstData)
writeJSON(c, code, resp)
}
// Output return standard HTTP status codes and message, parameter code is HTTP status code
func Output(c *gin.Context, code int, data ...interface{}) {
switch code {
case http.StatusOK:
respJSONWithStatusCode(c, http.StatusOK, errcode.Success.Msg(), data...)
case http.StatusBadRequest:
respJSONWithStatusCode(c, http.StatusBadRequest, errcode.InvalidParams.Msg(), data...)
case http.StatusUnauthorized:
respJSONWithStatusCode(c, http.StatusUnauthorized, errcode.Unauthorized.Msg(), data...)
case http.StatusForbidden:
respJSONWithStatusCode(c, http.StatusForbidden, errcode.Forbidden.Msg(), data...)
case http.StatusNotFound:
respJSONWithStatusCode(c, http.StatusNotFound, errcode.NotFound.Msg(), data...)
case http.StatusRequestTimeout:
respJSONWithStatusCode(c, http.StatusRequestTimeout, errcode.Timeout.Msg(), data...)
case http.StatusConflict:
respJSONWithStatusCode(c, http.StatusConflict, errcode.Conflict.Msg(), data...)
case http.StatusInternalServerError:
respJSONWithStatusCode(c, http.StatusInternalServerError, errcode.InternalServerError.Msg(), data...)
case http.StatusTooManyRequests:
respJSONWithStatusCode(c, http.StatusTooManyRequests, errcode.LimitExceed.Msg(), data...)
case http.StatusServiceUnavailable:
respJSONWithStatusCode(c, http.StatusServiceUnavailable, errcode.ServiceUnavailable.Msg(), data...)
default:
respJSONWithStatusCode(c, code, http.StatusText(code), data...)
}
}
// Out returns the standard HTTP status code and message, parameter err is errcode.Error
func Out(c *gin.Context, err *errcode.Error, data ...interface{}) {
code := err.ToHTTPCode()
switch code {
case http.StatusOK:
respJSONWithStatusCode(c, http.StatusOK, errcode.Success.Msg(), data...)
case http.StatusInternalServerError:
respJSONWithStatusCode(c, http.StatusInternalServerError, err.Msg(), data...)
case http.StatusBadRequest:
respJSONWithStatusCode(c, http.StatusBadRequest, err.Msg(), data...)
case http.StatusUnauthorized:
respJSONWithStatusCode(c, http.StatusUnauthorized, err.Msg(), data...)
case http.StatusForbidden:
respJSONWithStatusCode(c, http.StatusForbidden, err.Msg(), data...)
case http.StatusNotFound:
respJSONWithStatusCode(c, http.StatusNotFound, err.Msg(), data...)
case http.StatusRequestTimeout:
respJSONWithStatusCode(c, http.StatusRequestTimeout, err.Msg(), data...)
case http.StatusConflict:
respJSONWithStatusCode(c, http.StatusConflict, err.Msg(), data...)
case http.StatusTooManyRequests:
respJSONWithStatusCode(c, http.StatusTooManyRequests, err.Msg(), data...)
case http.StatusServiceUnavailable:
respJSONWithStatusCode(c, http.StatusServiceUnavailable, err.Msg(), data...)
default:
respJSONWithStatusCode(c, http.StatusNotExtended, err.Msg(), data...)
}
}
// status code flat 200, custom error codes in data.code
func respJSONWith200(c *gin.Context, code int, msg string, data ...interface{}) {
c.Writer.Header().Set(ctxutils.HeaderXTimestampKey, strconv.FormatInt(time.Now().Unix(), 10))
if len(data) > 0 {
writeJSON(c, http.StatusOK, newResp(c, code, msg, data[0]))
return
}
resp := newResp(c, code, msg, nil)
writeJSON(c, http.StatusOK, resp)
}
// Success return success
func Success(c *gin.Context, data ...interface{}) {
c.Set(ctxutils.KeyRspCode, 1)
respJSONWith200(c, errcode.Success.Code(), errcode.Success.Msg(), data...)
}
// SuccessWithPage return success
//
// func SuccessWithPage[T any](c *gin.Context, list []*T, total int64) {
// currPage := 1
// pageSize := 10
// if req, ok := c.Get("reqbody"); ok {
// if pagination, ok := req.(query.IPagination); ok {
// currPage = pagination.GetPageIndex()
// pageSize = pagination.GetPageSize()
// }
// }
// totalPage := total / int64(pageSize)
// if total%int64(pageSize) > 0 {
// totalPage = totalPage + 1
// }
// c.Set(ctxutils.KeyRspCode, 1)
// if list == nil {
// list = []*T{}
// }
// respJSONWith200(c, errcode.Success.Code(), errcode.Success.Msg(), gin.H{
// "list": list, "totalCount": total, "currPage": currPage, "pageSize": pageSize, "totalPage": totalPage,
// })
// }
//
// SuccessWithPage return success
func SuccessWithPage[T any](c *gin.Context, list []*T, total int64) {
pageIndex := 1
pageSize := 10
if req, ok := c.Get(ctxutils.KeyPagination); ok {
if pagination, ok := req.(query.Pagination); ok {
pageIndex = pagination.PageIndex
if pagination.PageSize > 0 {
pageSize = pagination.PageSize
}
}
}
if pageIndex <= 0 {
pageIndex = 1
}
if pageSize <= 0 {
pageSize = 10
}
pageTotal := total / int64(pageSize)
if total%int64(pageSize) > 0 {
pageTotal = pageTotal + 1
}
c.Set(ctxutils.KeyRspCode, 1)
if list == nil {
list = []*T{}
}
respJSONWith200(c, errcode.Success.Code(), errcode.Success.Msg(), gin.H{
"list": list, "total": total, "pageIndex": pageIndex, "pageTotal": pageTotal, "pageSize": pageSize,
})
}
// SuccessWithList return success
func SuccessWithList[T any](c *gin.Context, list []*T) {
c.Set(ctxutils.KeyRspCode, 1)
if list == nil {
list = []*T{}
}
respJSONWith200(c, errcode.Success.Code(), errcode.Success.Msg(), gin.H{"list": list})
}
// ErrorE return error
func ErrorE(c *gin.Context, err *errcode.Error, data ...interface{}) {
c.Set(ctxutils.KeyRspCode, 0)
respJSONWith200(c, err.Code(), err.Msg(), data...)
}
func Error(c *gin.Context, err error) {
c.Set(ctxutils.KeyRspCode, 0)
msg := ""
if err != nil {
msg = err.Error()
if e, ok := err.(*xerror.Error); ok {
//if !errcode.IsSysDefinedError(xerr.Code()) {
// logger.Error(err.Error(), logger.Err(err), ctxutils.GinTraceIDField(c))
//}
if e.Code() != errcode.InvalidParams.Code() {
logger.Error(err.Error(), logger.Err(err), ctxutils.GinTraceIDField(c))
}
} else {
logger.Error(err.Error(), logger.Err(err), ctxutils.GinTraceIDField(c))
}
}
respJSONWith200(c, CustomErrorCode, msg)
}
go.mod
浏览文件 @ d57375cc
...@@ -5,16 +5,25 @@ go 1.24.3 ...@@ -5,16 +5,25 @@ go 1.24.3
require ( require (
github.com/aliyun/aliyun-oss-go-sdk v3.0.2+incompatible github.com/aliyun/aliyun-oss-go-sdk v3.0.2+incompatible
github.com/bwmarrin/snowflake v0.3.0 github.com/bwmarrin/snowflake v0.3.0
github.com/gin-contrib/cors v1.7.6
github.com/gin-gonic/gin v1.11.0 github.com/gin-gonic/gin v1.11.0
github.com/go-redsync/redsync/v4 v4.14.0 github.com/go-redsync/redsync/v4 v4.14.0
github.com/gocarina/gocsv v0.0.0-20240520201108-78e41c74b4b1 github.com/gocarina/gocsv v0.0.0-20240520201108-78e41c74b4b1
github.com/golang-jwt/jwt/v5 v5.3.0
github.com/huandu/xstrings v1.5.0 github.com/huandu/xstrings v1.5.0
github.com/jinzhu/copier v0.4.0 github.com/jinzhu/copier v0.4.0
github.com/mojocn/base64Captcha v1.3.8 github.com/mojocn/base64Captcha v1.3.8
github.com/pkg/errors v0.9.1 github.com/pkg/errors v0.9.1
github.com/prometheus/client_golang v1.19.1
github.com/redis/go-redis/v9 v9.16.0 github.com/redis/go-redis/v9 v9.16.0
github.com/shirou/gopsutil/v3 v3.24.5
github.com/spf13/cast v1.10.0
github.com/stretchr/testify v1.11.1 github.com/stretchr/testify v1.11.1
github.com/uptrace/opentelemetry-go-extra/otelgorm v0.3.2 github.com/uptrace/opentelemetry-go-extra/otelgorm v0.3.2
gitlab.wanzhuangkj.com/tush/xpkg v1.2.30
go.opentelemetry.io/contrib v1.38.0
go.opentelemetry.io/otel v1.37.0
go.opentelemetry.io/otel/trace v1.37.0
go.uber.org/zap v1.27.0 go.uber.org/zap v1.27.0
golang.org/x/sync v0.17.0 golang.org/x/sync v0.17.0
google.golang.org/grpc v1.76.0 google.golang.org/grpc v1.76.0
...@@ -30,21 +39,23 @@ require ( ...@@ -30,21 +39,23 @@ require (
require ( require (
filippo.io/edwards25519 v1.1.0 // indirect filippo.io/edwards25519 v1.1.0 // indirect
github.com/beorn7/perks v1.0.1 // indirect
github.com/bytedance/sonic v1.14.0 // indirect github.com/bytedance/sonic v1.14.0 // indirect
github.com/bytedance/sonic/loader v0.3.0 // indirect github.com/bytedance/sonic/loader v0.3.0 // indirect
github.com/cespare/xxhash/v2 v2.3.0 // indirect github.com/cespare/xxhash/v2 v2.3.0 // indirect
github.com/cloudwego/base64x v0.1.6 // indirect github.com/cloudwego/base64x v0.1.6 // indirect
github.com/davecgh/go-spew v1.1.1 // indirect github.com/davecgh/go-spew v1.1.1 // indirect
github.com/dgryski/go-rendezvous v0.0.0-20200823014737-9f7001d12a5f // indirect github.com/dgryski/go-rendezvous v0.0.0-20200823014737-9f7001d12a5f // indirect
github.com/gabriel-vasile/mimetype v1.4.8 // indirect github.com/gabriel-vasile/mimetype v1.4.9 // indirect
github.com/gin-contrib/sse v1.1.0 // indirect github.com/gin-contrib/sse v1.1.0 // indirect
github.com/go-logr/logr v1.4.3 // indirect github.com/go-logr/logr v1.4.3 // indirect
github.com/go-logr/stdr v1.2.2 // indirect github.com/go-logr/stdr v1.2.2 // indirect
github.com/go-ole/go-ole v1.2.6 // indirect
github.com/go-playground/locales v0.14.1 // indirect github.com/go-playground/locales v0.14.1 // indirect
github.com/go-playground/universal-translator v0.18.1 // indirect github.com/go-playground/universal-translator v0.18.1 // indirect
github.com/go-playground/validator/v10 v10.27.0 // indirect github.com/go-playground/validator/v10 v10.27.0 // indirect
github.com/go-sql-driver/mysql v1.8.1 // indirect github.com/go-sql-driver/mysql v1.8.1 // indirect
github.com/goccy/go-json v0.10.2 // indirect github.com/goccy/go-json v0.10.5 // indirect
github.com/goccy/go-yaml v1.18.0 // indirect github.com/goccy/go-yaml v1.18.0 // indirect
github.com/golang/freetype v0.0.0-20170609003504-e2365dfdc4a0 // indirect github.com/golang/freetype v0.0.0-20170609003504-e2365dfdc4a0 // indirect
github.com/hashicorp/errwrap v1.1.0 // indirect github.com/hashicorp/errwrap v1.1.0 // indirect
...@@ -58,21 +69,28 @@ require ( ...@@ -58,21 +69,28 @@ require (
github.com/json-iterator/go v1.1.12 // indirect github.com/json-iterator/go v1.1.12 // indirect
github.com/klauspost/cpuid/v2 v2.3.0 // indirect github.com/klauspost/cpuid/v2 v2.3.0 // indirect
github.com/leodido/go-urn v1.4.0 // indirect github.com/leodido/go-urn v1.4.0 // indirect
github.com/lufia/plan9stats v0.0.0-20211012122336-39d0f177ccd0 // indirect
github.com/mattn/go-isatty v0.0.20 // indirect github.com/mattn/go-isatty v0.0.20 // indirect
github.com/mattn/go-sqlite3 v1.14.22 // indirect github.com/mattn/go-sqlite3 v1.14.22 // indirect
github.com/modern-go/concurrent v0.0.0-20180228061459-e0a39a4cb421 // indirect github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd // indirect
github.com/modern-go/reflect2 v1.0.2 // indirect github.com/modern-go/reflect2 v1.0.2 // indirect
github.com/pelletier/go-toml/v2 v2.2.4 // indirect github.com/pelletier/go-toml/v2 v2.2.4 // indirect
github.com/pmezard/go-difflib v1.0.0 // indirect github.com/pmezard/go-difflib v1.0.0 // indirect
github.com/power-devops/perfstat v0.0.0-20210106213030-5aafc221ea8c // indirect
github.com/prometheus/client_model v0.6.0 // indirect
github.com/prometheus/common v0.48.0 // indirect
github.com/prometheus/procfs v0.12.0 // indirect
github.com/quic-go/qpack v0.5.1 // indirect github.com/quic-go/qpack v0.5.1 // indirect
github.com/quic-go/quic-go v0.54.0 // indirect github.com/quic-go/quic-go v0.54.0 // indirect
github.com/shoenig/go-m1cpu v0.1.6 // indirect
github.com/tklauser/go-sysconf v0.3.12 // indirect
github.com/tklauser/numcpus v0.6.1 // indirect
github.com/twitchyliquid64/golang-asm v0.15.1 // indirect github.com/twitchyliquid64/golang-asm v0.15.1 // indirect
github.com/ugorji/go/codec v1.3.0 // indirect github.com/ugorji/go/codec v1.3.0 // indirect
github.com/uptrace/opentelemetry-go-extra/otelsql v0.3.2 // indirect github.com/uptrace/opentelemetry-go-extra/otelsql v0.3.2 // indirect
github.com/yusufpapurcu/wmi v1.2.4 // indirect
go.opentelemetry.io/auto/sdk v1.1.0 // indirect go.opentelemetry.io/auto/sdk v1.1.0 // indirect
go.opentelemetry.io/otel v1.37.0 // indirect
go.opentelemetry.io/otel/metric v1.37.0 // indirect go.opentelemetry.io/otel/metric v1.37.0 // indirect
go.opentelemetry.io/otel/trace v1.37.0 // indirect
go.uber.org/mock v0.5.0 // indirect go.uber.org/mock v0.5.0 // indirect
go.uber.org/multierr v1.10.0 // indirect go.uber.org/multierr v1.10.0 // indirect
golang.org/x/arch v0.20.0 // indirect golang.org/x/arch v0.20.0 // indirect
......
go.sum
浏览文件 @ d57375cc
...@@ -2,6 +2,8 @@ filippo.io/edwards25519 v1.1.0 h1:FNf4tywRC1HmFuKW5xopWpigGjJKiJSV0Cqo0cJWDaA= ...@@ -2,6 +2,8 @@ filippo.io/edwards25519 v1.1.0 h1:FNf4tywRC1HmFuKW5xopWpigGjJKiJSV0Cqo0cJWDaA=
filippo.io/edwards25519 v1.1.0/go.mod h1:BxyFTGdWcka3PhytdK4V28tE5sGfRvvvRV7EaN4VDT4= filippo.io/edwards25519 v1.1.0/go.mod h1:BxyFTGdWcka3PhytdK4V28tE5sGfRvvvRV7EaN4VDT4=
github.com/aliyun/aliyun-oss-go-sdk v3.0.2+incompatible h1:8psS8a+wKfiLt1iVDX79F7Y6wUM49Lcha2FMXt4UM8g= github.com/aliyun/aliyun-oss-go-sdk v3.0.2+incompatible h1:8psS8a+wKfiLt1iVDX79F7Y6wUM49Lcha2FMXt4UM8g=
github.com/aliyun/aliyun-oss-go-sdk v3.0.2+incompatible/go.mod h1:T/Aws4fEfogEE9v+HPhhw+CntffsBHJ8nXQCwKr0/g8= github.com/aliyun/aliyun-oss-go-sdk v3.0.2+incompatible/go.mod h1:T/Aws4fEfogEE9v+HPhhw+CntffsBHJ8nXQCwKr0/g8=
github.com/beorn7/perks v1.0.1 h1:VlbKKnNfV8bJzeqoa4cOKqO6bYr3WgKZxO8Z16+hsOM=
github.com/beorn7/perks v1.0.1/go.mod h1:G2ZrVWU2WbWT9wwq4/hrbKbnv/1ERSJQ0ibhJ6rlkpw=
github.com/bsm/ginkgo/v2 v2.12.0 h1:Ny8MWAHyOepLGlLKYmXG4IEkioBysk6GpaRTLC8zwWs= github.com/bsm/ginkgo/v2 v2.12.0 h1:Ny8MWAHyOepLGlLKYmXG4IEkioBysk6GpaRTLC8zwWs=
github.com/bsm/ginkgo/v2 v2.12.0/go.mod h1:SwYbGRRDovPVboqFv0tPTcG1sN61LM1Z4ARdbAV9g4c= github.com/bsm/ginkgo/v2 v2.12.0/go.mod h1:SwYbGRRDovPVboqFv0tPTcG1sN61LM1Z4ARdbAV9g4c=
github.com/bsm/gomega v1.27.10 h1:yeMWxP2pV2fG3FgAODIY8EiRE3dy0aeFYt4l7wh6yKA= github.com/bsm/gomega v1.27.10 h1:yeMWxP2pV2fG3FgAODIY8EiRE3dy0aeFYt4l7wh6yKA=
...@@ -21,8 +23,12 @@ github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c ...@@ -21,8 +23,12 @@ 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/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
github.com/dgryski/go-rendezvous v0.0.0-20200823014737-9f7001d12a5f h1:lO4WD4F/rVNCu3HqELle0jiPLLBs70cWOduZpkS1E78= github.com/dgryski/go-rendezvous v0.0.0-20200823014737-9f7001d12a5f h1:lO4WD4F/rVNCu3HqELle0jiPLLBs70cWOduZpkS1E78=
github.com/dgryski/go-rendezvous v0.0.0-20200823014737-9f7001d12a5f/go.mod h1:cuUVRXasLTGF7a8hSLbxyZXjz+1KgoB3wDUb6vlszIc= github.com/dgryski/go-rendezvous v0.0.0-20200823014737-9f7001d12a5f/go.mod h1:cuUVRXasLTGF7a8hSLbxyZXjz+1KgoB3wDUb6vlszIc=
github.com/gabriel-vasile/mimetype v1.4.8 h1:FfZ3gj38NjllZIeJAmMhr+qKL8Wu+nOoI3GqacKw1NM= github.com/frankban/quicktest v1.14.6 h1:7Xjx+VpznH+oBnejlPUj8oUpdxnVs4f8XU8WnHkI4W8=
github.com/gabriel-vasile/mimetype v1.4.8/go.mod h1:ByKUIKGjh1ODkGM1asKUbQZOLGrPjydw3hYPU2YU9t8= github.com/frankban/quicktest v1.14.6/go.mod h1:4ptaffx2x8+WTWXmUCuVU6aPUX1/Mz7zb5vbUoiM6w0=
github.com/gabriel-vasile/mimetype v1.4.9 h1:5k+WDwEsD9eTLL8Tz3L0VnmVh9QxGjRmjBvAG7U/oYY=
github.com/gabriel-vasile/mimetype v1.4.9/go.mod h1:WnSQhFKJuBlRyLiKohA/2DtIlPFAbguNaG7QCHcyGok=
github.com/gin-contrib/cors v1.7.6 h1:3gQ8GMzs1Ylpf70y8bMw4fVpycXIeX1ZemuSQIsnQQY=
github.com/gin-contrib/cors v1.7.6/go.mod h1:Ulcl+xN4jel9t1Ry8vqph23a60FwH9xVLd+3ykmTjOk=
github.com/gin-contrib/sse v1.1.0 h1:n0w2GMuUpWDVp7qSpvze6fAu9iRxJY4Hmj6AmBOU05w= github.com/gin-contrib/sse v1.1.0 h1:n0w2GMuUpWDVp7qSpvze6fAu9iRxJY4Hmj6AmBOU05w=
github.com/gin-contrib/sse v1.1.0/go.mod h1:hxRZ5gVpWMT7Z0B0gSNYqqsSCNIJMjzvm6fqCz9vjwM= github.com/gin-contrib/sse v1.1.0/go.mod h1:hxRZ5gVpWMT7Z0B0gSNYqqsSCNIJMjzvm6fqCz9vjwM=
github.com/gin-gonic/gin v1.11.0 h1:OW/6PLjyusp2PPXtyxKHU0RbX6I/l28FTdDlae5ueWk= github.com/gin-gonic/gin v1.11.0 h1:OW/6PLjyusp2PPXtyxKHU0RbX6I/l28FTdDlae5ueWk=
...@@ -32,6 +38,8 @@ github.com/go-logr/logr v1.4.3 h1:CjnDlHq8ikf6E492q6eKboGOC0T8CDaOvkHCIg8idEI= ...@@ -32,6 +38,8 @@ github.com/go-logr/logr v1.4.3 h1:CjnDlHq8ikf6E492q6eKboGOC0T8CDaOvkHCIg8idEI=
github.com/go-logr/logr v1.4.3/go.mod h1:9T104GzyrTigFIr8wt5mBrctHMim0Nb2HLGrmQ40KvY= github.com/go-logr/logr v1.4.3/go.mod h1:9T104GzyrTigFIr8wt5mBrctHMim0Nb2HLGrmQ40KvY=
github.com/go-logr/stdr v1.2.2 h1:hSWxHoqTgW2S2qGc0LTAI563KZ5YKYRhT3MFKZMbjag= github.com/go-logr/stdr v1.2.2 h1:hSWxHoqTgW2S2qGc0LTAI563KZ5YKYRhT3MFKZMbjag=
github.com/go-logr/stdr v1.2.2/go.mod h1:mMo/vtBO5dYbehREoey6XUKy/eSumjCCveDpRre4VKE= github.com/go-logr/stdr v1.2.2/go.mod h1:mMo/vtBO5dYbehREoey6XUKy/eSumjCCveDpRre4VKE=
github.com/go-ole/go-ole v1.2.6 h1:/Fpf6oFPoeFik9ty7siob0G6Ke8QvQEuVcuChpwXzpY=
github.com/go-ole/go-ole v1.2.6/go.mod h1:pprOEPIfldk/42T2oK7lQ4v4JSDwmV0As9GaiUsvbm0=
github.com/go-playground/assert/v2 v2.2.0 h1:JvknZsQTYeFEAhQwI4qEt9cyV5ONwRHC+lYKSsYSR8s= github.com/go-playground/assert/v2 v2.2.0 h1:JvknZsQTYeFEAhQwI4qEt9cyV5ONwRHC+lYKSsYSR8s=
github.com/go-playground/assert/v2 v2.2.0/go.mod h1:VDjEfimB/XKnb+ZQfWdccd7VUvScMdVu0Titje2rxJ4= github.com/go-playground/assert/v2 v2.2.0/go.mod h1:VDjEfimB/XKnb+ZQfWdccd7VUvScMdVu0Titje2rxJ4=
github.com/go-playground/locales v0.14.1 h1:EWaQ/wswjilfKLTECiXz7Rh+3BjFhfDFKv/oXslEjJA= github.com/go-playground/locales v0.14.1 h1:EWaQ/wswjilfKLTECiXz7Rh+3BjFhfDFKv/oXslEjJA=
...@@ -52,16 +60,19 @@ github.com/go-sql-driver/mysql v1.8.1 h1:LedoTUt/eveggdHS9qUFC1EFSa8bU2+1pZjSRpv ...@@ -52,16 +60,19 @@ github.com/go-sql-driver/mysql v1.8.1 h1:LedoTUt/eveggdHS9qUFC1EFSa8bU2+1pZjSRpv
github.com/go-sql-driver/mysql v1.8.1/go.mod h1:wEBSXgmK//2ZFJyE+qWnIsVGmvmEKlqwuVSjsCm7DZg= github.com/go-sql-driver/mysql v1.8.1/go.mod h1:wEBSXgmK//2ZFJyE+qWnIsVGmvmEKlqwuVSjsCm7DZg=
github.com/gocarina/gocsv v0.0.0-20240520201108-78e41c74b4b1 h1:FWNFq4fM1wPfcK40yHE5UO3RUdSNPaBC+j3PokzA6OQ= github.com/gocarina/gocsv v0.0.0-20240520201108-78e41c74b4b1 h1:FWNFq4fM1wPfcK40yHE5UO3RUdSNPaBC+j3PokzA6OQ=
github.com/gocarina/gocsv v0.0.0-20240520201108-78e41c74b4b1/go.mod h1:5YoVOkjYAQumqlV356Hj3xeYh4BdZuLE0/nRkf2NKkI= github.com/gocarina/gocsv v0.0.0-20240520201108-78e41c74b4b1/go.mod h1:5YoVOkjYAQumqlV356Hj3xeYh4BdZuLE0/nRkf2NKkI=
github.com/goccy/go-json v0.10.2 h1:CrxCmQqYDkv1z7lO7Wbh2HN93uovUHgrECaO5ZrCXAU= github.com/goccy/go-json v0.10.5 h1:Fq85nIqj+gXn/S5ahsiTlK3TmC85qgirsdTP/+DeaC4=
github.com/goccy/go-json v0.10.2/go.mod h1:6MelG93GURQebXPDq3khkgXZkazVtN9CRI+MGFi0w8I= github.com/goccy/go-json v0.10.5/go.mod h1:oq7eo15ShAhp70Anwd5lgX2pLfOS3QCiwU/PULtXL6M=
github.com/goccy/go-yaml v1.18.0 h1:8W7wMFS12Pcas7KU+VVkaiCng+kG8QiFeFwzFb+rwuw= github.com/goccy/go-yaml v1.18.0 h1:8W7wMFS12Pcas7KU+VVkaiCng+kG8QiFeFwzFb+rwuw=
github.com/goccy/go-yaml v1.18.0/go.mod h1:XBurs7gK8ATbW4ZPGKgcbrY1Br56PdM69F7LkFRi1kA= github.com/goccy/go-yaml v1.18.0/go.mod h1:XBurs7gK8ATbW4ZPGKgcbrY1Br56PdM69F7LkFRi1kA=
github.com/golang-jwt/jwt/v5 v5.3.0 h1:pv4AsKCKKZuqlgs5sUmn4x8UlGa0kEVt/puTpKx9vvo=
github.com/golang-jwt/jwt/v5 v5.3.0/go.mod h1:fxCRLWMO43lRc8nhHWY6LGqRcf+1gQWArsqaEUEa5bE=
github.com/golang/freetype v0.0.0-20170609003504-e2365dfdc4a0 h1:DACJavvAHhabrF08vX0COfcOBJRhZ8lUbR+ZWIs0Y5g= github.com/golang/freetype v0.0.0-20170609003504-e2365dfdc4a0 h1:DACJavvAHhabrF08vX0COfcOBJRhZ8lUbR+ZWIs0Y5g=
github.com/golang/freetype v0.0.0-20170609003504-e2365dfdc4a0/go.mod h1:E/TSTwGwJL78qG/PmXZO1EjYhfJinVAhrmmHX6Z8B9k= github.com/golang/freetype v0.0.0-20170609003504-e2365dfdc4a0/go.mod h1:E/TSTwGwJL78qG/PmXZO1EjYhfJinVAhrmmHX6Z8B9k=
github.com/golang/protobuf v1.5.4 h1:i7eJL8qZTpSEXOPTxNKhASYpMn+8e5Q6AdndVa1dWek= github.com/golang/protobuf v1.5.4 h1:i7eJL8qZTpSEXOPTxNKhASYpMn+8e5Q6AdndVa1dWek=
github.com/golang/protobuf v1.5.4/go.mod h1:lnTiLA8Wa4RWRcIUkrtSVa5nRhsEGBg48fD6rSs7xps= github.com/golang/protobuf v1.5.4/go.mod h1:lnTiLA8Wa4RWRcIUkrtSVa5nRhsEGBg48fD6rSs7xps=
github.com/gomodule/redigo v1.9.2 h1:HrutZBLhSIU8abiSfW8pj8mPhOyMYjZT/wcA4/L9L9s= github.com/gomodule/redigo v1.9.2 h1:HrutZBLhSIU8abiSfW8pj8mPhOyMYjZT/wcA4/L9L9s=
github.com/gomodule/redigo v1.9.2/go.mod h1:KsU3hiK/Ay8U42qpaJk+kuNa3C+spxapWpM+ywhcgtw= github.com/gomodule/redigo v1.9.2/go.mod h1:KsU3hiK/Ay8U42qpaJk+kuNa3C+spxapWpM+ywhcgtw=
github.com/google/go-cmp v0.5.6/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
github.com/google/go-cmp v0.6.0/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY= github.com/google/go-cmp v0.6.0/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY=
github.com/google/go-cmp v0.7.0 h1:wk8382ETsv4JYUZwIsn6YpYiWiBsYLSJiTsyBybVuN8= github.com/google/go-cmp v0.7.0 h1:wk8382ETsv4JYUZwIsn6YpYiWiBsYLSJiTsyBybVuN8=
github.com/google/go-cmp v0.7.0/go.mod h1:pXiqmnSA92OHEEa9HXL2W4E7lf9JzCmGVUdgjX3N/iU= github.com/google/go-cmp v0.7.0/go.mod h1:pXiqmnSA92OHEEa9HXL2W4E7lf9JzCmGVUdgjX3N/iU=
...@@ -97,12 +108,15 @@ github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY= ...@@ -97,12 +108,15 @@ github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY=
github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE= github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE=
github.com/leodido/go-urn v1.4.0 h1:WT9HwE9SGECu3lg4d/dIA+jxlljEa1/ffXKmRjqdmIQ= github.com/leodido/go-urn v1.4.0 h1:WT9HwE9SGECu3lg4d/dIA+jxlljEa1/ffXKmRjqdmIQ=
github.com/leodido/go-urn v1.4.0/go.mod h1:bvxc+MVxLKB4z00jd1z+Dvzr47oO32F/QSNjSBOlFxI= github.com/leodido/go-urn v1.4.0/go.mod h1:bvxc+MVxLKB4z00jd1z+Dvzr47oO32F/QSNjSBOlFxI=
github.com/lufia/plan9stats v0.0.0-20211012122336-39d0f177ccd0 h1:6E+4a0GO5zZEnZ81pIr0yLvtUWk2if982qA3F3QD6H4=
github.com/lufia/plan9stats v0.0.0-20211012122336-39d0f177ccd0/go.mod h1:zJYVVT2jmtg6P3p1VtQj7WsuWi/y4VnjVBn7F8KPB3I=
github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY= github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY=
github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y= github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
github.com/mattn/go-sqlite3 v1.14.22 h1:2gZY6PC6kBnID23Tichd1K+Z0oS6nE/XwU+Vz/5o4kU= github.com/mattn/go-sqlite3 v1.14.22 h1:2gZY6PC6kBnID23Tichd1K+Z0oS6nE/XwU+Vz/5o4kU=
github.com/mattn/go-sqlite3 v1.14.22/go.mod h1:Uh1q+B4BYcTPb+yiD3kU8Ct7aC0hY9fxUwlHK0RXw+Y= github.com/mattn/go-sqlite3 v1.14.22/go.mod h1:Uh1q+B4BYcTPb+yiD3kU8Ct7aC0hY9fxUwlHK0RXw+Y=
github.com/modern-go/concurrent v0.0.0-20180228061459-e0a39a4cb421 h1:ZqeYNhU3OHLH3mGKHDcjJRFFRrJa6eAM5H+CtDdOsPc=
github.com/modern-go/concurrent v0.0.0-20180228061459-e0a39a4cb421/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q= github.com/modern-go/concurrent v0.0.0-20180228061459-e0a39a4cb421/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q=
github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd h1:TRLaZ9cD/w8PVh93nsPXa1VrQ6jlwL5oN8l14QlcNfg=
github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q=
github.com/modern-go/reflect2 v1.0.2 h1:xBagoLtFs94CBntxluKeaWgTMpvLxC4ur3nMaC9Gz0M= github.com/modern-go/reflect2 v1.0.2 h1:xBagoLtFs94CBntxluKeaWgTMpvLxC4ur3nMaC9Gz0M=
github.com/modern-go/reflect2 v1.0.2/go.mod h1:yWuevngMOJpCy52FWWMvUC8ws7m/LJsjYzDa0/r8luk= github.com/modern-go/reflect2 v1.0.2/go.mod h1:yWuevngMOJpCy52FWWMvUC8ws7m/LJsjYzDa0/r8luk=
github.com/mojocn/base64Captcha v1.3.8 h1:rrN9BhCwXKS8ht1e21kvR3iTaMgf4qPC9sRoV52bqEg= github.com/mojocn/base64Captcha v1.3.8 h1:rrN9BhCwXKS8ht1e21kvR3iTaMgf4qPC9sRoV52bqEg=
...@@ -113,6 +127,16 @@ github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4= ...@@ -113,6 +127,16 @@ github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4=
github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0= github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM= github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
github.com/power-devops/perfstat v0.0.0-20210106213030-5aafc221ea8c h1:ncq/mPwQF4JjgDlrVEn3C11VoGHZN7m8qihwgMEtzYw=
github.com/power-devops/perfstat v0.0.0-20210106213030-5aafc221ea8c/go.mod h1:OmDBASR4679mdNQnz2pUhc2G8CO2JrUAVFDRBDP/hJE=
github.com/prometheus/client_golang v1.19.1 h1:wZWJDwK+NameRJuPGDhlnFgx8e8HN3XHQeLaYJFJBOE=
github.com/prometheus/client_golang v1.19.1/go.mod h1:mP78NwGzrVks5S2H6ab8+ZZGJLZUq1hoULYBAYBw1Ho=
github.com/prometheus/client_model v0.6.0 h1:k1v3CzpSRUTrKMppY35TLwPvxHqBu0bYgxZzqGIgaos=
github.com/prometheus/client_model v0.6.0/go.mod h1:NTQHnmxFpouOD0DpvP4XujX3CdOAGQPoaGhyTchlyt8=
github.com/prometheus/common v0.48.0 h1:QO8U2CdOzSn1BBsmXJXduaaW+dY/5QLjfB8svtSzKKE=
github.com/prometheus/common v0.48.0/go.mod h1:0/KsvlIEfPQCQ5I2iNSAWKPZziNCvRs5EC6ILDTlAPc=
github.com/prometheus/procfs v0.12.0 h1:jluTpSng7V9hY0O2R9DzzJHYb2xULk9VTR1V1R/k6Bo=
github.com/prometheus/procfs v0.12.0/go.mod h1:pcuDEFsWDnvcgNzo4EEweacyhjeA9Zk3cnaOZAZEfOo=
github.com/quic-go/qpack v0.5.1 h1:giqksBPnT/HDtZ6VhtFKgoLOWmlyo9Ei6u9PqzIMbhI= github.com/quic-go/qpack v0.5.1 h1:giqksBPnT/HDtZ6VhtFKgoLOWmlyo9Ei6u9PqzIMbhI=
github.com/quic-go/qpack v0.5.1/go.mod h1:+PC4XFrEskIVkcLzpEkbLqq1uCoxPhQuvK5rH1ZgaEg= github.com/quic-go/qpack v0.5.1/go.mod h1:+PC4XFrEskIVkcLzpEkbLqq1uCoxPhQuvK5rH1ZgaEg=
github.com/quic-go/quic-go v0.54.0 h1:6s1YB9QotYI6Ospeiguknbp2Znb/jZYjZLRXn9kMQBg= github.com/quic-go/quic-go v0.54.0 h1:6s1YB9QotYI6Ospeiguknbp2Znb/jZYjZLRXn9kMQBg=
...@@ -125,6 +149,14 @@ github.com/redis/rueidis/rueidiscompat v1.0.64 h1:M8JbLP4LyHQhBLBRsUQIzui8/LyTtd ...@@ -125,6 +149,14 @@ github.com/redis/rueidis/rueidiscompat v1.0.64 h1:M8JbLP4LyHQhBLBRsUQIzui8/LyTtd
github.com/redis/rueidis/rueidiscompat v1.0.64/go.mod h1:8pJVPhEjpw0izZFSxYwDziUiEYEkEklTSw/nZzga61M= github.com/redis/rueidis/rueidiscompat v1.0.64/go.mod h1:8pJVPhEjpw0izZFSxYwDziUiEYEkEklTSw/nZzga61M=
github.com/rogpeppe/go-internal v1.13.1 h1:KvO1DLK/DRN07sQ1LQKScxyZJuNnedQ5/wKSR38lUII= github.com/rogpeppe/go-internal v1.13.1 h1:KvO1DLK/DRN07sQ1LQKScxyZJuNnedQ5/wKSR38lUII=
github.com/rogpeppe/go-internal v1.13.1/go.mod h1:uMEvuHeurkdAXX61udpOXGD/AzZDWNMNyH2VO9fmH0o= github.com/rogpeppe/go-internal v1.13.1/go.mod h1:uMEvuHeurkdAXX61udpOXGD/AzZDWNMNyH2VO9fmH0o=
github.com/shirou/gopsutil/v3 v3.24.5 h1:i0t8kL+kQTvpAYToeuiVk3TgDeKOFioZO3Ztz/iZ9pI=
github.com/shirou/gopsutil/v3 v3.24.5/go.mod h1:bsoOS1aStSs9ErQ1WWfxllSeS1K5D+U30r2NfcubMVk=
github.com/shoenig/go-m1cpu v0.1.6 h1:nxdKQNcEB6vzgA2E2bvzKIYRuNj7XNJ4S/aRSwKzFtM=
github.com/shoenig/go-m1cpu v0.1.6/go.mod h1:1JJMcUBvfNwpq05QDQVAnx3gUHr9IYF7GNg9SUEw2VQ=
github.com/shoenig/test v0.6.4 h1:kVTaSd7WLz5WZ2IaoM0RSzRsUD+m8wRR+5qvntpn4LU=
github.com/shoenig/test v0.6.4/go.mod h1:byHiCGXqrVaflBLAMq/srcZIHynQPQgeyvkvXnjqq0k=
github.com/spf13/cast v1.10.0 h1:h2x0u2shc1QuLHfxi+cTJvs30+ZAHOGRic8uyGTDWxY=
github.com/spf13/cast v1.10.0/go.mod h1:jNfB8QC9IA6ZuY2ZjDp0KtFO2LZZlg4S/7bzP6qqeHo=
github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw= github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw=
github.com/stretchr/objx v0.5.0/go.mod h1:Yh+to48EsGEfYuaHDzXPcE3xhTkx73EhmCGUpEOglKo= github.com/stretchr/objx v0.5.0/go.mod h1:Yh+to48EsGEfYuaHDzXPcE3xhTkx73EhmCGUpEOglKo=
...@@ -137,6 +169,10 @@ github.com/stretchr/testify v1.11.1 h1:7s2iGBzp5EwR7/aIZr8ao5+dra3wiQyKjjFuvgVKu ...@@ -137,6 +169,10 @@ github.com/stretchr/testify v1.11.1 h1:7s2iGBzp5EwR7/aIZr8ao5+dra3wiQyKjjFuvgVKu
github.com/stretchr/testify v1.11.1/go.mod h1:wZwfW3scLgRK+23gO65QZefKpKQRnfz6sD981Nm4B6U= github.com/stretchr/testify v1.11.1/go.mod h1:wZwfW3scLgRK+23gO65QZefKpKQRnfz6sD981Nm4B6U=
github.com/stvp/tempredis v0.0.0-20181119212430-b82af8480203 h1:QVqDTf3h2WHt08YuiTGPZLls0Wq99X9bWd0Q5ZSBesM= github.com/stvp/tempredis v0.0.0-20181119212430-b82af8480203 h1:QVqDTf3h2WHt08YuiTGPZLls0Wq99X9bWd0Q5ZSBesM=
github.com/stvp/tempredis v0.0.0-20181119212430-b82af8480203/go.mod h1:oqN97ltKNihBbwlX8dLpwxCl3+HnXKV/R0e+sRLd9C8= github.com/stvp/tempredis v0.0.0-20181119212430-b82af8480203/go.mod h1:oqN97ltKNihBbwlX8dLpwxCl3+HnXKV/R0e+sRLd9C8=
github.com/tklauser/go-sysconf v0.3.12 h1:0QaGUFOdQaIVdPgfITYzaTegZvdCjmYO52cSFAEVmqU=
github.com/tklauser/go-sysconf v0.3.12/go.mod h1:Ho14jnntGE1fpdOqQEEaiKRpvIavV0hSfmBq8nJbHYI=
github.com/tklauser/numcpus v0.6.1 h1:ng9scYS7az0Bk4OZLvrNXNSAO2Pxr1XXRAPyjhIx+Fk=
github.com/tklauser/numcpus v0.6.1/go.mod h1:1XfjsgE2zo8GVw7POkMbHENHzVg3GzmoZ9fESEdAacY=
github.com/twitchyliquid64/golang-asm v0.15.1 h1:SU5vSMR7hnwNxj24w34ZyCi/FmDZTkS4MhqMhdFk5YI= github.com/twitchyliquid64/golang-asm v0.15.1 h1:SU5vSMR7hnwNxj24w34ZyCi/FmDZTkS4MhqMhdFk5YI=
github.com/twitchyliquid64/golang-asm v0.15.1/go.mod h1:a1lVb/DtPvCB8fslRZhAngC2+aY1QWCk3Cedj/Gdt08= github.com/twitchyliquid64/golang-asm v0.15.1/go.mod h1:a1lVb/DtPvCB8fslRZhAngC2+aY1QWCk3Cedj/Gdt08=
github.com/ugorji/go/codec v1.3.0 h1:Qd2W2sQawAfG8XSvzwhBeoGq71zXOC/Q1E9y/wUcsUA= github.com/ugorji/go/codec v1.3.0 h1:Qd2W2sQawAfG8XSvzwhBeoGq71zXOC/Q1E9y/wUcsUA=
...@@ -146,8 +182,14 @@ github.com/uptrace/opentelemetry-go-extra/otelgorm v0.3.2/go.mod h1:wocb5pNrj/sj ...@@ -146,8 +182,14 @@ github.com/uptrace/opentelemetry-go-extra/otelgorm v0.3.2/go.mod h1:wocb5pNrj/sj
github.com/uptrace/opentelemetry-go-extra/otelsql v0.3.2 h1:ZjUj9BLYf9PEqBn8W/OapxhPjVRdC6CsXTdULHsyk5c= github.com/uptrace/opentelemetry-go-extra/otelsql v0.3.2 h1:ZjUj9BLYf9PEqBn8W/OapxhPjVRdC6CsXTdULHsyk5c=
github.com/uptrace/opentelemetry-go-extra/otelsql v0.3.2/go.mod h1:O8bHQfyinKwTXKkiKNGmLQS7vRsqRxIQTFZpYpHK3IQ= github.com/uptrace/opentelemetry-go-extra/otelsql v0.3.2/go.mod h1:O8bHQfyinKwTXKkiKNGmLQS7vRsqRxIQTFZpYpHK3IQ=
github.com/yuin/goldmark v1.4.13/go.mod h1:6yULJ656Px+3vBD8DxQVa3kxgyrAnzto9xy5taEt/CY= github.com/yuin/goldmark v1.4.13/go.mod h1:6yULJ656Px+3vBD8DxQVa3kxgyrAnzto9xy5taEt/CY=
github.com/yusufpapurcu/wmi v1.2.4 h1:zFUKzehAFReQwLys1b/iSMl+JQGSCSjtVqQn9bBrPo0=
github.com/yusufpapurcu/wmi v1.2.4/go.mod h1:SBZ9tNy3G9/m5Oi98Zks0QjeHVDvuK0qfxQmPyzfmi0=
gitlab.wanzhuangkj.com/tush/xpkg v1.2.30 h1:nHS6M23/cUxFMdAX5hEoSTDYtBQIps/I36WI9x5r4uM=
gitlab.wanzhuangkj.com/tush/xpkg v1.2.30/go.mod h1:Pg1aL6bPUwYIxzmcxvFR6fUmI2UGPo2rjqpPBQMbHBY=
go.opentelemetry.io/auto/sdk v1.1.0 h1:cH53jehLUN6UFLY71z+NDOiNJqDdPRaXzTel0sJySYA= go.opentelemetry.io/auto/sdk v1.1.0 h1:cH53jehLUN6UFLY71z+NDOiNJqDdPRaXzTel0sJySYA=
go.opentelemetry.io/auto/sdk v1.1.0/go.mod h1:3wSPjt5PWp2RhlCcmmOial7AvC4DQqZb7a7wCow3W8A= go.opentelemetry.io/auto/sdk v1.1.0/go.mod h1:3wSPjt5PWp2RhlCcmmOial7AvC4DQqZb7a7wCow3W8A=
go.opentelemetry.io/contrib v1.38.0 h1:msaHYZ13HfLIbqXsGwZZQBg5zgxwumlZ1mCkXn3E7LM=
go.opentelemetry.io/contrib v1.38.0/go.mod h1:4Vp7Az5Dez02V1lCi9OqLvSmSz0lbZu/O2r4XZsqwB0=
go.opentelemetry.io/otel v1.37.0 h1:9zhNfelUvx0KBfu/gb+ZgeAfAgtWrfHJZcAqFC228wQ= go.opentelemetry.io/otel v1.37.0 h1:9zhNfelUvx0KBfu/gb+ZgeAfAgtWrfHJZcAqFC228wQ=
go.opentelemetry.io/otel v1.37.0/go.mod h1:ehE/umFRLnuLa/vSccNq9oS1ErUlkkK71gMcN34UG8I= go.opentelemetry.io/otel v1.37.0/go.mod h1:ehE/umFRLnuLa/vSccNq9oS1ErUlkkK71gMcN34UG8I=
go.opentelemetry.io/otel/metric v1.37.0 h1:mvwbQS5m0tbmqML4NqK+e3aDiO02vsf/WgbsdpcPoZE= go.opentelemetry.io/otel/metric v1.37.0 h1:mvwbQS5m0tbmqML4NqK+e3aDiO02vsf/WgbsdpcPoZE=
...@@ -200,13 +242,16 @@ golang.org/x/sync v0.10.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk= ...@@ -200,13 +242,16 @@ golang.org/x/sync v0.10.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk=
golang.org/x/sync v0.17.0 h1:l60nONMj9l5drqw6jlhIELNv9I0A4OFgRsG9k2oT9Ug= golang.org/x/sync v0.17.0 h1:l60nONMj9l5drqw6jlhIELNv9I0A4OFgRsG9k2oT9Ug=
golang.org/x/sync v0.17.0/go.mod h1:9KTHXmSnoGruLpwFjVSX0lNNA75CykiMECbovNTZqGI= golang.org/x/sync v0.17.0/go.mod h1:9KTHXmSnoGruLpwFjVSX0lNNA75CykiMECbovNTZqGI=
golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
golang.org/x/sys v0.0.0-20190916202348-b4ddaad3f8a3/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20201204225414-ed752295db88/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20210615035016-665e8c7367d1/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.0.0-20210615035016-665e8c7367d1/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.0.0-20220520151302-bc2c85ada10a/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.0.0-20220520151302-bc2c85ada10a/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.0.0-20220722155257-8c9f86f7a55f/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.0.0-20220722155257-8c9f86f7a55f/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.5.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.5.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.8.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.8.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.11.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.12.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.12.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.17.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA= golang.org/x/sys v0.17.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
golang.org/x/sys v0.20.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA= golang.org/x/sys v0.20.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
...@@ -242,6 +287,7 @@ golang.org/x/tools v0.21.1-0.20240508182429-e35e4ccd0d2d/go.mod h1:aiJjzUbINMkxb ...@@ -242,6 +287,7 @@ golang.org/x/tools v0.21.1-0.20240508182429-e35e4ccd0d2d/go.mod h1:aiJjzUbINMkxb
golang.org/x/tools v0.34.0 h1:qIpSLOxeCYGg9TrcJokLBG4KFA6d795g0xkBkiESGlo= golang.org/x/tools v0.34.0 h1:qIpSLOxeCYGg9TrcJokLBG4KFA6d795g0xkBkiESGlo=
golang.org/x/tools v0.34.0/go.mod h1:pAP9OwEaY1CAW3HOmg3hLZC5Z0CCmzjAF2UQMSqNARg= golang.org/x/tools v0.34.0/go.mod h1:pAP9OwEaY1CAW3HOmg3hLZC5Z0CCmzjAF2UQMSqNARg=
golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
google.golang.org/genproto/googleapis/rpc v0.0.0-20250804133106-a7a43d27e69b h1:zPKJod4w6F1+nRGDI9ubnXYhU9NSWoFAijkHkUXeTK8= google.golang.org/genproto/googleapis/rpc v0.0.0-20250804133106-a7a43d27e69b h1:zPKJod4w6F1+nRGDI9ubnXYhU9NSWoFAijkHkUXeTK8=
google.golang.org/genproto/googleapis/rpc v0.0.0-20250804133106-a7a43d27e69b/go.mod h1:qQ0YXyHHx3XkvlzUtpXDkS29lDSafHMZBAZDc03LQ3A= google.golang.org/genproto/googleapis/rpc v0.0.0-20250804133106-a7a43d27e69b/go.mod h1:qQ0YXyHHx3XkvlzUtpXDkS29lDSafHMZBAZDc03LQ3A=
google.golang.org/grpc v1.76.0 h1:UnVkv1+uMLYXoIz6o7chp59WfQUYA2ex/BXQ9rHZu7A= google.golang.org/grpc v1.76.0 h1:UnVkv1+uMLYXoIz6o7chp59WfQUYA2ex/BXQ9rHZu7A=
......
pkg/container/group/example_test.go 0 → 100644
浏览文件 @ d57375cc
package group
import "fmt"
type Counter struct {
Value int
}
func (c *Counter) Incr() {
c.Value++
}
func ExampleGroup_Get() {
group := NewGroup(func() interface{} {
fmt.Println("Only Once")
return &Counter{}
})
// Create a new Counter
group.Get("pass").(*Counter).Incr()
// Get the created Counter again.
group.Get("pass").(*Counter).Incr()
// Output:
// Only Once
}
func ExampleGroup_Reset() {
group := NewGroup(func() interface{} {
return &Counter{}
})
// Reset the new function and clear all created objects.
group.Reset(func() interface{} {
fmt.Println("reset")
return &Counter{}
})
// Create a new Counter
group.Get("pass").(*Counter).Incr()
// Output:reset
}
pkg/container/group/group.go 0 → 100644
浏览文件 @ d57375cc
// Package group provides a sample lazy load container.
// The group only creating a new object not until the object is needed by user.
// And it will cache all the objects to reduce the creation of object.
package group
import "sync"
// Group is a lazy load container.
type Group struct {
new func() interface{}
vals map[string]interface{}
sync.RWMutex
}
// NewGroup news a group container.
func NewGroup(fn func() interface{}) *Group {
if fn == nil {
panic("container.group: can't assign a nil to the new function")
}
return &Group{
new: fn,
vals: make(map[string]interface{}),
}
}
// Get gets the object by the given key.
func (g *Group) Get(key string) interface{} {
g.RLock()
v, ok := g.vals[key]
if ok {
g.RUnlock()
return v
}
g.RUnlock()
// slow path for group don`t have specified key value
g.Lock()
defer g.Unlock()
v, ok = g.vals[key]
if ok {
return v
}
v = g.new()
g.vals[key] = v
return v
}
// Reset resets the new function and deletes all existing objects.
func (g *Group) Reset(fn func() interface{}) {
if fn == nil {
panic("container.group: can't assign a nil to the new function")
}
g.Lock()
g.new = fn
g.Unlock()
g.Clear()
}
// Clear deletes all objects.
func (g *Group) Clear() {
g.Lock()
g.vals = make(map[string]interface{})
g.Unlock()
}
pkg/container/group/group_test.go 0 → 100644
浏览文件 @ d57375cc
package group
import (
"reflect"
"testing"
)
func TestGroupGet(t *testing.T) {
count := 0
g := NewGroup(func() interface{} {
count++
return count
})
v := g.Get("key_0")
if !reflect.DeepEqual(v.(int), 1) {
t.Errorf("expect 1, actual %v", v)
}
v = g.Get("key_1")
if !reflect.DeepEqual(v.(int), 2) {
t.Errorf("expect 2, actual %v", v)
}
v = g.Get("key_0")
if !reflect.DeepEqual(v.(int), 1) {
t.Errorf("expect 1, actual %v", v)
}
if !reflect.DeepEqual(count, 2) {
t.Errorf("expect count 2, actual %v", count)
}
}
func TestGroupReset(t *testing.T) {
g := NewGroup(func() interface{} {
return 1
})
g.Get("key")
call := false
g.Reset(func() interface{} {
call = true
return 1
})
length := 0
for range g.vals {
length++
}
if !reflect.DeepEqual(length, 0) {
t.Errorf("expect length 0, actual %v", length)
}
g.Get("key")
if !reflect.DeepEqual(call, true) {
t.Errorf("expect call true, actual %v", call)
}
}
func TestGroupClear(t *testing.T) {
g := NewGroup(func() interface{} {
return 1
})
g.Get("key")
length := 0
for range g.vals {
length++
}
if !reflect.DeepEqual(length, 1) {
t.Errorf("expect length 1, actual %v", length)
}
g.Clear()
length = 0
for range g.vals {
length++
}
if !reflect.DeepEqual(length, 0) {
t.Errorf("expect length 0, actual %v", length)
}
}
pkg/jwt/jwt.go 0 → 100644
浏览文件 @ d57375cc
// Package jwt is token generation and validation.
package jwt
import (
"time"
"github.com/golang-jwt/jwt/v5"
)
// ErrTokenExpired expired
var ErrTokenExpired = jwt.ErrTokenExpired
var opt *options
// Init initialize jwt
func Init(opts ...Option) {
o := defaultOptions()
o.apply(opts...)
opt = o
}
// Claims standard claims, include uid, name, and RegisteredClaims
type Claims struct {
UID string `json:"uid"`
Name string `json:"name"`
jwt.RegisteredClaims
}
// GenerateToken generate token by uid and name, use universal Claims
func GenerateToken(uid string, name string) (string, time.Time, error) {
expireAt := time.Now()
if opt == nil {
return "", expireAt, errInit
}
expireAt = time.Now().Add(opt.expire)
claims := Claims{
uid,
name,
jwt.RegisteredClaims{
ExpiresAt: jwt.NewNumericDate(expireAt),
IssuedAt: jwt.NewNumericDate(time.Now()),
Issuer: opt.issuer,
},
}
token := jwt.NewWithClaims(opt.signingMethod, claims)
tk, err := token.SignedString(opt.signingKey)
if err != nil {
return tk, expireAt, err
}
return tk, expireAt, nil
}
// ParseToken parse token, return universal Claims
func ParseToken(tokenString string) (*Claims, error) {
if opt == nil {
return nil, errInit
}
token, err := jwt.ParseWithClaims(tokenString, &Claims{}, func(token *jwt.Token) (interface{}, error) {
return opt.signingKey, nil
})
if err != nil {
return nil, err
}
if claims, ok := token.Claims.(*Claims); ok && token.Valid {
return claims, nil
}
return nil, errSignature
}
// RefreshToken refresh token
func RefreshToken(tokenString string) (string, error) {
claims, err := ParseToken(tokenString)
if err != nil {
return "", err
}
claims.RegisteredClaims.ExpiresAt = jwt.NewNumericDate(time.Now().Add(opt.expire))
claims.RegisteredClaims.IssuedAt = jwt.NewNumericDate(time.Now())
token := jwt.NewWithClaims(opt.signingMethod, claims)
return token.SignedString(opt.signingKey)
}
// -------------------------------------------------------------------------------------------
// KV map type
type KV = map[string]interface{}
// CustomClaims custom fields claims
type CustomClaims struct {
Fields KV `json:"fields"`
jwt.RegisteredClaims
}
// Get custom field value by key, if not found, return false
func (c *CustomClaims) Get(key string) (val interface{}, isExist bool) {
if c.Fields == nil {
return nil, false
}
val, isExist = c.Fields[key]
return val, isExist
}
// GetString custom field value by key, if not found, return false
func (c *CustomClaims) GetString(key string) (string, bool) {
val, isExist := c.Get(key)
if isExist {
str, ok := val.(string)
return str, ok
}
return "", false
}
// GetInt custom field value by key, if not found, return false
func (c *CustomClaims) GetInt(key string) (int, bool) {
val, isExist := c.Get(key)
if isExist {
if v, ok := val.(float64); ok {
return int(v), true
}
if v, ok := val.(int); ok {
return v, true
}
}
return 0, false
}
// GetUint64 custom field value by key, if not found, return false
func (c *CustomClaims) GetUint64(key string) (uint64, bool) {
val, isExist := c.Get(key)
if isExist {
if v, ok := val.(float64); ok {
return uint64(v), true
}
if v, ok := val.(uint64); ok {
return v, true
}
}
return 0, false
}
// GenerateCustomToken generate token by custom fields, use CustomClaims
func GenerateCustomToken(kv map[string]interface{}) (string, error) {
if opt == nil {
return "", errInit
}
claims := CustomClaims{
kv,
jwt.RegisteredClaims{
ExpiresAt: jwt.NewNumericDate(time.Now().Add(opt.expire)),
IssuedAt: jwt.NewNumericDate(time.Now()),
Issuer: opt.issuer,
},
}
token := jwt.NewWithClaims(opt.signingMethod, claims)
return token.SignedString(opt.signingKey)
}
// ParseCustomToken parse token, return CustomClaims
func ParseCustomToken(tokenString string) (*CustomClaims, error) {
if opt == nil {
return nil, errInit
}
cc := &CustomClaims{}
token, err := jwt.ParseWithClaims(tokenString, cc, func(token *jwt.Token) (interface{}, error) {
return opt.signingKey, nil
})
if err != nil {
return nil, err
}
if !token.Valid {
return nil, errSignature
}
return cc, nil
}
// RefreshCustomToken refresh custom token
func RefreshCustomToken(tokenString string) (string, error) {
claims, err := ParseCustomToken(tokenString)
if err != nil {
return "", err
}
claims.RegisteredClaims.ExpiresAt = jwt.NewNumericDate(time.Now().Add(opt.expire))
claims.RegisteredClaims.IssuedAt = jwt.NewNumericDate(time.Now())
token := jwt.NewWithClaims(opt.signingMethod, claims)
return token.SignedString(opt.signingKey)
}
pkg/jwt/jwt_test.go 0 → 100644
浏览文件 @ d57375cc
package jwt
import (
"errors"
"fmt"
"testing"
"time"
"github.com/stretchr/testify/assert"
)
func TestGenerateToken(t *testing.T) {
opt = nil
token, _, err := GenerateToken("123", "")
assert.Error(t, err)
Init()
token, _, err = GenerateToken("123", "")
assert.NoError(t, err)
v, err := ParseToken(token)
if err != nil {
t.Fatal(err)
}
t.Log(v)
time.Sleep(time.Second)
newToken, err := RefreshToken(token)
if err != nil {
t.Fatal(err)
}
t.Log(token, newToken)
}
func TestParseToken(t *testing.T) {
opt = nil
v, err := ParseToken("token")
assert.Error(t, err)
uid := "123"
name := "admin"
Init(
WithSigningKey("123456"),
WithExpire(time.Second),
WithSigningMethod(HS512),
)
// success
token, _, err := GenerateToken(uid, name)
if err != nil {
t.Fatal(err)
}
fmt.Println(token)
v, err = ParseToken(token)
if err != nil {
t.Fatal(err)
}
fmt.Println(v)
// invalid token format
token2 := "xxx.xxx.xxx"
v, err = ParseToken(token2)
assert.Error(t, err)
// signature failure
token3 := token + "xxx"
v, err = ParseToken(token3)
assert.Error(t, err)
// token has expired
token, _, err = GenerateToken(uid, name)
if err != nil {
t.Fatal(err)
}
time.Sleep(time.Second * 2)
v, err = ParseToken(token)
assert.True(t, errors.Is(err, ErrTokenExpired))
}
func TestParse(t *testing.T) {
Init(
WithSigningKey("6m2KywHIPEaWWIxffGpp8Dfl3z5SjE5WeeDStc1T64klnpoAqHrHN01vneteCAGE"),
WithExpire(time.Second),
WithSigningMethod(HS256),
)
token := "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJmaWVsZHMiOnsiY29tcGFueUlEIjoiNTIiLCJ1VHlwZSI6MiwidWlkIjoiMTMiLCJ1bmFtZSI6IuW8oOS4iSJ9LCJleHAiOjE3NTc2ODI2NzksImlhdCI6MTc1NzY2MTA3OX0.WqtvxF4XW52bC4mglFOg61i4D9mi7Bkb1ZZ00F4PB6k"
claims, err := ParseCustomToken(token)
if err != nil {
t.Error(err)
}
fmt.Println(claims)
}
func TestGenerateCustomToken(t *testing.T) {
var (
id uint64 = 20
name string = "admin"
age int = 10
fields = KV{"id": id, "name": name, "age": age}
)
Init()
token, err := GenerateCustomToken(fields)
assert.NoError(t, err)
claims, err := ParseCustomToken(token)
assert.NoError(t, err)
idValue, _ := claims.GetUint64("id")
assert.Equal(t, idValue, fields["id"])
nameValue, _ := claims.GetString("name")
assert.Equal(t, nameValue, fields["name"])
ageValue, _ := claims.GetInt("age")
assert.Equal(t, ageValue, fields["age"])
_, ok := claims.Get("foo")
assert.Equal(t, ok, false)
claims.Fields = nil
foo, _ := claims.Get("foo")
assert.Nil(t, foo)
time.Sleep(time.Second)
newToken, err := RefreshCustomToken(token)
if err != nil {
t.Fatal(err)
}
t.Log(token, newToken)
}
func TestParseCustomToken(t *testing.T) {
fields := KV{"id": 123, "foo": "bar"}
opt = nil
v, err := ParseCustomToken("token")
assert.Error(t, err)
Init(
WithSigningKey("123456"),
WithExpire(time.Second),
WithSigningMethod(HS512),
)
// success
token, err := GenerateCustomToken(fields)
if err != nil {
t.Fatal(err)
}
fmt.Println(token)
v, err = ParseCustomToken(token)
if err != nil {
t.Fatal(err)
}
fmt.Println(v)
// invalid token format
token2 := "xxx.xxx.xxx"
v, err = ParseCustomToken(token2)
assert.Error(t, err)
// signature failure
token3 := token + "xxx"
v, err = ParseCustomToken(token3)
assert.Error(t, err)
// token has expired
token, err = GenerateCustomToken(fields)
if err != nil {
t.Fatal(err)
}
time.Sleep(time.Second * 2)
v, err = ParseCustomToken(token)
assert.True(t, errors.Is(err, ErrTokenExpired))
}
pkg/jwt/option.go 0 → 100644
浏览文件 @ d57375cc
package jwt
import (
"errors"
"time"
"github.com/golang-jwt/jwt/v5"
)
var (
// HS256 Method
HS256 = jwt.SigningMethodHS256
// HS384 Method
HS384 = jwt.SigningMethodHS384
// HS512 Method
HS512 = jwt.SigningMethodHS512
)
var (
defaultSigningKey = []byte("zaq12wsxmko0") // default key
defaultSigningMethod = HS256 // default HS256
defaultExpire = 24 * time.Hour // default expiration
defaultIssuer = ""
)
type options struct {
signingKey []byte
expire time.Duration
issuer string
signingMethod *jwt.SigningMethodHMAC
}
func defaultOptions() *options {
return &options{
signingKey: defaultSigningKey,
signingMethod: defaultSigningMethod,
expire: defaultExpire,
issuer: defaultIssuer,
}
}
// Option set the jwt options.
type Option func(*options)
func (o *options) apply(opts ...Option) {
for _, opt := range opts {
opt(o)
}
}
// WithSigningKey set signing key value
func WithSigningKey(key string) Option {
return func(o *options) {
o.signingKey = []byte(key)
}
}
// WithSigningMethod set signing method value
func WithSigningMethod(sm *jwt.SigningMethodHMAC) Option {
return func(o *options) {
o.signingMethod = sm
}
}
// WithExpire set expire value
func WithExpire(d time.Duration) Option {
return func(o *options) {
o.expire = d
}
}
// WithIssuer set issuer value
func WithIssuer(issuer string) Option {
return func(o *options) {
o.issuer = issuer
}
}
var (
errSignature = errors.New("signature failure")
errInit = errors.New("not yet initialized jwt, usage 'jwt.Init()'")
)
pkg/jwt/option_test.go 0 → 100644
浏览文件 @ d57375cc
package jwt
import (
"testing"
"time"
"github.com/golang-jwt/jwt/v5"
"github.com/stretchr/testify/assert"
)
func TestInit(t *testing.T) {
Init(WithSigningKey("foo"))
}
func TestWithExpire(t *testing.T) {
testData := time.Second * 3
opt := WithExpire(testData)
o := new(options)
o.apply(opt)
assert.Equal(t, testData, o.expire)
}
func TestWithIssuer(t *testing.T) {
testData := "issuer"
opt := WithIssuer(testData)
o := new(options)
o.apply(opt)
assert.Equal(t, testData, o.issuer)
}
func TestWithSigningKey(t *testing.T) {
testData := "key"
opt := WithSigningKey(testData)
o := new(options)
o.apply(opt)
assert.Equal(t, testData, string(o.signingKey))
}
func TestWithSigningMethod(t *testing.T) {
testData := jwt.SigningMethodHS384
opt := WithSigningMethod(testData)
o := new(options)
o.apply(opt)
assert.Equal(t, testData, o.signingMethod)
}
func Test_defaultOptions(t *testing.T) {
o := defaultOptions()
assert.NotNil(t, o)
}
func Test_options_apply(t *testing.T) {
testData := "key"
opt := WithSigningKey(testData)
o := new(options)
o.apply(opt)
assert.Equal(t, testData, string(o.signingKey))
}
pkg/logger/logger.go
浏览文件 @ d57375cc
...@@ -58,7 +58,7 @@ func Init(cfg Config) (err error) { ...@@ -58,7 +58,7 @@ func Init(cfg Config) (err error) {
if err != nil { if err != nil {
return err return err
} }
Info("[olog] initialized") Info("[logger] initialized")
return nil return nil
} }
...@@ -95,10 +95,10 @@ func InitWithOptions(opts ...Option) (*zap.Logger, error) { ...@@ -95,10 +95,10 @@ func InitWithOptions(opts ...Option) (*zap.Logger, error) {
if err != nil { if err != nil {
panic(err) panic(err)
} }
str = fmt.Sprintf("[olog] config is output to 'terminal', format=%s, level=%s", encoding, levelName) str = fmt.Sprintf("[logger] config is output to 'terminal', format=%s, level=%s", encoding, levelName)
} else { } else {
zapLog = log2File(encoding, levelName, o.fileConfig) zapLog = log2File(encoding, levelName, o.fileConfig)
str = fmt.Sprintf("[olog] config is output to 'file', format=%s, level=%s, file=%s", encoding, levelName, o.fileConfig.filename) str = fmt.Sprintf("[logger] config is output to 'file', format=%s, level=%s, file=%s", encoding, levelName, o.fileConfig.filename)
} }
if len(o.hooks) > 0 { if len(o.hooks) > 0 {
......
pkg/shield/circuitbreaker/README.md 0 → 100644
浏览文件 @ d57375cc
## circuitbreaker
Circuit Breaker for web middleware and rpc interceptor.
<br>
### Example of use
**gin circuit breaker middleware**
```go
import "gitlab.wanzhuangkj.com/tush/xpkg/pkg/shield/circuitbreaker"
// CircuitBreaker a circuit breaker middleware
func CircuitBreaker(opts ...CircuitBreakerOption) gin.HandlerFunc {
o := defaultCircuitBreakerOptions()
o.apply(opts...)
return func(c *gin.Context) {
breaker := o.group.Get(c.FullPath()).(circuitbreaker.CircuitBreaker)
if err := breaker.Allow(); err != nil {
// NOTE: when client reject request locally, keep adding counter let the drop ratio higher.
breaker.MarkFailed()
response.Output(c, http.StatusServiceUnavailable, err.Error())
c.Abort()
return
}
c.Next()
code := c.Writer.Status()
// NOTE: need to check internal and service unavailable error, e.g. http.StatusInternalServerError
_, isHit := o.validCodes[code]
if isHit {
breaker.MarkFailed()
} else {
breaker.MarkSuccess()
}
}
}
```
<br>
**rpc server circuit breaker interceptor**
```go
import "gitlab.wanzhuangkj.com/tush/xpkg/pkg/shield/circuitbreaker"
// UnaryServerCircuitBreaker server-side unary circuit breaker interceptor
func UnaryServerCircuitBreaker(opts ...CircuitBreakerOption) grpc.UnaryServerInterceptor {
o := defaultCircuitBreakerOptions()
o.apply(opts...)
return func(ctx context.Context, req interface{}, info *grpc.UnaryServerInfo, handler grpc.UnaryHandler) (interface{}, error) {
breaker := o.group.Get(info.FullMethod).(circuitbreaker.CircuitBreaker)
if err := breaker.Allow(); err != nil {
// NOTE: when client reject request locally, keep adding let the drop ratio higher.
breaker.MarkFailed()
return nil, errcode.StatusServiceUnavailable.ToRPCErr(err.Error())
}
reply, err := handler(ctx, req)
if err != nil {
// NOTE: need to check internal and service unavailable error
s, ok := status.FromError(err)
_, isHit := o.validCodes[s.Code()]
if ok && isHit {
breaker.MarkFailed()
} else {
breaker.MarkSuccess()
}
}
return reply, err
}
}
```
pkg/shield/circuitbreaker/circuitbreaker.go 0 → 100644
浏览文件 @ d57375cc
// Package circuitbreaker is an adaptive circuit breaker library, support for use in gin middleware and grpc interceptors.
package circuitbreaker
import (
"errors"
)
// ErrNotAllowed error not allowed.
var ErrNotAllowed = errors.New("circuitbreaker: not allowed for circuit open")
// CircuitBreaker is a circuit breaker.
type CircuitBreaker interface {
Allow() error
MarkSuccess()
MarkFailed()
}
pkg/shield/circuitbreaker/circuitbreaker_test.go 0 → 100644
浏览文件 @ d57375cc
package circuitbreaker_test
import (
"testing"
"gitlab.wanzhuangkj.com/tush/xpkg/pkg/shield/circuitbreaker"
)
// This is an example of using a circuit breaker Do() when return nil.
func TestCircuitBreaker(t *testing.T) {
b := circuitbreaker.NewBreaker()
for i := 0; i < 1000; i++ {
b.MarkSuccess()
}
for i := 0; i < 100; i++ {
b.MarkFailed()
}
err := b.Allow()
t.Log(err)
// Output: err=<nil>
}
pkg/shield/circuitbreaker/sre.go 0 → 100644
浏览文件 @ d57375cc
package circuitbreaker
import (
"math"
"math/rand"
"sync"
"sync/atomic"
"time"
"gitlab.wanzhuangkj.com/tush/opkg/pkg/shield/window"
)
// Option is sre breaker option function.
type Option func(*options)
const (
// StateOpen when circuit breaker open, request not allowed, after sleep
// some duration, allow one single request for testing the health, if ok
// then state reset to closed, if not continue the step.
StateOpen int32 = iota
// StateClosed when circuit breaker closed, request allowed, the breaker
// calc the succeed ratio, if request num greater request setting and
// ratio lower than the setting ratio, then reset state to open.
StateClosed
)
var (
_ CircuitBreaker = &Breaker{}
)
// options is a breaker options.
type options struct {
success float64
request int64
bucket int
window time.Duration
}
// WithSuccess with the K = 1 / Success value of sre breaker, default success is 0.5
// Reducing the K will make adaptive throttling behave more aggressively,
// Increasing the K will make adaptive throttling behave less aggressively.
func WithSuccess(s float64) Option {
return func(c *options) {
c.success = s
}
}
// WithRequest with the minimum number of requests allowed.
func WithRequest(r int64) Option {
return func(c *options) {
c.request = r
}
}
// WithWindow with the duration size of the statistical window.
func WithWindow(d time.Duration) Option {
return func(c *options) {
c.window = d
}
}
// WithBucket set the bucket number in a window duration.
func WithBucket(b int) Option {
return func(c *options) {
c.bucket = b
}
}
// Breaker is a sre CircuitBreaker pattern.
type Breaker struct {
stat window.RollingCounter
r *rand.Rand
// rand.New(...) returns a non thread safe object
randLock sync.Mutex
// Reducing the k will make adaptive throttling behave more aggressively,
// Increasing the k will make adaptive throttling behave less aggressively.
k float64
request int64
state int32
}
// NewBreaker return a sreBresker with options
func NewBreaker(opts ...Option) CircuitBreaker {
opt := options{
success: 0.6,
request: 100,
bucket: 10,
window: 3 * time.Second,
}
for _, o := range opts {
o(&opt)
}
counterOpts := window.RollingCounterOpts{
Size: opt.bucket,
BucketDuration: time.Duration(int64(opt.window) / int64(opt.bucket)),
}
stat := window.NewRollingCounter(counterOpts)
return &Breaker{
stat: stat,
r: rand.New(rand.NewSource(time.Now().UnixNano())),
request: opt.request,
k: 1 / opt.success,
state: StateClosed,
}
}
func (b *Breaker) summary() (success int64, total int64) {
b.stat.Reduce(func(iterator window.Iterator) float64 {
for iterator.Next() {
bucket := iterator.Bucket()
total += bucket.Count
for _, p := range bucket.Points {
success += int64(p)
}
}
return 0
})
return //nolint
}
// Allow request if error returns nil.
func (b *Breaker) Allow() error {
// The number of requests accepted by the backend
accepts, total := b.summary()
// The number of requests attempted by the application layer(at the client, on top of the adaptive throttling system)
requests := b.k * float64(accepts)
// check overflow requests = K * accepts
if total < b.request || float64(total) < requests {
atomic.CompareAndSwapInt32(&b.state, StateOpen, StateClosed)
return nil
}
atomic.CompareAndSwapInt32(&b.state, StateClosed, StateOpen)
dr := math.Max(0, (float64(total)-requests)/float64(total+1))
drop := b.trueOnProba(dr)
if drop {
return ErrNotAllowed
}
return nil
}
// MarkSuccess mark request is success.
func (b *Breaker) MarkSuccess() {
b.stat.Add(1)
}
// MarkFailed mark request is failed.
func (b *Breaker) MarkFailed() {
// NOTE: when client reject request locally, keep adding counter let the drop ratio higher.
b.stat.Add(0)
}
func (b *Breaker) trueOnProba(proba float64) (truth bool) {
b.randLock.Lock()
truth = b.r.Float64() < proba
b.randLock.Unlock()
return truth
}
pkg/shield/cpu/cgroup.go 0 → 100644
浏览文件 @ d57375cc
package cpu
import (
"bufio"
"fmt"
"io"
"os"
"path"
"strconv"
"strings"
)
const cgroupRootDir = "/sys/fs/cgroup"
// cgroup Linux cgroup
type cgroup struct {
cgroupSet map[string]string
}
// CPUCFSQuotaUs cpu.cfs_quota_us
func (c *cgroup) CPUCFSQuotaUs() (int64, error) {
data, err := readFile(path.Join(c.cgroupSet["cpu"], "cpu.cfs_quota_us"))
if err != nil {
return 0, err
}
return strconv.ParseInt(data, 10, 64)
}
// CPUCFSPeriodUs cpu.cfs_period_us
func (c *cgroup) CPUCFSPeriodUs() (uint64, error) {
data, err := readFile(path.Join(c.cgroupSet["cpu"], "cpu.cfs_period_us"))
if err != nil {
return 0, err
}
return parseUint(data)
}
// CPUAcctUsage cpuacct.usage
func (c *cgroup) CPUAcctUsage() (uint64, error) {
data, err := readFile(path.Join(c.cgroupSet["cpuacct"], "cpuacct.usage"))
if err != nil {
return 0, err
}
return parseUint(data)
}
// CPUAcctUsagePerCPU cpuacct.usage_percpu
func (c *cgroup) CPUAcctUsagePerCPU() ([]uint64, error) {
data, err := readFile(path.Join(c.cgroupSet["cpuacct"], "cpuacct.usage_percpu"))
if err != nil {
return nil, err
}
var usage []uint64
for _, v := range strings.Fields(data) {
var u uint64
if u, err = parseUint(v); err != nil {
return nil, err
}
// fix possible_cpu:https://www.ibm.com/support/knowledgecenter/en/linuxonibm/com.ibm.linux.z.lgdd/lgdd_r_posscpusparm.html
if u != 0 {
usage = append(usage, u)
}
}
return usage, nil
}
// CPUSetCPUs cpuset.cpus
func (c *cgroup) CPUSetCPUs() ([]uint64, error) {
data, err := readFile(path.Join(c.cgroupSet["cpuset"], "cpuset.cpus"))
if err != nil {
return nil, err
}
cpus, err := ParseUintList(data)
if err != nil {
return nil, err
}
sets := make([]uint64, 0)
for k := range cpus {
sets = append(sets, uint64(k))
}
return sets, nil
}
// CurrentcGroup get current process cgroup
func currentcGroup() (*cgroup, error) {
pid := os.Getpid()
cgroupFile := fmt.Sprintf("/proc/%d/cgroup", pid)
cgroupSet := make(map[string]string)
fp, err := os.Open(cgroupFile)
if err != nil {
return nil, err
}
defer fp.Close() //nolint
buf := bufio.NewReader(fp)
for {
line, err := buf.ReadString('\n')
if err != nil {
if err == io.EOF {
break
}
return nil, err
}
col := strings.Split(strings.TrimSpace(line), ":")
if len(col) != 3 {
return nil, fmt.Errorf("invalid cgroup format %s", line)
}
dir := col[2]
// When dir is not equal to /, it must be in docker
if dir != "/" {
cgroupSet[col[1]] = path.Join(cgroupRootDir, col[1])
if strings.Contains(col[1], ",") {
for _, k := range strings.Split(col[1], ",") {
cgroupSet[k] = path.Join(cgroupRootDir, k)
}
}
} else {
cgroupSet[col[1]] = path.Join(cgroupRootDir, col[1], col[2])
if strings.Contains(col[1], ",") {
for _, k := range strings.Split(col[1], ",") {
cgroupSet[k] = path.Join(cgroupRootDir, k, col[2])
}
}
}
}
return &cgroup{cgroupSet: cgroupSet}, nil
}
pkg/shield/cpu/cgroup_cpu.go 0 → 100644
浏览文件 @ d57375cc
package cpu
import (
"bufio"
"errors"
"os"
"strconv"
"strings"
pscpu "github.com/shirou/gopsutil/v3/cpu"
)
type cgroupCPU struct {
frequency uint64
quota float64
cores uint64
preSystem uint64
preTotal uint64
}
func newCgroupCPU() (cpu *cgroupCPU, err error) {
cores, err := pscpu.Counts(true)
if err != nil || cores == 0 {
var cpus []uint64
cpus, err = perCPUUsage()
if err != nil {
return nil, err
}
cores = len(cpus)
}
sets, err := cpuSets()
if err != nil {
return nil, err
}
quota := float64(len(sets))
cq, err := cpuQuota()
if err == nil && cq != -1 {
var period uint64
if period, err = cpuPeriod(); err != nil {
return nil, err
}
limit := float64(cq) / float64(period)
if limit < quota {
quota = limit
}
}
maxFreq := cpuMaxFreq()
preSystem, err := systemCPUUsage()
if err != nil {
return nil, err
}
preTotal, err := totalCPUUsage()
if err != nil {
return nil, err
}
cpu = &cgroupCPU{
frequency: maxFreq,
quota: quota,
cores: uint64(cores),
preSystem: preSystem,
preTotal: preTotal,
}
return cpu, nil
}
func (cpu *cgroupCPU) Usage() (u uint64, err error) {
var (
total uint64
system uint64
)
total, err = totalCPUUsage()
if err != nil {
return 0, err
}
system, err = systemCPUUsage()
if err != nil {
return 0, err
}
if system != cpu.preSystem {
u = uint64(float64((total-cpu.preTotal)*cpu.cores*1e3) / (float64(system-cpu.preSystem) * cpu.quota))
}
cpu.preSystem = system
cpu.preTotal = total
return u, err
}
func (cpu *cgroupCPU) Info() Info {
return Info{
Frequency: cpu.frequency,
Quota: cpu.quota,
}
}
const nanoSecondsPerSecond = 1e9
// ErrNoCFSLimit is no quota limit
var ErrNoCFSLimit = errors.New("no quota limit")
var clockTicksPerSecond = uint64(getClockTicks())
// systemCPUUsage returns the host system's cpu usage in
// nanoseconds. An error is returned if the format of the underlying
// file does not match.
//
// Uses /proc/stat defined by POSIX. Looks for the cpu
// statistics line and then sums up the first seven fields
// provided. See man 5 proc for details on specific field
// information.
func systemCPUUsage() (usage uint64, err error) {
var (
line string
f *os.File
)
if f, err = os.Open("/proc/stat"); err != nil {
return usage, err
}
bufReader := bufio.NewReaderSize(nil, 128)
defer func() {
bufReader.Reset(nil)
_ = f.Close()
}()
bufReader.Reset(f)
for err == nil {
if line, err = bufReader.ReadString('\n'); err != nil {
return usage, err
}
parts := strings.Fields(line)
if parts[0] == "cpu" {
if len(parts) < 8 {
err = errors.New("bad format of cpu stats")
return usage, err
}
var totalClockTicks uint64
for _, i := range parts[1:8] {
var v uint64
if v, err = strconv.ParseUint(i, 10, 64); err != nil {
return usage, err
}
totalClockTicks += v
}
usage = (totalClockTicks * nanoSecondsPerSecond) / clockTicksPerSecond
return usage, nil
}
}
err = errors.New("bad stats format")
return usage, err
}
func totalCPUUsage() (usage uint64, err error) {
var cg *cgroup
if cg, err = currentcGroup(); err != nil {
return 0, err
}
return cg.CPUAcctUsage()
}
func perCPUUsage() (usage []uint64, err error) {
var cg *cgroup
if cg, err = currentcGroup(); err != nil {
return nil, err
}
return cg.CPUAcctUsagePerCPU()
}
func cpuSets() (sets []uint64, err error) {
var cg *cgroup
if cg, err = currentcGroup(); err != nil {
return nil, err
}
return cg.CPUSetCPUs()
}
func cpuQuota() (quota int64, err error) {
var cg *cgroup
if cg, err = currentcGroup(); err != nil {
return 0, err
}
return cg.CPUCFSQuotaUs()
}
func cpuPeriod() (peroid uint64, err error) {
var cg *cgroup
if cg, err = currentcGroup(); err != nil {
return 0, err
}
return cg.CPUCFSPeriodUs()
}
func cpuFreq() uint64 {
lines, err := readLines("/proc/cpuinfo")
if err != nil {
return 0
}
for _, line := range lines {
fields := strings.Split(line, ":")
if len(fields) < 2 {
continue
}
key := strings.TrimSpace(fields[0])
value := strings.TrimSpace(fields[1])
if key == "cpu MHz" || key == "clock" {
// treat this as the fallback value, thus we ignore error
if t, err := strconv.ParseFloat(strings.Replace(value, "MHz", "", 1), 64); err == nil {
return uint64(t * 1000.0 * 1000.0)
}
}
}
return 0
}
func cpuMaxFreq() uint64 {
feq := cpuFreq()
data, err := readFile("/sys/devices/system/cpu/cpu0/cpufreq/cpuinfo_max_freq")
if err != nil {
return feq
}
// override the max freq from /proc/cpuinfo
cfeq, err := parseUint(data)
if err == nil {
feq = cfeq
}
return feq
}
// GetClockTicks get the OS's ticks per second
func getClockTicks() int {
// TODO figure out a better alternative for platforms where we're missing cgo
//
// TODO Windows. This could be implemented using Win32 QueryPerformanceFrequency().
// https://msdn.microsoft.com/en-us/library/windows/desktop/ms644905(v=vs.85).aspx
//
// An example of its usage can be found here.
// https://msdn.microsoft.com/en-us/library/windows/desktop/dn553408(v=vs.85).aspx
return 100
}
pkg/shield/cpu/cgroup_test.go 0 → 100644
浏览文件 @ d57375cc
package cpu
import "testing"
func TestCgroup(t *testing.T) {
cgroup := &cgroup{cgroupSet: map[string]string{}}
us, err := cgroup.CPUCFSQuotaUs()
t.Log(us, err)
pus, err := cgroup.CPUCFSPeriodUs()
t.Log(pus, err)
usage, err := cgroup.CPUAcctUsage()
t.Log(usage, err)
pUsage, err := cgroup.CPUAcctUsagePerCPU()
t.Log(pUsage, err)
cpus, err := cgroup.CPUSetCPUs()
t.Log(cpus, err)
cgr, err := currentcGroup()
t.Log(cgr, err)
}
func TestCgroupCPUObj(t *testing.T) {
cgCPU := &cgroupCPU{
frequency: 3000,
quota: 12,
cores: 12,
preSystem: 10,
preTotal: 10,
}
usage, err := cgCPU.Usage()
t.Log(usage, err)
info := cgCPU.Info()
t.Log(info)
}
func TestCgroupCPU(t *testing.T) {
usage, err := systemCPUUsage()
t.Log(usage, err)
usage, err = totalCPUUsage()
t.Log(usage, err)
usages, err := perCPUUsage()
t.Log(usages, err)
sets, err := cpuSets()
t.Log(sets, err)
quota, err := cpuQuota()
t.Log(quota, err)
period, err := cpuPeriod()
t.Log(period, err)
freq := cpuFreq()
t.Log(freq, err)
maxFreq := cpuMaxFreq()
t.Log(maxFreq, err)
}
pkg/shield/cpu/psutil_cpu.go 0 → 100644
浏览文件 @ d57375cc
// Package cpu is a library that calculates cpu and memory usage.
package cpu
import (
"time"
"github.com/shirou/gopsutil/v3/cpu"
)
type psutilCPU struct {
interval time.Duration
}
func newPsutilCPU(interval time.Duration) (*psutilCPU, error) {
psCPU := &psutilCPU{interval: interval}
_, err := psCPU.Usage()
if err != nil {
return nil, err
}
return psCPU, nil
}
func (ps *psutilCPU) Usage() (uint64, error) {
var u uint64
percents, err := cpu.Percent(ps.interval, false)
if err == nil {
u = uint64(percents[0] * 10)
}
return u, err
}
func (ps *psutilCPU) Info() Info {
stats, err := cpu.Info()
if err != nil {
return Info{}
}
cores, err := cpu.Counts(true)
if err != nil {
return Info{}
}
return Info{
Frequency: uint64(stats[0].Mhz),
Quota: float64(cores),
}
}
pkg/shield/cpu/stat.go 0 → 100644
浏览文件 @ d57375cc
package cpu
import (
"fmt"
"sync/atomic"
"time"
)
const (
interval time.Duration = time.Millisecond * 500
)
var (
stats CPU
usage uint64
)
// CPU is cpu stat usage.
type CPU interface {
Usage() (u uint64, e error)
Info() Info
}
func init() {
var err error
stats, err = newCgroupCPU()
if err != nil {
errStr := err.Error()
stats, err = newPsutilCPU(interval)
if err != nil {
errStr += " | " + err.Error()
fmt.Printf(`
[ERROR] cgroup cpu init and psutil cpu init are all failed, %s.
the dependency library https://github.com/shirou/gopsutil does not support getting this CPU information.
[NOTE] After using the project code generated by xmall, please set "enableStat", "enableLimit" and "enableCircuitBreaker"
in configs/xxx.yml to false, which will not affect the normal use of the application.
`, errStr)
return
}
}
go func() {
ticker := time.NewTicker(interval)
defer ticker.Stop()
for {
<-ticker.C
u, err := stats.Usage()
if err == nil && u != 0 {
atomic.StoreUint64(&usage, u)
}
}
}()
}
// Stat cpu stat.
type Stat struct {
Usage uint64 // cpu use ratio.
}
// Info cpu info.
type Info struct {
Frequency uint64
Quota float64
}
// ReadStat read cpu stat.
func ReadStat(stat *Stat) {
stat.Usage = atomic.LoadUint64(&usage)
}
// GetInfo get cpu info.
func GetInfo() Info {
return stats.Info()
}
pkg/shield/cpu/stat_test.go 0 → 100644
浏览文件 @ d57375cc
package cpu
import (
"testing"
"time"
)
func TestStat(t *testing.T) {
time.Sleep(time.Second * 2)
var s Stat
var i Info
ReadStat(&s)
i = GetInfo()
t.Log(s.Usage, i.Frequency, i.Quota)
}
pkg/shield/cpu/utils.go 0 → 100644
浏览文件 @ d57375cc
package cpu
import (
"bufio"
"fmt"
"os"
"strconv"
"strings"
)
func readFile(path string) (string, error) {
contents, err := os.ReadFile(path)
if err != nil {
return "", err
}
return strings.TrimSpace(string(contents)), nil
}
func parseUint(s string) (uint64, error) {
v, err := strconv.ParseUint(s, 10, 64)
if err != nil {
intValue, intErr := strconv.ParseInt(s, 10, 64)
// 1. Handle negative values greater than MinInt64 (and)
// 2. Handle negative values lesser than MinInt64
if intErr == nil && intValue < 0 {
return 0, nil
} else if intErr != nil &&
intErr.(*strconv.NumError).Err == strconv.ErrRange &&
intValue < 0 {
return 0, nil
}
return 0, err
}
return v, nil
}
// ParseUintList parses and validates the specified string as the value
// found in some cgroup file (e.g. cpuset.cpus, cpuset.mems), which could be
// one of the formats below. Note that duplicates are actually allowed in the
// input string. It returns a map[int]bool with available elements from val
// set to true.
// Supported formats:
// 7
// 1-6
// 0,3-4,7,8-10
// 0-0,0,1-7
// 03,1-3 <- this is gonna get parsed as [1,2,3]
// 3,2,1
// 0-2,3,1
func ParseUintList(val string) (map[int]bool, error) {
if val == "" {
return map[int]bool{}, nil
}
availableInts := make(map[int]bool)
split := strings.Split(val, ",")
errInvalidFormat := fmt.Errorf("os/stat: invalid format: %s", val)
for _, r := range split {
if !strings.Contains(r, "-") {
v, err := strconv.Atoi(r)
if err != nil {
return nil, errInvalidFormat
}
availableInts[v] = true
} else {
split := strings.SplitN(r, "-", 2)
min, err := strconv.Atoi(split[0])
if err != nil {
return nil, errInvalidFormat
}
max, err := strconv.Atoi(split[1])
if err != nil {
return nil, errInvalidFormat
}
if max < min {
return nil, errInvalidFormat
}
for i := min; i <= max; i++ {
availableInts[i] = true
}
}
}
return availableInts, nil
}
// ReadLines reads contents from a file and splits them by new lines.
// A convenience wrapper to ReadLinesOffsetN(filename, 0, -1).
func readLines(filename string) ([]string, error) {
return readLinesOffsetN(filename, 0, -1)
}
// ReadLinesOffsetN reads contents from file and splits them by new line.
// The offset tells at which line number to start.
// The count determines the number of lines to read (starting from offset):
//
// n >= 0: at most n lines
// n < 0: whole file
func readLinesOffsetN(filename string, offset uint, n int) ([]string, error) {
f, err := os.Open(filename)
if err != nil {
return []string{""}, err
}
defer f.Close() //nolint
var ret []string
r := bufio.NewReader(f)
for i := 0; i < n+int(offset) || n < 0; i++ {
line, err := r.ReadString('\n')
if err != nil {
break
}
if i < int(offset) {
continue
}
ret = append(ret, strings.Trim(line, "\n"))
}
return ret, nil
}
pkg/shield/cpu/utils_test.go 0 → 100644
浏览文件 @ d57375cc
package cpu
import (
"testing"
"github.com/stretchr/testify/assert"
)
func Testutils(t *testing.T) {
_, err := readFile("notfound")
assert.Error(t, err)
_, err = readFile("utils.go")
assert.NoError(t, err)
_, err = parseUint("-100")
assert.Nil(t, err)
_, err = parseUint("abc")
assert.Error(t, err)
_, err = parseUint("100")
_, err = ParseUintList("")
assert.Nil(t, err)
_, err = readLines("notfound")
assert.Error(t, err)
_, err = readLinesOffsetN("test.data", 0, -1)
assert.NoError(t, err)
}
func TestParseUintList(t *testing.T) {
testData := []string{
"",
"7",
"1-6",
"0,3-4,7,8-10",
"0-0,0,1-7",
"03,1-3",
"3,2,1",
"0-2,3,1",
}
for _, val := range testData {
_, err := ParseUintList(val)
assert.NoError(t, err)
}
}
pkg/shield/ratelimit/bbr.go 0 → 100644
浏览文件 @ d57375cc
// Package ratelimit is an adaptive rate limit library, support for use in gin middleware and grpc interceptors.
package ratelimit
import (
"math"
"runtime"
"sync/atomic"
"time"
"gitlab.wanzhuangkj.com/tush/xpkg/pkg/shield/cpu"
"gitlab.wanzhuangkj.com/tush/xpkg/pkg/shield/window"
)
var (
gCPU int64
decay = 0.95
_ Limiter = &BBR{}
)
type (
cpuGetter func() int64
// Option function for bbr limiter
Option func(*options)
)
func init() {
go cpuproc()
}
// cpu = cpuᵗ⁻¹ * decay + cpuᵗ * (1 - decay)
func cpuproc() {
ticker := time.NewTicker(time.Millisecond * 500) // same to cpu sample rate
defer func() {
ticker.Stop()
if err := recover(); err != nil {
go cpuproc()
}
}()
// EMA algorithm: https://blog.csdn.net/m0_38106113/article/details/81542863
for range ticker.C {
stat := &cpu.Stat{}
cpu.ReadStat(stat)
stat.Usage = min(stat.Usage, 1000)
prevCPU := atomic.LoadInt64(&gCPU)
curCPU := int64(float64(prevCPU)*decay + float64(stat.Usage)*(1.0-decay))
atomic.StoreInt64(&gCPU, curCPU)
}
}
func min(l, r uint64) uint64 {
if l < r {
return l
}
return r
}
// Stat contains the metrics snapshot of bbr.
type Stat struct {
CPU int64
InFlight int64
MaxInFlight int64
MinRt int64
MaxPass int64
}
// counterCache is used to cache maxPASS and minRt result.
// Value of current bucket is not counted in real time.
// Cache time is equal to a bucket duration.
type counterCache struct {
val int64
time time.Time
}
// options of bbr limiter.
type options struct {
// WindowSize defines time duration per window
Window time.Duration
// BucketNum defines bucket number for each window
Bucket int
// CPUThreshold
CPUThreshold int64
// CPUQuota
CPUQuota float64
}
// WithWindow with window size.
func WithWindow(d time.Duration) Option {
return func(o *options) {
o.Window = d
}
}
// WithBucket with bucket ize.
func WithBucket(b int) Option {
return func(o *options) {
o.Bucket = b
}
}
// WithCPUThreshold with cpu threshold;
func WithCPUThreshold(threshold int64) Option {
return func(o *options) {
o.CPUThreshold = threshold
}
}
// WithCPUQuota with real cpu quota(if it can not collect from process correct);
func WithCPUQuota(quota float64) Option {
return func(o *options) {
o.CPUQuota = quota
}
}
// BBR implements bbr-like limiter.
// It is inspired by sentinel.
// https://github.com/alibaba/Sentinel/wiki/%E7%B3%BB%E7%BB%9F%E8%87%AA%E9%80%82%E5%BA%94%E9%99%90%E6%B5%81
type BBR struct {
cpu cpuGetter
passStat window.RollingCounter
rtStat window.RollingCounter
inFlight int64
bucketPerSecond int64
bucketDuration time.Duration
// prevDropTime defines previous start drop since initTime
prevDropTime atomic.Value
maxPASSCache atomic.Value
minRtCache atomic.Value
opts options
}
// NewLimiter returns a bbr limiter
func NewLimiter(opts ...Option) *BBR {
opt := options{
Window: time.Second * 10,
Bucket: 100,
CPUThreshold: 800,
}
for _, o := range opts {
o(&opt)
}
bucketDuration := opt.Window / time.Duration(opt.Bucket)
passStat := window.NewRollingCounter(window.RollingCounterOpts{Size: opt.Bucket, BucketDuration: bucketDuration})
rtStat := window.NewRollingCounter(window.RollingCounterOpts{Size: opt.Bucket, BucketDuration: bucketDuration})
limiter := &BBR{
opts: opt,
passStat: passStat,
rtStat: rtStat,
bucketDuration: bucketDuration,
bucketPerSecond: int64(time.Second / bucketDuration),
cpu: func() int64 { return atomic.LoadInt64(&gCPU) },
}
if opt.CPUQuota != 0 {
// if cpuQuota is set, use new cpuGetter,Calculate the real CPU value based on the number of CPUs and Quota.
limiter.cpu = func() int64 {
return int64(float64(atomic.LoadInt64(&gCPU)) * float64(runtime.NumCPU()) / opt.CPUQuota)
}
}
return limiter
}
func (l *BBR) maxPASS() int64 {
passCache := l.maxPASSCache.Load()
if passCache != nil {
ps := passCache.(*counterCache)
if l.timespan(ps.time) < 1 {
return ps.val
}
}
rawMaxPass := int64(l.passStat.Reduce(func(iterator window.Iterator) float64 {
var result = 1.0
for i := 1; iterator.Next() && i < l.opts.Bucket; i++ {
bucket := iterator.Bucket()
count := 0.0
for _, p := range bucket.Points {
count += p
}
result = math.Max(result, count)
}
return result
}))
l.maxPASSCache.Store(&counterCache{
val: rawMaxPass,
time: time.Now(),
})
return rawMaxPass
}
// timespan returns the passed bucket count
// since lastTime, if it is one bucket duration earlier than
// the last recorded time, it will return the BucketNum.
func (l *BBR) timespan(lastTime time.Time) int {
v := int(time.Since(lastTime) / l.bucketDuration)
if v > -1 {
return v
}
return l.opts.Bucket
}
func (l *BBR) minRT() int64 {
rtCache := l.minRtCache.Load()
if rtCache != nil {
rc := rtCache.(*counterCache)
if l.timespan(rc.time) < 1 {
return rc.val
}
}
rawMinRT := int64(math.Ceil(l.rtStat.Reduce(func(iterator window.Iterator) float64 {
var result = math.MaxFloat64
for i := 1; iterator.Next() && i < l.opts.Bucket; i++ {
bucket := iterator.Bucket()
if len(bucket.Points) == 0 {
continue
}
total := 0.0
for _, p := range bucket.Points {
total += p
}
avg := total / float64(bucket.Count)
result = math.Min(result, avg)
}
return result
})))
if rawMinRT <= 0 {
rawMinRT = 1
}
l.minRtCache.Store(&counterCache{
val: rawMinRT,
time: time.Now(),
})
return rawMinRT
}
func (l *BBR) maxInFlight() int64 {
return int64(math.Floor(float64(l.maxPASS()*l.minRT()*l.bucketPerSecond)/1000.0) + 0.5)
}
func (l *BBR) shouldDrop() bool {
now := time.Duration(time.Now().UnixNano())
if l.cpu() < l.opts.CPUThreshold {
// current cpu payload below the threshold
prevDropTime, _ := l.prevDropTime.Load().(time.Duration)
if prevDropTime == 0 {
// haven't start drop,
// accept current request
return false
}
if now-prevDropTime <= time.Second {
// just start drop one second ago, check current inflight count
inFlight := atomic.LoadInt64(&l.inFlight)
return inFlight > 1 && inFlight > l.maxInFlight()
}
l.prevDropTime.Store(time.Duration(0))
return false
}
// current cpu payload exceeds the threshold
inFlight := atomic.LoadInt64(&l.inFlight)
drop := inFlight > 1 && inFlight > l.maxInFlight()
if drop {
prevDrop, _ := l.prevDropTime.Load().(time.Duration)
if prevDrop != 0 {
// already started drop, return directly
return drop
}
// store start drop time
l.prevDropTime.Store(now)
}
return drop
}
// Stat tasks a snapshot of the bbr limiter.
func (l *BBR) Stat() Stat {
return Stat{
CPU: l.cpu(),
MinRt: l.minRT(),
MaxPass: l.maxPASS(),
MaxInFlight: l.maxInFlight(),
InFlight: atomic.LoadInt64(&l.inFlight),
}
}
// Allow checks all inbound traffic.
// Once overload is detected, it raises limit.ErrLimitExceed error.
func (l *BBR) Allow() (DoneFunc, error) {
if l.shouldDrop() {
return nil, ErrLimitExceed
}
atomic.AddInt64(&l.inFlight, 1)
start := time.Now().UnixNano()
ms := float64(time.Millisecond)
return func(DoneInfo) {
rt := int64(math.Ceil(float64(time.Now().UnixNano()-start)) / ms) //nolint
l.rtStat.Add(rt)
atomic.AddInt64(&l.inFlight, -1)
l.passStat.Add(1)
}, nil
}
pkg/shield/ratelimit/bbr_test.go 0 → 100644
浏览文件 @ d57375cc
package ratelimit
import (
"math/rand"
"sync"
"sync/atomic"
"testing"
"time"
"github.com/stretchr/testify/assert"
"gitlab.wanzhuangkj.com/tush/xpkg/pkg/shield/window"
)
var (
windowSizeTest = time.Second
bucketNumTest = 10
cpuThresholdTest = int64(800)
optsForTest = []Option{
WithWindow(windowSizeTest),
WithBucket(bucketNumTest),
WithCPUThreshold(cpuThresholdTest),
}
)
func warmup(bbr *BBR, count int) {
for i := 0; i < count; i++ {
done, err := bbr.Allow()
time.Sleep(time.Millisecond * 1)
if err == nil {
done(DoneInfo{})
}
}
}
func forceAllow(bbr *BBR) {
inflight := bbr.inFlight
bbr.inFlight = bbr.maxPASS() - 1
done, err := bbr.Allow()
if err == nil {
done(DoneInfo{})
}
bbr.inFlight = inflight
}
func TestBBR(t *testing.T) {
limiter := NewLimiter(
WithWindow(2*time.Second),
WithBucket(5),
WithCPUThreshold(20))
var wg sync.WaitGroup
var drop int64
for i := 0; i < 100; i++ {
wg.Add(1)
go func() {
defer wg.Done()
for i := 0; i < 300; i++ {
done, err := limiter.Allow()
if err != nil {
atomic.AddInt64(&drop, 1)
} else {
count := rand.Intn(10)
time.Sleep(time.Millisecond * time.Duration(count))
done(DoneInfo{})
}
}
}()
}
wg.Wait()
t.Log("drop: ", drop)
}
func TestBBRMaxPass(t *testing.T) {
bucketDuration := windowSizeTest / time.Duration(bucketNumTest)
bbr := NewLimiter(optsForTest...)
for i := 1; i <= 10; i++ {
bbr.passStat.Add(int64(i * 100))
time.Sleep(bucketDuration)
}
assert.Equal(t, int64(1000), bbr.maxPASS())
// default max pass is equal to 1.
bbr = NewLimiter(optsForTest...)
assert.Equal(t, int64(1), bbr.maxPASS())
}
func TestBBRMaxPassWithCache(t *testing.T) {
bucketDuration := windowSizeTest / time.Duration(bucketNumTest)
bbr := NewLimiter(optsForTest...)
// witch cache, value of latest bucket is not counted instantly.
// after a bucket duration time, this bucket will be fully counted.
bbr.passStat.Add(int64(50))
time.Sleep(bucketDuration / 2)
assert.Equal(t, int64(1), bbr.maxPASS())
bbr.passStat.Add(int64(50))
time.Sleep(bucketDuration / 2)
assert.Equal(t, int64(1), bbr.maxPASS())
bbr.passStat.Add(int64(1))
time.Sleep(bucketDuration)
assert.Equal(t, int64(100), bbr.maxPASS())
}
func TestBBRMinRt(t *testing.T) {
bucketDuration := windowSizeTest / time.Duration(bucketNumTest)
bbr := NewLimiter(optsForTest...)
for i := 0; i < 10; i++ {
for j := i*10 + 1; j <= i*10+10; j++ {
bbr.rtStat.Add(int64(j))
}
if i != 9 {
time.Sleep(bucketDuration)
}
}
t.Log(int64(6), bbr.minRT())
// default max min rt is equal to maxFloat64.
bbr = NewLimiter(optsForTest...)
bbr.rtStat = window.NewRollingCounter(window.RollingCounterOpts{Size: 10, BucketDuration: bucketDuration})
t.Log(int64(1), bbr.minRT())
}
func TestBBRMinRtWithCache(t *testing.T) {
bucketDuration := windowSizeTest / time.Duration(bucketNumTest)
bbr := NewLimiter(optsForTest...)
for i := 0; i < 10; i++ {
for j := i*10 + 1; j <= i*10+5; j++ {
bbr.rtStat.Add(int64(j))
}
if i != 9 {
time.Sleep(bucketDuration / 2)
}
_ = bbr.minRT()
for j := i*10 + 6; j <= i*10+10; j++ {
bbr.rtStat.Add(int64(j))
}
if i != 9 {
time.Sleep(bucketDuration / 2)
}
}
t.Log(int64(16), bbr.minRT())
}
func TestBBRMaxQps(t *testing.T) {
bbr := NewLimiter(optsForTest...)
bucketDuration := windowSizeTest / time.Duration(bucketNumTest)
passStat := window.NewRollingCounter(window.RollingCounterOpts{Size: 10, BucketDuration: bucketDuration})
rtStat := window.NewRollingCounter(window.RollingCounterOpts{Size: 10, BucketDuration: bucketDuration})
for i := 0; i < 10; i++ {
passStat.Add(int64((i + 2) * 100))
for j := i*10 + 1; j <= i*10+10; j++ {
rtStat.Add(int64(j))
}
if i != 9 {
time.Sleep(bucketDuration)
}
}
bbr.passStat = passStat
bbr.rtStat = rtStat
t.Log(int64(60), bbr.maxInFlight())
}
func TestBBRShouldDrop(t *testing.T) {
var cpu int64
bbr := NewLimiter(optsForTest...)
bbr.cpu = func() int64 {
return cpu
}
bucketDuration := windowSizeTest / time.Duration(bucketNumTest)
passStat := window.NewRollingCounter(window.RollingCounterOpts{Size: 10, BucketDuration: bucketDuration})
rtStat := window.NewRollingCounter(window.RollingCounterOpts{Size: 10, BucketDuration: bucketDuration})
for i := 0; i < 10; i++ {
passStat.Add(int64((i + 1) * 100))
for j := i*10 + 1; j <= i*10+10; j++ {
rtStat.Add(int64(j))
}
if i != 9 {
time.Sleep(bucketDuration)
}
}
bbr.passStat = passStat
bbr.rtStat = rtStat
// cpu >= 800, inflight < maxQps
cpu = 800
bbr.inFlight = 50
t.Log(false, bbr.shouldDrop())
// cpu >= 800, inflight > maxQps
cpu = 800
bbr.inFlight = 80
t.Log(true, bbr.shouldDrop())
// cpu < 800, inflight > maxQps, cold duration
cpu = 700
bbr.inFlight = 80
t.Log(true, bbr.shouldDrop())
// cpu < 800, inflight > maxQps
time.Sleep(2 * time.Second)
cpu = 700
bbr.inFlight = 80
t.Log(false, bbr.shouldDrop())
}
func BenchmarkBBRAllowUnderLowLoad(b *testing.B) {
bbr := NewLimiter(optsForTest...)
bbr.cpu = func() int64 {
return 500
}
b.ResetTimer()
for i := 0; i <= b.N; i++ {
done, err := bbr.Allow()
if err == nil {
done(DoneInfo{})
}
}
}
func BenchmarkBBRAllowUnderHighLoad(b *testing.B) {
bbr := NewLimiter(optsForTest...)
bbr.cpu = func() int64 {
return 900
}
bbr.inFlight = 1
b.ResetTimer()
for i := 0; i <= b.N; i++ {
if i%10000 == 0 {
maxFlight := bbr.maxInFlight()
if maxFlight != 0 {
bbr.inFlight = rand.Int63n(bbr.maxInFlight() * 2)
}
}
done, err := bbr.Allow()
if err == nil {
done(DoneInfo{})
}
}
}
func BenchmarkBBRShouldDropUnderLowLoad(b *testing.B) {
bbr := NewLimiter(optsForTest...)
bbr.cpu = func() int64 {
return 500
}
warmup(bbr, 10000)
b.ResetTimer()
for i := 0; i <= b.N; i++ {
bbr.shouldDrop()
}
}
func BenchmarkBBRShouldDropUnderHighLoad(b *testing.B) {
bbr := NewLimiter(optsForTest...)
bbr.cpu = func() int64 {
return 900
}
warmup(bbr, 10000)
bbr.inFlight = 1000
b.ResetTimer()
for i := 0; i <= b.N; i++ {
bbr.shouldDrop()
if i%10000 == 0 {
forceAllow(bbr)
}
}
}
func BenchmarkBBRShouldDropUnderUnstableLoad(b *testing.B) {
bbr := NewLimiter(optsForTest...)
bbr.cpu = func() int64 {
return 500
}
warmup(bbr, 10000)
bbr.prevDropTime.Store(time.Now().UnixNano())
bbr.inFlight = 1000
b.ResetTimer()
for i := 0; i <= b.N; i++ {
bbr.shouldDrop()
if i%100000 == 0 {
forceAllow(bbr)
}
}
}
pkg/shield/ratelimit/ratelimit.go 0 → 100644
浏览文件 @ d57375cc
package ratelimit
import (
"errors"
)
var (
// ErrLimitExceed is returned when the rate limiter is
// triggered and the request is rejected due to limit exceeded.
ErrLimitExceed = errors.New("rate limit exceeded")
)
// DoneFunc is done function.
type DoneFunc func(DoneInfo)
// DoneInfo is done info.
type DoneInfo struct {
Err error
}
// Limiter is a rate limiter.
type Limiter interface {
Allow() (DoneFunc, error)
}
pkg/shield/window/counter.go 0 → 100644
浏览文件 @ d57375cc
package window
import (
"fmt"
"time"
)
// Metric is a sample interface.
// Implementations of Metrics in metric package are Counter, Gauge,
// PointGauge, RollingCounter and RollingGauge.
type Metric interface {
// Add adds the given value to the counter.
Add(int64)
// Value gets the current value.
// If the metric's type is PointGauge, RollingCounter, RollingGauge,
// it returns the sum value within the window.
Value() int64
}
// Aggregation contains some common aggregation function.
// Each aggregation can compute summary statistics of window.
type Aggregation interface {
// Min finds the min value within the window.
Min() float64
// Max finds the max value within the window.
Max() float64
// Avg computes average value within the window.
Avg() float64
// Sum computes sum value within the window.
Sum() float64
}
// RollingCounter represents a ring window based on time duration.
// e.g. [[1], [3], [5]]
type RollingCounter interface {
Metric
Aggregation
Timespan() int
// Reduce applies the reduction function to all buckets within the window.
Reduce(func(Iterator) float64) float64
}
// RollingCounterOpts contains the arguments for creating RollingCounter.
type RollingCounterOpts struct {
Size int
BucketDuration time.Duration
}
type rollingCounter struct {
policy *RollingPolicy
}
// NewRollingCounter creates a new RollingCounter bases on RollingCounterOpts.
func NewRollingCounter(opts RollingCounterOpts) RollingCounter {
window := NewWindow(Options{Size: opts.Size})
policy := NewRollingPolicy(window, RollingPolicyOpts{BucketDuration: opts.BucketDuration})
return &rollingCounter{
policy: policy,
}
}
func (r *rollingCounter) Add(val int64) {
if val < 0 {
panic(fmt.Errorf("stat/metric: cannot decrease in value. val: %d", val))
}
r.policy.Add(float64(val))
}
func (r *rollingCounter) Reduce(f func(Iterator) float64) float64 {
return r.policy.Reduce(f)
}
func (r *rollingCounter) Avg() float64 {
return r.policy.Reduce(Avg)
}
func (r *rollingCounter) Min() float64 {
return r.policy.Reduce(Min)
}
func (r *rollingCounter) Max() float64 {
return r.policy.Reduce(Max)
}
func (r *rollingCounter) Sum() float64 {
return r.policy.Reduce(Sum)
}
func (r *rollingCounter) Value() int64 {
return int64(r.Sum())
}
func (r *rollingCounter) Timespan() int {
r.policy.mu.RLock()
defer r.policy.mu.RUnlock()
return r.policy.timespan()
}
pkg/shield/window/counter_test.go 0 → 100644
浏览文件 @ d57375cc
package window
import (
"testing"
"time"
"github.com/stretchr/testify/assert"
)
func TestRollingCounterAdd(t *testing.T) {
size := 3
bucketDuration := time.Second
opts := RollingCounterOpts{
Size: size,
BucketDuration: bucketDuration,
}
r := NewRollingCounter(opts)
listBuckets := func() [][]float64 {
buckets := make([][]float64, 0)
r.Reduce(func(i Iterator) float64 {
for i.Next() {
bucket := i.Bucket()
buckets = append(buckets, bucket.Points)
}
return 0.0
})
return buckets
}
assert.Equal(t, [][]float64{{}, {}, {}}, listBuckets())
r.Add(1)
assert.Equal(t, [][]float64{{}, {}, {1}}, listBuckets())
time.Sleep(time.Second)
r.Add(2)
r.Add(3)
assert.Equal(t, [][]float64{{}, {1}, {5}}, listBuckets())
time.Sleep(time.Second)
r.Add(4)
r.Add(5)
r.Add(6)
assert.Equal(t, [][]float64{{1}, {5}, {15}}, listBuckets())
time.Sleep(time.Second)
r.Add(7)
assert.Equal(t, [][]float64{{5}, {15}, {7}}, listBuckets())
}
func TestRollingCounterReduce(t *testing.T) {
size := 3
bucketDuration := time.Second
opts := RollingCounterOpts{
Size: size,
BucketDuration: bucketDuration,
}
r := NewRollingCounter(opts)
for x := 0; x < size; x = x + 1 {
for i := 0; i <= x; i++ {
r.Add(1)
}
if x < size-1 {
time.Sleep(bucketDuration)
}
}
var result = r.Reduce(func(iterator Iterator) float64 {
var result float64
for iterator.Next() {
bucket := iterator.Bucket()
result += bucket.Points[0]
}
return result
})
if result != 6.0 {
t.Fatalf("Validate sum of points. result: %f", result)
}
}
func TestRollingCounterDataRace(t *testing.T) {
size := 3
bucketDuration := time.Millisecond * 10
opts := RollingCounterOpts{
Size: size,
BucketDuration: bucketDuration,
}
r := NewRollingCounter(opts)
var stop = make(chan bool)
go func() {
for {
select {
case <-stop:
return
default:
r.Add(1)
time.Sleep(time.Millisecond * 5)
}
}
}()
go func() {
for {
select {
case <-stop:
return
default:
_ = r.Reduce(func(i Iterator) float64 {
for i.Next() {
bucket := i.Bucket()
for range bucket.Points {
continue
}
}
return 0
})
}
}
}()
time.Sleep(time.Second * 3)
close(stop)
}
func BenchmarkRollingCounterIncr(b *testing.B) {
size := 3
bucketDuration := time.Millisecond * 100
opts := RollingCounterOpts{
Size: size,
BucketDuration: bucketDuration,
}
r := NewRollingCounter(opts)
b.ResetTimer()
for i := 0; i <= b.N; i++ {
r.Add(1)
}
}
func BenchmarkRollingCounterReduce(b *testing.B) {
size := 3
bucketDuration := time.Second
opts := RollingCounterOpts{
Size: size,
BucketDuration: bucketDuration,
}
r := NewRollingCounter(opts)
for i := 0; i <= 10; i++ {
r.Add(1)
time.Sleep(time.Millisecond * 500)
}
b.ResetTimer()
for i := 0; i <= b.N; i++ {
var _ = r.Reduce(func(i Iterator) float64 {
var result float64
for i.Next() {
bucket := i.Bucket()
if len(bucket.Points) != 0 {
result += bucket.Points[0]
}
}
return result
})
}
}
func TestRollingCounter(t *testing.T) {
size := 3
bucketDuration := time.Second
opts := RollingCounterOpts{
Size: size,
BucketDuration: bucketDuration,
}
counter := NewRollingCounter(opts)
t.Log(counter.Avg())
t.Log(counter.Min())
t.Log(counter.Max())
t.Log(counter.Sum())
t.Log(counter.Value())
t.Log(counter.Timespan())
}
pkg/shield/window/iterator.go 0 → 100644
浏览文件 @ d57375cc
package window
import "fmt"
// Iterator iterates the buckets within the window.
type Iterator struct {
count int
iteratedCount int
cur *Bucket
}
// Next returns true util all of the buckets has been iterated.
func (i *Iterator) Next() bool {
return i.count != i.iteratedCount
}
// Bucket gets current bucket.
func (i *Iterator) Bucket() Bucket {
if !(i.Next()) {
panic(fmt.Errorf("stat/metric: iteration out of range iteratedCount: %d count: %d", i.iteratedCount, i.count))
}
bucket := *i.cur
i.iteratedCount++
i.cur = i.cur.Next()
return bucket
}
pkg/shield/window/policy.go 0 → 100644
浏览文件 @ d57375cc
package window
import (
"sync"
"time"
)
// RollingPolicy is a policy for ring window based on time duration.
// RollingPolicy moves bucket offset with time duration.
// e.g. If the last point is appended one bucket duration ago,
// RollingPolicy will increment current offset.
type RollingPolicy struct {
mu sync.RWMutex
size int
window *Window
offset int
bucketDuration time.Duration
lastAppendTime time.Time
}
// RollingPolicyOpts contains the arguments for creating RollingPolicy.
type RollingPolicyOpts struct {
BucketDuration time.Duration
}
// NewRollingPolicy creates a new RollingPolicy based on the given window and RollingPolicyOpts.
func NewRollingPolicy(window *Window, opts RollingPolicyOpts) *RollingPolicy {
return &RollingPolicy{
window: window,
size: window.Size(),
offset: 0,
bucketDuration: opts.BucketDuration,
lastAppendTime: time.Now(),
}
}
// timespan returns passed bucket number since lastAppendTime,
// if it is one bucket duration earlier than the last recorded
// time, it will return the size.
func (r *RollingPolicy) timespan() int {
v := int(time.Since(r.lastAppendTime) / r.bucketDuration)
if v > -1 { // maybe time backwards
return v
}
return r.size
}
// apply applies function f with value val on
// current offset bucket, expired bucket will be reset
func (r *RollingPolicy) apply(f func(offset int, val float64), val float64) {
r.mu.Lock()
defer r.mu.Unlock()
// calculate current offset
timespan := r.timespan()
oriTimespan := timespan
if timespan > 0 {
start := (r.offset + 1) % r.size
end := (r.offset + timespan) % r.size
if timespan > r.size {
timespan = r.size
}
// reset the expired buckets
r.window.ResetBuckets(start, timespan)
r.offset = end
r.lastAppendTime = r.lastAppendTime.Add(time.Duration(oriTimespan * int(r.bucketDuration)))
}
f(r.offset, val)
}
// Append appends the given points to the window.
func (r *RollingPolicy) Append(val float64) {
r.apply(r.window.Append, val)
}
// Add adds the given value to the latest point within bucket.
func (r *RollingPolicy) Add(val float64) {
r.apply(r.window.Add, val)
}
// Reduce applies the reduction function to all buckets within the window.
func (r *RollingPolicy) Reduce(f func(Iterator) float64) (val float64) {
r.mu.RLock()
defer r.mu.RUnlock()
timespan := r.timespan()
if count := r.size - timespan; count > 0 {
offset := r.offset + timespan + 1
if offset >= r.size {
offset = offset - r.size
}
val = f(r.window.Iterator(offset, count))
}
return val
}
pkg/shield/window/policy_test.go 0 → 100644
浏览文件 @ d57375cc
package window
import (
"fmt"
"testing"
"time"
"github.com/stretchr/testify/assert"
)
func GetRollingPolicy() *RollingPolicy {
w := NewWindow(Options{Size: 3})
return NewRollingPolicy(w, RollingPolicyOpts{BucketDuration: 100 * time.Millisecond})
}
func TestRollingPolicy_Add(t *testing.T) {
// test func timespan return real span
tests := []struct {
timeSleep []int
offset []int
points []int
}{
{
timeSleep: []int{150, 51},
offset: []int{1, 2},
points: []int{1, 1},
},
{
timeSleep: []int{94, 250},
offset: []int{0, 0},
points: []int{1, 1},
},
{
timeSleep: []int{150, 300, 600},
offset: []int{1, 1, 1},
points: []int{1, 1, 1},
},
}
for _, test := range tests {
t.Run("test policy add", func(t *testing.T) {
var totalTs, lastOffset int
timeSleep := test.timeSleep
policy := GetRollingPolicy()
for i, n := range timeSleep {
totalTs += n
time.Sleep(time.Duration(n) * time.Millisecond)
policy.Add(float64(test.points[i]))
offset, points := test.offset[i], test.points[i]
if len(policy.window.buckets[offset].Points) == 0 {
continue
}
assert.Equal(t, points, int(policy.window.buckets[offset].Points[0]),
fmt.Sprintf("error, time since last append: %vms, last offset: %v", totalTs, lastOffset))
lastOffset = offset
}
})
}
}
func TestRollingPolicy_AddWithTimespan(t *testing.T) {
t.Run("timespan < bucket number", func(t *testing.T) {
policy := GetRollingPolicy()
// bucket 0
policy.Add(0)
// bucket 1
time.Sleep(101 * time.Millisecond)
policy.Add(1)
// bucket 2
time.Sleep(101 * time.Millisecond)
policy.Add(2)
// bucket 1
time.Sleep(201 * time.Millisecond)
policy.Add(4)
for _, bkt := range policy.window.buckets {
t.Logf("%+v", bkt)
}
assert.Equal(t, 0, len(policy.window.buckets[0].Points))
assert.Equal(t, 4, int(policy.window.buckets[1].Points[0]))
assert.Equal(t, 2, int(policy.window.buckets[2].Points[0]))
})
t.Run("timespan > bucket number", func(t *testing.T) {
policy := GetRollingPolicy()
// bucket 0
policy.Add(0)
// bucket 1
time.Sleep(101 * time.Millisecond)
policy.Add(1)
// bucket 2
time.Sleep(101 * time.Millisecond)
policy.Add(2)
// bucket 1
time.Sleep(501 * time.Millisecond)
policy.Add(4)
for _, bkt := range policy.window.buckets {
t.Logf("%+v", bkt)
}
assert.Equal(t, 0, len(policy.window.buckets[0].Points))
assert.Equal(t, 4, int(policy.window.buckets[1].Points[0]))
assert.Equal(t, 0, len(policy.window.buckets[2].Points))
})
}
pkg/shield/window/reduce.go 0 → 100644
浏览文件 @ d57375cc
package window
// Sum the values within the window.
func Sum(iterator Iterator) float64 {
var result = 0.0
for iterator.Next() {
bucket := iterator.Bucket()
for _, p := range bucket.Points {
result = result + p
}
}
return result
}
// Avg the values within the window.
func Avg(iterator Iterator) float64 {
var result = 0.0
var count = 0.0
for iterator.Next() {
bucket := iterator.Bucket()
for _, p := range bucket.Points {
result = result + p
count = count + 1
}
}
return result / count
}
// Min the values within the window.
func Min(iterator Iterator) float64 {
var result = 0.0
var started = false
for iterator.Next() {
bucket := iterator.Bucket()
for _, p := range bucket.Points {
if !started {
result = p
started = true
continue
}
if p < result {
result = p
}
}
}
return result
}
// Max the values within the window.
func Max(iterator Iterator) float64 {
var result = 0.0
var started = false
for iterator.Next() {
bucket := iterator.Bucket()
for _, p := range bucket.Points {
if !started {
result = p
started = true
continue
}
if p > result {
result = p
}
}
}
return result
}
// Count sums the count value within the window.
func Count(iterator Iterator) float64 {
var result int64
for iterator.Next() {
bucket := iterator.Bucket()
result += bucket.Count
}
return float64(result)
}
pkg/shield/window/reduce_test.go 0 → 100644
浏览文件 @ d57375cc
package window
import (
"testing"
)
func TestSum(t *testing.T) {
it := Iterator{
count: 0,
iteratedCount: 0,
cur: &Bucket{},
}
t.Log(Sum(it))
t.Log(Avg(it))
t.Log(Max(it))
t.Log(Count(it))
}
pkg/shield/window/window.go 0 → 100644
浏览文件 @ d57375cc
// Package window is a library that calculates windows cpu and memory usage.
package window
// Bucket contains multiple float64 points.
type Bucket struct {
Points []float64
Count int64
next *Bucket
}
// Append appends the given value to the bucket.
func (b *Bucket) Append(val float64) {
b.Points = append(b.Points, val)
b.Count++
}
// Add adds the given value to the point.
func (b *Bucket) Add(offset int, val float64) {
b.Points[offset] += val
b.Count++
}
// Reset empties the bucket.
func (b *Bucket) Reset() {
b.Points = b.Points[:0]
b.Count = 0
}
// Next returns the next bucket.
func (b *Bucket) Next() *Bucket {
return b.next
}
// Window contains multiple buckets.
type Window struct {
buckets []Bucket
size int
}
// Options contains the arguments for creating Window.
type Options struct {
Size int
}
// NewWindow creates a new Window based on WindowOpts.
func NewWindow(opts Options) *Window {
buckets := make([]Bucket, opts.Size)
for offset := range buckets {
buckets[offset].Points = make([]float64, 0)
nextOffset := offset + 1
if nextOffset == opts.Size {
nextOffset = 0
}
buckets[offset].next = &buckets[nextOffset]
}
return &Window{buckets: buckets, size: opts.Size}
}
// ResetWindow empties all buckets within the window.
func (w *Window) ResetWindow() {
for offset := range w.buckets {
w.ResetBucket(offset)
}
}
// ResetBucket empties the bucket based on the given offset.
func (w *Window) ResetBucket(offset int) {
w.buckets[offset%w.size].Reset()
}
// ResetBuckets empties the buckets based on the given offsets.
func (w *Window) ResetBuckets(offset int, count int) {
for i := 0; i < count; i++ {
w.ResetBucket(offset + i)
}
}
// Append appends the given value to the bucket where index equals the given offset.
func (w *Window) Append(offset int, val float64) {
w.buckets[offset%w.size].Append(val)
}
// Add adds the given value to the latest point within bucket where index equals the given offset.
func (w *Window) Add(offset int, val float64) {
offset %= w.size
if w.buckets[offset].Count == 0 {
w.buckets[offset].Append(val)
return
}
w.buckets[offset].Add(0, val)
}
// Bucket returns the bucket where index equals the given offset.
func (w *Window) Bucket(offset int) Bucket {
return w.buckets[offset%w.size]
}
// Size returns the size of the window.
func (w *Window) Size() int {
return w.size
}
// Iterator returns the count number buckets iterator from offset.
func (w *Window) Iterator(offset int, count int) Iterator {
return Iterator{
count: count,
cur: &w.buckets[offset%w.size],
}
}
pkg/shield/window/window_test.go 0 → 100644
浏览文件 @ d57375cc
package window
import (
"testing"
"github.com/stretchr/testify/assert"
)
func TestWindowResetWindow(t *testing.T) {
opts := Options{Size: 3}
window := NewWindow(opts)
for i := 0; i < opts.Size; i++ {
window.Append(i, 1.0)
}
window.ResetWindow()
for i := 0; i < opts.Size; i++ {
assert.Equal(t, len(window.Bucket(i).Points), 0)
}
}
func TestWindowResetBucket(t *testing.T) {
opts := Options{Size: 3}
window := NewWindow(opts)
for i := 0; i < opts.Size; i++ {
window.Append(i, 1.0)
}
window.ResetBucket(1)
assert.Equal(t, len(window.Bucket(1).Points), 0)
assert.Equal(t, window.Bucket(0).Points[0], float64(1.0))
assert.Equal(t, window.Bucket(2).Points[0], float64(1.0))
}
func TestWindowResetBuckets(t *testing.T) {
opts := Options{Size: 3}
window := NewWindow(opts)
for i := 0; i < opts.Size; i++ {
window.Append(i, 1.0)
}
window.ResetBuckets(0, 3)
for i := 0; i < opts.Size; i++ {
assert.Equal(t, len(window.Bucket(i).Points), 0)
}
}
func TestWindowAppend(t *testing.T) {
opts := Options{Size: 3}
window := NewWindow(opts)
for i := 0; i < opts.Size; i++ {
window.Append(i, 1.0)
}
for i := 0; i < opts.Size; i++ {
assert.Equal(t, window.Bucket(i).Points[0], float64(1.0))
}
}
func TestWindowAdd(t *testing.T) {
opts := Options{Size: 3}
window := NewWindow(opts)
window.Append(0, 1.0)
window.Add(0, 1.0)
assert.Equal(t, window.Bucket(0).Points[0], float64(2.0))
}
func TestWindowSize(t *testing.T) {
opts := Options{Size: 3}
window := NewWindow(opts)
assert.Equal(t, window.Size(), 3)
}
xutils/ctxutils/ctxutils.go
浏览文件 @ d57375cc
...@@ -4,6 +4,7 @@ import ( ...@@ -4,6 +4,7 @@ import (
"context" "context"
"errors" "errors"
"gitlab.wanzhuangkj.com/tush/opkg/pkg/sf"
"gitlab.wanzhuangkj.com/tush/opkg/pkg/sgorm/query" "gitlab.wanzhuangkj.com/tush/opkg/pkg/sgorm/query"
"github.com/gin-gonic/gin" "github.com/gin-gonic/gin"
...@@ -52,12 +53,7 @@ func Set(c *gin.Context, key string, val any) { ...@@ -52,12 +53,7 @@ func Set(c *gin.Context, key string, val any) {
} }
func GinTraceID(c *gin.Context) string { func GinTraceID(c *gin.Context) string {
if v, isExist := c.Get(ContextTraceIDKey); isExist { return c.GetString(ContextTraceIDKey)
if requestID, ok := v.(string); ok {
return requestID
}
}
return ""
} }
func CtxTraceID(ctx context.Context) string { func CtxTraceID(ctx context.Context) string {
...@@ -127,3 +123,10 @@ func SetPage(ctx context.Context, in IPagination) { ...@@ -127,3 +123,10 @@ func SetPage(ctx context.Context, in IPagination) {
c.Set(KeyPagination, pagination) c.Set(KeyPagination, pagination)
} }
} }
func GenerateTraceID(c *gin.Context) string {
if tid := GinTraceID(c); tid != "" {
return tid
}
return sf.GenerateID().String()
}
Markdown 格式
0% 或
您添加了 0 人 到此讨论。请谨慎行事。
请先完成此评论的编辑！
请 注册 或者 后发表评论