Add extra fields to runmqserver JSON log

cmd/runmqdevserver/main.go

@@ -24,6 +24,7 @@ import (
 
 	"github.com/ibm-messaging/mq-container/internal/command"
 	"github.com/ibm-messaging/mq-container/internal/logger"
+	"github.com/ibm-messaging/mq-container/internal/name"
 )
 
 var log *logger.Logger
@@ -57,15 +58,26 @@ func getDebug() bool {
 }
 
 func configureLogger() error {
+	var err error
 	f := getLogFormat()
 	d := getDebug()
+	n, err := name.GetQueueManagerName()
+	if err != nil {
+		return err
+	}
 	switch f {
 	case "json":
-		log = logger.NewLogger(os.Stderr, d, true)
+		log, err = logger.NewLogger(os.Stderr, d, true, n)
+		if err != nil {
+			return err
+		}
 	case "basic":
-		log = logger.NewLogger(os.Stderr, d, false)
+		log, err = logger.NewLogger(os.Stderr, d, false, n)
+		if err != nil {
+			return err
+		}
 	default:
-		log = logger.NewLogger(os.Stdout, d, false)
+		log, err = logger.NewLogger(os.Stdout, d, false, n)
 		return fmt.Errorf("invalid value for LOG_FORMAT: %v", f)
 	}
 	return nil

cmd/runmqserver/logging.go

@@ -89,15 +89,22 @@ func getDebug() bool {
 	return false
 }
 
-func configureLogger() (mirrorFunc, error) {
+func configureLogger(name string) (mirrorFunc, error) {
+	var err error
 	f := getLogFormat()
 	d := getDebug()
 	switch f {
 	case "json":
-		log = logger.NewLogger(os.Stderr, d, true)
+		log, err = logger.NewLogger(os.Stderr, d, true, name)
+		if err != nil {
+			return nil, err
+		}
 		return log.LogDirect, nil
 	case "basic":
-		log = logger.NewLogger(os.Stderr, d, false)
+		log, err = logger.NewLogger(os.Stderr, d, false, name)
+		if err != nil {
+			return nil, err
+		}
 		return func(msg string) {
 			// Parse the JSON message, and print a simplified version
 			var obj map[string]interface{}
@@ -105,7 +112,10 @@ func configureLogger() (mirrorFunc, error) {
 			fmt.Printf(formatSimple(obj["ibm_datetime"].(string), obj["message"].(string)))
 		}, nil
 	default:
-		log = logger.NewLogger(os.Stdout, d, false)
+		log, err = logger.NewLogger(os.Stdout, d, false, name)
+		if err != nil {
+			return nil, err
+		}
 		return nil, fmt.Errorf("invalid value for LOG_FORMAT: %v", f)
 	}
 }

cmd/runmqserver/main.go

@@ -28,21 +28,21 @@ import (
 )
 
 func doMain() error {
-	mf, err := configureLogger()
+	name, nameErr := name.GetQueueManagerName()
+	mf, err := configureLogger(name)
 	if err != nil {
 		logTermination(err)
 		return err
 	}
+	if nameErr != nil {
+		logTermination(err)
+		return err
+	}
 	err = ready.Clear()
 	if err != nil {
 		logTermination(err)
 		return err
 	}
-	name, err := name.GetQueueManagerName()
-	if err != nil {
-		logTermination(err)
-		return err
-	}
 	accepted, err := checkLicense()
 	if err != nil {
 		logTerminationf("Error checking license acceptance: %v", err)

cmd/runmqserver/main_test.go

@@ -31,7 +31,7 @@ const filename = "/var/coverage/exitCode"
 
 func init() {
 	test = flag.Bool("test", false, "Set to true when running tests for coverage")
-	log = logger.NewLogger(os.Stdout, true, false)
+	log, _ = logger.NewLogger(os.Stdout, true, false, "test")
 }
 
 // Test started when the test binary is started. Only calls main.

internal/logger/logger.go

@@ -21,6 +21,7 @@ import (
 	"fmt"
 	"io"
 	"os"
+	"os/user"
 	"sync"
 	"time"
 )
@@ -39,10 +40,21 @@ type Logger struct {
 	json        bool
 	processName string
 	pid         int
+	serverName  string
+	host        string
+	user        *user.User
 }
 
 // NewLogger creates a new logger
-func NewLogger(writer io.Writer, debug bool, json bool) *Logger {
+func NewLogger(writer io.Writer, debug bool, json bool, serverName string) (*Logger, error) {
+	hostname, err := os.Hostname()
+	if err != nil {
+		return nil, err
+	}
+	user, err := user.Current()
+	if err != nil {
+		return nil, err
+	}
 	return &Logger{
 		mutex:       sync.Mutex{},
 		writer:      writer,
@@ -50,7 +62,10 @@ func NewLogger(writer io.Writer, debug bool, json bool) *Logger {
 		json:        json,
 		processName: os.Args[0],
 		pid:         os.Getpid(),
-	}
+		serverName:  serverName,
+		host:        hostname,
+		user:        user,
+	}, nil
 }
 
 func (l *Logger) format(entry map[string]interface{}) (string, error) {
@@ -72,8 +87,12 @@ func (l *Logger) log(level string, msg string) {
 		"message":         fmt.Sprint(msg),
 		"ibm_datetime":    t.Format(timestampFormat),
 		"loglevel":        level,
+		"host":            l.host,
+		"ibm_serverName":  l.serverName,
 		"ibm_processName": l.processName,
 		"ibm_processId":   l.pid,
+		"ibm_userName":    l.user.Username,
+		"type":            "mq_log",
 	}
 	s, err := l.format(entry)
 	l.mutex.Lock()

internal/logger/logger_test.go

@@ -25,11 +25,14 @@ import (
 
 func TestJSONLogger(t *testing.T) {
 	buf := new(bytes.Buffer)
-	l := NewLogger(buf, true, true)
+	l, err := NewLogger(buf, true, true, t.Name())
+	if err != nil {
+		t.Fatal(err)
+	}
 	s := "Hello world"
 	l.Print(s)
 	var e map[string]interface{}
-	err := json.Unmarshal([]byte(buf.String()), &e)
+	err = json.Unmarshal([]byte(buf.String()), &e)
 	if err != nil {
 		t.Error(err)
 	}
@@ -40,7 +43,10 @@ func TestJSONLogger(t *testing.T) {
 
 func TestSimpleLogger(t *testing.T) {
 	buf := new(bytes.Buffer)
-	l := NewLogger(buf, true, false)
+	l, err := NewLogger(buf, true, false, t.Name())
+	if err != nil {
+		t.Fatal(err)
+	}
 	s := "Hello world"
 	l.Print(s)
 	if !strings.Contains(buf.String(), s) {