feat: mv internal/pkg to root [skip ci]

pkg/logging/gormlogrus/gormlogrus.go

@@ -0,0 +1,71 @@
+package gormlogrus
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"time"
+
+	"github.com/sirupsen/logrus"
+
+	"gorm.io/gorm"
+	gormlogger "gorm.io/gorm/logger"
+	"gorm.io/gorm/utils"
+)
+
+type GormLogrusAdapter struct {
+	SlowThreshold         time.Duration
+	SourceField           string
+	SkipErrRecordNotFound bool
+	Logger                logrus.FieldLogger
+}
+
+func New(logger logrus.FieldLogger) *GormLogrusAdapter {
+	return &GormLogrusAdapter{
+		Logger:                logger,
+		SkipErrRecordNotFound: false,
+		SourceField:           "gorm",
+		SlowThreshold:         1 * time.Second,
+	}
+}
+
+func (l *GormLogrusAdapter) LogMode(gormlogger.LogLevel) gormlogger.Interface {
+	return l
+}
+
+func (l *GormLogrusAdapter) Info(ctx context.Context, s string, args ...interface{}) {
+	l.Logger.Infof(s, args)
+}
+
+func (l *GormLogrusAdapter) Warn(ctx context.Context, s string, args ...interface{}) {
+	logrus.Warnf(s, args)
+}
+
+func (l *GormLogrusAdapter) Error(ctx context.Context, s string, args ...interface{}) {
+	logrus.Errorf(s, args)
+}
+
+func (l *GormLogrusAdapter) Trace(ctx context.Context, begin time.Time, fc func() (string, int64), err error) {
+	elapsed := time.Since(begin)
+	sql, rowsAffectedNum := fc()
+	fields := logrus.Fields{}
+	if l.SourceField != "" {
+		fields[l.SourceField] = utils.FileWithLineNum()
+	}
+
+	// format := "%s [cost: %s] [rows: %d]"
+	// args := []interface{}{sql, elapsed, rowsAffectedNum}
+	msg := fmt.Sprintf("%s [cost: %s] [rows: %d]", sql, elapsed, rowsAffectedNum)
+	if err != nil && !(errors.Is(err, gorm.ErrRecordNotFound) && l.SkipErrRecordNotFound) {
+		fields[logrus.ErrorKey] = err
+		l.Logger.WithFields(fields).Error(msg)
+		return
+	}
+
+	if l.SlowThreshold != 0 && elapsed > l.SlowThreshold {
+		l.Logger.WithFields(fields).Warn(msg)
+		return
+	}
+
+	l.Logger.WithFields(fields).Debug(msg)
+}

pkg/logging/hook/logrumgo/logrusmgo.go

@@ -0,0 +1,68 @@
+package logrusmgo
+
+import (
+	"github.com/sirupsen/logrus"
+	"go.mongodb.org/mongo-driver/mongo"
+)
+
+type LogrusMongoHook struct {
+	col    *mongo.Collection
+	levels []logrus.Level
+}
+
+func NewLogrusMongoHook(col *mongo.Collection,
+	levels ...logrus.Level) *LogrusMongoHook {
+	return &LogrusMongoHook{
+		col:    col,
+		levels: levels,
+	}
+}
+
+var _ logrus.Hook = (*LogrusMongoHook)(nil)
+
+func (hook *LogrusMongoHook) Fire(entry *logrus.Entry) error {
+	doc := make(logrus.Fields)
+	doc["Level"] = entry.Level.String()
+	doc["Time"] = entry.Time
+	doc["Message"] = entry.Message
+
+	if caller := entry.Caller; caller != nil {
+		doc["File"] = caller.File
+		doc["Line"] = caller.Line
+		doc["Func"] = caller.Function
+	}
+
+	if data := hook.FieldsData(entry.Data); len(data) > 0 {
+		doc["Data"] = data
+	}
+
+	_, err := hook.col.InsertOne(entry.Context, doc)
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func (hook *LogrusMongoHook) SetLevels(levels ...logrus.Level) {
+	hook.levels = append(hook.levels, levels...)
+}
+
+func (hook *LogrusMongoHook) Levels() []logrus.Level {
+	if len(hook.levels) == 0 {
+		return logrus.AllLevels
+	}
+	return hook.levels
+}
+
+func (hook *LogrusMongoHook) FieldsData(fields logrus.Fields) map[string]interface{} {
+	data := make(map[string]interface{})
+	for k, v := range fields {
+		if errData, isError := v.(error); logrus.ErrorKey == k && v != nil && isError {
+			data[k] = errData.Error()
+		} else {
+			data[k] = v
+		}
+	}
+	return data
+}

pkg/logging/logrus.go

@@ -0,0 +1,75 @@
+package logging
+
+import (
+	"github.com/sirupsen/logrus"
+)
+
+const (
+	defaultTimestampFormat = "2006-01-02 15:04:05.000000"
+	defaultLoggerLevel     = logrus.DebugLevel
+)
+
+var DefaultConfig = defaultConfig()
+
+func defaultConfig() *Config {
+	return &Config{
+		Level:           defaultLoggerLevel.String(),
+		TimestampFormat: defaultTimestampFormat,
+		ReportCaller:    true,
+	}
+}
+
+type Config struct {
+	Level           string
+	TimestampFormat string `mapstructure:"timestamp_format"`
+	ReportCaller    bool   `mapstructure:"report_caller"`
+}
+
+func (cfg Config) GetLevel() logrus.Level {
+	l, err := logrus.ParseLevel(cfg.Level)
+	if err != nil {
+		logrus.
+			WithError(err).
+			Errorf("parse logger level failed with: %s", cfg.Level)
+		return defaultLoggerLevel
+	}
+	return l
+}
+
+func (cfg Config) GetTimestampFormat() string {
+	if cfg.TimestampFormat != "" {
+		return cfg.TimestampFormat
+	}
+	return defaultTimestampFormat
+}
+
+func Init() {
+	InitLogger(DefaultConfig)
+}
+
+func InitLogger(cfg *Config, hooks ...logrus.Hook) {
+	logrus.SetLevel(cfg.GetLevel())
+	logrus.SetReportCaller(cfg.ReportCaller)
+	formatter := logrus.JSONFormatter{
+		PrettyPrint:     true,
+		TimestampFormat: cfg.GetTimestampFormat(),
+	}
+	logrus.SetFormatter(&formatter)
+
+	for _, hook := range hooks {
+		logrus.AddHook(hook)
+	}
+
+}
+
+func New() logrus.FieldLogger {
+	return logrus.StandardLogger()
+}
+
+func WithScope(scope string) logrus.FieldLogger {
+	return logrus.WithField("scope", scope)
+}
+
+func AddHook(hook logrus.Hook) {
+	logrus.AddHook(hook)
+}

pkg/logging/pgxlogrus/pgxlogrus.go

@@ -0,0 +1,50 @@
+package pgxlogrus
+
+import (
+	"context"
+	"fmt"
+	"time"
+
+	"github.com/jackc/pgx/v4"
+	"github.com/sirupsen/logrus"
+)
+
+type pgxLogger struct {
+	logger logrus.FieldLogger
+}
+
+func New(logger logrus.FieldLogger) *pgxLogger {
+	return &pgxLogger{
+		logger: logger,
+	}
+}
+
+func (lg pgxLogger) Log(ctx context.Context, level pgx.LogLevel, msg string, data map[string]interface{}) {
+	lg.logger.WithFields(lg.fieldsData(data)).Info(msg)
+}
+
+func (lg pgxLogger) fieldsData(data map[string]interface{}) logrus.Fields {
+	fields := make(logrus.Fields)
+	if v, ok := data["time"]; ok && v != nil {
+		fields["cost"] = v
+		fields["costString"] = fmt.Sprintf("%v", time.Duration(v.(time.Duration)))
+	}
+
+	if v, ok := data["sql"]; ok {
+		fields["SQL"] = v
+	}
+
+	if v, ok := data["pid"]; ok {
+		fields["PID"] = v
+	}
+
+	if v, ok := data["args"]; ok {
+		fields["args"] = v
+	}
+
+	if v, ok := data["rowCount"]; ok {
+		fields["rowCount"] = v
+	}
+
+	return fields
+}