feat: add json support

Author: YoSev

debugo.go

@@ -1,9 +1,7 @@
 package debugo
 
 import (
-	"fmt"
 	"io"
-	"maps"
 	"sync"
 	"time"
 
@@ -22,42 +20,24 @@ type Debugger struct {
 
 	output io.Writer
 
-	fields map[string]any
-
 	mutex *sync.Mutex
 }
 
 func New(namespace string) *Debugger {
 	return newDebugger(namespace)
 }
 
+// Extend creates a new debugger instance with an extended namespace
 func (d *Debugger) Extend(namespace string) *Debugger {
 	d.mutex.Lock()
 	defer d.mutex.Unlock()
 
-	n := newDebugger(d.namespace + ":" + namespace)
-	n.color = d.color
-	n.lastLog = d.lastLog
-	n.output = d.output
-	n.mutex = d.mutex
-	return n
-}
-
-func (d *Debugger) With(kv ...any) *Debugger {
-	d.mutex.Lock()
-	defer d.mutex.Unlock()
-
 	n := *d
-	maps.Copy(n.fields, d.fields)
-
-	for i := 0; i+1 < len(kv); i += 2 {
-		key := fmt.Sprint(kv[i]) // ensures key is always a string
-		n.fields[key] = kv[i+1]
-	}
-
+	n.namespace = d.namespace + ":" + namespace
 	return &n
 }
 
+// SetOutput sets the output writer for the debugger instance
 func (d *Debugger) SetOutput(output io.Writer) {
 	d.mutex.Lock()
 	defer d.mutex.Unlock()
@@ -74,7 +54,5 @@ func newDebugger(namespace string) *Debugger {
 
 		output: nil,
 
-		fields: make(map[string]any),
-
 		mutex: &sync.Mutex{}}
 }

namespace.go

@@ -44,24 +44,24 @@ func (d *Debugger) matchNamespace() bool {
 }
 
 func matchPattern(namespace, pattern string) bool {
-	// Handle the "optional" case with ":?"
 	if strings.HasSuffix(pattern, ":?") {
 		base := strings.TrimSuffix(pattern, ":?")
 		// Match exactly the base or the base followed by anything
 		regexPattern := "^" + regexp.QuoteMeta(base) + "(:.*)?$"
-		re, _ := regexp.Compile(regexPattern) // can not fail due to QuoteMeta
+		re, err := regexp.Compile(regexPattern)
+		if err != nil {
+			return false
+		}
 		return re.MatchString(namespace)
 	}
 
-	// Replace '*' with '.*' for regex matching (.* matches any sequence of characters)
+	// replace '*' with '.*' for regex matching (.* matches any sequence of characters)
 	regexPattern := "^" + strings.ReplaceAll(pattern, "*", ".*") + "$"
 
-	// Compile the pattern into a regular expression
 	re, err := regexp.Compile(regexPattern)
 	if err != nil {
 		return false
 	}
 
-	// Check if the namespace matches the regular expression
 	return re.MatchString(namespace)
 }

runtime.go

@@ -6,6 +6,13 @@ import (
 	"sync"
 )
 
+type Format string
+
+const (
+	Plain Format = "plain"
+	JSON  Format = "json"
+)
+
 type config struct {
 	namespace string
 	timestamp *Timestamp
@@ -14,6 +21,8 @@ type config struct {
 
 	useColors bool
 
+	format Format
+
 	mutex *sync.RWMutex
 }
 
@@ -25,13 +34,31 @@ var runtime = &config{
 
 	useColors: true,
 
+	format: Plain,
+
 	mutex: &sync.RWMutex{},
 }
 
 type Timestamp struct {
 	Format string
 }
 
+// SetFormat sets the global output format for debugging.
+func SetFormat(format Format) {
+	runtime.mutex.Lock()
+	defer runtime.mutex.Unlock()
+
+	runtime.format = format
+}
+
+// GetFormat retrieves the current global output format for debugging.
+func GetFormat() Format {
+	runtime.mutex.RLock()
+	defer runtime.mutex.RUnlock()
+
+	return runtime.format
+}
+
 // SetUseColors sets the global color usage for debugging.
 func SetUseColors(use bool) {
 	runtime.mutex.Lock()

write.go

@@ -1,11 +1,20 @@
 package debugo
 
 import (
+	"encoding/json"
 	"fmt"
 	"strings"
 	"time"
 )
 
+type asJSON struct {
+	Timestamp string         `json:"timestamp,omitempty"`
+	Namespace string         `json:"namespace,omitempty"`
+	Fields    map[string]any `json:"fields,omitempty"`
+	Message   string         `json:"message,omitempty"`
+	ElapsedMs int64          `json:"elapsed_ms,omitempty"`
+}
+
 func (d *Debugger) Debug(message ...any) *Debugger {
 	d.write(message...)
 	return d
@@ -29,6 +38,11 @@ func (d *Debugger) write(message ...any) {
 		return
 	}
 
+	if GetFormat() == JSON {
+		d.writeJSON(message...)
+		return
+	}
+
 	// Optional timestamp
 	var timestamp string
 	if t := GetTimestamp(); t != nil {
@@ -47,10 +61,6 @@ func (d *Debugger) write(message ...any) {
 		parts = append(parts, d.namespace)
 	}
 
-	if f := d.formatFields(); f != "" {
-		parts = append(parts, f)
-	}
-
 	parts = append(parts, msg)
 	parts = append(parts, fmt.Sprintf("+%s", prettyPrintDuration(d.elapsed())))
 
@@ -64,15 +74,25 @@ func (d *Debugger) write(message ...any) {
 	}
 }
 
-func (d *Debugger) formatFields() string {
-	if len(d.fields) == 0 {
-		return ""
+func (d *Debugger) writeJSON(message ...any) {
+	entry := asJSON{
+		Namespace: d.namespace,
+		Message:   fmt.Sprint(message...),
+		ElapsedMs: d.elapsed().Milliseconds(),
 	}
 
-	parts := make([]string, 0, len(d.fields))
-	for k, v := range d.fields {
-		parts = append(parts, fmt.Sprintf("%s=%v", k, v))
+	if t := GetTimestamp(); t != nil {
+		entry.Timestamp = time.Now().Format(t.Format)
+	}
+
+	data, err := json.Marshal(entry)
+	if err != nil {
+		return
 	}
 
-	return strings.Join(parts, " ")
+	if d.output != nil {
+		_, _ = d.output.Write(append(data, '\n'))
+	} else if o := GetOutput(); o != nil {
+		_, _ = o.Write(append(data, '\n'))
+	}
 }

write_test.go

@@ -42,27 +42,41 @@ func TestDebug(t *testing.T) {
 
 	d.Debug(testMessage)
 
-	assert.True(t, hasANSI(buf.String()), "Must have no colors")
+	assert.True(t, hasANSI(buf.String()))
 
 	output := strings.TrimSpace(stripANSI(buf.String())) // Strip colors and trim whitespace
 	expected := strings.TrimSpace(testMessageExpected)
-	assert.Equal(t, expected, output, "Must have no colors")
+	assert.Equal(t, expected, output)
 }
 
-func TestDebugWithFields(t *testing.T) {
+func TestDebugJSON(t *testing.T) {
 	var buf bytes.Buffer
 	d := getDebugger()
 	d.SetOutput(&buf)
+	SetFormat(JSON)
+	d.Debug(testMessage)
+	SetFormat(Plain)
 
-	x := d.With("key1", "value1").With("key2", 42)
-
-	x.Debug(testMessage)
+	assert.False(t, hasANSI(buf.String()))
+	output := strings.TrimSpace(stripANSI(buf.String())) // Strip colors and trim whitespace
+	expected := strings.TrimSpace("{\"namespace\":\"" + namespace + "\",\"message\":\"" + testMessage + "\"}")
+	assert.Equal(t, expected, output)
+}
 
-	assert.True(t, hasANSI(buf.String()), "Must have no colors")
+func TestDebugJSONWithTimestamp(t *testing.T) {
+	var buf bytes.Buffer
+	d := getDebugger()
+	SetOutput(&buf)
+	SetTimestamp(&Timestamp{Format: "2006"})
+	SetFormat(JSON)
+	d.Debug(testMessage)
+	SetFormat(Plain)
+	SetTimestamp(nil)
 
+	assert.False(t, hasANSI(buf.String()))
 	output := strings.TrimSpace(stripANSI(buf.String())) // Strip colors and trim whitespace
-	expected := strings.TrimSpace(fmt.Sprintf("%s key1=value1 key2=42 %s +0ms\n", namespace, testMessage))
-	assert.Equal(t, expected, output, "Must have fields")
+	expected := strings.TrimSpace("{\"timestamp\":\"" + fmt.Sprint(time.Now().Year()) + "\",\"namespace\":\"" + namespace + "\",\"message\":\"" + testMessage + "\"}")
+	assert.Equal(t, expected, output)
 }
 
 func TestDebugGlobalOutput(t *testing.T) {
@@ -74,11 +88,11 @@ func TestDebugGlobalOutput(t *testing.T) {
 
 	d.Debug(testMessage)
 
-	assert.True(t, hasANSI(buf.String()), "Must have no colors")
+	assert.True(t, hasANSI(buf.String()))
 
 	output := strings.TrimSpace(stripANSI(buf.String())) // Strip colors and trim whitespace
 	expected := strings.TrimSpace(testMessageExpected)
-	assert.Equal(t, expected, output, "Must have no colors")
+	assert.Equal(t, expected, output)
 }
 
 func TestDebugNoColors(t *testing.T) {
@@ -89,7 +103,7 @@ func TestDebugNoColors(t *testing.T) {
 
 	d.Debug(testMessage)
 
-	assert.False(t, hasANSI(buf.String()), "Must have no colors")
+	assert.False(t, hasANSI(buf.String()))
 }
 
 func TestDebugNonMatchingNamespace(t *testing.T) {
@@ -100,7 +114,7 @@ func TestDebugNonMatchingNamespace(t *testing.T) {
 
 	d.Debug("")
 
-	assert.Empty(t, buf.String(), "Must have no message")
+	assert.Empty(t, buf.String())
 }
 
 func TestDebugEmptyMessage(t *testing.T) {
@@ -112,7 +126,7 @@ func TestDebugEmptyMessage(t *testing.T) {
 	SetNamespace("does:not:exist")
 	d.Debug("test")
 
-	assert.Empty(t, buf.String(), "Must have no message")
+	assert.Empty(t, buf.String())
 }
 
 func TestDebugWithColors(t *testing.T) {
@@ -123,7 +137,7 @@ func TestDebugWithColors(t *testing.T) {
 
 	d.Debug(testMessage)
 
-	assert.True(t, hasANSI(buf.String()), "Must have colors")
+	assert.True(t, hasANSI(buf.String()))
 }
 
 func TestDebugf(t *testing.T) {
@@ -172,3 +186,25 @@ func TestDebugRaceCondition(_ *testing.T) {
 	// Optionally, verify output without colors
 	_ = stripANSI(buf.String())
 }
+
+func TestJSONWritePrint(t *testing.T) {
+	var buf bytes.Buffer
+	d := getDebugger()
+	d.SetOutput(&buf)
+	SetFormat(JSON)
+	SetTimestamp(&Timestamp{Format: time.Kitchen})
+	d.Debug("foo", "bar", true)
+	t.Log(buf.String())
+}
+
+func TestPlainWritePrint(t *testing.T) {
+	var buf bytes.Buffer
+	d := getDebugger()
+	d.SetOutput(&buf)
+	SetTimestamp(&Timestamp{Format: time.Kitchen})
+	SetUseColors(false)
+	SetFormat(Plain)
+	SetTimestamp(&Timestamp{Format: time.Kitchen})
+	d.Debugf("%s %s %t", "foo", "bar", true)
+	t.Log(buf.String())
+}