chore(posting): strip debug fmt.Println from hot paths

Removes the unconditional debug prints scattered through posting/
during the original WIP work — they fired on every read, mutation,
rollup, and commit. None of them were guarded by a verbosity flag,
so under load they would have produced megabytes of stdout noise
per second.

Sites stripped:
- posting/lists.go: READING / READING SINGLE / GETTING KEY FROM DELTAS
- posting/index.go: TOKENS, LOCAL MAP, INSERTING INDEX, UPDATE INDEX,
  ERRORRRING, "Inserting tokenizer indexes ... took"
- posting/mvcc.go: COMMITTING (and unused fmt import)
- posting/list.go: "Buidlding committed uids", "Setting mutation",
  PrintRollup helper (called once internally, never elsewhere)

Left in place: printTreeStats() in index.go, which is already
gated by the DEBUG_SHOW_HNSW_TREE env var and is an intentional
opt-in HNSW debug helper.

No behavior change.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: matthewmcneely

posting/index.go

@@ -129,11 +129,6 @@ func (mp *MutationPipeline) ProcessVectorIndex(ctx context.Context, pipeline *Pr
 }
 
 func (mp *MutationPipeline) InsertTokenizerIndexes(ctx context.Context, pipeline *PredicatePipeline, postings *map[uint64]*pb.PostingList, info predicateInfo) error {
-	startTime := time.Now()
-	defer func() {
-		fmt.Println("Inserting tokenizer indexes for predicate", pipeline.attr, "took", time.Since(startTime))
-	}()
-
 	tokenizers := schema.State().Tokenizer(ctx, pipeline.attr)
 	if len(tokenizers) == 0 {
 		return nil
@@ -192,7 +187,6 @@ func (mp *MutationPipeline) InsertTokenizerIndexes(ctx context.Context, pipeline
 				if !loaded {
 					tokens, err = indexTokens(ctx, info)
 					if err != nil {
-						fmt.Println("ERRORRRING", err)
 						x.Panic(err)
 					}
 					syncMap.Store(key, tokens)
@@ -204,8 +198,6 @@ func (mp *MutationPipeline) InsertTokenizerIndexes(ctx context.Context, pipeline
 
 				for _, token := range tokens.([]string) {
 					key := x.IndexKey(pipeline.attr, token)
-					pk, _ := x.Parse([]byte(key))
-					fmt.Println("TOKENS", key, pk)
 					val, ok := indexGenInThread[string(key)]
 					if !ok {
 						val = &pb.PostingList{}
@@ -217,8 +209,6 @@ func (mp *MutationPipeline) InsertTokenizerIndexes(ctx context.Context, pipeline
 		}
 
 		for key, value := range indexGenInThread {
-			pk, _ := x.Parse([]byte(key))
-			fmt.Println("LOCAL MAP", pk, value)
 			indexesGenInMutation.Update(key, func(val *MutableLayer, ok bool) *MutableLayer {
 				if !ok {
 					val = newMutableLayer()
@@ -261,10 +251,7 @@ func (mp *MutationPipeline) InsertTokenizerIndexes(ctx context.Context, pipeline
 		mp.txn.cache.deltas.indexMap[pipeline.attr] = indexGenInTxn
 	}
 
-	fmt.Println("INSERTING INDEX", pipeline.attr, *postings)
 	updateFn := func(key string, value *MutableLayer) {
-		pk, _ := x.Parse([]byte(key))
-		fmt.Println("UPDATE INDEX", pk, value)
 		indexGenInTxn.Update(key, func(val *pb.PostingList, ok bool) *pb.PostingList {
 			if !ok {
 				val = &pb.PostingList{}

posting/list.go

@@ -335,7 +335,6 @@ func (mm *MutableLayer) insertCommittedPostings(pl *pb.PostingList) {
 		// We insert old postings in reverse order. So we only need to read the first update to an UID.
 		if _, ok := mm.committedUids[mpost.Uid]; !ok {
 			mm.committedUids[mpost.Uid] = mpost
-			fmt.Println("Buidlding committed uids", mm.committedUids, mpost)
 		}
 	}
 }
@@ -1104,9 +1103,6 @@ func (l *List) setMutation(startTs uint64, data []byte) {
 }
 
 func (l *List) setMutationWithPosting(startTs uint64, pl *pb.PostingList) {
-	// pk, _ := x.Parse(l.key)
-	// fmt.Println("Setting mutation for ", l.key, pk, pl)
-
 	l.Lock()
 	if l.mutationMap == nil {
 		l.mutationMap = newMutableLayer()
@@ -1526,17 +1522,10 @@ func (l *List) Rollup(alloc *z.Allocator, readTs uint64) ([]*bpb.KV, error) {
 		return bytes.Compare(kvs[i].Key, kvs[j].Key) <= 0
 	})
 
-	PrintRollup(out.plist, out.parts, l.key, kv.Version)
 	x.VerifyPostingSplits(kvs, out.plist, out.parts, l.key)
 	return kvs, nil
 }
 
-func PrintRollup(plist *pb.PostingList, parts map[uint64]*pb.PostingList, baseKey []byte, ts uint64) {
-	k, _ := x.Parse(baseKey)
-	uids := codec.Decode(plist.Pack, 0)
-	fmt.Printf("[TXNLOG] DOING ROLLUP for key: %+v at timestamp: %v, uids: %+v\n", k, ts, uids)
-}
-
 // ToBackupPostingList uses rollup to generate a single list with no splits.
 // It's used during backup so that each backed up posting list is stored in a single key.
 func (l *List) ToBackupPostingList(

posting/lists.go

@@ -128,8 +128,6 @@ func (d *Deltas) Get(key string) (*pb.PostingList, bool) {
 		}
 	}
 
-	// fmt.Println("GETTING KEY FROM DELTAS", pk, "res", res, "val", val, "d.deltas", d.deltas, "d.indexMap[pk.Attr]", d.indexMap[pk.Attr], "ok", ok)
-
 	return res, len(res.Postings) > 0
 }
 
@@ -396,20 +394,12 @@ func (lc *LocalCache) getInternal(key []byte, readFromDisk, readUids bool) (*Lis
 		lc.RLock()
 		defer lc.RUnlock()
 		if lc.plists == nil {
-			l, err := getNew(key, pstore, lc.startTs, readUids)
-			if err != nil {
-				return nil, err
-			}
-			pk, _ := x.Parse(key)
-			fmt.Println("READING NEW PLIST", pk, l.Print())
-			return l, nil
+			return getNew(key, pstore, lc.startTs, readUids)
 		}
 		if l, ok := lc.plists[skey]; ok {
 			if delta, ok := lc.deltas.Get(skey); ok && delta != nil {
 				l.setMutationWithPosting(lc.startTs, delta)
 			}
-			pk, _ := x.Parse(key)
-			fmt.Println("READING PLIST", pk, l.Print())
 			return l, nil
 		}
 		return nil, nil
@@ -442,8 +432,6 @@ func (lc *LocalCache) getInternal(key []byte, readFromDisk, readUids bool) (*Lis
 	}
 	lc.RUnlock()
 
-	pk, _ := x.Parse(key)
-	fmt.Println("READING ", pk, pl.Print())
 	return lc.SetIfAbsent(skey, pl), nil
 }
 
@@ -480,26 +468,19 @@ func (lc *LocalCache) readPostingListAt(key []byte) (*pb.PostingList, error) {
 // given key. This is used for retrieving the value of a scalar predicats.
 func (lc *LocalCache) GetSinglePosting(key []byte) (*pb.PostingList, error) {
 	// This would return an error if there is some data in the local cache, but we couldn't read it.
-
-	pk, _ := x.Parse(key)
-	fmt.Println("READING SINGLE ", pk)
-
 	getListFromLocalCache := func() (*pb.PostingList, error) {
 		lc.RLock()
 
 		if delta, ok := lc.deltas.Get(string(key)); ok && delta != nil {
 			lc.RUnlock()
-			fmt.Println("READING SINGLE FROM DELTA", pk, delta)
 			return delta, nil
 		}
 
 		l := lc.plists[string(key)]
 		lc.RUnlock()
 
 		if l != nil {
-			res, err := l.StaticValue(lc.startTs)
-			fmt.Println("READING SINGLE FROM PLISTS", pk, res, err, l.Print())
-			return res, err
+			return l.StaticValue(lc.startTs)
 		}
 
 		return nil, nil
@@ -517,15 +498,10 @@ func (lc *LocalCache) GetSinglePosting(key []byte) (*pb.PostingList, error) {
 	}
 
 	pl, err := getPostings()
-
-	fmt.Println("READING SINGLE ", pk, "pl:", pl)
-
 	if err == badger.ErrKeyNotFound {
-		fmt.Println("READING ", pk, nil)
 		return nil, nil
 	}
 	if err != nil {
-		fmt.Println("READING ", pk, err)
 		return nil, err
 	}
 
@@ -538,7 +514,6 @@ func (lc *LocalCache) GetSinglePosting(key []byte) (*pb.PostingList, error) {
 		}
 	}
 	pl.Postings = pl.Postings[:idx]
-	// fmt.Println("READING ", pk, pl)
 	return pl, nil
 }
 

posting/mvcc.go

@@ -9,7 +9,6 @@ import (
 	"bytes"
 	"context"
 	"encoding/hex"
-	"fmt"
 	"math"
 	"strconv"
 	"sync"
@@ -308,8 +307,6 @@ func (txn *Txn) CommitToDisk(writer *TxnWriter, commitTs uint64) error {
 				if len(pl.Postings) == 0 {
 					continue
 				}
-				pk, _ := x.Parse([]byte(key))
-				fmt.Println("COMMITTING", pk, pl)
 				if ts := cache.maxVersions[key]; ts >= commitTs {
 					// Skip write because we already have a write at a higher ts.
 					// Logging here can cause a lot of output when doing Raft log replay. So, let's