fields.go

@@ -1,12 +0,0 @@
-package log
-
-func (l myLogger) WithFields(fields Fields) Logger {
-	if l.data != nil && len(l.data) > 0 {
-		for k, v := range fields {
-			l.data[k] = v
-		}
-	} else {
-		l.data = fields
-	}
-	return l
-}

logger.go

@@ -29,6 +29,4 @@ type Logger interface {
 	End(a ...interface{})
 
 	Level(uint8) Logger
-
-	WithFields(fields Fields) Logger
 }

logger_begin.go

@@ -6,6 +6,6 @@ func (l myLogger) Begin(s ...interface{}) Logger {
 	if hasLevel(l.level, logFlag) {
 		l.log(logFlag, append([]interface{}{"BEGIN"}, s...)...)
 	}
-	logger := myLogger{Writer: l.Writer, ErrWriter: l.ErrWriter, prefix: l.prefix, begin: time.Now(), level: l.level, data: l.data}
+	logger := myLogger{Writer: l.Writer, prefix: l.prefix, begin: time.Now(), level: l.level}
 	return logger
 }

logger_level.go

@@ -20,7 +20,7 @@ const (
 // Anything above 6 as level will be considered Level 6.
 // Pass 0 to output no logs.
 func (l myLogger) Level(level uint8) Logger {
-	logger := myLogger{Writer: l.Writer, ErrWriter: l.ErrWriter, prefix: l.prefix, begin: l.begin, data: l.data}
+	logger := myLogger{Writer: l.Writer, prefix: l.prefix, begin: l.begin}
 	switch level {
 	case 1:
 		logger.level = alertFlag
@@ -44,19 +44,19 @@ func (l myLogger) Level(level uint8) Logger {
 
 func unmarshalLevel(level uint8) string {
 	switch level {
-	case alertFlag:
+	case 1:
 		return "alert"
-	case errorFlag:
+	case 2:
 		return "error"
-	case warnFlag:
+	case 3:
 		return "warn"
-	case highlightFlag:
+	case 4:
 		return "highlight"
-	case informFlag:
+	case 5:
 		return "inform"
-	case logFlag:
+	case 6:
 		return "log"
-	case traceFlag:
+	case 7:
 		return "trace"
 	default:
 		return ""

logger_prefix.go

@@ -11,6 +11,6 @@ func (l myLogger) Prefix(p ...string) Logger {
 	for _, prefix := range p {
 		buffer.WriteString(fmt.Sprintf("%s: ", prefix))
 	}
-	logger := myLogger{Writer: l.Writer, ErrWriter: l.ErrWriter, prefix: buffer.String(), data: l.data}
+	logger := myLogger{Writer: l.Writer, prefix: buffer.String()}
 	return logger
 }

my_logger.go

@@ -13,62 +13,33 @@ var (
 	DefaultTimeFormat = time.RFC3339
 )
 
-type Fields map[string]interface{}
-
 type myLogger struct {
 	Writer io.Writer
-	ErrWriter io.Writer
 	prefix string
 	begin  time.Time
 	level  uint8
-	data      Fields
 }
 
 func logPrefix(level uint8) string {
 	return fmt.Sprintf("time=%q level=%s function=%s", time.Now().Format(DefaultTimeFormat), unmarshalLevel(level), funcName())
 }
 
-func (fields Fields) String() string {
+func (l myLogger) log(level uint8, s ...interface{}) {
-	if len(fields) == 0 {
+	if l.Writer == nil {
-		return ""
+		return
 	}
-	var buffer strings.Builder
+	f := fmt.Sprintf("%s%s msg=%q\n", logPrefix(level), l.prefix, fmt.Sprint(s...))
-	for k, v := range fields {
+	fmt.Fprintln(l.Writer, f)
-		switch v := v.(type) {
-		case string:
-			buffer.WriteString(fmt.Sprintf(" %s=%q", k, v))
-		default:
-			buffer.WriteString(fmt.Sprintf(" %s=%v", k, v))
-		}
-	}
-	return buffer.String()
 }
 
-func (l myLogger) log(flag uint8, s ...interface{}) {
+func (l myLogger) logf(level uint8, format string, s ...interface{}) {
-	var w io.Writer
+	if l.Writer == nil {
-	{
+		return
-		if flag == errorFlag {
-			w = l.ErrWriter
-		} else {
-			w = l.Writer
 	}
-	}
+	format = fmt.Sprintf("%%s %%s msg=\"%s\"\n", format)
-	f := fmt.Sprintf("%s%s msg=%q%s", logPrefix(flag), l.prefix, fmt.Sprint(s...), l.data)
+	s = append([]interface{}{logPrefix(level), l.prefix}, s...)
-	fmt.Fprintln(w, f)
-}
 
-func (l myLogger) logf(flag uint8, format string, s ...interface{}) {
+	fmt.Fprintf(l.Writer, format, s...)
-	var w io.Writer
-	{
-		if flag == errorFlag {
-			w = l.ErrWriter
-		} else {
-			w = l.Writer
-		}
-	}
-	format = fmt.Sprintf("%%s%%s msg=\"%s\"%s\n", format, l.data)
-	s = append([]interface{}{logPrefix(flag), l.prefix}, s...)
-	fmt.Fprintf(w, format, s...)
 }
 
 func funcName() string {
@@ -88,16 +59,12 @@ func funcName() string {
 	return ""
 }
 
-func NewLogger(w, errw io.Writer) Logger {
+func NewLogger(w io.Writer) Logger {
 	if w == nil {
 		w = os.Stdout
 	}
-	if errw == nil {
-		errw = os.Stderr
-	}
 	return myLogger{
 		Writer: w,
-		ErrWriter: errw,
 		begin:  time.Now(),
 		level:  traceFlag,
 	}