Added extensive logging to problem endpoint.

Author: Thanus-Kumaar

controllers/problem_controller.go

@@ -2,7 +2,6 @@ package controllers
 
 import (
 	"context"
-	"database/sql"
 	"encoding/json"
 	"fmt"
 	"net/http"
@@ -31,119 +30,183 @@ func NewProblemController(problemModule *modules.ProblemModule, logger zerolog.L
 
 // CreateProblemHandler handles POST /api/v1/problems
 func (c *ProblemController) CreateProblemHandler(w http.ResponseWriter, r *http.Request) {
+	c.Logger.Info().Msg("received request to create a new problem")
+
 	ctx, cancel := context.WithTimeout(r.Context(), 10*time.Second)
 	defer cancel()
 
 	user, ok := ctx.Value(middleware.UserContextKey).(*middleware.User)
 	if !ok {
+		c.Logger.Error().Msg("user not found in context for problem creation")
 		http.Error(w, "user not found in context", http.StatusUnauthorized)
 		return
 	}
+	c.Logger.Info().Str("userID", user.ID).Msg("user authorized for problem creation")
 
 	var req models.CreateProblemRequest
 	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
+		c.Logger.Error().Err(err).Msg("invalid request body for problem creation")
 		http.Error(w, "invalid request body", http.StatusBadRequest)
 		return
 	}
+	c.Logger.Debug().
+		Str("title", req.Title).
+		RawJSON("description_json", req.DescriptionJSON).
+		Msg("decoded create problem request body")
+
 	problemStatement, err := c.ProblemModule.CreateProblem(ctx, &req, user.ID)
 	if err != nil {
-		c.Logger.Error().Err(err).Msg("failed to create problem statement")
+		c.Logger.Error().Err(err).
+			Str("userID", user.ID).
+			Str("title", req.Title).
+			Msg("failed to create problem statement via module")
 		http.Error(w, fmt.Sprintf("error creating problem statemnet: %v", err), http.StatusInternalServerError)
 		return
 	}
+
+	c.Logger.Info().Str("problemID", problemStatement.ID.String()).Msg("problem statement created successfully")
 	pkg.WriteJSONResponseWithLogger(w, http.StatusCreated, problemStatement, &c.Logger)
 }
 
 // ListProblemsHandler handles GET /api/v1/problems
 func (c *ProblemController) ListProblemsHandler(w http.ResponseWriter, r *http.Request) {
+	c.Logger.Info().Msg("received request to list problems")
+
 	ctx, cancel := context.WithTimeout(r.Context(), 5*time.Second)
 	defer cancel()
 
 	user, ok := ctx.Value(middleware.UserContextKey).(*middleware.User)
 	if !ok {
+		c.Logger.Error().Msg("user not found in context for listing problems")
 		http.Error(w, "user not found in context", http.StatusUnauthorized)
 		return
 	}
+	c.Logger.Info().Str("userID", user.ID).Msg("user authorized for listing problems")
 
 	problems, err := c.ProblemModule.GetProblemsByUserID(ctx, user.ID)
 	if err != nil {
-		c.Logger.Error().Err(err).Msg("failed to list problems by user id")
+		c.Logger.Error().Err(err).Str("userID", user.ID).Msg("failed to list problems by user id via module")
 		http.Error(w, "failed to retrieve problems", http.StatusInternalServerError)
 		return
 	}
 
-	// If no problems are found, it should return an empty list, not an error.
+	c.Logger.Info().
+		Str("userID", user.ID).
+		Int("problem_count", len(problems)).
+		Msg("successfully listed problems for user")
 	pkg.WriteJSONResponseWithLogger(w, http.StatusOK, problems, &c.Logger)
 }
 
 // GetProblemByIDHandler handles GET /api/v1/problems/{id}
 func (c *ProblemController) GetProblemByIDHandler(w http.ResponseWriter, r *http.Request) {
 	problemID := r.PathValue("id")
+	c.Logger.Info().Str("problemID", problemID).Msg("received request to get problem by ID")
+
 	ctx, cancel := context.WithTimeout(r.Context(), 5*time.Second)
 	defer cancel()
 
 	problem, err := c.ProblemModule.GetProblemByID(ctx, problemID)
 	if err != nil {
-		c.Logger.Error().Err(err).Msg("failed to get problem by id")
-		if err == sql.ErrNoRows {
+		c.Logger.Error().Err(err).Str("problemID", problemID).Msg("failed to get problem by id via module")
+		if err.Error() == "problem not found" { // Matching the error string from problem_module
 			http.Error(w, "problem not found", http.StatusNotFound)
-		} else {
-			http.Error(w, "failed to retrive problem", http.StatusInternalServerError)
+			return
 		}
+		http.Error(w, "failed to retrieve problem", http.StatusInternalServerError)
 		return
 	}
 
+	c.Logger.Info().Str("problemID", problemID).Msg("successfully retrieved problem by ID")
 	pkg.WriteJSONResponseWithLogger(w, http.StatusOK, problem, &c.Logger)
 }
 
 // UpdateProblemByIDHandler handles PUT /api/v1/problems/{id}
 func (c *ProblemController) UpdateProblemByIDHandler(w http.ResponseWriter, r *http.Request) {
 	problemID := r.PathValue("id")
+	c.Logger.Info().Str("problemID", problemID).Msg("received request to update problem by ID")
+
 	ctx, cancel := context.WithTimeout(r.Context(), 5*time.Second)
 	defer cancel()
 
 	user, ok := ctx.Value(middleware.UserContextKey).(*middleware.User)
 	if !ok {
+		c.Logger.Error().Msg("user not found in context for updating problem")
 		http.Error(w, "user not found in context", http.StatusUnauthorized)
 		return
 	}
+	c.Logger.Info().Str("userID", user.ID).Msg("user authorized for updating problem")
 
 	var req models.UpdateProblemRequest
 	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
+		c.Logger.Error().Err(err).Msg("invalid request body for updating problem")
 		http.Error(w, "invalid request body", http.StatusBadRequest)
 		return
 	}
+	c.Logger.Debug().
+		Str("problemID", problemID).
+		Str("userID", user.ID).
+		Str("title_update", req.Title).
+		RawJSON("description_json_update", req.DescriptionJSON).
+		Msg("decoded update problem request body")
 
 	updatedProblem, err := c.ProblemModule.UpdateProblem(ctx, problemID, &req, user.ID)
 	if err != nil {
-		c.Logger.Error().Err(err).Msg("failed to update problem")
+		c.Logger.Error().Err(err).
+			Str("problemID", problemID).
+			Str("userID", user.ID).
+			Msg("failed to update problem via module")
 		// This could be a not found error or an authorization error.
+		if err.Error() == "problem not found" {
+			http.Error(w, "problem not found", http.StatusNotFound)
+			return
+		}
+		if err.Error() == "user not authorized to update this problem" {
+			http.Error(w, "user not authorized", http.StatusForbidden)
+			return
+		}
 		http.Error(w, err.Error(), http.StatusInternalServerError)
 		return
 	}
 
+	c.Logger.Info().Str("problemID", updatedProblem.ID.String()).Msg("successfully updated problem by ID")
 	pkg.WriteJSONResponseWithLogger(w, http.StatusOK, updatedProblem, &c.Logger)
 }
 
 // DeleteProblemByIDHandler handles DELETE /api/v1/problems/{id}
 func (c *ProblemController) DeleteProblemByIDHandler(w http.ResponseWriter, r *http.Request) {
 	problemID := r.PathValue("id")
+	c.Logger.Info().Str("problemID", problemID).Msg("received request to delete problem by ID")
+
 	ctx, cancel := context.WithTimeout(r.Context(), 5*time.Second)
 	defer cancel()
 
 	user, ok := ctx.Value(middleware.UserContextKey).(*middleware.User)
 	if !ok {
+		c.Logger.Error().Msg("user not found in context for deleting problem")
 		http.Error(w, "user not found in context", http.StatusUnauthorized)
 		return
 	}
+	c.Logger.Info().Str("userID", user.ID).Msg("user authorized for deleting problem")
 
 	err := c.ProblemModule.DeleteProblem(ctx, problemID, user.ID)
 	if err != nil {
-		c.Logger.Error().Err(err).Msg("failed to delete problem")
+		c.Logger.Error().Err(err).
+			Str("problemID", problemID).
+			Str("userID", user.ID).
+			Msg("failed to delete problem via module")
 		// This could be a not found error or an authorization error.
+		if err.Error() == "problem not found" {
+			http.Error(w, "problem not found", http.StatusNotFound)
+			return
+		}
+		if err.Error() == "user not authorized to delete this problem" {
+			http.Error(w, "user not authorized", http.StatusForbidden)
+			return
+		}
 		http.Error(w, err.Error(), http.StatusInternalServerError)
 		return
 	}
 
+	c.Logger.Info().Str("problemID", problemID).Msg("successfully deleted problem by ID")
 	w.WriteHeader(http.StatusNoContent)
 }

db/repository/problem_repository.go

@@ -5,6 +5,7 @@ import (
 	"encoding/json"
 
 	"github.com/Thanus-Kumaar/controller_microservice_v2/pkg/models"
+	"github.com/jackc/pgx/v4"
 	"github.com/jackc/pgx/v4/pgxpool"
 	"github.com/rs/zerolog"
 )
@@ -38,6 +39,11 @@ func (r *problemRepository) WithLogger(logger zerolog.Logger) ProblemRepository
 
 // CreateProblem inserts a new problem statement into the database.
 func (r *problemRepository) CreateProblem(ctx context.Context, problem *models.ProblemStatement) (*models.ProblemStatement, error) {
+	r.logger.Info().
+		Str("problemID", problem.ID.String()).
+		Str("title", problem.Title).
+		Msg("attempting to create new problem")
+
 	query := `
 		INSERT INTO problem_statements (id, title, description_json, created_by, created_at)
 		VALUES ($1, $2, $3, $4, $5)
@@ -66,11 +72,17 @@ func (r *problemRepository) CreateProblem(ctx context.Context, problem *models.P
 		return nil, err
 	}
 
+	r.logger.Info().
+		Str("problemID", createdProblem.ID.String()).
+		Msg("successfully created new problem")
+
 	return &createdProblem, nil
 }
 
 // GetProblemByID retrieves a problem statement from the database by its ID.
 func (r *problemRepository) GetProblemByID(ctx context.Context, problemID string) (*models.ProblemStatement, error) {
+	r.logger.Info().Str("problemID", problemID).Msg("attempting to get problem by ID")
+
 	query := `
 		SELECT id, title, description_json, created_by, created_at
 		FROM problem_statements
@@ -86,15 +98,22 @@ func (r *problemRepository) GetProblemByID(ctx context.Context, problemID string
 		&problem.CreatedBy,
 		&problem.CreatedAt,
 	); err != nil {
+		if err == pgx.ErrNoRows {
+			r.logger.Warn().Str("problemID", problemID).Msg("problem not found")
+			return nil, nil // Or return a custom error like models.ErrNotFound
+		}
 		r.logger.Error().Err(err).Str("problemID", problemID).Msg("failed to get problem by ID or scan row")
 		return nil, err
 	}
 
+	r.logger.Info().Str("problemID", problemID).Msg("successfully retrieved problem by ID")
 	return &problem, nil
 }
 
 // GetProblemsByUserID retrieves all problem statements for a given user.
 func (r *problemRepository) GetProblemsByUserID(ctx context.Context, userID string) ([]models.ProblemStatement, error) {
+	r.logger.Info().Str("userID", userID).Msg("attempting to get problems by user ID")
+
 	query := `
 		SELECT id, title, description_json, created_by, created_at
 		FROM problem_statements
@@ -128,11 +147,21 @@ func (r *problemRepository) GetProblemsByUserID(ctx context.Context, userID stri
 		return nil, err
 	}
 
+	r.logger.Info().
+		Str("userID", userID).
+		Int("problem_count", len(problems)).
+		Msg("successfully retrieved problems by user ID")
+
 	return problems, nil
 }
 
 // UpdateProblem updates a problem statement in the database.
 func (r *problemRepository) UpdateProblem(ctx context.Context, problemID string, title string, description json.RawMessage) (*models.ProblemStatement, error) {
+	r.logger.Info().
+		Str("problemID", problemID).
+		Str("title", title).
+		Msg("attempting to update problem")
+
 	query := `
 		UPDATE problem_statements
 		SET title = $2, description_json = $3
@@ -153,15 +182,24 @@ func (r *problemRepository) UpdateProblem(ctx context.Context, problemID string,
 		return nil, err
 	}
 
+	r.logger.Info().
+		Str("problemID", updatedProblem.ID.String()).
+		Msg("successfully updated problem")
+
 	return &updatedProblem, nil
 }
 
 // DeleteProblem deletes a problem statement from the database.
 func (r *problemRepository) DeleteProblem(ctx context.Context, problemID string) error {
+	r.logger.Info().Str("problemID", problemID).Msg("attempting to delete problem")
+
 	query := `DELETE FROM problem_statements WHERE id = $1;`
 	_, err := r.db.Exec(ctx, query, problemID)
 	if err != nil {
 		r.logger.Error().Err(err).Str("problemID", problemID).Msg("failed to delete problem")
+		return err
 	}
-	return err
+
+	r.logger.Info().Str("problemID", problemID).Msg("successfully deleted problem")
+	return nil
 }