- Logs are now stored in local file and every 1K register we upload to the database

- Maximum threads elevated to 10
- Passing user as cookie after login
- Separate gorm models from regular models
- Log model created
- Better feedback

Author: DanielFillol

controllers/controller.go

@@ -84,6 +84,7 @@ func Login(c *gin.Context) {
 
 	// Set token as a cookie
 	c.SetCookie("token", token, 60*60, "/", "", false, true)
+	c.SetCookie("user", user.Email, 60*60, "/", "", false, true)
 
 	// Return success response
 	c.JSON(http.StatusOK, gin.H{"Message": "Login successful"})

database/db.go

@@ -82,6 +82,13 @@ func connectDB() *gorm.DB {
 		return nil
 	}
 
+	//create table log
+	err = db.AutoMigrate(&models.Log{})
+	if err != nil {
+		fmt.Printf("Error on gorm auto migrate to database : error=%v\n", err)
+		return nil
+	}
+
 	return db
 }
 

log/log.go

@@ -0,0 +1,104 @@
+package log
+
+import (
+	"bytes"
+	"fmt"
+	database2 "github.com/Darklabel91/API_Names/database"
+	"github.com/Darklabel91/API_Names/models"
+	"github.com/gin-gonic/gin"
+	"gorm.io/gorm"
+	"io"
+	"os"
+	"sync"
+)
+
+//user, err := c.Cookie("user")
+//if err != nil {
+//	c.AbortWithStatus(http.StatusUnauthorized)
+//	return
+//}
+
+const logBufferSize = 1000
+
+type databaseWriter struct {
+	buffer   bytes.Buffer
+	db       *gorm.DB
+	mutex    sync.Mutex
+	logCount int
+}
+
+func (w *databaseWriter) Write(p []byte) (n int, err error) {
+	w.mutex.Lock()
+	defer w.mutex.Unlock()
+
+	n, err = w.buffer.Write(p)
+	if err != nil {
+		return
+	}
+
+	// Count the number of logs written to the buffer
+	w.logCount += bytes.Count(p, []byte{'\n'})
+
+	// If the buffer is full, flush it to the database
+	if w.logCount >= logBufferSize {
+		err = w.flush()
+		if err != nil {
+			return
+		}
+	}
+
+	return
+}
+
+func (w *databaseWriter) flush() error {
+	// Split the buffer into individual log messages
+	logs := bytes.Split(w.buffer.Bytes(), []byte{'\n'})
+	for _, log := range logs {
+		// Skip empty log messages
+		if len(log) == 0 {
+			continue
+		}
+
+		// Insert the log into the database
+		err := w.db.Create(&models.Log{Message: string(log)}).Error
+		if err != nil {
+			return err
+		}
+	}
+
+	// Reset the buffer and log count
+	w.buffer.Reset()
+	w.logCount = 0
+
+	return nil
+}
+
+func LocalLog() gin.HandlerFunc {
+	// Create the file writer and database writer
+	file, err := os.Create("log/gin.txt")
+	if err != nil {
+		fmt.Println("Log not created")
+		return nil
+	}
+	database := &databaseWriter{db: database2.InitDb()}
+
+	// Use a multi-writer to write to both the file and database writers
+	writer := io.MultiWriter(file, database)
+
+	// Create the gin logger with the custom writer
+	logger := gin.LoggerWithWriter(writer)
+
+	return func(c *gin.Context) {
+		// Call the logger middleware
+		logger(c)
+
+		// Flush the logs to the database if necessary
+		if database.logCount >= logBufferSize {
+			err = database.flush()
+			if err != nil {
+				fmt.Println(err)
+				return
+			}
+		}
+	}
+}

main.go

@@ -12,6 +12,6 @@ func main() {
 		return
 	}
 
-	fmt.Println("-	live")
+	fmt.Println("-	Listening and serving")
 	routes.HandleRequests()
 }

middleware/requireAuth.go

@@ -12,7 +12,7 @@ import (
 	"time"
 )
 
-const MaxThreadsByToken = 5
+const MaxThreadsByToken = 10
 
 // RequireAuth returns a Gin middleware function that checks for a valid JWT token in the request header or cookie, and limits the rate of requests to prevent DDoS attacks.
 //	- The rate limit is enforced using a token bucket algorithm.

models/models.go

@@ -5,28 +5,18 @@ import (
 	"time"
 )
 
-//NameType main struct
-type NameType struct {
-	gorm.Model
-	Name           string `gorm:"unique" json:"Name,omitempty"`
-	Classification string `json:"Classification,omitempty"`
-	Metaphone      string `json:"Metaphone,omitempty"`
-	NameVariations string `json:"NameVariations,omitempty"`
-}
-
-//User is the struct of API users
-type User struct {
-	gorm.Model
-	Email    string `gorm:"unique"`
-	Password string
-}
-
 //NameLevenshtein struct for organizing name variations by Levenshtein
 type NameLevenshtein struct {
 	Name        string
 	Levenshtein float32
 }
 
+//InputBody struct for validation middleware
+type InputBody struct {
+	Email    string `json:"Email,omitempty"`
+	Password string `json:"Password,omitempty"`
+}
+
 //MetaphoneR only use for SearchSimilarNames return
 type MetaphoneR struct {
 	ID             uint           `json:"ID,omitempty"`
@@ -38,9 +28,3 @@ type MetaphoneR struct {
 	Metaphone      string         `json:"Metaphone,omitempty"`
 	NameVariations []string       `json:"NameVariations,omitempty"`
 }
-
-//InputBody struct for validation middleware
-type InputBody struct {
-	Email    string `json:"Email,omitempty"`
-	Password string `json:"Password,omitempty"`
-}

models/modelsGrom.go

@@ -0,0 +1,28 @@
+package models
+
+import (
+	"gorm.io/gorm"
+)
+
+//NameType main struct
+type NameType struct {
+	gorm.Model
+	Name           string `gorm:"unique" json:"Name,omitempty"`
+	Classification string `json:"Classification,omitempty"`
+	Metaphone      string `json:"Metaphone,omitempty"`
+	NameVariations string `json:"NameVariations,omitempty"`
+}
+
+//User is the struct of API users
+type User struct {
+	gorm.Model
+	Email    string `gorm:"unique"`
+	Password string
+}
+
+//Log is the struct used to register the log file
+type Log struct {
+	gorm.Model
+	user    string
+	Message string
+}

routes/routes.go

@@ -3,6 +3,7 @@ package routes
 import (
 	"github.com/Darklabel91/API_Names/controllers"
 	"github.com/Darklabel91/API_Names/database"
+	"github.com/Darklabel91/API_Names/log"
 	"github.com/Darklabel91/API_Names/middleware"
 	"github.com/Darklabel91/API_Names/models"
 	"github.com/gin-gonic/gin"
@@ -16,13 +17,17 @@ var allowedIPs = []string{"127.0.0.1", "::1"} // List of allowed IP addresses
 func HandleRequests() {
 	gin.SetMode(gin.ReleaseMode)
 	r := gin.Default()
+	r.Use(log.LocalLog())
 
-	// Use the OnlyAllowIPs middleware on all routes
+	//use the OnlyAllowIPs middleware on all routes
 	err := r.SetTrustedProxies(allowedIPs)
 	if err != nil {
 		return
 	}
 
+	//export every log to a local file and upload to the database on every 1000k request's
+	//r.Use(log.Testando)
+
 	//set up routes
 	r.POST("/signup", controllers.Signup)
 	r.POST("/login", controllers.Login)
@@ -38,6 +43,8 @@ func HandleRequests() {
 	r.GET("/name/:name", middleware.ValidateNameParam(), waitGroupName)
 	r.GET("/metaphone/:name", middleware.ValidateNameParam(), preloadNameTypes(), middleware.ValidateNameParam(), waitGroupMetaphone)
 
+	gin.Logger()
+
 	// run
 	err = r.Run(door)
 	if err != nil {