init project

providers/logger/logger.go

@@ -0,0 +1,101 @@
+package logger
+
+import (
+	"app/container"
+	"app/providers/config"
+	"log"
+	"strings"
+
+	"github.com/go-micro/plugins/v4/logger/zap"
+	"go-micro.dev/v4/logger"
+)
+
+type Logger struct {
+}
+
+type LevelWriter struct {
+	Logger logger.Logger
+	Level  string
+}
+
+func (w LevelWriter) Write(p []byte) (n int, err error) {
+	level, _ := logger.GetLevel(w.Level)
+	w.Logger.Logf(level, strings.TrimSpace(string(p)))
+	return len(p), nil
+}
+
+func init() {
+	if err := container.Container.Provide(NewLogger); err != nil {
+		log.Fatal(err)
+	}
+}
+
+func NewLogger(conf *config.Config) (*Logger, error) {
+	zapLogger, err := zap.NewLogger()
+	if err != nil {
+		return nil, err
+	}
+	logger.DefaultLogger = zapLogger
+
+	return &Logger{}, nil
+}
+
+func (l *Logger) Init(options ...logger.Option) error                { panic("do not use") }
+func (l *Logger) Options() logger.Options                            { panic("do not use") }
+func (l *Logger) Fields(fields map[string]interface{}) logger.Logger { panic("do not use") }
+func (l *Logger) String() string                                     { panic("do not use") }
+
+func (l *Logger) Logf(level logger.Level, format string, v ...interface{}) {
+	logger.Logf(level, format, v...)
+}
+func (l *Logger) Log(level logger.Level, v ...interface{}) {
+	logger.Log(level, v...)
+}
+
+func (l *Logger) Info(args ...interface{}) {
+	logger.Log(logger.InfoLevel, args...)
+}
+
+func (l *Logger) Infof(template string, args ...interface{}) {
+	logger.Logf(logger.InfoLevel, template, args...)
+}
+
+func (l *Logger) Trace(args ...interface{}) {
+	logger.Log(logger.TraceLevel, args...)
+}
+
+func (l *Logger) Tracef(template string, args ...interface{}) {
+	logger.Logf(logger.TraceLevel, template, args...)
+}
+
+func (l *Logger) Debug(args ...interface{}) {
+	logger.Log(logger.DebugLevel, args...)
+}
+
+func (l *Logger) Debugf(template string, args ...interface{}) {
+	logger.Logf(logger.DebugLevel, template, args...)
+}
+
+func (l *Logger) Warn(args ...interface{}) {
+	logger.Log(logger.WarnLevel, args...)
+}
+
+func (l *Logger) Warnf(template string, args ...interface{}) {
+	logger.Logf(logger.WarnLevel, template, args...)
+}
+
+func (l *Logger) Error(args ...interface{}) {
+	logger.Log(logger.ErrorLevel, args...)
+}
+
+func (l *Logger) Errorf(template string, args ...interface{}) {
+	logger.Logf(logger.ErrorLevel, template, args...)
+}
+
+func (l *Logger) Fatal(args ...interface{}) {
+	logger.Log(logger.FatalLevel, args...)
+}
+
+func (l *Logger) Fatalf(template string, args ...interface{}) {
+	logger.Logf(logger.FatalLevel, template, args...)
+}