diff --git a/lib/ipc/manager.go b/lib/ipc/manager.go
index 84d52edee..76d30f6d1 100644
--- a/lib/ipc/manager.go
+++ b/lib/ipc/manager.go
@@ -94,17 +94,17 @@ func (i *Manager) Start(eventManager interfaces.EventManager, bindingManager int
 					logdata := incomingMessage.Payload.(*messages.LogData)
 					switch logdata.Level {
 					case "info":
-						i.log.Info(logdata.Message)
+						logger.GlobalLogger.Info(logdata.Message)
 					case "debug":
-						i.log.Debug(logdata.Message)
+						logger.GlobalLogger.Debug(logdata.Message)
 					case "warning":
-						i.log.Warn(logdata.Message)
+						logger.GlobalLogger.Warn(logdata.Message)
 					case "error":
-						i.log.Error(logdata.Message)
+						logger.GlobalLogger.Error(logdata.Message)
 					case "fatal":
-						i.log.Fatal(logdata.Message)
+						logger.GlobalLogger.Fatal(logdata.Message)
 					default:
-						i.log.ErrorFields("Invalid log level sent", logger.Fields{
+						logger.ErrorFields("Invalid log level sent", logger.Fields{
 							"level":   logdata.Level,
 							"message": logdata.Message,
 						})
diff --git a/lib/logger/custom.go b/lib/logger/custom.go
index 11eb02cc5..fd055d0e8 100644
--- a/lib/logger/custom.go
+++ b/lib/logger/custom.go
@@ -15,90 +15,90 @@ func NewCustomLogger(prefix string) *CustomLogger {
 
 // Info level message
 func (c *CustomLogger) Info(message string) {
-	logger.Info(c.prefix + message)
+	GlobalLogger.Info(c.prefix + message)
 }
 
 // Infof - formatted message
 func (c *CustomLogger) Infof(message string, args ...interface{}) {
-	logger.Infof(c.prefix+message, args...)
+	GlobalLogger.Infof(c.prefix+message, args...)
 }
 
 // InfoFields - message with fields
 func (c *CustomLogger) InfoFields(message string, fields Fields) {
-	logger.WithFields(map[string]interface{}(fields)).Info(c.prefix + message)
+	GlobalLogger.WithFields(map[string]interface{}(fields)).Info(c.prefix + message)
 }
 
 // Debug level message
 func (c *CustomLogger) Debug(message string) {
-	logger.Debug(c.prefix + message)
+	GlobalLogger.Debug(c.prefix + message)
 }
 
 // Debugf - formatted message
 func (c *CustomLogger) Debugf(message string, args ...interface{}) {
-	logger.Debugf(c.prefix+message, args...)
+	GlobalLogger.Debugf(c.prefix+message, args...)
 }
 
 // DebugFields - message with fields
 func (c *CustomLogger) DebugFields(message string, fields Fields) {
-	logger.WithFields(map[string]interface{}(fields)).Debug(c.prefix + message)
+	GlobalLogger.WithFields(map[string]interface{}(fields)).Debug(c.prefix + message)
 }
 
 // Warn level message
 func (c *CustomLogger) Warn(message string) {
-	logger.Warn(c.prefix + message)
+	GlobalLogger.Warn(c.prefix + message)
 }
 
 // Warnf - formatted message
 func (c *CustomLogger) Warnf(message string, args ...interface{}) {
-	logger.Warnf(c.prefix+message, args...)
+	GlobalLogger.Warnf(c.prefix+message, args...)
 }
 
 // WarnFields - message with fields
 func (c *CustomLogger) WarnFields(message string, fields Fields) {
-	logger.WithFields(map[string]interface{}(fields)).Warn(c.prefix + message)
+	GlobalLogger.WithFields(map[string]interface{}(fields)).Warn(c.prefix + message)
 }
 
 // Error level message
 func (c *CustomLogger) Error(message string) {
-	logger.Error(c.prefix + message)
+	GlobalLogger.Error(c.prefix + message)
 }
 
 // Errorf - formatted message
 func (c *CustomLogger) Errorf(message string, args ...interface{}) {
-	logger.Errorf(c.prefix+message, args...)
+	GlobalLogger.Errorf(c.prefix+message, args...)
 }
 
 // ErrorFields - message with fields
 func (c *CustomLogger) ErrorFields(message string, fields Fields) {
-	logger.WithFields(map[string]interface{}(fields)).Error(c.prefix + message)
+	GlobalLogger.WithFields(map[string]interface{}(fields)).Error(c.prefix + message)
 }
 
 // Fatal level message
 func (c *CustomLogger) Fatal(message string) {
-	logger.Fatal(c.prefix + message)
+	GlobalLogger.Fatal(c.prefix + message)
 }
 
 // Fatalf - formatted message
 func (c *CustomLogger) Fatalf(message string, args ...interface{}) {
-	logger.Fatalf(c.prefix+message, args...)
+	GlobalLogger.Fatalf(c.prefix+message, args...)
 }
 
 // FatalFields - message with fields
 func (c *CustomLogger) FatalFields(message string, fields Fields) {
-	logger.WithFields(map[string]interface{}(fields)).Fatal(c.prefix + message)
+	GlobalLogger.WithFields(map[string]interface{}(fields)).Fatal(c.prefix + message)
 }
 
 // Panic level message
 func (c *CustomLogger) Panic(message string) {
-	logger.Panic(c.prefix + message)
+	GlobalLogger.Panic(c.prefix + message)
 }
 
 // Panicf - formatted message
 func (c *CustomLogger) Panicf(message string, args ...interface{}) {
-	logger.Panicf(c.prefix+message, args...)
+	GlobalLogger.Panicf(c.prefix+message, args...)
 }
 
 // PanicFields - message with fields
 func (c *CustomLogger) PanicFields(message string, fields Fields) {
-	logger.WithFields(map[string]interface{}(fields)).Panic(c.prefix + message)
+	GlobalLogger.WithFields(map[string]interface{}(fields)).Panic(c.prefix + message)
 }
diff --git a/lib/logger/log.go b/lib/logger/log.go
index 97d8130b0..791328645 100644
--- a/lib/logger/log.go
+++ b/lib/logger/log.go
@@ -7,8 +7,8 @@ import (
 	"github.com/sirupsen/logrus"
 )
 
-// Global logger reference
-var logger = logrus.New()
+// GlobalLogger is the global logger
+var GlobalLogger = logrus.New()
 
 // Fields is used by the customLogger object to output
 // fields along with a message
@@ -16,27 +16,32 @@ type Fields map[string]interface{}
 
 // Default options for the global logger
 func init() {
-	logger.SetOutput(os.Stdout)
-	logger.SetLevel(logrus.DebugLevel)
+	GlobalLogger.SetOutput(os.Stdout)
+	GlobalLogger.SetLevel(logrus.DebugLevel)
+}
+
+// ErrorFields is a helper for logging fields to the global logger
+func ErrorFields(message string, fields Fields) {
+	GlobalLogger.WithFields(map[string]interface{}(fields)).Error(message)
 }
 
 // SetLogLevel sets the log level to the given level
 func SetLogLevel(level string) {
 	switch strings.ToLower(level) {
 	case "info":
-		logger.SetLevel(logrus.InfoLevel)
+		GlobalLogger.SetLevel(logrus.InfoLevel)
 	case "debug":
-		logger.SetLevel(logrus.DebugLevel)
+		GlobalLogger.SetLevel(logrus.DebugLevel)
 	case "warn":
-		logger.SetLevel(logrus.WarnLevel)
+		GlobalLogger.SetLevel(logrus.WarnLevel)
 	case "error":
-		logger.SetLevel(logrus.ErrorLevel)
+		GlobalLogger.SetLevel(logrus.ErrorLevel)
 	case "fatal":
-		logger.SetLevel(logrus.FatalLevel)
+		GlobalLogger.SetLevel(logrus.FatalLevel)
 	case "panic":
-		logger.SetLevel(logrus.PanicLevel)
+		GlobalLogger.SetLevel(logrus.PanicLevel)
 	default:
-		logger.SetLevel(logrus.DebugLevel)
-		logger.Warnf("Log level '%s' not recognised. Setting to Debug.", level)
+		GlobalLogger.SetLevel(logrus.DebugLevel)
+		GlobalLogger.Warnf("Log level '%s' not recognised. Setting to Debug.", level)
 	}
 }