Jannex
/
admin-dashboard-backend
2
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

implemented rslogger

main
alex 2023-10-08 13:04:08 +02:00
parent 6fe143301e
commit 577ff4f4e3
4 changed files with 13 additions and 258 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
go.mod
View File

@ -3,7 +3,7 @@ module jannex/admin-dashboard-backend
go 1.21.0
require (
git.ex.umbach.dev/Alex/roese-utils v1.0.6
git.ex.umbach.dev/Alex/roese-utils v1.0.8
github.com/gofiber/fiber/v2 v2.49.2
github.com/gofiber/websocket/v2 v2.1.6
github.com/google/uuid v1.3.1

4
go.sum
View File

@ -1,5 +1,9 @@
git.ex.umbach.dev/Alex/roese-utils v1.0.6 h1:dqel8hRA+7IEwxPN1ld88UQu+ZnccECwWuwRbXDdh3U=
git.ex.umbach.dev/Alex/roese-utils v1.0.6/go.mod h1:tjq6m6lNFo0TzAvq8jHhlK48IGxi+SrlrQwf9WYg408=
git.ex.umbach.dev/Alex/roese-utils v1.0.7 h1:eLw6u1ibPeG6zd702Q3Ge8VebABiz0KQJkzr3Rp++HM=
git.ex.umbach.dev/Alex/roese-utils v1.0.7/go.mod h1:tjq6m6lNFo0TzAvq8jHhlK48IGxi+SrlrQwf9WYg408=
git.ex.umbach.dev/Alex/roese-utils v1.0.8 h1:ph18N52R9UsJ0AsJW95W6afa9qKlMDMh60xE4wlfFi8=
git.ex.umbach.dev/Alex/roese-utils v1.0.8/go.mod h1:tjq6m6lNFo0TzAvq8jHhlK48IGxi+SrlrQwf9WYg408=
github.com/andybalholm/brotli v1.0.5 h1:8uQZIdzKmjc/iuPu7O2ioW48L81FgatrcpfFmiq/cCs=
github.com/andybalholm/brotli v1.0.5/go.mod h1:fO7iG3H7G2nSZ7m0zPUDn85XEX2GTukHGRSepvi9Eig=
github.com/coreos/go-systemd/v22 v22.5.0/go.mod h1:Y58oyj3AT4RCenI/lSvhwexgC+NSVTIJ3seZv2GcEnc=

5
main.go
View File

@ -20,7 +20,6 @@ import (
"jannex/admin-dashboard-backend/modules/config"
"jannex/admin-dashboard-backend/modules/database"
"jannex/admin-dashboard-backend/modules/grouptasks"
"jannex/admin-dashboard-backend/modules/logger"
"jannex/admin-dashboard-backend/modules/structs"
"jannex/admin-dashboard-backend/modules/systempermissions"
"jannex/admin-dashboard-backend/modules/utils"
@ -31,6 +30,7 @@ import (
"time"
"git.ex.umbach.dev/Alex/roese-utils/rsconfig"
"git.ex.umbach.dev/Alex/roese-utils/rslogger"
"github.com/gofiber/fiber/v2"
"github.com/gofiber/fiber/v2/middleware/cors"
flogger "github.com/gofiber/fiber/v2/middleware/logger"
@ -69,7 +69,8 @@ INVEX_API_BASE=api_url
INVEX_API_TOKEN=api_token`)
config.LoadConfig()
logger.InitLogger()
rslogger.InitLogger(config.Cfg.Debug, config.Cfg.ColorizedOutput, config.Cfg.LogManagerServerUrl)
if os.Getenv("DOCKER") != "" {
fmt.Println("Waiting for mariadb docker")

260
modules/logger/logger.go
View File

@ -1,271 +1,21 @@
package logger
import (
"encoding/json"
"fmt"
"jannex/admin-dashboard-backend/modules/config"
"os"
"time"
"git.ex.umbach.dev/Alex/roese-utils/rslogger"
"github.com/gofiber/fiber/v2"
"github.com/rs/zerolog"
"github.com/rs/zerolog/log"
)
func InitLogger() {
zerolog.TimeFieldFormat = zerolog.TimeFormatUnix
if config.Cfg.Debug {
zerolog.SetGlobalLevel(zerolog.DebugLevel)
} else {
zerolog.SetGlobalLevel(zerolog.InfoLevel)
}
if config.Cfg.ColorizedOutput {
log.Logger = log.Output(zerolog.ConsoleWriter{Out: os.Stderr, TimeFormat: "15:04:05"})
}
}
func getTime() string {
return time.Now().Format("15:04:05 02-01-2006") + " "
}
func AddSystemLog(format string, v ...any) {
go LogManagerRequestClient(fiber.MethodPost, config.Cfg.LogManagerServerUrl+"/v1/log", LogManagerRequestBody{
go rslogger.LogManagerRequestClient(fiber.MethodPost, config.Cfg.LogManagerServerUrl+"/v1/log", rslogger.LogManagerRequestBody{
Type: "system",
Logs: []string{"I " + getTime() + fmt.Sprintf(format, v...)}})
Logs: []string{"I " + rslogger.GetTime() + fmt.Sprintf(format, v...)}})
}
func AddGroupTasksLog(format string, v ...any) {
go LogManagerRequestClient(fiber.MethodPost, config.Cfg.LogManagerServerUrl+"/v1/log", LogManagerRequestBody{
go rslogger.LogManagerRequestClient(fiber.MethodPost, config.Cfg.LogManagerServerUrl+"/v1/log", rslogger.LogManagerRequestBody{
Type: "grouptasks",
Logs: []string{"I " + getTime() + fmt.Sprintf(format, v...)}})
Logs: []string{"I " + rslogger.GetTime() + fmt.Sprintf(format, v...)}})
}
type LogManagerRequestBody struct {
Type string
Logs []string
}
func LogManagerRequestClient(requestMethod string, url string, body interface{}) {
a := fiber.AcquireAgent()
req := a.Request()
req.Header.SetMethod(requestMethod)
req.SetRequestURI(url)
req.Header.SetContentType("application/json")
reqestBodyBytes, err := json.Marshal(body)
if err != nil {
log.Error().Msgf("Failed to marshal request body, err: %s", err)
return
}
req.SetBody(reqestBodyBytes)
if err := a.Parse(); err != nil {
log.Error().Msgf("Failed to parse request, err: %s", err)
return
}
code, body, _ := a.Bytes()
log.Info().Msgf("Log manager request, code: %d, body: %s", code, body)
}
/*
func addLog(logMessage structs.LogMessage, systemLog bool) {
year, month, day := time.Now().Date()
path := config.Cfg.FolderPaths.LogsSystem
if !systemLog {
path = config.Cfg.FolderPaths.LogsGroupTasks
}
f, err := os.OpenFile(path+strconv.Itoa(day)+"-"+strconv.Itoa(int(month))+"-"+strconv.Itoa(year)+".json", os.O_APPEND|os.O_WRONLY|os.O_CREATE, 0644)
if err != nil {
log.Error().Msgf("Failed to open log file %s", err.Error())
return
}
defer f.Close()
logMessage.Time = time.Now()
file, _ := json.Marshal(logMessage)
if _, err = fmt.Fprintln(f, string(file)); err != nil {
log.Error().Msgf("Failed to write to log file %s", err.Error())
}
}
func ReadLogs(date string, systemLogs bool, language string) []structs.LogListMessage {
path := config.Cfg.FolderPaths.LogsSystem
if !systemLogs {
path = config.Cfg.FolderPaths.LogsGroupTasks
}
file, err := os.Open(path + date + ".json")
if err != nil {
log.Error().Msgf("Failed to read log file %s", err.Error())
return nil
}
defer file.Close()
fileScanner := bufio.NewScanner(file)
var logMessages []structs.LogListMessage
for fileScanner.Scan() {
var logMessage structs.LogMessage
if err := json.Unmarshal(fileScanner.Bytes(), &logMessage); err != nil {
log.Error().Msgf("Failed to unmarshal log message %v", err.Error())
}
var languageLogMessages []structs.LanguageLogMessages
if systemLogs {
languageLogMessages = systemLanguageLogMessages
} else {
languageLogMessages = grouptasksLanguageLogMessages
}
logMessages = append(logMessages, getLogMessage(languageLogMessages, logMessage, language))
}
if err := fileScanner.Err(); err != nil {
log.Error().Msgf("Error while reading file: %s", err)
return nil
}
return logMessages
}
func getLogMessage(languageLogMessages []structs.LanguageLogMessages, logMessage structs.LogMessage, language string) structs.LogListMessage {
logListMessage := structs.LogListMessage{
Time: logMessage.Time,
Type: logMessage.Type,
LogData: logMessage.Messages,
}
for _, systemLanguageLogMessage := range languageLogMessages {
if logMessage.Id == systemLanguageLogMessage.Id {
logListMessage.Message = getLogLanguageMessage(systemLanguageLogMessage.Languages, language)
return logListMessage
}
}
return logListMessage
}
func getLogLanguageMessage(languages []structs.LanguageLogMessagesLanguage, language string) string {
englishIndex := 0
for i, l := range languages {
if l.Lang == language {
return l.Message
}
if l.Lang == "en" {
englishIndex = i
}
}
return languages[englishIndex].Message
}
func GetAllLogMessagesDates(systemLogs bool) []string {
path := config.Cfg.FolderPaths.LogsSystem
if !systemLogs {
path = config.Cfg.FolderPaths.LogsGroupTasks
}
files, err := os.ReadDir(path)
if err != nil {
log.Error().Msgf("Failed to read log messages directory %s", err.Error())
return []string{}
}
var dates []string
for _, file := range files {
dates = append(dates, strings.Split(file.Name(), ".")[0])
}
layout := "2-1-2006"
parsedDates := make([]time.Time, len(dates))
for i, dateStr := range dates {
parsedDate, err := time.Parse(layout, dateStr)
if err != nil {
log.Error().Msgf("Failed to parse date %s", err.Error())
return []string{}
}
parsedDates[i] = parsedDate
}
sort.Slice(parsedDates, func(i, j int) bool {
return parsedDates[i].Before(parsedDates[j])
})
sortedDates := []string{}
for _, date := range parsedDates {
sortedDates = append(sortedDates, date.Format(layout))
}
return sortedDates
}
func InitLanguageLogMessages() {
readLanguageLogMessages(true)
readLanguageLogMessages(false)
AddSystemLog(structs.LogMessage{
Id: 8,
Type: utils.LogTypeInfo,
})
AddGroupTasksLog(structs.LogMessage{
Id: 6,
Type: utils.LogTypeInfo,
})
}
func readLanguageLogMessages(systemLogs bool) {
path := config.Cfg.LogLanguageSystem
if !systemLogs {
path = config.Cfg.LogLanguageGroupTasks
}
content, err := os.ReadFile(path)
if err != nil {
panic("Could not read language log messages: " + err.Error())
}
var langLogMessages []structs.LanguageLogMessages
if err = json.Unmarshal(content, &langLogMessages); err != nil {
panic("Failed to unmarshal: " + err.Error())
}
if systemLogs {
systemLanguageLogMessages = langLogMessages
} else {
grouptasksLanguageLogMessages = langLogMessages
}
}
*/