all: sync with master; upd chlog

internal/querylog/querylogfile.go

@@ -14,68 +14,75 @@ import (
 // flushLogBuffer flushes the current buffer to file and resets the current
 // buffer.
 func (l *queryLog) flushLogBuffer() (err error) {
+	defer func() { err = errors.Annotate(err, "flushing log buffer: %w") }()
 	l.fileFlushLock.Lock()
 	defer l.fileFlushLock.Unlock()
 
-	var flushBuffer []*logEntry
-	func() {
-		l.bufferLock.Lock()
-		defer l.bufferLock.Unlock()
+	b, err := l.encodeEntries()
+	if err != nil {
+		// Don't wrap the error since it's informative enough as is.
+		return err
+	}
 
-		flushBuffer = l.buffer
-		l.buffer = nil
-		l.flushPending = false
-	}()
-
-	err = l.flushToFile(flushBuffer)
-
-	return errors.Annotate(err, "writing to file: %w")
+	return l.flushToFile(b)
 }
 
-// flushToFile saves the specified log entries to the query log file
-func (l *queryLog) flushToFile(buffer []*logEntry) (err error) {
-	if len(buffer) == 0 {
-		log.Debug("querylog: nothing to write to a file")
+// encodeEntries returns JSON encoded log entries, logs estimated time, clears
+// the log buffer.
+func (l *queryLog) encodeEntries() (b *bytes.Buffer, err error) {
+	l.bufferLock.Lock()
+	defer l.bufferLock.Unlock()
 
-		return nil
+	bufLen := l.buffer.Len()
+	if bufLen == 0 {
+		return nil, errors.Error("nothing to write to a file")
 	}
 
 	start := time.Now()
 
-	var b bytes.Buffer
-	e := json.NewEncoder(&b)
-	for _, entry := range buffer {
-		err = e.Encode(entry)
-		if err != nil {
-			log.Error("Failed to marshal entry: %s", err)
+	b = &bytes.Buffer{}
+	e := json.NewEncoder(b)
 
-			return err
-		}
+	l.buffer.Range(func(entry *logEntry) (cont bool) {
+		err = e.Encode(entry)
+
+		return err == nil
+	})
+
+	if err != nil {
+		// Don't wrap the error since it's informative enough as is.
+		return nil, err
 	}
 
 	elapsed := time.Since(start)
-	log.Debug("%d elements serialized via json in %v: %d kB, %v/entry, %v/entry", len(buffer), elapsed, b.Len()/1024, float64(b.Len())/float64(len(buffer)), elapsed/time.Duration(len(buffer)))
+	log.Debug("%d elements serialized via json in %v: %d kB, %v/entry, %v/entry", bufLen, elapsed, b.Len()/1024, float64(b.Len())/float64(bufLen), elapsed/time.Duration(bufLen))
 
-	var zb bytes.Buffer
-	filename := l.logFile
-	zb = b
+	l.buffer.Clear()
+	l.flushPending = false
 
+	return b, nil
+}
+
+// flushToFile saves the encoded log entries to the query log file.
+func (l *queryLog) flushToFile(b *bytes.Buffer) (err error) {
 	l.fileWriteLock.Lock()
 	defer l.fileWriteLock.Unlock()
+
+	filename := l.logFile
+
 	f, err := os.OpenFile(filename, os.O_WRONLY|os.O_CREATE|os.O_APPEND, 0o644)
 	if err != nil {
-		log.Error("failed to create file \"%s\": %s", filename, err)
-		return err
+		return fmt.Errorf("creating file %q: %w", filename, err)
 	}
+
 	defer func() { err = errors.WithDeferred(err, f.Close()) }()
 
-	n, err := f.Write(zb.Bytes())
+	n, err := f.Write(b.Bytes())
 	if err != nil {
-		log.Error("Couldn't write to file: %s", err)
-		return err
+		return fmt.Errorf("writing to file %q: %w", filename, err)
 	}
 
-	log.Debug("querylog: ok \"%s\": %v bytes written", filename, n)
+	log.Debug("querylog: ok %q: %v bytes written", filename, n)
 
 	return nil
 }