+// Copyright (C) The Arvados Authors. All rights reserved.
+//
+// SPDX-License-Identifier: AGPL-3.0
+
package main
import (
buf *bytes.Buffer
sync.Mutex
writer io.WriteCloser
- stopping chan struct{}
+ flush chan struct{}
stopped chan struct{}
+ stopping chan struct{}
Timestamper
- Immediate *log.Logger
+ Immediate *log.Logger
+ pendingFlush bool
}
// RFC3339NanoFixed is a fixed-width version of time.RFC3339Nano.
n = len(p)
}
}
+
+ if int64(tl.buf.Len()) >= crunchLogBytesPerEvent {
+ // Non-blocking send. Try send a flush if it is ready to
+ // accept it. Otherwise do nothing because a flush is already
+ // pending.
+ select {
+ case tl.flush <- struct{}{}:
+ default:
+ }
+ }
+
return
}
// Periodically check the current buffer; if not empty, send it on the
// channel to the goWriter goroutine.
func (tl *ThrottledLogger) flusher() {
- ticker := time.NewTicker(time.Second)
+ ticker := time.NewTicker(time.Duration(crunchLogSecondsBetweenEvents))
defer ticker.Stop()
for stopping := false; !stopping; {
select {
case <-tl.stopping:
- // flush tl.buf, then exit the loop
+ // flush tl.buf and exit the loop
stopping = true
+ case <-tl.flush:
case <-ticker.C:
}
var ready *bytes.Buffer
tl.Mutex.Lock()
- ready, tl.buf = tl.buf, nil
+ ready, tl.buf = tl.buf, &bytes.Buffer{}
tl.Mutex.Unlock()
if ready != nil && ready.Len() > 0 {
// NewThrottledLogger creates a new thottled logger that
// (a) prepends timestamps to each line
-// (b) batches log messages and only calls the underlying Writer at most once
-// per second.
+// (b) batches log messages and only calls the underlying Writer
+// at most once per "crunchLogSecondsBetweenEvents" seconds.
func NewThrottledLogger(writer io.WriteCloser) *ThrottledLogger {
tl := &ThrottledLogger{}
- tl.stopping = make(chan struct{})
+ tl.flush = make(chan struct{}, 1)
tl.stopped = make(chan struct{})
+ tl.stopping = make(chan struct{})
tl.writer = writer
tl.Logger = log.New(tl, "", 0)
tl.Timestamper = RFC3339Timestamp
return tl
}
+// Log throttling rate limiting config parameters
+var crunchLimitLogBytesPerJob int64 = 67108864
+var crunchLogThrottleBytes int64 = 65536
+var crunchLogThrottlePeriod time.Duration = time.Second * 60
+var crunchLogThrottleLines int64 = 1024
+var crunchLogPartialLineThrottlePeriod time.Duration = time.Second * 5
+var crunchLogBytesPerEvent int64 = 4096
+var crunchLogSecondsBetweenEvents = time.Second
+var crunchLogUpdatePeriod = time.Hour / 2
+var crunchLogUpdateSize = int64(1 << 25)
+
// ArvLogWriter is an io.WriteCloser that processes each write by
// writing it through to another io.WriteCloser (typically a
// CollectionFileWriter) and creating an Arvados log entry.
logThrottleBytesSoFar int64
logThrottleBytesSkipped int64
logThrottleIsOpen bool
- logThrottlePartialLineLastAt time.Time
+ logThrottlePartialLineNextAt time.Time
logThrottleFirstPartialLine bool
bufToFlush bytes.Buffer
bufFlushedAt time.Time
-
- // rate limiting config parameters
- crunchLimitLogBytesPerJob int64
- crunchLogThrottleBytes int64
- crunchLogThrottlePeriod int
- crunchLogThrottleLines int64
- crunchLogPartialLineThrottlePeriod int
- crunchLogBytesPerEvent int64
- crunchLogSecondsBetweenEvents int
-}
-
-// NewArvLogWriter creates new ArvLogWriter and loads the rate limiting config params
-func NewArvLogWriter(clnt IArvadosClient, uuid string, ls string, wc io.WriteCloser) *ArvLogWriter {
- w := &ArvLogWriter{ArvClient: clnt, UUID: uuid, loggingStream: ls, writeCloser: wc}
-
- // load the rate limit discovery config paramters
- param, err := clnt.Discovery("crunchLimitLogBytesPerJob")
- if err != nil {
- w.crunchLimitLogBytesPerJob = 67108864
- } else {
- w.crunchLimitLogBytesPerJob = int64(param.(float64))
- }
-
- param, err = clnt.Discovery("crunchLogThrottleBytes")
- if err != nil {
- w.crunchLogThrottleBytes = 65536
- } else {
- w.crunchLogThrottleBytes = int64(param.(float64))
- }
-
- param, err = clnt.Discovery("crunchLogThrottlePeriod")
- if err != nil {
- w.crunchLogThrottlePeriod = 60
- } else {
- w.crunchLogThrottlePeriod = int(param.(float64))
- }
-
- param, err = clnt.Discovery("crunchLogThrottleLines")
- if err != nil {
- w.crunchLogThrottleLines = 1024
- } else {
- w.crunchLogThrottleLines = int64(param.(float64))
- }
-
- param, err = clnt.Discovery("crunchLogPartialLineThrottlePeriod")
- if err != nil {
- w.crunchLogPartialLineThrottlePeriod = 5
- } else {
- w.crunchLogPartialLineThrottlePeriod = int(param.(float64))
- }
-
- param, err = clnt.Discovery("crunchLogBytesPerEvent")
- if err != nil {
- w.crunchLogBytesPerEvent = 4096
- } else {
- w.crunchLogBytesPerEvent = int64(param.(float64))
- }
-
- param, err = clnt.Discovery("crunchLogSecondsBetweenEvents")
- if err != nil {
- w.crunchLogSecondsBetweenEvents = 1
- } else {
- w.crunchLogSecondsBetweenEvents = int(param.(float64))
- }
-
- return w
+ closing bool
}
-func (arvlog *ArvLogWriter) Write(p []byte) (n int, err error) {
+func (arvlog *ArvLogWriter) Write(p []byte) (int, error) {
// Write to the next writer in the chain (a file in Keep)
var err1 error
if arvlog.writeCloser != nil {
// write to API after checking rate limit
now := time.Now()
- bytesWritten := 0
if now.After(arvlog.logThrottleResetTime) {
// It has been more than throttle_period seconds since the last
arvlog.bufToFlush.WriteString(fmt.Sprintf("%s Skipped %d bytes of log\n", RFC3339Timestamp(now.UTC()), arvlog.logThrottleBytesSkipped))
}
- arvlog.logThrottleResetTime = now.Add(time.Second * time.Duration(arvlog.crunchLogThrottlePeriod))
+ arvlog.logThrottleResetTime = now.Add(crunchLogThrottlePeriod)
arvlog.logThrottleBytesSoFar = 0
arvlog.logThrottleLinesSoFar = 0
arvlog.logThrottleBytesSkipped = 0
arvlog.logThrottleIsOpen = true
- arvlog.logThrottlePartialLineLastAt = time.Time{}
- arvlog.logThrottleFirstPartialLine = true
}
lines := bytes.Split(p, []byte("\n"))
// check rateLimit
logOpen, msg := arvlog.rateLimit(line, now)
- arvlog.bufToFlush.WriteString(string(msg) + "\n")
- arvlog.logThrottleIsOpen = logOpen
+ if logOpen {
+ arvlog.bufToFlush.WriteString(string(msg) + "\n")
+ }
}
- if int64(arvlog.bufToFlush.Len()) > arvlog.crunchLogBytesPerEvent ||
- (now.Sub(arvlog.bufFlushedAt) >= time.Duration(arvlog.crunchLogSecondsBetweenEvents)) {
+ if (int64(arvlog.bufToFlush.Len()) >= crunchLogBytesPerEvent ||
+ (now.Sub(arvlog.bufFlushedAt) >= crunchLogSecondsBetweenEvents) ||
+ arvlog.closing) && (arvlog.bufToFlush.Len() > 0) {
// write to API
lr := arvadosclient.Dict{"log": arvadosclient.Dict{
"object_uuid": arvlog.UUID,
"properties": map[string]string{"text": arvlog.bufToFlush.String()}}}
err2 := arvlog.ArvClient.Create("logs", lr, nil)
- bytesWritten = arvlog.bufToFlush.Len()
arvlog.bufToFlush = bytes.Buffer{}
arvlog.bufFlushedAt = now
}
}
- return bytesWritten, nil
+ return len(p), nil
}
// Close the underlying writer
func (arvlog *ArvLogWriter) Close() (err error) {
+ arvlog.closing = true
+ arvlog.Write([]byte{})
if arvlog.writeCloser != nil {
err = arvlog.writeCloser.Close()
arvlog.writeCloser = nil
func (arvlog *ArvLogWriter) rateLimit(line []byte, now time.Time) (bool, []byte) {
message := ""
lineSize := int64(len(line))
- partialLine := false
- skipCounts := false
if arvlog.logThrottleIsOpen {
matches := lineRegexp.FindStringSubmatch(string(line))
if len(matches) == 2 && strings.HasPrefix(matches[1], "[...]") && strings.HasSuffix(matches[1], "[...]") {
- partialLine = true
-
- if now.After(arvlog.logThrottlePartialLineLastAt.Add(time.Second * time.Duration(arvlog.crunchLogPartialLineThrottlePeriod))) {
- arvlog.logThrottlePartialLineLastAt = now
+ // This is a partial line.
+
+ if arvlog.logThrottleFirstPartialLine {
+ // Partial should be suppressed. First time this is happening for this line so provide a message instead.
+ arvlog.logThrottleFirstPartialLine = false
+ arvlog.logThrottlePartialLineNextAt = now.Add(crunchLogPartialLineThrottlePeriod)
+ arvlog.logThrottleBytesSkipped += lineSize
+ return true, []byte(fmt.Sprintf("%s Rate-limiting partial segments of long lines to one every %d seconds.",
+ RFC3339Timestamp(now.UTC()), crunchLogPartialLineThrottlePeriod/time.Second))
+ } else if now.After(arvlog.logThrottlePartialLineNextAt) {
+ // The throttle period has passed. Update timestamp and let it through.
+ arvlog.logThrottlePartialLineNextAt = now.Add(crunchLogPartialLineThrottlePeriod)
} else {
- skipCounts = true
+ // Suppress line.
+ arvlog.logThrottleBytesSkipped += lineSize
+ return false, line
}
+ } else {
+ // Not a partial line so reset.
+ arvlog.logThrottlePartialLineNextAt = time.Time{}
+ arvlog.logThrottleFirstPartialLine = true
}
- if !skipCounts {
- arvlog.logThrottleLinesSoFar += 1
- arvlog.logThrottleBytesSoFar += lineSize
- arvlog.bytesLogged += lineSize
- }
+ arvlog.bytesLogged += lineSize
+ arvlog.logThrottleBytesSoFar += lineSize
+ arvlog.logThrottleLinesSoFar += 1
- if arvlog.bytesLogged > arvlog.crunchLimitLogBytesPerJob {
- message = fmt.Sprintf("%s Exceeded log limit %d bytes (crunch_limit_log_bytes_per_job). Log will be truncated.", RFC3339Timestamp(now.UTC()), arvlog.crunchLimitLogBytesPerJob)
+ if arvlog.bytesLogged > crunchLimitLogBytesPerJob {
+ message = fmt.Sprintf("%s Exceeded log limit %d bytes (crunch_limit_log_bytes_per_job). Log will be truncated.",
+ RFC3339Timestamp(now.UTC()), crunchLimitLogBytesPerJob)
arvlog.logThrottleResetTime = now.Add(time.Duration(365 * 24 * time.Hour))
arvlog.logThrottleIsOpen = false
- } else if arvlog.logThrottleBytesSoFar > arvlog.crunchLogThrottleBytes {
+ } else if arvlog.logThrottleBytesSoFar > crunchLogThrottleBytes {
remainingTime := arvlog.logThrottleResetTime.Sub(now)
- message = fmt.Sprintf("%s Exceeded rate %d bytes per %d seconds (crunch_log_throttle_bytes). Logging will be silenced for the next %d seconds.", RFC3339Timestamp(now.UTC()), arvlog.crunchLogThrottleBytes, arvlog.crunchLogThrottlePeriod, remainingTime/time.Second)
+ message = fmt.Sprintf("%s Exceeded rate %d bytes per %d seconds (crunch_log_throttle_bytes). Logging will be silenced for the next %d seconds.",
+ RFC3339Timestamp(now.UTC()), crunchLogThrottleBytes, crunchLogThrottlePeriod/time.Second, remainingTime/time.Second)
arvlog.logThrottleIsOpen = false
- } else if arvlog.logThrottleLinesSoFar > arvlog.crunchLogThrottleLines {
+ } else if arvlog.logThrottleLinesSoFar > crunchLogThrottleLines {
remainingTime := arvlog.logThrottleResetTime.Sub(now)
- message = fmt.Sprintf("%s Exceeded rate %d lines per %d seconds (crunch_log_throttle_lines), logging will be silenced for the next %d seconds.", RFC3339Timestamp(now.UTC()), arvlog.crunchLogThrottleLines, arvlog.crunchLogThrottlePeriod, remainingTime/time.Second)
+ message = fmt.Sprintf("%s Exceeded rate %d lines per %d seconds (crunch_log_throttle_lines), logging will be silenced for the next %d seconds.",
+ RFC3339Timestamp(now.UTC()), crunchLogThrottleLines, crunchLogThrottlePeriod/time.Second, remainingTime/time.Second)
arvlog.logThrottleIsOpen = false
- } else if partialLine && arvlog.logThrottleFirstPartialLine {
- arvlog.logThrottleFirstPartialLine = false
- message = fmt.Sprintf("%s Rate-limiting partial segments of long lines to one every %d seconds.", RFC3339Timestamp(now.UTC()), arvlog.crunchLogPartialLineThrottlePeriod)
-
}
}
// instead of the log message that exceeded the limit.
message += " A complete log is still being written to Keep, and will be available when the job finishes."
return true, []byte(message)
- } else if partialLine {
- return false, line
} else {
return arvlog.logThrottleIsOpen, line
}
}
+
+// load the rate limit discovery config parameters
+func loadLogThrottleParams(clnt IArvadosClient) {
+ loadDuration := func(dst *time.Duration, key string) {
+ if param, err := clnt.Discovery(key); err != nil {
+ return
+ } else if d, ok := param.(float64); !ok {
+ return
+ } else {
+ *dst = time.Duration(d) * time.Second
+ }
+ }
+ loadInt64 := func(dst *int64, key string) {
+ if param, err := clnt.Discovery(key); err != nil {
+ return
+ } else if val, ok := param.(float64); !ok {
+ return
+ } else {
+ *dst = int64(val)
+ }
+ }
+
+ loadInt64(&crunchLimitLogBytesPerJob, "crunchLimitLogBytesPerJob")
+ loadInt64(&crunchLogThrottleBytes, "crunchLogThrottleBytes")
+ loadDuration(&crunchLogThrottlePeriod, "crunchLogThrottlePeriod")
+ loadInt64(&crunchLogThrottleLines, "crunchLogThrottleLines")
+ loadDuration(&crunchLogPartialLineThrottlePeriod, "crunchLogPartialLineThrottlePeriod")
+ loadInt64(&crunchLogBytesPerEvent, "crunchLogBytesPerEvent")
+ loadDuration(&crunchLogSecondsBetweenEvents, "crunchLogSecondsBetweenEvents")
+ loadInt64(&crunchLogUpdateSize, "crunchLogUpdateSize")
+ loadDuration(&crunchLogUpdatePeriod, "crunchLogUpdatePeriod")
+
+}