kvserver: assign some Dev logs to KvDistribution

tbg · tbg · commit 287260220e8f · 2025-09-24T11:24:53.000+02:00
```
sed -i '' 's/log\.Dev/log.KvDistribution/g' consistency_queue.go flow_control_stores.go kv_snapshot_strategy.go merge_queue.go mma_store_rebalancer.go mvcc_gc_queue.go queue.go queue_helpers_testutil.go rebalance_objective.go  replica_closedts.go replica_destroy.go replica_gc_queue.go replica_gossip.go replica_proposal_quota.go replica_rangefeed.go replicate_queue.go scanner.go  snapshot_apply_prepare.go store_gossip.go store_init.go store_merge.go store_remove_replica.go store_snapshot.go
```
diff --git a/pkg/kv/kvserver/flow_control_stores.go b/pkg/kv/kvserver/flow_control_stores.go
@@ -45,7 +45,7 @@ func (sh *storesForFlowControl) LookupReplicationAdmissionHandle(
 		return nil
 	}); err != nil {
 		ctx := ls.AnnotateCtx(context.Background())
-		log.Dev.Errorf(ctx, "unexpected error: %s", err)
+		log.KvDistribution.Errorf(ctx, "unexpected error: %s", err)
 		return nil, false
 	}
 	return handle, found
@@ -151,7 +151,7 @@ func (ss *storesForRACv2) ScheduleAdmittedResponseForRangeRACv2(
 	for _, m := range msgs {
 		s, err := ls.GetStore(m.ToStoreID)
 		if err != nil {
-			log.Dev.Errorf(ctx, "store %s not found", m.ToStoreID)
+			log.KvDistribution.Errorf(ctx, "store %s not found", m.ToStoreID)
 			continue
 		}
 		repl := s.GetReplicaIfExists(m.RangeID)
@@ -179,7 +179,7 @@ func (ss *storesForRACv2) LookupInspect(
 		}
 		return nil
 	}); err != nil {
-		log.Dev.Errorf(ls.AnnotateCtx(context.Background()),
+		log.KvDistribution.Errorf(ls.AnnotateCtx(context.Background()),
 			"unexpected error iterating stores: %s", err)
 	}
 	return handle, found
@@ -196,7 +196,7 @@ func (ss *storesForRACv2) Inspect() []roachpb.RangeID {
 		})
 		return nil
 	}); err != nil {
-		log.Dev.Errorf(ls.AnnotateCtx(context.Background()),
+		log.KvDistribution.Errorf(ls.AnnotateCtx(context.Background()),
 			"unexpected error iterating stores: %s", err)
 	}
 	return rangeIDs
diff --git a/pkg/kv/kvserver/kv_snapshot_strategy.go b/pkg/kv/kvserver/kv_snapshot_strategy.go
@@ -136,7 +136,7 @@ func (kvSS *kvBatchSnapshotStrategy) Receive(
 
 	snapshotQ := s.cfg.KVAdmissionController.GetSnapshotQueue(s.StoreID())
 	if snapshotQ == nil {
-		log.Dev.Errorf(ctx, "unable to find snapshot queue for store: %s", s.StoreID())
+		log.KvDistribution.Errorf(ctx, "unable to find snapshot queue for store: %s", s.StoreID())
 	}
 	// Using a nil pacer is effectively a noop if snapshot control is disabled.
 	var pacer *admission.SnapshotPacer = nil
@@ -602,7 +602,7 @@ func (kvSS *kvBatchSnapshotStrategy) Close(ctx context.Context) {
 		// disk space (which is reclaimed on node restart). It is unexpected
 		// though, so log a warning.
 		if err := kvSS.scratch.Close(); err != nil {
-			log.Dev.Warningf(ctx, "error closing kvBatchSnapshotStrategy: %v", err)
+			log.KvDistribution.Warningf(ctx, "error closing kvBatchSnapshotStrategy: %v", err)
 		}
 	}
 }
diff --git a/pkg/kv/kvserver/mma_store_rebalancer.go b/pkg/kv/kvserver/mma_store_rebalancer.go
@@ -69,7 +69,7 @@ func newMMAStoreRebalancer(
 func (m *mmaStoreRebalancer) run(ctx context.Context, stopper *stop.Stopper) {
 	timer := time.NewTicker(jitteredInterval(allocator.LoadBasedRebalanceInterval.Get(&m.st.SV)))
 	defer timer.Stop()
-	log.Dev.Infof(ctx, "starting multi-metric store rebalancer with mode=%v", kvserverbase.LoadBasedRebalancingMode.Get(&m.st.SV))
+	log.KvDistribution.Infof(ctx, "starting multi-metric store rebalancer with mode=%v", kvserverbase.LoadBasedRebalancingMode.Get(&m.st.SV))
 
 	for {
 		select {
@@ -129,7 +129,7 @@ func (m *mmaStoreRebalancer) rebalance(ctx context.Context) bool {
 	knownStoresByMMA := m.mma.KnownStores()
 	storeLeaseholderMsg, numIgnoredRanges := m.store.MakeStoreLeaseholderMsg(ctx, knownStoresByMMA)
 	if numIgnoredRanges > 0 {
-		log.Dev.Infof(ctx, "mma rebalancer: ignored %d ranges since the allocator does not know all stores",
+		log.KvDistribution.Infof(ctx, "mma rebalancer: ignored %d ranges since the allocator does not know all stores",
 			numIgnoredRanges)
 	}
 
@@ -140,7 +140,7 @@ func (m *mmaStoreRebalancer) rebalance(ctx context.Context) bool {
 	// TODO(wenyihu6): add allocator sync and post apply here
 	for _, change := range changes {
 		if err := m.applyChange(ctx, change); err != nil {
-			log.Dev.VInfof(ctx, 1, "failed to apply change for range %d: %v", change.RangeID, err)
+			log.KvDistribution.VInfof(ctx, 1, "failed to apply change for range %d: %v", change.RangeID, err)
 		}
 	}
 
diff --git a/pkg/kv/kvserver/rebalance_objective.go b/pkg/kv/kvserver/rebalance_objective.go
@@ -243,7 +243,7 @@ func (rom *RebalanceObjectiveManager) maybeUpdateRebalanceObjective(ctx context.
 		return
 	}
 
-	log.Dev.Infof(ctx, "Updating the rebalance objective from %s to %s",
+	log.KvDistribution.Infof(ctx, "Updating the rebalance objective from %s to %s",
 		prev, next)
 
 	rom.mu.obj = next
@@ -264,7 +264,7 @@ func ResolveLBRebalancingObjective(
 	// When the cpu timekeeping utility is unsupported on this aarch, the cpu
 	// usage cannot be gathered. Fall back to QPS balancing.
 	if !grunning.Supported {
-		log.Dev.Infof(ctx, "cpu timekeeping unavailable on host, reverting to qps balance objective")
+		log.KvDistribution.Infof(ctx, "cpu timekeeping unavailable on host, reverting to qps balance objective")
 		return LBRebalancingQueries
 	}
 
@@ -275,7 +275,7 @@ func ResolveLBRebalancingObjective(
 	// disallows any other store using the cpu balancing objective.
 	for _, desc := range descs {
 		if desc.Capacity.CPUPerSecond == -1 {
-			log.Dev.Warningf(ctx,
+			log.KvDistribution.Warningf(ctx,
 				"cpu timekeeping unavailable on node %d but available locally, reverting to qps balance objective",
 				desc.Node.NodeID)
 			return LBRebalancingQueries
diff --git a/pkg/kv/kvserver/replica_closedts.go b/pkg/kv/kvserver/replica_closedts.go
@@ -292,7 +292,7 @@ func (st *sidetransportAccess) forward(
 
 func (st *sidetransportAccess) assertNoRegression(ctx context.Context, cur, up closedTimestamp) {
 	if cur.regression(up) {
-		log.Dev.Fatalf(ctx, "side-transport update saw closed timestamp regression on r%d: "+
+		log.KvDistribution.Fatalf(ctx, "side-transport update saw closed timestamp regression on r%d: "+
 			"(lai=%d, ts=%s) -> (lai=%d, ts=%s)", st.rangeID, cur.lai, cur.ts, up.lai, up.ts)
 	}
 }
diff --git a/pkg/kv/kvserver/replica_destroy.go b/pkg/kv/kvserver/replica_destroy.go
@@ -130,13 +130,13 @@ func (r *Replica) destroyRaftMuLocked(ctx context.Context, nextReplicaID roachpb
 		return err
 	}
 	if r.IsInitialized() {
-		log.Dev.Infof(ctx, "removed %d (%d+%d) keys in %0.0fms [clear=%0.0fms commit=%0.0fms]",
+		log.KvDistribution.Infof(ctx, "removed %d (%d+%d) keys in %0.0fms [clear=%0.0fms commit=%0.0fms]",
 			ms.KeyCount+ms.SysCount, ms.KeyCount, ms.SysCount,
 			commitTime.Sub(startTime).Seconds()*1000,
 			preTime.Sub(startTime).Seconds()*1000,
 			commitTime.Sub(preTime).Seconds()*1000)
 	} else {
-		log.Dev.Infof(ctx, "removed uninitialized range in %0.0fms [clear=%0.0fms commit=%0.0fms]",
+		log.KvDistribution.Infof(ctx, "removed uninitialized range in %0.0fms [clear=%0.0fms commit=%0.0fms]",
 			commitTime.Sub(startTime).Seconds()*1000,
 			preTime.Sub(startTime).Seconds()*1000,
 			commitTime.Sub(preTime).Seconds()*1000)
@@ -168,7 +168,7 @@ func (r *Replica) disconnectReplicationRaftMuLocked(ctx context.Context) {
 	}
 
 	if !r.shMu.destroyStatus.Removed() {
-		log.Dev.Fatalf(ctx, "removing raft group before destroying replica %s", r)
+		log.KvDistribution.Fatalf(ctx, "removing raft group before destroying replica %s", r)
 	}
 	r.mu.internalRaftGroup = nil
 	r.mu.raftTracer.Close()
diff --git a/pkg/kv/kvserver/replica_gossip.go b/pkg/kv/kvserver/replica_gossip.go
@@ -35,20 +35,20 @@ func (r *Replica) gossipFirstRangeLocked(ctx context.Context) {
 	}
 	log.Event(ctx, "gossiping sentinel and first range")
 	if log.V(1) {
-		log.Dev.Infof(ctx, "gossiping sentinel from store %d, r%d", r.store.StoreID(), r.RangeID)
+		log.KvDistribution.Infof(ctx, "gossiping sentinel from store %d, r%d", r.store.StoreID(), r.RangeID)
 	}
 	if err := r.store.Gossip().AddInfo(
 		gossip.KeySentinel, r.store.ClusterID().GetBytes(),
 		r.store.cfg.SentinelGossipTTL()); err != nil {
-		log.Dev.Errorf(ctx, "failed to gossip sentinel: %+v", err)
+		log.KvDistribution.Errorf(ctx, "failed to gossip sentinel: %+v", err)
 	}
 	if log.V(1) {
-		log.Dev.Infof(ctx, "gossiping first range from store %d, r%d: %s",
+		log.KvDistribution.Infof(ctx, "gossiping first range from store %d, r%d: %s",
 			r.store.StoreID(), r.RangeID, r.shMu.state.Desc.Replicas())
 	}
 	if err := r.store.Gossip().AddInfoProto(
 		gossip.KeyFirstRangeDescriptor, r.shMu.state.Desc, configGossipTTL); err != nil {
-		log.Dev.Errorf(ctx, "failed to gossip first range metadata: %+v", err)
+		log.KvDistribution.Errorf(ctx, "failed to gossip first range metadata: %+v", err)
 	}
 }
 
@@ -176,7 +176,7 @@ func (r *Replica) getLeaseForGossip(ctx context.Context) (bool, *kvpb.Error) {
 					}
 				default:
 					// Any other error is worth being logged visibly.
-					log.Dev.Warningf(ctx, "could not acquire lease for range gossip: %s", pErr)
+					log.KvDistribution.Warningf(ctx, "could not acquire lease for range gossip: %s", pErr)
 				}
 			}
 		}); err != nil {
@@ -198,7 +198,7 @@ func (r *Replica) maybeGossipFirstRange(ctx context.Context) *kvpb.Error {
 	// so we error out below.
 	if gossipClusterID, err := r.store.Gossip().GetClusterID(); err == nil {
 		if gossipClusterID != r.store.ClusterID() {
-			log.Dev.Fatalf(
+			log.KvDistribution.Fatalf(
 				ctx, "store %d belongs to cluster %s, but attempted to join cluster %s via gossip",
 				r.store.StoreID(), r.store.ClusterID(), gossipClusterID)
 		}
@@ -207,11 +207,11 @@ func (r *Replica) maybeGossipFirstRange(ctx context.Context) *kvpb.Error {
 	// Gossip the cluster ID from all replicas of the first range; there
 	// is no expiration on the cluster ID.
 	if log.V(1) {
-		log.Dev.Infof(ctx, "gossiping cluster ID %q from store %d, r%d", r.store.ClusterID(),
+		log.KvDistribution.Infof(ctx, "gossiping cluster ID %q from store %d, r%d", r.store.ClusterID(),
 			r.store.StoreID(), r.RangeID)
 	}
 	if err := r.store.Gossip().AddClusterID(r.store.ClusterID()); err != nil {
-		log.Dev.Errorf(ctx, "failed to gossip cluster ID: %+v", err)
+		log.KvDistribution.Errorf(ctx, "failed to gossip cluster ID: %+v", err)
 	}
 
 	hasLease, pErr := r.getLeaseForGossip(ctx)
diff --git a/pkg/kv/kvserver/replica_proposal_quota.go b/pkg/kv/kvserver/replica_proposal_quota.go
@@ -213,10 +213,10 @@ func (r *Replica) updateProposalQuotaRaftMuLocked(
 		// and the quotaReleaseQueue together track status.Applied exactly.
 		r.mu.proposalQuotaBaseIndex = kvpb.RaftIndex(status.Applied)
 		if r.mu.proposalQuota != nil {
-			log.Dev.Fatal(ctx, "proposalQuota was not nil before becoming the leader")
+			log.KvDistribution.Fatal(ctx, "proposalQuota was not nil before becoming the leader")
 		}
 		if releaseQueueLen := len(r.mu.quotaReleaseQueue); releaseQueueLen != 0 {
-			log.Dev.Fatalf(ctx, "len(r.mu.quotaReleaseQueue) = %d, expected 0", releaseQueueLen)
+			log.KvDistribution.Fatalf(ctx, "len(r.mu.quotaReleaseQueue) = %d, expected 0", releaseQueueLen)
 		}
 		r.mu.proposalQuota = quotapool.NewIntPool(
 			"raft proposal",
@@ -324,7 +324,7 @@ func (r *Replica) updateProposalQuotaRaftMuLocked(
 	// index.
 	releasableIndex := r.mu.proposalQuotaBaseIndex + kvpb.RaftIndex(len(r.mu.quotaReleaseQueue))
 	if releasableIndex != kvpb.RaftIndex(status.Applied) {
-		log.Dev.Fatalf(ctx, "proposalQuotaBaseIndex (%d) + quotaReleaseQueueLen (%d) = %d"+
+		log.KvDistribution.Fatalf(ctx, "proposalQuotaBaseIndex (%d) + quotaReleaseQueueLen (%d) = %d"+
 			" must equal the applied index (%d)",
 			r.mu.proposalQuotaBaseIndex, len(r.mu.quotaReleaseQueue), releasableIndex,
 			status.Applied)
diff --git a/pkg/kv/kvserver/replica_rangefeed.go b/pkg/kv/kvserver/replica_rangefeed.go
@@ -431,7 +431,7 @@ func logSlowRangefeedRegistration(ctx context.Context) func() {
 	return func() {
 		elapsed := timeutil.Since(start)
 		if elapsed >= slowRaftMuWarnThreshold {
-			log.Dev.Warningf(ctx, "rangefeed registration took %s", elapsed)
+			log.KvDistribution.Warningf(ctx, "rangefeed registration took %s", elapsed)
 		}
 	}
 }
@@ -889,9 +889,9 @@ func (r *Replica) handleClosedTimestampUpdateRaftMuLocked(
 		expensiveLog := m.RangeFeedSlowClosedTimestampLogN.ShouldLog()
 		if expensiveLog {
 			if closedTS.IsEmpty() {
-				log.Dev.Infof(ctx, "RangeFeed closed timestamp is empty")
+				log.KvDistribution.Infof(ctx, "RangeFeed closed timestamp is empty")
 			} else {
-				log.Dev.Infof(ctx, "RangeFeed closed timestamp %s is behind by %s (%v)",
+				log.KvDistribution.Infof(ctx, "RangeFeed closed timestamp %s is behind by %s (%v)",
 					closedTS, signal.lag, signal)
 			}
 		}
@@ -919,7 +919,7 @@ func (r *Replica) handleClosedTimestampUpdateRaftMuLocked(
 				}
 				defer func() { <-m.RangeFeedSlowClosedTimestampNudgeSem }()
 				if err := r.ensureClosedTimestampStarted(ctx); err != nil {
-					log.Dev.Infof(ctx, `RangeFeed failed to nudge: %s`, err)
+					log.KvDistribution.Infof(ctx, `RangeFeed failed to nudge: %s`, err)
 				} else if signal.exceedsCancelLagThreshold {
 					// We have successfully nudged the leaseholder to make progress on
 					// the closed timestamp. If the lag was already persistently too
@@ -933,7 +933,7 @@ func (r *Replica) handleClosedTimestampUpdateRaftMuLocked(
 					// prohibit us from cancelling the rangefeed in the current version,
 					// due to mixed version compatibility.
 					if expensiveLog {
-						log.Dev.Infof(ctx,
+						log.KvDistribution.Infof(ctx,
 							`RangeFeed is too far behind, cancelling for replanning [%v]`, signal)
 					}
 					r.disconnectRangefeedWithReason(kvpb.RangeFeedRetryError_REASON_RANGEFEED_CLOSED)
diff --git a/pkg/kv/kvserver/scanner.go b/pkg/kv/kvserver/scanner.go
@@ -213,20 +213,20 @@ func (rs *replicaScanner) waitAndProcess(ctx context.Context, start time.Time, r
 	waitInterval := rs.paceInterval(start, timeutil.Now())
 	rs.waitTimer.Reset(waitInterval)
 	if log.V(6) {
-		log.Dev.Infof(ctx, "wait timer interval set to %s", waitInterval)
+		log.KvDistribution.Infof(ctx, "wait timer interval set to %s", waitInterval)
 	}
 	for {
 		select {
 		case <-rs.waitTimer.C:
 			if log.V(6) {
-				log.Dev.Infof(ctx, "wait timer fired")
+				log.KvDistribution.Infof(ctx, "wait timer fired")
 			}
 			if repl == nil {
 				return false
 			}
 
 			if log.V(2) {
-				log.Dev.Infof(ctx, "replica scanner processing %s", repl)
+				log.KvDistribution.Infof(ctx, "replica scanner processing %s", repl)
 			}
 			for _, q := range rs.queues {
 				q.MaybeAddAsync(ctx, repl, rs.clock.NowAsClockTimestamp())
@@ -251,7 +251,7 @@ func (rs *replicaScanner) removeReplica(repl *Replica) {
 	}
 	if log.V(6) {
 		ctx := rs.AnnotateCtx(context.TODO())
-		log.Dev.Infof(ctx, "removed replica %s", repl)
+		log.KvDistribution.Infof(ctx, "removed replica %s", repl)
 	}
 }
 
@@ -299,7 +299,7 @@ func (rs *replicaScanner) scanLoop() {
 				rs.mu.total += timeutil.Since(start)
 			}()
 			if log.V(6) {
-				log.Dev.Infof(ctx, "reset replica scan iteration")
+				log.KvDistribution.Infof(ctx, "reset replica scan iteration")
 			}
 
 			// Reset iteration and start time.
diff --git a/pkg/kv/kvserver/snapshot_apply_prepare.go b/pkg/kv/kvserver/snapshot_apply_prepare.go
@@ -124,7 +124,7 @@ func (s *snapWriteBuilder) clearSubsumedReplicaDiskData(ctx context.Context) err
 	// we're applying a snapshot for another range (we don't do that either).
 	// Something is severely wrong for this to happen, so perform a sanity check.
 	if s.subsume[0].desc.StartKey.Compare(s.desc.StartKey) < 0 { // subsumedDescs are sorted by StartKey
-		log.Dev.Fatalf(ctx,
+		log.KvDistribution.Fatalf(ctx,
 			"subsuming replica to our left; subsumed desc start key: %v; snapshot desc start key %v",
 			s.subsume[0].desc.StartKey, s.desc.StartKey,
 		)
diff --git a/pkg/kv/kvserver/store_gossip.go b/pkg/kv/kvserver/store_gossip.go
@@ -153,7 +153,7 @@ func (s *Store) startGossip() {
 						annotatedCtx := repl.AnnotateCtx(ctx)
 						if err := gossipFn.fn(annotatedCtx, repl); err != nil {
 							if cannotGossipEvery.ShouldLog() {
-								log.Dev.Infof(annotatedCtx, "could not gossip %s: %v", gossipFn.description, err)
+								log.KvDistribution.Infof(annotatedCtx, "could not gossip %s: %v", gossipFn.description, err)
 							}
 							if !errors.Is(err, errPeriodicGossipsDisabled) {
 								continue
@@ -192,7 +192,7 @@ func (s *Store) systemGossipUpdate(sysCfg *config.SystemConfig) {
 		// get the first system config, then periodically in the background
 		// (managed by the Node).
 		if err := s.ComputeMetrics(ctx); err != nil {
-			log.Dev.Infof(ctx, "%s: failed initial metrics computation: %s", s, err)
+			log.KvDistribution.Infof(ctx, "%s: failed initial metrics computation: %s", s, err)
 		}
 		log.Event(ctx, "computed initial metrics")
 	})
@@ -347,7 +347,7 @@ func (s *StoreGossip) asyncGossipStore(ctx context.Context, reason string, useCa
 	gossipFn := func(ctx context.Context) {
 		log.VEventf(ctx, 2, "gossiping on %s", reason)
 		if err := s.GossipStore(ctx, useCached); err != nil {
-			log.Dev.Warningf(ctx, "error gossiping on %s: %+v", reason, err)
+			log.KvDistribution.Warningf(ctx, "error gossiping on %s: %+v", reason, err)
 		}
 	}
 
@@ -361,7 +361,7 @@ func (s *StoreGossip) asyncGossipStore(ctx context.Context, reason string, useCa
 	if err := s.stopper.RunAsyncTask(
 		ctx, fmt.Sprintf("storage.Store: gossip on %s", reason), gossipFn,
 	); err != nil {
-		log.Dev.Warningf(ctx, "unable to gossip on %s: %+v", reason, err)
+		log.KvDistribution.Warningf(ctx, "unable to gossip on %s: %+v", reason, err)
 	}
 }
 
diff --git a/pkg/kv/kvserver/store_init.go b/pkg/kv/kvserver/store_init.go
@@ -270,6 +270,6 @@ func writeGlobalMVCCRangeTombstone(
 	if err := w.PutMVCCRangeKey(rangeKey, storage.MVCCValue{}); err != nil {
 		return err
 	}
-	log.Dev.Warningf(ctx, "wrote global MVCC range tombstone %s", rangeKey)
+	log.KvDistribution.Warningf(ctx, "wrote global MVCC range tombstone %s", rangeKey)
 	return nil
 }
diff --git a/pkg/kv/kvserver/store_merge.go b/pkg/kv/kvserver/store_merge.go
@@ -75,10 +75,10 @@ func (s *Store) maybeAssertNoHole(ctx context.Context, from, to roachpb.RKey) fu
 						return nil
 					})
 				if err != nil {
-					log.Dev.Fatalf(ctx, "%v", err)
+					log.KvDistribution.Fatalf(ctx, "%v", err)
 				}
 				if last.isEmpty() {
-					log.Dev.Fatalf(ctx, "found hole in keyspace [%s,%s), during:\n%s", from, to, caller)
+					log.KvDistribution.Fatalf(ctx, "found hole in keyspace [%s,%s), during:\n%s", from, to, caller)
 				}
 				runtime.Gosched()
 			}()
diff --git a/pkg/kv/kvserver/store_remove_replica.go b/pkg/kv/kvserver/store_remove_replica.go
diff --git a/pkg/kv/kvserver/store_snapshot.go b/pkg/kv/kvserver/store_snapshot.go

Original file line number	Diff line number	Diff line change
`@@ -136,7 +136,7 @@ func (kvSS *kvBatchSnapshotStrategy) Receive(`
`136`	`136`
`137`	`137`	`snapshotQ := s.cfg.KVAdmissionController.GetSnapshotQueue(s.StoreID())`
`138`	`138`	`if snapshotQ == nil {`
`139`		`- log.Dev.Errorf(ctx, "unable to find snapshot queue for store: %s", s.StoreID())`
	`139`	`+ log.KvDistribution.Errorf(ctx, "unable to find snapshot queue for store: %s", s.StoreID())`
`140`	`140`	`}`
`141`	`141`	`// Using a nil pacer is effectively a noop if snapshot control is disabled.`
`142`	`142`	`var pacer *admission.SnapshotPacer = nil`
`@@ -602,7 +602,7 @@ func (kvSS *kvBatchSnapshotStrategy) Close(ctx context.Context) {`
`602`	`602`	`// disk space (which is reclaimed on node restart). It is unexpected`
`603`	`603`	`// though, so log a warning.`
`604`	`604`	`if err := kvSS.scratch.Close(); err != nil {`
`605`		`- log.Dev.Warningf(ctx, "error closing kvBatchSnapshotStrategy: %v", err)`
	`605`	`+ log.KvDistribution.Warningf(ctx, "error closing kvBatchSnapshotStrategy: %v", err)`
`606`	`606`	`}`
`607`	`607`	`}`
`608`	`608`	`}`
Original file line number	Diff line number	Diff line change
`@@ -292,7 +292,7 @@ func (st *sidetransportAccess) forward(`
`292`	`292`
`293`	`293`	`func (st *sidetransportAccess) assertNoRegression(ctx context.Context, cur, up closedTimestamp) {`
`294`	`294`	`if cur.regression(up) {`
`295`		`- log.Dev.Fatalf(ctx, "side-transport update saw closed timestamp regression on r%d: "+`
	`295`	`+ log.KvDistribution.Fatalf(ctx, "side-transport update saw closed timestamp regression on r%d: "+`
`296`	`296`	`"(lai=%d, ts=%s) -> (lai=%d, ts=%s)", st.rangeID, cur.lai, cur.ts, up.lai, up.ts)`
`297`	`297`	`}`
`298`	`298`	`}`
Original file line number	Diff line number	Diff line change
`@@ -35,20 +35,20 @@ func (r *Replica) gossipFirstRangeLocked(ctx context.Context) {`
`35`	`35`	`}`
`36`	`36`	`log.Event(ctx, "gossiping sentinel and first range")`
`37`	`37`	`if log.V(1) {`
`38`		`- log.Dev.Infof(ctx, "gossiping sentinel from store %d, r%d", r.store.StoreID(), r.RangeID)`
	`38`	`+ log.KvDistribution.Infof(ctx, "gossiping sentinel from store %d, r%d", r.store.StoreID(), r.RangeID)`
`39`	`39`	`}`
`40`	`40`	`if err := r.store.Gossip().AddInfo(`
`41`	`41`	`gossip.KeySentinel, r.store.ClusterID().GetBytes(),`
`42`	`42`	`r.store.cfg.SentinelGossipTTL()); err != nil {`
`43`		`- log.Dev.Errorf(ctx, "failed to gossip sentinel: %+v", err)`
	`43`	`+ log.KvDistribution.Errorf(ctx, "failed to gossip sentinel: %+v", err)`
`44`	`44`	`}`
`45`	`45`	`if log.V(1) {`
`46`		`- log.Dev.Infof(ctx, "gossiping first range from store %d, r%d: %s",`
	`46`	`+ log.KvDistribution.Infof(ctx, "gossiping first range from store %d, r%d: %s",`
`47`	`47`	`r.store.StoreID(), r.RangeID, r.shMu.state.Desc.Replicas())`
`48`	`48`	`}`
`49`	`49`	`if err := r.store.Gossip().AddInfoProto(`
`50`	`50`	`gossip.KeyFirstRangeDescriptor, r.shMu.state.Desc, configGossipTTL); err != nil {`
`51`		`- log.Dev.Errorf(ctx, "failed to gossip first range metadata: %+v", err)`
	`51`	`+ log.KvDistribution.Errorf(ctx, "failed to gossip first range metadata: %+v", err)`
`52`	`52`	`}`
`53`	`53`	`}`
`54`	`54`
`@@ -176,7 +176,7 @@ func (r Replica) getLeaseForGossip(ctx context.Context) (bool, kvpb.Error) {`
`176`	`176`	`}`
`177`	`177`	`default:`
`178`	`178`	`// Any other error is worth being logged visibly.`
`179`		`- log.Dev.Warningf(ctx, "could not acquire lease for range gossip: %s", pErr)`
	`179`	`+ log.KvDistribution.Warningf(ctx, "could not acquire lease for range gossip: %s", pErr)`
`180`	`180`	`}`
`181`	`181`	`}`
`182`	`182`	`}); err != nil {`
`@@ -198,7 +198,7 @@ func (r Replica) maybeGossipFirstRange(ctx context.Context) kvpb.Error {`
`198`	`198`	`// so we error out below.`
`199`	`199`	`if gossipClusterID, err := r.store.Gossip().GetClusterID(); err == nil {`
`200`	`200`	`if gossipClusterID != r.store.ClusterID() {`
`201`		`- log.Dev.Fatalf(`
	`201`	`+ log.KvDistribution.Fatalf(`
`202`	`202`	`ctx, "store %d belongs to cluster %s, but attempted to join cluster %s via gossip",`
`203`	`203`	`r.store.StoreID(), r.store.ClusterID(), gossipClusterID)`
`204`	`204`	`}`
`@@ -207,11 +207,11 @@ func (r Replica) maybeGossipFirstRange(ctx context.Context) kvpb.Error {`
`207`	`207`	`// Gossip the cluster ID from all replicas of the first range; there`
`208`	`208`	`// is no expiration on the cluster ID.`
`209`	`209`	`if log.V(1) {`
`210`		`- log.Dev.Infof(ctx, "gossiping cluster ID %q from store %d, r%d", r.store.ClusterID(),`
	`210`	`+ log.KvDistribution.Infof(ctx, "gossiping cluster ID %q from store %d, r%d", r.store.ClusterID(),`
`211`	`211`	`r.store.StoreID(), r.RangeID)`
`212`	`212`	`}`
`213`	`213`	`if err := r.store.Gossip().AddClusterID(r.store.ClusterID()); err != nil {`
`214`		`- log.Dev.Errorf(ctx, "failed to gossip cluster ID: %+v", err)`
	`214`	`+ log.KvDistribution.Errorf(ctx, "failed to gossip cluster ID: %+v", err)`
`215`	`215`	`}`
`216`	`216`
`217`	`217`	`hasLease, pErr := r.getLeaseForGossip(ctx)`
Original file line number	Diff line number	Diff line change
`@@ -431,7 +431,7 @@ func logSlowRangefeedRegistration(ctx context.Context) func() {`
`431`	`431`	`return func() {`
`432`	`432`	`elapsed := timeutil.Since(start)`
`433`	`433`	`if elapsed >= slowRaftMuWarnThreshold {`
`434`		`- log.Dev.Warningf(ctx, "rangefeed registration took %s", elapsed)`
	`434`	`+ log.KvDistribution.Warningf(ctx, "rangefeed registration took %s", elapsed)`
`435`	`435`	`}`
`436`	`436`	`}`
`437`	`437`	`}`
`@@ -889,9 +889,9 @@ func (r *Replica) handleClosedTimestampUpdateRaftMuLocked(`
`889`	`889`	`expensiveLog := m.RangeFeedSlowClosedTimestampLogN.ShouldLog()`
`890`	`890`	`if expensiveLog {`
`891`	`891`	`if closedTS.IsEmpty() {`
`892`		`- log.Dev.Infof(ctx, "RangeFeed closed timestamp is empty")`
	`892`	`+ log.KvDistribution.Infof(ctx, "RangeFeed closed timestamp is empty")`
`893`	`893`	`} else {`
`894`		`- log.Dev.Infof(ctx, "RangeFeed closed timestamp %s is behind by %s (%v)",`
	`894`	`+ log.KvDistribution.Infof(ctx, "RangeFeed closed timestamp %s is behind by %s (%v)",`
`895`	`895`	`closedTS, signal.lag, signal)`
`896`	`896`	`}`
`897`	`897`	`}`
`@@ -919,7 +919,7 @@ func (r *Replica) handleClosedTimestampUpdateRaftMuLocked(`
`919`	`919`	`}`
`920`	`920`	`defer func() { <-m.RangeFeedSlowClosedTimestampNudgeSem }()`
`921`	`921`	`if err := r.ensureClosedTimestampStarted(ctx); err != nil {`
`922`		- log.Dev.Infof(ctx, `RangeFeed failed to nudge: %s`, err)
	`922`	+ log.KvDistribution.Infof(ctx, `RangeFeed failed to nudge: %s`, err)
`923`	`923`	`} else if signal.exceedsCancelLagThreshold {`
`924`	`924`	`// We have successfully nudged the leaseholder to make progress on`
`925`	`925`	`// the closed timestamp. If the lag was already persistently too`
`@@ -933,7 +933,7 @@ func (r *Replica) handleClosedTimestampUpdateRaftMuLocked(`
`933`	`933`	`// prohibit us from cancelling the rangefeed in the current version,`
`934`	`934`	`// due to mixed version compatibility.`
`935`	`935`	`if expensiveLog {`
`936`		`- log.Dev.Infof(ctx,`
	`936`	`+ log.KvDistribution.Infof(ctx,`
`937`	`937`	`RangeFeed is too far behind, cancelling for replanning [%v]`, signal)
`938`	`938`	`}`
`939`	`939`	`r.disconnectRangefeedWithReason(kvpb.RangeFeedRetryError_REASON_RANGEFEED_CLOSED)`
Original file line number	Diff line number	Diff line change
`@@ -213,20 +213,20 @@ func (rs *replicaScanner) waitAndProcess(ctx context.Context, start time.Time, r`
`213`	`213`	`waitInterval := rs.paceInterval(start, timeutil.Now())`
`214`	`214`	`rs.waitTimer.Reset(waitInterval)`
`215`	`215`	`if log.V(6) {`
`216`		`- log.Dev.Infof(ctx, "wait timer interval set to %s", waitInterval)`
	`216`	`+ log.KvDistribution.Infof(ctx, "wait timer interval set to %s", waitInterval)`
`217`	`217`	`}`
`218`	`218`	`for {`
`219`	`219`	`select {`
`220`	`220`	`case <-rs.waitTimer.C:`
`221`	`221`	`if log.V(6) {`
`222`		`- log.Dev.Infof(ctx, "wait timer fired")`
	`222`	`+ log.KvDistribution.Infof(ctx, "wait timer fired")`
`223`	`223`	`}`
`224`	`224`	`if repl == nil {`
`225`	`225`	`return false`
`226`	`226`	`}`
`227`	`227`
`228`	`228`	`if log.V(2) {`
`229`		`- log.Dev.Infof(ctx, "replica scanner processing %s", repl)`
	`229`	`+ log.KvDistribution.Infof(ctx, "replica scanner processing %s", repl)`
`230`	`230`	`}`
`231`	`231`	`for _, q := range rs.queues {`
`232`	`232`	`q.MaybeAddAsync(ctx, repl, rs.clock.NowAsClockTimestamp())`
`@@ -251,7 +251,7 @@ func (rs replicaScanner) removeReplica(repl Replica) {`
`251`	`251`	`}`
`252`	`252`	`if log.V(6) {`
`253`	`253`	`ctx := rs.AnnotateCtx(context.TODO())`
`254`		`- log.Dev.Infof(ctx, "removed replica %s", repl)`
	`254`	`+ log.KvDistribution.Infof(ctx, "removed replica %s", repl)`
`255`	`255`	`}`
`256`	`256`	`}`
`257`	`257`
`@@ -299,7 +299,7 @@ func (rs *replicaScanner) scanLoop() {`
`299`	`299`	`rs.mu.total += timeutil.Since(start)`
`300`	`300`	`}()`
`301`	`301`	`if log.V(6) {`
`302`		`- log.Dev.Infof(ctx, "reset replica scan iteration")`
	`302`	`+ log.KvDistribution.Infof(ctx, "reset replica scan iteration")`
`303`	`303`	`}`
`304`	`304`
`305`	`305`	`// Reset iteration and start time.`