1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
|
package log
import (
"fmt"
"os"
"strings"
)
var rules []Rule
type Rule func(names []string) (level Level, matched bool)
func alwaysLevel(level Level) Rule {
return func(names []string) (Level, bool) {
return level, true
}
}
func stringSliceContains(s string, ss []string) bool {
for _, sss := range ss {
if s == sss {
return true
}
}
return false
}
func containsAllNames(all []string, level Level) Rule {
return func(names []string) (_ Level, matched bool) {
for _, s := range all {
//log.Println(s, all, names)
if !stringSliceContains(s, names) {
return
}
}
return level, true
}
}
func parseRuleString(s string) (_ Rule, ok bool, _ error) {
if s == "" {
return
}
ss := strings.SplitN(s, "=", 2)
level := NotSet
var names []string
if ss[0] != "*" {
names = []string{ss[0]}
}
if len(ss) > 1 {
var ok bool
var err error
level, ok, err = levelFromString(ss[1])
if !ok {
// blah= means disable the name, but just blah means to always include it
level = disabled
}
if err != nil {
return nil, false, fmt.Errorf("parsing level %q: %w", ss[1], err)
}
}
return containsAllNames(names, level), true, nil
}
func parseEnvRules() (rules []Rule, err error) {
rulesStr := os.Getenv("GO_LOG")
ruleStrs := strings.Split(rulesStr, ",")
for _, ruleStr := range ruleStrs {
rule, ok, err := parseRuleString(ruleStr)
if err != nil {
return nil, fmt.Errorf("parsing rule %q: %w", ruleStr, err)
}
if !ok {
continue
}
rules = append(rules, rule)
}
return
}
func levelFromString(s string) (level Level, ok bool, err error) {
if s == "" {
return
}
ok = true
err = level.UnmarshalText([]byte(s))
return
}
func levelFromRules(names []string) (_ Level, ok bool) {
// Later rules take precedence
for i := len(rules) - 1; i >= 0; i-- {
r := rules[i]
level, ok := r(names)
if ok {
return level, true
}
}
return
}
|
