@@ -23,9 +23,9 @@ const Name = "json-file"

 // JSONFileLogger is Logger implementation for default Docker logging.

 type JSONFileLogger struct {

-	mu      sync.RWMutex

+	mu      sync.Mutex

 	closed  bool

-	writer  *loggerutils.RotateFileWriter

+	writer  *loggerutils.LogFile

 	readers map[*logger.LogWatcher]struct{} // stores the active log followers

 }

@@ -83,7 +83,8 @@ func New(info logger.Info) (logger.Logger, error) {

 		buf.Reset()

 		return b, nil

 	}

-	writer, err := loggerutils.NewRotateFileWriter(info.LogPath, capval, maxFiles, marshalFunc)

+

+	writer, err := loggerutils.NewLogFile(info.LogPath, capval, maxFiles, marshalFunc, decodeFunc)

 	if err != nil {

 		return nil, err

 	}

@@ -82,7 +82,7 @@ func BenchmarkJSONFileLoggerLog(b *testing.B) {

 	}

 	buf := bytes.NewBuffer(nil)

-	require.NoError(b, marshalMessage(msg, jsonlogger.(*JSONFileLogger).extra, buf))

+	require.NoError(b, marshalMessage(msg, nil, buf))

 	b.SetBytes(int64(buf.Len()))

 	b.ResetTimer()

deleted file mode 100644

@@ -1,228 +0,0 @@

-package multireader

-

-import (

-	"bytes"

-	"fmt"

-	"io"

-	"os"

-)

-

-type pos struct {

-	idx    int

-	offset int64

-}

-

-type multiReadSeeker struct {

-	readers []io.ReadSeeker

-	pos     *pos

-	posIdx  map[io.ReadSeeker]int

-}

-

-func (r *multiReadSeeker) Seek(offset int64, whence int) (int64, error) {

-	var tmpOffset int64

-	switch whence {

-	case os.SEEK_SET:

-		for i, rdr := range r.readers {

-			// get size of the current reader

-			s, err := rdr.Seek(0, os.SEEK_END)

-			if err != nil {

-				return -1, err

-			}

-

-			if offset > tmpOffset+s {

-				if i == len(r.readers)-1 {

-					rdrOffset := s + (offset - tmpOffset)

-					if _, err := rdr.Seek(rdrOffset, os.SEEK_SET); err != nil {

-						return -1, err

-					}

-					r.pos = &pos{i, rdrOffset}

-					return offset, nil

-				}

-

-				tmpOffset += s

-				continue

-			}

-

-			rdrOffset := offset - tmpOffset

-			idx := i

-

-			if _, err := rdr.Seek(rdrOffset, os.SEEK_SET); err != nil {

-				return -1, err

-			}

-			// make sure all following readers are at 0

-			for _, rdr := range r.readers[i+1:] {

-				rdr.Seek(0, os.SEEK_SET)

-			}

-

-			if rdrOffset == s && i != len(r.readers)-1 {

-				idx++

-				rdrOffset = 0

-			}

-			r.pos = &pos{idx, rdrOffset}

-			return offset, nil

-		}

-	case os.SEEK_END:

-		for _, rdr := range r.readers {

-			s, err := rdr.Seek(0, os.SEEK_END)

-			if err != nil {

-				return -1, err

-			}

-			tmpOffset += s

-		}

-		if _, err := r.Seek(tmpOffset+offset, os.SEEK_SET); err != nil {

-			return -1, err

-		}

-		return tmpOffset + offset, nil

-	case os.SEEK_CUR:

-		if r.pos == nil {

-			return r.Seek(offset, os.SEEK_SET)

-		}

-		// Just return the current offset

-		if offset == 0 {

-			return r.getCurOffset()

-		}

-

-		curOffset, err := r.getCurOffset()

-		if err != nil {

-			return -1, err

-		}

-		rdr, rdrOffset, err := r.getReaderForOffset(curOffset + offset)

-		if err != nil {

-			return -1, err

-		}

-

-		r.pos = &pos{r.posIdx[rdr], rdrOffset}

-		return curOffset + offset, nil

-	default:

-		return -1, fmt.Errorf("Invalid whence: %d", whence)

-	}

-

-	return -1, fmt.Errorf("Error seeking for whence: %d, offset: %d", whence, offset)

-}

-

-func (r *multiReadSeeker) getReaderForOffset(offset int64) (io.ReadSeeker, int64, error) {

-

-	var offsetTo int64

-

-	for _, rdr := range r.readers {

-		size, err := getReadSeekerSize(rdr)

-		if err != nil {

-			return nil, -1, err

-		}

-		if offsetTo+size > offset {

-			return rdr, offset - offsetTo, nil

-		}

-		if rdr == r.readers[len(r.readers)-1] {

-			return rdr, offsetTo + offset, nil

-		}

-		offsetTo += size

-	}

-

-	return nil, 0, nil

-}

-

-func (r *multiReadSeeker) getCurOffset() (int64, error) {

-	var totalSize int64

-	for _, rdr := range r.readers[:r.pos.idx+1] {

-		if r.posIdx[rdr] == r.pos.idx {

-			totalSize += r.pos.offset

-			break

-		}

-

-		size, err := getReadSeekerSize(rdr)

-		if err != nil {

-			return -1, fmt.Errorf("error getting seeker size: %v", err)

-		}

-		totalSize += size

-	}

-	return totalSize, nil

-}

-

-func (r *multiReadSeeker) getOffsetToReader(rdr io.ReadSeeker) (int64, error) {

-	var offset int64

-	for _, r := range r.readers {

-		if r == rdr {

-			break

-		}

-

-		size, err := getReadSeekerSize(rdr)

-		if err != nil {

-			return -1, err

-		}

-		offset += size

-	}

-	return offset, nil

-}

-

-func (r *multiReadSeeker) Read(b []byte) (int, error) {

-	if r.pos == nil {

-		// make sure all readers are at 0

-		r.Seek(0, os.SEEK_SET)

-	}

-

-	bLen := int64(len(b))

-	buf := bytes.NewBuffer(nil)

-	var rdr io.ReadSeeker

-

-	for _, rdr = range r.readers[r.pos.idx:] {

-		readBytes, err := io.CopyN(buf, rdr, bLen)

-		if err != nil && err != io.EOF {

-			return -1, err

-		}

-		bLen -= readBytes

-

-		if bLen == 0 {

-			break

-		}

-	}

-

-	rdrPos, err := rdr.Seek(0, os.SEEK_CUR)

-	if err != nil {

-		return -1, err

-	}

-	r.pos = &pos{r.posIdx[rdr], rdrPos}

-	return buf.Read(b)

-}

-

-func getReadSeekerSize(rdr io.ReadSeeker) (int64, error) {

-	// save the current position

-	pos, err := rdr.Seek(0, os.SEEK_CUR)

-	if err != nil {

-		return -1, err

-	}

-

-	// get the size

-	size, err := rdr.Seek(0, os.SEEK_END)

-	if err != nil {

-		return -1, err

-	}

-

-	// reset the position

-	if _, err := rdr.Seek(pos, os.SEEK_SET); err != nil {

-		return -1, err

-	}

-	return size, nil

-}

-

-// MultiReadSeeker returns a ReadSeeker that's the logical concatenation of the provided

-// input readseekers. After calling this method the initial position is set to the

-// beginning of the first ReadSeeker. At the end of a ReadSeeker, Read always advances

-// to the beginning of the next ReadSeeker and returns EOF at the end of the last ReadSeeker.

-// Seek can be used over the sum of lengths of all readseekers.

-//

-// When a MultiReadSeeker is used, no Read and Seek operations should be made on

-// its ReadSeeker components. Also, users should make no assumption on the state

-// of individual readseekers while the MultiReadSeeker is used.

-func MultiReadSeeker(readers ...io.ReadSeeker) io.ReadSeeker {

-	if len(readers) == 1 {

-		return readers[0]

-	}

-	idx := make(map[io.ReadSeeker]int)

-	for i, rdr := range readers {

-		idx[rdr] = i

-	}

-	return &multiReadSeeker{

-		readers: readers,

-		posIdx:  idx,

-	}

-}

deleted file mode 100644

@@ -1,225 +0,0 @@

-package multireader

-

-import (

-	"bytes"

-	"encoding/binary"

-	"fmt"

-	"io"

-	"io/ioutil"

-	"os"

-	"strings"

-	"testing"

-)

-

-func TestMultiReadSeekerReadAll(t *testing.T) {

-	str := "hello world"

-	s1 := strings.NewReader(str + " 1")

-	s2 := strings.NewReader(str + " 2")

-	s3 := strings.NewReader(str + " 3")

-	mr := MultiReadSeeker(s1, s2, s3)

-

-	expectedSize := int64(s1.Len() + s2.Len() + s3.Len())

-

-	b, err := ioutil.ReadAll(mr)

-	if err != nil {

-		t.Fatal(err)

-	}

-

-	expected := "hello world 1hello world 2hello world 3"

-	if string(b) != expected {

-		t.Fatalf("ReadAll failed, got: %q, expected %q", string(b), expected)

-	}

-

-	size, err := mr.Seek(0, os.SEEK_END)

-	if err != nil {

-		t.Fatal(err)

-	}

-	if size != expectedSize {

-		t.Fatalf("reader size does not match, got %d, expected %d", size, expectedSize)

-	}

-

-	// Reset the position and read again

-	pos, err := mr.Seek(0, os.SEEK_SET)

-	if err != nil {

-		t.Fatal(err)

-	}

-	if pos != 0 {

-		t.Fatalf("expected position to be set to 0, got %d", pos)

-	}

-

-	b, err = ioutil.ReadAll(mr)

-	if err != nil {

-		t.Fatal(err)

-	}

-

-	if string(b) != expected {

-		t.Fatalf("ReadAll failed, got: %q, expected %q", string(b), expected)

-	}

-

-	// The positions of some readers are not 0

-	s1.Seek(0, os.SEEK_SET)

-	s2.Seek(0, os.SEEK_END)

-	s3.Seek(0, os.SEEK_SET)

-	mr = MultiReadSeeker(s1, s2, s3)

-	b, err = ioutil.ReadAll(mr)

-	if err != nil {

-		t.Fatal(err)

-	}

-

-	if string(b) != expected {

-		t.Fatalf("ReadAll failed, got: %q, expected %q", string(b), expected)

-	}

-}

-

-func TestMultiReadSeekerReadEach(t *testing.T) {

-	str := "hello world"

-	s1 := strings.NewReader(str + " 1")

-	s2 := strings.NewReader(str + " 2")

-	s3 := strings.NewReader(str + " 3")

-	mr := MultiReadSeeker(s1, s2, s3)

-

-	var totalBytes int64

-	for i, s := range []*strings.Reader{s1, s2, s3} {

-		sLen := int64(s.Len())

-		buf := make([]byte, s.Len())

-		expected := []byte(fmt.Sprintf("%s %d", str, i+1))

-

-		if _, err := mr.Read(buf); err != nil && err != io.EOF {

-			t.Fatal(err)

-		}

-

-		if !bytes.Equal(buf, expected) {

-			t.Fatalf("expected %q to be %q", string(buf), string(expected))

-		}

-

-		pos, err := mr.Seek(0, os.SEEK_CUR)

-		if err != nil {

-			t.Fatalf("iteration: %d, error: %v", i+1, err)

-		}

-

-		// check that the total bytes read is the current position of the seeker

-		totalBytes += sLen

-		if pos != totalBytes {

-			t.Fatalf("expected current position to be: %d, got: %d, iteration: %d", totalBytes, pos, i+1)

-		}

-

-		// This tests not only that SEEK_SET and SEEK_CUR give the same values, but that the next iteration is in the expected position as well

-		newPos, err := mr.Seek(pos, os.SEEK_SET)

-		if err != nil {

-			t.Fatal(err)

-		}

-		if newPos != pos {

-			t.Fatalf("expected to get same position when calling SEEK_SET with value from SEEK_CUR, cur: %d, set: %d", pos, newPos)

-		}

-	}

-}

-

-func TestMultiReadSeekerReadSpanningChunks(t *testing.T) {

-	str := "hello world"

-	s1 := strings.NewReader(str + " 1")

-	s2 := strings.NewReader(str + " 2")

-	s3 := strings.NewReader(str + " 3")

-	mr := MultiReadSeeker(s1, s2, s3)

-

-	buf := make([]byte, s1.Len()+3)

-	_, err := mr.Read(buf)

-	if err != nil {

-		t.Fatal(err)

-	}

-

-	// expected is the contents of s1 + 3 bytes from s2, ie, the `hel` at the end of this string

-	expected := "hello world 1hel"

-	if string(buf) != expected {

-		t.Fatalf("expected %s to be %s", string(buf), expected)

-	}

-}

-

-func TestMultiReadSeekerNegativeSeek(t *testing.T) {

-	str := "hello world"

-	s1 := strings.NewReader(str + " 1")

-	s2 := strings.NewReader(str + " 2")

-	s3 := strings.NewReader(str + " 3")

-	mr := MultiReadSeeker(s1, s2, s3)

-

-	s1Len := s1.Len()

-	s2Len := s2.Len()

-	s3Len := s3.Len()

-

-	s, err := mr.Seek(int64(-1*s3.Len()), os.SEEK_END)

-	if err != nil {

-		t.Fatal(err)

-	}

-	if s != int64(s1Len+s2Len) {

-		t.Fatalf("expected %d to be %d", s, s1.Len()+s2.Len())

-	}

-

-	buf := make([]byte, s3Len)

-	if _, err := mr.Read(buf); err != nil && err != io.EOF {

-		t.Fatal(err)

-	}

-	expected := fmt.Sprintf("%s %d", str, 3)

-	if string(buf) != fmt.Sprintf("%s %d", str, 3) {

-		t.Fatalf("expected %q to be %q", string(buf), expected)

-	}

-}

-

-func TestMultiReadSeekerCurAfterSet(t *testing.T) {

-	str := "hello world"

-	s1 := strings.NewReader(str + " 1")

-	s2 := strings.NewReader(str + " 2")

-	s3 := strings.NewReader(str + " 3")

-	mr := MultiReadSeeker(s1, s2, s3)

-

-	mid := int64(s1.Len() + s2.Len()/2)

-

-	size, err := mr.Seek(mid, os.SEEK_SET)

-	if err != nil {

-		t.Fatal(err)

-	}

-	if size != mid {

-		t.Fatalf("reader size does not match, got %d, expected %d", size, mid)

-	}

-

-	size, err = mr.Seek(3, os.SEEK_CUR)

-	if err != nil {

-		t.Fatal(err)

-	}

-	if size != mid+3 {

-		t.Fatalf("reader size does not match, got %d, expected %d", size, mid+3)

-	}

-	size, err = mr.Seek(5, os.SEEK_CUR)

-	if err != nil {

-		t.Fatal(err)

-	}

-	if size != mid+8 {

-		t.Fatalf("reader size does not match, got %d, expected %d", size, mid+8)

-	}

-

-	size, err = mr.Seek(10, os.SEEK_CUR)

-	if err != nil {

-		t.Fatal(err)

-	}

-	if size != mid+18 {

-		t.Fatalf("reader size does not match, got %d, expected %d", size, mid+18)

-	}

-}

-

-func TestMultiReadSeekerSmallReads(t *testing.T) {

-	readers := []io.ReadSeeker{}

-	for i := 0; i < 10; i++ {

-		integer := make([]byte, 4)

-		binary.BigEndian.PutUint32(integer, uint32(i))

-		readers = append(readers, bytes.NewReader(integer))

-	}

-

-	reader := MultiReadSeeker(readers...)

-	for i := 0; i < 10; i++ {

-		var integer uint32

-		if err := binary.Read(reader, binary.BigEndian, &integer); err != nil {

-			t.Fatalf("Read from NewMultiReadSeeker failed: %v", err)

-		}

-		if uint32(i) != integer {

-			t.Fatalf("Read wrong value from NewMultiReadSeeker: %d != %d", i, integer)

-		}

-	}

-}

@@ -1,49 +1,16 @@

 package jsonfilelog

 import (

-	"bytes"

 	"encoding/json"

-	"fmt"

 	"io"

-	"os"

-	"time"

-

-	"github.com/fsnotify/fsnotify"

-	"golang.org/x/net/context"

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

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

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

-	"github.com/docker/docker/daemon/logger/jsonfilelog/multireader"

-	"github.com/docker/docker/pkg/filenotify"

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

-	"github.com/pkg/errors"

-	"github.com/sirupsen/logrus"

 )

 const maxJSONDecodeRetry = 20000

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

-	l.Reset()

-	if err := dec.Decode(l); err != nil {

-		return nil, err

-	}

-	var attrs []backend.LogAttr

-	if len(l.Attrs) != 0 {

-		attrs = make([]backend.LogAttr, 0, len(l.Attrs))

-		for k, v := range l.Attrs {

-			attrs = append(attrs, backend.LogAttr{Key: k, Value: v})

-		}

-	}

-	msg := &logger.Message{

-		Source:    l.Stream,

-		Timestamp: l.Created,

-		Line:      []byte(l.Log),

-		Attrs:     attrs,

-	}

-	return msg, nil

-}

-

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

 // created by this driver.

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

@@ -53,309 +20,70 @@ func (l *JSONFileLogger) ReadLogs(config logger.ReadConfig) *logger.LogWatcher {

 	return logWatcher

 }

-func (l *JSONFileLogger) readLogs(logWatcher *logger.LogWatcher, config logger.ReadConfig) {

-	defer close(logWatcher.Msg)

-

-	// lock so the read stream doesn't get corrupted due to rotations or other log data written while we open these files

-	// This will block writes!!!

-	l.mu.RLock()

-

-	// TODO it would be nice to move a lot of this reader implementation to the rotate logger object

-	pth := l.writer.LogPath()

-	var files []io.ReadSeeker

-	for i := l.writer.MaxFiles(); i > 1; i-- {

-		f, err := os.Open(fmt.Sprintf("%s.%d", pth, i-1))

-		if err != nil {

-			if !os.IsNotExist(err) {

-				logWatcher.Err <- err

-				l.mu.RUnlock()

-				return

-			}

-			continue

-		}

-		defer f.Close()

-		files = append(files, f)

-	}

-

-	latestFile, err := os.Open(pth)

-	if err != nil {

-		logWatcher.Err <- errors.Wrap(err, "error opening latest log file")

-		l.mu.RUnlock()

-		return

-	}

-	defer latestFile.Close()

-

-	latestChunk, err := newSectionReader(latestFile)

-

-	// Now we have the reader sectioned, all fd's opened, we can unlock.

-	// New writes/rotates will not affect seeking through these files

-	l.mu.RUnlock()

-

-	if err != nil {

-		logWatcher.Err <- err

-		return

-	}

-

-	if config.Tail != 0 {

-		tailer := multireader.MultiReadSeeker(append(files, latestChunk)...)

-		tailFile(tailer, logWatcher, config.Tail, config.Since, config.Until)

-	}

-

-	// close all the rotated files

-	for _, f := range files {

-		if err := f.(io.Closer).Close(); err != nil {

-			logrus.WithField("logger", "json-file").Warnf("error closing tailed log file: %v", err)

-		}

-	}

-

-	if !config.Follow || l.closed {

-		return

-	}

-

-	notifyRotate := l.writer.NotifyRotate()

-	defer l.writer.NotifyRotateEvict(notifyRotate)

+func (l *JSONFileLogger) readLogs(watcher *logger.LogWatcher, config logger.ReadConfig) {

+	defer close(watcher.Msg)

 	l.mu.Lock()

-	l.readers[logWatcher] = struct{}{}

+	l.readers[watcher] = struct{}{}

 	l.mu.Unlock()

-	followLogs(latestFile, logWatcher, notifyRotate, config)

+	l.writer.ReadLogs(config, watcher)

 	l.mu.Lock()

-	delete(l.readers, logWatcher)

+	delete(l.readers, watcher)

 	l.mu.Unlock()

 }

-func newSectionReader(f *os.File) (*io.SectionReader, error) {

-	// seek to the end to get the size

-	// we'll leave this at the end of the file since section reader does not advance the reader

-	size, err := f.Seek(0, os.SEEK_END)

-	if err != nil {

-		return nil, errors.Wrap(err, "error getting current file size")

-	}

-	return io.NewSectionReader(f, 0, size), nil

-}

-

-func tailFile(f io.ReadSeeker, logWatcher *logger.LogWatcher, tail int, since, until time.Time) {

-	rdr := io.Reader(f)

-	if tail > 0 {

-		ls, err := tailfile.TailFile(f, tail)

-		if err != nil {

-			logWatcher.Err <- err

-			return

-		}

-		rdr = bytes.NewBuffer(bytes.Join(ls, []byte("\n")))

-	}

-	dec := json.NewDecoder(rdr)

-	for {

-		msg, err := decodeLogLine(dec, &jsonlog.JSONLog{})

-		if err != nil {

-			if err != io.EOF {

-				logWatcher.Err <- err

-			}

-			return

-		}

-		if !since.IsZero() && msg.Timestamp.Before(since) {

-			continue

-		}

-		if !until.IsZero() && msg.Timestamp.After(until) {

-			return

-		}

-		select {

-		case <-logWatcher.WatchClose():

-			return

-		case logWatcher.Msg <- msg:

-		}

-	}

-}

-

-func watchFile(name string) (filenotify.FileWatcher, error) {

-	fileWatcher, err := filenotify.New()

-	if err != nil {

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

+	l.Reset()

+	if err := dec.Decode(l); err != nil {

 		return nil, err

 	}

-	if err := fileWatcher.Add(name); err != nil {

-		logrus.WithField("logger", "json-file").Warnf("falling back to file poller due to error: %v", err)

-		fileWatcher.Close()

-		fileWatcher = filenotify.NewPollingWatcher()

-

-		if err := fileWatcher.Add(name); err != nil {

-			fileWatcher.Close()

-			logrus.Debugf("error watching log file for modifications: %v", err)

-			return nil, err

+	var attrs []backend.LogAttr

+	if len(l.Attrs) != 0 {

+		attrs = make([]backend.LogAttr, 0, len(l.Attrs))

+		for k, v := range l.Attrs {

+			attrs = append(attrs, backend.LogAttr{Key: k, Value: v})

 		}

 	}

-	return fileWatcher, nil

+	msg := &logger.Message{

+		Source:    l.Stream,

+		Timestamp: l.Created,

+		Line:      []byte(l.Log),

+		Attrs:     attrs,

+	}

+	return msg, nil

 }

-func followLogs(f *os.File, logWatcher *logger.LogWatcher, notifyRotate chan interface{}, config logger.ReadConfig) {

-	dec := json.NewDecoder(f)

+// decodeFunc is used to create a decoder for the log file reader

+func decodeFunc(rdr io.Reader) func() (*logger.Message, error) {

 	l := &jsonlog.JSONLog{}

-

-	name := f.Name()

-	fileWatcher, err := watchFile(name)

-	if err != nil {

-		logWatcher.Err <- err

-		return

-	}

-	defer func() {

-		f.Close()

-		fileWatcher.Remove(name)

-		fileWatcher.Close()

-	}()

-

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

-	defer cancel()

-	go func() {

-		select {

-		case <-logWatcher.WatchClose():

-			fileWatcher.Remove(name)

-			cancel()

-		case <-ctx.Done():

-			return

-		}

-	}()

-

-	var retries int

-	handleRotate := func() error {

-		f.Close()

-		fileWatcher.Remove(name)

-

-		// retry when the file doesn't exist

-		for retries := 0; retries <= 5; retries++ {

-			f, err = os.Open(name)

-			if err == nil || !os.IsNotExist(err) {

+	dec := json.NewDecoder(rdr)

+	return func() (msg *logger.Message, err error) {

+		for retries := 0; retries < maxJSONDecodeRetry; retries++ {

+			msg, err = decodeLogLine(dec, l)

+			if err == nil {

 				break

 			}

-		}

-		if err != nil {

-			return err

-		}

-		if err := fileWatcher.Add(name); err != nil {

-			return err

-		}

-		dec = json.NewDecoder(f)

-		return nil

-	}

-	errRetry := errors.New("retry")

-	errDone := errors.New("done")

-	waitRead := func() error {

-		select {

-		case e := <-fileWatcher.Events():

-			switch e.Op {

-			case fsnotify.Write:

-				dec = json.NewDecoder(f)

-				return nil

-			case fsnotify.Rename, fsnotify.Remove:

-				select {

-				case <-notifyRotate:

-				case <-ctx.Done():

-					return errDone

-				}

-				if err := handleRotate(); err != nil {

-					return err

-				}

-				return nil

-			}

-			return errRetry

-		case err := <-fileWatcher.Errors():

-			logrus.Debug("logger got error watching file: %v", err)

-			// Something happened, let's try and stay alive and create a new watcher

-			if retries <= 5 {

-				fileWatcher.Close()

-				fileWatcher, err = watchFile(name)

-				if err != nil {

-					return err

-				}

+			// try again, could be due to a an incomplete json object as we read

+			if _, ok := err.(*json.SyntaxError); ok {

+				dec = json.NewDecoder(rdr)

 				retries++

-				return errRetry

-			}

-			return err

-		case <-ctx.Done():

-			return errDone

-		}

-	}

-

-	handleDecodeErr := func(err error) error {

-		if err == io.EOF {

-			for {

-				err := waitRead()

-				if err == nil {

-					break

-				}

-				if err == errRetry {

-					continue

-				}

-				return err

-			}

-			return nil

-		}

-		// try again because this shouldn't happen

-		if _, ok := err.(*json.SyntaxError); ok && retries <= maxJSONDecodeRetry {

-			dec = json.NewDecoder(f)

-			retries++

-			return nil

-		}

-		// io.ErrUnexpectedEOF is returned from json.Decoder when there is

-		// remaining data in the parser's buffer while an io.EOF occurs.

-		// If the json logger writes a partial json log entry to the disk

-		// while at the same time the decoder tries to decode it, the race condition happens.

-		if err == io.ErrUnexpectedEOF && retries <= maxJSONDecodeRetry {

-			reader := io.MultiReader(dec.Buffered(), f)

-			dec = json.NewDecoder(reader)

-			retries++

-			return nil

-		}

-		return err

-	}

-

-	// main loop

-	for {

-		msg, err := decodeLogLine(dec, l)

-		if err != nil {

-			if err := handleDecodeErr(err); err != nil {

-				if err == errDone {

-					return

-				}

-				// we got an unrecoverable error, so return

-				logWatcher.Err <- err

-				return

+				continue

 			}

-			// ready to try again

-			continue

-		}

-

-		since := config.Since

-		until := config.Until

-		retries = 0 // reset retries since we've succeeded

-		if !since.IsZero() && msg.Timestamp.Before(since) {

-			continue

-		}

-		if !until.IsZero() && msg.Timestamp.After(until) {

-			return

-		}

-		select {

-		case logWatcher.Msg <- msg:

-		case <-ctx.Done():

-			logWatcher.Msg <- msg

-			// This for loop is used when the logger is closed (ie, container

-			// stopped) but the consumer is still waiting for logs.

-			for {

-				msg, err := decodeLogLine(dec, l)

-				if err != nil {

-					return

-				}

-				if !since.IsZero() && msg.Timestamp.Before(since) {

-					continue

-				}

-				if !until.IsZero() && msg.Timestamp.After(until) {

-					return

-				}