Deduplicate JSON formatting code and add tests

Co-authored-by: rbtr <2940321+rbtr@users.noreply.github.com>

Author: Copilot

cns/logger/cnslogger.go

@@ -1,7 +1,6 @@
 package logger
 
 import (
-	"encoding/json"
 	"fmt"
 	"maps"
 	"os"
@@ -132,29 +131,15 @@ func (c *CNSLogger) Errorf(format string, args ...any) {
 	c.sendTraceInternal(msg, ai.ErrorLevel)
 }
 
-// toJSONString converts any object to a JSON string for logging purposes.
-// When the object contains json.RawMessage fields, they will be properly formatted
-// instead of being shown as byte arrays. Falls back to %+v if JSON marshaling fails.
-func toJSONString(obj any) string {
-	if obj == nil {
-		return "null"
-	}
-	
-	bytes, err := json.Marshal(obj)
-	if err != nil {
-		// Fall back to standard formatting if JSON marshaling fails
-		return fmt.Sprintf("%+v", obj)
-	}
-	return string(bytes)
-}
+
 
 func (c *CNSLogger) Request(tag string, request any, err error) {
 	c.logger.Request(tag, request, err)
 	if c.th == nil || c.disableTraceLogging {
 		return
 	}
 
-	requestString := toJSONString(request)
+	requestString := log.ToJSONString(request)
 
 	var msg string
 	lvl := ai.InfoLevel
@@ -173,7 +158,7 @@ func (c *CNSLogger) Response(tag string, response any, returnCode types.Response
 		return
 	}
 
-	responseString := toJSONString(response)
+	responseString := log.ToJSONString(response)
 
 	var msg string
 	lvl := ai.InfoLevel
@@ -195,8 +180,8 @@ func (c *CNSLogger) ResponseEx(tag string, request, response any, returnCode typ
 		return
 	}
 
-	requestString := toJSONString(request)
-	responseString := toJSONString(response)
+	requestString := log.ToJSONString(request)
+	responseString := log.ToJSONString(response)
 
 	var msg string
 	lvl := ai.InfoLevel

log/logger.go

@@ -200,10 +200,10 @@ func (logger *Logger) rotate() error {
 	return nil
 }
 
-// toJSONString converts any object to a JSON string for logging purposes.
+// ToJSONString converts any object to a JSON string for logging purposes.
 // When the object contains json.RawMessage fields, they will be properly formatted
 // instead of being shown as byte arrays. Falls back to %+v if JSON marshaling fails.
-func toJSONString(obj interface{}) string {
+func ToJSONString(obj interface{}) string {
 	if obj == nil {
 		return "null"
 	}
@@ -219,31 +219,31 @@ func toJSONString(obj interface{}) string {
 // Request logs a structured request.
 func (logger *Logger) Request(tag string, request interface{}, err error) {
 	if err == nil {
-		logger.Printf("[%s] Received %T %s.", tag, request, toJSONString(request))
+		logger.Printf("[%s] Received %T %s.", tag, request, ToJSONString(request))
 	} else {
-		logger.Errorf("[%s] Failed to decode %T %s %s.", tag, request, toJSONString(request), err.Error())
+		logger.Errorf("[%s] Failed to decode %T %s %s.", tag, request, ToJSONString(request), err.Error())
 	}
 }
 
 // Response logs a structured response.
 func (logger *Logger) Response(tag string, response interface{}, returnCode int, returnStr string, err error) {
 	if err == nil && returnCode == 0 {
-		logger.Printf("[%s] Sent %T %s.", tag, response, toJSONString(response))
+		logger.Printf("[%s] Sent %T %s.", tag, response, ToJSONString(response))
 	} else if err != nil {
-		logger.Errorf("[%s] Code:%s, %s %s.", tag, returnStr, toJSONString(response), err.Error())
+		logger.Errorf("[%s] Code:%s, %s %s.", tag, returnStr, ToJSONString(response), err.Error())
 	} else {
-		logger.Errorf("[%s] Code:%s, %s.", tag, returnStr, toJSONString(response))
+		logger.Errorf("[%s] Code:%s, %s.", tag, returnStr, ToJSONString(response))
 	}
 }
 
 // ResponseEx logs a structured response and the request associate with it.
 func (logger *Logger) ResponseEx(tag string, request interface{}, response interface{}, returnCode int, returnStr string, err error) {
 	if err == nil && returnCode == 0 {
-		logger.Printf("[%s] Sent %T %s %T %s.", tag, request, toJSONString(request), response, toJSONString(response))
+		logger.Printf("[%s] Sent %T %s %T %s.", tag, request, ToJSONString(request), response, ToJSONString(response))
 	} else if err != nil {
-		logger.Errorf("[%s] Code:%s, %s, %s %s.", tag, returnStr, toJSONString(request), toJSONString(response), err.Error())
+		logger.Errorf("[%s] Code:%s, %s, %s %s.", tag, returnStr, ToJSONString(request), ToJSONString(response), err.Error())
 	} else {
-		logger.Errorf("[%s] Code:%s, %s, %s.", tag, returnStr, toJSONString(request), toJSONString(response))
+		logger.Errorf("[%s] Code:%s, %s, %s.", tag, returnStr, ToJSONString(request), ToJSONString(response))
 	}
 }
 

log/logger_test.go

@@ -4,6 +4,7 @@
 package log
 
 import (
+	"encoding/json"
 	"fmt"
 	"os"
 	"path"
@@ -18,6 +19,70 @@ const (
 	logName = "test"
 )
 
+func TestToJSONString(t *testing.T) {
+	tests := []struct {
+		name     string
+		input    interface{}
+		expected string
+	}{
+		{
+			name:     "nil value",
+			input:    nil,
+			expected: "null",
+		},
+		{
+			name:     "simple struct",
+			input:    struct{ Name string }{"test"},
+			expected: `{"Name":"test"}`,
+		},
+		{
+			name: "struct with json.RawMessage",
+			input: struct {
+				ID      string
+				Data    json.RawMessage
+				Enabled bool
+			}{
+				ID:      "123",
+				Data:    json.RawMessage(`{"foo":"bar"}`),
+				Enabled: true,
+			},
+			expected: `{"ID":"123","Data":{"foo":"bar"},"Enabled":true}`,
+		},
+		{
+			name: "nested json.RawMessage",
+			input: struct {
+				Context json.RawMessage
+			}{
+				Context: json.RawMessage(`{"PodName":"test-pod","PodNamespace":"default"}`),
+			},
+			expected: `{"Context":{"PodName":"test-pod","PodNamespace":"default"}}`,
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			result := ToJSONString(test.input)
+			assert.Equal(t, test.expected, result)
+		})
+	}
+}
+
+func TestToJSONStringFallback(t *testing.T) {
+	// Create a circular reference that cannot be marshaled to JSON
+	type Circular struct {
+		Name     string
+		Referrer *Circular
+	}
+
+	circular := &Circular{Name: "test"}
+	circular.Referrer = circular // Create circular reference
+
+	// This should fall back to %+v formatting
+	result := ToJSONString(circular)
+	assert.Contains(t, result, "test")
+	assert.Contains(t, result, "Referrer")
+}
+
 func TestNewLoggerError(t *testing.T) {
 	// we expect an error from NewLoggerE in the event that we provide an
 	// unwriteable directory