fix

shibukazu · Oct 16, 2024 · a709439 · a709439
1 parent afc86e5
commit a709439
Show file tree

Hide file tree

Showing 6 changed files with 73 additions and 27 deletions.
diff --git a/go/pkg/logger/util.go b/go/pkg/logger/util.go
@@ -0,0 +1,12 @@
+package logger
+
+import (
+	"fmt"
+	"log/slog"
+
+	"github.com/morikuni/failure/v2"
+)
+
+func LogError(logger *slog.Logger, err error) {
+	logger.Error(string(failure.MessageOf(err)), slog.Any("code", failure.CodeOf(err)), slog.String("details", fmt.Sprintf("%+v", err)))
+}
diff --git a/go/pkg/server/gateway.go b/go/pkg/server/gateway.go
@@ -18,6 +18,7 @@ import (
 	"github.com/shibukazu/open-ve/go/pkg/appError"
 	"github.com/shibukazu/open-ve/go/pkg/config"
 	"github.com/shibukazu/open-ve/go/pkg/dsl/reader"
+	"github.com/shibukazu/open-ve/go/pkg/logger"
 	"github.com/shibukazu/open-ve/go/pkg/slave"
 	pbDSL "github.com/shibukazu/open-ve/go/proto/dsl/v1"
 	pbSlave "github.com/shibukazu/open-ve/go/proto/slave/v1"
@@ -173,13 +174,17 @@ func (g *Gateway) forwardCheckRequestMiddleware(next http.Handler) http.Handler
 			var reqBody map[string]interface{}
 			var resBody map[string]interface{}
 			if err := json.NewDecoder(r.Body).Decode(&reqBody); err != nil {
-				http.Error(w, failure.Translate(err, appError.ErrRequestParameterInvalid, failure.Messagef("failed to decode request body")).Error(), http.StatusBadRequest)
+				err = failure.Translate(err, appError.ErrRequestParameterInvalid, failure.Messagef("failed to decode request body"))
+				http.Error(w, err.Error(), http.StatusBadRequest)
+				logger.LogError(g.logger, err)
 				return
 			}
 
 			validations, ok := reqBody["validations"].([]interface{})
 			if !ok {
-				http.Error(w, failure.New(appError.ErrRequestParameterInvalid, failure.Messagef("validations field is invalid")).Error(), http.StatusBadRequest)
+				err := failure.New(appError.ErrRequestParameterInvalid, failure.Messagef("validations field is invalid"))
+				http.Error(w, err.Error(), http.StatusBadRequest)
+				logger.LogError(g.logger, err)
 				return
 			}
 
@@ -195,12 +200,16 @@ func (g *Gateway) forwardCheckRequestMiddleware(next http.Handler) http.Handler
 			for _, validation := range validations {
 				validation, ok := validation.(map[string]interface{})
 				if !ok {
-					http.Error(w, failure.New(appError.ErrRequestParameterInvalid, failure.Messagef("validation field is invalid")).Error(), http.StatusBadRequest)
+					err := failure.New(appError.ErrRequestParameterInvalid, failure.Messagef("validation field is invalid"))
+					http.Error(w, err.Error(), http.StatusBadRequest)
+					logger.LogError(g.logger, err)
 					return
 				}
 				id, ok := validation["id"].(string)
 				if !ok {
-					http.Error(w, failure.New(appError.ErrRequestParameterInvalid, failure.Messagef("id field is invalid")).Error(), http.StatusBadRequest)
+					err := failure.New(appError.ErrRequestParameterInvalid, failure.Messagef("id field is invalid"))
+					http.Error(w, err.Error(), http.StatusBadRequest)
+					logger.LogError(g.logger, err)
 					return
 				}
 
@@ -290,18 +299,23 @@ func (g *Gateway) forwardCheckRequestMiddleware(next http.Handler) http.Handler
 				select {
 				case err := <-errCh:
 					http.Error(w, err.Error(), http.StatusInternalServerError)
+					logger.LogError(g.logger, err)
 					return
 				case results := <-ch:
 					validationResults = append(validationResults, results...)
 				case <-time.After(30 * time.Second):
-					http.Error(w, failure.New(appError.ErrRequestForwardFailed, failure.Message("request forward timeout")).Error(), http.StatusInternalServerError)
+					err := failure.New(appError.ErrRequestForwardFailed, failure.Message("request forward timeout"))
+					http.Error(w, err.Error(), http.StatusInternalServerError)
+					logger.LogError(g.logger, err)
 				}
 			}
 
 			reqBody["validations"] = modifiedRequestValidations
 			modifiedReqBody, err := json.Marshal(reqBody)
 			if err != nil {
-				http.Error(w, failure.Translate(err, appError.ErrRequestParameterInvalid, failure.Messagef("failed to marshal modified request body")).Error(), http.StatusInternalServerError)
+				err = failure.Translate(err, appError.ErrRequestParameterInvalid, failure.Messagef("failed to marshal modified request body"))
+				http.Error(w, err.Error(), http.StatusInternalServerError)
+				logger.LogError(g.logger, err)
 				return
 			}
 			r.Body = io.NopCloser(bytes.NewBuffer(modifiedReqBody))
@@ -315,18 +329,24 @@ func (g *Gateway) forwardCheckRequestMiddleware(next http.Handler) http.Handler
 
 			// Concat the validation results
 			if err := json.Unmarshal(rec.body.Bytes(), &resBody); err != nil {
-				http.Error(w, failure.Translate(err, appError.ErrRequestParameterInvalid, failure.Messagef("failed to decode response body")).Error(), http.StatusInternalServerError)
+				err = failure.Translate(err, appError.ErrRequestParameterInvalid, failure.Messagef("failed to decode response body"))
+				http.Error(w, err.Error(), http.StatusInternalServerError)
+				logger.LogError(g.logger, err)
 				return
 			}
 			originalValidationResults, ok := resBody["results"].([]interface{})
 			if !ok {
-				http.Error(w, failure.New(appError.ErrRequestParameterInvalid, failure.Messagef("results field is invalid")).Error(), http.StatusInternalServerError)
+				err := failure.New(appError.ErrRequestParameterInvalid, failure.Messagef("results field is invalid"))
+				http.Error(w, err.Error(), http.StatusInternalServerError)
+				logger.LogError(g.logger, err)
 				return
 			}
 			resBody["results"] = append(originalValidationResults, validationResults...)
 			resBodyJson, err := json.Marshal(resBody)
 			if err != nil {
-				http.Error(w, failure.Translate(err, appError.ErrRequestParameterInvalid, failure.Messagef("failed to marshal response body")).Error(), http.StatusInternalServerError)
+				err = failure.Translate(err, appError.ErrRequestParameterInvalid, failure.Messagef("failed to marshal response body"))
+				http.Error(w, err.Error(), http.StatusInternalServerError)
+				logger.LogError(g.logger, err)
 				return
 			}
 
@@ -348,38 +368,49 @@ func (g *Gateway) validateRequestTypeConvertMiddleware(next http.Handler) http.H
 		if r.URL.Path == "/v1/check" && r.Method == "POST" {
 			var body map[string]interface{}
 			if err := json.NewDecoder(r.Body).Decode(&body); err != nil {
-				http.Error(w, failure.Translate(err, appError.ErrRequestParameterInvalid).Error(), http.StatusBadRequest)
+				err = failure.Translate(err, appError.ErrRequestParameterInvalid, failure.Messagef("failed to decode request body"))
+				http.Error(w, err.Error(), http.StatusBadRequest)
+				logger.LogError(g.logger, err)
 				return
 			}
 
 			validations, ok := body["validations"].([]interface{})
 			if !ok {
-				http.Error(w, failure.New(appError.ErrRequestParameterInvalid, failure.Messagef("validations field is invalid")).Error(), http.StatusBadRequest)
+				err := failure.New(appError.ErrRequestParameterInvalid, failure.Messagef("validations field is invalid"))
+				http.Error(w, err.Error(), http.StatusBadRequest)
+				logger.LogError(g.logger, err)
 				return
 			}
 
 			for idx, validation := range validations {
 				validation, ok := validation.(map[string]interface{})
 				if !ok {
-					http.Error(w, failure.New(appError.ErrRequestParameterInvalid, failure.Messagef("validation field is invalid")).Error(), http.StatusBadRequest)
+					err := failure.New(appError.ErrRequestParameterInvalid, failure.Messagef("validation field is invalid"))
+					http.Error(w, err.Error(), http.StatusBadRequest)
+					logger.LogError(g.logger, err)
 					return
 				}
 
 				id, ok := validation["id"].(string)
 				if !ok {
-					http.Error(w, failure.New(appError.ErrRequestParameterInvalid, failure.Messagef("id field is invalid")).Error(), http.StatusBadRequest)
+					err := failure.New(appError.ErrRequestParameterInvalid, failure.Messagef("id field is invalid"))
+					http.Error(w, err.Error(), http.StatusBadRequest)
+					logger.LogError(g.logger, err)
 					return
 				}
 
 				variables, ok := validation["variables"].(map[string]interface{})
 				if !ok {
-					http.Error(w, failure.New(appError.ErrRequestParameterInvalid, failure.Messagef("variables field is invalid")).Error(), http.StatusBadRequest)
+					err := failure.New(appError.ErrRequestParameterInvalid, failure.Messagef("variables field is invalid"))
+					http.Error(w, err.Error(), http.StatusBadRequest)
+					logger.LogError(g.logger, err)
 					return
 				}
 
 				variableNameToCELType, err := g.dslReader.GetVariableNameToCELType(context.Background(), id)
 				if err != nil {
-					http.Error(w, err.Error(), http.StatusBadRequest)
+					http.Error(w, err.Error(), http.StatusInternalServerError)
+					logger.LogError(g.logger, err)
 					return
 				}
 
@@ -389,6 +420,7 @@ func (g *Gateway) validateRequestTypeConvertMiddleware(next http.Handler) http.H
 					convertedType, err := convertCELTypeToGoogleProtobufType(celType)
 					if err != nil {
 						http.Error(w, err.Error(), http.StatusBadRequest)
+						logger.LogError(g.logger, err)
 						return
 					}
 					variable := make(map[string]interface{}, 2)
@@ -404,7 +436,9 @@ func (g *Gateway) validateRequestTypeConvertMiddleware(next http.Handler) http.H
 			body["validations"] = validations
 			convertedBody, err := json.Marshal(body)
 			if err != nil {
-				http.Error(w, failure.Translate(err, appError.ErrRequestParameterInvalid, failure.Messagef("failed to marshal request body")).Error(), http.StatusBadRequest)
+				err = failure.Translate(err, appError.ErrRequestParameterInvalid, failure.Messagef("failed to marshal request body"))
+				http.Error(w, err.Error(), http.StatusBadRequest)
+				logger.LogError(g.logger, err)
 				return
 			}
 

diff --git a/go/pkg/services/dsl/v1/read.go b/go/pkg/services/dsl/v1/read.go
@@ -2,19 +2,17 @@ package dslv1
 
 import (
 	"context"
-	"fmt"
-	"log/slog"
 
-	"github.com/morikuni/failure/v2"
 	"github.com/shibukazu/open-ve/go/pkg/appError"
 	dslPkg "github.com/shibukazu/open-ve/go/pkg/dsl"
+	"github.com/shibukazu/open-ve/go/pkg/logger"
 	pb "github.com/shibukazu/open-ve/go/proto/dsl/v1"
 )
 
 func (s *Service) Read(ctx context.Context, req *pb.ReadRequest) (*pb.ReadResponse, error) {
 	dsl, err := s.dslReader.Read(ctx)
 	if err != nil {
-		s.logger.Error("failed to read dsl: %v", slog.Any("code", failure.CodeOf(err)), slog.String("message", failure.MessageOf(err).String()), slog.String("details", fmt.Sprintf("%+v", err)))
+		logger.LogError(s.logger, err)
 		return nil, appError.ToGRPCError(err)
 	}
 	return toProto(dsl), nil

diff --git a/go/pkg/services/dsl/v1/register.go b/go/pkg/services/dsl/v1/register.go
@@ -2,23 +2,22 @@ package dslv1
 
 import (
 	"context"
-	"fmt"
-	"log/slog"
 
 	"github.com/morikuni/failure/v2"
 	"github.com/shibukazu/open-ve/go/pkg/appError"
 	dslPkg "github.com/shibukazu/open-ve/go/pkg/dsl"
+	"github.com/shibukazu/open-ve/go/pkg/logger"
 	pb "github.com/shibukazu/open-ve/go/proto/dsl/v1"
 )
 
 func (s *Service) Register(ctx context.Context, req *pb.RegisterRequest) (*pb.RegisterResponse, error) {
 	dsl, err := toDSL(req)
 	if err != nil {
-		s.logger.Error("failed to parse dsl: %v", slog.Any("code", failure.CodeOf(err)), slog.String("message", failure.MessageOf(err).String()), slog.String("details", fmt.Sprintf("%+v", err)))
+		logger.LogError(s.logger, err)
 		return nil, appError.ToGRPCError(err)
 	}
 	if err := s.dslReader.Register(ctx, dsl); err != nil {
-		s.logger.Error("failed to register dsl: %v", slog.Any("code", failure.CodeOf(err)), slog.String("message", failure.MessageOf(err).String()), slog.String("details", fmt.Sprintf("%+v", err)))
+		logger.LogError(s.logger, err)
 		return nil, appError.ToGRPCError(err)
 	}
 	if s.mode == "slave" {

diff --git a/go/pkg/services/validate/v1/check.go b/go/pkg/services/validate/v1/check.go
@@ -5,6 +5,7 @@ import (
 
 	"github.com/morikuni/failure/v2"
 	"github.com/shibukazu/open-ve/go/pkg/appError"
+	"github.com/shibukazu/open-ve/go/pkg/logger"
 	pb "github.com/shibukazu/open-ve/go/proto/validate/v1"
 	"google.golang.org/protobuf/types/known/anypb"
 	"google.golang.org/protobuf/types/known/wrapperspb"
@@ -16,10 +17,12 @@ func (s *Service) Check(ctx context.Context, req *pb.CheckRequest) (*pb.CheckRes
 	for _, validation := range req.Validations {
 		variables, err := convertAnyMapToInterfaceMap(validation.Variables)
 		if err != nil {
+			logger.LogError(s.logger, err)
 			return nil, appError.ToGRPCError(err)
 		}
 		is_valid, msg, err := s.validator.Validate(validation.Id, variables)
 		if err != nil {
+			logger.LogError(s.logger, err)
 			return nil, appError.ToGRPCError(err)
 		}
 		results = append(results, &pb.ValidationResult{Id: validation.Id, IsValid: is_valid, Message: msg})

diff --git a/go/pkg/slave/registrar.go b/go/pkg/slave/registrar.go
@@ -5,7 +5,6 @@ import (
 	"context"
 	"crypto/tls"
 	"encoding/json"
-	"fmt"
 	"log/slog"
 	"net/http"
 	"strings"
@@ -16,6 +15,7 @@ import (
 	"github.com/shibukazu/open-ve/go/pkg/appError"
 	"github.com/shibukazu/open-ve/go/pkg/config"
 	"github.com/shibukazu/open-ve/go/pkg/dsl/reader"
+	"github.com/shibukazu/open-ve/go/pkg/logger"
 )
 
 type SlaveRegistrar struct {
@@ -61,7 +61,7 @@ func (s *SlaveRegistrar) RegisterTimer(ctx context.Context, wg *sync.WaitGroup)
 	s.Register(ctx)
 	err := s.Register(ctx)
 	if err != nil {
-		s.logger.Error("failed to register slave to master: %+v", slog.Any("code", failure.CodeOf(err)), slog.String("message", failure.MessageOf(err).String()), slog.String("details", fmt.Sprintf("%+v", err)))
+		logger.LogError(s.logger, err)
 	}
 	ticker := time.NewTicker(30 * time.Second)
 	for {
@@ -74,7 +74,7 @@ func (s *SlaveRegistrar) RegisterTimer(ctx context.Context, wg *sync.WaitGroup)
 		case <-ticker.C:
 			err := s.Register(ctx)
 			if err != nil {
-				s.logger.Error("failed to register slave to master", slog.Any("code", failure.CodeOf(err)), slog.String("message", failure.MessageOf(err).String()), slog.String("details", fmt.Sprintf("%+v", err)))
+				logger.LogError(s.logger, err)
 			}
 		}
 	}