fix/add logging

cmd/coursesense/main.go

@@ -53,7 +53,7 @@ func main() {
 	trigger := trigger.NewTrigger(webadvisorService, repository, emailNotifier)
 
 	go func() {
-		log.Info().Msgf("starting trigger ticker: polling every %d seconds", cfg.PollIntervalSecs)
+		log.Info().Msgf("starting poll ticker: polling every %d seconds", cfg.PollIntervalSecs)
 		ticker := time.NewTicker(time.Second * time.Duration(cfg.PollIntervalSecs))
 
 		for {

notifier/noop.go

@@ -4,6 +4,7 @@ import (
 	"context"
 
 	coursesense "github.com/jacobmichels/Course-Sense-Go"
+	"github.com/rs/zerolog/log"
 )
 
 var _ coursesense.Notifier = Noop{}
@@ -16,5 +17,6 @@ func NewNoop() Noop {
 }
 
 func (n Noop) Notify(ctx context.Context, section coursesense.Section, watchers ...coursesense.Watcher) error {
+	log.Info().Str("section", section.String()).Int("watcher_count", len(watchers)).Msg("noop notifier called")
 	return nil
 }

notifier/smtp.go

@@ -45,7 +45,7 @@ Thanks for using Course Sense.`, watcher.Email, section.Course.Department, secti
 		if err != nil {
 			return fmt.Errorf("failed to notify %s: %w", watcher.Email, err)
 		}
-		log.Info().Msg("Notification email sent")
+		log.Info().Msgf("Notification email sent to %s", watcher)
 	}
 
 	return nil

register/register.go

@@ -12,11 +12,11 @@ var _ coursesense.RegistrationService = Register{}
 
 type Register struct {
 	sectionService coursesense.SectionService
-	watcherService coursesense.Repository
+	repository     coursesense.Repository
 }
 
-func NewRegister(s coursesense.SectionService, w coursesense.Repository) Register {
-	return Register{s, w}
+func NewRegister(s coursesense.SectionService, r coursesense.Repository) Register {
+	return Register{s, r}
 }
 
 func (r Register) Register(ctx context.Context, section coursesense.Section, watcher coursesense.Watcher) error {
@@ -33,7 +33,7 @@ func (r Register) Register(ctx context.Context, section coursesense.Section, wat
 		return fmt.Errorf("section %s does not exist", section)
 	}
 
-	if err := r.watcherService.AddWatcher(ctx, section, watcher); err != nil {
+	if err := r.repository.AddWatcher(ctx, section, watcher); err != nil {
 		return fmt.Errorf("failed to persist %s to %s: %w", watcher, section, err)
 	}
 

repository/factory.go

@@ -12,10 +12,10 @@ import (
 
 func New(ctx context.Context, cfg config.Database) (coursesense.Repository, error) {
 	if cfg.Type == "firestore" {
-		log.Info().Msg("creating firestore repository")
+		log.Info().Msg("using firestore repository")
 		return newFirestoreRepository(ctx, cfg.Firestore)
 	} else if cfg.Type == "sqlite" {
-		log.Info().Msg("creating sqlite repository")
+		log.Info().Msg("using sqlite repository")
 		return newSQLiteRepository(ctx, cfg.SQLite)
 	} else {
 		return nil, errors.New("invalid database type")

server/server.go

@@ -61,7 +61,7 @@ func (s Server) pingHandler() httprouter.Handle {
 		log.Info().Msg("Ping request received")
 
 		if _, err := w.Write([]byte("OK")); err != nil {
-			log.Info().Msgf("Error writing ping response: %s", err)
+			log.Error().Msgf("Error writing ping response: %s", err)
 		}
 	}
 }
@@ -86,26 +86,26 @@ func (s Server) registerHandler() httprouter.Handle {
 
 		var req RegisterRequest
 		if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
-			log.Info().Msgf("error decoding register request: %s", err)
+			log.Error().Msgf("error decoding register request: %s", err)
 			http.Error(w, "Failed to parse request", http.StatusBadRequest)
 			return
 		}
 
 		if err := req.Valid(); err != nil {
-			log.Info().Msgf("register request invalid: %s", err)
+			log.Error().Msgf("register request invalid: %s", err)
 			http.Error(w, "Invalid request body", http.StatusBadRequest)
 			return
 		}
 
 		if err := s.registrationService.Register(r.Context(), req.Section, req.Watcher); err != nil {
-			log.Info().Msgf("registration failed: %s", err)
+			log.Error().Msgf("registration failed: %s", err)
 			http.Error(w, "Registration failed, please ensure the course you are registering for exists. If error persists please contact service owner", http.StatusBadRequest)
 			return
 		}
 
 		w.WriteHeader(http.StatusCreated)
 		if _, err := w.Write([]byte("Registered for section\n")); err != nil {
-			log.Info().Msgf("error writing register response: %s", err)
+			log.Error().Msgf("error writing register response: %s", err)
 		}
 		log.Info().Msgf("Register request succeeded: %s*%d*%s*%s for %s", req.Section.Course.Department, req.Section.Course.Code, req.Section.Code, req.Section.Term, req.Watcher.Email)
 	}

trigger/trigger.go

@@ -65,7 +65,7 @@ func (t Trigger) Trigger(ctx context.Context) error {
 		}
 
 		if err := t.watcherService.Cleanup(ctx, section); err != nil {
-			return fmt.Errorf("failed to remove watchers from %s: %w", section, err)
+			return fmt.Errorf("failed to cleanup section %s: %w", section, err)
 		}
 	}