mirror of https://github.com/hashicorp/terraform
We want to always be using the hclogger to filter whenever possiblepull/26632/head
James Bardin
6 years ago
parent
0b31ffa587
commit
a3a20e0396
@ -1,159 +0,0 @@
|
||||
package logging
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"io"
|
||||
"sync"
|
||||
)
|
||||
|
||||
// LogLevel is a special string, conventionally written all in uppercase, that
|
||||
// can be used to mark a log line for filtering and to specify filtering
|
||||
// levels in the LevelFilter type.
|
||||
type LogLevel string
|
||||
|
||||
// LevelFilter is an io.Writer that can be used with a logger that
|
||||
// will attempt to filter out log messages that aren't at least a certain
|
||||
// level.
|
||||
//
|
||||
// This filtering is HEURISTIC-BASED, and so will not be 100% reliable. The
|
||||
// assumptions it makes are:
|
||||
//
|
||||
// - Individual log messages are never split across multiple calls to the
|
||||
// Write method.
|
||||
//
|
||||
// - Messages that carry levels are marked by a sequence starting with "[",
|
||||
// then the level name string, and then "]". Any message without a sequence
|
||||
// like this is an un-levelled message, and is not subject to filtering.
|
||||
//
|
||||
// - Each \n-delimited line in a write is a separate log message, unless a
|
||||
// line starts with at least one space in which case it is interpreted
|
||||
// as a continuation of the previous line.
|
||||
//
|
||||
// - If a log line starts with a non-whitespace character that isn't a digit
|
||||
// then it's recognized as a degenerate continuation, because "real" log
|
||||
// lines should start with a date/time and thus always have a leading
|
||||
// digit. (This also cleans up after some situations where the assumptuion
|
||||
// that messages arrive atomically aren't met, which is sadly sometimes
|
||||
// true for longer messages that trip over some buffering behavior in
|
||||
// panicwrap.)
|
||||
//
|
||||
// Because logging is a cross-cutting concern and not fully under the control
|
||||
// of Terraform itself, there will certainly be cases where the above
|
||||
// heuristics will fail. For example, it is likely that LevelFilter will
|
||||
// occasionally misinterpret a continuation line as a new message because the
|
||||
// code generating it doesn't know about our indentation convention.
|
||||
//
|
||||
// Our goal here is just to make a best effort to reduce the log volume,
|
||||
// accepting that the results will not be 100% correct.
|
||||
//
|
||||
// Logging calls within Terraform Core should follow the above conventions so
|
||||
// that the log output is broadly correct, however.
|
||||
//
|
||||
// Once the filter is in use somewhere, it is not safe to modify
|
||||
// the structure.
|
||||
type LevelFilter struct {
|
||||
// Levels is the list of log levels, in increasing order of
|
||||
// severity. Example might be: {"DEBUG", "WARN", "ERROR"}.
|
||||
Levels []LogLevel
|
||||
|
||||
// MinLevel is the minimum level allowed through
|
||||
MinLevel LogLevel
|
||||
|
||||
// The underlying io.Writer where log messages that pass the filter
|
||||
// will be set.
|
||||
Writer io.Writer
|
||||
|
||||
badLevels map[LogLevel]struct{}
|
||||
show bool
|
||||
once sync.Once
|
||||
}
|
||||
|
||||
// Check will check a given line if it would be included in the level
|
||||
// filter.
|
||||
func (f *LevelFilter) Check(line []byte) bool {
|
||||
f.once.Do(f.init)
|
||||
|
||||
// Check for a log level
|
||||
var level LogLevel
|
||||
x := bytes.IndexByte(line, '[')
|
||||
if x >= 0 {
|
||||
y := bytes.IndexByte(line[x:], ']')
|
||||
if y >= 0 {
|
||||
level = LogLevel(line[x+1 : x+y])
|
||||
}
|
||||
}
|
||||
|
||||
//return level == ""
|
||||
|
||||
_, ok := f.badLevels[level]
|
||||
return !ok
|
||||
}
|
||||
|
||||
// Write is a specialized implementation of io.Writer suitable for being
|
||||
// the output of a logger from the "log" package.
|
||||
//
|
||||
// This Writer implementation assumes that it will only recieve byte slices
|
||||
// containing one or more entire lines of log output, each one terminated by
|
||||
// a newline. This is compatible with the behavior of the "log" package
|
||||
// directly, and is also tolerant of intermediaries that might buffer multiple
|
||||
// separate writes together, as long as no individual log line is ever
|
||||
// split into multiple slices.
|
||||
//
|
||||
// Behavior is undefined if any log line is split across multiple writes or
|
||||
// written without a trailing '\n' delimiter.
|
||||
func (f *LevelFilter) Write(p []byte) (n int, err error) {
|
||||
for len(p) > 0 {
|
||||
// Split at the first \n, inclusive
|
||||
idx := bytes.IndexByte(p, '\n')
|
||||
if idx == -1 {
|
||||
// Invalid, undelimited write. We'll tolerate it assuming that
|
||||
// our assumptions are being violated, but the results may be
|
||||
// non-ideal.
|
||||
idx = len(p) - 1
|
||||
break
|
||||
}
|
||||
var l []byte
|
||||
l, p = p[:idx+1], p[idx+1:]
|
||||
// Lines starting with characters other than decimal digits (including
|
||||
// whitespace) are assumed to be continuations lines. This is an
|
||||
// imprecise heuristic, but experimentally it seems to generate
|
||||
// "good enough" results from Terraform Core's own logging. Its mileage
|
||||
// may vary with output from other systems.
|
||||
if l[0] >= '0' && l[0] <= '9' {
|
||||
f.show = f.Check(l)
|
||||
}
|
||||
if f.show {
|
||||
_, err = f.Writer.Write(l)
|
||||
if err != nil {
|
||||
// Technically it's not correct to say we've written the whole
|
||||
// buffer, but for our purposes here it's good enough as we're
|
||||
// only implementing io.Writer enough to satisfy logging
|
||||
// use-cases.
|
||||
return len(p), err
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// We always behave as if we wrote the whole of the buffer, even if
|
||||
// we actually skipped some lines. We're only implementiong io.Writer
|
||||
// enough to satisfy logging use-cases.
|
||||
return len(p), nil
|
||||
}
|
||||
|
||||
// SetMinLevel is used to update the minimum log level
|
||||
func (f *LevelFilter) SetMinLevel(min LogLevel) {
|
||||
f.MinLevel = min
|
||||
f.init()
|
||||
}
|
||||
|
||||
func (f *LevelFilter) init() {
|
||||
badLevels := make(map[LogLevel]struct{})
|
||||
for _, level := range f.Levels {
|
||||
if level == f.MinLevel {
|
||||
break
|
||||
}
|
||||
badLevels[level] = struct{}{}
|
||||
}
|
||||
f.badLevels = badLevels
|
||||
f.show = true
|
||||
}
|
||||
@ -1,93 +0,0 @@
|
||||
package logging
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"io"
|
||||
"log"
|
||||
"testing"
|
||||
)
|
||||
|
||||
func TestLevelFilter_impl(t *testing.T) {
|
||||
var _ io.Writer = new(LevelFilter)
|
||||
}
|
||||
|
||||
func TestLevelFilter(t *testing.T) {
|
||||
buf := new(bytes.Buffer)
|
||||
filter := &LevelFilter{
|
||||
Levels: []LogLevel{"DEBUG", "WARN", "ERROR"},
|
||||
MinLevel: "WARN",
|
||||
Writer: buf,
|
||||
}
|
||||
|
||||
logger := log.New(filter, "", 0)
|
||||
logger.Print("2019/01/01 00:00:00 [WARN] foo")
|
||||
logger.Println("2019/01/01 00:00:00 [ERROR] bar\n2019/01/01 00:00:00 [DEBUG] buzz")
|
||||
logger.Println("2019/01/01 00:00:00 [DEBUG] baz\n continuation\n2019/01/01 00:00:00 [WARN] buzz\n more\n2019/01/01 00:00:00 [DEBUG] fizz")
|
||||
|
||||
result := buf.String()
|
||||
expected := "2019/01/01 00:00:00 [WARN] foo\n2019/01/01 00:00:00 [ERROR] bar\n2019/01/01 00:00:00 [WARN] buzz\n more\n"
|
||||
if result != expected {
|
||||
t.Fatalf("wrong result\ngot:\n%s\nwant:\n%s", result, expected)
|
||||
}
|
||||
}
|
||||
|
||||
func TestLevelFilterCheck(t *testing.T) {
|
||||
filter := &LevelFilter{
|
||||
Levels: []LogLevel{"DEBUG", "WARN", "ERROR"},
|
||||
MinLevel: "WARN",
|
||||
Writer: nil,
|
||||
}
|
||||
|
||||
testCases := []struct {
|
||||
line string
|
||||
check bool
|
||||
}{
|
||||
{"[WARN] foo\n", true},
|
||||
{"[ERROR] bar\n", true},
|
||||
{"[DEBUG] baz\n", false},
|
||||
{"[WARN] buzz\n", true},
|
||||
}
|
||||
|
||||
for _, testCase := range testCases {
|
||||
result := filter.Check([]byte(testCase.line))
|
||||
if result != testCase.check {
|
||||
t.Errorf("Fail: %s", testCase.line)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestLevelFilter_SetMinLevel(t *testing.T) {
|
||||
filter := &LevelFilter{
|
||||
Levels: []LogLevel{"DEBUG", "WARN", "ERROR"},
|
||||
MinLevel: "ERROR",
|
||||
Writer: nil,
|
||||
}
|
||||
|
||||
testCases := []struct {
|
||||
line string
|
||||
checkBefore bool
|
||||
checkAfter bool
|
||||
}{
|
||||
{"[WARN] foo\n", false, true},
|
||||
{"[ERROR] bar\n", true, true},
|
||||
{"[DEBUG] baz\n", false, false},
|
||||
{"[WARN] buzz\n", false, true},
|
||||
}
|
||||
|
||||
for _, testCase := range testCases {
|
||||
result := filter.Check([]byte(testCase.line))
|
||||
if result != testCase.checkBefore {
|
||||
t.Errorf("Fail: %s", testCase.line)
|
||||
}
|
||||
}
|
||||
|
||||
// Update the minimum level to WARN
|
||||
filter.SetMinLevel("WARN")
|
||||
|
||||
for _, testCase := range testCases {
|
||||
result := filter.Check([]byte(testCase.line))
|
||||
if result != testCase.checkAfter {
|
||||
t.Errorf("Fail: %s", testCase.line)
|
||||
}
|
||||
}
|
||||
}
|
||||
Loading…
Reference in new issue