2014-03-11 03:22:08 +04:00
|
|
|
package logrus
|
|
|
|
|
|
|
|
import (
|
2014-05-24 18:46:03 +04:00
|
|
|
"bytes"
|
2014-03-11 03:22:08 +04:00
|
|
|
"fmt"
|
2018-07-13 18:33:25 +03:00
|
|
|
"os"
|
2018-11-16 17:17:01 +03:00
|
|
|
"runtime"
|
2014-03-11 03:22:08 +04:00
|
|
|
"sort"
|
2019-06-25 06:42:20 +03:00
|
|
|
"strconv"
|
2014-03-11 03:22:08 +04:00
|
|
|
"strings"
|
2017-02-06 03:10:19 +03:00
|
|
|
"sync"
|
2014-05-04 04:43:55 +04:00
|
|
|
"time"
|
2019-06-27 06:48:04 +03:00
|
|
|
"unicode/utf8"
|
2014-03-11 03:22:08 +04:00
|
|
|
)
|
|
|
|
|
|
|
|
const (
|
2019-01-11 22:22:21 +03:00
|
|
|
red = 31
|
|
|
|
yellow = 33
|
|
|
|
blue = 36
|
|
|
|
gray = 37
|
2014-03-11 03:22:08 +04:00
|
|
|
)
|
|
|
|
|
2019-01-11 22:22:21 +03:00
|
|
|
var baseTimestamp time.Time
|
2014-09-17 01:19:03 +04:00
|
|
|
|
2014-05-04 04:43:55 +04:00
|
|
|
func init() {
|
|
|
|
baseTimestamp = time.Now()
|
|
|
|
}
|
|
|
|
|
2017-07-26 15:26:30 +03:00
|
|
|
// TextFormatter formats logs into text
|
2014-03-11 03:22:08 +04:00
|
|
|
type TextFormatter struct {
|
2024-05-14 09:00:24 +03:00
|
|
|
// Set to true if want the log not to contain the startingKey, e.g.
|
|
|
|
// 0001-01-01T00:00:00Z warning message
|
|
|
|
ExcludeKey bool
|
|
|
|
|
2014-03-16 07:36:51 +04:00
|
|
|
// Set to true to bypass checking for a TTY before outputting colors.
|
2015-02-25 22:01:02 +03:00
|
|
|
ForceColors bool
|
|
|
|
|
|
|
|
// Force disabling colors.
|
2014-08-13 21:30:25 +04:00
|
|
|
DisableColors bool
|
2015-02-25 22:01:02 +03:00
|
|
|
|
2019-10-15 08:53:51 +03:00
|
|
|
// Force quoting of all values
|
|
|
|
ForceQuote bool
|
|
|
|
|
2020-04-29 10:15:21 +03:00
|
|
|
// DisableQuote disables quoting for all values.
|
|
|
|
// DisableQuote will have a lower priority than ForceQuote.
|
|
|
|
// If both of them are set to true, quote will be forced on all values.
|
2020-04-23 15:02:38 +03:00
|
|
|
DisableQuote bool
|
|
|
|
|
2018-07-13 18:33:25 +03:00
|
|
|
// Override coloring based on CLICOLOR and CLICOLOR_FORCE. - https://bixense.com/clicolors/
|
2018-08-09 16:00:46 +03:00
|
|
|
EnvironmentOverrideColors bool
|
2018-07-13 18:33:25 +03:00
|
|
|
|
2015-02-25 22:01:02 +03:00
|
|
|
// Disable timestamp logging. useful when output is redirected to logging
|
|
|
|
// system that already adds timestamps.
|
2014-12-15 22:02:02 +03:00
|
|
|
DisableTimestamp bool
|
2015-02-25 22:01:02 +03:00
|
|
|
|
|
|
|
// Enable logging the full timestamp when a TTY is attached instead of just
|
|
|
|
// the time passed since beginning of execution.
|
|
|
|
FullTimestamp bool
|
2015-03-09 18:19:51 +03:00
|
|
|
|
2021-03-08 20:02:30 +03:00
|
|
|
// TimestampFormat to use for display when a full timestamp is printed.
|
|
|
|
// The format to use is the same than for time.Format or time.Parse from the standard
|
|
|
|
// library.
|
|
|
|
// The standard Library already provides a set of predefined format.
|
2015-03-27 02:04:45 +03:00
|
|
|
TimestampFormat string
|
|
|
|
|
2015-03-09 18:19:51 +03:00
|
|
|
// The fields are sorted by default for a consistent output. For applications
|
|
|
|
// that log extremely frequently and don't use the JSON formatter this may not
|
|
|
|
// be desired.
|
|
|
|
DisableSorting bool
|
2017-02-05 17:21:03 +03:00
|
|
|
|
2018-09-25 14:45:23 +03:00
|
|
|
// The keys sorting function, when uninitialized it uses sort.Strings.
|
|
|
|
SortingFunc func([]string)
|
|
|
|
|
2016-08-31 16:54:59 +03:00
|
|
|
// Disables the truncation of the level text to 4 characters.
|
|
|
|
DisableLevelTruncation bool
|
2018-01-24 07:04:29 +03:00
|
|
|
|
2019-06-05 10:10:46 +03:00
|
|
|
// PadLevelText Adds padding the level text so that all the levels output at the same length
|
|
|
|
// PadLevelText is a superset of the DisableLevelTruncation option
|
|
|
|
PadLevelText bool
|
|
|
|
|
2017-02-14 13:53:03 +03:00
|
|
|
// QuoteEmptyFields will wrap empty fields in quotes if true
|
|
|
|
QuoteEmptyFields bool
|
|
|
|
|
2017-02-05 17:21:03 +03:00
|
|
|
// Whether the logger's out is to a terminal
|
2017-02-14 14:51:23 +03:00
|
|
|
isTerminal bool
|
|
|
|
|
2017-11-22 06:43:47 +03:00
|
|
|
// FieldMap allows users to customize the names of keys for default fields.
|
|
|
|
// As an example:
|
2017-11-22 06:56:37 +03:00
|
|
|
// formatter := &TextFormatter{
|
2017-11-22 06:43:47 +03:00
|
|
|
// FieldMap: FieldMap{
|
2017-11-22 06:56:37 +03:00
|
|
|
// FieldKeyTime: "@timestamp",
|
2017-11-22 06:43:47 +03:00
|
|
|
// FieldKeyLevel: "@level",
|
2017-11-22 06:56:37 +03:00
|
|
|
// FieldKeyMsg: "@message"}}
|
2017-11-22 06:43:47 +03:00
|
|
|
FieldMap FieldMap
|
|
|
|
|
2019-02-27 15:34:02 +03:00
|
|
|
// CallerPrettyfier can be set by the user to modify the content
|
2019-04-02 06:43:56 +03:00
|
|
|
// of the function and file keys in the data when ReportCaller is
|
2019-02-27 15:34:02 +03:00
|
|
|
// activated. If any of the returned value is the empty string the
|
2019-04-02 06:43:56 +03:00
|
|
|
// corresponding key will be removed from fields.
|
2019-02-27 15:34:02 +03:00
|
|
|
CallerPrettyfier func(*runtime.Frame) (function string, file string)
|
|
|
|
|
2018-09-25 14:45:23 +03:00
|
|
|
terminalInitOnce sync.Once
|
2019-06-25 06:42:20 +03:00
|
|
|
|
|
|
|
// The max length of the level text, generated dynamically on init
|
|
|
|
levelTextMaxLength int
|
2014-03-11 03:22:08 +04:00
|
|
|
}
|
|
|
|
|
2017-02-15 16:08:26 +03:00
|
|
|
func (f *TextFormatter) init(entry *Entry) {
|
|
|
|
if entry.Logger != nil {
|
2017-09-06 20:34:58 +03:00
|
|
|
f.isTerminal = checkIfTerminal(entry.Logger.Out)
|
2017-02-15 16:08:26 +03:00
|
|
|
}
|
2019-06-25 06:42:20 +03:00
|
|
|
// Get the max length of the level text
|
|
|
|
for _, level := range AllLevels {
|
2019-06-27 06:48:04 +03:00
|
|
|
levelTextLength := utf8.RuneCount([]byte(level.String()))
|
2019-06-25 06:42:20 +03:00
|
|
|
if levelTextLength > f.levelTextMaxLength {
|
|
|
|
f.levelTextMaxLength = levelTextLength
|
|
|
|
}
|
|
|
|
}
|
2017-02-15 16:08:26 +03:00
|
|
|
}
|
|
|
|
|
2018-07-13 18:33:25 +03:00
|
|
|
func (f *TextFormatter) isColored() bool {
|
2018-12-09 23:47:44 +03:00
|
|
|
isColored := f.ForceColors || (f.isTerminal && (runtime.GOOS != "windows"))
|
2018-07-13 18:33:25 +03:00
|
|
|
|
2018-08-09 16:00:46 +03:00
|
|
|
if f.EnvironmentOverrideColors {
|
2019-03-13 12:38:09 +03:00
|
|
|
switch force, ok := os.LookupEnv("CLICOLOR_FORCE"); {
|
|
|
|
case ok && force != "0":
|
2018-07-13 18:33:25 +03:00
|
|
|
isColored = true
|
2019-03-13 12:38:09 +03:00
|
|
|
case ok && force == "0", os.Getenv("CLICOLOR") == "0":
|
2018-07-13 18:33:25 +03:00
|
|
|
isColored = false
|
|
|
|
}
|
2017-02-15 16:08:26 +03:00
|
|
|
}
|
2018-07-13 18:33:25 +03:00
|
|
|
|
|
|
|
return isColored && !f.DisableColors
|
2014-03-11 03:22:08 +04:00
|
|
|
}
|
|
|
|
|
2017-07-26 15:26:30 +03:00
|
|
|
// Format renders a single log entry
|
2014-03-11 03:22:08 +04:00
|
|
|
func (f *TextFormatter) Format(entry *Entry) ([]byte, error) {
|
2018-11-05 15:29:28 +03:00
|
|
|
data := make(Fields)
|
|
|
|
for k, v := range entry.Data {
|
|
|
|
data[k] = v
|
|
|
|
}
|
|
|
|
prefixFieldClashes(data, f.FieldMap, entry.HasCaller())
|
|
|
|
keys := make([]string, 0, len(data))
|
|
|
|
for k := range data {
|
2014-09-17 04:19:42 +04:00
|
|
|
keys = append(keys, k)
|
|
|
|
}
|
2015-03-09 18:19:51 +03:00
|
|
|
|
2019-02-27 15:34:02 +03:00
|
|
|
var funcVal, fileVal string
|
|
|
|
|
2018-11-05 15:29:28 +03:00
|
|
|
fixedKeys := make([]string, 0, 4+len(data))
|
2018-09-25 14:45:23 +03:00
|
|
|
if !f.DisableTimestamp {
|
|
|
|
fixedKeys = append(fixedKeys, f.FieldMap.resolve(FieldKeyTime))
|
|
|
|
}
|
|
|
|
fixedKeys = append(fixedKeys, f.FieldMap.resolve(FieldKeyLevel))
|
|
|
|
if entry.Message != "" {
|
|
|
|
fixedKeys = append(fixedKeys, f.FieldMap.resolve(FieldKeyMsg))
|
|
|
|
}
|
2018-09-30 23:51:02 +03:00
|
|
|
if entry.err != "" {
|
|
|
|
fixedKeys = append(fixedKeys, f.FieldMap.resolve(FieldKeyLogrusError))
|
|
|
|
}
|
2018-10-23 07:22:00 +03:00
|
|
|
if entry.HasCaller() {
|
2019-02-27 15:34:02 +03:00
|
|
|
if f.CallerPrettyfier != nil {
|
|
|
|
funcVal, fileVal = f.CallerPrettyfier(entry.Caller)
|
|
|
|
} else {
|
|
|
|
funcVal = entry.Caller.Function
|
|
|
|
fileVal = fmt.Sprintf("%s:%d", entry.Caller.File, entry.Caller.Line)
|
|
|
|
}
|
2019-04-02 06:43:56 +03:00
|
|
|
|
|
|
|
if funcVal != "" {
|
|
|
|
fixedKeys = append(fixedKeys, f.FieldMap.resolve(FieldKeyFunc))
|
|
|
|
}
|
|
|
|
if fileVal != "" {
|
|
|
|
fixedKeys = append(fixedKeys, f.FieldMap.resolve(FieldKeyFile))
|
|
|
|
}
|
2018-10-23 07:22:00 +03:00
|
|
|
}
|
2018-09-25 14:45:23 +03:00
|
|
|
|
2015-03-09 18:19:51 +03:00
|
|
|
if !f.DisableSorting {
|
2018-09-25 14:45:23 +03:00
|
|
|
if f.SortingFunc == nil {
|
|
|
|
sort.Strings(keys)
|
|
|
|
fixedKeys = append(fixedKeys, keys...)
|
|
|
|
} else {
|
|
|
|
if !f.isColored() {
|
|
|
|
fixedKeys = append(fixedKeys, keys...)
|
|
|
|
f.SortingFunc(fixedKeys)
|
|
|
|
} else {
|
|
|
|
f.SortingFunc(keys)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
fixedKeys = append(fixedKeys, keys...)
|
2015-03-09 18:19:51 +03:00
|
|
|
}
|
2018-06-19 04:32:35 +03:00
|
|
|
|
|
|
|
var b *bytes.Buffer
|
2016-06-18 16:47:44 +03:00
|
|
|
if entry.Buffer != nil {
|
|
|
|
b = entry.Buffer
|
|
|
|
} else {
|
|
|
|
b = &bytes.Buffer{}
|
|
|
|
}
|
2014-03-11 03:22:08 +04:00
|
|
|
|
2018-09-25 14:45:23 +03:00
|
|
|
f.terminalInitOnce.Do(func() { f.init(entry) })
|
2014-03-11 03:22:08 +04:00
|
|
|
|
2015-07-17 04:02:46 +03:00
|
|
|
timestampFormat := f.TimestampFormat
|
|
|
|
if timestampFormat == "" {
|
2017-07-26 15:26:30 +03:00
|
|
|
timestampFormat = defaultTimestampFormat
|
2015-03-27 02:04:45 +03:00
|
|
|
}
|
2018-07-13 18:33:25 +03:00
|
|
|
if f.isColored() {
|
2018-11-06 13:01:28 +03:00
|
|
|
f.printColored(b, entry, keys, data, timestampFormat)
|
2014-03-14 21:01:06 +04:00
|
|
|
} else {
|
2019-02-27 15:34:02 +03:00
|
|
|
|
2018-09-25 14:45:23 +03:00
|
|
|
for _, key := range fixedKeys {
|
|
|
|
var value interface{}
|
2018-10-31 09:01:35 +03:00
|
|
|
switch {
|
|
|
|
case key == f.FieldMap.resolve(FieldKeyTime):
|
2018-09-25 14:45:23 +03:00
|
|
|
value = entry.Time.Format(timestampFormat)
|
2018-10-31 09:01:35 +03:00
|
|
|
case key == f.FieldMap.resolve(FieldKeyLevel):
|
2018-09-25 14:45:23 +03:00
|
|
|
value = entry.Level.String()
|
2018-10-31 09:01:35 +03:00
|
|
|
case key == f.FieldMap.resolve(FieldKeyMsg):
|
2018-09-25 14:45:23 +03:00
|
|
|
value = entry.Message
|
2018-10-31 09:01:35 +03:00
|
|
|
case key == f.FieldMap.resolve(FieldKeyLogrusError):
|
2018-09-30 23:51:02 +03:00
|
|
|
value = entry.err
|
2018-10-31 09:01:35 +03:00
|
|
|
case key == f.FieldMap.resolve(FieldKeyFunc) && entry.HasCaller():
|
2019-02-27 15:34:02 +03:00
|
|
|
value = funcVal
|
2018-10-31 09:01:35 +03:00
|
|
|
case key == f.FieldMap.resolve(FieldKeyFile) && entry.HasCaller():
|
2019-02-27 15:34:02 +03:00
|
|
|
value = fileVal
|
2018-09-25 14:45:23 +03:00
|
|
|
default:
|
2018-11-05 15:29:28 +03:00
|
|
|
value = data[key]
|
2018-09-25 14:45:23 +03:00
|
|
|
}
|
|
|
|
f.appendKeyValue(b, key, value)
|
2014-03-11 03:22:08 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-05-24 18:46:03 +04:00
|
|
|
b.WriteByte('\n')
|
2015-01-15 21:40:48 +03:00
|
|
|
return b.Bytes(), nil
|
2014-03-11 03:22:08 +04:00
|
|
|
}
|
2014-03-14 21:01:06 +04:00
|
|
|
|
2018-11-05 15:29:28 +03:00
|
|
|
func (f *TextFormatter) printColored(b *bytes.Buffer, entry *Entry, keys []string, data Fields, timestampFormat string) {
|
2014-09-17 04:19:42 +04:00
|
|
|
var levelColor int
|
|
|
|
switch entry.Level {
|
2017-10-20 15:40:54 +03:00
|
|
|
case DebugLevel, TraceLevel:
|
2015-02-20 18:32:47 +03:00
|
|
|
levelColor = gray
|
2014-09-17 04:19:42 +04:00
|
|
|
case WarnLevel:
|
|
|
|
levelColor = yellow
|
|
|
|
case ErrorLevel, FatalLevel, PanicLevel:
|
|
|
|
levelColor = red
|
2020-11-08 09:07:05 +03:00
|
|
|
case InfoLevel:
|
|
|
|
levelColor = blue
|
2014-09-17 04:19:42 +04:00
|
|
|
default:
|
|
|
|
levelColor = blue
|
|
|
|
}
|
|
|
|
|
2016-08-31 16:54:59 +03:00
|
|
|
levelText := strings.ToUpper(entry.Level.String())
|
2019-06-05 10:10:46 +03:00
|
|
|
if !f.DisableLevelTruncation && !f.PadLevelText {
|
2016-08-31 16:54:59 +03:00
|
|
|
levelText = levelText[0:4]
|
|
|
|
}
|
2019-06-05 10:10:46 +03:00
|
|
|
if f.PadLevelText {
|
2019-06-25 06:42:20 +03:00
|
|
|
// Generates the format string used in the next line, for example "%-6s" or "%-7s".
|
|
|
|
// Based on the max level text length.
|
|
|
|
formatString := "%-" + strconv.Itoa(f.levelTextMaxLength) + "s"
|
|
|
|
// Formats the level text by appending spaces up to the max length, for example:
|
|
|
|
// - "INFO "
|
|
|
|
// - "WARNING"
|
|
|
|
levelText = fmt.Sprintf(formatString, levelText)
|
2019-06-05 10:10:46 +03:00
|
|
|
}
|
2014-09-17 04:19:42 +04:00
|
|
|
|
2017-12-29 22:26:35 +03:00
|
|
|
// Remove a single newline if it already exists in the message to keep
|
|
|
|
// the behavior of logrus text_formatter the same as the stdlib log package
|
|
|
|
entry.Message = strings.TrimSuffix(entry.Message, "\n")
|
2014-09-17 04:19:42 +04:00
|
|
|
|
2016-11-26 06:02:56 +03:00
|
|
|
caller := ""
|
2016-12-01 02:15:38 +03:00
|
|
|
if entry.HasCaller() {
|
2019-02-27 15:34:02 +03:00
|
|
|
funcVal := fmt.Sprintf("%s()", entry.Caller.Function)
|
|
|
|
fileVal := fmt.Sprintf("%s:%d", entry.Caller.File, entry.Caller.Line)
|
|
|
|
|
|
|
|
if f.CallerPrettyfier != nil {
|
|
|
|
funcVal, fileVal = f.CallerPrettyfier(entry.Caller)
|
|
|
|
}
|
2019-04-02 06:43:56 +03:00
|
|
|
|
|
|
|
if fileVal == "" {
|
|
|
|
caller = funcVal
|
|
|
|
} else if funcVal == "" {
|
|
|
|
caller = fileVal
|
|
|
|
} else {
|
|
|
|
caller = fileVal + " " + funcVal
|
|
|
|
}
|
2016-11-26 06:02:56 +03:00
|
|
|
}
|
|
|
|
|
2019-03-13 12:38:09 +03:00
|
|
|
switch {
|
|
|
|
case f.DisableTimestamp:
|
2017-02-04 02:08:53 +03:00
|
|
|
fmt.Fprintf(b, "\x1b[%dm%s\x1b[0m%s %-44s ", levelColor, levelText, caller, entry.Message)
|
2019-03-13 12:38:09 +03:00
|
|
|
case !f.FullTimestamp:
|
2017-02-04 01:56:03 +03:00
|
|
|
fmt.Fprintf(b, "\x1b[%dm%s\x1b[0m[%04d]%s %-44s ", levelColor, levelText, int(entry.Time.Sub(baseTimestamp)/time.Second), caller, entry.Message)
|
2019-03-13 12:38:09 +03:00
|
|
|
default:
|
2017-02-04 01:56:03 +03:00
|
|
|
fmt.Fprintf(b, "\x1b[%dm%s\x1b[0m[%s]%s %-44s ", levelColor, levelText, entry.Time.Format(timestampFormat), caller, entry.Message)
|
2015-02-20 19:43:24 +03:00
|
|
|
}
|
2014-09-17 04:19:42 +04:00
|
|
|
for _, k := range keys {
|
2018-11-05 15:29:28 +03:00
|
|
|
v := data[k]
|
2016-09-28 13:55:00 +03:00
|
|
|
fmt.Fprintf(b, " \x1b[%dm%s\x1b[0m=", levelColor, k)
|
|
|
|
f.appendValue(b, v)
|
2014-09-17 04:19:42 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-14 13:53:03 +03:00
|
|
|
func (f *TextFormatter) needsQuoting(text string) bool {
|
2019-10-15 08:53:51 +03:00
|
|
|
if f.ForceQuote {
|
|
|
|
return true
|
|
|
|
}
|
2017-02-14 13:53:03 +03:00
|
|
|
if f.QuoteEmptyFields && len(text) == 0 {
|
|
|
|
return true
|
|
|
|
}
|
2020-04-23 15:02:38 +03:00
|
|
|
if f.DisableQuote {
|
|
|
|
return false
|
|
|
|
}
|
2014-12-18 17:09:01 +03:00
|
|
|
for _, ch := range text {
|
|
|
|
if !((ch >= 'a' && ch <= 'z') ||
|
|
|
|
(ch >= 'A' && ch <= 'Z') ||
|
2015-03-04 17:04:50 +03:00
|
|
|
(ch >= '0' && ch <= '9') ||
|
2017-06-18 16:48:52 +03:00
|
|
|
ch == '-' || ch == '.' || ch == '_' || ch == '/' || ch == '@' || ch == '^' || ch == '+') {
|
2016-04-16 11:18:56 +03:00
|
|
|
return true
|
2014-12-18 17:09:01 +03:00
|
|
|
}
|
|
|
|
}
|
2016-04-16 11:18:56 +03:00
|
|
|
return false
|
2014-12-18 17:09:01 +03:00
|
|
|
}
|
|
|
|
|
2015-06-27 17:09:22 +03:00
|
|
|
func (f *TextFormatter) appendKeyValue(b *bytes.Buffer, key string, value interface{}) {
|
2017-07-25 10:39:35 +03:00
|
|
|
if b.Len() > 0 {
|
2017-07-21 17:14:28 +03:00
|
|
|
b.WriteByte(' ')
|
|
|
|
}
|
2024-05-14 09:00:24 +03:00
|
|
|
if !f.ExcludeKey {
|
|
|
|
b.WriteString(key)
|
|
|
|
b.WriteByte('=')
|
|
|
|
}
|
2016-09-28 13:55:00 +03:00
|
|
|
f.appendValue(b, value)
|
|
|
|
}
|
2015-06-27 17:09:22 +03:00
|
|
|
|
2016-09-28 13:55:00 +03:00
|
|
|
func (f *TextFormatter) appendValue(b *bytes.Buffer, value interface{}) {
|
2017-07-12 18:33:04 +03:00
|
|
|
stringVal, ok := value.(string)
|
|
|
|
if !ok {
|
2017-07-12 18:16:13 +03:00
|
|
|
stringVal = fmt.Sprint(value)
|
|
|
|
}
|
|
|
|
|
2024-05-14 09:00:24 +03:00
|
|
|
// write value without quoting directly when ExcludeKey is true
|
|
|
|
if f.ExcludeKey {
|
2017-07-12 18:16:13 +03:00
|
|
|
b.WriteString(stringVal)
|
|
|
|
} else {
|
2024-05-14 09:00:24 +03:00
|
|
|
if !f.needsQuoting(stringVal) {
|
|
|
|
b.WriteString(stringVal)
|
|
|
|
} else {
|
|
|
|
b.WriteString(fmt.Sprintf("%q", stringVal))
|
|
|
|
}
|
2015-01-04 11:01:49 +03:00
|
|
|
}
|
2014-03-14 21:01:06 +04:00
|
|
|
}
|