Remove standard console logging and use zerolog

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())
 }

app/dbOperations/subjects.go

@@ -1,13 +1,11 @@
 package dbOperations
 
 import (
-	"errors"
-	"fmt"
-
 	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 +16,6 @@ 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")
 		return nil, err
 	}
 
@@ -41,8 +37,6 @@ 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")
 		return subject, err
 	}
 
@@ -53,19 +47,17 @@ 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}
+		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 {
-		fmt.Println("Failed to execute a gremlin command " + query.String())
-		// logger.Error().Err(err).Msg("Failed to execute gremlin command")
 		return storageModel.Subject{}, err
 	}
 
@@ -74,18 +66,15 @@ 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 {
-		return storageModel.Subject{}, errors.New("There is no subject with name " + oldSubject.Name)
+		return storageModel.Subject{}, err
 	}
 
 	g := api.NewGraph("g")
 	query := addVertexProperties(g.VByStr(oldSubject.Id), 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")
 		return storageModel.Subject{}, err
 	}
 
@@ -124,7 +113,8 @@ 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.ErrorNoVerticesInQuery{}
+		return subject, err
 	}
 
 	subject = vertexToSubject(vertices[0])

app/handler/subjects.go

@@ -2,70 +2,90 @@ 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) {
 	storageSubjects, err := dbOperations.GetSubjects(cosmos)
-
 	if err != nil {
-		fmt.Println(err)
+		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 {
-		fmt.Println(err)
+		msg := logger.FailedToEncodeJSON{
+			Resource: "storageModel.Subject",
+		}
+		log.Error().Stack().Err(err).Msg(msg.Info())
 		w.WriteHeader(http.StatusInternalServerError)
 	}
+
+	msg := logger.ResourceRead{
+		ResourceName:    "subjects",
+		ResourceContent: storageModel.PrettyPrint(storageSubjects),
+	}
+	log.Info().Msg(msg.Info())
 }
 
 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 {
-		fmt.Println(err)
+		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 {
-		fmt.Println(err)
+		msg := logger.FailedToEncodeJSON{
+			Resource: "storageModel.Subject",
+		}
+		log.Error().Stack().Err(err).Msg(msg.Info())
 		w.WriteHeader(http.StatusInternalServerError)
 	}
+
+	msg := logger.ResourceRead{
+		ResourceName:    "subjects/" + storageSubject.Name,
+		ResourceContent: storageModel.PrettyPrint(storageSubject),
+	}
+	log.Info().Msg(msg.Info())
 }
 
 func UpdateSubject(cosmos gremcos.Cosmos, w http.ResponseWriter, r *http.Request) {
 	vars := mux.Vars(r)
+	name := vars["name"]
 
 	apiSubject := apiModel.Subject{}
-	err := json.NewDecoder(r.Body).Decode(&apiSubject)
-
-	if err != nil {
+	if err := json.NewDecoder(r.Body).Decode(&apiSubject); err != nil {
+		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 {
-		fmt.Println(err)
+		msg := logger.FailedToExecuteGremlinQuery{}
+		log.Error().Stack().Err(err).Msg(msg.Info())
 		w.WriteHeader(http.StatusInternalServerError)
 		return
 	}
@@ -75,48 +95,75 @@ func UpdateSubject(cosmos gremcos.Cosmos, w http.ResponseWriter, r *http.Request
 	err = json.NewEncoder(w).Encode(storageSubject)
 
 	if err != nil {
-		fmt.Println(err)
+		msg := logger.FailedToEncodeJSON{
+			Resource: "apiModel.Subject",
+		}
+		log.Error().Stack().Err(err).Msg(msg.Info())
 		w.WriteHeader(http.StatusInternalServerError)
 	}
+
+	msg := logger.ResourceUpdated{
+		ResourceName:    "subjects/" + storageSubject.Name,
+		ResourceContent: 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"]
 
-	err := dbOperations.DeleteSubject(cosmos, vars["name"])
-
+	err := dbOperations.DeleteSubject(cosmos, name)
 	if err != nil {
-		fmt.Println(err)
+		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.StatusAccepted)
+
+	msg := logger.ResourceDeleted{
+		ResourceName: "subjects/" + name,
+	}
+	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 {
+		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 {
-		fmt.Println(err)
+		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 {
-		fmt.Println(err)
+		msg := logger.FailedToEncodeJSON{
+			Resource: "storageModel.Subject",
+		}
+		log.Error().Stack().Err(err).Msg(msg.Info())
 		w.WriteHeader(http.StatusInternalServerError)
 	}
+
+	msg := logger.ResourceCreated{
+		ResourceName:    "subjects/" + storageSubject.Name,
+		ResourceContent: storageModel.PrettyPrint(storageSubject),
+	}
+	log.Info().Msg(msg.Info())
 }

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"}
+	errorNoVerticesInQueryMessage     = LogEvent{3, "the Gremlin Query did not return any vertices"}
+)
+
+type ErrorResourceAlreadyExists struct{ ResourceName string }
+type ErrorResourceNotFound struct{ ResourceName string }
+type ErrorNoVerticesInQuery struct{}
+
+func (e ErrorResourceAlreadyExists) Error() string {
+	return fmt.Sprintf(errorResourceAlreadyExistsMessage.message, e.ResourceName)
+}
+
+func (e ErrorResourceNotFound) Error() string {
+	return fmt.Sprintf(errorResourceNotFoundMessage.message, e.ResourceName)
+}
+
+func (e ErrorNoVerticesInQuery) Error() string {
+	return fmt.Sprintf(errorNoVerticesInQueryMessage.message)
+}

app/logger/logger.go

@@ -0,0 +1,19 @@
+package logger
+
+import (
+	"os"
+
+	"github.com/rs/zerolog"
+	"github.com/rs/zerolog/log"
+	"github.com/rs/zerolog/pkgerrors"
+)
+
+type LogEvent struct {
+	id      int
+	message 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
+}