- now if there is a perfect match on metaphone endpoint we return the result early

- now all log is exported to logs.txt and every 5 minutes exports data to the database

Author: DanielFillol

controllers/controller.go

@@ -197,19 +197,36 @@ func GetName(c *gin.Context) {
 
 //SearchSimilarNames search for all similar names by metaphone and Levenshtein method
 func SearchSimilarNames(c *gin.Context) {
+	var metaphoneNames []models.NameType
+
 	//name to be searched
 	name := c.Params.ByName("name")
 	nameMetaphone := Metaphone.Pack(name)
 
+	//search perfect match
+	database.Db.Raw("select * from name_types where name = ?", strings.ToUpper(name)).Find(&metaphoneNames)
+	if len(metaphoneNames) == 1 {
+		r := models.MetaphoneR{
+			ID:             metaphoneNames[0].ID,
+			CreatedAt:      metaphoneNames[0].CreatedAt,
+			UpdatedAt:      metaphoneNames[0].UpdatedAt,
+			DeletedAt:      metaphoneNames[0].DeletedAt,
+			Name:           metaphoneNames[0].Name,
+			Classification: metaphoneNames[0].Classification,
+			Metaphone:      metaphoneNames[0].Metaphone,
+			NameVariations: []string{metaphoneNames[0].NameVariations},
+		}
+		c.JSON(200, r)
+		return
+	}
+
 	//find all metaphoneNames matching metaphone
-	var metaphoneNames []models.NameType
 	database.Db.Raw("select * from name_types where metaphone = ?", nameMetaphone).Find(&metaphoneNames)
 	similarNames := findNames(metaphoneNames, name, levenshtein)
 
 	//for recall purposes we can't only search for metaphone exact match's if no similar word is found
-	preloadTable := c.MustGet("nameTypes").([]models.NameType)
-
 	if len(metaphoneNames) == 0 || len(similarNames) == 0 {
+		preloadTable := c.MustGet("nameTypes").([]models.NameType)
 		metaphoneNames = searchForAllSimilarMetaphone(nameMetaphone, preloadTable)
 		similarNames = findNames(metaphoneNames, name, levenshtein)
 
@@ -255,6 +272,7 @@ func SearchSimilarNames(c *gin.Context) {
 		NameVariations: nameV,
 	}
 	c.JSON(200, r)
+	return
 }
 
 /*---------- used on SearchSimilarNames ----------*/

log/log.go

@@ -1,103 +1,81 @@
 package log
 
 import (
-	"bytes"
+	"bufio"
+	"errors"
 	"fmt"
-	database2 "github.com/Darklabel91/API_Names/database"
+	"github.com/Darklabel91/API_Names/database"
 	"github.com/Darklabel91/API_Names/models"
-	"github.com/gin-gonic/gin"
-	"gorm.io/gorm"
-	"io"
 	"os"
-	"sync"
+	"strings"
+	"time"
 )
 
-//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)
+func exportLog(filename string) error {
+	//open the file
+	file, err := os.OpenFile(filename, os.O_RDWR|os.O_CREATE, 0666)
 	if err != nil {
-		return
+		return err
 	}
+	defer file.Close()
 
-	// Count the number of logs written to the buffer
-	w.logCount += bytes.Count(p, []byte{'\n'})
+	//create a scanner to read the file line by line
+	scanner := bufio.NewScanner(file)
 
-	// If the buffer is full, flush it to the database
-	if w.logCount >= logBufferSize {
-		err = w.flush()
-		if err != nil {
-			return
-		}
+	// Loop through the lines
+	var logs []models.Log
+	for scanner.Scan() {
+		line := scanner.Text()
+		log, _ := logBreaker(line)
+		logs = append(logs, log)
 	}
 
-	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
-		}
+	//check for any errors during scanning
+	if err = scanner.Err(); err != nil {
+		return err
 	}
 
-	// Reset the buffer and log count
-	w.buffer.Reset()
-	w.logCount = 0
+	//uploads to the database
+	database.Db.Create(&logs)
 
+	// Return the line count and no error
 	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
+func logBreaker(message string) (models.Log, error) {
+	stp1 := strings.Replace(message, "[GIN] ", "", -1)
+
+	stp2 := strings.Split(strings.TrimSpace(stp1), "|")
+	if len(stp2) != 5 {
+		fmt.Println("oi")
+		return models.Log{}, errors.New("unexpected string length")
 	}
-	database := &databaseWriter{db: database2.InitDb()}
 
-	// Use a multi-writer to write to both the file and database writers
-	writer := io.MultiWriter(file, database)
+	stp3 := strings.Split(stp2[4], " ")
+	if len(stp3) < 2 {
+		return models.Log{}, errors.New("unexpected string length on second division")
+	}
 
-	// Create the gin logger with the custom writer
-	logger := gin.LoggerWithWriter(writer)
+	return models.Log{
+		Time:    strings.TrimSpace(stp2[0]),
+		Status:  strings.TrimSpace(stp2[1]),
+		Latency: strings.TrimSpace(stp2[2]),
+		IP:      strings.TrimSpace(stp2[3]),
+		Method:  strings.TrimSpace(stp3[1]),
+		Path:    strings.TrimSpace(stp3[len(stp3)-1]),
+	}, nil
+}
 
-	return func(c *gin.Context) {
-		// Call the logger middleware
-		logger(c)
+func StartExportLog(filename string) {
+	ticker := time.NewTicker(5 * time.Minute)
+	defer ticker.Stop()
 
-		// Flush the logs to the database if necessary
-		if database.logCount >= logBufferSize {
-			err = database.flush()
+	for {
+		select {
+		case <-ticker.C:
+			err := exportLog(filename)
 			if err != nil {
-				fmt.Println(err)
-				return
+				fmt.Println("Error exporting log:", err)
 			}
 		}
 	}

main.go

@@ -3,15 +3,19 @@ package main
 import (
 	"fmt"
 	"github.com/Darklabel91/API_Names/database"
+	"github.com/Darklabel91/API_Names/log"
 	"github.com/Darklabel91/API_Names/routes"
 )
 
+const FILENAME = "logs.txt"
+
 func main() {
 	r := database.InitDb()
 	if r == nil {
 		return
 	}
 
 	fmt.Println("-	Listening and serving")
+	go log.StartExportLog(FILENAME)
 	routes.HandleRequests()
 }

models/modelsGrom.go

@@ -21,8 +21,13 @@ type User struct {
 }
 
 //Log is the struct used to register the log file
+// Define a struct to hold the log data
 type Log struct {
 	gorm.Model
-	user    string
-	Message string
+	Time    string
+	Status  string
+	Latency string
+	IP      string
+	Method  string
+	Path    string
 }

routes/routes.go

@@ -3,30 +3,34 @@ 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"
+	"os"
 	"sync"
 )
 
-const door = ":8080"
+const DOOR = ":8080"
+const FILENAME = "logs.txt"
 
 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
 	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)
+	// Create a file to store the logs
+	file, err := os.OpenFile(FILENAME, os.O_RDWR|os.O_CREATE, 0666)
+	if err != nil {
+		return
+	}
+	r.Use(gin.LoggerWithWriter(file))
 
 	//set up routes
 	r.POST("/signup", controllers.Signup)
@@ -46,10 +50,11 @@ func HandleRequests() {
 	gin.Logger()
 
 	// run
-	err = r.Run(door)
+	err = r.Run(DOOR)
 	if err != nil {
 		return
 	}
+
 }
 
 //waitGroupMetaphone crates a waiting group for handling requests using controllers.SearchSimilarNames