Merge pull request #123 from containerish/pretty-logger

Feat: added console writer for local logging

auth/basic_auth.go

@@ -64,14 +64,14 @@ func (a *auth) BasicAuth() echo.MiddlewareFunc {
 			printInMiddleware := true
 			defer func() {
 				if printInMiddleware {
-					a.logger.Log(ctx).Send()
+					a.logger.Log(ctx, nil)
 				}
 			}()
 
 			if ctx.Request().RequestURI == "/v2/" {
 				_, err := a.validateUser(username, password)
 				if err != nil {
-					ctx.Set(types.HttpEndpointErrorKey, err.Error())
+					a.logger.Log(ctx, err)
 					return false, ctx.NoContent(http.StatusUnauthorized)
 				}
 
@@ -87,12 +87,12 @@ func (a *auth) BasicAuth() echo.MiddlewareFunc {
 					Message: "not authorised",
 					Detail:  nil,
 				})
-				ctx.Set(types.HttpEndpointErrorKey, errMsg)
+				a.logger.Log(ctx, fmt.Errorf("%s", errMsg))
 				return false, ctx.JSON(http.StatusForbidden, errMsg)
 			}
 			resp, err := a.validateUser(username, password)
 			if err != nil {
-				ctx.Set(types.HttpEndpointErrorKey, err.Error())
+				a.logger.Log(ctx, err)
 				return false, err
 			}
 

auth/jwt_middleware.go

@@ -1,6 +1,7 @@
 package auth
 
 import (
+	"fmt"
 	"net/http"
 	"time"
 
@@ -32,8 +33,7 @@ func (a *auth) JWT() echo.MiddlewareFunc {
 		ErrorHandlerWithContext: func(err error, ctx echo.Context) error {
 			// ErrorHandlerWithContext only logs the failing requtest
 			ctx.Set(types.HandlerStartTime, time.Now())
-			ctx.Set(types.HttpEndpointErrorKey, err.Error())
-			a.logger.Log(ctx)
+			a.logger.Log(ctx, err)
 			return ctx.NoContent(http.StatusUnauthorized)
 		},
 		KeyFunc:        middleware.DefaultJWTConfig.KeyFunc,
@@ -51,7 +51,7 @@ func (a *auth) ACL() echo.MiddlewareFunc {
 		return func(ctx echo.Context) error {
 			ctx.Set(types.HandlerStartTime, time.Now())
 			defer func() {
-				a.logger.Log(ctx)
+				a.logger.Log(ctx, nil)
 			}()
 
 			m := ctx.Request().Method
@@ -61,13 +61,13 @@ func (a *auth) ACL() echo.MiddlewareFunc {
 
 			token, ok := ctx.Get("user").(*jwt.Token)
 			if !ok {
-				ctx.Set(types.HttpEndpointErrorKey, "ACL: unauthorized")
+				a.logger.Log(ctx, fmt.Errorf("ACL: unauthorized"))
 				return ctx.NoContent(http.StatusUnauthorized)
 			}
 
 			claims, ok := token.Claims.(*Claims)
 			if !ok {
-				ctx.Set(types.HttpEndpointErrorKey, "ACL: invalid claims")
+				a.logger.Log(ctx, fmt.Errorf("ACL: invalid claims"))
 				return ctx.NoContent(http.StatusUnauthorized)
 			}
 
@@ -76,7 +76,7 @@ func (a *auth) ACL() echo.MiddlewareFunc {
 				return hf(ctx)
 			}
 
-			ctx.Set(types.HttpEndpointErrorKey, "ACL: username didn't match from token")
+			a.logger.Log(ctx, fmt.Errorf("ACL: username didn't match from token"))
 			return ctx.NoContent(http.StatusUnauthorized)
 		}
 	}

auth/signin.go

@@ -2,6 +2,7 @@ package auth
 
 import (
 	"encoding/json"
+	"fmt"
 	"net/http"
 	"time"
 
@@ -11,37 +12,30 @@ import (
 
 func (a *auth) SignIn(ctx echo.Context) error {
 	ctx.Set(types.HandlerStartTime, time.Now())
-	defer func() {
-		a.logger.Log(ctx).Send()
-	}()
-	var user User
 
+	var user User
 	if err := json.NewDecoder(ctx.Request().Body).Decode(&user); err != nil {
 		return ctx.JSON(http.StatusBadRequest, echo.Map{
 			"error": err.Error(),
 		})
 	}
 	if user.Email == "" && user.Username == "" {
-		errMsg := echo.Map{
-			"error": "email and username cannot be empty, please provide at least one of them",
-		}
-		ctx.Set(types.HttpEndpointErrorKey, errMsg)
+		errMsg := fmt.Errorf("email and username cannot be empty, please provide at least one of them")
+		a.logger.Log(ctx, errMsg)
 		return ctx.JSON(http.StatusBadRequest, errMsg)
 	}
 
 	if user.Password == "" {
-		errMsg := echo.Map{
-			"error": "password cannot be empty",
-		}
-		ctx.Set(types.HttpEndpointErrorKey, errMsg)
+		errMsg := fmt.Errorf("password cannot be empty")
+		a.logger.Log(ctx, errMsg)
 		return ctx.JSON(http.StatusBadRequest, errMsg)
 	}
 
 	var key string
 
 	if user.Email != "" {
 		if err := verifyEmail(user.Email); err != nil {
-			ctx.Set(types.HttpEndpointErrorKey, err.Error())
+			a.logger.Log(ctx, err)
 			return ctx.JSON(http.StatusBadRequest, echo.Map{
 				"error": err.Error(),
 			})
@@ -54,15 +48,15 @@ func (a *auth) SignIn(ctx echo.Context) error {
 	//bz, err := a.store.Get([]byte(key))
 	userFromDb, err := a.pgStore.GetUser(ctx.Request().Context(), key)
 	if err != nil {
-		ctx.Set(types.HttpEndpointErrorKey, err.Error())
+		a.logger.Log(ctx, err)
 		return ctx.JSON(http.StatusBadRequest, echo.Map{
 			"error": err.Error(),
 		})
 	}
 
 	if !a.verifyPassword(userFromDb.Password, user.Password) {
-		errMsg := "invalid password"
-		ctx.Set(types.HttpEndpointErrorKey, errMsg)
+		errMsg := fmt.Errorf("invalid password")
+		a.logger.Log(ctx, errMsg)
 		return ctx.JSON(http.StatusUnauthorized, errMsg)
 	}
 
@@ -74,12 +68,13 @@ func (a *auth) SignIn(ctx echo.Context) error {
 
 	token, err := a.newToken(uu, tokenLife)
 	if err != nil {
-		ctx.Set(types.HttpEndpointErrorKey, err.Error())
+		a.logger.Log(ctx, err)
 		return ctx.JSON(http.StatusInternalServerError, echo.Map{
 			"error": err.Error(),
 		})
 	}
 
+	a.logger.Log(ctx, nil)
 	return ctx.JSON(http.StatusOK, echo.Map{
 		"token":      token,
 		"expires_in": tokenLife,

auth/signup.go

@@ -140,14 +140,10 @@ func verifyPassword(password string) error {
 
 func (a *auth) SignUp(ctx echo.Context) error {
 	ctx.Set(types.HandlerStartTime, time.Now())
-	defer func() {
-		a.logger.Log(ctx).Send()
-	}()
 
 	var u User
-
 	if err := json.NewDecoder(ctx.Request().Body).Decode(&u); err != nil {
-		ctx.Set(types.HttpEndpointErrorKey, err.Error())
+		a.logger.Log(ctx, err)
 		return ctx.JSON(http.StatusBadRequest, echo.Map{
 			"error":   err.Error(),
 			"message": "error decoding request body in sign-up",
@@ -156,15 +152,15 @@ func (a *auth) SignUp(ctx echo.Context) error {
 	_ = ctx.Request().Body.Close()
 
 	if err := u.Validate(a.store); err != nil {
-		ctx.Set(types.HttpEndpointErrorKey, err.Error())
+		a.logger.Log(ctx, err)
 		return ctx.JSON(http.StatusBadRequest, echo.Map{
 			"error": err.Error(),
 		})
 	}
 
 	hpwd, err := a.hashPassword(u.Password)
 	if err != nil {
-		ctx.Set(types.HttpEndpointErrorKey, err.Error())
+		a.logger.Log(ctx, err)
 		return ctx.JSON(http.StatusInternalServerError, echo.Map{
 			"error": err.Error(),
 		})
@@ -179,12 +175,13 @@ func (a *auth) SignUp(ctx echo.Context) error {
 
 	err = a.pgStore.AddUser(ctx.Request().Context(), newUser)
 	if err != nil {
-		ctx.Set(types.HttpEndpointErrorKey, err.Error())
+		a.logger.Log(ctx, err)
 		return ctx.JSON(http.StatusInternalServerError, echo.Map{
 			"error": err.Error(),
 		})
 	}
 
+	a.logger.Log(ctx, nil)
 	return ctx.JSON(http.StatusCreated, echo.Map{
 		"message": "user successfully created",
 	})

auth/token.go

@@ -18,21 +18,18 @@ func (a *auth) Token(ctx echo.Context) error {
 	// TODO (jay-dee7) - check for all valid query params here like serive, client_id, offline_token, etc
 	// more at this link - https://docs.docker.com/registry/spec/auth/token/
 	ctx.Set(types.HandlerStartTime, time.Now())
-	defer func() {
-		a.logger.Log(ctx).Send()
-	}()
 
 	authHeader := ctx.Request().Header.Get(AuthorizationHeaderKey)
 	if authHeader != "" {
 		username, password, err := a.getCredsFromHeader(ctx.Request())
 		if err != nil {
-			ctx.Set(types.HttpEndpointErrorKey, err.Error())
+			a.logger.Log(ctx, err)
 			return ctx.NoContent(http.StatusUnauthorized)
 		}
 
 		creds, err := a.validateUser(username, password)
 		if err != nil {
-			ctx.Set(types.HttpEndpointErrorKey, err.Error())
+			a.logger.Log(ctx, err)
 			return ctx.JSON(http.StatusUnauthorized, echo.Map{
 				"error": err.Error(),
 			})
@@ -47,7 +44,7 @@ func (a *auth) Token(ctx echo.Context) error {
 			"error": err.Error(),
 			"msg":   "invalid scope provided",
 		}
-		ctx.Set(types.HttpEndpointErrorKey, errMsg)
+		a.logger.Log(ctx, fmt.Errorf("%s", errMsg))
 		return ctx.JSON(http.StatusBadRequest, errMsg)
 	}
 
@@ -56,7 +53,7 @@ func (a *auth) Token(ctx echo.Context) error {
 	if len(scope.Actions) == 1 && scope.Actions["pull"] {
 		token, err := a.newPublicPullToken()
 		if err != nil {
-			ctx.Set(types.HttpEndpointErrorKey, err.Error())
+			a.logger.Log(ctx, err)
 			return ctx.NoContent(http.StatusInternalServerError)
 		}
 

go.mod

@@ -9,6 +9,7 @@ require (
 	github.com/go-playground/validator/v10 v10.9.0
 	github.com/golang-jwt/jwt v3.2.2+incompatible
 	github.com/google/uuid v1.3.0
+	github.com/hashicorp/go-multierror v1.0.0
 	github.com/labstack/echo-contrib v0.11.0
 	github.com/labstack/echo/v4 v4.5.0
 	github.com/rs/zerolog v1.24.0
@@ -18,6 +19,8 @@ require (
 	golang.org/x/crypto v0.0.0-20210817164053-32db794688a5
 )
 
+require github.com/hashicorp/errwrap v1.0.0 // indirect
+
 require (
 	github.com/beorn7/perks v1.0.1 // indirect
 	github.com/cespare/xxhash v1.1.0 // indirect

go.sum

@@ -266,10 +266,12 @@ github.com/hashicorp/consul/api v1.1.0/go.mod h1:VmuI/Lkw1nC05EYQWNKwWGbkg+FbDBt
 github.com/hashicorp/consul/api v1.3.0/go.mod h1:MmDNSzIMUjNpY/mQ398R4bk2FnqQLoPndWW5VkKPlCE=
 github.com/hashicorp/consul/sdk v0.1.1/go.mod h1:VKf9jXwCTEY1QZP2MOLRhb5i/I/ssyNV1vwHyQBF0x8=
 github.com/hashicorp/consul/sdk v0.3.0/go.mod h1:VKf9jXwCTEY1QZP2MOLRhb5i/I/ssyNV1vwHyQBF0x8=
+github.com/hashicorp/errwrap v1.0.0 h1:hLrqtEDnRye3+sgx6z4qVLNuviH3MR5aQ0ykNJa/UYA=
 github.com/hashicorp/errwrap v1.0.0/go.mod h1:YH+1FKiLXxHSkmPseP+kNlulaMuP3n2brvKWEqk/Jc4=
 github.com/hashicorp/go-cleanhttp v0.5.1/go.mod h1:JpRdi6/HCYpAwUzNwuwqhbovhLtngrth3wmdIIUrZ80=
 github.com/hashicorp/go-immutable-radix v1.0.0/go.mod h1:0y9vanUI8NX6FsYoO3zeMjhV/C5i9g4Q3DwcSNZ4P60=
 github.com/hashicorp/go-msgpack v0.5.3/go.mod h1:ahLV/dePpqEmjfWmKiqvPkv/twdG7iPBM1vqhUKIvfM=
+github.com/hashicorp/go-multierror v1.0.0 h1:iVjPR7a6H0tWELX5NxNe7bYopibicUzc7uPribsnS6o=
 github.com/hashicorp/go-multierror v1.0.0/go.mod h1:dHtQlpGsu+cZNNAkkCN/P3hoUDHhCYQXV3UM06sGGrk=
 github.com/hashicorp/go-rootcerts v1.0.0/go.mod h1:K6zTfqpRlCUIjkwsN4Z+hiSfzSTQa6eBIzfwKfwNnHU=
 github.com/hashicorp/go-sockaddr v1.0.0/go.mod h1:7Xibr9yA9JjQq1JpNB2Vw7kxv8xerXegt+ozgdvDeDU=

main.go

@@ -44,7 +44,7 @@ func main() {
 		os.Exit(1)
 	}
 
-	logger := telemetry.ZLogger(telemetry.SetupLogger(), fluentBitCollector)
+	logger := telemetry.ZLogger(fluentBitCollector, cfg.Environment)
 	authSvc := auth.New(localCache, cfg, pgStore, logger)
 	skynetClient := skynet.NewClient(cfg)
 
@@ -55,5 +55,5 @@ func main() {
 	}
 
 	router.Register(cfg, e, reg, authSvc, localCache, pgStore)
-	logger.Errorf("error initialising OpenRegistry Server: %s", e.Start(cfg.Registry.Address()))
+	color.Red("error initialising OpenRegistry Server: %s", e.Start(cfg.Registry.Address()))
 }