matias.tngl.sh / core
forked from tangled.org/core
Monorepo for Tangled
test
1
fork

Configure Feed

Select the types of activity you want to include in your feed.

pulls: replace log.Println/Printf with structured slog

Signed-off-by: Matías Insaurralde <matias@insaurral.de>

Matías Insaurralde 23da93c1 5a17af77

+129 -130
+129 -130
appview/pulls/pulls.go
··· 9 9 "errors" 10 10 "fmt" 11 11 "io" 12 - "log" 13 12 "log/slog" 14 13 "net/http" 15 14 "slices" ··· 107 106 user := s.oauth.GetMultiAccountUser(r) 108 107 f, err := s.repoResolver.Resolve(r) 109 108 if err != nil { 110 - log.Println("failed to get repo and knot", err) 109 + s.logger.Error("failed to get repo and knot", "err", err) 111 110 return 112 111 } 113 112 114 113 pull, ok := r.Context().Value("pull").(*models.Pull) 115 114 if !ok { 116 - log.Println("failed to get pull") 115 + s.logger.Error("failed to get pull") 117 116 s.pages.Notice(w, "pull-error", "Failed to edit patch. Try again later.") 118 117 return 119 118 } ··· 128 127 } 129 128 if roundNumber >= len(pull.Submissions) { 130 129 http.Error(w, "bad round id", http.StatusBadRequest) 131 - log.Println("failed to parse round id", err) 130 + s.logger.Error("failed to parse round id", "err", err) 132 131 return 133 132 } 134 133 ··· 157 156 user := s.oauth.GetMultiAccountUser(r) 158 157 f, err := s.repoResolver.Resolve(r) 159 158 if err != nil { 160 - log.Println("failed to get repo and knot", err) 159 + s.logger.Error("failed to get repo and knot", "err", err) 161 160 return 162 161 } 163 162 164 163 pull, ok := r.Context().Value("pull").(*models.Pull) 165 164 if !ok { 166 - log.Println("failed to get pull") 165 + s.logger.Error("failed to get pull") 167 166 s.pages.Notice(w, "pull-error", "Failed to edit patch. Try again later.") 168 167 return 169 168 } 170 169 171 170 backlinks, err := db.GetBacklinks(s.db, pull.AtUri()) 172 171 if err != nil { 173 - log.Println("failed to get pull backlinks", err) 172 + s.logger.Error("failed to get pull backlinks", "err", err) 174 173 s.pages.Notice(w, "pull-error", "Failed to get pull. Try again later.") 175 174 return 176 175 } ··· 182 181 } 183 182 if roundIdInt >= len(pull.Submissions) { 184 183 http.Error(w, "bad round id", http.StatusBadRequest) 185 - log.Println("failed to parse round id", err) 184 + s.logger.Error("failed to parse round id", "err", err) 186 185 return 187 186 } 188 187 ··· 224 223 orm.FilterIn("p.sha", shas), 225 224 ) 226 225 if err != nil { 227 - log.Printf("failed to fetch pipeline statuses: %s", err) 226 + s.logger.Error("failed to fetch pipeline statuses", "err", err) 228 227 // non-fatal 229 228 } 230 229 ··· 234 233 235 234 reactionMap, err := db.GetReactionMap(s.db, 20, pull.AtUri()) 236 235 if err != nil { 237 - log.Println("failed to get pull reactions") 236 + s.logger.Error("failed to get pull reactions", "err", err) 238 237 } 239 238 240 239 userReactions := map[models.ReactionKind]bool{} ··· 248 247 orm.FilterContains("scope", tangled.RepoPullNSID), 249 248 ) 250 249 if err != nil { 251 - log.Println("failed to fetch labels", err) 250 + s.logger.Error("failed to fetch labels", "err", err) 252 251 s.pages.Error503(w) 253 252 return 254 253 } ··· 265 264 if interdiff { 266 265 currentPatch, err := patchutil.AsDiff(pull.Submissions[roundIdInt].CombinedPatch()) 267 266 if err != nil { 268 - log.Println("failed to interdiff; current patch malformed") 267 + s.logger.Error("failed to interdiff; current patch malformed", "err", err) 269 268 s.pages.Notice(w, fmt.Sprintf("interdiff-error-%d", roundIdInt), "Failed to calculate interdiff; current patch is invalid.") 270 269 return 271 270 } 272 271 273 272 previousPatch, err := patchutil.AsDiff(pull.Submissions[roundIdInt-1].CombinedPatch()) 274 273 if err != nil { 275 - log.Println("failed to interdiff; previous patch malformed") 274 + s.logger.Error("failed to interdiff; previous patch malformed", "err", err) 276 275 s.pages.Notice(w, fmt.Sprintf("interdiff-error-%d", roundIdInt), "Failed to calculate interdiff; previous patch is invalid.") 277 276 return 278 277 } ··· 306 305 func (s *Pulls) RepoSinglePull(w http.ResponseWriter, r *http.Request) { 307 306 pull, ok := r.Context().Value("pull").(*models.Pull) 308 307 if !ok { 309 - log.Println("failed to get pull") 308 + s.logger.Error("failed to get pull") 310 309 s.pages.Notice(w, "pull-error", "Failed to edit patch. Try again later.") 311 310 return 312 311 } ··· 350 349 }, 351 350 ) 352 351 if err := xrpcclient.HandleXrpcErr(xe); err != nil { 353 - log.Println("failed to check for mergeability", "err", err) 352 + s.logger.Error("failed to check for mergeability", "err", err) 354 353 return types.MergeCheckResponse{ 355 354 Error: fmt.Sprintf("failed to check merge status: %s", err.Error()), 356 355 } ··· 444 443 branchResp, err := tangled.GitTempGetBranch(r.Context(), xrpcc, pull.PullSource.Branch, sourceRepo.String()) 445 444 if err != nil { 446 445 if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil { 447 - log.Println("failed to call XRPC repo.branches", xrpcerr) 446 + s.logger.Error("failed to call XRPC repo.branches", "err", xrpcerr) 448 447 return pages.Unknown 449 448 } 450 - log.Println("failed to reach knotserver", err) 449 + s.logger.Error("failed to reach knotserver", "err", err) 451 450 return pages.Unknown 452 451 } 453 452 ··· 478 477 func (s *Pulls) RepoPullPatchRaw(w http.ResponseWriter, r *http.Request) { 479 478 pull, ok := r.Context().Value("pull").(*models.Pull) 480 479 if !ok { 481 - log.Println("failed to get pull") 480 + s.logger.Error("failed to get pull") 482 481 s.pages.Notice(w, "pull-error", "Failed to edit patch. Try again later.") 483 482 return 484 483 } ··· 487 486 roundIdInt, err := strconv.Atoi(roundId) 488 487 if err != nil || roundIdInt >= len(pull.Submissions) { 489 488 http.Error(w, "bad round id", http.StatusBadRequest) 490 - log.Println("failed to parse round id", err) 489 + s.logger.Error("failed to parse round id", "err", err) 491 490 return 492 491 } 493 492 ··· 504 503 505 504 f, err := s.repoResolver.Resolve(r) 506 505 if err != nil { 507 - log.Println("failed to get repo and knot", err) 506 + s.logger.Error("failed to get repo and knot", "err", err) 508 507 return 509 508 } 510 509 ··· 673 672 if p.PullSource.RepoAt != nil { 674 673 pullSourceRepo, err = db.GetRepoByAtUri(s.db, p.PullSource.RepoAt.String()) 675 674 if err != nil { 676 - log.Printf("failed to get repo by at uri: %v", err) 675 + s.logger.Error("failed to get repo by at uri", "err", err) 677 676 continue 678 677 } else { 679 678 p.PullSource.Repo = pullSourceRepo ··· 716 715 orm.FilterIn("p.sha", shas), 717 716 ) 718 717 if err != nil { 719 - log.Printf("failed to fetch pipeline statuses: %s", err) 718 + s.logger.Error("failed to fetch pipeline statuses", "err", err) 720 719 // non-fatal 721 720 } 722 721 m := make(map[string]models.Pipeline) ··· 763 762 user := s.oauth.GetMultiAccountUser(r) 764 763 f, err := s.repoResolver.Resolve(r) 765 764 if err != nil { 766 - log.Println("failed to get repo and knot", err) 765 + s.logger.Error("failed to get repo and knot", "err", err) 767 766 return 768 767 } 769 768 770 769 pull, ok := r.Context().Value("pull").(*models.Pull) 771 770 if !ok { 772 - log.Println("failed to get pull") 771 + s.logger.Error("failed to get pull") 773 772 s.pages.Notice(w, "pull-error", "Failed to edit patch. Try again later.") 774 773 return 775 774 } ··· 778 777 roundNumber, err := strconv.Atoi(roundNumberStr) 779 778 if err != nil || roundNumber >= len(pull.Submissions) { 780 779 http.Error(w, "bad round id", http.StatusBadRequest) 781 - log.Println("failed to parse round id", err) 780 + s.logger.Error("failed to parse round id", "err", err) 782 781 return 783 782 } 784 783 ··· 803 802 // Start a transaction 804 803 tx, err := s.db.BeginTx(r.Context(), nil) 805 804 if err != nil { 806 - log.Println("failed to start transaction", err) 805 + s.logger.Error("failed to start transaction", "err", err) 807 806 s.pages.Notice(w, "pull-comment", "Failed to create comment.") 808 807 return 809 808 } ··· 813 812 814 813 client, err := s.oauth.AuthorizedClient(r) 815 814 if err != nil { 816 - log.Println("failed to get authorized client", err) 815 + s.logger.Error("failed to get authorized client", "err", err) 817 816 s.pages.Notice(w, "pull-comment", "Failed to create comment.") 818 817 return 819 818 } ··· 830 829 }, 831 830 }) 832 831 if err != nil { 833 - log.Println("failed to create pull comment", err) 832 + s.logger.Error("failed to create pull comment", "err", err) 834 833 s.pages.Notice(w, "pull-comment", "Failed to create comment.") 835 834 return 836 835 } ··· 849 848 // Create the pull comment in the database with the commentAt field 850 849 commentId, err := db.NewPullComment(tx, comment) 851 850 if err != nil { 852 - log.Println("failed to create pull comment", err) 851 + s.logger.Error("failed to create pull comment", "err", err) 853 852 s.pages.Notice(w, "pull-comment", "Failed to create comment.") 854 853 return 855 854 } 856 855 857 856 // Commit the transaction 858 857 if err = tx.Commit(); err != nil { 859 - log.Println("failed to commit transaction", err) 858 + s.logger.Error("failed to commit transaction", "err", err) 860 859 s.pages.Notice(w, "pull-comment", "Failed to create comment.") 861 860 return 862 861 } ··· 873 872 user := s.oauth.GetMultiAccountUser(r) 874 873 f, err := s.repoResolver.Resolve(r) 875 874 if err != nil { 876 - log.Println("failed to get repo and knot", err) 875 + s.logger.Error("failed to get repo and knot", "err", err) 877 876 return 878 877 } 879 878 ··· 884 883 xrpcBytes, err := tangled.GitTempListBranches(r.Context(), xrpcc, "", 0, f.RepoAt().String()) 885 884 if err != nil { 886 885 if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil { 887 - log.Println("failed to call XRPC repo.branches", xrpcerr) 886 + s.logger.Error("failed to call XRPC repo.branches", "err", xrpcerr) 888 887 s.pages.Error503(w) 889 888 return 890 889 } 891 - log.Println("failed to fetch branches", err) 890 + s.logger.Error("failed to fetch branches", "err", err) 892 891 return 893 892 } 894 893 895 894 var result types.RepoBranchesResponse 896 895 if err := json.Unmarshal(xrpcBytes, &result); err != nil { 897 - log.Println("failed to decode XRPC response", err) 896 + s.logger.Error("failed to decode XRPC response", "err", err) 898 897 s.pages.Error503(w) 899 898 return 900 899 } ··· 1050 1049 xrpcBytes, err := tangled.RepoCompare(r.Context(), xrpcc, didSlashRepo, targetBranch, sourceBranch) 1051 1050 if err != nil { 1052 1051 if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil { 1053 - log.Println("failed to call XRPC repo.compare", xrpcerr) 1052 + s.logger.Error("failed to call XRPC repo.compare", "err", xrpcerr) 1054 1053 s.pages.Notice(w, "pull", "Failed to create pull request. Try again later.") 1055 1054 return 1056 1055 } 1057 - log.Println("failed to compare", err) 1056 + s.logger.Error("failed to compare", "err", err) 1058 1057 s.pages.Notice(w, "pull", err.Error()) 1059 1058 return 1060 1059 } 1061 1060 1062 1061 var comparison types.RepoFormatPatchResponse 1063 1062 if err := json.Unmarshal(xrpcBytes, &comparison); err != nil { 1064 - log.Println("failed to decode XRPC compare response", err) 1063 + s.logger.Error("failed to decode XRPC compare response", "err", err) 1065 1064 s.pages.Notice(w, "pull", "Failed to create pull request. Try again later.") 1066 1065 return 1067 1066 } ··· 1106 1105 s.pages.Notice(w, "pull", "No such fork.") 1107 1106 return 1108 1107 } else if err != nil { 1109 - log.Println("failed to fetch fork:", err) 1108 + s.logger.Error("failed to fetch fork:", "err", err) 1110 1109 s.pages.Notice(w, "pull", "Failed to fetch fork.") 1111 1110 return 1112 1111 } ··· 1160 1159 forkXrpcBytes, err := tangled.RepoCompare(r.Context(), forkXrpcc, forkRepoId, hiddenRef, sourceBranch) 1161 1160 if err != nil { 1162 1161 if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil { 1163 - log.Println("failed to call XRPC repo.compare for fork", xrpcerr) 1162 + s.logger.Error("failed to call XRPC repo.compare for fork", "err", xrpcerr) 1164 1163 s.pages.Notice(w, "pull", "Failed to create pull request. Try again later.") 1165 1164 return 1166 1165 } 1167 - log.Println("failed to compare across branches", err) 1166 + s.logger.Error("failed to compare across branches", "err", err) 1168 1167 s.pages.Notice(w, "pull", err.Error()) 1169 1168 return 1170 1169 } 1171 1170 1172 1171 var comparison types.RepoFormatPatchResponse 1173 1172 if err := json.Unmarshal(forkXrpcBytes, &comparison); err != nil { 1174 - log.Println("failed to decode XRPC compare response for fork", err) 1173 + s.logger.Error("failed to decode XRPC compare response for fork", "err", err) 1175 1174 s.pages.Notice(w, "pull", "Failed to create pull request. Try again later.") 1176 1175 return 1177 1176 } ··· 1232 1231 1233 1232 client, err := s.oauth.AuthorizedClient(r) 1234 1233 if err != nil { 1235 - log.Println("failed to get authorized client", err) 1234 + s.logger.Error("failed to get authorized client", "err", err) 1236 1235 s.pages.Notice(w, "pull", "Failed to create pull request. Try again later.") 1237 1236 return 1238 1237 } 1239 1238 1240 1239 tx, err := s.db.BeginTx(r.Context(), nil) 1241 1240 if err != nil { 1242 - log.Println("failed to start tx") 1241 + s.logger.Error("failed to start tx", "err", err) 1243 1242 s.pages.Notice(w, "pull", "Failed to create pull request. Try again later.") 1244 1243 return 1245 1244 } ··· 1290 1289 } 1291 1290 err = db.NewPull(tx, pull) 1292 1291 if err != nil { 1293 - log.Println("failed to create pull request", err) 1292 + s.logger.Error("failed to create pull request", "err", err) 1294 1293 s.pages.Notice(w, "pull", "Failed to create pull request. Try again later.") 1295 1294 return 1296 1295 } 1297 1296 pullId, err := db.NextPullId(tx, repo.RepoAt()) 1298 1297 if err != nil { 1299 - log.Println("failed to get pull id", err) 1298 + s.logger.Error("failed to get pull id", "err", err) 1300 1299 s.pages.Notice(w, "pull", "Failed to create pull request. Try again later.") 1301 1300 return 1302 1301 } 1303 1302 1304 1303 blob, err := xrpc.RepoUploadBlob(r.Context(), client, gz(patch), ApplicationGzip) 1305 1304 if err != nil { 1306 - log.Println("failed to upload patch", err) 1305 + s.logger.Error("failed to upload patch", "err", err) 1307 1306 s.pages.Notice(w, "pull", "Failed to create pull request. Try again later.") 1308 1307 return 1309 1308 } ··· 1326 1325 }, 1327 1326 }) 1328 1327 if err != nil { 1329 - log.Println("failed to create pull request", err) 1328 + s.logger.Error("failed to create pull request", "err", err) 1330 1329 s.pages.Notice(w, "pull", "Failed to create pull request. Try again later.") 1331 1330 return 1332 1331 } 1333 1332 1334 1333 if err = tx.Commit(); err != nil { 1335 - log.Println("failed to create pull request", err) 1334 + s.logger.Error("failed to create pull request", "err", err) 1336 1335 s.pages.Notice(w, "pull", "Failed to create pull request. Try again later.") 1337 1336 return 1338 1337 } ··· 1357 1356 1358 1357 // must be branch or fork based 1359 1358 if sourceRev == "" { 1360 - log.Println("stacked PR from patch-based pull") 1359 + s.logger.Warn("stacked PR from patch-based pull") 1361 1360 s.pages.Notice(w, "pull", "Stacking is only supported on branch and fork based pull-requests.") 1362 1361 return 1363 1362 } 1364 1363 1365 1364 formatPatches, err := patchutil.ExtractPatches(patch) 1366 1365 if err != nil { 1367 - log.Println("failed to extract patches", err) 1366 + s.logger.Error("failed to extract patches", "err", err) 1368 1367 s.pages.Notice(w, "pull", fmt.Sprintf("Failed to extract patches: %v", err)) 1369 1368 return 1370 1369 } 1371 1370 1372 1371 // must have atleast 1 patch to begin with 1373 1372 if len(formatPatches) == 0 { 1374 - log.Println("empty patches") 1373 + s.logger.Error("empty patches") 1375 1374 s.pages.Notice(w, "pull", "No patches found in the generated format-patch.") 1376 1375 return 1377 1376 } ··· 1380 1379 stackId := uuid.New() 1381 1380 stack, err := s.newStack(r.Context(), repo, user, targetBranch, patch, pullSource, stackId.String()) 1382 1381 if err != nil { 1383 - log.Println("failed to create stack", err) 1382 + s.logger.Error("failed to create stack", "err", err) 1384 1383 s.pages.Notice(w, "pull", fmt.Sprintf("Failed to create stack: %v", err)) 1385 1384 return 1386 1385 } 1387 1386 1388 1387 client, err := s.oauth.AuthorizedClient(r) 1389 1388 if err != nil { 1390 - log.Println("failed to get authorized client", err) 1389 + s.logger.Error("failed to get authorized client", "err", err) 1391 1390 s.pages.Notice(w, "pull", "Failed to create pull request. Try again later.") 1392 1391 return 1393 1392 } ··· 1397 1396 for _, p := range stack { 1398 1397 blob, err := xrpc.RepoUploadBlob(r.Context(), client, gz(p.LatestPatch()), ApplicationGzip) 1399 1398 if err != nil { 1400 - log.Println("failed to upload patch blob", err) 1399 + s.logger.Error("failed to upload patch blob", "err", err) 1401 1400 s.pages.Notice(w, "pull", "Failed to create pull request. Try again later.") 1402 1401 return 1403 1402 } ··· 1419 1418 Writes: writes, 1420 1419 }) 1421 1420 if err != nil { 1422 - log.Println("failed to create stacked pull request", err) 1421 + s.logger.Error("failed to create stacked pull request", "err", err) 1423 1422 s.pages.Notice(w, "pull", "Failed to create stacked pull request. Try again later.") 1424 1423 return 1425 1424 } ··· 1427 1426 // create all pulls at once 1428 1427 tx, err := s.db.BeginTx(r.Context(), nil) 1429 1428 if err != nil { 1430 - log.Println("failed to start tx") 1429 + s.logger.Error("failed to start tx", "err", err) 1431 1430 s.pages.Notice(w, "pull", "Failed to create pull request. Try again later.") 1432 1431 return 1433 1432 } ··· 1436 1435 for _, p := range stack { 1437 1436 err = db.NewPull(tx, p) 1438 1437 if err != nil { 1439 - log.Println("failed to create pull request", err) 1438 + s.logger.Error("failed to create pull request", "err", err) 1440 1439 s.pages.Notice(w, "pull", "Failed to create pull request. Try again later.") 1441 1440 return 1442 1441 } ··· 1444 1443 } 1445 1444 1446 1445 if err = tx.Commit(); err != nil { 1447 - log.Println("failed to create pull request", err) 1446 + s.logger.Error("failed to create pull request", "err", err) 1448 1447 s.pages.Notice(w, "pull", "Failed to create pull request. Try again later.") 1449 1448 return 1450 1449 } ··· 1463 1462 func (s *Pulls) ValidatePatch(w http.ResponseWriter, r *http.Request) { 1464 1463 _, err := s.repoResolver.Resolve(r) 1465 1464 if err != nil { 1466 - log.Println("failed to get repo and knot", err) 1465 + s.logger.Error("failed to get repo and knot", "err", err) 1467 1466 return 1468 1467 } 1469 1468 ··· 1498 1497 user := s.oauth.GetMultiAccountUser(r) 1499 1498 f, err := s.repoResolver.Resolve(r) 1500 1499 if err != nil { 1501 - log.Println("failed to get repo and knot", err) 1500 + s.logger.Error("failed to get repo and knot", "err", err) 1502 1501 return 1503 1502 } 1504 1503 ··· 1506 1505 1507 1506 xrpcBytes, err := tangled.GitTempListBranches(r.Context(), xrpcc, "", 0, f.RepoAt().String()) 1508 1507 if err != nil { 1509 - log.Println("failed to fetch branches", err) 1508 + s.logger.Error("failed to fetch branches", "err", err) 1510 1509 s.pages.Error503(w) 1511 1510 return 1512 1511 } 1513 1512 1514 1513 var result types.RepoBranchesResponse 1515 1514 if err := json.Unmarshal(xrpcBytes, &result); err != nil { 1516 - log.Println("failed to decode XRPC response", err) 1515 + s.logger.Error("failed to decode XRPC response", "err", err) 1517 1516 s.pages.Error503(w) 1518 1517 return 1519 1518 } ··· 1542 1541 1543 1542 forks, err := db.GetForksByDid(s.db, user.Active.Did) 1544 1543 if err != nil { 1545 - log.Println("failed to get forks", err) 1544 + s.logger.Error("failed to get forks", "err", err) 1546 1545 return 1547 1546 } 1548 1547 ··· 1558 1557 1559 1558 f, err := s.repoResolver.Resolve(r) 1560 1559 if err != nil { 1561 - log.Println("failed to get repo and knot", err) 1560 + s.logger.Error("failed to get repo and knot", "err", err) 1562 1561 return 1563 1562 } 1564 1563 ··· 1575 1574 orm.FilterEq("name", forkName), 1576 1575 ) 1577 1576 if err != nil { 1578 - log.Println("failed to get repo", "did", forkOwnerDid, "name", forkName, "err", err) 1577 + s.logger.Error("failed to get repo", "did", forkOwnerDid, "name", forkName, "err", err) 1579 1578 return 1580 1579 } 1581 1580 1582 1581 sourceXrpcBytes, err := tangled.GitTempListBranches(r.Context(), xrpcc, "", 0, repo.RepoAt().String()) 1583 1582 if err != nil { 1584 1583 if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil { 1585 - log.Println("failed to call XRPC repo.branches for source", xrpcerr) 1584 + s.logger.Error("failed to call XRPC repo.branches for source", "err", xrpcerr) 1586 1585 s.pages.Error503(w) 1587 1586 return 1588 1587 } 1589 - log.Println("failed to fetch source branches", err) 1588 + s.logger.Error("failed to fetch source branches", "err", err) 1590 1589 return 1591 1590 } 1592 1591 1593 1592 // Decode source branches 1594 1593 var sourceBranches types.RepoBranchesResponse 1595 1594 if err := json.Unmarshal(sourceXrpcBytes, &sourceBranches); err != nil { 1596 - log.Println("failed to decode source branches XRPC response", err) 1595 + s.logger.Error("failed to decode source branches XRPC response", "err", err) 1597 1596 s.pages.Error503(w) 1598 1597 return 1599 1598 } ··· 1601 1600 targetXrpcBytes, err := tangled.GitTempListBranches(r.Context(), xrpcc, "", 0, f.RepoAt().String()) 1602 1601 if err != nil { 1603 1602 if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil { 1604 - log.Println("failed to call XRPC repo.branches for target", xrpcerr) 1603 + s.logger.Error("failed to call XRPC repo.branches for target", "err", xrpcerr) 1605 1604 s.pages.Error503(w) 1606 1605 return 1607 1606 } 1608 - log.Println("failed to fetch target branches", err) 1607 + s.logger.Error("failed to fetch target branches", "err", err) 1609 1608 return 1610 1609 } 1611 1610 1612 1611 // Decode target branches 1613 1612 var targetBranches types.RepoBranchesResponse 1614 1613 if err := json.Unmarshal(targetXrpcBytes, &targetBranches); err != nil { 1615 - log.Println("failed to decode target branches XRPC response", err) 1614 + s.logger.Error("failed to decode target branches XRPC response", "err", err) 1616 1615 s.pages.Error503(w) 1617 1616 return 1618 1617 } ··· 1633 1632 1634 1633 pull, ok := r.Context().Value("pull").(*models.Pull) 1635 1634 if !ok { 1636 - log.Println("failed to get pull") 1635 + s.logger.Error("failed to get pull") 1637 1636 s.pages.Notice(w, "pull-error", "Failed to edit patch. Try again later.") 1638 1637 return 1639 1638 } ··· 1664 1663 1665 1664 pull, ok := r.Context().Value("pull").(*models.Pull) 1666 1665 if !ok { 1667 - log.Println("failed to get pull") 1666 + s.logger.Error("failed to get pull") 1668 1667 s.pages.Notice(w, "pull-error", "Failed to edit patch. Try again later.") 1669 1668 return 1670 1669 } 1671 1670 1672 1671 f, err := s.repoResolver.Resolve(r) 1673 1672 if err != nil { 1674 - log.Println("failed to get repo and knot", err) 1673 + s.logger.Error("failed to get repo and knot", "err", err) 1675 1674 return 1676 1675 } 1677 1676 1678 1677 if user.Active.Did != pull.OwnerDid { 1679 - log.Println("unauthorized user") 1678 + s.logger.Warn("unauthorized user") 1680 1679 w.WriteHeader(http.StatusUnauthorized) 1681 1680 return 1682 1681 } ··· 1691 1690 1692 1691 pull, ok := r.Context().Value("pull").(*models.Pull) 1693 1692 if !ok { 1694 - log.Println("failed to get pull") 1693 + s.logger.Error("failed to get pull") 1695 1694 s.pages.Notice(w, "resubmit-error", "Failed to edit patch. Try again later.") 1696 1695 return 1697 1696 } 1698 1697 1699 1698 f, err := s.repoResolver.Resolve(r) 1700 1699 if err != nil { 1701 - log.Println("failed to get repo and knot", err) 1700 + s.logger.Error("failed to get repo and knot", "err", err) 1702 1701 return 1703 1702 } 1704 1703 1705 1704 if user.Active.Did != pull.OwnerDid { 1706 - log.Println("unauthorized user") 1705 + s.logger.Warn("unauthorized user") 1707 1706 w.WriteHeader(http.StatusUnauthorized) 1708 1707 return 1709 1708 } 1710 1709 1711 1710 roles := repoinfo.RolesInRepo{Roles: s.enforcer.GetPermissionsInRepo(user.Active.Did, f.Knot, f.DidSlashRepo())} 1712 1711 if !roles.IsPushAllowed() { 1713 - log.Println("unauthorized user") 1712 + s.logger.Warn("unauthorized user") 1714 1713 w.WriteHeader(http.StatusUnauthorized) 1715 1714 return 1716 1715 } ··· 1728 1727 xrpcBytes, err := tangled.RepoCompare(r.Context(), xrpcc, repo, pull.TargetBranch, pull.PullSource.Branch) 1729 1728 if err != nil { 1730 1729 if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil { 1731 - log.Println("failed to call XRPC repo.compare", xrpcerr) 1730 + s.logger.Error("failed to call XRPC repo.compare", "err", xrpcerr) 1732 1731 s.pages.Notice(w, "resubmit-error", "Failed to create pull request. Try again later.") 1733 1732 return 1734 1733 } 1735 - log.Printf("compare request failed: %s", err) 1734 + s.logger.Error("compare request failed", "err", err) 1736 1735 s.pages.Notice(w, "resubmit-error", err.Error()) 1737 1736 return 1738 1737 } 1739 1738 1740 1739 var comparison types.RepoFormatPatchResponse 1741 1740 if err := json.Unmarshal(xrpcBytes, &comparison); err != nil { 1742 - log.Println("failed to decode XRPC compare response", err) 1741 + s.logger.Error("failed to decode XRPC compare response", "err", err) 1743 1742 s.pages.Notice(w, "resubmit-error", "Failed to create pull request. Try again later.") 1744 1743 return 1745 1744 } ··· 1756 1755 1757 1756 pull, ok := r.Context().Value("pull").(*models.Pull) 1758 1757 if !ok { 1759 - log.Println("failed to get pull") 1758 + s.logger.Error("failed to get pull") 1760 1759 s.pages.Notice(w, "resubmit-error", "Failed to edit patch. Try again later.") 1761 1760 return 1762 1761 } 1763 1762 1764 1763 f, err := s.repoResolver.Resolve(r) 1765 1764 if err != nil { 1766 - log.Println("failed to get repo and knot", err) 1765 + s.logger.Error("failed to get repo and knot", "err", err) 1767 1766 return 1768 1767 } 1769 1768 1770 1769 if user.Active.Did != pull.OwnerDid { 1771 - log.Println("unauthorized user") 1770 + s.logger.Warn("unauthorized user") 1772 1771 w.WriteHeader(http.StatusUnauthorized) 1773 1772 return 1774 1773 } 1775 1774 1776 1775 forkRepo, err := db.GetRepoByAtUri(s.db, pull.PullSource.RepoAt.String()) 1777 1776 if err != nil { 1778 - log.Println("failed to get source repo", err) 1777 + s.logger.Error("failed to get source repo", "err", err) 1779 1778 s.pages.Notice(w, "resubmit-error", "Failed to create pull request. Try again later.") 1780 1779 return 1781 1780 } ··· 1788 1787 oauth.WithDev(s.config.Core.Dev), 1789 1788 ) 1790 1789 if err != nil { 1791 - log.Printf("failed to connect to knot server: %v", err) 1790 + s.logger.Error("failed to connect to knot server", "err", err) 1792 1791 return 1793 1792 } 1794 1793 ··· 1806 1805 return 1807 1806 } 1808 1807 if !resp.Success { 1809 - log.Println("Failed to update tracking ref.", "err", resp.Error) 1808 + s.logger.Warn("failed to update tracking ref", "err", resp.Error) 1810 1809 s.pages.Notice(w, "resubmit-error", "Failed to update tracking ref.") 1811 1810 return 1812 1811 } ··· 1822 1821 forkXrpcBytes, err := tangled.RepoCompare(r.Context(), &indigoxrpc.Client{Host: forkHost}, forkRepoId, hiddenRef, pull.PullSource.Branch) 1823 1822 if err != nil { 1824 1823 if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil { 1825 - log.Println("failed to call XRPC repo.compare for fork", xrpcerr) 1824 + s.logger.Error("failed to call XRPC repo.compare for fork", "err", xrpcerr) 1826 1825 s.pages.Notice(w, "resubmit-error", "Failed to create pull request. Try again later.") 1827 1826 return 1828 1827 } 1829 - log.Printf("failed to compare branches: %s", err) 1828 + s.logger.Error("failed to compare branches", "err", err) 1830 1829 s.pages.Notice(w, "resubmit-error", "Failed to create pull request. Try again later.") 1831 1830 return 1832 1831 } 1833 1832 1834 1833 var forkComparison types.RepoFormatPatchResponse 1835 1834 if err := json.Unmarshal(forkXrpcBytes, &forkComparison); err != nil { 1836 - log.Println("failed to decode XRPC compare response for fork", err) 1835 + s.logger.Error("failed to decode XRPC compare response for fork", "err", err) 1837 1836 s.pages.Notice(w, "resubmit-error", "Failed to create pull request. Try again later.") 1838 1837 return 1839 1838 } ··· 1859 1858 sourceRev string, 1860 1859 ) { 1861 1860 if pull.IsStacked() { 1862 - log.Println("resubmitting stacked PR") 1861 + s.logger.Info("resubmitting stacked PR") 1863 1862 s.resubmitStackedPullHelper(w, r, repo, user, pull, patch, pull.StackId) 1864 1863 return 1865 1864 } ··· 1884 1883 1885 1884 tx, err := s.db.BeginTx(r.Context(), nil) 1886 1885 if err != nil { 1887 - log.Println("failed to start tx") 1886 + s.logger.Error("failed to start tx", "err", err) 1888 1887 s.pages.Notice(w, "resubmit-error", "Failed to create pull request. Try again later.") 1889 1888 return 1890 1889 } ··· 1897 1896 combinedPatch := combined 1898 1897 err = db.ResubmitPull(tx, pullAt, newRoundNumber, newPatch, combinedPatch, newSourceRev) 1899 1898 if err != nil { 1900 - log.Println("failed to create pull request", err) 1899 + s.logger.Error("failed to create pull request", "err", err) 1901 1900 s.pages.Notice(w, "resubmit-error", "Failed to create pull request. Try again later.") 1902 1901 return 1903 1902 } 1904 1903 client, err := s.oauth.AuthorizedClient(r) 1905 1904 if err != nil { 1906 - log.Println("failed to authorize client") 1905 + s.logger.Error("failed to authorize client", "err", err) 1907 1906 s.pages.Notice(w, "resubmit-error", "Failed to create pull request. Try again later.") 1908 1907 return 1909 1908 } ··· 1917 1916 1918 1917 blob, err := xrpc.RepoUploadBlob(r.Context(), client, gz(patch), ApplicationGzip) 1919 1918 if err != nil { 1920 - log.Println("failed to upload patch blob", err) 1919 + s.logger.Error("failed to upload patch blob", "err", err) 1921 1920 s.pages.Notice(w, "resubmit-error", "Failed to update pull request on the PDS. Try again later.") 1922 1921 return 1923 1922 } ··· 1939 1938 }, 1940 1939 }) 1941 1940 if err != nil { 1942 - log.Println("failed to update record", err) 1941 + s.logger.Error("failed to update record", "err", err) 1943 1942 s.pages.Notice(w, "resubmit-error", "Failed to update pull request on the PDS. Try again later.") 1944 1943 return 1945 1944 } 1946 1945 1947 1946 if err = tx.Commit(); err != nil { 1948 - log.Println("failed to commit transaction", err) 1947 + s.logger.Error("failed to commit transaction", "err", err) 1949 1948 s.pages.Notice(w, "resubmit-error", "Failed to resubmit pull.") 1950 1949 return 1951 1950 } ··· 1968 1967 origStack, _ := r.Context().Value("stack").(models.Stack) 1969 1968 newStack, err := s.newStack(r.Context(), repo, user, targetBranch, patch, pull.PullSource, stackId) 1970 1969 if err != nil { 1971 - log.Println("failed to create resubmitted stack", err) 1970 + s.logger.Error("failed to create resubmitted stack", "err", err) 1972 1971 s.pages.Notice(w, "pull-merge-error", "Failed to merge pull request. Try again later.") 1973 1972 return 1974 1973 } ··· 2015 2014 2016 2015 tx, err := s.db.Begin() 2017 2016 if err != nil { 2018 - log.Println("failed to start transaction", err) 2017 + s.logger.Error("failed to start transaction", "err", err) 2019 2018 s.pages.Notice(w, "pull-resubmit-error", "Failed to resubmit pull request. Try again later.") 2020 2019 return 2021 2020 } ··· 2023 2022 2024 2023 client, err := s.oauth.AuthorizedClient(r) 2025 2024 if err != nil { 2026 - log.Println("failed to authorize client") 2025 + s.logger.Error("failed to authorize client", "err", err) 2027 2026 s.pages.Notice(w, "resubmit-error", "Failed to create pull request. Try again later.") 2028 2027 return 2029 2028 } ··· 2040 2039 2041 2040 err := db.DeletePull(tx, p.RepoAt, p.PullId) 2042 2041 if err != nil { 2043 - log.Println("failed to delete pull", err, p.PullId) 2042 + s.logger.Error("failed to delete pull", "err", err, "pull_id", p.PullId) 2044 2043 s.pages.Notice(w, "pull-resubmit-error", "Failed to resubmit pull request. Try again later.") 2045 2044 return 2046 2045 } ··· 2056 2055 for _, p := range additions { 2057 2056 err := db.NewPull(tx, p) 2058 2057 if err != nil { 2059 - log.Println("failed to create pull", err, p.PullId) 2058 + s.logger.Error("failed to create pull", "err", err, "pull_id", p.PullId) 2060 2059 s.pages.Notice(w, "pull-resubmit-error", "Failed to resubmit pull request. Try again later.") 2061 2060 return 2062 2061 } 2063 2062 2064 2063 blob, err := xrpc.RepoUploadBlob(r.Context(), client, gz(patch), ApplicationGzip) 2065 2064 if err != nil { 2066 - log.Println("failed to upload patch blob", err) 2065 + s.logger.Error("failed to upload patch blob", "err", err) 2067 2066 s.pages.Notice(w, "resubmit-error", "Failed to update pull request on the PDS. Try again later.") 2068 2067 return 2069 2068 } ··· 2098 2097 newSourceRev := np.LatestSha() 2099 2098 err := db.ResubmitPull(tx, pullAt, newRoundNumber, newPatch, combinedPatch, newSourceRev) 2100 2099 if err != nil { 2101 - log.Println("failed to update pull", err, op.PullId) 2100 + s.logger.Error("failed to update pull", "err", err, "pull_id", op.PullId) 2102 2101 s.pages.Notice(w, "pull-resubmit-error", "Failed to resubmit pull request. Try again later.") 2103 2102 return 2104 2103 } 2105 2104 2106 2105 blob, err := xrpc.RepoUploadBlob(r.Context(), client, gz(patch), ApplicationGzip) 2107 2106 if err != nil { 2108 - log.Println("failed to upload patch blob", err) 2107 + s.logger.Error("failed to upload patch blob", "err", err) 2109 2108 s.pages.Notice(w, "resubmit-error", "Failed to update pull request on the PDS. Try again later.") 2110 2109 return 2111 2110 } ··· 2134 2133 ) 2135 2134 2136 2135 if err != nil { 2137 - log.Println("failed to update pull", err, p.PullId) 2136 + s.logger.Error("failed to update pull", "err", err, "pull_id", p.PullId) 2138 2137 s.pages.Notice(w, "pull-resubmit-error", "Failed to resubmit pull request. Try again later.") 2139 2138 return 2140 2139 } ··· 2142 2141 2143 2142 err = tx.Commit() 2144 2143 if err != nil { 2145 - log.Println("failed to resubmit pull", err) 2144 + s.logger.Error("failed to resubmit pull", "err", err) 2146 2145 s.pages.Notice(w, "pull-resubmit-error", "Failed to resubmit pull request. Try again later.") 2147 2146 return 2148 2147 } ··· 2152 2151 Writes: writes, 2153 2152 }) 2154 2153 if err != nil { 2155 - log.Println("failed to create stacked pull request", err) 2154 + s.logger.Error("failed to create stacked pull request", "err", err) 2156 2155 s.pages.Notice(w, "pull", "Failed to create stacked pull request. Try again later.") 2157 2156 return 2158 2157 } ··· 2165 2164 user := s.oauth.GetMultiAccountUser(r) 2166 2165 f, err := s.repoResolver.Resolve(r) 2167 2166 if err != nil { 2168 - log.Println("failed to resolve repo:", err) 2167 + s.logger.Error("failed to resolve repo:", "err", err) 2169 2168 s.pages.Notice(w, "pull-merge-error", "Failed to merge pull request. Try again later.") 2170 2169 return 2171 2170 } 2172 2171 2173 2172 pull, ok := r.Context().Value("pull").(*models.Pull) 2174 2173 if !ok { 2175 - log.Println("failed to get pull") 2174 + s.logger.Error("failed to get pull") 2176 2175 s.pages.Notice(w, "pull-merge-error", "Failed to merge patch. Try again later.") 2177 2176 return 2178 2177 } ··· 2182 2181 if pull.IsStacked() { 2183 2182 stack, ok := r.Context().Value("stack").(models.Stack) 2184 2183 if !ok { 2185 - log.Println("failed to get stack") 2184 + s.logger.Error("failed to get stack") 2186 2185 s.pages.Notice(w, "pull-merge-error", "Failed to merge patch. Try again later.") 2187 2186 return 2188 2187 } ··· 2199 2198 2200 2199 ident, err := s.idResolver.ResolveIdent(r.Context(), pull.OwnerDid) 2201 2200 if err != nil { 2202 - log.Printf("resolving identity: %s", err) 2201 + s.logger.Error("resolving identity", "err", err) 2203 2202 w.WriteHeader(http.StatusNotFound) 2204 2203 return 2205 2204 } 2206 2205 2207 2206 email, err := db.GetPrimaryEmail(s.db, pull.OwnerDid) 2208 2207 if err != nil { 2209 - log.Printf("failed to get primary email: %s", err) 2208 + s.logger.Error("failed to get primary email", "err", err) 2210 2209 } 2211 2210 2212 2211 authorName := ident.Handle.String() ··· 2234 2233 oauth.WithDev(s.config.Core.Dev), 2235 2234 ) 2236 2235 if err != nil { 2237 - log.Printf("failed to connect to knot server: %v", err) 2236 + s.logger.Error("failed to connect to knot server", "err", err) 2238 2237 s.pages.Notice(w, "pull-merge-error", "Failed to merge pull request. Try again later.") 2239 2238 return 2240 2239 } ··· 2247 2246 2248 2247 tx, err := s.db.Begin() 2249 2248 if err != nil { 2250 - log.Println("failed to start transcation", err) 2249 + s.logger.Error("failed to start transaction", "err", err) 2251 2250 s.pages.Notice(w, "pull-merge-error", "Failed to merge pull request. Try again later.") 2252 2251 return 2253 2252 } ··· 2256 2255 for _, p := range pullsToMerge { 2257 2256 err := db.MergePull(tx, f.RepoAt(), p.PullId) 2258 2257 if err != nil { 2259 - log.Printf("failed to update pull request status in database: %s", err) 2258 + s.logger.Error("failed to update pull request status in database", "err", err) 2260 2259 s.pages.Notice(w, "pull-merge-error", "Failed to merge pull request. Try again later.") 2261 2260 return 2262 2261 } ··· 2266 2265 err = tx.Commit() 2267 2266 if err != nil { 2268 2267 // TODO: this is unsound, we should also revert the merge from the knotserver here 2269 - log.Printf("failed to update pull request status in database: %s", err) 2268 + s.logger.Error("failed to update pull request status in database", "err", err) 2270 2269 s.pages.Notice(w, "pull-merge-error", "Failed to merge pull request. Try again later.") 2271 2270 return 2272 2271 } ··· 2285 2284 2286 2285 f, err := s.repoResolver.Resolve(r) 2287 2286 if err != nil { 2288 - log.Println("malformed middleware") 2287 + s.logger.Error("malformed middleware", "err", err) 2289 2288 return 2290 2289 } 2291 2290 2292 2291 pull, ok := r.Context().Value("pull").(*models.Pull) 2293 2292 if !ok { 2294 - log.Println("failed to get pull") 2293 + s.logger.Error("failed to get pull") 2295 2294 s.pages.Notice(w, "pull-error", "Failed to edit patch. Try again later.") 2296 2295 return 2297 2296 } ··· 2303 2302 isPullAuthor := user.Active.Did == pull.OwnerDid 2304 2303 isCloseAllowed := isOwner || isCollaborator || isPullAuthor 2305 2304 if !isCloseAllowed { 2306 - log.Println("failed to close pull") 2305 + s.logger.Warn("failed to close pull: unauthorized") 2307 2306 s.pages.Notice(w, "pull-close", "You are unauthorized to close this pull.") 2308 2307 return 2309 2308 } ··· 2311 2310 // Start a transaction 2312 2311 tx, err := s.db.BeginTx(r.Context(), nil) 2313 2312 if err != nil { 2314 - log.Println("failed to start transaction", err) 2313 + s.logger.Error("failed to start transaction", "err", err) 2315 2314 s.pages.Notice(w, "pull-close", "Failed to close pull.") 2316 2315 return 2317 2316 } ··· 2331 2330 // Close the pull in the database 2332 2331 err = db.ClosePull(tx, f.RepoAt(), p.PullId) 2333 2332 if err != nil { 2334 - log.Println("failed to close pull", err) 2333 + s.logger.Error("failed to close pull", "err", err) 2335 2334 s.pages.Notice(w, "pull-close", "Failed to close pull.") 2336 2335 return 2337 2336 } ··· 2340 2339 2341 2340 // Commit the transaction 2342 2341 if err = tx.Commit(); err != nil { 2343 - log.Println("failed to commit transaction", err) 2342 + s.logger.Error("failed to commit transaction", "err", err) 2344 2343 s.pages.Notice(w, "pull-close", "Failed to close pull.") 2345 2344 return 2346 2345 } ··· 2358 2357 2359 2358 f, err := s.repoResolver.Resolve(r) 2360 2359 if err != nil { 2361 - log.Println("failed to resolve repo", err) 2360 + s.logger.Error("failed to resolve repo", "err", err) 2362 2361 s.pages.Notice(w, "pull-reopen", "Failed to reopen pull.") 2363 2362 return 2364 2363 } 2365 2364 2366 2365 pull, ok := r.Context().Value("pull").(*models.Pull) 2367 2366 if !ok { 2368 - log.Println("failed to get pull") 2367 + s.logger.Error("failed to get pull") 2369 2368 s.pages.Notice(w, "pull-error", "Failed to edit patch. Try again later.") 2370 2369 return 2371 2370 } ··· 2377 2376 isPullAuthor := user.Active.Did == pull.OwnerDid 2378 2377 isCloseAllowed := isOwner || isCollaborator || isPullAuthor 2379 2378 if !isCloseAllowed { 2380 - log.Println("failed to close pull") 2379 + s.logger.Warn("failed to close pull: unauthorized") 2381 2380 s.pages.Notice(w, "pull-close", "You are unauthorized to close this pull.") 2382 2381 return 2383 2382 } ··· 2385 2384 // Start a transaction 2386 2385 tx, err := s.db.BeginTx(r.Context(), nil) 2387 2386 if err != nil { 2388 - log.Println("failed to start transaction", err) 2387 + s.logger.Error("failed to start transaction", "err", err) 2389 2388 s.pages.Notice(w, "pull-reopen", "Failed to reopen pull.") 2390 2389 return 2391 2390 } ··· 2405 2404 // Close the pull in the database 2406 2405 err = db.ReopenPull(tx, f.RepoAt(), p.PullId) 2407 2406 if err != nil { 2408 - log.Println("failed to close pull", err) 2407 + s.logger.Error("failed to close pull", "err", err) 2409 2408 s.pages.Notice(w, "pull-close", "Failed to close pull.") 2410 2409 return 2411 2410 } ··· 2414 2413 2415 2414 // Commit the transaction 2416 2415 if err = tx.Commit(); err != nil { 2417 - log.Println("failed to commit transaction", err) 2416 + s.logger.Error("failed to commit transaction", "err", err) 2418 2417 s.pages.Notice(w, "pull-reopen", "Failed to reopen pull.") 2419 2418 return 2420 2419 }