ref(logger): leave incoming messages unparsed

Author: Matthew Fisher

logger/syslog/filehandler.go

@@ -19,7 +19,7 @@ type FileHandler struct {
 
 // NewFileHandler accepts all arguments expected by NewBaseHandler plus
 // filename which is the path to the log file.
-func NewFileHandler(filename string, qlen int, filter func(*Message) bool,
+func NewFileHandler(filename string, qlen int, filter func(SyslogMessage) bool,
 	ft bool) *FileHandler {
 
 	h := &FileHandler{
@@ -61,7 +61,7 @@ func (h *FileHandler) mainLoop() {
 	}
 }
 
-func (h *FileHandler) saveMessage(m *Message) {
+func (h *FileHandler) saveMessage(m SyslogMessage) {
 	var err error
 	if h.f == nil {
 		h.f, err = os.OpenFile(
@@ -90,6 +90,6 @@ func (h *FileHandler) checkErr(err error) bool {
 }
 
 // Handle queues and dispatches a message. See BaseHandler.Handle
-func (h *FileHandler) Handle(m *Message) *Message {
+func (h *FileHandler) Handle(m SyslogMessage) SyslogMessage {
 	return h.bh.Handle(m)
 }

logger/syslog/filehandler_test.go

@@ -2,7 +2,6 @@ package syslog
 
 import (
 	"testing"
-	"time"
 )
 
 type TestLogger struct{}
@@ -12,24 +11,24 @@ func (tl TestLogger) Printf(format string, v ...interface{}) {}
 func (tl TestLogger) Println(...interface{})                 {}
 
 func TestNewFileHandler(t *testing.T) {
-	fh := NewFileHandler("", 1, func(m *Message) bool { return true }, true)
+	fh := NewFileHandler("", 1, func(m SyslogMessage) bool { return true }, true)
 	if fh == nil {
 		t.Errorf("expected filehandler, got nil")
 	}
 }
 
 func TestSetLogger(t *testing.T) {
 	tl := TestLogger{}
-	fh := NewFileHandler("", 1, func(m *Message) bool { return true }, true)
+	fh := NewFileHandler("", 1, func(m SyslogMessage) bool { return true }, true)
 	fh.SetLogger(tl)
 	if fh.l != tl {
 		t.Errorf("expected the logger to be set")
 	}
 }
 
 func TestHandle(t *testing.T) {
-	fh := NewFileHandler("/tmp/test", 1, func(m *Message) bool { return true }, true)
-	handle := fh.Handle(&Message{time.Now(), nil, 0, 0, time.Now(), "localhost", "test", "message", "", ""})
+	fh := NewFileHandler("/tmp/test", 1, func(m SyslogMessage) bool { return true }, true)
+	handle := fh.Handle(&Message{"localhost test message"})
 	if handle == nil {
 		t.Errorf("expected a handle, got nil")
 	}

logger/syslog/handler.go

@@ -5,26 +5,26 @@ type Handler interface {
 	// Handle should return Message (maybe modified) for future processing by
 	// other handlers or return nil. If Handle is called with nil message it
 	// should complete all remaining work and properly shutdown before return.
-	Handle(*Message) *Message
+	Handle(SyslogMessage) SyslogMessage
 }
 
 // BaseHandler is designed to simplify the creation of real handlers. It
 // implements Handler interface using nonblocking queuing of messages and
 // simple message filtering.
 type BaseHandler struct {
-	queue  chan *Message
+	queue  chan SyslogMessage
 	end    chan struct{}
-	filter func(*Message) bool
+	filter func(SyslogMessage) bool
 	ft     bool
 }
 
 // NewBaseHandler creates BaseHandler using a specified filter. If filter is nil
 // or if it returns true messages are passed to BaseHandler internal queue
 // (of qlen length). If filter returns false or ft is true messages are returned
 // to server for future processing by other handlers.
-func NewBaseHandler(qlen int, filter func(*Message) bool, ft bool) *BaseHandler {
+func NewBaseHandler(qlen int, filter func(SyslogMessage) bool, ft bool) *BaseHandler {
 	return &BaseHandler{
-		queue:  make(chan *Message, qlen),
+		queue:  make(chan SyslogMessage, qlen),
 		end:    make(chan struct{}),
 		filter: filter,
 		ft:     ft,
@@ -34,7 +34,7 @@ func NewBaseHandler(qlen int, filter func(*Message) bool, ft bool) *BaseHandler
 // Handle inserts m in an internal queue. It immediately returns even if
 // queue is full. If m == nil it closes queue and waits for End method call
 // before return.
-func (h *BaseHandler) Handle(m *Message) *Message {
+func (h *BaseHandler) Handle(m SyslogMessage) SyslogMessage {
 	if m == nil {
 		close(h.queue) // signal that there is no more messages for processing
 		<-h.end        // wait for handler shutdown
@@ -58,7 +58,7 @@ func (h *BaseHandler) Handle(m *Message) *Message {
 // Get returns first message from internal queue. It waits for message if queue
 // is empty. It returns nil if there is no more messages to process and handler
 // should shutdown.
-func (h *BaseHandler) Get() *Message {
+func (h *BaseHandler) Get() SyslogMessage {
 	m, ok := <-h.queue
 	if ok {
 		return m
@@ -70,7 +70,7 @@ func (h *BaseHandler) Get() *Message {
 // it directly, especially if your handler needs to select from multiple channels
 // or have to work without blocking. You need to check if this channel is closed by
 // sender and properly shutdown in this case.
-func (h *BaseHandler) Queue() <-chan *Message {
+func (h *BaseHandler) Queue() <-chan SyslogMessage {
 	return h.queue
 }
 

logger/syslog/message.go

@@ -1,48 +1,16 @@
 package syslog
 
-import (
-	"fmt"
-	"net"
-	"time"
-)
+import "fmt"
 
-// Message defines an RFC 3164 syslog message.
-type Message struct {
-	Time      time.Time // time the message was logged
-	Source    net.Addr  // source address of the log message
-	Facility            // facility tag (see type Facility)
-	Severity            // severity tag (see type Severity)
-	Timestamp time.Time // optional
-	Hostname  string    // optional
-	Tag       string    // message tag as defined in RFC 3164
-	Content   string    // message content as defined in RFC 3164
-	Tag1      string    // alternate message tag (white rune as separator)
-	Content1  string    // alternate message content (white rune as separator)
+type SyslogMessage interface {
+	fmt.Stringer
 }
 
-// NetSrc only network part of Source as string (IP for UDP or Name for UDS)
-func (m *Message) NetSrc() string {
-	switch a := m.Source.(type) {
-	case *net.UDPAddr:
-		return a.IP.String()
-	case *net.UnixAddr:
-		return a.Name
-	case *net.TCPAddr:
-		return a.IP.String()
-	}
-	// Unknown type
-	return m.Source.String()
+// Message defines a syslog message.
+type Message struct {
+	Msg string
 }
 
-// String returns the Message in a string format. This satisfies the fmt.Stringer
-// interface.
 func (m *Message) String() string {
-	timeLayout := "2006-01-02 15:04:05"
-	return fmt.Sprintf(
-		"%s %s %s%s",
-		m.Time.Format(timeLayout),
-		m.Hostname,
-		m.Tag,
-		m.Content,
-	)
+	return m.Msg
 }

logger/syslog/message_test.go

@@ -3,13 +3,10 @@
 package syslog
 
 import (
-	"bytes"
 	"log"
 	"net"
 	"os"
-	"strconv"
 	"strings"
-	"time"
 	"unicode"
 )
 
@@ -90,7 +87,7 @@ func isNulCrLf(r rune) bool {
 	return r == 0 || r == '\r' || r == '\n'
 }
 
-func (s *Server) passToHandlers(m *Message) {
+func (s *Server) passToHandlers(m SyslogMessage) {
 	for _, h := range s.handlers {
 		m = h.Handle(m)
 		if m == nil {
@@ -103,72 +100,14 @@ func (s *Server) receiver(c net.PacketConn) {
 	//q := (chan<- Message)(s.q)
 	buf := make([]byte, 1024)
 	for {
-		n, addr, err := c.ReadFrom(buf)
+		n, _, err := c.ReadFrom(buf)
 		if err != nil {
 			if !s.shutdown {
 				s.l.Fatalln("Read error:", err)
 			}
 			return
 		}
-		pkt := buf[:n]
-
-		m := new(Message)
-		m.Source = addr
-		m.Time = time.Now()
-
-		// Parse priority (if exists)
-		prio := 13 // default priority
-		hasPrio := false
-		if pkt[0] == '<' {
-			n = 1 + bytes.IndexByte(pkt[1:], '>')
-			if n > 1 && n < 5 {
-				p, err := strconv.Atoi(string(pkt[1:n]))
-				if err == nil && p >= 0 {
-					hasPrio = true
-					prio = p
-					pkt = pkt[n+1:]
-				}
-			}
-		}
-		m.Severity = Severity(prio & 0x07)
-		m.Facility = Facility(prio >> 3)
-
-		// Parse header (if exists)
-		if hasPrio && len(pkt) >= 16 && pkt[15] == ' ' {
-			// Get timestamp
-			layout := "Jan _2 15:04:05"
-			ts, err := time.Parse(layout, string(pkt[:15]))
-			if err == nil && !ts.IsZero() {
-				// Get hostname
-				n = 16 + bytes.IndexByte(pkt[16:], ' ')
-				if n != 15 {
-					m.Timestamp = ts
-					m.Hostname = string(pkt[16:n])
-					pkt = pkt[n+1:]
-				}
-			}
-			// TODO: check for version an new format of header as
-			// described in RFC 5424.
-		}
-
-		// Parse msg part
-		msg := string(bytes.TrimRightFunc(pkt, isNulCrLf))
-		n = strings.IndexFunc(msg, isNotAlnum)
-		if n != -1 {
-			m.Tag = msg[:n]
-			m.Content = msg[n:]
-		} else {
-			m.Content = msg
-		}
-		msg = strings.TrimFunc(msg, unicode.IsSpace)
-		n = strings.IndexFunc(msg, unicode.IsSpace)
-		if n != -1 {
-			m.Tag1 = msg[:n]
-			m.Content1 = strings.TrimLeftFunc(msg[n+1:], unicode.IsSpace)
-		} else {
-			m.Content1 = msg
-		}
-
-		s.passToHandlers(m)
+		// pass along the incoming syslog message
+		s.passToHandlers(&Message{string(buf[:n])})
 	}
 }

logger/syslog/server.go

@@ -22,8 +22,7 @@ type handler struct {
 }
 
 // Simple fiter for named/bind messages which can be used with BaseHandler
-func filter(m *syslog.Message) bool {
-	// return m.Tag == "named" || m.Tag == "bind"
+func filter(m syslog.SyslogMessage) bool {
 	return true
 }
 
@@ -45,11 +44,11 @@ func fileExists(path string) (bool, error) {
 	return false, err
 }
 
-func getLogFile(m *syslog.Message) (io.Writer, error) {
+func getLogFile(message string) (io.Writer, error) {
 	r := regexp.MustCompile(`^.* ([-a-z0-9]+)\[[a-z0-9-_\.]+\].*`)
-	match := r.FindStringSubmatch(m.String())
+	match := r.FindStringSubmatch(message)
 	if match == nil {
-		return nil, fmt.Errorf("Could not find app name in message: %s", m)
+		return nil, fmt.Errorf("Could not find app name in message: %s", message)
 	}
 	appName := match[1]
 	filePath := path.Join(logRoot, appName+".log")
@@ -68,8 +67,8 @@ func getLogFile(m *syslog.Message) (io.Writer, error) {
 	return file, err
 }
 
-func writeToDisk(m *syslog.Message) error {
-	file, err := getLogFile(m)
+func writeToDisk(m syslog.SyslogMessage) error {
+	file, err := getLogFile(m.String())
 	if err != nil {
 		return err
 	}