some parallization for the getThreadV2 api

backend/backend.go

···
 	repoCache *lru.TwoQueueCache[string, *Repo]
 	reposLk   sync.Mutex
 
+	didByIDCache *lru.TwoQueueCache[uint, string]
+
 	postInfoCache *lru.TwoQueueCache[string, cachedPostInfo]
 }
 
···
 	rc, _ := lru.New2Q[string, *Repo](1_000_000)
 	pc, _ := lru.New2Q[string, cachedPostInfo](1_000_000)
 	revc, _ := lru.New2Q[uint, string](1_000_000)
+	dbic, _ := lru.New2Q[uint, string](1_000_000)
 
 	b := &PostgresBackend{
 		client:        client,
···
 		repoCache:     rc,
 		postInfoCache: pc,
 		revCache:      revc,
+		didByIDCache:  dbic,
 	}
 
 	r, err := b.GetOrCreateRepo(context.TODO(), mydid)
···
 	}
 
 	return &r, nil
+}
+
+func (b *PostgresBackend) DidFromID(ctx context.Context, uid uint) (string, error) {
+	val, ok := b.didByIDCache.Get(uid)
+	if ok {
+		return val, nil
+	}
+
+	r, err := b.GetRepoByID(ctx, uid)
+	if err != nil {
+		return "", err
+	}
+
+	b.didByIDCache.Add(uid, r.Did)
+	return r.Did, nil
 }
 
 func (b *PostgresBackend) checkPostExists(ctx context.Context, repo *Repo, rkey string) (bool, error) {

hydration/utils.go

···
 }
 
 func (h *Hydrator) UriForPost(ctx context.Context, p *models.Post) (string, error) {
-	r, err := h.backend.GetRepoByID(ctx, p.Author)
+	did, err := h.backend.DidFromID(ctx, p.Author)
 	if err != nil {
 		return "", err
 	}
 
-	return fmt.Sprintf("at://%s/app.bsky.feed.post/%s", r.Did, p.Rkey), nil
+	return fmt.Sprintf("at://%s/app.bsky.feed.post/%s", did, p.Rkey), nil
 }

main.go

···
 		db.AutoMigrate(SequenceTracker{})
 		db.Exec("CREATE INDEX IF NOT EXISTS reposts_subject_idx ON reposts (subject)")
 		db.Exec("CREATE INDEX IF NOT EXISTS posts_reply_to_idx ON posts (reply_to)")
+		db.Exec("CREATE INDEX IF NOT EXISTS posts_in_thread_idx ON posts (in_thread)")
 
 		ctx := context.TODO()
 

xrpc/unspecced/getPostThreadV2.go

···
 	"log/slog"
 	"net/http"
 	"strconv"
+	"sync"
 
 	"github.com/bluesky-social/indigo/api/bsky"
 	"github.com/labstack/echo/v4"
 	"github.com/whyrusleeping/konbini/hydration"
 	"github.com/whyrusleeping/konbini/views"
 	"github.com/whyrusleeping/market/models"
+	"go.opentelemetry.io/otel"
 	"gorm.io/gorm"
 )
+
+var tracer = otel.Tracer("xrpc/unspecced")
 
 // HandleGetPostThreadV2 implements app.bsky.unspecced.getPostThreadV2
 func HandleGetPostThreadV2(c echo.Context, db *gorm.DB, hydrator *hydration.Hydrator) error {
-	ctx := c.Request().Context()
+	ctx, span := tracer.Start(c.Request().Context(), "getPostThreadV2")
+	defer span.End()
 	ctx = context.WithValue(ctx, "auto-fetch", true)
 
 	// Parse parameters
···
 		return nil, nil
 	}
 
-	var out []*bsky.UnspeccedGetPostThreadV2_ThreadItem
-	for _, child := range curnode.children {
-		out = append(out, buildThreadItem(ctx, hydrator, child, depth+1, viewer))
-		if child.missing {
-			continue
-		}
+	type parThreadResults struct {
+		node     *bsky.UnspeccedGetPostThreadV2_ThreadItem
+		children []*bsky.UnspeccedGetPostThreadV2_ThreadItem
+	}
+
+	results := make([]parThreadResults, len(curnode.children))
+
+	var wg sync.WaitGroup
+	for i := range curnode.children {
+		ix := i
+		wg.Go(func() {
+			child := curnode.children[ix]
+
+			results[ix].node = buildThreadItem(ctx, hydrator, child, depth+1, viewer)
+			if child.missing {
+				return
+			}
+
+			sub, err := collectReplies(ctx, hydrator, child, depth+1, below-1, branchingFactor, sort, viewer)
+			if err != nil {
+				slog.Error("failed to collect replies", "node", child.uri, "error", err)
+				return
+			}
+
+			results[ix].children = sub
+		})
+	}
 
-		sub, err := collectReplies(ctx, hydrator, child, depth+1, below-1, branchingFactor, sort, viewer)
-		if err != nil {
-			return nil, err
-		}
+	wg.Wait()
 
-		out = append(out, sub...)
+	var out []*bsky.UnspeccedGetPostThreadV2_ThreadItem
+	for _, res := range results {
+		out = append(out, res.node)
+		out = append(out, res.children...)
 	}
 
 	return out, nil