chore: add standard test logger ignoring db canceled (#15556)

Refactors our use of `slogtest` to instantiate a "standard logger" across most of our tests.  This standard logger incorporates https://github.com/coder/slog/pull/217 to also ignore database query canceled errors by default, which are a source of low-severity flakes.

Any test that has set non-default `slogtest.Options` is left alone. In particular, `coderdtest` defaults to ignoring all errors. We might consider revisiting that decision now that we have better tools to target the really common flaky Error logs on shutdown.

agent/agent_test.go

@@ -1508,7 +1508,7 @@ func TestAgent_Lifecycle(t *testing.T) {
 
 	t.Run("ShutdownScriptOnce", func(t *testing.T) {
 		t.Parallel()
-		logger := slogtest.Make(t, nil).Leveled(slog.LevelDebug)
+		logger := testutil.Logger(t)
 		expected := "this-is-shutdown"
 		derpMap, _ := tailnettest.RunDERPAndSTUN(t)
 
@@ -1863,7 +1863,7 @@ func TestAgent_Dial(t *testing.T) {
 func TestAgent_UpdatedDERP(t *testing.T) {
 	t.Parallel()
 
-	logger := slogtest.Make(t, nil).Leveled(slog.LevelDebug)
+	logger := testutil.Logger(t)
 
 	originalDerpMap, _ := tailnettest.RunDERPAndSTUN(t)
 	require.NotNil(t, originalDerpMap)
@@ -2019,7 +2019,7 @@ func TestAgent_Speedtest(t *testing.T) {
 
 func TestAgent_Reconnect(t *testing.T) {
 	t.Parallel()
-	logger := slogtest.Make(t, nil).Leveled(slog.LevelDebug)
+	logger := testutil.Logger(t)
 	// After the agent is disconnected from a coordinator, it's supposed
 	// to reconnect!
 	coordinator := tailnet.NewCoordinator(logger)
@@ -2060,7 +2060,7 @@ func TestAgent_Reconnect(t *testing.T) {
 
 func TestAgent_WriteVSCodeConfigs(t *testing.T) {
 	t.Parallel()
-	logger := slogtest.Make(t, nil).Leveled(slog.LevelDebug)
+	logger := testutil.Logger(t)
 	coordinator := tailnet.NewCoordinator(logger)
 	defer coordinator.Close()
 

agent/agentscripts/agentscripts_test.go

@@ -14,7 +14,6 @@ import (
 	"github.com/stretchr/testify/require"
 	"go.uber.org/goleak"
 
-	"cdr.dev/slog/sloggers/slogtest"
 	"github.com/coder/coder/v2/agent/agentscripts"
 	"github.com/coder/coder/v2/agent/agentssh"
 	"github.com/coder/coder/v2/agent/agenttest"
@@ -35,7 +34,7 @@ func TestExecuteBasic(t *testing.T) {
 		return fLogger
 	})
 	defer runner.Close()
-	aAPI := agenttest.NewFakeAgentAPI(t, slogtest.Make(t, nil), nil, nil)
+	aAPI := agenttest.NewFakeAgentAPI(t, testutil.Logger(t), nil, nil)
 	err := runner.Init([]codersdk.WorkspaceAgentScript{{
 		LogSourceID: uuid.New(),
 		Script:      "echo hello",
@@ -61,7 +60,7 @@ func TestEnv(t *testing.T) {
 			cmd.exe /c echo %CODER_SCRIPT_BIN_DIR%
 		`
 	}
-	aAPI := agenttest.NewFakeAgentAPI(t, slogtest.Make(t, nil), nil, nil)
+	aAPI := agenttest.NewFakeAgentAPI(t, testutil.Logger(t), nil, nil)
 	err := runner.Init([]codersdk.WorkspaceAgentScript{{
 		LogSourceID: id,
 		Script:      script,
@@ -102,7 +101,7 @@ func TestTimeout(t *testing.T) {
 	t.Parallel()
 	runner := setup(t, nil)
 	defer runner.Close()
-	aAPI := agenttest.NewFakeAgentAPI(t, slogtest.Make(t, nil), nil, nil)
+	aAPI := agenttest.NewFakeAgentAPI(t, testutil.Logger(t), nil, nil)
 	err := runner.Init([]codersdk.WorkspaceAgentScript{{
 		LogSourceID: uuid.New(),
 		Script:      "sleep infinity",
@@ -121,7 +120,7 @@ func TestScriptReportsTiming(t *testing.T) {
 		return fLogger
 	})
 
-	aAPI := agenttest.NewFakeAgentAPI(t, slogtest.Make(t, nil), nil, nil)
+	aAPI := agenttest.NewFakeAgentAPI(t, testutil.Logger(t), nil, nil)
 	err := runner.Init([]codersdk.WorkspaceAgentScript{{
 		DisplayName: "say-hello",
 		LogSourceID: uuid.New(),
@@ -160,7 +159,7 @@ func setup(t *testing.T, getScriptLogger func(logSourceID uuid.UUID) agentscript
 		}
 	}
 	fs := afero.NewMemMapFs()
-	logger := slogtest.Make(t, nil)
+	logger := testutil.Logger(t)
 	s, err := agentssh.NewServer(context.Background(), logger, prometheus.NewRegistry(), fs, nil)
 	require.NoError(t, err)
 	t.Cleanup(func() {

agent/agentssh/agentssh_internal_test.go

@@ -17,8 +17,6 @@ import (
 
 	"github.com/coder/coder/v2/pty"
 	"github.com/coder/coder/v2/testutil"
-
-	"cdr.dev/slog/sloggers/slogtest"
 )
 
 const longScript = `
@@ -36,7 +34,7 @@ func Test_sessionStart_orphan(t *testing.T) {
 
 	ctx, cancel := context.WithTimeout(context.Background(), testutil.WaitMedium)
 	defer cancel()
-	logger := slogtest.Make(t, nil)
+	logger := testutil.Logger(t)
 	s, err := NewServer(ctx, logger, prometheus.NewRegistry(), afero.NewMemMapFs(), nil)
 	require.NoError(t, err)
 	defer s.Close()

agent/agentssh/agentssh_test.go

@@ -35,7 +35,7 @@ func TestNewServer_ServeClient(t *testing.T) {
 	t.Parallel()
 
 	ctx := context.Background()
-	logger := slogtest.Make(t, nil)
+	logger := testutil.Logger(t)
 	s, err := agentssh.NewServer(ctx, logger, prometheus.NewRegistry(), afero.NewMemMapFs(), nil)
 	require.NoError(t, err)
 	defer s.Close()
@@ -76,7 +76,7 @@ func TestNewServer_ExecuteShebang(t *testing.T) {
 	}
 
 	ctx := context.Background()
-	logger := slogtest.Make(t, nil)
+	logger := testutil.Logger(t)
 	s, err := agentssh.NewServer(ctx, logger, prometheus.NewRegistry(), afero.NewMemMapFs(), nil)
 	require.NoError(t, err)
 	t.Cleanup(func() {
@@ -158,7 +158,7 @@ func TestNewServer_Signal(t *testing.T) {
 		t.Parallel()
 
 		ctx := context.Background()
-		logger := slogtest.Make(t, nil)
+		logger := testutil.Logger(t)
 		s, err := agentssh.NewServer(ctx, logger, prometheus.NewRegistry(), afero.NewMemMapFs(), nil)
 		require.NoError(t, err)
 		defer s.Close()
@@ -223,7 +223,7 @@ func TestNewServer_Signal(t *testing.T) {
 		t.Parallel()
 
 		ctx := context.Background()
-		logger := slogtest.Make(t, nil)
+		logger := testutil.Logger(t)
 		s, err := agentssh.NewServer(ctx, logger, prometheus.NewRegistry(), afero.NewMemMapFs(), nil)
 		require.NoError(t, err)
 		defer s.Close()

agent/agentssh/x11_test.go

@@ -21,8 +21,6 @@ import (
 	"github.com/stretchr/testify/require"
 	gossh "golang.org/x/crypto/ssh"
 
-	"cdr.dev/slog"
-	"cdr.dev/slog/sloggers/slogtest"
 	"github.com/coder/coder/v2/agent/agentssh"
 	"github.com/coder/coder/v2/testutil"
 )
@@ -34,7 +32,7 @@ func TestServer_X11(t *testing.T) {
 	}
 
 	ctx := context.Background()
-	logger := slogtest.Make(t, nil).Leveled(slog.LevelDebug)
+	logger := testutil.Logger(t)
 	fs := afero.NewOsFs()
 	s, err := agentssh.NewServer(ctx, logger, prometheus.NewRegistry(), fs, &agentssh.Config{})
 	require.NoError(t, err)

agent/agenttest/agent.go

@@ -7,10 +7,9 @@ import (
 
 	"github.com/stretchr/testify/assert"
 
-	"cdr.dev/slog"
-	"cdr.dev/slog/sloggers/slogtest"
 	"github.com/coder/coder/v2/agent"
 	"github.com/coder/coder/v2/codersdk/agentsdk"
+	"github.com/coder/coder/v2/testutil"
 )
 
 // New starts a new agent for use in tests.
@@ -24,7 +23,7 @@ func New(t testing.TB, coderURL *url.URL, agentToken string, opts ...func(*agent
 	t.Helper()
 
 	var o agent.Options
-	log := slogtest.Make(t, nil).Leveled(slog.LevelDebug).Named("agent")
+	log := testutil.Logger(t).Named("agent")
 	o.Logger = log
 
 	for _, opt := range opts {

agent/apphealth_test.go

@@ -12,8 +12,6 @@ import (
 	"github.com/google/uuid"
 	"github.com/stretchr/testify/require"
 
-	"cdr.dev/slog"
-	"cdr.dev/slog/sloggers/slogtest"
 	"github.com/coder/coder/v2/agent"
 	"github.com/coder/coder/v2/agent/agenttest"
 	"github.com/coder/coder/v2/agent/proto"
@@ -258,10 +256,10 @@ func setupAppReporter(
 	// We use a proper fake agent API so we can test the conversion code and the
 	// request code as well. Before we were bypassing these by using a custom
 	// post function.
-	fakeAAPI := agenttest.NewFakeAgentAPI(t, slogtest.Make(t, nil), nil, nil)
+	fakeAAPI := agenttest.NewFakeAgentAPI(t, testutil.Logger(t), nil, nil)
 
 	go agent.NewAppHealthReporterWithClock(
-		slogtest.Make(t, nil).Leveled(slog.LevelDebug),
+		testutil.Logger(t),
 		apps, agentsdk.AppHealthPoster(fakeAAPI), clk,
 	)(ctx)
 

agent/checkpoint_internal_test.go

@@ -12,7 +12,7 @@ import (
 
 func TestCheckpoint_CompleteWait(t *testing.T) {
 	t.Parallel()
-	logger := slogtest.Make(t, nil)
+	logger := testutil.Logger(t)
 	ctx := testutil.Context(t, testutil.WaitShort)
 	uut := newCheckpoint(logger)
 	err := xerrors.New("test")
@@ -35,7 +35,7 @@ func TestCheckpoint_CompleteTwice(t *testing.T) {
 
 func TestCheckpoint_WaitComplete(t *testing.T) {
 	t.Parallel()
-	logger := slogtest.Make(t, nil)
+	logger := testutil.Logger(t)
 	ctx := testutil.Context(t, testutil.WaitShort)
 	uut := newCheckpoint(logger)
 	err := xerrors.New("test")

agent/stats_internal_test.go

@@ -18,7 +18,6 @@ import (
 
 	"cdr.dev/slog"
 	"cdr.dev/slog/sloggers/slogjson"
-	"cdr.dev/slog/sloggers/slogtest"
 	"github.com/coder/coder/v2/agent/proto"
 	"github.com/coder/coder/v2/testutil"
 )
@@ -26,7 +25,7 @@ import (
 func TestStatsReporter(t *testing.T) {
 	t.Parallel()
 	ctx := testutil.Context(t, testutil.WaitShort)
-	logger := slogtest.Make(t, nil).Leveled(slog.LevelDebug)
+	logger := testutil.Logger(t)
 	fSource := newFakeNetworkStatsSource(ctx, t)
 	fCollector := newFakeCollector(t)
 	fDest := newFakeStatsDest()

cli/server_internal_test.go

@@ -13,8 +13,6 @@ import (
 
 	"cdr.dev/slog"
 	"cdr.dev/slog/sloggers/sloghuman"
-	"cdr.dev/slog/sloggers/slogtest"
-
 	"github.com/coder/coder/v2/codersdk"
 	"github.com/coder/coder/v2/testutil"
 	"github.com/coder/serpent"
@@ -24,7 +22,7 @@ func Test_configureServerTLS(t *testing.T) {
 	t.Parallel()
 	t.Run("DefaultNoInsecureCiphers", func(t *testing.T) {
 		t.Parallel()
-		logger := slogtest.Make(t, nil)
+		logger := testutil.Logger(t)
 		cfg, err := configureServerTLS(context.Background(), logger, "tls12", "none", nil, nil, "", nil, false)
 		require.NoError(t, err)
 
@@ -251,7 +249,7 @@ func TestRedirectHTTPToHTTPSDeprecation(t *testing.T) {
 		t.Run(tc.name, func(t *testing.T) {
 			t.Parallel()
 			ctx := testutil.Context(t, testutil.WaitShort)
-			logger := slogtest.Make(t, nil)
+			logger := testutil.Logger(t)
 			flags := pflag.NewFlagSet("test", pflag.ContinueOnError)
 			_ = flags.Bool("tls-redirect-http-to-https", true, "")
 			err := flags.Parse(tc.flags)

cli/server_test.go

@@ -38,8 +38,6 @@ import (
 	"tailscale.com/derp/derphttp"
 	"tailscale.com/types/key"
 
-	"cdr.dev/slog/sloggers/slogtest"
-
 	"github.com/coder/coder/v2/cli"
 	"github.com/coder/coder/v2/cli/clitest"
 	"github.com/coder/coder/v2/cli/config"
@@ -1833,7 +1831,7 @@ func TestConnectToPostgres(t *testing.T) {
 	ctx, cancel := context.WithTimeout(context.Background(), testutil.WaitShort)
 	t.Cleanup(cancel)
 
-	log := slogtest.Make(t, nil)
+	log := testutil.Logger(t)
 
 	dbURL, err := dbtestutil.Open(t)
 	require.NoError(t, err)

cli/speedtest_test.go

@@ -9,8 +9,6 @@ import (
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 
-	"cdr.dev/slog"
-	"cdr.dev/slog/sloggers/slogtest"
 	"github.com/coder/coder/v2/agent/agenttest"
 	"github.com/coder/coder/v2/cli"
 	"github.com/coder/coder/v2/cli/clitest"
@@ -52,7 +50,7 @@ func TestSpeedtest(t *testing.T) {
 	ctx, cancel = context.WithTimeout(context.Background(), testutil.WaitLong)
 	defer cancel()
 
-	inv.Logger = slogtest.Make(t, nil).Named("speedtest").Leveled(slog.LevelDebug)
+	inv.Logger = testutil.Logger(t).Named("speedtest")
 	cmdDone := tGo(t, func() {
 		err := inv.WithContext(ctx).Run()
 		assert.NoError(t, err)
@@ -90,7 +88,7 @@ func TestSpeedtestJson(t *testing.T) {
 	ctx, cancel = context.WithTimeout(context.Background(), testutil.WaitLong)
 	defer cancel()
 
-	inv.Logger = slogtest.Make(t, nil).Named("speedtest").Leveled(slog.LevelDebug)
+	inv.Logger = testutil.Logger(t).Named("speedtest")
 	cmdDone := tGo(t, func() {
 		err := inv.WithContext(ctx).Run()
 		assert.NoError(t, err)

cli/ssh_internal_test.go

@@ -70,7 +70,7 @@ func TestBuildWorkspaceLink(t *testing.T) {
 func TestCloserStack_Mainline(t *testing.T) {
 	t.Parallel()
 	ctx := testutil.Context(t, testutil.WaitShort)
-	logger := slogtest.Make(t, nil).Leveled(slog.LevelDebug)
+	logger := testutil.Logger(t)
 	uut := newCloserStack(ctx, logger, quartz.NewMock(t))
 	closes := new([]*fakeCloser)
 	fc0 := &fakeCloser{closes: closes}
@@ -90,7 +90,7 @@ func TestCloserStack_Mainline(t *testing.T) {
 func TestCloserStack_Empty(t *testing.T) {
 	t.Parallel()
 	ctx := testutil.Context(t, testutil.WaitShort)
-	logger := slogtest.Make(t, nil).Leveled(slog.LevelDebug)
+	logger := testutil.Logger(t)
 	uut := newCloserStack(ctx, logger, quartz.NewMock(t))
 
 	closed := make(chan struct{})
@@ -106,7 +106,7 @@ func TestCloserStack_Context(t *testing.T) {
 	ctx := testutil.Context(t, testutil.WaitShort)
 	ctx, cancel := context.WithCancel(ctx)
 	defer cancel()
-	logger := slogtest.Make(t, nil).Leveled(slog.LevelDebug)
+	logger := testutil.Logger(t)
 	uut := newCloserStack(ctx, logger, quartz.NewMock(t))
 	closes := new([]*fakeCloser)
 	fc0 := &fakeCloser{closes: closes}

cli/ssh_test.go

@@ -30,9 +30,6 @@ import (
 	"golang.org/x/sync/errgroup"
 	"golang.org/x/xerrors"
 
-	"cdr.dev/slog"
-	"cdr.dev/slog/sloggers/slogtest"
-
 	"github.com/coder/coder/v2/agent"
 	"github.com/coder/coder/v2/agent/agentssh"
 	"github.com/coder/coder/v2/agent/agenttest"
@@ -57,7 +54,7 @@ func setupWorkspaceForAgent(t *testing.T, mutations ...func([]*proto.Agent) []*p
 	t.Helper()
 
 	client, store := coderdtest.NewWithDatabase(t, nil)
-	client.SetLogger(slogtest.Make(t, nil).Named("client").Leveled(slog.LevelDebug))
+	client.SetLogger(testutil.Logger(t).Named("client"))
 	first := coderdtest.CreateFirstUser(t, client)
 	userClient, user := coderdtest.CreateAnotherUser(t, client, first.OrganizationID)
 	r := dbfake.WorkspaceBuild(t, store, database.WorkspaceTable{
@@ -257,7 +254,7 @@ func TestSSH(t *testing.T) {
 
 		store, ps := dbtestutil.NewDB(t)
 		client := coderdtest.New(t, &coderdtest.Options{Pubsub: ps, Database: store})
-		client.SetLogger(slogtest.Make(t, nil).Named("client").Leveled(slog.LevelDebug))
+		client.SetLogger(testutil.Logger(t).Named("client"))
 		first := coderdtest.CreateFirstUser(t, client)
 		userClient, user := coderdtest.CreateAnotherUser(t, client, first.OrganizationID)
 		r := dbfake.WorkspaceBuild(t, store, database.WorkspaceTable{
@@ -760,7 +757,7 @@ func TestSSH(t *testing.T) {
 
 		store, ps := dbtestutil.NewDB(t)
 		client := coderdtest.New(t, &coderdtest.Options{Pubsub: ps, Database: store})
-		client.SetLogger(slogtest.Make(t, nil).Named("client").Leveled(slog.LevelDebug))
+		client.SetLogger(testutil.Logger(t).Named("client"))
 		first := coderdtest.CreateFirstUser(t, client)
 		userClient, user := coderdtest.CreateAnotherUser(t, client, first.OrganizationID)
 		r := dbfake.WorkspaceBuild(t, store, database.WorkspaceTable{
@@ -1367,7 +1364,7 @@ func TestSSH(t *testing.T) {
 					DeploymentValues: dv,
 					StatsBatcher:     batcher,
 				})
-				admin.SetLogger(slogtest.Make(t, nil).Named("client").Leveled(slog.LevelDebug))
+				admin.SetLogger(testutil.Logger(t).Named("client"))
 				first := coderdtest.CreateFirstUser(t, admin)
 				client, user := coderdtest.CreateAnotherUser(t, admin, first.OrganizationID)
 				r := dbfake.WorkspaceBuild(t, store, database.WorkspaceTable{

cli/vscodessh_test.go

@@ -9,9 +9,6 @@ import (
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 
-	"cdr.dev/slog"
-	"cdr.dev/slog/sloggers/slogtest"
-
 	"github.com/coder/coder/v2/agent/agenttest"
 	agentproto "github.com/coder/coder/v2/agent/proto"
 	"github.com/coder/coder/v2/cli/clitest"
@@ -38,7 +35,7 @@ func TestVSCodeSSH(t *testing.T) {
 		DeploymentValues: dv,
 		StatsBatcher:     batcher,
 	})
-	admin.SetLogger(slogtest.Make(t, nil).Named("client").Leveled(slog.LevelDebug))
+	admin.SetLogger(testutil.Logger(t).Named("client"))
 	first := coderdtest.CreateFirstUser(t, admin)
 	client, user := coderdtest.CreateAnotherUser(t, admin, first.OrganizationID)
 	r := dbfake.WorkspaceBuild(t, store, database.WorkspaceTable{

coderd/activitybump_test.go

@@ -8,7 +8,6 @@ import (
 	"github.com/google/uuid"
 	"github.com/stretchr/testify/require"
 
-	"cdr.dev/slog/sloggers/slogtest"
 	"github.com/coder/coder/v2/agent/agenttest"
 	"github.com/coder/coder/v2/coderd/coderdtest"
 	"github.com/coder/coder/v2/coderd/database"
@@ -203,7 +202,7 @@ func TestWorkspaceActivityBump(t *testing.T) {
 		resources := coderdtest.AwaitWorkspaceAgents(t, client, workspace.ID)
 		conn, err := workspacesdk.New(client).
 			DialAgent(ctx, resources[0].Agents[0].ID, &workspacesdk.DialAgentOptions{
-				Logger: slogtest.Make(t, nil),
+				Logger: testutil.Logger(t),
 			})
 		require.NoError(t, err)
 		defer conn.Close()
@@ -241,7 +240,7 @@ func TestWorkspaceActivityBump(t *testing.T) {
 		resources := coderdtest.AwaitWorkspaceAgents(t, client, workspace.ID)
 		conn, err := workspacesdk.New(client).
 			DialAgent(ctx, resources[0].Agents[0].ID, &workspacesdk.DialAgentOptions{
-				Logger: slogtest.Make(t, nil),
+				Logger: testutil.Logger(t),
 			})
 		require.NoError(t, err)
 		defer conn.Close()

coderd/agentapi/apps_test.go

@@ -8,13 +8,12 @@ import (
 	"github.com/stretchr/testify/require"
 	"go.uber.org/mock/gomock"
 
-	"cdr.dev/slog/sloggers/slogtest"
-
 	agentproto "github.com/coder/coder/v2/agent/proto"
 	"github.com/coder/coder/v2/coderd/agentapi"
 	"github.com/coder/coder/v2/coderd/database"
 	"github.com/coder/coder/v2/coderd/database/dbmock"
 	"github.com/coder/coder/v2/coderd/wspubsub"
+	"github.com/coder/coder/v2/testutil"
 )
 
 func TestBatchUpdateAppHealths(t *testing.T) {
@@ -62,7 +61,7 @@ func TestBatchUpdateAppHealths(t *testing.T) {
 				return agent, nil
 			},
 			Database: dbM,
-			Log:      slogtest.Make(t, nil),
+			Log:      testutil.Logger(t),
 			PublishWorkspaceUpdateFn: func(ctx context.Context, wa *database.WorkspaceAgent, kind wspubsub.WorkspaceEventKind) error {
 				publishCalled = true
 				return nil
@@ -100,7 +99,7 @@ func TestBatchUpdateAppHealths(t *testing.T) {
 				return agent, nil
 			},
 			Database: dbM,
-			Log:      slogtest.Make(t, nil),
+			Log:      testutil.Logger(t),
 			PublishWorkspaceUpdateFn: func(ctx context.Context, wa *database.WorkspaceAgent, kind wspubsub.WorkspaceEventKind) error {
 				publishCalled = true
 				return nil
@@ -139,7 +138,7 @@ func TestBatchUpdateAppHealths(t *testing.T) {
 				return agent, nil
 			},
 			Database: dbM,
-			Log:      slogtest.Make(t, nil),
+			Log:      testutil.Logger(t),
 			PublishWorkspaceUpdateFn: func(ctx context.Context, wa *database.WorkspaceAgent, kind wspubsub.WorkspaceEventKind) error {
 				publishCalled = true
 				return nil
@@ -174,7 +173,7 @@ func TestBatchUpdateAppHealths(t *testing.T) {
 				return agent, nil
 			},
 			Database:                 dbM,
-			Log:                      slogtest.Make(t, nil),
+			Log:                      testutil.Logger(t),
 			PublishWorkspaceUpdateFn: nil,
 		}
 
@@ -203,7 +202,7 @@ func TestBatchUpdateAppHealths(t *testing.T) {
 				return agent, nil
 			},
 			Database:                 dbM,
-			Log:                      slogtest.Make(t, nil),
+			Log:                      testutil.Logger(t),
 			PublishWorkspaceUpdateFn: nil,
 		}
 
@@ -233,7 +232,7 @@ func TestBatchUpdateAppHealths(t *testing.T) {
 				return agent, nil
 			},
 			Database:                 dbM,
-			Log:                      slogtest.Make(t, nil),
+			Log:                      testutil.Logger(t),
 			PublishWorkspaceUpdateFn: nil,
 		}
 

coderd/agentapi/lifecycle_test.go

@@ -13,13 +13,13 @@ import (
 	"go.uber.org/mock/gomock"
 	"google.golang.org/protobuf/types/known/timestamppb"
 
-	"cdr.dev/slog/sloggers/slogtest"
 	agentproto "github.com/coder/coder/v2/agent/proto"
 	"github.com/coder/coder/v2/coderd/agentapi"
 	"github.com/coder/coder/v2/coderd/database"
 	"github.com/coder/coder/v2/coderd/database/dbmock"
 	"github.com/coder/coder/v2/coderd/database/dbtime"
 	"github.com/coder/coder/v2/coderd/wspubsub"
+	"github.com/coder/coder/v2/testutil"
 )
 
 func TestUpdateLifecycle(t *testing.T) {
@@ -72,7 +72,7 @@ func TestUpdateLifecycle(t *testing.T) {
 			},
 			WorkspaceID: workspaceID,
 			Database:    dbM,
-			Log:         slogtest.Make(t, nil),
+			Log:         testutil.Logger(t),
 			PublishWorkspaceUpdateFn: func(ctx context.Context, agent *database.WorkspaceAgent, kind wspubsub.WorkspaceEventKind) error {
 				publishCalled = true
 				return nil
@@ -112,7 +112,7 @@ func TestUpdateLifecycle(t *testing.T) {
 			},
 			WorkspaceID: workspaceID,
 			Database:    dbM,
-			Log:         slogtest.Make(t, nil),
+			Log:         testutil.Logger(t),
 			// Test that nil publish fn works.
 			PublishWorkspaceUpdateFn: nil,
 		}
@@ -155,7 +155,7 @@ func TestUpdateLifecycle(t *testing.T) {
 			},
 			WorkspaceID: workspaceID,
 			Database:    dbM,
-			Log:         slogtest.Make(t, nil),
+			Log:         testutil.Logger(t),
 			PublishWorkspaceUpdateFn: func(ctx context.Context, agent *database.WorkspaceAgent, kind wspubsub.WorkspaceEventKind) error {
 				publishCalled = true
 				return nil
@@ -201,7 +201,7 @@ func TestUpdateLifecycle(t *testing.T) {
 			},
 			WorkspaceID:              workspaceID,
 			Database:                 dbM,
-			Log:                      slogtest.Make(t, nil),
+			Log:                      testutil.Logger(t),
 			PublishWorkspaceUpdateFn: nil,
 			TimeNowFn: func() time.Time {
 				return now
@@ -234,7 +234,7 @@ func TestUpdateLifecycle(t *testing.T) {
 			},
 			WorkspaceID: workspaceID,
 			Database:    dbM,
-			Log:         slogtest.Make(t, nil),
+			Log:         testutil.Logger(t),
 			PublishWorkspaceUpdateFn: func(ctx context.Context, agent *database.WorkspaceAgent, kind wspubsub.WorkspaceEventKind) error {
 				atomic.AddInt64(&publishCalled, 1)
 				return nil
@@ -307,7 +307,7 @@ func TestUpdateLifecycle(t *testing.T) {
 			},
 			WorkspaceID: workspaceID,
 			Database:    dbM,
-			Log:         slogtest.Make(t, nil),
+			Log:         testutil.Logger(t),
 			PublishWorkspaceUpdateFn: func(ctx context.Context, agent *database.WorkspaceAgent, kind wspubsub.WorkspaceEventKind) error {
 				publishCalled = true
 				return nil
@@ -345,7 +345,7 @@ func TestUpdateStartup(t *testing.T) {
 			},
 			WorkspaceID: workspaceID,
 			Database:    dbM,
-			Log:         slogtest.Make(t, nil),
+			Log:         testutil.Logger(t),
 			// Not used by UpdateStartup.
 			PublishWorkspaceUpdateFn: nil,
 		}
@@ -391,7 +391,7 @@ func TestUpdateStartup(t *testing.T) {
 			},
 			WorkspaceID: workspaceID,
 			Database:    dbM,
-			Log:         slogtest.Make(t, nil),
+			Log:         testutil.Logger(t),
 			// Not used by UpdateStartup.
 			PublishWorkspaceUpdateFn: nil,
 		}
@@ -422,7 +422,7 @@ func TestUpdateStartup(t *testing.T) {
 			},
 			WorkspaceID: workspaceID,
 			Database:    dbM,
-			Log:         slogtest.Make(t, nil),
+			Log:         testutil.Logger(t),
 			// Not used by UpdateStartup.
 			PublishWorkspaceUpdateFn: nil,
 		}

coderd/agentapi/logs_test.go

@@ -13,7 +13,6 @@ import (
 	"go.uber.org/mock/gomock"
 	"google.golang.org/protobuf/types/known/timestamppb"
 
-	"cdr.dev/slog/sloggers/slogtest"
 	agentproto "github.com/coder/coder/v2/agent/proto"
 	"github.com/coder/coder/v2/coderd/agentapi"
 	"github.com/coder/coder/v2/coderd/database"
@@ -21,6 +20,7 @@ import (
 	"github.com/coder/coder/v2/coderd/database/dbtime"
 	"github.com/coder/coder/v2/coderd/wspubsub"
 	"github.com/coder/coder/v2/codersdk/agentsdk"
+	"github.com/coder/coder/v2/testutil"
 )
 
 func TestBatchCreateLogs(t *testing.T) {
@@ -50,7 +50,7 @@ func TestBatchCreateLogs(t *testing.T) {
 				return agent, nil
 			},
 			Database: dbM,
-			Log:      slogtest.Make(t, nil),
+			Log:      testutil.Logger(t),
 			PublishWorkspaceUpdateFn: func(ctx context.Context, wa *database.WorkspaceAgent, kind wspubsub.WorkspaceEventKind) error {
 				publishWorkspaceUpdateCalled = true
 				return nil
@@ -154,7 +154,7 @@ func TestBatchCreateLogs(t *testing.T) {
 				return agentWithLogs, nil
 			},
 			Database: dbM,
-			Log:      slogtest.Make(t, nil),
+			Log:      testutil.Logger(t),
 			PublishWorkspaceUpdateFn: func(ctx context.Context, wa *database.WorkspaceAgent, kind wspubsub.WorkspaceEventKind) error {
 				publishWorkspaceUpdateCalled = true
 				return nil
@@ -202,7 +202,7 @@ func TestBatchCreateLogs(t *testing.T) {
 				return overflowedAgent, nil
 			},
 			Database: dbM,
-			Log:      slogtest.Make(t, nil),
+			Log:      testutil.Logger(t),
 			PublishWorkspaceUpdateFn: func(ctx context.Context, wa *database.WorkspaceAgent, kind wspubsub.WorkspaceEventKind) error {
 				publishWorkspaceUpdateCalled = true
 				return nil
@@ -233,7 +233,7 @@ func TestBatchCreateLogs(t *testing.T) {
 				return agent, nil
 			},
 			Database: dbM,
-			Log:      slogtest.Make(t, nil),
+			Log:      testutil.Logger(t),
 			// Test that they are ignored when nil.
 			PublishWorkspaceUpdateFn:          nil,
 			PublishWorkspaceAgentLogsUpdateFn: nil,
@@ -295,7 +295,7 @@ func TestBatchCreateLogs(t *testing.T) {
 					return agent, nil
 				},
 				Database: dbM,
-				Log:      slogtest.Make(t, nil),
+				Log:      testutil.Logger(t),
 				PublishWorkspaceUpdateFn: func(ctx context.Context, wa *database.WorkspaceAgent, kind wspubsub.WorkspaceEventKind) error {
 					publishWorkspaceUpdateCalled = true
 					return nil
@@ -339,7 +339,7 @@ func TestBatchCreateLogs(t *testing.T) {
 					return agent, nil
 				},
 				Database: dbM,
-				Log:      slogtest.Make(t, nil),
+				Log:      testutil.Logger(t),
 				PublishWorkspaceUpdateFn: func(ctx context.Context, wa *database.WorkspaceAgent, kind wspubsub.WorkspaceEventKind) error {
 					publishWorkspaceUpdateCalled = true
 					return nil
@@ -386,7 +386,7 @@ func TestBatchCreateLogs(t *testing.T) {
 				return agent, nil
 			},
 			Database: dbM,
-			Log:      slogtest.Make(t, nil),
+			Log:      testutil.Logger(t),
 			PublishWorkspaceUpdateFn: func(ctx context.Context, wa *database.WorkspaceAgent, kind wspubsub.WorkspaceEventKind) error {
 				publishWorkspaceUpdateCalled = true
 				return nil

coderd/agentapi/metadata_test.go

@@ -12,14 +12,13 @@ import (
 	"go.uber.org/mock/gomock"
 	"google.golang.org/protobuf/types/known/timestamppb"
 
-	"cdr.dev/slog/sloggers/slogtest"
-
 	agentproto "github.com/coder/coder/v2/agent/proto"
 	"github.com/coder/coder/v2/coderd/agentapi"
 	"github.com/coder/coder/v2/coderd/database"
 	"github.com/coder/coder/v2/coderd/database/dbmock"
 	"github.com/coder/coder/v2/coderd/database/dbtime"
 	"github.com/coder/coder/v2/coderd/database/pubsub"
+	"github.com/coder/coder/v2/testutil"
 )
 
 type fakePublisher struct {
@@ -87,7 +86,7 @@ func TestBatchUpdateMetadata(t *testing.T) {
 			},
 			Database: dbM,
 			Pubsub:   pub,
-			Log:      slogtest.Make(t, nil),
+			Log:      testutil.Logger(t),
 			TimeNowFn: func() time.Time {
 				return now
 			},
@@ -172,7 +171,7 @@ func TestBatchUpdateMetadata(t *testing.T) {
 			},
 			Database: dbM,
 			Pubsub:   pub,
-			Log:      slogtest.Make(t, nil),
+			Log:      testutil.Logger(t),
 			TimeNowFn: func() time.Time {
 				return now
 			},
@@ -241,7 +240,7 @@ func TestBatchUpdateMetadata(t *testing.T) {
 			},
 			Database: dbM,
 			Pubsub:   pub,
-			Log:      slogtest.Make(t, nil),
+			Log:      testutil.Logger(t),
 			TimeNowFn: func() time.Time {
 				return now
 			},

coderd/coderd_test.go

@@ -19,8 +19,6 @@ import (
 	"go.uber.org/goleak"
 	"tailscale.com/tailcfg"
 
-	"cdr.dev/slog"
-	"cdr.dev/slog/sloggers/slogtest"
 	"github.com/coder/coder/v2/coderd/database"
 	"github.com/coder/coder/v2/coderd/database/dbfake"
 	"github.com/coder/coder/v2/codersdk/workspacesdk"
@@ -62,7 +60,7 @@ func TestDERP(t *testing.T) {
 	ctx := testutil.Context(t, testutil.WaitMedium)
 	client := coderdtest.New(t, nil)
 
-	logger := slogtest.Make(t, nil).Leveled(slog.LevelDebug)
+	logger := testutil.Logger(t)
 
 	derpPort, err := strconv.Atoi(client.URL.Port())
 	require.NoError(t, err)
@@ -217,7 +215,7 @@ func TestDERPForceWebSockets(t *testing.T) {
 	resources := coderdtest.AwaitWorkspaceAgents(t, client, workspace.ID)
 	conn, err := wsclient.DialAgent(ctx, resources[0].Agents[0].ID,
 		&workspacesdk.DialAgentOptions{
-			Logger: slogtest.Make(t, nil).Leveled(slog.LevelDebug).Named("client"),
+			Logger: testutil.Logger(t).Named("client"),
 		},
 	)
 	require.NoError(t, err)

coderd/cryptokeys/cache_test.go

@@ -11,8 +11,6 @@ import (
 	"github.com/stretchr/testify/require"
 	"go.uber.org/goleak"
 
-	"cdr.dev/slog/sloggers/slogtest"
-
 	"github.com/coder/coder/v2/coderd/cryptokeys"
 	"github.com/coder/coder/v2/codersdk"
 	"github.com/coder/coder/v2/testutil"
@@ -33,7 +31,7 @@ func TestCryptoKeyCache(t *testing.T) {
 			t.Parallel()
 			var (
 				ctx    = testutil.Context(t, testutil.WaitShort)
-				logger = slogtest.Make(t, nil)
+				logger = testutil.Logger(t)
 				clock  = quartz.NewMock(t)
 			)
 
@@ -63,7 +61,7 @@ func TestCryptoKeyCache(t *testing.T) {
 			t.Parallel()
 			var (
 				ctx    = testutil.Context(t, testutil.WaitShort)
-				logger = slogtest.Make(t, nil)
+				logger = testutil.Logger(t)
 				clock  = quartz.NewMock(t)
 			)
 
@@ -103,7 +101,7 @@ func TestCryptoKeyCache(t *testing.T) {
 
 			var (
 				ctx    = testutil.Context(t, testutil.WaitShort)
-				logger = slogtest.Make(t, nil)
+				logger = testutil.Logger(t)
 				clock  = quartz.NewMock(t)
 			)
 			now := clock.Now().UTC()
@@ -143,7 +141,7 @@ func TestCryptoKeyCache(t *testing.T) {
 
 			var (
 				ctx    = testutil.Context(t, testutil.WaitShort)
-				logger = slogtest.Make(t, nil)
+				logger = testutil.Logger(t)
 			)
 
 			ff := &fakeFetcher{
@@ -166,7 +164,7 @@ func TestCryptoKeyCache(t *testing.T) {
 
 			var (
 				ctx    = testutil.Context(t, testutil.WaitShort)
-				logger = slogtest.Make(t, nil)
+				logger = testutil.Logger(t)
 				clock  = quartz.NewMock(t)
 			)
 
@@ -202,7 +200,7 @@ func TestCryptoKeyCache(t *testing.T) {
 			t.Parallel()
 			var (
 				ctx    = testutil.Context(t, testutil.WaitShort)
-				logger = slogtest.Make(t, nil)
+				logger = testutil.Logger(t)
 				clock  = quartz.NewMock(t)
 			)
 
@@ -238,7 +236,7 @@ func TestCryptoKeyCache(t *testing.T) {
 
 			var (
 				ctx    = testutil.Context(t, testutil.WaitShort)
-				logger = slogtest.Make(t, nil)
+				logger = testutil.Logger(t)
 				clock  = quartz.NewMock(t)
 			)
 
@@ -270,7 +268,7 @@ func TestCryptoKeyCache(t *testing.T) {
 
 			var (
 				ctx    = testutil.Context(t, testutil.WaitShort)
-				logger = slogtest.Make(t, nil)
+				logger = testutil.Logger(t)
 				clock  = quartz.NewMock(t)
 			)
 
@@ -302,7 +300,7 @@ func TestCryptoKeyCache(t *testing.T) {
 
 			var (
 				ctx    = testutil.Context(t, testutil.WaitShort)
-				logger = slogtest.Make(t, nil)
+				logger = testutil.Logger(t)
 				clock  = quartz.NewMock(t)
 			)
 
@@ -323,7 +321,7 @@ func TestCryptoKeyCache(t *testing.T) {
 
 		var (
 			ctx    = testutil.Context(t, testutil.WaitShort)
-			logger = slogtest.Make(t, nil)
+			logger = testutil.Logger(t)
 			clock  = quartz.NewMock(t)
 		)
 
@@ -386,7 +384,7 @@ func TestCryptoKeyCache(t *testing.T) {
 
 		var (
 			ctx    = testutil.Context(t, testutil.WaitShort)
-			logger = slogtest.Make(t, nil)
+			logger = testutil.Logger(t)
 			clock  = quartz.NewMock(t)
 		)
 
@@ -442,7 +440,7 @@ func TestCryptoKeyCache(t *testing.T) {
 
 		var (
 			ctx    = testutil.Context(t, testutil.WaitShort)
-			logger = slogtest.Make(t, nil)
+			logger = testutil.Logger(t)
 			clock  = quartz.NewMock(t)
 		)
 

coderd/cryptokeys/rotate_internal_test.go

@@ -8,8 +8,6 @@ import (
 
 	"github.com/stretchr/testify/require"
 
-	"cdr.dev/slog"
-	"cdr.dev/slog/sloggers/slogtest"
 	"github.com/coder/coder/v2/coderd/database"
 	"github.com/coder/coder/v2/coderd/database/dbgen"
 	"github.com/coder/coder/v2/coderd/database/dbtestutil"
@@ -28,7 +26,7 @@ func Test_rotateKeys(t *testing.T) {
 			db, _       = dbtestutil.NewDB(t)
 			clock       = quartz.NewMock(t)
 			keyDuration = time.Hour * 24 * 7
-			logger      = slogtest.Make(t, nil).Leveled(slog.LevelDebug)
+			logger      = testutil.Logger(t)
 			ctx         = testutil.Context(t, testutil.WaitShort)
 		)
 
@@ -113,7 +111,7 @@ func Test_rotateKeys(t *testing.T) {
 			db, _       = dbtestutil.NewDB(t)
 			clock       = quartz.NewMock(t)
 			keyDuration = time.Hour * 24 * 7
-			logger      = slogtest.Make(t, nil).Leveled(slog.LevelDebug)
+			logger      = testutil.Logger(t)
 			ctx         = testutil.Context(t, testutil.WaitShort)
 		)
 
@@ -169,7 +167,7 @@ func Test_rotateKeys(t *testing.T) {
 			db, _       = dbtestutil.NewDB(t)
 			clock       = quartz.NewMock(t)
 			keyDuration = time.Hour * 24 * 7
-			logger      = slogtest.Make(t, nil).Leveled(slog.LevelDebug)
+			logger      = testutil.Logger(t)
 			ctx         = testutil.Context(t, testutil.WaitShort)
 		)
 
@@ -222,7 +220,7 @@ func Test_rotateKeys(t *testing.T) {
 			db, _       = dbtestutil.NewDB(t)
 			clock       = quartz.NewMock(t)
 			keyDuration = time.Hour * 24 * 7
-			logger      = slogtest.Make(t, nil).Leveled(slog.LevelDebug)
+			logger      = testutil.Logger(t)
 			ctx         = testutil.Context(t, testutil.WaitShort)
 		)
 
@@ -271,7 +269,7 @@ func Test_rotateKeys(t *testing.T) {
 			db, _       = dbtestutil.NewDB(t)
 			clock       = quartz.NewMock(t)
 			keyDuration = time.Hour * 24 * 7
-			logger      = slogtest.Make(t, nil).Leveled(slog.LevelDebug)
+			logger      = testutil.Logger(t)
 			ctx         = testutil.Context(t, testutil.WaitShort)
 		)
 
@@ -302,7 +300,7 @@ func Test_rotateKeys(t *testing.T) {
 			db, _       = dbtestutil.NewDB(t)
 			clock       = quartz.NewMock(t)
 			keyDuration = time.Hour * 24 * 7
-			logger      = slogtest.Make(t, nil).Leveled(slog.LevelDebug)
+			logger      = testutil.Logger(t)
 			ctx         = testutil.Context(t, testutil.WaitShort)
 		)
 
@@ -351,7 +349,7 @@ func Test_rotateKeys(t *testing.T) {
 			db, _       = dbtestutil.NewDB(t)
 			clock       = quartz.NewMock(t)
 			keyDuration = time.Hour * 24 * 30
-			logger      = slogtest.Make(t, nil).Leveled(slog.LevelDebug)
+			logger      = testutil.Logger(t)
 			ctx         = testutil.Context(t, testutil.WaitShort)
 		)
 
@@ -449,7 +447,7 @@ func Test_rotateKeys(t *testing.T) {
 			db, _       = dbtestutil.NewDB(t)
 			clock       = quartz.NewMock(t)
 			keyDuration = time.Hour * 24 * 7
-			logger      = slogtest.Make(t, nil).Leveled(slog.LevelDebug)
+			logger      = testutil.Logger(t)
 			ctx         = testutil.Context(t, testutil.WaitShort)
 		)
 
@@ -472,7 +470,7 @@ func Test_rotateKeys(t *testing.T) {
 			db, _       = dbtestutil.NewDB(t)
 			clock       = quartz.NewMock(t)
 			keyDuration = time.Hour * 24 * 5
-			logger      = slogtest.Make(t, nil).Leveled(slog.LevelDebug)
+			logger      = testutil.Logger(t)
 			ctx         = testutil.Context(t, testutil.WaitShort)
 		)
 
@@ -518,7 +516,7 @@ func Test_rotateKeys(t *testing.T) {
 			db, _       = dbtestutil.NewDB(t)
 			clock       = quartz.NewMock(t)
 			keyDuration = time.Hour * 24 * 3
-			logger      = slogtest.Make(t, nil).Leveled(slog.LevelDebug)
+			logger      = testutil.Logger(t)
 			ctx         = testutil.Context(t, testutil.WaitShort)
 		)
 

coderd/cryptokeys/rotate_test.go

@@ -6,9 +6,6 @@ import (
 
 	"github.com/stretchr/testify/require"
 
-	"cdr.dev/slog"
-	"cdr.dev/slog/sloggers/slogtest"
-
 	"github.com/coder/coder/v2/coderd/cryptokeys"
 	"github.com/coder/coder/v2/coderd/database"
 	"github.com/coder/coder/v2/coderd/database/dbgen"
@@ -26,7 +23,7 @@ func TestRotator(t *testing.T) {
 		var (
 			db, _  = dbtestutil.NewDB(t)
 			clock  = quartz.NewMock(t)
-			logger = slogtest.Make(t, nil).Leveled(slog.LevelDebug)
+			logger = testutil.Logger(t)
 			ctx    = testutil.Context(t, testutil.WaitShort)
 		)
 
@@ -50,7 +47,7 @@ func TestRotator(t *testing.T) {
 		var (
 			db, _  = dbtestutil.NewDB(t)
 			clock  = quartz.NewMock(t)
-			logger = slogtest.Make(t, nil).Leveled(slog.LevelDebug)
+			logger = testutil.Logger(t)
 			ctx    = testutil.Context(t, testutil.WaitShort)
 		)
 

coderd/database/awsiamrds/awsiamrds_test.go

@@ -7,8 +7,6 @@ import (
 
 	"github.com/stretchr/testify/require"
 
-	"cdr.dev/slog"
-	"cdr.dev/slog/sloggers/slogtest"
 	"github.com/coder/coder/v2/cli"
 	"github.com/coder/coder/v2/coderd/database/awsiamrds"
 	"github.com/coder/coder/v2/coderd/database/pubsub"
@@ -27,14 +25,14 @@ func TestDriver(t *testing.T) {
 		t.Skip()
 	}
 
-	logger := slogtest.Make(t, nil).Leveled(slog.LevelDebug)
+	logger := testutil.Logger(t)
 	ctx, cancel := context.WithTimeout(context.Background(), testutil.WaitShort)
 	defer cancel()
 
 	sqlDriver, err := awsiamrds.Register(ctx, "postgres")
 	require.NoError(t, err)
 
-	db, err := cli.ConnectToPostgres(ctx, slogtest.Make(t, nil), sqlDriver, url)
+	db, err := cli.ConnectToPostgres(ctx, testutil.Logger(t), sqlDriver, url)
 	require.NoError(t, err)
 	defer func() {
 		_ = db.Close()

coderd/database/dbmetrics/dbmetrics_test.go

@@ -10,11 +10,11 @@ import (
 
 	"cdr.dev/slog"
 	"cdr.dev/slog/sloggers/sloghuman"
-	"cdr.dev/slog/sloggers/slogtest"
 	"github.com/coder/coder/v2/coderd/coderdtest/promhelp"
 	"github.com/coder/coder/v2/coderd/database"
 	"github.com/coder/coder/v2/coderd/database/dbmem"
 	"github.com/coder/coder/v2/coderd/database/dbmetrics"
+	"github.com/coder/coder/v2/testutil"
 )
 
 func TestInTxMetrics(t *testing.T) {
@@ -31,7 +31,7 @@ func TestInTxMetrics(t *testing.T) {
 
 		db := dbmem.New()
 		reg := prometheus.NewRegistry()
-		db = dbmetrics.NewQueryMetrics(db, slogtest.Make(t, nil), reg)
+		db = dbmetrics.NewQueryMetrics(db, testutil.Logger(t), reg)
 
 		err := db.InTx(func(s database.Store) error {
 			return nil
@@ -49,7 +49,7 @@ func TestInTxMetrics(t *testing.T) {
 
 		db := dbmem.New()
 		reg := prometheus.NewRegistry()
-		db = dbmetrics.NewDBMetrics(db, slogtest.Make(t, nil), reg)
+		db = dbmetrics.NewDBMetrics(db, testutil.Logger(t), reg)
 
 		err := db.InTx(func(s database.Store) error {
 			return nil

coderd/database/dbpurge/dbpurge_test.go

@@ -47,7 +47,7 @@ func TestPurge(t *testing.T) {
 	// We want to make sure dbpurge is actually started so that this test is meaningful.
 	clk := quartz.NewMock(t)
 	done := awaitDoTick(ctx, t, clk)
-	purger := dbpurge.New(context.Background(), slogtest.Make(t, nil), dbmem.New(), clk)
+	purger := dbpurge.New(context.Background(), testutil.Logger(t), dbmem.New(), clk)
 	<-done // wait for doTick() to run.
 	require.NoError(t, purger.Close())
 }

coderd/database/dbrollup/dbrollup_test.go

@@ -28,7 +28,7 @@ func TestMain(m *testing.M) {
 
 func TestRollup_Close(t *testing.T) {
 	t.Parallel()
-	rolluper := dbrollup.New(slogtest.Make(t, nil), dbmem.New(), dbrollup.WithInterval(250*time.Millisecond))
+	rolluper := dbrollup.New(testutil.Logger(t), dbmem.New(), dbrollup.WithInterval(250*time.Millisecond))
 	err := rolluper.Close()
 	require.NoError(t, err)
 }
@@ -57,7 +57,7 @@ func TestRollup_TwoInstancesUseLocking(t *testing.T) {
 	}
 
 	db, ps := dbtestutil.NewDB(t, dbtestutil.WithDumpOnFailure())
-	logger := slogtest.Make(t, &slogtest.Options{IgnoreErrors: false}).Leveled(slog.LevelDebug)
+	logger := testutil.Logger(t)
 
 	var (
 		org   = dbgen.Organization(t, db, database.Organization{})

coderd/database/dbtestutil/db.go

@@ -19,10 +19,10 @@ import (
 	"golang.org/x/xerrors"
 
 	"cdr.dev/slog"
-	"cdr.dev/slog/sloggers/slogtest"
 	"github.com/coder/coder/v2/coderd/database"
 	"github.com/coder/coder/v2/coderd/database/dbmem"
 	"github.com/coder/coder/v2/coderd/database/pubsub"
+	"github.com/coder/coder/v2/testutil"
 )
 
 // WillUsePostgres returns true if a call to NewDB() will return a real, postgres-backed Store and Pubsub.
@@ -90,7 +90,7 @@ func NewDBWithSQLDB(t testing.TB, opts ...Option) (database.Store, pubsub.Pubsub
 func NewDB(t testing.TB, opts ...Option) (database.Store, pubsub.Pubsub) {
 	t.Helper()
 
-	o := options{logger: slogtest.Make(t, nil).Named("pubsub").Leveled(slog.LevelDebug)}
+	o := options{logger: testutil.Logger(t).Named("pubsub")}
 	for _, opt := range opts {
 		opt(&o)
 	}

coderd/database/pubsub/pubsub_internal_test.go

@@ -10,8 +10,6 @@ import (
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 
-	"cdr.dev/slog"
-	"cdr.dev/slog/sloggers/slogtest"
 	"github.com/coder/coder/v2/testutil"
 )
 
@@ -147,7 +145,7 @@ func Test_msgQueue_Full(t *testing.T) {
 func TestPubSub_DoesntBlockNotify(t *testing.T) {
 	t.Parallel()
 	ctx := testutil.Context(t, testutil.WaitShort)
-	logger := slogtest.Make(t, nil).Leveled(slog.LevelDebug)
+	logger := testutil.Logger(t)
 
 	uut := newWithoutListener(logger, nil)
 	fListener := newFakePqListener()
@@ -183,7 +181,7 @@ func TestPubSub_DoesntBlockNotify(t *testing.T) {
 func TestPubSub_DoesntRaceListenUnlisten(t *testing.T) {
 	t.Parallel()
 	ctx := testutil.Context(t, testutil.WaitShort)
-	logger := slogtest.Make(t, nil).Leveled(slog.LevelDebug)
+	logger := testutil.Logger(t)
 
 	uut := newWithoutListener(logger, nil)
 	fListener := newFakePqListener()

coderd/database/pubsub/pubsub_linux_test.go

@@ -38,7 +38,7 @@ func TestPubsub(t *testing.T) {
 	t.Run("Postgres", func(t *testing.T) {
 		ctx, cancelFunc := context.WithCancel(context.Background())
 		defer cancelFunc()
-		logger := slogtest.Make(t, nil).Leveled(slog.LevelDebug)
+		logger := testutil.Logger(t)
 
 		connectionURL, err := dbtestutil.Open(t)
 		require.NoError(t, err)
@@ -67,7 +67,7 @@ func TestPubsub(t *testing.T) {
 	t.Run("PostgresCloseCancel", func(t *testing.T) {
 		ctx, cancelFunc := context.WithCancel(context.Background())
 		defer cancelFunc()
-		logger := slogtest.Make(t, nil).Leveled(slog.LevelDebug)
+		logger := testutil.Logger(t)
 		connectionURL, err := dbtestutil.Open(t)
 		require.NoError(t, err)
 		db, err := sql.Open("postgres", connectionURL)
@@ -82,7 +82,7 @@ func TestPubsub(t *testing.T) {
 	t.Run("NotClosedOnCancelContext", func(t *testing.T) {
 		ctx, cancel := context.WithCancel(context.Background())
 		defer cancel()
-		logger := slogtest.Make(t, nil).Leveled(slog.LevelDebug)
+		logger := testutil.Logger(t)
 		connectionURL, err := dbtestutil.Open(t)
 		require.NoError(t, err)
 		db, err := sql.Open("postgres", connectionURL)
@@ -117,7 +117,7 @@ func TestPubsub_ordering(t *testing.T) {
 
 	ctx, cancelFunc := context.WithCancel(context.Background())
 	defer cancelFunc()
-	logger := slogtest.Make(t, nil).Leveled(slog.LevelDebug)
+	logger := testutil.Logger(t)
 
 	connectionURL, err := dbtestutil.Open(t)
 	require.NoError(t, err)
@@ -300,7 +300,7 @@ func TestMeasureLatency(t *testing.T) {
 
 	newPubsub := func() (pubsub.Pubsub, func()) {
 		ctx, cancel := context.WithCancel(context.Background())
-		logger := slogtest.Make(t, nil).Leveled(slog.LevelDebug)
+		logger := testutil.Logger(t)
 		connectionURL, err := dbtestutil.Open(t)
 		require.NoError(t, err)
 		db, err := sql.Open("postgres", connectionURL)
@@ -318,7 +318,7 @@ func TestMeasureLatency(t *testing.T) {
 	t.Run("MeasureLatency", func(t *testing.T) {
 		t.Parallel()
 
-		logger := slogtest.Make(t, nil).Leveled(slog.LevelDebug)
+		logger := testutil.Logger(t)
 		ps, done := newPubsub()
 		defer done()
 
@@ -334,7 +334,7 @@ func TestMeasureLatency(t *testing.T) {
 	t.Run("MeasureLatencyRecvTimeout", func(t *testing.T) {
 		t.Parallel()
 
-		logger := slogtest.Make(t, nil).Leveled(slog.LevelDebug)
+		logger := testutil.Logger(t)
 		ctrl := gomock.NewController(t)
 		ps := psmock.NewMockPubsub(ctrl)
 

coderd/database/pubsub/pubsub_test.go

@@ -23,7 +23,7 @@ func TestPGPubsub_Metrics(t *testing.T) {
 		t.Skip("test only with postgres")
 	}
 
-	logger := slogtest.Make(t, nil).Leveled(slog.LevelDebug)
+	logger := testutil.Logger(t)
 	connectionURL, err := dbtestutil.Open(t)
 	require.NoError(t, err)
 	db, err := sql.Open("postgres", connectionURL)

coderd/devtunnel/tunnel_test.go

@@ -16,12 +16,9 @@ import (
 	"testing"
 	"time"
 
-	"cdr.dev/slog"
-
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 
-	"cdr.dev/slog/sloggers/slogtest"
 	"github.com/coder/coder/v2/coderd/devtunnel"
 	"github.com/coder/coder/v2/testutil"
 	"github.com/coder/wgtunnel/tunneld"
@@ -76,7 +73,7 @@ func TestTunnel(t *testing.T) {
 			tunServer := newTunnelServer(t)
 			cfg := tunServer.config(t, c.version)
 
-			tun, err := devtunnel.NewWithConfig(ctx, slogtest.Make(t, nil).Leveled(slog.LevelDebug), cfg)
+			tun, err := devtunnel.NewWithConfig(ctx, testutil.Logger(t), cfg)
 			require.NoError(t, err)
 			require.Len(t, tun.OtherURLs, 1)
 			t.Log(tun.URL, tun.OtherURLs[0])

coderd/httpmw/recover_test.go

@@ -7,9 +7,9 @@ import (
 
 	"github.com/stretchr/testify/require"
 
-	"cdr.dev/slog/sloggers/slogtest"
 	"github.com/coder/coder/v2/coderd/httpmw"
 	"github.com/coder/coder/v2/coderd/tracing"
+	"github.com/coder/coder/v2/testutil"
 )
 
 func TestRecover(t *testing.T) {
@@ -58,7 +58,7 @@ func TestRecover(t *testing.T) {
 			t.Parallel()
 
 			var (
-				log = slogtest.Make(t, nil)
+				log = testutil.Logger(t)
 				r   = httptest.NewRequest("GET", "/", nil)
 				w   = &tracing.StatusWriter{
 					ResponseWriter: httptest.NewRecorder(),

coderd/insights_test.go

@@ -46,7 +46,7 @@ func TestDeploymentInsights(t *testing.T) {
 	require.NoError(t, err)
 
 	db, ps := dbtestutil.NewDB(t, dbtestutil.WithDumpOnFailure())
-	logger := slogtest.Make(t, &slogtest.Options{IgnoreErrors: false}).Leveled(slog.LevelDebug)
+	logger := testutil.Logger(t)
 	rollupEvents := make(chan dbrollup.Event)
 	client := coderdtest.New(t, &coderdtest.Options{
 		Database:                  db,
@@ -87,7 +87,7 @@ func TestDeploymentInsights(t *testing.T) {
 
 	conn, err := workspacesdk.New(client).
 		DialAgent(ctx, resources[0].Agents[0].ID, &workspacesdk.DialAgentOptions{
-			Logger: slogtest.Make(t, nil).Named("dialagent"),
+			Logger: testutil.Logger(t).Named("dialagent"),
 		})
 	require.NoError(t, err)
 	defer conn.Close()
@@ -127,7 +127,7 @@ func TestUserActivityInsights_SanityCheck(t *testing.T) {
 	t.Parallel()
 
 	db, ps := dbtestutil.NewDB(t)
-	logger := slogtest.Make(t, &slogtest.Options{IgnoreErrors: false}).Leveled(slog.LevelDebug)
+	logger := testutil.Logger(t)
 	client := coderdtest.New(t, &coderdtest.Options{
 		Database:                  db,
 		Pubsub:                    ps,
@@ -502,7 +502,7 @@ func TestTemplateInsights_Golden(t *testing.T) {
 	}
 
 	prepare := func(t *testing.T, templates []*testTemplate, users []*testUser, testData map[*testWorkspace]testDataGen) (*codersdk.Client, chan dbrollup.Event) {
-		logger := slogtest.Make(t, &slogtest.Options{IgnoreErrors: false}).Leveled(slog.LevelDebug)
+		logger := testutil.Logger(t)
 		db, ps := dbtestutil.NewDB(t)
 		events := make(chan dbrollup.Event)
 		client := coderdtest.New(t, &coderdtest.Options{
@@ -1421,7 +1421,7 @@ func TestUserActivityInsights_Golden(t *testing.T) {
 	}
 
 	prepare := func(t *testing.T, templates []*testTemplate, users []*testUser, testData map[*testWorkspace]testDataGen) (*codersdk.Client, chan dbrollup.Event) {
-		logger := slogtest.Make(t, &slogtest.Options{IgnoreErrors: false}).Leveled(slog.LevelDebug)
+		logger := testutil.Logger(t)
 		db, ps := dbtestutil.NewDB(t)
 		events := make(chan dbrollup.Event)
 		client := coderdtest.New(t, &coderdtest.Options{

coderd/jwtutils/jwt_test.go

@@ -11,8 +11,6 @@ import (
 	"github.com/google/uuid"
 	"github.com/stretchr/testify/require"
 
-	"cdr.dev/slog/sloggers/slogtest"
-
 	"github.com/coder/coder/v2/coderd/cryptokeys"
 	"github.com/coder/coder/v2/coderd/database"
 	"github.com/coder/coder/v2/coderd/database/dbgen"
@@ -239,7 +237,7 @@ func TestJWS(t *testing.T) {
 				Feature:  database.CryptoKeyFeatureOIDCConvert,
 				StartsAt: time.Now(),
 			})
-			log     = slogtest.Make(t, nil)
+			log     = testutil.Logger(t)
 			fetcher = &cryptokeys.DBFetcher{DB: db}
 		)
 
@@ -329,7 +327,7 @@ func TestJWE(t *testing.T) {
 				Feature:  database.CryptoKeyFeatureWorkspaceAppsAPIKey,
 				StartsAt: time.Now(),
 			})
-			log = slogtest.Make(t, nil)
+			log = testutil.Logger(t)
 
 			fetcher = &cryptokeys.DBFetcher{DB: db}
 		)

coderd/metricscache/metricscache_test.go

@@ -10,7 +10,6 @@ import (
 	"github.com/google/uuid"
 	"github.com/stretchr/testify/require"
 
-	"cdr.dev/slog/sloggers/slogtest"
 	"github.com/coder/coder/v2/coderd/database"
 	"github.com/coder/coder/v2/coderd/database/dbgen"
 	"github.com/coder/coder/v2/coderd/database/dbmem"
@@ -30,7 +29,7 @@ func TestCache_TemplateWorkspaceOwners(t *testing.T) {
 
 	var (
 		db    = dbmem.New()
-		cache = metricscache.New(db, slogtest.Make(t, nil), metricscache.Intervals{
+		cache = metricscache.New(db, testutil.Logger(t), metricscache.Intervals{
 			TemplateBuildTimes: testutil.IntervalFast,
 		}, false)
 	)
@@ -181,7 +180,7 @@ func TestCache_BuildTime(t *testing.T) {
 
 			var (
 				db    = dbmem.New()
-				cache = metricscache.New(db, slogtest.Make(t, nil), metricscache.Intervals{
+				cache = metricscache.New(db, testutil.Logger(t), metricscache.Intervals{
 					TemplateBuildTimes: testutil.IntervalFast,
 				}, false)
 			)
@@ -276,7 +275,7 @@ func TestCache_BuildTime(t *testing.T) {
 func TestCache_DeploymentStats(t *testing.T) {
 	t.Parallel()
 	db := dbmem.New()
-	cache := metricscache.New(db, slogtest.Make(t, nil), metricscache.Intervals{
+	cache := metricscache.New(db, testutil.Logger(t), metricscache.Intervals{
 		DeploymentStats: testutil.IntervalFast,
 	}, false)
 	defer cache.Close()

coderd/notifications/manager_test.go

@@ -13,15 +13,13 @@ import (
 	"github.com/stretchr/testify/require"
 	"golang.org/x/xerrors"
 
-	"cdr.dev/slog"
-	"cdr.dev/slog/sloggers/slogtest"
-	"github.com/coder/coder/v2/coderd/database/dbtestutil"
 	"github.com/coder/quartz"
 	"github.com/coder/serpent"
 
 	"github.com/coder/coder/v2/coderd/database"
 	"github.com/coder/coder/v2/coderd/database/dbauthz"
 	"github.com/coder/coder/v2/coderd/database/dbgen"
+	"github.com/coder/coder/v2/coderd/database/dbtestutil"
 	"github.com/coder/coder/v2/coderd/notifications"
 	"github.com/coder/coder/v2/coderd/notifications/dispatch"
 	"github.com/coder/coder/v2/coderd/notifications/types"
@@ -36,7 +34,7 @@ func TestBufferedUpdates(t *testing.T) {
 	// nolint:gocritic // Unit test.
 	ctx := dbauthz.AsSystemRestricted(testutil.Context(t, testutil.WaitSuperLong))
 	store, _ := dbtestutil.NewDB(t)
-	logger := slogtest.Make(t, nil).Leveled(slog.LevelDebug)
+	logger := testutil.Logger(t)
 
 	interceptor := &syncInterceptor{Store: store}
 	santa := &santaHandler{}
@@ -108,7 +106,7 @@ func TestBuildPayload(t *testing.T) {
 	// nolint:gocritic // Unit test.
 	ctx := dbauthz.AsSystemRestricted(testutil.Context(t, testutil.WaitSuperLong))
 	store, _ := dbtestutil.NewDB(t)
-	logger := slogtest.Make(t, nil).Leveled(slog.LevelDebug)
+	logger := testutil.Logger(t)
 
 	// GIVEN: a set of helpers to be injected into the templates
 	const label = "Click here!"
@@ -166,7 +164,7 @@ func TestStopBeforeRun(t *testing.T) {
 	// nolint:gocritic // Unit test.
 	ctx := dbauthz.AsSystemRestricted(testutil.Context(t, testutil.WaitSuperLong))
 	store, _ := dbtestutil.NewDB(t)
-	logger := slogtest.Make(t, nil).Leveled(slog.LevelDebug)
+	logger := testutil.Logger(t)
 
 	// GIVEN: a standard manager
 	mgr, err := notifications.NewManager(defaultNotificationsConfig(database.NotificationMethodSmtp), store, defaultHelpers(), createMetrics(), logger.Named("notifications-manager"))

coderd/notifications/metrics_test.go

@@ -16,8 +16,6 @@ import (
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 
-	"cdr.dev/slog"
-	"cdr.dev/slog/sloggers/slogtest"
 	"github.com/coder/quartz"
 	"github.com/coder/serpent"
 
@@ -41,7 +39,7 @@ func TestMetrics(t *testing.T) {
 	// nolint:gocritic // Unit test.
 	ctx := dbauthz.AsSystemRestricted(testutil.Context(t, testutil.WaitSuperLong))
 	store, _ := dbtestutil.NewDB(t)
-	logger := slogtest.Make(t, nil).Leveled(slog.LevelDebug)
+	logger := testutil.Logger(t)
 
 	reg := prometheus.NewRegistry()
 	metrics := notifications.NewMetrics(reg)
@@ -215,7 +213,7 @@ func TestPendingUpdatesMetric(t *testing.T) {
 	// nolint:gocritic // Unit test.
 	ctx := dbauthz.AsSystemRestricted(testutil.Context(t, testutil.WaitSuperLong))
 	store, _ := dbtestutil.NewDB(t)
-	logger := slogtest.Make(t, nil).Leveled(slog.LevelDebug)
+	logger := testutil.Logger(t)
 
 	reg := prometheus.NewRegistry()
 	metrics := notifications.NewMetrics(reg)
@@ -306,7 +304,7 @@ func TestInflightDispatchesMetric(t *testing.T) {
 	// nolint:gocritic // Unit test.
 	ctx := dbauthz.AsSystemRestricted(testutil.Context(t, testutil.WaitSuperLong))
 	store, _ := dbtestutil.NewDB(t)
-	logger := slogtest.Make(t, nil).Leveled(slog.LevelDebug)
+	logger := testutil.Logger(t)
 
 	reg := prometheus.NewRegistry()
 	metrics := notifications.NewMetrics(reg)
@@ -385,7 +383,7 @@ func TestCustomMethodMetricCollection(t *testing.T) {
 	// nolint:gocritic // Unit test.
 	ctx := dbauthz.AsSystemRestricted(testutil.Context(t, testutil.WaitSuperLong))
 	store, _ := dbtestutil.NewDB(t)
-	logger := slogtest.Make(t, nil).Leveled(slog.LevelDebug)
+	logger := testutil.Logger(t)
 
 	var (
 		reg             = prometheus.NewRegistry()

coderd/notifications/notifications_test.go

@@ -35,7 +35,6 @@ import (
 	"golang.org/x/xerrors"
 
 	"cdr.dev/slog"
-	"cdr.dev/slog/sloggers/slogtest"
 	"github.com/coder/coder/v2/coderd/coderdtest"
 	"github.com/coder/coder/v2/coderd/database"
 	"github.com/coder/coder/v2/coderd/database/dbauthz"
@@ -73,7 +72,7 @@ func TestBasicNotificationRoundtrip(t *testing.T) {
 	// nolint:gocritic // Unit test.
 	ctx := dbauthz.AsNotifier(testutil.Context(t, testutil.WaitSuperLong))
 	store, _ := dbtestutil.NewDB(t)
-	logger := slogtest.Make(t, nil).Leveled(slog.LevelDebug)
+	logger := testutil.Logger(t)
 	method := database.NotificationMethodSmtp
 
 	// GIVEN: a manager with standard config but a faked dispatch handler
@@ -137,7 +136,7 @@ func TestSMTPDispatch(t *testing.T) {
 	// nolint:gocritic // Unit test.
 	ctx := dbauthz.AsNotifier(testutil.Context(t, testutil.WaitSuperLong))
 	store, _ := dbtestutil.NewDB(t)
-	logger := slogtest.Make(t, nil).Leveled(slog.LevelDebug)
+	logger := testutil.Logger(t)
 
 	// start mock SMTP server
 	mockSMTPSrv := smtpmock.New(smtpmock.ConfigurationAttr{
@@ -199,7 +198,7 @@ func TestWebhookDispatch(t *testing.T) {
 	// nolint:gocritic // Unit test.
 	ctx := dbauthz.AsNotifier(testutil.Context(t, testutil.WaitSuperLong))
 	store, _ := dbtestutil.NewDB(t)
-	logger := slogtest.Make(t, nil).Leveled(slog.LevelDebug)
+	logger := testutil.Logger(t)
 
 	sent := make(chan dispatch.WebhookPayload, 1)
 	// Mock server to simulate webhook endpoint.
@@ -279,7 +278,7 @@ func TestBackpressure(t *testing.T) {
 	}
 
 	store, _ := dbtestutil.NewDB(t)
-	logger := slogtest.Make(t, nil).Leveled(slog.LevelDebug)
+	logger := testutil.Logger(t)
 	// nolint:gocritic // Unit test.
 	ctx := dbauthz.AsNotifier(testutil.Context(t, testutil.WaitShort))
 
@@ -409,7 +408,7 @@ func TestRetries(t *testing.T) {
 	// nolint:gocritic // Unit test.
 	ctx := dbauthz.AsNotifier(testutil.Context(t, testutil.WaitSuperLong))
 	store, _ := dbtestutil.NewDB(t)
-	logger := slogtest.Make(t, nil).Leveled(slog.LevelDebug)
+	logger := testutil.Logger(t)
 
 	// GIVEN: a mock HTTP server which will receive webhooksand a map to track the dispatch attempts
 
@@ -503,7 +502,7 @@ func TestExpiredLeaseIsRequeued(t *testing.T) {
 	// nolint:gocritic // Unit test.
 	ctx := dbauthz.AsNotifier(testutil.Context(t, testutil.WaitSuperLong))
 	store, _ := dbtestutil.NewDB(t)
-	logger := slogtest.Make(t, nil).Leveled(slog.LevelDebug)
+	logger := testutil.Logger(t)
 
 	// GIVEN: a manager which has its updates intercepted and paused until measurements can be taken
 
@@ -602,7 +601,7 @@ func TestInvalidConfig(t *testing.T) {
 	t.Parallel()
 
 	store, _ := dbtestutil.NewDB(t)
-	logger := slogtest.Make(t, nil).Leveled(slog.LevelDebug)
+	logger := testutil.Logger(t)
 
 	// GIVEN: invalid config with dispatch period <= lease period
 	const (
@@ -628,7 +627,7 @@ func TestNotifierPaused(t *testing.T) {
 	// nolint:gocritic // Unit test.
 	ctx := dbauthz.AsNotifier(testutil.Context(t, testutil.WaitSuperLong))
 	store, _ := dbtestutil.NewDB(t)
-	logger := slogtest.Make(t, nil).Leveled(slog.LevelDebug)
+	logger := testutil.Logger(t)
 
 	// Prepare the test.
 	handler := &fakeHandler{}
@@ -1380,7 +1379,7 @@ func TestDisabledBeforeEnqueue(t *testing.T) {
 	// nolint:gocritic // Unit test.
 	ctx := dbauthz.AsNotifier(testutil.Context(t, testutil.WaitSuperLong))
 	store, _ := dbtestutil.NewDB(t)
-	logger := slogtest.Make(t, nil).Leveled(slog.LevelDebug)
+	logger := testutil.Logger(t)
 
 	// GIVEN: an enqueuer & a sample user
 	cfg := defaultNotificationsConfig(database.NotificationMethodSmtp)
@@ -1416,7 +1415,7 @@ func TestDisabledAfterEnqueue(t *testing.T) {
 	// nolint:gocritic // Unit test.
 	ctx := dbauthz.AsNotifier(testutil.Context(t, testutil.WaitSuperLong))
 	store, _ := dbtestutil.NewDB(t)
-	logger := slogtest.Make(t, nil).Leveled(slog.LevelDebug)
+	logger := testutil.Logger(t)
 
 	method := database.NotificationMethodSmtp
 	cfg := defaultNotificationsConfig(method)
@@ -1473,7 +1472,7 @@ func TestCustomNotificationMethod(t *testing.T) {
 	// nolint:gocritic // Unit test.
 	ctx := dbauthz.AsNotifier(testutil.Context(t, testutil.WaitSuperLong))
 	store, _ := dbtestutil.NewDB(t)
-	logger := slogtest.Make(t, nil).Leveled(slog.LevelDebug)
+	logger := testutil.Logger(t)
 
 	received := make(chan uuid.UUID, 1)
 
@@ -1614,7 +1613,7 @@ func TestNotificationDuplicates(t *testing.T) {
 	// nolint:gocritic // Unit test.
 	ctx := dbauthz.AsNotifier(testutil.Context(t, testutil.WaitSuperLong))
 	store, _ := dbtestutil.NewDB(t)
-	logger := slogtest.Make(t, nil).Leveled(slog.LevelDebug)
+	logger := testutil.Logger(t)
 
 	method := database.NotificationMethodSmtp
 	cfg := defaultNotificationsConfig(method)

coderd/prometheusmetrics/prometheusmetrics_test.go

@@ -99,7 +99,7 @@ func TestActiveUsers(t *testing.T) {
 		t.Run(tc.Name, func(t *testing.T) {
 			t.Parallel()
 			registry := prometheus.NewRegistry()
-			closeFunc, err := prometheusmetrics.ActiveUsers(context.Background(), slogtest.Make(t, nil), registry, tc.Database(t), time.Millisecond)
+			closeFunc, err := prometheusmetrics.ActiveUsers(context.Background(), testutil.Logger(t), registry, tc.Database(t), time.Millisecond)
 			require.NoError(t, err)
 			t.Cleanup(closeFunc)
 
@@ -165,7 +165,7 @@ func TestUsers(t *testing.T) {
 			registry := prometheus.NewRegistry()
 			mClock := quartz.NewMock(t)
 			db := tc.Database(t)
-			closeFunc, err := prometheusmetrics.Users(context.Background(), slogtest.Make(t, nil), mClock, registry, db, time.Millisecond)
+			closeFunc, err := prometheusmetrics.Users(context.Background(), testutil.Logger(t), mClock, registry, db, time.Millisecond)
 			require.NoError(t, err)
 			t.Cleanup(closeFunc)
 
@@ -246,7 +246,7 @@ func TestWorkspaceLatestBuildTotals(t *testing.T) {
 		t.Run(tc.Name, func(t *testing.T) {
 			t.Parallel()
 			registry := prometheus.NewRegistry()
-			closeFunc, err := prometheusmetrics.Workspaces(context.Background(), slogtest.Make(t, nil).Leveled(slog.LevelWarn), registry, tc.Database(), testutil.IntervalFast)
+			closeFunc, err := prometheusmetrics.Workspaces(context.Background(), testutil.Logger(t).Leveled(slog.LevelWarn), registry, tc.Database(), testutil.IntervalFast)
 			require.NoError(t, err)
 			t.Cleanup(closeFunc)
 
@@ -320,7 +320,7 @@ func TestWorkspaceLatestBuildStatuses(t *testing.T) {
 		t.Run(tc.Name, func(t *testing.T) {
 			t.Parallel()
 			registry := prometheus.NewRegistry()
-			closeFunc, err := prometheusmetrics.Workspaces(context.Background(), slogtest.Make(t, nil), registry, tc.Database(), testutil.IntervalFast)
+			closeFunc, err := prometheusmetrics.Workspaces(context.Background(), testutil.Logger(t), registry, tc.Database(), testutil.IntervalFast)
 			require.NoError(t, err)
 			t.Cleanup(closeFunc)
 
@@ -413,7 +413,7 @@ func TestAgents(t *testing.T) {
 	derpMapFn := func() *tailcfg.DERPMap {
 		return derpMap
 	}
-	coordinator := tailnet.NewCoordinator(slogtest.Make(t, nil).Leveled(slog.LevelDebug))
+	coordinator := tailnet.NewCoordinator(testutil.Logger(t))
 	coordinatorPtr := atomic.Pointer[tailnet.Coordinator]{}
 	coordinatorPtr.Store(&coordinator)
 	agentInactiveDisconnectTimeout := 1 * time.Hour // don't need to focus on this value in tests
@@ -485,7 +485,7 @@ func TestAgentStats(t *testing.T) {
 	t.Cleanup(cancelFunc)
 
 	db, pubsub := dbtestutil.NewDB(t)
-	log := slogtest.Make(t, nil).Leveled(slog.LevelDebug)
+	log := testutil.Logger(t)
 
 	batcher, closeBatcher, err := workspacestats.NewBatcher(ctx,
 		// We had previously set the batch size to 1 here, but that caused
@@ -499,7 +499,7 @@ func TestAgentStats(t *testing.T) {
 	require.NoError(t, err, "create stats batcher failed")
 	t.Cleanup(closeBatcher)
 
-	tLogger := slogtest.Make(t, nil)
+	tLogger := testutil.Logger(t)
 	// Build sample workspaces with test agents and fake agent client
 	client, _, _ := coderdtest.NewWithAPI(t, &coderdtest.Options{
 		Database:                 db,

coderd/provisionerdserver/acquirer_test.go

@@ -17,8 +17,6 @@ import (
 	"go.uber.org/goleak"
 	"golang.org/x/exp/slices"
 
-	"cdr.dev/slog"
-	"cdr.dev/slog/sloggers/slogtest"
 	"github.com/coder/coder/v2/coderd/database"
 	"github.com/coder/coder/v2/coderd/database/dbmem"
 	"github.com/coder/coder/v2/coderd/database/dbtestutil"
@@ -40,7 +38,7 @@ func TestAcquirer_Store(t *testing.T) {
 	ps := pubsub.NewInMemory()
 	ctx, cancel := context.WithTimeout(context.Background(), testutil.WaitShort)
 	defer cancel()
-	logger := slogtest.Make(t, nil).Leveled(slog.LevelDebug)
+	logger := testutil.Logger(t)
 	_ = provisionerdserver.NewAcquirer(ctx, logger.Named("acquirer"), db, ps)
 }
 
@@ -50,7 +48,7 @@ func TestAcquirer_Single(t *testing.T) {
 	ps := pubsub.NewInMemory()
 	ctx, cancel := context.WithTimeout(context.Background(), testutil.WaitShort)
 	defer cancel()
-	logger := slogtest.Make(t, nil).Leveled(slog.LevelDebug)
+	logger := testutil.Logger(t)
 	uut := provisionerdserver.NewAcquirer(ctx, logger.Named("acquirer"), fs, ps)
 
 	orgID := uuid.New()
@@ -77,7 +75,7 @@ func TestAcquirer_MultipleSameDomain(t *testing.T) {
 	ps := pubsub.NewInMemory()
 	ctx, cancel := context.WithTimeout(context.Background(), testutil.WaitShort)
 	defer cancel()
-	logger := slogtest.Make(t, nil).Leveled(slog.LevelDebug)
+	logger := testutil.Logger(t)
 	uut := provisionerdserver.NewAcquirer(ctx, logger.Named("acquirer"), fs, ps)
 
 	acquirees := make([]*testAcquiree, 0, 10)
@@ -123,7 +121,7 @@ func TestAcquirer_WaitsOnNoJobs(t *testing.T) {
 	ps := pubsub.NewInMemory()
 	ctx, cancel := context.WithTimeout(context.Background(), testutil.WaitShort)
 	defer cancel()
-	logger := slogtest.Make(t, nil).Leveled(slog.LevelDebug)
+	logger := testutil.Logger(t)
 	uut := provisionerdserver.NewAcquirer(ctx, logger.Named("acquirer"), fs, ps)
 
 	orgID := uuid.New()
@@ -175,7 +173,7 @@ func TestAcquirer_RetriesPending(t *testing.T) {
 	ps := pubsub.NewInMemory()
 	ctx, cancel := context.WithTimeout(context.Background(), testutil.WaitShort)
 	defer cancel()
-	logger := slogtest.Make(t, nil).Leveled(slog.LevelDebug)
+	logger := testutil.Logger(t)
 	uut := provisionerdserver.NewAcquirer(ctx, logger.Named("acquirer"), fs, ps)
 
 	orgID := uuid.New()
@@ -219,7 +217,7 @@ func TestAcquirer_DifferentDomains(t *testing.T) {
 	ps := pubsub.NewInMemory()
 	ctx, cancel := context.WithTimeout(context.Background(), testutil.WaitShort)
 	defer cancel()
-	logger := slogtest.Make(t, nil).Leveled(slog.LevelDebug)
+	logger := testutil.Logger(t)
 
 	orgID := uuid.New()
 	pt := []database.ProvisionerType{database.ProvisionerTypeEcho}
@@ -266,7 +264,7 @@ func TestAcquirer_BackupPoll(t *testing.T) {
 	ps := pubsub.NewInMemory()
 	ctx, cancel := context.WithTimeout(context.Background(), testutil.WaitShort)
 	defer cancel()
-	logger := slogtest.Make(t, nil).Leveled(slog.LevelDebug)
+	logger := testutil.Logger(t)
 	uut := provisionerdserver.NewAcquirer(
 		ctx, logger.Named("acquirer"), fs, ps,
 		provisionerdserver.TestingBackupPollDuration(testutil.IntervalMedium),
@@ -297,7 +295,7 @@ func TestAcquirer_UnblockOnCancel(t *testing.T) {
 	ps := pubsub.NewInMemory()
 	ctx, cancel := context.WithTimeout(context.Background(), testutil.WaitShort)
 	defer cancel()
-	logger := slogtest.Make(t, nil).Leveled(slog.LevelDebug)
+	logger := testutil.Logger(t)
 
 	pt := []database.ProvisionerType{database.ProvisionerTypeEcho}
 	orgID := uuid.New()
@@ -476,7 +474,7 @@ func TestAcquirer_MatchTags(t *testing.T) {
 			ctx := testutil.Context(t, testutil.WaitShort)
 			// NOTE: explicitly not using fake store for this test.
 			db, ps := dbtestutil.NewDB(t)
-			log := slogtest.Make(t, nil).Leveled(slog.LevelDebug)
+			log := testutil.Logger(t)
 			org, err := db.InsertOrganization(ctx, database.InsertOrganizationParams{
 				ID:          uuid.New(),
 				Name:        "test org",

coderd/provisionerdserver/provisionerdserver_test.go

@@ -13,16 +13,13 @@ import (
 	"testing"
 	"time"
 
-	"golang.org/x/xerrors"
-	"storj.io/drpc"
-
-	"cdr.dev/slog"
-
 	"github.com/google/uuid"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 	"go.opentelemetry.io/otel/trace"
 	"golang.org/x/oauth2"
+	"golang.org/x/xerrors"
+	"storj.io/drpc"
 
 	"cdr.dev/slog/sloggers/slogtest"
 	"github.com/coder/serpent"
@@ -2202,7 +2199,7 @@ type overrides struct {
 
 func setup(t *testing.T, ignoreLogErrors bool, ov *overrides) (proto.DRPCProvisionerDaemonServer, database.Store, pubsub.Pubsub, database.ProvisionerDaemon) {
 	t.Helper()
-	logger := slogtest.Make(t, nil).Leveled(slog.LevelDebug)
+	logger := testutil.Logger(t)
 	db := dbmem.New()
 	ps := pubsub.NewInMemory()
 	defOrg, err := db.GetDefaultOrganization(context.Background())

coderd/provisionerjobs_internal_test.go

@@ -16,8 +16,6 @@ import (
 	"go.uber.org/mock/gomock"
 	"nhooyr.io/websocket"
 
-	"cdr.dev/slog/sloggers/slogtest"
-
 	"github.com/coder/coder/v2/coderd/database"
 	"github.com/coder/coder/v2/coderd/database/dbmock"
 	"github.com/coder/coder/v2/coderd/database/dbtime"
@@ -147,7 +145,7 @@ func Test_logFollower_completeBeforeFollow(t *testing.T) {
 	t.Parallel()
 	ctx, cancel := context.WithTimeout(context.Background(), testutil.WaitShort)
 	defer cancel()
-	logger := slogtest.Make(t, nil)
+	logger := testutil.Logger(t)
 	ctrl := gomock.NewController(t)
 	mDB := dbmock.NewMockStore(ctrl)
 	ps := pubsub.NewInMemory()
@@ -210,7 +208,7 @@ func Test_logFollower_completeBeforeSubscribe(t *testing.T) {
 	t.Parallel()
 	ctx, cancel := context.WithTimeout(context.Background(), testutil.WaitShort)
 	defer cancel()
-	logger := slogtest.Make(t, nil)
+	logger := testutil.Logger(t)
 	ctrl := gomock.NewController(t)
 	mDB := dbmock.NewMockStore(ctrl)
 	ps := pubsub.NewInMemory()
@@ -288,7 +286,7 @@ func Test_logFollower_EndOfLogs(t *testing.T) {
 	t.Parallel()
 	ctx, cancel := context.WithTimeout(context.Background(), testutil.WaitShort)
 	defer cancel()
-	logger := slogtest.Make(t, nil)
+	logger := testutil.Logger(t)
 	ctrl := gomock.NewController(t)
 	mDB := dbmock.NewMockStore(ctrl)
 	ps := pubsub.NewInMemory()

coderd/tailnet_test.go

@@ -20,8 +20,6 @@ import (
 	"go.opentelemetry.io/otel/trace"
 	"tailscale.com/tailcfg"
 
-	"cdr.dev/slog"
-	"cdr.dev/slog/sloggers/slogtest"
 	"github.com/coder/coder/v2/agent"
 	"github.com/coder/coder/v2/agent/agenttest"
 	"github.com/coder/coder/v2/agent/proto"
@@ -392,7 +390,7 @@ type agentWithID struct {
 }
 
 func setupServerTailnetAgent(t *testing.T, agentNum int, opts ...tailnettest.DERPAndStunOption) ([]agentWithID, *coderd.ServerTailnet) {
-	logger := slogtest.Make(t, nil).Leveled(slog.LevelDebug)
+	logger := testutil.Logger(t)
 	derpMap, derpServer := tailnettest.RunDERPAndSTUN(t, opts...)
 
 	coord := tailnet.NewCoordinator(logger)

coderd/telemetry/telemetry_test.go

@@ -15,8 +15,6 @@ import (
 	"github.com/stretchr/testify/require"
 	"go.uber.org/goleak"
 
-	"cdr.dev/slog"
-	"cdr.dev/slog/sloggers/slogtest"
 	"github.com/coder/coder/v2/buildinfo"
 	"github.com/coder/coder/v2/coderd/database"
 	"github.com/coder/coder/v2/coderd/database/dbgen"
@@ -186,7 +184,7 @@ func collectSnapshot(t *testing.T, db database.Store, addOptionsFn func(opts tel
 	require.NoError(t, err)
 	options := telemetry.Options{
 		Database:     db,
-		Logger:       slogtest.Make(t, nil).Leveled(slog.LevelDebug),
+		Logger:       testutil.Logger(t),
 		URL:          serverURL,
 		DeploymentID: uuid.NewString(),
 	}

coderd/templates_test.go

@@ -11,8 +11,6 @@ import (
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 
-	"cdr.dev/slog/sloggers/slogtest"
-
 	"github.com/coder/coder/v2/agent/agenttest"
 	"github.com/coder/coder/v2/coderd/audit"
 	"github.com/coder/coder/v2/coderd/coderdtest"
@@ -1342,7 +1340,7 @@ func TestTemplateMetrics(t *testing.T) {
 
 	conn, err := workspacesdk.New(client).
 		DialAgent(ctx, resources[0].Agents[0].ID, &workspacesdk.DialAgentOptions{
-			Logger: slogtest.Make(t, nil).Named("tailnet"),
+			Logger: testutil.Logger(t).Named("tailnet"),
 		})
 	require.NoError(t, err)
 	defer func() {

coderd/unhanger/detector_test.go

@@ -15,7 +15,6 @@ import (
 	"go.uber.org/goleak"
 
 	"cdr.dev/slog"
-	"cdr.dev/slog/sloggers/slogtest"
 	"github.com/coder/coder/v2/coderd/coderdtest"
 	"github.com/coder/coder/v2/coderd/database"
 	"github.com/coder/coder/v2/coderd/database/dbauthz"
@@ -38,7 +37,7 @@ func TestDetectorNoJobs(t *testing.T) {
 	var (
 		ctx        = testutil.Context(t, testutil.WaitLong)
 		db, pubsub = dbtestutil.NewDB(t)
-		log        = slogtest.Make(t, nil)
+		log        = testutil.Logger(t)
 		tickCh     = make(chan time.Time)
 		statsCh    = make(chan unhanger.Stats)
 	)
@@ -61,7 +60,7 @@ func TestDetectorNoHungJobs(t *testing.T) {
 	var (
 		ctx        = testutil.Context(t, testutil.WaitLong)
 		db, pubsub = dbtestutil.NewDB(t)
-		log        = slogtest.Make(t, nil)
+		log        = testutil.Logger(t)
 		tickCh     = make(chan time.Time)
 		statsCh    = make(chan unhanger.Stats)
 	)
@@ -108,7 +107,7 @@ func TestDetectorHungWorkspaceBuild(t *testing.T) {
 	var (
 		ctx        = testutil.Context(t, testutil.WaitLong)
 		db, pubsub = dbtestutil.NewDB(t)
-		log        = slogtest.Make(t, nil)
+		log        = testutil.Logger(t)
 		tickCh     = make(chan time.Time)
 		statsCh    = make(chan unhanger.Stats)
 	)
@@ -230,7 +229,7 @@ func TestDetectorHungWorkspaceBuildNoOverrideState(t *testing.T) {
 	var (
 		ctx        = testutil.Context(t, testutil.WaitLong)
 		db, pubsub = dbtestutil.NewDB(t)
-		log        = slogtest.Make(t, nil)
+		log        = testutil.Logger(t)
 		tickCh     = make(chan time.Time)
 		statsCh    = make(chan unhanger.Stats)
 	)
@@ -353,7 +352,7 @@ func TestDetectorHungWorkspaceBuildNoOverrideStateIfNoExistingBuild(t *testing.T
 	var (
 		ctx        = testutil.Context(t, testutil.WaitLong)
 		db, pubsub = dbtestutil.NewDB(t)
-		log        = slogtest.Make(t, nil)
+		log        = testutil.Logger(t)
 		tickCh     = make(chan time.Time)
 		statsCh    = make(chan unhanger.Stats)
 	)
@@ -446,7 +445,7 @@ func TestDetectorHungOtherJobTypes(t *testing.T) {
 	var (
 		ctx        = testutil.Context(t, testutil.WaitLong)
 		db, pubsub = dbtestutil.NewDB(t)
-		log        = slogtest.Make(t, nil)
+		log        = testutil.Logger(t)
 		tickCh     = make(chan time.Time)
 		statsCh    = make(chan unhanger.Stats)
 	)
@@ -550,7 +549,7 @@ func TestDetectorHungCanceledJob(t *testing.T) {
 	var (
 		ctx        = testutil.Context(t, testutil.WaitLong)
 		db, pubsub = dbtestutil.NewDB(t)
-		log        = slogtest.Make(t, nil)
+		log        = testutil.Logger(t)
 		tickCh     = make(chan time.Time)
 		statsCh    = make(chan unhanger.Stats)
 	)
@@ -652,7 +651,7 @@ func TestDetectorPushesLogs(t *testing.T) {
 			var (
 				ctx        = testutil.Context(t, testutil.WaitLong)
 				db, pubsub = dbtestutil.NewDB(t)
-				log        = slogtest.Make(t, nil)
+				log        = testutil.Logger(t)
 				tickCh     = make(chan time.Time)
 				statsCh    = make(chan unhanger.Stats)
 			)
@@ -770,7 +769,7 @@ func TestDetectorMaxJobsPerRun(t *testing.T) {
 	var (
 		ctx        = testutil.Context(t, testutil.WaitLong)
 		db, pubsub = dbtestutil.NewDB(t)
-		log        = slogtest.Make(t, nil)
+		log        = testutil.Logger(t)
 		tickCh     = make(chan time.Time)
 		statsCh    = make(chan unhanger.Stats)
 		org        = dbgen.Organization(t, db, database.Organization{})

coderd/userauth_test.go

@@ -1404,7 +1404,7 @@ func TestUserOIDC(t *testing.T) {
 
 		var (
 			ctx    = testutil.Context(t, testutil.WaitMedium)
-			logger = slogtest.Make(t, nil)
+			logger = testutil.Logger(t)
 		)
 
 		auditor := audit.NewMock()

coderd/workspaceagents_test.go

@@ -464,7 +464,7 @@ func TestWorkspaceAgentTailnet(t *testing.T) {
 
 		return workspacesdk.New(client).
 			DialAgent(ctx, resources[0].Agents[0].ID, &workspacesdk.DialAgentOptions{
-				Logger: slogtest.Make(t, nil).Named("client").Leveled(slog.LevelDebug),
+				Logger: testutil.Logger(t).Named("client"),
 			})
 	}()
 	require.NoError(t, err)
@@ -561,7 +561,7 @@ func TestWorkspaceAgentClientCoordinate_ResumeToken(t *testing.T) {
 	t.Run("OK", func(t *testing.T) {
 		t.Parallel()
 
-		logger := slogtest.Make(t, nil).Leveled(slog.LevelDebug)
+		logger := testutil.Logger(t)
 		clock := quartz.NewMock(t)
 		resumeTokenSigningKey, err := tailnet.GenerateResumeTokenSigningKey()
 		mgr := jwtutils.StaticKey{
@@ -633,7 +633,7 @@ func TestWorkspaceAgentClientCoordinate_ResumeToken(t *testing.T) {
 	t.Run("BadJWT", func(t *testing.T) {
 		t.Parallel()
 
-		logger := slogtest.Make(t, nil).Leveled(slog.LevelDebug)
+		logger := testutil.Logger(t)
 		clock := quartz.NewMock(t)
 		resumeTokenSigningKey, err := tailnet.GenerateResumeTokenSigningKey()
 		mgr := jwtutils.StaticKey{
@@ -797,7 +797,7 @@ func TestWorkspaceAgentTailnetDirectDisabled(t *testing.T) {
 
 	conn, err := workspacesdk.New(client).
 		DialAgent(ctx, resources[0].Agents[0].ID, &workspacesdk.DialAgentOptions{
-			Logger: slogtest.Make(t, nil).Named("client").Leveled(slog.LevelDebug),
+			Logger: testutil.Logger(t).Named("client"),
 		})
 	require.NoError(t, err)
 	defer conn.Close()
@@ -1747,7 +1747,7 @@ func TestWorkspaceAgent_Startup(t *testing.T) {
 func TestWorkspaceAgent_UpdatedDERP(t *testing.T) {
 	t.Parallel()
 
-	logger := slogtest.Make(t, nil).Leveled(slog.LevelDebug)
+	logger := testutil.Logger(t)
 
 	dv := coderdtest.DeploymentValues(t)
 	err := dv.DERP.Config.BlockDirect.Set("true")
@@ -1936,7 +1936,7 @@ func TestOwnedWorkspacesCoordinate(t *testing.T) {
 	t.Parallel()
 
 	ctx := testutil.Context(t, testutil.WaitLong)
-	logger := slogtest.Make(t, nil).Leveled(slog.LevelDebug)
+	logger := testutil.Logger(t)
 	firstClient, _, api := coderdtest.NewWithAPI(t, &coderdtest.Options{
 		Coordinator: tailnet.NewCoordinator(logger),
 	})

coderd/workspaceagentsrpc_internal_test.go

@@ -16,8 +16,6 @@ import (
 	"go.uber.org/mock/gomock"
 	"nhooyr.io/websocket"
 
-	"cdr.dev/slog"
-	"cdr.dev/slog/sloggers/slogtest"
 	"github.com/coder/coder/v2/coderd/database"
 	"github.com/coder/coder/v2/coderd/database/dbmock"
 	"github.com/coder/coder/v2/coderd/database/dbtime"
@@ -32,7 +30,7 @@ func TestAgentConnectionMonitor_ContextCancel(t *testing.T) {
 	ctrl := gomock.NewController(t)
 	mDB := dbmock.NewMockStore(ctrl)
 	fUpdater := &fakeUpdater{}
-	logger := slogtest.Make(t, nil).Leveled(slog.LevelDebug)
+	logger := testutil.Logger(t)
 	agent := database.WorkspaceAgent{
 		ID: uuid.New(),
 		FirstConnectedAt: sql.NullTime{
@@ -106,7 +104,7 @@ func TestAgentConnectionMonitor_PingTimeout(t *testing.T) {
 	ctrl := gomock.NewController(t)
 	mDB := dbmock.NewMockStore(ctrl)
 	fUpdater := &fakeUpdater{}
-	logger := slogtest.Make(t, nil).Leveled(slog.LevelDebug)
+	logger := testutil.Logger(t)
 	agent := database.WorkspaceAgent{
 		ID: uuid.New(),
 		FirstConnectedAt: sql.NullTime{
@@ -166,7 +164,7 @@ func TestAgentConnectionMonitor_BuildOutdated(t *testing.T) {
 	ctrl := gomock.NewController(t)
 	mDB := dbmock.NewMockStore(ctrl)
 	fUpdater := &fakeUpdater{}
-	logger := slogtest.Make(t, nil).Leveled(slog.LevelDebug)
+	logger := testutil.Logger(t)
 	agent := database.WorkspaceAgent{
 		ID: uuid.New(),
 		FirstConnectedAt: sql.NullTime{
@@ -247,7 +245,7 @@ func TestAgentConnectionMonitor_StartClose(t *testing.T) {
 	ctrl := gomock.NewController(t)
 	mDB := dbmock.NewMockStore(ctrl)
 	fUpdater := &fakeUpdater{}
-	logger := slogtest.Make(t, nil).Leveled(slog.LevelDebug)
+	logger := testutil.Logger(t)
 	agent := database.WorkspaceAgent{
 		ID: uuid.New(),
 		FirstConnectedAt: sql.NullTime{

coderd/workspaceapps/apptest/setup.go

@@ -17,8 +17,6 @@ import (
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 
-	"cdr.dev/slog"
-	"cdr.dev/slog/sloggers/slogtest"
 	"github.com/coder/coder/v2/agent"
 	agentproto "github.com/coder/coder/v2/agent/proto"
 	"github.com/coder/coder/v2/coderd/coderdtest"
@@ -441,7 +439,7 @@ func createWorkspaceWithApps(t *testing.T, client *codersdk.Client, orgID uuid.U
 	}
 	agentCloser := agent.New(agent.Options{
 		Client: agentClient,
-		Logger: slogtest.Make(t, nil).Named("agent").Leveled(slog.LevelDebug),
+		Logger: testutil.Logger(t).Named("agent"),
 	})
 	t.Cleanup(func() {
 		_ = agentCloser.Close()

coderd/workspaceapps_test.go

@@ -10,8 +10,6 @@ import (
 	"github.com/go-jose/go-jose/v4/jwt"
 	"github.com/stretchr/testify/require"
 
-	"cdr.dev/slog/sloggers/slogtest"
-
 	"github.com/coder/coder/v2/coderd/coderdtest"
 	"github.com/coder/coder/v2/coderd/cryptokeys"
 	"github.com/coder/coder/v2/coderd/database"
@@ -189,7 +187,7 @@ func TestWorkspaceApplicationAuth(t *testing.T) {
 			t.Parallel()
 
 			ctx := testutil.Context(t, testutil.WaitMedium)
-			logger := slogtest.Make(t, nil)
+			logger := testutil.Logger(t)
 			accessURL, err := url.Parse(c.accessURL)
 			require.NoError(t, err)
 

coderd/workspaces_test.go

@@ -19,8 +19,6 @@ import (
 	"github.com/stretchr/testify/require"
 
 	"cdr.dev/slog"
-	"cdr.dev/slog/sloggers/slogtest"
-
 	"github.com/coder/coder/v2/agent/agenttest"
 	"github.com/coder/coder/v2/coderd/audit"
 	"github.com/coder/coder/v2/coderd/coderdtest"
@@ -2502,7 +2500,7 @@ func TestWorkspaceWatcher(t *testing.T) {
 	require.NoError(t, err)
 
 	// Wait events are easier to debug with timestamped logs.
-	logger := slogtest.Make(t, nil).Named(t.Name()).Leveled(slog.LevelDebug)
+	logger := testutil.Logger(t).Named(t.Name())
 	wait := func(event string, ready func(w codersdk.Workspace) bool) {
 		for {
 			select {

coderd/workspacestats/activitybump_test.go

@@ -7,7 +7,6 @@ import (
 
 	"github.com/google/uuid"
 
-	"cdr.dev/slog/sloggers/slogtest"
 	"github.com/coder/coder/v2/coderd/database"
 	"github.com/coder/coder/v2/coderd/database/dbgen"
 	"github.com/coder/coder/v2/coderd/database/dbtestutil"
@@ -172,7 +171,7 @@ func Test_ActivityBumpWorkspace(t *testing.T) {
 				var (
 					now   = dbtime.Now()
 					ctx   = testutil.Context(t, testutil.WaitShort)
-					log   = slogtest.Make(t, nil)
+					log   = testutil.Logger(t)
 					db, _ = dbtestutil.NewDB(t, dbtestutil.WithTimezone(tz))
 					org   = dbgen.Organization(t, db, database.Organization{})
 					user  = dbgen.User(t, db, database.User{

coderd/workspacestats/tracker_test.go

@@ -12,8 +12,6 @@ import (
 	"go.uber.org/goleak"
 	"go.uber.org/mock/gomock"
 
-	"cdr.dev/slog"
-	"cdr.dev/slog/sloggers/slogtest"
 	"github.com/coder/coder/v2/coderd/coderdtest"
 	"github.com/coder/coder/v2/coderd/database"
 	"github.com/coder/coder/v2/coderd/database/dbfake"
@@ -31,7 +29,7 @@ func TestTracker(t *testing.T) {
 
 	ctrl := gomock.NewController(t)
 	mDB := dbmock.NewMockStore(ctrl)
-	log := slogtest.Make(t, nil).Leveled(slog.LevelDebug)
+	log := testutil.Logger(t)
 
 	tickCh := make(chan time.Time)
 	flushCh := make(chan int, 1)

coderd/workspaceupdates_test.go

@@ -10,7 +10,6 @@ import (
 	"github.com/google/uuid"
 	"github.com/stretchr/testify/require"
 
-	"cdr.dev/slog/sloggers/slogtest"
 	"github.com/coder/coder/v2/coderd"
 	"github.com/coder/coder/v2/coderd/database"
 	"github.com/coder/coder/v2/coderd/database/dbauthz"
@@ -98,7 +97,7 @@ func TestWorkspaceUpdates(t *testing.T) {
 			cbs: map[string]pubsub.ListenerWithErr{},
 		}
 
-		updateProvider := coderd.NewUpdatesProvider(slogtest.Make(t, nil), ps, db, &mockAuthorizer{})
+		updateProvider := coderd.NewUpdatesProvider(testutil.Logger(t), ps, db, &mockAuthorizer{})
 		t.Cleanup(func() {
 			_ = updateProvider.Close()
 		})
@@ -255,7 +254,7 @@ func TestWorkspaceUpdates(t *testing.T) {
 			cbs: map[string]pubsub.ListenerWithErr{},
 		}
 
-		updateProvider := coderd.NewUpdatesProvider(slogtest.Make(t, nil), ps, db, &mockAuthorizer{})
+		updateProvider := coderd.NewUpdatesProvider(testutil.Logger(t), ps, db, &mockAuthorizer{})
 		t.Cleanup(func() {
 			_ = updateProvider.Close()
 		})

codersdk/agentsdk/logs_internal_test.go

@@ -11,8 +11,6 @@ import (
 	"golang.org/x/xerrors"
 	protobuf "google.golang.org/protobuf/proto"
 
-	"cdr.dev/slog"
-	"cdr.dev/slog/sloggers/slogtest"
 	"github.com/coder/coder/v2/agent/proto"
 	"github.com/coder/coder/v2/coderd/database/dbtime"
 	"github.com/coder/coder/v2/codersdk"
@@ -23,7 +21,7 @@ func TestLogSender_Mainline(t *testing.T) {
 	t.Parallel()
 	testCtx := testutil.Context(t, testutil.WaitShort)
 	ctx, cancel := context.WithCancel(testCtx)
-	logger := slogtest.Make(t, nil).Leveled(slog.LevelDebug)
+	logger := testutil.Logger(t)
 	fDest := newFakeLogDest()
 	uut := NewLogSender(logger)
 
@@ -128,7 +126,7 @@ func TestLogSender_Mainline(t *testing.T) {
 func TestLogSender_LogLimitExceeded(t *testing.T) {
 	t.Parallel()
 	ctx := testutil.Context(t, testutil.WaitShort)
-	logger := slogtest.Make(t, nil).Leveled(slog.LevelDebug)
+	logger := testutil.Logger(t)
 	fDest := newFakeLogDest()
 	uut := NewLogSender(logger)
 
@@ -189,7 +187,7 @@ func TestLogSender_SkipHugeLog(t *testing.T) {
 	t.Parallel()
 	testCtx := testutil.Context(t, testutil.WaitShort)
 	ctx, cancel := context.WithCancel(testCtx)
-	logger := slogtest.Make(t, nil).Leveled(slog.LevelDebug)
+	logger := testutil.Logger(t)
 	fDest := newFakeLogDest()
 	uut := NewLogSender(logger)
 
@@ -235,7 +233,7 @@ func TestLogSender_InvalidUTF8(t *testing.T) {
 	t.Parallel()
 	testCtx := testutil.Context(t, testutil.WaitShort)
 	ctx, cancel := context.WithCancel(testCtx)
-	logger := slogtest.Make(t, nil).Leveled(slog.LevelDebug)
+	logger := testutil.Logger(t)
 	fDest := newFakeLogDest()
 	uut := NewLogSender(logger)
 
@@ -280,7 +278,7 @@ func TestLogSender_Batch(t *testing.T) {
 	t.Parallel()
 	testCtx := testutil.Context(t, testutil.WaitShort)
 	ctx, cancel := context.WithCancel(testCtx)
-	logger := slogtest.Make(t, nil).Leveled(slog.LevelDebug)
+	logger := testutil.Logger(t)
 	fDest := newFakeLogDest()
 	uut := NewLogSender(logger)
 
@@ -330,7 +328,7 @@ func TestLogSender_MaxQueuedLogs(t *testing.T) {
 	t.Parallel()
 	testCtx := testutil.Context(t, testutil.WaitShort)
 	ctx, cancel := context.WithCancel(testCtx)
-	logger := slogtest.Make(t, nil).Leveled(slog.LevelDebug)
+	logger := testutil.Logger(t)
 	fDest := newFakeLogDest()
 	uut := NewLogSender(logger)
 
@@ -389,7 +387,7 @@ func TestLogSender_MaxQueuedLogs(t *testing.T) {
 func TestLogSender_SendError(t *testing.T) {
 	t.Parallel()
 	ctx := testutil.Context(t, testutil.WaitShort)
-	logger := slogtest.Make(t, nil).Leveled(slog.LevelDebug)
+	logger := testutil.Logger(t)
 	fDest := newFakeLogDest()
 	expectedErr := xerrors.New("test")
 	fDest.err = expectedErr
@@ -431,7 +429,7 @@ func TestLogSender_WaitUntilEmpty_ContextExpired(t *testing.T) {
 	t.Parallel()
 	testCtx := testutil.Context(t, testutil.WaitShort)
 	ctx, cancel := context.WithCancel(testCtx)
-	logger := slogtest.Make(t, nil).Leveled(slog.LevelDebug)
+	logger := testutil.Logger(t)
 	uut := NewLogSender(logger)
 
 	t0 := dbtime.Now()

codersdk/agentsdk/logs_test.go

@@ -12,8 +12,6 @@ import (
 	"github.com/stretchr/testify/require"
 	"golang.org/x/exp/slices"
 
-	"cdr.dev/slog"
-	"cdr.dev/slog/sloggers/slogtest"
 	"github.com/coder/coder/v2/codersdk"
 	"github.com/coder/coder/v2/codersdk/agentsdk"
 	"github.com/coder/coder/v2/testutil"
@@ -274,7 +272,7 @@ func TestStartupLogsSender(t *testing.T) {
 				return nil
 			}
 
-			sendLog, flushAndClose := agentsdk.LogsSender(uuid.New(), patchLogs, slogtest.Make(t, nil).Leveled(slog.LevelDebug))
+			sendLog, flushAndClose := agentsdk.LogsSender(uuid.New(), patchLogs, testutil.Logger(t))
 			defer func() {
 				err := flushAndClose(ctx)
 				require.NoError(t, err)
@@ -313,7 +311,7 @@ func TestStartupLogsSender(t *testing.T) {
 			return nil
 		}
 
-		sendLog, flushAndClose := agentsdk.LogsSender(uuid.New(), patchLogs, slogtest.Make(t, nil).Leveled(slog.LevelDebug))
+		sendLog, flushAndClose := agentsdk.LogsSender(uuid.New(), patchLogs, testutil.Logger(t))
 		defer func() {
 			_ = flushAndClose(ctx)
 		}()
@@ -349,7 +347,7 @@ func TestStartupLogsSender(t *testing.T) {
 
 		// Prevent race between auto-flush and context cancellation with
 		// a really long timeout.
-		sendLog, flushAndClose := agentsdk.LogsSender(uuid.New(), patchLogs, slogtest.Make(t, nil).Leveled(slog.LevelDebug), agentsdk.LogsSenderFlushTimeout(time.Hour))
+		sendLog, flushAndClose := agentsdk.LogsSender(uuid.New(), patchLogs, testutil.Logger(t), agentsdk.LogsSenderFlushTimeout(time.Hour))
 		defer func() {
 			_ = flushAndClose(ctx)
 		}()

enterprise/coderd/coderd_test.go

@@ -17,7 +17,6 @@ import (
 	"github.com/stretchr/testify/require"
 	"go.uber.org/goleak"
 
-	"cdr.dev/slog/sloggers/slogtest"
 	"github.com/coder/coder/v2/coderd/httpapi"
 	"github.com/coder/coder/v2/coderd/rbac/policy"
 	"github.com/coder/coder/v2/tailnet/tailnettest"
@@ -426,7 +425,7 @@ func TestMultiReplica_EmptyRelayAddress(t *testing.T) {
 
 	ctx := testutil.Context(t, testutil.WaitLong)
 	db, ps := dbtestutil.NewDB(t)
-	logger := slogtest.Make(t, nil)
+	logger := testutil.Logger(t)
 
 	_, _ = coderdenttest.New(t, &coderdenttest.Options{
 		EntitlementsUpdateInterval: 25 * time.Millisecond,
@@ -468,7 +467,7 @@ func TestMultiReplica_EmptyRelayAddress_DisabledDERP(t *testing.T) {
 
 	ctx := testutil.Context(t, testutil.WaitLong)
 	db, ps := dbtestutil.NewDB(t)
-	logger := slogtest.Make(t, nil)
+	logger := testutil.Logger(t)
 
 	dv := coderdtest.DeploymentValues(t)
 	dv.DERP.Server.Enable = serpent.Bool(false)

enterprise/coderd/coderdenttest/coderdenttest.go

@@ -11,32 +11,28 @@ import (
 	"testing"
 	"time"
 
+	"github.com/golang-jwt/jwt/v4"
+	"github.com/google/uuid"
 	"github.com/moby/moby/pkg/namesgenerator"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 	"golang.org/x/xerrors"
 
-	"cdr.dev/slog"
-	"cdr.dev/slog/sloggers/slogtest"
+	"github.com/coder/coder/v2/coderd/coderdtest"
 	"github.com/coder/coder/v2/coderd/database"
 	"github.com/coder/coder/v2/coderd/database/dbmem"
 	"github.com/coder/coder/v2/coderd/database/pubsub"
+	"github.com/coder/coder/v2/codersdk"
 	"github.com/coder/coder/v2/codersdk/drpc"
+	"github.com/coder/coder/v2/enterprise/coderd"
+	"github.com/coder/coder/v2/enterprise/coderd/license"
+	"github.com/coder/coder/v2/enterprise/dbcrypt"
 	"github.com/coder/coder/v2/provisioner/echo"
 	"github.com/coder/coder/v2/provisionerd"
 	provisionerdproto "github.com/coder/coder/v2/provisionerd/proto"
 	"github.com/coder/coder/v2/provisionersdk"
 	sdkproto "github.com/coder/coder/v2/provisionersdk/proto"
 	"github.com/coder/coder/v2/testutil"
-
-	"github.com/golang-jwt/jwt/v4"
-	"github.com/google/uuid"
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-
-	"github.com/coder/coder/v2/coderd/coderdtest"
-	"github.com/coder/coder/v2/codersdk"
-	"github.com/coder/coder/v2/enterprise/coderd"
-	"github.com/coder/coder/v2/enterprise/coderd/license"
-	"github.com/coder/coder/v2/enterprise/dbcrypt"
 )
 
 const (
@@ -354,7 +350,7 @@ func NewExternalProvisionerDaemon(t testing.TB, client *codersdk.Client, org uui
 			Tags:         tags,
 		})
 	}, &provisionerd.Options{
-		Logger:              slogtest.Make(t, nil).Named("provisionerd").Leveled(slog.LevelDebug),
+		Logger:              testutil.Logger(t).Named("provisionerd"),
 		UpdateInterval:      250 * time.Millisecond,
 		ForceCancelInterval: 5 * time.Second,
 		Connector: provisionerd.LocalProvisioners{

enterprise/coderd/coderdenttest/proxytest.go

@@ -18,11 +18,11 @@ import (
 	"github.com/stretchr/testify/require"
 
 	"cdr.dev/slog"
-	"cdr.dev/slog/sloggers/slogtest"
 	"github.com/coder/coder/v2/coderd/workspaceapps/appurl"
 	"github.com/coder/coder/v2/codersdk"
 	"github.com/coder/coder/v2/enterprise/coderd"
 	"github.com/coder/coder/v2/enterprise/wsproxy"
+	"github.com/coder/coder/v2/testutil"
 )
 
 type ProxyOptions struct {
@@ -144,7 +144,7 @@ func NewWorkspaceProxyReplica(t *testing.T, coderdAPI *coderd.API, owner *coders
 		statsCollectorOptions.Flush = options.FlushStats
 	}
 
-	logger := slogtest.Make(t, nil).Leveled(slog.LevelDebug).With(slog.F("server_url", serverURL.String()))
+	logger := testutil.Logger(t).With(slog.F("server_url", serverURL.String()))
 
 	wssrv, err := wsproxy.New(ctx, &wsproxy.Options{
 		Logger:            logger,

enterprise/coderd/enidpsync/role_test.go

@@ -7,13 +7,13 @@ import (
 	"github.com/golang-jwt/jwt/v4"
 	"github.com/stretchr/testify/require"
 
-	"cdr.dev/slog/sloggers/slogtest"
 	"github.com/coder/coder/v2/coderd/entitlements"
 	"github.com/coder/coder/v2/coderd/idpsync"
 	"github.com/coder/coder/v2/coderd/rbac"
 	"github.com/coder/coder/v2/coderd/runtimeconfig"
 	"github.com/coder/coder/v2/codersdk"
 	"github.com/coder/coder/v2/enterprise/coderd/enidpsync"
+	"github.com/coder/coder/v2/testutil"
 )
 
 func TestEnterpriseParseRoleClaims(t *testing.T) {
@@ -31,7 +31,7 @@ func TestEnterpriseParseRoleClaims(t *testing.T) {
 		t.Parallel()
 
 		mgr := runtimeconfig.NewManager()
-		s := enidpsync.NewSync(slogtest.Make(t, nil), mgr, entitlements.New(), idpsync.DeploymentSyncSettings{})
+		s := enidpsync.NewSync(testutil.Logger(t), mgr, entitlements.New(), idpsync.DeploymentSyncSettings{})
 
 		params, err := s.ParseRoleClaims(context.Background(), jwt.MapClaims{})
 		require.Nil(t, err)
@@ -44,7 +44,7 @@ func TestEnterpriseParseRoleClaims(t *testing.T) {
 		// Since it is not entitled, it should not be enabled
 
 		mgr := runtimeconfig.NewManager()
-		s := enidpsync.NewSync(slogtest.Make(t, nil), mgr, entitlements.New(), idpsync.DeploymentSyncSettings{
+		s := enidpsync.NewSync(testutil.Logger(t), mgr, entitlements.New(), idpsync.DeploymentSyncSettings{
 			SiteRoleField: "roles",
 		})
 
@@ -58,7 +58,7 @@ func TestEnterpriseParseRoleClaims(t *testing.T) {
 		t.Parallel()
 
 		mgr := runtimeconfig.NewManager()
-		s := enidpsync.NewSync(slogtest.Make(t, nil), mgr, entitled, idpsync.DeploymentSyncSettings{})
+		s := enidpsync.NewSync(testutil.Logger(t), mgr, entitled, idpsync.DeploymentSyncSettings{})
 
 		params, err := s.ParseRoleClaims(context.Background(), jwt.MapClaims{})
 		require.Nil(t, err)
@@ -70,7 +70,7 @@ func TestEnterpriseParseRoleClaims(t *testing.T) {
 		t.Parallel()
 
 		mgr := runtimeconfig.NewManager()
-		s := enidpsync.NewSync(slogtest.Make(t, nil), mgr, entitled, idpsync.DeploymentSyncSettings{
+		s := enidpsync.NewSync(testutil.Logger(t), mgr, entitled, idpsync.DeploymentSyncSettings{
 			SiteRoleField:    "roles",
 			SiteRoleMapping:  map[string][]string{},
 			SiteDefaultRoles: []string{rbac.RoleTemplateAdmin().Name},
@@ -92,7 +92,7 @@ func TestEnterpriseParseRoleClaims(t *testing.T) {
 		t.Parallel()
 
 		mgr := runtimeconfig.NewManager()
-		s := enidpsync.NewSync(slogtest.Make(t, nil), mgr, entitled, idpsync.DeploymentSyncSettings{
+		s := enidpsync.NewSync(testutil.Logger(t), mgr, entitled, idpsync.DeploymentSyncSettings{
 			SiteRoleField: "roles",
 			SiteRoleMapping: map[string][]string{
 				"foo": {rbac.RoleAuditor().Name, rbac.RoleUserAdmin().Name},
@@ -121,7 +121,7 @@ func TestEnterpriseParseRoleClaims(t *testing.T) {
 		t.Parallel()
 
 		mgr := runtimeconfig.NewManager()
-		s := enidpsync.NewSync(slogtest.Make(t, nil), mgr, entitled, idpsync.DeploymentSyncSettings{
+		s := enidpsync.NewSync(testutil.Logger(t), mgr, entitled, idpsync.DeploymentSyncSettings{
 			SiteRoleField: "roles",
 			SiteRoleMapping: map[string][]string{
 				"foo": {rbac.RoleOwner().Name, rbac.RoleAuditor().Name},

enterprise/coderd/provisionerdaemons_test.go

@@ -14,7 +14,6 @@ import (
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 
-	"cdr.dev/slog"
 	"cdr.dev/slog/sloggers/slogtest"
 	"github.com/coder/coder/v2/apiversion"
 	"github.com/coder/coder/v2/buildinfo"
@@ -398,7 +397,7 @@ func TestProvisionerDaemonServe(t *testing.T) {
 			},
 			ProvisionerDaemonPSK: provPSK,
 		})
-		logger := slogtest.Make(t, nil).Leveled(slog.LevelDebug)
+		logger := testutil.Logger(t)
 		ctx, cancel := context.WithTimeout(context.Background(), testutil.WaitLong)
 		defer cancel()
 

enterprise/coderd/proxyhealth/proxyhealth_test.go

@@ -10,7 +10,6 @@ import (
 	"github.com/stretchr/testify/require"
 	"golang.org/x/xerrors"
 
-	"cdr.dev/slog/sloggers/slogtest"
 	"github.com/coder/coder/v2/coderd/database"
 	"github.com/coder/coder/v2/coderd/database/dbgen"
 	"github.com/coder/coder/v2/coderd/database/dbmem"
@@ -57,7 +56,7 @@ func TestProxyHealth_Unregistered(t *testing.T) {
 	ph, err := proxyhealth.New(&proxyhealth.Options{
 		Interval: 0,
 		DB:       db,
-		Logger:   slogtest.Make(t, nil),
+		Logger:   testutil.Logger(t),
 	})
 	require.NoError(t, err, "failed to create proxy health")
 
@@ -96,7 +95,7 @@ func TestProxyHealth_Unhealthy(t *testing.T) {
 	ph, err := proxyhealth.New(&proxyhealth.Options{
 		Interval: 0,
 		DB:       db,
-		Logger:   slogtest.Make(t, nil),
+		Logger:   testutil.Logger(t),
 		Client:   srvBadReport.Client(),
 	})
 	require.NoError(t, err, "failed to create proxy health")
@@ -131,7 +130,7 @@ func TestProxyHealth_Reachable(t *testing.T) {
 	ph, err := proxyhealth.New(&proxyhealth.Options{
 		Interval: 0,
 		DB:       db,
-		Logger:   slogtest.Make(t, nil),
+		Logger:   testutil.Logger(t),
 		Client:   srv.Client(),
 	})
 	require.NoError(t, err, "failed to create proxy health")
@@ -167,7 +166,7 @@ func TestProxyHealth_Unreachable(t *testing.T) {
 	ph, err := proxyhealth.New(&proxyhealth.Options{
 		Interval: 0,
 		DB:       db,
-		Logger:   slogtest.Make(t, nil),
+		Logger:   testutil.Logger(t),
 		Client:   cli,
 	})
 	require.NoError(t, err, "failed to create proxy health")

enterprise/coderd/replicas_test.go

@@ -8,9 +8,6 @@ import (
 
 	"github.com/stretchr/testify/require"
 
-	"cdr.dev/slog"
-	"cdr.dev/slog/sloggers/slogtest"
-
 	"github.com/coder/coder/v2/coderd/coderdtest"
 	"github.com/coder/coder/v2/coderd/database/dbtestutil"
 	"github.com/coder/coder/v2/codersdk"
@@ -120,7 +117,7 @@ func TestReplicas(t *testing.T) {
 		conn, err := workspacesdk.New(secondClient).
 			DialAgent(context.Background(), r.sdkAgent.ID, &workspacesdk.DialAgentOptions{
 				BlockEndpoints: true,
-				Logger:         slogtest.Make(t, nil).Leveled(slog.LevelDebug),
+				Logger:         testutil.Logger(t),
 			})
 		require.NoError(t, err)
 		require.Eventually(t, func() bool {
@@ -167,7 +164,7 @@ func TestReplicas(t *testing.T) {
 		conn, err := workspacesdk.New(secondClient).
 			DialAgent(context.Background(), r.sdkAgent.ID, &workspacesdk.DialAgentOptions{
 				BlockEndpoints: true,
-				Logger:         slogtest.Make(t, nil).Named("client").Leveled(slog.LevelDebug),
+				Logger:         testutil.Logger(t).Named("client"),
 			})
 		require.NoError(t, err)
 		require.Eventually(t, func() bool {

enterprise/coderd/workspaceagents_test.go

@@ -10,7 +10,6 @@ import (
 	"github.com/google/uuid"
 	"github.com/stretchr/testify/require"
 
-	"cdr.dev/slog/sloggers/slogtest"
 	"github.com/coder/coder/v2/agent"
 	"github.com/coder/coder/v2/coderd/coderdtest"
 	"github.com/coder/coder/v2/codersdk"
@@ -138,7 +137,7 @@ func setupWorkspaceAgent(t *testing.T, client *codersdk.Client, user codersdk.Cr
 	agentClient.SetSessionToken(authToken)
 	agnt := agent.New(agent.Options{
 		Client: agentClient,
-		Logger: slogtest.Make(t, nil).Named("agent"),
+		Logger: testutil.Logger(t).Named("agent"),
 	})
 	t.Cleanup(func() {
 		_ = agnt.Close()

enterprise/derpmesh/derpmesh_test.go

@@ -17,8 +17,6 @@ import (
 	"tailscale.com/derp/derphttp"
 	"tailscale.com/types/key"
 
-	"cdr.dev/slog"
-	"cdr.dev/slog/sloggers/slogtest"
 	"github.com/coder/coder/v2/enterprise/derpmesh"
 	"github.com/coder/coder/v2/tailnet"
 	"github.com/coder/coder/v2/testutil"
@@ -49,19 +47,19 @@ func TestDERPMesh(t *testing.T) {
 		firstServer, firstServerURL := startDERP(t, tlsConfig)
 		defer firstServer.Close()
 		secondServer, secondServerURL := startDERP(t, tlsConfig)
-		firstMesh := derpmesh.New(slogtest.Make(t, nil).Named("first").Leveled(slog.LevelDebug), firstServer, tlsConfig)
+		firstMesh := derpmesh.New(testutil.Logger(t).Named("first"), firstServer, tlsConfig)
 		firstMesh.SetAddresses([]string{secondServerURL}, false)
-		secondMesh := derpmesh.New(slogtest.Make(t, nil).Named("second").Leveled(slog.LevelDebug), secondServer, tlsConfig)
+		secondMesh := derpmesh.New(testutil.Logger(t).Named("second"), secondServer, tlsConfig)
 		secondMesh.SetAddresses([]string{firstServerURL}, false)
 		defer firstMesh.Close()
 		defer secondMesh.Close()
 
 		first := key.NewNode()
 		second := key.NewNode()
-		firstClient, err := derphttp.NewClient(first, secondServerURL, tailnet.Logger(slogtest.Make(t, nil)))
+		firstClient, err := derphttp.NewClient(first, secondServerURL, tailnet.Logger(testutil.Logger(t)))
 		require.NoError(t, err)
 		firstClient.TLSConfig = tlsConfig
-		secondClient, err := derphttp.NewClient(second, firstServerURL, tailnet.Logger(slogtest.Make(t, nil)))
+		secondClient, err := derphttp.NewClient(second, firstServerURL, tailnet.Logger(testutil.Logger(t)))
 		require.NoError(t, err)
 		secondClient.TLSConfig = tlsConfig
 		err = secondClient.Connect(context.Background())
@@ -95,7 +93,7 @@ func TestDERPMesh(t *testing.T) {
 		// This tests messages passing through multiple DERP servers.
 		t.Parallel()
 		server, serverURL := startDERP(t, tlsConfig)
-		mesh := derpmesh.New(slogtest.Make(t, nil).Named("first").Leveled(slog.LevelDebug), server, tlsConfig)
+		mesh := derpmesh.New(testutil.Logger(t).Named("first"), server, tlsConfig)
 		mesh.SetAddresses([]string{"http://fake.com"}, false)
 		// This should trigger a removal...
 		mesh.SetAddresses([]string{}, false)
@@ -103,10 +101,10 @@ func TestDERPMesh(t *testing.T) {
 
 		first := key.NewNode()
 		second := key.NewNode()
-		firstClient, err := derphttp.NewClient(first, serverURL, tailnet.Logger(slogtest.Make(t, nil)))
+		firstClient, err := derphttp.NewClient(first, serverURL, tailnet.Logger(testutil.Logger(t)))
 		require.NoError(t, err)
 		firstClient.TLSConfig = tlsConfig
-		secondClient, err := derphttp.NewClient(second, serverURL, tailnet.Logger(slogtest.Make(t, nil)))
+		secondClient, err := derphttp.NewClient(second, serverURL, tailnet.Logger(testutil.Logger(t)))
 		require.NoError(t, err)
 		secondClient.TLSConfig = tlsConfig
 		err = secondClient.Connect(context.Background())
@@ -141,7 +139,7 @@ func TestDERPMesh(t *testing.T) {
 		serverURLs := make([]string, 0, 20)
 		for i := 0; i < 20; i++ {
 			server, url := startDERP(t, tlsConfig)
-			mesh := derpmesh.New(slogtest.Make(t, nil).Named("mesh").Leveled(slog.LevelDebug), server, tlsConfig)
+			mesh := derpmesh.New(testutil.Logger(t).Named("mesh"), server, tlsConfig)
 			t.Cleanup(func() {
 				_ = server.Close()
 				_ = mesh.Close()
@@ -155,10 +153,10 @@ func TestDERPMesh(t *testing.T) {
 
 		first := key.NewNode()
 		second := key.NewNode()
-		firstClient, err := derphttp.NewClient(first, serverURLs[9], tailnet.Logger(slogtest.Make(t, nil)))
+		firstClient, err := derphttp.NewClient(first, serverURLs[9], tailnet.Logger(testutil.Logger(t)))
 		require.NoError(t, err)
 		firstClient.TLSConfig = tlsConfig
-		secondClient, err := derphttp.NewClient(second, serverURLs[16], tailnet.Logger(slogtest.Make(t, nil)))
+		secondClient, err := derphttp.NewClient(second, serverURLs[16], tailnet.Logger(testutil.Logger(t)))
 		require.NoError(t, err)
 		secondClient.TLSConfig = tlsConfig
 		err = secondClient.Connect(context.Background())
@@ -193,9 +191,9 @@ func TestDERPMesh(t *testing.T) {
 		firstServer, firstServerURL := startDERP(t, tlsConfig)
 		defer firstServer.Close()
 		secondServer, secondServerURL := startDERP(t, tlsConfig)
-		firstMesh := derpmesh.New(slogtest.Make(t, nil).Named("first").Leveled(slog.LevelDebug), firstServer, tlsConfig)
+		firstMesh := derpmesh.New(testutil.Logger(t).Named("first"), firstServer, tlsConfig)
 		firstMesh.SetAddresses([]string{secondServerURL}, false)
-		secondMesh := derpmesh.New(slogtest.Make(t, nil).Named("second").Leveled(slog.LevelDebug), secondServer, tlsConfig)
+		secondMesh := derpmesh.New(testutil.Logger(t).Named("second"), secondServer, tlsConfig)
 		// Ensures that the client properly re-adds the address after it's removed.
 		secondMesh.SetAddresses([]string{firstServerURL}, true)
 		secondMesh.SetAddresses([]string{}, true)
@@ -205,10 +203,10 @@ func TestDERPMesh(t *testing.T) {
 
 		first := key.NewNode()
 		second := key.NewNode()
-		firstClient, err := derphttp.NewClient(first, secondServerURL, tailnet.Logger(slogtest.Make(t, nil)))
+		firstClient, err := derphttp.NewClient(first, secondServerURL, tailnet.Logger(testutil.Logger(t)))
 		require.NoError(t, err)
 		firstClient.TLSConfig = tlsConfig
-		secondClient, err := derphttp.NewClient(second, firstServerURL, tailnet.Logger(slogtest.Make(t, nil)))
+		secondClient, err := derphttp.NewClient(second, firstServerURL, tailnet.Logger(testutil.Logger(t)))
 		require.NoError(t, err)
 		secondClient.TLSConfig = tlsConfig
 		err = secondClient.Connect(context.Background())
@@ -258,7 +256,7 @@ func recvData(t *testing.T, client *derphttp.Client) []byte {
 }
 
 func startDERP(t *testing.T, tlsConfig *tls.Config) (*derp.Server, string) {
-	logf := tailnet.Logger(slogtest.Make(t, nil))
+	logf := tailnet.Logger(testutil.Logger(t))
 	d := derp.NewServer(key.NewNode(), logf)
 	d.SetMeshKey("some-key")
 	server := httptest.NewUnstartedServer(derphttp.Handler(d))

enterprise/provisionerd/remoteprovisioners_test.go

@@ -10,7 +10,6 @@ import (
 	"go.uber.org/goleak"
 
 	"cdr.dev/slog"
-	"cdr.dev/slog/sloggers/slogtest"
 	"github.com/coder/coder/v2/coderd/database"
 	"github.com/coder/coder/v2/enterprise/provisionerd"
 	"github.com/coder/coder/v2/provisioner/echo"
@@ -39,7 +38,7 @@ func TestRemoteConnector_Mainline(t *testing.T) {
 			t.Parallel()
 			ctx, cancel := context.WithTimeout(context.Background(), testutil.WaitMedium)
 			defer cancel()
-			logger := slogtest.Make(t, nil).Leveled(slog.LevelDebug)
+			logger := testutil.Logger(t)
 			exec := &testExecutor{
 				t:           t,
 				logger:      logger,
@@ -93,7 +92,7 @@ func TestRemoteConnector_BadToken(t *testing.T) {
 	t.Parallel()
 	ctx, cancel := context.WithTimeout(context.Background(), testutil.WaitMedium)
 	defer cancel()
-	logger := slogtest.Make(t, nil).Leveled(slog.LevelDebug)
+	logger := testutil.Logger(t)
 	exec := &testExecutor{
 		t:             t,
 		logger:        logger,
@@ -123,7 +122,7 @@ func TestRemoteConnector_BadJobID(t *testing.T) {
 	t.Parallel()
 	ctx, cancel := context.WithTimeout(context.Background(), testutil.WaitMedium)
 	defer cancel()
-	logger := slogtest.Make(t, nil).Leveled(slog.LevelDebug)
+	logger := testutil.Logger(t)
 	exec := &testExecutor{
 		t:             t,
 		logger:        logger,
@@ -155,7 +154,7 @@ func TestRemoteConnector_BadCert(t *testing.T) {
 	require.NoError(t, err)
 	ctx, cancel := context.WithTimeout(context.Background(), testutil.WaitMedium)
 	defer cancel()
-	logger := slogtest.Make(t, nil).Leveled(slog.LevelDebug)
+	logger := testutil.Logger(t)
 	exec := &testExecutor{
 		t:            t,
 		logger:       logger,
@@ -185,7 +184,7 @@ func TestRemoteConnector_Fuzz(t *testing.T) {
 	t.Parallel()
 	ctx, cancel := context.WithTimeout(context.Background(), testutil.WaitMedium)
 	defer cancel()
-	logger := slogtest.Make(t, nil).Leveled(slog.LevelDebug)
+	logger := testutil.Logger(t)
 	exec := newFuzzExecutor(t, logger)
 	uut, err := provisionerd.NewRemoteConnector(ctx, logger.Named("connector"), exec)
 	require.NoError(t, err)
@@ -222,7 +221,7 @@ func TestRemoteConnector_CancelConnect(t *testing.T) {
 	t.Parallel()
 	ctx, cancel := context.WithTimeout(context.Background(), testutil.WaitMedium)
 	defer cancel()
-	logger := slogtest.Make(t, nil).Leveled(slog.LevelDebug)
+	logger := testutil.Logger(t)
 	exec := &testExecutor{
 		t:         t,
 		logger:    logger,

enterprise/replicasync/replicasync_test.go

@@ -15,7 +15,6 @@ import (
 	"github.com/stretchr/testify/require"
 	"go.uber.org/goleak"
 
-	"cdr.dev/slog/sloggers/slogtest"
 	"github.com/coder/coder/v2/coderd/database"
 	"github.com/coder/coder/v2/coderd/database/dbmem"
 	"github.com/coder/coder/v2/coderd/database/dbtestutil"
@@ -46,7 +45,7 @@ func TestReplica(t *testing.T) {
 		defer cancel()
 		ctx, cancelCtx := context.WithCancel(context.Background())
 		defer cancelCtx()
-		server, err := replicasync.New(ctx, slogtest.Make(t, nil), db, pubsub, nil)
+		server, err := replicasync.New(ctx, testutil.Logger(t), db, pubsub, nil)
 		require.NoError(t, err)
 		<-closeChan
 		_ = server.Close()
@@ -73,7 +72,7 @@ func TestReplica(t *testing.T) {
 		require.NoError(t, err)
 		ctx, cancelCtx := context.WithCancel(context.Background())
 		defer cancelCtx()
-		server, err := replicasync.New(ctx, slogtest.Make(t, nil), db, pubsub, &replicasync.Options{
+		server, err := replicasync.New(ctx, testutil.Logger(t), db, pubsub, &replicasync.Options{
 			RelayAddress: "http://169.254.169.254",
 		})
 		require.NoError(t, err)
@@ -118,7 +117,7 @@ func TestReplica(t *testing.T) {
 		require.NoError(t, err)
 		ctx, cancelCtx := context.WithCancel(context.Background())
 		defer cancelCtx()
-		server, err := replicasync.New(ctx, slogtest.Make(t, nil), db, pubsub, &replicasync.Options{
+		server, err := replicasync.New(ctx, testutil.Logger(t), db, pubsub, &replicasync.Options{
 			RelayAddress: "http://169.254.169.254",
 			TLSConfig:    tlsConfig,
 		})
@@ -146,7 +145,7 @@ func TestReplica(t *testing.T) {
 		require.NoError(t, err)
 		ctx, cancelCtx := context.WithCancel(context.Background())
 		defer cancelCtx()
-		server, err := replicasync.New(ctx, slogtest.Make(t, nil), db, pubsub, &replicasync.Options{
+		server, err := replicasync.New(ctx, testutil.Logger(t), db, pubsub, &replicasync.Options{
 			PeerTimeout:  1 * time.Millisecond,
 			RelayAddress: "http://127.0.0.1:1",
 		})
@@ -165,7 +164,7 @@ func TestReplica(t *testing.T) {
 		db, pubsub := dbtestutil.NewDB(t)
 		ctx, cancelCtx := context.WithCancel(context.Background())
 		defer cancelCtx()
-		server, err := replicasync.New(ctx, slogtest.Make(t, nil), db, pubsub, nil)
+		server, err := replicasync.New(ctx, testutil.Logger(t), db, pubsub, nil)
 		require.NoError(t, err)
 		defer server.Close()
 		dh := &derpyHandler{}
@@ -200,7 +199,7 @@ func TestReplica(t *testing.T) {
 		require.NoError(t, err)
 		ctx, cancelCtx := context.WithCancel(context.Background())
 		defer cancelCtx()
-		server, err := replicasync.New(ctx, slogtest.Make(t, nil), db, pubsub, &replicasync.Options{
+		server, err := replicasync.New(ctx, testutil.Logger(t), db, pubsub, &replicasync.Options{
 			RelayAddress:    "google.com",
 			CleanupInterval: time.Millisecond,
 		})
@@ -221,7 +220,7 @@ func TestReplica(t *testing.T) {
 		// configuration tweaking.
 		db := dbmem.New()
 		pubsub := pubsub.NewInMemory()
-		logger := slogtest.Make(t, nil)
+		logger := testutil.Logger(t)
 		dh := &derpyHandler{}
 		defer dh.requireOnlyDERPPaths(t)
 		srv := httptest.NewServer(dh)
@@ -260,7 +259,7 @@ func TestReplica(t *testing.T) {
 		db, pubsub := dbtestutil.NewDB(t)
 		ctx, cancelCtx := context.WithCancel(context.Background())
 		defer cancelCtx()
-		server, err := replicasync.New(ctx, slogtest.Make(t, nil), db, pubsub, &replicasync.Options{
+		server, err := replicasync.New(ctx, testutil.Logger(t), db, pubsub, &replicasync.Options{
 			RelayAddress:    "google.com",
 			CleanupInterval: time.Millisecond,
 			UpdateInterval:  time.Millisecond,

enterprise/tailnet/handshaker_test.go

@@ -6,8 +6,6 @@ import (
 
 	"github.com/stretchr/testify/require"
 
-	"cdr.dev/slog"
-	"cdr.dev/slog/sloggers/slogtest"
 	"github.com/coder/coder/v2/coderd/database/dbtestutil"
 	"github.com/coder/coder/v2/enterprise/tailnet"
 	agpltest "github.com/coder/coder/v2/tailnet/test"
@@ -22,7 +20,7 @@ func TestPGCoordinator_ReadyForHandshake_OK(t *testing.T) {
 	store, ps := dbtestutil.NewDB(t)
 	ctx, cancel := context.WithTimeout(context.Background(), testutil.WaitSuperLong)
 	defer cancel()
-	logger := slogtest.Make(t, nil).Leveled(slog.LevelDebug)
+	logger := testutil.Logger(t)
 	coord1, err := tailnet.NewPGCoord(ctx, logger.Named("coord1"), ps, store)
 	require.NoError(t, err)
 	defer coord1.Close()
@@ -38,7 +36,7 @@ func TestPGCoordinator_ReadyForHandshake_NoPermission(t *testing.T) {
 	store, ps := dbtestutil.NewDB(t)
 	ctx, cancel := context.WithTimeout(context.Background(), testutil.WaitSuperLong)
 	defer cancel()
-	logger := slogtest.Make(t, nil).Leveled(slog.LevelDebug)
+	logger := testutil.Logger(t)
 	coord1, err := tailnet.NewPGCoord(ctx, logger.Named("coord1"), ps, store)
 	require.NoError(t, err)
 	defer coord1.Close()

enterprise/tailnet/pgcoord_internal_test.go

@@ -44,7 +44,7 @@ func TestHeartbeats_Cleanup(t *testing.T) {
 
 	ctx, cancel := context.WithTimeout(context.Background(), testutil.WaitShort)
 	defer cancel()
-	logger := slogtest.Make(t, nil).Leveled(slog.LevelDebug)
+	logger := testutil.Logger(t)
 
 	mStore.EXPECT().CleanTailnetCoordinators(gomock.Any()).Times(2).Return(nil)
 	mStore.EXPECT().CleanTailnetLostPeers(gomock.Any()).Times(2).Return(nil)
@@ -77,7 +77,7 @@ func TestHeartbeats_recvBeat_resetSkew(t *testing.T) {
 	t.Parallel()
 
 	ctx := testutil.Context(t, testutil.WaitShort)
-	logger := slogtest.Make(t, nil).Leveled(slog.LevelDebug)
+	logger := testutil.Logger(t)
 	mClock := quartz.NewMock(t)
 	trap := mClock.Trap().Until("heartbeats", "resetExpiryTimerWithLock")
 	defer trap.Close()
@@ -133,7 +133,7 @@ func TestHeartbeats_LostCoordinator_MarkLost(t *testing.T) {
 
 	ctx, cancel := context.WithTimeout(context.Background(), testutil.WaitShort)
 	defer cancel()
-	logger := slogtest.Make(t, nil).Leveled(slog.LevelDebug)
+	logger := testutil.Logger(t)
 
 	uut := &heartbeats{
 		ctx:    ctx,

enterprise/tailnet/pgcoord_test.go

@@ -42,7 +42,7 @@ func TestPGCoordinatorSingle_ClientWithoutAgent(t *testing.T) {
 	store, ps := dbtestutil.NewDB(t)
 	ctx, cancel := context.WithTimeout(context.Background(), testutil.WaitSuperLong)
 	defer cancel()
-	logger := slogtest.Make(t, nil).Leveled(slog.LevelDebug)
+	logger := testutil.Logger(t)
 	coordinator, err := tailnet.NewPGCoord(ctx, logger, ps, store)
 	require.NoError(t, err)
 	defer coordinator.Close()
@@ -77,7 +77,7 @@ func TestPGCoordinatorSingle_AgentWithoutClients(t *testing.T) {
 	store, ps := dbtestutil.NewDB(t)
 	ctx, cancel := context.WithTimeout(context.Background(), testutil.WaitSuperLong)
 	defer cancel()
-	logger := slogtest.Make(t, nil).Leveled(slog.LevelDebug)
+	logger := testutil.Logger(t)
 	coordinator, err := tailnet.NewPGCoord(ctx, logger, ps, store)
 	require.NoError(t, err)
 	defer coordinator.Close()
@@ -111,7 +111,7 @@ func TestPGCoordinatorSingle_AgentInvalidIP(t *testing.T) {
 	store, ps := dbtestutil.NewDB(t)
 	ctx, cancel := context.WithTimeout(context.Background(), testutil.WaitSuperLong)
 	defer cancel()
-	logger := slogtest.Make(t, nil).Leveled(slog.LevelDebug)
+	logger := testutil.Logger(t)
 	coordinator, err := tailnet.NewPGCoord(ctx, logger, ps, store)
 	require.NoError(t, err)
 	defer coordinator.Close()
@@ -138,7 +138,7 @@ func TestPGCoordinatorSingle_AgentInvalidIPBits(t *testing.T) {
 	store, ps := dbtestutil.NewDB(t)
 	ctx, cancel := context.WithTimeout(context.Background(), testutil.WaitSuperLong)
 	defer cancel()
-	logger := slogtest.Make(t, nil).Leveled(slog.LevelDebug)
+	logger := testutil.Logger(t)
 	coordinator, err := tailnet.NewPGCoord(ctx, logger, ps, store)
 	require.NoError(t, err)
 	defer coordinator.Close()
@@ -165,7 +165,7 @@ func TestPGCoordinatorSingle_AgentValidIP(t *testing.T) {
 	store, ps := dbtestutil.NewDB(t)
 	ctx, cancel := context.WithTimeout(context.Background(), testutil.WaitSuperLong)
 	defer cancel()
-	logger := slogtest.Make(t, nil).Leveled(slog.LevelDebug)
+	logger := testutil.Logger(t)
 	coordinator, err := tailnet.NewPGCoord(ctx, logger, ps, store)
 	require.NoError(t, err)
 	defer coordinator.Close()
@@ -204,7 +204,7 @@ func TestPGCoordinatorSingle_AgentWithClient(t *testing.T) {
 	store, ps := dbtestutil.NewDB(t)
 	ctx, cancel := context.WithTimeout(context.Background(), testutil.WaitSuperLong)
 	defer cancel()
-	logger := slogtest.Make(t, nil).Leveled(slog.LevelDebug)
+	logger := testutil.Logger(t)
 	coordinator, err := tailnet.NewPGCoord(ctx, logger, ps, store)
 	require.NoError(t, err)
 	defer coordinator.Close()
@@ -253,7 +253,7 @@ func TestPGCoordinatorSingle_MissedHeartbeats(t *testing.T) {
 	store, ps := dbtestutil.NewDB(t)
 	ctx, cancel := context.WithTimeout(context.Background(), testutil.WaitShort)
 	defer cancel()
-	logger := slogtest.Make(t, nil).Leveled(slog.LevelDebug)
+	logger := testutil.Logger(t)
 	mClock := quartz.NewMock(t)
 	afTrap := mClock.Trap().AfterFunc("heartbeats", "recvBeat")
 	defer afTrap.Close()
@@ -338,7 +338,7 @@ func TestPGCoordinatorSingle_MissedHeartbeats_NoDrop(t *testing.T) {
 	store, ps := dbtestutil.NewDB(t)
 	ctx, cancel := context.WithTimeout(context.Background(), testutil.WaitSuperLong)
 	defer cancel()
-	logger := slogtest.Make(t, nil).Leveled(slog.LevelDebug)
+	logger := testutil.Logger(t)
 
 	coordinator, err := tailnet.NewPGCoord(ctx, logger, ps, store)
 	require.NoError(t, err)
@@ -384,7 +384,7 @@ func TestPGCoordinatorSingle_SendsHeartbeats(t *testing.T) {
 	store, ps := dbtestutil.NewDB(t)
 	ctx, cancel := context.WithTimeout(context.Background(), testutil.WaitSuperLong)
 	defer cancel()
-	logger := slogtest.Make(t, nil).Leveled(slog.LevelDebug)
+	logger := testutil.Logger(t)
 
 	mu := sync.Mutex{}
 	heartbeats := []time.Time{}
@@ -434,7 +434,7 @@ func TestPGCoordinatorDual_Mainline(t *testing.T) {
 	store, ps := dbtestutil.NewDB(t)
 	ctx, cancel := context.WithTimeout(context.Background(), testutil.WaitSuperLong)
 	defer cancel()
-	logger := slogtest.Make(t, nil).Leveled(slog.LevelDebug)
+	logger := testutil.Logger(t)
 	coord1, err := tailnet.NewPGCoord(ctx, logger.Named("coord1"), ps, store)
 	require.NoError(t, err)
 	defer coord1.Close()
@@ -532,7 +532,7 @@ func TestPGCoordinator_MultiCoordinatorAgent(t *testing.T) {
 	store, ps := dbtestutil.NewDB(t)
 	ctx, cancel := context.WithTimeout(context.Background(), testutil.WaitSuperLong)
 	defer cancel()
-	logger := slogtest.Make(t, nil).Leveled(slog.LevelDebug)
+	logger := testutil.Logger(t)
 	coord1, err := tailnet.NewPGCoord(ctx, logger.Named("coord1"), ps, store)
 	require.NoError(t, err)
 	defer coord1.Close()
@@ -665,7 +665,7 @@ func TestPGCoordinator_Node_Empty(t *testing.T) {
 	ctrl := gomock.NewController(t)
 	mStore := dbmock.NewMockStore(ctrl)
 	ps := pubsub.NewInMemory()
-	logger := slogtest.Make(t, nil).Leveled(slog.LevelDebug)
+	logger := testutil.Logger(t)
 
 	id := uuid.New()
 	mStore.EXPECT().GetTailnetPeers(gomock.Any(), id).Times(1).Return(nil, nil)
@@ -700,7 +700,7 @@ func TestPGCoordinator_BidirectionalTunnels(t *testing.T) {
 	store, ps := dbtestutil.NewDB(t)
 	ctx, cancel := context.WithTimeout(context.Background(), testutil.WaitSuperLong)
 	defer cancel()
-	logger := slogtest.Make(t, nil).Leveled(slog.LevelDebug)
+	logger := testutil.Logger(t)
 	coordinator, err := tailnet.NewPGCoord(ctx, logger, ps, store)
 	require.NoError(t, err)
 	defer coordinator.Close()
@@ -715,7 +715,7 @@ func TestPGCoordinator_GracefulDisconnect(t *testing.T) {
 	store, ps := dbtestutil.NewDB(t)
 	ctx, cancel := context.WithTimeout(context.Background(), testutil.WaitSuperLong)
 	defer cancel()
-	logger := slogtest.Make(t, nil).Leveled(slog.LevelDebug)
+	logger := testutil.Logger(t)
 	coordinator, err := tailnet.NewPGCoord(ctx, logger, ps, store)
 	require.NoError(t, err)
 	defer coordinator.Close()
@@ -730,7 +730,7 @@ func TestPGCoordinator_Lost(t *testing.T) {
 	store, ps := dbtestutil.NewDB(t)
 	ctx, cancel := context.WithTimeout(context.Background(), testutil.WaitSuperLong)
 	defer cancel()
-	logger := slogtest.Make(t, nil).Leveled(slog.LevelDebug)
+	logger := testutil.Logger(t)
 	coordinator, err := tailnet.NewPGCoord(ctx, logger, ps, store)
 	require.NoError(t, err)
 	defer coordinator.Close()
@@ -745,7 +745,7 @@ func TestPGCoordinator_NoDeleteOnClose(t *testing.T) {
 	store, ps := dbtestutil.NewDB(t)
 	ctx, cancel := context.WithTimeout(context.Background(), testutil.WaitSuperLong)
 	defer cancel()
-	logger := slogtest.Make(t, nil).Leveled(slog.LevelDebug)
+	logger := testutil.Logger(t)
 	coordinator, err := tailnet.NewPGCoord(ctx, logger, ps, store)
 	require.NoError(t, err)
 	defer coordinator.Close()
@@ -867,7 +867,7 @@ func TestPGCoordinatorDual_PeerReconnect(t *testing.T) {
 	store, ps := dbtestutil.NewDB(t)
 	ctx, cancel := context.WithTimeout(context.Background(), testutil.WaitSuperLong)
 	defer cancel()
-	logger := slogtest.Make(t, nil).Leveled(slog.LevelDebug)
+	logger := testutil.Logger(t)
 
 	// Create two coordinators, 1 for each peer.
 	c1, err := tailnet.NewPGCoord(ctx, logger, ps, store)
@@ -923,7 +923,7 @@ func TestPGCoordinatorPropogatedPeerContext(t *testing.T) {
 
 	ctx := testutil.Context(t, testutil.WaitShort)
 	store, ps := dbtestutil.NewDB(t)
-	logger := slogtest.Make(t, nil).Leveled(slog.LevelDebug)
+	logger := testutil.Logger(t)
 
 	peerCtx := context.WithValue(ctx, agpltest.FakeSubjectKey{}, struct{}{})
 	peerID := uuid.UUID{0x01}

go.mod

@@ -68,7 +68,7 @@ replace github.com/pkg/sftp => github.com/mafredri/sftp v1.13.6-0.20231212144145
 replace github.com/lib/pq => github.com/coder/pq v1.10.5-0.20240813183442-0c420cb5a048
 
 require (
-	cdr.dev/slog v1.6.2-0.20240126064726-20367d4aede6
+	cdr.dev/slog v1.6.2-0.20241112041820-0ec81e6e67bb
 	cloud.google.com/go/compute/metadata v0.5.2
 	github.com/acarl005/stripansi v0.0.0-20180116102854-5a71ef0e047d
 	github.com/adrg/xdg v0.5.0

go.sum

@@ -1,5 +1,5 @@
-cdr.dev/slog v1.6.2-0.20240126064726-20367d4aede6 h1:KHblWIE/KHOwQ6lEbMZt6YpcGve2FEZ1sDtrW1Am5UI=
-cdr.dev/slog v1.6.2-0.20240126064726-20367d4aede6/go.mod h1:NaoTA7KwopCrnaSb0JXTC0PTp/O/Y83Lndnq0OEV3ZQ=
+cdr.dev/slog v1.6.2-0.20241112041820-0ec81e6e67bb h1:4MKA8lBQLnCqj2myJCb5Lzoa65y0tABO4gHrxuMdsCQ=
+cdr.dev/slog v1.6.2-0.20241112041820-0ec81e6e67bb/go.mod h1:NaoTA7KwopCrnaSb0JXTC0PTp/O/Y83Lndnq0OEV3ZQ=
 cloud.google.com/go v0.26.0/go.mod h1:aQUYkXzVsufM+DwF1aE+0xfcU+56JwCaLick0ClmMTw=
 cloud.google.com/go/auth v0.10.1 h1:TnK46qldSfHWt2a0b/hciaiVJsmDXWy9FqyUan0uYiI=
 cloud.google.com/go/auth v0.10.1/go.mod h1:xxA5AqpDrvS+Gkmo9RqrGGRh6WSNKKOXhY3zNOr38tI=

provisioner/terraform/cleanup_test.go

@@ -18,7 +18,6 @@ import (
 	"github.com/stretchr/testify/require"
 
 	"cdr.dev/slog"
-	"cdr.dev/slog/sloggers/slogtest"
 	"github.com/coder/coder/v2/provisioner/terraform"
 	"github.com/coder/coder/v2/testutil"
 )
@@ -41,7 +40,7 @@ func TestPluginCache_Golden(t *testing.T) {
 		// afero.MemMapFs does not modify atimes, so use a real FS instead.
 		tmpDir := t.TempDir()
 		fs := afero.NewBasePathFs(afero.NewOsFs(), tmpDir)
-		logger := slogtest.Make(t, nil).
+		logger := testutil.Logger(t).
 			Leveled(slog.LevelDebug).
 			Named("cleanup-test")
 		return fs, logger

provisioner/terraform/install.go

@@ -49,10 +49,14 @@ func Install(ctx context.Context, log slog.Logger, dir string, wantVersion *vers
 
 	binPath := filepath.Join(dir, product.Terraform.BinaryName())
 
+	hasVersionStr := "nil"
 	hasVersion, err := versionFromBinaryPath(ctx, binPath)
-	if err == nil && hasVersion.Equal(wantVersion) {
+	if err == nil {
+		hasVersionStr = hasVersion.String()
+		if hasVersion.Equal(wantVersion) {
 			return binPath, err
 		}
+	}
 
 	installer := &releases.ExactVersion{
 		InstallDir: dir,
@@ -63,7 +67,7 @@ func Install(ctx context.Context, log slog.Logger, dir string, wantVersion *vers
 	log.Debug(
 		ctx,
 		"installing terraform",
-		slog.F("prev_version", hasVersion),
+		slog.F("prev_version", hasVersionStr),
 		slog.F("dir", dir),
 		slog.F("version", TerraformVersion),
 	)

provisioner/terraform/install_test.go

@@ -16,8 +16,8 @@ import (
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 
-	"cdr.dev/slog/sloggers/slogtest"
 	"github.com/coder/coder/v2/provisioner/terraform"
+	"github.com/coder/coder/v2/testutil"
 )
 
 func TestInstall(t *testing.T) {
@@ -27,7 +27,7 @@ func TestInstall(t *testing.T) {
 	}
 	ctx := context.Background()
 	dir := t.TempDir()
-	log := slogtest.Make(t, nil)
+	log := testutil.Logger(t)
 
 	// Install spins off 8 installs with Version and waits for them all
 	// to complete. The locking mechanism within Install should

provisioner/terraform/provision_test.go

@@ -45,7 +45,7 @@ func setupProvisioner(t *testing.T, opts *provisionerServeOptions) (context.Cont
 		opts.workDir = t.TempDir()
 	}
 	if opts.logger == nil {
-		logger := slogtest.Make(t, nil).Leveled(slog.LevelDebug)
+		logger := testutil.Logger(t)
 		opts.logger = &logger
 	}
 	client, server := drpc.MemTransportPipe()

provisioner/terraform/resources_test.go

@@ -17,6 +17,7 @@ import (
 
 	"cdr.dev/slog"
 	"cdr.dev/slog/sloggers/slogtest"
+	"github.com/coder/coder/v2/testutil"
 
 	"github.com/coder/coder/v2/cryptorand"
 	"github.com/coder/coder/v2/provisioner/terraform"
@@ -24,7 +25,7 @@ import (
 )
 
 func ctxAndLogger(t *testing.T) (context.Context, slog.Logger) {
-	return context.Background(), slogtest.Make(t, nil).Leveled(slog.LevelDebug)
+	return context.Background(), testutil.Logger(t)
 }
 
 func TestConvertResources(t *testing.T) {

provisioner/terraform/serve_internal_test.go

@@ -12,8 +12,6 @@ import (
 	"golang.org/x/xerrors"
 
 	"github.com/coder/coder/v2/testutil"
-
-	"cdr.dev/slog/sloggers/slogtest"
 )
 
 // nolint:paralleltest
@@ -56,7 +54,7 @@ func Test_absoluteBinaryPath(t *testing.T) {
 				t.Skip("Dummy terraform executable on Windows requires sh which isn't very practical.")
 			}
 
-			log := slogtest.Make(t, nil)
+			log := testutil.Logger(t)
 			// Create a temp dir with the binary
 			tempDir := t.TempDir()
 			terraformBinaryOutput := fmt.Sprintf(`#!/bin/sh

provisioner/terraform/tfparse/tfparse_test.go

@@ -6,13 +6,13 @@ import (
 	"log"
 	"testing"
 
+	"github.com/stretchr/testify/require"
+
 	"cdr.dev/slog"
 	"cdr.dev/slog/sloggers/sloghuman"
-	"cdr.dev/slog/sloggers/slogtest"
+
 	"github.com/coder/coder/v2/provisioner/terraform/tfparse"
 	"github.com/coder/coder/v2/testutil"
-
-	"github.com/stretchr/testify/require"
 )
 
 func Test_WorkspaceTagDefaultsFromFile(t *testing.T) {
@@ -361,7 +361,7 @@ func Test_WorkspaceTagDefaultsFromFile(t *testing.T) {
 			t.Parallel()
 			ctx := testutil.Context(t, testutil.WaitShort)
 			tar := testutil.CreateTar(t, tc.files)
-			logger := slogtest.Make(t, nil).Leveled(slog.LevelDebug)
+			logger := testutil.Logger(t)
 			tmpDir := t.TempDir()
 			tfparse.WriteArchive(tar, "application/x-tar", tmpDir)
 			parser, diags := tfparse.New(tmpDir, tfparse.WithLogger(logger))
@@ -379,7 +379,7 @@ func Test_WorkspaceTagDefaultsFromFile(t *testing.T) {
 			t.Parallel()
 			ctx := testutil.Context(t, testutil.WaitShort)
 			zip := testutil.CreateZip(t, tc.files)
-			logger := slogtest.Make(t, nil).Leveled(slog.LevelDebug)
+			logger := testutil.Logger(t)
 			tmpDir := t.TempDir()
 			tfparse.WriteArchive(zip, "application/zip", tmpDir)
 			parser, diags := tfparse.New(tmpDir, tfparse.WithLogger(logger))

provisionerd/provisionerd_test.go

@@ -1152,7 +1152,7 @@ func createProvisionerClient(t *testing.T, done <-chan struct{}, server provisio
 		defer close(closed)
 		_ = provisionersdk.Serve(ctx, &server, &provisionersdk.ServeOptions{
 			Listener:      serverPipe,
-			Logger:        slogtest.Make(t, nil).Leveled(slog.LevelDebug).Named("test-provisioner"),
+			Logger:        testutil.Logger(t).Named("test-provisioner"),
 			WorkDirectory: tempDir,
 		})
 	}()

provisionersdk/cleanup_test.go

@@ -11,8 +11,6 @@ import (
 	"github.com/stretchr/testify/require"
 
 	"cdr.dev/slog"
-	"cdr.dev/slog/sloggers/slogtest"
-
 	"github.com/coder/coder/v2/provisionersdk"
 	"github.com/coder/coder/v2/testutil"
 )
@@ -27,7 +25,7 @@ func TestStaleSessions(t *testing.T) {
 	prepare := func() (afero.Fs, slog.Logger) {
 		tempDir := t.TempDir()
 		fs := afero.NewBasePathFs(afero.NewOsFs(), tempDir)
-		logger := slogtest.Make(t, nil).
+		logger := testutil.Logger(t).
 			Leveled(slog.LevelDebug).
 			Named("cleanup-test")
 		return fs, logger

support/support_test.go

@@ -50,7 +50,7 @@ func TestRun(t *testing.T) {
 
 		bun, err := support.Run(ctx, &support.Deps{
 			Client:      client,
-			Log:         slogtest.Make(t, nil).Named("bundle").Leveled(slog.LevelDebug),
+			Log:         testutil.Logger(t).Named("bundle"),
 			WorkspaceID: ws.ID,
 			AgentID:     agt.ID,
 		})
@@ -149,7 +149,7 @@ func TestRun(t *testing.T) {
 		memberClient, _ := coderdtest.CreateAnotherUser(t, client, admin.OrganizationID)
 		bun, err := support.Run(ctx, &support.Deps{
 			Client: memberClient,
-			Log:    slogtest.Make(t, nil).Named("bundle").Leveled(slog.LevelDebug),
+			Log:    testutil.Logger(t).Named("bundle"),
 		})
 		require.ErrorContains(t, err, "failed authorization check")
 		require.NotEmpty(t, bun)

tailnet/configmaps_internal_test.go

@@ -21,8 +21,6 @@ import (
 	"tailscale.com/wgengine/router"
 	"tailscale.com/wgengine/wgcfg"
 
-	"cdr.dev/slog"
-	"cdr.dev/slog/sloggers/slogtest"
 	"github.com/coder/coder/v2/tailnet/proto"
 	"github.com/coder/coder/v2/testutil"
 	"github.com/coder/quartz"
@@ -31,7 +29,7 @@ import (
 func TestConfigMaps_setAddresses_different(t *testing.T) {
 	t.Parallel()
 	ctx := testutil.Context(t, testutil.WaitShort)
-	logger := slogtest.Make(t, nil).Leveled(slog.LevelDebug)
+	logger := testutil.Logger(t)
 	fEng := newFakeEngineConfigurable()
 	nodePrivateKey := key.NewNode()
 	nodeID := tailcfg.NodeID(5)
@@ -89,7 +87,7 @@ func TestConfigMaps_setAddresses_different(t *testing.T) {
 func TestConfigMaps_setAddresses_same(t *testing.T) {
 	t.Parallel()
 	ctx := testutil.Context(t, testutil.WaitShort)
-	logger := slogtest.Make(t, nil).Leveled(slog.LevelDebug)
+	logger := testutil.Logger(t)
 	fEng := newFakeEngineConfigurable()
 	nodePrivateKey := key.NewNode()
 	nodeID := tailcfg.NodeID(5)
@@ -120,7 +118,7 @@ func TestConfigMaps_setAddresses_same(t *testing.T) {
 func TestConfigMaps_updatePeers_new(t *testing.T) {
 	t.Parallel()
 	ctx := testutil.Context(t, testutil.WaitShort)
-	logger := slogtest.Make(t, nil).Leveled(slog.LevelDebug)
+	logger := testutil.Logger(t)
 	fEng := newFakeEngineConfigurable()
 	nodePrivateKey := key.NewNode()
 	nodeID := tailcfg.NodeID(5)
@@ -190,7 +188,7 @@ func TestConfigMaps_updatePeers_new(t *testing.T) {
 func TestConfigMaps_updatePeers_new_waitForHandshake_neverConfigures(t *testing.T) {
 	t.Parallel()
 	ctx := testutil.Context(t, testutil.WaitShort)
-	logger := slogtest.Make(t, nil).Leveled(slog.LevelDebug)
+	logger := testutil.Logger(t)
 	fEng := newFakeEngineConfigurable()
 	nodePrivateKey := key.NewNode()
 	nodeID := tailcfg.NodeID(5)
@@ -234,7 +232,7 @@ func TestConfigMaps_updatePeers_new_waitForHandshake_neverConfigures(t *testing.
 func TestConfigMaps_updatePeers_new_waitForHandshake_outOfOrder(t *testing.T) {
 	t.Parallel()
 	ctx := testutil.Context(t, testutil.WaitShort)
-	logger := slogtest.Make(t, nil).Leveled(slog.LevelDebug)
+	logger := testutil.Logger(t)
 	fEng := newFakeEngineConfigurable()
 	nodePrivateKey := key.NewNode()
 	nodeID := tailcfg.NodeID(5)
@@ -305,7 +303,7 @@ func TestConfigMaps_updatePeers_new_waitForHandshake_outOfOrder(t *testing.T) {
 func TestConfigMaps_updatePeers_new_waitForHandshake(t *testing.T) {
 	t.Parallel()
 	ctx := testutil.Context(t, testutil.WaitShort)
-	logger := slogtest.Make(t, nil).Leveled(slog.LevelDebug)
+	logger := testutil.Logger(t)
 	fEng := newFakeEngineConfigurable()
 	nodePrivateKey := key.NewNode()
 	nodeID := tailcfg.NodeID(5)
@@ -376,7 +374,7 @@ func TestConfigMaps_updatePeers_new_waitForHandshake(t *testing.T) {
 func TestConfigMaps_updatePeers_new_waitForHandshake_timeout(t *testing.T) {
 	t.Parallel()
 	ctx := testutil.Context(t, testutil.WaitShort)
-	logger := slogtest.Make(t, nil).Leveled(slog.LevelDebug)
+	logger := testutil.Logger(t)
 	fEng := newFakeEngineConfigurable()
 	nodePrivateKey := key.NewNode()
 	nodeID := tailcfg.NodeID(5)
@@ -434,7 +432,7 @@ func TestConfigMaps_updatePeers_new_waitForHandshake_timeout(t *testing.T) {
 func TestConfigMaps_updatePeers_same(t *testing.T) {
 	t.Parallel()
 	ctx := testutil.Context(t, testutil.WaitShort)
-	logger := slogtest.Make(t, nil).Leveled(slog.LevelDebug)
+	logger := testutil.Logger(t)
 	fEng := newFakeEngineConfigurable()
 	nodePrivateKey := key.NewNode()
 	nodeID := tailcfg.NodeID(5)
@@ -493,7 +491,7 @@ func TestConfigMaps_updatePeers_same(t *testing.T) {
 func TestConfigMaps_updatePeers_disconnect(t *testing.T) {
 	t.Parallel()
 	ctx := testutil.Context(t, testutil.WaitShort)
-	logger := slogtest.Make(t, nil).Leveled(slog.LevelDebug)
+	logger := testutil.Logger(t)
 	fEng := newFakeEngineConfigurable()
 	nodePrivateKey := key.NewNode()
 	nodeID := tailcfg.NodeID(5)
@@ -561,7 +559,7 @@ func TestConfigMaps_updatePeers_disconnect(t *testing.T) {
 func TestConfigMaps_updatePeers_lost(t *testing.T) {
 	t.Parallel()
 	ctx := testutil.Context(t, testutil.WaitShort)
-	logger := slogtest.Make(t, nil).Leveled(slog.LevelDebug)
+	logger := testutil.Logger(t)
 	fEng := newFakeEngineConfigurable()
 	nodePrivateKey := key.NewNode()
 	nodeID := tailcfg.NodeID(5)
@@ -646,7 +644,7 @@ func TestConfigMaps_updatePeers_lost(t *testing.T) {
 func TestConfigMaps_updatePeers_lost_and_found(t *testing.T) {
 	t.Parallel()
 	ctx := testutil.Context(t, testutil.WaitShort)
-	logger := slogtest.Make(t, nil).Leveled(slog.LevelDebug)
+	logger := testutil.Logger(t)
 	fEng := newFakeEngineConfigurable()
 	nodePrivateKey := key.NewNode()
 	nodeID := tailcfg.NodeID(5)
@@ -731,7 +729,7 @@ func TestConfigMaps_updatePeers_lost_and_found(t *testing.T) {
 func TestConfigMaps_setAllPeersLost(t *testing.T) {
 	t.Parallel()
 	ctx := testutil.Context(t, testutil.WaitShort)
-	logger := slogtest.Make(t, nil).Leveled(slog.LevelDebug)
+	logger := testutil.Logger(t)
 	fEng := newFakeEngineConfigurable()
 	nodePrivateKey := key.NewNode()
 	nodeID := tailcfg.NodeID(5)
@@ -817,7 +815,7 @@ func TestConfigMaps_setAllPeersLost(t *testing.T) {
 func TestConfigMaps_setBlockEndpoints_different(t *testing.T) {
 	t.Parallel()
 	ctx := testutil.Context(t, testutil.WaitShort)
-	logger := slogtest.Make(t, nil).Leveled(slog.LevelDebug)
+	logger := testutil.Logger(t)
 	fEng := newFakeEngineConfigurable()
 	nodePrivateKey := key.NewNode()
 	nodeID := tailcfg.NodeID(5)
@@ -861,7 +859,7 @@ func TestConfigMaps_setBlockEndpoints_different(t *testing.T) {
 func TestConfigMaps_setBlockEndpoints_same(t *testing.T) {
 	t.Parallel()
 	ctx := testutil.Context(t, testutil.WaitShort)
-	logger := slogtest.Make(t, nil).Leveled(slog.LevelDebug)
+	logger := testutil.Logger(t)
 	fEng := newFakeEngineConfigurable()
 	nodePrivateKey := key.NewNode()
 	nodeID := tailcfg.NodeID(5)
@@ -904,7 +902,7 @@ func TestConfigMaps_setBlockEndpoints_same(t *testing.T) {
 func TestConfigMaps_setDERPMap_different(t *testing.T) {
 	t.Parallel()
 	ctx := testutil.Context(t, testutil.WaitShort)
-	logger := slogtest.Make(t, nil).Leveled(slog.LevelDebug)
+	logger := testutil.Logger(t)
 	fEng := newFakeEngineConfigurable()
 	nodePrivateKey := key.NewNode()
 	nodeID := tailcfg.NodeID(5)
@@ -945,7 +943,7 @@ func TestConfigMaps_setDERPMap_different(t *testing.T) {
 func TestConfigMaps_setDERPMap_same(t *testing.T) {
 	t.Parallel()
 	ctx := testutil.Context(t, testutil.WaitShort)
-	logger := slogtest.Make(t, nil).Leveled(slog.LevelDebug)
+	logger := testutil.Logger(t)
 	fEng := newFakeEngineConfigurable()
 	nodePrivateKey := key.NewNode()
 	nodeID := tailcfg.NodeID(5)
@@ -1014,7 +1012,7 @@ func TestConfigMaps_setDERPMap_same(t *testing.T) {
 func TestConfigMaps_fillPeerDiagnostics(t *testing.T) {
 	t.Parallel()
 	ctx := testutil.Context(t, testutil.WaitShort)
-	logger := slogtest.Make(t, nil).Leveled(slog.LevelDebug)
+	logger := testutil.Logger(t)
 	fEng := newFakeEngineConfigurable()
 	nodePrivateKey := key.NewNode()
 	nodeID := tailcfg.NodeID(5)
@@ -1122,7 +1120,7 @@ func TestConfigMaps_updatePeers_nonexist(t *testing.T) {
 		t.Run(k.String(), func(t *testing.T) {
 			t.Parallel()
 			ctx := testutil.Context(t, testutil.WaitShort)
-			logger := slogtest.Make(t, nil).Leveled(slog.LevelDebug)
+			logger := testutil.Logger(t)
 			fEng := newFakeEngineConfigurable()
 			nodePrivateKey := key.NewNode()
 			nodeID := tailcfg.NodeID(5)
@@ -1163,7 +1161,7 @@ func TestConfigMaps_addRemoveHosts(t *testing.T) {
 	t.Parallel()
 
 	ctx := testutil.Context(t, testutil.WaitShort)
-	logger := slogtest.Make(t, nil).Leveled(slog.LevelDebug)
+	logger := testutil.Logger(t)
 	fEng := newFakeEngineConfigurable()
 	nodePrivateKey := key.NewNode()
 	nodeID := tailcfg.NodeID(5)

tailnet/conn_test.go

@@ -12,8 +12,6 @@ import (
 	"github.com/stretchr/testify/require"
 	"go.uber.org/goleak"
 
-	"cdr.dev/slog"
-	"cdr.dev/slog/sloggers/slogtest"
 	"github.com/coder/coder/v2/tailnet"
 	"github.com/coder/coder/v2/tailnet/proto"
 	"github.com/coder/coder/v2/tailnet/tailnettest"
@@ -29,7 +27,7 @@ func TestTailnet(t *testing.T) {
 	derpMap, _ := tailnettest.RunDERPAndSTUN(t)
 	t.Run("InstantClose", func(t *testing.T) {
 		t.Parallel()
-		logger := slogtest.Make(t, nil).Leveled(slog.LevelDebug)
+		logger := testutil.Logger(t)
 		conn, err := tailnet.NewConn(&tailnet.Options{
 			Addresses: []netip.Prefix{tailnet.TailscaleServicePrefix.RandomPrefix()},
 			Logger:    logger.Named("w1"),
@@ -41,7 +39,7 @@ func TestTailnet(t *testing.T) {
 	})
 	t.Run("Connect", func(t *testing.T) {
 		t.Parallel()
-		logger := slogtest.Make(t, nil).Leveled(slog.LevelDebug)
+		logger := testutil.Logger(t)
 		ctx := testutil.Context(t, testutil.WaitLong)
 		w1IP := tailnet.TailscaleServicePrefix.RandomAddr()
 		w1, err := tailnet.NewConn(&tailnet.Options{
@@ -104,7 +102,7 @@ func TestTailnet(t *testing.T) {
 
 	t.Run("ForcesWebSockets", func(t *testing.T) {
 		t.Parallel()
-		logger := slogtest.Make(t, nil).Leveled(slog.LevelDebug)
+		logger := testutil.Logger(t)
 		ctx := testutil.Context(t, testutil.WaitMedium)
 
 		w1IP := tailnet.TailscaleServicePrefix.RandomAddr()
@@ -167,7 +165,7 @@ func TestTailnet(t *testing.T) {
 
 	t.Run("PingDirect", func(t *testing.T) {
 		t.Parallel()
-		logger := slogtest.Make(t, nil).Leveled(slog.LevelDebug)
+		logger := testutil.Logger(t)
 		ctx := testutil.Context(t, testutil.WaitLong)
 		w1IP := tailnet.TailscaleServicePrefix.RandomAddr()
 		w1, err := tailnet.NewConn(&tailnet.Options{
@@ -210,7 +208,7 @@ func TestTailnet(t *testing.T) {
 
 	t.Run("PingDERPOnly", func(t *testing.T) {
 		t.Parallel()
-		logger := slogtest.Make(t, nil).Leveled(slog.LevelDebug)
+		logger := testutil.Logger(t)
 		ctx := testutil.Context(t, testutil.WaitLong)
 		w1IP := tailnet.TailscaleServicePrefix.RandomAddr()
 		w1, err := tailnet.NewConn(&tailnet.Options{
@@ -259,7 +257,7 @@ func TestConn_PreferredDERP(t *testing.T) {
 	t.Parallel()
 	ctx, cancel := context.WithTimeout(context.Background(), testutil.WaitShort)
 	defer cancel()
-	logger := slogtest.Make(t, nil).Leveled(slog.LevelDebug)
+	logger := testutil.Logger(t)
 	derpMap, _ := tailnettest.RunDERPAndSTUN(t)
 	conn, err := tailnet.NewConn(&tailnet.Options{
 		Addresses: []netip.Prefix{tailnet.TailscaleServicePrefix.RandomPrefix()},
@@ -288,7 +286,7 @@ func TestConn_PreferredDERP(t *testing.T) {
 // preferred DERP server and new connections can be made from clients.
 func TestConn_UpdateDERP(t *testing.T) {
 	t.Parallel()
-	logger := slogtest.Make(t, nil).Leveled(slog.LevelDebug)
+	logger := testutil.Logger(t)
 
 	derpMap1, _ := tailnettest.RunDERPAndSTUN(t)
 	ip := tailnet.TailscaleServicePrefix.RandomAddr()
@@ -421,7 +419,7 @@ parentLoop:
 
 func TestConn_BlockEndpoints(t *testing.T) {
 	t.Parallel()
-	logger := slogtest.Make(t, nil).Leveled(slog.LevelDebug)
+	logger := testutil.Logger(t)
 
 	derpMap, _ := tailnettest.RunDERPAndSTUN(t)
 

tailnet/controllers_test.go

@@ -40,7 +40,7 @@ var unimplementedError = drpcerr.WithCode(xerrors.New("Unimplemented"), drpcerr.
 func TestInMemoryCoordination(t *testing.T) {
 	t.Parallel()
 	ctx := testutil.Context(t, testutil.WaitShort)
-	logger := slogtest.Make(t, nil).Leveled(slog.LevelDebug)
+	logger := testutil.Logger(t)
 	clientID := uuid.UUID{1}
 	agentID := uuid.UUID{2}
 	mCoord := tailnettest.NewMockCoordinator(gomock.NewController(t))
@@ -67,7 +67,7 @@ func TestInMemoryCoordination(t *testing.T) {
 func TestTunnelSrcCoordController_Mainline(t *testing.T) {
 	t.Parallel()
 	ctx := testutil.Context(t, testutil.WaitShort)
-	logger := slogtest.Make(t, nil).Leveled(slog.LevelDebug)
+	logger := testutil.Logger(t)
 	clientID := uuid.UUID{1}
 	agentID := uuid.UUID{2}
 	mCoord := tailnettest.NewMockCoordinator(gomock.NewController(t))
@@ -124,7 +124,7 @@ func TestTunnelSrcCoordController_Mainline(t *testing.T) {
 func TestTunnelSrcCoordController_AddDestination(t *testing.T) {
 	t.Parallel()
 	ctx := testutil.Context(t, testutil.WaitShort)
-	logger := slogtest.Make(t, nil).Leveled(slog.LevelDebug)
+	logger := testutil.Logger(t)
 
 	fConn := &fakeCoordinatee{}
 	uut := tailnet.NewTunnelSrcCoordController(logger, fConn)
@@ -193,7 +193,7 @@ func TestTunnelSrcCoordController_AddDestination(t *testing.T) {
 func TestTunnelSrcCoordController_RemoveDestination(t *testing.T) {
 	t.Parallel()
 	ctx := testutil.Context(t, testutil.WaitShort)
-	logger := slogtest.Make(t, nil).Leveled(slog.LevelDebug)
+	logger := testutil.Logger(t)
 
 	fConn := &fakeCoordinatee{}
 	uut := tailnet.NewTunnelSrcCoordController(logger, fConn)
@@ -253,7 +253,7 @@ func TestTunnelSrcCoordController_RemoveDestination(t *testing.T) {
 func TestTunnelSrcCoordController_RemoveDestination_Error(t *testing.T) {
 	t.Parallel()
 	ctx := testutil.Context(t, testutil.WaitShort)
-	logger := slogtest.Make(t, nil).Leveled(slog.LevelDebug)
+	logger := testutil.Logger(t)
 
 	fConn := &fakeCoordinatee{}
 	uut := tailnet.NewTunnelSrcCoordController(logger, fConn)
@@ -311,7 +311,7 @@ func TestTunnelSrcCoordController_RemoveDestination_Error(t *testing.T) {
 func TestTunnelSrcCoordController_Sync(t *testing.T) {
 	t.Parallel()
 	ctx := testutil.Context(t, testutil.WaitShort)
-	logger := slogtest.Make(t, nil).Leveled(slog.LevelDebug)
+	logger := testutil.Logger(t)
 
 	fConn := &fakeCoordinatee{}
 	uut := tailnet.NewTunnelSrcCoordController(logger, fConn)
@@ -366,7 +366,7 @@ func TestTunnelSrcCoordController_Sync(t *testing.T) {
 func TestTunnelSrcCoordController_AddDestination_Error(t *testing.T) {
 	t.Parallel()
 	ctx := testutil.Context(t, testutil.WaitShort)
-	logger := slogtest.Make(t, nil).Leveled(slog.LevelDebug)
+	logger := testutil.Logger(t)
 
 	fConn := &fakeCoordinatee{}
 	uut := tailnet.NewTunnelSrcCoordController(logger, fConn)
@@ -406,7 +406,7 @@ func TestTunnelSrcCoordController_AddDestination_Error(t *testing.T) {
 func TestAgentCoordinationController_SendsReadyForHandshake(t *testing.T) {
 	t.Parallel()
 	ctx := testutil.Context(t, testutil.WaitShort)
-	logger := slogtest.Make(t, nil).Leveled(slog.LevelDebug)
+	logger := testutil.Logger(t)
 	clientID := uuid.UUID{1}
 	agentID := uuid.UUID{2}
 	mCoord := tailnettest.NewMockCoordinator(gomock.NewController(t))
@@ -584,7 +584,7 @@ func (f *fakeCoordinatee) SetNodeCallback(callback func(*tailnet.Node)) {
 func TestNewBasicDERPController_Mainline(t *testing.T) {
 	t.Parallel()
 	fs := make(chan *tailcfg.DERPMap)
-	logger := slogtest.Make(t, nil).Leveled(slog.LevelDebug)
+	logger := testutil.Logger(t)
 	uut := tailnet.NewBasicDERPController(logger, fakeSetter(fs))
 	fc := fakeDERPClient{
 		ch: make(chan *tailcfg.DERPMap),
@@ -607,7 +607,7 @@ func TestNewBasicDERPController_Mainline(t *testing.T) {
 func TestNewBasicDERPController_RecvErr(t *testing.T) {
 	t.Parallel()
 	fs := make(chan *tailcfg.DERPMap)
-	logger := slogtest.Make(t, nil).Leveled(slog.LevelDebug)
+	logger := testutil.Logger(t)
 	uut := tailnet.NewBasicDERPController(logger, fakeSetter(fs))
 	expectedErr := xerrors.New("a bad thing happened")
 	fc := fakeDERPClient{
@@ -653,7 +653,7 @@ func (f fakeDERPClient) Recv() (*tailcfg.DERPMap, error) {
 func TestBasicTelemetryController_Success(t *testing.T) {
 	t.Parallel()
 	ctx := testutil.Context(t, testutil.WaitShort)
-	logger := slogtest.Make(t, nil).Leveled(slog.LevelDebug)
+	logger := testutil.Logger(t)
 
 	uut := tailnet.NewBasicTelemetryController(logger)
 	ft := newFakeTelemetryClient()
@@ -678,7 +678,7 @@ func TestBasicTelemetryController_Success(t *testing.T) {
 func TestBasicTelemetryController_Unimplemented(t *testing.T) {
 	t.Parallel()
 	ctx := testutil.Context(t, testutil.WaitShort)
-	logger := slogtest.Make(t, nil).Leveled(slog.LevelDebug)
+	logger := testutil.Logger(t)
 
 	ft := newFakeTelemetryClient()
 
@@ -735,7 +735,7 @@ func TestBasicTelemetryController_Unimplemented(t *testing.T) {
 func TestBasicTelemetryController_NotRecognised(t *testing.T) {
 	t.Parallel()
 	ctx := testutil.Context(t, testutil.WaitShort)
-	logger := slogtest.Make(t, nil).Leveled(slog.LevelDebug)
+	logger := testutil.Logger(t)
 	ft := newFakeTelemetryClient()
 	uut := tailnet.NewBasicTelemetryController(logger)
 	uut.New(ft)
@@ -807,7 +807,7 @@ type fakeTelemetryCall struct {
 func TestBasicResumeTokenController_Mainline(t *testing.T) {
 	t.Parallel()
 	ctx := testutil.Context(t, testutil.WaitShort)
-	logger := slogtest.Make(t, nil).Leveled(slog.LevelDebug)
+	logger := testutil.Logger(t)
 	fr := newFakeResumeTokenClient(ctx)
 	mClock := quartz.NewMock(t)
 	trp := mClock.Trap().TimerReset("basicResumeTokenRefresher", "refresh")
@@ -865,7 +865,7 @@ func TestBasicResumeTokenController_Mainline(t *testing.T) {
 func TestBasicResumeTokenController_NewWhileRefreshing(t *testing.T) {
 	t.Parallel()
 	ctx := testutil.Context(t, testutil.WaitShort)
-	logger := slogtest.Make(t, nil).Leveled(slog.LevelDebug)
+	logger := testutil.Logger(t)
 	mClock := quartz.NewMock(t)
 	trp := mClock.Trap().TimerReset("basicResumeTokenRefresher", "refresh")
 	defer trp.Close()
@@ -937,7 +937,7 @@ func TestBasicResumeTokenController_NewWhileRefreshing(t *testing.T) {
 func TestBasicResumeTokenController_Unimplemented(t *testing.T) {
 	t.Parallel()
 	ctx := testutil.Context(t, testutil.WaitShort)
-	logger := slogtest.Make(t, nil).Leveled(slog.LevelDebug)
+	logger := testutil.Logger(t)
 	mClock := quartz.NewMock(t)
 
 	uut := tailnet.NewBasicResumeTokenController(logger, mClock)
@@ -1076,7 +1076,7 @@ func TestController_Disconnects(t *testing.T) {
 func TestController_TelemetrySuccess(t *testing.T) {
 	t.Parallel()
 	ctx := testutil.Context(t, testutil.WaitShort)
-	logger := slogtest.Make(t, nil).Leveled(slog.LevelDebug)
+	logger := testutil.Logger(t)
 	agentID := uuid.UUID{0x55}
 	clientID := uuid.UUID{0x66}
 	fCoord := tailnettest.NewFakeCoordinator()
@@ -1493,7 +1493,7 @@ func setupConnectedAllWorkspaceUpdatesController(
 func TestTunnelAllWorkspaceUpdatesController_Initial(t *testing.T) {
 	t.Parallel()
 	ctx := testutil.Context(t, testutil.WaitShort)
-	logger := slogtest.Make(t, nil).Leveled(slog.LevelDebug)
+	logger := testutil.Logger(t)
 
 	fDNS := newFakeDNSSetter(ctx, t)
 	coordC, updateC := setupConnectedAllWorkspaceUpdatesController(ctx, t, logger, fDNS)
@@ -1544,7 +1544,7 @@ func TestTunnelAllWorkspaceUpdatesController_Initial(t *testing.T) {
 func TestTunnelAllWorkspaceUpdatesController_DeleteAgent(t *testing.T) {
 	t.Parallel()
 	ctx := testutil.Context(t, testutil.WaitShort)
-	logger := slogtest.Make(t, nil).Leveled(slog.LevelDebug)
+	logger := testutil.Logger(t)
 
 	fDNS := newFakeDNSSetter(ctx, t)
 	coordC, updateC := setupConnectedAllWorkspaceUpdatesController(ctx, t, logger, fDNS)

tailnet/coordinator_test.go

@@ -20,7 +20,7 @@ func TestCoordinator(t *testing.T) {
 	t.Parallel()
 	t.Run("ClientWithoutAgent", func(t *testing.T) {
 		t.Parallel()
-		logger := slogtest.Make(t, nil).Leveled(slog.LevelDebug)
+		logger := testutil.Logger(t)
 		ctx := testutil.Context(t, testutil.WaitShort)
 		coordinator := tailnet.NewCoordinator(logger)
 		defer func() {
@@ -63,7 +63,7 @@ func TestCoordinator(t *testing.T) {
 
 	t.Run("AgentWithoutClients", func(t *testing.T) {
 		t.Parallel()
-		logger := slogtest.Make(t, nil).Leveled(slog.LevelDebug)
+		logger := testutil.Logger(t)
 		ctx := testutil.Context(t, testutil.WaitShort)
 		coordinator := tailnet.NewCoordinator(logger)
 		defer func() {
@@ -127,7 +127,7 @@ func TestCoordinator(t *testing.T) {
 
 	t.Run("AgentWithClient", func(t *testing.T) {
 		t.Parallel()
-		logger := slogtest.Make(t, nil).Leveled(slog.LevelDebug)
+		logger := testutil.Logger(t)
 		coordinator := tailnet.NewCoordinator(logger)
 		defer func() {
 			err := coordinator.Close()
@@ -166,7 +166,7 @@ func TestCoordinator(t *testing.T) {
 
 	t.Run("AgentDoubleConnect", func(t *testing.T) {
 		t.Parallel()
-		logger := slogtest.Make(t, nil).Leveled(slog.LevelDebug)
+		logger := testutil.Logger(t)
 		coordinator := tailnet.NewCoordinator(logger)
 		ctx := testutil.Context(t, testutil.WaitShort)
 
@@ -203,7 +203,7 @@ func TestCoordinator(t *testing.T) {
 
 	t.Run("AgentAck", func(t *testing.T) {
 		t.Parallel()
-		logger := slogtest.Make(t, nil).Leveled(slog.LevelDebug)
+		logger := testutil.Logger(t)
 		coordinator := tailnet.NewCoordinator(logger)
 		ctx := testutil.Context(t, testutil.WaitShort)
 
@@ -212,7 +212,7 @@ func TestCoordinator(t *testing.T) {
 
 	t.Run("AgentAck_NoPermission", func(t *testing.T) {
 		t.Parallel()
-		logger := slogtest.Make(t, nil).Leveled(slog.LevelDebug)
+		logger := testutil.Logger(t)
 		coordinator := tailnet.NewCoordinator(logger)
 		ctx := testutil.Context(t, testutil.WaitShort)
 
@@ -222,7 +222,7 @@ func TestCoordinator(t *testing.T) {
 
 func TestCoordinator_BidirectionalTunnels(t *testing.T) {
 	t.Parallel()
-	logger := slogtest.Make(t, nil).Leveled(slog.LevelDebug)
+	logger := testutil.Logger(t)
 	coordinator := tailnet.NewCoordinator(logger)
 	ctx := testutil.Context(t, testutil.WaitShort)
 	test.BidirectionalTunnels(ctx, t, coordinator)
@@ -230,7 +230,7 @@ func TestCoordinator_BidirectionalTunnels(t *testing.T) {
 
 func TestCoordinator_GracefulDisconnect(t *testing.T) {
 	t.Parallel()
-	logger := slogtest.Make(t, nil).Leveled(slog.LevelDebug)
+	logger := testutil.Logger(t)
 	coordinator := tailnet.NewCoordinator(logger)
 	ctx := testutil.Context(t, testutil.WaitShort)
 	test.GracefulDisconnectTest(ctx, t, coordinator)
@@ -238,7 +238,7 @@ func TestCoordinator_GracefulDisconnect(t *testing.T) {
 
 func TestCoordinator_Lost(t *testing.T) {
 	t.Parallel()
-	logger := slogtest.Make(t, nil).Leveled(slog.LevelDebug)
+	logger := testutil.Logger(t)
 	coordinator := tailnet.NewCoordinator(logger)
 	ctx := testutil.Context(t, testutil.WaitShort)
 	test.LostTest(ctx, t, coordinator)
@@ -250,7 +250,7 @@ func TestCoordinatorPropogatedPeerContext(t *testing.T) {
 	t.Parallel()
 
 	ctx := testutil.Context(t, testutil.WaitShort)
-	logger := slogtest.Make(t, nil).Leveled(slog.LevelDebug)
+	logger := testutil.Logger(t)
 
 	peerCtx := context.WithValue(ctx, test.FakeSubjectKey{}, struct{}{})
 	peerCtx, peerCtxCancel := context.WithCancel(peerCtx)

tailnet/node_internal_test.go

@@ -14,15 +14,13 @@ import (
 	"tailscale.com/types/key"
 	"tailscale.com/wgengine"
 
-	"cdr.dev/slog"
-	"cdr.dev/slog/sloggers/slogtest"
 	"github.com/coder/coder/v2/testutil"
 )
 
 func TestNodeUpdater_setNetInfo_different(t *testing.T) {
 	t.Parallel()
 	ctx := testutil.Context(t, testutil.WaitShort)
-	logger := slogtest.Make(t, nil).Leveled(slog.LevelDebug)
+	logger := testutil.Logger(t)
 	id := tailcfg.NodeID(1)
 	nodeKey := key.NewNode().Public()
 	discoKey := key.NewDisco().Public()
@@ -75,7 +73,7 @@ func TestNodeUpdater_setNetInfo_different(t *testing.T) {
 func TestNodeUpdater_setNetInfo_same(t *testing.T) {
 	t.Parallel()
 	ctx := testutil.Context(t, testutil.WaitShort)
-	logger := slogtest.Make(t, nil).Leveled(slog.LevelDebug)
+	logger := testutil.Logger(t)
 	id := tailcfg.NodeID(1)
 	nodeKey := key.NewNode().Public()
 	discoKey := key.NewDisco().Public()
@@ -116,7 +114,7 @@ func TestNodeUpdater_setNetInfo_same(t *testing.T) {
 func TestNodeUpdater_setDERPForcedWebsocket_different(t *testing.T) {
 	t.Parallel()
 	ctx := testutil.Context(t, testutil.WaitShort)
-	logger := slogtest.Make(t, nil).Leveled(slog.LevelDebug)
+	logger := testutil.Logger(t)
 	id := tailcfg.NodeID(1)
 	nodeKey := key.NewNode().Public()
 	discoKey := key.NewDisco().Public()
@@ -155,7 +153,7 @@ func TestNodeUpdater_setDERPForcedWebsocket_different(t *testing.T) {
 func TestNodeUpdater_setDERPForcedWebsocket_same(t *testing.T) {
 	t.Parallel()
 	ctx := testutil.Context(t, testutil.WaitShort)
-	logger := slogtest.Make(t, nil).Leveled(slog.LevelDebug)
+	logger := testutil.Logger(t)
 	id := tailcfg.NodeID(1)
 	nodeKey := key.NewNode().Public()
 	discoKey := key.NewDisco().Public()
@@ -193,7 +191,7 @@ func TestNodeUpdater_setDERPForcedWebsocket_same(t *testing.T) {
 func TestNodeUpdater_setStatus_different(t *testing.T) {
 	t.Parallel()
 	ctx := testutil.Context(t, testutil.WaitShort)
-	logger := slogtest.Make(t, nil).Leveled(slog.LevelDebug)
+	logger := testutil.Logger(t)
 	id := tailcfg.NodeID(1)
 	nodeKey := key.NewNode().Public()
 	discoKey := key.NewDisco().Public()
@@ -243,7 +241,7 @@ func TestNodeUpdater_setStatus_different(t *testing.T) {
 func TestNodeUpdater_setStatus_same(t *testing.T) {
 	t.Parallel()
 	ctx := testutil.Context(t, testutil.WaitShort)
-	logger := slogtest.Make(t, nil).Leveled(slog.LevelDebug)
+	logger := testutil.Logger(t)
 	id := tailcfg.NodeID(1)
 	nodeKey := key.NewNode().Public()
 	discoKey := key.NewDisco().Public()
@@ -283,7 +281,7 @@ func TestNodeUpdater_setStatus_same(t *testing.T) {
 func TestNodeUpdater_setStatus_error(t *testing.T) {
 	t.Parallel()
 	ctx := testutil.Context(t, testutil.WaitShort)
-	logger := slogtest.Make(t, nil).Leveled(slog.LevelDebug)
+	logger := testutil.Logger(t)
 	id := tailcfg.NodeID(1)
 	nodeKey := key.NewNode().Public()
 	discoKey := key.NewDisco().Public()
@@ -321,7 +319,7 @@ func TestNodeUpdater_setStatus_error(t *testing.T) {
 func TestNodeUpdater_setStatus_outdated(t *testing.T) {
 	t.Parallel()
 	ctx := testutil.Context(t, testutil.WaitShort)
-	logger := slogtest.Make(t, nil).Leveled(slog.LevelDebug)
+	logger := testutil.Logger(t)
 	id := tailcfg.NodeID(1)
 	nodeKey := key.NewNode().Public()
 	discoKey := key.NewDisco().Public()
@@ -363,7 +361,7 @@ func TestNodeUpdater_setStatus_outdated(t *testing.T) {
 func TestNodeUpdater_setAddresses_different(t *testing.T) {
 	t.Parallel()
 	ctx := testutil.Context(t, testutil.WaitShort)
-	logger := slogtest.Make(t, nil).Leveled(slog.LevelDebug)
+	logger := testutil.Logger(t)
 	id := tailcfg.NodeID(1)
 	nodeKey := key.NewNode().Public()
 	discoKey := key.NewDisco().Public()
@@ -404,7 +402,7 @@ func TestNodeUpdater_setAddresses_different(t *testing.T) {
 func TestNodeUpdater_setAddresses_same(t *testing.T) {
 	t.Parallel()
 	ctx := testutil.Context(t, testutil.WaitShort)
-	logger := slogtest.Make(t, nil).Leveled(slog.LevelDebug)
+	logger := testutil.Logger(t)
 	id := tailcfg.NodeID(1)
 	nodeKey := key.NewNode().Public()
 	discoKey := key.NewDisco().Public()
@@ -443,7 +441,7 @@ func TestNodeUpdater_setAddresses_same(t *testing.T) {
 func TestNodeUpdater_setCallback(t *testing.T) {
 	t.Parallel()
 	ctx := testutil.Context(t, testutil.WaitShort)
-	logger := slogtest.Make(t, nil).Leveled(slog.LevelDebug)
+	logger := testutil.Logger(t)
 	id := tailcfg.NodeID(1)
 	nodeKey := key.NewNode().Public()
 	discoKey := key.NewDisco().Public()
@@ -484,7 +482,7 @@ func TestNodeUpdater_setCallback(t *testing.T) {
 func TestNodeUpdater_setBlockEndpoints_different(t *testing.T) {
 	t.Parallel()
 	ctx := testutil.Context(t, testutil.WaitShort)
-	logger := slogtest.Make(t, nil).Leveled(slog.LevelDebug)
+	logger := testutil.Logger(t)
 	id := tailcfg.NodeID(1)
 	nodeKey := key.NewNode().Public()
 	discoKey := key.NewDisco().Public()
@@ -533,7 +531,7 @@ func TestNodeUpdater_setBlockEndpoints_different(t *testing.T) {
 func TestNodeUpdater_setBlockEndpoints_same(t *testing.T) {
 	t.Parallel()
 	ctx := testutil.Context(t, testutil.WaitShort)
-	logger := slogtest.Make(t, nil).Leveled(slog.LevelDebug)
+	logger := testutil.Logger(t)
 	id := tailcfg.NodeID(1)
 	nodeKey := key.NewNode().Public()
 	discoKey := key.NewDisco().Public()
@@ -571,7 +569,7 @@ func TestNodeUpdater_setBlockEndpoints_same(t *testing.T) {
 func TestNodeUpdater_fillPeerDiagnostics(t *testing.T) {
 	t.Parallel()
 	ctx := testutil.Context(t, testutil.WaitShort)
-	logger := slogtest.Make(t, nil).Leveled(slog.LevelDebug)
+	logger := testutil.Logger(t)
 	id := tailcfg.NodeID(1)
 	nodeKey := key.NewNode().Public()
 	discoKey := key.NewDisco().Public()
@@ -619,7 +617,7 @@ func TestNodeUpdater_fillPeerDiagnostics(t *testing.T) {
 func TestNodeUpdater_fillPeerDiagnostics_noCallback(t *testing.T) {
 	t.Parallel()
 	ctx := testutil.Context(t, testutil.WaitShort)
-	logger := slogtest.Make(t, nil).Leveled(slog.LevelDebug)
+	logger := testutil.Logger(t)
 	id := tailcfg.NodeID(1)
 	nodeKey := key.NewNode().Public()
 	discoKey := key.NewDisco().Public()

tailnet/service_test.go

@@ -15,8 +15,6 @@ import (
 	"golang.org/x/xerrors"
 	"tailscale.com/tailcfg"
 
-	"cdr.dev/slog"
-	"cdr.dev/slog/sloggers/slogtest"
 	"github.com/coder/coder/v2/tailnet"
 	"github.com/coder/coder/v2/tailnet/proto"
 	"github.com/coder/coder/v2/tailnet/tailnettest"
@@ -30,7 +28,7 @@ func TestClientService_ServeClient_V2(t *testing.T) {
 	var coord tailnet.Coordinator = fCoord
 	coordPtr := atomic.Pointer[tailnet.Coordinator]{}
 	coordPtr.Store(&coord)
-	logger := slogtest.Make(t, nil).Leveled(slog.LevelDebug)
+	logger := testutil.Logger(t)
 	derpMap := &tailcfg.DERPMap{Regions: map[int]*tailcfg.DERPRegion{999: {RegionCode: "test"}}}
 
 	telemetryEvents := make(chan []*proto.TelemetryEvent, 64)
@@ -146,7 +144,7 @@ func TestClientService_ServeClient_V1(t *testing.T) {
 	var coord tailnet.Coordinator = fCoord
 	coordPtr := atomic.Pointer[tailnet.Coordinator]{}
 	coordPtr.Store(&coord)
-	logger := slogtest.Make(t, nil).Leveled(slog.LevelDebug)
+	logger := testutil.Logger(t)
 	uut, err := tailnet.NewClientService(tailnet.ClientServiceOptions{
 		Logger:                  logger,
 		CoordPtr:                &coordPtr,
@@ -322,7 +320,7 @@ func createUpdateService(t *testing.T, ctx context.Context, clientID uuid.UUID,
 	var coord tailnet.Coordinator = fCoord
 	coordPtr := atomic.Pointer[tailnet.Coordinator]{}
 	coordPtr.Store(&coord)
-	logger := slogtest.Make(t, nil).Leveled(slog.LevelDebug)
+	logger := testutil.Logger(t)
 
 	uut, err := tailnet.NewClientService(tailnet.ClientServiceOptions{
 		Logger:                   logger,

tailnet/tailnettest/tailnettest.go

@@ -19,9 +19,9 @@ import (
 	tslogger "tailscale.com/types/logger"
 	"tailscale.com/types/nettype"
 
-	"cdr.dev/slog/sloggers/slogtest"
 	"github.com/coder/coder/v2/tailnet"
 	"github.com/coder/coder/v2/tailnet/proto"
+	"github.com/coder/coder/v2/testutil"
 )
 
 //go:generate mockgen -destination ./coordinatormock.go -package tailnettest github.com/coder/coder/v2/tailnet Coordinator
@@ -50,7 +50,7 @@ func RunDERPAndSTUN(t *testing.T, opts ...DERPAndStunOption) (*tailcfg.DERPMap,
 	for _, o := range opts {
 		o(cfg)
 	}
-	logf := tailnet.Logger(slogtest.Make(t, nil))
+	logf := tailnet.Logger(testutil.Logger(t))
 	d := derp.NewServer(key.NewNode(), logf)
 	server := httptest.NewUnstartedServer(derphttp.Handler(d))
 	server.Config.ErrorLog = tslogger.StdLogger(logf)
@@ -102,7 +102,7 @@ func RunDERPAndSTUN(t *testing.T, opts ...DERPAndStunOption) (*tailcfg.DERPMap,
 // only allows WebSockets through it. Many proxies do not support
 // upgrading DERP, so this is a good fallback.
 func RunDERPOnlyWebSockets(t *testing.T) *tailcfg.DERPMap {
-	logf := tailnet.Logger(slogtest.Make(t, nil))
+	logf := tailnet.Logger(testutil.Logger(t))
 	d := derp.NewServer(key.NewNode(), logf)
 	handler := derphttp.Handler(d)
 	var closeFunc func()

tailnet/test/integration/integration_test.go

@@ -26,8 +26,6 @@ import (
 	"tailscale.com/tailcfg"
 	"tailscale.com/types/nettype"
 
-	"cdr.dev/slog"
-	"cdr.dev/slog/sloggers/slogtest"
 	"github.com/coder/coder/v2/tailnet"
 	"github.com/coder/coder/v2/tailnet/test/integration"
 	"github.com/coder/coder/v2/testutil"
@@ -158,7 +156,7 @@ func TestIntegration(t *testing.T) {
 			// isolated NetNS.
 			t.Parallel()
 
-			log := slogtest.Make(t, nil).Leveled(slog.LevelDebug)
+			log := testutil.Logger(t)
 			networking := topo.SetupNetworking(t, log)
 
 			// Useful for debugging network namespaces by avoiding cleanup.
@@ -228,7 +226,7 @@ func handleTestSubprocess(t *testing.T) {
 	}
 
 	t.Run(testName, func(t *testing.T) {
-		logger := slogtest.Make(t, nil).Leveled(slog.LevelDebug)
+		logger := testutil.Logger(t)
 		switch *role {
 		case "server":
 			logger = logger.Named("server")

testutil/logger.go

@@ -0,0 +1,47 @@
+package testutil
+
+import (
+	"context"
+	"strings"
+	"testing"
+
+	"golang.org/x/xerrors"
+
+	"cdr.dev/slog"
+	"cdr.dev/slog/sloggers/slogtest"
+)
+
+// Logger returns a "standard" testing logger, with debug level and common flaky
+// errors ignored.
+func Logger(t testing.TB) slog.Logger {
+	return slogtest.Make(
+		t, &slogtest.Options{IgnoreErrorFn: IgnoreLoggedError},
+	).Leveled(slog.LevelDebug)
+}
+
+func IgnoreLoggedError(entry slog.SinkEntry) bool {
+	err, ok := slogtest.FindFirstError(entry)
+	if !ok {
+		return false
+	}
+	// Canceled queries usually happen when we're shutting down tests, and so
+	// ignoring them should reduce flakiness.  This also includes
+	// context.Canceled and context.DeadlineExceeded errors, even if they are
+	// not part of a query.
+	return isQueryCanceledError(err)
+}
+
+// isQueryCanceledError checks if the error is due to a query being canceled. This reproduces
+// database.IsQueryCanceledError, but is reimplemented here to avoid importing the database package,
+// which would result in import loops. We also use string matching on the error PostgreSQL returns
+// to us, rather than the pq error type, because we don't want testutil, which is imported in lots
+// of places to import lib/pq, which we have our own fork of.
+func isQueryCanceledError(err error) bool {
+	if xerrors.Is(err, context.Canceled) || xerrors.Is(err, context.DeadlineExceeded) {
+		return true
+	}
+	if strings.Contains(err.Error(), "canceling statement due to user request") {
+		return true
+	}
+	return false
+}

vpn/speaker_internal_test.go

@@ -38,7 +38,7 @@ func TestSpeaker_RawPeer(t *testing.T) {
 	require.NoError(t, err)
 	err = mp.SetWriteDeadline(time.Now().Add(testutil.WaitShort))
 	require.NoError(t, err)
-	logger := slogtest.Make(t, nil).Leveled(slog.LevelDebug)
+	logger := testutil.Logger(t)
 	var tun *speaker[*TunnelMessage, *ManagerMessage, ManagerMessage]
 	errCh := make(chan error, 1)
 	go func() {
@@ -427,7 +427,7 @@ func setupSpeakers(t *testing.T) (
 	t.Cleanup(func() { _ = mp.Close() })
 	t.Cleanup(func() { _ = tp.Close() })
 	ctx := testutil.Context(t, testutil.WaitShort)
-	logger := slogtest.Make(t, nil).Leveled(slog.LevelDebug)
+	logger := testutil.Logger(t)
 
 	var tun *speaker[*TunnelMessage, *ManagerMessage, ManagerMessage]
 	var mgr *speaker[*ManagerMessage, *TunnelMessage, TunnelMessage]