chore: format server package

* feat: better health check and less log noise

* feat: better health check and less log noise

internal/server/server.go

@@ -21,6 +21,23 @@ type Server struct {
 	Router   *gin.Engine
 }
 
+var (
+	loggerSkipPathsPrefix = []string{
+		"GET /api/healthcheck",
+		"HEAD /api/healthcheck",
+		"GET /favicon.ico",
+	}
+)
+
+func logPath(path string) bool {
+	for _, prefix := range loggerSkipPathsPrefix {
+		if strings.HasPrefix(path, prefix) {
+			return false
+		}
+	}
+	return true
+}
+
 func NewServer(config types.ServerConfig, handlers *handlers.Handlers) (*Server, error) {
 	gin.SetMode(gin.ReleaseMode)
 
@@ -68,6 +85,7 @@ func NewServer(config types.ServerConfig, handlers *handlers.Handlers) (*Server,
 
 	// App routes
 	router.GET("/api/healthcheck", handlers.HealthcheckHandler)
+	router.HEAD("/api/healthcheck", handlers.HealthcheckHandler)
 
 	return &Server{
 		Config:   config,
@@ -84,29 +102,29 @@ func (s *Server) Start() error {
 // zerolog is a middleware for gin that logs requests using zerolog
 func zerolog() gin.HandlerFunc {
 	return func(c *gin.Context) {
-		// Get initial time
 		tStart := time.Now()
 
-		// Process request
 		c.Next()
 
-		// Get status code, address, method and path
 		code := c.Writer.Status()
 		address := c.Request.RemoteAddr
 		method := c.Request.Method
 		path := c.Request.URL.Path
 
-		// Get latency
 		latency := time.Since(tStart).String()
 
-		// Log request
-		switch {
-		case code >= 200 && code < 300:
-			log.Info().Str("method", method).Str("path", path).Str("address", address).Int("status", code).Str("latency", latency).Msg("Request")
-		case code >= 300 && code < 400:
-			log.Warn().Str("method", method).Str("path", path).Str("address", address).Int("status", code).Str("latency", latency).Msg("Request")
-		case code >= 400:
-			log.Error().Str("method", method).Str("path", path).Str("address", address).Int("status", code).Str("latency", latency).Msg("Request")
+		// logPath check if the path should be logged normally or with debug
+		if logPath(method + " " + path) {
+			switch {
+			case code >= 200 && code < 300:
+				log.Info().Str("method", method).Str("path", path).Str("address", address).Int("status", code).Str("latency", latency).Msg("Request")
+			case code >= 300 && code < 400:
+				log.Warn().Str("method", method).Str("path", path).Str("address", address).Int("status", code).Str("latency", latency).Msg("Request")
+			case code >= 400:
+				log.Error().Str("method", method).Str("path", path).Str("address", address).Int("status", code).Str("latency", latency).Msg("Request")
+			}
+		} else {
+			log.Debug().Str("method", method).Str("path", path).Str("address", address).Int("status", code).Str("latency", latency).Msg("Request")
 		}
 	}
 }

internal/utils/utils.go

@@ -330,12 +330,21 @@ func DeriveKey(secret string, info string) (string, error) {
 
 func CoalesceToString(value any) string {
 	switch v := value.(type) {
-	case []string:
-		return strings.Join(v, ",")
+	case []any:
+		log.Debug().Msg("Coalescing []any to string")
+		strs := make([]string, 0, len(v))
+		for _, item := range v {
+			if str, ok := item.(string); ok {
+				strs = append(strs, str)
+				continue
+			}
+			log.Warn().Interface("item", item).Msg("Item in []any is not a string, skipping")
+		}
+		return strings.Join(strs, ",")
 	case string:
 		return v
 	default:
-		log.Warn().Interface("value", value).Msg("Unsupported type, returning empty string")
+		log.Warn().Interface("value", value).Interface("type", v).Msg("Unsupported type, returning empty string")
 		return ""
 	}
 }

internal/utils/utils_test.go

@@ -515,7 +515,7 @@ func TestDeriveKey(t *testing.T) {
 func TestCoalesceToString(t *testing.T) {
 	t.Log("Testing coalesce to string with a string")
 
-	value := "test"
+	value := any("test")
 	expected := "test"
 
 	result := utils.CoalesceToString(value)
@@ -526,10 +526,10 @@ func TestCoalesceToString(t *testing.T) {
 
 	t.Log("Testing coalesce to string with a slice of strings")
 
-	valueSlice := []string{"test1", "test2"}
+	value = []any{any("test1"), any("test2"), any(123)}
 	expected = "test1,test2"
 
-	result = utils.CoalesceToString(valueSlice)
+	result = utils.CoalesceToString(value)
 
 	if result != expected {
 		t.Fatalf("Expected %v, got %v", expected, result)
@@ -537,10 +537,10 @@ func TestCoalesceToString(t *testing.T) {
 
 	t.Log("Testing coalesce to string with an unsupported type")
 
-	valueUnsupported := 12345
+	value = 12345
 	expected = ""
 
-	result = utils.CoalesceToString(valueUnsupported)
+	result = utils.CoalesceToString(value)
 
 	if result != expected {
 		t.Fatalf("Expected %v, got %v", expected, result)