Commit 5dc79025f26fac1377065bed218d751ae1e917cc - golang-github-go-kit-kit

log: More concise functions names for experimental_level package. Chris Hines 7 years ago

4 changed file(s) with 26 addition(s) and 25 deletion(s). Raw diff Collapse all Expand all

-1

log/experimental_level/benchmark_test.go less more

43	43	return l
44	44	}},
45	45	{"DisallowedLevel", func(l log.Logger) log.Logger {
46		return level.NewFilter(l, level.AllowInfoAndAbove())
	46	return level.NewFilter(l, level.AllowInfo())
47	47	}},
48	48	{"AllowedLevel", func(l log.Logger) log.Logger {
49	49	return level.NewFilter(l, level.AllowAll())

-1

log/experimental_level/example_test.go less more

10	10	func Example_basic() {
11	11	// setup logger with level filter
12	12	logger := log.NewLogfmtLogger(os.Stdout)
13		logger = level.NewFilter(logger, level.AllowInfoAndAbove())
	13	logger = level.NewFilter(logger, level.AllowInfo())
14	14	logger = log.NewContext(logger).With("caller", log.DefaultCaller)
15	15
16	16	// use level helpers to log at different levels

+19

-18

log/experimental_level/level.go less more

65	65	// Option sets a parameter for the leveled logger.
66	66	type Option func(*logger)
67	67
68		// AllowAll is an alias for AllowDebugAndAbove.
	68	// AllowAll is an alias for AllowDebug.
69	69	func AllowAll() Option {
70		return AllowDebugAndAbove()
	70	return AllowDebug()
71	71	}
72	72
73		// AllowDebugAndAbove allows all of the four default log levels.
74		func AllowDebugAndAbove() Option {
75		return allowed(levelDebug \| levelInfo \| levelWarn \| levelError)
	73	// AllowDebug allows error, warn, info and debug level log events to pass.
	74	func AllowDebug() Option {
	75	return allowed(levelError \| levelWarn \| levelInfo \| levelDebug)
76	76	}
77	77
78		// AllowInfoAndAbove allows the default info, warn, and error log levels.
79		func AllowInfoAndAbove() Option {
80		return allowed(levelInfo \| levelWarn \| levelError)
	78	// AllowInfo allows error, warn and info level log events to pass.
	79	func AllowInfo() Option {
	80	return allowed(levelError \| levelWarn \| levelInfo)
81	81	}
82	82
83		// AllowWarnAndAbove allows the default warn and error log levels.
84		func AllowWarnAndAbove() Option {
85		return allowed(levelWarn \| levelError)
	83	// AllowWarn allows error and warn level log events to pass.
	84	func AllowWarn() Option {
	85	return allowed(levelError \| levelWarn)
86	86	}
87	87
88		// AllowErrorOnly allows only the default error log level.
89		func AllowErrorOnly() Option {
	88	// AllowError allows only error level log events to pass.
	89	func AllowError() Option {
90	90	return allowed(levelError)
91	91	}
92	92
93		// AllowNone allows none of the default log levels.
	93	// AllowNone allows no leveled log events to pass.
94	94	func AllowNone() Option {
95	95	return allowed(0)
96	96	}

100	100	}
101	101
102	102	// ErrNotAllowed sets the error to return from Log when it squelches a log
103		// event below the configured filtering level. By default, ErrNotAllowed is
104		// nil; in this case, the log event is squelched with no error.
	103	// event disallowed by the configured Allow[Level] option. By default,
	104	// ErrNotAllowed is nil; in this case the log event is squelched with no
	105	// error.
105	106	func ErrNotAllowed(err error) Option {
106	107	return func(l *logger) { l.errNotAllowed = err }
107	108	}

115	116	}
116	117
117	118	// ErrNoLevel sets the error to return from Log when it squelches a log event
118		// with no level. By default, ErrNoLevel is nil; in this case, the log event
119		// is squelched with no error.
	119	// with no level. By default, ErrNoLevel is nil; in this case the log event is
	120	// squelched with no error.
120	121	func ErrNoLevel(err error) Option {
121	122	return func(l *logger) { l.errNoLevel = err }
122	123	}

-5

log/experimental_level/level_test.go less more

25	25	}, "\n"),
26	26	},
27	27	{
28		level.AllowDebugAndAbove(),
	28	level.AllowDebug(),
29	29	strings.Join([]string{
30	30	`{"level":"debug","this is":"debug log"}`,
31	31	`{"level":"info","this is":"info log"}`,

34	34	}, "\n"),
35	35	},
36	36	{
37		level.AllowInfoAndAbove(),
	37	level.AllowInfo(),
38	38	strings.Join([]string{
39	39	`{"level":"info","this is":"info log"}`,
40	40	`{"level":"warn","this is":"warn log"}`,

42	42	}, "\n"),
43	43	},
44	44	{
45		level.AllowWarnAndAbove(),
	45	level.AllowWarn(),
46	46	strings.Join([]string{
47	47	`{"level":"warn","this is":"warn log"}`,
48	48	`{"level":"error","this is":"error log"}`,
49	49	}, "\n"),
50	50	},
51	51	{
52		level.AllowErrorOnly(),
	52	level.AllowError(),
53	53	strings.Join([]string{
54	54	`{"level":"error","this is":"error log"}`,
55	55	}, "\n"),

76	76	func TestErrNotAllowed(t *testing.T) {
77	77	myError := errors.New("squelched!")
78	78	opts := []level.Option{
79		level.AllowWarnAndAbove(),
	79	level.AllowWarn(),
80	80	level.ErrNotAllowed(myError),
81	81	}
82	82	logger := level.NewFilter(log.NewNopLogger(), opts...)