From ff0e2536617c1ff58420132c88f944dbc5ffeecc Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jo=C3=A3o=20Pedro=20de=20Ara=C3=BAjo=20Xavier?= Date: Thu, 22 Jul 2021 17:00:17 -0300 Subject: [PATCH 1/3] Add error and info logging --- app/app.go | 7 ++-- app/dbOperations/subjects.go | 27 +++++++------- app/handler/subjects.go | 69 +++++++++++++++++++++++++++--------- app/logger/errors.go | 27 ++++++++++++++ app/logger/logger.go | 51 ++++++++++++++++++++++++++ app/model/api/subject.go | 16 +++++++++ app/model/storage/subject.go | 16 +++++++++ go.mod | 1 + 8 files changed, 182 insertions(+), 32 deletions(-) create mode 100644 app/logger/errors.go create mode 100644 app/logger/logger.go diff --git a/app/app.go b/app/app.go index a19e1f6..1f692ae 100644 --- a/app/app.go +++ b/app/app.go @@ -9,6 +9,7 @@ import ( "github.com/gorilla/mux" "github.com/rs/zerolog" + "github.com/rs/zerolog/log" gremcos "github.com/supplyon/gremcos" "github.com/imeplusplus/dont-panic-api/app/handler" @@ -31,7 +32,7 @@ func (app *App) Initialize() { fmt.Println(username) fmt.Println(password) - app.Logger = zerolog.New(os.Stdout).Output(zerolog.ConsoleWriter{Out: os.Stdout, TimeFormat: zerolog.TimeFieldFormat}).With().Timestamp().Logger() + app.Logger = log.Logger app.Cosmos, err = gremcos.New(host, gremcos.WithAuth(username, password), gremcos.WithLogger(app.Logger), @@ -41,7 +42,7 @@ func (app *App) Initialize() { ) if err != nil { - fmt.Println("Could not connect database") + log.Error().Err(err).Msg("Could not connect to server") } app.Router = mux.NewRouter() @@ -87,5 +88,5 @@ func (app *App) handleRequest(handler RequestHandlerFunction) http.HandlerFunc { // Run the app on it's router func (app *App) Run(host string) { - fmt.Println(http.ListenAndServe(host, app.Router)) + log.Info().Msg(http.ListenAndServe(host, app.Router).Error()) } diff --git a/app/dbOperations/subjects.go b/app/dbOperations/subjects.go index aee11d9..4c3df24 100644 --- a/app/dbOperations/subjects.go +++ b/app/dbOperations/subjects.go @@ -1,13 +1,14 @@ package dbOperations import ( - "errors" "fmt" + "github.com/rs/zerolog/log" gremcos "github.com/supplyon/gremcos" "github.com/supplyon/gremcos/api" "github.com/supplyon/gremcos/interfaces" + "github.com/imeplusplus/dont-panic-api/app/logger" apiModel "github.com/imeplusplus/dont-panic-api/app/model/api" storageModel "github.com/imeplusplus/dont-panic-api/app/model/storage" ) @@ -19,8 +20,7 @@ func GetSubjects(cosmos gremcos.Cosmos) ([]storageModel.Subject, error) { res, err := cosmos.ExecuteQuery(query) if err != nil { - fmt.Println("Failed to execute a gremlin command " + query.String()) - //logger.Error().Err(err).Msg("Failed to execute a gremlin command") + log.Error().Err(err).Msg(fmt.Sprintf("Failed to execute the gremlin command: %v", query)) return nil, err } @@ -42,8 +42,7 @@ func GetSubjectByName(cosmos gremcos.Cosmos, name string) (storageModel.Subject, res, err := cosmos.ExecuteQuery(query) if err != nil { - fmt.Println("Failed to execute a gremlin command " + query.String()) - //logger.Error().Err(err).Msg("Failed to execute a gremlin command") + log.Error().Err(err).Msg(fmt.Sprintf("Failed to execute the gremlin command: %v", query)) return subject, err } @@ -54,7 +53,9 @@ func CreateSubject(cosmos gremcos.Cosmos, subject apiModel.Subject) (storageMode _, err := GetSubjectByName(cosmos, subject.Name) if err == nil { - return storageModel.Subject{}, errors.New("There is already a subject with name " + subject.Name) + err := logger.ErrorResourceAlreadyExists{ResourceName: subject.Name}.Error() + log.Error().Err(err).Msg(fmt.Sprintf("There is already a subject with name %s in the database", subject.Name)) + return storageModel.Subject{}, err } g := api.NewGraph("g") @@ -64,8 +65,7 @@ func CreateSubject(cosmos gremcos.Cosmos, subject apiModel.Subject) (storageMode res, err := cosmos.ExecuteQuery(query) if err != nil { - fmt.Println("Failed to execute a gremlin command " + query.String()) - // logger.Error().Err(err).Msg("Failed to execute gremlin command") + log.Error().Err(err).Msg(fmt.Sprintf("Failed to execute the gremlin command: %v", query)) return storageModel.Subject{}, err } @@ -76,7 +76,9 @@ func UpdateSubject(cosmos gremcos.Cosmos, subject apiModel.Subject, name string) oldSubject, err := GetSubjectByName(cosmos, name) if err != nil { - return storageModel.Subject{}, errors.New("There is no subject with name " + oldSubject.Name) + err := logger.ErrorResourceNotFound{ResourceName: name}.Error() + log.Error().Err(err).Msg(fmt.Sprintf("Couldn't find subject with name %s in the database", name)) + return storageModel.Subject{}, err } g := api.NewGraph("g") @@ -84,8 +86,7 @@ func UpdateSubject(cosmos gremcos.Cosmos, subject apiModel.Subject, name string) res, err := cosmos.ExecuteQuery(query) if err != nil { - fmt.Println("Failed to execute a gremlin command " + query.String()) - //logger.Error().Err(err).Msg("Failed to execute a gremlin command") + log.Error().Err(err).Msg(fmt.Sprintf("Failed to execute the gremlin command: %v", query)) return storageModel.Subject{}, err } @@ -124,7 +125,9 @@ func getSubjectFromResponse(res []interfaces.Response) (storageModel.Subject, er vertices, _ := response.ToVertices() if len(vertices) == 0 { - return subject, errors.New("there is no vertex in the response") + err := logger.ErrorResourceNotFound{ResourceName: "response"}.Error() + log.Error().Err(err).Msg("") + return subject, err } subject = vertexToSubject(vertices[0]) diff --git a/app/handler/subjects.go b/app/handler/subjects.go index 6b136f2..346fe88 100644 --- a/app/handler/subjects.go +++ b/app/handler/subjects.go @@ -2,21 +2,23 @@ package handler import ( "encoding/json" - "fmt" "net/http" "github.com/gorilla/mux" + "github.com/rs/zerolog/log" gremcos "github.com/supplyon/gremcos" "github.com/imeplusplus/dont-panic-api/app/dbOperations" + "github.com/imeplusplus/dont-panic-api/app/logger" apiModel "github.com/imeplusplus/dont-panic-api/app/model/api" + storageModel "github.com/imeplusplus/dont-panic-api/app/model/storage" ) func GetSubjects(cosmos gremcos.Cosmos, w http.ResponseWriter, _ *http.Request) { res, err := dbOperations.GetSubjects(cosmos) if err != nil { - fmt.Println(err) + log.Error().Stack().Err(err).Msg("") w.WriteHeader(http.StatusInternalServerError) return } @@ -25,9 +27,13 @@ func GetSubjects(cosmos gremcos.Cosmos, w http.ResponseWriter, _ *http.Request) err = json.NewEncoder(w).Encode(res) if err != nil { - fmt.Println(err) + log.Error().Stack().Err(err).Msg("") w.WriteHeader(http.StatusInternalServerError) } + msg := logger.ResourceRead{ + Resource: storageModel.PrettyPrint(res), + } + log.Info().Msg(msg.Info()) } func GetSubject(cosmos gremcos.Cosmos, w http.ResponseWriter, r *http.Request) { @@ -36,7 +42,7 @@ func GetSubject(cosmos gremcos.Cosmos, w http.ResponseWriter, r *http.Request) { res, err := dbOperations.GetSubjectByName(cosmos, vars["name"]) if err != nil { - fmt.Println(err) + log.Error().Stack().Err(err).Msg("") w.WriteHeader(http.StatusInternalServerError) return } @@ -45,26 +51,32 @@ func GetSubject(cosmos gremcos.Cosmos, w http.ResponseWriter, r *http.Request) { err = json.NewEncoder(w).Encode(res) if err != nil { - fmt.Println(err) + log.Error().Stack().Err(err).Msg("") w.WriteHeader(http.StatusInternalServerError) } + + msg := logger.ResourceRead{ + Resource: storageModel.PrettyPrint(res), + } + log.Info().Msg(msg.Info()) } func UpdateSubject(cosmos gremcos.Cosmos, w http.ResponseWriter, r *http.Request) { vars := mux.Vars(r) + name := vars["name"] + oldSubject, err := dbOperations.GetSubjectByName(cosmos, name) subject := apiModel.Subject{} - err := json.NewDecoder(r.Body).Decode(&subject) - - if err != nil { + if err := json.NewDecoder(r.Body).Decode(&subject); err != nil { + log.Error().Stack().Err(err).Msg("Couldn't parse request body into apiModel.Subject") w.WriteHeader(http.StatusBadRequest) return } - res, err := dbOperations.UpdateSubject(cosmos, subject, vars["name"]) + res, err := dbOperations.UpdateSubject(cosmos, subject, name) if err != nil { - fmt.Println(err) + log.Error().Stack().Err(err).Msg("") w.WriteHeader(http.StatusInternalServerError) return } @@ -74,30 +86,48 @@ func UpdateSubject(cosmos gremcos.Cosmos, w http.ResponseWriter, r *http.Request err = json.NewEncoder(w).Encode(res) if err != nil { - fmt.Println(err) + log.Error().Stack().Err(err).Msg("Couldn't create response body with created subject") w.WriteHeader(http.StatusInternalServerError) } + msg := logger.ResourceUpdated{ + PastResource: storageModel.PrettyPrint(oldSubject), + NewResource: storageModel.PrettyPrint(res), + } + log.Info().Msg(msg.Info()) } func DeleteSubject(cosmos gremcos.Cosmos, w http.ResponseWriter, r *http.Request) { vars := mux.Vars(r) + name := vars["name"] + subject, err := dbOperations.GetSubjectByName(cosmos, name) - err := dbOperations.DeleteSubject(cosmos, vars["name"]) + if err != nil { + log.Error().Stack().Err(err).Msg("") + w.WriteHeader(http.StatusInternalServerError) + return + } + + err = dbOperations.DeleteSubject(cosmos, name) if err != nil { - fmt.Println(err) + log.Error().Stack().Err(err).Msg("") w.WriteHeader(http.StatusInternalServerError) return } w.Header().Add("Content-Type", "application/json") w.WriteHeader(http.StatusAccepted) + + msg := logger.ResourceCreated{ + Resource: storageModel.PrettyPrint(subject), + } + log.Info().Msg(msg.Info()) } func CreateSubject(cosmos gremcos.Cosmos, w http.ResponseWriter, r *http.Request) { subject := apiModel.Subject{} - var err error - if err = json.NewDecoder(r.Body).Decode(&subject); err != nil { + if err := json.NewDecoder(r.Body).Decode(&subject); err != nil { + log.Error().Stack().Err(err).Msg("Couldn't parse request body into apiModel.Subject") w.WriteHeader(http.StatusBadRequest) return } @@ -105,7 +135,7 @@ func CreateSubject(cosmos gremcos.Cosmos, w http.ResponseWriter, r *http.Request res, err := dbOperations.CreateSubject(cosmos, subject) if err != nil { - fmt.Println(err) + log.Error().Stack().Err(err).Msg("") w.WriteHeader(http.StatusInternalServerError) return } @@ -115,7 +145,12 @@ func CreateSubject(cosmos gremcos.Cosmos, w http.ResponseWriter, r *http.Request err = json.NewEncoder(w).Encode(res) if err != nil { - fmt.Println(err) + log.Error().Stack().Err(err).Msg("Couldn't create response body with created subject") w.WriteHeader(http.StatusInternalServerError) } + + msg := logger.ResourceCreated{ + Resource: storageModel.PrettyPrint(res), + } + log.Info().Msg(msg.Info()) } diff --git a/app/logger/errors.go b/app/logger/errors.go new file mode 100644 index 0000000..5a77770 --- /dev/null +++ b/app/logger/errors.go @@ -0,0 +1,27 @@ +package logger + +import ( + "fmt" +) + +var ( + errorResourceAlreadyExistsMessage = LogEvent{1, "Resource %s already exists"} + errorResourceNotFoundMessage = LogEvent{2, "Resource %s not found"} + errorNoVertexInResourceMessage = LogEvent{3, "There is no vertex in resource %s"} +) + +type ErrorResourceAlreadyExists struct{ ResourceName string } +type ErrorResourceNotFound struct{ ResourceName string } +type ErrorNoVertexInResource struct{ ResourceName string } + +func (e ErrorResourceAlreadyExists) Error() error { + return fmt.Errorf(errorResourceAlreadyExistsMessage.message, e.ResourceName) +} + +func (e ErrorResourceNotFound) Error() error { + return fmt.Errorf(errorResourceNotFoundMessage.message, e.ResourceName) +} + +func (e ErrorNoVertexInResource) Error() error { + return fmt.Errorf(errorNoVertexInResourceMessage.message, e.ResourceName) +} diff --git a/app/logger/logger.go b/app/logger/logger.go new file mode 100644 index 0000000..93c7fdd --- /dev/null +++ b/app/logger/logger.go @@ -0,0 +1,51 @@ +package logger + +import ( + "fmt" + "os" + + "github.com/rs/zerolog" + "github.com/rs/zerolog/log" + "github.com/rs/zerolog/pkgerrors" +) + +type LogEvent struct { + id int + message string +} + +var ( + resourceCreatedMessage = LogEvent{1001, "Resource created.\nContent:\n%s"} + resourceUpdatedMessage = LogEvent{1002, "Resource updated.\nBefore:\n%s\nAfter:\n%s"} + resourceReadMessage = LogEvent{1003, "Resource read.\nContent:\n%s"} + resourceDeletedMessage = LogEvent{1004, "Resource %s deleted."} +) + +type ResourceCreated struct{ Resource string } +type ResourceUpdated struct { + PastResource string + NewResource string +} +type ResourceRead struct{ Resource string } +type ResourceDeleted struct{ Resource string } + +func init() { + log.Logger = zerolog.New(os.Stdout).Output(zerolog.ConsoleWriter{Out: os.Stdout, TimeFormat: zerolog.TimeFieldFormat}).With().Timestamp().Logger() + zerolog.ErrorStackMarshaler = pkgerrors.MarshalStack +} + +func (e ResourceCreated) Info() string { + return fmt.Sprintf(resourceCreatedMessage.message, e.Resource) +} + +func (e ResourceUpdated) Info() string { + return fmt.Sprintf(resourceUpdatedMessage.message, e.PastResource, e.NewResource) +} + +func (e ResourceRead) Info() string { + return fmt.Sprintf(resourceReadMessage.message, e.Resource) +} + +func (e ResourceDeleted) Info() string { + return fmt.Sprintf(resourceReadMessage.message, e.Resource) +} diff --git a/app/model/api/subject.go b/app/model/api/subject.go index a635432..6d5c21e 100644 --- a/app/model/api/subject.go +++ b/app/model/api/subject.go @@ -1,5 +1,12 @@ package model +import ( + "encoding/json" + "fmt" + + "github.com/rs/zerolog/log" +) + type Subject struct { Id string `json:"id"` Name string `json:"name"` @@ -8,3 +15,12 @@ type Subject struct { Category string `json:"category"` PartitionKey string `json:"partitionKey"` } + +func PrettyPrint(subjects ...interface{}) string { + subjectJSON, err := json.MarshalIndent(subjects, "", " ") + if err != nil { + log.Error().Stack().Err(err).Msg("Couldn't make resource pretty to print") + return fmt.Sprintf("%v", subjects) + } + return string(subjectJSON) +} diff --git a/app/model/storage/subject.go b/app/model/storage/subject.go index a635432..6d5c21e 100644 --- a/app/model/storage/subject.go +++ b/app/model/storage/subject.go @@ -1,5 +1,12 @@ package model +import ( + "encoding/json" + "fmt" + + "github.com/rs/zerolog/log" +) + type Subject struct { Id string `json:"id"` Name string `json:"name"` @@ -8,3 +15,12 @@ type Subject struct { Category string `json:"category"` PartitionKey string `json:"partitionKey"` } + +func PrettyPrint(subjects ...interface{}) string { + subjectJSON, err := json.MarshalIndent(subjects, "", " ") + if err != nil { + log.Error().Stack().Err(err).Msg("Couldn't make resource pretty to print") + return fmt.Sprintf("%v", subjects) + } + return string(subjectJSON) +} diff --git a/go.mod b/go.mod index 5b8eb84..c0eaea9 100644 --- a/go.mod +++ b/go.mod @@ -4,6 +4,7 @@ go 1.16 require ( github.com/gorilla/mux v1.8.0 + github.com/pkg/errors v0.9.1 // indirect github.com/rs/zerolog v1.22.0 github.com/supplyon/gremcos v0.1.7 ) From b20f414550a24e0e795560ae241064b41ed01b87 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jo=C3=A3o=20Pedro=20de=20Ara=C3=BAjo=20Xavier?= Date: Thu, 22 Jul 2021 17:00:17 -0300 Subject: [PATCH 2/3] Add error and info logging --- app/app.go | 7 ++-- app/dbOperations/subjects.go | 27 ++++++++------- app/handler/subjects.go | 66 +++++++++++++++++++++++++++--------- app/logger/errors.go | 27 +++++++++++++++ app/logger/logger.go | 51 ++++++++++++++++++++++++++++ app/model/api/subject.go | 16 +++++++++ app/model/storage/subject.go | 16 +++++++++ go.mod | 1 + 8 files changed, 180 insertions(+), 31 deletions(-) create mode 100644 app/logger/errors.go create mode 100644 app/logger/logger.go diff --git a/app/app.go b/app/app.go index a19e1f6..1f692ae 100644 --- a/app/app.go +++ b/app/app.go @@ -9,6 +9,7 @@ import ( "github.com/gorilla/mux" "github.com/rs/zerolog" + "github.com/rs/zerolog/log" gremcos "github.com/supplyon/gremcos" "github.com/imeplusplus/dont-panic-api/app/handler" @@ -31,7 +32,7 @@ func (app *App) Initialize() { fmt.Println(username) fmt.Println(password) - app.Logger = zerolog.New(os.Stdout).Output(zerolog.ConsoleWriter{Out: os.Stdout, TimeFormat: zerolog.TimeFieldFormat}).With().Timestamp().Logger() + app.Logger = log.Logger app.Cosmos, err = gremcos.New(host, gremcos.WithAuth(username, password), gremcos.WithLogger(app.Logger), @@ -41,7 +42,7 @@ func (app *App) Initialize() { ) if err != nil { - fmt.Println("Could not connect database") + log.Error().Err(err).Msg("Could not connect to server") } app.Router = mux.NewRouter() @@ -87,5 +88,5 @@ func (app *App) handleRequest(handler RequestHandlerFunction) http.HandlerFunc { // Run the app on it's router func (app *App) Run(host string) { - fmt.Println(http.ListenAndServe(host, app.Router)) + log.Info().Msg(http.ListenAndServe(host, app.Router).Error()) } diff --git a/app/dbOperations/subjects.go b/app/dbOperations/subjects.go index 0b84b1e..ab14f14 100644 --- a/app/dbOperations/subjects.go +++ b/app/dbOperations/subjects.go @@ -1,13 +1,14 @@ package dbOperations import ( - "errors" "fmt" + "github.com/rs/zerolog/log" gremcos "github.com/supplyon/gremcos" "github.com/supplyon/gremcos/api" "github.com/supplyon/gremcos/interfaces" + "github.com/imeplusplus/dont-panic-api/app/logger" storageModel "github.com/imeplusplus/dont-panic-api/app/model/storage" ) @@ -18,8 +19,7 @@ func GetSubjects(cosmos gremcos.Cosmos) ([]storageModel.Subject, error) { res, err := cosmos.ExecuteQuery(query) if err != nil { - fmt.Println("Failed to execute a gremlin command " + query.String()) - //logger.Error().Err(err).Msg("Failed to execute a gremlin command") + log.Error().Err(err).Msg(fmt.Sprintf("Failed to execute the gremlin command: %v", query)) return nil, err } @@ -41,8 +41,7 @@ func GetSubjectByName(cosmos gremcos.Cosmos, name string) (storageModel.Subject, res, err := cosmos.ExecuteQuery(query) if err != nil { - fmt.Println("Failed to execute a gremlin command " + query.String()) - //logger.Error().Err(err).Msg("Failed to execute a gremlin command") + log.Error().Err(err).Msg(fmt.Sprintf("Failed to execute the gremlin command: %v", query)) return subject, err } @@ -53,7 +52,9 @@ func CreateSubject(cosmos gremcos.Cosmos, subject storageModel.Subject) (storage _, err := GetSubjectByName(cosmos, subject.Name) if err == nil { - return storageModel.Subject{}, errors.New("There is already a subject with name " + subject.Name) + err := logger.ErrorResourceAlreadyExists{ResourceName: subject.Name}.Error() + log.Error().Err(err).Msg(fmt.Sprintf("There is already a subject with name %s in the database", subject.Name)) + return storageModel.Subject{}, err } g := api.NewGraph("g") @@ -64,8 +65,7 @@ func CreateSubject(cosmos gremcos.Cosmos, subject storageModel.Subject) (storage res, err := cosmos.ExecuteQuery(query) if err != nil { - fmt.Println("Failed to execute a gremlin command " + query.String()) - // logger.Error().Err(err).Msg("Failed to execute gremlin command") + log.Error().Err(err).Msg(fmt.Sprintf("Failed to execute the gremlin command: %v", query)) return storageModel.Subject{}, err } @@ -76,7 +76,9 @@ func UpdateSubject(cosmos gremcos.Cosmos, subject storageModel.Subject, name str oldSubject, err := GetSubjectByName(cosmos, name) if err != nil { - return storageModel.Subject{}, errors.New("There is no subject with name " + oldSubject.Name) + err := logger.ErrorResourceNotFound{ResourceName: name}.Error() + log.Error().Err(err).Msg(fmt.Sprintf("Couldn't find subject with name %s in the database", name)) + return storageModel.Subject{}, err } g := api.NewGraph("g") @@ -84,8 +86,7 @@ func UpdateSubject(cosmos gremcos.Cosmos, subject storageModel.Subject, name str res, err := cosmos.ExecuteQuery(query) if err != nil { - fmt.Println("Failed to execute a gremlin command " + query.String()) - //logger.Error().Err(err).Msg("Failed to execute a gremlin command") + log.Error().Err(err).Msg(fmt.Sprintf("Failed to execute the gremlin command: %v", query)) return storageModel.Subject{}, err } @@ -124,7 +125,9 @@ func getSubjectFromResponse(res []interfaces.Response) (storageModel.Subject, er vertices, _ := response.ToVertices() if len(vertices) == 0 { - return subject, errors.New("there is no vertex in the response") + err := logger.ErrorResourceNotFound{ResourceName: "response"}.Error() + log.Error().Err(err).Msg("") + return subject, err } subject = vertexToSubject(vertices[0]) diff --git a/app/handler/subjects.go b/app/handler/subjects.go index b6fa512..1aa9521 100644 --- a/app/handler/subjects.go +++ b/app/handler/subjects.go @@ -2,13 +2,14 @@ package handler import ( "encoding/json" - "fmt" "net/http" "github.com/gorilla/mux" + "github.com/rs/zerolog/log" gremcos "github.com/supplyon/gremcos" "github.com/imeplusplus/dont-panic-api/app/dbOperations" + "github.com/imeplusplus/dont-panic-api/app/logger" apiModel "github.com/imeplusplus/dont-panic-api/app/model/api" storageModel "github.com/imeplusplus/dont-panic-api/app/model/storage" ) @@ -17,7 +18,7 @@ func GetSubjects(cosmos gremcos.Cosmos, w http.ResponseWriter, _ *http.Request) storageSubjects, err := dbOperations.GetSubjects(cosmos) if err != nil { - fmt.Println(err) + log.Error().Stack().Err(err).Msg("") w.WriteHeader(http.StatusInternalServerError) return } @@ -26,9 +27,13 @@ func GetSubjects(cosmos gremcos.Cosmos, w http.ResponseWriter, _ *http.Request) err = json.NewEncoder(w).Encode(storageSubjects) if err != nil { - fmt.Println(err) + log.Error().Stack().Err(err).Msg("") w.WriteHeader(http.StatusInternalServerError) } + msg := logger.ResourceRead{ + Resource: storageModel.PrettyPrint(res), + } + log.Info().Msg(msg.Info()) } func GetSubject(cosmos gremcos.Cosmos, w http.ResponseWriter, r *http.Request) { @@ -37,7 +42,7 @@ func GetSubject(cosmos gremcos.Cosmos, w http.ResponseWriter, r *http.Request) { storageSubject, err := dbOperations.GetSubjectByName(cosmos, vars["name"]) if err != nil { - fmt.Println(err) + log.Error().Stack().Err(err).Msg("") w.WriteHeader(http.StatusInternalServerError) return } @@ -46,18 +51,24 @@ func GetSubject(cosmos gremcos.Cosmos, w http.ResponseWriter, r *http.Request) { err = json.NewEncoder(w).Encode(storageSubject) if err != nil { - fmt.Println(err) + log.Error().Stack().Err(err).Msg("") w.WriteHeader(http.StatusInternalServerError) } + + msg := logger.ResourceRead{ + Resource: storageModel.PrettyPrint(res), + } + log.Info().Msg(msg.Info()) } func UpdateSubject(cosmos gremcos.Cosmos, w http.ResponseWriter, r *http.Request) { vars := mux.Vars(r) + name := vars["name"] + oldSubject, err := dbOperations.GetSubjectByName(cosmos, name) apiSubject := apiModel.Subject{} - err := json.NewDecoder(r.Body).Decode(&apiSubject) - - if err != nil { + if err := json.NewDecoder(r.Body).Decode(&apiSubject); err != nil { + log.Error().Stack().Err(err).Msg("Couldn't parse request body into apiModel.Subject") w.WriteHeader(http.StatusBadRequest) return } @@ -65,7 +76,7 @@ func UpdateSubject(cosmos gremcos.Cosmos, w http.ResponseWriter, r *http.Request storageSubject, err := dbOperations.UpdateSubject(cosmos, storageModel.Subject(apiSubject), vars["name"]) if err != nil { - fmt.Println(err) + log.Error().Stack().Err(err).Msg("") w.WriteHeader(http.StatusInternalServerError) return } @@ -75,30 +86,48 @@ func UpdateSubject(cosmos gremcos.Cosmos, w http.ResponseWriter, r *http.Request err = json.NewEncoder(w).Encode(storageSubject) if err != nil { - fmt.Println(err) + log.Error().Stack().Err(err).Msg("Couldn't create response body with created subject") w.WriteHeader(http.StatusInternalServerError) } + msg := logger.ResourceUpdated{ + PastResource: storageModel.PrettyPrint(oldSubject), + NewResource: storageModel.PrettyPrint(storageSubject), + } + log.Info().Msg(msg.Info()) } func DeleteSubject(cosmos gremcos.Cosmos, w http.ResponseWriter, r *http.Request) { vars := mux.Vars(r) + name := vars["name"] + subject, err := dbOperations.GetSubjectByName(cosmos, name) - err := dbOperations.DeleteSubject(cosmos, vars["name"]) + if err != nil { + log.Error().Stack().Err(err).Msg("") + w.WriteHeader(http.StatusInternalServerError) + return + } + + err = dbOperations.DeleteSubject(cosmos, name) if err != nil { - fmt.Println(err) + log.Error().Stack().Err(err).Msg("") w.WriteHeader(http.StatusInternalServerError) return } w.Header().Add("Content-Type", "application/json") w.WriteHeader(http.StatusAccepted) + + msg := logger.ResourceCreated{ + Resource: storageModel.PrettyPrint(subject), + } + log.Info().Msg(msg.Info()) } func CreateSubject(cosmos gremcos.Cosmos, w http.ResponseWriter, r *http.Request) { apiSubject := apiModel.Subject{} - var err error - if err = json.NewDecoder(r.Body).Decode(&apiSubject); err != nil { + if err := json.NewDecoder(r.Body).Decode(&apiSubject); err != nil { + log.Error().Stack().Err(err).Msg("Couldn't parse request body into apiModel.Subject") w.WriteHeader(http.StatusBadRequest) return } @@ -106,7 +135,7 @@ func CreateSubject(cosmos gremcos.Cosmos, w http.ResponseWriter, r *http.Request storageSubject, err := dbOperations.CreateSubject(cosmos, storageModel.Subject(apiSubject)) if err != nil { - fmt.Println(err) + log.Error().Stack().Err(err).Msg("") w.WriteHeader(http.StatusInternalServerError) return } @@ -116,7 +145,12 @@ func CreateSubject(cosmos gremcos.Cosmos, w http.ResponseWriter, r *http.Request err = json.NewEncoder(w).Encode(storageSubject) if err != nil { - fmt.Println(err) + log.Error().Stack().Err(err).Msg("Couldn't create response body with created subject") w.WriteHeader(http.StatusInternalServerError) } + + msg := logger.ResourceCreated{ + Resource: storageModel.PrettyPrint(storageSubject), + } + log.Info().Msg(msg.Info()) } diff --git a/app/logger/errors.go b/app/logger/errors.go new file mode 100644 index 0000000..5a77770 --- /dev/null +++ b/app/logger/errors.go @@ -0,0 +1,27 @@ +package logger + +import ( + "fmt" +) + +var ( + errorResourceAlreadyExistsMessage = LogEvent{1, "Resource %s already exists"} + errorResourceNotFoundMessage = LogEvent{2, "Resource %s not found"} + errorNoVertexInResourceMessage = LogEvent{3, "There is no vertex in resource %s"} +) + +type ErrorResourceAlreadyExists struct{ ResourceName string } +type ErrorResourceNotFound struct{ ResourceName string } +type ErrorNoVertexInResource struct{ ResourceName string } + +func (e ErrorResourceAlreadyExists) Error() error { + return fmt.Errorf(errorResourceAlreadyExistsMessage.message, e.ResourceName) +} + +func (e ErrorResourceNotFound) Error() error { + return fmt.Errorf(errorResourceNotFoundMessage.message, e.ResourceName) +} + +func (e ErrorNoVertexInResource) Error() error { + return fmt.Errorf(errorNoVertexInResourceMessage.message, e.ResourceName) +} diff --git a/app/logger/logger.go b/app/logger/logger.go new file mode 100644 index 0000000..93c7fdd --- /dev/null +++ b/app/logger/logger.go @@ -0,0 +1,51 @@ +package logger + +import ( + "fmt" + "os" + + "github.com/rs/zerolog" + "github.com/rs/zerolog/log" + "github.com/rs/zerolog/pkgerrors" +) + +type LogEvent struct { + id int + message string +} + +var ( + resourceCreatedMessage = LogEvent{1001, "Resource created.\nContent:\n%s"} + resourceUpdatedMessage = LogEvent{1002, "Resource updated.\nBefore:\n%s\nAfter:\n%s"} + resourceReadMessage = LogEvent{1003, "Resource read.\nContent:\n%s"} + resourceDeletedMessage = LogEvent{1004, "Resource %s deleted."} +) + +type ResourceCreated struct{ Resource string } +type ResourceUpdated struct { + PastResource string + NewResource string +} +type ResourceRead struct{ Resource string } +type ResourceDeleted struct{ Resource string } + +func init() { + log.Logger = zerolog.New(os.Stdout).Output(zerolog.ConsoleWriter{Out: os.Stdout, TimeFormat: zerolog.TimeFieldFormat}).With().Timestamp().Logger() + zerolog.ErrorStackMarshaler = pkgerrors.MarshalStack +} + +func (e ResourceCreated) Info() string { + return fmt.Sprintf(resourceCreatedMessage.message, e.Resource) +} + +func (e ResourceUpdated) Info() string { + return fmt.Sprintf(resourceUpdatedMessage.message, e.PastResource, e.NewResource) +} + +func (e ResourceRead) Info() string { + return fmt.Sprintf(resourceReadMessage.message, e.Resource) +} + +func (e ResourceDeleted) Info() string { + return fmt.Sprintf(resourceReadMessage.message, e.Resource) +} diff --git a/app/model/api/subject.go b/app/model/api/subject.go index a635432..6d5c21e 100644 --- a/app/model/api/subject.go +++ b/app/model/api/subject.go @@ -1,5 +1,12 @@ package model +import ( + "encoding/json" + "fmt" + + "github.com/rs/zerolog/log" +) + type Subject struct { Id string `json:"id"` Name string `json:"name"` @@ -8,3 +15,12 @@ type Subject struct { Category string `json:"category"` PartitionKey string `json:"partitionKey"` } + +func PrettyPrint(subjects ...interface{}) string { + subjectJSON, err := json.MarshalIndent(subjects, "", " ") + if err != nil { + log.Error().Stack().Err(err).Msg("Couldn't make resource pretty to print") + return fmt.Sprintf("%v", subjects) + } + return string(subjectJSON) +} diff --git a/app/model/storage/subject.go b/app/model/storage/subject.go index a635432..6d5c21e 100644 --- a/app/model/storage/subject.go +++ b/app/model/storage/subject.go @@ -1,5 +1,12 @@ package model +import ( + "encoding/json" + "fmt" + + "github.com/rs/zerolog/log" +) + type Subject struct { Id string `json:"id"` Name string `json:"name"` @@ -8,3 +15,12 @@ type Subject struct { Category string `json:"category"` PartitionKey string `json:"partitionKey"` } + +func PrettyPrint(subjects ...interface{}) string { + subjectJSON, err := json.MarshalIndent(subjects, "", " ") + if err != nil { + log.Error().Stack().Err(err).Msg("Couldn't make resource pretty to print") + return fmt.Sprintf("%v", subjects) + } + return string(subjectJSON) +} diff --git a/go.mod b/go.mod index 5b8eb84..c0eaea9 100644 --- a/go.mod +++ b/go.mod @@ -4,6 +4,7 @@ go 1.16 require ( github.com/gorilla/mux v1.8.0 + github.com/pkg/errors v0.9.1 // indirect github.com/rs/zerolog v1.22.0 github.com/supplyon/gremcos v0.1.7 ) From 57b76257bb27924035ad3d1cbcbf7483d103553b Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jo=C3=A3o=20Pedro=20de=20Ara=C3=BAjo=20Xavier?= Date: Tue, 3 Aug 2021 18:59:59 -0300 Subject: [PATCH 3/3] Refactor error messages and log them only in handler --- app/dbOperations/subjects.go | 17 +------ app/handler/subjects.go | 87 +++++++++++++++++++++--------------- app/logger/errors.go | 20 ++++----- app/logger/logger.go | 32 ------------- app/logger/messages.go | 60 +++++++++++++++++++++++++ 5 files changed, 123 insertions(+), 93 deletions(-) create mode 100644 app/logger/messages.go diff --git a/app/dbOperations/subjects.go b/app/dbOperations/subjects.go index ab14f14..b07a24e 100644 --- a/app/dbOperations/subjects.go +++ b/app/dbOperations/subjects.go @@ -1,9 +1,6 @@ package dbOperations import ( - "fmt" - - "github.com/rs/zerolog/log" gremcos "github.com/supplyon/gremcos" "github.com/supplyon/gremcos/api" "github.com/supplyon/gremcos/interfaces" @@ -19,7 +16,6 @@ func GetSubjects(cosmos gremcos.Cosmos) ([]storageModel.Subject, error) { res, err := cosmos.ExecuteQuery(query) if err != nil { - log.Error().Err(err).Msg(fmt.Sprintf("Failed to execute the gremlin command: %v", query)) return nil, err } @@ -41,7 +37,6 @@ func GetSubjectByName(cosmos gremcos.Cosmos, name string) (storageModel.Subject, res, err := cosmos.ExecuteQuery(query) if err != nil { - log.Error().Err(err).Msg(fmt.Sprintf("Failed to execute the gremlin command: %v", query)) return subject, err } @@ -52,20 +47,17 @@ func CreateSubject(cosmos gremcos.Cosmos, subject storageModel.Subject) (storage _, err := GetSubjectByName(cosmos, subject.Name) if err == nil { - err := logger.ErrorResourceAlreadyExists{ResourceName: subject.Name}.Error() - log.Error().Err(err).Msg(fmt.Sprintf("There is already a subject with name %s in the database", subject.Name)) + err := logger.ErrorResourceAlreadyExists{ResourceName: subject.Name} return storageModel.Subject{}, err } g := api.NewGraph("g") query := g.AddV("subject").Property("partitionKey", "subject") - query = addVertexProperties(query, subject) res, err := cosmos.ExecuteQuery(query) if err != nil { - log.Error().Err(err).Msg(fmt.Sprintf("Failed to execute the gremlin command: %v", query)) return storageModel.Subject{}, err } @@ -74,10 +66,7 @@ func CreateSubject(cosmos gremcos.Cosmos, subject storageModel.Subject) (storage func UpdateSubject(cosmos gremcos.Cosmos, subject storageModel.Subject, name string) (storageModel.Subject, error) { oldSubject, err := GetSubjectByName(cosmos, name) - if err != nil { - err := logger.ErrorResourceNotFound{ResourceName: name}.Error() - log.Error().Err(err).Msg(fmt.Sprintf("Couldn't find subject with name %s in the database", name)) return storageModel.Subject{}, err } @@ -86,7 +75,6 @@ func UpdateSubject(cosmos gremcos.Cosmos, subject storageModel.Subject, name str res, err := cosmos.ExecuteQuery(query) if err != nil { - log.Error().Err(err).Msg(fmt.Sprintf("Failed to execute the gremlin command: %v", query)) return storageModel.Subject{}, err } @@ -125,8 +113,7 @@ func getSubjectFromResponse(res []interfaces.Response) (storageModel.Subject, er vertices, _ := response.ToVertices() if len(vertices) == 0 { - err := logger.ErrorResourceNotFound{ResourceName: "response"}.Error() - log.Error().Err(err).Msg("") + err := logger.ErrorNoVerticesInQuery{} return subject, err } diff --git a/app/handler/subjects.go b/app/handler/subjects.go index 1aa9521..cffe0d2 100644 --- a/app/handler/subjects.go +++ b/app/handler/subjects.go @@ -2,6 +2,7 @@ package handler import ( "encoding/json" + "fmt" "net/http" "github.com/gorilla/mux" @@ -16,22 +17,26 @@ import ( func GetSubjects(cosmos gremcos.Cosmos, w http.ResponseWriter, _ *http.Request) { storageSubjects, err := dbOperations.GetSubjects(cosmos) - if err != nil { - log.Error().Stack().Err(err).Msg("") + msg := logger.FailedToExecuteGremlinQuery{} + log.Error().Stack().Err(err).Msg(msg.Info()) w.WriteHeader(http.StatusInternalServerError) return } w.Header().Add("Content-Type", "application/json") err = json.NewEncoder(w).Encode(storageSubjects) - if err != nil { - log.Error().Stack().Err(err).Msg("") + msg := logger.FailedToEncodeJSON{ + Resource: "storageModel.Subject", + } + log.Error().Stack().Err(err).Msg(msg.Info()) w.WriteHeader(http.StatusInternalServerError) } + msg := logger.ResourceRead{ - Resource: storageModel.PrettyPrint(res), + ResourceName: "subjects", + ResourceContent: storageModel.PrettyPrint(storageSubjects), } log.Info().Msg(msg.Info()) } @@ -40,23 +45,26 @@ func GetSubject(cosmos gremcos.Cosmos, w http.ResponseWriter, r *http.Request) { vars := mux.Vars(r) storageSubject, err := dbOperations.GetSubjectByName(cosmos, vars["name"]) - if err != nil { - log.Error().Stack().Err(err).Msg("") + msg := logger.FailedToExecuteGremlinQuery{} + log.Error().Stack().Err(err).Msg(msg.Info()) w.WriteHeader(http.StatusInternalServerError) return } w.Header().Add("Content-Type", "application/json") err = json.NewEncoder(w).Encode(storageSubject) - if err != nil { - log.Error().Stack().Err(err).Msg("") + msg := logger.FailedToEncodeJSON{ + Resource: "storageModel.Subject", + } + log.Error().Stack().Err(err).Msg(msg.Info()) w.WriteHeader(http.StatusInternalServerError) } msg := logger.ResourceRead{ - Resource: storageModel.PrettyPrint(res), + ResourceName: "subjects/" + storageSubject.Name, + ResourceContent: storageModel.PrettyPrint(storageSubject), } log.Info().Msg(msg.Info()) } @@ -64,19 +72,21 @@ func GetSubject(cosmos gremcos.Cosmos, w http.ResponseWriter, r *http.Request) { func UpdateSubject(cosmos gremcos.Cosmos, w http.ResponseWriter, r *http.Request) { vars := mux.Vars(r) name := vars["name"] - oldSubject, err := dbOperations.GetSubjectByName(cosmos, name) apiSubject := apiModel.Subject{} if err := json.NewDecoder(r.Body).Decode(&apiSubject); err != nil { - log.Error().Stack().Err(err).Msg("Couldn't parse request body into apiModel.Subject") + msg := logger.FailedToDecodeJSON{ + Resource: "apiModel.Subject", + } + log.Error().Stack().Err(err).Msg(msg.Info()) w.WriteHeader(http.StatusBadRequest) return } - storageSubject, err := dbOperations.UpdateSubject(cosmos, storageModel.Subject(apiSubject), vars["name"]) - + storageSubject, err := dbOperations.UpdateSubject(cosmos, storageModel.Subject(apiSubject), name) if err != nil { - log.Error().Stack().Err(err).Msg("") + msg := logger.FailedToExecuteGremlinQuery{} + log.Error().Stack().Err(err).Msg(msg.Info()) w.WriteHeader(http.StatusInternalServerError) return } @@ -86,12 +96,16 @@ func UpdateSubject(cosmos gremcos.Cosmos, w http.ResponseWriter, r *http.Request err = json.NewEncoder(w).Encode(storageSubject) if err != nil { - log.Error().Stack().Err(err).Msg("Couldn't create response body with created subject") + msg := logger.FailedToEncodeJSON{ + Resource: "apiModel.Subject", + } + log.Error().Stack().Err(err).Msg(msg.Info()) w.WriteHeader(http.StatusInternalServerError) } + msg := logger.ResourceUpdated{ - PastResource: storageModel.PrettyPrint(oldSubject), - NewResource: storageModel.PrettyPrint(storageSubject), + ResourceName: "subjects/" + storageSubject.Name, + ResourceContent: storageModel.PrettyPrint(storageSubject), } log.Info().Msg(msg.Info()) } @@ -99,18 +113,11 @@ func UpdateSubject(cosmos gremcos.Cosmos, w http.ResponseWriter, r *http.Request func DeleteSubject(cosmos gremcos.Cosmos, w http.ResponseWriter, r *http.Request) { vars := mux.Vars(r) name := vars["name"] - subject, err := dbOperations.GetSubjectByName(cosmos, name) + err := dbOperations.DeleteSubject(cosmos, name) if err != nil { - log.Error().Stack().Err(err).Msg("") - w.WriteHeader(http.StatusInternalServerError) - return - } - - err = dbOperations.DeleteSubject(cosmos, name) - - if err != nil { - log.Error().Stack().Err(err).Msg("") + msg := logger.FailedToExecuteGremlinQuery{} + log.Error().Stack().Err(err).Msg(msg.Info()) w.WriteHeader(http.StatusInternalServerError) return } @@ -118,8 +125,8 @@ func DeleteSubject(cosmos gremcos.Cosmos, w http.ResponseWriter, r *http.Request w.Header().Add("Content-Type", "application/json") w.WriteHeader(http.StatusAccepted) - msg := logger.ResourceCreated{ - Resource: storageModel.PrettyPrint(subject), + msg := logger.ResourceDeleted{ + ResourceName: "subjects/" + name, } log.Info().Msg(msg.Info()) } @@ -127,30 +134,38 @@ func DeleteSubject(cosmos gremcos.Cosmos, w http.ResponseWriter, r *http.Request func CreateSubject(cosmos gremcos.Cosmos, w http.ResponseWriter, r *http.Request) { apiSubject := apiModel.Subject{} if err := json.NewDecoder(r.Body).Decode(&apiSubject); err != nil { - log.Error().Stack().Err(err).Msg("Couldn't parse request body into apiModel.Subject") + msg := logger.FailedToDecodeJSON{ + Resource: "apiModel.Subject", + } + log.Error().Stack().Err(err).Msg(msg.Info()) w.WriteHeader(http.StatusBadRequest) return } storageSubject, err := dbOperations.CreateSubject(cosmos, storageModel.Subject(apiSubject)) - if err != nil { - log.Error().Stack().Err(err).Msg("") + msg := logger.FailedToExecuteGremlinQuery{} + log.Error().Stack().Err(err).Msg(msg.Info()) w.WriteHeader(http.StatusInternalServerError) return } w.Header().Add("Content-Type", "application/json") w.WriteHeader(http.StatusCreated) - err = json.NewEncoder(w).Encode(storageSubject) + err = json.NewEncoder(w).Encode(storageSubject) if err != nil { - log.Error().Stack().Err(err).Msg("Couldn't create response body with created subject") + msg := logger.FailedToEncodeJSON{ + Resource: "storageModel.Subject", + } + log.Error().Stack().Err(err).Msg(msg.Info()) w.WriteHeader(http.StatusInternalServerError) } + fmt.Println(storageSubject.Name) msg := logger.ResourceCreated{ - Resource: storageModel.PrettyPrint(storageSubject), + ResourceName: "subjects/" + storageSubject.Name, + ResourceContent: storageModel.PrettyPrint(storageSubject), } log.Info().Msg(msg.Info()) } diff --git a/app/logger/errors.go b/app/logger/errors.go index 5a77770..f1ee5c7 100644 --- a/app/logger/errors.go +++ b/app/logger/errors.go @@ -5,23 +5,23 @@ import ( ) var ( - errorResourceAlreadyExistsMessage = LogEvent{1, "Resource %s already exists"} - errorResourceNotFoundMessage = LogEvent{2, "Resource %s not found"} - errorNoVertexInResourceMessage = LogEvent{3, "There is no vertex in resource %s"} + errorResourceAlreadyExistsMessage = LogEvent{1, "resource %s already exists"} + errorResourceNotFoundMessage = LogEvent{2, "resource %s not found"} + errorNoVerticesInQueryMessage = LogEvent{3, "the Gremlin Query did not return any vertices"} ) type ErrorResourceAlreadyExists struct{ ResourceName string } type ErrorResourceNotFound struct{ ResourceName string } -type ErrorNoVertexInResource struct{ ResourceName string } +type ErrorNoVerticesInQuery struct{} -func (e ErrorResourceAlreadyExists) Error() error { - return fmt.Errorf(errorResourceAlreadyExistsMessage.message, e.ResourceName) +func (e ErrorResourceAlreadyExists) Error() string { + return fmt.Sprintf(errorResourceAlreadyExistsMessage.message, e.ResourceName) } -func (e ErrorResourceNotFound) Error() error { - return fmt.Errorf(errorResourceNotFoundMessage.message, e.ResourceName) +func (e ErrorResourceNotFound) Error() string { + return fmt.Sprintf(errorResourceNotFoundMessage.message, e.ResourceName) } -func (e ErrorNoVertexInResource) Error() error { - return fmt.Errorf(errorNoVertexInResourceMessage.message, e.ResourceName) +func (e ErrorNoVerticesInQuery) Error() string { + return fmt.Sprintf(errorNoVerticesInQueryMessage.message) } diff --git a/app/logger/logger.go b/app/logger/logger.go index 93c7fdd..1d48fd9 100644 --- a/app/logger/logger.go +++ b/app/logger/logger.go @@ -1,7 +1,6 @@ package logger import ( - "fmt" "os" "github.com/rs/zerolog" @@ -14,38 +13,7 @@ type LogEvent struct { message string } -var ( - resourceCreatedMessage = LogEvent{1001, "Resource created.\nContent:\n%s"} - resourceUpdatedMessage = LogEvent{1002, "Resource updated.\nBefore:\n%s\nAfter:\n%s"} - resourceReadMessage = LogEvent{1003, "Resource read.\nContent:\n%s"} - resourceDeletedMessage = LogEvent{1004, "Resource %s deleted."} -) - -type ResourceCreated struct{ Resource string } -type ResourceUpdated struct { - PastResource string - NewResource string -} -type ResourceRead struct{ Resource string } -type ResourceDeleted struct{ Resource string } - func init() { log.Logger = zerolog.New(os.Stdout).Output(zerolog.ConsoleWriter{Out: os.Stdout, TimeFormat: zerolog.TimeFieldFormat}).With().Timestamp().Logger() zerolog.ErrorStackMarshaler = pkgerrors.MarshalStack } - -func (e ResourceCreated) Info() string { - return fmt.Sprintf(resourceCreatedMessage.message, e.Resource) -} - -func (e ResourceUpdated) Info() string { - return fmt.Sprintf(resourceUpdatedMessage.message, e.PastResource, e.NewResource) -} - -func (e ResourceRead) Info() string { - return fmt.Sprintf(resourceReadMessage.message, e.Resource) -} - -func (e ResourceDeleted) Info() string { - return fmt.Sprintf(resourceReadMessage.message, e.Resource) -} diff --git a/app/logger/messages.go b/app/logger/messages.go new file mode 100644 index 0000000..07bfcd9 --- /dev/null +++ b/app/logger/messages.go @@ -0,0 +1,60 @@ +package logger + +import ( + "fmt" +) + +var ( + resourceCreatedMessage = LogEvent{1001, "Resource %s created.\nContent:\n%s"} + resourceUpdatedMessage = LogEvent{1002, "Resource %s updated.\nNew Content:\n%s"} + resourceReadMessage = LogEvent{1003, "Resource %s read.\nContent:\n%s"} + resourceDeletedMessage = LogEvent{1004, "Resource %s deleted.\n"} + failedToDecodeJSONMessage = LogEvent{1005, "Failed to parse JSON into %s.\n"} + failedToEncodeJSONMessage = LogEvent{1006, "Failed to encode %s into JSON format.\n"} + failedToExecuteGremlinQueryMessage = LogEvent{1007, "Failed to execute Gremlin query.\n"} +) + +type ResourceCreated struct { + ResourceName string + ResourceContent string +} +type ResourceUpdated struct { + ResourceName string + ResourceContent string +} +type ResourceRead struct { + ResourceName string + ResourceContent string +} +type ResourceDeleted struct{ ResourceName string } +type FailedToDecodeJSON struct{ Resource string } +type FailedToEncodeJSON struct{ Resource string } +type FailedToExecuteGremlinQuery struct{} + +func (e ResourceCreated) Info() string { + return fmt.Sprintf(resourceCreatedMessage.message, e.ResourceName, e.ResourceContent) +} + +func (e ResourceUpdated) Info() string { + return fmt.Sprintf(resourceUpdatedMessage.message, e.ResourceName, e.ResourceContent) +} + +func (e ResourceRead) Info() string { + return fmt.Sprintf(resourceReadMessage.message, e.ResourceName, e.ResourceContent) +} + +func (e ResourceDeleted) Info() string { + return fmt.Sprintf(resourceDeletedMessage.message, e.ResourceName) +} + +func (e FailedToDecodeJSON) Info() string { + return fmt.Sprintf(failedToDecodeJSONMessage.message, e.Resource) +} + +func (e FailedToEncodeJSON) Info() string { + return fmt.Sprintf(failedToEncodeJSONMessage.message, e.Resource) +} + +func (e FailedToExecuteGremlinQuery) Info() string { + return fmt.Sprintf(failedToExecuteGremlinQueryMessage.message) +}