@@ -141,7 +141,7 @@ func (daemon *Daemon) containerAttach(c *container.Container, cfg *stream.Attach

 		if !ok {

 			return logger.ErrReadLogsNotSupported{}

 		}

-		logs := cLog.ReadLogs(logger.ReadConfig{Tail: -1})

+		logs := cLog.ReadLogs(context.TODO(), logger.ReadConfig{Tail: -1})

 		defer logs.ConsumerGone()

 	LogLoop:

@@ -87,7 +87,7 @@ type pluginAdapterWithRead struct {

 	*pluginAdapter

 }

-func (a *pluginAdapterWithRead) ReadLogs(config ReadConfig) *LogWatcher {

+func (a *pluginAdapterWithRead) ReadLogs(ctx context.Context, config ReadConfig) *LogWatcher {

 	watcher := NewLogWatcher()

 	go func() {

@@ -101,6 +101,10 @@ func (a *pluginAdapterWithRead) ReadLogs(config ReadConfig) *LogWatcher {

 		dec := logdriver.NewLogEntryDecoder(stream)

 		for {

+			if ctx.Err() != nil {

+				return

+			}

+

 			var buf logdriver.LogEntry

 			if err := dec.Decode(&buf); err != nil {

 				if err == io.EOF {

@@ -127,6 +131,8 @@ func (a *pluginAdapterWithRead) ReadLogs(config ReadConfig) *LogWatcher {

 			// send the message unless the consumer is gone

 			select {

 			case watcher.Msg <- msg:

+			case <-ctx.Done():

+				return

 			case <-watcher.WatchConsumerGone():

 				return

 			}

@@ -1,6 +1,7 @@

 package logger // import "github.com/docker/docker/daemon/logger"

 import (

+	"context"

 	"encoding/binary"

 	"io"

 	"sync"

@@ -154,7 +155,7 @@ func TestAdapterReadLogs(t *testing.T) {

 	lr, ok := l.(LogReader)

 	assert.Check(t, ok, "Logger does not implement LogReader")

-	lw := lr.ReadLogs(ReadConfig{})

+	lw := lr.ReadLogs(context.TODO(), ReadConfig{})

 	for _, x := range testMsg {

 		select {

@@ -173,7 +174,7 @@ func TestAdapterReadLogs(t *testing.T) {

 	}

 	lw.ConsumerGone()

-	lw = lr.ReadLogs(ReadConfig{Follow: true})

+	lw = lr.ReadLogs(context.TODO(), ReadConfig{Follow: true})

 	for _, x := range testMsg {

 		select {

 		case msg := <-lw.Msg:

@@ -20,6 +20,8 @@ const (

 	waitInterval       = 250 * time.Millisecond

 )

+var _ logger.LogReader = (*journald)(nil)

+

 // Fields which we know are not user-provided attribute fields.

 var wellKnownFields = map[string]bool{

 	"MESSAGE":             true,

@@ -447,7 +449,7 @@ func (r *reader) signalReady() {

 	}

 }

-func (s *journald) ReadLogs(config logger.ReadConfig) *logger.LogWatcher {

+func (s *journald) ReadLogs(ctx context.Context, config logger.ReadConfig) *logger.LogWatcher {

 	r := &reader{

 		s:          s,

 		logWatcher: logger.NewLogWatcher(),

@@ -12,10 +12,12 @@ import (

 	"github.com/docker/docker/pkg/tailfile"

 )

+var _ logger.LogReader = (*JSONFileLogger)(nil)

+

 // ReadLogs implements the logger's LogReader interface for the logs

 // created by this driver.

-func (l *JSONFileLogger) ReadLogs(config logger.ReadConfig) *logger.LogWatcher {

-	return l.writer.ReadLogs(config)

+func (l *JSONFileLogger) ReadLogs(ctx context.Context, config logger.ReadConfig) *logger.LogWatcher {

+	return l.writer.ReadLogs(ctx, config)

 }

 func decodeLogLine(dec *json.Decoder, l *jsonlog.JSONLog) (*logger.Message, error) {

@@ -3,6 +3,7 @@ package jsonfilelog // import "github.com/docker/docker/daemon/logger/jsonfilelo

 import (

 	"bufio"

 	"bytes"

+	"context"

 	"fmt"

 	"io"

 	"os"

@@ -62,7 +63,7 @@ func BenchmarkJSONFileLoggerReadLogs(b *testing.B) {

 		}

 	}()

-	lw := jsonlogger.(*JSONFileLogger).ReadLogs(logger.ReadConfig{Follow: true})

+	lw := jsonlogger.(*JSONFileLogger).ReadLogs(context.TODO(), logger.ReadConfig{Follow: true})

 	for {

 		select {

 		case _, ok := <-lw.Msg:

@@ -18,8 +18,8 @@ import (

 // logger.defaultBufSize caps the size of Line field.

 const maxMsgLen int = 1e6 // 1MB.

-func (d *driver) ReadLogs(config logger.ReadConfig) *logger.LogWatcher {

-	return d.logfile.ReadLogs(config)

+func (d *driver) ReadLogs(ctx context.Context, config logger.ReadConfig) *logger.LogWatcher {

+	return d.logfile.ReadLogs(ctx, config)

 }

 func getTailReader(ctx context.Context, r loggerutils.SizeReaderAt, req int) (loggerutils.SizeReaderAt, int, error) {

@@ -8,6 +8,7 @@

 package logger // import "github.com/docker/docker/daemon/logger"

 import (

+	"context"

 	"sync"

 	"time"

@@ -88,7 +89,7 @@ type ReadConfig struct {

 // LogReader is the interface for reading log messages for loggers that support reading.

 type LogReader interface {

 	// ReadLogs reads logs from underlying logging backend.

-	ReadLogs(ReadConfig) *LogWatcher

+	ReadLogs(context.Context, ReadConfig) *LogWatcher

 }

 // LogWatcher is used when consuming logs read from the LogReader interface.

@@ -1,6 +1,7 @@

 package loggertest // import "github.com/docker/docker/daemon/logger/loggertest"

 import (

+	"context"

 	"fmt"

 	"runtime"

 	"strings"

@@ -93,63 +94,63 @@ func (tr Reader) testTail(t *testing.T, live bool) {

 	t.Run("Exact", func(t *testing.T) {

 		t.Parallel()

-		lw := lr.ReadLogs(logger.ReadConfig{Tail: len(mm)})

+		lw := lr.ReadLogs(context.TODO(), logger.ReadConfig{Tail: len(mm)})

 		defer lw.ConsumerGone()

 		assert.DeepEqual(t, readAll(t, lw), expected, compareLog)

 	})

 	t.Run("LessThanAvailable", func(t *testing.T) {

 		t.Parallel()

-		lw := lr.ReadLogs(logger.ReadConfig{Tail: 2})

+		lw := lr.ReadLogs(context.TODO(), logger.ReadConfig{Tail: 2})

 		defer lw.ConsumerGone()

 		assert.DeepEqual(t, readAll(t, lw), expected[len(mm)-2:], compareLog)

 	})

 	t.Run("MoreThanAvailable", func(t *testing.T) {

 		t.Parallel()

-		lw := lr.ReadLogs(logger.ReadConfig{Tail: 100})

+		lw := lr.ReadLogs(context.TODO(), logger.ReadConfig{Tail: 100})

 		defer lw.ConsumerGone()

 		assert.DeepEqual(t, readAll(t, lw), expected, compareLog)

 	})

 	t.Run("All", func(t *testing.T) {

 		t.Parallel()

-		lw := lr.ReadLogs(logger.ReadConfig{Tail: -1})

+		lw := lr.ReadLogs(context.TODO(), logger.ReadConfig{Tail: -1})

 		defer lw.ConsumerGone()

 		assert.DeepEqual(t, readAll(t, lw), expected, compareLog)

 	})

 	t.Run("Since", func(t *testing.T) {

 		t.Parallel()

-		lw := lr.ReadLogs(logger.ReadConfig{Tail: -1, Since: mm[1].Timestamp.Truncate(time.Millisecond)})

+		lw := lr.ReadLogs(context.TODO(), logger.ReadConfig{Tail: -1, Since: mm[1].Timestamp.Truncate(time.Millisecond)})

 		defer lw.ConsumerGone()

 		assert.DeepEqual(t, readAll(t, lw), expected[1:], compareLog)

 	})

 	t.Run("MoreThanSince", func(t *testing.T) {

 		t.Parallel()

-		lw := lr.ReadLogs(logger.ReadConfig{Tail: len(mm), Since: mm[1].Timestamp.Truncate(time.Millisecond)})

+		lw := lr.ReadLogs(context.TODO(), logger.ReadConfig{Tail: len(mm), Since: mm[1].Timestamp.Truncate(time.Millisecond)})

 		defer lw.ConsumerGone()

 		assert.DeepEqual(t, readAll(t, lw), expected[1:], compareLog)

 	})

 	t.Run("LessThanSince", func(t *testing.T) {

 		t.Parallel()

-		lw := lr.ReadLogs(logger.ReadConfig{Tail: len(mm) - 2, Since: mm[1].Timestamp.Truncate(time.Millisecond)})

+		lw := lr.ReadLogs(context.TODO(), logger.ReadConfig{Tail: len(mm) - 2, Since: mm[1].Timestamp.Truncate(time.Millisecond)})

 		defer lw.ConsumerGone()

 		assert.DeepEqual(t, readAll(t, lw), expected[2:], compareLog)

 	})

 	t.Run("Until", func(t *testing.T) {

 		t.Parallel()

-		lw := lr.ReadLogs(logger.ReadConfig{Tail: -1, Until: mm[2].Timestamp.Add(-time.Millisecond)})

+		lw := lr.ReadLogs(context.TODO(), logger.ReadConfig{Tail: -1, Until: mm[2].Timestamp.Add(-time.Millisecond)})

 		defer lw.ConsumerGone()

 		assert.DeepEqual(t, readAll(t, lw), expected[:2], compareLog)

 	})

 	t.Run("SinceAndUntil", func(t *testing.T) {

 		t.Parallel()

-		lw := lr.ReadLogs(logger.ReadConfig{Tail: -1, Since: mm[1].Timestamp.Truncate(time.Millisecond), Until: mm[1].Timestamp.Add(time.Millisecond)})

+		lw := lr.ReadLogs(context.TODO(), logger.ReadConfig{Tail: -1, Since: mm[1].Timestamp.Truncate(time.Millisecond), Until: mm[1].Timestamp.Add(time.Millisecond)})

 		defer lw.ConsumerGone()

 		assert.DeepEqual(t, readAll(t, lw), expected[1:2], compareLog)

 	})

@@ -182,7 +183,7 @@ func (tr Reader) testTailEmptyLogs(t *testing.T, live bool) {

 		tt := tt

 		t.Run(tt.name, func(t *testing.T) {

 			t.Parallel()

-			lw := l.(logger.LogReader).ReadLogs(logger.ReadConfig{})

+			lw := l.(logger.LogReader).ReadLogs(context.TODO(), logger.ReadConfig{})

 			defer lw.ConsumerGone()

 			assert.DeepEqual(t, readAll(t, lw), ([]*logger.Message)(nil), cmpopts.EquateEmpty())

 		})

@@ -204,7 +205,7 @@ func (tr Reader) TestFollow(t *testing.T) {

 				ContainerID:   fmt.Sprintf("followstart%d", i),

 				ContainerName: fmt.Sprintf("logloglog%d", i),

 			})(t)

-			lw := l.(logger.LogReader).ReadLogs(logger.ReadConfig{Tail: tail, Follow: true})

+			lw := l.(logger.LogReader).ReadLogs(context.TODO(), logger.ReadConfig{Tail: tail, Follow: true})

 			defer lw.ConsumerGone()

 			doneReading := make(chan struct{})

@@ -232,7 +233,7 @@ func (tr Reader) TestFollow(t *testing.T) {

 		mm := makeTestMessages()

 		expected := logMessages(t, l, mm[0:1])

-		lw := l.(logger.LogReader).ReadLogs(logger.ReadConfig{Tail: -1, Follow: true})

+		lw := l.(logger.LogReader).ReadLogs(context.TODO(), logger.ReadConfig{Tail: -1, Follow: true})

 		defer lw.ConsumerGone()

 		doneReading := make(chan struct{})

@@ -257,7 +258,7 @@ func (tr Reader) TestFollow(t *testing.T) {

 		mm := makeTestMessages()

-		lw := l.(logger.LogReader).ReadLogs(logger.ReadConfig{Tail: -1, Follow: true, Since: mm[2].Timestamp.Truncate(time.Millisecond)})

+		lw := l.(logger.LogReader).ReadLogs(context.TODO(), logger.ReadConfig{Tail: -1, Follow: true, Since: mm[2].Timestamp.Truncate(time.Millisecond)})

 		defer lw.ConsumerGone()

 		doneReading := make(chan struct{})

@@ -282,7 +283,7 @@ func (tr Reader) TestFollow(t *testing.T) {

 		mm := makeTestMessages()

-		lw := l.(logger.LogReader).ReadLogs(logger.ReadConfig{Tail: -1, Follow: true, Until: mm[2].Timestamp.Add(-time.Millisecond)})

+		lw := l.(logger.LogReader).ReadLogs(context.TODO(), logger.ReadConfig{Tail: -1, Follow: true, Until: mm[2].Timestamp.Add(-time.Millisecond)})

 		defer lw.ConsumerGone()

 		doneReading := make(chan struct{})

@@ -307,7 +308,7 @@ func (tr Reader) TestFollow(t *testing.T) {

 		mm := makeTestMessages()

-		lw := l.(logger.LogReader).ReadLogs(logger.ReadConfig{Tail: -1, Follow: true, Since: mm[1].Timestamp.Add(-time.Millisecond), Until: mm[2].Timestamp.Add(-time.Millisecond)})

+		lw := l.(logger.LogReader).ReadLogs(context.TODO(), logger.ReadConfig{Tail: -1, Follow: true, Since: mm[1].Timestamp.Add(-time.Millisecond), Until: mm[2].Timestamp.Add(-time.Millisecond)})

 		defer lw.ConsumerGone()

 		doneReading := make(chan struct{})

@@ -334,7 +335,7 @@ func (tr Reader) TestFollow(t *testing.T) {

 		logMessages(t, l, mm[0:2])

 		syncLogger(t, l)

-		lw := l.(logger.LogReader).ReadLogs(logger.ReadConfig{Tail: 0, Follow: true})

+		lw := l.(logger.LogReader).ReadLogs(context.TODO(), logger.ReadConfig{Tail: 0, Follow: true})

 		defer lw.ConsumerGone()

 		doneReading := make(chan struct{})

@@ -361,7 +362,7 @@ func (tr Reader) TestFollow(t *testing.T) {

 		expected := logMessages(t, l, mm[0:2])[1:]

 		syncLogger(t, l)

-		lw := l.(logger.LogReader).ReadLogs(logger.ReadConfig{Tail: 1, Follow: true})

+		lw := l.(logger.LogReader).ReadLogs(context.TODO(), logger.ReadConfig{Tail: 1, Follow: true})

 		defer lw.ConsumerGone()

 		doneReading := make(chan struct{})

@@ -390,7 +391,7 @@ func (tr Reader) TestFollow(t *testing.T) {

 		assert.NilError(t, l.Close())

 		l = factory(t)

-		lw := l.(logger.LogReader).ReadLogs(logger.ReadConfig{Tail: -1, Follow: true})

+		lw := l.(logger.LogReader).ReadLogs(context.TODO(), logger.ReadConfig{Tail: -1, Follow: true})

 		defer lw.ConsumerGone()

 		doneReading := make(chan struct{})

@@ -430,7 +431,7 @@ func (tr Reader) TestConcurrent(t *testing.T) {

 	}

 	// Follow all logs

-	lw := l.(logger.LogReader).ReadLogs(logger.ReadConfig{Follow: true, Tail: -1})

+	lw := l.(logger.LogReader).ReadLogs(context.TODO(), logger.ReadConfig{Follow: true, Tail: -1})

 	defer lw.ConsumerGone()

 	// Log concurrently from two sources and close log

@@ -24,6 +24,8 @@ var builtInCacheLogOpts = map[string]bool{

 	cacheDisabledKey: true,

 }

+var _ logger.LogReader = (*loggerWithCache)(nil)

+

 // WithLocalCache wraps the passed in logger with a logger caches all writes locally

 // in addition to writing to the passed in logger.

 func WithLocalCache(l logger.Logger, info logger.Info) (logger.Logger, error) {

@@ -85,8 +87,8 @@ func (l *loggerWithCache) Name() string {

 	return l.l.Name()

 }

-func (l *loggerWithCache) ReadLogs(config logger.ReadConfig) *logger.LogWatcher {

-	return l.cache.(logger.LogReader).ReadLogs(config)

+func (l *loggerWithCache) ReadLogs(ctx context.Context, config logger.ReadConfig) *logger.LogWatcher {

+	return l.cache.(logger.LogReader).ReadLogs(ctx, config)

 }

 func (l *loggerWithCache) Close() error {

@@ -38,7 +38,7 @@ func (fl *follow) Do(ctx context.Context, f *os.File, read logPos) {

 	}()

 	for {

-		wrote, ok := fl.nextPos(read)

+		wrote, ok := fl.nextPos(ctx, read)

 		if !ok {

 			return

 		}

@@ -100,9 +100,11 @@ func (fl *follow) Do(ctx context.Context, f *os.File, read logPos) {

 // nextPos waits until the write position of the LogFile being followed has

 // advanced from current and returns the new position.

-func (fl *follow) nextPos(current logPos) (next logPos, ok bool) {

+func (fl *follow) nextPos(ctx context.Context, current logPos) (next logPos, ok bool) {

 	var st logReadState

 	select {

+	case <-ctx.Done():

+		return current, false

 	case <-fl.Watcher.WatchConsumerGone():

 		return current, false

 	case st = <-fl.LogFile.read:

@@ -14,10 +14,13 @@ import (

 	"sync"

 	"time"

+	"github.com/containerd/containerd/tracing"

 	"github.com/containerd/log"

 	"github.com/docker/docker/daemon/logger"

 	"github.com/docker/docker/pkg/pools"

 	"github.com/pkg/errors"

+	"go.opentelemetry.io/otel/attribute"

+	"go.opentelemetry.io/otel/trace"

 )

 // rotateFileMetadata is a metadata of the gzip header of the compressed log file

@@ -373,7 +376,12 @@ func (w *LogFile) Close() error {

 // ReadLogs decodes entries from log files.

 //

 // It is the caller's responsibility to call ConsumerGone on the LogWatcher.

-func (w *LogFile) ReadLogs(config logger.ReadConfig) *logger.LogWatcher {

+func (w *LogFile) ReadLogs(ctx context.Context, config logger.ReadConfig) *logger.LogWatcher {

+	ctx, span := tracing.StartSpan(ctx, "logger.LogFile.ReadLogs")

+	defer span.End()

+

+	span.SetAttributes(tracing.Attribute("config", config))

+

 	watcher := logger.NewLogWatcher()

 	// Lock out filesystem operations so that we can capture the read

 	// position and atomically open the corresponding log file, without the

@@ -385,43 +393,57 @@ func (w *LogFile) ReadLogs(config logger.ReadConfig) *logger.LogWatcher {

 	st := <-w.read

 	pos := st.pos

 	w.read <- st

-	go w.readLogsLocked(pos, config, watcher)

+	go w.readLogsLocked(ctx, pos, config, watcher)

 	return watcher

 }

 // tailFiles must be called with w.fsopMu locked for reads.

 // w.fsopMu.RUnlock() is called before returning.

-func (w *LogFile) tailFiles(config logger.ReadConfig, watcher *logger.LogWatcher, current SizeReaderAt, dec Decoder, fwd *forwarder) bool {

+func (w *LogFile) tailFiles(ctx context.Context, config logger.ReadConfig, watcher *logger.LogWatcher, current SizeReaderAt, dec Decoder, fwd *forwarder) (cont bool) {

 	if config.Tail == 0 {

 		w.fsopMu.RUnlock()

 		return true

 	}

-	files, err := w.openRotatedFiles(config)

+	ctx, span := tracing.StartSpan(ctx, "logger.Logfile.TailLogs")

+	defer func() {

+		span.SetAttributes(attribute.Bool("continue", cont))

+		span.End()

+	}()

+

+	files, err := w.openRotatedFiles(ctx, config)

 	w.fsopMu.RUnlock()

 	if err != nil {

+		// TODO: Should we allow this to continue (as in set `cont=true`) and not error out the log stream?

+		err = errors.Wrap(err, "error opening rotated log files")

+		span.SetStatus(err)

 		watcher.Err <- err

 		return false

 	}

 	if current.Size() > 0 {

-		files = append(files, &sizeReaderAtOpener{current})

+		files = append(files, &sizeReaderAtOpener{current, "current"})

 	}

-	return tailFiles(files, watcher, dec, w.getTailReader, config.Tail, fwd)

+	return tailFiles(ctx, files, watcher, dec, w.getTailReader, config.Tail, fwd)

 }

 type sizeReaderAtOpener struct {

 	SizeReaderAt

+	ref string

 }

-func (o *sizeReaderAtOpener) ReaderAt() (sizeReaderAtCloser, error) {

+func (o *sizeReaderAtOpener) ReaderAt(context.Context) (sizeReaderAtCloser, error) {

 	return &sizeReaderAtWithCloser{o, nil}, nil

 }

 func (o *sizeReaderAtOpener) Close() {}

+func (o *sizeReaderAtOpener) Ref() string {

+	return o.ref

+}

+

 type sizeReaderAtWithCloser struct {

 	SizeReaderAt

 	close func() error

@@ -459,12 +481,16 @@ func (r *sizeReaderAtWithCloser) Close() error {

 //

 // w.fsopMu must be locked for reading when calling this method.

 // w.fsopMu.RUnlock() is called before returning.

-func (w *LogFile) readLogsLocked(currentPos logPos, config logger.ReadConfig, watcher *logger.LogWatcher) {

+func (w *LogFile) readLogsLocked(ctx context.Context, currentPos logPos, config logger.ReadConfig, watcher *logger.LogWatcher) {

+	ctx, span := tracing.StartSpan(ctx, "logger.Logfile.ReadLogsLocked")

+	defer span.End()

+

 	defer close(watcher.Msg)

 	currentFile, err := open(w.f.Name())

 	if err != nil {

 		w.fsopMu.RUnlock()

+		span.SetStatus(err)

 		watcher.Err <- err

 		return

 	}

@@ -476,7 +502,7 @@ func (w *LogFile) readLogsLocked(currentPos logPos, config logger.ReadConfig, wa

 	fwd := newForwarder(config)

 	// At this point, w.tailFiles is responsible for unlocking w.fsopmu

-	ok := w.tailFiles(config, watcher, io.NewSectionReader(currentFile, 0, currentPos.size), dec, fwd)

+	ok := w.tailFiles(ctx, config, watcher, io.NewSectionReader(currentFile, 0, currentPos.size), dec, fwd)

 	if !ok {

 		return

@@ -491,12 +517,13 @@ func (w *LogFile) readLogsLocked(currentPos logPos, config logger.ReadConfig, wa

 		Watcher:   watcher,

 		Decoder:   dec,

 		Forwarder: fwd,

-	}).Do(context.TODO(), currentFile, currentPos)

+	}).Do(ctx, currentFile, currentPos)

 }

 type fileOpener interface {

-	ReaderAt() (ra sizeReaderAtCloser, err error)

+	ReaderAt(context.Context) (ra sizeReaderAtCloser, err error)

 	Close()

+	Ref() string

 }

 // simpleFileOpener just holds a reference to an already open file

@@ -506,10 +533,11 @@ type simpleFileOpener struct {

 	closed bool

 }

-func (o *simpleFileOpener) ReaderAt() (sizeReaderAtCloser, error) {

+func (o *simpleFileOpener) ReaderAt(context.Context) (sizeReaderAtCloser, error) {

 	if o.closed {

 		return nil, errors.New("file is closed")

 	}

+

 	if o.sz == 0 {

 		stat, err := o.f.Stat()

 		if err != nil {

@@ -520,6 +548,10 @@ func (o *simpleFileOpener) ReaderAt() (sizeReaderAtCloser, error) {

 	return &sizeReaderAtWithCloser{io.NewSectionReader(o.f, 0, o.sz), nil}, nil

 }

+func (o *simpleFileOpener) Ref() string {

+	return o.f.Name()

+}

+

 func (o *simpleFileOpener) Close() {

 	_ = o.f.Close()

 	o.closed = true

@@ -552,7 +584,17 @@ type compressedFileOpener struct {

 	ifBefore time.Time

 }

-func (cfo *compressedFileOpener) ReaderAt() (_ sizeReaderAtCloser, retErr error) {

+func (cfo *compressedFileOpener) ReaderAt(ctx context.Context) (_ sizeReaderAtCloser, retErr error) {

+	_, span := tracing.StartSpan(ctx, "logger.Logfile.Compressed.ReaderAt")

+	defer func() {

+		if retErr != nil {

+			span.SetStatus(retErr)

+		}

+		span.End()

+	}()

+

+	span.SetAttributes(attribute.String("file", cfo.f.Name()))

+

 	if cfo.closed {

 		return nil, errors.New("compressed file closed")

 	}

@@ -568,9 +610,14 @@ func (cfo *compressedFileOpener) ReaderAt() (_ sizeReaderAtCloser, retErr error)

 	extra := &rotateFileMetadata{}

 	err = json.Unmarshal(gzr.Header.Extra, extra)

 	if err == nil && !extra.LastTime.IsZero() && extra.LastTime.Before(cfo.ifBefore) {

+		span.SetAttributes(attribute.Bool("skip", true))

 		return &sizeReaderAtWithCloser{}, nil

 	}

+	if err == nil {

+		span.SetAttributes(attribute.Stringer("lastLogTime", extra.LastTime))

+	}

+	span.AddEvent("Start decompress")

 	return cfo.lf.decompress.Do(cfo.f)

 }

@@ -579,19 +626,27 @@ func (cfo *compressedFileOpener) Close() {

 	cfo.f.Close()

 }

+func (cfo *compressedFileOpener) Ref() string {

+	return cfo.f.Name()

+}

+

 type emptyFileOpener struct{}

-func (emptyFileOpener) ReaderAt() (sizeReaderAtCloser, error) {

+func (emptyFileOpener) ReaderAt(context.Context) (sizeReaderAtCloser, error) {

 	return &sizeReaderAtWithCloser{}, nil

 }

 func (emptyFileOpener) Close() {}

+func (emptyFileOpener) Ref() string {

+	return "null"

+}

+

 // openRotatedFiles returns a slice of files open for reading, in order from

 // oldest to newest, and calls w.fsopMu.RUnlock() before returning.

 //

 // This method must only be called with w.fsopMu locked for reading.

-func (w *LogFile) openRotatedFiles(config logger.ReadConfig) (_ []fileOpener, retErr error) {

+func (w *LogFile) openRotatedFiles(ctx context.Context, config logger.ReadConfig) (_ []fileOpener, retErr error) {

 	var out []fileOpener

 	defer func() {

@@ -603,7 +658,7 @@ func (w *LogFile) openRotatedFiles(config logger.ReadConfig) (_ []fileOpener, re

 	}()

 	for i := w.maxFiles; i > 1; i-- {

-		fo, err := w.openRotatedFile(i-1, config)

+		fo, err := w.openRotatedFile(ctx, i-1, config)

 		if err != nil {

 			return nil, err

 		}

@@ -613,7 +668,7 @@ func (w *LogFile) openRotatedFiles(config logger.ReadConfig) (_ []fileOpener, re

 	return out, nil

 }

-func (w *LogFile) openRotatedFile(i int, config logger.ReadConfig) (fileOpener, error) {

+func (w *LogFile) openRotatedFile(ctx context.Context, i int, config logger.ReadConfig) (fileOpener, error) {

 	f, err := open(fmt.Sprintf("%s.%d", w.f.Name(), i))

 	if err == nil {

 		return &simpleFileOpener{

@@ -650,6 +705,15 @@ type sizeReaderAtCloser interface {

 }

 func getTailFiles(ctx context.Context, files []fileOpener, nLines int, getTailReader GetTailReaderFunc) (_ []sizeReaderAtCloser, retErr error) {

+	ctx, span := tracing.StartSpan(ctx, "logger.Logfile.CollectTailFiles")

+	span.SetAttributes(attribute.Int("requested_lines", nLines))

+

+	defer func() {

+		if retErr != nil {

+			span.SetStatus(retErr)

+		}

+		span.End()

+	}()

 	out := make([]sizeReaderAtCloser, 0, len(files))

 	defer func() {

@@ -664,11 +728,14 @@ func getTailFiles(ctx context.Context, files []fileOpener, nLines int, getTailRe

 	if nLines <= 0 {

 		for _, fo := range files {

-			ra, err := fo.ReaderAt()

+			span.AddEvent("Open file", trace.WithAttributes(attribute.String("file", fo.Ref())))

+

+			ra, err := fo.ReaderAt(ctx)

 			if err != nil {

 				return nil, err

 			}

 			out = append(out, ra)

+

 		}

 		return out, nil

 	}

@@ -677,11 +744,19 @@ func getTailFiles(ctx context.Context, files []fileOpener, nLines int, getTailRe

 		if err := ctx.Err(); err != nil {

 			return nil, errors.Wrap(err, "stopping parsing files to tail due to error")

 		}

-		ra, err := files[i].ReaderAt()

+

+		fo := files[i]

+

+		fileAttr := attribute.String("file", fo.Ref())

+		span.AddEvent("Open file", trace.WithAttributes(fileAttr))

+

+		ra, err := fo.ReaderAt(ctx)

 		if err != nil {

 			return nil, err

 		}

+		span.AddEvent("Scan file to tail", trace.WithAttributes(fileAttr, attribute.Int("remaining_lines", nLines)))

+

 		tail, n, err := getTailReader(ctx, ra, nLines)

 		if err != nil {

 			ra.Close()

@@ -697,11 +772,10 @@ func getTailFiles(ctx context.Context, files []fileOpener, nLines int, getTailRe

 	return out, nil

 }

-func tailFiles(files []fileOpener, watcher *logger.LogWatcher, dec Decoder, getTailReader GetTailReaderFunc, nLines int, fwd *forwarder) (cont bool) {

-	ctx, cancel := context.WithCancel(context.Background())

+func tailFiles(ctx context.Context, files []fileOpener, watcher *logger.LogWatcher, dec Decoder, getTailReader GetTailReaderFunc, nLines int, fwd *forwarder) (cont bool) {

+	ctx, cancel := context.WithCancel(ctx)

 	defer cancel()

-	// TODO(@cpuguy83): we should plumb a context through instead of dealing with `WatchClose()` here.

 	go func() {

 		select {

 		case <-ctx.Done():

@@ -779,11 +853,19 @@ func newForwarder(config logger.ReadConfig) *forwarder {

 // dec without encountering a message with a timestamp which is after the

 // configured until time.

 func (fwd *forwarder) Do(ctx context.Context, watcher *logger.LogWatcher, next func() (*logger.Message, error)) (cont bool) {

+	ctx, span := tracing.StartSpan(ctx, "logger.Logfile.Forward")

+	defer func() {

+		span.SetAttributes(attribute.Bool("continue", cont))

+		span.End()

+	}()

+

 	for {

 		select {

 		case <-watcher.WatchConsumerGone():

+			span.AddEvent("watch consumer gone")

 			return false

 		case <-ctx.Done():

+			span.AddEvent(ctx.Err().Error())

 			return false

 		default:

 		}

@@ -791,8 +873,10 @@ func (fwd *forwarder) Do(ctx context.Context, watcher *logger.LogWatcher, next f

 		msg, err := next()

 		if err != nil {

 			if errors.Is(err, io.EOF) {

+				span.AddEvent("EOF")

 				return true

 			}

+			span.SetStatus(err)

 			log.G(ctx).WithError(err).Debug("Error while decoding log entry, not continuing")

 			return false

 		}

@@ -811,10 +895,13 @@ func (fwd *forwarder) Do(ctx context.Context, watcher *logger.LogWatcher, next f

 			log.G(ctx).Debug("Log is newer than requested window, skipping remaining logs")

 			return false

 		}

+

 		select {

 		case <-ctx.Done():

+			span.AddEvent(ctx.Err().Error())

 			return false

 		case <-watcher.WatchConsumerGone():

+			span.AddEvent("watch consumer gone")

 			return false

 		case watcher.Msg <- msg:

 		}

@@ -9,6 +9,7 @@ import (

 	"io"

 	"os"

 	"path/filepath"

+	"strconv"

 	"strings"

 	"testing"

 	"text/tabwriter"

@@ -78,8 +79,8 @@ func TestTailFiles(t *testing.T) {

 	makeOpener := func(ls ...SizeReaderAt) []fileOpener {

 		out := make([]fileOpener, 0, len(ls))

-		for _, rdr := range ls {

-			out = append(out, &sizeReaderAtOpener{rdr})

+		for i, rdr := range ls {

+			out = append(out, &sizeReaderAtOpener{rdr, strconv.Itoa(i)})

 		}

 		return out

 	}

@@ -98,7 +99,7 @@ func TestTailFiles(t *testing.T) {

 	started := make(chan struct{})

 	go func() {

 		close(started)

-		tailFiles(files, watcher, dec, tailReader, config.Tail, fwd)

+		tailFiles(context.TODO(), files, watcher, dec, tailReader, config.Tail, fwd)

 	}()

 	<-started

@@ -166,7 +167,7 @@ func TestTailFiles(t *testing.T) {

 		done := make(chan struct{})

 		go func() {

 			close(started)

-			tailFiles(files, watcher, &testJSONStreamDecoder{}, tailReader, config.Tail, fwd)

+			tailFiles(context.TODO(), files, watcher, &testJSONStreamDecoder{}, tailReader, config.Tail, fwd)

 			close(done)

 		}()

@@ -249,7 +250,7 @@ func TestCheckCapacityAndRotate(t *testing.T) {

 	t.Run("with log reader", func(t *testing.T) {

 		// Make sure rotate works with an active reader

-		lw := l.ReadLogs(logger.ReadConfig{Follow: true, Tail: 1000})

+		lw := l.ReadLogs(context.TODO(), logger.ReadConfig{Follow: true, Tail: 1000})

 		defer lw.ConsumerGone()

 		assert.NilError(t, l.WriteLogEntry(timestamp, []byte("hello world 0!\n")), ls)

@@ -1,6 +1,7 @@

 package logger // import "github.com/docker/docker/daemon/logger"

 import (

+	"context"

 	"errors"

 	"sync"

 	"sync/atomic"

@@ -20,19 +21,22 @@ type RingLogger struct {

 	wg        sync.WaitGroup

 }

-var _ SizedLogger = &RingLogger{}

+var (

+	_ SizedLogger = (*RingLogger)(nil)

+	_ LogReader   = (*ringWithReader)(nil)

+)

 type ringWithReader struct {

 	*RingLogger

 }

-func (r *ringWithReader) ReadLogs(cfg ReadConfig) *LogWatcher {

+func (r *ringWithReader) ReadLogs(ctx context.Context, cfg ReadConfig) *LogWatcher {

 	reader, ok := r.l.(LogReader)

 	if !ok {

 		// something is wrong if we get here

 		panic("expected log reader")

 	}

-	return reader.ReadLogs(cfg)

+	return reader.ReadLogs(ctx, cfg)

 }

 func newRingLogger(driver Logger, logInfo Info, maxSize int64) *RingLogger {

@@ -5,6 +5,7 @@ import (

 	"strconv"

 	"time"

+	"github.com/containerd/containerd/tracing"

 	"github.com/containerd/log"

 	"github.com/docker/docker/api/types/backend"

 	containertypes "github.com/docker/docker/api/types/container"

@@ -24,6 +25,14 @@ import (

 // if it returns nil, the config channel will be active and return log

 // messages until it runs out or the context is canceled.

 func (daemon *Daemon) ContainerLogs(ctx context.Context, containerName string, config *containertypes.LogsOptions) (messages <-chan *backend.LogMessage, isTTY bool, retErr error) {

+	ctx, span := tracing.StartSpan(ctx, "daemon.ContainerLogs")

+	defer func() {

+		if retErr != nil {

+			span.SetStatus(retErr)

+		}

+		span.End()

+	}()

+

 	lg := log.G(ctx).WithFields(log.Fields{

 		"module":    "daemon",

 		"method":    "(*Daemon).ContainerLogs",

@@ -96,7 +105,7 @@ func (daemon *Daemon) ContainerLogs(ctx context.Context, containerName string, c

 		Follow: follow,

 	}

-	logs := logReader.ReadLogs(readConfig)

+	logs := logReader.ReadLogs(ctx, readConfig)

 	// past this point, we can't possibly return any errors, so we can just

 	// start a goroutine and return to tell the caller not to expect errors