logmsglint/rules.go at main · timur-developer/logmsglint · GitHub

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
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
package logmsglint

import (
	"strings"
	"unicode"
)

type issue struct {
	message   string
	suggested string
}

var currentConfig = defaultConfig()

var builtInKeywords = []string{
	"password",
	"passwd",
	"api_key",
	"apikey",
	"secret",
	"token",
	"authorization",
	"bearer",
}

func checkMessage(m extractedMessage) []issue {
	msg := normalizeSpaces(m.text)
	if msg == "" {
		return nil
	}

	var out []issue

	if iss, ok := ruleLowercaseStart(msg, currentConfig); ok {
		out = append(out, iss)
	}

	if iss, ok := ruleEnglishOnly(msg); ok {
		out = append(out, iss)
	}

	if iss, ok := ruleAllowedChars(msg, currentConfig); ok {
		out = append(out, iss)
	}

	if iss, ok := ruleSensitive(msg, currentConfig); ok {
		out = append(out, iss)
	}

	return out
}

func ruleLowercaseStart(msg string, cfg Config) (issue, bool) {
	runes := []rune(strings.TrimSpace(msg))
	if len(runes) == 0 {
		return issue{}, false
	}

	r := runes[0]
	if unicode.IsLetter(r) && unicode.IsUpper(r) {
		if !cfg.EnableFixes {
			return issue{
				message: "log message must start with a lowercase letter",
			}, true
		}
		runes[0] = unicode.ToLower(r)
		return issue{
			message:   "log message must start with a lowercase letter",
			suggested: string(runes),
		}, true
	}

	return issue{}, false
}

func ruleEnglishOnly(msg string) (issue, bool) {
	for _, r := range msg {
		if !unicode.IsLetter(r) {
			continue
		}

		if (r >= 'a' && r <= 'z') || (r >= 'A' && r <= 'Z') {
			continue
		}

		return issue{message: "log message must contain only English letters"}, true
	}

	return issue{}, false
}

func ruleAllowedChars(msg string, cfg Config) (issue, bool) {
	allowedPunct := cfg.AllowedPunct

	for _, r := range msg {
		if unicode.IsLetter(r) || unicode.IsNumber(r) || r == ' ' {
			continue
		}
		if strings.ContainsRune(allowedPunct, r) {
			continue
		}
		return issue{message: "log message must not contain special characters or emoji"}, true
	}
	return issue{}, false
}

func ruleSensitive(msg string, cfg Config) (issue, bool) {
	l := strings.ToLower(msg)

	for _, kw := range builtInKeywords {
		if strings.Contains(l, kw) {
			return issue{message: "log message may contain sensitive data"}, true
		}
	}
	for _, kw := range cfg.ExtraKeywords {
		if strings.Contains(l, strings.ToLower(kw)) {
			return issue{message: "log message may contain sensitive data"}, true
		}
	}
	for _, re := range cfg.SensitivePatterns {
		if re.MatchString(msg) {
			return issue{message: "log message may contain sensitive data"}, true
		}
	}

	return issue{}, false
}