log,*: find and replace log.*Info* with log.Dev.*Info*

Epic: CRDB-53410
Release note: None

Author: kyle-a-wong

pkg/acceptance/cluster/docker.go

@@ -125,12 +125,12 @@ func pullImage(
 	// acceptance test even though that image is already present. So we first
 	// check to see if our image is present in order to avoid this slowness.
 	if hasImage(ctx, l, ref) == nil {
-		log.Infof(ctx, "ImagePull %s already exists", ref)
+		log.Dev.Infof(ctx, "ImagePull %s already exists", ref)
 		return nil
 	}
 
-	log.Infof(ctx, "ImagePull %s starting", ref)
-	defer log.Infof(ctx, "ImagePull %s complete", ref)
+	log.Dev.Infof(ctx, "ImagePull %s starting", ref)
+	defer log.Dev.Infof(ctx, "ImagePull %s complete", ref)
 
 	rc, err := l.client.ImagePull(ctx, ref, options)
 	if err != nil {
@@ -424,13 +424,13 @@ func (cli resilientDockerClient) ContainerCreate(
 		ctx, config, hostConfig, networkingConfig, platformSpec, containerName,
 	)
 	if err != nil && strings.Contains(err.Error(), "already in use") {
-		log.Infof(ctx, "unable to create container %s: %v", containerName, err)
+		log.Dev.Infof(ctx, "unable to create container %s: %v", containerName, err)
 		containers, cerr := cli.ContainerList(ctx, types.ContainerListOptions{
 			All:   true,
 			Limit: -1, // no limit, see docker/docker/client/container_list.go
 		})
 		if cerr != nil {
-			log.Infof(ctx, "unable to list containers: %v", cerr)
+			log.Dev.Infof(ctx, "unable to list containers: %v", cerr)
 			return container.CreateResponse{}, err
 		}
 		for _, c := range containers {
@@ -440,13 +440,13 @@ func (cli resilientDockerClient) ContainerCreate(
 				if n != containerName {
 					continue
 				}
-				log.Infof(ctx, "trying to remove %s", c.ID)
+				log.Dev.Infof(ctx, "trying to remove %s", c.ID)
 				options := types.ContainerRemoveOptions{
 					RemoveVolumes: true,
 					Force:         true,
 				}
 				if rerr := cli.ContainerRemove(ctx, c.ID, options); rerr != nil {
-					log.Infof(ctx, "unable to remove container: %v", rerr)
+					log.Dev.Infof(ctx, "unable to remove container: %v", rerr)
 					return container.CreateResponse{}, err
 				}
 				return cli.ContainerCreate(ctx, config, hostConfig, networkingConfig, platformSpec, containerName)

pkg/acceptance/cluster/dockercluster.go

@@ -181,7 +181,7 @@ func CreateDocker(
 		volumesDir = filepath.Join(pwd, volumesDir)
 	}
 	maybePanic(os.MkdirAll(volumesDir, 0755))
-	log.Infof(ctx, "cluster volume directory: %s", volumesDir)
+	log.Dev.Infof(ctx, "cluster volume directory: %s", volumesDir)
 
 	return &DockerCluster{
 		clusterID: clusterIDS,
@@ -281,7 +281,7 @@ func (l *DockerCluster) createNetwork(ctx context.Context) {
 	l.panicOnStop()
 
 	l.networkName = fmt.Sprintf("%s-%s", networkPrefix, l.clusterID)
-	log.Infof(ctx, "creating docker network with name: %s", l.networkName)
+	log.Dev.Infof(ctx, "creating docker network with name: %s", l.networkName)
 	net, err := l.client.NetworkInspect(ctx, l.networkName, types.NetworkInspectOptions{})
 	if err == nil {
 		// We need to destroy the network and any running containers inside of it.
@@ -313,7 +313,7 @@ func (l *DockerCluster) createNetwork(ctx context.Context) {
 func (l *DockerCluster) initCluster(ctx context.Context) {
 	configJSON, err := json.Marshal(l.config)
 	maybePanic(err)
-	log.Infof(ctx, "Initializing Cluster %s:\n%s", l.config.Name, configJSON)
+	log.Dev.Infof(ctx, "Initializing Cluster %s:\n%s", l.config.Name, configJSON)
 	l.panicOnStop()
 
 	pwd, err := os.Getwd()
@@ -417,7 +417,7 @@ func (l *DockerCluster) createRoach(
 	if node.index >= 0 {
 		hostname = fmt.Sprintf("roach-%s-%d", l.clusterID, node.index)
 	}
-	log.Infof(ctx, "creating docker container with name: %s", hostname)
+	log.Dev.Infof(ctx, "creating docker container with name: %s", hostname)
 	var err error
 	node.Container, err = createContainer(
 		ctx,
@@ -516,7 +516,7 @@ func (l *DockerCluster) startNode(ctx context.Context, node *testNode, singleNod
 	maybePanic(node.Start(ctx))
 	httpAddr := node.Addr(ctx, defaultHTTP)
 
-	log.Infof(ctx, `*** started %[1]s ***
+	log.Dev.Infof(ctx, `*** started %[1]s ***
   ui:        %[2]s
   trace:     %[2]s/debug/requests
   logs:      %[3]s/cockroach.INFO
@@ -551,10 +551,10 @@ func (l *DockerCluster) RunInitCommand(ctx context.Context, nodeIdx int) {
 		},
 	}
 
-	log.Infof(ctx, "trying to initialize via %v", containerConfig.Cmd)
+	log.Dev.Infof(ctx, "trying to initialize via %v", containerConfig.Cmd)
 	maybePanic(l.OneShot(ctx, defaultImage, types.ImagePullOptions{},
 		containerConfig, container.HostConfig{}, platforms.DefaultSpec(), "init-command-"+randomID))
-	log.Info(ctx, "cluster successfully initialized")
+	log.Dev.Info(ctx, "cluster successfully initialized")
 }
 
 // returns false is the event
@@ -564,12 +564,12 @@ func (l *DockerCluster) processEvent(ctx context.Context, event events.Message)
 
 	// Logging everything we get from Docker in service of finding the root
 	// cause of #58955.
-	log.Infof(ctx, "processing event from Docker: %+v", event)
+	log.Dev.Infof(ctx, "processing event from Docker: %+v", event)
 
 	// If there's currently a oneshot container, ignore any die messages from
 	// it because those are expected.
 	if l.oneshot != nil && event.ID == l.oneshot.id && event.Status == eventDie {
-		log.Infof(ctx, "Docker event was: the oneshot container terminated")
+		log.Dev.Infof(ctx, "Docker event was: the oneshot container terminated")
 		return true
 	}
 
@@ -587,7 +587,7 @@ func (l *DockerCluster) processEvent(ctx context.Context, event events.Message)
 		}
 	}
 
-	log.Infof(ctx, "received docker event for unrecognized container: %+v",
+	log.Dev.Infof(ctx, "received docker event for unrecognized container: %+v",
 		event)
 
 	// An event on any other container is unexpected. Die.
@@ -604,7 +604,7 @@ func (l *DockerCluster) processEvent(ctx context.Context, event events.Message)
 		}); err == nil {
 			defer rc.Close()
 			if _, err := io.Copy(os.Stderr, rc); err != nil {
-				log.Infof(ctx, "error listing logs: %s", err)
+				log.Dev.Infof(ctx, "error listing logs: %s", err)
 			}
 		}
 	}
@@ -615,8 +615,8 @@ func (l *DockerCluster) monitor(ctx context.Context, monitorDone chan struct{})
 	defer close(monitorDone)
 
 	if log.V(1) {
-		log.Infof(ctx, "events monitor starts")
-		defer log.Infof(ctx, "events monitor exits")
+		log.Dev.Infof(ctx, "events monitor starts")
+		defer log.Dev.Infof(ctx, "events monitor exits")
 	}
 	longPoll := func() bool {
 		// If our context was canceled, it's time to go home.
@@ -632,10 +632,10 @@ func (l *DockerCluster) monitor(ctx context.Context, monitorDone chan struct{})
 		for {
 			select {
 			case <-l.monitorCtx.Done():
-				log.Infof(ctx, "monitor shutting down")
+				log.Dev.Infof(ctx, "monitor shutting down")
 				return false
 			case err := <-errq:
-				log.Infof(ctx, "event stream done, resetting...: %s", err)
+				log.Dev.Infof(ctx, "event stream done, resetting...: %s", err)
 				// Sometimes we get a random string-wrapped EOF error back.
 				// Hard to assert on, so we just let this goroutine spin.
 				return true
@@ -666,10 +666,10 @@ func (l *DockerCluster) Start(ctx context.Context) {
 
 	l.createNetwork(ctx)
 	l.initCluster(ctx)
-	log.Infof(ctx, "creating node certs (%dbit) in: %s", keyLen, certsDir)
+	log.Dev.Infof(ctx, "creating node certs (%dbit) in: %s", keyLen, certsDir)
 	l.createNodeCerts()
 
-	log.Infof(ctx, "starting %d nodes", len(l.Nodes))
+	log.Dev.Infof(ctx, "starting %d nodes", len(l.Nodes))
 	l.monitorCtx, l.monitorCtxCancelFunc = context.WithCancel(context.Background())
 	l.monitorDone = make(chan struct{})
 	go l.monitor(ctx, l.monitorDone)
@@ -730,7 +730,7 @@ func (l *DockerCluster) Assert(ctx context.Context, t testing.TB) {
 		t.Fatalf("unexpected extra event %v (after %v)", cur, events)
 	}
 	if log.V(2) {
-		log.Infof(ctx, "asserted %v", events)
+		log.Dev.Infof(ctx, "asserted %v", events)
 	}
 }
 
@@ -744,11 +744,11 @@ func (l *DockerCluster) AssertAndStop(ctx context.Context, t testing.TB) {
 // stop stops the cluster.
 func (l *DockerCluster) stop(ctx context.Context) {
 	if *waitOnStop {
-		log.Infof(ctx, "waiting for interrupt")
+		log.Dev.Infof(ctx, "waiting for interrupt")
 		<-l.stopper.ShouldQuiesce()
 	}
 
-	log.Infof(ctx, "stopping")
+	log.Dev.Infof(ctx, "stopping")
 
 	l.mu.Lock()
 	defer l.mu.Unlock()
@@ -778,9 +778,9 @@ func (l *DockerCluster) stop(ctx context.Context) {
 			defer w.Close()
 			maybePanic(n.Logs(ctx, w))
 		}()
-		log.Infof(ctx, "node %d: stderr at %s", i, file)
+		log.Dev.Infof(ctx, "node %d: stderr at %s", i, file)
 		if crashed {
-			log.Infof(ctx, "~~~ node %d CRASHED ~~~~", i)
+			log.Dev.Infof(ctx, "~~~ node %d CRASHED ~~~~", i)
 		}
 		maybePanic(n.Remove(ctx))
 		n.Container = nil
@@ -925,7 +925,7 @@ func (l *DockerCluster) Cleanup(ctx context.Context, preserveLogs bool) {
 	}
 	for _, v := range volumes {
 		if preserveLogs && v.Name() == "logs" {
-			log.Infof(ctx, "preserving log directory: %s", l.volumesDir)
+			log.Dev.Infof(ctx, "preserving log directory: %s", l.volumesDir)
 			continue
 		}
 		if err := os.RemoveAll(filepath.Join(l.volumesDir, v.Name())); err != nil {

pkg/acceptance/localcluster/cluster.go

@@ -197,13 +197,13 @@ func (c *Cluster) Start(ctx context.Context) {
 		}
 	}
 
-	log.Infof(context.Background(), "started %.3fs", timeutil.Since(c.started).Seconds())
+	log.Dev.Infof(context.Background(), "started %.3fs", timeutil.Since(c.started).Seconds())
 
 	if c.Cfg.NumNodes > 1 || !c.Cfg.NoWait {
 		c.waitForFullReplication()
 	} else {
 		// NB: This is useful for TestRapidRestarts.
-		log.Infof(ctx, "not waiting for initial replication")
+		log.Dev.Infof(ctx, "not waiting for initial replication")
 	}
 }
 
@@ -314,15 +314,15 @@ func (c *Cluster) waitForFullReplication() {
 		done, detail := c.isReplicated()
 		if (done && i >= 50) || (i%50) == 0 {
 			fmt.Print(detail)
-			log.Infof(context.Background(), "waiting for replication")
+			log.Dev.Infof(context.Background(), "waiting for replication")
 		}
 		if done {
 			break
 		}
 		time.Sleep(100 * time.Millisecond)
 	}
 
-	log.Infof(context.Background(), "replicated %.3fs", timeutil.Since(c.started).Seconds())
+	log.Dev.Infof(context.Background(), "replicated %.3fs", timeutil.Since(c.started).Seconds())
 }
 
 func (c *Cluster) isReplicated() (bool, string) {
@@ -572,7 +572,7 @@ func (n *Node) startAsyncInnerLocked(ctx context.Context, joins ...string) error
 		return errors.Wrapf(err, "running %s %v", n.cmd.Path, n.cmd.Args)
 	}
 
-	log.Infof(ctx, "process %d starting: %s", n.cmd.Process.Pid, n.cmd.Args)
+	log.Dev.Infof(ctx, "process %d starting: %s", n.cmd.Process.Pid, n.cmd.Args)
 
 	go func(cmd *exec.Cmd) {
 		waitErr := cmd.Wait()
@@ -586,7 +586,7 @@ func (n *Node) startAsyncInnerLocked(ctx context.Context, joins ...string) error
 			log.Warningf(ctx, "%v", err)
 		}
 
-		log.Infof(ctx, "process %d: %s", cmd.Process.Pid, cmd.ProcessState)
+		log.Dev.Infof(ctx, "process %d: %s", cmd.Process.Pid, cmd.ProcessState)
 
 		var execErr *exec.ExitError
 		_ = errors.As(waitErr, &execErr)
@@ -701,20 +701,20 @@ func (n *Node) waitUntilLive(dur time.Duration) error {
 		}
 		n.Unlock()
 		if pid == 0 {
-			log.Info(ctx, "process already quit")
+			log.Dev.Info(ctx, "process already quit")
 			return nil
 		}
 
 		urlBytes, err := os.ReadFile(n.listeningURLFile())
 		if err != nil {
-			log.Infof(ctx, "%v", err)
+			log.Dev.Infof(ctx, "%v", err)
 			continue
 		}
 
 		var pgURL *url.URL
 		_, pgURL, err = portFromURL(string(urlBytes))
 		if err != nil {
-			log.Infof(ctx, "%v", err)
+			log.Dev.Infof(ctx, "%v", err)
 			continue
 		}
 
@@ -750,12 +750,12 @@ func (n *Node) waitUntilLive(dur time.Duration) error {
 		if err := n.db.QueryRow(
 			`SELECT value FROM crdb_internal.node_runtime_info WHERE component='UI' AND field = 'URL'`,
 		).Scan(&uiStr); err != nil {
-			log.Infof(ctx, "%v", err)
+			log.Dev.Infof(ctx, "%v", err)
 		} else if _, uiURL, err = portFromURL(uiStr); err != nil {
-			log.Infof(ctx, "%v", err)
+			log.Dev.Infof(ctx, "%v", err)
 			// TODO(tschottdorf): see above.
 		}
-		log.Infof(ctx, "process %d started (db: %s ui: %s)", pid, pgURL, uiURL)
+		log.Dev.Infof(ctx, "process %d started (db: %s ui: %s)", pid, pgURL, uiURL)
 		return nil
 	}
 	return errors.Errorf("node %+v was unable to join cluster within %s", n.Cfg, dur)

pkg/acceptance/util_cluster.go

@@ -100,7 +100,7 @@ func StartCluster(ctx context.Context, t *testing.T, cfg cluster.TestConfig) (c
 		// We actually start zero-node clusters in the reference tests. For one-node
 		// clusters, no replication is possible, so we can also skip this step.
 		if wantedReplicas > 1 {
-			log.Infof(ctx, "waiting for first range to have %d replicas", wantedReplicas)
+			log.Dev.Infof(ctx, "waiting for first range to have %d replicas", wantedReplicas)
 
 			testutils.SucceedsSoon(t, func() error {
 				select {
@@ -131,7 +131,7 @@ func StartCluster(ctx context.Context, t *testing.T, cfg cluster.TestConfig) (c
 						t.Fatalf("unable to scan for length of replicas array: %s", err)
 					}
 					if log.V(1) {
-						log.Infof(ctx, "found %d replicas", foundReplicas)
+						log.Dev.Infof(ctx, "found %d replicas", foundReplicas)
 					}
 				} else {
 					return errors.Errorf("no ranges listed")

pkg/acceptance/util_docker.go

@@ -146,20 +146,20 @@ func testDocker(
 			// Otherwise, the directory removal will cause the cluster nodes
 			// to crash and report abnormal termination, even when the test
 			// succeeds otherwise.
-			log.Infof(ctx, "cleaning up docker volume")
+			log.Dev.Infof(ctx, "cleaning up docker volume")
 			l.Cleanup(ctx, preserveLogs)
 		}()
 
 		if len(l.Nodes) > 0 {
 			containerConfig.Env = append(containerConfig.Env, "PGHOST="+l.Hostname(0))
 		}
 
-		log.Infof(ctx, "starting one-shot container")
+		log.Dev.Infof(ctx, "starting one-shot container")
 		err = l.OneShot(
 			ctx, acceptanceImage, types.ImagePullOptions{}, containerConfig, hostConfig,
 			platforms.DefaultSpec(), "docker-"+name,
 		)
-		log.Infof(ctx, "one-shot container terminated: %v", err)
+		log.Dev.Infof(ctx, "one-shot container terminated: %v", err)
 		preserveLogs = err != nil
 	})
 	return err
@@ -233,7 +233,7 @@ func runTestDockerCLI(t *testing.T, testNameSuffix, testFilePath string) {
 	testFile := filepath.Base(testFilePath)
 	testPath := filepath.Join(containerPath, testFile)
 	t.Run(testFile, func(t *testing.T) {
-		log.Infof(ctx, "-- starting tests from: %s", testFile)
+		log.Dev.Infof(ctx, "-- starting tests from: %s", testFile)
 
 		// Symlink the logs directory to /logs, which is visible outside of the
 		// container and preserved if the test fails. (They don't write to /logs

pkg/backup/backup_job.go

@@ -796,7 +796,7 @@ func (b *backupResumer) Resume(ctx context.Context, execCtx interface{}) error {
 			// If we made decent progress with the BACKUP, reset the last
 			// progress state.
 			if madeProgress := curProgress - lastProgress; madeProgress >= 0.01 {
-				log.Infof(ctx, "backport made %d%% progress, resetting retry duration", int(math.Round(float64(100*madeProgress))))
+				log.Dev.Infof(ctx, "backport made %d%% progress, resetting retry duration", int(math.Round(float64(100*madeProgress))))
 				lastProgress = curProgress
 				r.Reset()
 			}
@@ -1364,7 +1364,7 @@ func maybeRelocateJobExecution(
 			return err
 		}
 		if ok, missedTier := current.Locality.Matches(locality); !ok {
-			log.Infof(ctx,
+			log.Dev.Infof(ctx,
 				"%s job %d initially adopted on instance %d but it does not match locality filter %s, finding a new coordinator",
 				jobDesc, jobID, current.NodeID, missedTier.String(),
 			)