| 1 | package logrus
|
|---|
| 2 |
|
|---|
| 3 | import (
|
|---|
| 4 | "bytes"
|
|---|
| 5 | "fmt"
|
|---|
| 6 | "os"
|
|---|
| 7 | "runtime"
|
|---|
| 8 | "sort"
|
|---|
| 9 | "strconv"
|
|---|
| 10 | "strings"
|
|---|
| 11 | "sync"
|
|---|
| 12 | "time"
|
|---|
| 13 | "unicode/utf8"
|
|---|
| 14 | )
|
|---|
| 15 |
|
|---|
| 16 | const (
|
|---|
| 17 | red = 31
|
|---|
| 18 | yellow = 33
|
|---|
| 19 | blue = 36
|
|---|
| 20 | gray = 37
|
|---|
| 21 | )
|
|---|
| 22 |
|
|---|
| 23 | var baseTimestamp time.Time
|
|---|
| 24 |
|
|---|
| 25 | func init() {
|
|---|
| 26 | baseTimestamp = time.Now()
|
|---|
| 27 | }
|
|---|
| 28 |
|
|---|
| 29 | // TextFormatter formats logs into text
|
|---|
| 30 | type TextFormatter struct {
|
|---|
| 31 | // Set to true to bypass checking for a TTY before outputting colors.
|
|---|
| 32 | ForceColors bool
|
|---|
| 33 |
|
|---|
| 34 | // Force disabling colors.
|
|---|
| 35 | DisableColors bool
|
|---|
| 36 |
|
|---|
| 37 | // Force quoting of all values
|
|---|
| 38 | ForceQuote bool
|
|---|
| 39 |
|
|---|
| 40 | // DisableQuote disables quoting for all values.
|
|---|
| 41 | // DisableQuote will have a lower priority than ForceQuote.
|
|---|
| 42 | // If both of them are set to true, quote will be forced on all values.
|
|---|
| 43 | DisableQuote bool
|
|---|
| 44 |
|
|---|
| 45 | // Override coloring based on CLICOLOR and CLICOLOR_FORCE. - https://bixense.com/clicolors/
|
|---|
| 46 | EnvironmentOverrideColors bool
|
|---|
| 47 |
|
|---|
| 48 | // Disable timestamp logging. useful when output is redirected to logging
|
|---|
| 49 | // system that already adds timestamps.
|
|---|
| 50 | DisableTimestamp bool
|
|---|
| 51 |
|
|---|
| 52 | // Enable logging the full timestamp when a TTY is attached instead of just
|
|---|
| 53 | // the time passed since beginning of execution.
|
|---|
| 54 | FullTimestamp bool
|
|---|
| 55 |
|
|---|
| 56 | // TimestampFormat to use for display when a full timestamp is printed.
|
|---|
| 57 | // The format to use is the same than for time.Format or time.Parse from the standard
|
|---|
| 58 | // library.
|
|---|
| 59 | // The standard Library already provides a set of predefined format.
|
|---|
| 60 | TimestampFormat string
|
|---|
| 61 |
|
|---|
| 62 | // The fields are sorted by default for a consistent output. For applications
|
|---|
| 63 | // that log extremely frequently and don't use the JSON formatter this may not
|
|---|
| 64 | // be desired.
|
|---|
| 65 | DisableSorting bool
|
|---|
| 66 |
|
|---|
| 67 | // The keys sorting function, when uninitialized it uses sort.Strings.
|
|---|
| 68 | SortingFunc func([]string)
|
|---|
| 69 |
|
|---|
| 70 | // Disables the truncation of the level text to 4 characters.
|
|---|
| 71 | DisableLevelTruncation bool
|
|---|
| 72 |
|
|---|
| 73 | // PadLevelText Adds padding the level text so that all the levels output at the same length
|
|---|
| 74 | // PadLevelText is a superset of the DisableLevelTruncation option
|
|---|
| 75 | PadLevelText bool
|
|---|
| 76 |
|
|---|
| 77 | // QuoteEmptyFields will wrap empty fields in quotes if true
|
|---|
| 78 | QuoteEmptyFields bool
|
|---|
| 79 |
|
|---|
| 80 | // Whether the logger's out is to a terminal
|
|---|
| 81 | isTerminal bool
|
|---|
| 82 |
|
|---|
| 83 | // FieldMap allows users to customize the names of keys for default fields.
|
|---|
| 84 | // As an example:
|
|---|
| 85 | // formatter := &TextFormatter{
|
|---|
| 86 | // FieldMap: FieldMap{
|
|---|
| 87 | // FieldKeyTime: "@timestamp",
|
|---|
| 88 | // FieldKeyLevel: "@level",
|
|---|
| 89 | // FieldKeyMsg: "@message"}}
|
|---|
| 90 | FieldMap FieldMap
|
|---|
| 91 |
|
|---|
| 92 | // CallerPrettyfier can be set by the user to modify the content
|
|---|
| 93 | // of the function and file keys in the data when ReportCaller is
|
|---|
| 94 | // activated. If any of the returned value is the empty string the
|
|---|
| 95 | // corresponding key will be removed from fields.
|
|---|
| 96 | CallerPrettyfier func(*runtime.Frame) (function string, file string)
|
|---|
| 97 |
|
|---|
| 98 | terminalInitOnce sync.Once
|
|---|
| 99 |
|
|---|
| 100 | // The max length of the level text, generated dynamically on init
|
|---|
| 101 | levelTextMaxLength int
|
|---|
| 102 | }
|
|---|
| 103 |
|
|---|
| 104 | func (f *TextFormatter) init(entry *Entry) {
|
|---|
| 105 | if entry.Logger != nil {
|
|---|
| 106 | f.isTerminal = checkIfTerminal(entry.Logger.Out)
|
|---|
| 107 | }
|
|---|
| 108 | // Get the max length of the level text
|
|---|
| 109 | for _, level := range AllLevels {
|
|---|
| 110 | levelTextLength := utf8.RuneCount([]byte(level.String()))
|
|---|
| 111 | if levelTextLength > f.levelTextMaxLength {
|
|---|
| 112 | f.levelTextMaxLength = levelTextLength
|
|---|
| 113 | }
|
|---|
| 114 | }
|
|---|
| 115 | }
|
|---|
| 116 |
|
|---|
| 117 | func (f *TextFormatter) isColored() bool {
|
|---|
| 118 | isColored := f.ForceColors || (f.isTerminal && (runtime.GOOS != "windows"))
|
|---|
| 119 |
|
|---|
| 120 | if f.EnvironmentOverrideColors {
|
|---|
| 121 | switch force, ok := os.LookupEnv("CLICOLOR_FORCE"); {
|
|---|
| 122 | case ok && force != "0":
|
|---|
| 123 | isColored = true
|
|---|
| 124 | case ok && force == "0", os.Getenv("CLICOLOR") == "0":
|
|---|
| 125 | isColored = false
|
|---|
| 126 | }
|
|---|
| 127 | }
|
|---|
| 128 |
|
|---|
| 129 | return isColored && !f.DisableColors
|
|---|
| 130 | }
|
|---|
| 131 |
|
|---|
| 132 | // Format renders a single log entry
|
|---|
| 133 | func (f *TextFormatter) Format(entry *Entry) ([]byte, error) {
|
|---|
| 134 | data := make(Fields)
|
|---|
| 135 | for k, v := range entry.Data {
|
|---|
| 136 | data[k] = v
|
|---|
| 137 | }
|
|---|
| 138 | prefixFieldClashes(data, f.FieldMap, entry.HasCaller())
|
|---|
| 139 | keys := make([]string, 0, len(data))
|
|---|
| 140 | for k := range data {
|
|---|
| 141 | keys = append(keys, k)
|
|---|
| 142 | }
|
|---|
| 143 |
|
|---|
| 144 | var funcVal, fileVal string
|
|---|
| 145 |
|
|---|
| 146 | fixedKeys := make([]string, 0, 4+len(data))
|
|---|
| 147 | if !f.DisableTimestamp {
|
|---|
| 148 | fixedKeys = append(fixedKeys, f.FieldMap.resolve(FieldKeyTime))
|
|---|
| 149 | }
|
|---|
| 150 | fixedKeys = append(fixedKeys, f.FieldMap.resolve(FieldKeyLevel))
|
|---|
| 151 | if entry.Message != "" {
|
|---|
| 152 | fixedKeys = append(fixedKeys, f.FieldMap.resolve(FieldKeyMsg))
|
|---|
| 153 | }
|
|---|
| 154 | if entry.err != "" {
|
|---|
| 155 | fixedKeys = append(fixedKeys, f.FieldMap.resolve(FieldKeyLogrusError))
|
|---|
| 156 | }
|
|---|
| 157 | if entry.HasCaller() {
|
|---|
| 158 | if f.CallerPrettyfier != nil {
|
|---|
| 159 | funcVal, fileVal = f.CallerPrettyfier(entry.Caller)
|
|---|
| 160 | } else {
|
|---|
| 161 | funcVal = entry.Caller.Function
|
|---|
| 162 | fileVal = fmt.Sprintf("%s:%d", entry.Caller.File, entry.Caller.Line)
|
|---|
| 163 | }
|
|---|
| 164 |
|
|---|
| 165 | if funcVal != "" {
|
|---|
| 166 | fixedKeys = append(fixedKeys, f.FieldMap.resolve(FieldKeyFunc))
|
|---|
| 167 | }
|
|---|
| 168 | if fileVal != "" {
|
|---|
| 169 | fixedKeys = append(fixedKeys, f.FieldMap.resolve(FieldKeyFile))
|
|---|
| 170 | }
|
|---|
| 171 | }
|
|---|
| 172 |
|
|---|
| 173 | if !f.DisableSorting {
|
|---|
| 174 | if f.SortingFunc == nil {
|
|---|
| 175 | sort.Strings(keys)
|
|---|
| 176 | fixedKeys = append(fixedKeys, keys...)
|
|---|
| 177 | } else {
|
|---|
| 178 | if !f.isColored() {
|
|---|
| 179 | fixedKeys = append(fixedKeys, keys...)
|
|---|
| 180 | f.SortingFunc(fixedKeys)
|
|---|
| 181 | } else {
|
|---|
| 182 | f.SortingFunc(keys)
|
|---|
| 183 | }
|
|---|
| 184 | }
|
|---|
| 185 | } else {
|
|---|
| 186 | fixedKeys = append(fixedKeys, keys...)
|
|---|
| 187 | }
|
|---|
| 188 |
|
|---|
| 189 | var b *bytes.Buffer
|
|---|
| 190 | if entry.Buffer != nil {
|
|---|
| 191 | b = entry.Buffer
|
|---|
| 192 | } else {
|
|---|
| 193 | b = &bytes.Buffer{}
|
|---|
| 194 | }
|
|---|
| 195 |
|
|---|
| 196 | f.terminalInitOnce.Do(func() { f.init(entry) })
|
|---|
| 197 |
|
|---|
| 198 | timestampFormat := f.TimestampFormat
|
|---|
| 199 | if timestampFormat == "" {
|
|---|
| 200 | timestampFormat = defaultTimestampFormat
|
|---|
| 201 | }
|
|---|
| 202 | if f.isColored() {
|
|---|
| 203 | f.printColored(b, entry, keys, data, timestampFormat)
|
|---|
| 204 | } else {
|
|---|
| 205 |
|
|---|
| 206 | for _, key := range fixedKeys {
|
|---|
| 207 | var value interface{}
|
|---|
| 208 | switch {
|
|---|
| 209 | case key == f.FieldMap.resolve(FieldKeyTime):
|
|---|
| 210 | value = entry.Time.Format(timestampFormat)
|
|---|
| 211 | case key == f.FieldMap.resolve(FieldKeyLevel):
|
|---|
| 212 | value = entry.Level.String()
|
|---|
| 213 | case key == f.FieldMap.resolve(FieldKeyMsg):
|
|---|
| 214 | value = entry.Message
|
|---|
| 215 | case key == f.FieldMap.resolve(FieldKeyLogrusError):
|
|---|
| 216 | value = entry.err
|
|---|
| 217 | case key == f.FieldMap.resolve(FieldKeyFunc) && entry.HasCaller():
|
|---|
| 218 | value = funcVal
|
|---|
| 219 | case key == f.FieldMap.resolve(FieldKeyFile) && entry.HasCaller():
|
|---|
| 220 | value = fileVal
|
|---|
| 221 | default:
|
|---|
| 222 | value = data[key]
|
|---|
| 223 | }
|
|---|
| 224 | f.appendKeyValue(b, key, value)
|
|---|
| 225 | }
|
|---|
| 226 | }
|
|---|
| 227 |
|
|---|
| 228 | b.WriteByte('\n')
|
|---|
| 229 | return b.Bytes(), nil
|
|---|
| 230 | }
|
|---|
| 231 |
|
|---|
| 232 | func (f *TextFormatter) printColored(b *bytes.Buffer, entry *Entry, keys []string, data Fields, timestampFormat string) {
|
|---|
| 233 | var levelColor int
|
|---|
| 234 | switch entry.Level {
|
|---|
| 235 | case DebugLevel, TraceLevel:
|
|---|
| 236 | levelColor = gray
|
|---|
| 237 | case WarnLevel:
|
|---|
| 238 | levelColor = yellow
|
|---|
| 239 | case ErrorLevel, FatalLevel, PanicLevel:
|
|---|
| 240 | levelColor = red
|
|---|
| 241 | case InfoLevel:
|
|---|
| 242 | levelColor = blue
|
|---|
| 243 | default:
|
|---|
| 244 | levelColor = blue
|
|---|
| 245 | }
|
|---|
| 246 |
|
|---|
| 247 | levelText := strings.ToUpper(entry.Level.String())
|
|---|
| 248 | if !f.DisableLevelTruncation && !f.PadLevelText {
|
|---|
| 249 | levelText = levelText[0:4]
|
|---|
| 250 | }
|
|---|
| 251 | if f.PadLevelText {
|
|---|
| 252 | // Generates the format string used in the next line, for example "%-6s" or "%-7s".
|
|---|
| 253 | // Based on the max level text length.
|
|---|
| 254 | formatString := "%-" + strconv.Itoa(f.levelTextMaxLength) + "s"
|
|---|
| 255 | // Formats the level text by appending spaces up to the max length, for example:
|
|---|
| 256 | // - "INFO "
|
|---|
| 257 | // - "WARNING"
|
|---|
| 258 | levelText = fmt.Sprintf(formatString, levelText)
|
|---|
| 259 | }
|
|---|
| 260 |
|
|---|
| 261 | // Remove a single newline if it already exists in the message to keep
|
|---|
| 262 | // the behavior of logrus text_formatter the same as the stdlib log package
|
|---|
| 263 | entry.Message = strings.TrimSuffix(entry.Message, "\n")
|
|---|
| 264 |
|
|---|
| 265 | caller := ""
|
|---|
| 266 | if entry.HasCaller() {
|
|---|
| 267 | funcVal := fmt.Sprintf("%s()", entry.Caller.Function)
|
|---|
| 268 | fileVal := fmt.Sprintf("%s:%d", entry.Caller.File, entry.Caller.Line)
|
|---|
| 269 |
|
|---|
| 270 | if f.CallerPrettyfier != nil {
|
|---|
| 271 | funcVal, fileVal = f.CallerPrettyfier(entry.Caller)
|
|---|
| 272 | }
|
|---|
| 273 |
|
|---|
| 274 | if fileVal == "" {
|
|---|
| 275 | caller = funcVal
|
|---|
| 276 | } else if funcVal == "" {
|
|---|
| 277 | caller = fileVal
|
|---|
| 278 | } else {
|
|---|
| 279 | caller = fileVal + " " + funcVal
|
|---|
| 280 | }
|
|---|
| 281 | }
|
|---|
| 282 |
|
|---|
| 283 | switch {
|
|---|
| 284 | case f.DisableTimestamp:
|
|---|
| 285 | fmt.Fprintf(b, "\x1b[%dm%s\x1b[0m%s %-44s ", levelColor, levelText, caller, entry.Message)
|
|---|
| 286 | case !f.FullTimestamp:
|
|---|
| 287 | fmt.Fprintf(b, "\x1b[%dm%s\x1b[0m[%04d]%s %-44s ", levelColor, levelText, int(entry.Time.Sub(baseTimestamp)/time.Second), caller, entry.Message)
|
|---|
| 288 | default:
|
|---|
| 289 | fmt.Fprintf(b, "\x1b[%dm%s\x1b[0m[%s]%s %-44s ", levelColor, levelText, entry.Time.Format(timestampFormat), caller, entry.Message)
|
|---|
| 290 | }
|
|---|
| 291 | for _, k := range keys {
|
|---|
| 292 | v := data[k]
|
|---|
| 293 | fmt.Fprintf(b, " \x1b[%dm%s\x1b[0m=", levelColor, k)
|
|---|
| 294 | f.appendValue(b, v)
|
|---|
| 295 | }
|
|---|
| 296 | }
|
|---|
| 297 |
|
|---|
| 298 | func (f *TextFormatter) needsQuoting(text string) bool {
|
|---|
| 299 | if f.ForceQuote {
|
|---|
| 300 | return true
|
|---|
| 301 | }
|
|---|
| 302 | if f.QuoteEmptyFields && len(text) == 0 {
|
|---|
| 303 | return true
|
|---|
| 304 | }
|
|---|
| 305 | if f.DisableQuote {
|
|---|
| 306 | return false
|
|---|
| 307 | }
|
|---|
| 308 | for _, ch := range text {
|
|---|
| 309 | if !((ch >= 'a' && ch <= 'z') ||
|
|---|
| 310 | (ch >= 'A' && ch <= 'Z') ||
|
|---|
| 311 | (ch >= '0' && ch <= '9') ||
|
|---|
| 312 | ch == '-' || ch == '.' || ch == '_' || ch == '/' || ch == '@' || ch == '^' || ch == '+') {
|
|---|
| 313 | return true
|
|---|
| 314 | }
|
|---|
| 315 | }
|
|---|
| 316 | return false
|
|---|
| 317 | }
|
|---|
| 318 |
|
|---|
| 319 | func (f *TextFormatter) appendKeyValue(b *bytes.Buffer, key string, value interface{}) {
|
|---|
| 320 | if b.Len() > 0 {
|
|---|
| 321 | b.WriteByte(' ')
|
|---|
| 322 | }
|
|---|
| 323 | b.WriteString(key)
|
|---|
| 324 | b.WriteByte('=')
|
|---|
| 325 | f.appendValue(b, value)
|
|---|
| 326 | }
|
|---|
| 327 |
|
|---|
| 328 | func (f *TextFormatter) appendValue(b *bytes.Buffer, value interface{}) {
|
|---|
| 329 | stringVal, ok := value.(string)
|
|---|
| 330 | if !ok {
|
|---|
| 331 | stringVal = fmt.Sprint(value)
|
|---|
| 332 | }
|
|---|
| 333 |
|
|---|
| 334 | if !f.needsQuoting(stringVal) {
|
|---|
| 335 | b.WriteString(stringVal)
|
|---|
| 336 | } else {
|
|---|
| 337 | b.WriteString(fmt.Sprintf("%q", stringVal))
|
|---|
| 338 | }
|
|---|
| 339 | }
|
|---|
