tempdir: Replace use of ctxlogrus with injected logger

The ctxlogrus package is going away with the replacement being log
fields extracted from the context via `log.DebugContext()` et al.
Refactor the code to stop using ctxlogrus by injecting a logger and
using the new context-based logging methods.

20 files changed, 46 insertions, 40 deletions

diff --git a/internal/git/localrepo/bundle.go b/internal/git/localrepo/bundle.go
index f15dc219a..53a02a9b9 100644
--- a/internal/git/localrepo/bundle.go
+++ b/internal/git/localrepo/bundle.go
@@ -171,7 +171,7 @@ func (repo *Repo) FetchBundle(ctx context.Context, txManager transaction.Manager
 // createTempBundle copies reader onto the filesystem so that a path can be
 // passed to git. git-fetch does not support streaming a bundle over a pipe.
 func (repo *Repo) createTempBundle(ctx context.Context, reader io.Reader) (bundlPath string, returnErr error) {
-	tmpDir, err := tempdir.New(ctx, repo.GetStorageName(), repo.locator)
+	tmpDir, err := tempdir.New(ctx, repo.GetStorageName(), repo.logger, repo.locator)
 	if err != nil {
 		return "", fmt.Errorf("create temp bundle: %w", err)
 	}
diff --git a/internal/git/localrepo/paths_test.go b/internal/git/localrepo/paths_test.go
index b33c1444a..80d13f76d 100644
--- a/internal/git/localrepo/paths_test.go
+++ b/internal/git/localrepo/paths_test.go
@@ -73,7 +73,7 @@ func TestRepo_ObjectDirectoryPath(t *testing.T) {
 	})
 	locator := config.NewLocator(cfg)
 
-	quarantine, err := quarantine.New(ctx, repoProto, locator)
+	quarantine, err := quarantine.New(ctx, repoProto, testhelper.NewLogger(t), locator)
 	require.NoError(t, err)
 	quarantinedRepo := quarantine.QuarantinedRepo()
 
diff --git a/internal/git/quarantine/quarantine.go b/internal/git/quarantine/quarantine.go
index 14811a93a..d726822e3 100644
--- a/internal/git/quarantine/quarantine.go
+++ b/internal/git/quarantine/quarantine.go
@@ -11,6 +11,7 @@ import (
 
 	"gitlab.com/gitlab-org/gitaly/v16/internal/gitaly/storage"
 	"gitlab.com/gitlab-org/gitaly/v16/internal/helper/perm"
+	"gitlab.com/gitlab-org/gitaly/v16/internal/log"
 	"gitlab.com/gitlab-org/gitaly/v16/internal/safe"
 	"gitlab.com/gitlab-org/gitaly/v16/internal/structerr"
 	"gitlab.com/gitlab-org/gitaly/v16/internal/tempdir"
@@ -33,14 +34,14 @@ type Dir struct {
 
 // New creates a new quarantine directory and returns the directory. The repository is cleaned
 // up when the user invokes the Migrate() functionality on the Dir.
-func New(ctx context.Context, repo *gitalypb.Repository, locator storage.Locator) (*Dir, error) {
+func New(ctx context.Context, repo *gitalypb.Repository, logger log.Logger, locator storage.Locator) (*Dir, error) {
 	repoPath, err := locator.GetRepoPath(repo, storage.WithRepositoryVerificationSkipped())
 	if err != nil {
 		return nil, structerr.NewInternal("getting repo path: %w", err)
 	}
 
 	quarantineDir, err := tempdir.NewWithPrefix(ctx, repo.GetStorageName(),
-		storage.QuarantineDirectoryPrefix(repo), locator)
+		storage.QuarantineDirectoryPrefix(repo), logger, locator)
 	if err != nil {
 		return nil, fmt.Errorf("creating quarantine: %w", err)
 	}
diff --git a/internal/git/quarantine/quarantine_ext_test.go b/internal/git/quarantine/quarantine_ext_test.go
index b3aff0548..6da12de47 100644
--- a/internal/git/quarantine/quarantine_ext_test.go
+++ b/internal/git/quarantine/quarantine_ext_test.go
@@ -28,7 +28,7 @@ func TestQuarantine_localrepo(t *testing.T) {
 
 	locator := config.NewLocator(cfg)
 
-	quarantine, err := quarantine.New(ctx, repoProto, locator)
+	quarantine, err := quarantine.New(ctx, repoProto, testhelper.NewLogger(t), locator)
 	require.NoError(t, err)
 
 	quarantined := localrepo.NewTestRepo(t, cfg, quarantine.QuarantinedRepo())
diff --git a/internal/git/quarantine/quarantine_test.go b/internal/git/quarantine/quarantine_test.go
index fff85d10c..99fe12d78 100644
--- a/internal/git/quarantine/quarantine_test.go
+++ b/internal/git/quarantine/quarantine_test.go
@@ -47,9 +47,10 @@ func TestQuarantine_lifecycle(t *testing.T) {
 		SkipCreationViaService: true,
 	})
 	locator := config.NewLocator(cfg)
+	logger := testhelper.NewLogger(t)
 
 	t.Run("quarantine directory gets created", func(t *testing.T) {
-		quarantine, err := New(ctx, repo, locator)
+		quarantine, err := New(ctx, repo, logger, locator)
 		require.NoError(t, err)
 
 		relativeQuarantinePath, err := filepath.Rel(repoPath, quarantine.dir.Path())
@@ -74,7 +75,7 @@ func TestQuarantine_lifecycle(t *testing.T) {
 	t.Run("context cancellation cleans up quarantine directory", func(t *testing.T) {
 		ctx, cancel := context.WithCancel(ctx)
 
-		quarantine, err := New(ctx, repo, locator)
+		quarantine, err := New(ctx, repo, logger, locator)
 		require.NoError(t, err)
 
 		require.DirExists(t, quarantine.dir.Path())
@@ -89,6 +90,7 @@ func TestQuarantine_Migrate(t *testing.T) {
 
 	cfg := testcfg.Build(t)
 	locator := config.NewLocator(cfg)
+	logger := testhelper.NewLogger(t)
 
 	t.Run("no changes", func(t *testing.T) {
 		ctx := testhelper.Context(t)
@@ -100,7 +102,7 @@ func TestQuarantine_Migrate(t *testing.T) {
 
 		oldContents := listEntries(t, repoPath)
 
-		quarantine, err := New(ctx, repo, locator)
+		quarantine, err := New(ctx, repo, logger, locator)
 		require.NoError(t, err)
 
 		require.NoError(t, quarantine.Migrate())
@@ -118,7 +120,7 @@ func TestQuarantine_Migrate(t *testing.T) {
 		oldContents := listEntries(t, repoPath)
 		require.NotContains(t, oldContents, "objects/file")
 
-		quarantine, err := New(ctx, repo, locator)
+		quarantine, err := New(ctx, repo, logger, locator)
 		require.NoError(t, err)
 
 		require.NoError(t, os.WriteFile(filepath.Join(quarantine.dir.Path(), "file"), []byte("foobar"), perm.PublicFile))
@@ -141,7 +143,7 @@ func TestQuarantine_Migrate(t *testing.T) {
 		repoContents := listEntries(t, repoPath)
 		require.NotContains(t, repoContents, "objects/file")
 
-		quarantine, err := New(ctx, repo, locator)
+		quarantine, err := New(ctx, repo, logger, locator)
 		require.NoError(t, err)
 
 		require.Empty(t, listEntries(t, quarantine.dir.Path()))
@@ -149,7 +151,7 @@ func TestQuarantine_Migrate(t *testing.T) {
 		// Quarantine the already quarantined repository and write the object there. We expect the
 		// object to be migrated from the second level quarantine to the first level quarantine. The
 		// main repository should stay untouched.
-		recursiveQuarantine, err := New(ctx, quarantine.QuarantinedRepo(), locator)
+		recursiveQuarantine, err := New(ctx, quarantine.QuarantinedRepo(), logger, locator)
 		require.NoError(t, err)
 
 		require.NoError(t, os.WriteFile(filepath.Join(recursiveQuarantine.dir.Path(), "file"), []byte("foobar"), perm.PublicFile))
diff --git a/internal/gitaly/hook/postreceive_test.go b/internal/gitaly/hook/postreceive_test.go
index f5b40ffac..808035831 100644
--- a/internal/gitaly/hook/postreceive_test.go
+++ b/internal/gitaly/hook/postreceive_test.go
@@ -410,7 +410,7 @@ func TestPostReceive_quarantine(t *testing.T) {
 		SkipCreationViaService: true,
 	})
 
-	quarantine, err := quarantine.New(ctx, repoProto, config.NewLocator(cfg))
+	quarantine, err := quarantine.New(ctx, repoProto, testhelper.SharedLogger(t), config.NewLocator(cfg))
 	require.NoError(t, err)
 
 	quarantinedRepo := localrepo.NewTestRepo(t, cfg, quarantine.QuarantinedRepo())
diff --git a/internal/gitaly/hook/prereceive_test.go b/internal/gitaly/hook/prereceive_test.go
index e02599fce..2f276448b 100644
--- a/internal/gitaly/hook/prereceive_test.go
+++ b/internal/gitaly/hook/prereceive_test.go
@@ -219,7 +219,7 @@ func TestPrereceive_quarantine(t *testing.T) {
 		SkipCreationViaService: true,
 	})
 
-	quarantine, err := quarantine.New(ctx, repoProto, config.NewLocator(cfg))
+	quarantine, err := quarantine.New(ctx, repoProto, testhelper.SharedLogger(t), config.NewLocator(cfg))
 	require.NoError(t, err)
 
 	quarantinedRepo := localrepo.NewTestRepo(t, cfg, quarantine.QuarantinedRepo())
diff --git a/internal/gitaly/hook/update_test.go b/internal/gitaly/hook/update_test.go
index 9342a2f6e..8d8ab8e30 100644
--- a/internal/gitaly/hook/update_test.go
+++ b/internal/gitaly/hook/update_test.go
@@ -249,7 +249,7 @@ func TestUpdate_quarantine(t *testing.T) {
 		SkipCreationViaService: true,
 	})
 
-	quarantine, err := quarantine.New(ctx, repoProto, config.NewLocator(cfg))
+	quarantine, err := quarantine.New(ctx, repoProto, testhelper.SharedLogger(t), config.NewLocator(cfg))
 	require.NoError(t, err)
 
 	quarantinedRepo := localrepo.NewTestRepo(t, cfg, quarantine.QuarantinedRepo())
diff --git a/internal/gitaly/hook/updateref/update_with_hooks_test.go b/internal/gitaly/hook/updateref/update_with_hooks_test.go
index 2443cb2e8..36bfbe658 100644
--- a/internal/gitaly/hook/updateref/update_with_hooks_test.go
+++ b/internal/gitaly/hook/updateref/update_with_hooks_test.go
@@ -316,7 +316,7 @@ func TestUpdaterWithHooks_quarantine(t *testing.T) {
 
 	unquarantinedRepo := localrepo.NewTestRepo(t, cfg, repoProto)
 
-	quarantine, err := quarantine.New(ctx, repoProto, locator)
+	quarantine, err := quarantine.New(ctx, repoProto, testhelper.NewLogger(t), locator)
 	require.NoError(t, err)
 	quarantinedRepo := localrepo.NewTestRepo(t, cfg, quarantine.QuarantinedRepo())
 	blobID, err := quarantinedRepo.WriteBlob(ctx, strings.NewReader("1834298812398123"), localrepo.WriteBlobConfig{})
diff --git a/internal/gitaly/repoutil/create.go b/internal/gitaly/repoutil/create.go
index e4839cb7e..83eb2d847 100644
--- a/internal/gitaly/repoutil/create.go
+++ b/internal/gitaly/repoutil/create.go
@@ -85,7 +85,7 @@ func Create(
 		return structerr.NewAlreadyExists("repository exists already")
 	}
 
-	newRepo, newRepoDir, err := tempdir.NewRepository(ctx, repository.GetStorageName(), locator)
+	newRepo, newRepoDir, err := tempdir.NewRepository(ctx, repository.GetStorageName(), logger, locator)
 	if err != nil {
 		return fmt.Errorf("creating temporary repository: %w", err)
 	}
diff --git a/internal/gitaly/repoutil/custom_hooks.go b/internal/gitaly/repoutil/custom_hooks.go
index 7ac343724..f81d827e8 100644
--- a/internal/gitaly/repoutil/custom_hooks.go
+++ b/internal/gitaly/repoutil/custom_hooks.go
@@ -133,7 +133,7 @@ func SetCustomHooks(
 	// temporarily store the current repository hooks. This enables "atomic"
 	// directory swapping by acting as an intermediary storage location between
 	// moves.
-	tmpDir, err := tempdir.NewWithoutContext(repo.GetStorageName(), locator)
+	tmpDir, err := tempdir.NewWithoutContext(repo.GetStorageName(), logger, locator)
 	if err != nil {
 		return fmt.Errorf("creating temp directory: %w", err)
 	}
diff --git a/internal/gitaly/service/blob/blobs_test.go b/internal/gitaly/service/blob/blobs_test.go
index 78dcd2bf5..f1ccd5e5e 100644
--- a/internal/gitaly/service/blob/blobs_test.go
+++ b/internal/gitaly/service/blob/blobs_test.go
@@ -311,7 +311,7 @@ func TestListAllBlobs(t *testing.T) {
 
 	repo, _, _ := setupRepoWithLFS(t, ctx, cfg)
 
-	quarantine, err := quarantine.New(ctx, gittest.RewrittenRepository(t, ctx, cfg, repo), config.NewLocator(cfg))
+	quarantine, err := quarantine.New(ctx, gittest.RewrittenRepository(t, ctx, cfg, repo), testhelper.NewLogger(t), config.NewLocator(cfg))
 	require.NoError(t, err)
 
 	// quarantine.New in Gitaly would receive an already rewritten repository. Gitaly would then calculate
diff --git a/internal/gitaly/service/blob/lfs_pointers_test.go b/internal/gitaly/service/blob/lfs_pointers_test.go
index adc7dff08..a61336005 100644
--- a/internal/gitaly/service/blob/lfs_pointers_test.go
+++ b/internal/gitaly/service/blob/lfs_pointers_test.go
@@ -217,7 +217,7 @@ size 12345`
 			setup: func(t *testing.T) setupData {
 				repo, _, _ := setupRepoWithLFS(t, ctx, cfg)
 
-				quarantineDir, err := quarantine.New(ctx, gittest.RewrittenRepository(t, ctx, cfg, repo), config.NewLocator(cfg))
+				quarantineDir, err := quarantine.New(ctx, gittest.RewrittenRepository(t, ctx, cfg, repo), testhelper.NewLogger(t), config.NewLocator(cfg))
 				require.NoError(t, err)
 
 				repo.GitObjectDirectory = quarantineDir.QuarantinedRepo().GitObjectDirectory
@@ -240,7 +240,7 @@ size 12345`
 				// this case, LFS pointer checks may want to inspect all newly
 				// pushed objects, denoted by a repository proto message which only
 				// has its object directory set to the quarantine directory.
-				quarantineDir, err := quarantine.New(ctx, gittest.RewrittenRepository(t, ctx, cfg, repo), config.NewLocator(cfg))
+				quarantineDir, err := quarantine.New(ctx, gittest.RewrittenRepository(t, ctx, cfg, repo), testhelper.NewLogger(t), config.NewLocator(cfg))
 				require.NoError(t, err)
 
 				// Note that we need to continue using the non-rewritten repository
diff --git a/internal/gitaly/service/conflicts/server.go b/internal/gitaly/service/conflicts/server.go
index 40344e5c2..745380d78 100644
--- a/internal/gitaly/service/conflicts/server.go
+++ b/internal/gitaly/service/conflicts/server.go
@@ -48,7 +48,7 @@ func (s *server) localrepo(repo storage.Repository) *localrepo.Repo {
 func (s *server) quarantinedRepo(
 	ctx context.Context, repo *gitalypb.Repository,
 ) (*quarantine.Dir, *localrepo.Repo, error) {
-	quarantineDir, err := quarantine.New(ctx, repo, s.locator)
+	quarantineDir, err := quarantine.New(ctx, repo, s.logger, s.locator)
 	if err != nil {
 		return nil, nil, structerr.NewInternal("creating object quarantine: %w", err)
 	}
diff --git a/internal/gitaly/service/operations/server.go b/internal/gitaly/service/operations/server.go
index fff31edf8..9673bb2da 100644
--- a/internal/gitaly/service/operations/server.go
+++ b/internal/gitaly/service/operations/server.go
@@ -54,7 +54,7 @@ func (s *Server) localrepo(repo storage.Repository) *localrepo.Repo {
 func (s *Server) quarantinedRepo(
 	ctx context.Context, repo *gitalypb.Repository,
 ) (*quarantine.Dir, *localrepo.Repo, error) {
-	quarantineDir, err := quarantine.New(ctx, repo, s.locator)
+	quarantineDir, err := quarantine.New(ctx, repo, s.logger, s.locator)
 	if err != nil {
 		return nil, nil, structerr.NewInternal("creating object quarantine: %w", err)
 	}
diff --git a/internal/gitaly/service/repository/replicate.go b/internal/gitaly/service/repository/replicate.go
index cd8ac9ecd..74c7f7b61 100644
--- a/internal/gitaly/service/repository/replicate.go
+++ b/internal/gitaly/service/repository/replicate.go
@@ -141,7 +141,7 @@ func validateReplicateRepository(locator storage.Locator, in *gitalypb.Replicate
 func (s *server) create(ctx context.Context, in *gitalypb.ReplicateRepositoryRequest, repoPath string) error {
 	// if the directory exists, remove it
 	if _, err := os.Stat(repoPath); err == nil {
-		tempDir, err := tempdir.NewWithoutContext(in.GetRepository().GetStorageName(), s.locator)
+		tempDir, err := tempdir.NewWithoutContext(in.GetRepository().GetStorageName(), s.logger, s.locator)
 		if err != nil {
 			return err
 		}
diff --git a/internal/gitaly/service/repository/server.go b/internal/gitaly/service/repository/server.go
index b7e19c9ea..230fb4160 100644
--- a/internal/gitaly/service/repository/server.go
+++ b/internal/gitaly/service/repository/server.go
@@ -66,7 +66,7 @@ func (s *server) localrepo(repo storage.Repository) *localrepo.Repo {
 func (s *server) quarantinedRepo(
 	ctx context.Context, repo *gitalypb.Repository,
 ) (*quarantine.Dir, *localrepo.Repo, error) {
-	quarantineDir, err := quarantine.New(ctx, repo, s.locator)
+	quarantineDir, err := quarantine.New(ctx, repo, s.logger, s.locator)
 	if err != nil {
 		return nil, nil, structerr.NewInternal("creating object quarantine: %w", err)
 	}
diff --git a/internal/gitaly/service/repository/size_test.go b/internal/gitaly/service/repository/size_test.go
index 07039a724..f41cb2186 100644
--- a/internal/gitaly/service/repository/size_test.go
+++ b/internal/gitaly/service/repository/size_test.go
@@ -166,6 +166,7 @@ func TestGetObjectDirectorySize_quarantine(t *testing.T) {
 	ctx := testhelper.Context(t)
 	cfg, client := setupRepositoryService(t)
 	locator := config.NewLocator(cfg)
+	logger := testhelper.NewLogger(t)
 
 	t.Run("quarantined repo", func(t *testing.T) {
 		repo, repoPath := gittest.CreateRepository(t, ctx, cfg)
@@ -173,7 +174,7 @@ func TestGetObjectDirectorySize_quarantine(t *testing.T) {
 		gittest.WriteBlob(t, cfg, repoPath, uncompressibleData(16*1024))
 		requireObjectDirectorySize(t, ctx, client, repo, 16)
 
-		quarantine, err := quarantine.New(ctx, gittest.RewrittenRepository(t, ctx, cfg, repo), locator)
+		quarantine, err := quarantine.New(ctx, gittest.RewrittenRepository(t, ctx, cfg, repo), logger, locator)
 		require.NoError(t, err)
 
 		// quarantine.New in Gitaly would receive an already rewritten repository. Gitaly would then calculate
@@ -191,11 +192,11 @@ func TestGetObjectDirectorySize_quarantine(t *testing.T) {
 
 	t.Run("quarantined repo with different relative path", func(t *testing.T) {
 		repo1, _ := gittest.CreateRepository(t, ctx, cfg)
-		quarantine1, err := quarantine.New(ctx, gittest.RewrittenRepository(t, ctx, cfg, repo1), locator)
+		quarantine1, err := quarantine.New(ctx, gittest.RewrittenRepository(t, ctx, cfg, repo1), logger, locator)
 		require.NoError(t, err)
 
 		repo2, _ := gittest.CreateRepository(t, ctx, cfg)
-		quarantine2, err := quarantine.New(ctx, gittest.RewrittenRepository(t, ctx, cfg, repo2), locator)
+		quarantine2, err := quarantine.New(ctx, gittest.RewrittenRepository(t, ctx, cfg, repo2), logger, locator)
 		require.NoError(t, err)
 
 		// We swap out the the object directories of both quarantines. So while both are
diff --git a/internal/tempdir/tempdir.go b/internal/tempdir/tempdir.go
index 349938dd8..7ad88c469 100644
--- a/internal/tempdir/tempdir.go
+++ b/internal/tempdir/tempdir.go
@@ -15,6 +15,7 @@ import (
 
 // Dir is a storage-scoped temporary directory.
 type Dir struct {
+	logger log.Logger
 	path   string
 	doneCh chan struct{}
 }
@@ -26,15 +27,15 @@ func (d Dir) Path() string {
 
 // New returns the path of a new temporary directory for the given storage. The directory is removed
 // asynchronously with os.RemoveAll when the context expires.
-func New(ctx context.Context, storageName string, locator storage.Locator) (Dir, error) {
-	return NewWithPrefix(ctx, storageName, "repo", locator)
+func New(ctx context.Context, storageName string, logger log.Logger, locator storage.Locator) (Dir, error) {
+	return NewWithPrefix(ctx, storageName, "repo", logger, locator)
 }
 
 // NewWithPrefix returns the path of a new temporary directory for the given storage with a specific
 // prefix used to create the temporary directory's name. The directory is removed asynchronously
 // with os.RemoveAll when the context expires.
-func NewWithPrefix(ctx context.Context, storageName, prefix string, locator storage.Locator) (Dir, error) {
-	dir, err := newDirectory(ctx, storageName, prefix, locator)
+func NewWithPrefix(ctx context.Context, storageName, prefix string, logger log.Logger, locator storage.Locator) (Dir, error) {
+	dir, err := newDirectory(ctx, storageName, prefix, logger, locator)
 	if err != nil {
 		return Dir{}, err
 	}
@@ -47,20 +48,20 @@ func NewWithPrefix(ctx context.Context, storageName, prefix string, locator stor
 // NewWithoutContext returns a temporary directory for the given storage suitable which is not
 // storage scoped. The temporary directory will thus not get cleaned up when the context expires,
 // but instead when the temporary directory is older than MaxAge.
-func NewWithoutContext(storageName string, locator storage.Locator) (Dir, error) {
+func NewWithoutContext(storageName string, logger log.Logger, locator storage.Locator) (Dir, error) {
 	prefix := fmt.Sprintf("%s-repositories.old.%d.", storageName, time.Now().Unix())
-	return newDirectory(context.Background(), storageName, prefix, locator)
+	return newDirectory(context.Background(), storageName, prefix, logger, locator)
 }
 
 // NewRepository is the same as New, but it returns a *gitalypb.Repository for the created directory
 // as well as the bare path as a string.
-func NewRepository(ctx context.Context, storageName string, locator storage.Locator) (*gitalypb.Repository, Dir, error) {
+func NewRepository(ctx context.Context, storageName string, logger log.Logger, locator storage.Locator) (*gitalypb.Repository, Dir, error) {
 	storagePath, err := locator.GetStorageByName(storageName)
 	if err != nil {
 		return nil, Dir{}, err
 	}
 
-	dir, err := New(ctx, storageName, locator)
+	dir, err := New(ctx, storageName, logger, locator)
 	if err != nil {
 		return nil, Dir{}, err
 	}
@@ -74,7 +75,7 @@ func NewRepository(ctx context.Context, storageName string, locator storage.Loca
 	return newRepo, dir, nil
 }
 
-func newDirectory(ctx context.Context, storageName string, prefix string, loc storage.Locator) (Dir, error) {
+func newDirectory(ctx context.Context, storageName string, prefix string, logger log.Logger, loc storage.Locator) (Dir, error) {
 	root, err := loc.TempDir(storageName)
 	if err != nil {
 		return Dir{}, fmt.Errorf("temp directory: %w", err)
@@ -90,6 +91,7 @@ func newDirectory(ctx context.Context, storageName string, prefix string, loc st
 	}
 
 	return Dir{
+		logger: logger,
 		path:   tempDir,
 		doneCh: make(chan struct{}),
 	}, err
@@ -98,7 +100,7 @@ func newDirectory(ctx context.Context, storageName string, prefix string, loc st
 func (d Dir) cleanupOnDone(ctx context.Context) {
 	<-ctx.Done()
 	if err := os.RemoveAll(d.Path()); err != nil {
-		log.FromContext(ctx).WithError(err).WithField("temporary_directory", d.Path).Error("failed to cleanup temp dir")
+		d.logger.WithError(err).WithField("temporary_directory", d.Path).ErrorContext(ctx, "failed to cleanup temp dir")
 	}
 	close(d.doneCh)
 }
diff --git a/internal/tempdir/tempdir_test.go b/internal/tempdir/tempdir_test.go
index 61aaba1eb..c625b7d4b 100644
--- a/internal/tempdir/tempdir_test.go
+++ b/internal/tempdir/tempdir_test.go
@@ -20,7 +20,7 @@ func TestNewRepositorySuccess(t *testing.T) {
 	cfg := testcfg.Build(t)
 	locator := config.NewLocator(cfg)
 
-	repo, tempDir, err := NewRepository(ctx, cfg.Storages[0].Name, locator)
+	repo, tempDir, err := NewRepository(ctx, cfg.Storages[0].Name, testhelper.NewLogger(t), locator)
 	require.NoError(t, err)
 	require.Equal(t, cfg.Storages[0].Name, repo.StorageName)
 	require.Contains(t, repo.RelativePath, tmpRootPrefix)
@@ -44,7 +44,7 @@ func TestNewWithPrefix(t *testing.T) {
 	locator := config.NewLocator(cfg)
 	ctx := testhelper.Context(t)
 
-	dir, err := NewWithPrefix(ctx, cfg.Storages[0].Name, "foobar-", locator)
+	dir, err := NewWithPrefix(ctx, cfg.Storages[0].Name, "foobar-", testhelper.NewLogger(t), locator)
 	require.NoError(t, err)
 
 	require.Contains(t, dir.Path(), "/foobar-")
@@ -52,6 +52,6 @@ func TestNewWithPrefix(t *testing.T) {
 
 func TestNewAsRepositoryFailStorageUnknown(t *testing.T) {
 	ctx := testhelper.Context(t)
-	_, err := New(ctx, "does-not-exist", config.NewLocator(config.Cfg{}))
+	_, err := New(ctx, "does-not-exist", testhelper.NewLogger(t), config.NewLocator(config.Cfg{}))
 	require.Error(t, err)
 }