feat: improve logs

Author: tituschewxj

apps/matching-service/handlers/websocket.go

@@ -94,7 +94,7 @@ func readMatchRequest(ws *websocket.Conn) (models.MatchRequest, error) {
 // If user is already removed, then nothing happens.
 // This function is unaffected by the external context.
 func cleanUpUser(username string) {
-	redisClient := servers.GetRedisClient()
+	rdb := servers.GetRedisClient()
 	ctx := context.Background()
 
 	// Obtain lock with retry
@@ -104,13 +104,8 @@ func cleanUpUser(username string) {
 	}
 	defer lock.Release(ctx)
 
-	if err := redisClient.Watch(ctx, func(tx *redis.Tx) error {
-		// Cleanup Redis
-		databases.CleanUpUser(tx, username, ctx)
-		return nil
-	}); err != nil {
-		return
-	}
+	// Cleanup Redis
+	databases.CleanUpUser((*redis.Tx)(rdb.Conn()), username, ctx)
 }
 
 // waitForResult waits for a match result, timeout, or cancellation.

apps/matching-service/processes/performmatches.go

@@ -10,7 +10,6 @@ import (
 	"matching-service/models"
 	pb "matching-service/proto"
 	"matching-service/servers"
-	"time"
 
 	"github.com/redis/go-redis/v9"
 )
@@ -19,6 +18,7 @@ import (
 // until a match is found or no match and the user is enqueued to the queue.
 func PerformMatching(rdb *redis.Client, matchRequest models.MatchRequest, ctx context.Context, errorChan chan error) {
 	currentUsername := matchRequest.Username
+	var matchFound *models.MatchFound
 
 	// Obtain lock with retry
 	lock, err := servers.ObtainRedisLock(ctx)
@@ -39,7 +39,7 @@ func PerformMatching(rdb *redis.Client, matchRequest models.MatchRequest, ctx co
 		defer databases.PrintMatchingQueue(tx, "After Matchmaking", ctx)
 
 		// Find a matching user if any
-		matchFound, err := findMatchingUsers(tx, currentUsername, ctx)
+		matchFound, err = findMatchingUsers(tx, currentUsername, ctx)
 		if err != nil {
 			if errors.Is(err, models.NoMatchFound) {
 				return nil
@@ -48,42 +48,15 @@ func PerformMatching(rdb *redis.Client, matchRequest models.MatchRequest, ctx co
 			return err
 		} else if matchFound != nil && err != models.NoMatchFound {
 			matchedUsername := matchFound.MatchedUser
-			matchedTopics := matchFound.MatchedTopics
-			matchedDifficulties := matchFound.MatchedDifficulties
 
 			// Log down which users got matched
-			log.Printf("Users %s and %s matched on the topics: %v; with difficulties: %v", currentUsername, matchedUsername, matchedTopics, matchedDifficulties)
+			log.Printf("Match %v: Users %s and %s matched on the topics: %v; with difficulties: %v",
+				matchFound.MatchID, currentUsername, matchedUsername,
+				matchFound.MatchedTopics, matchFound.MatchedDifficulties)
 
 			// Clean up redis for this match
 			databases.CleanUpUser(tx, currentUsername, ctx)
 			databases.CleanUpUser(tx, matchedUsername, ctx)
-
-			// Query question service to find a question for the match
-			ctx2, cancel := context.WithTimeout(ctx, time.Second)
-			defer cancel()
-
-			question, err := servers.GetGrpcClient().FindMatchingQuestion(ctx2, &pb.MatchQuestionRequest{
-				MatchedTopics:       matchedTopics,
-				MatchedDifficulties: matchedDifficulties,
-			})
-			if err != nil {
-				log.Fatalf("Could not retrieve question from question-service: %v", err)
-			}
-
-			matchQuestionFound := models.MatchQuestionFound{
-				Type:               "match_found",
-				MatchID:            matchFound.MatchID,
-				User:               matchFound.User,
-				MatchedUser:        matchFound.MatchedUser,
-				MatchedTopics:      matchedTopics,
-				QuestionID:         question.QuestionId,
-				QuestionName:       question.QuestionName,
-				QuestionDifficulty: question.QuestionDifficulty,
-				QuestionTopics:     question.QuestionTopics,
-			}
-
-			publishMatch(tx, ctx, currentUsername, matchedUsername, &matchQuestionFound)
-			publishMatch(tx, ctx, matchedUsername, currentUsername, &matchQuestionFound)
 		}
 
 		return nil
@@ -94,18 +67,61 @@ func PerformMatching(rdb *redis.Client, matchRequest models.MatchRequest, ctx co
 			// transaction failed, no retry
 			println(fmt.Errorf("Transaction execution failed: %v", err))
 		}
+	} else if matchFound != nil {
+		completeMatch((*redis.Tx)(rdb.Conn()), ctx, matchFound)
 	}
 }
 
+// Finds the question and publishes it to complete the matching process.
+func completeMatch(tx *redis.Tx, ctx context.Context, matchFound *models.MatchFound) {
+	matchQuestionFound := queryQuestionService(ctx, matchFound)
+
+	log.Printf("Match %v: Question %v found with topics: %v and difficulty %v",
+		matchFound.MatchID, matchQuestionFound.QuestionID,
+		matchQuestionFound.QuestionTopics, matchQuestionFound.QuestionDifficulty)
+
+	currentUsername := matchFound.User
+	matchedUsername := matchFound.MatchedUser
+
+	publishMatch(tx, ctx, currentUsername, matchedUsername, matchQuestionFound)
+	publishMatch(tx, ctx, matchedUsername, currentUsername, matchQuestionFound)
+}
+
 // Publish a match to the target user's pub/sub channel
 func publishMatch(tx *redis.Tx, ctx context.Context, targetUser string, otherMatchedUser string, matchFound *models.MatchQuestionFound) error {
 	matchFound.User = targetUser
 	matchFound.MatchedUser = otherMatchedUser
+
 	msg, err := json.Marshal(matchFound)
 	if err != nil {
 		log.Fatalf("Could not marshal message: %v", err)
 		return err
 	}
+
 	tx.Publish(ctx, targetUser, msg)
+
 	return nil
 }
+
+// Query question service to find a question for the match
+func queryQuestionService(ctx context.Context, matchFound *models.MatchFound) *models.MatchQuestionFound {
+	question, err := servers.GetGrpcClient().FindMatchingQuestion(ctx, &pb.MatchQuestionRequest{
+		MatchedTopics:       matchFound.MatchedTopics,
+		MatchedDifficulties: matchFound.MatchedDifficulties,
+	})
+	if err != nil {
+		log.Fatalf("Could not retrieve question from question-service: %v", err)
+	}
+
+	return &models.MatchQuestionFound{
+		Type:               "match_question_found",
+		MatchID:            matchFound.MatchID,
+		User:               matchFound.User,
+		MatchedUser:        matchFound.MatchedUser,
+		MatchedTopics:      matchFound.MatchedTopics,
+		QuestionID:         question.QuestionId,
+		QuestionName:       question.QuestionName,
+		QuestionDifficulty: question.QuestionDifficulty,
+		QuestionTopics:     question.QuestionTopics,
+	}
+}

apps/matching-service/servers/grpc.go

@@ -17,6 +17,8 @@ func InitGrpcServer() *grpc.ClientConn {
 	conn, err := grpc.NewClient("localhost:50051", grpc.WithTransportCredentials(insecure.NewCredentials()))
 	if err != nil {
 		log.Fatalf("Did not connect: %v", err)
+	} else {
+		log.Println("Connected to Grpc server at :50051")
 	}
 
 	// Create a new client for the ExampleService

apps/question-service/handlers/findmatchingquestion.go

@@ -2,11 +2,12 @@ package handlers
 
 import (
 	"context"
+	"log"
 	pb "proto/questionmatching"
 )
 
 func (s *GrpcServer) FindMatchingQuestion(ctx context.Context, req *pb.MatchQuestionRequest) (*pb.QuestionFound, error) {
-	// STUB
+	log.Printf("Received find matching question request: %v", req)
 	return &pb.QuestionFound{
 		QuestionId:         1,
 		QuestionName:       "abc",

apps/question-service/handlers/list.go

@@ -1,12 +1,13 @@
 package handlers
 
 import (
-	"cloud.google.com/go/firestore"
 	"encoding/json"
 	"net/http"
 	"question-service/models"
 	"strconv"
 	"strings"
+
+	"cloud.google.com/go/firestore"
 )
 
 var isValidSortField = map[string]bool{

apps/question-service/main.go

@@ -33,8 +33,7 @@ func main() {
 
 	// Initialize Firestore client
 	ctx := context.Background()
-	firebaseCredentialPath := os.Getenv("FIREBASE_CREDENTIAL_PATH")
-	client, err := initFirestore(ctx, firebaseCredentialPath)
+	client, err := initFirestore(ctx)
 	if err != nil {
 		log.Fatalf("Failed to initialize Firestore client: %v", err)
 	}
@@ -57,7 +56,8 @@ func main() {
 }
 
 // initFirestore initializes the Firestore client
-func initFirestore(ctx context.Context, credentialsPath string) (*firestore.Client, error) {
+func initFirestore(ctx context.Context) (*firestore.Client, error) {
+	credentialsPath := os.Getenv("FIREBASE_CREDENTIAL_PATH")
 	opt := option.WithCredentialsFile(credentialsPath)
 	app, err := firebase.NewApp(ctx, nil, opt)
 	if err != nil {