+36 -28

appview/db/db.go

reviewed

··· 4 4 "context" 5 5 "database/sql" 6 6 "fmt" 7 7 - "log" 7 7 + "log/slog" 8 8 "reflect" 9 9 "strings" 10 10 11 11 _ "github.com/mattn/go-sqlite3" 12 12 + "tangled.org/core/log" 12 13 ) 13 14 14 15 type DB struct { 15 16 *sql.DB 17 17 + logger *slog.Logger 16 18 } 17 19 18 20 type Execer interface { ··· 28 26 PrepareContext(ctx context.Context, query string) (*sql.Stmt, error) 29 27 } 30 28 31 31 - func Make(dbPath string) (*DB, error) { 29 29 + func Make(ctx context.Context, dbPath string) (*DB, error) { 32 30 // https://github.com/mattn/go-sqlite3#connection-string 33 31 opts := []string{ 34 32 "_foreign_keys=1", ··· 37 35 "_auto_vacuum=incremental", 38 36 } 39 37 38 38 + logger := log.FromContext(ctx) 39 39 + logger = log.SubLogger(logger, "db") 40 40 + 40 41 db, err := sql.Open("sqlite3", dbPath+"?"+strings.Join(opts, "&")) 41 42 if err != nil { 42 43 return nil, err 43 44 } 44 44 - 45 45 - ctx := context.Background() 46 45 47 46 conn, err := db.Conn(ctx) 48 47 if err != nil { ··· 577 574 } 578 575 579 576 // run migrations 580 580 - runMigration(conn, "add-description-to-repos", func(tx *sql.Tx) error { 577 577 + runMigration(conn, logger, "add-description-to-repos", func(tx *sql.Tx) error { 581 578 tx.Exec(` 582 579 alter table repos add column description text check (length(description) <= 200); 583 580 `) 584 581 return nil 585 582 }) 586 583 587 587 - runMigration(conn, "add-rkey-to-pubkeys", func(tx *sql.Tx) error { 584 584 + runMigration(conn, logger, "add-rkey-to-pubkeys", func(tx *sql.Tx) error { 588 585 // add unconstrained column 589 586 _, err := tx.Exec(` 590 587 alter table public_keys ··· 607 604 return nil 608 605 }) 609 606 610 610 - runMigration(conn, "add-rkey-to-comments", func(tx *sql.Tx) error { 607 607 + runMigration(conn, logger, "add-rkey-to-comments", func(tx *sql.Tx) error { 611 608 _, err := tx.Exec(` 612 609 alter table comments drop column comment_at; 613 610 alter table comments add column rkey text; ··· 615 612 return err 616 613 }) 617 614 618 618 - runMigration(conn, "add-deleted-and-edited-to-issue-comments", func(tx *sql.Tx) error { 615 615 + runMigration(conn, logger, "add-deleted-and-edited-to-issue-comments", func(tx *sql.Tx) error { 619 616 _, err := tx.Exec(` 620 617 alter table comments add column deleted text; -- timestamp 621 618 alter table comments add column edited text; -- timestamp ··· 623 620 return err 624 621 }) 625 622 626 626 - runMigration(conn, "add-source-info-to-pulls-and-submissions", func(tx *sql.Tx) error { 623 623 + runMigration(conn, logger, "add-source-info-to-pulls-and-submissions", func(tx *sql.Tx) error { 627 624 _, err := tx.Exec(` 628 625 alter table pulls add column source_branch text; 629 626 alter table pulls add column source_repo_at text; ··· 632 629 return err 633 630 }) 634 631 635 635 - runMigration(conn, "add-source-to-repos", func(tx *sql.Tx) error { 632 632 + runMigration(conn, logger, "add-source-to-repos", func(tx *sql.Tx) error { 636 633 _, err := tx.Exec(` 637 634 alter table repos add column source text; 638 635 `) ··· 644 641 // 645 642 // [0]: https://sqlite.org/pragma.html#pragma_foreign_keys 646 643 conn.ExecContext(ctx, "pragma foreign_keys = off;") 647 647 - runMigration(conn, "recreate-pulls-column-for-stacking-support", func(tx *sql.Tx) error { 644 644 + runMigration(conn, logger, "recreate-pulls-column-for-stacking-support", func(tx *sql.Tx) error { 648 645 _, err := tx.Exec(` 649 646 create table pulls_new ( 650 647 -- identifiers ··· 701 698 }) 702 699 conn.ExecContext(ctx, "pragma foreign_keys = on;") 703 700 704 704 - runMigration(conn, "add-spindle-to-repos", func(tx *sql.Tx) error { 701 701 + runMigration(conn, logger, "add-spindle-to-repos", func(tx *sql.Tx) error { 705 702 tx.Exec(` 706 703 alter table repos add column spindle text; 707 704 `) ··· 711 708 // drop all knot secrets, add unique constraint to knots 712 709 // 713 710 // knots will henceforth use service auth for signed requests 714 714 - runMigration(conn, "no-more-secrets", func(tx *sql.Tx) error { 711 711 + runMigration(conn, logger, "no-more-secrets", func(tx *sql.Tx) error { 715 712 _, err := tx.Exec(` 716 713 create table registrations_new ( 717 714 id integer primary key autoincrement, ··· 734 731 }) 735 732 736 733 // recreate and add rkey + created columns with default constraint 737 737 - runMigration(conn, "rework-collaborators-table", func(tx *sql.Tx) error { 734 734 + runMigration(conn, logger, "rework-collaborators-table", func(tx *sql.Tx) error { 738 735 // create new table 739 736 // - repo_at instead of repo integer 740 737 // - rkey field ··· 788 785 return err 789 786 }) 790 787 791 791 - runMigration(conn, "add-rkey-to-issues", func(tx *sql.Tx) error { 788 788 + runMigration(conn, logger, "add-rkey-to-issues", func(tx *sql.Tx) error { 792 789 _, err := tx.Exec(` 793 790 alter table issues add column rkey text not null default ''; 794 791 ··· 800 797 }) 801 798 802 799 // repurpose the read-only column to "needs-upgrade" 803 803 - runMigration(conn, "rename-registrations-read-only-to-needs-upgrade", func(tx *sql.Tx) error { 800 800 + runMigration(conn, logger, "rename-registrations-read-only-to-needs-upgrade", func(tx *sql.Tx) error { 804 801 _, err := tx.Exec(` 805 802 alter table registrations rename column read_only to needs_upgrade; 806 803 `) ··· 808 805 }) 809 806 810 807 // require all knots to upgrade after the release of total xrpc 811 811 - runMigration(conn, "migrate-knots-to-total-xrpc", func(tx *sql.Tx) error { 808 808 + runMigration(conn, logger, "migrate-knots-to-total-xrpc", func(tx *sql.Tx) error { 812 809 _, err := tx.Exec(` 813 810 update registrations set needs_upgrade = 1; 814 811 `) ··· 816 813 }) 817 814 818 815 // require all knots to upgrade after the release of total xrpc 819 819 - runMigration(conn, "migrate-spindles-to-xrpc-owner", func(tx *sql.Tx) error { 816 816 + runMigration(conn, logger, "migrate-spindles-to-xrpc-owner", func(tx *sql.Tx) error { 820 817 _, err := tx.Exec(` 821 818 alter table spindles add column needs_upgrade integer not null default 0; 822 819 `) ··· 834 831 // 835 832 // disable foreign-keys for the next migration 836 833 conn.ExecContext(ctx, "pragma foreign_keys = off;") 837 837 - runMigration(conn, "remove-issue-at-from-issues", func(tx *sql.Tx) error { 834 834 + runMigration(conn, logger, "remove-issue-at-from-issues", func(tx *sql.Tx) error { 838 835 _, err := tx.Exec(` 839 836 create table if not exists issues_new ( 840 837 -- identifiers ··· 904 901 // - new columns 905 902 // * column "reply_to" which can be any other comment 906 903 // * column "at-uri" which is a generated column 907 907 - runMigration(conn, "rework-issue-comments", func(tx *sql.Tx) error { 904 904 + runMigration(conn, logger, "rework-issue-comments", func(tx *sql.Tx) error { 908 905 _, err := tx.Exec(` 909 906 create table if not exists issue_comments ( 910 907 -- identifiers ··· 964 961 // 965 962 // disable foreign-keys for the next migration 966 963 conn.ExecContext(ctx, "pragma foreign_keys = off;") 967 967 - runMigration(conn, "add-at-uri-to-pulls", func(tx *sql.Tx) error { 964 964 + runMigration(conn, logger, "add-at-uri-to-pulls", func(tx *sql.Tx) error { 968 965 _, err := tx.Exec(` 969 966 create table if not exists pulls_new ( 970 967 -- identifiers ··· 1045 1042 // 1046 1043 // disable foreign-keys for the next migration 1047 1044 conn.ExecContext(ctx, "pragma foreign_keys = off;") 1048 1048 - runMigration(conn, "remove-repo-at-pull-id-from-pull-submissions", func(tx *sql.Tx) error { 1045 1045 + runMigration(conn, logger, "remove-repo-at-pull-id-from-pull-submissions", func(tx *sql.Tx) error { 1049 1046 _, err := tx.Exec(` 1050 1047 create table if not exists pull_submissions_new ( 1051 1048 -- identifiers ··· 1097 1094 }) 1098 1095 conn.ExecContext(ctx, "pragma foreign_keys = on;") 1099 1096 1100 1100 - return &DB{db}, nil 1097 1097 + return &DB{ 1098 1098 + db, 1099 1099 + logger, 1100 1100 + }, nil 1101 1101 } 1102 1102 1103 1103 type migrationFn = func(*sql.Tx) error 1104 1104 1105 1105 - func runMigration(c *sql.Conn, name string, migrationFn migrationFn) error { 1105 1105 + func runMigration(c *sql.Conn, logger *slog.Logger, name string, migrationFn migrationFn) error { 1106 1106 + logger = logger.With("migration", name) 1107 1107 + 1106 1108 tx, err := c.BeginTx(context.Background(), nil) 1107 1109 if err != nil { 1108 1110 return err ··· 1124 1116 // run migration 1125 1117 err = migrationFn(tx) 1126 1118 if err != nil { 1127 1127 - log.Printf("Failed to run migration %s: %v", name, err) 1119 1119 + logger.Error("failed to run migration", "err", err) 1128 1120 return err 1129 1121 } 1130 1122 1131 1123 // mark migration as complete 1132 1124 _, err = tx.Exec("insert into migrations (name) values (?)", name) 1133 1125 if err != nil { 1134 1134 - log.Printf("Failed to mark migration %s as complete: %v", name, err) 1126 1126 + logger.Error("failed to mark migration as complete", "err", err) 1135 1127 return err 1136 1128 } 1137 1129 ··· 1140 1132 return err 1141 1133 } 1142 1134 1143 1143 - log.Printf("migration %s applied successfully", name) 1135 1135 + logger.Info("migration applied successfully") 1144 1136 } else { 1145 1145 - log.Printf("skipped migration %s, already applied", name) 1137 1137 + logger.Warn("skipped migration, already applied") 1146 1138 } 1147 1139 1148 1140 return nil

+1 -1

appview/ingester.go

reviewed

··· 89 89 } 90 90 91 91 if err != nil { 92 92 - l.Debug("error ingesting record", "err", err) 92 92 + l.Warn("refused to ingest record", "err", err) 93 93 } 94 94 95 95 return nil

+27 -26

appview/issues/issues.go

reviewed

··· 5 5 "database/sql" 6 6 "errors" 7 7 "fmt" 8 8 - "log" 9 8 "log/slog" 10 9 "net/http" 11 10 "slices" ··· 27 28 "tangled.org/core/appview/reporesolver" 28 29 "tangled.org/core/appview/validator" 29 30 "tangled.org/core/idresolver" 30 30 - tlog "tangled.org/core/log" 31 31 "tangled.org/core/tid" 32 32 ) 33 33 ··· 51 53 config *config.Config, 52 54 notifier notify.Notifier, 53 55 validator *validator.Validator, 56 56 + logger *slog.Logger, 54 57 ) *Issues { 55 58 return &Issues{ 56 59 oauth: oauth, ··· 61 62 db: db, 62 63 config: config, 63 64 notifier: notifier, 64 64 - logger: tlog.New("issues"), 65 65 + logger: logger, 65 66 validator: validator, 66 67 } 67 68 } ··· 71 72 user := rp.oauth.GetUser(r) 72 73 f, err := rp.repoResolver.Resolve(r) 73 74 if err != nil { 74 74 - log.Println("failed to get repo and knot", err) 75 75 + l.Error("failed to get repo and knot", "err", err) 75 76 return 76 77 } 77 78 ··· 98 99 db.FilterContains("scope", tangled.RepoIssueNSID), 99 100 ) 100 101 if err != nil { 101 101 - log.Println("failed to fetch labels", err) 102 102 + l.Error("failed to fetch labels", "err", err) 102 103 rp.pages.Error503(w) 103 104 return 104 105 } ··· 125 126 user := rp.oauth.GetUser(r) 126 127 f, err := rp.repoResolver.Resolve(r) 127 128 if err != nil { 128 128 - log.Println("failed to get repo and knot", err) 129 129 + l.Error("failed to get repo and knot", "err", err) 129 130 return 130 131 } 131 132 ··· 198 199 199 200 err = db.PutIssue(tx, newIssue) 200 201 if err != nil { 201 201 - log.Println("failed to edit issue", err) 202 202 + l.Error("failed to edit issue", "err", err) 202 203 rp.pages.Notice(w, "issues", "Failed to edit issue.") 203 204 return 204 205 } ··· 236 237 // delete from PDS 237 238 client, err := rp.oauth.AuthorizedClient(r) 238 239 if err != nil { 239 239 - log.Println("failed to get authorized client", err) 240 240 + l.Error("failed to get authorized client", "err", err) 240 241 rp.pages.Notice(w, "issue-comment", "Failed to delete comment.") 241 242 return 242 243 } ··· 281 282 282 283 collaborators, err := f.Collaborators(r.Context()) 283 284 if err != nil { 284 284 - log.Println("failed to fetch repo collaborators: %w", err) 285 285 + l.Error("failed to fetch repo collaborators", "err", err) 285 286 } 286 287 isCollaborator := slices.ContainsFunc(collaborators, func(collab pages.Collaborator) bool { 287 288 return user.Did == collab.Did ··· 295 296 db.FilterEq("id", issue.Id), 296 297 ) 297 298 if err != nil { 298 298 - log.Println("failed to close issue", err) 299 299 + l.Error("failed to close issue", "err", err) 299 300 rp.pages.Notice(w, "issue-action", "Failed to close issue. Try again later.") 300 301 return 301 302 } ··· 306 307 rp.pages.HxLocation(w, fmt.Sprintf("/%s/issues/%d", f.OwnerSlashRepo(), issue.IssueId)) 307 308 return 308 309 } else { 309 309 - log.Println("user is not permitted to close issue") 310 310 + l.Error("user is not permitted to close issue") 310 311 http.Error(w, "for biden", http.StatusUnauthorized) 311 312 return 312 313 } ··· 317 318 user := rp.oauth.GetUser(r) 318 319 f, err := rp.repoResolver.Resolve(r) 319 320 if err != nil { 320 320 - log.Println("failed to get repo and knot", err) 321 321 + l.Error("failed to get repo and knot", "err", err) 321 322 return 322 323 } 323 324 ··· 330 331 331 332 collaborators, err := f.Collaborators(r.Context()) 332 333 if err != nil { 333 333 - log.Println("failed to fetch repo collaborators: %w", err) 334 334 + l.Error("failed to fetch repo collaborators", "err", err) 334 335 } 335 336 isCollaborator := slices.ContainsFunc(collaborators, func(collab pages.Collaborator) bool { 336 337 return user.Did == collab.Did ··· 343 344 db.FilterEq("id", issue.Id), 344 345 ) 345 346 if err != nil { 346 346 - log.Println("failed to reopen issue", err) 347 347 + l.Error("failed to reopen issue", "err", err) 347 348 rp.pages.Notice(w, "issue-action", "Failed to reopen issue. Try again later.") 348 349 return 349 350 } 350 351 rp.pages.HxLocation(w, fmt.Sprintf("/%s/issues/%d", f.OwnerSlashRepo(), issue.IssueId)) 351 352 return 352 353 } else { 353 353 - log.Println("user is not the owner of the repo") 354 354 + l.Error("user is not the owner of the repo") 354 355 http.Error(w, "forbidden", http.StatusUnauthorized) 355 356 return 356 357 } ··· 537 538 newBody := r.FormValue("body") 538 539 client, err := rp.oauth.AuthorizedClient(r) 539 540 if err != nil { 540 540 - log.Println("failed to get authorized client", err) 541 541 + l.Error("failed to get authorized client", "err", err) 541 542 rp.pages.Notice(w, "issue-comment", "Failed to create comment.") 542 543 return 543 544 } ··· 550 551 551 552 _, err = db.AddIssueComment(rp.db, newComment) 552 553 if err != nil { 553 553 - log.Println("failed to perferom update-description query", err) 554 554 + l.Error("failed to perferom update-description query", "err", err) 554 555 rp.pages.Notice(w, "repo-notice", "Failed to update description, try again later.") 555 556 return 556 557 } ··· 560 561 // update the record on pds 561 562 ex, err := comatproto.RepoGetRecord(r.Context(), client, "", tangled.RepoIssueCommentNSID, user.Did, comment.Rkey) 562 563 if err != nil { 563 563 - log.Println("failed to get record", "err", err, "did", newComment.Did, "rkey", newComment.Rkey) 564 564 + l.Error("failed to get record", "err", err, "did", newComment.Did, "rkey", newComment.Rkey) 564 565 rp.pages.Notice(w, fmt.Sprintf("comment-%s-status", commentId), "Failed to update description, no record found on PDS.") 565 566 return 566 567 } ··· 728 729 if comment.Rkey != "" { 729 730 client, err := rp.oauth.AuthorizedClient(r) 730 731 if err != nil { 731 731 - log.Println("failed to get authorized client", err) 732 732 + l.Error("failed to get authorized client", "err", err) 732 733 rp.pages.Notice(w, "issue-comment", "Failed to delete comment.") 733 734 return 734 735 } ··· 738 739 Rkey: comment.Rkey, 739 740 }) 740 741 if err != nil { 741 741 - log.Println(err) 742 742 + l.Error("failed to delete from PDS", "err", err) 742 743 } 743 744 } 744 745 ··· 756 757 } 757 758 758 759 func (rp *Issues) RepoIssues(w http.ResponseWriter, r *http.Request) { 760 760 + l := rp.logger.With("handler", "RepoIssues") 761 761 + 759 762 params := r.URL.Query() 760 763 state := params.Get("state") 761 764 isOpen := true ··· 772 771 773 772 page, ok := r.Context().Value("page").(pagination.Page) 774 773 if !ok { 775 775 - log.Println("failed to get page") 774 774 + l.Error("failed to get page") 776 775 page = pagination.FirstPage() 777 776 } 778 777 779 778 user := rp.oauth.GetUser(r) 780 779 f, err := rp.repoResolver.Resolve(r) 781 780 if err != nil { 782 782 - log.Println("failed to get repo and knot", err) 781 781 + l.Error("failed to get repo and knot", "err", err) 783 782 return 784 783 } 785 784 ··· 794 793 db.FilterEq("open", openVal), 795 794 ) 796 795 if err != nil { 797 797 - log.Println("failed to get issues", err) 796 796 + l.Error("failed to get issues", "err", err) 798 797 rp.pages.Notice(w, "issues", "Failed to load issues. Try again later.") 799 798 return 800 799 } ··· 805 804 db.FilterContains("scope", tangled.RepoIssueNSID), 806 805 ) 807 806 if err != nil { 808 808 - log.Println("failed to fetch labels", err) 807 807 + l.Error("failed to fetch labels", "err", err) 809 808 rp.pages.Error503(w) 810 809 return 811 810 } ··· 902 901 903 902 err = db.PutIssue(tx, issue) 904 903 if err != nil { 905 905 - log.Println("failed to create issue", err) 904 904 + l.Error("failed to create issue", "err", err) 906 905 rp.pages.Notice(w, "issues", "Failed to create issue.") 907 906 return 908 907 } 909 908 910 909 if err = tx.Commit(); err != nil { 911 911 - log.Println("failed to create issue", err) 910 910 + l.Error("failed to create issue", "err", err) 912 911 rp.pages.Notice(w, "issues", "Failed to create issue.") 913 912 return 914 913 }

+1 -3

appview/labels/labels.go

reviewed

··· 16 16 "tangled.org/core/appview/oauth" 17 17 "tangled.org/core/appview/pages" 18 18 "tangled.org/core/appview/validator" 19 19 - "tangled.org/core/log" 20 19 "tangled.org/core/rbac" 21 20 "tangled.org/core/tid" 22 21 ··· 41 42 db *db.DB, 42 43 validator *validator.Validator, 43 44 enforcer *rbac.Enforcer, 45 45 + logger *slog.Logger, 44 46 ) *Labels { 45 45 - logger := log.New("labels") 46 46 - 47 47 return &Labels{ 48 48 oauth: oauth, 49 49 pages: pages,

+15 -12

appview/notifications/notifications.go

reviewed

··· 1 1 package notifications 2 2 3 3 import ( 4 4 - "log" 4 4 + "log/slog" 5 5 "net/http" 6 6 "strconv" 7 7 ··· 14 14 ) 15 15 16 16 type Notifications struct { 17 17 - db *db.DB 18 18 - oauth *oauth.OAuth 19 19 - pages *pages.Pages 17 17 + db *db.DB 18 18 + oauth *oauth.OAuth 19 19 + pages *pages.Pages 20 20 + logger *slog.Logger 20 21 } 21 22 22 22 - func New(database *db.DB, oauthHandler *oauth.OAuth, pagesHandler *pages.Pages) *Notifications { 23 23 + func New(database *db.DB, oauthHandler *oauth.OAuth, pagesHandler *pages.Pages, logger *slog.Logger) *Notifications { 23 24 return &Notifications{ 24 24 - db: database, 25 25 - oauth: oauthHandler, 26 26 - pages: pagesHandler, 25 25 + db: database, 26 26 + oauth: oauthHandler, 27 27 + pages: pagesHandler, 28 28 + logger: logger, 27 29 } 28 30 } 29 31 ··· 46 44 } 47 45 48 46 func (n *Notifications) notificationsPage(w http.ResponseWriter, r *http.Request) { 47 47 + l := n.logger.With("handler", "notificationsPage") 49 48 user := n.oauth.GetUser(r) 50 49 51 50 page, ok := r.Context().Value("page").(pagination.Page) 52 51 if !ok { 53 53 - log.Println("failed to get page") 52 52 + l.Error("failed to get page") 54 53 page = pagination.FirstPage() 55 54 } 56 55 ··· 60 57 db.FilterEq("recipient_did", user.Did), 61 58 ) 62 59 if err != nil { 63 63 - log.Println("failed to get total notifications:", err) 60 60 + l.Error("failed to get total notifications", "err", err) 64 61 n.pages.Error500(w) 65 62 return 66 63 } ··· 71 68 db.FilterEq("recipient_did", user.Did), 72 69 ) 73 70 if err != nil { 74 74 - log.Println("failed to get notifications:", err) 71 71 + l.Error("failed to get notifications", "err", err) 75 72 n.pages.Error500(w) 76 73 return 77 74 } 78 75 79 76 err = n.db.MarkAllNotificationsRead(r.Context(), user.Did) 80 77 if err != nil { 81 81 - log.Println("failed to mark notifications as read:", err) 78 78 + l.Error("failed to mark notifications as read", "err", err) 82 79 } 83 80 84 81 unreadCount := 0

+2 -2

appview/pages/pages.go

reviewed

··· 54 54 logger *slog.Logger 55 55 } 56 56 57 57 - func NewPages(config *config.Config, res *idresolver.Resolver) *Pages { 57 57 + func NewPages(config *config.Config, res *idresolver.Resolver, logger *slog.Logger) *Pages { 58 58 // initialized with safe defaults, can be overriden per use 59 59 rctx := &markup.RenderContext{ 60 60 IsDev: config.Core.Dev, ··· 72 72 rctx: rctx, 73 73 resolver: res, 74 74 templateDir: "appview/pages", 75 75 - logger: slog.Default().With("component", "pages"), 75 75 + logger: logger, 76 76 } 77 77 78 78 if p.dev {

+1 -3

appview/pipelines/pipelines.go

reviewed

··· 16 16 "tangled.org/core/appview/reporesolver" 17 17 "tangled.org/core/eventconsumer" 18 18 "tangled.org/core/idresolver" 19 19 - "tangled.org/core/log" 20 19 "tangled.org/core/rbac" 21 20 spindlemodel "tangled.org/core/spindle/models" 22 21 ··· 44 45 db *db.DB, 45 46 config *config.Config, 46 47 enforcer *rbac.Enforcer, 48 48 + logger *slog.Logger, 47 49 ) *Pipelines { 48 48 - logger := log.New("pipelines") 49 49 - 50 50 return &Pipelines{ 51 51 oauth: oauth, 52 52 repoResolver: repoResolver,

+4

appview/pulls/pulls.go

reviewed

··· 6 6 "errors" 7 7 "fmt" 8 8 "log" 9 9 + "log/slog" 9 10 "net/http" 10 11 "slices" 11 12 "sort" ··· 47 46 config *config.Config 48 47 notifier notify.Notifier 49 48 enforcer *rbac.Enforcer 49 49 + logger *slog.Logger 50 50 } 51 51 52 52 func New( ··· 59 57 config *config.Config, 60 58 notifier notify.Notifier, 61 59 enforcer *rbac.Enforcer, 60 60 + logger *slog.Logger, 62 61 ) *Pulls { 63 62 return &Pulls{ 64 63 oauth: oauth, ··· 70 67 config: config, 71 68 notifier: notifier, 72 69 enforcer: enforcer, 70 70 + logger: logger, 73 71 } 74 72 } 75 73

+14 -11

appview/repo/index.go

reviewed

··· 3 3 import ( 4 4 "errors" 5 5 "fmt" 6 6 - "log" 6 6 + "log/slog" 7 7 "net/http" 8 8 "net/url" 9 9 "slices" ··· 31 31 ) 32 32 33 33 func (rp *Repo) RepoIndex(w http.ResponseWriter, r *http.Request) { 34 34 + l := rp.logger.With("handler", "RepoIndex") 35 35 + 34 36 ref := chi.URLParam(r, "ref") 35 37 ref, _ = url.PathUnescape(ref) 36 38 37 39 f, err := rp.repoResolver.Resolve(r) 38 40 if err != nil { 39 39 - log.Println("failed to fully resolve repo", err) 41 41 + l.Error("failed to fully resolve repo", "err", err) 40 42 return 41 43 } 42 44 ··· 58 56 result, err := rp.buildIndexResponse(r.Context(), xrpcc, f, ref) 59 57 if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil { 60 58 if errors.Is(xrpcerr, xrpcclient.ErrXrpcUnsupported) { 61 61 - log.Println("failed to call XRPC repo.index", err) 59 59 + l.Error("failed to call XRPC repo.index", "err", err) 62 60 rp.pages.RepoIndexPage(w, pages.RepoIndexParams{ 63 61 LoggedInUser: user, 64 62 NeedsKnotUpgrade: true, ··· 68 66 } 69 67 70 68 rp.pages.Error503(w) 71 71 - log.Println("failed to build index response", err) 69 69 + l.Error("failed to build index response", "err", err) 72 70 return 73 71 } 74 72 ··· 121 119 emails := uniqueEmails(commitsTrunc) 122 120 emailToDidMap, err := db.GetEmailToDid(rp.db, emails, true) 123 121 if err != nil { 124 124 - log.Println("failed to get email to did map", err) 122 122 + l.Error("failed to get email to did map", "err", err) 125 123 } 126 124 127 125 vc, err := commitverify.GetVerifiedObjectCommits(rp.db, emailToDidMap, commitsTrunc) 128 126 if err != nil { 129 129 - log.Println(err) 127 127 + l.Error("failed to GetVerifiedObjectCommits", "err", err) 130 128 } 131 129 132 130 // TODO: a bit dirty 133 133 - languageInfo, err := rp.getLanguageInfo(r.Context(), f, xrpcc, result.Ref, ref == "") 131 131 + languageInfo, err := rp.getLanguageInfo(r.Context(), l, f, xrpcc, result.Ref, ref == "") 134 132 if err != nil { 135 135 - log.Printf("failed to compute language percentages: %s", err) 133 133 + l.Warn("failed to compute language percentages", "err", err) 136 134 // non-fatal 137 135 } 138 136 ··· 142 140 } 143 141 pipelines, err := getPipelineStatuses(rp.db, repoInfo, shas) 144 142 if err != nil { 145 145 - log.Printf("failed to fetch pipeline statuses: %s", err) 143 143 + l.Error("failed to fetch pipeline statuses", "err", err) 146 144 // non-fatal 147 145 } 148 146 ··· 164 162 165 163 func (rp *Repo) getLanguageInfo( 166 164 ctx context.Context, 165 165 + l *slog.Logger, 167 166 f *reporesolver.ResolvedRepo, 168 167 xrpcc *indigoxrpc.Client, 169 168 currentRef string, ··· 183 180 ls, err := tangled.RepoLanguages(ctx, xrpcc, currentRef, repo) 184 181 if err != nil { 185 182 if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil { 186 186 - log.Println("failed to call XRPC repo.languages", xrpcerr) 183 183 + l.Error("failed to call XRPC repo.languages", "err", xrpcerr) 187 184 return nil, xrpcerr 188 185 } 189 186 return nil, err ··· 213 210 err = db.UpdateRepoLanguages(tx, f.RepoAt(), currentRef, langs) 214 211 if err != nil { 215 212 // non-fatal 216 216 - log.Println("failed to cache lang results", err) 213 213 + l.Error("failed to cache lang results", "err", err) 217 214 } 218 215 219 216 err = tx.Commit()

+130 -92

appview/repo/repo.go

reviewed

··· 7 7 "errors" 8 8 "fmt" 9 9 "io" 10 10 - "log" 11 10 "log/slog" 12 11 "net/http" 13 12 "net/url" ··· 89 90 } 90 91 91 92 func (rp *Repo) DownloadArchive(w http.ResponseWriter, r *http.Request) { 93 93 + l := rp.logger.With("handler", "DownloadArchive") 94 94 + 92 95 ref := chi.URLParam(r, "ref") 93 96 ref, _ = url.PathUnescape(ref) 94 97 95 98 f, err := rp.repoResolver.Resolve(r) 96 99 if err != nil { 97 97 - log.Println("failed to get repo and knot", err) 100 100 + l.Error("failed to get repo and knot", "err", err) 98 101 return 99 102 } 100 103 ··· 112 111 repo := fmt.Sprintf("%s/%s", f.OwnerDid(), f.Name) 113 112 archiveBytes, err := tangled.RepoArchive(r.Context(), xrpcc, "tar.gz", "", ref, repo) 114 113 if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil { 115 115 - log.Println("failed to call XRPC repo.archive", xrpcerr) 114 114 + l.Error("failed to call XRPC repo.archive", "err", xrpcerr) 116 115 rp.pages.Error503(w) 117 116 return 118 117 } ··· 129 128 } 130 129 131 130 func (rp *Repo) RepoLog(w http.ResponseWriter, r *http.Request) { 131 131 + l := rp.logger.With("handler", "RepoLog") 132 132 + 132 133 f, err := rp.repoResolver.Resolve(r) 133 134 if err != nil { 134 134 - log.Println("failed to fully resolve repo", err) 135 135 + l.Error("failed to fully resolve repo", "err", err) 135 136 return 136 137 } 137 138 ··· 168 165 repo := fmt.Sprintf("%s/%s", f.OwnerDid(), f.Name) 169 166 xrpcBytes, err := tangled.RepoLog(r.Context(), xrpcc, cursor, limit, "", ref, repo) 170 167 if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil { 171 171 - log.Println("failed to call XRPC repo.log", xrpcerr) 168 168 + l.Error("failed to call XRPC repo.log", "err", xrpcerr) 172 169 rp.pages.Error503(w) 173 170 return 174 171 } 175 172 176 173 var xrpcResp types.RepoLogResponse 177 174 if err := json.Unmarshal(xrpcBytes, &xrpcResp); err != nil { 178 178 - log.Println("failed to decode XRPC response", err) 175 175 + l.Error("failed to decode XRPC response", "err", err) 179 176 rp.pages.Error503(w) 180 177 return 181 178 } 182 179 183 180 tagBytes, err := tangled.RepoTags(r.Context(), xrpcc, "", 0, repo) 184 181 if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil { 185 185 - log.Println("failed to call XRPC repo.tags", xrpcerr) 182 182 + l.Error("failed to call XRPC repo.tags", "err", xrpcerr) 186 183 rp.pages.Error503(w) 187 184 return 188 185 } ··· 199 196 200 197 branchBytes, err := tangled.RepoBranches(r.Context(), xrpcc, "", 0, repo) 201 198 if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil { 202 202 - log.Println("failed to call XRPC repo.branches", xrpcerr) 199 199 + l.Error("failed to call XRPC repo.branches", "err", xrpcerr) 203 200 rp.pages.Error503(w) 204 201 return 205 202 } ··· 217 214 218 215 emailToDidMap, err := db.GetEmailToDid(rp.db, uniqueEmails(xrpcResp.Commits), true) 219 216 if err != nil { 220 220 - log.Println("failed to fetch email to did mapping", err) 217 217 + l.Error("failed to fetch email to did mapping", "err", err) 221 218 } 222 219 223 220 vc, err := commitverify.GetVerifiedObjectCommits(rp.db, emailToDidMap, xrpcResp.Commits) 224 221 if err != nil { 225 225 - log.Println(err) 222 222 + l.Error("failed to GetVerifiedObjectCommits", "err", err) 226 223 } 227 224 228 225 repoInfo := f.RepoInfo(user) ··· 233 230 } 234 231 pipelines, err := getPipelineStatuses(rp.db, repoInfo, shas) 235 232 if err != nil { 236 236 - log.Println(err) 233 233 + l.Error("failed to getPipelineStatuses", "err", err) 237 234 // non-fatal 238 235 } 239 236 ··· 249 246 } 250 247 251 248 func (rp *Repo) RepoDescriptionEdit(w http.ResponseWriter, r *http.Request) { 249 249 + l := rp.logger.With("handler", "RepoDescriptionEdit") 250 250 + 252 251 f, err := rp.repoResolver.Resolve(r) 253 252 if err != nil { 254 254 - log.Println("failed to get repo and knot", err) 253 253 + l.Error("failed to get repo and knot", "err", err) 255 254 w.WriteHeader(http.StatusBadRequest) 256 255 return 257 256 } ··· 265 260 } 266 261 267 262 func (rp *Repo) RepoDescription(w http.ResponseWriter, r *http.Request) { 263 263 + l := rp.logger.With("handler", "RepoDescription") 264 264 + 268 265 f, err := rp.repoResolver.Resolve(r) 269 266 if err != nil { 270 270 - log.Println("failed to get repo and knot", err) 267 267 + l.Error("failed to get repo and knot", "err", err) 271 268 w.WriteHeader(http.StatusBadRequest) 272 269 return 273 270 } ··· 277 270 repoAt := f.RepoAt() 278 271 rkey := repoAt.RecordKey().String() 279 272 if rkey == "" { 280 280 - log.Println("invalid aturi for repo", err) 273 273 + l.Error("invalid aturi for repo", "err", err) 281 274 w.WriteHeader(http.StatusInternalServerError) 282 275 return 283 276 } ··· 294 287 newDescription := r.FormValue("description") 295 288 client, err := rp.oauth.AuthorizedClient(r) 296 289 if err != nil { 297 297 - log.Println("failed to get client") 290 290 + l.Error("failed to get client") 298 291 rp.pages.Notice(w, "repo-notice", "Failed to update description, try again later.") 299 292 return 300 293 } ··· 302 295 // optimistic update 303 296 err = db.UpdateDescription(rp.db, string(repoAt), newDescription) 304 297 if err != nil { 305 305 - log.Println("failed to perferom update-description query", err) 298 298 + l.Error("failed to perform update-description query", "err", err) 306 299 rp.pages.Notice(w, "repo-notice", "Failed to update description, try again later.") 307 300 return 308 301 } ··· 331 324 }) 332 325 333 326 if err != nil { 334 334 - log.Println("failed to perferom update-description query", err) 327 327 + l.Error("failed to perferom update-description query", "err", err) 335 328 // failed to get record 336 329 rp.pages.Notice(w, "repo-notice", "Failed to update description, unable to save to PDS.") 337 330 return ··· 348 341 } 349 342 350 343 func (rp *Repo) RepoCommit(w http.ResponseWriter, r *http.Request) { 344 344 + l := rp.logger.With("handler", "RepoCommit") 345 345 + 351 346 f, err := rp.repoResolver.Resolve(r) 352 347 if err != nil { 353 353 - log.Println("failed to fully resolve repo", err) 348 348 + l.Error("failed to fully resolve repo", "err", err) 354 349 return 355 350 } 356 351 ref := chi.URLParam(r, "ref") ··· 380 371 repo := fmt.Sprintf("%s/%s", f.OwnerDid(), f.Name) 381 372 xrpcBytes, err := tangled.RepoDiff(r.Context(), xrpcc, ref, repo) 382 373 if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil { 383 383 - log.Println("failed to call XRPC repo.diff", xrpcerr) 374 374 + l.Error("failed to call XRPC repo.diff", "err", xrpcerr) 384 375 rp.pages.Error503(w) 385 376 return 386 377 } 387 378 388 379 var result types.RepoCommitResponse 389 380 if err := json.Unmarshal(xrpcBytes, &result); err != nil { 390 390 - log.Println("failed to decode XRPC response", err) 381 381 + l.Error("failed to decode XRPC response", "err", err) 391 382 rp.pages.Error503(w) 392 383 return 393 384 } 394 385 395 386 emailToDidMap, err := db.GetEmailToDid(rp.db, []string{result.Diff.Commit.Committer.Email, result.Diff.Commit.Author.Email}, true) 396 387 if err != nil { 397 397 - log.Println("failed to get email to did mapping:", err) 388 388 + l.Error("failed to get email to did mapping", "err", err) 398 389 } 399 390 400 391 vc, err := commitverify.GetVerifiedCommits(rp.db, emailToDidMap, []types.NiceDiff{*result.Diff}) 401 392 if err != nil { 402 402 - log.Println(err) 393 393 + l.Error("failed to GetVerifiedCommits", "err", err) 403 394 } 404 395 405 396 user := rp.oauth.GetUser(r) 406 397 repoInfo := f.RepoInfo(user) 407 398 pipelines, err := getPipelineStatuses(rp.db, repoInfo, []string{result.Diff.Commit.This}) 408 399 if err != nil { 409 409 - log.Println(err) 400 400 + l.Error("failed to getPipelineStatuses", "err", err) 410 401 // non-fatal 411 402 } 412 403 var pipeline *models.Pipeline ··· 426 417 } 427 418 428 419 func (rp *Repo) RepoTree(w http.ResponseWriter, r *http.Request) { 420 420 + l := rp.logger.With("handler", "RepoTree") 421 421 + 429 422 f, err := rp.repoResolver.Resolve(r) 430 423 if err != nil { 431 431 - log.Println("failed to fully resolve repo", err) 424 424 + l.Error("failed to fully resolve repo", "err", err) 432 425 return 433 426 } 434 427 ··· 455 444 repo := fmt.Sprintf("%s/%s", f.OwnerDid(), f.Name) 456 445 xrpcResp, err := tangled.RepoTree(r.Context(), xrpcc, treePath, ref, repo) 457 446 if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil { 458 458 - log.Println("failed to call XRPC repo.tree", xrpcerr) 447 447 + l.Error("failed to call XRPC repo.tree", "err", xrpcerr) 459 448 rp.pages.Error503(w) 460 449 return 461 450 } ··· 530 519 } 531 520 532 521 func (rp *Repo) RepoTags(w http.ResponseWriter, r *http.Request) { 522 522 + l := rp.logger.With("handler", "RepoTags") 523 523 + 533 524 f, err := rp.repoResolver.Resolve(r) 534 525 if err != nil { 535 535 - log.Println("failed to get repo and knot", err) 526 526 + l.Error("failed to get repo and knot", "err", err) 536 527 return 537 528 } 538 529 ··· 550 537 repo := fmt.Sprintf("%s/%s", f.OwnerDid(), f.Name) 551 538 xrpcBytes, err := tangled.RepoTags(r.Context(), xrpcc, "", 0, repo) 552 539 if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil { 553 553 - log.Println("failed to call XRPC repo.tags", xrpcerr) 540 540 + l.Error("failed to call XRPC repo.tags", "err", xrpcerr) 554 541 rp.pages.Error503(w) 555 542 return 556 543 } 557 544 558 545 var result types.RepoTagsResponse 559 546 if err := json.Unmarshal(xrpcBytes, &result); err != nil { 560 560 - log.Println("failed to decode XRPC response", err) 547 547 + l.Error("failed to decode XRPC response", "err", err) 561 548 rp.pages.Error503(w) 562 549 return 563 550 } 564 551 565 552 artifacts, err := db.GetArtifact(rp.db, db.FilterEq("repo_at", f.RepoAt())) 566 553 if err != nil { 567 567 - log.Println("failed grab artifacts", err) 554 554 + l.Error("failed grab artifacts", "err", err) 568 555 return 569 556 } 570 557 ··· 601 588 } 602 589 603 590 func (rp *Repo) RepoBranches(w http.ResponseWriter, r *http.Request) { 591 591 + l := rp.logger.With("handler", "RepoBranches") 592 592 + 604 593 f, err := rp.repoResolver.Resolve(r) 605 594 if err != nil { 606 606 - log.Println("failed to get repo and knot", err) 595 595 + l.Error("failed to get repo and knot", "err", err) 607 596 return 608 597 } 609 598 ··· 621 606 repo := fmt.Sprintf("%s/%s", f.OwnerDid(), f.Name) 622 607 xrpcBytes, err := tangled.RepoBranches(r.Context(), xrpcc, "", 0, repo) 623 608 if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil { 624 624 - log.Println("failed to call XRPC repo.branches", xrpcerr) 609 609 + l.Error("failed to call XRPC repo.branches", "err", xrpcerr) 625 610 rp.pages.Error503(w) 626 611 return 627 612 } 628 613 629 614 var result types.RepoBranchesResponse 630 615 if err := json.Unmarshal(xrpcBytes, &result); err != nil { 631 631 - log.Println("failed to decode XRPC response", err) 616 616 + l.Error("failed to decode XRPC response", "err", err) 632 617 rp.pages.Error503(w) 633 618 return 634 619 } ··· 644 629 } 645 630 646 631 func (rp *Repo) DeleteBranch(w http.ResponseWriter, r *http.Request) { 632 632 + l := rp.logger.With("handler", "DeleteBranch") 633 633 + 647 634 f, err := rp.repoResolver.Resolve(r) 648 635 if err != nil { 649 649 - log.Println("failed to get repo and knot", err) 636 636 + l.Error("failed to get repo and knot", "err", err) 650 637 return 651 638 } 652 639 653 640 noticeId := "delete-branch-error" 654 641 fail := func(msg string, err error) { 655 655 - log.Println(msg, "err", err) 642 642 + l.Error(msg, "err", err) 656 643 rp.pages.Notice(w, noticeId, msg) 657 644 } 658 645 ··· 687 670 fail(fmt.Sprintf("Failed to delete branch: %s", err), err) 688 671 return 689 672 } 690 690 - log.Println("deleted branch from knot", "branch", branch, "repo", f.RepoAt()) 673 673 + l.Error("deleted branch from knot", "branch", branch, "repo", f.RepoAt()) 691 674 692 675 rp.pages.HxRefresh(w) 693 676 } 694 677 695 678 func (rp *Repo) RepoBlob(w http.ResponseWriter, r *http.Request) { 679 679 + l := rp.logger.With("handler", "RepoBlob") 680 680 + 696 681 f, err := rp.repoResolver.Resolve(r) 697 682 if err != nil { 698 698 - log.Println("failed to get repo and knot", err) 683 683 + l.Error("failed to get repo and knot", "err", err) 699 684 return 700 685 } 701 686 ··· 719 700 repo := fmt.Sprintf("%s/%s", f.OwnerDid(), f.Repo.Name) 720 701 resp, err := tangled.RepoBlob(r.Context(), xrpcc, filePath, false, ref, repo) 721 702 if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil { 722 722 - log.Println("failed to call XRPC repo.blob", xrpcerr) 703 703 + l.Error("failed to call XRPC repo.blob", "err", xrpcerr) 723 704 rp.pages.Error503(w) 724 705 return 725 706 } ··· 819 800 } 820 801 821 802 func (rp *Repo) RepoBlobRaw(w http.ResponseWriter, r *http.Request) { 803 803 + l := rp.logger.With("handler", "RepoBlobRaw") 804 804 + 822 805 f, err := rp.repoResolver.Resolve(r) 823 806 if err != nil { 824 824 - log.Println("failed to get repo and knot", err) 807 807 + l.Error("failed to get repo and knot", err) 825 808 w.WriteHeader(http.StatusBadRequest) 826 809 return 827 810 } ··· 855 834 856 835 req, err := http.NewRequest("GET", blobURL, nil) 857 836 if err != nil { 858 858 - log.Println("failed to create request", err) 837 837 + l.Error("failed to create request", "err", err) 859 838 return 860 839 } 861 840 ··· 867 846 client := &http.Client{} 868 847 resp, err := client.Do(req) 869 848 if err != nil { 870 870 - log.Println("failed to reach knotserver", err) 849 849 + l.Error("failed to reach knotserver", "err", err) 871 850 rp.pages.Error503(w) 872 851 return 873 852 } ··· 880 859 } 881 860 882 861 if resp.StatusCode != http.StatusOK { 883 883 - log.Printf("knotserver returned non-OK status for raw blob %s: %d", blobURL, resp.StatusCode) 862 862 + l.Error("knotserver returned non-OK status for raw blob", "url", blobURL, "statuscode", resp.StatusCode) 884 863 w.WriteHeader(resp.StatusCode) 885 864 _, _ = io.Copy(w, resp.Body) 886 865 return ··· 889 868 contentType := resp.Header.Get("Content-Type") 890 869 body, err := io.ReadAll(resp.Body) 891 870 if err != nil { 892 892 - log.Printf("error reading response body from knotserver: %v", err) 871 871 + l.Error("error reading response body from knotserver", "err", err) 893 872 w.WriteHeader(http.StatusInternalServerError) 894 873 return 895 874 } ··· 1464 1443 db.FilterContains("scope", subject.Collection().String()), 1465 1444 ) 1466 1445 if err != nil { 1467 1467 - log.Println("failed to fetch label defs", err) 1446 1446 + l.Error("failed to fetch label defs", "err", err) 1468 1447 return 1469 1448 } 1470 1449 ··· 1475 1454 1476 1455 states, err := db.GetLabels(rp.db, db.FilterEq("subject", subject)) 1477 1456 if err != nil { 1478 1478 - log.Println("failed to build label state", err) 1457 1457 + l.Error("failed to build label state", "err", err) 1479 1458 return 1480 1459 } 1481 1460 state := states[subject] ··· 1512 1491 db.FilterContains("scope", subject.Collection().String()), 1513 1492 ) 1514 1493 if err != nil { 1515 1515 - log.Println("failed to fetch labels", err) 1494 1494 + l.Error("failed to fetch labels", "err", err) 1516 1495 return 1517 1496 } 1518 1497 ··· 1523 1502 1524 1503 states, err := db.GetLabels(rp.db, db.FilterEq("subject", subject)) 1525 1504 if err != nil { 1526 1526 - log.Println("failed to build label state", err) 1505 1505 + l.Error("failed to build label state", "err", err) 1527 1506 return 1528 1507 } 1529 1508 state := states[subject] ··· 1670 1649 1671 1650 func (rp *Repo) DeleteRepo(w http.ResponseWriter, r *http.Request) { 1672 1651 user := rp.oauth.GetUser(r) 1652 1652 + l := rp.logger.With("handler", "DeleteRepo") 1673 1653 1674 1654 noticeId := "operation-error" 1675 1655 f, err := rp.repoResolver.Resolve(r) 1676 1656 if err != nil { 1677 1677 - log.Println("failed to get repo and knot", err) 1657 1657 + l.Error("failed to get repo and knot", "err", err) 1678 1658 return 1679 1659 } 1680 1660 1681 1661 // remove record from pds 1682 1662 atpClient, err := rp.oauth.AuthorizedClient(r) 1683 1663 if err != nil { 1684 1684 - log.Println("failed to get authorized client", err) 1664 1664 + l.Error("failed to get authorized client", "err", err) 1685 1665 return 1686 1666 } 1687 1667 _, err = comatproto.RepoDeleteRecord(r.Context(), atpClient, &comatproto.RepoDeleteRecord_Input{ ··· 1691 1669 Rkey: f.Rkey, 1692 1670 }) 1693 1671 if err != nil { 1694 1694 - log.Printf("failed to delete record: %s", err) 1672 1672 + l.Error("failed to delete record", "err", err) 1695 1673 rp.pages.Notice(w, noticeId, "Failed to delete repository from PDS.") 1696 1674 return 1697 1675 } 1698 1698 - log.Println("removed repo record ", f.RepoAt().String()) 1676 1676 + l.Info("removed repo record", "aturi", f.RepoAt().String()) 1699 1677 1700 1678 client, err := rp.oauth.ServiceClient( 1701 1679 r, ··· 1704 1682 oauth.WithDev(rp.config.Core.Dev), 1705 1683 ) 1706 1684 if err != nil { 1707 1707 - log.Println("failed to connect to knot server:", err) 1685 1685 + l.Error("failed to connect to knot server", "err", err) 1708 1686 return 1709 1687 } 1710 1688 ··· 1721 1699 rp.pages.Notice(w, noticeId, err.Error()) 1722 1700 return 1723 1701 } 1724 1724 - log.Println("deleted repo from knot") 1702 1702 + l.Info("deleted repo from knot") 1725 1703 1726 1704 tx, err := rp.db.BeginTx(r.Context(), nil) 1727 1705 if err != nil { 1728 1728 - log.Println("failed to start tx") 1706 1706 + l.Error("failed to start tx") 1729 1707 w.Write(fmt.Append(nil, "failed to add collaborator: ", err)) 1730 1708 return 1731 1709 } ··· 1733 1711 tx.Rollback() 1734 1712 err = rp.enforcer.E.LoadPolicy() 1735 1713 if err != nil { 1736 1736 - log.Println("failed to rollback policies") 1714 1714 + l.Error("failed to rollback policies") 1737 1715 } 1738 1716 }() 1739 1717 ··· 1747 1725 did := c[0] 1748 1726 rp.enforcer.RemoveCollaborator(did, f.Knot, f.DidSlashRepo()) 1749 1727 } 1750 1750 - log.Println("removed collaborators") 1728 1728 + l.Info("removed collaborators") 1751 1729 1752 1730 // remove repo RBAC 1753 1731 err = rp.enforcer.RemoveRepo(f.OwnerDid(), f.Knot, f.DidSlashRepo()) ··· 1762 1740 rp.pages.Notice(w, noticeId, "Failed to update appview") 1763 1741 return 1764 1742 } 1765 1765 - log.Println("removed repo from db") 1743 1743 + l.Info("removed repo from db") 1766 1744 1767 1745 err = tx.Commit() 1768 1746 if err != nil { 1769 1769 - log.Println("failed to commit changes", err) 1747 1747 + l.Error("failed to commit changes", "err", err) 1770 1748 http.Error(w, err.Error(), http.StatusInternalServerError) 1771 1749 return 1772 1750 } 1773 1751 1774 1752 err = rp.enforcer.E.SavePolicy() 1775 1753 if err != nil { 1776 1776 - log.Println("failed to update ACLs", err) 1754 1754 + l.Error("failed to update ACLs", "err", err) 1777 1755 http.Error(w, err.Error(), http.StatusInternalServerError) 1778 1756 return 1779 1757 } ··· 1782 1760 } 1783 1761 1784 1762 func (rp *Repo) SetDefaultBranch(w http.ResponseWriter, r *http.Request) { 1763 1763 + l := rp.logger.With("handler", "SetDefaultBranch") 1764 1764 + 1785 1765 f, err := rp.repoResolver.Resolve(r) 1786 1766 if err != nil { 1787 1787 - log.Println("failed to get repo and knot", err) 1767 1767 + l.Error("failed to get repo and knot", "err", err) 1788 1768 return 1789 1769 } 1790 1770 ··· 1804 1780 oauth.WithDev(rp.config.Core.Dev), 1805 1781 ) 1806 1782 if err != nil { 1807 1807 - log.Println("failed to connect to knot server:", err) 1783 1783 + l.Error("failed to connect to knot server", "err", err) 1808 1784 rp.pages.Notice(w, noticeId, "Failed to connect to knot server.") 1809 1785 return 1810 1786 } ··· 1818 1794 }, 1819 1795 ) 1820 1796 if err := xrpcclient.HandleXrpcErr(xe); err != nil { 1821 1821 - log.Println("xrpc failed", "err", xe) 1797 1797 + l.Error("xrpc failed", "err", xe) 1822 1798 rp.pages.Notice(w, noticeId, err.Error()) 1823 1799 return 1824 1800 } ··· 1833 1809 1834 1810 f, err := rp.repoResolver.Resolve(r) 1835 1811 if err != nil { 1836 1836 - log.Println("failed to get repo and knot", err) 1812 1812 + l.Error("failed to get repo and knot", "err", err) 1837 1813 return 1838 1814 } 1839 1815 1840 1816 if f.Spindle == "" { 1841 1841 - log.Println("empty spindle cannot add/rm secret", err) 1817 1817 + l.Error("empty spindle cannot add/rm secret", "err", err) 1842 1818 return 1843 1819 } 1844 1820 ··· 1855 1831 oauth.WithDev(rp.config.Core.Dev), 1856 1832 ) 1857 1833 if err != nil { 1858 1858 - log.Println("failed to create spindle client", err) 1834 1834 + l.Error("failed to create spindle client", "err", err) 1859 1835 return 1860 1836 } 1861 1837 ··· 1941 1917 } 1942 1918 1943 1919 func (rp *Repo) generalSettings(w http.ResponseWriter, r *http.Request) { 1920 1920 + l := rp.logger.With("handler", "generalSettings") 1921 1921 + 1944 1922 f, err := rp.repoResolver.Resolve(r) 1945 1923 user := rp.oauth.GetUser(r) 1946 1924 ··· 1958 1932 repo := fmt.Sprintf("%s/%s", f.OwnerDid(), f.Name) 1959 1933 xrpcBytes, err := tangled.RepoBranches(r.Context(), xrpcc, "", 0, repo) 1960 1934 if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil { 1961 1961 - log.Println("failed to call XRPC repo.branches", xrpcerr) 1935 1935 + l.Error("failed to call XRPC repo.branches", "err", xrpcerr) 1962 1936 rp.pages.Error503(w) 1963 1937 return 1964 1938 } 1965 1939 1966 1940 var result types.RepoBranchesResponse 1967 1941 if err := json.Unmarshal(xrpcBytes, &result); err != nil { 1968 1968 - log.Println("failed to decode XRPC response", err) 1942 1942 + l.Error("failed to decode XRPC response", "err", err) 1969 1943 rp.pages.Error503(w) 1970 1944 return 1971 1945 } 1972 1946 1973 1947 defaultLabels, err := db.GetLabelDefinitions(rp.db, db.FilterIn("at_uri", models.DefaultLabelDefs())) 1974 1948 if err != nil { 1975 1975 - log.Println("failed to fetch labels", err) 1949 1949 + l.Error("failed to fetch labels", "err", err) 1976 1950 rp.pages.Error503(w) 1977 1951 return 1978 1952 } 1979 1953 1980 1954 labels, err := db.GetLabelDefinitions(rp.db, db.FilterIn("at_uri", f.Repo.Labels)) 1981 1955 if err != nil { 1982 1982 - log.Println("failed to fetch labels", err) 1956 1956 + l.Error("failed to fetch labels", "err", err) 1983 1957 rp.pages.Error503(w) 1984 1958 return 1985 1959 } ··· 2027 2001 } 2028 2002 2029 2003 func (rp *Repo) accessSettings(w http.ResponseWriter, r *http.Request) { 2004 2004 + l := rp.logger.With("handler", "accessSettings") 2005 2005 + 2030 2006 f, err := rp.repoResolver.Resolve(r) 2031 2007 user := rp.oauth.GetUser(r) 2032 2008 2033 2009 repoCollaborators, err := f.Collaborators(r.Context()) 2034 2010 if err != nil { 2035 2035 - log.Println("failed to get collaborators", err) 2011 2011 + l.Error("failed to get collaborators", "err", err) 2036 2012 } 2037 2013 2038 2014 rp.pages.RepoAccessSettings(w, pages.RepoAccessSettingsParams{ ··· 2047 2019 } 2048 2020 2049 2021 func (rp *Repo) pipelineSettings(w http.ResponseWriter, r *http.Request) { 2022 2022 + l := rp.logger.With("handler", "pipelineSettings") 2023 2023 + 2050 2024 f, err := rp.repoResolver.Resolve(r) 2051 2025 user := rp.oauth.GetUser(r) 2052 2026 2053 2027 // all spindles that the repo owner is a member of 2054 2028 spindles, err := rp.enforcer.GetSpindlesForUser(f.OwnerDid()) 2055 2029 if err != nil { 2056 2056 - log.Println("failed to fetch spindles", err) 2030 2030 + l.Error("failed to fetch spindles", "err", err) 2057 2031 return 2058 2032 } 2059 2033 ··· 2068 2038 oauth.WithExp(60), 2069 2039 oauth.WithDev(rp.config.Core.Dev), 2070 2040 ); err != nil { 2071 2071 - log.Println("failed to create spindle client", err) 2041 2041 + l.Error("failed to create spindle client", "err", err) 2072 2042 } else if resp, err := tangled.RepoListSecrets(r.Context(), spindleClient, f.RepoAt().String()); err != nil { 2073 2073 - log.Println("failed to fetch secrets", err) 2043 2043 + l.Error("failed to fetch secrets", "err", err) 2074 2044 } else { 2075 2045 secrets = resp.Secrets 2076 2046 } ··· 2110 2080 } 2111 2081 2112 2082 func (rp *Repo) SyncRepoFork(w http.ResponseWriter, r *http.Request) { 2083 2083 + l := rp.logger.With("handler", "SyncRepoFork") 2084 2084 + 2113 2085 ref := chi.URLParam(r, "ref") 2114 2086 ref, _ = url.PathUnescape(ref) 2115 2087 2116 2088 user := rp.oauth.GetUser(r) 2117 2089 f, err := rp.repoResolver.Resolve(r) 2118 2090 if err != nil { 2119 2119 - log.Printf("failed to resolve source repo: %v", err) 2091 2091 + l.Error("failed to resolve source repo", "err", err) 2120 2092 return 2121 2093 } 2122 2094 ··· 2162 2130 } 2163 2131 2164 2132 func (rp *Repo) ForkRepo(w http.ResponseWriter, r *http.Request) { 2133 2133 + l := rp.logger.With("handler", "ForkRepo") 2134 2134 + 2165 2135 user := rp.oauth.GetUser(r) 2166 2136 f, err := rp.repoResolver.Resolve(r) 2167 2137 if err != nil { 2168 2168 - log.Printf("failed to resolve source repo: %v", err) 2138 2138 + l.Error("failed to resolve source repo", "err", err) 2169 2139 return 2170 2140 } 2171 2141 ··· 2218 2184 ) 2219 2185 if err != nil { 2220 2186 if !errors.Is(err, sql.ErrNoRows) { 2221 2221 - log.Println("error fetching existing repo from db", "err", err) 2187 2187 + l.Error("error fetching existing repo from db", "err", err) 2222 2188 rp.pages.Notice(w, "repo", "Failed to fork this repository. Try again later.") 2223 2189 return 2224 2190 } ··· 2333 2299 2334 2300 err = db.AddRepo(tx, repo) 2335 2301 if err != nil { 2336 2336 - log.Println(err) 2302 2302 + l.Error("failed to AddRepo", "err", err) 2337 2303 rp.pages.Notice(w, "repo", "Failed to save repository information.") 2338 2304 return 2339 2305 } ··· 2342 2308 p, _ := securejoin.SecureJoin(user.Did, forkName) 2343 2309 err = rp.enforcer.AddRepo(user.Did, targetKnot, p) 2344 2310 if err != nil { 2345 2345 - log.Println(err) 2311 2311 + l.Error("failed to add ACLs", "err", err) 2346 2312 rp.pages.Notice(w, "repo", "Failed to set up repository permissions.") 2347 2313 return 2348 2314 } 2349 2315 2350 2316 err = tx.Commit() 2351 2317 if err != nil { 2352 2352 - log.Println("failed to commit changes", err) 2318 2318 + l.Error("failed to commit changes", "err", err) 2353 2319 http.Error(w, err.Error(), http.StatusInternalServerError) 2354 2320 return 2355 2321 } 2356 2322 2357 2323 err = rp.enforcer.E.SavePolicy() 2358 2324 if err != nil { 2359 2359 - log.Println("failed to update ACLs", err) 2325 2325 + l.Error("failed to update ACLs", "err", err) 2360 2326 http.Error(w, err.Error(), http.StatusInternalServerError) 2361 2327 return 2362 2328 } ··· 2392 2358 } 2393 2359 2394 2360 func (rp *Repo) RepoCompareNew(w http.ResponseWriter, r *http.Request) { 2361 2361 + l := rp.logger.With("handler", "RepoCompareNew") 2362 2362 + 2395 2363 user := rp.oauth.GetUser(r) 2396 2364 f, err := rp.repoResolver.Resolve(r) 2397 2365 if err != nil { 2398 2398 - log.Println("failed to get repo and knot", err) 2366 2366 + l.Error("failed to get repo and knot", "err", err) 2399 2367 return 2400 2368 } 2401 2369 ··· 2413 2377 repo := fmt.Sprintf("%s/%s", f.OwnerDid(), f.Name) 2414 2378 branchBytes, err := tangled.RepoBranches(r.Context(), xrpcc, "", 0, repo) 2415 2379 if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil { 2416 2416 - log.Println("failed to call XRPC repo.branches", xrpcerr) 2380 2380 + l.Error("failed to call XRPC repo.branches", "err", xrpcerr) 2417 2381 rp.pages.Error503(w) 2418 2382 return 2419 2383 } 2420 2384 2421 2385 var branchResult types.RepoBranchesResponse 2422 2386 if err := json.Unmarshal(branchBytes, &branchResult); err != nil { 2423 2423 - log.Println("failed to decode XRPC branches response", err) 2387 2387 + l.Error("failed to decode XRPC branches response", "err", err) 2424 2388 rp.pages.Notice(w, "compare-error", "Failed to produce comparison. Try again later.") 2425 2389 return 2426 2390 } ··· 2450 2414 2451 2415 tagBytes, err := tangled.RepoTags(r.Context(), xrpcc, "", 0, repo) 2452 2416 if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil { 2453 2453 - log.Println("failed to call XRPC repo.tags", xrpcerr) 2417 2417 + l.Error("failed to call XRPC repo.tags", "err", xrpcerr) 2454 2418 rp.pages.Error503(w) 2455 2419 return 2456 2420 } 2457 2421 2458 2422 var tags types.RepoTagsResponse 2459 2423 if err := json.Unmarshal(tagBytes, &tags); err != nil { 2460 2460 - log.Println("failed to decode XRPC tags response", err) 2424 2424 + l.Error("failed to decode XRPC tags response", "err", err) 2461 2425 rp.pages.Notice(w, "compare-error", "Failed to produce comparison. Try again later.") 2462 2426 return 2463 2427 } ··· 2475 2439 } 2476 2440 2477 2441 func (rp *Repo) RepoCompare(w http.ResponseWriter, r *http.Request) { 2442 2442 + l := rp.logger.With("handler", "RepoCompare") 2443 2443 + 2478 2444 user := rp.oauth.GetUser(r) 2479 2445 f, err := rp.repoResolver.Resolve(r) 2480 2446 if err != nil { 2481 2481 - log.Println("failed to get repo and knot", err) 2447 2447 + l.Error("failed to get repo and knot", "err", err) 2482 2448 return 2483 2449 } 2484 2450 ··· 2507 2469 head, _ = url.PathUnescape(head) 2508 2470 2509 2471 if base == "" || head == "" { 2510 2510 - log.Printf("invalid comparison") 2472 2472 + l.Error("invalid comparison") 2511 2473 rp.pages.Error404(w) 2512 2474 return 2513 2475 } ··· 2525 2487 2526 2488 branchBytes, err := tangled.RepoBranches(r.Context(), xrpcc, "", 0, repo) 2527 2489 if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil { 2528 2528 - log.Println("failed to call XRPC repo.branches", xrpcerr) 2490 2490 + l.Error("failed to call XRPC repo.branches", "err", xrpcerr) 2529 2491 rp.pages.Error503(w) 2530 2492 return 2531 2493 } 2532 2494 2533 2495 var branches types.RepoBranchesResponse 2534 2496 if err := json.Unmarshal(branchBytes, &branches); err != nil { 2535 2535 - log.Println("failed to decode XRPC branches response", err) 2497 2497 + l.Error("failed to decode XRPC branches response", "err", err) 2536 2498 rp.pages.Notice(w, "compare-error", "Failed to produce comparison. Try again later.") 2537 2499 return 2538 2500 } 2539 2501 2540 2502 tagBytes, err := tangled.RepoTags(r.Context(), xrpcc, "", 0, repo) 2541 2503 if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil { 2542 2542 - log.Println("failed to call XRPC repo.tags", xrpcerr) 2504 2504 + l.Error("failed to call XRPC repo.tags", "err", xrpcerr) 2543 2505 rp.pages.Error503(w) 2544 2506 return 2545 2507 } 2546 2508 2547 2509 var tags types.RepoTagsResponse 2548 2510 if err := json.Unmarshal(tagBytes, &tags); err != nil { 2549 2549 - log.Println("failed to decode XRPC tags response", err) 2511 2511 + l.Error("failed to decode XRPC tags response", "err", err) 2550 2512 rp.pages.Notice(w, "compare-error", "Failed to produce comparison. Try again later.") 2551 2513 return 2552 2514 } 2553 2515 2554 2516 compareBytes, err := tangled.RepoCompare(r.Context(), xrpcc, repo, base, head) 2555 2517 if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil { 2556 2556 - log.Println("failed to call XRPC repo.compare", xrpcerr) 2518 2518 + l.Error("failed to call XRPC repo.compare", "err", xrpcerr) 2557 2519 rp.pages.Error503(w) 2558 2520 return 2559 2521 } 2560 2522 2561 2523 var formatPatch types.RepoFormatPatchResponse 2562 2524 if err := json.Unmarshal(compareBytes, &formatPatch); err != nil { 2563 2563 - log.Println("failed to decode XRPC compare response", err) 2525 2525 + l.Error("failed to decode XRPC compare response", "err", err) 2564 2526 rp.pages.Notice(w, "compare-error", "Failed to produce comparison. Try again later.") 2565 2527 return 2566 2528 }

+1 -1

appview/signup/signup.go

reviewed

··· 62 62 disallowed := make(map[string]bool) 63 63 64 64 if filepath == "" { 65 65 - logger.Debug("no disallowed nicknames file configured") 65 65 + logger.Warn("no disallowed nicknames file configured") 66 66 return disallowed 67 67 } 68 68

+3 -1

appview/state/knotstream.go

reviewed

··· 25 25 ) 26 26 27 27 func Knotstream(ctx context.Context, c *config.Config, d *db.DB, enforcer *rbac.Enforcer, posthog posthog.Client) (*ec.Consumer, error) { 28 28 + logger := log.FromContext(ctx) 29 29 + logger = log.SubLogger(logger, "knotstream") 30 30 + 28 31 knots, err := db.GetRegistrations( 29 32 d, 30 33 db.FilterIsNot("registered", "null"), ··· 42 39 srcs[s] = struct{}{} 43 40 } 44 41 45 45 - logger := log.New("knotstream") 46 42 cache := cache.New(c.Redis.Addr) 47 43 cursorStore := cursor.NewRedisCursorStore(cache) 48 44

+7 -4

appview/state/login.go

reviewed

··· 2 2 3 3 import ( 4 4 "fmt" 5 5 - "log" 6 5 "net/http" 7 6 "strings" 8 7 ··· 9 10 ) 10 11 11 12 func (s *State) Login(w http.ResponseWriter, r *http.Request) { 13 13 + l := s.logger.With("handler", "Login") 14 14 + 12 15 switch r.Method { 13 16 case http.MethodGet: 14 17 returnURL := r.URL.Query().Get("return_url") ··· 33 32 34 33 // basic handle validation 35 34 if !strings.Contains(handle, ".") { 36 36 - log.Println("invalid handle format", "raw", handle) 35 35 + l.Error("invalid handle format", "raw", handle) 37 36 s.pages.Notice( 38 37 w, 39 38 "login-msg", ··· 53 52 } 54 53 55 54 func (s *State) Logout(w http.ResponseWriter, r *http.Request) { 55 55 + l := s.logger.With("handler", "Logout") 56 56 + 56 57 err := s.oauth.DeleteSession(w, r) 57 58 if err != nil { 58 58 - log.Println("failed to logout", "err", err) 59 59 + l.Error("failed to logout", "err", err) 59 60 } else { 60 60 - log.Println("logged out successfully") 61 61 + l.Info("logged out successfully") 61 62 } 62 63 63 64 s.pages.HxRedirect(w, "/login")

+59 -13

appview/state/router.go

reviewed

··· 205 205 } 206 206 207 207 func (s *State) SpindlesRouter() http.Handler { 208 208 - logger := log.New("spindles") 208 208 + logger := log.SubLogger(s.logger, "spindles") 209 209 210 210 spindles := &spindles.Spindles{ 211 211 Db: s.db, ··· 221 221 } 222 222 223 223 func (s *State) KnotsRouter() http.Handler { 224 224 - logger := log.New("knots") 224 224 + logger := log.SubLogger(s.logger, "knots") 225 225 226 226 knots := &knots.Knots{ 227 227 Db: s.db, ··· 238 238 } 239 239 240 240 func (s *State) StringsRouter(mw *middleware.Middleware) http.Handler { 241 241 - logger := log.New("strings") 241 241 + logger := log.SubLogger(s.logger, "strings") 242 242 243 243 strs := &avstrings.Strings{ 244 244 Db: s.db, ··· 253 253 } 254 254 255 255 func (s *State) IssuesRouter(mw *middleware.Middleware) http.Handler { 256 256 - issues := issues.New(s.oauth, s.repoResolver, s.pages, s.idResolver, s.db, s.config, s.notifier, s.validator) 256 256 + issues := issues.New( 257 257 + s.oauth, 258 258 + s.repoResolver, 259 259 + s.pages, 260 260 + s.idResolver, 261 261 + s.db, 262 262 + s.config, 263 263 + s.notifier, 264 264 + s.validator, 265 265 + log.SubLogger(s.logger, "issues"), 266 266 + ) 257 267 return issues.Router(mw) 258 268 } 259 269 260 270 func (s *State) PullsRouter(mw *middleware.Middleware) http.Handler { 261 261 - pulls := pulls.New(s.oauth, s.repoResolver, s.pages, s.idResolver, s.db, s.config, s.notifier, s.enforcer) 271 271 + pulls := pulls.New( 272 272 + s.oauth, 273 273 + s.repoResolver, 274 274 + s.pages, 275 275 + s.idResolver, 276 276 + s.db, 277 277 + s.config, 278 278 + s.notifier, 279 279 + s.enforcer, 280 280 + log.SubLogger(s.logger, "pulls"), 281 281 + ) 262 282 return pulls.Router(mw) 263 283 } 264 284 265 285 func (s *State) RepoRouter(mw *middleware.Middleware) http.Handler { 266 266 - logger := log.New("repo") 267 267 - repo := repo.New(s.oauth, s.repoResolver, s.pages, s.spindlestream, s.idResolver, s.db, s.config, s.notifier, s.enforcer, logger, s.validator) 286 286 + repo := repo.New( 287 287 + s.oauth, 288 288 + s.repoResolver, 289 289 + s.pages, 290 290 + s.spindlestream, 291 291 + s.idResolver, 292 292 + s.db, 293 293 + s.config, 294 294 + s.notifier, 295 295 + s.enforcer, 296 296 + log.SubLogger(s.logger, "repo"), 297 297 + s.validator, 298 298 + ) 268 299 return repo.Router(mw) 269 300 } 270 301 271 302 func (s *State) PipelinesRouter(mw *middleware.Middleware) http.Handler { 272 272 - pipes := pipelines.New(s.oauth, s.repoResolver, s.pages, s.spindlestream, s.idResolver, s.db, s.config, s.enforcer) 303 303 + pipes := pipelines.New( 304 304 + s.oauth, 305 305 + s.repoResolver, 306 306 + s.pages, 307 307 + s.spindlestream, 308 308 + s.idResolver, 309 309 + s.db, 310 310 + s.config, 311 311 + s.enforcer, 312 312 + log.SubLogger(s.logger, "pipelines"), 313 313 + ) 273 314 return pipes.Router(mw) 274 315 } 275 316 276 317 func (s *State) LabelsRouter(mw *middleware.Middleware) http.Handler { 277 277 - ls := labels.New(s.oauth, s.pages, s.db, s.validator, s.enforcer) 318 318 + ls := labels.New( 319 319 + s.oauth, 320 320 + s.pages, 321 321 + s.db, 322 322 + s.validator, 323 323 + s.enforcer, 324 324 + log.SubLogger(s.logger, "labels"), 325 325 + ) 278 326 return ls.Router(mw) 279 327 } 280 328 281 329 func (s *State) NotificationsRouter(mw *middleware.Middleware) http.Handler { 282 282 - notifs := notifications.New(s.db, s.oauth, s.pages) 330 330 + notifs := notifications.New(s.db, s.oauth, s.pages, log.SubLogger(s.logger, "notifications")) 283 331 return notifs.Router(mw) 284 332 } 285 333 286 334 func (s *State) SignupRouter() http.Handler { 287 287 - logger := log.New("signup") 288 288 - 289 289 - sig := signup.New(s.config, s.db, s.posthog, s.idResolver, s.pages, logger) 335 335 + sig := signup.New(s.config, s.db, s.posthog, s.idResolver, s.pages, log.SubLogger(s.logger, "signup")) 290 336 return sig.Router() 291 337 }

+3 -1

appview/state/spindlestream.go

reviewed

··· 22 22 ) 23 23 24 24 func Spindlestream(ctx context.Context, c *config.Config, d *db.DB, enforcer *rbac.Enforcer) (*ec.Consumer, error) { 25 25 + logger := log.FromContext(ctx) 26 26 + logger = log.SubLogger(logger, "spindlestream") 27 27 + 25 28 spindles, err := db.GetSpindles( 26 29 d, 27 30 db.FilterIsNot("verified", "null"), ··· 39 36 srcs[src] = struct{}{} 40 37 } 41 38 42 42 - logger := log.New("spindlestream") 43 39 cache := cache.New(c.Redis.Addr) 44 40 cursorStore := cursor.NewRedisCursorStore(cache) 45 41

+15 -19

appview/state/state.go

reviewed

··· 5 5 "database/sql" 6 6 "errors" 7 7 "fmt" 8 8 - "log" 9 8 "log/slog" 10 9 "net/http" 11 10 "strings" ··· 12 13 13 14 "tangled.org/core/api/tangled" 14 15 "tangled.org/core/appview" 15 15 - "tangled.org/core/appview/cache" 16 16 - "tangled.org/core/appview/cache/session" 17 16 "tangled.org/core/appview/config" 18 17 "tangled.org/core/appview/db" 19 18 "tangled.org/core/appview/models" ··· 26 29 "tangled.org/core/eventconsumer" 27 30 "tangled.org/core/idresolver" 28 31 "tangled.org/core/jetstream" 32 32 + "tangled.org/core/log" 29 33 tlog "tangled.org/core/log" 30 34 "tangled.org/core/rbac" 31 35 "tangled.org/core/tid" ··· 46 48 oauth *oauth.OAuth 47 49 enforcer *rbac.Enforcer 48 50 pages *pages.Pages 49 49 - sess *session.SessionStore 50 51 idResolver *idresolver.Resolver 51 52 posthog posthog.Client 52 53 jc *jetstream.JetstreamClient ··· 58 61 } 59 62 60 63 func Make(ctx context.Context, config *config.Config) (*State, error) { 61 61 - d, err := db.Make(config.Core.DbPath) 64 64 + logger := tlog.FromContext(ctx) 65 65 + 66 66 + d, err := db.Make(ctx, config.Core.DbPath) 62 67 if err != nil { 63 68 return nil, fmt.Errorf("failed to create db: %w", err) 64 69 } ··· 72 73 73 74 res, err := idresolver.RedisResolver(config.Redis.ToURL()) 74 75 if err != nil { 75 75 - log.Printf("failed to create redis resolver: %v", err) 76 76 + logger.Error("failed to create redis resolver", "err", err) 76 77 res = idresolver.DefaultResolver() 77 78 } 78 79 ··· 81 82 return nil, fmt.Errorf("failed to create posthog client: %w", err) 82 83 } 83 84 84 84 - pages := pages.NewPages(config, res) 85 85 - cache := cache.New(config.Redis.Addr) 86 86 - sess := session.New(cache) 87 87 - oauth2, err := oauth.New(config, posthog, d, enforcer, res) 85 85 + pages := pages.NewPages(config, res, log.SubLogger(logger, "pages")) 86 86 + oauth, err := oauth.New(config, posthog, d, enforcer, res) 88 87 if err != nil { 89 88 return nil, fmt.Errorf("failed to start oauth handler: %w", err) 90 89 } ··· 109 112 tangled.LabelOpNSID, 110 113 }, 111 114 nil, 112 112 - slog.Default(), 115 115 + tlog.SubLogger(logger, "jetstream"), 113 116 wrapper, 114 117 false, 115 118 ··· 130 133 Enforcer: enforcer, 131 134 IdResolver: res, 132 135 Config: config, 133 133 - Logger: tlog.New("ingester"), 136 136 + Logger: log.SubLogger(logger, "ingester"), 134 137 Validator: validator, 135 138 } 136 139 err = jc.StartJetstream(ctx, ingester.Ingest()) ··· 164 167 state := &State{ 165 168 d, 166 169 notifier, 167 167 - oauth2, 170 170 + oauth, 168 171 enforcer, 169 172 pages, 170 170 - sess, 171 173 res, 172 174 posthog, 173 175 jc, ··· 174 178 repoResolver, 175 179 knotstream, 176 180 spindlestream, 177 177 - slog.Default(), 181 181 + logger, 178 182 validator, 179 183 } 180 184 ··· 273 277 } 274 278 timeline, err := db.MakeTimeline(s.db, 50, userDid, filtered) 275 279 if err != nil { 276 276 - log.Println(err) 280 280 + s.logger.Error("failed to make timeline", "err", err) 277 281 s.pages.Notice(w, "timeline", "Uh oh! Failed to load timeline.") 278 282 } 279 283 280 284 repos, err := db.GetTopStarredReposLastWeek(s.db) 281 285 if err != nil { 282 282 - log.Println(err) 286 286 + s.logger.Error("failed to get top starred repos", "err", err) 283 287 s.pages.Notice(w, "topstarredrepos", "Unable to load.") 284 288 return 285 289 } ··· 340 344 341 345 timeline, err := db.MakeTimeline(s.db, 5, "", filtered) 342 346 if err != nil { 343 343 - log.Println(err) 347 347 + s.logger.Error("failed to make timeline", "err", err) 344 348 s.pages.Notice(w, "timeline", "Uh oh! Failed to load timeline.") 345 349 return 346 350 } 347 351 348 352 repos, err := db.GetTopStarredReposLastWeek(s.db) 349 353 if err != nil { 350 350 - log.Println(err) 354 354 + s.logger.Error("failed to get top starred repos", "err", err) 351 355 s.pages.Notice(w, "topstarredrepos", "Unable to load.") 352 356 return 353 357 }

+14 -9

cmd/appview/main.go

reviewed

··· 2 2 3 3 import ( 4 4 "context" 5 5 - "log" 6 6 - "log/slog" 7 5 "net/http" 8 6 "os" 9 7 10 8 "tangled.org/core/appview/config" 11 9 "tangled.org/core/appview/state" 10 10 + tlog "tangled.org/core/log" 12 11 ) 13 12 14 13 func main() { 15 15 - slog.SetDefault(slog.New(slog.NewTextHandler(os.Stdout, nil))) 16 16 - 17 14 ctx := context.Background() 15 15 + logger := tlog.New("appview") 16 16 + ctx = tlog.IntoContext(ctx, logger) 18 17 19 18 c, err := config.LoadConfig(ctx) 20 19 if err != nil { 21 21 - log.Println("failed to load config", "error", err) 20 20 + logger.Error("failed to load config", "error", err) 22 21 return 23 22 } 24 23 25 24 state, err := state.Make(ctx, c) 26 25 defer func() { 27 27 - log.Println(state.Close()) 26 26 + if err := state.Close(); err != nil { 27 27 + logger.Error("failed to close state", "err", err) 28 28 + } 28 29 }() 29 30 30 31 if err != nil { 31 31 - log.Fatal(err) 32 32 + logger.Error("failed to start appview", "err", err) 33 33 + os.Exit(-1) 32 34 } 33 35 34 34 - log.Println("starting server on", c.Core.ListenAddr) 35 35 - log.Println(http.ListenAndServe(c.Core.ListenAddr, state.Router())) 36 36 + logger.Info("starting server", "address", c.Core.ListenAddr) 37 37 + 38 38 + if err := http.ListenAndServe(c.Core.ListenAddr, state.Router()); err != nil { 39 39 + logger.Error("failed to start appview", "err", err) 40 40 + } 36 41 }

+9 -3

cmd/spindle/main.go

reviewed

··· 2 2 3 3 import ( 4 4 "context" 5 5 + "log/slog" 5 6 "os" 6 7 7 7 - "tangled.org/core/log" 8 8 + tlog "tangled.org/core/log" 8 9 "tangled.org/core/spindle" 9 10 _ "tangled.org/core/tid" 10 11 ) 11 12 12 13 func main() { 13 13 - ctx := log.NewContext(context.Background(), "spindle") 14 14 + logger := tlog.New("spindl3") 15 15 + slog.SetDefault(logger) 16 16 + 17 17 + ctx := context.Background() 18 18 + ctx = tlog.IntoContext(ctx, logger) 19 19 + 14 20 err := spindle.Run(ctx) 15 21 if err != nil { 16 16 - log.FromContext(ctx).Error("error running spindle", "error", err) 22 22 + logger.Error("error running spindle", "error", err) 17 23 os.Exit(-1) 18 24 } 19 25 }

+13

go.mod

reviewed

··· 60 60 github.com/ProtonMail/go-crypto v1.3.0 // indirect 61 61 github.com/alecthomas/repr v0.4.0 // indirect 62 62 github.com/anmitsu/go-shlex v0.0.0-20200514113438-38f4b401e2be // indirect 63 63 + github.com/aymanbagabas/go-osc52/v2 v2.0.1 // indirect 63 64 github.com/aymerick/douceur v0.2.0 // indirect 64 65 github.com/beorn7/perks v1.0.1 // indirect 65 66 github.com/bmatcuk/doublestar/v4 v4.7.1 // indirect 66 67 github.com/casbin/govaluate v1.3.0 // indirect 67 68 github.com/cenkalti/backoff/v4 v4.3.0 // indirect 68 69 github.com/cespare/xxhash/v2 v2.3.0 // indirect 70 70 + github.com/charmbracelet/colorprofile v0.2.3-0.20250311203215-f60798e515dc // indirect 71 71 + github.com/charmbracelet/lipgloss v1.1.0 // indirect 72 72 + github.com/charmbracelet/log v0.4.2 // indirect 73 73 + github.com/charmbracelet/x/ansi v0.8.0 // indirect 74 74 + github.com/charmbracelet/x/cellbuf v0.0.13-0.20250311204145-2c3ea96c31dd // indirect 75 75 + github.com/charmbracelet/x/term v0.2.1 // indirect 69 76 github.com/cloudflare/circl v1.6.2-0.20250618153321-aa837fd1539d // indirect 70 77 github.com/containerd/errdefs v1.0.0 // indirect 71 78 github.com/containerd/errdefs/pkg v0.3.0 // indirect ··· 91 84 github.com/go-git/gcfg v1.5.1-0.20230307220236-3a3c6141e376 // indirect 92 85 github.com/go-git/go-billy/v5 v5.6.2 // indirect 93 86 github.com/go-jose/go-jose/v3 v3.0.4 // indirect 87 87 + github.com/go-logfmt/logfmt v0.6.0 // indirect 94 88 github.com/go-logr/logr v1.4.3 // indirect 95 89 github.com/go-logr/stdr v1.2.2 // indirect 96 90 github.com/go-redis/cache/v9 v9.0.0 // indirect ··· 134 126 github.com/lestrrat-go/httprc v1.0.6 // indirect 135 127 github.com/lestrrat-go/iter v1.0.2 // indirect 136 128 github.com/lestrrat-go/option v1.0.1 // indirect 129 129 + github.com/lucasb-eyer/go-colorful v1.2.0 // indirect 137 130 github.com/mattn/go-isatty v0.0.20 // indirect 131 131 + github.com/mattn/go-runewidth v0.0.16 // indirect 138 132 github.com/minio/sha256-simd v1.0.1 // indirect 139 133 github.com/mitchellh/mapstructure v1.5.0 // indirect 140 134 github.com/moby/docker-image-spec v1.3.1 // indirect ··· 144 134 github.com/moby/term v0.5.2 // indirect 145 135 github.com/morikuni/aec v1.0.0 // indirect 146 136 github.com/mr-tron/base58 v1.2.0 // indirect 137 137 + github.com/muesli/termenv v0.16.0 // indirect 147 138 github.com/multiformats/go-base32 v0.1.0 // indirect 148 139 github.com/multiformats/go-base36 v0.2.0 // indirect 149 140 github.com/multiformats/go-multibase v0.2.0 // indirect ··· 163 152 github.com/prometheus/client_model v0.6.2 // indirect 164 153 github.com/prometheus/common v0.64.0 // indirect 165 154 github.com/prometheus/procfs v0.16.1 // indirect 155 155 + github.com/rivo/uniseg v0.4.7 // indirect 166 156 github.com/ryanuber/go-glob v1.0.0 // indirect 167 157 github.com/segmentio/asm v1.2.0 // indirect 168 158 github.com/sergi/go-diff v1.3.2-0.20230802210424-5b0b94c5c0d3 // indirect ··· 172 160 github.com/vmihailenco/msgpack/v5 v5.4.1 // indirect 173 161 github.com/vmihailenco/tagparser/v2 v2.0.0 // indirect 174 162 github.com/wyatt915/treeblood v0.1.15 // indirect 163 163 + github.com/xo/terminfo v0.0.0-20220910002029-abceb7e1c41e // indirect 175 164 gitlab.com/staticnoise/goldmark-callout v0.0.0-20240609120641-6366b799e4ab // indirect 176 165 gitlab.com/yawning/secp256k1-voi v0.0.0-20230925100816-f2616030848b // indirect 177 166 gitlab.com/yawning/tuplehash v0.0.0-20230713102510-df83abbf9a02 // indirect

+27

go.sum

reviewed

··· 19 19 github.com/armon/go-socks5 v0.0.0-20160902184237-e75332964ef5/go.mod h1:wHh0iHkYZB8zMSxRWpUBQtwG5a7fFgvEO+odwuTv2gs= 20 20 github.com/avast/retry-go/v4 v4.6.1 h1:VkOLRubHdisGrHnTu89g08aQEWEgRU7LVEop3GbIcMk= 21 21 github.com/avast/retry-go/v4 v4.6.1/go.mod h1:V6oF8njAwxJ5gRo1Q7Cxab24xs5NCWZBeaHHBklR8mA= 22 22 + github.com/aymanbagabas/go-osc52/v2 v2.0.1 h1:HwpRHbFMcZLEVr42D4p7XBqjyuxQH5SMiErDT4WkJ2k= 23 23 + github.com/aymanbagabas/go-osc52/v2 v2.0.1/go.mod h1:uYgXzlJ7ZpABp8OJ+exZzJJhRNQ2ASbcXHWsFqH8hp8= 22 24 github.com/aymerick/douceur v0.2.0 h1:Mv+mAeH1Q+n9Fr+oyamOlAkUNPWPlA8PPGR0QAaYuPk= 23 25 github.com/aymerick/douceur v0.2.0/go.mod h1:wlT5vV2O3h55X9m7iVYN0TBM0NH/MmbLnd30/FjWUq4= 24 26 github.com/beorn7/perks v1.0.1 h1:VlbKKnNfV8bJzeqoa4cOKqO6bYr3WgKZxO8Z16+hsOM= ··· 50 48 github.com/cespare/xxhash/v2 v2.2.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs= 51 49 github.com/cespare/xxhash/v2 v2.3.0 h1:UL815xU9SqsFlibzuggzjXhog7bL6oX9BbNZnL2UFvs= 52 50 github.com/cespare/xxhash/v2 v2.3.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs= 51 51 + github.com/charmbracelet/colorprofile v0.2.3-0.20250311203215-f60798e515dc h1:4pZI35227imm7yK2bGPcfpFEmuY1gc2YSTShr4iJBfs= 52 52 + github.com/charmbracelet/colorprofile v0.2.3-0.20250311203215-f60798e515dc/go.mod h1:X4/0JoqgTIPSFcRA/P6INZzIuyqdFY5rm8tb41s9okk= 53 53 + github.com/charmbracelet/lipgloss v1.1.0 h1:vYXsiLHVkK7fp74RkV7b2kq9+zDLoEU4MZoFqR/noCY= 54 54 + github.com/charmbracelet/lipgloss v1.1.0/go.mod h1:/6Q8FR2o+kj8rz4Dq0zQc3vYf7X+B0binUUBwA0aL30= 55 55 + github.com/charmbracelet/log v0.4.2 h1:hYt8Qj6a8yLnvR+h7MwsJv/XvmBJXiueUcI3cIxsyig= 56 56 + github.com/charmbracelet/log v0.4.2/go.mod h1:qifHGX/tc7eluv2R6pWIpyHDDrrb/AG71Pf2ysQu5nw= 57 57 + github.com/charmbracelet/x/ansi v0.8.0 h1:9GTq3xq9caJW8ZrBTe0LIe2fvfLR/bYXKTx2llXn7xE= 58 58 + github.com/charmbracelet/x/ansi v0.8.0/go.mod h1:wdYl/ONOLHLIVmQaxbIYEC/cRKOQyjTkowiI4blgS9Q= 59 59 + github.com/charmbracelet/x/cellbuf v0.0.13-0.20250311204145-2c3ea96c31dd h1:vy0GVL4jeHEwG5YOXDmi86oYw2yuYUGqz6a8sLwg0X8= 60 60 + github.com/charmbracelet/x/cellbuf v0.0.13-0.20250311204145-2c3ea96c31dd/go.mod h1:xe0nKWGd3eJgtqZRaN9RjMtK7xUYchjzPr7q6kcvCCs= 61 61 + github.com/charmbracelet/x/term v0.2.1 h1:AQeHeLZ1OqSXhrAWpYUtZyX1T3zVxfpZuEQMIQaGIAQ= 62 62 + github.com/charmbracelet/x/term v0.2.1/go.mod h1:oQ4enTYFV7QN4m0i9mzHrViD7TQKvNEEkHUMCmsxdUg= 53 63 github.com/chzyer/logex v1.1.10/go.mod h1:+Ywpsq7O8HXn0nuIou7OrIPyXbp3wmkHB+jjWRnGsAI= 54 64 github.com/chzyer/readline v0.0.0-20180603132655-2972be24d48e/go.mod h1:nSuG5e5PlCu98SY8svDHJxuZscDgtXS6KTTbou5AhLI= 55 65 github.com/chzyer/test v0.0.0-20180213035817-a1ea475d72b1/go.mod h1:Q3SI9o4m/ZMnBNeIyt5eFwwo7qiLfzFZmjNmxjkiQlU= ··· 134 120 github.com/go-git/go-git-fixtures/v5 v5.0.0-20241203230421-0753e18f8f03/go.mod h1:hMKrMnUE4W0SJ7bFyM00dyz/HoknZoptGWzrj6M+dEM= 135 121 github.com/go-jose/go-jose/v3 v3.0.4 h1:Wp5HA7bLQcKnf6YYao/4kpRpVMp/yf6+pJKV8WFSaNY= 136 122 github.com/go-jose/go-jose/v3 v3.0.4/go.mod h1:5b+7YgP7ZICgJDBdfjZaIt+H/9L9T/YQrVfLAMboGkQ= 123 123 + github.com/go-logfmt/logfmt v0.6.0 h1:wGYYu3uicYdqXVgoYbvnkrPVXkuLM1p1ifugDMEdRi4= 124 124 + github.com/go-logfmt/logfmt v0.6.0/go.mod h1:WYhtIu8zTZfxdn5+rREduYbwxfcBr/Vr6KEVveWlfTs= 137 125 github.com/go-logr/logr v1.2.2/go.mod h1:jdQByPbusPIv2/zmleS9BjJVeZ6kBagPoEUsqbVz/1A= 138 126 github.com/go-logr/logr v1.2.3/go.mod h1:jdQByPbusPIv2/zmleS9BjJVeZ6kBagPoEUsqbVz/1A= 139 127 github.com/go-logr/logr v1.4.3 h1:CjnDlHq8ikf6E492q6eKboGOC0T8CDaOvkHCIg8idEI= ··· 292 276 github.com/lestrrat-go/jwx/v2 v2.1.6/go.mod h1:Y722kU5r/8mV7fYDifjug0r8FK8mZdw0K0GpJw/l8pU= 293 277 github.com/lestrrat-go/option v1.0.1 h1:oAzP2fvZGQKWkvHa1/SAcFolBEca1oN+mQ7eooNBEYU= 294 278 github.com/lestrrat-go/option v1.0.1/go.mod h1:5ZHFbivi4xwXxhxY9XHDe2FHo6/Z7WWmtT7T5nBBp3I= 279 279 + github.com/lucasb-eyer/go-colorful v1.2.0 h1:1nnpGOrhyZZuNyfu1QjKiUICQ74+3FNCN69Aj6K7nkY= 280 280 + github.com/lucasb-eyer/go-colorful v1.2.0/go.mod h1:R4dSotOR9KMtayYi1e77YzuveK+i7ruzyGqttikkLy0= 295 281 github.com/mattn/go-colorable v0.1.14 h1:9A9LHSqF/7dyVVX6g0U9cwm9pG3kP9gSzcuIPHPsaIE= 296 282 github.com/mattn/go-colorable v0.1.14/go.mod h1:6LmQG8QLFO4G5z1gPvYEzlUgJ2wF+stgPZH1UqBm1s8= 297 283 github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY= 298 284 github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y= 285 285 + github.com/mattn/go-runewidth v0.0.16 h1:E5ScNMtiwvlvB5paMFdw9p4kSQzbXFikJ5SQO6TULQc= 286 286 + github.com/mattn/go-runewidth v0.0.16/go.mod h1:Jdepj2loyihRzMpdS35Xk/zdY8IAYHsh153qUoGf23w= 299 287 github.com/mattn/go-sqlite3 v1.14.24 h1:tpSp2G2KyMnnQu99ngJ47EIkWVmliIizyZBfPrBWDRM= 300 288 github.com/mattn/go-sqlite3 v1.14.24/go.mod h1:Uh1q+B4BYcTPb+yiD3kU8Ct7aC0hY9fxUwlHK0RXw+Y= 301 289 github.com/microcosm-cc/bluemonday v1.0.27 h1:MpEUotklkwCSLeH+Qdx1VJgNqLlpY2KXwXFM08ygZfk= ··· 320 300 github.com/morikuni/aec v1.0.0/go.mod h1:BbKIizmSmc5MMPqRYbxO4ZU0S0+P200+tUnFx7PXmsc= 321 301 github.com/mr-tron/base58 v1.2.0 h1:T/HDJBh4ZCPbU39/+c3rRvE0uKBQlU27+QI8LJ4t64o= 322 302 github.com/mr-tron/base58 v1.2.0/go.mod h1:BinMc/sQntlIE1frQmRFPUoPA1Zkr8VRgBdjWI2mNwc= 303 303 + github.com/muesli/termenv v0.16.0 h1:S5AlUN9dENB57rsbnkPyfdGuWIlkmzJjbFf0Tf5FWUc= 304 304 + github.com/muesli/termenv v0.16.0/go.mod h1:ZRfOIKPFDYQoDFF4Olj7/QJbW60Ol/kL1pU3VfY/Cnk= 323 305 github.com/multiformats/go-base32 v0.1.0 h1:pVx9xoSPqEIQG8o+UbAe7DNi51oej1NtK+aGkbLYxPE= 324 306 github.com/multiformats/go-base32 v0.1.0/go.mod h1:Kj3tFY6zNr+ABYMqeUNeGvkIC/UYgtWibDcT0rExnbI= 325 307 github.com/multiformats/go-base36 v0.2.0 h1:lFsAbNOGeKtuKozrtBsAkSVhv1p9D0/qedU9rQyccr0= ··· 399 377 github.com/redis/go-redis/v9 v9.7.3/go.mod h1:bGUrSggJ9X9GUmZpZNEOQKaANxSGgOEBRltRTZHSvrA= 400 378 github.com/resend/resend-go/v2 v2.15.0 h1:B6oMEPf8IEQwn2Ovx/9yymkESLDSeNfLFaNMw+mzHhE= 401 379 github.com/resend/resend-go/v2 v2.15.0/go.mod h1:3YCb8c8+pLiqhtRFXTyFwlLvfjQtluxOr9HEh2BwCkQ= 380 380 + github.com/rivo/uniseg v0.2.0/go.mod h1:J6wj4VEh+S6ZtnVlnTBMWIodfgj8LQOQFoIToxlJtxc= 381 381 + github.com/rivo/uniseg v0.4.7 h1:WUdvkW8uEhrYfLC4ZzdpI2ztxP1I582+49Oc5Mq64VQ= 382 382 + github.com/rivo/uniseg v0.4.7/go.mod h1:FN3SvrM+Zdj16jyLfmOkMNblXMcoc8DfTHruCPUcx88= 402 383 github.com/rogpeppe/go-internal v1.3.0/go.mod h1:M8bDsm7K2OlrFYOpmOWEs/qY81heoFRclV5y23lUDJ4= 403 384 github.com/rogpeppe/go-internal v1.6.1/go.mod h1:xXDCJY+GAPziupqXw64V24skbSoqbTEfhy4qGm1nDQc= 404 385 github.com/rogpeppe/go-internal v1.14.1 h1:UQB4HGPB6osV0SQTLymcB4TgvyWu6ZyliaW0tI/otEQ= ··· 459 434 github.com/wyatt915/goldmark-treeblood v0.0.0-20250825231212-5dcbdb2f4b57/go.mod h1:BxSCWByWSRSuembL3cDG1IBUbkBoO/oW/6tF19aA4hs= 460 435 github.com/wyatt915/treeblood v0.1.15 h1:3KZ3o2LpcKZAzOLqMoW9qeUzKEaKArKpbcPpTkNfQC8= 461 436 github.com/wyatt915/treeblood v0.1.15/go.mod h1:i7+yhhmzdDP17/97pIsOSffw74EK/xk+qJ0029cSXUY= 437 437 + github.com/xo/terminfo v0.0.0-20220910002029-abceb7e1c41e h1:JVG44RsyaB9T2KIHavMF/ppJZNG9ZpyihvCd0w101no= 438 438 + github.com/xo/terminfo v0.0.0-20220910002029-abceb7e1c41e/go.mod h1:RbqR21r5mrJuqunuUZ/Dhy/avygyECGrLceyNeo4LiM= 462 439 github.com/yuin/goldmark v1.1.27/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74= 463 440 github.com/yuin/goldmark v1.2.1/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74= 464 441 github.com/yuin/goldmark v1.3.5/go.mod h1:mwnBkeHKe2W/ZEtQ+71ViKU8L12m81fl3OWwC1Zlc8k=

+1 -1

jetstream/jetstream.go

reviewed

··· 114 114 115 115 sched := sequential.NewScheduler(j.ident, logger, j.withDidFilter(processFunc)) 116 116 117 117 - client, err := client.NewClient(j.cfg, log.New("jetstream"), sched) 117 117 + client, err := client.NewClient(j.cfg, logger, sched) 118 118 if err != nil { 119 119 return fmt.Errorf("failed to create jetstream client: %w", err) 120 120 }

+39

nix/gomod2nix.toml

reviewed

··· 29 29 [mod."github.com/avast/retry-go/v4"] 30 30 version = "v4.6.1" 31 31 hash = "sha256-PeZc8k4rDV64+k8nZt/oy1YNVbLevltXP3ZD1jf6Z6k=" 32 32 + [mod."github.com/aymanbagabas/go-osc52/v2"] 33 33 + version = "v2.0.1" 34 34 + hash = "sha256-6Bp0jBZ6npvsYcKZGHHIUSVSTAMEyieweAX2YAKDjjg=" 32 35 [mod."github.com/aymerick/douceur"] 33 36 version = "v0.2.0" 34 37 hash = "sha256-NiBX8EfOvLXNiK3pJaZX4N73YgfzdrzRXdiBFe3X3sE=" ··· 66 63 [mod."github.com/cespare/xxhash/v2"] 67 64 version = "v2.3.0" 68 65 hash = "sha256-7hRlwSR+fos1kx4VZmJ/7snR7zHh8ZFKX+qqqqGcQpY=" 66 66 + [mod."github.com/charmbracelet/colorprofile"] 67 67 + version = "v0.2.3-0.20250311203215-f60798e515dc" 68 68 + hash = "sha256-D9E/bMOyLXAUVOHA1/6o3i+vVmLfwIMOWib6sU7A6+Q=" 69 69 + [mod."github.com/charmbracelet/lipgloss"] 70 70 + version = "v1.1.0" 71 71 + hash = "sha256-RHsRT2EZ1nDOElxAK+6/DC9XAaGVjDTgPvRh3pyCfY4=" 72 72 + [mod."github.com/charmbracelet/log"] 73 73 + version = "v0.4.2" 74 74 + hash = "sha256-3w1PCM/c4JvVEh2d0sMfv4C77Xs1bPa1Ea84zdynC7I=" 75 75 + [mod."github.com/charmbracelet/x/ansi"] 76 76 + version = "v0.8.0" 77 77 + hash = "sha256-/YyDkGrULV2BtnNk3ojeSl0nUWQwIfIdW7WJuGbAZas=" 78 78 + [mod."github.com/charmbracelet/x/cellbuf"] 79 79 + version = "v0.0.13-0.20250311204145-2c3ea96c31dd" 80 80 + hash = "sha256-XAhCOt8qJ2vR77lH1ez0IVU1/2CaLTq9jSmrHVg5HHU=" 81 81 + [mod."github.com/charmbracelet/x/term"] 82 82 + version = "v0.2.1" 83 83 + hash = "sha256-VBkCZLI90PhMasftGw3403IqoV7d3E5WEGAIVrN5xQM=" 69 84 [mod."github.com/cloudflare/circl"] 70 85 version = "v1.6.2-0.20250618153321-aa837fd1539d" 71 86 hash = "sha256-0s/i/XmMcuvPQ+qK9OIU5KxwYZyLVXRtdlYvIXRJT3Y=" ··· 166 145 [mod."github.com/go-jose/go-jose/v3"] 167 146 version = "v3.0.4" 168 147 hash = "sha256-RrLHCu9l6k0XVobdZQJ9Sx/VTQcWjrdLR5BEG7yXTEQ=" 148 148 + [mod."github.com/go-logfmt/logfmt"] 149 149 + version = "v0.6.0" 150 150 + hash = "sha256-RtIG2qARd5sT10WQ7F3LR8YJhS8exs+KiuUiVf75bWg=" 169 151 [mod."github.com/go-logr/logr"] 170 152 version = "v1.4.3" 171 153 hash = "sha256-Nnp/dEVNMxLp3RSPDHZzGbI8BkSNuZMX0I0cjWKXXLA=" ··· 322 298 [mod."github.com/lestrrat-go/option"] 323 299 version = "v1.0.1" 324 300 hash = "sha256-jVcIYYVsxElIS/l2akEw32vdEPR8+anR6oeT1FoYULI=" 301 301 + [mod."github.com/lucasb-eyer/go-colorful"] 302 302 + version = "v1.2.0" 303 303 + hash = "sha256-Gg9dDJFCTaHrKHRR1SrJgZ8fWieJkybljybkI9x0gyE=" 325 304 [mod."github.com/mattn/go-isatty"] 326 305 version = "v0.0.20" 327 306 hash = "sha256-qhw9hWtU5wnyFyuMbKx+7RB8ckQaFQ8D+8GKPkN3HHQ=" 307 307 + [mod."github.com/mattn/go-runewidth"] 308 308 + version = "v0.0.16" 309 309 + hash = "sha256-NC+ntvwIpqDNmXb7aixcg09il80ygq6JAnW0Gb5b/DQ=" 328 310 [mod."github.com/mattn/go-sqlite3"] 329 311 version = "v1.14.24" 330 312 hash = "sha256-taGKFZFQlR5++5b2oZ1dYS3RERKv6yh1gniNWhb4egg=" ··· 358 328 [mod."github.com/mr-tron/base58"] 359 329 version = "v1.2.0" 360 330 hash = "sha256-8FzMu3kHUbBX10pUdtGf59Ag7BNupx8ZHeUaodR1/Vk=" 331 331 + [mod."github.com/muesli/termenv"] 332 332 + version = "v0.16.0" 333 333 + hash = "sha256-hGo275DJlyLtcifSLpWnk8jardOksdeX9lH4lBeE3gI=" 361 334 [mod."github.com/multiformats/go-base32"] 362 335 version = "v0.1.0" 363 336 hash = "sha256-O2IM7FB+Y9MkDdZztyQL5F8oEnmON2Yew7XkotQziio=" ··· 427 394 [mod."github.com/resend/resend-go/v2"] 428 395 version = "v2.15.0" 429 396 hash = "sha256-1lMoxuMLQXaNWFKadS6rpztAKwvIl3/LWMXqw7f5WYg=" 397 397 + [mod."github.com/rivo/uniseg"] 398 398 + version = "v0.4.7" 399 399 + hash = "sha256-rDcdNYH6ZD8KouyyiZCUEy8JrjOQoAkxHBhugrfHjFo=" 430 400 [mod."github.com/ryanuber/go-glob"] 431 401 version = "v1.0.0" 432 402 hash = "sha256-YkMl1utwUhi3E0sHK23ISpAsPyj4+KeXyXKoFYGXGVY=" ··· 476 440 [mod."github.com/wyatt915/treeblood"] 477 441 version = "v0.1.15" 478 442 hash = "sha256-hb99exdkoY2Qv8WdDxhwgPXGbEYimUr6wFtPXEvcO9g=" 443 443 + [mod."github.com/xo/terminfo"] 444 444 + version = "v0.0.0-20220910002029-abceb7e1c41e" 445 445 + hash = "sha256-GyCDxxMQhXA3Pi/TsWXpA8cX5akEoZV7CFx4RO3rARU=" 479 446 [mod."github.com/yuin/goldmark"] 480 447 version = "v1.7.13" 481 448 hash = "sha256-vBCxZrPYPc8x/nvAAv3Au59dCCyfS80Vw3/a9EXK7TE="

+5 -4

xrpc/serviceauth/service_auth.go

reviewed

··· 9 9 10 10 "github.com/bluesky-social/indigo/atproto/auth" 11 11 "tangled.org/core/idresolver" 12 12 + "tangled.org/core/log" 12 13 xrpcerr "tangled.org/core/xrpc/errors" 13 14 ) 14 15 ··· 23 22 24 23 func NewServiceAuth(logger *slog.Logger, resolver *idresolver.Resolver, audienceDid string) *ServiceAuth { 25 24 return &ServiceAuth{ 26 26 - logger: logger, 25 25 + logger: log.SubLogger(logger, "serviceauth"), 27 26 resolver: resolver, 28 27 audienceDid: audienceDid, 29 28 } ··· 31 30 32 31 func (sa *ServiceAuth) VerifyServiceAuth(next http.Handler) http.Handler { 33 32 return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { 34 34 - l := sa.logger.With("url", r.URL) 35 35 - 36 33 token := r.Header.Get("Authorization") 37 34 token = strings.TrimPrefix(token, "Bearer ") 38 35 ··· 41 42 42 43 did, err := s.Validate(r.Context(), token, nil) 43 44 if err != nil { 44 44 - l.Error("signature verification failed", "err", err) 45 45 + sa.logger.Error("signature verification failed", "err", err) 45 46 writeError(w, xrpcerr.AuthError(err), http.StatusForbidden) 46 47 return 47 48 } 49 49 + 50 50 + sa.logger.Debug("valid signature", ActorDid, did) 48 51 49 52 r = r.WithContext( 50 53 context.WithValue(r.Context(), ActorDid, did),