add Paymaster Mertics Log

common/network/ethereum_adaptable_executor_test.go

@@ -13,6 +13,7 @@ import (
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/sirupsen/logrus"
 	"testing"
+	"time"
 )
 
 func TestEthereumAdaptableExecutor(t *testing.T) {
@@ -365,3 +366,8 @@ func testEthereumExecutorClientConnect(t *testing.T, chain global_const.Network)
 	}
 	t.Logf("network %s chainId: %s", chain, chainId.String())
 }
+func TestTime(t *testing.T) {
+	start := time.Now()
+	t.Logf("start time: %v", start.String())
+	t.Logf("start time: %v", start.Format("2006-01-02 15:04:05.MST"))
+}

common/utils/util.go

@@ -61,6 +61,7 @@ func GenerateMockUservOperation() *map[string]any {
 
 	return &MockUserOpData
 }
+
 func ValidateHex(value string) bool {
 	if HexPattern.MatchString(value) {
 		return true

rpc_server/api/health.go

@@ -4,7 +4,6 @@ import (
 	"AAStarCommunity/EthPaymaster_BackService/common/model"
 	"AAStarCommunity/EthPaymaster_BackService/envirment"
 	"github.com/gin-gonic/gin"
-	"github.com/sirupsen/logrus"
 	"time"
 )
 
@@ -17,7 +16,6 @@ import (
 // @Success 200
 func Healthz(c *gin.Context) {
 	response := model.GetResponse()
-	logrus.Debug("In the Healthz")
 	response.WithDataSuccess(c, gin.H{
 		"hello":       "Eth Paymaster",
 		"environment": envirment.Environment.Name,

rpc_server/api/v1/paymaster.go

@@ -3,7 +3,6 @@ package v1
 import (
 	"AAStarCommunity/EthPaymaster_BackService/common/global_const"
 	"AAStarCommunity/EthPaymaster_BackService/common/model"
-	"AAStarCommunity/EthPaymaster_BackService/common/utils"
 	"AAStarCommunity/EthPaymaster_BackService/config"
 	"AAStarCommunity/EthPaymaster_BackService/service/operator"
 	"fmt"
@@ -38,16 +37,17 @@ func Paymaster(ctx *gin.Context) {
 
 	jsonRpcRequest := model.JsonRpcRequest{}
 	response := model.GetResponse()
-
-	defer func() {
-		if r := recover(); r != nil {
-			errInfo := fmt.Sprintf("[panic]: err : [%v] , stack :[%v]", r, utils.GetCurrentGoroutineStack())
-			logrus.Error(errInfo)
-			response.SetHttpCode(http.StatusInternalServerError).FailCode(ctx, http.StatusInternalServerError, fmt.Sprintf("%v", r))
-		}
-
-	}()
+	//
+	//defer func() {
+	//	if r := recover(); r != nil {
+	//		errInfo := fmt.Sprintf("[panic]: err : [%v] , stack :[%v]", r, utils.GetCurrentGoroutineStack())
+	//		logrus.Error(errInfo)
+	//		response.SetHttpCode(http.StatusInternalServerError).FailCode(ctx, http.StatusInternalServerError, fmt.Sprintf("%v", r))
+	//	}
+	//
+	//}()
 	network := ctx.Param("network")
+	logrus.Debugf("Paymaster network: %s", network)
 	if network == "" {
 		errStr := fmt.Sprintf("Request Error [network is empty]")
 		response.SetHttpCode(http.StatusBadRequest).FailCode(ctx, http.StatusBadRequest, errStr)
@@ -58,13 +58,13 @@ func Paymaster(ctx *gin.Context) {
 		response.SetHttpCode(http.StatusBadRequest).FailCode(ctx, http.StatusBadRequest, errStr)
 		return
 	}
-	jsonRpcRequest.Network = global_const.Network(network)
 
 	if err := ctx.ShouldBindJSON(&jsonRpcRequest); err != nil {
-		errStr := fmt.Sprintf("Request Error [%v]", err)
+		errStr := fmt.Sprintf("Parse Request Error [%v]", err)
 		response.SetHttpCode(http.StatusBadRequest).FailCode(ctx, http.StatusBadRequest, errStr)
 		return
 	}
+	jsonRpcRequest.Network = global_const.Network(network)
 	method := jsonRpcRequest.Method
 	if method == "" {
 		errStr := fmt.Sprintf("Request Error [method is empty]")

rpc_server/middlewares/logger.go

@@ -6,5 +6,7 @@ import (
 
 // LogHandler log handler
 func LogHandler() gin.HandlerFunc {
-	return gin.Logger()
+	return gin.LoggerWithConfig(gin.LoggerConfig{
+		SkipPaths: []string{"/api/healthz"},
+	})
 }

rpc_server/middlewares/pv_mertics.go

@@ -0,0 +1,106 @@
+package middlewares
+
+import (
+	"AAStarCommunity/EthPaymaster_BackService/common/global_const"
+	"AAStarCommunity/EthPaymaster_BackService/common/model"
+	"AAStarCommunity/EthPaymaster_BackService/service/dashboard_service"
+	"bytes"
+	"encoding/json"
+	"github.com/gin-gonic/gin"
+	"github.com/sirupsen/logrus"
+	"io"
+	"net/http"
+	"strings"
+	"time"
+)
+
+type PayMasterParam struct {
+	ApiUserId    int64
+	ApiKey       string
+	Method       string
+	SendTime     string
+	Latency      time.Duration
+	RequestBody  string
+	ResponseBody string
+	NetWork      string
+	Status       int
+}
+
+func PvMetrics() gin.HandlerFunc {
+	return func(c *gin.Context) {
+		path := c.Request.URL.Path
+		if strings.HasPrefix(path, "/api/v1/paymaster/") {
+			responseWriter := &CustomResponseWriter{body: bytes.NewBufferString(""), ResponseWriter: c.Writer}
+			c.Writer = responseWriter
+			start := time.Now()
+			// get Request Body
+			requestBodyBytes, err := io.ReadAll(c.Request.Body)
+			if err != nil {
+				c.JSON(http.StatusBadRequest, gin.H{"error": "Failed to read request body"})
+				c.Abort()
+				return
+			}
+			//Restore the request body to Request.Body for use by subsequent handlers.
+			c.Request.Body = io.NopCloser(bytes.NewBuffer(requestBodyBytes))
+
+			c.Next()
+
+			request := model.JsonRpcRequest{}
+			_ = json.Unmarshal(requestBodyBytes, &request)
+			requestJson, _ := json.Marshal(request)
+			requestBodyStr := string(requestJson)
+
+			responseWriter.body.Bytes()
+			responseBody := responseWriter.body.String()
+			endEnd := time.Now()
+			network := c.Param("network")
+			metricsParam := PayMasterParam{
+				NetWork:      network,
+				Method:       request.Method,
+				SendTime:     start.Format("2006-01-02 15:04:05.MST"),
+				Latency:      endEnd.Sub(start),
+				Status:       c.Writer.Status(),
+				RequestBody:  requestBodyStr,
+				ResponseBody: responseBody,
+			}
+			apiKeyContext, exist := c.Get(global_const.ContextKeyApiMoDel)
+			if exist {
+				apiKeyModel := apiKeyContext.(*model.ApiKeyModel)
+				metricsParam.ApiKey = apiKeyModel.ApiKey
+				metricsParam.ApiUserId = apiKeyModel.UserId
+			}
+			MetricsPaymaster(c, metricsParam)
+		} else {
+			return
+		}
+
+	}
+}
+
+type CustomResponseWriter struct {
+	gin.ResponseWriter
+	body *bytes.Buffer
+}
+
+func (w *CustomResponseWriter) Write(b []byte) (int, error) {
+	w.body.Write(b)
+	return w.ResponseWriter.Write(b)
+}
+func MetricsPaymaster(c *gin.Context, metricsParam PayMasterParam) {
+
+	recallModel := dashboard_service.PaymasterRecallLogDbModel{
+		ProjectApikey:   metricsParam.ApiKey,
+		ProjectUserId:   metricsParam.ApiUserId,
+		PaymasterMethod: metricsParam.Method,
+		SendTime:        metricsParam.SendTime,
+		Latency:         int64(metricsParam.Latency),
+		RequestBody:     metricsParam.RequestBody,
+		ResponseBody:    metricsParam.ResponseBody,
+		Status:          metricsParam.Status,
+		NetWork:         metricsParam.NetWork,
+	}
+	err := dashboard_service.CreatePaymasterCall(&recallModel)
+	if err != nil {
+		logrus.Error("CreatePaymasterCall error:", err)
+	}
+}

rpc_server/middlewares/recovery.go

@@ -2,10 +2,11 @@ package middlewares
 
 import (
 	"AAStarCommunity/EthPaymaster_BackService/common/model"
-	"AAStarCommunity/EthPaymaster_BackService/envirment"
+	"AAStarCommunity/EthPaymaster_BackService/common/utils"
 	"errors"
 	"fmt"
 	"github.com/gin-gonic/gin"
+	"github.com/sirupsen/logrus"
 	"net/http"
 	"strings"
 )
@@ -14,11 +15,11 @@ import (
 func GenericRecoveryHandler() gin.HandlerFunc {
 	DefaultErrorWriter := &PanicExceptionRecord{}
 	return gin.RecoveryWithWriter(DefaultErrorWriter, func(c *gin.Context, err interface{}) {
-		errStr := ""
-		if envirment.Environment.Debugger {
-			errStr = fmt.Sprintf("%v", err)
-		}
-		model.GetResponse().SetHttpCode(http.StatusInternalServerError).FailCode(c, http.StatusInternalServerError, errStr)
+		errInfo := fmt.Sprintf("[panic]: err : [%v] , stack :[%v]", err, utils.GetCurrentGoroutineStack())
+		logrus.Error(errInfo)
+		logrus.Errorf("%v", errInfo)
+		returnError := fmt.Sprintf("%v", err)
+		model.GetResponse().SetHttpCode(http.StatusInternalServerError).FailCode(c, http.StatusInternalServerError, returnError)
 	})
 }
 

rpc_server/routers/boot.go

@@ -45,9 +45,10 @@ func SetRouters() (routers *gin.Engine) {
 func buildRoute(routers *gin.Engine) {
 	// build http routers and middleware
 	routers.Use(middlewares.GenericRecoveryHandler())
-	if envirment.Environment.IsDevelopment() {
-		routers.Use(middlewares.LogHandler())
-	}
+
+	routers.Use(middlewares.LogHandler())
+
+	routers.Use(middlewares.PvMetrics())
 	routers.Use(middlewares.CorsHandler())
 	//build the routers not need api access like auth or Traffic limit
 	buildRouters(routers, PublicRouterMaps)

service/dashboard_service/dashboard_service.go

@@ -17,8 +17,8 @@ import (
 )
 
 var (
-	configDB *gorm.DB
-	onlyOnce = sync.Once{}
+	dashBoardDb *gorm.DB
+	onlyOnce    = sync.Once{}
 )
 
 func Init() {
@@ -29,7 +29,7 @@ func Init() {
 		if err != nil {
 			panic(err)
 		}
-		configDB = configDBVar
+		dashBoardDb = configDBVar
 
 	})
 
@@ -58,7 +58,7 @@ func GetStrategyByCode(strategyCode string, entryPointVersion global_const.Entry
 		entryPointVersion = global_const.EntrypointV06
 	}
 	strategyDbModel := &StrategyDBModel{}
-	tx := configDB.Where("strategy_code = ?", strategyCode).First(&strategyDbModel)
+	tx := dashBoardDb.Where("strategy_code = ?", strategyCode).First(&strategyDbModel)
 	if tx.Error != nil {
 		if errors.Is(tx.Error, gorm.ErrRecordNotFound) {
 			return nil, xerrors.Errorf("strategy not found: %w", tx.Error)
@@ -242,7 +242,7 @@ func convertApiKeyDbModelToApiKeyModel(apiKeyDbModel *ApiKeyDbModel) *model.ApiK
 }
 func GetAPiInfoByApiKey(apiKey string) (*model.ApiKeyModel, error) {
 	apikeyModel := &ApiKeyDbModel{}
-	tx := configDB.Where("api_key = ?", apiKey).First(&apikeyModel)
+	tx := dashBoardDb.Where("api_key = ?", apiKey).First(&apikeyModel)
 	if tx.Error != nil {
 		if errors.Is(tx.Error, gorm.ErrRecordNotFound) {
 			return nil, tx.Error
@@ -252,3 +252,24 @@ func GetAPiInfoByApiKey(apiKey string) (*model.ApiKeyModel, error) {
 	apikeyRes := convertApiKeyDbModelToApiKeyModel(apikeyModel)
 	return apikeyRes, nil
 }
+
+type PaymasterRecallLogDbModel struct {
+	model.BaseData
+	ProjectUserId   int64          `gorm:"column:project_user_id;type:integer" json:"project_user_id"`
+	ProjectApikey   string         `gorm:"column:project_apikey;type:varchar(255)" json:"project_apikey"`
+	PaymasterMethod string         `gorm:"column:paymaster_method;type:varchar(25)" json:"paymaster_method"`
+	SendTime        string         `gorm:"column:send_time;type:varchar(50)" json:"send_time"`
+	Latency         int64          `gorm:"column:latency;type:integer" json:"latency"`
+	RequestBody     string         `gorm:"column:request_body;type:varchar(500)" json:"request_body"`
+	ResponseBody    string         `gorm:"column:response_body;type:varchar(1000)" json:"response_body"`
+	NetWork         string         `gorm:"column:network;type:varchar(25)" json:"network"`
+	Status          int            `gorm:"column:status;type:integer" json:"status"`
+	Extra           datatypes.JSON `gorm:"column:extra" json:"extra"`
+}
+
+func (*PaymasterRecallLogDbModel) TableName() string {
+	return "paymaster_recall_log"
+}
+func CreatePaymasterCall(recallModel *PaymasterRecallLogDbModel) error {
+	return dashBoardDb.Create(recallModel).Error
+}

sponsor_manager/sponsor_balance_repository.go

@@ -25,6 +25,7 @@ func CreateSponsorBalance(balanceModel *UserSponsorBalanceDBModel) error {
 	return relayDB.Create(balanceModel).Error
 }
 func FindUserSponsorBalance(userId string, isTestNet bool) (balanceModel *UserSponsorBalanceDBModel, err error) {
+
 	balanceModel = &UserSponsorBalanceDBModel{}
 	tx := relayDB.Where("pay_user_id = ?", userId).Where("is_test_net = ?", isTestNet).First(balanceModel)
 	if tx.Error != nil {