+36 -28

appview/db/db.go

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

+1 -1

appview/ingester.go

··· 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

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

+1 -3

appview/labels/labels.go

··· 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 ··· 42 41 db *db.DB, 43 42 validator *validator.Validator, 44 43 enforcer *rbac.Enforcer, 44 44 + logger *slog.Logger, 45 45 ) *Labels { 46 46 - logger := log.New("labels") 47 47 - 48 46 return &Labels{ 49 47 oauth: oauth, 50 48 pages: pages,

+15 -12

appview/notifications/notifications.go

··· 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 ··· 44 46 } 45 47 46 48 func (n *Notifications) notificationsPage(w http.ResponseWriter, r *http.Request) { 49 49 + l := n.logger.With("handler", "notificationsPage") 47 50 user := n.oauth.GetUser(r) 48 51 49 52 page, ok := r.Context().Value("page").(pagination.Page) 50 53 if !ok { 51 51 - log.Println("failed to get page") 54 54 + l.Error("failed to get page") 52 55 page = pagination.FirstPage() 53 56 } 54 57 ··· 57 60 db.FilterEq("recipient_did", user.Did), 58 61 ) 59 62 if err != nil { 60 60 - log.Println("failed to get total notifications:", err) 63 63 + l.Error("failed to get total notifications", "err", err) 61 64 n.pages.Error500(w) 62 65 return 63 66 } ··· 68 71 db.FilterEq("recipient_did", user.Did), 69 72 ) 70 73 if err != nil { 71 71 - log.Println("failed to get notifications:", err) 74 74 + l.Error("failed to get notifications", "err", err) 72 75 n.pages.Error500(w) 73 76 return 74 77 } 75 78 76 79 err = n.db.MarkAllNotificationsRead(r.Context(), user.Did) 77 80 if err != nil { 78 78 - log.Println("failed to mark notifications as read:", err) 81 81 + l.Error("failed to mark notifications as read", "err", err) 79 82 } 80 83 81 84 unreadCount := 0

+2 -2

appview/pages/pages.go

··· 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 -1

appview/pages/templates/layouts/fragments/topbar.html

··· 1 1 {{ define "layouts/fragments/topbar" }} 2 2 - <nav class="mx-auto space-x-4 px-6 py-2 dark:text-white drop-shadow-sm bg-white dark:bg-gray-800"> 2 2 + <nav class="mx-auto space-x-4 px-6 py-2 rounded-b dark:text-white drop-shadow-sm bg-white dark:bg-gray-800"> 3 3 <div class="flex justify-between p-0 items-center"> 4 4 <div id="left-items"> 5 5 <a href="/" hx-boost="true" class="text-2xl no-underline hover:no-underline flex items-center gap-2">

+1 -3

appview/pipelines/pipelines.go

··· 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 ··· 45 44 db *db.DB, 46 45 config *config.Config, 47 46 enforcer *rbac.Enforcer, 47 47 + logger *slog.Logger, 48 48 ) *Pipelines { 49 49 - logger := log.New("pipelines") 50 50 - 51 49 return &Pipelines{ 52 50 oauth: oauth, 53 51 repoResolver: repoResolver,

+4 -5

appview/pulls/pulls.go

··· 6 6 "errors" 7 7 "fmt" 8 8 "log" 9 9 + "log/slog" 9 10 "net/http" 10 11 "slices" 11 12 "sort" ··· 46 47 config *config.Config 47 48 notifier notify.Notifier 48 49 enforcer *rbac.Enforcer 50 50 + logger *slog.Logger 49 51 } 50 52 51 53 func New( ··· 57 59 config *config.Config, 58 60 notifier notify.Notifier, 59 61 enforcer *rbac.Enforcer, 62 62 + logger *slog.Logger, 60 63 ) *Pulls { 61 64 return &Pulls{ 62 65 oauth: oauth, ··· 67 70 config: config, 68 71 notifier: notifier, 69 72 enforcer: enforcer, 73 73 + logger: logger, 70 74 } 71 75 } 72 76 ··· 331 335 branch = pull.PullSource.Branch 332 336 repo = pull.PullSource.Repo 333 337 } else { 334 334 - return nil 335 335 - } 336 336 - 337 337 - // deleted fork 338 338 - if repo == nil { 339 338 return nil 340 339 } 341 340

+14 -11

appview/repo/index.go

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

+1 -1

appview/repo/ogcard/card.go

··· 46 46 47 47 // DefaultSize returns the default size for a card 48 48 func DefaultSize() (int, int) { 49 49 - return 1200, 630 49 49 + return 1200, 600 50 50 } 51 51 52 52 // NewCard creates a new card with the given dimensions in pixels

+28 -54

appview/repo/opengraph.go

··· 35 35 // Split content horizontally: main content (80%) and avatar area (20%) 36 36 mainContent, avatarArea := contentCard.Split(true, 80) 37 37 38 38 - // Use main content area for both repo name and description to allow dynamic wrapping. 39 39 - mainContent.SetMargin(10) 38 38 + // Split main content: 50% for name/description, 50% for spacing 39 39 + topSection, _ := mainContent.Split(false, 50) 40 40 + 41 41 + // Split top section: 40% for repo name, 60% for description 42 42 + repoNameCard, descriptionCard := topSection.Split(false, 50) 40 43 44 44 + // Draw repo name with owner in regular and repo name in bold 45 45 + repoNameCard.SetMargin(10) 41 46 var ownerHandle string 42 47 owner, err := rp.idResolver.ResolveIdent(context.Background(), repo.Did) 43 48 if err != nil { ··· 46 51 ownerHandle = "@" + owner.Handle.String() 47 52 } 48 53 49 49 - bounds := mainContent.Img.Bounds() 50 50 - startX := bounds.Min.X + mainContent.Margin 51 51 - startY := bounds.Min.Y + mainContent.Margin 54 54 + // Draw repo name with wrapping support 55 55 + repoNameCard.SetMargin(10) 56 56 + bounds := repoNameCard.Img.Bounds() 57 57 + startX := bounds.Min.X + repoNameCard.Margin 58 58 + startY := bounds.Min.Y + repoNameCard.Margin 52 59 currentX := startX 53 53 - currentY := startY 54 54 - lineHeight := 64 // Font size 54 + padding 55 60 textColor := color.RGBA{88, 96, 105, 255} 56 61 57 57 - // Draw owner handle 58 58 - ownerWidth, err := mainContent.DrawTextAtWithWidth(ownerHandle, currentX, currentY, textColor, 54, ogcard.Top, ogcard.Left) 62 62 + // Draw owner handle in gray 63 63 + ownerWidth, err := repoNameCard.DrawTextAtWithWidth(ownerHandle, currentX, startY, textColor, 54, ogcard.Top, ogcard.Left) 59 64 if err != nil { 60 65 return nil, err 61 66 } 62 67 currentX += ownerWidth 63 68 64 69 // Draw separator 65 65 - sepWidth, err := mainContent.DrawTextAtWithWidth(" / ", currentX, currentY, textColor, 54, ogcard.Top, ogcard.Left) 70 70 + sepWidth, err := repoNameCard.DrawTextAtWithWidth(" / ", currentX, startY, textColor, 54, ogcard.Top, ogcard.Left) 66 71 if err != nil { 67 72 return nil, err 68 73 } 69 74 currentX += sepWidth 70 75 71 71 - words := strings.Fields(repo.Name) 72 72 - spaceWidth, _ := mainContent.DrawTextAtWithWidth(" ", -1000, -1000, color.Black, 54, ogcard.Top, ogcard.Left) 73 73 - if spaceWidth == 0 { 74 74 - spaceWidth = 15 76 76 + // Draw repo name in bold 77 77 + _, err = repoNameCard.DrawBoldText(repo.Name, currentX, startY, color.Black, 54, ogcard.Top, ogcard.Left) 78 78 + if err != nil { 79 79 + return nil, err 75 80 } 76 81 77 77 - for _, word := range words { 78 78 - // estimate bold width by measuring regular width and adding a multiplier 79 79 - regularWidth, _ := mainContent.DrawTextAtWithWidth(word, -1000, -1000, color.Black, 54, ogcard.Top, ogcard.Left) 80 80 - estimatedBoldWidth := int(float64(regularWidth) * 1.15) // Heuristic for bold text 81 81 - 82 82 - if currentX+estimatedBoldWidth > (bounds.Max.X - mainContent.Margin) { 83 83 - currentX = startX 84 84 - currentY += lineHeight 85 85 - } 86 86 - 87 87 - _, err := mainContent.DrawBoldText(word, currentX, currentY, color.Black, 54, ogcard.Top, ogcard.Left) 88 88 - if err != nil { 89 89 - return nil, err 90 90 - } 91 91 - currentX += estimatedBoldWidth + spaceWidth 82 82 + // Draw description (DrawText handles multi-line wrapping automatically) 83 83 + descriptionCard.SetMargin(10) 84 84 + description := repo.Description 85 85 + if len(description) > 70 { 86 86 + description = description[:70] + "…" 92 87 } 93 88 94 94 - // update Y position for the description 95 95 - currentY += lineHeight 96 96 - 97 97 - // draw description 98 98 - if currentY < bounds.Max.Y-mainContent.Margin { 99 99 - totalHeight := float64(bounds.Dy()) 100 100 - repoNameHeight := float64(currentY - bounds.Min.Y) 101 101 - 102 102 - if totalHeight > 0 && repoNameHeight < totalHeight { 103 103 - repoNamePercent := (repoNameHeight / totalHeight) * 100 104 104 - if repoNamePercent < 95 { // Ensure there's space left for description 105 105 - _, descriptionCard := mainContent.Split(false, int(repoNamePercent)) 106 106 - descriptionCard.SetMargin(8) 107 107 - 108 108 - description := repo.Description 109 109 - if len(description) > 70 { 110 110 - description = description[:70] + "…" 111 111 - } 112 112 - 113 113 - _, err = descriptionCard.DrawText(description, color.RGBA{88, 96, 105, 255}, 36, ogcard.Top, ogcard.Left) 114 114 - if err != nil { 115 115 - log.Printf("failed to draw description: %v", err) 116 116 - } 117 117 - } 118 118 - } 89 89 + _, err = descriptionCard.DrawText(description, color.RGBA{88, 96, 105, 255}, 36, ogcard.Top, ogcard.Left) 90 90 + if err != nil { 91 91 + log.Printf("failed to draw description: %v", err) 92 92 + return nil, err 119 93 } 120 94 121 95 // Draw avatar circle on the right side

+130 -92

appview/repo/repo.go

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

+1 -1

appview/signup/signup.go

··· 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

··· 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"), ··· 39 42 srcs[s] = struct{}{} 40 43 } 41 44 42 42 - logger := log.New("knotstream") 43 45 cache := cache.New(c.Redis.Addr) 44 46 cursorStore := cursor.NewRedisCursorStore(cache) 45 47

+7 -4

appview/state/login.go

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

+59 -13

appview/state/router.go

··· 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

··· 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"), ··· 36 39 srcs[src] = struct{}{} 37 40 } 38 41 39 39 - logger := log.New("spindlestream") 40 42 cache := cache.New(c.Redis.Addr) 41 43 cursorStore := cursor.NewRedisCursorStore(cache) 42 44

+18 -20

appview/state/state.go

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

+14 -9

cmd/appview/main.go

··· 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 }

+6 -3

cmd/knot/main.go

··· 2 2 3 3 import ( 4 4 "context" 5 5 + "log/slog" 5 6 "os" 6 7 7 8 "github.com/urfave/cli/v3" ··· 9 10 "tangled.org/core/hook" 10 11 "tangled.org/core/keyfetch" 11 12 "tangled.org/core/knotserver" 12 12 - "tangled.org/core/log" 13 13 + tlog "tangled.org/core/log" 13 14 ) 14 15 15 16 func main() { ··· 24 25 }, 25 26 } 26 27 28 28 + logger := tlog.New("knot") 29 29 + slog.SetDefault(logger) 30 30 + 27 31 ctx := context.Background() 28 28 - logger := log.New("knot") 29 29 - ctx = log.IntoContext(ctx, logger.With("command", cmd.Name)) 32 32 + ctx = tlog.IntoContext(ctx, logger) 30 33 31 34 if err := cmd.Run(ctx, os.Args); err != nil { 32 35 logger.Error(err.Error())

+9 -4

cmd/spindle/main.go

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

+13

go.mod

··· 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 ··· 84 91 github.com/go-git/gcfg v1.5.1-0.20230307220236-3a3c6141e376 // indirect 85 92 github.com/go-git/go-billy/v5 v5.6.2 // indirect 86 93 github.com/go-jose/go-jose/v3 v3.0.4 // indirect 94 94 + github.com/go-logfmt/logfmt v0.6.0 // indirect 87 95 github.com/go-logr/logr v1.4.3 // indirect 88 96 github.com/go-logr/stdr v1.2.2 // indirect 89 97 github.com/go-redis/cache/v9 v9.0.0 // indirect ··· 126 134 github.com/lestrrat-go/httprc v1.0.6 // indirect 127 135 github.com/lestrrat-go/iter v1.0.2 // indirect 128 136 github.com/lestrrat-go/option v1.0.1 // indirect 137 137 + github.com/lucasb-eyer/go-colorful v1.2.0 // indirect 129 138 github.com/mattn/go-isatty v0.0.20 // indirect 139 139 + github.com/mattn/go-runewidth v0.0.16 // indirect 130 140 github.com/minio/sha256-simd v1.0.1 // indirect 131 141 github.com/mitchellh/mapstructure v1.5.0 // indirect 132 142 github.com/moby/docker-image-spec v1.3.1 // indirect ··· 134 144 github.com/moby/term v0.5.2 // indirect 135 145 github.com/morikuni/aec v1.0.0 // indirect 136 146 github.com/mr-tron/base58 v1.2.0 // indirect 147 147 + github.com/muesli/termenv v0.16.0 // indirect 137 148 github.com/multiformats/go-base32 v0.1.0 // indirect 138 149 github.com/multiformats/go-base36 v0.2.0 // indirect 139 150 github.com/multiformats/go-multibase v0.2.0 // indirect ··· 152 163 github.com/prometheus/client_model v0.6.2 // indirect 153 164 github.com/prometheus/common v0.64.0 // indirect 154 165 github.com/prometheus/procfs v0.16.1 // indirect 166 166 + github.com/rivo/uniseg v0.4.7 // indirect 155 167 github.com/ryanuber/go-glob v1.0.0 // indirect 156 168 github.com/segmentio/asm v1.2.0 // indirect 157 169 github.com/sergi/go-diff v1.3.2-0.20230802210424-5b0b94c5c0d3 // indirect ··· 160 172 github.com/vmihailenco/msgpack/v5 v5.4.1 // indirect 161 173 github.com/vmihailenco/tagparser/v2 v2.0.0 // indirect 162 174 github.com/wyatt915/treeblood v0.1.15 // indirect 175 175 + github.com/xo/terminfo v0.0.0-20220910002029-abceb7e1c41e // indirect 163 176 gitlab.com/staticnoise/goldmark-callout v0.0.0-20240609120641-6366b799e4ab // indirect 164 177 gitlab.com/yawning/secp256k1-voi v0.0.0-20230925100816-f2616030848b // indirect 165 178 gitlab.com/yawning/tuplehash v0.0.0-20230713102510-df83abbf9a02 // indirect

+27

go.sum

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

+1 -1

jetstream/jetstream.go

··· 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 }

+2 -3

knotserver/events.go

··· 8 8 "time" 9 9 10 10 "github.com/gorilla/websocket" 11 11 + "tangled.org/core/log" 11 12 ) 12 13 13 14 var upgrader = websocket.Upgrader{ ··· 16 17 } 17 18 18 19 func (h *Knot) Events(w http.ResponseWriter, r *http.Request) { 19 19 - l := h.l.With("handler", "OpLog") 20 20 + l := log.SubLogger(h.l, "eventstream") 20 21 l.Debug("received new connection") 21 22 22 23 conn, err := upgrader.Upgrade(w, r, nil) ··· 75 76 } 76 77 case <-time.After(30 * time.Second): 77 78 // send a keep-alive 78 78 - l.Debug("sent keepalive") 79 79 if err = conn.WriteControl(websocket.PingMessage, []byte{}, time.Now().Add(time.Second)); err != nil { 80 80 l.Error("failed to write control", "err", err) 81 81 } ··· 89 89 h.l.Error("failed to fetch events from db", "err", err, "cursor", cursor) 90 90 return err 91 91 } 92 92 - h.l.Debug("ops", "ops", events) 93 92 94 93 for _, event := range events { 95 94 // first extract the inner json into a map

+18 -18

knotserver/git.go

··· 13 13 "tangled.org/core/knotserver/git/service" 14 14 ) 15 15 16 16 - func (d *Knot) InfoRefs(w http.ResponseWriter, r *http.Request) { 16 16 + func (h *Knot) InfoRefs(w http.ResponseWriter, r *http.Request) { 17 17 did := chi.URLParam(r, "did") 18 18 name := chi.URLParam(r, "name") 19 19 repoName, err := securejoin.SecureJoin(did, name) 20 20 if err != nil { 21 21 gitError(w, "repository not found", http.StatusNotFound) 22 22 - d.l.Error("git: failed to secure join repo path", "handler", "InfoRefs", "error", err) 22 22 + h.l.Error("git: failed to secure join repo path", "handler", "InfoRefs", "error", err) 23 23 return 24 24 } 25 25 26 26 - repoPath, err := securejoin.SecureJoin(d.c.Repo.ScanPath, repoName) 26 26 + repoPath, err := securejoin.SecureJoin(h.c.Repo.ScanPath, repoName) 27 27 if err != nil { 28 28 gitError(w, "repository not found", http.StatusNotFound) 29 29 - d.l.Error("git: failed to secure join repo path", "handler", "InfoRefs", "error", err) 29 29 + h.l.Error("git: failed to secure join repo path", "handler", "InfoRefs", "error", err) 30 30 return 31 31 } 32 32 ··· 46 46 47 47 if err := cmd.InfoRefs(); err != nil { 48 48 gitError(w, err.Error(), http.StatusInternalServerError) 49 49 - d.l.Error("git: process failed", "handler", "InfoRefs", "service", serviceName, "error", err) 49 49 + h.l.Error("git: process failed", "handler", "InfoRefs", "service", serviceName, "error", err) 50 50 return 51 51 } 52 52 case "git-receive-pack": 53 53 - d.RejectPush(w, r, name) 53 53 + h.RejectPush(w, r, name) 54 54 default: 55 55 gitError(w, fmt.Sprintf("service unsupported: '%s'", serviceName), http.StatusForbidden) 56 56 } 57 57 } 58 58 59 59 - func (d *Knot) UploadPack(w http.ResponseWriter, r *http.Request) { 59 59 + func (h *Knot) UploadPack(w http.ResponseWriter, r *http.Request) { 60 60 did := chi.URLParam(r, "did") 61 61 name := chi.URLParam(r, "name") 62 62 - repo, err := securejoin.SecureJoin(d.c.Repo.ScanPath, filepath.Join(did, name)) 62 62 + repo, err := securejoin.SecureJoin(h.c.Repo.ScanPath, filepath.Join(did, name)) 63 63 if err != nil { 64 64 gitError(w, err.Error(), http.StatusInternalServerError) 65 65 - d.l.Error("git: failed to secure join repo path", "handler", "UploadPack", "error", err) 65 65 + h.l.Error("git: failed to secure join repo path", "handler", "UploadPack", "error", err) 66 66 return 67 67 } 68 68 ··· 77 77 gzipReader, err := gzip.NewReader(r.Body) 78 78 if err != nil { 79 79 gitError(w, err.Error(), http.StatusInternalServerError) 80 80 - d.l.Error("git: failed to create gzip reader", "handler", "UploadPack", "error", err) 80 80 + h.l.Error("git: failed to create gzip reader", "handler", "UploadPack", "error", err) 81 81 return 82 82 } 83 83 defer gzipReader.Close() ··· 88 88 w.Header().Set("Connection", "Keep-Alive") 89 89 w.Header().Set("Cache-Control", "no-cache, max-age=0, must-revalidate") 90 90 91 91 - d.l.Info("git: executing git-upload-pack", "handler", "UploadPack", "repo", repo) 91 91 + h.l.Info("git: executing git-upload-pack", "handler", "UploadPack", "repo", repo) 92 92 93 93 cmd := service.ServiceCommand{ 94 94 GitProtocol: r.Header.Get("Git-Protocol"), ··· 100 100 w.WriteHeader(http.StatusOK) 101 101 102 102 if err := cmd.UploadPack(); err != nil { 103 103 - d.l.Error("git: failed to execute git-upload-pack", "handler", "UploadPack", "error", err) 103 103 + h.l.Error("git: failed to execute git-upload-pack", "handler", "UploadPack", "error", err) 104 104 return 105 105 } 106 106 } 107 107 108 108 - func (d *Knot) ReceivePack(w http.ResponseWriter, r *http.Request) { 108 108 + func (h *Knot) ReceivePack(w http.ResponseWriter, r *http.Request) { 109 109 did := chi.URLParam(r, "did") 110 110 name := chi.URLParam(r, "name") 111 111 - _, err := securejoin.SecureJoin(d.c.Repo.ScanPath, filepath.Join(did, name)) 111 111 + _, err := securejoin.SecureJoin(h.c.Repo.ScanPath, filepath.Join(did, name)) 112 112 if err != nil { 113 113 gitError(w, err.Error(), http.StatusForbidden) 114 114 - d.l.Error("git: failed to secure join repo path", "handler", "ReceivePack", "error", err) 114 114 + h.l.Error("git: failed to secure join repo path", "handler", "ReceivePack", "error", err) 115 115 return 116 116 } 117 117 118 118 - d.RejectPush(w, r, name) 118 118 + h.RejectPush(w, r, name) 119 119 } 120 120 121 121 - func (d *Knot) RejectPush(w http.ResponseWriter, r *http.Request, unqualifiedRepoName string) { 121 121 + func (h *Knot) RejectPush(w http.ResponseWriter, r *http.Request, unqualifiedRepoName string) { 122 122 // A text/plain response will cause git to print each line of the body 123 123 // prefixed with "remote: ". 124 124 w.Header().Set("content-type", "text/plain; charset=UTF-8") ··· 131 131 ownerHandle := r.Header.Get("x-tangled-repo-owner-handle") 132 132 ownerHandle = strings.TrimPrefix(ownerHandle, "@") 133 133 if ownerHandle != "" && !strings.ContainsAny(ownerHandle, ":") { 134 134 - hostname := d.c.Server.Hostname 134 134 + hostname := h.c.Server.Hostname 135 135 if strings.Contains(hostname, ":") { 136 136 hostname = strings.Split(hostname, ":")[0] 137 137 }

+4 -1

knotserver/internal.go

··· 20 20 "tangled.org/core/knotserver/config" 21 21 "tangled.org/core/knotserver/db" 22 22 "tangled.org/core/knotserver/git" 23 23 + "tangled.org/core/log" 23 24 "tangled.org/core/notifier" 24 25 "tangled.org/core/rbac" 25 26 "tangled.org/core/workflow" ··· 314 315 return h.db.InsertEvent(event, h.n) 315 316 } 316 317 317 317 - func Internal(ctx context.Context, c *config.Config, db *db.DB, e *rbac.Enforcer, l *slog.Logger, n *notifier.Notifier) http.Handler { 318 318 + func Internal(ctx context.Context, c *config.Config, db *db.DB, e *rbac.Enforcer, n *notifier.Notifier) http.Handler { 318 319 r := chi.NewRouter() 320 320 + l := log.FromContext(ctx) 321 321 + l = log.SubLogger(l, "internal") 319 322 320 323 h := InternalHandle{ 321 324 db,

+35

knotserver/middleware.go

··· 1 1 + package knotserver 2 2 + 3 3 + import ( 4 4 + "log/slog" 5 5 + "net/http" 6 6 + "time" 7 7 + ) 8 8 + 9 9 + func (h *Knot) RequestLogger(next http.Handler) http.Handler { 10 10 + return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { 11 11 + start := time.Now() 12 12 + 13 13 + next.ServeHTTP(w, r) 14 14 + 15 15 + // Build query params as slog.Attrs for the group 16 16 + queryParams := r.URL.Query() 17 17 + queryAttrs := make([]any, 0, len(queryParams)) 18 18 + for key, values := range queryParams { 19 19 + if len(values) == 1 { 20 20 + queryAttrs = append(queryAttrs, slog.String(key, values[0])) 21 21 + } else { 22 22 + queryAttrs = append(queryAttrs, slog.Any(key, values)) 23 23 + } 24 24 + } 25 25 + 26 26 + h.l.LogAttrs(r.Context(), slog.LevelInfo, "", 27 27 + slog.Group("request", 28 28 + slog.String("method", r.Method), 29 29 + slog.String("path", r.URL.Path), 30 30 + slog.Group("query", queryAttrs...), 31 31 + slog.Duration("duration", time.Since(start)), 32 32 + ), 33 33 + ) 34 34 + }) 35 35 + }

+16 -9

knotserver/router.go

··· 12 12 "tangled.org/core/knotserver/config" 13 13 "tangled.org/core/knotserver/db" 14 14 "tangled.org/core/knotserver/xrpc" 15 15 - tlog "tangled.org/core/log" 15 15 + "tangled.org/core/log" 16 16 "tangled.org/core/notifier" 17 17 "tangled.org/core/rbac" 18 18 "tangled.org/core/xrpc/serviceauth" ··· 28 28 resolver *idresolver.Resolver 29 29 } 30 30 31 31 - func Setup(ctx context.Context, c *config.Config, db *db.DB, e *rbac.Enforcer, jc *jetstream.JetstreamClient, l *slog.Logger, n *notifier.Notifier) (http.Handler, error) { 32 32 - r := chi.NewRouter() 33 33 - 31 31 + func Setup(ctx context.Context, c *config.Config, db *db.DB, e *rbac.Enforcer, jc *jetstream.JetstreamClient, n *notifier.Notifier) (http.Handler, error) { 34 32 h := Knot{ 35 33 c: c, 36 34 db: db, 37 35 e: e, 38 38 - l: l, 36 36 + l: log.FromContext(ctx), 39 37 jc: jc, 40 38 n: n, 41 39 resolver: idresolver.DefaultResolver(), ··· 67 65 return nil, fmt.Errorf("failed to start jetstream: %w", err) 68 66 } 69 67 68 68 + return h.Router(), nil 69 69 + } 70 70 + 71 71 + func (h *Knot) Router() http.Handler { 72 72 + r := chi.NewRouter() 73 73 + 74 74 + r.Use(h.RequestLogger) 75 75 + 70 76 r.Get("/", func(w http.ResponseWriter, r *http.Request) { 71 77 w.Write([]byte("This is a knot server. More info at https://tangled.sh")) 72 78 }) ··· 86 92 // Socket that streams git oplogs 87 93 r.Get("/events", h.Events) 88 94 89 89 - return r, nil 95 95 + return r 90 96 } 91 97 92 98 func (h *Knot) XrpcRouter() http.Handler { 93 93 - logger := tlog.New("knots") 99 99 + serviceAuth := serviceauth.NewServiceAuth(h.l, h.resolver, h.c.Server.Did().String()) 94 100 95 95 - serviceAuth := serviceauth.NewServiceAuth(h.l, h.resolver, h.c.Server.Did().String()) 101 101 + l := log.SubLogger(h.l, "xrpc") 96 102 97 103 xrpc := &xrpc.Xrpc{ 98 104 Config: h.c, 99 105 Db: h.db, 100 106 Ingester: h.jc, 101 107 Enforcer: h.e, 102 102 - Logger: logger, 108 108 + Logger: l, 103 109 Notifier: h.n, 104 110 Resolver: h.resolver, 105 111 ServiceAuth: serviceAuth, 106 112 } 113 113 + 107 114 return xrpc.Router() 108 115 } 109 116

+5 -4

knotserver/server.go

··· 43 43 44 44 func Run(ctx context.Context, cmd *cli.Command) error { 45 45 logger := log.FromContext(ctx) 46 46 - iLogger := log.New("knotserver/internal") 46 46 + logger = log.SubLogger(logger, cmd.Name) 47 47 + ctx = log.IntoContext(ctx, logger) 47 48 48 49 c, err := config.Load(ctx) 49 50 if err != nil { ··· 80 81 tangled.KnotMemberNSID, 81 82 tangled.RepoPullNSID, 82 83 tangled.RepoCollaboratorNSID, 83 83 - }, nil, logger, db, true, c.Server.LogDids) 84 84 + }, nil, log.SubLogger(logger, "jetstream"), db, true, c.Server.LogDids) 84 85 if err != nil { 85 86 logger.Error("failed to setup jetstream", "error", err) 86 87 } 87 88 88 89 notifier := notifier.New() 89 90 90 90 - mux, err := Setup(ctx, c, db, e, jc, logger, &notifier) 91 91 + mux, err := Setup(ctx, c, db, e, jc, &notifier) 91 92 if err != nil { 92 93 return fmt.Errorf("failed to setup server: %w", err) 93 94 } 94 95 95 95 - imux := Internal(ctx, c, db, e, iLogger, &notifier) 96 96 + imux := Internal(ctx, c, db, e, &notifier) 96 97 97 98 logger.Info("starting internal server", "address", c.Server.InternalListenAddr) 98 99 go http.ListenAndServe(c.Server.InternalListenAddr, imux)

+23 -9

log/log.go

··· 4 4 "context" 5 5 "log/slog" 6 6 "os" 7 7 + 8 8 + "github.com/charmbracelet/log" 7 9 ) 8 10 9 9 - // NewHandler sets up a new slog.Handler with the service name 10 10 - // as an attribute 11 11 func NewHandler(name string) slog.Handler { 12 12 - handler := slog.NewTextHandler(os.Stdout, &slog.HandlerOptions{ 13 13 - Level: slog.LevelDebug, 12 12 + return log.NewWithOptions(os.Stderr, log.Options{ 13 13 + ReportTimestamp: true, 14 14 + Prefix: name, 15 15 + Level: log.DebugLevel, 14 16 }) 15 15 - 16 16 - var attrs []slog.Attr 17 17 - attrs = append(attrs, slog.Attr{Key: "service", Value: slog.StringValue(name)}) 18 18 - handler.WithAttrs(attrs) 19 19 - return handler 20 17 } 21 18 22 19 func New(name string) *slog.Logger { ··· 49 46 50 47 return slog.Default() 51 48 } 49 49 + 50 50 + // sublogger derives a new logger from an existing one by appending a suffix to its prefix. 51 51 + func SubLogger(base *slog.Logger, suffix string) *slog.Logger { 52 52 + // try to get the underlying charmbracelet logger 53 53 + if cl, ok := base.Handler().(*log.Logger); ok { 54 54 + prefix := cl.GetPrefix() 55 55 + if prefix != "" { 56 56 + prefix = prefix + "/" + suffix 57 57 + } else { 58 58 + prefix = suffix 59 59 + } 60 60 + return slog.New(NewHandler(prefix)) 61 61 + } 62 62 + 63 63 + // Fallback: no known handler type 64 64 + return slog.New(NewHandler(suffix)) 65 65 + }

+39

nix/gomod2nix.toml

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

+35

spindle/middleware.go

··· 1 1 + package spindle 2 2 + 3 3 + import ( 4 4 + "log/slog" 5 5 + "net/http" 6 6 + "time" 7 7 + ) 8 8 + 9 9 + func (s *Spindle) RequestLogger(next http.Handler) http.Handler { 10 10 + return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { 11 11 + start := time.Now() 12 12 + 13 13 + next.ServeHTTP(w, r) 14 14 + 15 15 + // Build query params as slog.Attrs for the group 16 16 + queryParams := r.URL.Query() 17 17 + queryAttrs := make([]any, 0, len(queryParams)) 18 18 + for key, values := range queryParams { 19 19 + if len(values) == 1 { 20 20 + queryAttrs = append(queryAttrs, slog.String(key, values[0])) 21 21 + } else { 22 22 + queryAttrs = append(queryAttrs, slog.Any(key, values)) 23 23 + } 24 24 + } 25 25 + 26 26 + s.l.LogAttrs(r.Context(), slog.LevelInfo, "", 27 27 + slog.Group("request", 28 28 + slog.String("method", r.Method), 29 29 + slog.String("path", r.URL.Path), 30 30 + slog.Group("query", queryAttrs...), 31 31 + slog.Duration("duration", time.Since(start)), 32 32 + ), 33 33 + ) 34 34 + }) 35 35 + }

+6 -6

spindle/server.go

··· 108 108 tangled.RepoNSID, 109 109 tangled.RepoCollaboratorNSID, 110 110 } 111 111 - jc, err := jetstream.NewJetstreamClient(cfg.Server.JetstreamEndpoint, "spindle", collections, nil, logger, d, true, true) 111 111 + jc, err := jetstream.NewJetstreamClient(cfg.Server.JetstreamEndpoint, "spindle", collections, nil, log.SubLogger(logger, "jetstream"), d, true, true) 112 112 if err != nil { 113 113 return fmt.Errorf("failed to setup jetstream client: %w", err) 114 114 } ··· 171 171 // spindle.processPipeline, which in turn enqueues the pipeline 172 172 // job in the above registered queue. 173 173 ccfg := eventconsumer.NewConsumerConfig() 174 174 - ccfg.Logger = logger 174 174 + ccfg.Logger = log.SubLogger(logger, "eventconsumer") 175 175 ccfg.Dev = cfg.Server.Dev 176 176 ccfg.ProcessFunc = spindle.processPipeline 177 177 ccfg.CursorStore = cursorStore ··· 210 210 } 211 211 212 212 func (s *Spindle) XrpcRouter() http.Handler { 213 213 - logger := s.l.With("route", "xrpc") 214 214 - 215 213 serviceAuth := serviceauth.NewServiceAuth(s.l, s.res, s.cfg.Server.Did().String()) 216 214 215 215 + l := log.SubLogger(s.l, "xrpc") 216 216 + 217 217 x := xrpc.Xrpc{ 218 218 - Logger: logger, 218 218 + Logger: l, 219 219 Db: s.db, 220 220 Enforcer: s.e, 221 221 Engines: s.engs, ··· 305 305 306 306 ok := s.jq.Enqueue(queue.Job{ 307 307 Run: func() error { 308 308 - engine.StartWorkflows(s.l, s.vault, s.cfg, s.db, s.n, ctx, &models.Pipeline{ 308 308 + engine.StartWorkflows(log.SubLogger(s.l, "engine"), s.vault, s.cfg, s.db, s.n, ctx, &models.Pipeline{ 309 309 RepoOwner: tpl.TriggerMetadata.Repo.Did, 310 310 RepoName: tpl.TriggerMetadata.Repo.Repo, 311 311 Workflows: workflows,

+3 -3

spindle/stream.go

··· 10 10 "strconv" 11 11 "time" 12 12 13 13 + "tangled.org/core/log" 13 14 "tangled.org/core/spindle/models" 14 15 15 16 "github.com/go-chi/chi/v5" ··· 23 24 } 24 25 25 26 func (s *Spindle) Events(w http.ResponseWriter, r *http.Request) { 26 26 - l := s.l.With("handler", "Events") 27 27 + l := log.SubLogger(s.l, "eventstream") 28 28 + 27 29 l.Debug("received new connection") 28 30 29 31 conn, err := upgrader.Upgrade(w, r, nil) ··· 82 84 } 83 85 case <-time.After(30 * time.Second): 84 86 // send a keep-alive 85 85 - l.Debug("sent keepalive") 86 87 if err = conn.WriteControl(websocket.PingMessage, []byte{}, time.Now().Add(time.Second)); err != nil { 87 88 l.Error("failed to write control", "err", err) 88 89 } ··· 222 223 s.l.Debug("err", "err", err) 223 224 return err 224 225 } 225 225 - s.l.Debug("ops", "ops", events) 226 226 227 227 for _, event := range events { 228 228 // first extract the inner json into a map

+5 -4

xrpc/serviceauth/service_auth.go

··· 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 ··· 22 23 23 24 func NewServiceAuth(logger *slog.Logger, resolver *idresolver.Resolver, audienceDid string) *ServiceAuth { 24 25 return &ServiceAuth{ 25 25 - logger: logger, 26 26 + logger: log.SubLogger(logger, "serviceauth"), 26 27 resolver: resolver, 27 28 audienceDid: audienceDid, 28 29 } ··· 30 31 31 32 func (sa *ServiceAuth) VerifyServiceAuth(next http.Handler) http.Handler { 32 33 return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { 33 33 - l := sa.logger.With("url", r.URL) 34 34 - 35 34 token := r.Header.Get("Authorization") 36 35 token = strings.TrimPrefix(token, "Bearer ") 37 36 ··· 42 41 43 42 did, err := s.Validate(r.Context(), token, nil) 44 43 if err != nil { 45 45 - l.Error("signature verification failed", "err", err) 44 44 + sa.logger.Error("signature verification failed", "err", err) 46 45 writeError(w, xrpcerr.AuthError(err), http.StatusForbidden) 47 46 return 48 47 } 48 48 + 49 49 + sa.logger.Debug("valid signature", ActorDid, did) 49 50 50 51 r = r.WithContext( 51 52 context.WithValue(r.Context(), ActorDid, did),