kvserver: assign some Dev logs to KvExec

```
sed -i '' 's/log\.Dev/log.KvExec/g' app_batch.go metric_rules.go metrics.go raft.go raft_log_truncator.go raft_transport.go range_log.go replica_app_batch.go replica_application_cmd.go replica_application_decoder.go  replica_application_result.go replica_application_state_machine.go replica_backpressure.go replica_batch_updates.go replica_circuit_breaker.go replica_corruption.go replica_eval_context.go replica_evaluate.go replica_proposal.go replica_proposal_buf.go replica_raft.go replica_raft_quiesce.go replica_raftlog.go replica_raftstorage.go replica_range_lease.go replica_read.go replica_send.go replica_tscache.go replica_write.go scheduler.go split_trigger_helper.go store_create_replica.go store_raft.go store_send.go store_split.go stores_server.go
```

Author: tbg

pkg/kv/kvserver/app_batch.go

@@ -84,7 +84,7 @@ func (b *appBatch) assertAndCheckCommand(
 	ctx context.Context, cmd *raftlog.ReplicatedCmd, state *kvserverpb.ReplicaState, isLocal bool,
 ) (kvserverbase.ForcedErrResult, error) {
 	if log.V(4) {
-		log.Dev.Infof(ctx, "processing command %x: raftIndex=%d maxLeaseIndex=%d closedts=%s",
+		log.KvExec.Infof(ctx, "processing command %x: raftIndex=%d maxLeaseIndex=%d closedts=%s",
 			cmd.ID, cmd.Index(), cmd.Cmd.MaxLeaseIndex, cmd.Cmd.ClosedTimestamp)
 	}
 
@@ -138,7 +138,7 @@ func (b *appBatch) addWriteBatch(
 		return nil
 	}
 	if mutations, err := storage.BatchCount(wb.Data); err != nil {
-		log.Dev.Errorf(ctx, "unable to read header of committed WriteBatch: %+v", err)
+		log.KvExec.Errorf(ctx, "unable to read header of committed WriteBatch: %+v", err)
 	} else {
 		b.numMutations += mutations
 	}

pkg/kv/kvserver/metric_rules.go

@@ -291,10 +291,10 @@ func MaybeAddRuleToRegistry(
 	ctx context.Context, err error, name string, rule metric.Rule, ruleRegistry *metric.RuleRegistry,
 ) {
 	if err != nil {
-		log.Dev.Warningf(ctx, "unable to create kv rule %s: %s", name, err.Error())
+		log.KvExec.Warningf(ctx, "unable to create kv rule %s: %s", name, err.Error())
 	}
 	if ruleRegistry == nil {
-		log.Dev.Warningf(ctx, "unable to add kv rule %s: rule registry uninitialized", name)
+		log.KvExec.Warningf(ctx, "unable to add kv rule %s: rule registry uninitialized", name)
 	}
 	ruleRegistry.AddRule(rule)
 }

pkg/kv/kvserver/metrics.go

@@ -3515,11 +3515,11 @@ func (sm *TenantsStorageMetrics) releaseTenant(ctx context.Context, m *tenantSto
 	m.mu.Lock()
 	defer m.mu.Unlock()
 	if m.mu.released.Load() {
-		log.Dev.FatalfDepth(ctx, 1, "tenant metrics already released in:\n%s", m.mu.stack)
+		log.KvExec.FatalfDepth(ctx, 1, "tenant metrics already released in:\n%s", m.mu.stack)
 	}
 	m.mu.refCount--
 	if n := m.mu.refCount; n < 0 {
-		log.Dev.Fatalf(ctx, "invalid refCount on metrics for tenant %v: %d", m.tenantID, n)
+		log.KvExec.Fatalf(ctx, "invalid refCount on metrics for tenant %v: %d", m.tenantID, n)
 	} else if n > 0 {
 		return
 	}
@@ -3609,7 +3609,7 @@ func (tm *tenantStorageMetrics) assert(ctx context.Context) {
 	if tm.mu.released.Load() {
 		tm.mu.Lock()
 		defer tm.mu.Unlock()
-		log.Dev.Fatalf(ctx, "tenant metrics already released in:\n%s", tm.mu.stack)
+		log.KvExec.Fatalf(ctx, "tenant metrics already released in:\n%s", tm.mu.stack)
 	}
 }
 
@@ -4461,7 +4461,7 @@ func (sm *StoreMetrics) updateDiskStats(
 		sm.DiskIopsInProgress.Update(int64(cumulativeStats.InProgressCount))
 	} else {
 		// Don't update cumulative stats to the useless zero value.
-		log.Dev.Errorf(ctx, "not updating cumulative stats due to %s", cumulativeStatsErr)
+		log.KvExec.Errorf(ctx, "not updating cumulative stats due to %s", cumulativeStatsErr)
 	}
 	maxRollingStats := rollingStats.Max()
 	// maxRollingStats is computed as the change in stats every 100ms
@@ -4503,7 +4503,7 @@ func (sm *StoreMetrics) handleMetricsResult(ctx context.Context, metric result.M
 	metric.SplitEstimatedTotalBytesDiff = 0
 
 	if metric != (result.Metrics{}) {
-		log.Dev.Fatalf(ctx, "unhandled fields in metrics result: %+v", metric)
+		log.KvExec.Fatalf(ctx, "unhandled fields in metrics result: %+v", metric)
 	}
 }
 

pkg/kv/kvserver/raft.go

@@ -56,62 +56,62 @@ type raftLogger struct {
 
 func (r *raftLogger) Debug(v ...interface{}) {
 	if log.V(3) {
-		log.Dev.InfofDepth(r.ctx, 1, "", v...)
+		log.KvExec.InfofDepth(r.ctx, 1, "", v...)
 	}
 }
 
 func (r *raftLogger) Debugf(format string, v ...interface{}) {
 	if log.V(3) {
-		log.Dev.InfofDepth(r.ctx, 1, format, v...)
+		log.KvExec.InfofDepth(r.ctx, 1, format, v...)
 	}
 }
 
 func (r *raftLogger) Info(v ...interface{}) {
 	if log.V(2) {
-		log.Dev.InfofDepth(r.ctx, 1, "", v...)
+		log.KvExec.InfofDepth(r.ctx, 1, "", v...)
 	}
 }
 
 func (r *raftLogger) Infof(format string, v ...interface{}) {
 	if log.V(2) {
-		log.Dev.InfofDepth(r.ctx, 1, format, v...)
+		log.KvExec.InfofDepth(r.ctx, 1, format, v...)
 	}
 }
 
 func (r *raftLogger) Warning(v ...interface{}) {
-	log.Dev.WarningfDepth(r.ctx, 1, "", v...)
+	log.KvExec.WarningfDepth(r.ctx, 1, "", v...)
 }
 
 func (r *raftLogger) Warningf(format string, v ...interface{}) {
-	log.Dev.WarningfDepth(r.ctx, 1, format, v...)
+	log.KvExec.WarningfDepth(r.ctx, 1, format, v...)
 }
 
 func (r *raftLogger) Error(v ...interface{}) {
-	log.Dev.ErrorfDepth(r.ctx, 1, "", v...)
+	log.KvExec.ErrorfDepth(r.ctx, 1, "", v...)
 }
 
 func (r *raftLogger) Errorf(format string, v ...interface{}) {
-	log.Dev.ErrorfDepth(r.ctx, 1, format, v...)
+	log.KvExec.ErrorfDepth(r.ctx, 1, format, v...)
 }
 
 func (r *raftLogger) Fatal(v ...interface{}) {
 	wrapNumbersAsSafe(v)
-	log.Dev.FatalfDepth(r.ctx, 1, "", v...)
+	log.KvExec.FatalfDepth(r.ctx, 1, "", v...)
 }
 
 func (r *raftLogger) Fatalf(format string, v ...interface{}) {
 	wrapNumbersAsSafe(v)
-	log.Dev.FatalfDepth(r.ctx, 1, format, v...)
+	log.KvExec.FatalfDepth(r.ctx, 1, format, v...)
 }
 
 func (r *raftLogger) Panic(v ...interface{}) {
 	wrapNumbersAsSafe(v)
-	log.Dev.FatalfDepth(r.ctx, 1, "", v...)
+	log.KvExec.FatalfDepth(r.ctx, 1, "", v...)
 }
 
 func (r *raftLogger) Panicf(format string, v ...interface{}) {
 	wrapNumbersAsSafe(v)
-	log.Dev.FatalfDepth(r.ctx, 1, format, v...)
+	log.KvExec.FatalfDepth(r.ctx, 1, format, v...)
 }
 
 func wrapNumbersAsSafe(v ...interface{}) {
@@ -183,7 +183,7 @@ func logRaftReady(ctx context.Context, ready raft.Ready) {
 		fmt.Fprintf(&buf, "  Outgoing Message[%d]: %.200s\n",
 			i, raft.DescribeMessage(m, raftEntryFormatter))
 	}
-	log.Dev.Infof(ctx, "raft ready\n%s", buf.String())
+	log.KvExec.Infof(ctx, "raft ready\n%s", buf.String())
 }
 
 func raftEntryFormatter(data []byte) string {

pkg/kv/kvserver/raft_log_truncator.go

@@ -324,7 +324,7 @@ func (t *raftLogTruncator) addPendingTruncation(
 		After: alreadyTruncIndex, Last: pendingTrunc.Index,
 	}); err != nil {
 		// Log a loud error since we need to continue enqueuing the truncation.
-		log.Dev.Errorf(ctx, "while computing size of sideloaded files to truncate: %+v", err)
+		log.KvExec.Errorf(ctx, "while computing size of sideloaded files to truncate: %+v", err)
 		pendingTrunc.isDeltaTrusted = false
 	} else if entries != 0 {
 		pendingTrunc.logDeltaBytes -= size
@@ -523,7 +523,7 @@ func (t *raftLogTruncator) tryEnactTruncations(
 	stateLoader := r.getStateLoader()
 	as, err := stateLoader.LoadRangeAppliedState(ctx, reader)
 	if err != nil {
-		log.Dev.Errorf(ctx, "error loading RangeAppliedState, dropping all pending log truncations: %s",
+		log.KvExec.Errorf(ctx, "error loading RangeAppliedState, dropping all pending log truncations: %s",
 			err)
 		pendingTruncs.reset()
 		return
@@ -551,7 +551,7 @@ func (t *raftLogTruncator) tryEnactTruncations(
 		pendingTruncs.mu.truncs[enactIndex].RaftTruncatedState,
 		stateLoader.StateLoader, batch,
 	); err != nil {
-		log.Dev.Errorf(ctx, "while attempting to truncate raft log: %+v", err)
+		log.KvExec.Errorf(ctx, "while attempting to truncate raft log: %+v", err)
 		pendingTruncs.reset()
 		return
 	}
@@ -570,7 +570,7 @@ func (t *raftLogTruncator) tryEnactTruncations(
 	// so that the subsequent removals from the sideloaded storage are safe.
 	sync := pendingTruncs.mu.truncs[enactIndex].hasSideloaded
 	if err := batch.Commit(sync); err != nil {
-		log.Dev.Fatalf(ctx, "while committing batch to truncate raft log: %+v", err)
+		log.KvExec.Fatalf(ctx, "while committing batch to truncate raft log: %+v", err)
 		return
 	}
 	r.finalizeTruncation(ctx)

pkg/kv/kvserver/raft_transport.go

@@ -347,7 +347,7 @@ func (t *RaftTransport) handleRaftRequest(
 	incomingMessageHandler, ok := t.getIncomingRaftMessageHandler(req.ToReplica.StoreID)
 	if !ok {
 		if isV1 {
-			log.Dev.Warningf(ctx, "unable to accept Raft message from %+v: no handler registered for %+v",
+			log.KvExec.Warningf(ctx, "unable to accept Raft message from %+v: no handler registered for %+v",
 				req.FromReplica, req.ToReplica)
 		}
 		// We don't return an error to the client. If this node restarted with fewer
@@ -516,7 +516,7 @@ func (t *RaftTransport) InternalDelegateRaftSnapshot(
 	// Get the handler of the sender store.
 	incomingMessageHandler, ok := t.getIncomingRaftMessageHandler(req.DelegatedSender.StoreID)
 	if !ok {
-		log.Dev.Warningf(
+		log.KvExec.Warningf(
 			ctx,
 			"unable to accept Raft message: %+v: no handler registered for"+
 				" the sender store"+" %+v",
@@ -559,7 +559,7 @@ func (t *RaftTransport) raftSnapshot(stream RPCMultiRaft_RaftSnapshotStream) err
 	rmr := req.Header.RaftMessageRequest
 	incomingMessageHandler, ok := t.getIncomingRaftMessageHandler(rmr.ToReplica.StoreID)
 	if !ok {
-		log.Dev.Warningf(ctx, "unable to accept Raft message from %+v: no handler registered for %+v",
+		log.KvExec.Warningf(ctx, "unable to accept Raft message from %+v: no handler registered for %+v",
 			rmr.FromReplica, rmr.ToReplica)
 		return kvpb.NewStoreNotFoundError(rmr.ToReplica.StoreID)
 	}
@@ -633,7 +633,7 @@ func (t *RaftTransport) processQueue(
 				t.metrics.ReverseRcvd.Inc(1)
 				incomingMessageHandler, ok := t.getIncomingRaftMessageHandler(resp.ToReplica.StoreID)
 				if !ok {
-					log.Dev.Warningf(ctx, "no handler found for store %s in response %s",
+					log.KvExec.Warningf(ctx, "no handler found for store %s in response %s",
 						resp.ToReplica.StoreID, resp)
 					continue
 				}
@@ -857,7 +857,7 @@ func (t *RaftTransport) SendAsync(
 		return true
 	default:
 		if logRaftSendQueueFullEvery.ShouldLog() {
-			log.Dev.Warningf(t.AnnotateCtx(context.Background()), "raft send queue to n%d is full", toNodeID)
+			log.KvExec.Warningf(t.AnnotateCtx(context.Background()), "raft send queue to n%d is full", toNodeID)
 		}
 		return false
 	}
@@ -896,7 +896,7 @@ func (t *RaftTransport) startProcessNewQueue(
 	worker := func(ctx context.Context) {
 		q, existingQueue := t.getQueue(toNodeID, class)
 		if !existingQueue {
-			log.Dev.Fatalf(ctx, "queue for n%d does not exist", toNodeID)
+			log.KvExec.Fatalf(ctx, "queue for n%d does not exist", toNodeID)
 		}
 		defer func() {
 			if fn := t.knobs.OnWorkerTeardown; fn != nil {
@@ -916,7 +916,7 @@ func (t *RaftTransport) startProcessNewQueue(
 			return
 		}
 		if err := t.processQueue(ctx, q, client, class); err != nil {
-			log.Dev.Warningf(ctx, "while processing outgoing Raft queue to node %d: %s:", toNodeID, err)
+			log.KvExec.Warningf(ctx, "while processing outgoing Raft queue to node %d: %s:", toNodeID, err)
 		}
 	}
 	ctx, hdl, err := t.stopper.GetHandle(ctx, stop.TaskOpts{
@@ -1050,7 +1050,7 @@ func (t *RaftTransport) SendSnapshot(
 
 	defer func() {
 		if err := stream.CloseSend(); err != nil {
-			log.Dev.Warningf(ctx, "failed to close snapshot stream: %+v", err)
+			log.KvExec.Warningf(ctx, "failed to close snapshot stream: %+v", err)
 		}
 	}()
 	return sendSnapshot(ctx, clusterID, t.st, t.Tracer, stream, storePool, header, snap, newWriteBatch, sent, recordBytesSent)
@@ -1074,7 +1074,7 @@ func (t *RaftTransport) DelegateSnapshot(
 	}
 	defer func() {
 		if err := stream.CloseSend(); err != nil {
-			log.Dev.Warningf(ctx, "failed to close delegate snapshot stream: %+v", err)
+			log.KvExec.Warningf(ctx, "failed to close delegate snapshot stream: %+v", err)
 		}
 	}()
 
@@ -1094,7 +1094,7 @@ func (t *RaftTransport) DelegateSnapshot(
 	if len(resp.CollectedSpans) != 0 {
 		span := tracing.SpanFromContext(ctx)
 		if span == nil {
-			log.Dev.Warningf(ctx, "trying to ingest remote spans but there is no recording span set up")
+			log.KvExec.Warningf(ctx, "trying to ingest remote spans but there is no recording span set up")
 		} else {
 			span.ImportRemoteRecording(resp.CollectedSpans)
 		}

pkg/kv/kvserver/range_log.go

@@ -82,7 +82,7 @@ func maybeLogRangeLogEvent(ctx context.Context, event kvserverpb.RangeLogEvent)
 	if event.Info != nil {
 		info = event.Info.String()
 	}
-	log.Dev.Infof(ctx, "Range Event: %q, range: %d, info: %s",
+	log.KvExec.Infof(ctx, "Range Event: %q, range: %d, info: %s",
 		event.EventType, event.RangeID, info)
 }
 
@@ -246,13 +246,13 @@ func writeToRangeLogTable(
 					if err := timeutil.RunWithTimeout(ctx, "rangelog-timeout", perAttemptTimeout, func(ctx context.Context) error {
 						return s.cfg.RangeLogWriter.WriteRangeLogEvent(ctx, txn.DB(), logEvent)
 					}); err != nil {
-						log.Dev.Warningf(ctx, "error logging to system.rangelog: %v", err)
+						log.KvExec.Warningf(ctx, "error logging to system.rangelog: %v", err)
 						continue
 					}
 					break
 				}
 			}); err != nil {
-			log.Dev.Warningf(asyncCtx, "async task error while logging to system.rangelog: %v", err)
+			log.KvExec.Warningf(asyncCtx, "async task error while logging to system.rangelog: %v", err)
 			stopCancel()
 		}
 	}

pkg/kv/kvserver/replica_app_batch.go

@@ -474,7 +474,7 @@ func (b *replicaAppBatch) runPostAddTriggersReplicaOnly(
 	if ops := cmd.Cmd.LogicalOpLog; cmd.Cmd.WriteBatch != nil {
 		b.r.handleLogicalOpLogRaftMuLocked(ctx, ops, b.batch)
 	} else if ops != nil {
-		log.Dev.Fatalf(ctx, "non-nil logical op log with nil write batch: %v", cmd.Cmd)
+		log.KvExec.Fatalf(ctx, "non-nil logical op log with nil write batch: %v", cmd.Cmd)
 	}
 
 	return nil
@@ -598,7 +598,7 @@ func (b *replicaAppBatch) stageTrivialReplicatedEvalResult(
 // application.
 func (b *replicaAppBatch) ApplyToStateMachine(ctx context.Context) error {
 	if log.V(4) {
-		log.Dev.Infof(ctx, "flushing batch %v of %d entries", b.state, b.ab.numEntriesProcessed)
+		log.KvExec.Infof(ctx, "flushing batch %v of %d entries", b.state, b.ab.numEntriesProcessed)
 	}
 
 	// Add the replica applied state key to the write batch if this change

pkg/kv/kvserver/replica_application_cmd.go

@@ -158,7 +158,7 @@ func (c *replicatedCmd) AckOutcomeAndFinish(ctx context.Context) error {
 // command's proposal if it is local, it asserts that the proposal is not local.
 func (c *replicatedCmd) FinishNonLocal(ctx context.Context) {
 	if c.IsLocal() {
-		log.Dev.Fatalf(ctx, "proposal unexpectedly local: %v", c.ReplicatedResult())
+		log.KvExec.Fatalf(ctx, "proposal unexpectedly local: %v", c.ReplicatedResult())
 	}
 	c.finishTracingSpan()
 }

pkg/kv/kvserver/replica_application_decoder.go

@@ -158,7 +158,7 @@ func (d *replicaDecoder) createTracingSpans(ctx context.Context) {
 				Map: cmd.Cmd.TraceData,
 			})
 			if err != nil {
-				log.Dev.Errorf(ctx, "unable to extract trace data from raft command: %s", err)
+				log.KvExec.Errorf(ctx, "unable to extract trace data from raft command: %s", err)
 			} else {
 				cmd.ctx, cmd.sp = d.r.AmbientContext.Tracer.StartSpanCtx(
 					ctx,