refactor: Use a more engineering-oriented error code wrapper

app/favorite/cmd/main.go

@@ -1,7 +1,7 @@
 package main
 
 import (
-	"fmt"
+	"github.com/pkg/errors"
 	"net"
 
 	"github.com/sirupsen/logrus"
@@ -36,11 +36,13 @@ func main() {
 	if err != nil {
 		panic(err)
 	}
-	if _, err := etcdRegister.Register(node, 10); err != nil {
-		panic(fmt.Sprintf("start service failed, err: %v", err))
+	if _, err = etcdRegister.Register(node, 10); err != nil {
+		logs.LogrusObj.Errorf("start service failed, original error: %T %v", errors.Cause(err), errors.Cause(err))
+		logs.LogrusObj.Errorf("stack trace: \n%+v\n", err)
+		panic(err)
 	}
 	logrus.Info("service started listen on ", grpcAddress)
-	if err := server.Serve(lis); err != nil {
+	if err = server.Serve(lis); err != nil {
 		panic(err)
 	}
 }

app/favorite/internal/repository/db/dao/favorite.go

@@ -2,11 +2,11 @@ package dao
 
 import (
 	"context"
+	"github.com/pkg/errors"
 
 	"gorm.io/gorm"
 
 	favoritePb "github.com/CocaineCong/tangseng/idl/pb/favorite"
-	log "github.com/CocaineCong/tangseng/pkg/logger"
 	"github.com/CocaineCong/tangseng/repository/mysql/db"
 	"github.com/CocaineCong/tangseng/repository/mysql/model"
 )
@@ -23,7 +23,7 @@ func (dao *FavoriteDao) ListFavorite(req *favoritePb.FavoriteListReq) (r []*mode
 	err = dao.DB.Model(&model.Favorite{}).
 		Where("user_id = ?", req.UserId).Find(&r).Error
 	if err != nil {
-		return
+		return r, errors.Wrapf(err, "failed to query favorite list, userId = %v ", req.UserId)
 	}
 	return
 }
@@ -34,8 +34,7 @@ func (dao *FavoriteDao) CreateFavorite(req *favoritePb.FavoriteCreateReq) (err e
 		UserID:       req.UserId,
 	}
 	if err = dao.DB.Create(&favorite).Error; err != nil {
-		log.LogrusObj.Error("Insert Favorite Error:" + err.Error())
-		return
+		return errors.Wrapf(err, "failed to create favorite, userId = %v ", req.UserId)
 	}
 
 	return
@@ -44,7 +43,9 @@ func (dao *FavoriteDao) CreateFavorite(req *favoritePb.FavoriteCreateReq) (err e
 func (dao *FavoriteDao) DeleteFavorite(req *favoritePb.FavoriteDeleteReq) (err error) {
 	err = dao.DB.Where("favorite_id = ?", req.FavoriteId).
 		Delete(model.Favorite{}).Error
-
+	if err != nil {
+		return errors.Wrapf(err, "failed to delete favorite, favoriteId = %v", req.FavoriteId)
+	}
 	return
 }
 
@@ -53,7 +54,7 @@ func (dao *FavoriteDao) UpdateFavorite(req *favoritePb.FavoriteUpdateReq) (err e
 	fMap["favorite_name"] = req.FavoriteName
 	err = dao.DB.Where("favorite_id = ?", req.FavoriteId).Updates(&fMap).Error
 	if err != nil {
-		return
+		return errors.Wrapf(err, "failed to update favorite, favoriteId = %v ", req.FavoriteId)
 	}
 
 	return

app/favorite/internal/repository/db/dao/favortie_detail.go

@@ -2,6 +2,7 @@ package dao
 
 import (
 	"context"
+	"github.com/pkg/errors"
 
 	"gorm.io/gorm"
 
@@ -23,7 +24,7 @@ func (dao *FavoriteDetailDao) CreateFavoriteDetail(req *favoritePb.FavoriteDetai
 	var f []*model.Favorite
 	err = dao.DB.Where("favorite_id = ?", req.FavoriteId).Find(&f).Error
 	if err != nil {
-		return
+		return errors.Wrapf(err, "failed to query favorite, favoriteId = %v ", req.FavoriteId)
 	}
 
 	fd := model.FavoriteDetail{
@@ -34,26 +35,42 @@ func (dao *FavoriteDetailDao) CreateFavoriteDetail(req *favoritePb.FavoriteDetai
 		Favorite: f,
 	}
 	err = dao.DB.Model(&model.FavoriteDetail{}).Create(&fd).Error
-
+	if err != nil {
+		return errors.Wrapf(err, "failed to create favoriteDetail，userID = %v,urlId = %v", req.UserId, req.UrlId)
+	}
 	return
 }
 
 func (dao *FavoriteDetailDao) ListFavoriteDetail(req *favoritePb.FavoriteDetailListReq) (r []*model.Favorite, err error) {
 	var f []*model.Favorite
-	dao.DB.Where("user_id = ?", req.UserId).Find(&f)
+	err = dao.DB.Where("user_id = ?", req.UserId).Find(&f).Error
+	if err != nil {
+		return r, errors.Wrapf(err, "failed to query favorite, userId = %v ", req.UserId)
+	}
 	for _, v := range f {
-		_ = dao.DB.Model(&v).Association("FavoriteDetail").Find(&v.FavoriteDetail)
+		err = dao.DB.Model(&v).Association("FavoriteDetail").Find(&v.FavoriteDetail)
 		r = append(r, v)
 	}
-
+	if err != nil {
+		err = errors.Wrapf(err, "failed to query favoriteDetail")
+	}
 	return
 }
 
-func (dao *FavoriteDetailDao) DeleteFavoriteDetail(req *favoritePb.FavoriteDetailDeleteReq) error {
+func (dao *FavoriteDetailDao) DeleteFavoriteDetail(req *favoritePb.FavoriteDetailDeleteReq) (err error) {
 	var f model.Favorite
 	var fd model.FavoriteDetail
-	dao.DB.Where("favorite_id = ?", req.FavoriteId).First(&f)
-	dao.DB.Where("favorite_detail_id = ?", req.FavoriteDetailId).First(&fd)
-	err := dao.DB.Model(&f).Association("FavoriteDetail").Delete(&fd)
-	return err
+	err = dao.DB.Where("favorite_id = ?", req.FavoriteId).First(&f).Error
+	if err != nil {
+		return errors.Wrapf(err, "failed to query favorite, favoriteId = %v ", req.FavoriteId)
+	}
+	err = dao.DB.Where("favorite_detail_id = ?", req.FavoriteDetailId).First(&fd).Error
+	if err != nil {
+		return errors.Wrapf(err, "failed to query favoriteDetail, favoriteDetailId = %v ", req.FavoriteDetailId)
+	}
+	err = dao.DB.Model(&f).Association("FavoriteDetail").Delete(&fd)
+	if err != nil {
+		return errors.Wrapf(err, "failed to delete favoriteDetail, favoriteDetailId = %v ", req.FavoriteDetailId)
+	}
+	return
 }

app/favorite/internal/service/favorite.go

@@ -2,6 +2,7 @@ package service
 
 import (
 	"context"
+	"github.com/pkg/errors"
 	"sync"
 
 	"github.com/CocaineCong/tangseng/app/favorite/internal/repository/db/dao"
@@ -29,6 +30,7 @@ func (s *FavoriteSrv) FavoriteCreate(ctx context.Context, req *pb.FavoriteCreate
 	resp.Code = e.SUCCESS
 	err = dao.NewFavoriteDao(ctx).CreateFavorite(req)
 	if err != nil {
+		err = errors.WithMessage(err, "dao.CreateFavorite error")
 		resp.Error = err.Error()
 		return
 	}
@@ -43,6 +45,7 @@ func (s *FavoriteSrv) FavoriteList(ctx context.Context, req *pb.FavoriteListReq)
 	resp.Code = e.SUCCESS
 	if err != nil {
 		resp.Code = e.ERROR
+		err = errors.WithMessage(err, "dao.ListFavorite error")
 		return
 	}
 	for i := range f {
@@ -61,12 +64,13 @@ func (s *FavoriteSrv) FavoriteUpdate(ctx context.Context, req *pb.FavoriteUpdate
 	err = dao.NewFavoriteDao(ctx).UpdateFavorite(req)
 	if err != nil {
 		resp.Code = e.ERROR
+		err = errors.WithMessage(err, "dao.UpdateFavorite error")
 		resp.Error = err.Error()
 		return
 	}
 
 	resp.Msg = e.GetMsg(int(resp.Code))
-	return resp, nil
+	return
 }
 
 func (s *FavoriteSrv) FavoriteDelete(ctx context.Context, req *pb.FavoriteDeleteReq) (resp *pb.FavoriteCommonResponse, err error) {
@@ -75,6 +79,7 @@ func (s *FavoriteSrv) FavoriteDelete(ctx context.Context, req *pb.FavoriteDelete
 	err = dao.NewFavoriteDao(ctx).DeleteFavorite(req)
 	if err != nil {
 		resp.Code = e.ERROR
+		err = errors.WithMessage(err, "dao.DeleteFavorite error")
 		resp.Error = err.Error()
 		return
 	}
@@ -89,6 +94,7 @@ func (s *FavoriteSrv) FavoriteDetailCreate(ctx context.Context, req *pb.Favorite
 	err = dao.NewFavoriteDetailDao(ctx).CreateFavoriteDetail(req)
 	if err != nil {
 		resp.Code = e.ERROR
+		err = errors.WithMessage(err, "dao.CreateFavoriteDetail error")
 		resp.Error = err.Error()
 		return
 	}
@@ -102,6 +108,7 @@ func (s *FavoriteSrv) FavoriteDetailDelete(ctx context.Context, req *pb.Favorite
 	err = dao.NewFavoriteDetailDao(ctx).DeleteFavoriteDetail(req)
 	if err != nil {
 		resp.Code = e.ERROR
+		err = errors.WithMessage(err, "dao.DeleteFavoriteDetail error")
 		resp.Error = err.Error()
 		return
 	}
@@ -116,6 +123,7 @@ func (s *FavoriteSrv) FavoriteDetailList(ctx context.Context, req *pb.FavoriteDe
 	fdResp, err := dao.NewFavoriteDetailDao(ctx).ListFavoriteDetail(req)
 	if err != nil {
 		resp.Code = e.ERROR
+		err = errors.WithMessage(err, "dao.ListFavoriteDetail error")
 		return
 	}
 

app/gateway/http/favorites.go

@@ -1,6 +1,7 @@
 package http
 
 import (
+	"github.com/pkg/errors"
 	"net/http"
 
 	"github.com/gin-gonic/gin"
@@ -20,14 +21,16 @@ func ListFavorite(ctx *gin.Context) {
 	}
 	user, err := ctl.GetUserInfo(ctx.Request.Context())
 	if err != nil {
-		log.LogrusObj.Errorf("GetUserInfo:%v", err)
+		log.LogrusObj.Errorf("ctl.GetUserInfo failed, original error: %T %v", errors.Cause(err), errors.Cause(err))
+		log.LogrusObj.Errorf("stack trace: \n%+v\n", err)
 		ctx.JSON(http.StatusOK, ctl.RespError(ctx, err, "获取用户信息错误"))
 		return
 	}
 	req.UserId = user.Id
 	r, err := rpc.FavoriteList(ctx, &req)
 	if err != nil {
-		log.LogrusObj.Errorf("FavoriteList:%v", err)
+		log.LogrusObj.Errorf("rpc.FavoriteList failed, original error: %T %v", errors.Cause(err), errors.Cause(err))
+		log.LogrusObj.Errorf("stack trace: \n%+v\n", err)
 		ctx.JSON(http.StatusOK, ctl.RespError(ctx, err, "FavoriteList RPC服务调用错误"))
 		return
 	}
@@ -44,14 +47,16 @@ func CreateFavorite(ctx *gin.Context) {
 	}
 	user, err := ctl.GetUserInfo(ctx.Request.Context())
 	if err != nil {
-		log.LogrusObj.Errorf("GetUserInfo:%v", err)
+		log.LogrusObj.Errorf("ctl.GetUserInfo failed, original error: %T %v", errors.Cause(err), errors.Cause(err))
+		log.LogrusObj.Errorf("stack trace: \n%+v\n", err)
 		ctx.JSON(http.StatusOK, ctl.RespError(ctx, err, "获取用户信息错误"))
 		return
 	}
 	req.UserId = user.Id
 	r, err := rpc.FavoriteCreate(ctx, &req)
 	if err != nil {
-		log.LogrusObj.Errorf("FavoriteCreate:%v", err)
+		log.LogrusObj.Errorf("rpc.FavoriteCreate failed, original error: %T %v", errors.Cause(err), errors.Cause(err))
+		log.LogrusObj.Errorf("stack trace: \n%+v\n", err)
 		ctx.JSON(http.StatusOK, ctl.RespError(ctx, err, "FavoriteCreateReq RPC服务调用错误"))
 		return
 	}
@@ -68,14 +73,16 @@ func UpdateFavorite(ctx *gin.Context) {
 	}
 	user, err := ctl.GetUserInfo(ctx.Request.Context())
 	if err != nil {
-		log.LogrusObj.Errorf("GetUserInfo:%v", err)
+		log.LogrusObj.Errorf("ctl.GetUserInfo failed, original error: %T %v", errors.Cause(err), errors.Cause(err))
+		log.LogrusObj.Errorf("stack trace: \n%+v\n", err)
 		ctx.JSON(http.StatusOK, ctl.RespError(ctx, err, "获取用户信息错误"))
 		return
 	}
 	req.UserId = user.Id
 	r, err := rpc.FavoriteCreate(ctx, &req)
 	if err != nil {
-		log.LogrusObj.Errorf("FavoriteCreate:%v", err)
+		log.LogrusObj.Errorf("rpc.FavoriteCreate failed, original error: %T %v", errors.Cause(err), errors.Cause(err))
+		log.LogrusObj.Errorf("stack trace: \n%+v\n", err)
 		ctx.JSON(http.StatusOK, ctl.RespError(ctx, err, "UpdateFavorite RPC服务调用错误"))
 		return
 	}
@@ -92,14 +99,16 @@ func DeleteFavorite(ctx *gin.Context) {
 	}
 	user, err := ctl.GetUserInfo(ctx.Request.Context())
 	if err != nil {
-		log.LogrusObj.Errorf("GetUserInfo:%v", err)
+		log.LogrusObj.Errorf("ctl.GetUserInfo failed, original error: %T %v", errors.Cause(err), errors.Cause(err))
+		log.LogrusObj.Errorf("stack trace: \n%+v\n", err)
 		ctx.JSON(http.StatusOK, ctl.RespError(ctx, err, "获取用户信息错误"))
 		return
 	}
 	req.UserId = user.Id
 	r, err := rpc.FavoriteDelete(ctx, &req)
 	if err != nil {
-		log.LogrusObj.Errorf("FavoriteDelete:%v", err)
+		log.LogrusObj.Errorf("rpc.FavoriteDelete failed, original error: %T %v", errors.Cause(err), errors.Cause(err))
+		log.LogrusObj.Errorf("stack trace: \n%+v\n", err)
 		ctx.JSON(http.StatusOK, ctl.RespError(ctx, err, "DeleteFavorite RPC服务调用错误"))
 		return
 	}
@@ -116,14 +125,16 @@ func ListFavoriteDetail(ctx *gin.Context) {
 	}
 	user, err := ctl.GetUserInfo(ctx.Request.Context())
 	if err != nil {
-		log.LogrusObj.Errorf("GetUserInfo:%v", err)
+		log.LogrusObj.Errorf("ctl.GetUserInfo failed, original error: %T %v", errors.Cause(err), errors.Cause(err))
+		log.LogrusObj.Errorf("stack trace: \n%+v\n", err)
 		ctx.JSON(http.StatusOK, ctl.RespError(ctx, err, "获取用户信息错误"))
 		return
 	}
 	req.UserId = user.Id
 	r, err := rpc.FavoriteDetailList(ctx, &req)
 	if err != nil {
-		log.LogrusObj.Errorf("FavoriteDetailList:%v", err)
+		log.LogrusObj.Errorf("rpc.FavoriteDetailList failed, original error: %T %v", errors.Cause(err), errors.Cause(err))
+		log.LogrusObj.Errorf("stack trace: \n%+v\n", err)
 		ctx.JSON(http.StatusOK, ctl.RespError(ctx, err, "FavoriteDetailList RPC服务调用错误"))
 		return
 	}
@@ -140,14 +151,16 @@ func CreateFavoriteDetail(ctx *gin.Context) {
 	}
 	user, err := ctl.GetUserInfo(ctx.Request.Context())
 	if err != nil {
-		log.LogrusObj.Errorf("GetUserInfo:%v", err)
+		log.LogrusObj.Errorf("ctl.GetUserInfo failed, original error: %T %v", errors.Cause(err), errors.Cause(err))
+		log.LogrusObj.Errorf("stack trace: \n%+v\n", err)
 		ctx.JSON(http.StatusOK, ctl.RespError(ctx, err, "获取用户信息错误"))
 		return
 	}
 	req.UserId = user.Id
 	r, err := rpc.FavoriteDetailCreate(ctx, &req)
 	if err != nil {
-		log.LogrusObj.Errorf("FavoriteDetailCreate:%v", err)
+		log.LogrusObj.Errorf("rpc.FavoriteDetailCreate failed, original error: %T %v", errors.Cause(err), errors.Cause(err))
+		log.LogrusObj.Errorf("stack trace: \n%+v\n", err)
 		ctx.JSON(http.StatusOK, ctl.RespError(ctx, err, "FavoriteDetailCreate RPC服务调用错误"))
 		return
 	}
@@ -164,14 +177,16 @@ func DeleteFavoriteDetail(ctx *gin.Context) {
 	}
 	user, err := ctl.GetUserInfo(ctx.Request.Context())
 	if err != nil {
-		log.LogrusObj.Errorf("GetUserInfo:%v", err)
+		log.LogrusObj.Errorf("ctl.GetUserInfo failed, original error: %T %v", errors.Cause(err), errors.Cause(err))
+		log.LogrusObj.Errorf("stack trace: \n%+v\n", err)
 		ctx.JSON(http.StatusOK, ctl.RespError(ctx, err, "获取用户信息错误"))
 		return
 	}
 	req.UserId = user.Id
 	r, err := rpc.FavoriteDetailDelete(ctx, &req)
 	if err != nil {
-		log.LogrusObj.Errorf("FavoriteDetailDelete:%v", err)
+		log.LogrusObj.Errorf("rpc.FavoriteDetailDelete failed, original error: %T %v", errors.Cause(err), errors.Cause(err))
+		log.LogrusObj.Errorf("stack trace: \n%+v\n", err)
 		ctx.JSON(http.StatusOK, ctl.RespError(ctx, err, "FavoriteDetailDelete RPC服务调用错误"))
 		return
 	}

app/gateway/http/index_platform.go

@@ -1,6 +1,7 @@
 package http
 
 import (
+	"github.com/pkg/errors"
 	"net/http"
 
 	"github.com/gin-gonic/gin"
@@ -21,7 +22,8 @@ func BuildIndexByFiles(ctx *gin.Context) {
 
 	r, err := rpc.BuildIndex(ctx, &req)
 	if err != nil {
-		log.LogrusObj.Errorf("BuildIndexByFiles:%v", err)
+		log.LogrusObj.Errorf("rpc.BuildIndex failed, original error: %T %v", errors.Cause(err), errors.Cause(err))
+		log.LogrusObj.Errorf("stack trace: \n%+v\n", err)
 		ctx.JSON(http.StatusOK, ctl.RespError(ctx, err, "BuildIndexByFiles RPC服务调用错误"))
 		return
 	}