fix: format logs

2022-05-25 12:30:22 +05:30
parent d886d780b4
commit 714b79e4ab
47 changed files with 266 additions and 197 deletions
--- a/server/resolvers/admin_login.go
+++ b/server/resolvers/admin_login.go
@@ -20,7 +20,7 @@ func AdminLoginResolver(ctx context.Context, params model.AdminLoginInput) (*mod

 	gc, err := utils.GinContextFromContext(ctx)
 	if err != nil {
-		log.Debug("Failed to get GinContext", err)
+		log.Debug("Failed to get GinContext: ", err)
 		return res, err
 	}

--- a/server/resolvers/admin_logout.go
+++ b/server/resolvers/admin_logout.go
@@ -18,7 +18,7 @@ func AdminLogoutResolver(ctx context.Context) (*model.Response, error) {

 	gc, err := utils.GinContextFromContext(ctx)
 	if err != nil {
-		log.Debug("Failed to get GinContext", err)
+		log.Debug("Failed to get GinContext: ", err)
 		return res, err
 	}

--- a/server/resolvers/admin_session.go
+++ b/server/resolvers/admin_session.go
@@ -21,18 +21,18 @@ func AdminSessionResolver(ctx context.Context) (*model.Response, error) {

 	gc, err := utils.GinContextFromContext(ctx)
 	if err != nil {
-		log.Debug("Failed to get GinContext", err)
+		log.Debug("Failed to get GinContext: ", err)
 		return res, err
 	}

 	if !token.IsSuperAdmin(gc) {
-		log.Debug("Not logged in as super admin.")
+		log.Debug("Not logged in as super admin")
 		return res, fmt.Errorf("unauthorized")
 	}

 	hashedKey, err := crypto.EncryptPassword(envstore.EnvStoreObj.GetStringStoreEnvVariable(constants.EnvKeyAdminSecret))
 	if err != nil {
-		log.Debug("Failed to encrypt key:", err)
+		log.Debug("Failed to encrypt key: ", err)
 		return res, err
 	}
 	cookie.SetAdminCookie(gc, hashedKey)
--- a/server/resolvers/admin_signup.go
+++ b/server/resolvers/admin_signup.go
@@ -23,7 +23,7 @@ func AdminSignupResolver(ctx context.Context, params model.AdminSignupInput) (*m

 	gc, err := utils.GinContextFromContext(ctx)
 	if err != nil {
-		log.Debug("Failed to get GinContext:", err)
+		log.Debug("Failed to get GinContext: ", err)
 		return res, err
 	}

@@ -53,36 +53,36 @@ func AdminSignupResolver(ctx context.Context, params model.AdminSignupInput) (*m

 	jsonBytes, err := json.Marshal(envstore.EnvStoreObj.GetEnvStoreClone())
 	if err != nil {
-		log.Debug("Failed to marshal envstore:", err)
+		log.Debug("Failed to marshal envstore: ", err)
 		return res, err
 	}

 	if err := json.Unmarshal(jsonBytes, &storeData); err != nil {
-		log.Debug("Failed to unmarshal envstore:", err)
+		log.Debug("Failed to unmarshal envstore: ", err)
 		return res, err
 	}

 	env, err := db.Provider.GetEnv()
 	if err != nil {
-		log.Debug("Failed to get env:", err)
+		log.Debug("Failed to get env: ", err)
 		return res, err
 	}

 	envData, err := crypto.EncryptEnvData(storeData)
 	if err != nil {
-		log.Debug("Failed to encrypt envstore:", err)
+		log.Debug("Failed to encrypt envstore: ", err)
 		return res, err
 	}

 	env.EnvData = envData
 	if _, err := db.Provider.UpdateEnv(env); err != nil {
-		log.Debug("Failed to update env:", err)
+		log.Debug("Failed to update env: ", err)
 		return res, err
 	}

 	hashedKey, err := crypto.EncryptPassword(params.AdminSecret)
 	if err != nil {
-		log.Debug("Failed to encrypt admin session key:", err)
+		log.Debug("Failed to encrypt admin session key: ", err)
 		return res, err
 	}
 	cookie.SetAdminCookie(gc, hashedKey)
--- a/server/resolvers/delete_user.go
+++ b/server/resolvers/delete_user.go
@@ -19,12 +19,12 @@ func DeleteUserResolver(ctx context.Context, params model.DeleteUserInput) (*mod

 	gc, err := utils.GinContextFromContext(ctx)
 	if err != nil {
-		log.Debug("Failed to get GinContext", err)
+		log.Debug("Failed to get GinContext: ", err)
 		return res, err
 	}

 	if !token.IsSuperAdmin(gc) {
-		log.Debug("Not logged in as super admin.")
+		log.Debug("Not logged in as super admin")
 		return res, fmt.Errorf("unauthorized")
 	}

@@ -34,7 +34,7 @@ func DeleteUserResolver(ctx context.Context, params model.DeleteUserInput) (*mod

 	user, err := db.Provider.GetUserByEmail(params.Email)
 	if err != nil {
-		log.Debug("Failed to get user from DB:", err)
+		log.Debug("Failed to get user from DB: ", err)
 		return res, err
 	}

@@ -42,7 +42,7 @@ func DeleteUserResolver(ctx context.Context, params model.DeleteUserInput) (*mod

 	err = db.Provider.DeleteUser(user)
 	if err != nil {
-		log.Debug("Failed to delete user:", err)
+		log.Debug("Failed to delete user: ", err)
 		return res, err
 	}

--- a/server/resolvers/enable_access.go
+++ b/server/resolvers/enable_access.go
@@ -18,7 +18,7 @@ func EnableAccessResolver(ctx context.Context, params model.UpdateAccessInput) (

 	gc, err := utils.GinContextFromContext(ctx)
 	if err != nil {
-		log.Debug("Failed to get GinContext", err)
+		log.Debug("Failed to get GinContext: ", err)
 		return res, err
 	}

@@ -33,7 +33,7 @@ func EnableAccessResolver(ctx context.Context, params model.UpdateAccessInput) (

 	user, err := db.Provider.GetUserByID(params.UserID)
 	if err != nil {
-		log.Debug("Failed to get user from DB:", err)
+		log.Debug("Failed to get user from DB: ", err)
 		return res, err
 	}

@@ -41,7 +41,7 @@ func EnableAccessResolver(ctx context.Context, params model.UpdateAccessInput) (

 	user, err = db.Provider.UpdateUser(user)
 	if err != nil {
-		log.Debug("Failed to update user:", err)
+		log.Debug("Failed to update user: ", err)
 		return res, err
 	}

--- a/server/resolvers/env.go
+++ b/server/resolvers/env.go
@@ -20,7 +20,7 @@ func EnvResolver(ctx context.Context) (*model.Env, error) {

 	gc, err := utils.GinContextFromContext(ctx)
 	if err != nil {
-		log.Debug("Failed to get GinContext", err)
+		log.Debug("Failed to get GinContext: ", err)
 		return res, err
 	}

--- a/server/resolvers/forgot_password.go
+++ b/server/resolvers/forgot_password.go
@@ -24,18 +24,18 @@ func ForgotPasswordResolver(ctx context.Context, params model.ForgotPasswordInpu

 	gc, err := utils.GinContextFromContext(ctx)
 	if err != nil {
-		log.Debug("Failed to get GinContext", err)
+		log.Debug("Failed to get GinContext: ", err)
 		return res, err
 	}

 	if envstore.EnvStoreObj.GetBoolStoreEnvVariable(constants.EnvKeyDisableBasicAuthentication) {
-		log.Debug("Basic authentication is disabled.")
+		log.Debug("Basic authentication is disabled")
 		return res, fmt.Errorf(`basic authentication is disabled for this instance`)
 	}
 	params.Email = strings.ToLower(params.Email)

 	if !utils.IsValidEmail(params.Email) {
-		log.Debug("Invalid email address.")
+		log.Debug("Invalid email address: ", params.Email)
 		return res, fmt.Errorf("invalid email")
 	}

@@ -44,12 +44,14 @@ func ForgotPasswordResolver(ctx context.Context, params model.ForgotPasswordInpu
 	})
 	_, err = db.Provider.GetUserByEmail(params.Email)
 	if err != nil {
+		log.Debug("User not found: ", err)
 		return res, fmt.Errorf(`user with this email not found`)
 	}

 	hostname := utils.GetHost(gc)
 	_, nonceHash, err := utils.GenerateNonce()
 	if err != nil {
+		log.Debug("Failed to generate nonce: ", err)
 		return res, err
 	}
 	redirectURL := utils.GetAppURL(gc) + "/reset-password"
--- a/server/resolvers/generate_jwt_keys.go
+++ b/server/resolvers/generate_jwt_keys.go
@@ -17,12 +17,12 @@ import (
 func GenerateJWTKeysResolver(ctx context.Context, params model.GenerateJWTKeysInput) (*model.GenerateJWTKeysResponse, error) {
 	gc, err := utils.GinContextFromContext(ctx)
 	if err != nil {
-		log.Debug("Failed to get GinContext", err)
+		log.Debug("Failed to get GinContext: ", err)
 		return nil, err
 	}

 	if !token.IsSuperAdmin(gc) {
-		log.Debug("Not logged in as super admin.")
+		log.Debug("Not logged in as super admin")
 		return nil, fmt.Errorf("unauthorized")
 	}

@@ -30,7 +30,7 @@ func GenerateJWTKeysResolver(ctx context.Context, params model.GenerateJWTKeysIn
 	if crypto.IsHMACA(params.Type) {
 		secret, _, err := crypto.NewHMACKey(params.Type, clientID)
 		if err != nil {
-			log.Debug("Failed to generate new HMAC key:", err)
+			log.Debug("Failed to generate new HMAC key: ", err)
 			return nil, err
 		}
 		return &model.GenerateJWTKeysResponse{
@@ -41,7 +41,7 @@ func GenerateJWTKeysResolver(ctx context.Context, params model.GenerateJWTKeysIn
 	if crypto.IsRSA(params.Type) {
 		_, privateKey, publicKey, _, err := crypto.NewRSAKey(params.Type, clientID)
 		if err != nil {
-			log.Debug("Failed to generate new RSA key:", err)
+			log.Debug("Failed to generate new RSA key: ", err)
 			return nil, err
 		}
 		return &model.GenerateJWTKeysResponse{
@@ -53,7 +53,7 @@ func GenerateJWTKeysResolver(ctx context.Context, params model.GenerateJWTKeysIn
 	if crypto.IsECDSA(params.Type) {
 		_, privateKey, publicKey, _, err := crypto.NewECDSAKey(params.Type, clientID)
 		if err != nil {
-			log.Debug("Failed to generate new ECDSA key:", err)
+			log.Debug("Failed to generate new ECDSA key: ", err)
 			return nil, err
 		}
 		return &model.GenerateJWTKeysResponse{
@@ -62,6 +62,6 @@ func GenerateJWTKeysResolver(ctx context.Context, params model.GenerateJWTKeysIn
 		}, nil
 	}

-	log.Debug("Invalid algorithm:", params.Type)
+	log.Debug("Invalid algorithm: ", params.Type)
 	return nil, fmt.Errorf("invalid algorithm")
 }
--- a/server/resolvers/invite_members.go
+++ b/server/resolvers/invite_members.go
@@ -23,7 +23,7 @@ import (
 func InviteMembersResolver(ctx context.Context, params model.InviteMemberInput) (*model.Response, error) {
 	gc, err := utils.GinContextFromContext(ctx)
 	if err != nil {
-		log.Debug("Failed to get GinContext", err)
+		log.Debug("Failed to get GinContext: ", err)
 		return nil, err
 	}

@@ -34,7 +34,7 @@ func InviteMembersResolver(ctx context.Context, params model.InviteMemberInput)

 	// this feature is only allowed if email server is configured
 	if envstore.EnvStoreObj.GetBoolStoreEnvVariable(constants.EnvKeyDisableEmailVerification) {
-		log.Debug("Email server is not configured.")
+		log.Debug("Email server is not configured")
 		return nil, errors.New("email sending is disabled")
 	}

@@ -52,7 +52,7 @@ func InviteMembersResolver(ctx context.Context, params model.InviteMemberInput)
 	}

 	if len(emails) == 0 {
-		log.Debug("No valid email addresses.")
+		log.Debug("No valid email addresses")
 		return nil, errors.New("no valid emails found")
 	}

@@ -62,10 +62,10 @@ func InviteMembersResolver(ctx context.Context, params model.InviteMemberInput)
 	for _, email := range emails {
 		_, err := db.Provider.GetUserByEmail(email)
 		if err != nil {
-			log.Info("User with this email not found, so inviting...")
+			log.Debugf("User with %s email not found, so inviting user", email)
 			newEmails = append(newEmails, email)
 		} else {
-			log.Info("User with this email already exists, so not inviting...")
+			log.Debugf("User with %s email already exists, so not inviting user", email)
 		}
 	}

@@ -97,7 +97,7 @@ func InviteMembersResolver(ctx context.Context, params model.InviteMemberInput)

 		verificationToken, err := token.CreateVerificationToken(email, constants.VerificationTypeForgotPassword, hostname, nonceHash, redirectURL)
 		if err != nil {
-			log.Debug("Failed to create verification token.", err)
+			log.Debug("Failed to create verification token: ", err)
 		}

 		verificationRequest := models.VerificationRequest{
@@ -123,13 +123,13 @@ func InviteMembersResolver(ctx context.Context, params model.InviteMemberInput)

 		user, err = db.Provider.AddUser(user)
 		if err != nil {
-			log.Debug("Error adding user: %s, err: %v", email, err)
+			log.Debugf("Error adding user: %s, err: %v", email, err)
 			return nil, err
 		}

 		_, err = db.Provider.AddVerificationRequest(verificationRequest)
 		if err != nil {
-			log.Debug("Error adding verification request: %s, err: %v", email, err)
+			log.Debugf("Error adding verification request: %s, err: %v", email, err)
 			return nil, err
 		}

--- a/server/resolvers/login.go
+++ b/server/resolvers/login.go
@@ -26,7 +26,7 @@ func LoginResolver(ctx context.Context, params model.LoginInput) (*model.AuthRes

 	gc, err := utils.GinContextFromContext(ctx)
 	if err != nil {
-		log.Debug("Failed to get GinContext", err)
+		log.Debug("Failed to get GinContext: ", err)
 		return res, err
 	}

@@ -41,7 +41,7 @@ func LoginResolver(ctx context.Context, params model.LoginInput) (*model.AuthRes
 	params.Email = strings.ToLower(params.Email)
 	user, err := db.Provider.GetUserByEmail(params.Email)
 	if err != nil {
-		log.Debug("Failed to get user by email", err)
+		log.Debug("Failed to get user by email: ", err)
 		return res, fmt.Errorf(`user with this email not found`)
 	}

@@ -63,14 +63,14 @@ func LoginResolver(ctx context.Context, params model.LoginInput) (*model.AuthRes
 	err = bcrypt.CompareHashAndPassword([]byte(*user.Password), []byte(params.Password))

 	if err != nil {
-		log.Debug("Failed to compare password", err)
+		log.Debug("Failed to compare password: ", err)
 		return res, fmt.Errorf(`invalid password`)
 	}
 	roles := envstore.EnvStoreObj.GetSliceStoreEnvVariable(constants.EnvKeyDefaultRoles)
 	currentRoles := strings.Split(user.Roles, ",")
 	if len(params.Roles) > 0 {
 		if !utils.IsValidRoles(params.Roles, currentRoles) {
-			log.Debug("Invalid roles")
+			log.Debug("Invalid roles: ", params.Roles)
 			return res, fmt.Errorf(`invalid roles`)
 		}

--- a/server/resolvers/logout.go
+++ b/server/resolvers/logout.go
@@ -18,20 +18,20 @@ func LogoutResolver(ctx context.Context) (*model.Response, error) {

 	gc, err := utils.GinContextFromContext(ctx)
 	if err != nil {
-		log.Debug("Failed to get GinContext", err)
+		log.Debug("Failed to get GinContext: ", err)
 		return res, err
 	}

 	// get fingerprint hash
 	fingerprintHash, err := cookie.GetSession(gc)
 	if err != nil {
-		log.Debug("Failed to get fingerprint hash:", err)
+		log.Debug("Failed to get fingerprint hash: ", err)
 		return res, err
 	}

 	decryptedFingerPrint, err := crypto.DecryptAES(fingerprintHash)
 	if err != nil {
-		log.Debug("Failed to decrypt fingerprint hash:", err)
+		log.Debug("Failed to decrypt fingerprint hash: ", err)
 		return res, err
 	}

--- a/server/resolvers/magic_link_login.go
+++ b/server/resolvers/magic_link_login.go
@@ -24,7 +24,7 @@ func MagicLinkLoginResolver(ctx context.Context, params model.MagicLinkLoginInpu

 	gc, err := utils.GinContextFromContext(ctx)
 	if err != nil {
-		log.Debug("Failed to get GinContext", err)
+		log.Debug("Failed to get GinContext: ", err)
 		return res, err
 	}

@@ -63,7 +63,7 @@ func MagicLinkLoginResolver(ctx context.Context, params model.MagicLinkLoginInpu
 		if len(params.Roles) > 0 {
 			// check if roles exists
 			if !utils.IsValidRoles(params.Roles, envstore.EnvStoreObj.GetSliceStoreEnvVariable(constants.EnvKeyRoles)) {
-				log.Debug("Invalid roles")
+				log.Debug("Invalid roles: ", params.Roles)
 				return res, fmt.Errorf(`invalid roles`)
 			} else {
 				inputRoles = params.Roles
@@ -82,7 +82,7 @@ func MagicLinkLoginResolver(ctx context.Context, params model.MagicLinkLoginInpu
 		// 		Need to modify roles in this case

 		if user.RevokedTimestamp != nil {
-			log.Debug("User access is revoked")
+			log.Debug("User access is revoked at: ", user.RevokedTimestamp)
 			return res, fmt.Errorf(`user access has been revoked`)
 		}

@@ -125,7 +125,7 @@ func MagicLinkLoginResolver(ctx context.Context, params model.MagicLinkLoginInpu
 		user.SignupMethods = signupMethod
 		user, _ = db.Provider.UpdateUser(user)
 		if err != nil {
-			log.Debug("Failed to update user", err)
+			log.Debug("Failed to update user: ", err)
 		}
 	}

@@ -134,7 +134,7 @@ func MagicLinkLoginResolver(ctx context.Context, params model.MagicLinkLoginInpu
 		// insert verification request
 		_, nonceHash, err := utils.GenerateNonce()
 		if err != nil {
-			log.Debug("Failed to generate nonce", err)
+			log.Debug("Failed to generate nonce: ", err)
 			return res, err
 		}
 		redirectURLParams := "&roles=" + strings.Join(inputRoles, ",")
@@ -158,7 +158,7 @@ func MagicLinkLoginResolver(ctx context.Context, params model.MagicLinkLoginInpu
 		verificationType := constants.VerificationTypeMagicLinkLogin
 		verificationToken, err := token.CreateVerificationToken(params.Email, verificationType, hostname, nonceHash, redirectURL)
 		if err != nil {
-			log.Debug("Failed to create verification token", err)
+			log.Debug("Failed to create verification token: ", err)
 		}
 		_, err = db.Provider.AddVerificationRequest(models.VerificationRequest{
 			Token:       verificationToken,
@@ -169,7 +169,7 @@ func MagicLinkLoginResolver(ctx context.Context, params model.MagicLinkLoginInpu
 			RedirectURI: redirectURL,
 		})
 		if err != nil {
-			log.Debug("Failed to add verification request in db:", err)
+			log.Debug("Failed to add verification request in db: ", err)
 			return res, err
 		}

--- a/server/resolvers/profile.go
+++ b/server/resolvers/profile.go
@@ -17,19 +17,19 @@ func ProfileResolver(ctx context.Context) (*model.User, error) {

 	gc, err := utils.GinContextFromContext(ctx)
 	if err != nil {
-		log.Debug("Failed to get GinContext", err)
+		log.Debug("Failed to get GinContext: ", err)
 		return res, err
 	}

 	accessToken, err := token.GetAccessToken(gc)
 	if err != nil {
-		log.Debug("Failed to get access token:", err)
+		log.Debug("Failed to get access token: ", err)
 		return res, err
 	}

 	claims, err := token.ValidateAccessToken(gc, accessToken)
 	if err != nil {
-		log.Debug("Failed to validate access token:", err)
+		log.Debug("Failed to validate access token: ", err)
 		return res, err
 	}

@@ -40,7 +40,7 @@ func ProfileResolver(ctx context.Context) (*model.User, error) {
 	})
 	user, err := db.Provider.GetUserByID(userID)
 	if err != nil {
-		log.Debug("Failed to get user:", err)
+		log.Debug("Failed to get user: ", err)
 		return res, err
 	}

--- a/server/resolvers/resend_verify_email.go
+++ b/server/resolvers/resend_verify_email.go
@@ -22,43 +22,43 @@ func ResendVerifyEmailResolver(ctx context.Context, params model.ResendVerifyEma

 	gc, err := utils.GinContextFromContext(ctx)
 	if err != nil {
-		log.Debug("Failed to get GinContext", err)
+		log.Debug("Failed to get GinContext: ", err)
 		return res, err
 	}
 	params.Email = strings.ToLower(params.Email)

 	if !utils.IsValidEmail(params.Email) {
-		log.Debug("Invalid email", params.Email)
+		log.Debug("Invalid email: ", params.Email)
 		return res, fmt.Errorf("invalid email")
 	}

 	if !utils.IsValidVerificationIdentifier(params.Identifier) {
-		log.Debug("Invalid verification identifier", params.Identifier)
+		log.Debug("Invalid verification identifier: ", params.Identifier)
 		return res, fmt.Errorf("invalid identifier")
 	}

 	verificationRequest, err := db.Provider.GetVerificationRequestByEmail(params.Email, params.Identifier)
 	if err != nil {
-		log.Debug("Failed to get verification request", err)
+		log.Debug("Failed to get verification request: ", err)
 		return res, fmt.Errorf(`verification request not found`)
 	}

 	// delete current verification and create new one
 	err = db.Provider.DeleteVerificationRequest(verificationRequest)
 	if err != nil {
-		log.Debug("Failed to delete verification request", err)
+		log.Debug("Failed to delete verification request: ", err)
 	}

 	hostname := utils.GetHost(gc)
 	_, nonceHash, err := utils.GenerateNonce()
 	if err != nil {
-		log.Debug("Failed to generate nonce", err)
+		log.Debug("Failed to generate nonce: ", err)
 		return res, err
 	}

 	verificationToken, err := token.CreateVerificationToken(params.Email, params.Identifier, hostname, nonceHash, verificationRequest.RedirectURI)
 	if err != nil {
-		log.Debug("Failed to create verification token", err)
+		log.Debug("Failed to create verification token: ", err)
 	}
 	_, err = db.Provider.AddVerificationRequest(models.VerificationRequest{
 		Token:       verificationToken,
@@ -69,7 +69,7 @@ func ResendVerifyEmailResolver(ctx context.Context, params model.ResendVerifyEma
 		RedirectURI: verificationRequest.RedirectURI,
 	})
 	if err != nil {
-		log.Debug("Failed to add verification request", err)
+		log.Debug("Failed to add verification request: ", err)
 	}

 	// exec it as go routin so that we can reduce the api latency
--- a/server/resolvers/reset_password.go
+++ b/server/resolvers/reset_password.go
@@ -23,7 +23,7 @@ func ResetPasswordResolver(ctx context.Context, params model.ResetPasswordInput)

 	gc, err := utils.GinContextFromContext(ctx)
 	if err != nil {
-		log.Debug("Failed to get GinContext", err)
+		log.Debug("Failed to get GinContext: ", err)
 		return res, err
 	}
 	if envstore.EnvStoreObj.GetBoolStoreEnvVariable(constants.EnvKeyDisableBasicAuthentication) {
@@ -33,7 +33,7 @@ func ResetPasswordResolver(ctx context.Context, params model.ResetPasswordInput)

 	verificationRequest, err := db.Provider.GetVerificationRequestByToken(params.Token)
 	if err != nil {
-		log.Debug("Failed to get verification request", err)
+		log.Debug("Failed to get verification request: ", err)
 		return res, fmt.Errorf(`invalid token`)
 	}

@@ -51,7 +51,7 @@ func ResetPasswordResolver(ctx context.Context, params model.ResetPasswordInput)
 	hostname := utils.GetHost(gc)
 	claim, err := token.ParseJWTToken(params.Token, hostname, verificationRequest.Nonce, verificationRequest.Email)
 	if err != nil {
-		log.Debug("Failed to parse token", err)
+		log.Debug("Failed to parse token: ", err)
 		return res, fmt.Errorf(`invalid token`)
 	}

@@ -61,7 +61,7 @@ func ResetPasswordResolver(ctx context.Context, params model.ResetPasswordInput)
 	})
 	user, err := db.Provider.GetUserByEmail(email)
 	if err != nil {
-		log.Debug("Failed to get user", err)
+		log.Debug("Failed to get user: ", err)
 		return res, err
 	}

@@ -83,13 +83,13 @@ func ResetPasswordResolver(ctx context.Context, params model.ResetPasswordInput)
 	// delete from verification table
 	err = db.Provider.DeleteVerificationRequest(verificationRequest)
 	if err != nil {
-		log.Debug("Failed to delete verification request", err)
+		log.Debug("Failed to delete verification request: ", err)
 		return res, err
 	}

 	_, err = db.Provider.UpdateUser(user)
 	if err != nil {
-		log.Debug("Failed to update user", err)
+		log.Debug("Failed to update user: ", err)
 		return res, err
 	}

--- a/server/resolvers/revoke_access.go
+++ b/server/resolvers/revoke_access.go
@@ -20,12 +20,12 @@ func RevokeAccessResolver(ctx context.Context, params model.UpdateAccessInput) (

 	gc, err := utils.GinContextFromContext(ctx)
 	if err != nil {
-		log.Debug("Failed to get GinContext", err)
+		log.Debug("Failed to get GinContext: ", err)
 		return res, err
 	}

 	if !token.IsSuperAdmin(gc) {
-		log.Debug("Not logged in as super admin.")
+		log.Debug("Not logged in as super admin")
 		return res, fmt.Errorf("unauthorized")
 	}

@@ -34,7 +34,7 @@ func RevokeAccessResolver(ctx context.Context, params model.UpdateAccessInput) (
 	})
 	user, err := db.Provider.GetUserByID(params.UserID)
 	if err != nil {
-		log.Debug("Failed to get user by ID", err)
+		log.Debug("Failed to get user by ID: ", err)
 		return res, err
 	}

@@ -43,7 +43,7 @@ func RevokeAccessResolver(ctx context.Context, params model.UpdateAccessInput) (

 	user, err = db.Provider.UpdateUser(user)
 	if err != nil {
-		log.Debug("Failed to update user", err)
+		log.Debug("Failed to update user: ", err)
 		return res, err
 	}

--- a/server/resolvers/session.go
+++ b/server/resolvers/session.go
@@ -23,7 +23,7 @@ func SessionResolver(ctx context.Context, params *model.SessionQueryInput) (*mod

 	gc, err := utils.GinContextFromContext(ctx)
 	if err != nil {
-		log.Debug("Failed to get GinContext", err)
+		log.Debug("Failed to get GinContext: ", err)
 		return res, err
 	}

@@ -58,7 +58,7 @@ func SessionResolver(ctx context.Context, params *model.SessionQueryInput) (*mod
 	if params != nil && params.Roles != nil && len(params.Roles) > 0 {
 		for _, v := range params.Roles {
 			if !utils.StringSliceContains(claimRoles, v) {
-				log.Debug("User does not have required role:", claimRoles, v)
+				log.Debug("User does not have required role: ", claimRoles, v)
 				return res, fmt.Errorf(`unauthorized`)
 			}
 		}
@@ -71,7 +71,7 @@ func SessionResolver(ctx context.Context, params *model.SessionQueryInput) (*mod

 	authToken, err := token.CreateAuthToken(gc, user, claimRoles, scope)
 	if err != nil {
-		log.Debug("Failed to create auth token", err)
+		log.Debug("Failed to create auth token: ", err)
 		return res, err
 	}

--- a/server/resolvers/signup.go
+++ b/server/resolvers/signup.go
@@ -27,22 +27,22 @@ func SignupResolver(ctx context.Context, params model.SignUpInput) (*model.AuthR

 	gc, err := utils.GinContextFromContext(ctx)
 	if err != nil {
-		log.Debug("Failed to get GinContext", err)
+		log.Debug("Failed to get GinContext: ", err)
 		return res, err
 	}

 	if envstore.EnvStoreObj.GetBoolStoreEnvVariable(constants.EnvKeyDisableSignUp) {
-		log.Debug("Signup is disabled.")
+		log.Debug("Signup is disabled")
 		return res, fmt.Errorf(`signup is disabled for this instance`)
 	}

 	if envstore.EnvStoreObj.GetBoolStoreEnvVariable(constants.EnvKeyDisableBasicAuthentication) {
-		log.Debug("Basic authentication is disabled.")
+		log.Debug("Basic authentication is disabled")
 		return res, fmt.Errorf(`basic authentication is disabled for this instance`)
 	}

 	if params.ConfirmPassword != params.Password {
-		log.Debug("Passwords do not match.")
+		log.Debug("Passwords do not match")
 		return res, fmt.Errorf(`password and confirm password does not match`)
 	}

@@ -54,7 +54,7 @@ func SignupResolver(ctx context.Context, params model.SignUpInput) (*model.AuthR
 	params.Email = strings.ToLower(params.Email)

 	if !utils.IsValidEmail(params.Email) {
-		log.Debug("Invalid email:", params.Email)
+		log.Debug("Invalid email: ", params.Email)
 		return res, fmt.Errorf(`invalid email address`)
 	}

@@ -64,7 +64,7 @@ func SignupResolver(ctx context.Context, params model.SignUpInput) (*model.AuthR
 	// find user with email
 	existingUser, err := db.Provider.GetUserByEmail(params.Email)
 	if err != nil {
-		log.Debug("Failed to get user by email:", err)
+		log.Debug("Failed to get user by email: ", err)
 	}

 	if existingUser.EmailVerifiedAt != nil {
@@ -81,7 +81,7 @@ func SignupResolver(ctx context.Context, params model.SignUpInput) (*model.AuthR
 	if len(params.Roles) > 0 {
 		// check if roles exists
 		if !utils.IsValidRoles(envstore.EnvStoreObj.GetSliceStoreEnvVariable(constants.EnvKeyRoles), params.Roles) {
-			log.Debug("Invalid roles", params.Roles)
+			log.Debug("Invalid roles: ", params.Roles)
 			return res, fmt.Errorf(`invalid roles`)
 		} else {
 			inputRoles = params.Roles
@@ -138,7 +138,7 @@ func SignupResolver(ctx context.Context, params model.SignUpInput) (*model.AuthR
 	}
 	user, err = db.Provider.AddUser(user)
 	if err != nil {
-		log.Debug("Failed to add user:", err)
+		log.Debug("Failed to add user: ", err)
 		return res, err
 	}
 	roles := strings.Split(user.Roles, ",")
@@ -149,7 +149,7 @@ func SignupResolver(ctx context.Context, params model.SignUpInput) (*model.AuthR
 		// insert verification request
 		_, nonceHash, err := utils.GenerateNonce()
 		if err != nil {
-			log.Debug("Failed to generate nonce:", err)
+			log.Debug("Failed to generate nonce: ", err)
 			return res, err
 		}
 		verificationType := constants.VerificationTypeBasicAuthSignup
@@ -159,7 +159,7 @@ func SignupResolver(ctx context.Context, params model.SignUpInput) (*model.AuthR
 		}
 		verificationToken, err := token.CreateVerificationToken(params.Email, verificationType, hostname, nonceHash, redirectURL)
 		if err != nil {
-			log.Debug("Failed to create verification token:", err)
+			log.Debug("Failed to create verification token: ", err)
 			return res, err
 		}
 		_, err = db.Provider.AddVerificationRequest(models.VerificationRequest{
@@ -171,7 +171,7 @@ func SignupResolver(ctx context.Context, params model.SignUpInput) (*model.AuthR
 			RedirectURI: redirectURL,
 		})
 		if err != nil {
-			log.Debug("Failed to add verification request:", err)
+			log.Debug("Failed to add verification request: ", err)
 			return res, err
 		}

@@ -190,7 +190,7 @@ func SignupResolver(ctx context.Context, params model.SignUpInput) (*model.AuthR

 		authToken, err := token.CreateAuthToken(gc, user, roles, scope)
 		if err != nil {
-			log.Debug("Failed to create auth token:", err)
+			log.Debug("Failed to create auth token: ", err)
 			return res, err
 		}

--- a/server/resolvers/update_env.go
+++ b/server/resolvers/update_env.go
@@ -28,12 +28,12 @@ func UpdateEnvResolver(ctx context.Context, params model.UpdateEnvInput) (*model

 	gc, err := utils.GinContextFromContext(ctx)
 	if err != nil {
-		log.Debug("Failed to get GinContext", err)
+		log.Debug("Failed to get GinContext: ", err)
 		return res, err
 	}

 	if !token.IsSuperAdmin(gc) {
-		log.Debug("Not logged in as super admin.")
+		log.Debug("Not logged in as super admin")
 		return res, fmt.Errorf("unauthorized")
 	}

@@ -44,7 +44,7 @@ func UpdateEnvResolver(ctx context.Context, params model.UpdateEnvInput) (*model
 	if params.JwtType != nil {
 		algo = *params.JwtType
 		if !crypto.IsHMACA(algo) && !crypto.IsECDSA(algo) && !crypto.IsRSA(algo) {
-			log.Debug("Invalid JWT type", algo)
+			log.Debug("Invalid JWT type: ", algo)
 			return res, fmt.Errorf("invalid jwt type")
 		}

@@ -75,7 +75,7 @@ func UpdateEnvResolver(ctx context.Context, params model.UpdateEnvInput) (*model

 		if crypto.IsRSA(algo) {
 			if params.JwtPrivateKey == nil || params.JwtPublicKey == nil {
-				log.Debug("JWT private key and public key are required for RSA", params.JwtPrivateKey, params.JwtPublicKey)
+				log.Debug("JWT private key and public key are required for RSA: ", *params.JwtPrivateKey, *params.JwtPublicKey)
 				return res, fmt.Errorf("jwt private and public key is required for RSA (PKCS1) / ECDSA algorithm")
 			}

@@ -83,20 +83,20 @@ func UpdateEnvResolver(ctx context.Context, params model.UpdateEnvInput) (*model
 			params.JwtSecret = &defaultSecret
 			_, err = crypto.ParseRsaPrivateKeyFromPemStr(*params.JwtPrivateKey)
 			if err != nil {
-				log.Debug("Invalid JWT private key", err)
+				log.Debug("Invalid JWT private key: ", err)
 				return res, err
 			}

 			_, err := crypto.ParseRsaPublicKeyFromPemStr(*params.JwtPublicKey)
 			if err != nil {
-				log.Debug("Invalid JWT public key", err)
+				log.Debug("Invalid JWT public key: ", err)
 				return res, err
 			}
 		}

 		if crypto.IsECDSA(algo) {
 			if params.JwtPrivateKey == nil || params.JwtPublicKey == nil {
-				log.Debug("JWT private key and public key are required for ECDSA", params.JwtPrivateKey, params.JwtPublicKey)
+				log.Debug("JWT private key and public key are required for ECDSA: ", *params.JwtPrivateKey, *params.JwtPublicKey)
 				return res, fmt.Errorf("jwt private and public key is required for RSA (PKCS1) / ECDSA algorithm")
 			}

@@ -104,13 +104,13 @@ func UpdateEnvResolver(ctx context.Context, params model.UpdateEnvInput) (*model
 			params.JwtSecret = &defaultSecret
 			_, err = crypto.ParseEcdsaPrivateKeyFromPemStr(*params.JwtPrivateKey)
 			if err != nil {
-				log.Debug("Invalid JWT private key", err)
+				log.Debug("Invalid JWT private key: ", err)
 				return res, err
 			}

 			_, err := crypto.ParseEcdsaPublicKeyFromPemStr(*params.JwtPublicKey)
 			if err != nil {
-				log.Debug("Invalid JWT public key", err)
+				log.Debug("Invalid JWT public key: ", err)
 				return res, err
 			}
 		}
@@ -120,13 +120,13 @@ func UpdateEnvResolver(ctx context.Context, params model.UpdateEnvInput) (*model
 	var data map[string]interface{}
 	byteData, err := json.Marshal(params)
 	if err != nil {
-		log.Debug("Failed to marshal update env input", err)
+		log.Debug("Failed to marshal update env input: ", err)
 		return res, fmt.Errorf("error marshalling params: %t", err)
 	}

 	err = json.Unmarshal(byteData, &data)
 	if err != nil {
-		log.Debug("Failed to unmarshal update env input", err)
+		log.Debug("Failed to unmarshal update env input: ", err)
 		return res, fmt.Errorf("error un-marshalling params: %t", err)
 	}

@@ -209,14 +209,14 @@ func UpdateEnvResolver(ctx context.Context, params model.UpdateEnvInput) (*model
 	envstore.EnvStoreObj.UpdateEnvStore(updatedData)
 	jwk, err := crypto.GenerateJWKBasedOnEnv()
 	if err != nil {
-		log.Debug("Failed to generate JWK", err)
+		log.Debug("Failed to generate JWK: ", err)
 		return res, err
 	}
 	// updating jwk
 	envstore.EnvStoreObj.UpdateEnvVariable(constants.StringStoreIdentifier, constants.EnvKeyJWK, jwk)
 	err = sessionstore.InitSession()
 	if err != nil {
-		log.Debug("Failed to init session store", err)
+		log.Debug("Failed to init session store: ", err)
 		return res, err
 	}
 	err = oauth.InitOAuth()
@@ -227,14 +227,14 @@ func UpdateEnvResolver(ctx context.Context, params model.UpdateEnvInput) (*model
 	// Fetch the current db store and update it
 	env, err := db.Provider.GetEnv()
 	if err != nil {
-		log.Debug("Failed to get env", err)
+		log.Debug("Failed to get env: ", err)
 		return res, err
 	}

 	if params.AdminSecret != nil {
 		hashedKey, err := crypto.EncryptPassword(envstore.EnvStoreObj.GetStringStoreEnvVariable(constants.EnvKeyAdminSecret))
 		if err != nil {
-			log.Debug("Failed to encrypt admin secret", err)
+			log.Debug("Failed to encrypt admin secret: ", err)
 			return res, err
 		}
 		cookie.SetAdminCookie(gc, hashedKey)
@@ -242,14 +242,14 @@ func UpdateEnvResolver(ctx context.Context, params model.UpdateEnvInput) (*model

 	encryptedConfig, err := crypto.EncryptEnvData(updatedData)
 	if err != nil {
-		log.Debug("Failed to encrypt env data", err)
+		log.Debug("Failed to encrypt env data: ", err)
 		return res, err
 	}

 	env.EnvData = encryptedConfig
 	_, err = db.Provider.UpdateEnv(env)
 	if err != nil {
-		log.Debug("Failed to update env", err)
+		log.Debug("Failed to update env: ", err)
 		return res, err
 	}

--- a/server/resolvers/update_profile.go
+++ b/server/resolvers/update_profile.go
@@ -28,23 +28,24 @@ func UpdateProfileResolver(ctx context.Context, params model.UpdateProfileInput)

 	gc, err := utils.GinContextFromContext(ctx)
 	if err != nil {
-		log.Debug("Failed to get GinContext", err)
+		log.Debug("Failed to get GinContext: ", err)
 		return res, err
 	}

 	accessToken, err := token.GetAccessToken(gc)
 	if err != nil {
-		log.Debug("Failed to get access token", err)
+		log.Debug("Failed to get access token: ", err)
 		return res, err
 	}
 	claims, err := token.ValidateAccessToken(gc, accessToken)
 	if err != nil {
-		log.Debug("Failed to validate access token", err)
+		log.Debug("Failed to validate access token: ", err)
 		return res, err
 	}

 	// validate if all params are not empty
 	if params.GivenName == nil && params.FamilyName == nil && params.Picture == nil && params.MiddleName == nil && params.Nickname == nil && params.OldPassword == nil && params.Email == nil && params.Birthdate == nil && params.Gender == nil && params.PhoneNumber == nil {
+		log.Debug("All params are empty")
 		return res, fmt.Errorf("please enter at least one param to update")
 	}

@@ -55,7 +56,7 @@ func UpdateProfileResolver(ctx context.Context, params model.UpdateProfileInput)

 	user, err := db.Provider.GetUserByID(userID)
 	if err != nil {
-		log.Debug("Failed to get user by id", err)
+		log.Debug("Failed to get user by id: ", err)
 		return res, err
 	}

@@ -93,17 +94,17 @@ func UpdateProfileResolver(ctx context.Context, params model.UpdateProfileInput)

 	if params.OldPassword != nil {
 		if err = bcrypt.CompareHashAndPassword([]byte(*user.Password), []byte(*params.OldPassword)); err != nil {
-			log.Debug("Failed to compare hash and old password", err)
+			log.Debug("Failed to compare hash and old password: ", err)
 			return res, fmt.Errorf("incorrect old password")
 		}

 		if params.NewPassword == nil {
-			log.Debug("Failed to get new password")
+			log.Debug("Failed to get new password: ")
 			return res, fmt.Errorf("new password is required")
 		}

 		if params.ConfirmNewPassword == nil {
-			log.Debug("Failed to get confirm new password")
+			log.Debug("Failed to get confirm new password: ")
 			return res, fmt.Errorf("confirm password is required")
 		}

@@ -122,15 +123,21 @@ func UpdateProfileResolver(ctx context.Context, params model.UpdateProfileInput)
 	if params.Email != nil && user.Email != *params.Email {
 		// check if valid email
 		if !utils.IsValidEmail(*params.Email) {
-			log.Debug("Failed to validate email", *params.Email)
+			log.Debug("Failed to validate email: ", *params.Email)
 			return res, fmt.Errorf("invalid email address")
 		}
 		newEmail := strings.ToLower(*params.Email)
+
+		// check if valid email
+		if !utils.IsValidEmail(newEmail) {
+			log.Debug("Failed to validate new email: ", newEmail)
+			return res, fmt.Errorf("invalid new email address")
+		}
 		// check if user with new email exists
 		_, err := db.Provider.GetUserByEmail(newEmail)
 		// err = nil means user exists
 		if err == nil {
-			log.Debug("Failed to get user by email", newEmail)
+			log.Debug("Failed to get user by email: ", newEmail)
 			return res, fmt.Errorf("user with this email address already exists")
 		}

@@ -145,14 +152,14 @@ func UpdateProfileResolver(ctx context.Context, params model.UpdateProfileInput)
 			// insert verification request
 			_, nonceHash, err := utils.GenerateNonce()
 			if err != nil {
-				log.Debug("Failed to generate nonce", err)
+				log.Debug("Failed to generate nonce: ", err)
 				return res, err
 			}
 			verificationType := constants.VerificationTypeUpdateEmail
 			redirectURL := utils.GetAppURL(gc)
 			verificationToken, err := token.CreateVerificationToken(newEmail, verificationType, hostname, nonceHash, redirectURL)
 			if err != nil {
-				log.Debug("Failed to create verification token", err)
+				log.Debug("Failed to create verification token: ", err)
 				return res, err
 			}
 			_, err = db.Provider.AddVerificationRequest(models.VerificationRequest{
@@ -164,7 +171,7 @@ func UpdateProfileResolver(ctx context.Context, params model.UpdateProfileInput)
 				RedirectURI: redirectURL,
 			})
 			if err != nil {
-				log.Debug("Failed to add verification request", err)
+				log.Debug("Failed to add verification request: ", err)
 				return res, err
 			}

@@ -175,7 +182,7 @@ func UpdateProfileResolver(ctx context.Context, params model.UpdateProfileInput)
 	}
 	_, err = db.Provider.UpdateUser(user)
 	if err != nil {
-		log.Debug("Failed to update user", err)
+		log.Debug("Failed to update user: ", err)
 		return res, err
 	}
 	message := `Profile details updated successfully.`
--- a/server/resolvers/update_user.go
+++ b/server/resolvers/update_user.go
@@ -26,17 +26,17 @@ func UpdateUserResolver(ctx context.Context, params model.UpdateUserInput) (*mod

 	gc, err := utils.GinContextFromContext(ctx)
 	if err != nil {
-		log.Debug("Failed to get GinContext", err)
+		log.Debug("Failed to get GinContext: ", err)
 		return res, err
 	}

 	if !token.IsSuperAdmin(gc) {
-		log.Debug("Not logged in as super admin.")
+		log.Debug("Not logged in as super admin")
 		return res, fmt.Errorf("unauthorized")
 	}

 	if params.ID == "" {
-		log.Debug("Invalid user id")
+		log.Debug("UserID is empty")
 		return res, fmt.Errorf("User ID is required")
 	}

@@ -51,7 +51,7 @@ func UpdateUserResolver(ctx context.Context, params model.UpdateUserInput) (*mod

 	user, err := db.Provider.GetUserByID(params.ID)
 	if err != nil {
-		log.Debug("Failed to get user by id", err)
+		log.Debug("Failed to get user by id: ", err)
 		return res, fmt.Errorf(`User not found`)
 	}

@@ -99,7 +99,7 @@ func UpdateUserResolver(ctx context.Context, params model.UpdateUserInput) (*mod
 	if params.Email != nil && user.Email != *params.Email {
 		// check if valid email
 		if !utils.IsValidEmail(*params.Email) {
-			log.Debug("Invalid email", *params.Email)
+			log.Debug("Invalid email: ", *params.Email)
 			return res, fmt.Errorf("invalid email address")
 		}
 		newEmail := strings.ToLower(*params.Email)
@@ -107,7 +107,7 @@ func UpdateUserResolver(ctx context.Context, params model.UpdateUserInput) (*mod
 		_, err = db.Provider.GetUserByEmail(newEmail)
 		// err = nil means user exists
 		if err == nil {
-			log.Debug("User with email already exists", newEmail)
+			log.Debug("User with email already exists: ", newEmail)
 			return res, fmt.Errorf("user with this email address already exists")
 		}

@@ -120,14 +120,14 @@ func UpdateUserResolver(ctx context.Context, params model.UpdateUserInput) (*mod
 		// insert verification request
 		_, nonceHash, err := utils.GenerateNonce()
 		if err != nil {
-			log.Debug("Failed to generate nonce", err)
+			log.Debug("Failed to generate nonce: ", err)
 			return res, err
 		}
 		verificationType := constants.VerificationTypeUpdateEmail
 		redirectURL := utils.GetAppURL(gc)
 		verificationToken, err := token.CreateVerificationToken(newEmail, verificationType, hostname, nonceHash, redirectURL)
 		if err != nil {
-			log.Debug("Failed to create verification token", err)
+			log.Debug("Failed to create verification token: ", err)
 		}
 		_, err = db.Provider.AddVerificationRequest(models.VerificationRequest{
 			Token:       verificationToken,
@@ -138,7 +138,7 @@ func UpdateUserResolver(ctx context.Context, params model.UpdateUserInput) (*mod
 			RedirectURI: redirectURL,
 		})
 		if err != nil {
-			log.Debug("Failed to add verification request", err)
+			log.Debug("Failed to add verification request: ", err)
 			return res, err
 		}

@@ -156,7 +156,7 @@ func UpdateUserResolver(ctx context.Context, params model.UpdateUserInput) (*mod
 		}

 		if !utils.IsValidRoles(inputRoles, append([]string{}, append(envstore.EnvStoreObj.GetSliceStoreEnvVariable(constants.EnvKeyRoles), envstore.EnvStoreObj.GetSliceStoreEnvVariable(constants.EnvKeyProtectedRoles)...)...)) {
-			log.Debug("Invalid roles", params.Roles)
+			log.Debug("Invalid roles: ", params.Roles)
 			return res, fmt.Errorf("invalid list of roles")
 		}

@@ -173,7 +173,7 @@ func UpdateUserResolver(ctx context.Context, params model.UpdateUserInput) (*mod

 	user, err = db.Provider.UpdateUser(user)
 	if err != nil {
-		log.Debug("Failed to update user", err)
+		log.Debug("Failed to update user: ", err)
 		return res, err
 	}

--- a/server/resolvers/users.go
+++ b/server/resolvers/users.go
@@ -17,7 +17,7 @@ import (
 func UsersResolver(ctx context.Context, params *model.PaginatedInput) (*model.Users, error) {
 	gc, err := utils.GinContextFromContext(ctx)
 	if err != nil {
-		log.Debug("Failed to get GinContext", err)
+		log.Debug("Failed to get GinContext: ", err)
 		return nil, err
 	}

@@ -30,7 +30,7 @@ func UsersResolver(ctx context.Context, params *model.PaginatedInput) (*model.Us

 	res, err := db.Provider.ListUsers(pagination)
 	if err != nil {
-		log.Debug("Failed to get users", err)
+		log.Debug("Failed to get users: ", err)
 		return nil, err
 	}

--- a/server/resolvers/validate_jwt_token.go
+++ b/server/resolvers/validate_jwt_token.go
@@ -24,13 +24,13 @@ import (
 func ValidateJwtTokenResolver(ctx context.Context, params model.ValidateJWTTokenInput) (*model.ValidateJWTTokenResponse, error) {
 	gc, err := utils.GinContextFromContext(ctx)
 	if err != nil {
-		log.Debug("Failed to get GinContext", err)
+		log.Debug("Failed to get GinContext: ", err)
 		return nil, err
 	}

 	tokenType := params.TokenType
 	if tokenType != "access_token" && tokenType != "refresh_token" && tokenType != "id_token" {
-		log.Debug("Invalid token type:", tokenType)
+		log.Debug("Invalid token type: ", tokenType)
 		return nil, errors.New("invalid token type")
 	}

@@ -57,7 +57,7 @@ func ValidateJwtTokenResolver(ctx context.Context, params model.ValidateJWTToken
 	if userID != "" && nonce != "" {
 		claims, err = token.ParseJWTToken(params.Token, hostname, nonce, userID)
 		if err != nil {
-			log.Debug("Failed to parse jwt token", err)
+			log.Debug("Failed to parse jwt token: ", err)
 			return &model.ValidateJWTTokenResponse{
 				IsValid: false,
 			}, nil
@@ -65,7 +65,7 @@ func ValidateJwtTokenResolver(ctx context.Context, params model.ValidateJWTToken
 	} else {
 		claims, err = token.ParseJWTTokenWithoutNonce(params.Token, hostname)
 		if err != nil {
-			log.Debug("Failed to parse jwt token without nonce", err)
+			log.Debug("Failed to parse jwt token without nonce: ", err)
 			return &model.ValidateJWTTokenResponse{
 				IsValid: false,
 			}, nil
@@ -82,7 +82,7 @@ func ValidateJwtTokenResolver(ctx context.Context, params model.ValidateJWTToken
 	if params.Roles != nil && len(params.Roles) > 0 {
 		for _, v := range params.Roles {
 			if !utils.StringSliceContains(claimRoles, v) {
-				log.Debug("Token does not have required role:", v)
+				log.Debug("Token does not have required role: ", v)
 				return nil, fmt.Errorf(`unauthorized`)
 			}
 		}
--- a/server/resolvers/verification_requests.go
+++ b/server/resolvers/verification_requests.go
@@ -17,12 +17,12 @@ import (
 func VerificationRequestsResolver(ctx context.Context, params *model.PaginatedInput) (*model.VerificationRequests, error) {
 	gc, err := utils.GinContextFromContext(ctx)
 	if err != nil {
-		log.Debug("Failed to get GinContext", err)
+		log.Debug("Failed to get GinContext: ", err)
 		return nil, err
 	}

 	if !token.IsSuperAdmin(gc) {
-		log.Debug("Not logged in as super admin.")
+		log.Debug("Not logged in as super admin")
 		return nil, fmt.Errorf("unauthorized")
 	}

@@ -30,7 +30,7 @@ func VerificationRequestsResolver(ctx context.Context, params *model.PaginatedIn

 	res, err := db.Provider.ListVerificationRequests(pagination)
 	if err != nil {
-		log.Debug("Failed to get verification requests", err)
+		log.Debug("Failed to get verification requests: ", err)
 		return nil, err
 	}

--- a/server/resolvers/verify_email.go
+++ b/server/resolvers/verify_email.go
@@ -23,13 +23,13 @@ func VerifyEmailResolver(ctx context.Context, params model.VerifyEmailInput) (*m

 	gc, err := utils.GinContextFromContext(ctx)
 	if err != nil {
-		log.Debug("Failed to get GinContext", err)
+		log.Debug("Failed to get GinContext: ", err)
 		return res, err
 	}

 	verificationRequest, err := db.Provider.GetVerificationRequestByToken(params.Token)
 	if err != nil {
-		log.Debug("Failed to get verification request by token", err)
+		log.Debug("Failed to get verification request by token: ", err)
 		return res, fmt.Errorf(`invalid token: %s`, err.Error())
 	}

@@ -37,7 +37,7 @@ func VerifyEmailResolver(ctx context.Context, params model.VerifyEmailInput) (*m
 	hostname := utils.GetHost(gc)
 	claim, err := token.ParseJWTToken(params.Token, hostname, verificationRequest.Nonce, verificationRequest.Email)
 	if err != nil {
-		log.Debug("Failed to parse token", err)
+		log.Debug("Failed to parse token: ", err)
 		return res, fmt.Errorf(`invalid token: %s`, err.Error())
 	}

@@ -47,7 +47,7 @@ func VerifyEmailResolver(ctx context.Context, params model.VerifyEmailInput) (*m
 	})
 	user, err := db.Provider.GetUserByEmail(email)
 	if err != nil {
-		log.Debug("Failed to get user by email", err)
+		log.Debug("Failed to get user by email: ", err)
 		return res, err
 	}

@@ -56,13 +56,13 @@ func VerifyEmailResolver(ctx context.Context, params model.VerifyEmailInput) (*m
 	user.EmailVerifiedAt = &now
 	user, err = db.Provider.UpdateUser(user)
 	if err != nil {
-		log.Debug("Failed to update user", err)
+		log.Debug("Failed to update user: ", err)
 		return res, err
 	}
 	// delete from verification table
 	err = db.Provider.DeleteVerificationRequest(verificationRequest)
 	if err != nil {
-		log.Debug("Failed to delete verification request", err)
+		log.Debug("Failed to delete verification request: ", err)
 		return res, err
 	}

@@ -70,7 +70,7 @@ func VerifyEmailResolver(ctx context.Context, params model.VerifyEmailInput) (*m
 	scope := []string{"openid", "email", "profile"}
 	authToken, err := token.CreateAuthToken(gc, user, roles, scope)
 	if err != nil {
-		log.Debug("Failed to create auth token", err)
+		log.Debug("Failed to create auth token: ", err)
 		return res, err
 	}