text: package logrus
  
  import "time"
  
  // Default key names for the default fields
  const (
  	defaultTimestampFormat = time.RFC3339
  	FieldKeyMsg            = "msg"
  	FieldKeyLevel          = "level"
  	FieldKeyTime           = "time"
  	FieldKeyLogrusError    = "logrus_error"
  	FieldKeyFunc           = "func"
  	FieldKeyFile           = "file"
  )
  
  // The Formatter interface is used to implement a custom Formatter. It takes an
  // `Entry`. It exposes all the fields, including the default ones:
  //
  // * `entry.Data["msg"]`. The message passed from Info, Warn, Error ..
  // * `entry.Data["time"]`. The timestamp.
  // * `entry.Data["level"]. The level the entry was logged at.
  //
  // Any additional fields added with `WithField` or `WithFields` are also in
  // `entry.Data`. Format is expected to return an array of bytes which are then
  // logged to `logger.Out`.
  type Formatter interface {
  	Format(*Entry) ([]byte, error)
  }
  
  // This is to not silently overwrite `time`, `msg`, `func` and `level` fields when
  // dumping it. If this code wasn't there doing:
  //
  //  logrus.WithField("level", 1).Info("hello")
  //
  // Would just silently drop the user provided level. Instead with this code
  // it'll logged as:
  //
  //  {"level": "info", "fields.level": 1, "msg": "hello", "time": "..."}
  //
  // It's not exported because it's still using Data in an opinionated way. It's to
  // avoid code duplication between the two default formatters.
  func prefixFieldClashes(data Fields, fieldMap FieldMap, reportCaller bool) {
  	timeKey := fieldMap.resolve(FieldKeyTime)
  	if t, ok := data[timeKey]; ok {
  		data["fields."+timeKey] = t
  		delete(data, timeKey)
  	}
  
  	msgKey := fieldMap.resolve(FieldKeyMsg)
  	if m, ok := data[msgKey]; ok {
  		data["fields."+msgKey] = m
  		delete(data, msgKey)
  	}
  
  	levelKey := fieldMap.resolve(FieldKeyLevel)
  	if l, ok := data[levelKey]; ok {
  		data["fields."+levelKey] = l
  		delete(data, levelKey)
  	}
  
  	logrusErrKey := fieldMap.resolve(FieldKeyLogrusError)
  	if l, ok := data[logrusErrKey]; ok {
  		data["fields."+logrusErrKey] = l
  		delete(data, logrusErrKey)
  	}
  
  	// If reportCaller is not set, 'func' will not conflict.
  	if reportCaller {
  		funcKey := fieldMap.resolve(FieldKeyFunc)
  		if l, ok := data[funcKey]; ok {
  			data["fields."+funcKey] = l
  		}
  		fileKey := fieldMap.resolve(FieldKeyFile)
  		if l, ok := data[fileKey]; ok {
  			data["fields."+fileKey] = l
  		}
  	}
  }
  