Initial open source release

backend/controller/log.go

@@ -0,0 +1,214 @@
+package controller
+
+import (
+	"context"
+	"time"
+
+	"github.com/go-errors/errors"
+
+	"github.com/gin-gonic/gin"
+	"github.com/phishingclub/phishingclub/data"
+	"github.com/phishingclub/phishingclub/errs"
+	"github.com/phishingclub/phishingclub/model"
+	"github.com/phishingclub/phishingclub/service"
+	"github.com/phishingclub/phishingclub/vo"
+	"go.uber.org/zap"
+	"gorm.io/gorm"
+	"gorm.io/gorm/logger"
+)
+
+type SetLevelRequest struct {
+	Level   string `json:"level"`
+	DBLevel string `json:"dbLevel"`
+}
+
+type Log struct {
+	Common
+	OptionService *service.Option
+	Database      *gorm.DB
+	LoggerAtom    *zap.AtomicLevel
+}
+
+// Panic is a test utility
+func (c *Log) Panic(g *gin.Context) {
+	session, _, ok := c.handleSession(g)
+	if !ok {
+		return
+	}
+	if session == nil {
+		if ok := c.handleErrors(g, errors.New("no session")); !ok {
+			return
+		}
+	}
+	c.Deeper()
+}
+
+func (c *Log) Deeper() {
+	panic("panic test")
+}
+
+// Slow is a test utility
+func (c *Log) Slow(g *gin.Context) {
+	session, _, ok := c.handleSession(g)
+	if !ok {
+		return
+	}
+	if session == nil {
+		if ok := c.handleErrors(g, errors.New("no session")); !ok {
+			return
+		}
+	}
+	c.Logger.Debugf("Slow request testing start")
+	time.Sleep(10 * time.Second)
+	c.Logger.Debugf("Slow request testing stop")
+	c.Response.OK(g, gin.H{})
+}
+
+// GetLevel gets the log level
+func (c *Log) GetLevel(g *gin.Context) {
+	session, _, ok := c.handleSession(g)
+	if !ok {
+		return
+	}
+	// get the log levels
+	logLevelOption, err := c.OptionService.GetOption(
+		g,
+		session,
+		data.OptionKeyLogLevel,
+	)
+	// handle errors
+	if ok := c.handleErrors(g, err); !ok {
+		return
+	}
+	dbLogLevelOption, err := c.OptionService.GetOption(g, session, data.OptionKeyDBLogLevel)
+	// handle response
+	if ok := c.handleErrors(g, err); !ok {
+		return
+	}
+	c.Response.OK(g, gin.H{
+		"level":   logLevelOption.Value,
+		"dbLevel": dbLogLevelOption.Value,
+	})
+}
+
+// SetLevel sets the log level
+func (c *Log) SetLevel(g *gin.Context) {
+	session, _, ok := c.handleSession(g)
+	if !ok {
+		return
+	}
+	// parse request
+	var request SetLevelRequest
+	if ok := c.handleParseRequest(g, &request); !ok {
+		return
+	}
+	if request.Level == "" && request.DBLevel == "" {
+		c.Response.BadRequestMessage(g, "level or dbLevel is required")
+		return
+	}
+	if request.DBLevel != "" {
+		switch request.DBLevel {
+		case "silent":
+			c.Database.Logger = c.Database.Logger.LogMode(logger.Silent)
+		case "info":
+			c.Database.Logger = c.Database.Logger.LogMode(logger.Info)
+		case "warn":
+			c.Database.Logger = c.Database.Logger.LogMode(logger.Warn)
+		case "error":
+			c.Database.Logger = c.Database.Logger.LogMode(logger.Error)
+		default:
+			c.Logger.Debugw("invalid db log level",
+				"level", request.DBLevel,
+			)
+			c.Response.BadRequestMessage(g, "unknown DB log level")
+			return
+		}
+		// set db log level in database
+		dbLevel := vo.NewOptionalString1MBMust(request.DBLevel)
+		dbLogLevelOption := model.Option{
+			Key:   *vo.NewString64Must(data.OptionKeyDBLogLevel),
+			Value: *dbLevel,
+		}
+		err := c.persist(
+			g,
+			session,
+			&dbLogLevelOption,
+		)
+		// handle response
+		if ok := c.handleErrors(g, err); !ok {
+			return
+		}
+	}
+	if request.Level != "" {
+		switch request.Level {
+		case "debug":
+			c.LoggerAtom.SetLevel(zap.DebugLevel)
+		case "info":
+			c.LoggerAtom.SetLevel(zap.InfoLevel)
+		case "warn":
+			c.LoggerAtom.SetLevel(zap.WarnLevel)
+		case "error":
+			c.LoggerAtom.SetLevel(zap.ErrorLevel)
+		default:
+			c.Logger.Debugw("invalid log level",
+				"level", request.Level,
+			)
+			c.Response.BadRequestMessage(g, "Unknown log level")
+			return
+		}
+
+		// set log level in in memory logger struct
+		logLevel := model.Option{
+			Key:   *vo.NewString64Must(data.OptionKeyLogLevel),
+			Value: *vo.NewOptionalString1MBMust(request.Level),
+		}
+		err := c.persist(
+			g,
+			session,
+			&logLevel,
+		)
+		if ok := c.handleErrors(g, err); !ok {
+			return
+		}
+	}
+	c.Response.OK(g, nil)
+}
+
+// TestLog tests the log
+// Sends a log message for each log level debug, info, warn, error
+func (c *Log) TestLog(g *gin.Context) {
+	session, _, ok := c.handleSession(g)
+	if !ok {
+		return
+	}
+	// check permissions
+	isAuthorized, err := service.IsAuthorized(session, data.PERMISSION_ALLOW_GLOBAL)
+	if err != nil && !errors.Is(err, errs.ErrAuthorizationFailed) {
+		handleServerError(g, c.Response, err)
+		return
+	}
+	if !isAuthorized {
+		// TODO audit log
+		c.Response.Unauthorized(g)
+		return
+	}
+	c.Logger.Debug("Log: DEBUG Test")
+	c.Logger.Info("Log: INFO Test")
+	c.Logger.Warn("Log: WARN Test")
+	c.Logger.Error("Log: ERROR Test")
+	c.Response.OK(g, nil)
+}
+
+// persit saves the log level
+// TODO this has become empty and superflous
+func (c *Log) persist(
+	ctx context.Context,
+	session *model.Session,
+	logLevel *model.Option,
+) error {
+	return c.OptionService.SetOptionByKey(
+		ctx,
+		session,
+		logLevel,
+	)
+}