Refactor log implementation

- use []byte instead of unnecessary string conversions
- make LogManager.Broadcast private
- make LogManager.GetHistory public
- add tests

proxy/logMonitor.go

@@ -2,66 +2,73 @@ package proxy
 
 import (
 	"container/ring"
+	"io"
 	"os"
 	"sync"
 )
 
 type LogMonitor struct {
-	clients  map[chan string]bool
+	clients  map[chan []byte]bool
 	mu       sync.RWMutex
 	buffer   *ring.Ring
 	bufferMu sync.RWMutex
+
+	// typically this can be os.Stdout
+	stdout io.Writer
 }
 
 func NewLogMonitor() *LogMonitor {
+	return NewLogMonitorWriter(os.Stdout)
+}
+
+func NewLogMonitorWriter(stdout io.Writer) *LogMonitor {
 	return &LogMonitor{
-		clients: make(map[chan string]bool),
+		clients: make(map[chan []byte]bool),
 		buffer:  ring.New(10 * 1024), // keep 10KB of buffered logs
+		stdout:  stdout,
 	}
 }
 
 func (w *LogMonitor) Write(p []byte) (n int, err error) {
-	n, err = os.Stdout.Write(p)
+	n, err = w.stdout.Write(p)
 	if err != nil {
 		return n, err
 	}
 
-	content := string(p)
-
 	w.bufferMu.Lock()
-	w.buffer.Value = content
+	w.buffer.Value = p
 	w.buffer = w.buffer.Next()
 	w.bufferMu.Unlock()
 
-	w.Broadcast(content)
+	w.broadcast(p)
 	return n, nil
 }
 
-func (w *LogMonitor) getHistory() string {
+func (w *LogMonitor) GetHistory() []byte {
 	w.bufferMu.RLock()
 	defer w.bufferMu.RUnlock()
 
-	var history string
+	var history []byte
 	w.buffer.Do(func(p interface{}) {
 		if p != nil {
-			if content, ok := p.(string); ok {
-				history += content
+			if content, ok := p.([]byte); ok {
+				history = append(history, content...)
 			}
 		}
 	})
 	return history
 }
 
-func (w *LogMonitor) Subscribe() chan string {
+func (w *LogMonitor) Subscribe() chan []byte {
 	w.mu.Lock()
 	defer w.mu.Unlock()
 
-	ch := make(chan string, 100)
+	ch := make(chan []byte, 100)
 	w.clients[ch] = true
 	return ch
 }
 
-func (w *LogMonitor) Unsubscribe(ch chan string) {
+func (w *LogMonitor) Unsubscribe(ch chan []byte) {
 	w.mu.Lock()
 	defer w.mu.Unlock()
 
@@ -69,7 +76,7 @@ func (w *LogMonitor) Unsubscribe(ch chan string) {
 	close(ch)
 }
 
-func (w *LogMonitor) Broadcast(msg string) {
+func (w *LogMonitor) broadcast(msg []byte) {
 	w.mu.RLock()
 	defer w.mu.RUnlock()