addressing review comments to add Makefile and zap logger

Signed-off-by: Jalander Ramagiri <[email protected]>

Author: Jalander Ramagiri

Makefile

@@ -0,0 +1,25 @@
+# Go parameters
+GOCMD=go
+GOBUILD=$(GOCMD) build
+GOFMT=$(GOCMD) fmt
+GOVET=$(GOCMD) vet
+GOTEST=$(GOCMD) test
+BINARY_NAME=gerrit-translator-cdevents
+PKG_DIR=./pkg/
+
+all: fmt vet test build
+
+build:
+	$(GOBUILD) -o $(BINARY_NAME) $(PKG_DIR)
+
+test:
+	$(GOTEST) -v ./...
+
+fmt:
+	$(GOFMT) ./...
+
+vet:
+	$(GOVET) ./...
+
+clean:
+	rm -f $(BINARY_NAME)

README.md

@@ -7,9 +7,9 @@ The binary of this plugin is published with a release URL and is used by externa
 The published plugin's binary can be downloaded and loaded by creating a new plugin client using HashiCorp's go-plugin, which manages the lifecycle of this plugin and establishes the RPC connection.
 
 ### How to run locally
-Run the below command from the project root directory, which creates a plugin's binary with the name `gerrit-translator-cdevents`
-````go
-go build -o gerrit-translator-cdevents ./pkg/
+Run the `make` command from the project root directory, which creates a plugin's binary with the name `gerrit-translator-cdevents`
+````make
+make all
 ````
 
 ### Gerrit-CDEvents type mapping for translation

pkg/gerrit/create_cdevents.go

@@ -19,14 +19,13 @@ package gerrit
 
 import (
 	sdk "github.com/cdevents/sdk-go/pkg/api"
-	"log"
 )
 
 func (projectCreated *ProjectCreated) RepositoryCreatedCDEvent() (string, error) {
-	log.Println("Creating CDEvent RepositoryCreatedEvent")
+	Log().Info("Creating CDEvent RepositoryCreatedEvent")
 	cdEvent, err := sdk.NewRepositoryCreatedEvent()
 	if err != nil {
-		log.Printf("Error creating CDEvent RepositoryCreatedEvent %s\n", err)
+		Log().Error("Error creating CDEvent RepositoryCreatedEvent %s\n", err)
 		return "", err
 	}
 	cdEvent.SetSource(projectCreated.RepoURL)
@@ -35,18 +34,18 @@ func (projectCreated *ProjectCreated) RepositoryCreatedCDEvent() (string, error)
 	cdEvent.SetSubjectUrl(projectCreated.RepoURL)
 	cdEventStr, err := sdk.AsJsonString(cdEvent)
 	if err != nil {
-		log.Printf("Error creating RepositoryCreated CDEvent as Json string %s\n", err)
+		Log().Error("Error creating RepositoryCreated CDEvent as Json string %s\n", err)
 		return "", err
 	}
 
 	return cdEventStr, nil
 }
 
 func (projectHeadUpdated *ProjectHeadUpdated) RepositoryModifiedCDEvent() (string, error) {
-	log.Println("Creating CDEvent RepositoryModifiedEvent")
+	Log().Info("Creating CDEvent RepositoryModifiedEvent")
 	cdEvent, err := sdk.NewRepositoryModifiedEvent()
 	if err != nil {
-		log.Printf("Error creating CDEvent RepositoryModified %s\n", err)
+		Log().Error("Error creating CDEvent RepositoryModified %s\n", err)
 		return "", err
 	}
 	cdEvent.SetSource(projectHeadUpdated.RepoURL)
@@ -55,17 +54,18 @@ func (projectHeadUpdated *ProjectHeadUpdated) RepositoryModifiedCDEvent() (strin
 	cdEvent.SetSubjectUrl(projectHeadUpdated.NewHead)
 	cdEventStr, err := sdk.AsJsonString(cdEvent)
 	if err != nil {
-		log.Printf("Error creating RepositoryModified CDEvent as Json string %s\n", err)
+		Log().Error("Error creating RepositoryModified CDEvent as Json string %s\n", err)
 		return "", err
 	}
 
 	return cdEventStr, nil
 }
 
 func (refUpdated *RefUpdated) BranchCreatedCDEvent() (string, error) {
+	Log().Info("Creating CDEvent BranchCreatedEvent")
 	cdEvent, err := sdk.NewBranchCreatedEvent()
 	if err != nil {
-		log.Printf("Error creating CDEvent BranchCreatedEvent %s\n", err)
+		Log().Error("Error creating CDEvent BranchCreatedEvent %s\n", err)
 		return "", err
 	}
 	cdEvent.SetSource(refUpdated.RepoURL)
@@ -75,16 +75,17 @@ func (refUpdated *RefUpdated) BranchCreatedCDEvent() (string, error) {
 
 	cdEventStr, err := sdk.AsJsonString(cdEvent)
 	if err != nil {
-		log.Printf("Error creating BranchCreated CDEvent as Json string %s\n", err)
+		Log().Error("Error creating BranchCreated CDEvent as Json string %s\n", err)
 		return "", err
 	}
 	return cdEventStr, nil
 }
 
 func (refUpdated *RefUpdated) BranchDeletedCDEvent() (string, error) {
+	Log().Info("Creating CDEvent BranchDeletedEvent")
 	cdEvent, err := sdk.NewBranchDeletedEvent()
 	if err != nil {
-		log.Printf("Error creating CDEvent BranchDeletedEvent %s\n", err)
+		Log().Error("Error creating CDEvent BranchDeletedEvent %s\n", err)
 		return "", err
 	}
 	cdEvent.SetSource(refUpdated.RepoURL)
@@ -94,7 +95,7 @@ func (refUpdated *RefUpdated) BranchDeletedCDEvent() (string, error) {
 
 	cdEventStr, err := sdk.AsJsonString(cdEvent)
 	if err != nil {
-		log.Printf("Error creating BranchDeleted CDEvent as Json string %s\n", err)
+		Log().Error("Error creating BranchDeleted CDEvent as Json string %s\n", err)
 		return "", err
 	}
 	return cdEventStr, nil

pkg/gerrit/event.go

@@ -20,7 +20,6 @@ package gerrit
 import (
 	"encoding/json"
 	"fmt"
-	"log"
 	"net/http"
 )
 
@@ -35,18 +34,18 @@ func NewGerritEvent(event string, repoURL string) (pEvent *GerritEvent) {
 }
 
 func HandleTranslateGerritEvent(event string, header http.Header) (string, error) {
-	log.Printf("Handle translation into CDEvent from Gerrit event %s\n", event)
+	Log().Info("Handle translation into CDEvent from Gerrit event %s\n", event)
 	repoURL := ""
 	if header.Get("X-Origin-Url") != "" {
 		repoURL = header.Get("X-Origin-Url")
 	}
 	gerritEvent := NewGerritEvent(event, repoURL)
 	cdEvent, err := gerritEvent.TranslateIntoCDEvent()
 	if err != nil {
-		log.Printf("Error translating Gerrit event into CDEvent %s\n", err)
+		Log().Error("Error translating Gerrit event into CDEvent %s\n", err)
 		return "", err
 	}
-	log.Printf("Gerrit Event translated into CDEvent %s\n", cdEvent)
+	Log().Info("Gerrit Event translated into CDEvent %s\n", cdEvent)
 	return cdEvent, nil
 }
 
@@ -55,11 +54,11 @@ func (pEvent *GerritEvent) TranslateIntoCDEvent() (string, error) {
 	cdEvent := ""
 	err := json.Unmarshal([]byte(pEvent.Event), &eventMap)
 	if err != nil {
-		log.Println("Error occurred while Unmarshal gerritEvent data into gerritEvent map", err)
+		Log().Error("Error occurred while Unmarshal gerritEvent data into gerritEvent map", err)
 		return "", err
 	}
 	eventType := eventMap["type"]
-	log.Printf("handling translating to CDEvent from Gerrit Event type: %s\n", eventType)
+	Log().Info("handling translating to CDEvent from Gerrit Event type: %s\n", eventType)
 
 	switch eventType {
 	case "project-created":
@@ -78,7 +77,7 @@ func (pEvent *GerritEvent) TranslateIntoCDEvent() (string, error) {
 			return "", err
 		}
 	default:
-		log.Printf("Not handling CDEvent translation for Gerrit event type: %s\n", eventMap["type"])
+		Log().Info("Not handling CDEvent translation for Gerrit event type: %s\n", eventMap["type"])
 		return "", fmt.Errorf("gerrit event type %s, not supported for translation", eventType)
 	}
 	return cdEvent, nil

pkg/gerrit/logger.go

@@ -0,0 +1,25 @@
+package gerrit
+
+import (
+	"go.uber.org/zap"
+)
+
+var sugar *zap.SugaredLogger
+
+// InitLogger Initialize a new production zap logger
+func InitLogger() {
+	logger, err := zap.NewProduction()
+	if err != nil {
+		panic("failed to initialize logger: " + err.Error())
+	}
+	defer logger.Sync()
+	sugar = logger.Sugar()
+}
+
+// Log returns the zap logger If initialized
+func Log() *zap.SugaredLogger {
+	if sugar == nil {
+		panic("zap logger is not initialized")
+	}
+	return sugar
+}

pkg/gerrit/translate_events.go

@@ -19,40 +19,39 @@ package gerrit
 
 import (
 	"encoding/json"
-	"log"
 )
 
 func (pEvent *GerritEvent) HandleProjectCreatedEvent() (string, error) {
 	var projectCreated ProjectCreated
 	err := json.Unmarshal([]byte(pEvent.Event), &projectCreated)
 	if err != nil {
-		log.Println("Error occurred while Unmarshal GerritEvent into ProjectCreated struct", err)
+		Log().Error("Error occurred while Unmarshal GerritEvent into ProjectCreated struct", err)
 		return "", err
 	}
-	log.Println("ProjectCreated GerritEvent received : ", projectCreated.ProjectName, projectCreated.HeadName, projectCreated.CommonFields.Type)
+	Log().Info("ProjectCreated GerritEvent received : ", projectCreated.ProjectName, projectCreated.HeadName, projectCreated.CommonFields.Type)
 	projectCreated.RepoURL = pEvent.RepoURL
 	cdEvent, err := projectCreated.RepositoryCreatedCDEvent()
 	if err != nil {
 		return "", err
 	}
-	log.Println("Translated projectCreated gerrit event into RepositoryCreated CDEvent: ", cdEvent)
+	Log().Info("Translated project-created gerrit event into dev.cdevents.repository.created CDEvent: ", cdEvent)
 	return cdEvent, nil
 }
 
 func (pEvent *GerritEvent) HandleProjectHeadUpdatedEvent() (string, error) {
 	var projectHeadUpdated ProjectHeadUpdated
 	err := json.Unmarshal([]byte(pEvent.Event), &projectHeadUpdated)
 	if err != nil {
-		log.Println("Error occurred while Unmarshal GerritEvent into ProjectHeadUpdated struct", err)
+		Log().Error("Error occurred while Unmarshal GerritEvent into ProjectHeadUpdated struct", err)
 		return "", err
 	}
-	log.Println("ProjectHeadUpdated GerritEvent received for project : ", projectHeadUpdated.ProjectName)
+	Log().Info("ProjectHeadUpdated GerritEvent received for project : ", projectHeadUpdated.ProjectName)
 	projectHeadUpdated.RepoURL = pEvent.RepoURL
 	cdEvent, err := projectHeadUpdated.RepositoryModifiedCDEvent()
 	if err != nil {
 		return "", err
 	}
-	log.Println("Translated projectHeadUpdated gerrit event into RepositoryModified CDEvent: ", cdEvent)
+	Log().Info("Translated project-head-updated gerrit event into dev.cdevents.repository.modified CDEvent: ", cdEvent)
 	return cdEvent, nil
 }
 
@@ -61,23 +60,23 @@ func (pEvent *GerritEvent) HandleRefUpdatedEvent() (string, error) {
 	var refUpdated RefUpdated
 	err := json.Unmarshal([]byte(pEvent.Event), &refUpdated)
 	if err != nil {
-		log.Println("Error occurred while Unmarshal GerritEvent into RefUpdated struct", err)
+		Log().Error("Error occurred while Unmarshal GerritEvent into RefUpdated struct", err)
 		return "", err
 	}
-	log.Println("RefUpdated GerritEvent received : ", refUpdated.RefUpdate.RefName, refUpdated.Submitter.Name, refUpdated.CommonFields.Type)
+	Log().Info("RefUpdated GerritEvent received : ", refUpdated.RefUpdate.RefName, refUpdated.Submitter.Name, refUpdated.CommonFields.Type)
 	refUpdated.RepoURL = pEvent.RepoURL
 	if refUpdated.RefUpdate.OldRev == "0000000000000000000000000000000000000000" {
 		cdEvent, err = refUpdated.BranchCreatedCDEvent()
 		if err != nil {
 			return "", err
 		}
-		log.Println("Translated refUpdated gerrit event into BranchCreated CDEvent: ", cdEvent)
+		Log().Info("Translated ref-updated gerrit event into dev.cdevents.branch.created CDEvent: ", cdEvent)
 	} else if refUpdated.RefUpdate.NewRev == "0000000000000000000000000000000000000000" {
 		cdEvent, err = refUpdated.BranchDeletedCDEvent()
 		if err != nil {
 			return "", err
 		}
-		log.Println("Translated refUpdated gerrit event into BranchDeleted CDEvent: ", cdEvent)
+		Log().Info("Translated ref-updated gerrit event into dev.cdevents.branch.deleted CDEvent: ", cdEvent)
 	}
 
 	return cdEvent, nil

pkg/translator.go

@@ -21,15 +21,14 @@ import (
 	"github.com/cdevents/gerrit-translator/pkg/gerrit"
 	"github.com/cdevents/webhook-adapter/pkg/cdevents"
 	"github.com/hashicorp/go-plugin"
-	"log"
 	"net/http"
 )
 
 type EventTranslator struct{}
 
 // TranslateEvent Invoked from external application to translate Gerrit event into CDEvent
 func (EventTranslator) TranslateEvent(event string, headers http.Header) (string, error) {
-	log.Println("Serving from gerrit-translator plugin")
+	gerrit.Log().Info("Serving from gerrit-translator plugin")
 	cdEvent, err := gerrit.HandleTranslateGerritEvent(event, headers)
 	if err != nil {
 		return "", err
@@ -38,6 +37,7 @@ func (EventTranslator) TranslateEvent(event string, headers http.Header) (string
 }
 
 func main() {
+	gerrit.InitLogger()
 	plugin.Serve(&plugin.ServeConfig{
 		HandshakeConfig: cdevents.Handshake,
 		Plugins: map[string]plugin.Plugin{