1. http cli retry count

gin/middleware/logging.go

@@ -124,11 +124,21 @@ func getResponseBody(buf *bytes.Buffer, maxLen int) []byte {
 	if n == 0 {
 		return emptyBody
 	} else if n < maxLen {
-		return body[:n-1]
+		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()

httpcli/httpcli.go

@@ -14,8 +14,8 @@ import (
 	"time"
 
 	"gitlab.wanzhuangkj.com/tush/xpkg/gin/xctx"
-	"gitlab.wanzhuangkj.com/tush/xpkg/utils/xjson"
 	"gitlab.wanzhuangkj.com/tush/xpkg/logger"
+	"gitlab.wanzhuangkj.com/tush/xpkg/utils/xjson"
 	"gitlab.wanzhuangkj.com/tush/xpkg/xerrors/xerror"
 
 	"github.com/duke-git/lancet/v2/retry"
@@ -35,6 +35,7 @@ type Request struct {
 	body          string                 // Body data
 	bodyJSON      interface{}            // JSON marshal body data
 	timeout       time.Duration          // Client timeout
+	retryCount    uint
 	headers       map[string]string
 
 	request  *http.Request
@@ -118,6 +119,10 @@ func (req *Request) SetTimeout(t time.Duration) *Request {
 	req.timeout = t
 	return req
 }
+func (req *Request) SetRetry(count uint) *Request {
+	req.retryCount = count
+	return req
+}
 
 // SetContentType set ContentType
 func (req *Request) SetContentType(a string) *Request {
@@ -314,33 +319,66 @@ func (req *Request) send(ctx context.Context, body io.Reader, buf *bytes.Buffer)
 
 	ctx, cancel := context.WithTimeout(ctx, time.Second*20)
 	defer cancel()
-	err := retry.Retry(func() error {
-		response, err := client.Do(req.request)
-		if err != nil {
-			logger.Info("httpcli fail", logger.Any("err", err), xctx.CtxTraceIDField(ctx))
-			return xerror.New(err.Error())
-		}
-		resp.Status = response.Status
-		resp.StatusCode = response.StatusCode
-		for k, v := range response.Header {
-			resp.Header[k] = v
+	var err error
+	if req.retryCount > 0 {
+		err = retry.Retry(func() error {
+			response, err := client.Do(req.request)
+			if err != nil {
+				logger.Info("httpcli fail", logger.Any("err", err), xctx.CtxTraceIDField(ctx))
+				return xerror.Wrap(err, "client do")
+			}
+			if response != nil {
+				resp.Status = response.Status
+				resp.StatusCode = response.StatusCode
+				for k, v := range response.Header {
+					resp.Header[k] = v
+				}
+				defer response.Body.Close()
+				body, err := io.ReadAll(response.Body)
+				if err != nil {
+					return xerror.New(err.Error())
+				}
+				logger.Info("httpcli rsp", logger.Any("body", bytes.NewBuffer(body).String()), xctx.CtxTraceIDField(ctx))
+				if body != nil {
+					resp.Body = io.NopCloser(bytes.NewBuffer(body))
+				}
+			}
+			return nil
+		},
+			retry.RetryTimes(req.retryCount),
+			retry.RetryWithLinearBackoff(2*time.Second),
+			retry.Context(ctx),
+		)
+	} else {
+		response, e := client.Do(req.request)
+		if e != nil {
+			err = xerror.New(e.Error())
 		}
-		defer response.Body.Close()
-		body, err := io.ReadAll(response.Body)
-		if err != nil {
-			return xerror.New(err.Error())
+		if response != nil {
+			resp.Status = response.Status
+			resp.StatusCode = response.StatusCode
+			for k, v := range response.Header {
+				resp.Header[k] = v
+			}
+			defer response.Body.Close()
+			body, e := io.ReadAll(response.Body)
+			if e != nil {
+				err = xerror.New(e.Error())
+			}
+			logger.Info("httpcli rsp", logger.Any("body", bytes.NewBuffer(body).String()), xctx.CtxTraceIDField(ctx))
+			if body != nil {
+				resp.Body = io.NopCloser(bytes.NewBuffer(body))
+			}
 		}
-		logger.Info("httpcli rsp", logger.Any("body", bytes.NewBuffer(body).String()), xctx.CtxTraceIDField(ctx))
-		resp.Body = io.NopCloser(bytes.NewBuffer(body))
-		return nil
-	}, retry.RetryWithLinearBackoff(time.Second), retry.Context(ctx))
+	}
+
 	if err != nil {
-		err = xerror.New(err.Error())
 		logger.Error("httpcli fail", logger.Any("err", err), xctx.CtxTraceIDField(ctx))
 	}
 
 	req.response = resp
 	req.err = err
+	resp.err = err
 
 	return resp, resp.err
 }

utils/xsf/xsf.go

@@ -86,6 +86,10 @@ func (x ID) ToInt64() int64 {
 	return snowflake.ID(x).Int64()
 }
 
+func (x ID) ToInt() int {
+	return int(snowflake.ID(x).Int64())
+}
+
 func GenerateID() ID {
 	sid := Generate()
 	return ID(sid)