-
-
Notifications
You must be signed in to change notification settings - Fork 957
/
logger.go
143 lines (124 loc) · 4.15 KB
/
logger.go
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
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
package util
import (
"fmt"
"io"
"os"
"golang.org/x/term"
"github.com/hashicorp/hcl/v2"
"github.com/hashicorp/hcl/v2/hclparse"
"github.com/sirupsen/logrus"
)
// used in integration tests
const (
defaultLogLevel = logrus.InfoLevel
logLevelEnvVar = "TERRAGRUNT_LOG_LEVEL"
)
var (
// GlobalFallbackLogEntry is a global fallback logentry for the application
// Should be used in cases when more specific logger can't be created (like in the very beginning, when we have not yet
// parsed command line arguments).
//
// This might go away once we migrate toproper cli library
// (see https://github.com/gruntwork-io/terragrunt/blob/master/cli/args.go#L29)
GlobalFallbackLogEntry *logrus.Entry
disableLogColors bool
jsonLogFormat bool
)
func init() {
defaultLogLevel := GetDefaultLogLevel()
GlobalFallbackLogEntry = CreateLogEntry("", defaultLogLevel)
}
func DisableLogColors() {
disableLogColors = true
// Needs to re-create the global logger
GlobalFallbackLogEntry = CreateLogEntry("", defaultLogLevel)
}
func JsonFormat() {
jsonLogFormat = true
// Needs to re-create the global logger
GlobalFallbackLogEntry = CreateLogEntry("", defaultLogLevel)
}
func DisableJsonFormat() {
jsonLogFormat = false
// Needs to re-create the global logger
GlobalFallbackLogEntry = CreateLogEntry("", defaultLogLevel)
}
// CreateLogger creates a logger. If debug is set, we use ErrorLevel to enable verbose output, otherwise - only errors are shown
func CreateLogger(lvl logrus.Level) *logrus.Logger {
logger := logrus.New()
logger.SetLevel(lvl)
logger.SetOutput(os.Stderr) // Terragrunt should output all it's logs to stderr by default
if jsonLogFormat {
logger.SetFormatter(&logrus.JSONFormatter{})
} else {
logger.SetFormatter(&logrus.TextFormatter{
DisableQuote: true,
DisableColors: disableLogColors,
})
}
return logger
}
// CreateLogEntry creates a logger entry with the given prefix field
func CreateLogEntry(prefix string, level logrus.Level) *logrus.Entry {
logger := CreateLogger(level)
var fields logrus.Fields
if prefix != "" {
fields = logrus.Fields{"prefix": prefix}
} else {
fields = logrus.Fields{}
}
return logger.WithFields(fields)
}
// CreateLogEntryWithWriter Create a logger around the given output stream and prefix
func CreateLogEntryWithWriter(writer io.Writer, prefix string, level logrus.Level, hooks logrus.LevelHooks) *logrus.Entry {
if prefix != "" {
prefix = fmt.Sprintf("[%s] ", prefix)
} else {
prefix = fmt.Sprintf("[terragrunt] %s", prefix)
}
logger := CreateLogEntry(prefix, level)
logger.Logger.SetOutput(writer)
logger.Logger.ReplaceHooks(hooks)
return logger
}
// GetDiagnosticsWriter returns a hcl2 parsing diagnostics emitter for the current terminal.
func GetDiagnosticsWriter(logger *logrus.Entry, parser *hclparse.Parser) hcl.DiagnosticWriter {
termColor := term.IsTerminal(int(os.Stderr.Fd()))
termWidth, _, err := term.GetSize(int(os.Stdout.Fd()))
if err != nil {
termWidth = 80
}
var writer = LogWriter{Logger: logger, Level: logrus.ErrorLevel}
return hcl.NewDiagnosticTextWriter(&writer, parser.Files(), uint(termWidth), termColor)
}
// GetDefaultLogLevel returns the default log level to use. The log level is resolved based on the environment variable
// with name from LogLevelEnvVar, falling back to info if unspecified or there is an error parsing the given log level.
func GetDefaultLogLevel() logrus.Level {
defaultLogLevelStr := os.Getenv(logLevelEnvVar)
if defaultLogLevelStr == "" {
return defaultLogLevel
}
return ParseLogLevel(defaultLogLevelStr)
}
func ParseLogLevel(logLevelStr string) logrus.Level {
parsedLogLevel, err := logrus.ParseLevel(logLevelStr)
if err != nil {
CreateLogEntry("", defaultLogLevel).Errorf(
"Could not parse log level from environment variable %s (%s) - falling back to default %s",
logLevelEnvVar,
logLevelStr,
defaultLogLevel,
)
return defaultLogLevel
}
return parsedLogLevel
}
// LogWriter - Writer implementation which redirect Write requests to configured logger and level
type LogWriter struct {
Logger *logrus.Entry
Level logrus.Level
}
func (w *LogWriter) Write(p []byte) (n int, err error) {
w.Logger.Log(w.Level, string(p))
return len(p), nil
}