pulls: replace log.Println/Printf with structured slog

Signed-off-by: Matías Insaurralde <[e-mail]>

appview/pulls/pulls.go

···
 	"errors"
 	"fmt"
 	"io"
-	"log"
 	"log/slog"
 	"net/http"
 	"slices"
···
 		user := s.oauth.GetMultiAccountUser(r)
 		f, err := s.repoResolver.Resolve(r)
 		if err != nil {
-			log.Println("failed to get repo and knot", err)
+			s.logger.Error("failed to get repo and knot", "err", err)
 			return
 		}
 
 		pull, ok := r.Context().Value("pull").(*models.Pull)
 		if !ok {
-			log.Println("failed to get pull")
+			s.logger.Error("failed to get pull")
 			s.pages.Notice(w, "pull-error", "Failed to edit patch. Try again later.")
 			return
 		}
···
 		}
 		if roundNumber >= len(pull.Submissions) {
 			http.Error(w, "bad round id", http.StatusBadRequest)
-			log.Println("failed to parse round id", err)
+			s.logger.Error("failed to parse round id", "err", err)
 			return
 		}
 
···
 	user := s.oauth.GetMultiAccountUser(r)
 	f, err := s.repoResolver.Resolve(r)
 	if err != nil {
-		log.Println("failed to get repo and knot", err)
+		s.logger.Error("failed to get repo and knot", "err", err)
 		return
 	}
 
 	pull, ok := r.Context().Value("pull").(*models.Pull)
 	if !ok {
-		log.Println("failed to get pull")
+		s.logger.Error("failed to get pull")
 		s.pages.Notice(w, "pull-error", "Failed to edit patch. Try again later.")
 		return
 	}
 
 	backlinks, err := db.GetBacklinks(s.db, pull.AtUri())
 	if err != nil {
-		log.Println("failed to get pull backlinks", err)
+		s.logger.Error("failed to get pull backlinks", "err", err)
 		s.pages.Notice(w, "pull-error", "Failed to get pull. Try again later.")
 		return
 	}
···
 	}
 	if roundIdInt >= len(pull.Submissions) {
 		http.Error(w, "bad round id", http.StatusBadRequest)
-		log.Println("failed to parse round id", err)
+		s.logger.Error("failed to parse round id", "err", err)
 		return
 	}
 
···
 		orm.FilterIn("p.sha", shas),
 	)
 	if err != nil {
-		log.Printf("failed to fetch pipeline statuses: %s", err)
+		s.logger.Error("failed to fetch pipeline statuses", "err", err)
 		// non-fatal
 	}
 
···
 
 	reactionMap, err := db.GetReactionMap(s.db, 20, pull.AtUri())
 	if err != nil {
-		log.Println("failed to get pull reactions")
+		s.logger.Error("failed to get pull reactions", "err", err)
 	}
 
 	userReactions := map[models.ReactionKind]bool{}
···
 		orm.FilterContains("scope", tangled.RepoPullNSID),
 	)
 	if err != nil {
-		log.Println("failed to fetch labels", err)
+		s.logger.Error("failed to fetch labels", "err", err)
 		s.pages.Error503(w)
 		return
 	}
···
 	if interdiff {
 		currentPatch, err := patchutil.AsDiff(pull.Submissions[roundIdInt].CombinedPatch())
 		if err != nil {
-			log.Println("failed to interdiff; current patch malformed")
+			s.logger.Error("failed to interdiff; current patch malformed", "err", err)
 			s.pages.Notice(w, fmt.Sprintf("interdiff-error-%d", roundIdInt), "Failed to calculate interdiff; current patch is invalid.")
 			return
 		}
 
 		previousPatch, err := patchutil.AsDiff(pull.Submissions[roundIdInt-1].CombinedPatch())
 		if err != nil {
-			log.Println("failed to interdiff; previous patch malformed")
+			s.logger.Error("failed to interdiff; previous patch malformed", "err", err)
 			s.pages.Notice(w, fmt.Sprintf("interdiff-error-%d", roundIdInt), "Failed to calculate interdiff; previous patch is invalid.")
 			return
 		}
···
 func (s *Pulls) RepoSinglePull(w http.ResponseWriter, r *http.Request) {
 	pull, ok := r.Context().Value("pull").(*models.Pull)
 	if !ok {
-		log.Println("failed to get pull")
+		s.logger.Error("failed to get pull")
 		s.pages.Notice(w, "pull-error", "Failed to edit patch. Try again later.")
 		return
 	}
···
 		},
 	)
 	if err := xrpcclient.HandleXrpcErr(xe); err != nil {
-		log.Println("failed to check for mergeability", "err", err)
+		s.logger.Error("failed to check for mergeability", "err", err)
 		return types.MergeCheckResponse{
 			Error: fmt.Sprintf("failed to check merge status: %s", err.Error()),
 		}
···
 	branchResp, err := tangled.GitTempGetBranch(r.Context(), xrpcc, pull.PullSource.Branch, sourceRepo.String())
 	if err != nil {
 		if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {
-			log.Println("failed to call XRPC repo.branches", xrpcerr)
+			s.logger.Error("failed to call XRPC repo.branches", "err", xrpcerr)
 			return pages.Unknown
 		}
-		log.Println("failed to reach knotserver", err)
+		s.logger.Error("failed to reach knotserver", "err", err)
 		return pages.Unknown
 	}
 
···
 func (s *Pulls) RepoPullPatchRaw(w http.ResponseWriter, r *http.Request) {
 	pull, ok := r.Context().Value("pull").(*models.Pull)
 	if !ok {
-		log.Println("failed to get pull")
+		s.logger.Error("failed to get pull")
 		s.pages.Notice(w, "pull-error", "Failed to edit patch. Try again later.")
 		return
 	}
···
 	roundIdInt, err := strconv.Atoi(roundId)
 	if err != nil || roundIdInt >= len(pull.Submissions) {
 		http.Error(w, "bad round id", http.StatusBadRequest)
-		log.Println("failed to parse round id", err)
+		s.logger.Error("failed to parse round id", "err", err)
 		return
 	}
 
···
 
 	f, err := s.repoResolver.Resolve(r)
 	if err != nil {
-		log.Println("failed to get repo and knot", err)
+		s.logger.Error("failed to get repo and knot", "err", err)
 		return
 	}
 
···
 			if p.PullSource.RepoAt != nil {
 				pullSourceRepo, err = db.GetRepoByAtUri(s.db, p.PullSource.RepoAt.String())
 				if err != nil {
-					log.Printf("failed to get repo by at uri: %v", err)
+					s.logger.Error("failed to get repo by at uri", "err", err)
 					continue
 				} else {
 					p.PullSource.Repo = pullSourceRepo
···
 		orm.FilterIn("p.sha", shas),
 	)
 	if err != nil {
-		log.Printf("failed to fetch pipeline statuses: %s", err)
+		s.logger.Error("failed to fetch pipeline statuses", "err", err)
 		// non-fatal
 	}
 	m := make(map[string]models.Pipeline)
···
 	user := s.oauth.GetMultiAccountUser(r)
 	f, err := s.repoResolver.Resolve(r)
 	if err != nil {
-		log.Println("failed to get repo and knot", err)
+		s.logger.Error("failed to get repo and knot", "err", err)
 		return
 	}
 
 	pull, ok := r.Context().Value("pull").(*models.Pull)
 	if !ok {
-		log.Println("failed to get pull")
+		s.logger.Error("failed to get pull")
 		s.pages.Notice(w, "pull-error", "Failed to edit patch. Try again later.")
 		return
 	}
···
 	roundNumber, err := strconv.Atoi(roundNumberStr)
 	if err != nil || roundNumber >= len(pull.Submissions) {
 		http.Error(w, "bad round id", http.StatusBadRequest)
-		log.Println("failed to parse round id", err)
+		s.logger.Error("failed to parse round id", "err", err)
 		return
 	}
 
···
 		// Start a transaction
 		tx, err := s.db.BeginTx(r.Context(), nil)
 		if err != nil {
-			log.Println("failed to start transaction", err)
+			s.logger.Error("failed to start transaction", "err", err)
 			s.pages.Notice(w, "pull-comment", "Failed to create comment.")
 			return
 		}
···
 
 		client, err := s.oauth.AuthorizedClient(r)
 		if err != nil {
-			log.Println("failed to get authorized client", err)
+			s.logger.Error("failed to get authorized client", "err", err)
 			s.pages.Notice(w, "pull-comment", "Failed to create comment.")
 			return
 		}
···
 			},
 		})
 		if err != nil {
-			log.Println("failed to create pull comment", err)
+			s.logger.Error("failed to create pull comment", "err", err)
 			s.pages.Notice(w, "pull-comment", "Failed to create comment.")
 			return
 		}
···
 		// Create the pull comment in the database with the commentAt field
 		commentId, err := db.NewPullComment(tx, comment)
 		if err != nil {
-			log.Println("failed to create pull comment", err)
+			s.logger.Error("failed to create pull comment", "err", err)
 			s.pages.Notice(w, "pull-comment", "Failed to create comment.")
 			return
 		}
 
 		// Commit the transaction
 		if err = tx.Commit(); err != nil {
-			log.Println("failed to commit transaction", err)
+			s.logger.Error("failed to commit transaction", "err", err)
 			s.pages.Notice(w, "pull-comment", "Failed to create comment.")
 			return
 		}
···
 	user := s.oauth.GetMultiAccountUser(r)
 	f, err := s.repoResolver.Resolve(r)
 	if err != nil {
-		log.Println("failed to get repo and knot", err)
+		s.logger.Error("failed to get repo and knot", "err", err)
 		return
 	}
 
···
 		xrpcBytes, err := tangled.GitTempListBranches(r.Context(), xrpcc, "", 0, f.RepoAt().String())
 		if err != nil {
 			if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {
-				log.Println("failed to call XRPC repo.branches", xrpcerr)
+				s.logger.Error("failed to call XRPC repo.branches", "err", xrpcerr)
 				s.pages.Error503(w)
 				return
 			}
-			log.Println("failed to fetch branches", err)
+			s.logger.Error("failed to fetch branches", "err", err)
 			return
 		}
 
 		var result types.RepoBranchesResponse
 		if err := json.Unmarshal(xrpcBytes, &result); err != nil {
-			log.Println("failed to decode XRPC response", err)
+			s.logger.Error("failed to decode XRPC response", "err", err)
 			s.pages.Error503(w)
 			return
 		}
···
 	xrpcBytes, err := tangled.RepoCompare(r.Context(), xrpcc, didSlashRepo, targetBranch, sourceBranch)
 	if err != nil {
 		if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {
-			log.Println("failed to call XRPC repo.compare", xrpcerr)
+			s.logger.Error("failed to call XRPC repo.compare", "err", xrpcerr)
 			s.pages.Notice(w, "pull", "Failed to create pull request. Try again later.")
 			return
 		}
-		log.Println("failed to compare", err)
+		s.logger.Error("failed to compare", "err", err)
 		s.pages.Notice(w, "pull", err.Error())
 		return
 	}
 
 	var comparison types.RepoFormatPatchResponse
 	if err := json.Unmarshal(xrpcBytes, &comparison); err != nil {
-		log.Println("failed to decode XRPC compare response", err)
+		s.logger.Error("failed to decode XRPC compare response", "err", err)
 		s.pages.Notice(w, "pull", "Failed to create pull request. Try again later.")
 		return
 	}
···
 		s.pages.Notice(w, "pull", "No such fork.")
 		return
 	} else if err != nil {
-		log.Println("failed to fetch fork:", err)
+		s.logger.Error("failed to fetch fork:", "err", err)
 		s.pages.Notice(w, "pull", "Failed to fetch fork.")
 		return
 	}
···
 	forkXrpcBytes, err := tangled.RepoCompare(r.Context(), forkXrpcc, forkRepoId, hiddenRef, sourceBranch)
 	if err != nil {
 		if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {
-			log.Println("failed to call XRPC repo.compare for fork", xrpcerr)
+			s.logger.Error("failed to call XRPC repo.compare for fork", "err", xrpcerr)
 			s.pages.Notice(w, "pull", "Failed to create pull request. Try again later.")
 			return
 		}
-		log.Println("failed to compare across branches", err)
+		s.logger.Error("failed to compare across branches", "err", err)
 		s.pages.Notice(w, "pull", err.Error())
 		return
 	}
 
 	var comparison types.RepoFormatPatchResponse
 	if err := json.Unmarshal(forkXrpcBytes, &comparison); err != nil {
-		log.Println("failed to decode XRPC compare response for fork", err)
+		s.logger.Error("failed to decode XRPC compare response for fork", "err", err)
 		s.pages.Notice(w, "pull", "Failed to create pull request. Try again later.")
 		return
 	}
···
 
 	client, err := s.oauth.AuthorizedClient(r)
 	if err != nil {
-		log.Println("failed to get authorized client", err)
+		s.logger.Error("failed to get authorized client", "err", err)
 		s.pages.Notice(w, "pull", "Failed to create pull request. Try again later.")
 		return
 	}
 
 	tx, err := s.db.BeginTx(r.Context(), nil)
 	if err != nil {
-		log.Println("failed to start tx")
+		s.logger.Error("failed to start tx", "err", err)
 		s.pages.Notice(w, "pull", "Failed to create pull request. Try again later.")
 		return
 	}
···
 	}
 	err = db.NewPull(tx, pull)
 	if err != nil {
-		log.Println("failed to create pull request", err)
+		s.logger.Error("failed to create pull request", "err", err)
 		s.pages.Notice(w, "pull", "Failed to create pull request. Try again later.")
 		return
 	}
 	pullId, err := db.NextPullId(tx, repo.RepoAt())
 	if err != nil {
-		log.Println("failed to get pull id", err)
+		s.logger.Error("failed to get pull id", "err", err)
 		s.pages.Notice(w, "pull", "Failed to create pull request. Try again later.")
 		return
 	}
 
 	blob, err := xrpc.RepoUploadBlob(r.Context(), client, gz(patch), ApplicationGzip)
 	if err != nil {
-		log.Println("failed to upload patch", err)
+		s.logger.Error("failed to upload patch", "err", err)
 		s.pages.Notice(w, "pull", "Failed to create pull request. Try again later.")
 		return
 	}
···
 		},
 	})
 	if err != nil {
-		log.Println("failed to create pull request", err)
+		s.logger.Error("failed to create pull request", "err", err)
 		s.pages.Notice(w, "pull", "Failed to create pull request. Try again later.")
 		return
 	}
 
 	if err = tx.Commit(); err != nil {
-		log.Println("failed to create pull request", err)
+		s.logger.Error("failed to create pull request", "err", err)
 		s.pages.Notice(w, "pull", "Failed to create pull request. Try again later.")
 		return
 	}
···
 
 	//  must be branch or fork based
 	if sourceRev == "" {
-		log.Println("stacked PR from patch-based pull")
+		s.logger.Warn("stacked PR from patch-based pull")
 		s.pages.Notice(w, "pull", "Stacking is only supported on branch and fork based pull-requests.")
 		return
 	}
 
 	formatPatches, err := patchutil.ExtractPatches(patch)
 	if err != nil {
-		log.Println("failed to extract patches", err)
+		s.logger.Error("failed to extract patches", "err", err)
 		s.pages.Notice(w, "pull", fmt.Sprintf("Failed to extract patches: %v", err))
 		return
 	}
 
 	//  must have atleast 1 patch to begin with
 	if len(formatPatches) == 0 {
-		log.Println("empty patches")
+		s.logger.Error("empty patches")
 		s.pages.Notice(w, "pull", "No patches found in the generated format-patch.")
 		return
 	}
···
 	stackId := uuid.New()
 	stack, err := s.newStack(r.Context(), repo, user, targetBranch, patch, pullSource, stackId.String())
 	if err != nil {
-		log.Println("failed to create stack", err)
+		s.logger.Error("failed to create stack", "err", err)
 		s.pages.Notice(w, "pull", fmt.Sprintf("Failed to create stack: %v", err))
 		return
 	}
 
 	client, err := s.oauth.AuthorizedClient(r)
 	if err != nil {
-		log.Println("failed to get authorized client", err)
+		s.logger.Error("failed to get authorized client", "err", err)
 		s.pages.Notice(w, "pull", "Failed to create pull request. Try again later.")
 		return
 	}
···
 	for _, p := range stack {
 		blob, err := xrpc.RepoUploadBlob(r.Context(), client, gz(p.LatestPatch()), ApplicationGzip)
 		if err != nil {
-			log.Println("failed to upload patch blob", err)
+			s.logger.Error("failed to upload patch blob", "err", err)
 			s.pages.Notice(w, "pull", "Failed to create pull request. Try again later.")
 			return
 		}
···
 		Writes: writes,
 	})
 	if err != nil {
-		log.Println("failed to create stacked pull request", err)
+		s.logger.Error("failed to create stacked pull request", "err", err)
 		s.pages.Notice(w, "pull", "Failed to create stacked pull request. Try again later.")
 		return
 	}
···
 	// create all pulls at once
 	tx, err := s.db.BeginTx(r.Context(), nil)
 	if err != nil {
-		log.Println("failed to start tx")
+		s.logger.Error("failed to start tx", "err", err)
 		s.pages.Notice(w, "pull", "Failed to create pull request. Try again later.")
 		return
 	}
···
 	for _, p := range stack {
 		err = db.NewPull(tx, p)
 		if err != nil {
-			log.Println("failed to create pull request", err)
+			s.logger.Error("failed to create pull request", "err", err)
 			s.pages.Notice(w, "pull", "Failed to create pull request. Try again later.")
 			return
 		}
···
 	}
 
 	if err = tx.Commit(); err != nil {
-		log.Println("failed to create pull request", err)
+		s.logger.Error("failed to create pull request", "err", err)
 		s.pages.Notice(w, "pull", "Failed to create pull request. Try again later.")
 		return
 	}
···
 func (s *Pulls) ValidatePatch(w http.ResponseWriter, r *http.Request) {
 	_, err := s.repoResolver.Resolve(r)
 	if err != nil {
-		log.Println("failed to get repo and knot", err)
+		s.logger.Error("failed to get repo and knot", "err", err)
 		return
 	}
 
···
 	user := s.oauth.GetMultiAccountUser(r)
 	f, err := s.repoResolver.Resolve(r)
 	if err != nil {
-		log.Println("failed to get repo and knot", err)
+		s.logger.Error("failed to get repo and knot", "err", err)
 		return
 	}
 
···
 
 	xrpcBytes, err := tangled.GitTempListBranches(r.Context(), xrpcc, "", 0, f.RepoAt().String())
 	if err != nil {
-		log.Println("failed to fetch branches", err)
+		s.logger.Error("failed to fetch branches", "err", err)
 		s.pages.Error503(w)
 		return
 	}
 
 	var result types.RepoBranchesResponse
 	if err := json.Unmarshal(xrpcBytes, &result); err != nil {
-		log.Println("failed to decode XRPC response", err)
+		s.logger.Error("failed to decode XRPC response", "err", err)
 		s.pages.Error503(w)
 		return
 	}
···
 
 	forks, err := db.GetForksByDid(s.db, user.Active.Did)
 	if err != nil {
-		log.Println("failed to get forks", err)
+		s.logger.Error("failed to get forks", "err", err)
 		return
 	}
 
···
 
 	f, err := s.repoResolver.Resolve(r)
 	if err != nil {
-		log.Println("failed to get repo and knot", err)
+		s.logger.Error("failed to get repo and knot", "err", err)
 		return
 	}
 
···
 		orm.FilterEq("name", forkName),
 	)
 	if err != nil {
-		log.Println("failed to get repo", "did", forkOwnerDid, "name", forkName, "err", err)
+		s.logger.Error("failed to get repo", "did", forkOwnerDid, "name", forkName, "err", err)
 		return
 	}
 
 	sourceXrpcBytes, err := tangled.GitTempListBranches(r.Context(), xrpcc, "", 0, repo.RepoAt().String())
 	if err != nil {
 		if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {
-			log.Println("failed to call XRPC repo.branches for source", xrpcerr)
+			s.logger.Error("failed to call XRPC repo.branches for source", "err", xrpcerr)
 			s.pages.Error503(w)
 			return
 		}
-		log.Println("failed to fetch source branches", err)
+		s.logger.Error("failed to fetch source branches", "err", err)
 		return
 	}
 
 	// Decode source branches
 	var sourceBranches types.RepoBranchesResponse
 	if err := json.Unmarshal(sourceXrpcBytes, &sourceBranches); err != nil {
-		log.Println("failed to decode source branches XRPC response", err)
+		s.logger.Error("failed to decode source branches XRPC response", "err", err)
 		s.pages.Error503(w)
 		return
 	}
···
 	targetXrpcBytes, err := tangled.GitTempListBranches(r.Context(), xrpcc, "", 0, f.RepoAt().String())
 	if err != nil {
 		if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {
-			log.Println("failed to call XRPC repo.branches for target", xrpcerr)
+			s.logger.Error("failed to call XRPC repo.branches for target", "err", xrpcerr)
 			s.pages.Error503(w)
 			return
 		}
-		log.Println("failed to fetch target branches", err)
+		s.logger.Error("failed to fetch target branches", "err", err)
 		return
 	}
 
 	// Decode target branches
 	var targetBranches types.RepoBranchesResponse
 	if err := json.Unmarshal(targetXrpcBytes, &targetBranches); err != nil {
-		log.Println("failed to decode target branches XRPC response", err)
+		s.logger.Error("failed to decode target branches XRPC response", "err", err)
 		s.pages.Error503(w)
 		return
 	}
···
 
 	pull, ok := r.Context().Value("pull").(*models.Pull)
 	if !ok {
-		log.Println("failed to get pull")
+		s.logger.Error("failed to get pull")
 		s.pages.Notice(w, "pull-error", "Failed to edit patch. Try again later.")
 		return
 	}
···
 
 	pull, ok := r.Context().Value("pull").(*models.Pull)
 	if !ok {
-		log.Println("failed to get pull")
+		s.logger.Error("failed to get pull")
 		s.pages.Notice(w, "pull-error", "Failed to edit patch. Try again later.")
 		return
 	}
 
 	f, err := s.repoResolver.Resolve(r)
 	if err != nil {
-		log.Println("failed to get repo and knot", err)
+		s.logger.Error("failed to get repo and knot", "err", err)
 		return
 	}
 
 	if user.Active.Did != pull.OwnerDid {
-		log.Println("unauthorized user")
+		s.logger.Warn("unauthorized user")
 		w.WriteHeader(http.StatusUnauthorized)
 		return
 	}
···
 
 	pull, ok := r.Context().Value("pull").(*models.Pull)
 	if !ok {
-		log.Println("failed to get pull")
+		s.logger.Error("failed to get pull")
 		s.pages.Notice(w, "resubmit-error", "Failed to edit patch. Try again later.")
 		return
 	}
 
 	f, err := s.repoResolver.Resolve(r)
 	if err != nil {
-		log.Println("failed to get repo and knot", err)
+		s.logger.Error("failed to get repo and knot", "err", err)
 		return
 	}
 
 	if user.Active.Did != pull.OwnerDid {
-		log.Println("unauthorized user")
+		s.logger.Warn("unauthorized user")
 		w.WriteHeader(http.StatusUnauthorized)
 		return
 	}
 
 	roles := repoinfo.RolesInRepo{Roles: s.enforcer.GetPermissionsInRepo(user.Active.Did, f.Knot, f.DidSlashRepo())}
 	if !roles.IsPushAllowed() {
-		log.Println("unauthorized user")
+		s.logger.Warn("unauthorized user")
 		w.WriteHeader(http.StatusUnauthorized)
 		return
 	}
···
 	xrpcBytes, err := tangled.RepoCompare(r.Context(), xrpcc, repo, pull.TargetBranch, pull.PullSource.Branch)
 	if err != nil {
 		if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {
-			log.Println("failed to call XRPC repo.compare", xrpcerr)
+			s.logger.Error("failed to call XRPC repo.compare", "err", xrpcerr)
 			s.pages.Notice(w, "resubmit-error", "Failed to create pull request. Try again later.")
 			return
 		}
-		log.Printf("compare request failed: %s", err)
+		s.logger.Error("compare request failed", "err", err)
 		s.pages.Notice(w, "resubmit-error", err.Error())
 		return
 	}
 
 	var comparison types.RepoFormatPatchResponse
 	if err := json.Unmarshal(xrpcBytes, &comparison); err != nil {
-		log.Println("failed to decode XRPC compare response", err)
+		s.logger.Error("failed to decode XRPC compare response", "err", err)
 		s.pages.Notice(w, "resubmit-error", "Failed to create pull request. Try again later.")
 		return
 	}
···
 
 	pull, ok := r.Context().Value("pull").(*models.Pull)
 	if !ok {
-		log.Println("failed to get pull")
+		s.logger.Error("failed to get pull")
 		s.pages.Notice(w, "resubmit-error", "Failed to edit patch. Try again later.")
 		return
 	}
 
 	f, err := s.repoResolver.Resolve(r)
 	if err != nil {
-		log.Println("failed to get repo and knot", err)
+		s.logger.Error("failed to get repo and knot", "err", err)
 		return
 	}
 
 	if user.Active.Did != pull.OwnerDid {
-		log.Println("unauthorized user")
+		s.logger.Warn("unauthorized user")
 		w.WriteHeader(http.StatusUnauthorized)
 		return
 	}
 
 	forkRepo, err := db.GetRepoByAtUri(s.db, pull.PullSource.RepoAt.String())
 	if err != nil {
-		log.Println("failed to get source repo", err)
+		s.logger.Error("failed to get source repo", "err", err)
 		s.pages.Notice(w, "resubmit-error", "Failed to create pull request. Try again later.")
 		return
 	}
···
 		oauth.WithDev(s.config.Core.Dev),
 	)
 	if err != nil {
-		log.Printf("failed to connect to knot server: %v", err)
+		s.logger.Error("failed to connect to knot server", "err", err)
 		return
 	}
 
···
 		return
 	}
 	if !resp.Success {
-		log.Println("Failed to update tracking ref.", "err", resp.Error)
+		s.logger.Warn("failed to update tracking ref", "err", resp.Error)
 		s.pages.Notice(w, "resubmit-error", "Failed to update tracking ref.")
 		return
 	}
···
 	forkXrpcBytes, err := tangled.RepoCompare(r.Context(), &indigoxrpc.Client{Host: forkHost}, forkRepoId, hiddenRef, pull.PullSource.Branch)
 	if err != nil {
 		if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {
-			log.Println("failed to call XRPC repo.compare for fork", xrpcerr)
+			s.logger.Error("failed to call XRPC repo.compare for fork", "err", xrpcerr)
 			s.pages.Notice(w, "resubmit-error", "Failed to create pull request. Try again later.")
 			return
 		}
-		log.Printf("failed to compare branches: %s", err)
+		s.logger.Error("failed to compare branches", "err", err)
 		s.pages.Notice(w, "resubmit-error", "Failed to create pull request. Try again later.")
 		return
 	}
 
 	var forkComparison types.RepoFormatPatchResponse
 	if err := json.Unmarshal(forkXrpcBytes, &forkComparison); err != nil {
-		log.Println("failed to decode XRPC compare response for fork", err)
+		s.logger.Error("failed to decode XRPC compare response for fork", "err", err)
 		s.pages.Notice(w, "resubmit-error", "Failed to create pull request. Try again later.")
 		return
 	}
···
 	sourceRev string,
 ) {
 	if pull.IsStacked() {
-		log.Println("resubmitting stacked PR")
+		s.logger.Info("resubmitting stacked PR")
 		s.resubmitStackedPullHelper(w, r, repo, user, pull, patch, pull.StackId)
 		return
 	}
···
 
 	tx, err := s.db.BeginTx(r.Context(), nil)
 	if err != nil {
-		log.Println("failed to start tx")
+		s.logger.Error("failed to start tx", "err", err)
 		s.pages.Notice(w, "resubmit-error", "Failed to create pull request. Try again later.")
 		return
 	}
···
 	combinedPatch := combined
 	err = db.ResubmitPull(tx, pullAt, newRoundNumber, newPatch, combinedPatch, newSourceRev)
 	if err != nil {
-		log.Println("failed to create pull request", err)
+		s.logger.Error("failed to create pull request", "err", err)
 		s.pages.Notice(w, "resubmit-error", "Failed to create pull request. Try again later.")
 		return
 	}
 	client, err := s.oauth.AuthorizedClient(r)
 	if err != nil {
-		log.Println("failed to authorize client")
+		s.logger.Error("failed to authorize client", "err", err)
 		s.pages.Notice(w, "resubmit-error", "Failed to create pull request. Try again later.")
 		return
 	}
···
 
 	blob, err := xrpc.RepoUploadBlob(r.Context(), client, gz(patch), ApplicationGzip)
 	if err != nil {
-		log.Println("failed to upload patch blob", err)
+		s.logger.Error("failed to upload patch blob", "err", err)
 		s.pages.Notice(w, "resubmit-error", "Failed to update pull request on the PDS. Try again later.")
 		return
 	}
···
 		},
 	})
 	if err != nil {
-		log.Println("failed to update record", err)
+		s.logger.Error("failed to update record", "err", err)
 		s.pages.Notice(w, "resubmit-error", "Failed to update pull request on the PDS. Try again later.")
 		return
 	}
 
 	if err = tx.Commit(); err != nil {
-		log.Println("failed to commit transaction", err)
+		s.logger.Error("failed to commit transaction", "err", err)
 		s.pages.Notice(w, "resubmit-error", "Failed to resubmit pull.")
 		return
 	}
···
 	origStack, _ := r.Context().Value("stack").(models.Stack)
 	newStack, err := s.newStack(r.Context(), repo, user, targetBranch, patch, pull.PullSource, stackId)
 	if err != nil {
-		log.Println("failed to create resubmitted stack", err)
+		s.logger.Error("failed to create resubmitted stack", "err", err)
 		s.pages.Notice(w, "pull-merge-error", "Failed to merge pull request. Try again later.")
 		return
 	}
···
 
 	tx, err := s.db.Begin()
 	if err != nil {
-		log.Println("failed to start transaction", err)
+		s.logger.Error("failed to start transaction", "err", err)
 		s.pages.Notice(w, "pull-resubmit-error", "Failed to resubmit pull request. Try again later.")
 		return
 	}
···
 
 	client, err := s.oauth.AuthorizedClient(r)
 	if err != nil {
-		log.Println("failed to authorize client")
+		s.logger.Error("failed to authorize client", "err", err)
 		s.pages.Notice(w, "resubmit-error", "Failed to create pull request. Try again later.")
 		return
 	}
···
 
 		err := db.DeletePull(tx, p.RepoAt, p.PullId)
 		if err != nil {
-			log.Println("failed to delete pull", err, p.PullId)
+			s.logger.Error("failed to delete pull", "err", err, "pull_id", p.PullId)
 			s.pages.Notice(w, "pull-resubmit-error", "Failed to resubmit pull request. Try again later.")
 			return
 		}
···
 	for _, p := range additions {
 		err := db.NewPull(tx, p)
 		if err != nil {
-			log.Println("failed to create pull", err, p.PullId)
+			s.logger.Error("failed to create pull", "err", err, "pull_id", p.PullId)
 			s.pages.Notice(w, "pull-resubmit-error", "Failed to resubmit pull request. Try again later.")
 			return
 		}
 
 		blob, err := xrpc.RepoUploadBlob(r.Context(), client, gz(patch), ApplicationGzip)
 		if err != nil {
-			log.Println("failed to upload patch blob", err)
+			s.logger.Error("failed to upload patch blob", "err", err)
 			s.pages.Notice(w, "resubmit-error", "Failed to update pull request on the PDS. Try again later.")
 			return
 		}
···
 		newSourceRev := np.LatestSha()
 		err := db.ResubmitPull(tx, pullAt, newRoundNumber, newPatch, combinedPatch, newSourceRev)
 		if err != nil {
-			log.Println("failed to update pull", err, op.PullId)
+			s.logger.Error("failed to update pull", "err", err, "pull_id", op.PullId)
 			s.pages.Notice(w, "pull-resubmit-error", "Failed to resubmit pull request. Try again later.")
 			return
 		}
 
 		blob, err := xrpc.RepoUploadBlob(r.Context(), client, gz(patch), ApplicationGzip)
 		if err != nil {
-			log.Println("failed to upload patch blob", err)
+			s.logger.Error("failed to upload patch blob", "err", err)
 			s.pages.Notice(w, "resubmit-error", "Failed to update pull request on the PDS. Try again later.")
 			return
 		}
···
 		)
 
 		if err != nil {
-			log.Println("failed to update pull", err, p.PullId)
+			s.logger.Error("failed to update pull", "err", err, "pull_id", p.PullId)
 			s.pages.Notice(w, "pull-resubmit-error", "Failed to resubmit pull request. Try again later.")
 			return
 		}
···
 
 	err = tx.Commit()
 	if err != nil {
-		log.Println("failed to resubmit pull", err)
+		s.logger.Error("failed to resubmit pull", "err", err)
 		s.pages.Notice(w, "pull-resubmit-error", "Failed to resubmit pull request. Try again later.")
 		return
 	}
···
 		Writes: writes,
 	})
 	if err != nil {
-		log.Println("failed to create stacked pull request", err)
+		s.logger.Error("failed to create stacked pull request", "err", err)
 		s.pages.Notice(w, "pull", "Failed to create stacked pull request. Try again later.")
 		return
 	}
···
 	user := s.oauth.GetMultiAccountUser(r)
 	f, err := s.repoResolver.Resolve(r)
 	if err != nil {
-		log.Println("failed to resolve repo:", err)
+		s.logger.Error("failed to resolve repo:", "err", err)
 		s.pages.Notice(w, "pull-merge-error", "Failed to merge pull request. Try again later.")
 		return
 	}
 
 	pull, ok := r.Context().Value("pull").(*models.Pull)
 	if !ok {
-		log.Println("failed to get pull")
+		s.logger.Error("failed to get pull")
 		s.pages.Notice(w, "pull-merge-error", "Failed to merge patch. Try again later.")
 		return
 	}
···
 	if pull.IsStacked() {
 		stack, ok := r.Context().Value("stack").(models.Stack)
 		if !ok {
-			log.Println("failed to get stack")
+			s.logger.Error("failed to get stack")
 			s.pages.Notice(w, "pull-merge-error", "Failed to merge patch. Try again later.")
 			return
 		}
···
 
 	ident, err := s.idResolver.ResolveIdent(r.Context(), pull.OwnerDid)
 	if err != nil {
-		log.Printf("resolving identity: %s", err)
+		s.logger.Error("resolving identity", "err", err)
 		w.WriteHeader(http.StatusNotFound)
 		return
 	}
 
 	email, err := db.GetPrimaryEmail(s.db, pull.OwnerDid)
 	if err != nil {
-		log.Printf("failed to get primary email: %s", err)
+		s.logger.Error("failed to get primary email", "err", err)
 	}
 
 	authorName := ident.Handle.String()
···
 		oauth.WithDev(s.config.Core.Dev),
 	)
 	if err != nil {
-		log.Printf("failed to connect to knot server: %v", err)
+		s.logger.Error("failed to connect to knot server", "err", err)
 		s.pages.Notice(w, "pull-merge-error", "Failed to merge pull request. Try again later.")
 		return
 	}
···
 
 	tx, err := s.db.Begin()
 	if err != nil {
-		log.Println("failed to start transcation", err)
+		s.logger.Error("failed to start transaction", "err", err)
 		s.pages.Notice(w, "pull-merge-error", "Failed to merge pull request. Try again later.")
 		return
 	}
···
 	for _, p := range pullsToMerge {
 		err := db.MergePull(tx, f.RepoAt(), p.PullId)
 		if err != nil {
-			log.Printf("failed to update pull request status in database: %s", err)
+			s.logger.Error("failed to update pull request status in database", "err", err)
 			s.pages.Notice(w, "pull-merge-error", "Failed to merge pull request. Try again later.")
 			return
 		}
···
 	err = tx.Commit()
 	if err != nil {
 		// TODO: this is unsound, we should also revert the merge from the knotserver here
-		log.Printf("failed to update pull request status in database: %s", err)
+		s.logger.Error("failed to update pull request status in database", "err", err)
 		s.pages.Notice(w, "pull-merge-error", "Failed to merge pull request. Try again later.")
 		return
 	}
···
 
 	f, err := s.repoResolver.Resolve(r)
 	if err != nil {
-		log.Println("malformed middleware")
+		s.logger.Error("malformed middleware", "err", err)
 		return
 	}
 
 	pull, ok := r.Context().Value("pull").(*models.Pull)
 	if !ok {
-		log.Println("failed to get pull")
+		s.logger.Error("failed to get pull")
 		s.pages.Notice(w, "pull-error", "Failed to edit patch. Try again later.")
 		return
 	}
···
 	isPullAuthor := user.Active.Did == pull.OwnerDid
 	isCloseAllowed := isOwner || isCollaborator || isPullAuthor
 	if !isCloseAllowed {
-		log.Println("failed to close pull")
+		s.logger.Warn("failed to close pull: unauthorized")
 		s.pages.Notice(w, "pull-close", "You are unauthorized to close this pull.")
 		return
 	}
···
 	// Start a transaction
 	tx, err := s.db.BeginTx(r.Context(), nil)
 	if err != nil {
-		log.Println("failed to start transaction", err)
+		s.logger.Error("failed to start transaction", "err", err)
 		s.pages.Notice(w, "pull-close", "Failed to close pull.")
 		return
 	}
···
 		// Close the pull in the database
 		err = db.ClosePull(tx, f.RepoAt(), p.PullId)
 		if err != nil {
-			log.Println("failed to close pull", err)
+			s.logger.Error("failed to close pull", "err", err)
 			s.pages.Notice(w, "pull-close", "Failed to close pull.")
 			return
 		}
···
 
 	// Commit the transaction
 	if err = tx.Commit(); err != nil {
-		log.Println("failed to commit transaction", err)
+		s.logger.Error("failed to commit transaction", "err", err)
 		s.pages.Notice(w, "pull-close", "Failed to close pull.")
 		return
 	}
···
 
 	f, err := s.repoResolver.Resolve(r)
 	if err != nil {
-		log.Println("failed to resolve repo", err)
+		s.logger.Error("failed to resolve repo", "err", err)
 		s.pages.Notice(w, "pull-reopen", "Failed to reopen pull.")
 		return
 	}
 
 	pull, ok := r.Context().Value("pull").(*models.Pull)
 	if !ok {
-		log.Println("failed to get pull")
+		s.logger.Error("failed to get pull")
 		s.pages.Notice(w, "pull-error", "Failed to edit patch. Try again later.")
 		return
 	}
···
 	isPullAuthor := user.Active.Did == pull.OwnerDid
 	isCloseAllowed := isOwner || isCollaborator || isPullAuthor
 	if !isCloseAllowed {
-		log.Println("failed to close pull")
+		s.logger.Warn("failed to close pull: unauthorized")
 		s.pages.Notice(w, "pull-close", "You are unauthorized to close this pull.")
 		return
 	}
···
 	// Start a transaction
 	tx, err := s.db.BeginTx(r.Context(), nil)
 	if err != nil {
-		log.Println("failed to start transaction", err)
+		s.logger.Error("failed to start transaction", "err", err)
 		s.pages.Notice(w, "pull-reopen", "Failed to reopen pull.")
 		return
 	}
···
 		// Close the pull in the database
 		err = db.ReopenPull(tx, f.RepoAt(), p.PullId)
 		if err != nil {
-			log.Println("failed to close pull", err)
+			s.logger.Error("failed to close pull", "err", err)
 			s.pages.Notice(w, "pull-close", "Failed to close pull.")
 			return
 		}
···
 
 	// Commit the transaction
 	if err = tx.Commit(); err != nil {
-		log.Println("failed to commit transaction", err)
+		s.logger.Error("failed to commit transaction", "err", err)
 		s.pages.Notice(w, "pull-reopen", "Failed to reopen pull.")
 		return
 	}