use logg

common/vouchers.go

@@ -135,7 +135,7 @@ func GetTemporaryVoucherData(ctx context.Context, store DataStore, sessionId str
 	return data, nil
 }
 
-// UpdateVoucherData sets the active voucher data and clears the temporary voucher data in the DataStore.
+// UpdateVoucherData sets the active voucher data in the DataStore.
 func UpdateVoucherData(ctx context.Context, store DataStore, sessionId string, data *dataserviceapi.TokenHoldings) error {
 	logg.TraceCtxf(ctx, "dtal", "data", data)
 	// Active voucher data entries

internal/handlers/ussd/menuhandler.go

@@ -4,7 +4,6 @@ import (
 	"bytes"
 	"context"
 	"fmt"
-	"log"
 	"path"
 	"regexp"
 	"strconv"
@@ -162,7 +161,7 @@ func (h *Handlers) SetLanguage(ctx context.Context, sym string, input []byte) (r
 
 	languageSetFlag, err := h.flagManager.GetFlag("flag_language_set")
 	if err != nil {
-		log.Printf("Error: %s", err)
+		logg.ErrorCtxf(ctx, "Error setting the languageSetFlag", "error", err)
 		return res, err
 	}
 	res.FlagSet = append(res.FlagSet, languageSetFlag)
@@ -216,10 +215,10 @@ func (h *Handlers) CreateAccount(ctx context.Context, sym string, input []byte)
 	_, err = store.ReadEntry(ctx, sessionId, common.DATA_ACCOUNT_CREATED)
 	if err != nil {
 		if db.IsNotFound(err) {
-			logg.Printf(logging.LVL_INFO, "Creating an account because it doesn't exist")
+			logg.InfoCtxf(ctx, "Creating an account because it doesn't exist")
 			err = h.createAccountNoExist(ctx, sessionId, &res)
 			if err != nil {
-				log.Printf("Error: %s", err)
+				logg.ErrorCtxf(ctx, "failed on createAccountNoExist", "error", err)
 				return res, err
 			}
 		}
@@ -238,13 +237,12 @@ func (h *Handlers) CheckPinMisMatch(ctx context.Context, sym string, input []byt
 	store := h.userdataStore
 	blockedNumber, err := store.ReadEntry(ctx, sessionId, common.DATA_BLOCKED_NUMBER)
 	if err != nil {
-		log.Printf("Error: %s", err)
+		logg.ErrorCtxf(ctx, "failed to read blockedNumber entry with", "key", common.DATA_BLOCKED_NUMBER, "error", err)
 		return res, err
 	}
 	temporaryPin, err := store.ReadEntry(ctx, string(blockedNumber), common.DATA_TEMPORARY_VALUE)
 	if err != nil {
-
+		logg.ErrorCtxf(ctx, "failed to read temporaryPin entry with", "key", common.DATA_TEMPORARY_VALUE, "error", err)
-		log.Printf("Error: %s", err)
 		return res, err
 	}
 	if bytes.Equal(temporaryPin, input) {
@@ -297,8 +295,7 @@ func (h *Handlers) SaveTemporaryPin(ctx context.Context, sym string, input []byt
 	store := h.userdataStore
 	err = store.WriteEntry(ctx, sessionId, common.DATA_TEMPORARY_VALUE, []byte(accountPIN))
 	if err != nil {
-		logg.ErrorCtxf(ctx, "failed to write entry with", "key", common.DATA_TEMPORARY_VALUE, "value", accountPIN, "error", err)
+		logg.ErrorCtxf(ctx, "failed to write temporaryAccountPIN entry with", "key", common.DATA_TEMPORARY_VALUE, "value", accountPIN, "error", err)
-		log.Printf("Error: %s", err)
 		return res, err
 	}
 
@@ -316,16 +313,14 @@ func (h *Handlers) SaveOthersTemporaryPin(ctx context.Context, sym string, input
 	}
 	temporaryPin := string(input)
 	blockedNumber, err := store.ReadEntry(ctx, sessionId, common.DATA_BLOCKED_NUMBER)
-
 	if err != nil {
-		logg.ErrorCtxf(ctx, "failed to read entry with", "key", common.DATA_BLOCKED_NUMBER, "error", err)
+		logg.ErrorCtxf(ctx, "failed to read blockedNumber entry with", "key", common.DATA_BLOCKED_NUMBER, "error", err)
-		log.Printf("Error: %s", err)
 		return res, err
 	}
+
 	err = store.WriteEntry(ctx, string(blockedNumber), common.DATA_TEMPORARY_VALUE, []byte(temporaryPin))
 	if err != nil {
-		logg.ErrorCtxf(ctx, "failed to write entry with", "key", common.DATA_TEMPORARY_VALUE, "value", temporaryPin, "error", err)
+		logg.ErrorCtxf(ctx, "failed to write temporaryPin entry with", "key", common.DATA_TEMPORARY_VALUE, "value", temporaryPin, "error", err)
-		log.Printf("Error: %s", err)
 		return res, err
 	}
 
@@ -343,8 +338,7 @@ func (h *Handlers) ConfirmPinChange(ctx context.Context, sym string, input []byt
 	store := h.userdataStore
 	temporaryPin, err := store.ReadEntry(ctx, sessionId, common.DATA_TEMPORARY_VALUE)
 	if err != nil {
-		logg.ErrorCtxf(ctx, "failed to read entry with", "key", common.DATA_TEMPORARY_VALUE, "error", err)
+		logg.ErrorCtxf(ctx, "failed to read temporaryPin entry with", "key", common.DATA_TEMPORARY_VALUE, "error", err)
-		log.Printf("Error: %s", err)
 		return res, err
 	}
 	if bytes.Equal(temporaryPin, input) {
@@ -354,8 +348,7 @@ func (h *Handlers) ConfirmPinChange(ctx context.Context, sym string, input []byt
 	}
 	err = store.WriteEntry(ctx, sessionId, common.DATA_ACCOUNT_PIN, []byte(temporaryPin))
 	if err != nil {
-		logg.ErrorCtxf(ctx, "failed to write entry with", "key", common.DATA_ACCOUNT_PIN, "value", temporaryPin, "error", err)
+		logg.ErrorCtxf(ctx, "failed to write temporaryPin entry with", "key", common.DATA_ACCOUNT_PIN, "value", temporaryPin, "error", err)
-		log.Printf("Error: %s", err)
 		return res, err
 	}
 	return res, nil
@@ -378,7 +371,7 @@ func (h *Handlers) VerifyCreatePin(ctx context.Context, sym string, input []byte
 	store := h.userdataStore
 	temporaryPin, err := store.ReadEntry(ctx, sessionId, common.DATA_TEMPORARY_VALUE)
 	if err != nil {
-		log.Printf("Error: %s", err)
+		logg.ErrorCtxf(ctx, "failed to read temporaryPin entry with", "key", common.DATA_TEMPORARY_VALUE, "error", err)
 		return res, err
 	}
 	if bytes.Equal(input, temporaryPin) {
@@ -391,8 +384,7 @@ func (h *Handlers) VerifyCreatePin(ctx context.Context, sym string, input []byte
 
 	err = store.WriteEntry(ctx, sessionId, common.DATA_ACCOUNT_PIN, []byte(temporaryPin))
 	if err != nil {
-		logg.ErrorCtxf(ctx, "failed to write entry with", "key", common.DATA_ACCOUNT_PIN, "value", temporaryPin, "error", err)
+		logg.ErrorCtxf(ctx, "failed to write temporaryPin entry with", "key", common.DATA_ACCOUNT_PIN, "value", temporaryPin, "error", err)
-		log.Printf("Error: %s", err)
 		return res, err
 	}
 
@@ -425,15 +417,13 @@ func (h *Handlers) SaveFirstname(ctx context.Context, sym string, input []byte)
 		temporaryFirstName, _ := store.ReadEntry(ctx, sessionId, common.DATA_TEMPORARY_VALUE)
 		err = store.WriteEntry(ctx, sessionId, common.DATA_FIRST_NAME, []byte(temporaryFirstName))
 		if err != nil {
-			logg.ErrorCtxf(ctx, "failed to write entry with", "key", common.DATA_FIRST_NAME, "value", temporaryFirstName, "error", err)
+			logg.ErrorCtxf(ctx, "failed to write firstName entry with", "key", common.DATA_FIRST_NAME, "value", temporaryFirstName, "error", err)
-			log.Printf("Error: %s", err)
 			return res, err
 		}
 	} else {
 		err = store.WriteEntry(ctx, sessionId, common.DATA_TEMPORARY_VALUE, []byte(firstName))
 		if err != nil {
-			logg.ErrorCtxf(ctx, "failed to write entry with", "key", common.DATA_TEMPORARY_VALUE, "value", firstName, "error", err)
+			logg.ErrorCtxf(ctx, "failed to write temporaryFirstName entry with", "key", common.DATA_TEMPORARY_VALUE, "value", firstName, "error", err)
-			log.Printf("Error: %s", err)
 			return res, err
 		}
 	}
@@ -460,16 +450,17 @@ func (h *Handlers) SaveFamilyname(ctx context.Context, sym string, input []byte)
 		temporaryFamilyName, _ := store.ReadEntry(ctx, sessionId, common.DATA_TEMPORARY_VALUE)
 		err = store.WriteEntry(ctx, sessionId, common.DATA_FAMILY_NAME, []byte(temporaryFamilyName))
 		if err != nil {
-			log.Printf("Error: %s", err)
+			logg.ErrorCtxf(ctx, "failed to write familyName entry with", "key", common.DATA_FAMILY_NAME, "value", temporaryFamilyName, "error", err)
 			return res, err
 		}
 	} else {
 		err = store.WriteEntry(ctx, sessionId, common.DATA_TEMPORARY_VALUE, []byte(familyName))
 		if err != nil {
-			log.Printf("Error: %s", err)
+			logg.ErrorCtxf(ctx, "failed to write temporaryFamilyName entry with", "key", common.DATA_TEMPORARY_VALUE, "value", familyName, "error", err)
 			return res, err
 		}
 	}
+
 	return res, nil
 }
 
@@ -490,15 +481,13 @@ func (h *Handlers) SaveYob(ctx context.Context, sym string, input []byte) (resou
 		temporaryYob, _ := store.ReadEntry(ctx, sessionId, common.DATA_TEMPORARY_VALUE)
 		err = store.WriteEntry(ctx, sessionId, common.DATA_YOB, []byte(temporaryYob))
 		if err != nil {
-			logg.ErrorCtxf(ctx, "failed to write entry with", "key", common.DATA_TEMPORARY_VALUE, "value", temporaryYob, "error", err)
+			logg.ErrorCtxf(ctx, "failed to write yob entry with", "key", common.DATA_TEMPORARY_VALUE, "value", temporaryYob, "error", err)
-			log.Printf("Error: %s", err)
 			return res, err
 		}
 	} else {
 		err = store.WriteEntry(ctx, sessionId, common.DATA_TEMPORARY_VALUE, []byte(yob))
 		if err != nil {
-			logg.ErrorCtxf(ctx, "failed to write entry with", "key", common.DATA_TEMPORARY_VALUE, "value", yob, "error", err)
+			logg.ErrorCtxf(ctx, "failed to write temporaryYob entry with", "key", common.DATA_TEMPORARY_VALUE, "value", yob, "error", err)
-			log.Printf("Error: %s", err)
 			return res, err
 		}
 	}
@@ -524,15 +513,13 @@ func (h *Handlers) SaveLocation(ctx context.Context, sym string, input []byte) (
 		temporaryLocation, _ := store.ReadEntry(ctx, sessionId, common.DATA_TEMPORARY_VALUE)
 		err = store.WriteEntry(ctx, sessionId, common.DATA_LOCATION, []byte(temporaryLocation))
 		if err != nil {
-			logg.ErrorCtxf(ctx, "failed to write entry with", "key", common.DATA_LOCATION, "value", temporaryLocation, "error", err)
+			logg.ErrorCtxf(ctx, "failed to write location entry with", "key", common.DATA_LOCATION, "value", temporaryLocation, "error", err)
-			log.Printf("Error: %s", err)
 			return res, err
 		}
 	} else {
 		err = store.WriteEntry(ctx, sessionId, common.DATA_TEMPORARY_VALUE, []byte(location))
 		if err != nil {
-			logg.ErrorCtxf(ctx, "failed to write entry with", "key", common.DATA_TEMPORARY_VALUE, "value", location, "error", err)
+			logg.ErrorCtxf(ctx, "failed to write temporaryLocation entry with", "key", common.DATA_TEMPORARY_VALUE, "value", location, "error", err)
-			log.Printf("Error: %s", err)
 			return res, err
 		}
 	}
@@ -558,15 +545,13 @@ func (h *Handlers) SaveGender(ctx context.Context, sym string, input []byte) (re
 		temporaryGender, _ := store.ReadEntry(ctx, sessionId, common.DATA_TEMPORARY_VALUE)
 		err = store.WriteEntry(ctx, sessionId, common.DATA_GENDER, []byte(temporaryGender))
 		if err != nil {
-			logg.ErrorCtxf(ctx, "failed to write entry with", "key", common.DATA_GENDER, "value", gender, "error", err)
+			logg.ErrorCtxf(ctx, "failed to write gender entry with", "key", common.DATA_GENDER, "value", gender, "error", err)
-			log.Printf("Error: %s", err)
 			return res, err
 		}
 	} else {
 		err = store.WriteEntry(ctx, sessionId, common.DATA_TEMPORARY_VALUE, []byte(gender))
 		if err != nil {
-			logg.ErrorCtxf(ctx, "failed to write entry with", "key", common.DATA_TEMPORARY_VALUE, "value", gender, "error", err)
+			logg.ErrorCtxf(ctx, "failed to write temporaryGender entry with", "key", common.DATA_TEMPORARY_VALUE, "value", gender, "error", err)
-			log.Printf("Error: %s", err)
 			return res, err
 		}
 	}
@@ -593,15 +578,13 @@ func (h *Handlers) SaveOfferings(ctx context.Context, sym string, input []byte)
 		temporaryOfferings, _ := store.ReadEntry(ctx, sessionId, common.DATA_TEMPORARY_VALUE)
 		err = store.WriteEntry(ctx, sessionId, common.DATA_OFFERINGS, []byte(temporaryOfferings))
 		if err != nil {
-			logg.ErrorCtxf(ctx, "failed to write entry with", "key", common.DATA_TEMPORARY_VALUE, "value", offerings, "error", err)
+			logg.ErrorCtxf(ctx, "failed to write offerings entry with", "key", common.DATA_TEMPORARY_VALUE, "value", offerings, "error", err)
-			log.Printf("Error: %s", err)
 			return res, err
 		}
 	} else {
 		err = store.WriteEntry(ctx, sessionId, common.DATA_TEMPORARY_VALUE, []byte(offerings))
 		if err != nil {
-			logg.ErrorCtxf(ctx, "failed to write entry with", "key", common.DATA_TEMPORARY_VALUE, "value", offerings, "error", err)
+			logg.ErrorCtxf(ctx, "failed to write temporaryOfferings entry with", "key", common.DATA_TEMPORARY_VALUE, "value", offerings, "error", err)
-			log.Printf("Error: %s", err)
 			return res, err
 		}
 	}
@@ -612,9 +595,7 @@ func (h *Handlers) SaveOfferings(ctx context.Context, sym string, input []byte)
 // ResetAllowUpdate resets the allowupdate flag that allows a user to update  profile data.
 func (h *Handlers) ResetAllowUpdate(ctx context.Context, sym string, input []byte) (resource.Result, error) {
 	var res resource.Result
-
 	flag_allow_update, _ := h.flagManager.GetFlag("flag_allow_update")
-
 	res.FlagReset = append(res.FlagReset, flag_allow_update)
 	return res, nil
 }
@@ -631,7 +612,6 @@ func (h *Handlers) ResetValidPin(ctx context.Context, sym string, input []byte)
 func (h *Handlers) ResetAccountAuthorized(ctx context.Context, sym string, input []byte) (resource.Result, error) {
 	var res resource.Result
 	flag_account_authorized, _ := h.flagManager.GetFlag("flag_account_authorized")
-
 	res.FlagReset = append(res.FlagReset, flag_account_authorized)
 	return res, nil
 }
@@ -667,7 +647,7 @@ func (h *Handlers) Authorize(ctx context.Context, sym string, input []byte) (res
 	store := h.userdataStore
 	AccountPin, err := store.ReadEntry(ctx, sessionId, common.DATA_ACCOUNT_PIN)
 	if err != nil {
-		log.Printf("Error: %s", err)
+		logg.ErrorCtxf(ctx, "failed to read AccountPin entry with", "key", common.DATA_ACCOUNT_PIN, "error", err)
 		return res, err
 	}
 	if len(input) == 4 {
@@ -715,21 +695,19 @@ func (h *Handlers) CheckAccountStatus(ctx context.Context, sym string, input []b
 	store := h.userdataStore
 	publicKey, err := store.ReadEntry(ctx, sessionId, common.DATA_PUBLIC_KEY)
 	if err != nil {
-		log.Printf("Error: %s", err)
+		logg.ErrorCtxf(ctx, "failed to read publicKey entry with", "key", common.DATA_PUBLIC_KEY, "error", err)
 		return res, err
 	}
-	r, err := h.accountService.TrackAccountStatus(ctx, string(publicKey))
 
+	r, err := h.accountService.TrackAccountStatus(ctx, string(publicKey))
 	if err != nil {
 		res.FlagSet = append(res.FlagSet, flag_api_error)
-		log.Printf("Error: %s", err)
+		logg.ErrorCtxf(ctx, "failed on TrackAccountStatus", err)
 		return res, err
 	}
+
 	res.FlagReset = append(res.FlagReset, flag_api_error)
-	if !ok {
+
-		log.Printf("Error: %s", err)
-		return res, err
-	}
 	if r.Active {
 		res.FlagSet = append(res.FlagSet, flag_account_success)
 		res.FlagReset = append(res.FlagReset, flag_account_pending)
@@ -737,6 +715,7 @@ func (h *Handlers) CheckAccountStatus(ctx context.Context, sym string, input []b
 		res.FlagReset = append(res.FlagReset, flag_account_success)
 		res.FlagSet = append(res.FlagSet, flag_account_pending)
 	}
+
 	return res, nil
 }
 
@@ -828,13 +807,13 @@ func (h *Handlers) CheckBalance(ctx context.Context, sym string, input []byte) (
 			return res, nil
 		}
 
-		log.Printf("Error: %s", err)
+		logg.ErrorCtxf(ctx, "failed to read activeSym entry with", "key", common.DATA_ACTIVE_SYM, "error", err)
 		return res, err
 	}
 
 	activeBal, err := store.ReadEntry(ctx, sessionId, common.DATA_ACTIVE_BAL)
 	if err != nil {
-		log.Printf("Error: %s", err)
+		logg.ErrorCtxf(ctx, "failed to read activeBal entry with", "key", common.DATA_ACTIVE_BAL, "error", err)
 		return res, err
 	}
 
@@ -858,7 +837,7 @@ func (h *Handlers) FetchCustodialBalances(ctx context.Context, sym string, input
 	store := h.userdataStore
 	publicKey, err := store.ReadEntry(ctx, sessionId, common.DATA_PUBLIC_KEY)
 	if err != nil {
-		log.Printf("Error: %s", err)
+		logg.ErrorCtxf(ctx, "failed to read publicKey entry with", "key", common.DATA_PUBLIC_KEY, "error", err)
 		return res, err
 	}
 
@@ -891,18 +870,19 @@ func (h *Handlers) ResetOthersPin(ctx context.Context, sym string, input []byte)
 	}
 	blockedPhonenumber, err := store.ReadEntry(ctx, sessionId, common.DATA_BLOCKED_NUMBER)
 	if err != nil {
-		log.Printf("Error: %s", err)
+		logg.ErrorCtxf(ctx, "failed to read blockedPhonenumber entry with", "key", common.DATA_BLOCKED_NUMBER, "error", err)
 		return res, err
 	}
 	temporaryPin, err := store.ReadEntry(ctx, string(blockedPhonenumber), common.DATA_TEMPORARY_VALUE)
 	if err != nil {
-		log.Printf("Error: %s", err)
+		logg.ErrorCtxf(ctx, "failed to read temporaryPin entry with", "key", common.DATA_TEMPORARY_VALUE, "error", err)
 		return res, err
 	}
 	err = store.WriteEntry(ctx, string(blockedPhonenumber), common.DATA_ACCOUNT_PIN, []byte(temporaryPin))
 	if err != nil {
 		return res, nil
 	}
+
 	return res, nil
 }
 
@@ -931,11 +911,11 @@ func (h *Handlers) ValidateBlockedNumber(ctx context.Context, sym string, input
 	}
 	if err != nil {
 		if db.IsNotFound(err) {
-			logg.Printf(logging.LVL_INFO, "Invalid or unregistered number")
+			logg.InfoCtxf(ctx, "Invalid or unregistered number")
 			res.FlagSet = append(res.FlagSet, flag_unregistered_number)
 			return res, nil
 		} else {
-			log.Printf("Error: %s", err)
+			logg.ErrorCtxf(ctx, "Error on ValidateBlockedNumber", "error", err)
 			return res, err
 		}
 	}
@@ -1043,7 +1023,7 @@ func (h *Handlers) MaxAmount(ctx context.Context, sym string, input []byte) (res
 
 	activeBal, err := store.ReadEntry(ctx, sessionId, common.DATA_ACTIVE_BAL)
 	if err != nil {
-		log.Printf("Error: %s", err)
+		logg.ErrorCtxf(ctx, "failed to read activeBal entry with", "key", common.DATA_ACTIVE_BAL, "error", err)
 		return res, err
 	}
 
@@ -1069,12 +1049,12 @@ func (h *Handlers) ValidateAmount(ctx context.Context, sym string, input []byte)
 	// retrieve the active balance
 	activeBal, err := store.ReadEntry(ctx, sessionId, common.DATA_ACTIVE_BAL)
 	if err != nil {
-		log.Printf("Error: %s", err)
+		logg.ErrorCtxf(ctx, "failed to read activeBal entry with", "key", common.DATA_ACTIVE_BAL, "error", err)
 		return res, err
 	}
 	balanceValue, err = strconv.ParseFloat(string(activeBal), 64)
 	if err != nil {
-		log.Printf("Error: %s", err)
+		logg.ErrorCtxf(ctx, "Failed to convert the activeBal to a float", "error", err)
 		return res, err
 	}
 
@@ -1097,11 +1077,11 @@ func (h *Handlers) ValidateAmount(ctx context.Context, sym string, input []byte)
 	formattedAmount := fmt.Sprintf("%.2f", inputAmount)
 	err = store.WriteEntry(ctx, sessionId, common.DATA_AMOUNT, []byte(formattedAmount))
 	if err != nil {
-		log.Printf("Error: %s", err)
+		logg.ErrorCtxf(ctx, "failed to write amount entry with", "key", common.DATA_AMOUNT, "value", formattedAmount, "error", err)
 		return res, err
 	}
 
-	res.Content = fmt.Sprintf("%s", formattedAmount)
+	res.Content = formattedAmount
 	return res, nil
 }
 
@@ -1164,7 +1144,7 @@ func (h *Handlers) GetAmount(ctx context.Context, sym string, input []byte) (res
 	// retrieve the active symbol
 	activeSym, err := store.ReadEntry(ctx, sessionId, common.DATA_ACTIVE_SYM)
 	if err != nil {
-		log.Printf("Error: %s", err)
+		logg.ErrorCtxf(ctx, "failed to read activeSym entry with", "key", common.DATA_ACTIVE_SYM, "error", err)
 		return res, err
 	}
 
@@ -1202,7 +1182,7 @@ func (h *Handlers) InitiateTransaction(ctx context.Context, sym string, input []
 
 	account_authorized_flag, err := h.flagManager.GetFlag("flag_account_authorized")
 	if err != nil {
-		log.Printf("Error: %s", err)
+		logg.ErrorCtxf(ctx, "Failed to set the flag_account_authorized", "error", err)
 		return res, err
 	}
 
@@ -1305,7 +1285,7 @@ func (h *Handlers) SetDefaultVoucher(ctx context.Context, sym string, input []by
 		if db.IsNotFound(err) {
 			publicKey, err := store.ReadEntry(ctx, sessionId, common.DATA_PUBLIC_KEY)
 			if err != nil {
-				log.Printf("Error: %s", err)
+				logg.ErrorCtxf(ctx, "failed to read publicKey entry with", "key", common.DATA_PUBLIC_KEY, "error", err)
 				return res, err
 			}
 
@@ -1330,20 +1310,20 @@ func (h *Handlers) SetDefaultVoucher(ctx context.Context, sym string, input []by
 			// set the active symbol
 			err = store.WriteEntry(ctx, sessionId, common.DATA_ACTIVE_SYM, []byte(defaultSym))
 			if err != nil {
-				log.Printf("Error: %s", err)
+				logg.ErrorCtxf(ctx, "failed to write defaultSym entry with", "key", common.DATA_ACTIVE_SYM, "value", defaultSym, "error", err)
 				return res, err
 			}
 			// set the active balance
 			err = store.WriteEntry(ctx, sessionId, common.DATA_ACTIVE_BAL, []byte(defaultBal))
 			if err != nil {
-				log.Printf("Error: %s", err)
+				logg.ErrorCtxf(ctx, "failed to write defaultBal entry with", "key", common.DATA_ACTIVE_BAL, "value", defaultBal, "error", err)
 				return res, err
 			}
 
 			return res, nil
 		}
 
-		log.Printf("Error: %s", err)
+		logg.ErrorCtxf(ctx, "failed to read activeSym entry with", "key", common.DATA_ACTIVE_SYM, "error", err)
 		return res, err
 	}
 
@@ -1364,7 +1344,8 @@ func (h *Handlers) CheckVouchers(ctx context.Context, sym string, input []byte)
 	store := h.userdataStore
 	publicKey, err := store.ReadEntry(ctx, sessionId, common.DATA_PUBLIC_KEY)
 	if err != nil {
-		return res, nil
+		logg.ErrorCtxf(ctx, "failed to read publicKey entry with", "key", common.DATA_PUBLIC_KEY, "error", err)
+		return res, err
 	}
 
 	// Fetch vouchers from the API using the public key
@@ -1399,7 +1380,7 @@ func (h *Handlers) GetVoucherList(ctx context.Context, sym string, input []byte)
 	// Read vouchers from the store
 	voucherData, err := h.prefixDb.Get(ctx, []byte("sym"))
 	if err != nil {
-		log.Printf("Error: %s", err)
+		logg.ErrorCtxf(ctx, "Failed to read the voucherData from prefixDb", "error", err)
 		return res, err
 	}
 
@@ -1435,7 +1416,7 @@ func (h *Handlers) ViewVoucher(ctx context.Context, sym string, input []byte) (r
 	}
 
 	if err := common.StoreTemporaryVoucher(ctx, h.userdataStore, sessionId, metadata); err != nil {
-		log.Printf("Error: %s", err)
+		logg.ErrorCtxf(ctx, "failed on StoreTemporaryVoucher", "error", err)
 		return res, err
 	}
 
@@ -1457,13 +1438,13 @@ func (h *Handlers) SetVoucher(ctx context.Context, sym string, input []byte) (re
 	// Get temporary data
 	tempData, err := common.GetTemporaryVoucherData(ctx, h.userdataStore, sessionId)
 	if err != nil {
-		log.Printf("Error: %s", err)
+		logg.ErrorCtxf(ctx, "failed on GetTemporaryVoucherData", "error", err)
 		return res, err
 	}
 
 	// Set as active and clear temporary data
 	if err := common.UpdateVoucherData(ctx, h.userdataStore, sessionId, tempData); err != nil {
-		log.Printf("Error: %s", err)
+		logg.ErrorCtxf(ctx, "failed on UpdateVoucherData", "error", err)
 		return res, err
 	}